cipher.h

浏览该文件的文档.

 
#ifndef CIPHER_H
#define CIPHER_H
 
#include <stdint.h>
#include <stdbool.h>
#include "errcode.h"
 
#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif
#endif
 
typedef enum {
    UAPI_DRV_CIPHER_SYMC_TYPE_NORMAL = 0x0,
    UAPI_DRV_CIPHER_SYMC_TYPE_REG,
    UAPI_DRV_CIPHER_SYMC_TYPE_MAX,
    UAPI_DRV_CIPHER_SYMC_TYPE_INVALID = 0xffffffff,
} uapi_drv_cipher_symc_type_t;
 
typedef enum {
    UAPI_DRV_CIPHER_SYMC_ALG_TDES = 0x0,
    UAPI_DRV_CIPHER_SYMC_ALG_AES = 0x1,
    UAPI_DRV_CIPHER_SYMC_ALG_SM4 = 0x2,
    UAPI_DRV_CIPHER_SYMC_ALG_LEA = 0x3,
    UAPI_DRV_CIPHER_SYMC_ALG_DMA = 0x4,
    UAPI_DRV_CIPHER_SYMC_ALG_MAX,
    UAPI_DRV_CIPHER_SYMC_ALG_INVALID = 0xffffffff,
} uapi_drv_cipher_symc_alg_t;
 
typedef enum {
    UAPI_DRV_CIPHER_SYMC_WORK_MODE_ECB = 0x0,
    UAPI_DRV_CIPHER_SYMC_WORK_MODE_CBC,
    UAPI_DRV_CIPHER_SYMC_WORK_MODE_CTR,
    UAPI_DRV_CIPHER_SYMC_WORK_MODE_OFB,
    UAPI_DRV_CIPHER_SYMC_WORK_MODE_CFB,
    UAPI_DRV_CIPHER_SYMC_WORK_MODE_CCM,
    UAPI_DRV_CIPHER_SYMC_WORK_MODE_GCM,
    UAPI_DRV_CIPHER_SYMC_WORK_MODE_CBC_MAC,
    UAPI_DRV_CIPHER_SYMC_WORK_MODE_CMAC,
    UAPI_DRV_CIPHER_SYMC_WORK_MODE_MAX,
    UAPI_DRV_CIPHER_SYMC_WORK_MODE_INVALID = 0xffffffff,
} uapi_drv_cipher_symc_work_mode_t;
 
typedef enum {
    UAPI_DRV_CIPHER_SYMC_KEY_64BIT =  0x0,
    UAPI_DRV_CIPHER_SYMC_KEY_128BIT = 0x1,
    UAPI_DRV_CIPHER_SYMC_KEY_192BIT = 0x2,
    UAPI_DRV_CIPHER_SYMC_KEY_256BIT = 0x3,
    UAPI_DRV_CIPHER_SYMC_KEY_LENGTH_MAX,
    UAPI_DRV_CIPHER_SYMC_KEY_LENGTH_INVALID = 0xffffffff,
} uapi_drv_cipher_symc_key_length_t;
 
typedef enum {
    UAPI_DRV_CIPHER_SYMC_KEY_EVEN =  0x0,
    UAPI_DRV_CIPHER_SYMC_KEY_ODD  =  0x1,
    UAPI_DRV_CIPHER_SYMC_KEY_PARITY_MAX,
    UAPI_DRV_CIPHER_SYMC_KEY_PARITY_INVALID = 0xffffffff,
} uapi_drv_cipher_symc_key_parity_t;
 
typedef enum {
    UAPI_DRV_CIPHER_SYMC_BIT_WIDTH_1BIT = 0x0,
    UAPI_DRV_CIPHER_SYMC_BIT_WIDTH_8BIT = 0x1,
    UAPI_DRV_CIPHER_SYMC_BIT_WIDTH_64BIT = 0x2,
    UAPI_DRV_CIPHER_SYMC_BIT_WIDTH_128BIT = 0x3,
    UAPI_DRV_CIPHER_SYMC_BIT_WIDTH_MAX,
    UAPI_DRV_CIPHER_SYMC_BIT_WIDTH_INVALID = 0xffffffff,
} uapi_drv_cipher_symc_bit_width_t;
 
