drv_common_pke.h

浏览该文件的文档.

 
#ifndef DRV_COMMON_PKE_H
#define DRV_COMMON_PKE_H
 
#include "crypto_pke_struct.h"
#include "hal_pke.h"
#include "rom_lib.h"
 
#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif /* __cplusplus */
#endif /* __cplusplus */
 
/************************************************** pke common MICRO start************************************/
#define JAC_TO_AFF_INSTR_NUM    6
#define POINT_NAF_INSTR_NUM     3
 
#define LOCAL_STEP_CNT_INIT                    0x96C3785A
#define LOCAL_STEP_AUTH                        11
#define local_step(cnt)                        (LOCAL_STEP_CNT_INIT + LOCAL_STEP_AUTH * (cnt))
 
#define ED25519_MAX_HASH_ELEMENTS               3
#ifndef DRV_PKE_SM2_LEN_IN_BYTES
#define DRV_PKE_SM2_LEN_IN_BYTES                32
#endif
#define HALF_BYTE_VALUE 128
#define BYTE_VALUE 256
 
#define NEED_PAD_ZERO       1
#define NO_NEED_PAD_ZERO    0
 
#define gen_pke_data(len, value) ((drv_pke_data) {.length = (len), .data = (value)})
#define gen_pke_point(len, xvalue, yvalue) ((drv_pke_ecc_point) {.length = (len), .x = (xvalue), .y = (yvalue)})
 
#define PKE_COMPAT_ERRNO(err_code)      DRV_COMPAT_ERRNO(ERROR_MODULE_PKE, err_code)
 
#if (defined(CRYPTO_LOG_LEVEL) && (CRYPTO_LOG_LEVEL == 2 || CRYPTO_LOG_LEVEL == 3 || CRYPTO_LOG_LEVEL == 4))
#define crypto_dump_buffer(buffer_name, buffer, len) crypto_dump_data(buffer_name, buffer, len)
#else
#define crypto_dump_buffer(fmt, args...)
#endif
/************************************************** pke common MICRO end************************************/
 
/************************************************ pke common global variable start************************************/
typedef struct {
    td_u32 ram_section_a;   /* input data a ram section. */
    td_u32 ram_section_b;   /* input data b ram section. */
    td_u32 ram_section_c;   /* out data ram section. */
    td_u32 ram_section_tp;  /* intermediate parameter ram section. */
} instr_data_ram;
extern pke_default_parameters *g_ecc_params;
 
extern td_u32 *g_ecc_num;
/************************************************ pke common global variable end************************************/
 
/************************************************** pke common API start************************************/
const drv_pke_ecc_curve *crypto_drv_pke_common_get_ecc_curve(drv_pke_ecc_curve_type curve_type);
 
/* right shift any bit you want, the shift_bit should be [1, 8], and the k should be bigendian data. */
void crypto_drv_pke_common_arry_right_shift_value(td_u8 *k, td_u32 k_len, td_u32 shift_bit);
 
/* add or minus one. */
void crypto_drv_pke_common_array_add_plus_minus_one(td_u8 *k, td_u32 k_len, td_s32 value);
 
td_s32 crypto_drv_pke_common_get_binary_data(const td_u8 *mod_p, const td_u32 mod_p_len, td_u8 *mod_p_bin,
    td_u32 *mod_p_bin_len, td_u32 flag);
 
td_s32 crypto_drv_pke_common_convert_normal_scalar_to_naf(const td_u8 *k, const td_u32 k_len, td_s32 *k_naf,
    td_u32 *k_naf_len);
 
/* config data for montgomery calculation. */
td_s32 crypto_drv_pke_common_montgomery_data_config(td_u8 *rr, td_u32 rr_len, td_u8 *rrp, td_u32 rrp_len);
 
/* whether the data is whole zero. */
td_bool crypto_drv_pke_common_is_zero(const td_u8 *val, td_u32 klen);
 
td_void crypto_drv_pke_common_array_sub_value(td_u8 *k, td_u32 k_len, td_s32 value);
 
td_s32 crypto_drv_pke_common_little_big_endian_trans(td_u8 *output_endian, const td_u8 *input_endian, td_u32 byte_len);
 
