lcx_cipher.h

Go to the documentation of this file.

/* @BANNER@ */
 
#pragma once
#include "cx_errors.h"
#include "lcx_wrappers.h"
#include "lcx_common.h"
#include "lcx_aes.h"
#include <stddef.h>
 
#define MAX_IV_LENGTH    16
#define MAX_BLOCK_LENGTH 16
 
#ifdef HAVE_CMAC
#define CMAC_MAX_BLOCK_LENGTH (16)
 
typedef struct {
    uint8_t state[CMAC_MAX_BLOCK_LENGTH];
    uint8_t unprocessed_block[CMAC_MAX_BLOCK_LENGTH];
    size_t  unprocessed_len;
} cx_cmac_context_t;
#endif  // HAVE_CMAC
 
typedef enum {
    CX_CIPHER_NONE = 0,  
    CX_CIPHER_AES_128,   
    CX_CIPHER_AES_192,   
    CX_CIPHER_AES_256,   
} cx_cipher_id_t;
 
typedef struct {
    uint32_t size;
    uint8_t  keys[32];
} cipher_key_t;
 
typedef struct {
    cx_err_t (*enc_func)(const uint8_t *in_block, uint8_t *out_block);  
    cx_err_t (*dec_func)(const uint8_t *in_block, uint8_t *out_block);  
    cx_err_t (*ctr_func)(const cipher_key_t *ctx_key,
                         size_t              len,
                         size_t             *nc_off,
                         uint8_t            *nonce_counter,
                         uint8_t            *stream_block,
                         const uint8_t      *input,
                         uint8_t            *output);  
    cx_err_t (*setkey_func)(const cipher_key_t *ctx_key,
                            uint32_t            operation,
                            const uint8_t      *key,
                            uint32_t key_bitlen);  
    cx_err_t (*ctx_reset)(void);                   
} cx_cipher_base_t;
 
typedef struct {
    uint32_t key_bitlen;  
    uint32_t iv_size;     
    uint32_t block_size;  
#if !defined(BOLOS_OS_UPGRADER_APP)
    const cx_cipher_base_t *base;  
#else
    cx_cipher_base_t *base;  
#endif
 
} cx_cipher_info_t;
 
typedef struct {
    const cx_cipher_info_t *cipher_info;  
    uint32_t                key_bitlen;   
    uint32_t                operation;    
    void (*add_padding)(uint8_t *output, size_t out_len, size_t data_len);  
    cx_err_t (*get_padding)(uint8_t *input,
                            size_t   in_len,
                            size_t  *data_len);               
    uint8_t             unprocessed_data[MAX_BLOCK_LENGTH];  
    size_t              unprocessed_len;                     
    uint8_t             iv[MAX_IV_LENGTH];                   
    size_t              iv_size;                
    uint32_t            mode;                   
    uint8_t             sig[MAX_BLOCK_LENGTH];  
    const cipher_key_t *cipher_key;             
#ifdef HAVE_CMAC
    cx_cmac_context_t *cmac_ctx;
#endif  // HAVE_CMAC
} cx_cipher_context_t;
 
WARN_UNUSED_RESULT cx_err_t cx_cipher_init(cx_cipher_context_t *ctx);
 
WARN_UNUSED_RESULT cx_err_t cx_cipher_setup(cx_cipher_context_t *ctx,
                                            const cx_cipher_id_t type,
                                            uint32_t             mode);
 
WARN_UNUSED_RESULT cx_err_t cx_cipher_setkey(cx_cipher_context_t *ctx,
                                             const uint8_t       *key,
                                             uint32_t             key_bitlen,
                                             uint32_t             operation);
 
WARN_UNUSED_RESULT cx_err_t cx_cipher_setiv(cx_cipher_context_t *ctx,
                                            const uint8_t       *iv,
                                            size_t               iv_len);
 
WARN_UNUSED_RESULT cx_err_t cx_cipher_set_padding(cx_cipher_context_t *ctx, uint32_t padding);
 
WARN_UNUSED_RESULT cx_err_t cx_cipher_update(cx_cipher_context_t *ctx,
                                             const uint8_t       *input,
                                             size_t               in_len,
                                             uint8_t             *output,
                                             size_t              *out_len);
 
WARN_UNUSED_RESULT cx_err_t cx_cipher_finish(cx_cipher_context_t *ctx,
                                             uint8_t             *output,
                                             size_t              *out_len);
 
WARN_UNUSED_RESULT cx_err_t cx_cipher_enc_dec(cx_cipher_context_t *ctx,
                                              const uint8_t       *iv,
                                              size_t               iv_len,
                                              const uint8_t       *input,
                                              size_t               in_len,
                                              uint8_t             *output,
                                              size_t              *out_len);
 
void cx_cipher_reset(cx_cipher_context_t *ctx);
 
void add_one_and_zeros_padding(uint8_t *output, size_t out_len, size_t data_len);