typedef enum {
    UAPI_DRV_CIPHER_SYMC_IV_DO_NOT_CHANGE = 0,
    UAPI_DRV_CIPHER_SYMC_IV_CHANGE_ONE_PKG,
    UAPI_DRV_CIPHER_SYMC_IV_CHANGE_ALL_PKG,
    /* GCM. */
    UAPI_DRV_CIPHER_SYMC_GCM_IV_DO_NOT_CHANGE,
    UAPI_DRV_CIPHER_SYMC_GCM_IV_CHANGE_START,
    UAPI_DRV_CIPHER_SYMC_GCM_IV_CHANGE_UPDATE,
    UAPI_DRV_CIPHER_SYMC_GCM_IV_CHANGE_FINISH,
    /* CCM. */
    UAPI_DRV_CIPHER_SYMC_CCM_IV_DO_NOT_CHANGE,
    UAPI_DRV_CIPHER_SYMC_CCM_IV_CHANGE_START,
    UAPI_DRV_CIPHER_SYMC_CCM_IV_CHANGE_UPDATE,
    UAPI_DRV_CIPHER_SYMC_CCM_IV_CHANGE_FINISH,
    UAPI_DRV_CIPHER_SYMC_IV_CHANGE_MAX,
    UAPI_DRV_CIPHER_SYMC_IV_CHANGE_INVALID = 0xffffffff,
} uapi_drv_cipher_symc_iv_change_type_t;
 
typedef enum uapi_drv_cipher_buffer_secure {
    UAPI_DRV_CIPHER_BUF_NONSECURE,
    UAPI_DRV_CIPHER_BUF_SECURE,
} uapi_drv_cipher_buffer_secure_t;
 
typedef enum uapi_drv_hash_type {
    UAPI_DRV_CIPHER_HASH_TYPE_SHA1 = 0xf690a0,
    UAPI_DRV_CIPHER_HASH_TYPE_SHA224 = 0x10690e0,
    UAPI_DRV_CIPHER_HASH_TYPE_SHA256 = 0x1169100,
    UAPI_DRV_CIPHER_HASH_TYPE_SHA384 = 0x127a180,
    UAPI_DRV_CIPHER_HASH_TYPE_SHA512 = 0x137a200,
    UAPI_DRV_CIPHER_HASH_TYPE_SM3 = 0x2169100,
 
    UAPI_DRV_CIPHER_HASH_TYPE_HMAC_SHA1 = 0x10f690a0,
    UAPI_DRV_CIPHER_HASH_TYPE_HMAC_SHA224 = 0x110690e0,
    UAPI_DRV_CIPHER_HASH_TYPE_HMAC_SHA256 = 0x11169100,
    UAPI_DRV_CIPHER_HASH_TYPE_HMAC_SHA384 = 0x1127a180,
    UAPI_DRV_CIPHER_HASH_TYPE_HMAC_SHA512 = 0x1137a200,
    UAPI_DRV_CIPHER_HASH_TYPE_HMAC_SM3 = 0x12169100,
 
    UAPI_DRV_CIPHER_HASH_TYPE_INVALID = 0xffffffff,
} uapi_drv_cipher_hash_type_t;
 
typedef struct uapi_drv_cipher_buf_attr {
    uint64_t uapi_mem_handle;       
    uint64_t addr_offset;           
    void *kapi_mem_handle;          
    uintptr_t phys_addr;            
    void *virt_addr;                
    uapi_drv_cipher_buffer_secure_t buf_sec; 
} uapi_drv_cipher_buf_attr_t;
 
typedef struct {
    uapi_drv_cipher_symc_alg_t symc_alg;        
    uapi_drv_cipher_symc_work_mode_t work_mode; 
    uapi_drv_cipher_symc_type_t symc_type;      
    bool is_long_term;                          
} uapi_drv_cipher_symc_attr_t;
 
