ra8_rot.c

Go to the documentation of this file.

 
#include "ra8_rot.h"
 
#ifdef RA8_ENABLE_ROOT_OF_TRUST
 
#include "ra8_check.h"
#include "ra8_psa_crypto.h"
#include "ra8_rsip_core.h"

static const char* s_tag = "ROT";

static const uint8_t s_rot_root_pubkey[k_ra8_rot_pubkey_bytes] = {
  0x04U, 0xC8U, 0xDCU, 0xA2U, 0xF2U, 0x02U, 0x50U, 0x15U, 0xF2U, 0xFEU, 0x39U, 0xD1U, 0xBDU,
  0x9AU, 0xB9U, 0xAFU, 0x14U, 0x6AU, 0x76U, 0xA6U, 0x26U, 0x67U, 0x1DU, 0xE7U, 0xFDU, 0xDAU,
  0x53U, 0x11U, 0xF6U, 0xEAU, 0xC5U, 0x85U, 0xE6U, 0x8EU, 0x53U, 0x0DU, 0x1EU, 0x52U, 0x45U,
  0xBBU, 0x37U, 0x96U, 0xA4U, 0xF1U, 0x8CU, 0xFAU, 0x83U, 0x22U, 0x43U, 0x0BU, 0xAEU, 0x74U,
  0xD4U, 0xB5U, 0x53U, 0xE5U, 0xCDU, 0xC7U, 0x94U, 0xBAU, 0x57U, 0x49U, 0x22U, 0x94U, 0xDDU,
};

RA8_INTERNAL static bool internal_ct_equal(const uint8_t* a, const uint8_t* b, uint32_t len)
{
  if ((a == nullptr) || (b == nullptr)) {
    return false;
  }
  if (len == 0U) {
    return false;
  }
  uint8_t diff = 0U;
  /* Bounded by ``len`` (<= k_ra8_rot_digest_bytes at the only call site):
   * a statically bounded fold -- NASA Rule 2 compliant. */
  for (uint32_t i = 0U; i < len; ++i) {
    diff |= (uint8_t)(a[i] ^ b[i]);
  }
  return diff == 0U;
}

RA8_INTERNAL static ra8_err_t
internal_compute_digest(const uint8_t* body, uint32_t body_len, uint8_t* digest)
{
  RA8_CHECK_NULL_PTR(body, s_tag, "body");
  RA8_CHECK_NULL_PTR(digest, s_tag, "digest");
 
#ifdef RA8_OFF_TARGET
  size_t produced = 0U;
  return ra8_psa_hash_compute(k_ra8_psa_alg_sha_256,
                              body,
                              (size_t)body_len,
                              digest,
                              (size_t)k_ra8_rot_digest_bytes,
                              &produced);
#else
  /* HUM Ch 52.2.3 "Hash Generator" p 3306 -- RSIP HASH engine, fully
   * abstracted by ra8_rsip_sha256; no raw register access is added here. */
  return ra8_rsip_sha256(body, body_len, digest);
#endif
}

typedef enum : uint8_t {
  k_rot_octet_bits = 8U, 
} rot_serial_t;

RA8_INTERNAL static ra8_err_t
internal_bind_version(uint32_t img_version, const uint8_t* digest, uint8_t* out)
{
  RA8_CHECK_NULL_PTR(digest, s_tag, "digest");
  RA8_CHECK_NULL_PTR(out, s_tag, "out");
 
  uint8_t combined[sizeof(uint32_t) + k_ra8_rot_digest_bytes] = {};
  for (uint8_t i = 0U; i < (uint8_t)sizeof(uint32_t); ++i) {
    combined[i] = (uint8_t)(img_version >> ((uint32_t)i * (uint32_t)k_rot_octet_bits));
  }
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_rot_digest_bytes; ++i) {
    combined[(size_t)sizeof(uint32_t) + (size_t)i] = digest[i];
  }
  return internal_compute_digest(combined, (uint32_t)sizeof(combined), out);
}

RA8_INTERNAL static ra8_err_t
internal_verify_sig(const uint8_t* digest, const uint8_t* sig, uint32_t sig_len)
{
  RA8_CHECK_NULL_PTR(digest, s_tag, "digest");
  RA8_CHECK_NULL_PTR(sig, s_tag, "sig");
 
  const ra8_psa_key_attr_t attr = {
    .type  = k_ra8_psa_key_type_ecc_p256_pub,
    .alg   = k_ra8_psa_alg_ecdsa_sha_256,
    .usage = k_ra8_psa_usage_verify,
  };
  ra8_psa_key_t   key = nullptr;
  const ra8_err_t imp_err =
    ra8_psa_key_import(&key, &attr, s_rot_root_pubkey, (size_t)sizeof(s_rot_root_pubkey));
  RA8_RETURN_ON_ERROR(imp_err, s_tag, "rot: import root key failed");
 
  const ra8_err_t ver_err = ra8_psa_verify_hash(key,
                                                k_ra8_psa_alg_ecdsa_sha_256,
                                                digest,
                                                (size_t)k_ra8_rot_digest_bytes,
                                                sig,
                                                (size_t)sig_len);
  (void)ra8_psa_key_destroy(key);
  return ver_err;
}
 
