main.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "mbedtls/memory_buffer_alloc.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_rot.h"
#include "ra8_time.h"
#include "rot_fixture.h"

typedef enum : uint32_t {
  k_rot_baud       = 115200U,  
  k_rot_period_ms  = 1000U,    
  k_rot_heap_bytes = 0x10000U, 
} rot_const_t;

typedef enum : uint8_t {
  k_rot_tamper_bit = 0x01U, 
} rot_bit_t;
 
static const uint8_t k_rot_msg_pass[]      = "rot verify: PASS\r\n";
static const uint8_t k_rot_msg_fail[]      = "rot verify: FAIL\r\n";
static const uint8_t k_rot_diag_boot[]     = "rot: boot (console up)\r\n";
static const uint8_t k_rot_diag_psa_fail[] = "rot: psa_init FAIL\r\n";
static const uint8_t k_rot_diag_psa_ok[]   = "rot: psa_init ok\r\n";
static const uint8_t k_rot_diag_genuine[]  = "rot: genuine image ACCEPTED\r\n";
static const uint8_t k_rot_diag_no_gen[]   = "rot: genuine image REJECTED (bug)\r\n";
static const uint8_t k_rot_diag_tamper[]   = "rot: tampered image REJECTED\r\n";
static const uint8_t k_rot_diag_no_tamp[]  = "rot: tampered image ACCEPTED (bug)\r\n";

static uint8_t s_rot_heap[k_rot_heap_bytes];

static uint8_t s_rot_tamper[sizeof(k_rot_fixture_image)];
 
static void rot_write(const uint8_t* msg, size_t len)
{
  (void)ra8_board_uart_console_write(msg, len);
}

static bool rot_genuine_ok(void)
{
  const ra8_rot_trailer_t* trailer =
    ra8_rot_trailer_after(k_rot_fixture_image, k_rot_fixture_body_len);
  if (trailer == nullptr) {
    return false;
  }
  return ra8_rot_verify_image(k_rot_fixture_image, k_rot_fixture_body_len, trailer) == k_ra8_ok;
}

static bool rot_tamper_rejected(void)
{
  memcpy(s_rot_tamper, k_rot_fixture_image, sizeof(s_rot_tamper));
  s_rot_tamper[0] ^= (uint8_t)k_rot_tamper_bit;
  const ra8_rot_trailer_t* trailer = ra8_rot_trailer_after(s_rot_tamper, k_rot_fixture_body_len);
  if (trailer == nullptr) {
    return false;
  }
  return ra8_rot_verify_image(s_rot_tamper, k_rot_fixture_body_len, trailer) != k_ra8_ok;
}
 
static void rot_panic_halt(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}
 
static void rot_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    rot_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    rot_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    rot_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_rot_baud) != k_ra8_ok) {
    rot_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    rot_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    rot_panic_halt();
  }
  rot_write(k_rot_diag_boot, (size_t)(sizeof(k_rot_diag_boot) - 1U));
  mbedtls_memory_buffer_alloc_init(s_rot_heap, sizeof(s_rot_heap));
  if (ra8_psa_crypto_init() != k_ra8_ok) {
    rot_write(k_rot_diag_psa_fail, (size_t)(sizeof(k_rot_diag_psa_fail) - 1U));
    rot_panic_halt();
  }
  rot_write(k_rot_diag_psa_ok, (size_t)(sizeof(k_rot_diag_psa_ok) - 1U));
}
 
void main(void)
{
  rot_setup_or_halt();
  ra8_isr_globals_enable();
 
  while (1) {
    bool ok = true;
 
    if (rot_genuine_ok()) {
      rot_write(k_rot_diag_genuine, (size_t)(sizeof(k_rot_diag_genuine) - 1U));
    } else {
      rot_write(k_rot_diag_no_gen, (size_t)(sizeof(k_rot_diag_no_gen) - 1U));
      ok = false;
    }
 
    if (rot_tamper_rejected()) {
      rot_write(k_rot_diag_tamper, (size_t)(sizeof(k_rot_diag_tamper) - 1U));
    } else {
      rot_write(k_rot_diag_no_tamp, (size_t)(sizeof(k_rot_diag_no_tamp) - 1U));
      ok = false;
    }
 
    if (ok) {
      rot_write(k_rot_msg_pass, (size_t)(sizeof(k_rot_msg_pass) - 1U));
      (void)ra8_board_led_toggle(k_ra8_board_led1);
    } else {
      rot_write(k_rot_msg_fail, (size_t)(sizeof(k_rot_msg_fail) - 1U));
      (void)ra8_board_led_toggle(k_ra8_board_led2);
    }
    ra8_delay_ms(k_rot_period_ms);
  }
  rot_panic_halt();
}