ra8_psa_crypto.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_err.h"
 
/* =============================================================================
 * Limits
 * =============================================================================
 */

typedef enum : uint8_t {
  k_ra8_psa_max_keys = 16U,

  k_ra8_psa_max_key_bytes = 96U,

  k_ra8_psa_sha256_len = 32U,

  k_ra8_psa_gcm_nonce_len = 12U,

  k_ra8_psa_gcm_tag_len = 16U,

  k_ra8_psa_max_sig_bytes = 96U,
} ra8_psa_limits_t;
 
/* =============================================================================
 * Algorithm + key-type tags
 * =============================================================================
 */

typedef enum : uint8_t {
  k_ra8_psa_key_type_raw           = 0U, 
  k_ra8_psa_key_type_aes           = 1U, 
  k_ra8_psa_key_type_hmac          = 2U, 
  k_ra8_psa_key_type_ecc_p256_priv = 3U, 
  k_ra8_psa_key_type_ecc_p256_pub  = 4U, 
} ra8_psa_key_type_t;

typedef enum : uint8_t {
  k_ra8_psa_alg_none          = 0U, 
  k_ra8_psa_alg_sha_256       = 1U, 
  k_ra8_psa_alg_aes_gcm       = 2U, 
  k_ra8_psa_alg_ecdsa_sha_256 = 3U, 
} ra8_psa_alg_t;

typedef enum : uint32_t {
  k_ra8_psa_usage_none    = 0x00U, 
  k_ra8_psa_usage_sign    = 0x01U, 
  k_ra8_psa_usage_verify  = 0x02U, 
  k_ra8_psa_usage_encrypt = 0x04U, 
  k_ra8_psa_usage_decrypt = 0x08U, 
  k_ra8_psa_usage_derive  = 0x10U, 
} ra8_psa_key_usage_t;
 
/* =============================================================================
 * Opaque key handle
 * =============================================================================
 */

struct ra8_psa_key_handle;

typedef struct ra8_psa_key_handle* ra8_psa_key_t;

typedef struct ra8_psa_key_attr {
  ra8_psa_key_type_t  type;  
  ra8_psa_alg_t       alg;   
  ra8_psa_key_usage_t usage; 
} ra8_psa_key_attr_t;
 
/* =============================================================================
 * Public API
 * =============================================================================
 */

ra8_err_t ra8_psa_crypto_init(void);

ra8_err_t ra8_psa_crypto_deinit(void);

ra8_err_t ra8_psa_key_import(ra8_psa_key_t*            out_handle,
                             const ra8_psa_key_attr_t* attr,
                             const uint8_t*            data,
                             size_t                    data_len);

ra8_err_t ra8_psa_key_destroy(ra8_psa_key_t handle);

ra8_err_t ra8_psa_hash_compute(ra8_psa_alg_t  alg,
                               const uint8_t* input,
                               size_t         input_len,
                               uint8_t*       out,
                               size_t         out_cap,
                               size_t*        out_len);

ra8_err_t ra8_psa_sign_hash(ra8_psa_key_t  handle,
                            ra8_psa_alg_t  alg,
                            const uint8_t* hash,
                            size_t         hash_len,
                            uint8_t*       sig,
                            size_t         sig_cap,
                            size_t*        sig_len);

ra8_err_t ra8_psa_verify_hash(ra8_psa_key_t  handle,
                              ra8_psa_alg_t  alg,
                              const uint8_t* hash,
                              size_t         hash_len,
                              const uint8_t* sig,
                              size_t         sig_len);

ra8_err_t ra8_psa_aead_encrypt(ra8_psa_key_t  handle,
                               ra8_psa_alg_t  alg,
                               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_cap,
                               size_t*        out_len);

ra8_err_t ra8_psa_aead_decrypt(ra8_psa_key_t  handle,
                               ra8_psa_alg_t  alg,
                               const uint8_t* nonce,
                               size_t         nonce_len,
                               const uint8_t* aad,
                               size_t         aad_len,
                               const uint8_t* cipher,
                               size_t         cipher_len,
                               uint8_t*       out,
                               size_t         out_cap,
                               size_t*        out_len);

[[nodiscard]] ra8_err_t ra8_psa_crypto_random(uint8_t* out, size_t out_len);
 
#ifdef __cplusplus
}
#endif