ra8_err_t
ra8_rot_verify_image(const uint8_t* body, uint32_t body_len, const ra8_rot_trailer_t* trailer)
{
  RA8_CHECK_NULL_PTR(body, s_tag, "body");
  RA8_CHECK_NULL_PTR(trailer, s_tag, "trailer");
 
  /* Trailer header: a missing or malformed trailer is a default-deny. */
  if ((trailer->magic != (uint32_t)k_ra8_rot_trailer_magic) ||
      (trailer->version != (uint32_t)k_ra8_rot_version)) {
    ra8_log_error(s_tag, "rot: trailer magic/version invalid");
    return k_ra8_err_validation_failed;
  }
 
  /* Body-length sanity + cross-check against the trailer's recorded length. */
  if ((body_len == 0U) || (body_len > (uint32_t)k_ra8_rot_body_max) ||
      (trailer->body_len != body_len)) {
    ra8_log_error(s_tag, "rot: body_len out of range / mismatch");
    return k_ra8_err_invalid_size;
  }
 
  /* Signature-length sanity (bounds the bytes handed to the verifier). */
  if ((trailer->sig_len == 0U) || (trailer->sig_len > (uint32_t)k_ra8_rot_sig_bytes)) {
    ra8_log_error(s_tag, "rot: sig_len invalid");
    return k_ra8_err_invalid_size;
  }
 
  /* Ensure the PSA facade is ready (the fake hash and the ECDSA verify both
   * route through it). Already-initialized is fine. */
  const ra8_err_t psa_err = ra8_psa_crypto_init();
  // mcdc-deactivated: DO-178C 6.4.4.3 -- under RA8_OFF_TARGET (the only host-testable build) ra8_psa_crypto_init() returns exactly k_ra8_ok (first init) or k_ra8_err_exists (already initialized) and never a backend-fault code, so both conditions cannot be true together on the host; the fail-closed abort on a genuine PSA/RSIP init fault is exercisable only on target, where the crypto backend can fault, and is not host-instrumentable.
  if ((psa_err != k_ra8_ok) && (psa_err != k_ra8_err_exists)) {
    ra8_log_error(s_tag, "rot: psa init failed");
    return psa_err;
  }
 
  /* Re-compute the body digest. The signature's authority is asserted over
   * THIS freshly-computed digest, never over the trailer's stored digest. */
  uint8_t         digest[k_ra8_rot_digest_bytes] = {};
  const ra8_err_t hash_err                       = internal_compute_digest(body, body_len, digest);
  RA8_RETURN_ON_ERROR(hash_err, s_tag, "rot: hash compute failed");
 
  /* Tamper pre-check: the re-computed digest must equal the trailer digest. */
  if (!internal_ct_equal(digest, trailer->digest, (uint32_t)k_ra8_rot_digest_bytes)) {
    ra8_log_error(s_tag, "rot: body digest mismatch (tampered)");
    return k_ra8_err_checksum_mismatch;
  }
 
  /* Bind the anti-rollback img_version into the signed material so a forged
   * version riding on a validly-signed body fails verification (T5-05): the
   * signature's authority is asserted over SHA-256(img_version_le || digest),
   * not the bare body digest. */
  uint8_t         signed_material[k_ra8_rot_digest_bytes] = {};
  const ra8_err_t bind_err = internal_bind_version(trailer->img_version, digest, signed_material);
  RA8_RETURN_ON_ERROR(bind_err, s_tag, "rot: version-bind hash failed");
 
  /* Authority: ECDSA-P256 verify over the version-bound digest. */
  const ra8_err_t sig_err = internal_verify_sig(signed_material, trailer->sig, trailer->sig_len);
  RA8_RETURN_ON_ERROR(sig_err, s_tag, "rot: signature verify failed");
 
  return k_ra8_ok; /* image is authentic -- launch permitted */
}
 
const ra8_rot_trailer_t* ra8_rot_trailer_after(const void* image_base, uint32_t body_len)
{
  if (image_base == nullptr) {
    return nullptr;
  }
  if ((body_len == 0U) || (body_len > (uint32_t)k_ra8_rot_body_max)) {
    return nullptr;
  }
  const uint8_t* base = (const uint8_t*)image_base;
  /* The trailer sits immediately after the body; image bodies are placed at
   * 32-byte (page) multiples, so this address satisfies the struct alignment.
   * The void* hop documents the intent and silences -Wcast-align. */
  return (const ra8_rot_trailer_t*)(const void*)(base + body_len);
}
 
ra8_err_t ra8_rot_root_public_key(const uint8_t** out_key, uint32_t* out_len)
{
  RA8_CHECK_NULL_PTR(out_key, s_tag, "out_key");
  RA8_CHECK_NULL_PTR(out_len, s_tag, "out_len");
  *out_key = s_rot_root_pubkey;
  *out_len = (uint32_t)sizeof(s_rot_root_pubkey);
  return k_ra8_ok;
}
 
#endif /* RA8_ENABLE_ROOT_OF_TRUST */