key_import.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "key_import_internal.h"
#include "key_vault.h"
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_secure.h"
#include "sec_cmac_internal.h"
 
static const char* s_tag = "KEYIMP";

typedef enum : uint8_t {
  k_rotate_mask_5bit = 31U, 
} rotate_mask_t;

typedef enum : uint8_t {
  k_handle_rotate_bits = 13U, 
  k_salt_reroll_rot    = 7U,  
} ra8_key_import_internal_t;

typedef enum : uint32_t {
  k_initial_salt         = 0xA5A5A5A5U, 
  k_handle_high_bit_mask = 0x80000000U, 
  k_salt_reroll_xor      = 0xDEADBEEFU, 
} ra8_key_import_mask_t;

static uint16_t s_slot_used = 0U;

static uint32_t s_salt = (uint32_t)k_initial_salt;

RA8_INTERNAL static uint32_t internal_rotate_left_32(uint32_t value, uint8_t amount)
{
  const uint8_t bits = (uint8_t)(amount & (uint8_t)k_rotate_mask_5bit);
  if (bits == 0U) {
    return value;
  }
  return (value << bits) | (value >> (32U - bits));
}

RA8_INTERNAL static uint32_t internal_handle_for_slot(uint16_t slot)
{
  const uint32_t mixed = internal_rotate_left_32(s_salt, k_handle_rotate_bits);
  /* Force a non-zero handle: OR in bit 31 so we never collide with
   * the reserved zero sentinel even if the XOR happens to produce 0. */
  return ((uint32_t)slot ^ mixed) | (uint32_t)k_handle_high_bit_mask;
}

RA8_INTERNAL static ra8_err_t internal_verify_cmac(const uint8_t* blob)
{
  uint8_t         mac_key[k_ra8_key_vault_mac_key_bytes];
  uint16_t        mac_key_len = 0U;
  const ra8_err_t kerr =
    ra8_key_vault_load_mac_key(mac_key, (uint16_t)sizeof(mac_key), &mac_key_len);
  if (kerr != k_ra8_ok) {
    return kerr;
  }
  const ra8_err_t verr = priv_ra8_sec_cmac_verify(mac_key,
                                                  mac_key_len,
                                                  blob,
                                                  (uint32_t)k_ra8_key_import_key_bytes,
                                                  &blob[k_ra8_key_import_key_bytes],
                                                  (uint16_t)k_ra8_key_import_mac_bytes);
  ra8_secure_memzero(mac_key, sizeof(mac_key));
  return verr;
}

ra8_err_t priv_ra8_key_import_reset(void)
{
  s_slot_used = 0U;
  /* Bump the salt with a fixed mixing constant so successive resets
   * also produce different handles. */
  s_salt =
    internal_rotate_left_32(s_salt, (uint8_t)k_salt_reroll_rot) ^ (uint32_t)k_salt_reroll_xor;
  if (s_salt == 0U) {
    s_salt = (uint32_t)k_initial_salt;
  }
  return k_ra8_ok;
}

ra8_err_t priv_ra8_key_import_seal(const uint8_t* blob, uint32_t blob_len, uint32_t* out_handle)
{
  RA8_CHECK_NULL_PTR(blob, s_tag, "seal: blob");
  RA8_CHECK_NULL_PTR(out_handle, s_tag, "seal: out_handle");
  if (blob_len != (uint32_t)k_ra8_key_import_blob_bytes) {
    return k_ra8_err_invalid_size;
  }
  const ra8_err_t mac_err = internal_verify_cmac(blob);
  if (mac_err != k_ra8_ok) {
    return mac_err;
  }
 
  /* Pick the lowest free slot. Loop bound is the slot count -- NASA
   * Rule 2 compliant. */
  uint16_t chosen = (uint16_t)k_ra8_key_vault_slots;
  for (uint16_t i = 0U; i < (uint16_t)k_ra8_key_vault_slots; ++i) {
    const uint16_t bit = (uint16_t)((uint16_t)1U << i);
    if ((s_slot_used & bit) == 0U) {
      chosen = i;
      break;
    }
  }
  if (chosen == (uint16_t)k_ra8_key_vault_slots) {
    return k_ra8_err_no_mem;
  }
 
  const ra8_err_t store_err = ra8_key_vault_store(chosen, blob);
  if (store_err != k_ra8_ok) {
    return store_err;
  }
  s_slot_used = (uint16_t)(s_slot_used | (uint16_t)((uint16_t)1U << chosen));
  *out_handle = internal_handle_for_slot(chosen);
  return k_ra8_ok;
}

ra8_err_t priv_ra8_key_import_resolve(uint32_t handle, uint16_t* out_slot)
{
  RA8_CHECK_NULL_PTR(out_slot, s_tag, "resolve: out_slot");
  for (uint16_t i = 0U; i < (uint16_t)k_ra8_key_vault_slots; ++i) {
    const uint16_t bit = (uint16_t)((uint16_t)1U << i);
    if (((s_slot_used & bit) != 0U) && (internal_handle_for_slot(i) == handle)) {
      *out_slot = i;
      return k_ra8_ok;
    }
  }
  return k_ra8_err_not_found;
}

ra8_err_t priv_ra8_key_import_build_blob(const uint8_t* material, uint8_t* out_blob)
{
  RA8_CHECK_NULL_PTR(material, s_tag, "build_blob: material");
  RA8_CHECK_NULL_PTR(out_blob, s_tag, "build_blob: out_blob");
  uint8_t         mac_key[k_ra8_key_vault_mac_key_bytes];
  uint16_t        mac_key_len = 0U;
  const ra8_err_t kerr =
    ra8_key_vault_load_mac_key(mac_key, (uint16_t)sizeof(mac_key), &mac_key_len);
  if (kerr != k_ra8_ok) {
    return kerr;
  }
  for (uint16_t i = 0U; i < (uint16_t)k_ra8_key_import_key_bytes; ++i) {
    out_blob[i] = material[i];
  }
  const ra8_err_t cerr = priv_ra8_sec_cmac_compute(mac_key,
                                                   mac_key_len,
                                                   material,
                                                   (uint32_t)k_ra8_key_import_key_bytes,
                                                   &out_blob[k_ra8_key_import_key_bytes]);
  ra8_secure_memzero(mac_key, sizeof(mac_key));
  return cerr;
}