amduat-api/src/amduatd_derivation_index.c

#include "amduatd_derivation_index.h"

#include "amduat/asl/asl_derivation_index_fs.h"
#include "amduat/pel/core.h"
#include "amduat/pel/derivation_sid.h"
#include <string.h>

/* Reserve output_index values for non-output artifacts (result/trace/receipt). */
enum {
  AMDUATD_DERIVATION_OUTPUT_INDEX_RESULT = UINT32_MAX,
  AMDUATD_DERIVATION_OUTPUT_INDEX_TRACE = UINT32_MAX - 1u,
  AMDUATD_DERIVATION_OUTPUT_INDEX_RECEIPT = UINT32_MAX - 2u
};

static bool amduatd_derivation_index_add_record(
    amduat_asl_derivation_index_fs_t *index,
    amduat_octets_t sid,
    amduat_reference_t program_ref,
    const amduat_reference_t *input_refs,
    size_t input_refs_len,
    bool has_params_ref,
    amduat_reference_t params_ref,
    amduat_reference_t artifact_ref,
    uint32_t output_index,
    amduat_asl_store_error_t *out_err) {
  amduat_asl_derivation_record_t record;
  amduat_octets_t record_sid = amduat_octets(NULL, 0u);
  amduat_asl_store_error_t err;

  if (!amduat_octets_clone(sid, &record_sid)) {
    if (out_err != NULL) {
      *out_err = AMDUAT_ASL_STORE_ERR_INTEGRITY;
    }
    return false;
  }

  memset(&record, 0, sizeof(record));
  record.sid = record_sid;
  record.program_ref = program_ref;
  record.output_index = output_index;
  record.input_refs = (amduat_reference_t *)input_refs;
  record.input_refs_len = input_refs_len;
  record.has_params_ref = has_params_ref;
  if (has_params_ref) {
    record.params_ref = params_ref;
  }
  record.has_exec_profile = false;
  record.exec_profile = amduat_octets(NULL, 0u);

  err = amduat_asl_derivation_index_fs_add(index, artifact_ref, &record);
  amduat_octets_free(&record.sid);
  if (err != AMDUAT_ASL_STORE_OK) {
    if (out_err != NULL) {
      *out_err = err;
    }
    return false;
  }

  return true;
}

bool amduatd_derivation_index_pel_run(const char *root_path,
                                      bool enabled,
                                      amduat_reference_t program_ref,
                                      const amduat_reference_t *input_refs,
                                      size_t input_refs_len,
                                      bool has_params_ref,
                                      amduat_reference_t params_ref,
                                      const amduat_pel_run_result_t *run_result,
                                      bool has_receipt_ref,
                                      amduat_reference_t receipt_ref,
                                      amduat_asl_store_error_t *out_err) {
  amduat_asl_derivation_index_fs_t index;
  amduat_pel_derivation_sid_input_t sid_input;
  amduat_octets_t sid = amduat_octets(NULL, 0u);
  size_t i;

  if (out_err != NULL) {
    *out_err = AMDUAT_ASL_STORE_OK;
  }

  if (!enabled) {
    return true;
  }
  if (root_path == NULL || root_path[0] == '\0' || run_result == NULL) {
    if (out_err != NULL) {
      *out_err = AMDUAT_ASL_STORE_ERR_INTEGRITY;
    }
    return false;
  }
  if (!run_result->has_result_value) {
    return true;
  }
  if (run_result->result_value.has_store_failure) {
    return true;
  }
  if (run_result->result_value.core_result.status != AMDUAT_PEL_EXEC_STATUS_OK) {
    return true;
  }
  if (run_result->output_refs_len > UINT32_MAX) {
    if (out_err != NULL) {
      *out_err = AMDUAT_ASL_STORE_ERR_INTEGRITY;
    }
    return false;
  }
  if (!amduat_asl_derivation_index_fs_init(&index, root_path)) {
    if (out_err != NULL) {
      *out_err = AMDUAT_ASL_STORE_ERR_IO;
    }
    return false;
  }

  memset(&sid_input, 0, sizeof(sid_input));
  sid_input.program_ref = program_ref;
  sid_input.input_refs = input_refs;
  sid_input.input_refs_len = input_refs_len;
  sid_input.has_params_ref = has_params_ref;
  if (has_params_ref) {
    sid_input.params_ref = params_ref;
  }
  sid_input.has_exec_profile = false;
  sid_input.exec_profile = amduat_octets(NULL, 0u);

  if (!amduat_pel_derivation_sid_compute(&sid_input, &sid)) {
    if (out_err != NULL) {
      *out_err = AMDUAT_ASL_STORE_ERR_INTEGRITY;
    }
    return false;
  }

  for (i = 0u; i < run_result->output_refs_len; ++i) {
    if (!amduatd_derivation_index_add_record(&index,
                                             sid,
                                             program_ref,
                                             input_refs,
                                             input_refs_len,
                                             has_params_ref,
                                             params_ref,
                                             run_result->output_refs[i],
                                             (uint32_t)i,
                                             out_err)) {
      amduat_octets_free(&sid);
      return false;
    }
  }

  if (!amduatd_derivation_index_add_record(&index,
                                           sid,
                                           program_ref,
                                           input_refs,
                                           input_refs_len,
                                           has_params_ref,
                                           params_ref,
                                           run_result->result_ref,
                                           AMDUATD_DERIVATION_OUTPUT_INDEX_RESULT,
                                           out_err)) {
    amduat_octets_free(&sid);
    return false;
  }

  if (run_result->result_value.has_trace_ref) {
    if (!amduatd_derivation_index_add_record(
            &index,
            sid,
            program_ref,
            input_refs,
            input_refs_len,
            has_params_ref,
            params_ref,
            run_result->result_value.trace_ref,
            AMDUATD_DERIVATION_OUTPUT_INDEX_TRACE,
            out_err)) {
      amduat_octets_free(&sid);
      return false;
    }
  }

  if (has_receipt_ref) {
    if (!amduatd_derivation_index_add_record(
            &index,
            sid,
            program_ref,
            input_refs,
            input_refs_len,
            has_params_ref,
            params_ref,
            receipt_ref,
            AMDUATD_DERIVATION_OUTPUT_INDEX_RECEIPT,
            out_err)) {
      amduat_octets_free(&sid);
      return false;
    }
  }

  amduat_octets_free(&sid);
  return true;
}