typedef struct {
    uapi_drv_cipher_buf_attr_t aad_buf;    
    uint32_t aad_len;                      
    uint32_t data_len;                     
    uint32_t tag_len;                      
} uapi_drv_cipher_symc_config_aes_ccm_gcm_t;
 
#define UAPI_DRV_CIPHER_IV_LEN_IN_BYTES 16
 
typedef struct {
    uapi_drv_cipher_symc_alg_t symc_alg;                    
    uapi_drv_cipher_symc_work_mode_t work_mode;             
    uapi_drv_cipher_symc_key_length_t symc_key_length;      
    uapi_drv_cipher_symc_key_parity_t key_parity;           
    uapi_drv_cipher_symc_bit_width_t symc_bit_width;        
    uapi_drv_cipher_symc_iv_change_type_t iv_change_flag;   
    uint8_t iv[UAPI_DRV_CIPHER_IV_LEN_IN_BYTES];            
    uint32_t iv_length;                                     
    void *param;                                            
} uapi_drv_cipher_symc_ctrl_t;
 
typedef struct {
    bool is_long_term;                                  
    uapi_drv_cipher_symc_alg_t symc_alg;                
    uapi_drv_cipher_symc_work_mode_t work_mode;         
    uapi_drv_cipher_symc_key_length_t symc_key_length;  
    uint32_t keyslot_chn;                               
} uapi_drv_cipher_symc_mac_attr_t;
 
typedef struct uapi_drv_hash_attr {
    uint8_t *key;               
    uint32_t key_len;           
    uint32_t keyslot_handle;    
    uapi_drv_cipher_hash_type_t hash_type;  
    bool is_keyslot;    
    bool is_long_term;  
} uapi_drv_cipher_hash_attr_t;
 
#define UAPI_DRV_CIPHER_HASH_RESULT_SIZE_MAX_IN_WORD 16      // for SHA-512
#define UAPI_DRV_CIPHER_HASH_BLOCK_SIZE_MAX 128              // for SHA-512
 
typedef struct uapi_drv_cipher_hash_clone_ctx {
    uint32_t length[2]; 
    uint32_t state[UAPI_DRV_CIPHER_HASH_RESULT_SIZE_MAX_IN_WORD];  
    uint32_t tail_len;  
    uapi_drv_cipher_hash_type_t hash_type;  
    uint8_t o_key_pad[UAPI_DRV_CIPHER_HASH_BLOCK_SIZE_MAX];  
    uint8_t i_key_pad[UAPI_DRV_CIPHER_HASH_BLOCK_SIZE_MAX];  
    uint8_t tail[UAPI_DRV_CIPHER_HASH_BLOCK_SIZE_MAX]; 
} uapi_drv_cipher_hash_clone_ctx_t;
 
typedef struct {
    uapi_drv_cipher_hash_type_t hash_type;  
    uint8_t *password;      
    uint32_t plen;          
    uint8_t *salt;          
    uint32_t slen;          
    uint16_t count;         
} uapi_drv_cipher_kdf_pbkdf2_param_t;
 
typedef struct {
    uapi_drv_cipher_hash_type_t hmac_type;    
    uint8_t *salt;    
    uint32_t salt_length;    
    uint8_t *ikm;           
    uint32_t ikm_length;    
} uapi_drv_cipher_hkdf_extract_t;
 
typedef struct {
    uapi_drv_cipher_hash_type_t hmac_type;    
    uint8_t *prk;    
    uint32_t prk_length;    
    uint8_t *info;    
    uint32_t info_length;   
} uapi_drv_cipher_hkdf_expand_t;
 
typedef struct {
    uapi_drv_cipher_hash_type_t hmac_type;    
    uint8_t *salt;    
    uint32_t salt_length;    
    uint8_t *ikm;    
    uint32_t ikm_length;    
    uint8_t *info;    
    uint32_t info_length;    
} uapi_drv_cipher_hkdf_t;
 