td_s32 crypto_drv_pke_common_byte_stream_to_int_array(const td_u8 *byte_stream, const td_u32 stream_length,
    td_u32 *int_array, td_u32 array_length);
 
td_void crypto_drv_pke_common_normal_add(const drv_pke_data *a, const drv_pke_data *b, const drv_pke_data *c);
 
td_s32 crypto_drv_pke_common_set_mont_param(const drv_pke_data *p);
 
td_s32 crypto_drv_pke_common_set_ecc_mont_param(const drv_pke_data *p);
td_s32 crypto_drv_pke_common_batch_instr_process(const rom_lib *batch_instr, td_u32 work_len);
 
td_s32 crypto_drv_pke_common_get_single_instr(td_u32 instr_cmd, const instr_data_ram *data_ram, td_u32 *out_instr);
td_s32 crypto_drv_pke_common_single_instr_process(td_u32 single_instr, td_u32 work_len);
 
#ifdef PKE_V5_DEBUG
td_s32 crypto_drv_pke_common_batch_instr_single_process_test(const rom_lib *signle_instr_list, td_u32 work_len);
#endif
 
td_s32 crypto_drv_pke_common_jac_to_aff_cal(const rom_lib *batch_instr, const td_u32 batch_instr_num,
    const drv_pke_data *mod_p);
 
td_s32 crypto_drv_pke_common_point_mul_naf(const rom_lib *batch_instr, const td_u32 batch_instr_num,
    const drv_pke_data *k, td_u32 work_len);
 
td_s32 crypto_drv_pke_common_calc_hash(const drv_pke_data* arr, const td_u32 arr_len, const drv_pke_hash_type hash_type,
    drv_pke_data *hash);
 
td_s32 crypto_drv_pke_common_resume(void);
 
void crypto_drv_pke_common_suspend(void);
 
/* check whether y >= p, if yes, return failure. */
td_s32 crypto_drv_pke_common_limit_value_check(const td_u8 *in_buf, const td_u8 *limit_value, const td_u32 limit_len);
 
td_s32 crypto_drv_pke_common_range_check(const td_u8 *in_buf, const td_u8 *limit_value, const td_u32 limit_len);
 
td_s32 crypto_drv_pke_common_init_param(const drv_pke_ecc_curve *ecc);
 
/************************************************** pke common API end************************************/
td_s32 crypto_drv_pke_common_ecc_sign(drv_pke_ecc_curve_type curve_type, const drv_pke_data *priv_key,
    const drv_pke_data *hash, const drv_pke_ecc_sig *sig);
 
td_s32 crypto_drv_pke_common_ecc_verify(drv_pke_ecc_curve_type curve_type, const drv_pke_ecc_point *pub_key,
    const drv_pke_data *hash, const drv_pke_ecc_sig *sig);
 
td_s32 crypto_drv_pke_common_sm2_sign(const drv_pke_data *priv_key, const drv_pke_data *hash,
    const drv_pke_ecc_sig *sig);
 
td_s32 crypto_drv_pke_common_sm2_verify(const drv_pke_ecc_point *pub_key, const drv_pke_data *hash,
    const drv_pke_ecc_sig *sig);
 
td_s32 crypto_drv_pke_common_sm2_public_encrypt(const drv_pke_ecc_point *pub_key, const drv_pke_data *plain_text,
    const drv_pke_data *cipher_text);
 
td_s32 crypto_drv_pke_common_sm2_private_decrypt(const drv_pke_data *priv_key, const drv_pke_data *cipher_text,
    const drv_pke_data *plain_text);
 
td_s32 crypto_drv_pke_common_sm2_dsa_hash(const drv_pke_data *sm2_id, const drv_pke_ecc_point *pub_key,
    const drv_pke_msg *msg, const drv_pke_data *hash);
 
td_s32 normal_sub(const drv_pke_data *a, const drv_pke_data *b, const drv_pke_data *c);
 
#ifdef __cplusplus
#if __cplusplus
}
#endif /* __cplusplus */
#endif /* __cplusplus */
 
#endif /* DRV_COMMON_PKE_H */