1 /*
2 * Copyright (c) 2021-2022 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 #ifdef _CUT_AUTHENTICATE_
30 #undef HKS_SUPPORT_RSA_C
31 #undef HKS_SUPPORT_ECC_C
32 #undef HKS_SUPPORT_ECDH_C
33 #undef HKS_SUPPORT_X25519_C
34 #undef HKS_SUPPORT_ED25519_C
35 #endif
36
37 #define HKS_BLOCK_CIPHER_CBC_IV_LEN 16
38 #define HKS_AES_CCM_AAD_LEN_MIN 4
39 #define HKS_AES_CCM_NONCE_LEN_MIN 7
40 #define HKS_AES_CCM_NONCE_LEN_MAX 13
41 #define HKS_AES_GCM_NONCE_LEN_MIN 12
42
43 #define HKS_RSA_OAEP_DIGEST_NUM 2
44 #define HKS_BLOCK_CIPHER_CBC_BLOCK_SIZE 16
45
46 #define HKS_ECC_SIGN_MAX_TL_SIZE 8
47
48 #ifdef HKS_SUPPORT_RSA_C
49 static const uint32_t g_rsaKeySize[] = {
50 HKS_RSA_KEY_SIZE_512,
51 HKS_RSA_KEY_SIZE_768,
52 HKS_RSA_KEY_SIZE_1024,
53 HKS_RSA_KEY_SIZE_2048,
54 HKS_RSA_KEY_SIZE_3072,
55 HKS_RSA_KEY_SIZE_4096
56 };
57 static const uint32_t g_rsaPadding[] = {
58 HKS_PADDING_NONE,
59 HKS_PADDING_OAEP,
60 HKS_PADDING_PSS,
61 HKS_PADDING_PKCS1_V1_5
62 };
63 static const uint32_t g_rsaDigest[] = {
64 HKS_DIGEST_MD5,
65 HKS_DIGEST_NONE,
66 HKS_DIGEST_SHA1,
67 HKS_DIGEST_SHA224,
68 HKS_DIGEST_SHA256,
69 HKS_DIGEST_SHA384,
70 HKS_DIGEST_SHA512
71 };
72 static const uint32_t g_rsaSignPadding[] = {
73 HKS_PADDING_PSS,
74 HKS_PADDING_PKCS1_V1_5
75 };
76 static const uint32_t g_rsaCipherPadding[] = {
77 HKS_PADDING_NONE,
78 HKS_PADDING_OAEP,
79 HKS_PADDING_PKCS1_V1_5
80 };
81 #endif
82
83 #ifdef HKS_SUPPORT_AES_C
84 static const uint32_t g_aesKeySize[] = {
85 HKS_AES_KEY_SIZE_128,
86 HKS_AES_KEY_SIZE_192,
87 HKS_AES_KEY_SIZE_256
88 };
89 static const uint32_t g_aesMacKeySize[] = {
90 HKS_AES_KEY_SIZE_256,
91 };
92 static const uint32_t g_aesPadding[] = {
93 HKS_PADDING_NONE,
94 HKS_PADDING_PKCS7
95 };
96 static const uint32_t g_aesMode[] = {
97 HKS_MODE_CBC,
98 HKS_MODE_CCM,
99 HKS_MODE_CTR,
100 HKS_MODE_ECB,
101 HKS_MODE_GCM
102 };
103 static const uint32_t g_aesCbcPadding[] = {
104 HKS_PADDING_NONE,
105 HKS_PADDING_PKCS7
106 };
107 static const uint32_t g_aesAeadPadding[] = {
108 HKS_PADDING_NONE
109 };
110 static const uint32_t g_aesCtrPadding[] = {
111 HKS_PADDING_NONE
112 };
113 static const uint32_t g_aesEcbPadding[] = {
114 HKS_PADDING_NONE,
115 HKS_PADDING_PKCS7
116 };
117 #endif
118
119 #ifdef HKS_SUPPORT_SM4_C
120 static const uint32_t g_sm4KeySize[] = {
121 HKS_SM4_KEY_SIZE_128,
122 };
123 static const uint32_t g_sm4Padding[] = {
124 HKS_PADDING_NONE,
125 HKS_PADDING_PKCS7
126 };
127 static const uint32_t g_sm4Purpose[] = {
128 HKS_KEY_PURPOSE_ENCRYPT,
129 HKS_KEY_PURPOSE_DECRYPT,
130 HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
131 };
132 static const uint32_t g_sm4Mode[] = {
133 HKS_MODE_CBC,
134 HKS_MODE_CTR,
135 HKS_MODE_ECB
136 };
137 static const uint32_t g_sm4CbcPadding[] = {
138 HKS_PADDING_NONE,
139 HKS_PADDING_PKCS7
140 };
141 static const uint32_t g_sm4CtrPadding[] = {
142 HKS_PADDING_NONE
143 };
144 static const uint32_t g_sm4EcbPadding[] = {
145 HKS_PADDING_NONE,
146 HKS_PADDING_PKCS7
147 };
148 #endif
149
150 #ifdef HKS_SUPPORT_ECC_C
151 static const uint32_t g_eccKeySize[] = {
152 HKS_ECC_KEY_SIZE_224,
153 HKS_ECC_KEY_SIZE_256,
154 HKS_ECC_KEY_SIZE_384,
155 HKS_ECC_KEY_SIZE_521
156 };
157
158 static const uint32_t g_eccDigest[] = {
159 HKS_DIGEST_NONE,
160 HKS_DIGEST_SHA1,
161 HKS_DIGEST_SHA224,
162 HKS_DIGEST_SHA256,
163 HKS_DIGEST_SHA384,
164 HKS_DIGEST_SHA512
165 };
166 #endif
167
168 #ifdef HKS_SUPPORT_SM2_C
169 static const uint32_t g_sm2KeySize[] = {
170 HKS_SM2_KEY_SIZE_256
171 };
172
173 static const uint32_t g_sm2Digest[] = {
174 HKS_DIGEST_SM3,
175 HKS_DIGEST_NONE
176 };
177 #endif
178
179 #ifdef HKS_SUPPORT_SM3_C
180 static const uint32_t g_sm3Digest[] = {
181 HKS_DIGEST_SM3
182 };
183 #endif
184
185 static const uint32_t g_digest[] = {
186 HKS_DIGEST_SHA256,
187 HKS_DIGEST_SHA384,
188 HKS_DIGEST_SHA512
189 };
190
191 static const uint32_t g_macDigest[] = {
192 HKS_DIGEST_SHA256
193 };
194
195 #ifdef HKS_SUPPORT_ECDH_C
196 static const uint32_t g_ecdhKeySize[] = {
197 HKS_ECC_KEY_SIZE_224,
198 HKS_ECC_KEY_SIZE_256,
199 HKS_ECC_KEY_SIZE_384,
200 HKS_ECC_KEY_SIZE_521
201 };
202 #endif
203
204 #if defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_ED25519_C)
205 static const uint32_t g_curve25519KeySize[] = {
206 HKS_CURVE25519_KEY_SIZE_256,
207 };
208 #endif
209 #ifdef HKS_SUPPORT_HMAC_C
210 static const uint32_t g_hmacDigest[] = {
211 HKS_DIGEST_SHA1,
212 HKS_DIGEST_SHA224,
213 HKS_DIGEST_SHA256,
214 HKS_DIGEST_SHA384,
215 HKS_DIGEST_SHA512,
216 HKS_DIGEST_SM3
217 };
218 #endif
219 #ifdef HKS_SUPPORT_DSA_C
220 static const uint32_t g_dsaDigest[] = {
221 HKS_DIGEST_NONE,
222 HKS_DIGEST_SHA1,
223 HKS_DIGEST_SHA224,
224 HKS_DIGEST_SHA256,
225 HKS_DIGEST_SHA384,
226 HKS_DIGEST_SHA512
227 };
228 #endif
229 #ifdef HKS_SUPPORT_DH_C
230 static const uint32_t g_dhKeySize[] = {
231 HKS_DH_KEY_SIZE_2048,
232 HKS_DH_KEY_SIZE_3072,
233 HKS_DH_KEY_SIZE_4096
234 };
235 #endif
236
237 #ifdef HKS_SUPPORT_RSA_C
238 static const struct ParamsValuesChecker g_rsaParamSet[] = {
239 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { true, 0, false}, { true, 0, false}, { true, 0, false},
240 { false, 0, false} } },
241 { HKS_CHECK_TYPE_USE_KEY, { { true, 0, false}, { true, 0, false}, { true, 0, false}, { true, 0, false},
242 { false, 0, false} } }
243 };
244 static const struct ExpectParamsValuesChecker g_expectRsaParams[] = {
245 { HKS_CHECK_TYPE_GEN_KEY, {
246 { true, g_rsaKeySize, HKS_ARRAY_SIZE(g_rsaKeySize) },
247 { true, g_rsaPadding, HKS_ARRAY_SIZE(g_rsaPadding) },
248 { false, NULL, 0 },
249 { true, g_rsaDigest, HKS_ARRAY_SIZE(g_rsaDigest) },
250 { false, NULL, 0 }
251 }
252 },
253 { HKS_CHECK_TYPE_USE_KEY, {
254 { true, g_rsaKeySize, HKS_ARRAY_SIZE(g_rsaKeySize) },
255 { true, g_rsaPadding, HKS_ARRAY_SIZE(g_rsaPadding) },
256 { false, NULL, 0 },
257 { true, g_rsaDigest, HKS_ARRAY_SIZE(g_rsaDigest) },
258 { false, NULL, 0 }
259 }
260 }
261 };
262 #endif
263
264 #ifdef HKS_SUPPORT_AES_C
265 static const struct ParamsValuesChecker g_aesParamSet[] = {
266 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { true, 0, false}, { true, 0, false}, { false, 0, false},
267 { true, 0, false} } },
268 { HKS_CHECK_TYPE_USE_KEY, { { false, 0, false}, { true, 0, false}, { true, 0, false}, { false, 0, false},
269 { true, 0, false} } },
270 { HKS_CHECK_TYPE_GEN_MAC_KEY, { { true, 0, false}, { false, 0, false}, { false, 0, false}, { true, 0, false},
271 { false, 0, false} } },
272 { HKS_CHECK_TYPE_GEN_DERIVE_KEY, { { true, 0, false}, { false, 0, false}, { false, 0, false}, { true, 0, false},
273 { false, 0, false} } }
274 };
275
276 static const struct ExpectParamsValuesChecker g_expectAesParams[] = {
277 { HKS_CHECK_TYPE_GEN_KEY, {
278 { true, g_aesKeySize, HKS_ARRAY_SIZE(g_aesKeySize) },
279 { true, g_aesPadding, HKS_ARRAY_SIZE(g_aesPadding) },
280 { false, NULL, 0 },
281 { false, NULL, 0 },
282 { true, g_aesMode, HKS_ARRAY_SIZE(g_aesMode) }
283 }
284 },
285 { HKS_CHECK_TYPE_USE_KEY, {
286 { false, NULL, 0 },
287 { true, g_aesPadding, HKS_ARRAY_SIZE(g_aesPadding) },
288 { false, NULL, 0 },
289 { false, NULL, 0 },
290 { true, g_aesMode, HKS_ARRAY_SIZE(g_aesMode) }
291 }
292 },
293 { HKS_CHECK_TYPE_GEN_MAC_KEY, {
294 { true, g_aesMacKeySize, HKS_ARRAY_SIZE(g_aesMacKeySize) },
295 { false, NULL, 0 },
296 { false, NULL, 0 },
297 { true, g_macDigest, HKS_ARRAY_SIZE(g_macDigest) },
298 { false, NULL, 0 }
299 }
300 },
301 { HKS_CHECK_TYPE_GEN_DERIVE_KEY, {
302 { true, g_aesKeySize, HKS_ARRAY_SIZE(g_aesKeySize) },
303 { false, NULL, 0 },
304 { false, NULL, 0 },
305 { true, g_digest, HKS_ARRAY_SIZE(g_digest) },
306 { false, NULL, 0 }
307 }
308 }
309 };
310 #endif
311
312 #ifdef HKS_SUPPORT_ECC_C
313 static const struct ParamsValuesChecker g_eccParamSet[] = {
314 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
315 { false, 0, false} } },
316 { HKS_CHECK_TYPE_USE_KEY, { { false, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
317 { false, 0, false} } }
318 };
319 static const struct ExpectParamsValuesChecker g_expectEccParams[] = {
320 { HKS_CHECK_TYPE_GEN_KEY, {
321 { true, g_eccKeySize, HKS_ARRAY_SIZE(g_eccKeySize) },
322 { false, NULL, 0 },
323 { false, NULL, 0 },
324 { true, g_eccDigest, HKS_ARRAY_SIZE(g_eccDigest) },
325 { false, NULL, 0 }
326 }
327 },
328 { HKS_CHECK_TYPE_USE_KEY, {
329 { false, NULL, 0 },
330 { false, NULL, 0 },
331 { false, NULL, 0 },
332 { true, g_eccDigest, HKS_ARRAY_SIZE(g_eccDigest) },
333 { false, NULL, 0 }
334 }
335 }
336 };
337 #endif
338
339 #ifdef HKS_SUPPORT_SM2_C
340 static const struct ParamsValuesChecker g_sm2ParamSet[] = {
341 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
342 { false, 0, false} } },
343 { HKS_CHECK_TYPE_USE_KEY, { { false, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
344 { false, 0, false} } }
345 };
346 static const struct ExpectParamsValuesChecker g_expectSm2Params[] = {
347 { HKS_CHECK_TYPE_GEN_KEY, {
348 { true, g_sm2KeySize, HKS_ARRAY_SIZE(g_sm2KeySize) },
349 { false, NULL, 0 },
350 { false, NULL, 0 },
351 { true, g_sm2Digest, HKS_ARRAY_SIZE(g_sm2Digest) },
352 { false, NULL, 0 }
353 }
354 },
355 { HKS_CHECK_TYPE_USE_KEY, {
356 { false, NULL, 0 },
357 { false, NULL, 0 },
358 { false, NULL, 0 },
359 { true, g_sm2Digest, HKS_ARRAY_SIZE(g_sm2Digest) },
360 { false, NULL, 0 }
361 }
362 }
363 };
364 #endif
365
366 #ifdef HKS_SUPPORT_SM3_C
367 static const struct ParamsValuesChecker g_sm3ParamSet[] = {
368 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
369 { false, 0, false} } },
370 { HKS_CHECK_TYPE_GEN_MAC_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
371 { false, 0, false} } }
372 };
373 static const struct ExpectParamsValuesChecker g_expectSm3Params[] = {
374 { HKS_CHECK_TYPE_GEN_KEY, {
375 { false, NULL, 0 },
376 { false, NULL, 0 },
377 { false, NULL, 0 },
378 { true, g_sm3Digest, sizeof(g_sm3Digest) / sizeof(g_sm3Digest[0]) },
379 { false, NULL, 0 }
380 }
381 },
382 { HKS_CHECK_TYPE_GEN_MAC_KEY, {
383 { false, NULL, 0 },
384 { false, NULL, 0 },
385 { false, NULL, 0 },
386 { true, g_sm3Digest, sizeof(g_sm3Digest) / sizeof(g_sm3Digest[0]) },
387 { false, NULL, 0 }
388 }
389 }
390 };
391 #endif
392
393 #ifdef HKS_SUPPORT_SM4_C
394 static const struct ParamsValuesChecker g_sm4ParamSet[] = {
395 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { true, 0, false}, { true, 0, false}, { false, 0, false},
396 { true, 0, false} } },
397 { HKS_CHECK_TYPE_USE_KEY, { { true, 0, false}, { true, 0, false}, { true, 0, false}, { false, 0, false},
398 { true, 0, false} } }
399 };
400 static const struct ExpectParamsValuesChecker g_expectSm4Params[] = {
401 { HKS_CHECK_TYPE_GEN_KEY, {
402 { true, g_sm4KeySize, HKS_ARRAY_SIZE(g_sm4KeySize) },
403 { true, g_sm4Padding, HKS_ARRAY_SIZE(g_sm4Padding) },
404 { true, g_sm4Purpose, HKS_ARRAY_SIZE(g_sm4Purpose) },
405 { false, NULL, 0 },
406 { true, g_sm4Mode, HKS_ARRAY_SIZE(g_sm4Mode) }
407 }
408 },
409 { HKS_CHECK_TYPE_USE_KEY, {
410 { true, g_sm4KeySize, HKS_ARRAY_SIZE(g_sm4KeySize) },
411 { true, g_sm4Padding, HKS_ARRAY_SIZE(g_sm4Padding) },
412 { true, g_sm4Purpose, HKS_ARRAY_SIZE(g_sm4Purpose) },
413 { false, NULL, 0 },
414 { true, g_sm4Mode, HKS_ARRAY_SIZE(g_sm4Mode) }
415 }
416 }
417 };
418 #endif
419
420 #if defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_ED25519_C)
421 static const struct ParamsValuesChecker g_curve25519ParamSet[] = {
422 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { false, 0, false},
423 { false, 0, false} } },
424 { HKS_CHECK_TYPE_USE_KEY, { { false, 0, false}, { false, 0, false}, { true, 0, false}, { false, 0, false},
425 { false, 0, false} } }
426 };
427 static const struct ExpectParamsValuesChecker g_expectCurve25519Params[] = {
428 { HKS_CHECK_TYPE_GEN_KEY, {
429 { true, g_curve25519KeySize, sizeof(g_curve25519KeySize) / sizeof(g_curve25519KeySize[0]) },
430 { false, NULL, 0 },
431 { false, NULL, 0 },
432 { false, NULL, 0 },
433 { false, NULL, 0 }
434 }
435 },
436 { HKS_CHECK_TYPE_USE_KEY, {
437 { false, NULL, 0 },
438 { false, NULL, 0 },
439 { false, NULL, 0 },
440 { false, NULL, 0 },
441 { false, NULL, 0 }
442 }
443 }
444 };
445 #endif
446
447 #ifdef HKS_SUPPORT_HMAC_C
448 static const struct ParamsValuesChecker g_hmacParamSet[] = {
449 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
450 { false, 0, false} } },
451 { HKS_CHECK_TYPE_USE_KEY, { { false, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
452 { false, 0, false} } },
453 { HKS_CHECK_TYPE_GEN_MAC_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
454 { false, 0, false} } }
455 };
456 static const struct ExpectParamsValuesChecker g_expectHmacParams[] = {
457 { HKS_CHECK_TYPE_GEN_KEY, {
458 { false, NULL, 0 },
459 { false, NULL, 0 },
460 { false, NULL, 0 },
461 { true, g_hmacDigest, sizeof(g_hmacDigest) / sizeof(g_hmacDigest[0]) },
462 { false, NULL, 0 }
463 }
464 },
465 { HKS_CHECK_TYPE_USE_KEY, {
466 { false, NULL, 0 },
467 { false, NULL, 0 },
468 { false, NULL, 0 },
469 { true, g_hmacDigest, sizeof(g_hmacDigest) / sizeof(g_hmacDigest[0]) },
470 { false, NULL, 0 }
471 }
472 },
473 { HKS_CHECK_TYPE_GEN_MAC_KEY, {
474 { false, NULL, 0 },
475 { false, NULL, 0 },
476 { false, NULL, 0 },
477 { true, g_hmacDigest, sizeof(g_hmacDigest) / sizeof(g_hmacDigest[0]) },
478 { false, NULL, 0 }
479 }
480 }
481 };
482 #endif
483
484 #ifdef HKS_SUPPORT_DSA_C
485 static const struct ParamsValuesChecker g_dsaParamSet[] = {
486 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
487 { false, 0, false} } },
488 { HKS_CHECK_TYPE_USE_KEY, { { false, 0, false}, { false, 0, false}, { true, 0, false}, { true, 0, false},
489 { false, 0, false} } }
490 };
491 static const struct ExpectParamsValuesChecker g_expectDsaParams[] = {
492 { HKS_CHECK_TYPE_GEN_KEY, {
493 { false, NULL, 0 },
494 { false, NULL, 0 },
495 { false, NULL, 0 },
496 { true, g_dsaDigest, sizeof(g_dsaDigest) / sizeof(g_dsaDigest[0]) },
497 { false, NULL, 0 }
498 }
499 },
500 { HKS_CHECK_TYPE_USE_KEY, {
501 { false, NULL, 0 },
502 { false, NULL, 0 },
503 { false, NULL, 0 },
504 { true, g_dsaDigest, sizeof(g_dsaDigest) / sizeof(g_dsaDigest[0]) },
505 { false, NULL, 0 }
506 }
507 }
508 };
509 #endif
510
511 #ifdef HKS_SUPPORT_DH_C
512 static const struct ParamsValuesChecker g_dhParamSet[] = {
513 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { false, 0, false},
514 { false, 0, false} } },
515 { HKS_CHECK_TYPE_USE_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { false, 0, false},
516 { false, 0, false} } }
517 };
518 static const struct ExpectParamsValuesChecker g_expectDhParams[] = {
519 { HKS_CHECK_TYPE_GEN_KEY, {
520 { true, g_dhKeySize, sizeof(g_dhKeySize) / sizeof(g_dhKeySize[0]) },
521 { false, NULL, 0 },
522 { false, NULL, 0 },
523 { false, NULL, 0 },
524 { false, NULL, 0 }
525 }
526 },
527 { HKS_CHECK_TYPE_USE_KEY, {
528 { true, g_dhKeySize, sizeof(g_dhKeySize) / sizeof(g_dhKeySize[0]) },
529 { false, NULL, 0 },
530 { false, NULL, 0 },
531 { false, NULL, 0 },
532 { false, NULL, 0 }
533 }
534 }
535 };
536 #endif
537
538 #ifdef HKS_SUPPORT_ECDH_C
539 static const struct ParamsValuesChecker g_ecdhParamSet[] = {
540 { HKS_CHECK_TYPE_GEN_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { false, 0, false},
541 { false, 0, false} } },
542 { HKS_CHECK_TYPE_USE_KEY, { { true, 0, false}, { false, 0, false}, { true, 0, false}, { false, 0, false},
543 { false, 0, false} } }
544 };
545 static const struct ExpectParamsValuesChecker g_expectEcdhParams[] = {
546 { HKS_CHECK_TYPE_GEN_KEY, {
547 { true, g_ecdhKeySize, sizeof(g_ecdhKeySize) / sizeof(g_ecdhKeySize[0]) },
548 { false, NULL, 0 },
549 { false, NULL, 0 },
550 { false, NULL, 0 },
551 { false, NULL, 0 }
552 }
553 },
554 { HKS_CHECK_TYPE_USE_KEY, {
555 { true, g_ecdhKeySize, sizeof(g_ecdhKeySize) / sizeof(g_ecdhKeySize[0]) },
556 { false, NULL, 0 },
557 { false, NULL, 0 },
558 { false, NULL, 0 },
559 { false, NULL, 0 }
560 }
561 }
562 };
563 #endif
564
565 #ifndef _CUT_AUTHENTICATE_
566 static const uint32_t g_invalidPurpose[][2] = {
567 #ifdef HKS_SUPPORT_RSA_C
568 {
569 HKS_ALG_RSA,
570 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP |
571 HKS_KEY_PURPOSE_AGREE,
572 },
573 #endif
574 #ifdef HKS_SUPPORT_ECC_C
575 {
576 HKS_ALG_ECC,
577 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP |
578 HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
579 },
580 #endif
581 #ifdef HKS_SUPPORT_SM2_C
582 {
583 HKS_ALG_SM2,
584 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP |
585 HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
586 },
587 #endif
588 #ifdef HKS_SUPPORT_SM3_C
589 {
590 HKS_ALG_SM3,
591 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_WRAP |
592 HKS_KEY_PURPOSE_UNWRAP | HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_AGREE,
593 },
594 #endif
595 #ifdef HKS_SUPPORT_SM4_C
596 {
597 HKS_ALG_SM4,
598 HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_WRAP |
599 HKS_KEY_PURPOSE_UNWRAP | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_AGREE,
600 },
601 #endif
602 #ifdef HKS_SUPPORT_AES_C
603 {
604 HKS_ALG_AES,
605 HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_AGREE | HKS_KEY_PURPOSE_WRAP |
606 HKS_KEY_PURPOSE_UNWRAP,
607 },
608 #endif
609 #ifdef HKS_SUPPORT_ED25519_C
610 {
611 HKS_ALG_ED25519,
612 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP |
613 HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
614 },
615 #endif
616 #ifdef HKS_SUPPORT_X25519_C
617 {
618 HKS_ALG_X25519,
619 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT |
620 HKS_KEY_PURPOSE_WRAP,
621 },
622 #endif
623 #ifdef HKS_SUPPORT_HMAC_C
624 {
625 HKS_ALG_HMAC,
626 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_WRAP |
627 HKS_KEY_PURPOSE_UNWRAP | HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_AGREE,
628 },
629 #endif
630 #ifdef HKS_SUPPORT_DSA_C
631 {
632 HKS_ALG_DSA,
633 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP |
634 HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_AGREE,
635 },
636 #endif
637 #ifdef HKS_SUPPORT_DH_C
638 {
639 HKS_ALG_DH,
640 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP |
641 HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
642 },
643 #endif
644 #ifdef HKS_SUPPORT_ECDH_C
645 {
646 HKS_ALG_ECDH,
647 HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP |
648 HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
649 },
650 #endif
651 };
652 #endif
653
654 #ifdef HKS_SUPPORT_USER_AUTH_ACCESS_CONTROL
655 static const uint32_t g_userAuthChallengeType[] = {
656 HKS_CHALLENGE_TYPE_NORMAL,
657 HKS_CHALLENGE_TYPE_CUSTOM,
658 HKS_CHALLENGE_TYPE_NONE,
659 };
660
661 static const uint32_t g_validBiometricAuthAccessType[] = {
662 HKS_AUTH_ACCESS_INVALID_NEW_BIO_ENROLL,
663 HKS_AUTH_ACCESS_INVALID_CLEAR_PASSWORD
664 };
665
666 static const uint32_t g_validPinAuthAccessType[] = {
667 HKS_AUTH_ACCESS_INVALID_CLEAR_PASSWORD
668 };
669
670 static const struct AuthAccessTypeChecker g_expectAuthAccessParams[] = {
671 { HKS_USER_AUTH_TYPE_FACE,
672 { true, g_validBiometricAuthAccessType, HKS_ARRAY_SIZE(g_validBiometricAuthAccessType)}
673 },
674 { HKS_USER_AUTH_TYPE_FINGERPRINT,
675 { true, g_validBiometricAuthAccessType, HKS_ARRAY_SIZE(g_validBiometricAuthAccessType)}
676 },
677 { HKS_USER_AUTH_TYPE_PIN,
678 { true, g_validPinAuthAccessType, HKS_ARRAY_SIZE(g_validPinAuthAccessType)}
679 }
680 };
681
682 static const uint32_t g_supportUserAuthTypes[] = {
683 HKS_USER_AUTH_TYPE_PIN,
684 HKS_USER_AUTH_TYPE_FINGERPRINT,
685 HKS_USER_AUTH_TYPE_FACE,
686 HKS_USER_AUTH_TYPE_PIN | HKS_USER_AUTH_TYPE_FINGERPRINT,
687 HKS_USER_AUTH_TYPE_PIN | HKS_USER_AUTH_TYPE_FACE,
688 HKS_USER_AUTH_TYPE_FACE | HKS_USER_AUTH_TYPE_FINGERPRINT,
689 HKS_USER_AUTH_TYPE_PIN | HKS_USER_AUTH_TYPE_FACE | HKS_USER_AUTH_TYPE_FINGERPRINT
690 };
691
692 static const uint32_t g_supportSecureSignType[] = {
693 HKS_SECURE_SIGN_WITH_AUTHINFO
694 };
695 #endif
696
697 #ifndef _CUT_AUTHENTICATE_
698 #ifndef _STORAGE_LITE_
CheckAndGetKeySize(const struct HksBlob * key,const uint32_t * expectKeySize,uint32_t expectCnt,uint32_t * keySize)699 static int32_t CheckAndGetKeySize(const struct HksBlob *key, const uint32_t *expectKeySize,
700 uint32_t expectCnt, uint32_t *keySize)
701 {
702 if (key->size < sizeof(struct HksParamSet)) {
703 HKS_LOG_E("check key size: invalid keyfile size: %" LOG_PUBLIC "u", key->size);
704 return HKS_ERROR_INVALID_KEY_FILE;
705 }
706
707 struct HksParamSet *keyParamSet = (struct HksParamSet *)key->data;
708 int32_t ret = HksCheckParamSetValidity(keyParamSet);
709 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_KEY_FILE, "check key size: paramset invalid failed")
710
711 struct HksParam *keySizeParam = NULL;
712 ret = HksGetParam(keyParamSet, HKS_TAG_KEY_SIZE, &keySizeParam);
713 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_KEY_FILE,
714 "check key size: get param get tag:0x%" LOG_PUBLIC "x failed", HKS_TAG_KEY_SIZE)
715
716 ret = HksCheckValue(keySizeParam->uint32Param, expectKeySize, expectCnt);
717 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_KEY_FILE,
718 "check key size: key size value %" LOG_PUBLIC "u not expected", keySizeParam->uint32Param)
719 *keySize = keySizeParam->uint32Param;
720 return ret;
721 }
722 #else
CheckAndGetKeySize(const struct HksBlob * key,const uint32_t * expectKeySize,uint32_t expectCnt,uint32_t * keySize)723 static int32_t CheckAndGetKeySize(const struct HksBlob *key, const uint32_t *expectKeySize,
724 uint32_t expectCnt, uint32_t *keySize)
725 {
726 if (key->size < sizeof(struct HksStoreKeyInfo)) {
727 HKS_LOG_E("check key size: invalid keyfile size: %" LOG_PUBLIC "u", key->size);
728 return HKS_ERROR_INVALID_KEY_FILE;
729 }
730
731 struct HksStoreKeyInfo *keyInfo = (struct HksStoreKeyInfo *)key->data;
732 uint32_t keyLen = keyInfo->keyLen;
733 int32_t ret = HksCheckValue(keyLen, expectKeySize, expectCnt);
734 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_KEY_FILE,
735 "check key size: keySize value %" LOG_PUBLIC "u not expected", keyLen)
736 *keySize = keyLen;
737 return ret;
738 }
739 #endif
740
CheckPurposeUnique(uint32_t inputPurpose)741 static int32_t CheckPurposeUnique(uint32_t inputPurpose)
742 {
743 /* key usage uniqueness */
744 uint32_t purposeCipher = inputPurpose & (HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT);
745 uint32_t purposeSign = inputPurpose & (HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY);
746 uint32_t purposeDerive = inputPurpose & HKS_KEY_PURPOSE_DERIVE;
747 uint32_t purposeWrap = inputPurpose & (HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP);
748 uint32_t purposeMac = inputPurpose & HKS_KEY_PURPOSE_MAC;
749 uint32_t purposeAgree = inputPurpose & HKS_KEY_PURPOSE_AGREE;
750
751 uint32_t purposeCount = (purposeCipher != 0) ? 1 : 0;
752 purposeCount += (purposeSign != 0) ? 1 : 0;
753 purposeCount += (purposeDerive != 0) ? 1 : 0;
754 purposeCount += (purposeWrap != 0) ? 1 : 0;
755 purposeCount += (purposeMac != 0) ? 1 : 0;
756 purposeCount += (purposeAgree != 0) ? 1 : 0;
757
758 return (purposeCount == 1) ? HKS_SUCCESS : HKS_ERROR_INVALID_PURPOSE;
759 }
760
GetInvalidPurpose(uint32_t alg,uint32_t * inputPurpose)761 static int32_t GetInvalidPurpose(uint32_t alg, uint32_t *inputPurpose)
762 {
763 int32_t result = HKS_ERROR_INVALID_ALGORITHM;
764 if (sizeof(g_invalidPurpose) == 0) {
765 return result;
766 }
767 uint32_t count = sizeof(g_invalidPurpose) / sizeof(g_invalidPurpose[0]);
768 for (uint32_t i = 0; i < count; i++) {
769 if (alg == g_invalidPurpose[i][0]) {
770 result = HKS_SUCCESS;
771 *inputPurpose = g_invalidPurpose[i][1];
772 break;
773 }
774 }
775 return result;
776 }
777
CheckPurposeValid(uint32_t alg,uint32_t inputPurpose)778 static int32_t CheckPurposeValid(uint32_t alg, uint32_t inputPurpose)
779 {
780 uint32_t invalidPurpose = 0;
781
782 int32_t result = GetInvalidPurpose(alg, &invalidPurpose);
783 HKS_IF_NOT_SUCC_RETURN(result, result)
784
785 if ((inputPurpose & invalidPurpose) != 0) {
786 return HKS_ERROR_INVALID_PURPOSE;
787 }
788
789 return HKS_SUCCESS;
790 }
791 #endif /* _CUT_AUTHENTICATE_ */
792
793 // 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)794 static int32_t GetOptionalParams(const struct HksParamSet *paramSet, uint32_t tag, bool needCheck, uint32_t* value,
795 bool* isAbsent)
796 {
797 if (needCheck) {
798 struct HksParam *param;
799 int32_t ret = HksGetParam(paramSet, tag, ¶m);
800 if (ret == HKS_SUCCESS) {
801 *value = param->uint32Param;
802 return ret;
803 }
804 if (ret == HKS_ERROR_PARAM_NOT_EXIST) {
805 HKS_LOG_I("tag is empty, but it is supported!");
806 *isAbsent = true;
807 return HKS_SUCCESS;
808 }
809 return HKS_ERROR_INVALID_ARGUMENT;
810 }
811 return HKS_SUCCESS;
812 }
813
GetInputParams(const struct HksParamSet * paramSet,struct ParamsValues * inputParams)814 int32_t GetInputParams(const struct HksParamSet *paramSet, struct ParamsValues *inputParams)
815 {
816 int32_t ret = HKS_SUCCESS;
817 struct HksParam *checkParam = NULL;
818 if (inputParams->keyLen.needCheck) {
819 ret = HksGetParam(paramSet, HKS_TAG_KEY_SIZE, &checkParam);
820 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_KEY_SIZE_FAIL,
821 "get Param get tag:0x%" LOG_PUBLIC "x failed", HKS_TAG_KEY_SIZE);
822 inputParams->keyLen.value = checkParam->uint32Param;
823 }
824
825 if (inputParams->purpose.needCheck) {
826 ret = HksGetParam(paramSet, HKS_TAG_PURPOSE, &checkParam);
827 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_PURPOSE_FAIL,
828 "get Param get tag:0x%" LOG_PUBLIC "x failed", HKS_TAG_PURPOSE);
829 inputParams->purpose.value = checkParam->uint32Param;
830 }
831
832 ret = GetOptionalParams(paramSet, HKS_TAG_PADDING, inputParams->padding.needCheck, &inputParams->padding.value,
833 &inputParams->padding.isAbsent);
834 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_PADDING_FAIL,
835 "get Param get tag:0x%" LOG_PUBLIC "x failed", HKS_TAG_PADDING);
836 ret = GetOptionalParams(paramSet, HKS_TAG_DIGEST, inputParams->digest.needCheck, &inputParams->digest.value,
837 &inputParams->digest.isAbsent);
838 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_DIGEST_FAIL,
839 "get Param get tag:0x%" LOG_PUBLIC "x failed", HKS_TAG_DIGEST);
840 ret = GetOptionalParams(paramSet, HKS_TAG_BLOCK_MODE, inputParams->mode.needCheck, &inputParams->mode.value,
841 &inputParams->mode.isAbsent);
842 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_MODE_FAIL,
843 "get Param get tag:0x%" LOG_PUBLIC "x failed", HKS_TAG_BLOCK_MODE);
844 return ret;
845 }
846
InitInputParams(enum CheckKeyType checkType,struct ParamsValues * inputParams,const struct ParamsValuesChecker * checkSet,uint32_t checkSetSize)847 static int32_t InitInputParams(enum CheckKeyType checkType, struct ParamsValues *inputParams,
848 const struct ParamsValuesChecker *checkSet, uint32_t checkSetSize)
849 {
850 for (uint32_t i = 0; i < checkSetSize; ++i) {
851 if (checkType == checkSet[i].checkType) {
852 (void)memcpy_s(inputParams, sizeof(*inputParams), &checkSet[i].paramValues,
853 sizeof(checkSet[i].paramValues));
854 return HKS_SUCCESS;
855 }
856 }
857 return HKS_ERROR_NOT_SUPPORTED;
858 }
859
InitInputParamsByAlg(uint32_t alg,enum CheckKeyType checkType,struct ParamsValues * inputParams)860 static int32_t InitInputParamsByAlg(uint32_t alg, enum CheckKeyType checkType, struct ParamsValues *inputParams)
861 {
862 switch (alg) {
863 #ifdef HKS_SUPPORT_RSA_C
864 case HKS_ALG_RSA:
865 return InitInputParams(checkType, inputParams, g_rsaParamSet, HKS_ARRAY_SIZE(g_rsaParamSet));
866 #endif
867 #ifdef HKS_SUPPORT_AES_C
868 case HKS_ALG_AES:
869 return InitInputParams(checkType, inputParams, g_aesParamSet, HKS_ARRAY_SIZE(g_aesParamSet));
870 #endif
871 #ifdef HKS_SUPPORT_ECC_C
872 case HKS_ALG_ECC:
873 return InitInputParams(checkType, inputParams, g_eccParamSet, HKS_ARRAY_SIZE(g_eccParamSet));
874 #endif
875 #ifdef HKS_SUPPORT_SM2_C
876 case HKS_ALG_SM2:
877 return InitInputParams(checkType, inputParams, g_sm2ParamSet, HKS_ARRAY_SIZE(g_sm2ParamSet));
878 #endif
879 #ifdef HKS_SUPPORT_SM3_C
880 case HKS_ALG_SM3:
881 return InitInputParams(checkType, inputParams, g_sm3ParamSet, HKS_ARRAY_SIZE(g_sm3ParamSet));
882 #endif
883 #ifdef HKS_SUPPORT_SM4_C
884 case HKS_ALG_SM4:
885 return InitInputParams(checkType, inputParams, g_sm4ParamSet, HKS_ARRAY_SIZE(g_sm4ParamSet));
886 #endif
887 #if defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_ED25519_C)
888 case HKS_ALG_X25519:
889 case HKS_ALG_ED25519:
890 return InitInputParams(checkType, inputParams, g_curve25519ParamSet, HKS_ARRAY_SIZE(g_curve25519ParamSet));
891 #endif
892 #ifdef HKS_SUPPORT_HMAC_C
893 case HKS_ALG_HMAC:
894 return InitInputParams(checkType, inputParams, g_hmacParamSet, HKS_ARRAY_SIZE(g_hmacParamSet));
895 #endif
896 #ifdef HKS_SUPPORT_DSA_C
897 case HKS_ALG_DSA:
898 return InitInputParams(checkType, inputParams, g_dsaParamSet, HKS_ARRAY_SIZE(g_dsaParamSet));
899 #endif
900 #ifdef HKS_SUPPORT_DH_C
901 case HKS_ALG_DH:
902 return InitInputParams(checkType, inputParams, g_dhParamSet, HKS_ARRAY_SIZE(g_dhParamSet));
903 #endif
904 #ifdef HKS_SUPPORT_ECDH_C
905 case HKS_ALG_ECDH:
906 return InitInputParams(checkType, inputParams, g_ecdhParamSet, HKS_ARRAY_SIZE(g_ecdhParamSet));
907 #endif
908 default:
909 return HKS_ERROR_INVALID_ALGORITHM;
910 }
911 }
912
InitExpectParams(enum CheckKeyType checkType,struct ExpectParamsValues * expectValues,const struct ExpectParamsValuesChecker * checkSet,uint32_t checkSetSize)913 static int32_t InitExpectParams(enum CheckKeyType checkType, struct ExpectParamsValues *expectValues,
914 const struct ExpectParamsValuesChecker *checkSet, uint32_t checkSetSize)
915 {
916 for (uint32_t i = 0; i < checkSetSize; ++i) {
917 if (checkType == checkSet[i].checkType) {
918 (void)memcpy_s(expectValues, sizeof(*expectValues), &checkSet[i].paramValues,
919 sizeof(checkSet[i].paramValues));
920 return HKS_SUCCESS;
921 }
922 }
923 return HKS_ERROR_NOT_SUPPORTED;
924 }
925
GetExpectParams(uint32_t alg,enum CheckKeyType checkType,struct ExpectParamsValues * expectValues)926 static int32_t GetExpectParams(uint32_t alg, enum CheckKeyType checkType, struct ExpectParamsValues *expectValues)
927 {
928 switch (alg) {
929 #ifdef HKS_SUPPORT_RSA_C
930 case HKS_ALG_RSA:
931 return InitExpectParams(checkType, expectValues, g_expectRsaParams, HKS_ARRAY_SIZE(g_expectRsaParams));
932 #endif
933 #ifdef HKS_SUPPORT_AES_C
934 case HKS_ALG_AES:
935 return InitExpectParams(checkType, expectValues, g_expectAesParams, HKS_ARRAY_SIZE(g_expectAesParams));
936 #endif
937 #ifdef HKS_SUPPORT_ECC_C
938 case HKS_ALG_ECC:
939 return InitExpectParams(checkType, expectValues, g_expectEccParams, HKS_ARRAY_SIZE(g_expectEccParams));
940 #endif
941 #ifdef HKS_SUPPORT_SM2_C
942 case HKS_ALG_SM2:
943 return InitExpectParams(checkType, expectValues, g_expectSm2Params, HKS_ARRAY_SIZE(g_expectSm2Params));
944 #endif
945 #ifdef HKS_SUPPORT_SM3_C
946 case HKS_ALG_SM3:
947 return InitExpectParams(checkType, expectValues, g_expectSm3Params, HKS_ARRAY_SIZE(g_expectSm3Params));
948 #endif
949 #ifdef HKS_SUPPORT_SM4_C
950 case HKS_ALG_SM4:
951 return InitExpectParams(checkType, expectValues, g_expectSm4Params, HKS_ARRAY_SIZE(g_expectSm4Params));
952 #endif
953 #if defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_ED25519_C)
954 case HKS_ALG_X25519:
955 case HKS_ALG_ED25519:
956 return InitExpectParams(checkType, expectValues, g_expectCurve25519Params,
957 HKS_ARRAY_SIZE(g_expectCurve25519Params));
958 #endif
959 #ifdef HKS_SUPPORT_HMAC_C
960 case HKS_ALG_HMAC:
961 return InitExpectParams(checkType, expectValues, g_expectHmacParams, HKS_ARRAY_SIZE(g_expectHmacParams));
962 #endif
963 #ifdef HKS_SUPPORT_DSA_C
964 case HKS_ALG_DSA:
965 return InitExpectParams(checkType, expectValues, g_expectDsaParams, HKS_ARRAY_SIZE(g_expectDsaParams));
966 #endif
967 #ifdef HKS_SUPPORT_DH_C
968 case HKS_ALG_DH:
969 return InitExpectParams(checkType, expectValues, g_expectDhParams, HKS_ARRAY_SIZE(g_expectDhParams));
970 #endif
971 #ifdef HKS_SUPPORT_ECDH_C
972 case HKS_ALG_ECDH:
973 return InitExpectParams(checkType, expectValues, g_expectEcdhParams, HKS_ARRAY_SIZE(g_expectEcdhParams));
974 #endif
975 default:
976 return HKS_ERROR_INVALID_ALGORITHM;
977 }
978 }
979
980 #ifdef HKS_SUPPORT_ECC_C
CheckEccSignature(uint32_t cmdId,uint32_t keySize,const struct HksBlob * signature)981 static int32_t CheckEccSignature(uint32_t cmdId, uint32_t keySize, const struct HksBlob *signature)
982 {
983 /*
984 * ecc sign format: 0x30 + len1 + 0x02 + len2 + 0x00 (optional) + r + 0x02 + len3 + 0x00(optional) + s
985 * sign: signSize no less than 2*keySize/8 + 8;
986 * verify: signSize no greater than 2*keySize/8 + 8
987 */
988 uint32_t eccSignRSize = keySize / HKS_BITS_PER_BYTE + keySize % HKS_BITS_PER_BYTE;
989 uint32_t eccSignSSize = eccSignRSize;
990 switch (cmdId) {
991 case HKS_CMD_ID_SIGN:
992 if (signature->size < (eccSignRSize + eccSignSSize + HKS_ECC_SIGN_MAX_TL_SIZE)) {
993 HKS_LOG_E("eccsign: signature size too small, keySize %" LOG_PUBLIC "u, signatureSize %" LOG_PUBLIC "u",
994 keySize, signature->size);
995 return HKS_ERROR_BUFFER_TOO_SMALL;
996 }
997 break;
998 case HKS_CMD_ID_VERIFY:
999 if (signature->size > (eccSignRSize + eccSignSSize + HKS_ECC_SIGN_MAX_TL_SIZE)) {
1000 HKS_LOG_E("eccverfiy: invalid signature size, keySize %" LOG_PUBLIC "u, signatureSize %" LOG_PUBLIC "u",
1001 keySize, signature->size);
1002 return HKS_ERROR_INVALID_SIGNATURE_SIZE;
1003 }
1004 break;
1005 default:
1006 return HKS_ERROR_INVALID_ARGUMENT;
1007 }
1008
1009 return HKS_SUCCESS;
1010 }
1011 #endif
1012
1013 #ifdef HKS_SUPPORT_ED25519_C
CheckEd25519Signature(uint32_t cmdId,const struct HksBlob * signature)1014 static int32_t CheckEd25519Signature(uint32_t cmdId, const struct HksBlob *signature)
1015 {
1016 switch (cmdId) {
1017 case HKS_CMD_ID_SIGN:
1018 if (signature->size < HKS_SIGNATURE_MIN_SIZE) {
1019 HKS_LOG_E("ed25519 sign: signature size too small, signatureSize %" LOG_PUBLIC "u", signature->size);
1020 return HKS_ERROR_BUFFER_TOO_SMALL;
1021 }
1022 break;
1023 case HKS_CMD_ID_VERIFY:
1024 if (signature->size < HKS_SIGNATURE_MIN_SIZE) {
1025 HKS_LOG_E("ed25519 verfiy: invalid signature size, signatureSize %" LOG_PUBLIC "u", signature->size);
1026 return HKS_ERROR_INVALID_SIGNATURE_SIZE;
1027 }
1028 break;
1029 default:
1030 return HKS_ERROR_INVALID_ARGUMENT;
1031 }
1032
1033 return HKS_SUCCESS;
1034 }
1035 #endif
1036
1037 #ifdef HKS_SUPPORT_RSA_C
CheckRsaGenKeyPadding(const struct ParamsValues * inputParams)1038 static int32_t CheckRsaGenKeyPadding(const struct ParamsValues *inputParams)
1039 {
1040 if (inputParams->padding.isAbsent) {
1041 return HKS_SUCCESS;
1042 }
1043 if ((inputParams->purpose.value & (HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT)) != 0) {
1044 return HksCheckValue(inputParams->padding.value, g_rsaCipherPadding, HKS_ARRAY_SIZE(g_rsaCipherPadding));
1045 } else if ((inputParams->purpose.value & (HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY)) != 0) {
1046 return HksCheckValue(inputParams->padding.value, g_rsaSignPadding, HKS_ARRAY_SIZE(g_rsaSignPadding));
1047 }
1048 return HKS_SUCCESS;
1049 }
1050
1051 #ifdef HKS_SUPPORT_RSA_SIGN_VERIFY
CheckRsaSignature(uint32_t cmdId,uint32_t keySize,const struct HksBlob * signature)1052 static int32_t CheckRsaSignature(uint32_t cmdId, uint32_t keySize, const struct HksBlob *signature)
1053 {
1054 /*
1055 * k: the length of the RSA modulus n
1056 * sign: signSize no less than k; verify: signSize is same as k, thus no greater than keySize / 8
1057 */
1058 switch (cmdId) {
1059 case HKS_CMD_ID_SIGN:
1060 if (signature->size < keySize / HKS_BITS_PER_BYTE) {
1061 HKS_LOG_E("rsasign: signature size too small, keySize %" LOG_PUBLIC "u, signatureSize %" LOG_PUBLIC "u",
1062 keySize, signature->size);
1063 return HKS_ERROR_BUFFER_TOO_SMALL;
1064 }
1065 break;
1066 case HKS_CMD_ID_VERIFY:
1067 if (signature->size > keySize / HKS_BITS_PER_BYTE) {
1068 HKS_LOG_E("rsaverfiy: invalid signature size, keySize %" LOG_PUBLIC "u, signatureSize %" LOG_PUBLIC "u",
1069 keySize, signature->size);
1070 return HKS_ERROR_INVALID_SIGNATURE_SIZE;
1071 }
1072 break;
1073 default:
1074 return HKS_ERROR_INVALID_ARGUMENT;
1075 }
1076
1077 return HKS_SUCCESS;
1078 }
1079 #endif
1080
1081 #ifdef HKS_SUPPORT_RSA_CRYPT
CheckRsaNoPadCipherData(uint32_t keySize,const struct HksBlob * inData,const struct HksBlob * outData)1082 static int32_t CheckRsaNoPadCipherData(uint32_t keySize, const struct HksBlob *inData,
1083 const struct HksBlob *outData)
1084 {
1085 /* encrypt/decrypt: inSize no greater than keySize, outSize no less than keySize */
1086 if (inData->size > keySize) {
1087 HKS_LOG_E("invalid inData size: %" LOG_PUBLIC "u, keySize: %" LOG_PUBLIC "u", inData->size, keySize);
1088 return HKS_ERROR_INVALID_ARGUMENT;
1089 }
1090
1091 if (outData->size < keySize) {
1092 HKS_LOG_E("outData buffer too small size: %" LOG_PUBLIC "u, keySize: %" LOG_PUBLIC "u", outData->size, keySize);
1093 return HKS_ERROR_BUFFER_TOO_SMALL;
1094 }
1095
1096 return HKS_SUCCESS;
1097 }
1098
CheckRsaOaepCipherData(uint32_t cmdId,uint32_t keySize,uint32_t digest,const struct HksBlob * inData,const struct HksBlob * outData)1099 static int32_t CheckRsaOaepCipherData(uint32_t cmdId, uint32_t keySize, uint32_t digest,
1100 const struct HksBlob *inData, const struct HksBlob *outData)
1101 {
1102 uint32_t digestLen;
1103 if (digest == HKS_DIGEST_NONE) {
1104 digest = HKS_DIGEST_SHA1;
1105 }
1106 int32_t ret = HksGetDigestLen(digest, &digestLen);
1107 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "GetDigestLen failed, ret = %" LOG_PUBLIC "x", ret)
1108
1109 /*
1110 * encrypt: inSize no greater than keySize - 2*digestLen - 2, outSize no less than keySize (in: plain; out: cipher)
1111 * decrypt: inSize no greater than keySize, outSize no less than keySize - 2*digestLen - 2 (in: cipher; out: plain)
1112 */
1113 if (keySize <= (HKS_RSA_OAEP_DIGEST_NUM * digestLen + HKS_RSA_OAEP_DIGEST_NUM)) {
1114 return HKS_ERROR_INVALID_KEY_FILE;
1115 }
1116 uint32_t size = keySize - HKS_RSA_OAEP_DIGEST_NUM * digestLen - HKS_RSA_OAEP_DIGEST_NUM;
1117 if (cmdId == HKS_CMD_ID_ENCRYPT) {
1118 if (inData->size > size) {
1119 HKS_LOG_E("encrypt, invalid insize: %" LOG_PUBLIC "u, keySize: %" LOG_PUBLIC "u, "
1120 "digestLen: %" LOG_PUBLIC "u", inData->size, keySize, digestLen);
1121 return HKS_ERROR_INVALID_ARGUMENT;
1122 }
1123 if (outData->size < keySize) {
1124 HKS_LOG_E("encrypt, outData buffer too small size: %" LOG_PUBLIC "u, keySize: %" LOG_PUBLIC "u",
1125 outData->size, keySize);
1126 return HKS_ERROR_BUFFER_TOO_SMALL;
1127 }
1128 } else if (cmdId == HKS_CMD_ID_DECRYPT) {
1129 if (inData->size > keySize) {
1130 HKS_LOG_E("decrypt, invalid inData size: %" LOG_PUBLIC "u, keySize: %" LOG_PUBLIC "u",
1131 inData->size, keySize);
1132 return HKS_ERROR_INVALID_ARGUMENT;
1133 }
1134 if (outData->size < size) {
1135 HKS_LOG_E("decrypt, outData buffer too small size: %" LOG_PUBLIC "u, keySize: %" LOG_PUBLIC "u",
1136 outData->size, keySize);
1137 return HKS_ERROR_BUFFER_TOO_SMALL;
1138 }
1139 }
1140
1141 return HKS_SUCCESS;
1142 }
1143
CheckRsaCipherData(uint32_t cmdId,const struct ParamsValues * inputParams,const struct HksBlob * inData,const struct HksBlob * outData)1144 static int32_t CheckRsaCipherData(uint32_t cmdId, const struct ParamsValues *inputParams,
1145 const struct HksBlob *inData, const struct HksBlob *outData)
1146 {
1147 uint32_t padding = inputParams->padding.value;
1148 uint32_t keySize = inputParams->keyLen.value / HKS_BITS_PER_BYTE;
1149 int32_t ret = HKS_SUCCESS;
1150
1151 if (padding == HKS_PADDING_NONE) {
1152 ret = CheckRsaNoPadCipherData(keySize, inData, outData);
1153 } else if (padding == HKS_PADDING_OAEP) {
1154 ret = CheckRsaOaepCipherData(cmdId, keySize, inputParams->digest.value, inData, outData);
1155 }
1156
1157 HKS_IF_NOT_SUCC_LOGE(ret, "Check Rsa CipherData failed, cmdId: %" LOG_PUBLIC "u, padding: %" LOG_PUBLIC "u, "
1158 "keyLen: %" LOG_PUBLIC "u, inData size: %" LOG_PUBLIC "u, outData size: %" LOG_PUBLIC "u",
1159 cmdId, padding, keySize, inData->size, outData->size)
1160
1161 return ret;
1162 }
1163 #endif
1164 #endif
1165
1166 #ifdef HKS_SUPPORT_AES_C
1167 static int32_t CheckAesAeCipherData(uint32_t cmdId, const struct HksBlob *inData, const struct HksBlob *outData);
1168 #endif
1169
1170 #if defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_SM4_C)
CheckBlockCbcCipherData(uint32_t cmdId,uint32_t padding,const struct HksBlob * inData,const struct HksBlob * outData)1171 static int32_t CheckBlockCbcCipherData(uint32_t cmdId, uint32_t padding,
1172 const struct HksBlob *inData, const struct HksBlob *outData)
1173 {
1174 /*
1175 * encrypt: inSize greater than 0(has been checked), no-padding: inSize need to be integer multiple of 16
1176 * outSize no less than inSize + (16 - inSize % 16) (in: plain; out: cipher)
1177 * decrypt: inSize greater than 0(has been checked) && inSize is integer multiple of 16
1178 * outSize no less than inSize (in: cipher; out: plain)
1179 */
1180 switch (cmdId) {
1181 case HKS_CMD_ID_ENCRYPT: {
1182 uint32_t paddingSize = 0;
1183 if (padding == HKS_PADDING_NONE) {
1184 if (inData->size % HKS_BLOCK_CIPHER_CBC_BLOCK_SIZE != 0) {
1185 HKS_LOG_E("encrypt cbc no-padding, invalid inSize: %" LOG_PUBLIC "u", inData->size);
1186 return HKS_ERROR_INVALID_ARGUMENT;
1187 }
1188 } else {
1189 paddingSize = HKS_BLOCK_CIPHER_CBC_BLOCK_SIZE - inData->size % HKS_BLOCK_CIPHER_CBC_BLOCK_SIZE;
1190 if (inData->size > (UINT32_MAX - paddingSize)) {
1191 HKS_LOG_E("encrypt, invalid inData size: %" LOG_PUBLIC "u", inData->size);
1192 return HKS_ERROR_INVALID_ARGUMENT;
1193 }
1194 }
1195 if (outData->size < (inData->size + paddingSize)) {
1196 HKS_LOG_E("encrypt, outData buffer too small size: %" LOG_PUBLIC "u, need: %" LOG_PUBLIC "u",
1197 outData->size, inData->size + paddingSize);
1198 return HKS_ERROR_BUFFER_TOO_SMALL;
1199 }
1200 break;
1201 }
1202 case HKS_CMD_ID_DECRYPT:
1203 if ((inData->size % HKS_BLOCK_CIPHER_CBC_BLOCK_SIZE) != 0) {
1204 HKS_LOG_E("decrypt, invalid inData size: %" LOG_PUBLIC "u", inData->size);
1205 return HKS_ERROR_INVALID_ARGUMENT;
1206 }
1207 if (outData->size < inData->size) {
1208 HKS_LOG_E("decrypt, outData buffer too small size: %" LOG_PUBLIC "u, inDataSize: %" LOG_PUBLIC "u",
1209 outData->size, inData->size);
1210 return HKS_ERROR_BUFFER_TOO_SMALL;
1211 }
1212 break;
1213 default:
1214 return HKS_ERROR_INVALID_ARGUMENT;
1215 }
1216
1217 return HKS_SUCCESS;
1218 }
1219
CheckBlockCipherData(uint32_t cmdId,const struct ParamsValues * inputParams,const struct HksBlob * inData,const struct HksBlob * outData,uint32_t alg)1220 static int32_t CheckBlockCipherData(uint32_t cmdId, const struct ParamsValues *inputParams,
1221 const struct HksBlob *inData, const struct HksBlob *outData, uint32_t alg)
1222 {
1223 uint32_t mode = inputParams->mode.value;
1224
1225 #if defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_SM4_C)
1226 if (((alg == HKS_ALG_AES) || (alg == HKS_ALG_SM4)) &&
1227 ((mode == HKS_MODE_CBC) || (mode == HKS_MODE_CTR) || (mode == HKS_MODE_ECB))) {
1228 uint32_t padding = inputParams->padding.value;
1229 return CheckBlockCbcCipherData(cmdId, padding, inData, outData);
1230 #endif
1231 #ifdef HKS_SUPPORT_AES_C
1232 } else if ((alg == HKS_ALG_AES) && ((mode == HKS_MODE_GCM) || (mode == HKS_MODE_CCM))) {
1233 return CheckAesAeCipherData(cmdId, inData, outData);
1234 #endif
1235 #if defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_SM4_C)
1236 }
1237 #endif
1238
1239 return HKS_ERROR_INVALID_MODE;
1240 }
1241
CheckBlockCipherIvMaterial(const struct HksParamSet * paramSet)1242 static int32_t CheckBlockCipherIvMaterial(const struct HksParamSet *paramSet)
1243 {
1244 struct HksParam *ivParam = NULL;
1245 int32_t ret = HksGetParam(paramSet, HKS_TAG_IV, &ivParam);
1246 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_IV_FAIL, "cipher get iv param failed!")
1247
1248 if ((ivParam->blob.size != HKS_BLOCK_CIPHER_CBC_IV_LEN) || (ivParam->blob.data == NULL)) {
1249 HKS_LOG_E("cbc iv param invalid");
1250 return HKS_ERROR_INVALID_IV;
1251 }
1252
1253 return ret;
1254 }
1255 #endif // defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_SM4_C)
1256
1257 #ifdef HKS_SUPPORT_AES_C
CheckAesPadding(const struct ParamsValues * inputParams)1258 static int32_t CheckAesPadding(const struct ParamsValues *inputParams)
1259 {
1260 if ((inputParams->mode.isAbsent) || (inputParams->padding.isAbsent)) {
1261 return HKS_SUCCESS;
1262 }
1263 uint32_t mode = inputParams->mode.value;
1264 uint32_t padding = inputParams->padding.value;
1265 if (mode == HKS_MODE_CBC) {
1266 return HksCheckValue(padding, g_aesCbcPadding, HKS_ARRAY_SIZE(g_aesCbcPadding));
1267 }
1268
1269 if (mode == HKS_MODE_CTR) {
1270 return HksCheckValue(padding, g_aesCtrPadding, HKS_ARRAY_SIZE(g_aesCtrPadding));
1271 }
1272
1273 if (mode == HKS_MODE_ECB) {
1274 return HksCheckValue(padding, g_aesEcbPadding, HKS_ARRAY_SIZE(g_aesEcbPadding));
1275 }
1276
1277 if ((mode == HKS_MODE_GCM) || (mode == HKS_MODE_CCM)) {
1278 return HksCheckValue(padding, g_aesAeadPadding, HKS_ARRAY_SIZE(g_aesAeadPadding));
1279 }
1280
1281 return HKS_SUCCESS;
1282 }
1283
CheckAesAeCipherData(uint32_t cmdId,const struct HksBlob * inData,const struct HksBlob * outData)1284 static int32_t CheckAesAeCipherData(uint32_t cmdId, const struct HksBlob *inData, const struct HksBlob *outData)
1285 {
1286 /*
1287 * encrypt: inSize greater than 0(has been checked),
1288 * outSize no less than inSize + 16(tagLen) (in: plain; out: cipher)
1289 * decrypt: inSize greater than 16(tagLen), outSize no less than inSize - 16(tagLen)
1290 * decryptFinal: inSize greater than 0(has been checked), outSize no less than inSize (in: cipher; out: plain)
1291 */
1292 switch (cmdId) {
1293 case HKS_CMD_ID_ENCRYPT:
1294 if (inData->size > (UINT32_MAX - HKS_AE_TAG_LEN)) {
1295 HKS_LOG_E("encrypt, invalid inSize: %" LOG_PUBLIC "u", inData->size);
1296 return HKS_ERROR_INVALID_ARGUMENT;
1297 }
1298 if (outData->size < (inData->size + HKS_AE_TAG_LEN)) {
1299 HKS_LOG_E("encrypt, out buffer too small size: %" LOG_PUBLIC "u, inSize: %" LOG_PUBLIC "u",
1300 outData->size, inData->size);
1301 return HKS_ERROR_BUFFER_TOO_SMALL;
1302 }
1303 break;
1304 case HKS_CMD_ID_DECRYPT:
1305 if ((inData->size < HKS_AE_TAG_LEN) || (outData->size < inData->size - HKS_AE_TAG_LEN)) {
1306 HKS_LOG_E("decryptfinal, out buffer too small size: %" LOG_PUBLIC "u, inSize: %" LOG_PUBLIC "u",
1307 outData->size, inData->size);
1308 return HKS_ERROR_BUFFER_TOO_SMALL;
1309 }
1310 break;
1311 default:
1312 return HKS_ERROR_INVALID_ARGUMENT;
1313 }
1314
1315 return HKS_SUCCESS;
1316 }
1317
CheckCipherAeAadMaterial(uint32_t mode,const struct HksParamSet * paramSet)1318 static int32_t CheckCipherAeAadMaterial(uint32_t mode, const struct HksParamSet *paramSet)
1319 {
1320 struct HksParam *aadParam = NULL;
1321 int32_t ret = HksGetParam(paramSet, HKS_TAG_ASSOCIATED_DATA, &aadParam);
1322 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_AAD_FAIL, "cipher get aad param failed!")
1323 HKS_IF_NOT_SUCC_RETURN(CheckBlob(&aadParam->blob), HKS_ERROR_INVALID_AAD)
1324
1325 /* gcmMode: aadSize greater than 0 (has been checked); ccmMode: aadSize no less than 4 */
1326 if (mode == HKS_MODE_CCM) {
1327 if (aadParam->blob.size < HKS_AES_CCM_AAD_LEN_MIN) {
1328 HKS_LOG_E("ccm invalid aad size, aad size = %" LOG_PUBLIC "u", aadParam->blob.size);
1329 return HKS_ERROR_INVALID_AAD;
1330 }
1331 }
1332
1333 return HKS_SUCCESS;
1334 }
1335
CheckCipherAeNonceMaterial(uint32_t mode,const struct HksParamSet * paramSet)1336 static int32_t CheckCipherAeNonceMaterial(uint32_t mode, const struct HksParamSet *paramSet)
1337 {
1338 struct HksParam *nonceParam = NULL;
1339 int32_t ret = HksGetParam(paramSet, HKS_TAG_NONCE, &nonceParam);
1340 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_NONCE_FAIL, "cipher get nonce param failed!")
1341 HKS_IF_NOT_SUCC_RETURN(CheckBlob(&nonceParam->blob), HKS_ERROR_INVALID_NONCE)
1342
1343 /* gcmMode: nonceSize no less than 12; ccmMode: nonceSize no less than 7, and no greater than 13 */
1344 if (mode == HKS_MODE_GCM) {
1345 if (nonceParam->blob.size < HKS_AES_GCM_NONCE_LEN_MIN) {
1346 HKS_LOG_E("gcm invalid nonce size, nonce size = %" LOG_PUBLIC "u", nonceParam->blob.size);
1347 return HKS_ERROR_INVALID_NONCE;
1348 }
1349 } else if (mode == HKS_MODE_CCM) {
1350 if ((nonceParam->blob.size < HKS_AES_CCM_NONCE_LEN_MIN) ||
1351 (nonceParam->blob.size > HKS_AES_CCM_NONCE_LEN_MAX)) {
1352 HKS_LOG_E("ccm invalid nonce size, nonce size = %" LOG_PUBLIC "u", nonceParam->blob.size);
1353 return HKS_ERROR_INVALID_NONCE;
1354 }
1355 }
1356
1357 return HKS_SUCCESS;
1358 }
1359
CheckCipherAeMaterial(uint32_t mode,const struct HksParamSet * paramSet)1360 static int32_t CheckCipherAeMaterial(uint32_t mode, const struct HksParamSet *paramSet)
1361 {
1362 int32_t ret = CheckCipherAeAadMaterial(mode, paramSet);
1363 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "check ae cipher aad failed!")
1364
1365 ret = CheckCipherAeNonceMaterial(mode, paramSet);
1366 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "check ae cipher nonce failed!")
1367
1368 return ret;
1369 }
1370 #endif
1371
1372 #ifdef HKS_SUPPORT_SM4_C
CheckSm4Padding(const struct ParamsValues * inputParams)1373 static int32_t CheckSm4Padding(const struct ParamsValues *inputParams)
1374 {
1375 if ((inputParams->mode.isAbsent) || (inputParams->padding.isAbsent)) {
1376 return HKS_SUCCESS;
1377 }
1378 uint32_t mode = inputParams->mode.value;
1379 uint32_t padding = inputParams->padding.value;
1380 if (mode == HKS_MODE_CBC) {
1381 return HksCheckValue(padding, g_sm4CbcPadding, HKS_ARRAY_SIZE(g_sm4CbcPadding));
1382 }
1383
1384 if (mode == HKS_MODE_CTR) {
1385 return HksCheckValue(padding, g_sm4CtrPadding, HKS_ARRAY_SIZE(g_sm4CtrPadding));
1386 }
1387
1388 if (mode == HKS_MODE_ECB) {
1389 return HksCheckValue(padding, g_sm4EcbPadding, HKS_ARRAY_SIZE(g_sm4EcbPadding));
1390 }
1391
1392 return HKS_ERROR_INVALID_ARGUMENT;
1393 }
1394 #endif
1395
HksCheckValue(uint32_t inputValue,const uint32_t * expectValues,uint32_t valuesCount)1396 int32_t HksCheckValue(uint32_t inputValue, const uint32_t *expectValues, uint32_t valuesCount)
1397 {
1398 for (uint32_t i = 0; i < valuesCount; ++i) {
1399 if (inputValue == expectValues[i]) {
1400 return HKS_SUCCESS;
1401 }
1402 }
1403 return HKS_ERROR_INVALID_ARGUMENT;
1404 }
1405
1406 #ifndef _CUT_AUTHENTICATE_
HksCheckGenKeyPurpose(uint32_t alg,uint32_t inputPurpose)1407 int32_t HksCheckGenKeyPurpose(uint32_t alg, uint32_t inputPurpose)
1408 {
1409 int32_t ret = CheckPurposeUnique(inputPurpose);
1410 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "gen key purpose not unique")
1411
1412 return CheckPurposeValid(alg, inputPurpose);
1413 }
1414
1415 #ifdef HKS_SUPPORT_DSA_C
HksGetDsaKeySize(const struct HksBlob * key,uint32_t * keySize)1416 static int32_t HksGetDsaKeySize(const struct HksBlob *key, uint32_t *keySize)
1417 {
1418 if (key->size < sizeof(struct HksParamSet)) {
1419 HKS_LOG_E("check key size: invalid keyfile size: %" LOG_PUBLIC "u", key->size);
1420 return HKS_ERROR_INVALID_KEY_FILE;
1421 }
1422
1423 struct HksParamSet *keyParamSet = (struct HksParamSet *)key->data;
1424 int32_t ret = HksCheckParamSetValidity(keyParamSet);
1425 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_KEY_FILE, "check key size: paramset invalid failed")
1426
1427 struct HksParam *keySizeParam = NULL;
1428 ret = HksGetParam(keyParamSet, HKS_TAG_KEY_SIZE, &keySizeParam);
1429 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_KEY_FILE,
1430 "check key size: get param get tag:0x%" LOG_PUBLIC "x failed", HKS_TAG_KEY_SIZE)
1431 *keySize = keySizeParam->uint32Param;
1432 return ret;
1433 }
1434 #endif
1435
HksGetKeySize(uint32_t alg,const struct HksBlob * key,uint32_t * keySize)1436 int32_t HksGetKeySize(uint32_t alg, const struct HksBlob *key, uint32_t *keySize)
1437 {
1438 switch (alg) {
1439 #ifdef HKS_SUPPORT_RSA_C
1440 case HKS_ALG_RSA:
1441 return CheckAndGetKeySize(key, g_rsaKeySize, HKS_ARRAY_SIZE(g_rsaKeySize), keySize);
1442 #endif
1443 #ifdef HKS_SUPPORT_DSA_C
1444 case HKS_ALG_DSA:
1445 #ifndef _STORAGE_LITE_
1446 return HksGetDsaKeySize(key, keySize);
1447 #else
1448 return HKS_ERROR_INVALID_ALGORITHM;
1449 #endif
1450 #endif
1451 #ifdef HKS_SUPPORT_ECC_C
1452 case HKS_ALG_ECC:
1453 return CheckAndGetKeySize(key, g_eccKeySize, HKS_ARRAY_SIZE(g_eccKeySize), keySize);
1454 #endif
1455 #ifdef HKS_SUPPORT_ECDH_C
1456 case HKS_ALG_ECDH:
1457 return CheckAndGetKeySize(key, g_ecdhKeySize, HKS_ARRAY_SIZE(g_ecdhKeySize), keySize);
1458 #endif
1459 #if defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_ED25519_C)
1460 case HKS_ALG_X25519:
1461 case HKS_ALG_ED25519:
1462 return CheckAndGetKeySize(key, g_curve25519KeySize, HKS_ARRAY_SIZE(g_curve25519KeySize), keySize);
1463 #endif
1464 #ifdef HKS_SUPPORT_DH_C
1465 case HKS_ALG_DH:
1466 return CheckAndGetKeySize(key, g_dhKeySize, HKS_ARRAY_SIZE(g_dhKeySize), keySize);
1467 #endif
1468 #ifdef HKS_SUPPORT_SM4_C
1469 case HKS_ALG_SM4:
1470 return CheckAndGetKeySize(key, g_sm4KeySize, HKS_ARRAY_SIZE(g_sm4KeySize), keySize);
1471 #endif
1472 default:
1473 return HKS_ERROR_INVALID_ALGORITHM;
1474 }
1475 }
1476 #endif /* _CUT_AUTHENTICATE_ */
1477
HksGetInputParmasByAlg(uint32_t alg,enum CheckKeyType checkType,const struct HksParamSet * paramSet,struct ParamsValues * inputParams)1478 int32_t HksGetInputParmasByAlg(uint32_t alg, enum CheckKeyType checkType, const struct HksParamSet *paramSet,
1479 struct ParamsValues *inputParams)
1480 {
1481 int32_t ret = InitInputParamsByAlg(alg, checkType, inputParams);
1482 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "init input params failed!")
1483
1484 ret = GetInputParams(paramSet, inputParams);
1485 HKS_IF_NOT_SUCC_LOGE(ret, "get input params failed!")
1486
1487 return ret;
1488 }
CheckOptionalParams(bool needCheck,bool isAbsent,uint32_t inputValue,const uint32_t * expectValue,uint32_t expectCnt)1489 static int32_t CheckOptionalParams(bool needCheck, bool isAbsent, uint32_t inputValue, const uint32_t* expectValue,
1490 uint32_t expectCnt)
1491 {
1492 if (needCheck) {
1493 if (!isAbsent) {
1494 if (HksCheckValue(inputValue, expectValue, expectCnt) != HKS_SUCCESS) {
1495 HKS_LOG_E("CheckOptionalParams invalid argument, %d", inputValue);
1496 return HKS_ERROR_INVALID_ARGUMENT;
1497 }
1498 }
1499 }
1500 return HKS_SUCCESS;
1501 }
1502
InitCheckOptionalParams(bool needCheck,bool isAbsent,struct HksParam * param,const uint32_t * expectValue,uint32_t expectCnt)1503 static int32_t InitCheckOptionalParams(bool needCheck, bool isAbsent, struct HksParam *param,
1504 const uint32_t* expectValue, uint32_t expectCnt)
1505 {
1506 if (needCheck) {
1507 if (!isAbsent) {
1508 if (HksCheckValue(param->uint32Param, expectValue, expectCnt) != HKS_SUCCESS) {
1509 return HKS_ERROR_INVALID_ARGUMENT;
1510 }
1511 } else {
1512 HKS_LOG_E("This param is absent, but it is necessary.");
1513 return HKS_ERROR_NOT_EXIST;
1514 }
1515 }
1516 return HKS_SUCCESS;
1517 }
1518
HksCheckOptionalParam(uint32_t tag,uint32_t alg,uint32_t purpose,bool isAbsent,struct HksParam * param)1519 int32_t HksCheckOptionalParam(uint32_t tag, uint32_t alg, uint32_t purpose, bool isAbsent, struct HksParam *param)
1520 {
1521 enum CheckKeyType checkType = HKS_CHECK_TYPE_GEN_KEY;
1522 if (((purpose & HKS_KEY_PURPOSE_DERIVE) != 0) || ((purpose & HKS_KEY_PURPOSE_MAC) != 0)) {
1523 if (alg != HKS_ALG_AES && alg != HKS_ALG_HMAC && alg != HKS_ALG_SM3) {
1524 HKS_LOG_E("check mac or derive, not aes alg, alg: %u", alg);
1525 return HKS_ERROR_INVALID_PURPOSE;
1526 }
1527 if (purpose == HKS_KEY_PURPOSE_DERIVE) {
1528 checkType = HKS_CHECK_TYPE_GEN_DERIVE_KEY;
1529 } else {
1530 checkType = HKS_CHECK_TYPE_GEN_MAC_KEY;
1531 }
1532 }
1533 struct ExpectParamsValues expectValues = EXPECT_PARAMS_VALUES_INIT;
1534 int32_t ret = GetExpectParams(alg, checkType, &expectValues);
1535 HKS_IF_NOT_SUCC_RETURN(ret, ret)
1536 switch (tag) {
1537 case HKS_TAG_BLOCK_MODE:
1538 ret = InitCheckOptionalParams(expectValues.mode.needCheck, isAbsent, param,
1539 expectValues.mode.values, expectValues.mode.valueCnt);
1540 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_MODE_FAIL,
1541 "check param fail:0x%" LOG_PUBLIC "x failed", HKS_TAG_BLOCK_MODE);
1542 break;
1543 case HKS_TAG_DIGEST:
1544 ret = InitCheckOptionalParams(expectValues.digest.needCheck, isAbsent, param,
1545 expectValues.digest.values, expectValues.digest.valueCnt);
1546 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_DIGEST_FAIL,
1547 "check param fail:0x%" LOG_PUBLIC "x failed", HKS_TAG_DIGEST);
1548 break;
1549 case HKS_TAG_PADDING:
1550 ret = InitCheckOptionalParams(expectValues.padding.needCheck, isAbsent, param,
1551 expectValues.padding.values, expectValues.padding.valueCnt);
1552 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_CHECK_GET_PADDING_FAIL,
1553 "check param fail:0x%" LOG_PUBLIC "x failed", HKS_TAG_PADDING);
1554 break;
1555 default:
1556 HKS_LOG_E("invalid tag: %d", tag);
1557 ret = HKS_FAILURE;
1558 }
1559 return ret;
1560 }
1561
HksCheckFixedParams(uint32_t alg,enum CheckKeyType checkType,const struct ParamsValues * inputParams)1562 int32_t HksCheckFixedParams(uint32_t alg, enum CheckKeyType checkType, const struct ParamsValues *inputParams)
1563 {
1564 struct ExpectParamsValues expectValues = EXPECT_PARAMS_VALUES_INIT;
1565 int32_t ret = GetExpectParams(alg, checkType, &expectValues);
1566 HKS_IF_NOT_SUCC_RETURN(ret, ret)
1567
1568 ret = CheckOptionalParams(expectValues.keyLen.needCheck, inputParams->keyLen.isAbsent, inputParams->keyLen.value,
1569 expectValues.keyLen.values, expectValues.keyLen.valueCnt);
1570 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_KEY_SIZE,
1571 "check keyLen not expected, len = %" LOG_PUBLIC "u", inputParams->keyLen.value);
1572 ret = CheckOptionalParams(expectValues.padding.needCheck, inputParams->padding.isAbsent, inputParams->padding.value,
1573 expectValues.padding.values, expectValues.padding.valueCnt);
1574 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_PADDING,
1575 "check padding not expected, padding = %" LOG_PUBLIC "u", inputParams->padding.value);
1576 ret = CheckOptionalParams(expectValues.purpose.needCheck, inputParams->purpose.isAbsent, inputParams->purpose.value,
1577 expectValues.purpose.values, expectValues.purpose.valueCnt);
1578 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_PURPOSE,
1579 "check purpose not expected, purpose = %" LOG_PUBLIC "u", inputParams->purpose.value);
1580 ret = CheckOptionalParams(expectValues.digest.needCheck, inputParams->digest.isAbsent, inputParams->digest.value,
1581 expectValues.digest.values, expectValues.digest.valueCnt);
1582 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_DIGEST,
1583 "check digest not expected, digest = %" LOG_PUBLIC "u", inputParams->digest.value);
1584 ret = CheckOptionalParams(expectValues.mode.needCheck, inputParams->mode.isAbsent, inputParams->mode.value,
1585 expectValues.mode.values, expectValues.mode.valueCnt);
1586 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_MODE,
1587 "check mode not expected, mode = %" LOG_PUBLIC "u", inputParams->mode.value);
1588 return ret;
1589 }
1590
1591 #ifndef _CUT_AUTHENTICATE_
HksCheckGenKeyMutableParams(uint32_t alg,const struct ParamsValues * inputParams)1592 int32_t HksCheckGenKeyMutableParams(uint32_t alg, const struct ParamsValues *inputParams)
1593 {
1594 uint32_t ret = HKS_SUCCESS;
1595 switch (alg) {
1596 #ifdef HKS_SUPPORT_RSA_C
1597 case HKS_ALG_RSA:
1598 ret = CheckRsaGenKeyPadding(inputParams);
1599 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_PADDING,
1600 "Check padding not expected, padding = %" LOG_PUBLIC "u", inputParams->padding.value);
1601 break;
1602 #endif
1603 #ifdef HKS_SUPPORT_AES_C
1604 case HKS_ALG_AES:
1605 ret = CheckAesPadding(inputParams);
1606 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_PADDING,
1607 "Check padding not expected, padding = %" LOG_PUBLIC "u", inputParams->padding.value);
1608 break;
1609 #endif
1610 #ifdef HKS_SUPPORT_SM4_C
1611 case HKS_ALG_SM4:
1612 ret = CheckSm4Padding(inputParams);
1613 HKS_IF_NOT_SUCC_LOGE_RETURN(ret, HKS_ERROR_INVALID_PADDING,
1614 "Check padding not expected, padding = %" LOG_PUBLIC "u", inputParams->padding.value);
1615 break;
1616 #endif
1617 default:
1618 /* other alg no need check padding */
1619 break;
1620 }
1621
1622 return ret;
1623 }
1624
CheckImportMutableParams(uint32_t alg,const struct ParamsValues * params)1625 int32_t CheckImportMutableParams(uint32_t alg, const struct ParamsValues *params)
1626 {
1627 if (((alg == HKS_ALG_SM2) || (alg == HKS_ALG_DSA) || (alg == HKS_ALG_ED25519)) &&
1628 (params->purpose.value != HKS_KEY_PURPOSE_VERIFY)) {
1629 HKS_LOG_E("Import key check purpose failed.");
1630 return HKS_ERROR_INVALID_PURPOSE;
1631 }
1632
1633 if ((alg == HKS_ALG_ECC) &&
1634 ((params->purpose.value != HKS_KEY_PURPOSE_VERIFY) && (params->purpose.value != HKS_KEY_PURPOSE_UNWRAP) &&
1635 (params->purpose.value != HKS_KEY_PURPOSE_AGREE))) {
1636 HKS_LOG_E("Import key check purpose failed.");
1637 return HKS_ERROR_INVALID_PURPOSE;
1638 }
1639
1640 if ((alg == HKS_ALG_RSA) &&
1641 ((params->purpose.value != HKS_KEY_PURPOSE_VERIFY) && (params->purpose.value != HKS_KEY_PURPOSE_ENCRYPT))) {
1642 HKS_LOG_E("Import key check purpose failed.");
1643 return HKS_ERROR_INVALID_PURPOSE;
1644 }
1645
1646 if (alg == HKS_ALG_RSA) {
1647 #ifdef HKS_SUPPORT_RSA_C
1648 if (params->padding.isAbsent) {
1649 return HKS_SUCCESS;
1650 }
1651 if (params->purpose.value == HKS_KEY_PURPOSE_ENCRYPT) {
1652 return HksCheckValue(params->padding.value, g_rsaCipherPadding, HKS_ARRAY_SIZE(g_rsaCipherPadding));
1653 } else if (params->purpose.value == HKS_KEY_PURPOSE_VERIFY) {
1654 return HksCheckValue(params->padding.value, g_rsaSignPadding, HKS_ARRAY_SIZE(g_rsaSignPadding));
1655 }
1656 #else
1657 return HKS_ERROR_NOT_SUPPORTED;
1658 #endif
1659 }
1660
1661 return HKS_SUCCESS;
1662 }
1663
HksCheckSignature(uint32_t cmdId,uint32_t alg,uint32_t keySize,const struct HksBlob * signature)1664 int32_t HksCheckSignature(uint32_t cmdId, uint32_t alg, uint32_t keySize, const struct HksBlob *signature)
1665 {
1666 (void)cmdId;
1667 (void)keySize;
1668 (void)signature;
1669 switch (alg) {
1670 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY)
1671 case HKS_ALG_RSA:
1672 HKS_IF_NOT_SUCC_LOGE_RETURN(HksCheckValue(keySize, g_rsaKeySize, HKS_ARRAY_SIZE(g_rsaKeySize)),
1673 HKS_ERROR_INVALID_ARGUMENT, "check key size: key size value %" LOG_PUBLIC "u not expected", keySize)
1674 return CheckRsaSignature(cmdId, keySize, signature);
1675 #endif
1676 #if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_SIGN_VERIFY)
1677 case HKS_ALG_DSA:
1678 return HKS_SUCCESS;
1679 #endif
1680 #ifdef HKS_SUPPORT_ECC_C
1681 case HKS_ALG_ECC:
1682 HKS_IF_NOT_SUCC_LOGE_RETURN(HksCheckValue(keySize, g_eccKeySize, HKS_ARRAY_SIZE(g_eccKeySize)),
1683 HKS_ERROR_INVALID_ARGUMENT, "check key size: key size value %" LOG_PUBLIC "u not expected", keySize)
1684 return CheckEccSignature(cmdId, keySize, signature);
1685 #endif
1686 #ifdef HKS_SUPPORT_ED25519_C
1687 case HKS_ALG_ED25519:
1688 return CheckEd25519Signature(cmdId, signature);
1689 #endif
1690 #ifdef HKS_SUPPORT_SM2_C
1691 case HKS_ALG_SM2:
1692 HKS_IF_NOT_SUCC_LOGE_RETURN(HksCheckValue(keySize, g_sm2KeySize, HKS_ARRAY_SIZE(g_sm2KeySize)),
1693 HKS_ERROR_INVALID_ARGUMENT, "check key size: key size value %" LOG_PUBLIC "u not expected", keySize)
1694 return CheckEccSignature(cmdId, keySize, signature);
1695 #endif
1696 default:
1697 return HKS_ERROR_INVALID_ALGORITHM;
1698 }
1699 }
1700
HksCheckSignVerifyMutableParams(uint32_t cmdId,uint32_t alg,const struct ParamsValues * inputParams)1701 int32_t HksCheckSignVerifyMutableParams(uint32_t cmdId, uint32_t alg, const struct ParamsValues *inputParams)
1702 {
1703 switch (cmdId) {
1704 case HKS_CMD_ID_SIGN:
1705 if ((inputParams->purpose.value & HKS_KEY_PURPOSE_SIGN) == 0) {
1706 return HKS_ERROR_INVALID_PURPOSE;
1707 }
1708 break;
1709 case HKS_CMD_ID_VERIFY:
1710 if ((inputParams->purpose.value & HKS_KEY_PURPOSE_VERIFY) == 0) {
1711 return HKS_ERROR_INVALID_PURPOSE;
1712 }
1713 break;
1714 default:
1715 return HKS_ERROR_INVALID_ARGUMENT;
1716 }
1717
1718 switch (alg) {
1719 #ifdef HKS_SUPPORT_RSA_C
1720 case HKS_ALG_RSA:
1721 HKS_IF_NOT_SUCC_RETURN(HksCheckValue(inputParams->padding.value, g_rsaSignPadding,
1722 HKS_ARRAY_SIZE(g_rsaSignPadding)), HKS_ERROR_INVALID_PADDING)
1723 break;
1724 #endif
1725 #ifdef HKS_SUPPORT_DSA_C
1726 case HKS_ALG_DSA:
1727 break;
1728 #endif
1729 #ifdef HKS_SUPPORT_ECC_C
1730 case HKS_ALG_ECC:
1731 break;
1732 #endif
1733 default:
1734 /* other alg no need check padding */
1735 break;
1736 }
1737 return HKS_SUCCESS;
1738 }
1739 #endif /* _CUT_AUTHENTICATE_ */
1740
HksCheckCipherMutableParams(uint32_t cmdId,uint32_t alg,const struct ParamsValues * inputParams)1741 int32_t HksCheckCipherMutableParams(uint32_t cmdId, uint32_t alg, const struct ParamsValues *inputParams)
1742 {
1743 switch (cmdId) {
1744 case HKS_CMD_ID_ENCRYPT:
1745 if ((inputParams->purpose.value & HKS_KEY_PURPOSE_ENCRYPT) == 0) {
1746 return HKS_ERROR_INVALID_PURPOSE;
1747 }
1748 break;
1749 case HKS_CMD_ID_DECRYPT:
1750 if ((inputParams->purpose.value & HKS_KEY_PURPOSE_DECRYPT) == 0) {
1751 return HKS_ERROR_INVALID_PURPOSE;
1752 }
1753 break;
1754 default:
1755 return HKS_ERROR_INVALID_ARGUMENT;
1756 }
1757
1758 int32_t ret = HKS_ERROR_INVALID_PADDING;
1759 switch (alg) {
1760 #ifdef HKS_SUPPORT_RSA_C
1761 case HKS_ALG_RSA:
1762 ret = HksCheckValue(inputParams->padding.value, g_rsaCipherPadding, HKS_ARRAY_SIZE(g_rsaCipherPadding));
1763 break;
1764 #endif
1765 #ifdef HKS_SUPPORT_AES_C
1766 case HKS_ALG_AES:
1767 ret = CheckAesPadding(inputParams);
1768 break;
1769 #endif
1770 #ifdef HKS_SUPPORT_SM4_C
1771 case HKS_ALG_SM4:
1772 ret = CheckSm4Padding(inputParams);
1773 break;
1774 #endif
1775 default:
1776 return HKS_ERROR_INVALID_ALGORITHM;
1777 }
1778 HKS_IF_NOT_SUCC_RETURN(ret, HKS_ERROR_INVALID_PADDING)
1779 return ret;
1780 }
1781
HksCheckCihperData(uint32_t cmdId,uint32_t alg,const struct ParamsValues * inputParams,const struct HksBlob * inData,const struct HksBlob * outData)1782 int32_t HksCheckCihperData(uint32_t cmdId, uint32_t alg, const struct ParamsValues *inputParams,
1783 const struct HksBlob *inData, const struct HksBlob *outData)
1784 {
1785 switch (alg) {
1786 #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_CRYPT)
1787 case HKS_ALG_RSA:
1788 return CheckRsaCipherData(cmdId, inputParams, inData, outData);
1789 #endif
1790 #ifdef HKS_SUPPORT_AES_C
1791 case HKS_ALG_AES:
1792 return CheckBlockCipherData(cmdId, inputParams, inData, outData, HKS_ALG_AES);
1793 #endif
1794 #ifdef HKS_SUPPORT_SM4_C
1795 case HKS_ALG_SM4:
1796 return CheckBlockCipherData(cmdId, inputParams, inData, outData, HKS_ALG_SM4);
1797 #endif
1798 default:
1799 return HKS_ERROR_INVALID_ALGORITHM;
1800 }
1801 }
1802
HksCheckCipherMaterialParams(uint32_t alg,const struct ParamsValues * inputParams,const struct HksParamSet * paramSet)1803 int32_t HksCheckCipherMaterialParams(uint32_t alg, const struct ParamsValues *inputParams,
1804 const struct HksParamSet *paramSet)
1805 {
1806 #ifdef HKS_SUPPORT_AES_C
1807 if (alg == HKS_ALG_AES) {
1808 uint32_t mode = inputParams->mode.value;
1809 if (mode == HKS_MODE_CBC) {
1810 return CheckBlockCipherIvMaterial(paramSet);
1811 } else if ((mode == HKS_MODE_CCM) || (mode == HKS_MODE_GCM)) {
1812 return CheckCipherAeMaterial(mode, paramSet);
1813 }
1814 }
1815 #endif
1816 #ifdef HKS_SUPPORT_SM4_C
1817 if (alg == HKS_ALG_SM4) {
1818 uint32_t mode = inputParams->mode.value;
1819 if (mode == HKS_MODE_CBC) {
1820 return CheckBlockCipherIvMaterial(paramSet);
1821 }
1822 }
1823 #endif
1824 return HKS_SUCCESS;
1825 }
1826
1827 #ifdef HKS_SUPPORT_USER_AUTH_ACCESS_CONTROL
HasValidAuthAccessType(const struct ExpectParams allowAuthAccessTypes,uint32_t authAccessType)1828 static int32_t HasValidAuthAccessType(const struct ExpectParams allowAuthAccessTypes, uint32_t authAccessType)
1829 {
1830 for (uint32_t i = 0; i < allowAuthAccessTypes.valueCnt; i++) {
1831 if ((authAccessType & allowAuthAccessTypes.values[i]) != 0) {
1832 return HKS_SUCCESS;
1833 }
1834 }
1835 return HKS_ERROR_INVALID_ARGUMENT;
1836 }
1837
HksCheckAuthAccessTypeByUserAuthType(uint32_t userAuthType,uint32_t authAccessType)1838 static int32_t HksCheckAuthAccessTypeByUserAuthType(uint32_t userAuthType, uint32_t authAccessType)
1839 {
1840 uint32_t valuesCnt = HKS_ARRAY_SIZE(g_expectAuthAccessParams);
1841 for (uint32_t i = 0; i < valuesCnt; i++) {
1842 struct AuthAccessTypeChecker checker = g_expectAuthAccessParams[i];
1843 if ((checker.userAuthType & userAuthType) != 0 &&
1844 HasValidAuthAccessType(checker.allowAuthAccessTypes, authAccessType) != HKS_SUCCESS) {
1845 HKS_LOG_E("check access type valid failed");
1846 return HKS_ERROR_INVALID_ARGUMENT;
1847 }
1848 }
1849 return HKS_SUCCESS;
1850 }
1851 #endif
1852
HksCheckUserAuthParams(uint32_t userAuthType,uint32_t authAccessType,uint32_t challengeType)1853 int32_t HksCheckUserAuthParams(uint32_t userAuthType, uint32_t authAccessType, uint32_t challengeType)
1854 {
1855 #ifdef HKS_SUPPORT_USER_AUTH_ACCESS_CONTROL
1856 int32_t ret = HksCheckValue(userAuthType, g_supportUserAuthTypes, HKS_ARRAY_SIZE(g_supportUserAuthTypes));
1857 HKS_IF_NOT_SUCC_RETURN(ret, HKS_ERROR_INVALID_AUTH_TYPE)
1858
1859 ret = HksCheckValue(challengeType, g_userAuthChallengeType, HKS_ARRAY_SIZE(g_userAuthChallengeType));
1860 HKS_IF_NOT_SUCC_RETURN(ret, HKS_ERROR_INVALID_CHALLENGE_TYPE)
1861
1862 return HksCheckAuthAccessTypeByUserAuthType(userAuthType, authAccessType);
1863 #else
1864 (void)userAuthType;
1865 (void)authAccessType;
1866 (void)challengeType;
1867 return HKS_SUCCESS;
1868 #endif
1869 }
1870
HksCheckSecureSignParams(uint32_t secureSignType)1871 int32_t HksCheckSecureSignParams(uint32_t secureSignType)
1872 {
1873 #ifdef HKS_SUPPORT_USER_AUTH_ACCESS_CONTROL
1874 return HksCheckValue(secureSignType, g_supportSecureSignType, HKS_ARRAY_SIZE(g_supportSecureSignType));
1875 #else
1876 (void)secureSignType;
1877 return HKS_SUCCESS;
1878 #endif
1879 }
1880
1881 /* If the algorithm is ed25519, the plaintext is directly cached, and if the digest is HKS_DIGEST_NONE, the
1882 hash value has been passed in by the user. So the hash value does not need to be free.
1883 */
HksCheckNeedCache(uint32_t alg,uint32_t digest)1884 int32_t HksCheckNeedCache(uint32_t alg, uint32_t digest)
1885 {
1886 if ((alg == HKS_ALG_ED25519) || (digest == HKS_DIGEST_NONE)) {
1887 HKS_LOG_I("need to cache the data");
1888 return HKS_SUCCESS;
1889 }
1890 return HKS_FAILURE;
1891 }