errcode_t uapi_drv_cipher_symc_init(void);
 
errcode_t uapi_drv_cipher_symc_deinit(void);
 
errcode_t uapi_drv_cipher_symc_create(uint32_t *symc_handle, const uapi_drv_cipher_symc_attr_t *symc_attr);
 
errcode_t uapi_drv_cipher_symc_destroy(uint32_t symc_handle);
 
errcode_t uapi_drv_cipher_symc_set_config(uint32_t symc_handle, const uapi_drv_cipher_symc_ctrl_t *symc_ctrl);
 
errcode_t uapi_drv_cipher_symc_get_config(uint32_t symc_handle, const uapi_drv_cipher_symc_ctrl_t *symc_ctrl);
 
errcode_t uapi_drv_cipher_symc_attach(uint32_t symc_handle, uint32_t keyslot_handle);
 
errcode_t uapi_drv_cipher_symc_detach(uint32_t symc_handle, uint32_t keyslot_handle);
 
errcode_t uapi_drv_cipher_symc_encrypt(uint32_t symc_handle, const uapi_drv_cipher_buf_attr_t *src_buf,
    const uapi_drv_cipher_buf_attr_t *dst_buf, uint32_t length);
 
errcode_t uapi_drv_cipher_symc_decrypt(uint32_t symc_handle, const uapi_drv_cipher_buf_attr_t *src_buf,
    const uapi_drv_cipher_buf_attr_t *dst_buf, uint32_t length);
 
errcode_t uapi_drv_cipher_symc_get_tag(uint32_t symc_handle, uint8_t *tag, uint32_t tag_length);
 
errcode_t uapi_drv_cipher_mac_start(uint32_t *symc_handle, const uapi_drv_cipher_symc_mac_attr_t *mac_attr);
 
errcode_t uapi_drv_cipher_mac_update(uint32_t symc_handle, const uapi_drv_cipher_buf_attr_t *src_buf, uint32_t length);
 
errcode_t uapi_drv_cipher_mac_finish(uint32_t symc_handle, uint8_t *mac, uint32_t *mac_length);
 
errcode_t uapi_drv_cipher_hash_init(void);
 
errcode_t uapi_drv_cipher_hash_deinit(void);
 
errcode_t uapi_drv_cipher_hash_start(uint32_t *hash_handle, const uapi_drv_cipher_hash_attr_t *hash_attr);
 
errcode_t uapi_drv_cipher_hash_update(uint32_t hash_handle,  const uapi_drv_cipher_buf_attr_t *src_buf,
    const uint32_t len);
 
errcode_t uapi_drv_cipher_hash_finish(uint32_t hash_handle, uint8_t *out, uint32_t *out_len);
 
errcode_t uapi_drv_cipher_hash_get(uint32_t hash_handle, uapi_drv_cipher_hash_clone_ctx_t *hash_clone_ctx);
 
errcode_t uapi_drv_cipher_hash_set(uint32_t hash_handle, const uapi_drv_cipher_hash_clone_ctx_t *hash_clone_ctx);
 
errcode_t uapi_drv_cipher_hash_destroy(uint32_t hash_handle);
 
errcode_t uapi_drv_cipher_pbkdf2(const uapi_drv_cipher_kdf_pbkdf2_param_t *param, uint8_t *out, const uint32_t out_len);
 
errcode_t uapi_drv_cipher_hkdf_extract(uapi_drv_cipher_hkdf_extract_t *extract_param,
    uint8_t *prk, uint32_t *prk_length);
 
errcode_t uapi_drv_cipher_hkdf_expand(const uapi_drv_cipher_hkdf_expand_t *expand_param,
    uint8_t *okm, uint32_t okm_length);
 
errcode_t uapi_drv_cipher_hkdf(uapi_drv_cipher_hkdf_t *hkdf_param, uint8_t *okm, uint32_t okm_length);
 
#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif
 
#endif