ra8_psa_crypto_internal.h

Go to the documentation of this file.

 
#pragma once
 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_err.h"
#include "ra8_psa_crypto.h"
 
#ifndef RA8_OFF_TARGET
/* The real backend stores a PSA key handle in each slot; pull in the type the
 * struct below references. Skipped under RA8_OFF_TARGET, which keeps its own
 * software key material and never links tf-psa-crypto. */
#include "psa/crypto.h"
#endif
 
/* =============================================================================
 * Internal typed constants (no magic numbers)
 * =============================================================================
 */

typedef enum : uint16_t {
  k_ra8_psa_sha256_block_bytes   = 64U,   
  k_ra8_psa_sha256_state_words   = 8U,    
  k_ra8_psa_sha256_schedule_len  = 64U,   
  k_ra8_psa_sha256_init_words    = 16U,   
  k_ra8_psa_sha256_pad_buf_len   = 128U,  
  k_ra8_psa_sha256_pad_threshold = 56U,   
  k_ra8_psa_fake_scratch_bytes   = 256U,  
  k_ra8_psa_word_bits            = 32U,   
  k_ra8_psa_byte_bits            = 8U,    
  k_ra8_psa_bytes_per_word       = 4U,    
  k_ra8_psa_pad_marker           = 0x80U, 
  k_ra8_psa_length_field_bytes   = 8U,    
  k_ra8_psa_shift_b3             = 24U,   
  k_ra8_psa_shift_b2             = 16U,   
  k_ra8_psa_shift_b1             = 8U,    
  k_ra8_psa_rot_s0_a             = 7U,    
  k_ra8_psa_rot_s0_b             = 18U,   
  k_ra8_psa_shr_s0               = 3U,    
  k_ra8_psa_rot_s1_a             = 17U,   
  k_ra8_psa_rot_s1_b             = 19U,   
  k_ra8_psa_shr_s1               = 10U,   
  k_ra8_psa_rot_e_a              = 6U,    
  k_ra8_psa_rot_e_b              = 11U,   
  k_ra8_psa_rot_e_c              = 25U,   
  k_ra8_psa_rot_a_a              = 2U,    
  k_ra8_psa_rot_a_b              = 13U,   
  k_ra8_psa_rot_a_c              = 22U,   
  k_ra8_psa_w_back_15            = 15U,   
  k_ra8_psa_w_back_2             = 2U,    
  k_ra8_psa_w_back_16            = 16U,   
  k_ra8_psa_w_back_7             = 7U,    
  k_ra8_psa_state_idx_a          = 0U,    
  k_ra8_psa_state_idx_b          = 1U,    
  k_ra8_psa_state_idx_c          = 2U,    
  k_ra8_psa_state_idx_d          = 3U,    
  k_ra8_psa_state_idx_e          = 4U,    
  k_ra8_psa_state_idx_f          = 5U,    
  k_ra8_psa_state_idx_g          = 6U,    
  k_ra8_psa_state_idx_h          = 7U,    
} ra8_psa_internal_const_t;

typedef enum : uint32_t {
  k_xs32_seed   = 0xACE1ACE1U, 
  k_xs32_byte_m = 0xFFU,       
} ra8_psa_xs32_const_t;

typedef enum : uint8_t {
  k_xs32_shl_a = 13U, 
  k_xs32_shr_b = 17U, 
  k_xs32_shl_c = 5U,  
} ra8_psa_xs32_shift_t;

typedef enum : uint32_t {
  k_ra8_psa_sha256_h0 = 0x6a09e667U, 
  k_ra8_psa_sha256_h1 = 0xbb67ae85U, 
  k_ra8_psa_sha256_h2 = 0x3c6ef372U, 
  k_ra8_psa_sha256_h3 = 0xa54ff53aU, 
  k_ra8_psa_sha256_h4 = 0x510e527fU, 
  k_ra8_psa_sha256_h5 = 0x9b05688cU, 
  k_ra8_psa_sha256_h6 = 0x1f83d9abU, 
  k_ra8_psa_sha256_h7 = 0x5be0cd19U, 
} ra8_psa_sha256_iv_t;
 
/* =============================================================================
 * Pool slot definition
 * =============================================================================
 */

struct ra8_psa_key_handle {
  bool               in_use;                       
  ra8_psa_key_attr_t attr;                         
  size_t             key_len;                      
  uint8_t            key[k_ra8_psa_max_key_bytes]; 
#ifndef RA8_OFF_TARGET
  psa_key_id_t psa_id; 
#endif                 
};
 
#ifdef RA8_OFF_TARGET
 
/* =============================================================================
 * Off-target crypto helpers (defined in ra8_psa_crypto_fake.c)
 * =============================================================================
 */

void ra8_psa_fake_sha256_oneshot(const uint8_t* in,
                                 size_t         in_len,
                                 uint8_t        out[k_ra8_psa_sha256_len]);

ra8_err_t ra8_psa_fake_aead_encrypt(const struct ra8_psa_key_handle* slot,
                                    const uint8_t*                   nonce,
                                    size_t                           nonce_len,
                                    const uint8_t*                   aad,
                                    size_t                           aad_len,
                                    const uint8_t*                   plain,
                                    size_t                           plain_len,
                                    uint8_t*                         out,
                                    size_t*                          out_len);

ra8_err_t ra8_psa_fake_aead_decrypt(const struct ra8_psa_key_handle* slot,
                                    const uint8_t*                   nonce,
                                    size_t                           nonce_len,
                                    const uint8_t*                   aad,
                                    size_t                           aad_len,
                                    const uint8_t*                   cipher,
                                    size_t                           plain_len,
                                    uint8_t*                         out,
                                    size_t*                          out_len);
 
#endif /* RA8_OFF_TARGET */