main.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_psa_crypto.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_aes_demo_baud      = 115200U, 
  k_aes_demo_period_ms = 1000U,   
} aes_demo_const_t;

typedef enum : uint8_t {
  k_aes_demo_key_bytes   = 16U, 
  k_aes_demo_plain_bytes = 8U,  
  k_aes_demo_aad_bytes   = 4U,  
} aes_demo_layout_t;

typedef enum : uint32_t {
  k_aes_demo_usage_aead = (uint32_t)k_ra8_psa_usage_encrypt |
                          (uint32_t)k_ra8_psa_usage_decrypt, 
} aes_demo_usage_t;

static const uint8_t s_aes_demo_key[k_aes_demo_key_bytes] = {
  0x00U,
  0x11U,
  0x22U,
  0x33U,
  0x44U,
  0x55U,
  0x66U,
  0x77U,
  0x88U,
  0x99U,
  0xAAU,
  0xBBU,
  0xCCU,
  0xDDU,
  0xEEU,
  0xFFU,
};

static const uint8_t s_aes_demo_nonce[k_ra8_psa_gcm_nonce_len] = {
  0xA0U,
  0xA1U,
  0xA2U,
  0xA3U,
  0xA4U,
  0xA5U,
  0xA6U,
  0xA7U,
  0xA8U,
  0xA9U,
  0xAAU,
  0xABU,
};

static const uint8_t s_aes_demo_plain[k_aes_demo_plain_bytes] = {
  'R',
  'A',
  '8',
  'D',
  '2',
  '_',
  'O',
  'K',
};

static const uint8_t s_aes_demo_aad[k_aes_demo_aad_bytes] = {'A', 'E', 'A', 'D'};
 
static const uint8_t s_aes_demo_msg_ok[]   = "aes: round-trip OK\r\n";
static const uint8_t s_aes_demo_msg_fail[] = "aes: round-trip FAIL\r\n";

RA8_INTERNAL static void internal_panic_halt(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}

RA8_INTERNAL static void internal_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_aes_demo_baud) != k_ra8_ok) {
    internal_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    internal_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    internal_panic_halt();
  }
  if (ra8_psa_crypto_init() != k_ra8_ok) {
    internal_panic_halt();
  }
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_one_round_trip(void)
{
  /* The PSA usage enum is intentionally a bitfield -- combining
   * encrypt + decrypt yields 0x0C, which is a valid policy mask but
   * not a declared enumerator. */
  const ra8_psa_key_attr_t attr = {
    .type  = k_ra8_psa_key_type_aes,
    .alg   = k_ra8_psa_alg_aes_gcm,
    .usage = (ra8_psa_key_usage_t)k_aes_demo_usage_aead,
  };
  ra8_psa_key_t key = nullptr;
  ra8_err_t     err = ra8_psa_key_import(&key, &attr, s_aes_demo_key, (size_t)k_aes_demo_key_bytes);
  if (err != k_ra8_ok) {
    return err;
  }
 
  uint8_t ct[k_aes_demo_plain_bytes + k_ra8_psa_gcm_tag_len] = {};
  size_t  ct_len                                             = 0U;
  err = ra8_psa_aead_encrypt(key,
                             k_ra8_psa_alg_aes_gcm,
                             s_aes_demo_nonce,
                             (size_t)k_ra8_psa_gcm_nonce_len,
                             s_aes_demo_aad,
                             (size_t)k_aes_demo_aad_bytes,
                             s_aes_demo_plain,
                             (size_t)k_aes_demo_plain_bytes,
                             ct,
                             sizeof(ct),
                             &ct_len);
  if (err != k_ra8_ok) {
    (void)ra8_psa_key_destroy(key);
    return err;
  }
 
  uint8_t recovered[k_aes_demo_plain_bytes] = {};
  size_t  rec_len                           = 0U;
  err                                       = ra8_psa_aead_decrypt(key,
                                                                   k_ra8_psa_alg_aes_gcm,
                                                                   s_aes_demo_nonce,
                                                                   (size_t)k_ra8_psa_gcm_nonce_len,
                                                                   s_aes_demo_aad,
                                                                   (size_t)k_aes_demo_aad_bytes,
                                                                   ct,
                                                                   ct_len,
                                                                   recovered,
                                                                   sizeof(recovered),
                                                                   &rec_len);
  (void)ra8_psa_key_destroy(key);
  if (err != k_ra8_ok) {
    return err;
  }
  if (rec_len != (size_t)k_aes_demo_plain_bytes) {
    return k_ra8_err_invalid_size;
  }
  if (memcmp(recovered, s_aes_demo_plain, (size_t)k_aes_demo_plain_bytes) != 0) {
    return k_ra8_err_crc_mismatch;
  }
  return k_ra8_ok;
}
 
void main(void)
{
  internal_setup_or_halt();
  ra8_isr_globals_enable();
 
  while (1) {
    if (internal_one_round_trip() == k_ra8_ok) {
      (void)ra8_board_uart_console_write(s_aes_demo_msg_ok,
                                         (size_t)(sizeof(s_aes_demo_msg_ok) - 1U));
      (void)ra8_board_led_toggle(k_ra8_board_led1);
    } else {
      (void)ra8_board_uart_console_write(s_aes_demo_msg_fail,
                                         (size_t)(sizeof(s_aes_demo_msg_fail) - 1U));
      (void)ra8_board_led_toggle(k_ra8_board_led2);
    }
    ra8_delay_ms(k_aes_demo_period_ms);
  }
  internal_panic_halt();
}