1 /*
2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #ifdef HKS_CONFIG_FILE
17 #include HKS_CONFIG_FILE
18 #else
19 #include "hks_config.h"
20 #endif
21
22 #include "hks_base_check.h"
23
24 #include "hks_cmd_id.h"
25 #include "hks_common_check.h"
26 #include "hks_log.h"
27 #include "hks_template.h"
28
29 #include "securec.h"
30
31 #ifdef _CUT_AUTHENTICATE_
32 #undef HKS_SUPPORT_RSA_C
33 #undef HKS_SUPPORT_ECC_C
34 #undef HKS_SUPPORT_ECDH_C
35 #undef HKS_SUPPORT_X25519_C
36 #undef HKS_SUPPORT_ED25519_C
37 #endif
38
39 #define HKS_BLOCK_CIPHER_CBC_IV_LEN 16
40 #define HKS_AES_CCM_AAD_LEN_MIN 4
41 #define HKS_AES_CCM_NONCE_LEN_MIN 7
42 #define HKS_AES_CCM_NONCE_LEN_MAX 13
43 #define HKS_AES_GCM_NONCE_LEN_MIN 12
44
45 #define HKS_RSA_OAEP_DIGEST_NUM 2
46 #define HKS_RSA_KEY_BLOCK_SIZE 8
47 #define HKS_BLOCK_CIPHER_CBC_BLOCK_SIZE 16
48
49 #define HKS_ECC_SIGN_MAX_TL_SIZE 8
50
51 #ifdef HKS_SUPPORT_RSA_C
52 static const uint32_t g_rsaKeySize[] = {
53 HKS_RSA_KEY_SIZE_512,
54 HKS_RSA_KEY_SIZE_768,
55 HKS_RSA_KEY_SIZE_1024,
56 HKS_RSA_KEY_SIZE_2048,
57 HKS_RSA_KEY_SIZE_3072,
58 HKS_RSA_KEY_SIZE_4096
59 };
60 static const uint32_t g_rsaPadding[] = {
61 HKS_PADDING_NONE,
62 HKS_PADDING_OAEP,
63 HKS_PADDING_PSS,
64 HKS_PADDING_PKCS1_V1_5,
65 HKS_PADDING_ISO_IEC_9796_2
66 };
67 static const uint32_t g_rsaDigest[] = {
68 HKS_DIGEST_MD5,
69 HKS_DIGEST_NONE,
70 HKS_DIGEST_SHA1,
71 HKS_DIGEST_SHA224,
72 HKS_DIGEST_SHA256,
73 HKS_DIGEST_SHA384,
74 HKS_DIGEST_SHA512
75 };
76 static const uint32_t g_rsaSignPadding[] = {
77 HKS_PADDING_PSS,
78 HKS_PADDING_PKCS1_V1_5,
79 HKS_PADDING_ISO_IEC_9796_2
80 };
81 static const uint32_t g_rsaCipherPadding[] = {
82 HKS_PADDING_NONE,
83 HKS_PADDING_OAEP,
84 HKS_PADDING_PKCS1_V1_5,
85 HKS_PADDING_ISO_IEC_9796_2
86 };
87 #endif
88
89 #ifdef HKS_SUPPORT_AES_C
90 static const uint32_t g_aesKeySize[] = {
91 HKS_AES_KEY_SIZE_128,
92 HKS_AES_KEY_SIZE_192,
93 HKS_AES_KEY_SIZE_256
94 };
95 static const uint32_t g_aesMacKeySize[] = {
96 HKS_AES_KEY_SIZE_256,
97 };
98 static const uint32_t g_aesPadding[] = {
99 HKS_PADDING_NONE,
100 HKS_PADDING_PKCS7
101 };
102 static const uint32_t g_aesMode[] = {
103 HKS_MODE_CBC,
104 HKS_MODE_CCM,
105 HKS_MODE_CTR,
106 HKS_MODE_ECB,
107 HKS_MODE_GCM
108 };
109 static const uint32_t g_aesCbcPadding[] = {
110 HKS_PADDING_NONE,
111 HKS_PADDING_PKCS7
112 };
113 static const uint32_t g_aesAeadPadding[] = {
114 HKS_PADDING_NONE
115 };
116 static const uint32_t g_aesCtrPadding[] = {
117 HKS_PADDING_NONE
118 };
119 static const uint32_t g_aesEcbPadding[] = {
120 HKS_PADDING_NONE,
121 HKS_PADDING_PKCS7
122 };
123 #endif
124
125 #ifdef HKS_SUPPORT_DES_C
126 static const uint32_t g_desKeySize[] = {
127 HKS_DES_KEY_SIZE_64
128 };
129 static const uint32_t g_desMacKeySize[] = {
130 HKS_DES_KEY_SIZE_64
131 };
132 static const uint32_t g_desPadding[] = {
133 HKS_PADDING_NONE
134 };
135 static const uint32_t g_desMode[] = {
136 HKS_MODE_CBC,
137 HKS_MODE_ECB
138 };
139 static const uint32_t g_desCbcPadding[] = {
140 HKS_PADDING_NONE
141 };
142 static const uint32_t g_desEcbPadding[] = {
143 HKS_PADDING_NONE
144 };
145 #endif
146
147 #ifdef HKS_SUPPORT_3DES_C
148 static const uint32_t g_3desKeySize[] = {
149 HKS_3DES_KEY_SIZE_128,
150 HKS_3DES_KEY_SIZE_192
151 };
152 static const uint32_t g_3desMacKeySize[] = {
153 HKS_3DES_KEY_SIZE_128,
154 HKS_3DES_KEY_SIZE_192
155 };
156 static const uint32_t g_3desPadding[] = {
157 HKS_PADDING_NONE
158 };
159 static const uint32_t g_3desMode[] = {
160 HKS_MODE_CBC,
161 HKS_MODE_ECB
162 };
163 static const uint32_t g_3desCbcPadding[] = {
164 HKS_PADDING_NONE
165 };
166 static const uint32_t g_3desEcbPadding[] = {
167 HKS_PADDING_NONE
168 };
169 #endif
170
171 #ifdef HKS_SUPPORT_SM4_C
172 static const uint32_t g_sm4KeySize[] = {
173 HKS_SM4_KEY_SIZE_128,
174 };
175 static const uint32_t g_sm4Padding[] = {
176 HKS_PADDING_NONE,
177 HKS_PADDING_PKCS7
178 };
179 static const uint32_t g_sm4Purpose[] = {
180 HKS_KEY_PURPOSE_ENCRYPT,
181 HKS_KEY_PURPOSE_DECRYPT,
182 HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
183 };
184 static const uint32_t g_sm4Mode[] = {
185 HKS_MODE_CBC,
186 HKS_MODE_CTR,
187 HKS_MODE_ECB,
188 HKS_MODE_CFB,
189 HKS_MODE_OFB,
190 };
191 static const uint32_t g_sm4CbcPadding[] = {
192 HKS_PADDING_NONE,
193 HKS_PADDING_PKCS7
194 };
195 static const uint32_t g_sm4CtrPadding[] = {
196 HKS_PADDING_NONE
197 };
198 static const uint32_t g_sm4EcbPadding[] = {
199 HKS_PADDING_NONE,
200 HKS_PADDING_PKCS7
201 };
202 static const uint32_t g_sm4CfbPadding[] = {
203 HKS_PADDING_NONE
204 };
205 static const uint32_t g_sm4OfbPadding[] = {
206 HKS_PADDING_NONE
207 };
208 #endif
209
210 #ifdef HKS_SUPPORT_ECC_C
211 static const uint32_t g_eccKeySize[] = {
212 HKS_ECC_KEY_SIZE_224,
213 HKS_ECC_KEY_SIZE_256,
214 HKS_ECC_KEY_SIZE_384,
215 HKS_ECC_KEY_SIZE_521
216 };
217
218 static const uint32_t g_eccDigest[] = {
219 HKS_DIGEST_NONE,
220 HKS_DIGEST_SHA1,
221 HKS_DIGEST_SHA224,
222 HKS_DIGEST_SHA256,
223 HKS_DIGEST_SHA384,
224 HKS_DIGEST_SHA512
225 };
226 #endif
227
228 #ifdef HKS_SUPPORT_SM2_C
229 static const uint32_t g_sm2KeySize[] = {
230 HKS_SM2_KEY_SIZE_256
231 };
232
233 static const uint32_t g_sm2Digest[] = {
234 HKS_DIGEST_SM3,
235 HKS_DIGEST_NONE
236 };
237
238 static const uint32_t g_sm2CipherPadding[] = {
239 HKS_PADDING_NONE,
240 };
241 #endif
242
243 #ifdef HKS_SUPPORT_SM3_C
244 static const uint32_t g_sm3Digest[] = {
245 HKS_DIGEST_SM3
246 };
247 #endif
248
249 static const uint32_t g_digest[] = {
250 HKS_DIGEST_SHA256,
251 HKS_DIGEST_SHA384,
252 HKS_DIGEST_SHA512
253 };
254
255 static const uint32_t g_macDigest[] = {
256 HKS_DIGEST_SHA256
257 };
258
259 #ifdef HKS_SUPPORT_ECDH_C
260 static const uint32_t g_ecdhKeySize[] = {
261 HKS_ECC_KEY_SIZE_224,
262 HKS_ECC_KEY_SIZE_256,
263 HKS_ECC_KEY_SIZE_384,
264 HKS_ECC_KEY_SIZE_521
265 };
266 #endif
267
268 #if defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_ED25519_C)
269 static const uint32_t g_curve25519KeySize[] = {
270 HKS_CURVE25519_KEY_SIZE_256,
271 };
272 #endif
273 #ifdef HKS_SUPPORT_HMAC_C
274 static const uint32_t g_hmacDigest[] = {
275 HKS_DIGEST_SHA1,
276 HKS_DIGEST_SHA224,
277 HKS_DIGEST_SHA256,
278 HKS_DIGEST_SHA384,
279 HKS_DIGEST_SHA512,
280 HKS_DIGEST_SM3
281 };
282 #endif
283
284 #ifdef HKS_SUPPORT_DSA_C
285 static const uint32_t g_dsaDigest[] = {
286 HKS_DIGEST_NONE,
287 HKS_DIGEST_SHA1,
288 HKS_DIGEST_SHA224,
289 HKS_DIGEST_SHA256,
290 HKS_DIGEST_SHA384,
291 HKS_DIGEST_SHA512
292 };
293 #endif
294 #ifdef HKS_SUPPORT_DH_C
295 static const uint32_t g_dhKeySize[] = {
296 HKS_DH_KEY_SIZE_2048,
297 HKS_DH_KEY_SIZE_3072,
298 HKS_DH_KEY_SIZE_4096
299 };
300 #endif
301
302 #ifdef HKS_SUPPORT_RSA_C
303 static const struct ParamsValuesChecker g_rsaParamSet[] = {
304 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { true, 0, false}, { true, 0, false}, { true, 0, false},
305 { false, 0, false} } },
306 { HKS_CHECK_TYPE_USE_KEY, { { true, 0, false}, { true, 0, false}, { true, 0, false}, { true, 0, false},
307 { false, 0, false} } }
308 };
309 static const struct ExpectParamsValuesChecker g_expectRsaParams[] = {
310 { HKS_CHECK_TYPE_GEN_KEY, {
311 { true, g_rsaKeySize, HKS_ARRAY_SIZE(g_rsaKeySize) },
312 { true, g_rsaPadding, HKS_ARRAY_SIZE(g_rsaPadding) },
313 { false, NULL, 0 },
314 { true, g_rsaDigest, HKS_ARRAY_SIZE(g_rsaDigest) },
315 { false, NULL, 0 }
316 }
317 },
318 { HKS_CHECK_TYPE_USE_KEY, {
319 { true, g_rsaKeySize, HKS_ARRAY_SIZE(g_rsaKeySize) },
320 { true, g_rsaPadding, HKS_ARRAY_SIZE(g_rsaPadding) },
321 { false, NULL, 0 },
322 { true, g_rsaDigest, HKS_ARRAY_SIZE(g_rsaDigest) },
323 { false, NULL, 0 }
324 }
325 }
326 };
327 #endif
328
329 #ifdef HKS_SUPPORT_AES_C
330 static const struct ParamsValuesChecker g_aesParamSet[] = {
331 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { true, 0, false}, { true, 0, false}, { false, 0, false},
332 { true, 0, false} } },
333 { HKS_CHECK_TYPE_USE_KEY, { { false, 0, false}, { true, 0, false}, { true, 0, false}, { false, 0, false},
334 { true, 0, false} } },
335 { HKS_CHECK_TYPE_GEN_MAC_KEY, { { true, 0, false}, { false, 0, false}, { false, 0, false}, { true, 0, false},
336 { false, 0, false} } },
337 { HKS_CHECK_TYPE_GEN_DERIVE_KEY, { { true, 0, false}, { false, 0, false}, { false, 0, false}, { true, 0, false},
338 { false, 0, false} } }
339 };
340
341 static const struct ExpectParamsValuesChecker g_expectAesParams[] = {
342 { HKS_CHECK_TYPE_GEN_KEY, {
343 { true, g_aesKeySize, HKS_ARRAY_SIZE(g_aesKeySize) },
344 { true, g_aesPadding, HKS_ARRAY_SIZE(g_aesPadding) },
345 { false, NULL, 0 },
346 { false, NULL, 0 },
347 { true, g_aesMode, HKS_ARRAY_SIZE(g_aesMode) }
348 }
349 },
350 { HKS_CHECK_TYPE_USE_KEY, {
351 { false, NULL, 0 },
352 { true, g_aesPadding, HKS_ARRAY_SIZE(g_aesPadding) },
353 { false, NULL, 0 },
354 { false, NULL, 0 },
355 { true, g_aesMode, HKS_ARRAY_SIZE(g_aesMode) }
356 }
357 },
358 { HKS_CHECK_TYPE_GEN_MAC_KEY, {
359 { true, g_aesMacKeySize, HKS_ARRAY_SIZE(g_aesMacKeySize) },
360 { false, NULL, 0 },
361 { false, NULL, 0 },
362 { true, g_macDigest, HKS_ARRAY_SIZE(g_macDigest) },
363 { false, NULL, 0 }
364 }
365 },
366 { HKS_CHECK_TYPE_GEN_DERIVE_KEY, {
367 { true, g_aesKeySize, HKS_ARRAY_SIZE(g_aesKeySize) },
368 { false, NULL, 0 },
369 { false, NULL, 0 },
370 { true, g_digest, HKS_ARRAY_SIZE(g_digest) },
371 { false, NULL, 0 }
372 }
373 }
374 };
375 #endif
376
377 #ifdef HKS_SUPPORT_DES_C
378 static const struct ParamsValuesChecker g_desParamSet[] = {
379 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { true, 0, false}, { true, 0, false}, { false, 0, false},
380 { true, 0, false} } },
381 { HKS_CHECK_TYPE_USE_KEY, { { false, 0, false}, { true, 0, false}, { true, 0, false}, { false, 0, false},
382 { true, 0, false} } },
383 { HKS_CHECK_TYPE_GEN_MAC_KEY, { { true, 0, false}, { false, 0, false}, { false, 0, false}, { true, 0, false},
384 { false, 0, false} } },
385 { HKS_CHECK_TYPE_GEN_DERIVE_KEY, { { true, 0, false}, { false, 0, false}, { false, 0, false}, { true, 0, false},
386 { false, 0, false} } }
387 };
388
389 static const struct ExpectParamsValuesChecker g_expectDesParams[] = {
390 { HKS_CHECK_TYPE_GEN_KEY, {
391 { true, g_desKeySize, HKS_ARRAY_SIZE(g_desKeySize) },
392 { true, g_desPadding, HKS_ARRAY_SIZE(g_desPadding) },
393 { false, NULL, 0 },
394 { false, NULL, 0 },
395 { true, g_desMode, HKS_ARRAY_SIZE(g_desMode) }
396 }
397 },
398 { HKS_CHECK_TYPE_USE_KEY, {
399 { false, NULL, 0 },
400 { true, g_desPadding, HKS_ARRAY_SIZE(g_desPadding) },
401 { false, NULL, 0 },
402 { false, NULL, 0 },
403 { true, g_desMode, HKS_ARRAY_SIZE(g_desMode) }
404 }
405 },
406 { HKS_CHECK_TYPE_GEN_MAC_KEY, {
407 { true, g_desMacKeySize, HKS_ARRAY_SIZE(g_desMacKeySize) },
408 { false, NULL, 0 },
409 { false, NULL, 0 },
410 { true, g_macDigest, HKS_ARRAY_SIZE(g_macDigest) },
411 { false, NULL, 0 }
412 }
413 },
414 { HKS_CHECK_TYPE_GEN_DERIVE_KEY, {
415 { true, g_desKeySize, HKS_ARRAY_SIZE(g_desKeySize) },
416 { false, NULL, 0 },
417 { false, NULL, 0 },
418 { true, g_digest, HKS_ARRAY_SIZE(g_digest) },
419 { false, NULL, 0 }
420 }
421 }
422 };
423 #endif
424
425 #ifdef HKS_SUPPORT_3DES_C
426 static const struct ParamsValuesChecker g_3desParamSet[] = {
427 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { true, 0, false}, { true, 0, false}, { false, 0, false},
428 { true, 0, false} } },
429 { HKS_CHECK_TYPE_USE_KEY, { { false, 0, false}, { true, 0, false}, { true, 0, false}, { false, 0, false},
430 { true, 0, false} } },
431 { HKS_CHECK_TYPE_GEN_MAC_KEY, { { true, 0, false}, { false, 0, false}, { false, 0, false}, { true, 0, false},
432 { false, 0, false} } },
433 { HKS_CHECK_TYPE_GEN_DERIVE_KEY, { { true, 0, false}, { false, 0, false}, { false, 0, false}, { true, 0, false},
434 { false, 0, false} } }
435 };
436
437 static const struct ExpectParamsValuesChecker g_expect3DesParams[] = {
438 { HKS_CHECK_TYPE_GEN_KEY, {
439 { true, g_3desKeySize, HKS_ARRAY_SIZE(g_3desKeySize) },
440 { true, g_3desPadding, HKS_ARRAY_SIZE(g_3desPadding) },
441 { false, NULL, 0 },
442 { false, NULL, 0 },
443 { true, g_3desMode, HKS_ARRAY_SIZE(g_3desMode) }
444 }
445 },
446 { HKS_CHECK_TYPE_USE_KEY, {
447 { false, NULL, 0 },
448 { true, g_3desPadding, HKS_ARRAY_SIZE(g_3desPadding) },
449 { false, NULL, 0 },
450 { false, NULL, 0 },
451 { true, g_3desMode, HKS_ARRAY_SIZE(g_3desMode) }
452 }
453 },
454 { HKS_CHECK_TYPE_GEN_MAC_KEY, {
455 { true, g_3desMacKeySize, HKS_ARRAY_SIZE(g_3desMacKeySize) },
456 { false, NULL, 0 },
457 { false, NULL, 0 },
458 { true, g_macDigest, HKS_ARRAY_SIZE(g_macDigest) },
459 { false, NULL, 0 }
460 }
461 },
462 { HKS_CHECK_TYPE_GEN_DERIVE_KEY, {
463 { true, g_3desKeySize, HKS_ARRAY_SIZE(g_3desKeySize) },
464 { false, NULL, 0 },
465 { false, NULL, 0 },
466 { true, g_digest, HKS_ARRAY_SIZE(g_digest) },
467 { false, NULL, 0 }
468 }
469 }
470 };
471 #endif
472
473 #ifdef HKS_SUPPORT_ECC_C
474 static const struct ParamsValuesChecker g_eccParamSet[] = {
475 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
476 { false, 0, false} } },
477 { HKS_CHECK_TYPE_USE_KEY, { { false, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
478 { false, 0, false} } }
479 };
480 static const struct ExpectParamsValuesChecker g_expectEccParams[] = {
481 { HKS_CHECK_TYPE_GEN_KEY, {
482 { true, g_eccKeySize, HKS_ARRAY_SIZE(g_eccKeySize) },
483 { false, NULL, 0 },
484 { false, NULL, 0 },
485 { true, g_eccDigest, HKS_ARRAY_SIZE(g_eccDigest) },
486 { false, NULL, 0 }
487 }
488 },
489 { HKS_CHECK_TYPE_USE_KEY, {
490 { false, NULL, 0 },
491 { false, NULL, 0 },
492 { false, NULL, 0 },
493 { true, g_eccDigest, HKS_ARRAY_SIZE(g_eccDigest) },
494 { false, NULL, 0 }
495 }
496 }
497 };
498 #endif
499
500 #ifdef HKS_SUPPORT_SM2_C
501 static const struct ParamsValuesChecker g_sm2ParamSet[] = {
502 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
503 { false, 0, false} } },
504 { HKS_CHECK_TYPE_USE_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
505 { false, 0, false} } }
506 };
507 static const struct ExpectParamsValuesChecker g_expectSm2Params[] = {
508 { HKS_CHECK_TYPE_GEN_KEY, {
509 { true, g_sm2KeySize, HKS_ARRAY_SIZE(g_sm2KeySize) },
510 { false, NULL, 0 },
511 { false, NULL, 0 },
512 { true, g_sm2Digest, HKS_ARRAY_SIZE(g_sm2Digest) },
513 { false, NULL, 0 }
514 }
515 },
516 { HKS_CHECK_TYPE_USE_KEY, {
517 { true, g_sm2KeySize, HKS_ARRAY_SIZE(g_sm2KeySize) },
518 { false, NULL, 0 },
519 { false, NULL, 0 },
520 { true, g_sm2Digest, HKS_ARRAY_SIZE(g_sm2Digest) },
521 { false, NULL, 0 }
522 }
523 }
524 };
525 #endif
526
527 #ifdef HKS_SUPPORT_SM3_C
528 static const struct ParamsValuesChecker g_sm3ParamSet[] = {
529 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
530 { false, 0, false} } },
531 { HKS_CHECK_TYPE_GEN_MAC_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
532 { false, 0, false} } }
533 };
534 static const struct ExpectParamsValuesChecker g_expectSm3Params[] = {
535 { HKS_CHECK_TYPE_GEN_KEY, {
536 { false, NULL, 0 },
537 { false, NULL, 0 },
538 { false, NULL, 0 },
539 { true, g_sm3Digest, sizeof(g_sm3Digest) / sizeof(g_sm3Digest[0]) },
540 { false, NULL, 0 }
541 }
542 },
543 { HKS_CHECK_TYPE_GEN_MAC_KEY, {
544 { false, NULL, 0 },
545 { false, NULL, 0 },
546 { false, NULL, 0 },
547 { true, g_sm3Digest, sizeof(g_sm3Digest) / sizeof(g_sm3Digest[0]) },
548 { false, NULL, 0 }
549 }
550 }
551 };
552 #endif
553
554 #ifdef HKS_SUPPORT_SM4_C
555 static const struct ParamsValuesChecker g_sm4ParamSet[] = {
556 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { true, 0, false}, { true, 0, false}, { false, 0, false},
557 { true, 0, false} } },
558 { HKS_CHECK_TYPE_USE_KEY, { { true, 0, false}, { true, 0, false}, { true, 0, false}, { false, 0, false},
559 { true, 0, false} } },
560 { HKS_CHECK_TYPE_GEN_DERIVE_KEY, { { true, 0, false}, { false, 0, false}, { false, 0, false}, { true, 0, false},
561 { false, 0, false} } }
562 };
563 static const struct ExpectParamsValuesChecker g_expectSm4Params[] = {
564 { HKS_CHECK_TYPE_GEN_KEY, {
565 { true, g_sm4KeySize, HKS_ARRAY_SIZE(g_sm4KeySize) },
566 { true, g_sm4Padding, HKS_ARRAY_SIZE(g_sm4Padding) },
567 { true, g_sm4Purpose, HKS_ARRAY_SIZE(g_sm4Purpose) },
568 { false, NULL, 0 },
569 { true, g_sm4Mode, HKS_ARRAY_SIZE(g_sm4Mode) }
570 }
571 },
572 { HKS_CHECK_TYPE_USE_KEY, {
573 { true, g_sm4KeySize, HKS_ARRAY_SIZE(g_sm4KeySize) },
574 { true, g_sm4Padding, HKS_ARRAY_SIZE(g_sm4Padding) },
575 { true, g_sm4Purpose, HKS_ARRAY_SIZE(g_sm4Purpose) },
576 { false, NULL, 0 },
577 { true, g_sm4Mode, HKS_ARRAY_SIZE(g_sm4Mode) }
578 }
579 },
580 { HKS_CHECK_TYPE_GEN_DERIVE_KEY, {
581 { true, g_sm4KeySize, HKS_ARRAY_SIZE(g_sm4KeySize) },
582 { false, NULL, 0 },
583 { false, NULL, 0 },
584 { true, g_sm3Digest, HKS_ARRAY_SIZE(g_sm3Digest) },
585 { false, NULL, 0 }
586 }
587 }
588 };
589 #endif
590
591 #if defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_ED25519_C)
592 static const struct ParamsValuesChecker g_curve25519ParamSet[] = {
593 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { false, 0, false},
594 { false, 0, false} } },
595 { HKS_CHECK_TYPE_USE_KEY, { { false, 0, false}, { false, 0, false}, { true, 0, false}, { false, 0, false},
596 { false, 0, false} } }
597 };
598 static const struct ExpectParamsValuesChecker g_expectCurve25519Params[] = {
599 { HKS_CHECK_TYPE_GEN_KEY, {
600 { true, g_curve25519KeySize, sizeof(g_curve25519KeySize) / sizeof(g_curve25519KeySize[0]) },
601 { false, NULL, 0 },
602 { false, NULL, 0 },
603 { false, NULL, 0 },
604 { false, NULL, 0 }
605 }
606 },
607 { HKS_CHECK_TYPE_USE_KEY, {
608 { false, NULL, 0 },
609 { false, NULL, 0 },
610 { false, NULL, 0 },
611 { false, NULL, 0 },
612 { false, NULL, 0 }
613 }
614 }
615 };
616 #endif
617
618 #ifdef HKS_SUPPORT_HMAC_C
619 static const struct ParamsValuesChecker g_hmacParamSet[] = {
620 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
621 { false, 0, false} } },
622 { HKS_CHECK_TYPE_USE_KEY, { { false, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
623 { false, 0, false} } },
624 { HKS_CHECK_TYPE_GEN_MAC_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
625 { false, 0, false} } }
626 };
627 static const struct ExpectParamsValuesChecker g_expectHmacParams[] = {
628 { HKS_CHECK_TYPE_GEN_KEY, {
629 { false, NULL, 0 },
630 { false, NULL, 0 },
631 { false, NULL, 0 },
632 { true, g_hmacDigest, sizeof(g_hmacDigest) / sizeof(g_hmacDigest[0]) },
633 { false, NULL, 0 }
634 }
635 },
636 { HKS_CHECK_TYPE_USE_KEY, {
637 { false, NULL, 0 },
638 { false, NULL, 0 },
639 { false, NULL, 0 },
640 { true, g_hmacDigest, sizeof(g_hmacDigest) / sizeof(g_hmacDigest[0]) },
641 { false, NULL, 0 }
642 }
643 },
644 { HKS_CHECK_TYPE_GEN_MAC_KEY, {
645 { false, NULL, 0 },
646 { false, NULL, 0 },
647 { false, NULL, 0 },
648 { true, g_hmacDigest, sizeof(g_hmacDigest) / sizeof(g_hmacDigest[0]) },
649 { false, NULL, 0 }
650 }
651 }
652 };
653 #endif
654
655 #ifdef HKS_SUPPORT_CMAC_C
656 static const struct ParamsValuesChecker g_cmacParamSet[] = {
657 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
658 { false, 0, false} } },
659 { HKS_CHECK_TYPE_USE_KEY, { { false, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
660 { false, 0, false} } },
661 { HKS_CHECK_TYPE_GEN_MAC_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
662 { false, 0, false} } }
663 };
664 static const struct ExpectParamsValuesChecker g_expectCmacParams[] = {
665 { HKS_CHECK_TYPE_GEN_KEY, {
666 { false, NULL, 0 },
667 { false, NULL, 0 },
668 { false, NULL, 0 },
669 { false, NULL, 0 },
670 { false, NULL, 0 }
671 }
672 },
673 { HKS_CHECK_TYPE_USE_KEY, {
674 { false, NULL, 0 },
675 { false, NULL, 0 },
676 { false, NULL, 0 },
677 { false, NULL, 0 },
678 { false, NULL, 0 }
679 }
680 },
681 { HKS_CHECK_TYPE_GEN_MAC_KEY, {
682 { false, NULL, 0 },
683 { false, NULL, 0 },
684 { false, NULL, 0 },
685 { false, NULL, 0 },
686 { false, NULL, 0 }
687 }
688 }
689 };
690 #endif
691
692 #ifdef HKS_SUPPORT_DSA_C
693 static const struct ParamsValuesChecker g_dsaParamSet[] = {
694 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
695 { false, 0, false} } },
696 { HKS_CHECK_TYPE_USE_KEY, { { false, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
697 { false, 0, false} } }
698 };
699 static const struct ExpectParamsValuesChecker g_expectDsaParams[] = {
700 { HKS_CHECK_TYPE_GEN_KEY, {
701 { false, NULL, 0 },
702 { false, NULL, 0 },
703 { false, NULL, 0 },
704 { true, g_dsaDigest, sizeof(g_dsaDigest) / sizeof(g_dsaDigest[0]) },
705 { false, NULL, 0 }
706 }
707 },
708 { HKS_CHECK_TYPE_USE_KEY, {
709 { false, NULL, 0 },
710 { false, NULL, 0 },
711 { false, NULL, 0 },
712 { true, g_dsaDigest, sizeof(g_dsaDigest) / sizeof(g_dsaDigest[0]) },
713 { false, NULL, 0 }
714 }
715 }
716 };
717 #endif
718
719 #ifdef HKS_SUPPORT_DH_C
720 static const struct ParamsValuesChecker g_dhParamSet[] = {
721 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { false, 0, false},
722 { false, 0, false} } },
723 { HKS_CHECK_TYPE_USE_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { false, 0, false},
724 { false, 0, false} } }
725 };
726 static const struct ExpectParamsValuesChecker g_expectDhParams[] = {
727 { HKS_CHECK_TYPE_GEN_KEY, {
728 { true, g_dhKeySize, sizeof(g_dhKeySize) / sizeof(g_dhKeySize[0]) },
729 { false, NULL, 0 },
730 { false, NULL, 0 },
731 { false, NULL, 0 },
732 { false, NULL, 0 }
733 }
734 },
735 { HKS_CHECK_TYPE_USE_KEY, {
736 { true, g_dhKeySize, sizeof(g_dhKeySize) / sizeof(g_dhKeySize[0]) },
737 { false, NULL, 0 },
738 { false, NULL, 0 },
739 { false, NULL, 0 },
740 { false, NULL, 0 }
741 }
742 }
743 };
744 #endif
745
746 #ifdef HKS_SUPPORT_ECDH_C
747 static const struct ParamsValuesChecker g_ecdhParamSet[] = {
748 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { false, 0, false},
749 { false, 0, false} } },
750 { HKS_CHECK_TYPE_USE_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { false, 0, false},
751 { false, 0, false} } }
752 };
753 static const struct ExpectParamsValuesChecker g_expectEcdhParams[] = {
754 { HKS_CHECK_TYPE_GEN_KEY, {
755 { true, g_ecdhKeySize, sizeof(g_ecdhKeySize) / sizeof(g_ecdhKeySize[0]) },
756 { false, NULL, 0 },
757 { false, NULL, 0 },
758 { false, NULL, 0 },
759 { false, NULL, 0 }
760 }
761 },
762 { HKS_CHECK_TYPE_USE_KEY, {
763 { true, g_ecdhKeySize, sizeof(g_ecdhKeySize) / sizeof(g_ecdhKeySize[0]) },
764 { false, NULL, 0 },
765 { false, NULL, 0 },
766 { false, NULL, 0 },
767 { false, NULL, 0 }
768 }
769 }
770 };
771 #endif
772
773 #ifndef _CUT_AUTHENTICATE_
774 static const uint32_t g_invalidPurpose[][2] = {
775 #ifdef HKS_SUPPORT_RSA_C
776 {
777 HKS_ALG_RSA,
778 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP |
779 HKS_KEY_PURPOSE_AGREE,
780 },
781 #endif
782 #ifdef HKS_SUPPORT_ECC_C
783 {
784 HKS_ALG_ECC,
785 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP |
786 HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
787 },
788 #endif
789 #ifdef HKS_SUPPORT_SM2_C
790 {
791 HKS_ALG_SM2,
792 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP,
793 },
794 #endif
795 #ifdef HKS_SUPPORT_SM3_C
796 {
797 HKS_ALG_SM3,
798 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_WRAP |
799 HKS_KEY_PURPOSE_UNWRAP | HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_AGREE,
800 },
801 #endif
802 #ifdef HKS_SUPPORT_SM4_C
803 {
804 HKS_ALG_SM4,
805 HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_WRAP |
806 HKS_KEY_PURPOSE_UNWRAP | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_AGREE,
807 },
808 #endif
809 #ifdef HKS_SUPPORT_AES_C
810 {
811 HKS_ALG_AES,
812 HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_AGREE | HKS_KEY_PURPOSE_WRAP |
813 HKS_KEY_PURPOSE_UNWRAP,
814 },
815 #endif
816 #ifdef HKS_SUPPORT_DES_C
817 {
818 HKS_ALG_DES,
819 HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_AGREE | HKS_KEY_PURPOSE_WRAP |
820 HKS_KEY_PURPOSE_UNWRAP,
821 },
822 #endif
823 #ifdef HKS_SUPPORT_3DES_C
824 {
825 HKS_ALG_3DES,
826 HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_AGREE | HKS_KEY_PURPOSE_WRAP |
827 HKS_KEY_PURPOSE_UNWRAP,
828 },
829 #endif
830 #ifdef HKS_SUPPORT_ED25519_C
831 {
832 HKS_ALG_ED25519,
833 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP |
834 HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
835 },
836 #endif
837 #ifdef HKS_SUPPORT_X25519_C
838 {
839 HKS_ALG_X25519,
840 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT |
841 HKS_KEY_PURPOSE_WRAP,
842 },
843 #endif
844 #ifdef HKS_SUPPORT_HMAC_C
845 {
846 HKS_ALG_HMAC,
847 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_WRAP |
848 HKS_KEY_PURPOSE_UNWRAP | HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_AGREE,
849 },
850 #endif
851 #ifdef HKS_SUPPORT_CMAC_C
852 {
853 HKS_ALG_CMAC,
854 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_WRAP |
855 HKS_KEY_PURPOSE_UNWRAP | HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_AGREE,
856 },
857 #endif
858 #ifdef HKS_SUPPORT_DSA_C
859 {
860 HKS_ALG_DSA,
861 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP |
862 HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_AGREE,
863 },
864 #endif
865 #ifdef HKS_SUPPORT_DH_C
866 {
867 HKS_ALG_DH,
868 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP |
869 HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
870 },
871 #endif
872 #ifdef HKS_SUPPORT_ECDH_C
873 {
874 HKS_ALG_ECDH,
875 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP |
876 HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
877 },
878 #endif
879 };
880
881 static const uint32_t g_invalidImportKeyPurpose[][2] = {
882 #ifdef HKS_SUPPORT_ECC_C
883 {
884 HKS_ALG_ECC,
885 HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP,
886 },
887 #endif
888 #ifdef HKS_SUPPORT_X25519_C
889 {
890 HKS_ALG_X25519,
891 HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP,
892 },
893 #endif
894 #ifdef HKS_SUPPORT_SM2_C
895 {
896 HKS_ALG_SM2,
897 HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP,
898 },
899 #endif
900 };
901 #endif
902
903 #ifdef HKS_SUPPORT_USER_AUTH_ACCESS_CONTROL
904 static const uint32_t g_userAuthChallengeType[] = {
905 HKS_CHALLENGE_TYPE_NORMAL,
906 HKS_CHALLENGE_TYPE_CUSTOM,
907 HKS_CHALLENGE_TYPE_NONE,
908 };
909
910 static const uint32_t g_validBiometricAuthAccessType[] = {
911 HKS_AUTH_ACCESS_INVALID_NEW_BIO_ENROLL,
912 HKS_AUTH_ACCESS_INVALID_CLEAR_PASSWORD,
913 HKS_AUTH_ACCESS_ALWAYS_VALID
914 };
915
916 static const uint32_t g_validPinAuthAccessType[] = {
917 HKS_AUTH_ACCESS_INVALID_CLEAR_PASSWORD,
918 HKS_AUTH_ACCESS_ALWAYS_VALID
919 };
920
921 static const struct AuthAccessTypeChecker g_expectAuthAccessParams[] = {
922 { HKS_USER_AUTH_TYPE_FACE,
923 { true, g_validBiometricAuthAccessType, HKS_ARRAY_SIZE(g_validBiometricAuthAccessType)}
924 },
925 { HKS_USER_AUTH_TYPE_FINGERPRINT,
926 { true, g_validBiometricAuthAccessType, HKS_ARRAY_SIZE(g_validBiometricAuthAccessType)}
927 },
928 { HKS_USER_AUTH_TYPE_PIN,
929 { true, g_validPinAuthAccessType, HKS_ARRAY_SIZE(g_validPinAuthAccessType)}
930 }
931 };
932
933 static const uint32_t g_supportUserAuthTypes[] = {
934 HKS_USER_AUTH_TYPE_PIN,
935 HKS_USER_AUTH_TYPE_FINGERPRINT,
936 HKS_USER_AUTH_TYPE_FACE,
937 HKS_USER_AUTH_TYPE_PIN | HKS_USER_AUTH_TYPE_FINGERPRINT,
938 HKS_USER_AUTH_TYPE_PIN | HKS_USER_AUTH_TYPE_FACE,
939 HKS_USER_AUTH_TYPE_FACE | HKS_USER_AUTH_TYPE_FINGERPRINT,
940 HKS_USER_AUTH_TYPE_PIN | HKS_USER_AUTH_TYPE_FACE | HKS_USER_AUTH_TYPE_FINGERPRINT
941 };
942
943 static const uint32_t g_supportSecureSignType[] = {
944 HKS_SECURE_SIGN_WITH_AUTHINFO
945 };
946
947 #ifdef HKS_SUPPORT_AES_C
948 static const uint32_t g_supportAesPurpose[] = {
949 HKS_KEY_PURPOSE_ENCRYPT,
950 HKS_KEY_PURPOSE_DECRYPT,
951 HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
952 HKS_KEY_PURPOSE_DERIVE,
953 HKS_KEY_PURPOSE_MAC
954 };
955
956 static const uint32_t g_supportAesCipherMode[] = {
957 HKS_MODE_CBC,
958 HKS_MODE_GCM,
959 HKS_MODE_CCM
960 };
961
962 static const struct KeyInfoParams g_validAesKeyInfo[] = {
963 { true, HKS_TAG_PURPOSE, g_supportAesPurpose, HKS_ARRAY_SIZE(g_supportAesPurpose) },
964 { true, HKS_TAG_BLOCK_MODE, g_supportAesCipherMode, HKS_ARRAY_SIZE(g_supportAesCipherMode) }
965 };
966 #endif
967
968 #ifdef HKS_SUPPORT_DES_C
969 static const uint32_t g_supportDesPurpose[] = {
970 HKS_KEY_PURPOSE_ENCRYPT,
971 HKS_KEY_PURPOSE_DECRYPT,
972 HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
973 HKS_KEY_PURPOSE_DERIVE,
974 HKS_KEY_PURPOSE_MAC
975 };
976
977 static const uint32_t g_supportDesCipherMode[] = {
978 HKS_MODE_CBC,
979 HKS_MODE_ECB
980 };
981
982 static const struct KeyInfoParams g_validDesKeyInfo[] = {
983 { true, HKS_TAG_PURPOSE, g_supportDesPurpose, HKS_ARRAY_SIZE(g_supportDesPurpose) },
984 { true, HKS_TAG_BLOCK_MODE, g_supportDesCipherMode, HKS_ARRAY_SIZE(g_supportDesCipherMode) }
985 };
986 #endif
987
988 #ifdef HKS_SUPPORT_3DES_C
989 static const uint32_t g_support3DesPurpose[] = {
990 HKS_KEY_PURPOSE_ENCRYPT,
991 HKS_KEY_PURPOSE_DECRYPT,
992 HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
993 HKS_KEY_PURPOSE_DERIVE,
994 HKS_KEY_PURPOSE_MAC
995 };
996
997 static const uint32_t g_support3DesCipherMode[] = {
998 HKS_MODE_CBC,
999 HKS_MODE_ECB
1000 };
1001
1002 static const struct KeyInfoParams g_valid3DesKeyInfo[] = {
1003 { true, HKS_TAG_PURPOSE, g_support3DesPurpose, HKS_ARRAY_SIZE(g_support3DesPurpose) },
1004 { true, HKS_TAG_BLOCK_MODE, g_support3DesCipherMode, HKS_ARRAY_SIZE(g_support3DesCipherMode) }
1005 };
1006 #endif
1007
1008 #ifdef HKS_SUPPORT_SM4_C
1009 static const uint32_t g_supportSm4Purpose[] = {
1010 HKS_KEY_PURPOSE_ENCRYPT,
1011 HKS_KEY_PURPOSE_DECRYPT,
1012 HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT
1013 };
1014
1015 static const uint32_t g_supportSm4CipherMode[] = {
1016 HKS_MODE_CBC
1017 };
1018
1019 static const struct KeyInfoParams g_validSm4KeyInfo[] = {
1020 { true, HKS_TAG_PURPOSE, g_supportSm4Purpose, HKS_ARRAY_SIZE(g_supportSm4Purpose) },
1021 { true, HKS_TAG_BLOCK_MODE, g_supportSm4CipherMode, HKS_ARRAY_SIZE(g_supportSm4CipherMode) }
1022 };
1023 #endif
1024
1025 static const struct AuthAcceessKeyInfoChecker g_validKeyInfo[] = {
1026 #ifdef HKS_SUPPORT_AES_C
1027 { HKS_ALG_AES, g_validAesKeyInfo, HKS_ARRAY_SIZE(g_validAesKeyInfo) },
1028 #endif
1029 #ifdef HKS_SUPPORT_DES_C
1030 { HKS_ALG_DES, g_validDesKeyInfo, HKS_ARRAY_SIZE(g_validDesKeyInfo) },
1031 #endif
1032 #ifdef HKS_SUPPORT_3DES_C
1033 { HKS_ALG_3DES, g_valid3DesKeyInfo, HKS_ARRAY_SIZE(g_valid3DesKeyInfo) },
1034 #endif
1035 #ifdef HKS_SUPPORT_SM4_C
1036 { HKS_ALG_SM4, g_validSm4KeyInfo, HKS_ARRAY_SIZE(g_validSm4KeyInfo) }
1037 #endif
1038 };
1039 #endif
1040
1041 #ifndef _CUT_AUTHENTICATE_
1042 #ifndef _STORAGE_LITE_
CheckAndGetKeySize(const struct HksBlob * key,const uint32_t * expectKeySize,uint32_t expectCnt,uint32_t * keySize)1043 static int32_t CheckAndGetKeySize(const struct HksBlob *key, const uint32_t *expectKeySize,
1044 uint32_t expectCnt, uint32_t *keySize)
1045 {
1046 if (key->size < sizeof(struct HksParamSet)) {
1047 HKS_LOG_E("check key size: invalid keyfile size: %" LOG_PUBLIC "u", key->size);
1048 return HKS_ERROR_INVALID_KEY_FILE;
1049 }
1050
1051 struct HksParamSet *keyParamSet = (struct HksParamSet *)key->data;
1052 int32_t ret = HksCheckParamSetValidity(keyParamSet);
1053 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_KEY_FILE, "check key size: paramset invalid failed")
1054
1055 struct HksParam *keySizeParam = NULL;
1056 ret = HksGetParam(keyParamSet, HKS_TAG_KEY_SIZE, &keySizeParam);
1057 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_KEY_FILE,
1058 "check key size: get param get tag:0x%" LOG_PUBLIC "x failed", HKS_TAG_KEY_SIZE)
1059
1060 ret = HksCheckValue(keySizeParam->uint32Param, expectKeySize, expectCnt);
1061 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_KEY_FILE,
1062 "check key size: key size value %" LOG_PUBLIC "u not expected", keySizeParam->uint32Param)
1063 *keySize = keySizeParam->uint32Param;
1064 return ret;
1065 }
1066 #else
CheckAndGetKeySize(const struct HksBlob * key,const uint32_t * expectKeySize,uint32_t expectCnt,uint32_t * keySize)1067 static int32_t CheckAndGetKeySize(const struct HksBlob *key, const uint32_t *expectKeySize,
1068 uint32_t expectCnt, uint32_t *keySize)
1069 {
1070 if (key->size < sizeof(struct HksStoreKeyInfo)) {
1071 HKS_LOG_E("check key size: invalid keyfile size: %" LOG_PUBLIC "u", key->size);
1072 return HKS_ERROR_INVALID_KEY_FILE;
1073 }
1074
1075 struct HksStoreKeyInfo *keyInfo = (struct HksStoreKeyInfo *)key->data;
1076 uint32_t keyLen = keyInfo->keyLen;
1077 int32_t ret = HksCheckValue(keyLen, expectKeySize, expectCnt);
1078 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_KEY_FILE,
1079 "check key size: keySize value %" LOG_PUBLIC "u not expected", keyLen)
1080 *keySize = keyLen;
1081 return ret;
1082 }
1083 #endif
1084
1085 #ifdef HKS_SUPPORT_RSA_C
1086 #ifdef HKS_SUPPORT_RSA_C_FLEX_KEYSIZE
CheckRsaKeySize(uint32_t keyLen)1087 static int32_t CheckRsaKeySize(uint32_t keyLen)
1088 {
1089 if ((keyLen >= HKS_RSA_KEY_SIZE_1024) &&
1090 (keyLen <= HKS_RSA_KEY_SIZE_2048) &&
1091 ((keyLen % HKS_RSA_KEY_BLOCK_SIZE) == 0)) {
1092 return HKS_SUCCESS;
1093 } else {
1094 return HKS_ERROR_INVALID_KEY_FILE;
1095 }
1096 }
1097
CheckAndGetRsaKeySize(const struct HksBlob * key,uint32_t * keySize)1098 static int32_t CheckAndGetRsaKeySize(const struct HksBlob *key, uint32_t *keySize)
1099 {
1100 if (key->size < sizeof(struct HksParamSet)) {
1101 HKS_LOG_E("check key size: invalid keyfile size: %" LOG_PUBLIC "u", key->size);
1102 return HKS_ERROR_INVALID_KEY_FILE;
1103 }
1104
1105 struct HksParamSet *keyParamSet = (struct HksParamSet *)key->data;
1106 int32_t ret = HksCheckParamSetValidity(keyParamSet);
1107 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_KEY_FILE, "check key size: paramset invalid failed")
1108
1109 struct HksParam *keySizeParam = NULL;
1110 ret = HksGetParam(keyParamSet, HKS_TAG_KEY_SIZE, &keySizeParam);
1111 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_KEY_FILE,
1112 "check key size: get param get tag:0x%" LOG_PUBLIC "x failed", HKS_TAG_KEY_SIZE)
1113 ret = CheckRsaKeySize(keySizeParam->uint32Param);
1114 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_KEY_FILE,
1115 "check key size: key size value %" LOG_PUBLIC "u not expected", keySizeParam->uint32Param)
1116 *keySize = keySizeParam->uint32Param;
1117
1118 return ret;
1119 }
1120 #endif
1121 #endif
1122
CheckPurposeUnique(uint32_t inputPurpose)1123 static int32_t CheckPurposeUnique(uint32_t inputPurpose)
1124 {
1125 /* key usage uniqueness */
1126 uint32_t purposeCipher = inputPurpose & (HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT);
1127 uint32_t purposeSign = inputPurpose & (HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY);
1128 uint32_t purposeDerive = inputPurpose & HKS_KEY_PURPOSE_DERIVE;
1129 uint32_t purposeWrap = inputPurpose & (HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP);
1130 uint32_t purposeMac = inputPurpose & HKS_KEY_PURPOSE_MAC;
1131 uint32_t purposeAgree = inputPurpose & HKS_KEY_PURPOSE_AGREE;
1132
1133 uint32_t purposeCount = (purposeCipher != 0) ? 1 : 0;
1134 purposeCount += (purposeSign != 0) ? 1 : 0;
1135 purposeCount += (purposeDerive != 0) ? 1 : 0;
1136 purposeCount += (purposeWrap != 0) ? 1 : 0;
1137 purposeCount += (purposeMac != 0) ? 1 : 0;
1138 purposeCount += (purposeAgree != 0) ? 1 : 0;
1139
1140 return (purposeCount == 1) ? HKS_SUCCESS : HKS_ERROR_INVALID_PURPOSE;
1141 }
1142
GetInvalidPurpose(uint32_t alg,uint32_t * inputPurpose,uint32_t keyFlag)1143 static int32_t GetInvalidPurpose(uint32_t alg, uint32_t *inputPurpose, uint32_t keyFlag)
1144 {
1145 int32_t result = HKS_ERROR_INVALID_ALGORITHM;
1146 if (sizeof(g_invalidPurpose) == 0) {
1147 return result;
1148 }
1149 uint32_t count = sizeof(g_invalidPurpose) / sizeof(g_invalidPurpose[0]);
1150 for (uint32_t i = 0; i < count; i++) {
1151 if (alg == g_invalidPurpose[i][0]) {
1152 result = HKS_SUCCESS;
1153 *inputPurpose = g_invalidPurpose[i][1];
1154 break;
1155 }
1156 }
1157 if ((keyFlag != HKS_KEY_FLAG_IMPORT_KEY) || (sizeof(g_invalidImportKeyPurpose) == 0)) {
1158 return result;
1159 }
1160 // add invalid purpose for import key additionally
1161 count = sizeof(g_invalidImportKeyPurpose) / sizeof(g_invalidImportKeyPurpose[0]);
1162 for (uint32_t i = 0; i < count; i++) {
1163 if (alg == g_invalidImportKeyPurpose[i][0]) {
1164 *inputPurpose |= g_invalidImportKeyPurpose[i][1];
1165 break;
1166 }
1167 }
1168 return result;
1169 }
1170
CheckPurposeValid(uint32_t alg,uint32_t inputPurpose,uint32_t keyFlag)1171 static int32_t CheckPurposeValid(uint32_t alg, uint32_t inputPurpose, uint32_t keyFlag)
1172 {
1173 uint32_t invalidPurpose = 0;
1174
1175 int32_t result = GetInvalidPurpose(alg, &invalidPurpose, keyFlag);
1176 HKS_IF_NOT_SUCC_RETURN(result, result)
1177
1178 if ((inputPurpose & invalidPurpose) != 0) {
1179 return HKS_ERROR_INVALID_PURPOSE;
1180 }
1181
1182 return HKS_SUCCESS;
1183 }
1184 #endif /* _CUT_AUTHENTICATE_ */
1185
1186 // If tag is optional param, when tag is empty, it is supported.
GetOptionalParams(const struct HksParamSet * paramSet,uint32_t tag,bool needCheck,uint32_t * value,bool * isAbsent)1187 static int32_t GetOptionalParams(const struct HksParamSet *paramSet, uint32_t tag, bool needCheck, uint32_t* value,
1188 bool* isAbsent)
1189 {
1190 if (needCheck) {
1191 struct HksParam *param;
1192 int32_t ret = HksGetParam(paramSet, tag, ¶m);
1193 if (ret == HKS_SUCCESS) {
1194 *value = param->uint32Param;
1195 return ret;
1196 }
1197 if (ret == HKS_ERROR_PARAM_NOT_EXIST) {
1198 HKS_LOG_I("tag is empty, but it is supported!");
1199 *isAbsent = true;
1200 return HKS_SUCCESS;
1201 }
1202 return HKS_ERROR_INVALID_ARGUMENT;
1203 }
1204 return HKS_SUCCESS;
1205 }
1206
GetInputParams(const struct HksParamSet * paramSet,struct ParamsValues * inputParams)1207 int32_t GetInputParams(const struct HksParamSet *paramSet, struct ParamsValues *inputParams)
1208 {
1209 int32_t ret = HKS_SUCCESS;
1210 struct HksParam *checkParam = NULL;
1211 if (inputParams->keyLen.needCheck) {
1212 ret = HksGetParam(paramSet, HKS_TAG_KEY_SIZE, &checkParam);
1213 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_KEY_SIZE_FAIL,
1214 "get Param get tag:0x%" LOG_PUBLIC "x failed", HKS_TAG_KEY_SIZE);
1215 inputParams->keyLen.value = checkParam->uint32Param;
1216 }
1217
1218 if (inputParams->purpose.needCheck) {
1219 ret = HksGetParam(paramSet, HKS_TAG_PURPOSE, &checkParam);
1220 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_PURPOSE_FAIL,
1221 "get Param get tag:0x%" LOG_PUBLIC "x failed", HKS_TAG_PURPOSE);
1222 inputParams->purpose.value = checkParam->uint32Param;
1223 }
1224
1225 ret = GetOptionalParams(paramSet, HKS_TAG_PADDING, inputParams->padding.needCheck, &inputParams->padding.value,
1226 &inputParams->padding.isAbsent);
1227 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_PADDING_FAIL,
1228 "get Param get tag:0x%" LOG_PUBLIC "x failed", HKS_TAG_PADDING);
1229 ret = GetOptionalParams(paramSet, HKS_TAG_DIGEST, inputParams->digest.needCheck, &inputParams->digest.value,
1230 &inputParams->digest.isAbsent);
1231 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_DIGEST_FAIL,
1232 "get Param get tag:0x%" LOG_PUBLIC "x failed", HKS_TAG_DIGEST);
1233 ret = GetOptionalParams(paramSet, HKS_TAG_BLOCK_MODE, inputParams->mode.needCheck, &inputParams->mode.value,
1234 &inputParams->mode.isAbsent);
1235 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_MODE_FAIL,
1236 "get Param get tag:0x%" LOG_PUBLIC "x failed", HKS_TAG_BLOCK_MODE);
1237 return ret;
1238 }
1239
InitInputParams(enum CheckKeyType checkType,struct ParamsValues * inputParams,const struct ParamsValuesChecker * checkSet,uint32_t checkSetSize)1240 static int32_t InitInputParams(enum CheckKeyType checkType, struct ParamsValues *inputParams,
1241 const struct ParamsValuesChecker *checkSet, uint32_t checkSetSize)
1242 {
1243 for (uint32_t i = 0; i < checkSetSize; ++i) {
1244 if (checkType == checkSet[i].checkType) {
1245 (void)memcpy_s(inputParams, sizeof(*inputParams), &checkSet[i].paramValues,
1246 sizeof(checkSet[i].paramValues));
1247 return HKS_SUCCESS;
1248 }
1249 }
1250 return HKS_ERROR_NOT_SUPPORTED;
1251 }
1252
1253
InitInputParamsByAlgOne(uint32_t alg,enum CheckKeyType checkType,struct ParamsValues * inputParams)1254 static int32_t InitInputParamsByAlgOne(uint32_t alg, enum CheckKeyType checkType, struct ParamsValues *inputParams)
1255 {
1256 switch (alg) {
1257 #ifdef HKS_SUPPORT_HMAC_C
1258 case HKS_ALG_HMAC:
1259 return InitInputParams(checkType, inputParams, g_hmacParamSet, HKS_ARRAY_SIZE(g_hmacParamSet));
1260 #endif
1261 #ifdef HKS_SUPPORT_CMAC_C
1262 case HKS_ALG_CMAC:
1263 return InitInputParams(checkType, inputParams, g_cmacParamSet, HKS_ARRAY_SIZE(g_cmacParamSet));
1264 #endif
1265 #ifdef HKS_SUPPORT_DSA_C
1266 case HKS_ALG_DSA:
1267 return InitInputParams(checkType, inputParams, g_dsaParamSet, HKS_ARRAY_SIZE(g_dsaParamSet));
1268 #endif
1269 #ifdef HKS_SUPPORT_DH_C
1270 case HKS_ALG_DH:
1271 return InitInputParams(checkType, inputParams, g_dhParamSet, HKS_ARRAY_SIZE(g_dhParamSet));
1272 #endif
1273 #ifdef HKS_SUPPORT_ECDH_C
1274 case HKS_ALG_ECDH:
1275 return InitInputParams(checkType, inputParams, g_ecdhParamSet, HKS_ARRAY_SIZE(g_ecdhParamSet));
1276 #endif
1277 default:
1278 return HKS_ERROR_INVALID_ALGORITHM;
1279 }
1280 }
1281
InitInputParamsByAlg(uint32_t alg,enum CheckKeyType checkType,struct ParamsValues * inputParams)1282 static int32_t InitInputParamsByAlg(uint32_t alg, enum CheckKeyType checkType, struct ParamsValues *inputParams)
1283 {
1284 switch (alg) {
1285 #ifdef HKS_SUPPORT_RSA_C
1286 case HKS_ALG_RSA:
1287 return InitInputParams(checkType, inputParams, g_rsaParamSet, HKS_ARRAY_SIZE(g_rsaParamSet));
1288 #endif
1289 #ifdef HKS_SUPPORT_AES_C
1290 case HKS_ALG_AES:
1291 return InitInputParams(checkType, inputParams, g_aesParamSet, HKS_ARRAY_SIZE(g_aesParamSet));
1292 #endif
1293 #ifdef HKS_SUPPORT_DES_C
1294 case HKS_ALG_DES:
1295 return InitInputParams(checkType, inputParams, g_desParamSet, HKS_ARRAY_SIZE(g_desParamSet));
1296 #endif
1297 #ifdef HKS_SUPPORT_3DES_C
1298 case HKS_ALG_3DES:
1299 return InitInputParams(checkType, inputParams, g_3desParamSet, HKS_ARRAY_SIZE(g_3desParamSet));
1300 #endif
1301 #ifdef HKS_SUPPORT_ECC_C
1302 case HKS_ALG_ECC:
1303 return InitInputParams(checkType, inputParams, g_eccParamSet, HKS_ARRAY_SIZE(g_eccParamSet));
1304 #endif
1305 #ifdef HKS_SUPPORT_SM2_C
1306 case HKS_ALG_SM2:
1307 return InitInputParams(checkType, inputParams, g_sm2ParamSet, HKS_ARRAY_SIZE(g_sm2ParamSet));
1308 #endif
1309 #ifdef HKS_SUPPORT_SM3_C
1310 case HKS_ALG_SM3:
1311 return InitInputParams(checkType, inputParams, g_sm3ParamSet, HKS_ARRAY_SIZE(g_sm3ParamSet));
1312 #endif
1313 #ifdef HKS_SUPPORT_SM4_C
1314 case HKS_ALG_SM4:
1315 return InitInputParams(checkType, inputParams, g_sm4ParamSet, HKS_ARRAY_SIZE(g_sm4ParamSet));
1316 #endif
1317 #if defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_ED25519_C)
1318 case HKS_ALG_X25519:
1319 case HKS_ALG_ED25519:
1320 return InitInputParams(checkType, inputParams, g_curve25519ParamSet, HKS_ARRAY_SIZE(g_curve25519ParamSet));
1321 #endif
1322 default:
1323 return InitInputParamsByAlgOne(alg, checkType, inputParams);
1324 }
1325 }
1326
InitExpectParams(enum CheckKeyType checkType,struct ExpectParamsValues * expectValues,const struct ExpectParamsValuesChecker * checkSet,uint32_t checkSetSize)1327 static int32_t InitExpectParams(enum CheckKeyType checkType, struct ExpectParamsValues *expectValues,
1328 const struct ExpectParamsValuesChecker *checkSet, uint32_t checkSetSize)
1329 {
1330 for (uint32_t i = 0; i < checkSetSize; ++i) {
1331 if (checkType == checkSet[i].checkType) {
1332 (void)memcpy_s(expectValues, sizeof(*expectValues), &checkSet[i].paramValues,
1333 sizeof(checkSet[i].paramValues));
1334 return HKS_SUCCESS;
1335 }
1336 }
1337 return HKS_ERROR_NOT_SUPPORTED;
1338 }
1339
GetExpectParamsByAlg(uint32_t alg,enum CheckKeyType checkType,struct ExpectParamsValues * expectValues)1340 static int32_t GetExpectParamsByAlg(uint32_t alg, enum CheckKeyType checkType, struct ExpectParamsValues *expectValues)
1341 {
1342 switch (alg) {
1343 #ifdef HKS_SUPPORT_HMAC_C
1344 case HKS_ALG_HMAC:
1345 return InitExpectParams(checkType, expectValues, g_expectHmacParams, HKS_ARRAY_SIZE(g_expectHmacParams));
1346 #endif
1347 #ifdef HKS_SUPPORT_CMAC_C
1348 case HKS_ALG_CMAC:
1349 return InitExpectParams(checkType, expectValues, g_expectCmacParams, HKS_ARRAY_SIZE(g_expectCmacParams));
1350 #endif
1351 #ifdef HKS_SUPPORT_DSA_C
1352 case HKS_ALG_DSA:
1353 return InitExpectParams(checkType, expectValues, g_expectDsaParams, HKS_ARRAY_SIZE(g_expectDsaParams));
1354 #endif
1355 #ifdef HKS_SUPPORT_DH_C
1356 case HKS_ALG_DH:
1357 return InitExpectParams(checkType, expectValues, g_expectDhParams, HKS_ARRAY_SIZE(g_expectDhParams));
1358 #endif
1359 #ifdef HKS_SUPPORT_ECDH_C
1360 case HKS_ALG_ECDH:
1361 return InitExpectParams(checkType, expectValues, g_expectEcdhParams, HKS_ARRAY_SIZE(g_expectEcdhParams));
1362 #endif
1363 default:
1364 return HKS_ERROR_INVALID_ALGORITHM;
1365 }
1366 }
1367
GetExpectParams(uint32_t alg,enum CheckKeyType checkType,struct ExpectParamsValues * expectValues)1368 static int32_t GetExpectParams(uint32_t alg, enum CheckKeyType checkType, struct ExpectParamsValues *expectValues)
1369 {
1370 switch (alg) {
1371 #ifdef HKS_SUPPORT_RSA_C
1372 case HKS_ALG_RSA:
1373 return InitExpectParams(checkType, expectValues, g_expectRsaParams, HKS_ARRAY_SIZE(g_expectRsaParams));
1374 #endif
1375 #ifdef HKS_SUPPORT_AES_C
1376 case HKS_ALG_AES:
1377 return InitExpectParams(checkType, expectValues, g_expectAesParams, HKS_ARRAY_SIZE(g_expectAesParams));
1378 #endif
1379 #ifdef HKS_SUPPORT_DES_C
1380 case HKS_ALG_DES:
1381 return InitExpectParams(checkType, expectValues, g_expectDesParams, HKS_ARRAY_SIZE(g_expectDesParams));
1382 #endif
1383 #ifdef HKS_SUPPORT_3DES_C
1384 case HKS_ALG_3DES:
1385 return InitExpectParams(checkType, expectValues, g_expect3DesParams, HKS_ARRAY_SIZE(g_expect3DesParams));
1386 #endif
1387 #ifdef HKS_SUPPORT_ECC_C
1388 case HKS_ALG_ECC:
1389 return InitExpectParams(checkType, expectValues, g_expectEccParams, HKS_ARRAY_SIZE(g_expectEccParams));
1390 #endif
1391 #ifdef HKS_SUPPORT_SM2_C
1392 case HKS_ALG_SM2:
1393 return InitExpectParams(checkType, expectValues, g_expectSm2Params, HKS_ARRAY_SIZE(g_expectSm2Params));
1394 #endif
1395 #ifdef HKS_SUPPORT_SM3_C
1396 case HKS_ALG_SM3:
1397 return InitExpectParams(checkType, expectValues, g_expectSm3Params, HKS_ARRAY_SIZE(g_expectSm3Params));
1398 #endif
1399 #ifdef HKS_SUPPORT_SM4_C
1400 case HKS_ALG_SM4:
1401 return InitExpectParams(checkType, expectValues, g_expectSm4Params, HKS_ARRAY_SIZE(g_expectSm4Params));
1402 #endif
1403 #if defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_ED25519_C)
1404 case HKS_ALG_X25519:
1405 case HKS_ALG_ED25519:
1406 return InitExpectParams(checkType, expectValues, g_expectCurve25519Params,
1407 HKS_ARRAY_SIZE(g_expectCurve25519Params));
1408 #endif
1409 default:
1410 return GetExpectParamsByAlg(alg, checkType, expectValues);
1411 }
1412 }
1413
1414 #ifdef HKS_SUPPORT_ECC_C
CheckEccSignature(uint32_t cmdId,uint32_t keySize,const struct HksBlob * signature)1415 static int32_t CheckEccSignature(uint32_t cmdId, uint32_t keySize, const struct HksBlob *signature)
1416 {
1417 /*
1418 * ecc sign format: 0x30 + len1 + 0x02 + len2 + 0x00 (optional) + r + 0x02 + len3 + 0x00(optional) + s
1419 * sign: signSize no less than 2*keySize/8 + 8;
1420 * verify: signSize no greater than 2*keySize/8 + 8
1421 */
1422 uint32_t eccSignRSize = keySize / HKS_BITS_PER_BYTE + keySize % HKS_BITS_PER_BYTE;
1423 uint32_t eccSignSSize = eccSignRSize;
1424 switch (cmdId) {
1425 case HKS_CMD_ID_SIGN:
1426 if (signature->size < (eccSignRSize + eccSignSSize + HKS_ECC_SIGN_MAX_TL_SIZE)) {
1427 HKS_LOG_E("eccsign: signature size too small, keySize %" LOG_PUBLIC "u, signatureSize %" LOG_PUBLIC "u",
1428 keySize, signature->size);
1429 return HKS_ERROR_BUFFER_TOO_SMALL;
1430 }
1431 break;
1432 case HKS_CMD_ID_VERIFY:
1433 if (signature->size > (eccSignRSize + eccSignSSize + HKS_ECC_SIGN_MAX_TL_SIZE)) {
1434 HKS_LOG_E("eccverfiy: invalid signature size, keySize %" LOG_PUBLIC "u, signatureSize %" LOG_PUBLIC "u",
1435 keySize, signature->size);
1436 return HKS_ERROR_INVALID_SIGNATURE_SIZE;
1437 }
1438 break;
1439 default:
1440 return HKS_ERROR_INVALID_ARGUMENT;
1441 }
1442
1443 return HKS_SUCCESS;
1444 }
1445 #endif
1446
1447 #ifdef HKS_SUPPORT_ED25519_C
CheckEd25519Signature(uint32_t cmdId,const struct HksBlob * signature)1448 static int32_t CheckEd25519Signature(uint32_t cmdId, const struct HksBlob *signature)
1449 {
1450 switch (cmdId) {
1451 case HKS_CMD_ID_SIGN:
1452 if (signature->size < HKS_SIGNATURE_MIN_SIZE) {
1453 HKS_LOG_E("ed25519 sign: signature size too small, signatureSize %" LOG_PUBLIC "u", signature->size);
1454 return HKS_ERROR_BUFFER_TOO_SMALL;
1455 }
1456 break;
1457 case HKS_CMD_ID_VERIFY:
1458 if (signature->size < HKS_SIGNATURE_MIN_SIZE) {
1459 HKS_LOG_E("ed25519 verfiy: invalid signature size, signatureSize %" LOG_PUBLIC "u", signature->size);
1460 return HKS_ERROR_INVALID_SIGNATURE_SIZE;
1461 }
1462 break;
1463 default:
1464 return HKS_ERROR_INVALID_ARGUMENT;
1465 }
1466
1467 return HKS_SUCCESS;
1468 }
1469 #endif
1470
1471 #ifdef HKS_SUPPORT_RSA_C
CheckRsaGenKeyPadding(const struct ParamsValues * inputParams)1472 static int32_t CheckRsaGenKeyPadding(const struct ParamsValues *inputParams)
1473 {
1474 if (inputParams->padding.isAbsent) {
1475 return HKS_SUCCESS;
1476 }
1477 if ((inputParams->purpose.value & (HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT)) != 0) {
1478 return HksCheckValue(inputParams->padding.value, g_rsaCipherPadding, HKS_ARRAY_SIZE(g_rsaCipherPadding));
1479 } else if ((inputParams->purpose.value & (HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY)) != 0) {
1480 return HksCheckValue(inputParams->padding.value, g_rsaSignPadding, HKS_ARRAY_SIZE(g_rsaSignPadding));
1481 }
1482 return HKS_SUCCESS;
1483 }
1484
1485 #ifdef HKS_SUPPORT_RSA_SIGN_VERIFY
CheckRsaSignature(uint32_t cmdId,uint32_t keySize,const struct HksBlob * signature)1486 static int32_t CheckRsaSignature(uint32_t cmdId, uint32_t keySize, const struct HksBlob *signature)
1487 {
1488 /*
1489 * k: the length of the RSA modulus n
1490 * sign: signSize no less than k; verify: signSize is same as k, thus no greater than keySize / 8
1491 */
1492 switch (cmdId) {
1493 case HKS_CMD_ID_SIGN:
1494 if (signature->size < keySize / HKS_BITS_PER_BYTE) {
1495 HKS_LOG_E("rsasign: signature size too small, keySize %" LOG_PUBLIC "u, signatureSize %" LOG_PUBLIC "u",
1496 keySize, signature->size);
1497 return HKS_ERROR_BUFFER_TOO_SMALL;
1498 }
1499 break;
1500 case HKS_CMD_ID_VERIFY:
1501 if (signature->size > keySize / HKS_BITS_PER_BYTE) {
1502 HKS_LOG_E("rsaverfiy: invalid signature size, keySize %" LOG_PUBLIC "u, signatureSize %" LOG_PUBLIC "u",
1503 keySize, signature->size);
1504 return HKS_ERROR_INVALID_SIGNATURE_SIZE;
1505 }
1506 break;
1507 default:
1508 return HKS_ERROR_INVALID_ARGUMENT;
1509 }
1510
1511 return HKS_SUCCESS;
1512 }
1513 #endif
1514
1515 #ifdef HKS_SUPPORT_RSA_CRYPT
CheckRsaNoPadCipherData(uint32_t keySize,const struct HksBlob * inData,const struct HksBlob * outData)1516 static int32_t CheckRsaNoPadCipherData(uint32_t keySize, const struct HksBlob *inData,
1517 const struct HksBlob *outData)
1518 {
1519 /* encrypt/decrypt: inSize no greater than keySize, outSize no less than keySize */
1520 if (inData->size > keySize) {
1521 HKS_LOG_E("invalid inData size: %" LOG_PUBLIC "u, keySize: %" LOG_PUBLIC "u", inData->size, keySize);
1522 return HKS_ERROR_INVALID_ARGUMENT;
1523 }
1524
1525 if (outData->size < keySize) {
1526 HKS_LOG_E("outData buffer too small size: %" LOG_PUBLIC "u, keySize: %" LOG_PUBLIC "u",
1527 outData->size, keySize);
1528 return HKS_ERROR_BUFFER_TOO_SMALL;
1529 }
1530
1531 return HKS_SUCCESS;
1532 }
1533
CheckRsaOaepCipherData(uint32_t cmdId,uint32_t keySize,uint32_t digest,const struct HksBlob * inData,const struct HksBlob * outData)1534 static int32_t CheckRsaOaepCipherData(uint32_t cmdId, uint32_t keySize, uint32_t digest,
1535 const struct HksBlob *inData, const struct HksBlob *outData)
1536 {
1537 uint32_t digestLen;
1538 if (digest == HKS_DIGEST_NONE) {
1539 digest = HKS_DIGEST_SHA1;
1540 }
1541 int32_t ret = HksGetDigestLen(digest, &digestLen);
1542 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "GetDigestLen failed, ret = %" LOG_PUBLIC "x", ret)
1543
1544 /*
1545 * encrypt: inSize no greater than keySize - 2*digestLen - 2, outSize no less than keySize (in: plain; out: cipher)
1546 * decrypt: inSize no greater than keySize, outSize no less than keySize - 2*digestLen - 2 (in: cipher; out: plain)
1547 */
1548 if (keySize <= (HKS_RSA_OAEP_DIGEST_NUM * digestLen + HKS_RSA_OAEP_DIGEST_NUM)) {
1549 return HKS_ERROR_INVALID_KEY_FILE;
1550 }
1551 uint32_t size = keySize - HKS_RSA_OAEP_DIGEST_NUM * digestLen - HKS_RSA_OAEP_DIGEST_NUM;
1552 if (cmdId == HKS_CMD_ID_ENCRYPT) {
1553 if (inData->size > size) {
1554 HKS_LOG_E("encrypt, invalid insize: %" LOG_PUBLIC "u, keySize: %" LOG_PUBLIC "u, "
1555 "digestLen: %" LOG_PUBLIC "u", inData->size, keySize, digestLen);
1556 return HKS_ERROR_INVALID_ARGUMENT;
1557 }
1558 if (outData->size < keySize) {
1559 HKS_LOG_E("encrypt, outData buffer too small size: %" LOG_PUBLIC "u, keySize: %" LOG_PUBLIC "u",
1560 outData->size, keySize);
1561 return HKS_ERROR_BUFFER_TOO_SMALL;
1562 }
1563 } else if (cmdId == HKS_CMD_ID_DECRYPT) {
1564 if (inData->size > keySize) {
1565 HKS_LOG_E("decrypt, invalid inData size: %" LOG_PUBLIC "u, keySize: %" LOG_PUBLIC "u",
1566 inData->size, keySize);
1567 return HKS_ERROR_INVALID_ARGUMENT;
1568 }
1569 if (outData->size < size) {
1570 HKS_LOG_E("decrypt, outData buffer too small size: %" LOG_PUBLIC "u, keySize: %" LOG_PUBLIC "u",
1571 outData->size, keySize);
1572 return HKS_ERROR_BUFFER_TOO_SMALL;
1573 }
1574 }
1575
1576 return HKS_SUCCESS;
1577 }
1578
CheckRsaCipherData(uint32_t cmdId,const struct ParamsValues * inputParams,const struct HksBlob * inData,const struct HksBlob * outData)1579 static int32_t CheckRsaCipherData(uint32_t cmdId, const struct ParamsValues *inputParams,
1580 const struct HksBlob *inData, const struct HksBlob *outData)
1581 {
1582 uint32_t padding = inputParams->padding.value;
1583 uint32_t keySize = inputParams->keyLen.value / HKS_BITS_PER_BYTE;
1584 int32_t ret = HKS_SUCCESS;
1585
1586 if (padding == HKS_PADDING_NONE) {
1587 ret = CheckRsaNoPadCipherData(keySize, inData, outData);
1588 } else if (padding == HKS_PADDING_OAEP) {
1589 ret = CheckRsaOaepCipherData(cmdId, keySize, inputParams->digest.value, inData, outData);
1590 }
1591
1592 HKS_IF_NOT_SUCC_LOGE(ret, "Check Rsa CipherData failed, cmdId: %" LOG_PUBLIC "u, padding: %" LOG_PUBLIC "u, "
1593 "keyLen: %" LOG_PUBLIC "u, inData size: %" LOG_PUBLIC "u, outData size: %" LOG_PUBLIC "u",
1594 cmdId, padding, keySize, inData->size, outData->size)
1595
1596 return ret;
1597 }
1598 #endif
1599 #endif
1600
1601 #ifdef HKS_SUPPORT_AES_C
1602 static int32_t CheckAesAeCipherData(uint32_t cmdId, const struct HksBlob *inData, const struct HksBlob *outData);
1603 #endif
1604
1605 #if defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_DES_C) || defined(HKS_SUPPORT_3DES_C) || \
1606 defined(HKS_SUPPORT_SM4_C)
CheckBlockCbcCipherData(uint32_t mode,uint32_t cmdId,uint32_t padding,const struct HksBlob * inData,const struct HksBlob * outData)1607 static int32_t CheckBlockCbcCipherData(uint32_t mode, uint32_t cmdId, uint32_t padding,
1608 const struct HksBlob *inData, const struct HksBlob *outData)
1609 {
1610 /*
1611 * encrypt: inSize greater than 0(has been checked), no-padding: inSize need to be integer multiple of 16
1612 * outSize no less than inSize + (16 - inSize % 16) (in: plain; out: cipher)
1613 * decrypt: inSize greater than 0(has been checked) && inSize is integer multiple of 16
1614 * outSize no less than inSize (in: cipher; out: plain)
1615 */
1616 switch (cmdId) {
1617 case HKS_CMD_ID_ENCRYPT: {
1618 uint32_t paddingSize = 0;
1619 if (padding == HKS_PADDING_NONE) {
1620 if ((mode == HKS_MODE_CBC || mode == HKS_MODE_ECB) &&
1621 inData->size % HKS_BLOCK_CIPHER_CBC_BLOCK_SIZE != 0) {
1622 HKS_LOG_E("encrypt, mode id: %" LOG_PUBLIC "u, no-padding, invalid inSize: %" LOG_PUBLIC "u",
1623 mode, inData->size);
1624 return HKS_ERROR_INVALID_ARGUMENT;
1625 }
1626 } else {
1627 paddingSize = HKS_BLOCK_CIPHER_CBC_BLOCK_SIZE - inData->size % HKS_BLOCK_CIPHER_CBC_BLOCK_SIZE;
1628 if (inData->size > (UINT32_MAX - paddingSize)) {
1629 HKS_LOG_E("encrypt, invalid inData size: %" LOG_PUBLIC "u", inData->size);
1630 return HKS_ERROR_INVALID_ARGUMENT;
1631 }
1632 }
1633 if (outData->size < (inData->size + paddingSize)) {
1634 HKS_LOG_E("encrypt, outData buffer too small size: %" LOG_PUBLIC "u, need: %" LOG_PUBLIC "u",
1635 outData->size, inData->size + paddingSize);
1636 return HKS_ERROR_BUFFER_TOO_SMALL;
1637 }
1638 break;
1639 }
1640 case HKS_CMD_ID_DECRYPT:
1641 if ((mode == HKS_MODE_CBC || mode == HKS_MODE_ECB) && inData->size % HKS_BLOCK_CIPHER_CBC_BLOCK_SIZE != 0) {
1642 HKS_LOG_E("decrypt, mode id: %" LOG_PUBLIC "u, invalid inData size: %" LOG_PUBLIC "u",
1643 mode, inData->size);
1644 return HKS_ERROR_INVALID_ARGUMENT;
1645 }
1646 if (outData->size < inData->size) {
1647 HKS_LOG_E("decrypt, outData buffer too small size: %" LOG_PUBLIC "u, inDataSize: %" LOG_PUBLIC "u",
1648 outData->size, inData->size);
1649 return HKS_ERROR_BUFFER_TOO_SMALL;
1650 }
1651 break;
1652 default:
1653 return HKS_ERROR_INVALID_ARGUMENT;
1654 }
1655
1656 return HKS_SUCCESS;
1657 }
1658
CheckBlockCipherData(uint32_t cmdId,const struct ParamsValues * inputParams,const struct HksBlob * inData,const struct HksBlob * outData,uint32_t alg)1659 static int32_t CheckBlockCipherData(uint32_t cmdId, const struct ParamsValues *inputParams,
1660 const struct HksBlob *inData, const struct HksBlob *outData, uint32_t alg)
1661 {
1662 uint32_t mode = inputParams->mode.value;
1663
1664 #if defined(HKS_SUPPORT_AES_C)
1665 if (alg == HKS_ALG_AES) {
1666 if (mode == HKS_MODE_CBC || mode == HKS_MODE_CTR || mode == HKS_MODE_ECB) {
1667 uint32_t padding = inputParams->padding.value;
1668 return CheckBlockCbcCipherData(mode, cmdId, padding, inData, outData);
1669 } else if (mode == HKS_MODE_GCM || mode == HKS_MODE_CCM) {
1670 return CheckAesAeCipherData(cmdId, inData, outData);
1671 }
1672 }
1673 #endif
1674
1675 #if defined(HKS_SUPPORT_DES_C)
1676 if (alg == HKS_ALG_DES) {
1677 if (mode == HKS_MODE_CBC || mode == HKS_MODE_ECB) {
1678 uint32_t padding = inputParams->padding.value;
1679 return CheckBlockCbcCipherData(mode, cmdId, padding, inData, outData);
1680 }
1681 }
1682 #endif
1683
1684 #if defined(HKS_SUPPORT_3DES_C)
1685 if (alg == HKS_ALG_3DES) {
1686 if (mode == HKS_MODE_CBC || mode == HKS_MODE_ECB) {
1687 uint32_t padding = inputParams->padding.value;
1688 return CheckBlockCbcCipherData(mode, cmdId, padding, inData, outData);
1689 }
1690 }
1691 #endif
1692
1693 #if defined(HKS_SUPPORT_SM4_C)
1694 if (alg == HKS_ALG_SM4) {
1695 for (uint32_t i = 0; i < HKS_ARRAY_SIZE(g_sm4Mode); i++) {
1696 if (mode == g_sm4Mode[i]) {
1697 uint32_t padding = inputParams->padding.value;
1698 return CheckBlockCbcCipherData(mode, cmdId, padding, inData, outData);
1699 }
1700 }
1701 }
1702 #endif
1703
1704 return HKS_ERROR_INVALID_MODE;
1705 }
1706
CheckBlockCipherIvMaterial(const struct HksParamSet * paramSet)1707 static int32_t CheckBlockCipherIvMaterial(const struct HksParamSet *paramSet)
1708 {
1709 struct HksParam *ivParam = NULL;
1710 int32_t ret = HksGetParam(paramSet, HKS_TAG_IV, &ivParam);
1711 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_IV_FAIL, "cipher get iv param failed!")
1712
1713 if ((ivParam->blob.size != HKS_BLOCK_CIPHER_CBC_IV_LEN) || (ivParam->blob.data == NULL)) {
1714 HKS_LOG_E("cbc iv param invalid");
1715 return HKS_ERROR_INVALID_IV;
1716 }
1717
1718 return ret;
1719 }
1720 #endif // defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_DES_C) || defined(HKS_SUPPORT_3DES_C)
1721 // || defined(HKS_SUPPORT_SM4_C)
1722
1723 #ifdef HKS_SUPPORT_AES_C
CheckAesPadding(const struct ParamsValues * inputParams)1724 static int32_t CheckAesPadding(const struct ParamsValues *inputParams)
1725 {
1726 if ((inputParams->mode.isAbsent) || (inputParams->padding.isAbsent)) {
1727 return HKS_SUCCESS;
1728 }
1729 uint32_t mode = inputParams->mode.value;
1730 uint32_t padding = inputParams->padding.value;
1731 if (mode == HKS_MODE_CBC) {
1732 return HksCheckValue(padding, g_aesCbcPadding, HKS_ARRAY_SIZE(g_aesCbcPadding));
1733 }
1734
1735 if (mode == HKS_MODE_CTR) {
1736 return HksCheckValue(padding, g_aesCtrPadding, HKS_ARRAY_SIZE(g_aesCtrPadding));
1737 }
1738
1739 if (mode == HKS_MODE_ECB) {
1740 return HksCheckValue(padding, g_aesEcbPadding, HKS_ARRAY_SIZE(g_aesEcbPadding));
1741 }
1742
1743 if ((mode == HKS_MODE_GCM) || (mode == HKS_MODE_CCM)) {
1744 return HksCheckValue(padding, g_aesAeadPadding, HKS_ARRAY_SIZE(g_aesAeadPadding));
1745 }
1746
1747 return HKS_SUCCESS;
1748 }
1749
CheckAesAeCipherData(uint32_t cmdId,const struct HksBlob * inData,const struct HksBlob * outData)1750 static int32_t CheckAesAeCipherData(uint32_t cmdId, const struct HksBlob *inData, const struct HksBlob *outData)
1751 {
1752 /*
1753 * encrypt: inSize greater than 0(has been checked),
1754 * outSize no less than inSize + 16(tagLen) (in: plain; out: cipher)
1755 * decrypt: inSize greater than 16(tagLen), outSize no less than inSize - 16(tagLen)
1756 * decryptFinal: inSize greater than 0(has been checked), outSize no less than inSize (in: cipher; out: plain)
1757 */
1758 switch (cmdId) {
1759 case HKS_CMD_ID_ENCRYPT:
1760 if (inData->size > (UINT32_MAX - HKS_AE_TAG_LEN)) {
1761 HKS_LOG_E("encrypt, invalid inSize: %" LOG_PUBLIC "u", inData->size);
1762 return HKS_ERROR_INVALID_ARGUMENT;
1763 }
1764 if (outData->size < (inData->size + HKS_AE_TAG_LEN)) {
1765 HKS_LOG_E("encrypt, out buffer too small size: %" LOG_PUBLIC "u, inSize: %" LOG_PUBLIC "u",
1766 outData->size, inData->size);
1767 return HKS_ERROR_BUFFER_TOO_SMALL;
1768 }
1769 break;
1770 case HKS_CMD_ID_DECRYPT:
1771 if ((inData->size < HKS_AE_TAG_LEN) || (outData->size < inData->size - HKS_AE_TAG_LEN)) {
1772 HKS_LOG_E("decryptfinal, out buffer too small size: %" LOG_PUBLIC "u, inSize: %" LOG_PUBLIC "u",
1773 outData->size, inData->size);
1774 return HKS_ERROR_BUFFER_TOO_SMALL;
1775 }
1776 break;
1777 default:
1778 return HKS_ERROR_INVALID_ARGUMENT;
1779 }
1780
1781 return HKS_SUCCESS;
1782 }
1783
CheckCipherAeAadMaterial(uint32_t mode,const struct HksParamSet * paramSet)1784 static int32_t CheckCipherAeAadMaterial(uint32_t mode, const struct HksParamSet *paramSet)
1785 {
1786 struct HksParam *aadParam = NULL;
1787 int32_t ret = HksGetParam(paramSet, HKS_TAG_ASSOCIATED_DATA, &aadParam);
1788 if (mode == HKS_MODE_GCM && ret == HKS_ERROR_PARAM_NOT_EXIST) {
1789 HKS_LOG_W("gcm no input aad");
1790 return HKS_SUCCESS;
1791 } else if (ret != HKS_SUCCESS) {
1792 HKS_LOG_E("cipher get aad param failed!");
1793 return HKS_ERROR_CHECK_GET_AAD_FAIL;
1794 }
1795 HKS_IF_NOT_SUCC_RETURN(CheckBlob(&aadParam->blob), HKS_ERROR_INVALID_AAD)
1796
1797 /* gcmMode: aadSize greater than 0 (has been checked); ccmMode: aadSize no less than 4 */
1798 if (mode == HKS_MODE_CCM) {
1799 if (aadParam->blob.size < HKS_AES_CCM_AAD_LEN_MIN) {
1800 HKS_LOG_E("ccm invalid aad size, aad size = %" LOG_PUBLIC "u", aadParam->blob.size);
1801 return HKS_ERROR_INVALID_AAD;
1802 }
1803 }
1804
1805 return HKS_SUCCESS;
1806 }
1807
CheckCipherAeNonceMaterial(uint32_t mode,const struct HksParamSet * paramSet)1808 static int32_t CheckCipherAeNonceMaterial(uint32_t mode, const struct HksParamSet *paramSet)
1809 {
1810 struct HksParam *nonceParam = NULL;
1811 int32_t ret = HksGetParam(paramSet, HKS_TAG_NONCE, &nonceParam);
1812 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_NONCE_FAIL, "cipher get nonce param failed!")
1813 HKS_IF_NOT_SUCC_RETURN(CheckBlob(&nonceParam->blob), HKS_ERROR_INVALID_NONCE)
1814
1815 /* gcmMode: nonceSize no less than 12; ccmMode: nonceSize no less than 7, and no greater than 13 */
1816 if (mode == HKS_MODE_GCM) {
1817 if (nonceParam->blob.size < HKS_AES_GCM_NONCE_LEN_MIN) {
1818 HKS_LOG_E("gcm invalid nonce size, nonce size = %" LOG_PUBLIC "u", nonceParam->blob.size);
1819 return HKS_ERROR_INVALID_NONCE;
1820 }
1821 } else if (mode == HKS_MODE_CCM) {
1822 if ((nonceParam->blob.size < HKS_AES_CCM_NONCE_LEN_MIN) ||
1823 (nonceParam->blob.size > HKS_AES_CCM_NONCE_LEN_MAX)) {
1824 HKS_LOG_E("ccm invalid nonce size, nonce size = %" LOG_PUBLIC "u", nonceParam->blob.size);
1825 return HKS_ERROR_INVALID_NONCE;
1826 }
1827 }
1828
1829 return HKS_SUCCESS;
1830 }
1831
CheckCipherAeMaterial(uint32_t mode,const struct HksParamSet * paramSet)1832 static int32_t CheckCipherAeMaterial(uint32_t mode, const struct HksParamSet *paramSet)
1833 {
1834 int32_t ret = CheckCipherAeAadMaterial(mode, paramSet);
1835 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "check ae cipher aad failed!")
1836
1837 ret = CheckCipherAeNonceMaterial(mode, paramSet);
1838 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "check ae cipher nonce failed!")
1839
1840 return ret;
1841 }
1842 #endif
1843
1844 #ifdef HKS_SUPPORT_DES_C
CheckDesPadding(const struct ParamsValues * inputParams)1845 static int32_t CheckDesPadding(const struct ParamsValues *inputParams)
1846 {
1847 if ((inputParams->mode.isAbsent) || (inputParams->padding.isAbsent)) {
1848 return HKS_SUCCESS;
1849 }
1850 uint32_t mode = inputParams->mode.value;
1851 uint32_t padding = inputParams->padding.value;
1852 if (mode == HKS_MODE_CBC) {
1853 return HksCheckValue(padding, g_desCbcPadding, HKS_ARRAY_SIZE(g_desCbcPadding));
1854 }
1855
1856 if (mode == HKS_MODE_ECB) {
1857 return HksCheckValue(padding, g_desEcbPadding, HKS_ARRAY_SIZE(g_desEcbPadding));
1858 }
1859
1860 return HKS_SUCCESS;
1861 }
1862 #endif
1863
1864 #ifdef HKS_SUPPORT_3DES_C
Check3DesPadding(const struct ParamsValues * inputParams)1865 static int32_t Check3DesPadding(const struct ParamsValues *inputParams)
1866 {
1867 if ((inputParams->mode.isAbsent) || (inputParams->padding.isAbsent)) {
1868 return HKS_SUCCESS;
1869 }
1870 uint32_t mode = inputParams->mode.value;
1871 uint32_t padding = inputParams->padding.value;
1872 if (mode == HKS_MODE_CBC) {
1873 return HksCheckValue(padding, g_3desCbcPadding, HKS_ARRAY_SIZE(g_3desCbcPadding));
1874 }
1875
1876 if (mode == HKS_MODE_ECB) {
1877 return HksCheckValue(padding, g_3desEcbPadding, HKS_ARRAY_SIZE(g_3desEcbPadding));
1878 }
1879
1880 return HKS_SUCCESS;
1881 }
1882 #endif
1883
1884 #ifdef HKS_SUPPORT_SM4_C
CheckSm4Padding(const struct ParamsValues * inputParams)1885 static int32_t CheckSm4Padding(const struct ParamsValues *inputParams)
1886 {
1887 if ((inputParams->mode.isAbsent) || (inputParams->padding.isAbsent)) {
1888 return HKS_SUCCESS;
1889 }
1890 uint32_t mode = inputParams->mode.value;
1891 uint32_t padding = inputParams->padding.value;
1892 if (mode == HKS_MODE_CBC) {
1893 return HksCheckValue(padding, g_sm4CbcPadding, HKS_ARRAY_SIZE(g_sm4CbcPadding));
1894 }
1895
1896 if (mode == HKS_MODE_CTR) {
1897 return HksCheckValue(padding, g_sm4CtrPadding, HKS_ARRAY_SIZE(g_sm4CtrPadding));
1898 }
1899
1900 if (mode == HKS_MODE_ECB) {
1901 return HksCheckValue(padding, g_sm4EcbPadding, HKS_ARRAY_SIZE(g_sm4EcbPadding));
1902 }
1903
1904 if (mode == HKS_MODE_CFB) {
1905 return HksCheckValue(padding, g_sm4CfbPadding, HKS_ARRAY_SIZE(g_sm4CfbPadding));
1906 }
1907
1908 if (mode == HKS_MODE_OFB) {
1909 return HksCheckValue(padding, g_sm4OfbPadding, HKS_ARRAY_SIZE(g_sm4OfbPadding));
1910 }
1911
1912 return HKS_ERROR_INVALID_ARGUMENT;
1913 }
1914 #endif
1915
HksCheckValue(uint32_t inputValue,const uint32_t * expectValues,uint32_t valuesCount)1916 int32_t HksCheckValue(uint32_t inputValue, const uint32_t *expectValues, uint32_t valuesCount)
1917 {
1918 for (uint32_t i = 0; i < valuesCount; ++i) {
1919 if (inputValue == expectValues[i]) {
1920 return HKS_SUCCESS;
1921 }
1922 }
1923 return HKS_ERROR_INVALID_ARGUMENT;
1924 }
1925
1926 #ifndef _CUT_AUTHENTICATE_
HksCheckGenKeyPurpose(uint32_t alg,uint32_t inputPurpose,uint32_t keyFlag)1927 int32_t HksCheckGenKeyPurpose(uint32_t alg, uint32_t inputPurpose, uint32_t keyFlag)
1928 {
1929 int32_t ret = CheckPurposeUnique(inputPurpose);
1930 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "gen key purpose not unique")
1931
1932 return CheckPurposeValid(alg, inputPurpose, keyFlag);
1933 }
1934
1935 #ifdef HKS_SUPPORT_DSA_C
HksGetDsaKeySize(const struct HksBlob * key,uint32_t * keySize)1936 static int32_t HksGetDsaKeySize(const struct HksBlob *key, uint32_t *keySize)
1937 {
1938 if (key->size < sizeof(struct HksParamSet)) {
1939 HKS_LOG_E("check dsa key size: invalid keyfile size: %" LOG_PUBLIC "u", key->size);
1940 return HKS_ERROR_INVALID_KEY_FILE;
1941 }
1942
1943 struct HksParamSet *keyParamSet = (struct HksParamSet *)key->data;
1944 int32_t ret = HksCheckParamSetValidity(keyParamSet);
1945 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_KEY_FILE, "check dsa key size: paramset invalid failed")
1946
1947 struct HksParam *keySizeParam = NULL;
1948 ret = HksGetParam(keyParamSet, HKS_TAG_KEY_SIZE, &keySizeParam);
1949 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_KEY_FILE,
1950 "check dsa key size: get param get tag:0x%" LOG_PUBLIC "x failed", HKS_TAG_KEY_SIZE)
1951 *keySize = keySizeParam->uint32Param;
1952 return ret;
1953 }
1954 #endif
1955
HksGetKeySize(uint32_t alg,const struct HksBlob * key,uint32_t * keySize)1956 int32_t HksGetKeySize(uint32_t alg, const struct HksBlob *key, uint32_t *keySize)
1957 {
1958 int32_t ret = HKS_ERROR_INVALID_ALGORITHM;
1959 switch (alg) {
1960 #ifdef HKS_SUPPORT_RSA_C
1961 case HKS_ALG_RSA:
1962 ret = CheckAndGetKeySize(key, g_rsaKeySize, HKS_ARRAY_SIZE(g_rsaKeySize), keySize);
1963 #ifdef HKS_SUPPORT_RSA_C_FLEX_KEYSIZE
1964 if (ret != HKS_SUCCESS) {
1965 ret = CheckAndGetRsaKeySize(key, keySize);
1966 }
1967 #endif
1968 return ret;
1969 #endif
1970 #ifdef HKS_SUPPORT_DSA_C
1971 case HKS_ALG_DSA:
1972 #ifndef _STORAGE_LITE_
1973 return HksGetDsaKeySize(key, keySize);
1974 #else
1975 return HKS_ERROR_INVALID_ALGORITHM;
1976 #endif
1977 #endif
1978 #ifdef HKS_SUPPORT_ECC_C
1979 case HKS_ALG_ECC:
1980 return CheckAndGetKeySize(key, g_eccKeySize, HKS_ARRAY_SIZE(g_eccKeySize), keySize);
1981 #endif
1982 #ifdef HKS_SUPPORT_ECDH_C
1983 case HKS_ALG_ECDH:
1984 return CheckAndGetKeySize(key, g_ecdhKeySize, HKS_ARRAY_SIZE(g_ecdhKeySize), keySize);
1985 #endif
1986 #if defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_ED25519_C)
1987 case HKS_ALG_X25519:
1988 case HKS_ALG_ED25519:
1989 return CheckAndGetKeySize(key, g_curve25519KeySize, HKS_ARRAY_SIZE(g_curve25519KeySize), keySize);
1990 #endif
1991 #ifdef HKS_SUPPORT_DH_C
1992 case HKS_ALG_DH:
1993 return CheckAndGetKeySize(key, g_dhKeySize, HKS_ARRAY_SIZE(g_dhKeySize), keySize);
1994 #endif
1995 #ifdef HKS_SUPPORT_SM4_C
1996 case HKS_ALG_SM4:
1997 return CheckAndGetKeySize(key, g_sm4KeySize, HKS_ARRAY_SIZE(g_sm4KeySize), keySize);
1998 #endif
1999 #ifdef HKS_SUPPORT_SM2_C
2000 case HKS_ALG_SM2:
2001 return CheckAndGetKeySize(key, g_sm2KeySize, HKS_ARRAY_SIZE(g_sm2KeySize), keySize);
2002 #endif
2003 default:
2004 return ret;
2005 }
2006 }
2007 #endif /* _CUT_AUTHENTICATE_ */
2008
HksGetInputParmasByAlg(uint32_t alg,enum CheckKeyType checkType,const struct HksParamSet * paramSet,struct ParamsValues * inputParams)2009 int32_t HksGetInputParmasByAlg(uint32_t alg, enum CheckKeyType checkType, const struct HksParamSet *paramSet,
2010 struct ParamsValues *inputParams)
2011 {
2012 int32_t ret = InitInputParamsByAlg(alg, checkType, inputParams);
2013 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "init input params failed!")
2014
2015 ret = GetInputParams(paramSet, inputParams);
2016 HKS_IF_NOT_SUCC_LOGE(ret, "get input params failed!")
2017
2018 return ret;
2019 }
CheckOptionalParams(bool needCheck,bool isAbsent,uint32_t inputValue,const uint32_t * expectValue,uint32_t expectCnt)2020 static int32_t CheckOptionalParams(bool needCheck, bool isAbsent, uint32_t inputValue, const uint32_t* expectValue,
2021 uint32_t expectCnt)
2022 {
2023 if (needCheck) {
2024 if (!isAbsent) {
2025 if (HksCheckValue(inputValue, expectValue, expectCnt) != HKS_SUCCESS) {
2026 HKS_LOG_E("CheckOptionalParams invalid argument, %" LOG_PUBLIC "u", inputValue);
2027 return HKS_ERROR_INVALID_ARGUMENT;
2028 }
2029 }
2030 }
2031 return HKS_SUCCESS;
2032 }
2033
InitCheckOptionalParams(bool needCheck,bool isAbsent,struct HksParam * param,const uint32_t * expectValue,uint32_t expectCnt)2034 static int32_t InitCheckOptionalParams(bool needCheck, bool isAbsent, struct HksParam *param,
2035 const uint32_t* expectValue, uint32_t expectCnt)
2036 {
2037 if (needCheck) {
2038 if (!isAbsent) {
2039 if (HksCheckValue(param->uint32Param, expectValue, expectCnt) != HKS_SUCCESS) {
2040 return HKS_ERROR_INVALID_ARGUMENT;
2041 }
2042 } else {
2043 HKS_LOG_E("This param is absent, but it is necessary.");
2044 return HKS_ERROR_NOT_EXIST;
2045 }
2046 }
2047 return HKS_SUCCESS;
2048 }
2049
HksCheckOptionalParam(uint32_t tag,uint32_t alg,uint32_t purpose,bool isAbsent,struct HksParam * param)2050 int32_t HksCheckOptionalParam(uint32_t tag, uint32_t alg, uint32_t purpose, bool isAbsent, struct HksParam *param)
2051 {
2052 enum CheckKeyType checkType = HKS_CHECK_TYPE_GEN_KEY;
2053 if (((purpose & HKS_KEY_PURPOSE_DERIVE) != 0) || ((purpose & HKS_KEY_PURPOSE_MAC) != 0)) {
2054 if ((alg != HKS_ALG_AES) && (alg != HKS_ALG_DES) && (alg != HKS_ALG_3DES) &&
2055 (alg != HKS_ALG_HMAC) && (alg != HKS_ALG_CMAC) && (alg != HKS_ALG_SM3)) {
2056 HKS_LOG_E("check mac or derive, not aes alg, alg: %" LOG_PUBLIC "u", alg);
2057 return HKS_ERROR_INVALID_PURPOSE;
2058 }
2059 if (purpose == HKS_KEY_PURPOSE_DERIVE) {
2060 checkType = HKS_CHECK_TYPE_GEN_DERIVE_KEY;
2061 } else {
2062 checkType = HKS_CHECK_TYPE_GEN_MAC_KEY;
2063 }
2064 }
2065 struct ExpectParamsValues expectValues = EXPECT_PARAMS_VALUES_INIT;
2066 int32_t ret = GetExpectParams(alg, checkType, &expectValues);
2067 HKS_IF_NOT_SUCC_RETURN(ret, ret)
2068 switch (tag) {
2069 case HKS_TAG_BLOCK_MODE:
2070 ret = InitCheckOptionalParams(expectValues.mode.needCheck, isAbsent, param,
2071 expectValues.mode.values, expectValues.mode.valueCnt);
2072 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_MODE_FAIL,
2073 "check param fail:0x%" LOG_PUBLIC "x failed", HKS_TAG_BLOCK_MODE);
2074 break;
2075 case HKS_TAG_DIGEST:
2076 ret = InitCheckOptionalParams(expectValues.digest.needCheck, isAbsent, param,
2077 expectValues.digest.values, expectValues.digest.valueCnt);
2078 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_DIGEST_FAIL,
2079 "check param fail:0x%" LOG_PUBLIC "x failed", HKS_TAG_DIGEST);
2080 break;
2081 case HKS_TAG_PADDING:
2082 ret = InitCheckOptionalParams(expectValues.padding.needCheck, isAbsent, param,
2083 expectValues.padding.values, expectValues.padding.valueCnt);
2084 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_PADDING_FAIL,
2085 "check param fail:0x%" LOG_PUBLIC "x failed", HKS_TAG_PADDING);
2086 break;
2087 default:
2088 HKS_LOG_E("invalid tag: %" LOG_PUBLIC "u", tag);
2089 ret = HKS_FAILURE;
2090 }
2091 return ret;
2092 }
2093
HksCheckFixedParams(uint32_t alg,enum CheckKeyType checkType,const struct ParamsValues * inputParams)2094 int32_t HksCheckFixedParams(uint32_t alg, enum CheckKeyType checkType, const struct ParamsValues *inputParams)
2095 {
2096 struct ExpectParamsValues expectValues = EXPECT_PARAMS_VALUES_INIT;
2097 int32_t ret = GetExpectParams(alg, checkType, &expectValues);
2098 HKS_IF_NOT_SUCC_RETURN(ret, ret)
2099
2100 ret = CheckOptionalParams(expectValues.keyLen.needCheck, inputParams->keyLen.isAbsent, inputParams->keyLen.value,
2101 expectValues.keyLen.values, expectValues.keyLen.valueCnt);
2102 #ifdef HKS_SUPPORT_RSA_C_FLEX_KEYSIZE
2103 if ((ret != HKS_SUCCESS) && (alg == HKS_ALG_RSA)) {
2104 ret = CheckRsaKeySize(inputParams->keyLen.value);
2105 }
2106 #endif
2107 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_KEY_SIZE,
2108 "check keyLen not expected, len = %" LOG_PUBLIC "u", inputParams->keyLen.value);
2109 ret = CheckOptionalParams(expectValues.padding.needCheck, inputParams->padding.isAbsent, inputParams->padding.value,
2110 expectValues.padding.values, expectValues.padding.valueCnt);
2111 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_PADDING,
2112 "check padding not expected, padding = %" LOG_PUBLIC "u", inputParams->padding.value);
2113 ret = CheckOptionalParams(expectValues.purpose.needCheck, inputParams->purpose.isAbsent, inputParams->purpose.value,
2114 expectValues.purpose.values, expectValues.purpose.valueCnt);
2115 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_PURPOSE,
2116 "check purpose not expected, purpose = %" LOG_PUBLIC "u", inputParams->purpose.value);
2117 ret = CheckOptionalParams(expectValues.digest.needCheck, inputParams->digest.isAbsent, inputParams->digest.value,
2118 expectValues.digest.values, expectValues.digest.valueCnt);
2119 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_DIGEST,
2120 "check digest not expected, digest = %" LOG_PUBLIC "u", inputParams->digest.value);
2121 ret = CheckOptionalParams(expectValues.mode.needCheck, inputParams->mode.isAbsent, inputParams->mode.value,
2122 expectValues.mode.values, expectValues.mode.valueCnt);
2123 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_MODE,
2124 "check mode not expected, mode = %" LOG_PUBLIC "u", inputParams->mode.value);
2125 return ret;
2126 }
2127
2128 #ifndef _CUT_AUTHENTICATE_
HksCheckGenKeyMutableParams(uint32_t alg,const struct ParamsValues * inputParams)2129 int32_t HksCheckGenKeyMutableParams(uint32_t alg, const struct ParamsValues *inputParams)
2130 {
2131 int32_t ret = HKS_SUCCESS;
2132 switch (alg) {
2133 #ifdef HKS_SUPPORT_RSA_C
2134 case HKS_ALG_RSA:
2135 ret = CheckRsaGenKeyPadding(inputParams);
2136 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_PADDING,
2137 "Check padding not expected, padding = %" LOG_PUBLIC "u", inputParams->padding.value);
2138 break;
2139 #endif
2140 #ifdef HKS_SUPPORT_AES_C
2141 case HKS_ALG_AES:
2142 ret = CheckAesPadding(inputParams);
2143 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_PADDING,
2144 "Check padding not expected, padding = %" LOG_PUBLIC "u", inputParams->padding.value);
2145 break;
2146 #endif
2147 #ifdef HKS_SUPPORT_DES_C
2148 case HKS_ALG_DES:
2149 ret = CheckDesPadding(inputParams);
2150 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_PADDING,
2151 "Check padding not expected, padding = %" LOG_PUBLIC "u", inputParams->padding.value);
2152 break;
2153 #endif
2154 #ifdef HKS_SUPPORT_3DES_C
2155 case HKS_ALG_3DES:
2156 ret = Check3DesPadding(inputParams);
2157 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_PADDING,
2158 "Check padding not expected, padding = %" LOG_PUBLIC "u", inputParams->padding.value);
2159 break;
2160 #endif
2161 #ifdef HKS_SUPPORT_SM4_C
2162 case HKS_ALG_SM4:
2163 ret = CheckSm4Padding(inputParams);
2164 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_PADDING,
2165 "Check padding not expected, padding = %" LOG_PUBLIC "u", inputParams->padding.value);
2166 break;
2167 #endif
2168 default:
2169 /* other alg no need check padding */
2170 break;
2171 }
2172
2173 return ret;
2174 }
2175
CheckImportMutableParams(uint32_t alg,const struct ParamsValues * params)2176 int32_t CheckImportMutableParams(uint32_t alg, const struct ParamsValues *params)
2177 {
2178 if (((alg == HKS_ALG_DSA) || (alg == HKS_ALG_ED25519)) &&
2179 (params->purpose.value != HKS_KEY_PURPOSE_VERIFY)) {
2180 HKS_LOG_E("Import key check purpose failed.");
2181 return HKS_ERROR_INVALID_PURPOSE;
2182 }
2183
2184 if ((alg == HKS_ALG_SM2) &&
2185 ((params->purpose.value != HKS_KEY_PURPOSE_VERIFY) && (params->purpose.value != HKS_KEY_PURPOSE_ENCRYPT))) {
2186 HKS_LOG_E("Import key check purpose failed.");
2187 return HKS_ERROR_INVALID_PURPOSE;
2188 }
2189
2190 if ((alg == HKS_ALG_ECC) &&
2191 ((params->purpose.value != HKS_KEY_PURPOSE_VERIFY) && (params->purpose.value != HKS_KEY_PURPOSE_UNWRAP) &&
2192 (params->purpose.value != HKS_KEY_PURPOSE_AGREE))) {
2193 HKS_LOG_E("Import key check purpose failed.");
2194 return HKS_ERROR_INVALID_PURPOSE;
2195 }
2196
2197 if ((alg == HKS_ALG_RSA) &&
2198 ((params->purpose.value != HKS_KEY_PURPOSE_VERIFY) && (params->purpose.value != HKS_KEY_PURPOSE_ENCRYPT))) {
2199 HKS_LOG_E("Import key check purpose failed.");
2200 return HKS_ERROR_INVALID_PURPOSE;
2201 }
2202
2203 if (alg == HKS_ALG_RSA) {
2204 #ifdef HKS_SUPPORT_RSA_C
2205 if (params->padding.isAbsent) {
2206 return HKS_SUCCESS;
2207 }
2208 if (params->purpose.value == HKS_KEY_PURPOSE_ENCRYPT) {
2209 return HksCheckValue(params->padding.value, g_rsaCipherPadding, HKS_ARRAY_SIZE(g_rsaCipherPadding));
2210 } else if (params->purpose.value == HKS_KEY_PURPOSE_VERIFY) {
2211 return HksCheckValue(params->padding.value, g_rsaSignPadding, HKS_ARRAY_SIZE(g_rsaSignPadding));
2212 }
2213 #else
2214 return HKS_ERROR_NOT_SUPPORTED;
2215 #endif
2216 }
2217
2218 return HKS_SUCCESS;
2219 }
2220
HksCheckSignature(uint32_t cmdId,uint32_t alg,uint32_t keySize,const struct HksBlob * signature)2221 int32_t HksCheckSignature(uint32_t cmdId, uint32_t alg, uint32_t keySize, const struct HksBlob *signature)
2222 {
2223 (void)cmdId;
2224 (void)keySize;
2225 (void)signature;
2226 int32_t ret = HKS_ERROR_INVALID_ALGORITHM;
2227 switch (alg) {
2228 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY)
2229 case HKS_ALG_RSA:
2230 ret = HksCheckValue(keySize, g_rsaKeySize, HKS_ARRAY_SIZE(g_rsaKeySize));
2231 #ifdef HKS_SUPPORT_RSA_C_FLEX_KEYSIZE
2232 if (ret != HKS_SUCCESS) {
2233 ret = CheckRsaKeySize(keySize);
2234 }
2235 #endif
2236 HKS_IF_NOT_SUCC_LOGE_RETURN(ret,
2237 HKS_ERROR_INVALID_ARGUMENT, "check key size: key size value %" LOG_PUBLIC "u not expected", keySize)
2238 return CheckRsaSignature(cmdId, keySize, signature);
2239 #endif
2240 #if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_SIGN_VERIFY)
2241 case HKS_ALG_DSA:
2242 return HKS_SUCCESS;
2243 #endif
2244 #ifdef HKS_SUPPORT_ECC_C
2245 case HKS_ALG_ECC:
2246 HKS_IF_NOT_SUCC_LOGE_RETURN(HksCheckValue(keySize, g_eccKeySize, HKS_ARRAY_SIZE(g_eccKeySize)),
2247 HKS_ERROR_INVALID_ARGUMENT, "check key size: key size value %" LOG_PUBLIC "u not expected", keySize)
2248 return CheckEccSignature(cmdId, keySize, signature);
2249 #endif
2250 #ifdef HKS_SUPPORT_ED25519_C
2251 case HKS_ALG_ED25519:
2252 return CheckEd25519Signature(cmdId, signature);
2253 #endif
2254 #ifdef HKS_SUPPORT_SM2_C
2255 case HKS_ALG_SM2:
2256 HKS_IF_NOT_SUCC_LOGE_RETURN(HksCheckValue(keySize, g_sm2KeySize, HKS_ARRAY_SIZE(g_sm2KeySize)),
2257 HKS_ERROR_INVALID_ARGUMENT, "check key size: key size value %" LOG_PUBLIC "u not expected", keySize)
2258 return CheckEccSignature(cmdId, keySize, signature);
2259 #endif
2260 default:
2261 return ret;
2262 }
2263 }
2264
HksCheckSignVerifyMutableParams(uint32_t cmdId,uint32_t alg,const struct ParamsValues * inputParams)2265 int32_t HksCheckSignVerifyMutableParams(uint32_t cmdId, uint32_t alg, const struct ParamsValues *inputParams)
2266 {
2267 switch (cmdId) {
2268 case HKS_CMD_ID_SIGN:
2269 if ((inputParams->purpose.value & HKS_KEY_PURPOSE_SIGN) == 0) {
2270 return HKS_ERROR_INVALID_PURPOSE;
2271 }
2272 break;
2273 case HKS_CMD_ID_VERIFY:
2274 if ((inputParams->purpose.value & HKS_KEY_PURPOSE_VERIFY) == 0) {
2275 return HKS_ERROR_INVALID_PURPOSE;
2276 }
2277 break;
2278 default:
2279 return HKS_ERROR_INVALID_ARGUMENT;
2280 }
2281
2282 switch (alg) {
2283 #ifdef HKS_SUPPORT_RSA_C
2284 case HKS_ALG_RSA:
2285 HKS_IF_NOT_SUCC_RETURN(HksCheckValue(inputParams->padding.value, g_rsaSignPadding,
2286 HKS_ARRAY_SIZE(g_rsaSignPadding)), HKS_ERROR_INVALID_PADDING)
2287 break;
2288 #endif
2289 #ifdef HKS_SUPPORT_DSA_C
2290 case HKS_ALG_DSA:
2291 break;
2292 #endif
2293 #ifdef HKS_SUPPORT_ECC_C
2294 case HKS_ALG_ECC:
2295 break;
2296 #endif
2297 default:
2298 /* other alg no need check padding */
2299 break;
2300 }
2301 return HKS_SUCCESS;
2302 }
2303 #endif /* _CUT_AUTHENTICATE_ */
2304
2305 #if defined(HKS_SUPPORT_DES_C) || defined(HKS_SUPPORT_3DES_C)
HksCheckCipherMutableParamsByAlg(uint32_t alg,const struct ParamsValues * inputParams)2306 static int32_t HksCheckCipherMutableParamsByAlg(uint32_t alg, const struct ParamsValues *inputParams)
2307 {
2308 int32_t ret = HKS_ERROR_INVALID_PADDING;
2309 switch (alg) {
2310 #ifdef HKS_SUPPORT_DES_C
2311 case HKS_ALG_DES:
2312 ret = CheckDesPadding(inputParams);
2313 break;
2314 #endif
2315 #ifdef HKS_SUPPORT_3DES_C
2316 case HKS_ALG_3DES:
2317 ret = Check3DesPadding(inputParams);
2318 break;
2319 #endif
2320 default:
2321 return HKS_ERROR_INVALID_ALGORITHM;
2322 }
2323
2324 return ret;
2325 }
2326 #endif
2327
HksCheckCipherMutableParams(uint32_t cmdId,uint32_t alg,const struct ParamsValues * inputParams)2328 int32_t HksCheckCipherMutableParams(uint32_t cmdId, uint32_t alg, const struct ParamsValues *inputParams)
2329 {
2330 switch (cmdId) {
2331 case HKS_CMD_ID_ENCRYPT:
2332 if ((inputParams->purpose.value & HKS_KEY_PURPOSE_ENCRYPT) == 0) {
2333 return HKS_ERROR_INVALID_PURPOSE;
2334 }
2335 break;
2336 case HKS_CMD_ID_DECRYPT:
2337 if ((inputParams->purpose.value & HKS_KEY_PURPOSE_DECRYPT) == 0) {
2338 return HKS_ERROR_INVALID_PURPOSE;
2339 }
2340 break;
2341 default:
2342 return HKS_ERROR_INVALID_ARGUMENT;
2343 }
2344
2345 int32_t ret = HKS_ERROR_INVALID_PADDING;
2346 switch (alg) {
2347 #ifdef HKS_SUPPORT_RSA_C
2348 case HKS_ALG_RSA:
2349 ret = HksCheckValue(inputParams->padding.value, g_rsaCipherPadding, HKS_ARRAY_SIZE(g_rsaCipherPadding));
2350 break;
2351 #endif
2352 #ifdef HKS_SUPPORT_AES_C
2353 case HKS_ALG_AES:
2354 ret = CheckAesPadding(inputParams);
2355 break;
2356 #endif
2357 #ifdef HKS_SUPPORT_SM4_C
2358 case HKS_ALG_SM4:
2359 ret = CheckSm4Padding(inputParams);
2360 break;
2361 #endif
2362 #ifdef HKS_SUPPORT_SM2_C
2363 case HKS_ALG_SM2:
2364 ret = HksCheckValue(inputParams->padding.value, g_sm2CipherPadding, HKS_ARRAY_SIZE(g_sm2CipherPadding));
2365 break;
2366 #endif
2367 default:
2368 #if defined(HKS_SUPPORT_DES_C) || defined(HKS_SUPPORT_3DES_C)
2369 ret = HksCheckCipherMutableParamsByAlg(alg, inputParams);
2370 if (ret == HKS_ERROR_INVALID_ALGORITHM) {
2371 return HKS_ERROR_INVALID_ALGORITHM;
2372 }
2373 #endif
2374 break;
2375 }
2376 HKS_IF_NOT_SUCC_RETURN(ret, HKS_ERROR_INVALID_PADDING)
2377 return ret;
2378 }
2379
HksCheckCipherData(uint32_t cmdId,uint32_t alg,const struct ParamsValues * inputParams,const struct HksBlob * inData,const struct HksBlob * outData)2380 int32_t HksCheckCipherData(uint32_t cmdId, uint32_t alg, const struct ParamsValues *inputParams,
2381 const struct HksBlob *inData, const struct HksBlob *outData)
2382 {
2383 switch (alg) {
2384 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_CRYPT)
2385 case HKS_ALG_RSA:
2386 return CheckRsaCipherData(cmdId, inputParams, inData, outData);
2387 #endif
2388 #ifdef HKS_SUPPORT_AES_C
2389 case HKS_ALG_AES:
2390 return CheckBlockCipherData(cmdId, inputParams, inData, outData, HKS_ALG_AES);
2391 #endif
2392 #ifdef HKS_SUPPORT_DES_C
2393 case HKS_ALG_DES:
2394 return CheckBlockCipherData(cmdId, inputParams, inData, outData, HKS_ALG_DES);
2395 #endif
2396 #ifdef HKS_SUPPORT_3DES_C
2397 case HKS_ALG_3DES:
2398 return CheckBlockCipherData(cmdId, inputParams, inData, outData, HKS_ALG_3DES);
2399 #endif
2400 #ifdef HKS_SUPPORT_SM4_C
2401 case HKS_ALG_SM4:
2402 return CheckBlockCipherData(cmdId, inputParams, inData, outData, HKS_ALG_SM4);
2403 #endif
2404 #ifdef HKS_SUPPORT_SM2_C
2405 case HKS_ALG_SM2:
2406 return HKS_SUCCESS;
2407 #endif
2408 default:
2409 return HKS_ERROR_INVALID_ALGORITHM;
2410 }
2411 }
2412
HksCheckCipherMaterialParams(uint32_t alg,const struct ParamsValues * inputParams,const struct HksParamSet * paramSet)2413 int32_t HksCheckCipherMaterialParams(uint32_t alg, const struct ParamsValues *inputParams,
2414 const struct HksParamSet *paramSet)
2415 {
2416 #ifdef HKS_SUPPORT_AES_C
2417 if (alg == HKS_ALG_AES) {
2418 uint32_t mode = inputParams->mode.value;
2419 if (mode == HKS_MODE_CBC) {
2420 return CheckBlockCipherIvMaterial(paramSet);
2421 } else if ((mode == HKS_MODE_CCM) || (mode == HKS_MODE_GCM)) {
2422 return CheckCipherAeMaterial(mode, paramSet);
2423 }
2424 }
2425 #endif
2426 #ifdef HKS_SUPPORT_DES_C
2427 if (alg == HKS_ALG_DES) {
2428 uint32_t mode = inputParams->mode.value;
2429 if (mode == HKS_MODE_CBC) {
2430 return CheckBlockCipherIvMaterial(paramSet);
2431 }
2432 }
2433 #endif
2434 #ifdef HKS_SUPPORT_3DES_C
2435 if (alg == HKS_ALG_3DES) {
2436 uint32_t mode = inputParams->mode.value;
2437 if (mode == HKS_MODE_CBC) {
2438 return CheckBlockCipherIvMaterial(paramSet);
2439 }
2440 }
2441 #endif
2442 #ifdef HKS_SUPPORT_SM4_C
2443 if (alg == HKS_ALG_SM4) {
2444 uint32_t mode = inputParams->mode.value;
2445 if (mode == HKS_MODE_CBC || mode == HKS_MODE_CTR || mode == HKS_MODE_CFB || mode == HKS_MODE_OFB) {
2446 return CheckBlockCipherIvMaterial(paramSet);
2447 }
2448 }
2449 #endif
2450 return HKS_SUCCESS;
2451 }
2452
2453 #ifdef HKS_SUPPORT_USER_AUTH_ACCESS_CONTROL
HasValidAuthAccessType(const struct ExpectParams allowAuthAccessTypes,uint32_t authAccessType,uint32_t * matchType)2454 static int32_t HasValidAuthAccessType(const struct ExpectParams allowAuthAccessTypes,
2455 uint32_t authAccessType, uint32_t *matchType)
2456 {
2457 for (uint32_t i = 0; i < allowAuthAccessTypes.valueCnt; i++) {
2458 if ((authAccessType & allowAuthAccessTypes.values[i]) != 0) {
2459 *matchType = allowAuthAccessTypes.values[i];
2460 return HKS_SUCCESS;
2461 }
2462 }
2463 return HKS_ERROR_INVALID_ARGUMENT;
2464 }
2465
HksCheckAuthAccessTypeByUserAuthType(uint32_t userAuthType,uint32_t authAccessType)2466 static int32_t HksCheckAuthAccessTypeByUserAuthType(uint32_t userAuthType, uint32_t authAccessType)
2467 {
2468 uint32_t valuesCnt = HKS_ARRAY_SIZE(g_expectAuthAccessParams);
2469 uint32_t validAuthAccessType = 0;
2470 uint32_t tempType = 0;
2471 for (uint32_t i = 0; i < valuesCnt; i++) {
2472 struct AuthAccessTypeChecker checker = g_expectAuthAccessParams[i];
2473 if ((checker.userAuthType & userAuthType) != 0 &&
2474 HasValidAuthAccessType(checker.allowAuthAccessTypes, authAccessType, &tempType) == HKS_SUCCESS) {
2475 validAuthAccessType |= tempType;
2476 }
2477 }
2478 if ((authAccessType != 0) && (authAccessType == validAuthAccessType)) {
2479 if ((authAccessType & HKS_AUTH_ACCESS_ALWAYS_VALID) != 0
2480 && (authAccessType &(~HKS_AUTH_ACCESS_ALWAYS_VALID)) != 0) {
2481 HKS_LOG_E("auth access type is invalid: ALWAYS_VALID cannot coexist with other type");
2482 return HKS_ERROR_INVALID_ACCESS_TYPE;
2483 }
2484 return HKS_SUCCESS;
2485 }
2486 HKS_LOG_E("authAccessType %" LOG_PUBLIC "u is not equal to validAuthAccessType %" LOG_PUBLIC "u or is 0",
2487 authAccessType, validAuthAccessType);
2488 return HKS_ERROR_INVALID_ACCESS_TYPE;
2489 }
2490 #endif
2491
HksCheckUserAuthParams(uint32_t userAuthType,uint32_t authAccessType,uint32_t challengeType)2492 int32_t HksCheckUserAuthParams(uint32_t userAuthType, uint32_t authAccessType, uint32_t challengeType)
2493 {
2494 #ifdef HKS_SUPPORT_USER_AUTH_ACCESS_CONTROL
2495 int32_t ret = HksCheckValue(userAuthType, g_supportUserAuthTypes, HKS_ARRAY_SIZE(g_supportUserAuthTypes));
2496 HKS_IF_NOT_SUCC_RETURN(ret, HKS_ERROR_INVALID_AUTH_TYPE)
2497
2498 ret = HksCheckValue(challengeType, g_userAuthChallengeType, HKS_ARRAY_SIZE(g_userAuthChallengeType));
2499 HKS_IF_NOT_SUCC_RETURN(ret, HKS_ERROR_INVALID_CHALLENGE_TYPE)
2500
2501 return HksCheckAuthAccessTypeByUserAuthType(userAuthType, authAccessType);
2502 #else
2503 (void)userAuthType;
2504 (void)authAccessType;
2505 (void)challengeType;
2506 return HKS_SUCCESS;
2507 #endif
2508 }
2509
HksCheckSecureSignParams(uint32_t secureSignType)2510 int32_t HksCheckSecureSignParams(uint32_t secureSignType)
2511 {
2512 #ifdef HKS_SUPPORT_USER_AUTH_ACCESS_CONTROL
2513 return HksCheckValue(secureSignType, g_supportSecureSignType, HKS_ARRAY_SIZE(g_supportSecureSignType));
2514 #else
2515 (void)secureSignType;
2516 return HKS_SUCCESS;
2517 #endif
2518 }
2519
2520 /* If the algorithm is ed25519, the plaintext is directly cached, and if the digest is HKS_DIGEST_NONE, the
2521 hash value has been passed in by the user. So the hash value does not need to be free.
2522 */
HksCheckNeedCache(uint32_t alg,uint32_t digest)2523 int32_t HksCheckNeedCache(uint32_t alg, uint32_t digest)
2524 {
2525 if ((alg == HKS_ALG_ED25519) || (digest == HKS_DIGEST_NONE)) {
2526 HKS_LOG_I("need to cache the data");
2527 return HKS_SUCCESS;
2528 }
2529 return HKS_FAILURE;
2530 }
2531
2532 #ifdef HKS_SUPPORT_USER_AUTH_ACCESS_CONTROL
CheckUserAuthKeyInfoValidity(const struct HksParamSet * paramSet,const struct KeyInfoParams * params,uint32_t paramsCnt)2533 static int32_t CheckUserAuthKeyInfoValidity(const struct HksParamSet *paramSet,
2534 const struct KeyInfoParams *params, uint32_t paramsCnt)
2535 {
2536 for (uint32_t i = 0; i < paramsCnt; i++) {
2537 if (params[i].needCheck) {
2538 struct HksParam *param = NULL;
2539 int32_t ret = HksGetParam(paramSet, params[i].tag, ¶m);
2540 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_SUCCESS, "tag is empty and no need to check!")
2541
2542 ret = HksCheckValue(param->uint32Param, params[i].values, params[i].valueCnt);
2543 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "not support tag %" LOG_PUBLIC "u and value is %" LOG_PUBLIC "u",
2544 params[i].tag, param->uint32Param)
2545 }
2546 }
2547 return HKS_SUCCESS;
2548 }
2549 #endif
2550
HksCheckUserAuthKeyInfoValidity(const struct HksParamSet * paramSet)2551 int32_t HksCheckUserAuthKeyInfoValidity(const struct HksParamSet *paramSet)
2552 {
2553 #ifdef HKS_SUPPORT_USER_AUTH_ACCESS_CONTROL
2554 HKS_IF_NOT_SUCC_LOGE_RETURN(HksCheckParamSet(paramSet, paramSet->paramSetSize),
2555 HKS_ERROR_INVALID_ARGUMENT, "invalid paramSet!")
2556
2557 struct HksParam *algParam = NULL;
2558 int32_t ret = HksGetParam(paramSet, HKS_TAG_ALGORITHM, &algParam);
2559 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get alg param failed!")
2560
2561 for (uint32_t i = 0; i < HKS_ARRAY_SIZE(g_validKeyInfo); i++) {
2562 if (algParam->uint32Param == g_validKeyInfo[i].keyAlg) {
2563 ret = CheckUserAuthKeyInfoValidity(paramSet, g_validKeyInfo[i].params, g_validKeyInfo[i].paramsCnt);
2564 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_NOT_SUPPORTED, "not support set key auth purpose!")
2565 }
2566 }
2567 HKS_LOG_I("support set key auth purpose!");
2568 return ret;
2569 #else
2570 (void)paramSet;
2571 return HKS_SUCCESS;
2572 #endif
2573 }