1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
|
/*
* Copyright (C) 2017-2020 Alibaba Group Holding Limited
*/
/******************************************************************************
* @file drv/sm2.h
* @brief Header File for SM2 Driver
* @version V2.0
* @date 9. DEC 2020
* @model SM2
******************************************************************************/
#ifndef _DRV_SM2_H_
#define _DRV_SM2_H_
#include <stdint.h>
#include "common.h"
#ifdef __cplusplus
extern "C" {
#endif
#define CSI_SM2_PUBKEY_LEN (65-1)
#define CSI_SM2_PRIVKEY_LEN (32)
#define CSI_SM2_PUBKEYTMP_LEN (65)
#define CSI_SM2_RK_LEN (32) //random
#define CSI_SM2_SIGNATURE_LEN (64)
#define CSI_SM2_DIGEST_LEN (32)
#define SM2_PRIME_CURVE_G_BYTES (64)
#define SM2_PRIME_CURVE_N_BYTES (32)
typedef struct {
uint32_t sm2_curve : 1; ///< supports 256bits curve
} sm2_capabilities_t;
/**
\brief SM2 ciphertext order
*/
typedef enum {
SM2_C1C3C2 = 0,
SM2_C1C2C3,
} sm2_cipher_order_e;
typedef enum {
SM2_ENDIAN_LITTLE = 0, ///< Little Endian
SM2_ENDIAN_BIG ///< Big Endian
} sm2_endian_mode_e;
/**
\brief SM2 status
*/
typedef struct {
uint32_t busy : 1; ///< Calculate busy flag
} csi_sm2_state_t;
/**
\brief SM2 key exchange role
*/
typedef enum { SM2_Role_Sponsor = 0, SM2_Role_Responsor } sm2_exchange_role_e;
/****** SM2 Event *****/
typedef enum {
SM2_EVENT_MAKE_KEY_COMPLETE = 0, ///< Make key completed
SM2_EVENT_ENCRYPT_COMPLETE, ///< Encrypt completed
SM2_EVENT_DECRYPT_COMPLETE, ///< Decrypt completed
SM2_EVENT_SIGN_COMPLETE, ///< Sign completed
SM2_EVENT_VERIFY_COMPLETE, ///< Verify completed
SM2_EVENT_EXCHANGE_KEY_COMPLETE, ///< Exchange key completed
} sm2_event_e;
typedef struct {
csi_dev_t dev;
void * cb;
void * arg;
csi_sm2_state_t state;
void * prim;
} csi_sm2_t;
///< Pointer to \ref csi_sm2_callback_t : SM2 Event call back.
typedef void (*csi_sm2_callback_t)(sm2_event_e event);
/**
\brief Initialize SM2.
\param[in] sm2 sm2 handle to operate.
\param[in] idx device id
\return \ref uint32_t
*/
csi_error_t csi_sm2_init(csi_sm2_t *sm2, uint32_t idx);
/**
\brief De-initialize SM2 Interface. stops operation and releases the software resources used by the interface
\param[in] sm2 sm2 handle to operate.
\return none
*/
void csi_sm2_uninit(csi_sm2_t *sm2);
/**
\brief sm2 get capability.
\param[in] sm2 Operate handle.
\return \ref uint32_t
*/
csi_error_t csi_sm2_config(csi_sm2_t *sm2, sm2_cipher_order_e co,
sm2_endian_mode_e endian);
/**
\brief Attach the callback handler to SM2
\param[in] sm2 Operate handle.
\param[in] cb Callback function
\param[in] arg User can define it by himself as callback's param
\return Error code \ref csi_error_t
*/
csi_error_t csi_sm2_attach_callback(csi_sm2_t *sm2, csi_sm2_callback_t cb, void *arg);
/**
\brief Detach the callback handler
\param[in] sm2 Operate handle.
\return none
*/
void csi_sm2_detach_callback(csi_sm2_t *sm2);
/**
\brief sm2 get capability.
\param[in] sm2 Operate handle.
\param[out] cap Pointer of sm2_capabilities_t.
\return Error code \ref csi_error_t
*/
csi_error_t csi_sm2_get_capabilities(csi_sm2_t *sm2, sm2_capabilities_t *cap);
/**
\brief check whether the public key and private key are a pair.
\param[in] sm2 sm2 handle to operate.
\param[in] private Pointer to the sm2 private key, alloc by caller.
\param[in] public Pointer to the sm2 public key, alloc by caller.
\return Error code \ref csi_error_t
*/
csi_error_t csi_sm2_check_keypair(csi_sm2_t *sm2, uint8_t pubkey[65], uint8_t prikey[32]);
/**
\brief generate sm2 key.
\param[in] sm2 sm2 handle to operate.
\param[out] private Pointer to the sm2 private key, alloc by caller.
\param[out] public Pointer to the sm2 public key, alloc by caller.
\return Error code \ref csi_error_t
*/
csi_error_t csi_sm2_gen_key(csi_sm2_t *sm2, uint8_t pubkey[65], uint8_t prikey[32]);
/**
\brief sm2 sign
\param[in] sm2 sm2 handle to operate.
\param[in] d Pointer to the digest.
\param[out] privkey Pointer to the private key
\param[out] s Pointer to the signature
\return Error code \ref csi_error_t
*/
csi_error_t csi_sm2_sign(csi_sm2_t *sm2, uint8_t d[32], uint8_t prikey[32], uint8_t s[64]);
/**
\brief sm2 sign
\param[in] sm2 sm2 handle to operate.
\param[in] d Pointer to the digest.
\param[out] privkey Pointer to the private key
\param[out] s Pointer to the signature
\return Error code \ref csi_error_t
*/
csi_error_t csi_sm2_sign_async(csi_sm2_t *sm2, uint8_t d[32], uint8_t prikey[32], uint8_t s[64]);
/* TODO */
/**
\brief sm2 verify
\param[in] sm2 sm2 handle to operate.
\param[in] d Pointer to the digest.
\param[out] privkey Pointer to the private key
\param[out] s Pointer to the signature
\return verify result
*/
bool csi_sm2_verify(csi_sm2_t *sm2, uint8_t d[32], uint8_t pubkey[65], uint8_t s[64]);
/**
\brief sm2 verify
\param[in] sm2 sm2 handle to operate.
\param[in] d Pointer to the digest.
\param[out] privkey Pointer to the private key
\param[out] s Pointer to the signature
\return verify result
*/
bool csi_sm2_verify_async(csi_sm2_t *sm2, uint8_t d[32], uint8_t pubkey[65], uint8_t s[64]);
/**
\brief sm2 encrypto
\param[in] sm2 sm2 handle to operate.
\param[in] Plain Pointer to the plaintext.
\param[in] PlainByteLen plaintext len
\param[in] pubKey public key.
\param[out] Cipher Pointer to the chipher
\param[out] CipherByteLen Pointer to the chipher len.
\return Error code \ref csi_error_t
*/
csi_error_t csi_sm2_encrypt(csi_sm2_t *sm2, uint8_t *Plain,
uint32_t PlainByteLen, uint8_t pubKey[65],
uint8_t *Cipher, uint32_t *CipherByteLen);
/**
\brief sm2 encrypto
\param[in] sm2 sm2 handle to operate.
\param[in] Cipher Pointer to the chipher
\param[in] CipherByteLen chipher len.
\param[in] prikey private key.
\param[out] Plain Pointer to the plaintext.
\param[out] PlainByteLen plaintext len
\return Error code \ref csi_error_t
*/
csi_error_t csi_sm2_decrypt(csi_sm2_t *sm2, uint8_t *Cipher,
uint32_t CipherByteLen, uint8_t prikey[32],
uint8_t *Plain, uint32_t *PlainByteLen);
/**
\brief sm2 key exchange
\param[in] sm2 sm2 handle to operate.
\return Error code \ref csi_error_t
*/
csi_error_t csi_sm2_exchangekey(csi_sm2_t *sm2, sm2_exchange_role_e role,
uint8_t *dA, uint8_t *PB, uint8_t *rA,
uint8_t *RA, uint8_t *RB, uint8_t *ZA,
uint8_t *ZB, uint32_t kByteLen, uint8_t *KA,
uint8_t *S1, uint8_t *SA);
/**
\brief sm2 key exchange get Z.
\param[in] sm2 sm2 handle to operate.
\return Error code \ref csi_error_t
*/
csi_error_t csi_sm2_getZ(csi_sm2_t *sm2, uint8_t *ID, uint32_t byteLenofID,
uint8_t pubKey[65], uint8_t Z[32]);
/**
\brief sm2 key exchange get E
\param[in] sm2 sm2 handle to operate.
\return Error code \ref csi_error_t
*/
csi_error_t csi_sm2_getE(csi_sm2_t *sm2, uint8_t *M, uint32_t byteLen,
uint8_t Z[32], uint8_t E[32]);
/**
\brief Get SM2 state.
\param[in] sm2 SM2 handle to operate.
\param[out] state SM2 state \ref csi_sm2_state_t.
\return Error code \ref csi_error_t
*/
csi_error_t csi_sm2_get_state(csi_sm2_t *sm2, csi_sm2_state_t *state);
/**
\brief Enable sm2 power manage
\param[in] sm2 SM2 handle to operate.
\return Error code \ref csi_error_t
*/
csi_error_t csi_sm2_enable_pm(csi_sm2_t *sm2);
/**
\brief Disable sm2 power manage
\param[in] sm2 SM2 handle to operate.
*/
void csi_sm2_disable_pm(csi_sm2_t *sm2);
#ifdef __cplusplus
extern "C" {
#endif
#endif
|
