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 <stdbool.h>
17 #include "helper.h"
18
19 #include "crypt_algid.h"
20 #include "hitls_build.h"
21 #include "crypto_test_util.h"
22
23 #define ERR_ID (-1)
24
25 typedef struct {
26 int id;
27 int offset;
28 } MdAlgMap;
29
30 static MdAlgMap g_mdAlgMap[] = {
31 { CRYPT_MD_MD5, 0 },
32 { CRYPT_MD_SHA1, 1 },
33 { CRYPT_MD_SHA224, 2 },
34 { CRYPT_MD_SHA256, 3 },
35 { CRYPT_MD_SHA384, 4 },
36 { CRYPT_MD_SHA512, 5 },
37 { CRYPT_MD_SHA3_224, 6 },
38 { CRYPT_MD_SHA3_256, 7 },
39 { CRYPT_MD_SHA3_384, 8 },
40 { CRYPT_MD_SHA3_512, 9 },
41 { CRYPT_MD_SHAKE128, 10 },
42 { CRYPT_MD_SHAKE256, 11 },
43 { CRYPT_MD_SM3, 12 },
44 };
45
46 #define MD_ALG_MAP_CNT ((int)(sizeof(g_mdAlgMap) / sizeof(MdAlgMap)))
47
48 // All MD algorithms are available by default.
49 static int g_mdDisableTable[MD_ALG_MAP_CNT] = { 0 };
50 static bool g_isInitMd = false;
51
52 static int g_avlRandAlg = -1;
53 static bool g_isInitRandAlg = false;
54
InitMdTable(void)55 static void InitMdTable(void)
56 {
57 if (g_isInitMd) {
58 return;
59 }
60 #ifndef HITLS_CRYPTO_MD5
61 g_mdDisableTable[0] = 1;
62 #endif
63 #ifndef HITLS_CRYPTO_SHA1
64 g_mdDisableTable[1] = 1;
65 #endif
66 #ifndef HITLS_CRYPTO_SHA224
67 g_mdDisableTable[2] = 1;
68 #endif
69 #ifndef HITLS_CRYPTO_SHA256
70 g_mdDisableTable[3] = 1;
71 #endif
72 #ifndef HITLS_CRYPTO_SHA384
73 g_mdDisableTable[4] = 1;
74 #endif
75 #ifndef HITLS_CRYPTO_SHA512
76 g_mdDisableTable[5] = 1;
77 #endif
78 #ifndef HITLS_CRYPTO_SHA3
79 g_mdDisableTable[6] = 1;
80 g_mdDisableTable[7] = 1;
81 g_mdDisableTable[8] = 1;
82 g_mdDisableTable[9] = 1;
83 g_mdDisableTable[10] = 1;
84 g_mdDisableTable[11] = 1;
85 #endif
86 #ifndef HITLS_CRYPTO_SM3
87 g_mdDisableTable[12] = 1;
88 #endif
89 g_isInitMd = true;
90 }
91
IsDrbgHashDisabled(void)92 static bool IsDrbgHashDisabled(void)
93 {
94 #ifdef HITLS_CRYPTO_DRBG_HASH
95 return false;
96 #else
97 return true;
98 #endif
99 }
100
IsDrbgHmacDisabled(void)101 static bool IsDrbgHmacDisabled(void)
102 {
103 #ifdef HITLS_CRYPTO_DRBG_HMAC
104 return false;
105 #else
106 return true;
107 #endif
108 }
109
IsDrbgCtrDisabled(void)110 static bool IsDrbgCtrDisabled(void)
111 {
112 #ifdef HITLS_CRYPTO_DRBG_CTR
113 return false;
114 #else
115 return true;
116 #endif
117 }
118
IsDrbgCtrSm4Disabled()119 static bool IsDrbgCtrSm4Disabled()
120 {
121 #if defined(HITLS_CRYPTO_DRBG_CTR) && defined(HITLS_CRYPTO_DRBG_GM) && defined(HITLS_CRYPTO_SM4)
122 return false;
123 #else
124 return true;
125 #endif
126 }
127
128
GetDrbgHashAlgId(void)129 static int GetDrbgHashAlgId(void)
130 {
131 InitMdTable();
132 // CRYPT_RAND_SHA256 is preferred (224 depends on 256).
133 if (g_mdDisableTable[3] == 0) {
134 return CRYPT_RAND_SHA256;
135 }
136
137 if (g_mdDisableTable[5] == 0) {
138 return CRYPT_RAND_SHA512;
139 }
140
141 if (g_mdDisableTable[1] == 0) {
142 return CRYPT_RAND_SHA1;
143 }
144 return ERR_ID;
145 }
146
GetDrbgHmacAlgId(void)147 static int GetDrbgHmacAlgId(void)
148 {
149 InitMdTable();
150 if (g_mdDisableTable[3] == 0) {
151 return CRYPT_RAND_HMAC_SHA256;
152 }
153
154 if (g_mdDisableTable[5] == 0) {
155 return CRYPT_RAND_HMAC_SHA512;
156 }
157
158 if (g_mdDisableTable[1] == 0) {
159 return CRYPT_RAND_HMAC_SHA1;
160 }
161 return ERR_ID;
162 }
163
IsMdAlgDisabled(int id)164 bool IsMdAlgDisabled(int id)
165 {
166 InitMdTable();
167 bool res = false; // By default, this algorithm is not disabled.
168
169 for (int i = 0; i < MD_ALG_MAP_CNT; i++) {
170 if (id == g_mdAlgMap[i].id) {
171 res = g_mdDisableTable[g_mdAlgMap[i].offset] == 1;
172 break;
173 }
174 }
175 return res;
176 }
177
IsHmacAlgDisabled(int id)178 bool IsHmacAlgDisabled(int id)
179 {
180 #ifdef HITLS_CRYPTO_HMAC
181 InitMdTable();
182 switch (id) {
183 case CRYPT_MAC_HMAC_MD5:
184 return g_mdDisableTable[0] == 1;
185 case CRYPT_MAC_HMAC_SHA1:
186 return g_mdDisableTable[1] == 1;
187 case CRYPT_MAC_HMAC_SHA224:
188 return g_mdDisableTable[2] == 1;
189 case CRYPT_MAC_HMAC_SHA256:
190 return g_mdDisableTable[3] == 1;
191 case CRYPT_MAC_HMAC_SHA384:
192 return g_mdDisableTable[4] == 1;
193 case CRYPT_MAC_HMAC_SHA512:
194 return g_mdDisableTable[5] == 1;
195 case CRYPT_MAC_HMAC_SHA3_224:
196 return g_mdDisableTable[6] == 1;
197 case CRYPT_MAC_HMAC_SHA3_256:
198 return g_mdDisableTable[7] == 1;
199 case CRYPT_MAC_HMAC_SHA3_384:
200 return g_mdDisableTable[8] == 1;
201 case CRYPT_MAC_HMAC_SHA3_512:
202 return g_mdDisableTable[9] == 1;
203 case CRYPT_MAC_HMAC_SM3:
204 return g_mdDisableTable[12] == 1;
205 default:
206 return false;
207 }
208 #else
209 (void)id;
210 return false;
211 #endif
212 }
213
IsMacAlgDisabled(int id)214 bool IsMacAlgDisabled(int id)
215 {
216 switch (id) {
217 case CRYPT_MAC_HMAC_MD5:
218 case CRYPT_MAC_HMAC_SHA1:
219 case CRYPT_MAC_HMAC_SHA224:
220 case CRYPT_MAC_HMAC_SHA256:
221 case CRYPT_MAC_HMAC_SHA384:
222 case CRYPT_MAC_HMAC_SHA512:
223 case CRYPT_MAC_HMAC_SM3:
224 return IsHmacAlgDisabled(id);
225 case CRYPT_MAC_CBC_MAC_SM4:
226 #ifdef HITLS_CRYPTO_CBC_MAC
227 return false;
228 #else
229 return true;
230 #endif
231 default:
232 return false;
233 }
234 }
235
IsDrbgHashAlgDisabled(int id)236 bool IsDrbgHashAlgDisabled(int id)
237 {
238 if (IsDrbgHashDisabled()) {
239 return true;
240 }
241 InitMdTable();
242 switch (id) {
243 case CRYPT_RAND_SHA1:
244 return g_mdDisableTable[1] == 1;
245 case CRYPT_RAND_SHA224:
246 return g_mdDisableTable[2] == 1;
247 case CRYPT_RAND_SHA256:
248 return g_mdDisableTable[3] == 1;
249 case CRYPT_RAND_SHA384:
250 return g_mdDisableTable[4] == 1;
251 case CRYPT_RAND_SHA512:
252 return g_mdDisableTable[5] == 1;
253 case CRYPT_RAND_SM3:
254 #ifdef HITLS_CRYPTO_DRBG_GM
255 return g_mdDisableTable[12] == 1;
256 #else
257 return true;
258 #endif
259 default:
260 return false;
261 }
262 }
263
IsDrbgHmacAlgDisabled(int id)264 bool IsDrbgHmacAlgDisabled(int id)
265 {
266 if (IsDrbgHmacDisabled()) {
267 return true;
268 }
269 InitMdTable();
270 switch (id) {
271 case CRYPT_RAND_HMAC_SHA1:
272 return g_mdDisableTable[1] == 1;
273 case CRYPT_RAND_HMAC_SHA224:
274 return g_mdDisableTable[2] == 1;
275 case CRYPT_RAND_HMAC_SHA256:
276 return g_mdDisableTable[3] == 1;
277 case CRYPT_RAND_HMAC_SHA384:
278 return g_mdDisableTable[4] == 1;
279 case CRYPT_RAND_HMAC_SHA512:
280 return g_mdDisableTable[5] == 1;
281 default:
282 return false;
283 }
284 }
285
GetAvailableRandAlgId(void)286 int GetAvailableRandAlgId(void)
287 {
288 if (g_isInitRandAlg) {
289 return g_avlRandAlg;
290 }
291 g_isInitRandAlg = true;
292
293 if (!IsDrbgHashDisabled()) {
294 g_avlRandAlg = GetDrbgHashAlgId();
295 if (g_avlRandAlg != ERR_ID) {
296 return g_avlRandAlg;
297 }
298 }
299
300 if (!IsDrbgHmacDisabled()) {
301 g_avlRandAlg = GetDrbgHmacAlgId();
302 if (g_avlRandAlg != ERR_ID) {
303 return g_avlRandAlg;
304 }
305 }
306
307 if (!IsDrbgCtrDisabled()) {
308 g_avlRandAlg = CRYPT_RAND_AES256_CTR;
309 return g_avlRandAlg;
310 }
311
312 return g_avlRandAlg;
313 }
314
IsRandAlgDisabled(int id)315 bool IsRandAlgDisabled(int id)
316 {
317 switch (id) {
318 case CRYPT_RAND_SHA1:
319 case CRYPT_RAND_SHA224:
320 case CRYPT_RAND_SHA256:
321 case CRYPT_RAND_SHA384:
322 case CRYPT_RAND_SHA512:
323 case CRYPT_RAND_SM3:
324 return IsDrbgHashAlgDisabled(id);
325 case CRYPT_RAND_HMAC_SHA1:
326 case CRYPT_RAND_HMAC_SHA224:
327 case CRYPT_RAND_HMAC_SHA256:
328 case CRYPT_RAND_HMAC_SHA384:
329 case CRYPT_RAND_HMAC_SHA512:
330 return IsDrbgHmacAlgDisabled(id);
331 case CRYPT_RAND_AES128_CTR:
332 case CRYPT_RAND_AES192_CTR:
333 case CRYPT_RAND_AES256_CTR:
334 case CRYPT_RAND_AES128_CTR_DF:
335 case CRYPT_RAND_AES192_CTR_DF:
336 case CRYPT_RAND_AES256_CTR_DF:
337 return IsDrbgCtrDisabled();
338 case CRYPT_RAND_SM4_CTR_DF:
339 return IsDrbgCtrSm4Disabled();
340 default:
341 return false;
342 }
343 return false;
344 }
345
IsAesAlgDisabled(int id)346 bool IsAesAlgDisabled(int id)
347 {
348 #ifdef HITLS_CRYPTO_AES
349 switch (id) {
350 #ifndef HITLS_CRYPTO_CBC
351 case CRYPT_CIPHER_AES128_CBC:
352 case CRYPT_CIPHER_AES192_CBC:
353 case CRYPT_CIPHER_AES256_CBC:
354 return true;
355 #endif
356 #ifndef HITLS_CRYPTO_ECB
357 case CRYPT_CIPHER_AES128_ECB:
358 case CRYPT_CIPHER_AES192_ECB:
359 case CRYPT_CIPHER_AES256_ECB:
360 return true;
361 #endif
362 #ifndef HITLS_CRYPTO_CTR
363 case CRYPT_CIPHER_AES128_CTR:
364 case CRYPT_CIPHER_AES192_CTR:
365 case CRYPT_CIPHER_AES256_CTR:
366 return true;
367 #endif
368 #ifndef HITLS_CRYPTO_CCM
369 case CRYPT_CIPHER_AES128_CCM:
370 case CRYPT_CIPHER_AES192_CCM:
371 case CRYPT_CIPHER_AES256_CCM:
372 return true;
373 #endif
374 #ifndef HITLS_CRYPTO_GCM
375 case CRYPT_CIPHER_AES128_GCM:
376 case CRYPT_CIPHER_AES192_GCM:
377 case CRYPT_CIPHER_AES256_GCM:
378 return true;
379 #endif
380 #ifndef HITLS_CRYPTO_CFB
381 case CRYPT_CIPHER_AES128_CFB:
382 case CRYPT_CIPHER_AES192_CFB:
383 case CRYPT_CIPHER_AES256_CFB:
384 return true;
385 #endif
386 #ifndef HITLS_CRYPTO_OFB
387 case CRYPT_CIPHER_AES128_OFB:
388 case CRYPT_CIPHER_AES192_OFB:
389 case CRYPT_CIPHER_AES256_OFB:
390 return true;
391 #endif
392 #ifndef HITLS_CRYPTO_XTS
393 case CRYPT_CIPHER_AES128_XTS:
394 case CRYPT_CIPHER_AES256_XTS:
395 return true;
396 #endif
397 default:
398 return false; // Unsupported algorithm ID
399 }
400 #else
401 (void)id;
402 return true;
403 #endif
404 }
405
IsSm4AlgDisabled(int id)406 bool IsSm4AlgDisabled(int id)
407 {
408 #ifdef HITLS_CRYPTO_SM4
409 switch (id) {
410 #ifndef HITLS_CRYPTO_XTS
411 case CRYPT_CIPHER_SM4_XTS:
412 return true;
413 #endif
414 #ifndef HITLS_CRYPTO_CBC
415 case CRYPT_CIPHER_SM4_CBC:
416 return true;
417 #endif
418 #ifndef HITLS_CRYPTO_ECB
419 case CRYPT_CIPHER_SM4_ECB:
420 return true;
421 #endif
422 #ifndef HITLS_CRYPTO_CTR
423 case CRYPT_CIPHER_SM4_CTR:
424 return true;
425 #endif
426 #ifndef HITLS_CRYPTO_GCM
427 case CRYPT_CIPHER_SM4_GCM:
428 return true;
429 #endif
430 #ifndef HITLS_CRYPTO_CFB
431 case CRYPT_CIPHER_SM4_CFB:
432 return true;
433 #endif
434 #ifndef HITLS_CRYPTO_OFB
435 case CRYPT_CIPHER_SM4_OFB:
436 return true;
437 #endif
438 default:
439 return false; // Unsupported algorithm ID
440 }
441 #else
442 (void)id;
443 return true;
444 #endif
445 }
446
IsCipherAlgDisabled(int id)447 bool IsCipherAlgDisabled(int id)
448 {
449 switch (id) {
450 case CRYPT_CIPHER_AES128_CBC:
451 case CRYPT_CIPHER_AES192_CBC:
452 case CRYPT_CIPHER_AES256_CBC:
453 case CRYPT_CIPHER_AES128_CTR:
454 case CRYPT_CIPHER_AES192_CTR:
455 case CRYPT_CIPHER_AES256_CTR:
456 case CRYPT_CIPHER_AES128_CCM:
457 case CRYPT_CIPHER_AES192_CCM:
458 case CRYPT_CIPHER_AES256_CCM:
459 case CRYPT_CIPHER_AES128_GCM:
460 case CRYPT_CIPHER_AES192_GCM:
461 case CRYPT_CIPHER_AES256_GCM:
462 case CRYPT_CIPHER_AES128_CFB:
463 case CRYPT_CIPHER_AES192_CFB:
464 case CRYPT_CIPHER_AES256_CFB:
465 case CRYPT_CIPHER_AES128_OFB:
466 case CRYPT_CIPHER_AES192_OFB:
467 case CRYPT_CIPHER_AES256_OFB:
468 return IsAesAlgDisabled(id);
469 case CRYPT_CIPHER_CHACHA20_POLY1305:
470 #if !defined(HITLS_CRYPTO_CHACHA20) && !defined(HITLS_CRYPTO_CHACHA20POLY1305)
471 return true;
472 #else
473 return false;
474 #endif
475 case CRYPT_CIPHER_SM4_XTS:
476 case CRYPT_CIPHER_SM4_CBC:
477 case CRYPT_CIPHER_SM4_CTR:
478 case CRYPT_CIPHER_SM4_GCM:
479 case CRYPT_CIPHER_SM4_CFB:
480 case CRYPT_CIPHER_SM4_OFB:
481 return IsSm4AlgDisabled(id);
482 default:
483 return false;
484 }
485 }
486
IsCmacAlgDisabled(int id)487 bool IsCmacAlgDisabled(int id)
488 {
489 #ifdef HITLS_CRYPTO_CMAC
490 switch (id) {
491 #ifndef HITLS_CRYPTO_CMAC_AES
492 case CRYPT_MAC_CMAC_AES128:
493 case CRYPT_MAC_CMAC_AES192:
494 case CRYPT_MAC_CMAC_AES256:
495 return true;
496 #endif
497 #ifndef HITLS_CRYPTO_CMAC_SM4
498 case CRYPT_MAC_CMAC_SM4:
499 return true;
500 #endif
501 default:
502 return false; // Unsupported algorithm ID
503 }
504 #else
505 (void)id;
506 return true;
507 #endif
508 }
509
IsCurveDisabled(int eccId)510 bool IsCurveDisabled(int eccId)
511 {
512 switch (eccId) {
513 #ifdef HITLS_CRYPTO_CURVE_NISTP224
514 case CRYPT_ECC_NISTP224:
515 return false;
516 #endif
517 #ifdef HITLS_CRYPTO_CURVE_NISTP256
518 case CRYPT_ECC_NISTP256:
519 return false;
520 #endif
521 #ifdef HITLS_CRYPTO_CURVE_NISTP384
522 case CRYPT_ECC_NISTP384:
523 return false;
524 #endif
525 #ifdef HITLS_CRYPTO_CURVE_NISTP521
526 case CRYPT_ECC_NISTP521:
527 return false;
528 #endif
529 #ifdef HITLS_CRYPTO_CURVE_BP256R1
530 case CRYPT_ECC_BRAINPOOLP256R1:
531 return false;
532 #endif
533 #ifdef HITLS_CRYPTO_CURVE_BP384R1
534 case CRYPT_ECC_BRAINPOOLP384R1:
535 return false;
536 #endif
537 #ifdef HITLS_CRYPTO_CURVE_BP512R1
538 case CRYPT_ECC_BRAINPOOLP512R1:
539 return false;
540 #endif
541 #ifdef HITLS_CRYPTO_CURVE_192WAPI
542 case CRYPT_ECC_192WAPI:
543 return false;
544 #endif
545 default:
546 return true;
547 }
548 }
549
IsCurve25519AlgDisabled(int id)550 bool IsCurve25519AlgDisabled(int id)
551 {
552 if (id == CRYPT_PKEY_ED25519) {
553 #ifndef HITLS_CRYPTO_ED25519
554 return true;
555 #else
556 return false;
557 #endif
558 }
559 if (id == CRYPT_PKEY_X25519) {
560 #ifndef HITLS_CRYPTO_X25519
561 return true;
562 #else
563 return false;
564 #endif
565 }
566 return false; // Unsupported algorithm ID
567 }