1 /*
2 * This file is part of the openHiTLS project.
3 *
4 * openHiTLS is licensed under the Mulan PSL v2.
5 * You can use this software according to the terms and conditions of the Mulan PSL v2.
6 * You may obtain a copy of Mulan PSL v2 at:
7 *
8 * http://license.coscl.org.cn/MulanPSL2
9 *
10 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
11 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
12 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
13 * See the Mulan PSL v2 for more details.
14 */
15
16 #include "hitls_build.h"
17 #if defined(HITLS_CRYPTO_EAL) && defined(HITLS_CRYPTO_CIPHER)
18
19 #include "bsl_err_internal.h"
20 #include "crypt_errno.h"
21 #include "eal_cipher_local.h"
22 #include "crypt_modes.h"
23 #include "crypt_local_types.h"
24
25 #ifdef HITLS_CRYPTO_CTR
26 #include "crypt_modes_ctr.h"
27 #endif
28 #ifdef HITLS_CRYPTO_CBC
29 #include "crypt_modes_cbc.h"
30 #endif
31 #ifdef HITLS_CRYPTO_ECB
32 #include "crypt_modes_ecb.h"
33 #endif
34 #ifdef HITLS_CRYPTO_GCM
35 #include "crypt_modes_gcm.h"
36 #endif
37 #ifdef HITLS_CRYPTO_CCM
38 #include "crypt_modes_ccm.h"
39 #endif
40 #ifdef HITLS_CRYPTO_XTS
41 #include "crypt_modes_xts.h"
42 #endif
43 #ifdef HITLS_CRYPTO_AES
44 #include "crypt_aes.h"
45 #endif
46 #if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
47 #include "crypt_modes_chacha20poly1305.h"
48 #endif
49 #ifdef HITLS_CRYPTO_CHACHA20
50 #include "crypt_chacha20.h"
51 #endif
52 #ifdef HITLS_CRYPTO_SM4
53 #include "crypt_sm4.h"
54 #endif
55 #ifdef HITLS_CRYPTO_CFB
56 #include "crypt_modes_cfb.h"
57 #endif
58 #ifdef HITLS_CRYPTO_OFB
59 #include "crypt_modes_ofb.h"
60 #endif
61 #include "eal_common.h"
62 #include "bsl_sal.h"
63
64 #if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
65 static const EAL_CipherMethod CHACHA20_POLY1305_METHOD = {
66 (CipherNewCtx)MODES_CHACHA20POLY1305_NewCtx,
67 (CipherInitCtx)MODES_CHACHA20POLY1305_InitCtx,
68 (CipherDeInitCtx)MODES_CHACHA20POLY1305_DeInitCtx,
69 (CipherUpdate)MODES_CHACHA20POLY1305_Update,
70 (CipherFinal)MODES_CHACHA20POLY1305_Final,
71 (CipherCtrl)MODES_CHACHA20POLY1305_Ctrl,
72 (CipherFreeCtx)MODES_CHACHA20POLY1305_FreeCtx
73 };
74 #endif
75
76 #ifdef HITLS_CRYPTO_CTR
77 static const EAL_CipherMethod CTR_METHOD = {
78 (CipherNewCtx)MODES_CTR_NewCtx,
79 (CipherInitCtx)MODES_CTR_InitCtxEx,
80 (CipherDeInitCtx)MODES_CTR_DeInitCtx,
81 (CipherUpdate)MODES_CTR_UpdateEx,
82 (CipherFinal)MODES_CTR_Final,
83 (CipherCtrl)MODES_CTR_Ctrl,
84 (CipherFreeCtx)MODES_CTR_FreeCtx
85 };
86 #endif
87
88 #ifdef HITLS_CRYPTO_CBC
89 static const EAL_CipherMethod CBC_METHOD = {
90 (CipherNewCtx)MODES_CBC_NewCtx,
91 (CipherInitCtx)MODES_CBC_InitCtxEx,
92 (CipherDeInitCtx)MODES_CBC_DeInitCtx,
93 (CipherUpdate)MODES_CBC_UpdateEx,
94 (CipherFinal)MODES_CBC_FinalEx,
95 (CipherCtrl)MODES_CBC_Ctrl,
96 (CipherFreeCtx)MODES_CBC_FreeCtx
97 };
98 #endif
99
100 #ifdef HITLS_CRYPTO_ECB
101 static const EAL_CipherMethod ECB_METHOD = {
102 (CipherNewCtx)MODES_ECB_NewCtx,
103 (CipherInitCtx)MODES_ECB_InitCtxEx,
104 (CipherDeInitCtx)MODES_ECB_DeinitCtx,
105 (CipherUpdate)MODES_ECB_UpdateEx,
106 (CipherFinal)MODES_ECB_FinalEx,
107 (CipherCtrl)MODES_ECB_Ctrl,
108 (CipherFreeCtx)MODES_ECB_FreeCtx
109 };
110 #endif
111
112 #ifdef HITLS_CRYPTO_CCM
113 static const EAL_CipherMethod CCM_METHOD = {
114 (CipherNewCtx)MODES_CCM_NewCtx,
115 (CipherInitCtx)MODES_CCM_InitCtx,
116 (CipherDeInitCtx)MODES_CCM_DeInitCtx,
117 (CipherUpdate)MODES_CCM_UpdateEx,
118 (CipherFinal)MODES_CCM_Final,
119 (CipherCtrl)MODES_CCM_Ctrl,
120 (CipherFreeCtx)MODES_CCM_FreeCtx
121 };
122 #endif
123
124 #ifdef HITLS_CRYPTO_GCM
125 static const EAL_CipherMethod GCM_METHOD = {
126 (CipherNewCtx)MODES_GCM_NewCtx,
127 (CipherInitCtx)MODES_GCM_InitCtxEx,
128 (CipherDeInitCtx)MODES_GCM_DeInitCtx,
129 (CipherUpdate)MODES_GCM_UpdateEx,
130 (CipherFinal)MODES_GCM_Final,
131 (CipherCtrl)MODES_GCM_Ctrl,
132 (CipherFreeCtx)MODES_GCM_FreeCtx
133 };
134 #endif
135
136
137 #ifdef HITLS_CRYPTO_CFB
138 static const EAL_CipherMethod CFB_METHOD = {
139 (CipherNewCtx)MODES_CFB_NewCtx,
140 (CipherInitCtx)MODES_CFB_InitCtxEx,
141 (CipherDeInitCtx)MODES_CFB_DeInitCtx,
142 (CipherUpdate)MODES_CFB_UpdateEx,
143 (CipherFinal)MODES_CFB_Final,
144 (CipherCtrl)MODES_CFB_Ctrl,
145 (CipherFreeCtx)MODES_CFB_FreeCtx
146 };
147 #endif
148
149 #ifdef HITLS_CRYPTO_OFB
150 static const EAL_CipherMethod OFB_METHOD = {
151 (CipherNewCtx)MODES_OFB_NewCtx,
152 (CipherInitCtx)MODES_OFB_InitCtxEx,
153 (CipherDeInitCtx)MODES_OFB_DeInitCtx,
154 (CipherUpdate)MODES_OFB_UpdateEx,
155 (CipherFinal)MODES_OFB_Final,
156 (CipherCtrl)MODES_OFB_Ctrl,
157 (CipherFreeCtx)MODES_OFB_FreeCtx
158 };
159 #endif
160
161 #ifdef HITLS_CRYPTO_XTS
162 static const EAL_CipherMethod XTS_METHOD = {
163 (CipherNewCtx)MODES_XTS_NewCtx,
164 (CipherInitCtx)MODES_XTS_InitCtxEx,
165 (CipherDeInitCtx)MODES_XTS_DeInitCtx,
166 (CipherUpdate)MODES_XTS_UpdateEx,
167 (CipherFinal)MODES_XTS_Final,
168 (CipherCtrl)MODES_XTS_Ctrl,
169 (CipherFreeCtx)MODES_XTS_FreeCtx
170 };
171 #endif
172
173 /**
174 * g_modeMethod[id]
175 * The content of g_modeMethod has a hash mapping relationship with CRYPT_MODE_AlgId. Change the value accordingly.
176 */
177 static const EAL_CipherMethod *g_modeMethod[CRYPT_MODE_MAX] = {
178 #ifdef HITLS_CRYPTO_CBC
179 &CBC_METHOD,
180 #else
181 NULL,
182 #endif // cbc
183 #ifdef HITLS_CRYPTO_ECB
184 &ECB_METHOD,
185 #else
186 NULL,
187 #endif // ecb
188 #ifdef HITLS_CRYPTO_CTR
189 &CTR_METHOD,
190 #else
191 NULL,
192 #endif // ctr
193 #ifdef HITLS_CRYPTO_XTS
194 &XTS_METHOD,
195 #else
196 NULL,
197 #endif // xts
198 #ifdef HITLS_CRYPTO_CCM
199 &CCM_METHOD,
200 #else
201 NULL,
202 #endif // ccm
203 #ifdef HITLS_CRYPTO_GCM
204 &GCM_METHOD,
205 #else
206 NULL,
207 #endif // gcm
208 #if defined(HITLS_CRYPTO_CHACHA20) && defined(HITLS_CRYPTO_CHACHA20POLY1305)
209 &CHACHA20_POLY1305_METHOD,
210 #else
211 NULL,
212 #endif // chacha20
213 #ifdef HITLS_CRYPTO_CFB
214 &CFB_METHOD,
215 #else
216 NULL,
217 #endif // cfb
218 #ifdef HITLS_CRYPTO_OFB
219 &OFB_METHOD
220 #else
221 NULL
222 #endif // ofb
223 };
224
225
EAL_FindModeMethod(CRYPT_MODE_AlgId id)226 const EAL_CipherMethod *EAL_FindModeMethod(CRYPT_MODE_AlgId id)
227 {
228 if (id < 0 || id >= CRYPT_MODE_MAX) {
229 BSL_ERR_PUSH_ERROR(CRYPT_EAL_ERR_ALGID);
230 return NULL;
231 }
232 return g_modeMethod[id];
233 }
234
235 static const EAL_SymAlgMap SYM_ID_MAP[] = {
236 #ifdef HITLS_CRYPTO_AES
237 {.id = CRYPT_CIPHER_AES128_CBC, .modeId = CRYPT_MODE_CBC },
238 {.id = CRYPT_CIPHER_AES192_CBC, .modeId = CRYPT_MODE_CBC },
239 {.id = CRYPT_CIPHER_AES256_CBC, .modeId = CRYPT_MODE_CBC },
240 {.id = CRYPT_CIPHER_AES128_ECB, .modeId = CRYPT_MODE_ECB },
241 {.id = CRYPT_CIPHER_AES192_ECB, .modeId = CRYPT_MODE_ECB },
242 {.id = CRYPT_CIPHER_AES256_ECB, .modeId = CRYPT_MODE_ECB },
243 {.id = CRYPT_CIPHER_AES128_CTR, .modeId = CRYPT_MODE_CTR },
244 {.id = CRYPT_CIPHER_AES192_CTR, .modeId = CRYPT_MODE_CTR },
245 {.id = CRYPT_CIPHER_AES256_CTR, .modeId = CRYPT_MODE_CTR },
246 {.id = CRYPT_CIPHER_AES128_CCM, .modeId = CRYPT_MODE_CCM },
247 {.id = CRYPT_CIPHER_AES192_CCM, .modeId = CRYPT_MODE_CCM },
248 {.id = CRYPT_CIPHER_AES256_CCM, .modeId = CRYPT_MODE_CCM },
249 {.id = CRYPT_CIPHER_AES128_GCM, .modeId = CRYPT_MODE_GCM },
250 {.id = CRYPT_CIPHER_AES192_GCM, .modeId = CRYPT_MODE_GCM },
251 {.id = CRYPT_CIPHER_AES256_GCM, .modeId = CRYPT_MODE_GCM },
252 {.id = CRYPT_CIPHER_AES128_CFB, .modeId = CRYPT_MODE_CFB },
253 {.id = CRYPT_CIPHER_AES192_CFB, .modeId = CRYPT_MODE_CFB },
254 {.id = CRYPT_CIPHER_AES256_CFB, .modeId = CRYPT_MODE_CFB },
255 {.id = CRYPT_CIPHER_AES128_OFB, .modeId = CRYPT_MODE_OFB },
256 {.id = CRYPT_CIPHER_AES192_OFB, .modeId = CRYPT_MODE_OFB },
257 {.id = CRYPT_CIPHER_AES256_OFB, .modeId = CRYPT_MODE_OFB },
258 {.id = CRYPT_CIPHER_AES128_XTS, .modeId = CRYPT_MODE_XTS },
259 {.id = CRYPT_CIPHER_AES256_XTS, .modeId = CRYPT_MODE_XTS },
260 #endif
261 #ifdef HITLS_CRYPTO_CHACHA20
262 {.id = CRYPT_CIPHER_CHACHA20_POLY1305, .modeId = CRYPT_MODE_CHACHA20_POLY1305},
263 #endif
264 #ifdef HITLS_CRYPTO_SM4
265 {.id = CRYPT_CIPHER_SM4_XTS, .modeId = CRYPT_MODE_XTS },
266 {.id = CRYPT_CIPHER_SM4_ECB, .modeId = CRYPT_MODE_ECB },
267 {.id = CRYPT_CIPHER_SM4_CBC, .modeId = CRYPT_MODE_CBC },
268 {.id = CRYPT_CIPHER_SM4_CTR, .modeId = CRYPT_MODE_CTR },
269 {.id = CRYPT_CIPHER_SM4_GCM, .modeId = CRYPT_MODE_GCM },
270 {.id = CRYPT_CIPHER_SM4_CFB, .modeId = CRYPT_MODE_CFB },
271 {.id = CRYPT_CIPHER_SM4_OFB, .modeId = CRYPT_MODE_OFB },
272 #endif
273 };
274
EAL_FindCipher(CRYPT_CIPHER_AlgId id,const EAL_CipherMethod ** modeMethod)275 int32_t EAL_FindCipher(CRYPT_CIPHER_AlgId id, const EAL_CipherMethod **modeMethod)
276 {
277 uint32_t num = sizeof(SYM_ID_MAP) / sizeof(SYM_ID_MAP[0]);
278 const EAL_SymAlgMap *symAlgMap = NULL;
279
280 for (uint32_t i = 0; i < num; i++) {
281 if (SYM_ID_MAP[i].id == id) {
282 symAlgMap = &SYM_ID_MAP[i];
283 break;
284 }
285 }
286
287 if (symAlgMap == NULL) {
288 BSL_ERR_PUSH_ERROR(CRYPT_EAL_ERR_ALGID);
289 return CRYPT_EAL_ERR_ALGID;
290 }
291
292 *modeMethod = EAL_FindModeMethod(symAlgMap->modeId);
293 if (*modeMethod == NULL) {
294 BSL_ERR_PUSH_ERROR(CRYPT_EAL_ERR_ALGID);
295 return CRYPT_EAL_ERR_ALGID;
296 }
297 return CRYPT_SUCCESS;
298 }
299
300 #ifdef HITLS_CRYPTO_AES
301 static const EAL_SymMethod AES128_METHOD = {
302 (SetEncryptKey)CRYPT_AES_SetEncryptKey128,
303 (SetDecryptKey)CRYPT_AES_SetDecryptKey128,
304 (EncryptBlock)CRYPT_AES_Encrypt,
305 (DecryptBlock)CRYPT_AES_Decrypt,
306 (DeInitBlockCtx)CRYPT_AES_Clean,
307 NULL,
308 16,
309 sizeof(CRYPT_AES_Key),
310 CRYPT_SYM_AES128
311 };
312
313 static const EAL_SymMethod AES192_METHOD = {
314 (SetEncryptKey)CRYPT_AES_SetEncryptKey192,
315 (SetDecryptKey)CRYPT_AES_SetDecryptKey192,
316 (EncryptBlock)CRYPT_AES_Encrypt,
317 (DecryptBlock)CRYPT_AES_Decrypt,
318 (DeInitBlockCtx)CRYPT_AES_Clean,
319 NULL,
320 16,
321 sizeof(CRYPT_AES_Key),
322 CRYPT_SYM_AES192
323 };
324
325 static const EAL_SymMethod AES256_METHOD = {
326 (SetEncryptKey)CRYPT_AES_SetEncryptKey256,
327 (SetDecryptKey)CRYPT_AES_SetDecryptKey256,
328 (EncryptBlock)CRYPT_AES_Encrypt,
329 (DecryptBlock)CRYPT_AES_Decrypt,
330 (DeInitBlockCtx)CRYPT_AES_Clean,
331 NULL,
332 16,
333 sizeof(CRYPT_AES_Key),
334 CRYPT_SYM_AES256
335 };
336 #endif
337
338 #ifdef HITLS_CRYPTO_CHACHA20
339 static const EAL_SymMethod CHACHA20_METHOD = {
340 (SetEncryptKey)CRYPT_CHACHA20_SetKey,
341 (SetDecryptKey)CRYPT_CHACHA20_SetKey,
342 (EncryptBlock)CRYPT_CHACHA20_Update,
343 (DecryptBlock)CRYPT_CHACHA20_Update,
344 (DeInitBlockCtx)CRYPT_CHACHA20_Clean,
345 (CipherCtrl)CRYPT_CHACHA20_Ctrl,
346 1,
347 sizeof(CRYPT_CHACHA20_Ctx),
348 CRYPT_SYM_CHACHA20
349 };
350 #endif
351
352 #ifdef HITLS_CRYPTO_SM4
353 static const EAL_SymMethod SM4_METHOD = {
354 (SetEncryptKey)CRYPT_SM4_SetKey,
355 (SetDecryptKey)CRYPT_SM4_SetKey,
356 (EncryptBlock)CRYPT_SM4_Encrypt,
357 (DecryptBlock)CRYPT_SM4_Decrypt,
358 (DeInitBlockCtx)CRYPT_SM4_Clean,
359 NULL,
360 16,
361 sizeof(CRYPT_SM4_Ctx),
362 CRYPT_SYM_SM4
363 };
364 #endif
365
EAL_GetSymMethod(int32_t algId)366 const EAL_SymMethod *EAL_GetSymMethod(int32_t algId)
367 {
368 switch (algId) {
369 #ifdef HITLS_CRYPTO_AES
370 case CRYPT_CIPHER_AES128_CBC:
371 case CRYPT_CIPHER_AES128_ECB:
372 case CRYPT_CIPHER_AES128_XTS:
373 case CRYPT_CIPHER_AES128_CTR:
374 case CRYPT_CIPHER_AES128_CCM:
375 case CRYPT_CIPHER_AES128_GCM:
376 case CRYPT_CIPHER_AES128_CFB:
377 case CRYPT_CIPHER_AES128_OFB:
378 return &AES128_METHOD;
379 case CRYPT_CIPHER_AES192_CBC:
380 case CRYPT_CIPHER_AES192_ECB:
381 case CRYPT_CIPHER_AES192_CTR:
382 case CRYPT_CIPHER_AES192_CCM:
383 case CRYPT_CIPHER_AES192_GCM:
384 case CRYPT_CIPHER_AES192_CFB:
385 case CRYPT_CIPHER_AES192_OFB:
386 return &AES192_METHOD;
387 case CRYPT_CIPHER_AES256_CBC:
388 case CRYPT_CIPHER_AES256_ECB:
389 case CRYPT_CIPHER_AES256_CTR:
390 case CRYPT_CIPHER_AES256_XTS:
391 case CRYPT_CIPHER_AES256_CCM:
392 case CRYPT_CIPHER_AES256_GCM:
393 case CRYPT_CIPHER_AES256_CFB:
394 case CRYPT_CIPHER_AES256_OFB:
395 return &AES256_METHOD;
396 #endif
397 #ifdef HITLS_CRYPTO_SM4
398 case CRYPT_CIPHER_SM4_XTS:
399 case CRYPT_CIPHER_SM4_CBC:
400 case CRYPT_CIPHER_SM4_ECB:
401 case CRYPT_CIPHER_SM4_CTR:
402 case CRYPT_CIPHER_SM4_GCM:
403 case CRYPT_CIPHER_SM4_CFB:
404 case CRYPT_CIPHER_SM4_OFB:
405 return &SM4_METHOD;
406 #endif
407 #ifdef HITLS_CRYPTO_CHACHA20
408 case CRYPT_CIPHER_CHACHA20_POLY1305:
409 return &CHACHA20_METHOD;
410 #endif
411 default:
412 return NULL;
413 }
414 }
415
416 static CRYPT_CipherInfo g_cipherInfo[] = {
417 #ifdef HITLS_CRYPTO_AES
418 {.id = CRYPT_CIPHER_AES128_CBC, .blockSize = 16, .keyLen = 16, .ivLen = 16},
419 {.id = CRYPT_CIPHER_AES192_CBC, .blockSize = 16, .keyLen = 24, .ivLen = 16},
420 {.id = CRYPT_CIPHER_AES256_CBC, .blockSize = 16, .keyLen = 32, .ivLen = 16},
421 {.id = CRYPT_CIPHER_AES128_ECB, .blockSize = 16, .keyLen = 16, .ivLen = 0},
422 {.id = CRYPT_CIPHER_AES192_ECB, .blockSize = 16, .keyLen = 24, .ivLen = 0},
423 {.id = CRYPT_CIPHER_AES256_ECB, .blockSize = 16, .keyLen = 32, .ivLen = 0},
424 {.id = CRYPT_CIPHER_AES128_CTR, .blockSize = 1, .keyLen = 16, .ivLen = 16},
425 {.id = CRYPT_CIPHER_AES192_CTR, .blockSize = 1, .keyLen = 24, .ivLen = 16},
426 {.id = CRYPT_CIPHER_AES256_CTR, .blockSize = 1, .keyLen = 32, .ivLen = 16},
427 {.id = CRYPT_CIPHER_AES128_CCM, .blockSize = 1, .keyLen = 16, .ivLen = 12},
428 {.id = CRYPT_CIPHER_AES192_CCM, .blockSize = 1, .keyLen = 24, .ivLen = 12},
429 {.id = CRYPT_CIPHER_AES256_CCM, .blockSize = 1, .keyLen = 32, .ivLen = 12},
430 {.id = CRYPT_CIPHER_AES128_GCM, .blockSize = 1, .keyLen = 16, .ivLen = 12},
431 {.id = CRYPT_CIPHER_AES192_GCM, .blockSize = 1, .keyLen = 24, .ivLen = 12},
432 {.id = CRYPT_CIPHER_AES256_GCM, .blockSize = 1, .keyLen = 32, .ivLen = 12},
433 {.id = CRYPT_CIPHER_AES128_CFB, .blockSize = 1, .keyLen = 16, .ivLen = 16},
434 {.id = CRYPT_CIPHER_AES192_CFB, .blockSize = 1, .keyLen = 24, .ivLen = 16},
435 {.id = CRYPT_CIPHER_AES256_CFB, .blockSize = 1, .keyLen = 32, .ivLen = 16},
436 {.id = CRYPT_CIPHER_AES128_OFB, .blockSize = 1, .keyLen = 16, .ivLen = 16},
437 {.id = CRYPT_CIPHER_AES192_OFB, .blockSize = 1, .keyLen = 24, .ivLen = 16},
438 {.id = CRYPT_CIPHER_AES256_OFB, .blockSize = 1, .keyLen = 32, .ivLen = 16},
439 {.id = CRYPT_CIPHER_AES128_XTS, .blockSize = 1, .keyLen = 32, .ivLen = 16},
440 {.id = CRYPT_CIPHER_AES256_XTS, .blockSize = 1, .keyLen = 64, .ivLen = 16},
441 #endif
442 #ifdef HITLS_CRYPTO_CHACHA20
443 {.id = CRYPT_CIPHER_CHACHA20_POLY1305, .blockSize = 1, .keyLen = 32, .ivLen = 12},
444 #endif
445 #ifdef HITLS_CRYPTO_SM4
446 {.id = CRYPT_CIPHER_SM4_XTS, .blockSize = 1, .keyLen = 32, .ivLen = 16},
447 {.id = CRYPT_CIPHER_SM4_CBC, .blockSize = 16, .keyLen = 16, .ivLen = 16},
448 {.id = CRYPT_CIPHER_SM4_ECB, .blockSize = 16, .keyLen = 16, .ivLen = 0},
449 {.id = CRYPT_CIPHER_SM4_CTR, .blockSize = 1, .keyLen = 16, .ivLen = 16},
450 {.id = CRYPT_CIPHER_SM4_GCM, .blockSize = 1, .keyLen = 16, .ivLen = 12},
451 {.id = CRYPT_CIPHER_SM4_CFB, .blockSize = 1, .keyLen = 16, .ivLen = 16},
452 {.id = CRYPT_CIPHER_SM4_OFB, .blockSize = 1, .keyLen = 16, .ivLen = 16},
453 #endif
454 };
455
456 /**
457 * Search for the lengths of the block, key, and IV of algorithm. If ID in g_cipherInfo is changed,
458 * synchronize the value of the SDV_CRYPTO_CIPHER_FUN_TC008 test case.
459 * The input ID has a mapping relationship with g_ealCipherMethod and CRYPT_CIPHER_AlgId.
460 * The corresponding information must be synchronized to symMap.
461 * The symMap and CRYPT_SYM_AlgId, CRYPT_MODE_AlgId depend on each other. Synchronize the corresponding information.
462 */
EAL_GetCipherInfo(CRYPT_CIPHER_AlgId id,CRYPT_CipherInfo * info)463 int32_t EAL_GetCipherInfo(CRYPT_CIPHER_AlgId id, CRYPT_CipherInfo *info)
464 {
465 uint32_t num = sizeof(g_cipherInfo) / sizeof(g_cipherInfo[0]);
466 const CRYPT_CipherInfo *cipherInfoGet = NULL;
467
468 for (uint32_t i = 0; i < num; i++) {
469 if (g_cipherInfo[i].id == id) {
470 cipherInfoGet = &g_cipherInfo[i];
471 break;
472 }
473 }
474
475 if (cipherInfoGet == NULL) {
476 BSL_ERR_PUSH_ERROR(CRYPT_ERR_ALGID);
477 return CRYPT_ERR_ALGID;
478 }
479
480 info->blockSize = cipherInfoGet->blockSize;
481 info->ivLen = cipherInfoGet->ivLen;
482 info->keyLen = cipherInfoGet->keyLen;
483 return CRYPT_SUCCESS;
484 }
485
486 #endif
487