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