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 "bsl_init.h"
17 #include "bsl_err_internal.h"
18 #include "crypt_local_types.h"
19 #include "crypt_algid.h"
20 #include "crypt_errno.h"
21 #include "crypt_eal_rand.h"
22 #include "crypt_utils.h"
23 #include "asmcap_local.h"
24 #include "crypt_ealinit.h"
25 #include "crypt_util_rand.h"
26 #ifdef HITLS_CRYPTO_PROVIDER
27 #include "crypt_eal_provider.h"
28 #include "crypt_provider.h"
29 #endif
30 #include "crypt_eal_init.h"
31
32 static bool g_trigger = false;
33
34 #define CRYPT_INIT_ABILITY_CPU 1
35 #define CRYPT_INIT_ABILITY_BSL 2
36 #define CRYPT_INIT_ABILITY_RAND 4
37 #define CRYPT_INIT_ABILITY_PROVIDER 8
38 #define CRYPT_INIT_ABILITY_PROVIDER_RAND 16
39 #define CRYPT_INIT_ABILITY_LOCK 32
40
41
42
43 #if defined(HITLS_CRYPTO_PROVIDER)
ProviderModuleInit(uint64_t initOpt,int32_t alg)44 static int32_t ProviderModuleInit(uint64_t initOpt, int32_t alg)
45 {
46 (void) alg;
47 int32_t ret = CRYPT_SUCCESS;
48 if (initOpt & CRYPT_INIT_ABILITY_PROVIDER) {
49 ret = CRYPT_EAL_InitPreDefinedProviders();
50 if (ret != CRYPT_SUCCESS) {
51 return ret;
52 }
53 }
54 #if defined(HITLS_CRYPTO_DRBG)
55 if (initOpt & CRYPT_INIT_ABILITY_PROVIDER_RAND) {
56 ret = CRYPT_EAL_ProviderRandInitCtx(NULL, alg, "provider=default", NULL, 0, NULL);
57 if (ret != CRYPT_SUCCESS) {
58 return ret;
59 }
60 }
61 #endif
62 return ret;
63 }
64
ProviderModuleFree(uint64_t initOpt)65 static void ProviderModuleFree(uint64_t initOpt)
66 {
67 if (!(initOpt & CRYPT_INIT_ABILITY_PROVIDER)) {
68 return;
69 }
70 CRYPT_EAL_FreePreDefinedProviders();
71 }
72 #else
ProviderModuleInit(uint64_t initOpt,int32_t alg)73 static int32_t ProviderModuleInit(uint64_t initOpt, int32_t alg)
74 {
75 (void) initOpt;
76 (void) alg;
77 return CRYPT_SUCCESS;
78 }
79
ProviderModuleFree(uint64_t initOpt)80 static void ProviderModuleFree(uint64_t initOpt)
81 {
82 (void) initOpt;
83 return;
84 }
85 #endif
86
87 #if defined(HITLS_BSL_INIT)
BslModuleInit(uint64_t initOpt)88 static int32_t BslModuleInit(uint64_t initOpt)
89 {
90 if (!(initOpt & CRYPT_INIT_ABILITY_BSL)) {
91 return BSL_SUCCESS;
92 }
93 return BSL_GLOBAL_Init();
94 }
95
BslModuleFree(uint64_t initOpt)96 static void BslModuleFree(uint64_t initOpt)
97 {
98 if (!(initOpt & CRYPT_INIT_ABILITY_BSL)) {
99 return;
100 }
101 BSL_GLOBAL_DeInit();
102 }
103 #else
BslModuleInit(uint64_t initOpt)104 static int32_t BslModuleInit(uint64_t initOpt)
105 {
106 (void) initOpt;
107 return CRYPT_SUCCESS;
108 }
109
BslModuleFree(uint64_t initOpt)110 static void BslModuleFree(uint64_t initOpt)
111 {
112 (void) initOpt;
113 return;
114 }
115 #endif
116
117 #if defined(HITLS_CRYPTO_DRBG)
RandModuleFree(uint64_t initOpt)118 static void RandModuleFree(uint64_t initOpt)
119 {
120 if (!(initOpt & CRYPT_INIT_ABILITY_RAND)) {
121 return;
122 }
123 CRYPT_EAL_RandDeinit();
124 }
125
RandModuleInit(uint64_t initOpt,int32_t alg)126 static int32_t RandModuleInit(uint64_t initOpt, int32_t alg)
127 {
128 if (!(initOpt & CRYPT_INIT_ABILITY_RAND)) {
129 return BSL_SUCCESS;
130 }
131 return CRYPT_EAL_RandInit(alg, NULL, NULL, NULL, 0);
132 }
133 #else
RandModuleFree(uint64_t initOpt)134 static void RandModuleFree(uint64_t initOpt)
135 {
136 (void) initOpt;
137 return;
138 }
139
RandModuleInit(uint64_t initOpt,int32_t alg)140 static int32_t RandModuleInit(uint64_t initOpt, int32_t alg)
141 {
142 (void) alg;
143 (void) initOpt;
144 return CRYPT_SUCCESS;
145 }
146 #endif
147
GlobalLockInit(uint64_t initOpt,int32_t alg)148 static int32_t GlobalLockInit(uint64_t initOpt, int32_t alg)
149 {
150 (void) alg;
151 if ((initOpt & CRYPT_INIT_ABILITY_LOCK) == 0) {
152 return CRYPT_SUCCESS;
153 }
154 #ifdef HITLS_CRYPTO_ENTROPY
155 int32_t ret = EAL_SeedDrbgLockInit();
156 if (ret != CRYPT_SUCCESS) {
157 return ret;
158 }
159 #endif
160 return CRYPT_SUCCESS;
161 }
162
GlobalLockFree(uint64_t initOpt)163 static void GlobalLockFree(uint64_t initOpt)
164 {
165 if ((initOpt & CRYPT_INIT_ABILITY_LOCK) == 0) {
166 return;
167 }
168 #ifdef HITLS_CRYPTO_ENTROPY
169 EAL_SeedDrbgLockDeInit();
170 #endif
171 return;
172 }
173
174
175 #if defined(HITLS_EAL_INIT_OPTS)
CRYPT_EAL_Init(uint64_t opts)176 __attribute__((constructor(102))) int32_t CRYPT_EAL_Init(uint64_t opts)
177 #else
178 int32_t CRYPT_EAL_Init(uint64_t opts)
179 #endif
180 {
181 if (g_trigger) {
182 return CRYPT_SUCCESS;
183 }
184 int32_t ret = CRYPT_SUCCESS;
185 uint64_t initOpt = opts;
186 #if defined(HITLS_EAL_INIT_OPTS)
187 initOpt = HITLS_EAL_INIT_OPTS;
188 #endif
189
190 #if defined(HITLS_CRYPTO_INIT_RAND_ALG)
191 int32_t alg = HITLS_CRYPTO_INIT_RAND_ALG;
192 #else
193 int32_t alg = CRYPT_RAND_SHA256;
194 #endif
195
196 if (initOpt & CRYPT_INIT_ABILITY_CPU) {
197 GetCpuInstrSupportState();
198 }
199
200 ret = BslModuleInit(initOpt);
201 if (ret != CRYPT_SUCCESS) {
202 return ret;
203 }
204
205 ret = RandModuleInit(initOpt, alg);
206 if (ret != CRYPT_SUCCESS) {
207 BslModuleFree(initOpt);
208 return ret;
209 }
210
211 ret = ProviderModuleInit(initOpt, alg);
212 if (ret != CRYPT_SUCCESS) {
213 RandModuleFree(initOpt);
214 BslModuleFree(initOpt);
215 return ret;
216 }
217 ret = GlobalLockInit(initOpt, alg);
218 if (ret != CRYPT_SUCCESS) {
219 RandModuleFree(initOpt);
220 BslModuleFree(initOpt);
221 ProviderModuleFree(initOpt);
222 return ret;
223 }
224 g_trigger = true;
225 return ret;
226 }
227
228 #if defined(HITLS_EAL_INIT_OPTS)
CRYPT_EAL_Cleanup(uint64_t opts)229 __attribute__((destructor(101))) void CRYPT_EAL_Cleanup(uint64_t opts)
230 #else
231 void CRYPT_EAL_Cleanup(uint64_t opts)
232 #endif
233 {
234 uint64_t initOpt = opts;
235 #if defined(HITLS_EAL_INIT_OPTS)
236 initOpt = HITLS_EAL_INIT_OPTS;
237 #endif
238
239 ProviderModuleFree(initOpt);
240 RandModuleFree(initOpt);
241 BslModuleFree(initOpt);
242 GlobalLockFree(initOpt);
243 g_trigger = false;
244 }
245
246 #ifdef HITLS_CRYPTO_ASM_CHECK
247 typedef int (*HITLS_ASM_CHECK_CALLBACK)(void);
248
249 typedef struct EAL_CheckAsm {
250 uint32_t id;
251 HITLS_ASM_CHECK_CALLBACK callback[2];
252 } EAL_CheckAsm;
253
CryptCheckCapId(const BslCid id,const EAL_CheckAsm asmlist[],uint32_t len)254 static int32_t CryptCheckCapId(const BslCid id, const EAL_CheckAsm asmlist[], uint32_t len)
255 {
256 for (uint32_t i = 0; i < len; i++) {
257 if (asmlist[i].id != id) {
258 continue;
259 }
260 for (uint32_t j = 0; j < 2; j++) { // 2 means Alg and Method
261 if (asmlist[i].callback[j] != NULL && asmlist[i].callback[j]() != CRYPT_SUCCESS) {
262 BSL_ERR_PUSH_ERROR(CRYPT_EAL_ALG_ASM_NOT_SUPPORT);
263 return CRYPT_EAL_ALG_ASM_NOT_SUPPORT;
264 }
265 }
266 }
267 return CRYPT_SUCCESS;
268 }
269
270 static const EAL_CheckAsm HITLS_ASM_SYM_ALG_CHECK[] = {
271 /* symmetric encryption/decryption combination algorithm ID */
272 #if defined(HITLS_CRYPTO_AES_ASM)
273 {.id = CRYPT_CIPHER_AES128_CBC, .callback = {CRYPT_AES_AsmCheck, NULL}},
274 {.id = CRYPT_CIPHER_AES192_CBC, .callback = {CRYPT_AES_AsmCheck, NULL}},
275 {.id = CRYPT_CIPHER_AES256_CBC, .callback = {CRYPT_AES_AsmCheck, NULL}},
276 {.id = CRYPT_CIPHER_AES128_CTR, .callback = {CRYPT_AES_AsmCheck, NULL}},
277 {.id = CRYPT_CIPHER_AES192_CTR, .callback = {CRYPT_AES_AsmCheck, NULL}},
278 {.id = CRYPT_CIPHER_AES256_CTR, .callback = {CRYPT_AES_AsmCheck, NULL}},
279 {.id = CRYPT_CIPHER_AES128_ECB, .callback = {CRYPT_AES_AsmCheck, NULL}},
280 {.id = CRYPT_CIPHER_AES192_ECB, .callback = {CRYPT_AES_AsmCheck, NULL}},
281 {.id = CRYPT_CIPHER_AES256_ECB, .callback = {CRYPT_AES_AsmCheck, NULL}},
282 {.id = CRYPT_CIPHER_AES128_XTS, .callback = {CRYPT_AES_AsmCheck, NULL}},
283 {.id = CRYPT_CIPHER_AES256_XTS, .callback = {CRYPT_AES_AsmCheck, NULL}},
284 {.id = CRYPT_CIPHER_AES128_CCM, .callback = {CRYPT_AES_AsmCheck, NULL}},
285 {.id = CRYPT_CIPHER_AES192_CCM, .callback = {CRYPT_AES_AsmCheck, NULL}},
286 {.id = CRYPT_CIPHER_AES256_CCM, .callback = {CRYPT_AES_AsmCheck, NULL}},
287 #if defined(HITLS_CRYPTO_GCM_ASM)
288 {.id = CRYPT_CIPHER_AES128_GCM, .callback = {CRYPT_AES_AsmCheck, CRYPT_GHASH_AsmCheck}},
289 {.id = CRYPT_CIPHER_AES192_GCM, .callback = {CRYPT_AES_AsmCheck, CRYPT_GHASH_AsmCheck}},
290 {.id = CRYPT_CIPHER_AES256_GCM, .callback = {CRYPT_AES_AsmCheck, CRYPT_GHASH_AsmCheck}},
291 #endif // HITLS_CRYPTO_GCM_ASM
292 {.id = CRYPT_CIPHER_AES128_CFB, .callback = {CRYPT_AES_AsmCheck, NULL}},
293 {.id = CRYPT_CIPHER_AES192_CFB, .callback = {CRYPT_AES_AsmCheck, NULL}},
294 {.id = CRYPT_CIPHER_AES256_CFB, .callback = {CRYPT_AES_AsmCheck, NULL}},
295 {.id = CRYPT_CIPHER_AES128_OFB, .callback = {CRYPT_AES_AsmCheck, NULL}},
296 {.id = CRYPT_CIPHER_AES192_OFB, .callback = {CRYPT_AES_AsmCheck, NULL}},
297 {.id = CRYPT_CIPHER_AES256_OFB, .callback = {CRYPT_AES_AsmCheck, NULL}},
298 #endif // HITLS_CRYPTO_AES_ASM
299 #if defined(HITLS_CRYPTO_CHACHA20_ASM) || defined(HITLS_CRYPTO_CHACHA20POLY1305_ASM)
300 {.id = CRYPT_CIPHER_CHACHA20_POLY1305, .callback = {CRYPT_CHACHA20_AsmCheck, CRYPT_POLY1305_AsmCheck}},
301 #endif // HITLS_CRYPTO_CHACHA20POLY1305_ASM
302 #if defined(HITLS_CRYPTO_SM4_ASM)
303 {.id = CRYPT_CIPHER_SM4_XTS, .callback = {CRYPT_SM4_AsmCheck, NULL}},
304 {.id = CRYPT_CIPHER_SM4_CBC, .callback = {CRYPT_SM4_AsmCheck, NULL}},
305 {.id = CRYPT_CIPHER_SM4_ECB, .callback = {CRYPT_SM4_AsmCheck, NULL}},
306 {.id = CRYPT_CIPHER_SM4_CTR, .callback = {CRYPT_SM4_AsmCheck, NULL}},
307 #if defined(HITLS_CRYPTO_GCM_ASM)
308 {.id = CRYPT_CIPHER_SM4_GCM, .callback = {CRYPT_SM4_AsmCheck, CRYPT_GHASH_AsmCheck}},
309 #endif // HITLS_CRYPTO_GCM_ASM
310 {.id = CRYPT_CIPHER_SM4_CFB, .callback = {CRYPT_SM4_AsmCheck, NULL}},
311 {.id = CRYPT_CIPHER_SM4_OFB, .callback = {CRYPT_SM4_AsmCheck, NULL}},
312 #endif // HITLS_CRYPTO_SM4
313 {.id = CRYPT_CIPHER_MAX, .callback = {NULL, NULL}},
314 };
315
CRYPT_ASMCAP_Cipher(CRYPT_CIPHER_AlgId id)316 int32_t CRYPT_ASMCAP_Cipher(CRYPT_CIPHER_AlgId id)
317 {
318 return CryptCheckCapId((BslCid)id, HITLS_ASM_SYM_ALG_CHECK,
319 sizeof(HITLS_ASM_SYM_ALG_CHECK) / sizeof(EAL_CheckAsm));
320 }
321
322 #if defined(HITLS_CRYPTO_MD)
323 static const EAL_CheckAsm HITLS_ASM_MD_ALG_CHECK[] = {
324 /* hash algorithm ID */
325 #if defined(HITLS_CRYPTO_MD5_ASM)
326 {.id = CRYPT_MD_MD5, .callback = {CRYPT_MD5_AsmCheck, NULL}},
327 #endif
328 #if defined(HITLS_CRYPTO_SHA1_ASM)
329 {.id = CRYPT_MD_SHA1, .callback = {CRYPT_SHA1_AsmCheck, NULL}},
330 #endif
331 #if defined(HITLS_CRYPTO_SHA2_ASM)
332 {.id = CRYPT_MD_SHA224, .callback = {CRYPT_SHA2_AsmCheck, NULL}},
333 {.id = CRYPT_MD_SHA256, .callback = {CRYPT_SHA2_AsmCheck, NULL}},
334 {.id = CRYPT_MD_SHA384, .callback = {CRYPT_SHA2_AsmCheck, NULL}},
335 {.id = CRYPT_MD_SHA512, .callback = {CRYPT_SHA2_AsmCheck, NULL}},
336 #endif
337 #if defined(HITLS_CRYPTO_SM3_ASM)
338 {.id = CRYPT_MD_SM3, .callback = {CRYPT_SM3_AsmCheck, NULL}},
339 #endif
340 {.id = CRYPT_MD_MAX, .callback = {NULL, NULL}},
341 };
342 #endif
343
CRYPT_ASMCAP_Md(CRYPT_MD_AlgId id)344 int32_t CRYPT_ASMCAP_Md(CRYPT_MD_AlgId id)
345 {
346 return CryptCheckCapId((BslCid)id, HITLS_ASM_MD_ALG_CHECK,
347 sizeof(HITLS_ASM_MD_ALG_CHECK) / sizeof(EAL_CheckAsm));
348 }
349
350 #if defined(HITLS_CRYPTO_PKEY)
351 static const EAL_CheckAsm HITLS_ASM_PKEY_ALG_CHECK[] = {
352 /* Asymmetric algorithm ID */
353 #if defined(HITLS_CRYPTO_BN_ASM)
354 {.id = CRYPT_PKEY_DSA, .callback = {CRYPT_BN_AsmCheck, NULL}},
355 {.id = CRYPT_PKEY_RSA, .callback = {CRYPT_BN_AsmCheck, NULL}},
356 {.id = CRYPT_PKEY_DH, .callback = {CRYPT_BN_AsmCheck, NULL}},
357 #if defined(HITLS_CRYPTO_CURVE_NISTP256_ASM)
358 {.id = CRYPT_PKEY_ECDSA, .callback = {CRYPT_BN_AsmCheck, CRYPT_ECP256_AsmCheck}},
359 {.id = CRYPT_PKEY_ECDH, .callback = {CRYPT_BN_AsmCheck, CRYPT_ECP256_AsmCheck}},
360 #endif
361 {.id = CRYPT_PKEY_SM2, .callback = {CRYPT_BN_AsmCheck, NULL}},
362 #endif
363 {.id = CRYPT_PKEY_MAX, .callback = {NULL, NULL}},
364 };
365
CRYPT_ASMCAP_Pkey(CRYPT_PKEY_AlgId id)366 int32_t CRYPT_ASMCAP_Pkey(CRYPT_PKEY_AlgId id)
367 {
368 return CryptCheckCapId((BslCid)id, HITLS_ASM_PKEY_ALG_CHECK,
369 sizeof(HITLS_ASM_PKEY_ALG_CHECK) / sizeof(EAL_CheckAsm));
370 }
371 #endif // HITLS_CRYPTO_PKEY
372
373 #if defined(HITLS_CRYPTO_DRBG)
374 static const EAL_CheckAsm HITLS_ASM_DRBG_ALG_CHECK[] = {
375 /* RAND algorithm ID */
376 #if defined(HITLS_CRYPTO_SHA1_ASM)
377 {.id = CRYPT_RAND_SHA1, .callback = {CRYPT_SHA1_AsmCheck, NULL}},
378 {.id = CRYPT_RAND_HMAC_SHA1, .callback = {CRYPT_SHA1_AsmCheck, NULL}},
379 #endif
380 #if defined(HITLS_CRYPTO_SHA2_ASM)
381 {.id = CRYPT_RAND_SHA224, .callback = {CRYPT_SHA2_AsmCheck, NULL}},
382 {.id = CRYPT_RAND_SHA256, .callback = {CRYPT_SHA2_AsmCheck, NULL}},
383 {.id = CRYPT_RAND_SHA384, .callback = {CRYPT_SHA2_AsmCheck, NULL}},
384 {.id = CRYPT_RAND_SHA512, .callback = {CRYPT_SHA2_AsmCheck, NULL}},
385 {.id = CRYPT_RAND_HMAC_SHA224, .callback = {CRYPT_SHA2_AsmCheck, NULL}},
386 {.id = CRYPT_RAND_HMAC_SHA256, .callback = {CRYPT_SHA2_AsmCheck, NULL}},
387 {.id = CRYPT_RAND_HMAC_SHA384, .callback = {CRYPT_SHA2_AsmCheck, NULL}},
388 {.id = CRYPT_RAND_HMAC_SHA512, .callback = {CRYPT_SHA2_AsmCheck, NULL}},
389 #endif
390 #if defined(HITLS_CRYPTO_SM3_ASM)
391 {.id = CRYPT_RAND_SM3, .callback = {CRYPT_SM3_AsmCheck, NULL}},
392 #endif
393 #if defined(HITLS_CRYPTO_AES_ASM)
394 {.id = CRYPT_RAND_AES128_CTR, .callback = {CRYPT_AES_AsmCheck, NULL}},
395 {.id = CRYPT_RAND_AES192_CTR, .callback = {CRYPT_AES_AsmCheck, NULL}},
396 {.id = CRYPT_RAND_AES256_CTR, .callback = {CRYPT_AES_AsmCheck, NULL}},
397 {.id = CRYPT_RAND_AES128_CTR_DF, .callback = {CRYPT_AES_AsmCheck, NULL}},
398 {.id = CRYPT_RAND_AES192_CTR_DF, .callback = {CRYPT_AES_AsmCheck, NULL}},
399 {.id = CRYPT_RAND_AES256_CTR_DF, .callback = {CRYPT_AES_AsmCheck, NULL}},
400 #endif
401 #if defined(HITLS_CRYPTO_SM4_ASM)
402 {.id = CRYPT_RAND_SM4_CTR_DF, .callback = {CRYPT_SM4_AsmCheck, NULL}},
403 #endif
404 {.id = CRYPT_RAND_ALGID_MAX, .callback = {NULL, NULL}},
405 };
406
CRYPT_ASMCAP_Drbg(CRYPT_RAND_AlgId id)407 int32_t CRYPT_ASMCAP_Drbg(CRYPT_RAND_AlgId id)
408 {
409 return CryptCheckCapId((BslCid)id, HITLS_ASM_DRBG_ALG_CHECK,
410 sizeof(HITLS_ASM_DRBG_ALG_CHECK) / sizeof(EAL_CheckAsm));
411 }
412 #endif // HITLS_CRYPTO_DRBG
413
414 #if defined(HITLS_CRYPTO_MAC)
415 static const EAL_CheckAsm HITLS_ASM_MAC_ALG_CHECK[] = {
416 /* MAC algorithm ID */
417 #if defined(HITLS_CRYPTO_MD5_ASM)
418 {.id = CRYPT_MAC_HMAC_MD5, .callback = {CRYPT_MD5_AsmCheck, NULL}},
419 #endif
420 #if defined(HITLS_CRYPTO_SHA1_ASM)
421 {.id = CRYPT_MAC_HMAC_SHA1, .callback = {CRYPT_SHA1_AsmCheck, NULL}},
422 #endif
423 #if defined(HITLS_CRYPTO_SHA2_ASM)
424 {.id = CRYPT_MAC_HMAC_SHA224, .callback = {CRYPT_SHA2_AsmCheck, NULL}},
425 {.id = CRYPT_MAC_HMAC_SHA256, .callback = {CRYPT_SHA2_AsmCheck, NULL}},
426 {.id = CRYPT_MAC_HMAC_SHA384, .callback = {CRYPT_SHA2_AsmCheck, NULL}},
427 {.id = CRYPT_MAC_HMAC_SHA512, .callback = {CRYPT_SHA2_AsmCheck, NULL}},
428 #endif
429 #if defined(HITLS_CRYPTO_SM3_ASM)
430 {.id = CRYPT_MAC_HMAC_SM3, .callback = {CRYPT_SM3_AsmCheck, NULL}},
431 #endif
432 #if defined(HITLS_CRYPTO_AES_ASM)
433 {.id = CRYPT_MAC_CMAC_AES128, .callback = {CRYPT_AES_AsmCheck, NULL}},
434 {.id = CRYPT_MAC_CMAC_AES192, .callback = {CRYPT_AES_AsmCheck, NULL}},
435 {.id = CRYPT_MAC_CMAC_AES256, .callback = {CRYPT_AES_AsmCheck, NULL}},
436 {.id = CRYPT_MAC_GMAC_AES128, .callback = {CRYPT_AES_AsmCheck, NULL}},
437 {.id = CRYPT_MAC_GMAC_AES192, .callback = {CRYPT_AES_AsmCheck, NULL}},
438 {.id = CRYPT_MAC_GMAC_AES256, .callback = {CRYPT_AES_AsmCheck, NULL}},
439 #endif
440 {.id = CRYPT_MAC_MAX, .callback = {NULL, NULL}},
441 };
442
CRYPT_ASMCAP_Mac(CRYPT_MAC_AlgId id)443 int32_t CRYPT_ASMCAP_Mac(CRYPT_MAC_AlgId id)
444 {
445 return CryptCheckCapId((BslCid)id, HITLS_ASM_MAC_ALG_CHECK,
446 sizeof(HITLS_ASM_MAC_ALG_CHECK) / sizeof(EAL_CheckAsm));
447 }
448
449 #endif // HITLS_CRYPTO_MAC
450 #endif /* HITLS_CRYPTO_ASM_CHECK */
451