1 /*
2 * Copyright (c) 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 #include "hks_rsa_sign_verify_part1_test.h"
17 #include "hks_rsa_sign_verify_test_common.h"
18
19 #include <gtest/gtest.h>
20
21 using namespace testing::ext;
22 namespace Unittest::RsaSignVerify {
23 class HksRsaSignVerifyPart1Test : public testing::Test {
24 public:
25 static void SetUpTestCase(void);
26
27 static void TearDownTestCase(void);
28
29 void SetUp();
30
31 void TearDown();
32 };
33
SetUpTestCase(void)34 void HksRsaSignVerifyPart1Test::SetUpTestCase(void)
35 {
36 }
37
TearDownTestCase(void)38 void HksRsaSignVerifyPart1Test::TearDownTestCase(void)
39 {
40 }
41
SetUp()42 void HksRsaSignVerifyPart1Test::SetUp()
43 {
44 }
45
TearDown()46 void HksRsaSignVerifyPart1Test::TearDown()
47 {
48 }
49
50 static struct HksParam g_genParamsTest001[] = {
51 {
52 .tag = HKS_TAG_ALGORITHM,
53 .uint32Param = HKS_ALG_RSA
54 }, {
55 .tag = HKS_TAG_PURPOSE,
56 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
57 }, {
58 .tag = HKS_TAG_KEY_SIZE,
59 .uint32Param = HKS_RSA_KEY_SIZE_512
60 }, {
61 .tag = HKS_TAG_PADDING,
62 .uint32Param = HKS_PADDING_PKCS1_V1_5
63 }, {
64 .tag = HKS_TAG_DIGEST,
65 .uint32Param = HKS_DIGEST_MD5
66 }
67 };
68
69 static struct HksParam g_signParamsTest001[] = {
70 {
71 .tag = HKS_TAG_ALGORITHM,
72 .uint32Param = HKS_ALG_RSA
73 }, {
74 .tag = HKS_TAG_PURPOSE,
75 .uint32Param = HKS_KEY_PURPOSE_SIGN
76 }, {
77 .tag = HKS_TAG_KEY_SIZE,
78 .uint32Param = HKS_RSA_KEY_SIZE_512
79 }, {
80 .tag = HKS_TAG_PADDING,
81 .uint32Param = HKS_PADDING_PKCS1_V1_5
82 }, {
83 .tag = HKS_TAG_DIGEST,
84 .uint32Param = HKS_DIGEST_MD5
85 }
86 };
87
88 static struct HksParam g_verifyParamsTest001[] = {
89 {
90 .tag = HKS_TAG_ALGORITHM,
91 .uint32Param = HKS_ALG_RSA
92 }, {
93 .tag = HKS_TAG_PURPOSE,
94 .uint32Param = HKS_KEY_PURPOSE_VERIFY
95 }, {
96 .tag = HKS_TAG_KEY_SIZE,
97 .uint32Param = HKS_RSA_KEY_SIZE_512
98 }, {
99 .tag = HKS_TAG_PADDING,
100 .uint32Param = HKS_PADDING_PKCS1_V1_5
101 }, {
102 .tag = HKS_TAG_DIGEST,
103 .uint32Param = HKS_DIGEST_MD5
104 }
105 };
106
107 static struct HksParam g_genParamsTest002[] = {
108 {
109 .tag = HKS_TAG_ALGORITHM,
110 .uint32Param = HKS_ALG_RSA
111 }, {
112 .tag = HKS_TAG_PURPOSE,
113 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
114 }, {
115 .tag = HKS_TAG_KEY_SIZE,
116 .uint32Param = HKS_RSA_KEY_SIZE_512
117 }, {
118 .tag = HKS_TAG_PADDING,
119 .uint32Param = HKS_PADDING_PKCS1_V1_5
120 }, {
121 .tag = HKS_TAG_DIGEST,
122 .uint32Param = HKS_DIGEST_NONE
123 },
124 };
125
126 static struct HksParam g_signParamsTest002[] = {
127 {
128 .tag = HKS_TAG_ALGORITHM,
129 .uint32Param = HKS_ALG_RSA
130 }, {
131 .tag = HKS_TAG_PURPOSE,
132 .uint32Param = HKS_KEY_PURPOSE_SIGN
133 }, {
134 .tag = HKS_TAG_KEY_SIZE,
135 .uint32Param = HKS_RSA_KEY_SIZE_512
136 }, {
137 .tag = HKS_TAG_PADDING,
138 .uint32Param = HKS_PADDING_PKCS1_V1_5
139 }, {
140 .tag = HKS_TAG_DIGEST,
141 .uint32Param = HKS_DIGEST_NONE
142 }
143 };
144
145 static struct HksParam g_verifyParamsTest002[] = {
146 {
147 .tag = HKS_TAG_ALGORITHM,
148 .uint32Param = HKS_ALG_RSA
149 }, {
150 .tag = HKS_TAG_PURPOSE,
151 .uint32Param = HKS_KEY_PURPOSE_VERIFY
152 }, {
153 .tag = HKS_TAG_KEY_SIZE,
154 .uint32Param = HKS_RSA_KEY_SIZE_512
155 }, {
156 .tag = HKS_TAG_PADDING,
157 .uint32Param = HKS_PADDING_PKCS1_V1_5
158 }, {
159 .tag = HKS_TAG_DIGEST,
160 .uint32Param = HKS_DIGEST_NONE
161 }
162 };
163
164 static struct HksParam g_genParamsTest003[] = {
165 {
166 .tag = HKS_TAG_ALGORITHM,
167 .uint32Param = HKS_ALG_RSA
168 }, {
169 .tag = HKS_TAG_PURPOSE,
170 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
171 }, {
172 .tag = HKS_TAG_KEY_SIZE,
173 .uint32Param = HKS_RSA_KEY_SIZE_512
174 }, {
175 .tag = HKS_TAG_PADDING,
176 .uint32Param = HKS_PADDING_PKCS1_V1_5
177 }, {
178 .tag = HKS_TAG_DIGEST,
179 .uint32Param = HKS_DIGEST_SHA1
180 },
181 };
182 static struct HksParam g_signParamsTest003[] = {
183 {
184 .tag = HKS_TAG_ALGORITHM,
185 .uint32Param = HKS_ALG_RSA
186 }, {
187 .tag = HKS_TAG_PURPOSE,
188 .uint32Param = HKS_KEY_PURPOSE_SIGN
189 }, {
190 .tag = HKS_TAG_KEY_SIZE,
191 .uint32Param = HKS_RSA_KEY_SIZE_512
192 }, {
193 .tag = HKS_TAG_PADDING,
194 .uint32Param = HKS_PADDING_PKCS1_V1_5
195 }, {
196 .tag = HKS_TAG_DIGEST,
197 .uint32Param = HKS_DIGEST_SHA1
198 }
199 };
200 static struct HksParam g_verifyParamsTest003[] = {
201 {
202 .tag = HKS_TAG_ALGORITHM,
203 .uint32Param = HKS_ALG_RSA
204 }, {
205 .tag = HKS_TAG_PURPOSE,
206 .uint32Param = HKS_KEY_PURPOSE_VERIFY
207 }, {
208 .tag = HKS_TAG_KEY_SIZE,
209 .uint32Param = HKS_RSA_KEY_SIZE_512
210 }, {
211 .tag = HKS_TAG_PADDING,
212 .uint32Param = HKS_PADDING_PKCS1_V1_5
213 }, {
214 .tag = HKS_TAG_DIGEST,
215 .uint32Param = HKS_DIGEST_SHA1
216 }
217 };
218
219 static struct HksParam g_genParamsTest004[] = {
220 {
221 .tag = HKS_TAG_ALGORITHM,
222 .uint32Param = HKS_ALG_RSA
223 }, {
224 .tag = HKS_TAG_PURPOSE,
225 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
226 }, {
227 .tag = HKS_TAG_KEY_SIZE,
228 .uint32Param = HKS_RSA_KEY_SIZE_512
229 }, {
230 .tag = HKS_TAG_PADDING,
231 .uint32Param = HKS_PADDING_PKCS1_V1_5
232 }, {
233 .tag = HKS_TAG_DIGEST,
234 .uint32Param = HKS_DIGEST_SHA224
235 },
236 };
237 static struct HksParam g_signParamsTest004[] = {
238 {
239 .tag = HKS_TAG_ALGORITHM,
240 .uint32Param = HKS_ALG_RSA
241 }, {
242 .tag = HKS_TAG_PURPOSE,
243 .uint32Param = HKS_KEY_PURPOSE_SIGN
244 }, {
245 .tag = HKS_TAG_KEY_SIZE,
246 .uint32Param = HKS_RSA_KEY_SIZE_512
247 }, {
248 .tag = HKS_TAG_PADDING,
249 .uint32Param = HKS_PADDING_PKCS1_V1_5
250 }, {
251 .tag = HKS_TAG_DIGEST,
252 .uint32Param = HKS_DIGEST_SHA224
253 }
254 };
255 static struct HksParam g_verifyParamsTest004[] = {
256 {
257 .tag = HKS_TAG_ALGORITHM,
258 .uint32Param = HKS_ALG_RSA
259 }, {
260 .tag = HKS_TAG_PURPOSE,
261 .uint32Param = HKS_KEY_PURPOSE_VERIFY
262 }, {
263 .tag = HKS_TAG_KEY_SIZE,
264 .uint32Param = HKS_RSA_KEY_SIZE_512
265 }, {
266 .tag = HKS_TAG_PADDING,
267 .uint32Param = HKS_PADDING_PKCS1_V1_5
268 }, {
269 .tag = HKS_TAG_DIGEST,
270 .uint32Param = HKS_DIGEST_SHA224
271 }
272 };
273
274 static struct HksParam g_genParamsTest005[] = {
275 {
276 .tag = HKS_TAG_ALGORITHM,
277 .uint32Param = HKS_ALG_RSA
278 }, {
279 .tag = HKS_TAG_PURPOSE,
280 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
281 }, {
282 .tag = HKS_TAG_KEY_SIZE,
283 .uint32Param = HKS_RSA_KEY_SIZE_512
284 }, {
285 .tag = HKS_TAG_PADDING,
286 .uint32Param = HKS_PADDING_PKCS1_V1_5
287 }, {
288 .tag = HKS_TAG_DIGEST,
289 .uint32Param = HKS_DIGEST_SHA256
290 },
291 };
292 static struct HksParam g_signParamsTest005[] = {
293 {
294 .tag = HKS_TAG_ALGORITHM,
295 .uint32Param = HKS_ALG_RSA
296 }, {
297 .tag = HKS_TAG_PURPOSE,
298 .uint32Param = HKS_KEY_PURPOSE_SIGN
299 }, {
300 .tag = HKS_TAG_KEY_SIZE,
301 .uint32Param = HKS_RSA_KEY_SIZE_512
302 }, {
303 .tag = HKS_TAG_PADDING,
304 .uint32Param = HKS_PADDING_PKCS1_V1_5
305 }, {
306 .tag = HKS_TAG_DIGEST,
307 .uint32Param = HKS_DIGEST_SHA256
308 }
309 };
310 static struct HksParam g_verifyParamsTest005[] = {
311 {
312 .tag = HKS_TAG_ALGORITHM,
313 .uint32Param = HKS_ALG_RSA
314 }, {
315 .tag = HKS_TAG_PURPOSE,
316 .uint32Param = HKS_KEY_PURPOSE_VERIFY
317 }, {
318 .tag = HKS_TAG_KEY_SIZE,
319 .uint32Param = HKS_RSA_KEY_SIZE_512
320 }, {
321 .tag = HKS_TAG_PADDING,
322 .uint32Param = HKS_PADDING_PKCS1_V1_5
323 }, {
324 .tag = HKS_TAG_DIGEST,
325 .uint32Param = HKS_DIGEST_SHA256
326 }
327 };
328
329 static struct HksParam g_genParamsTest006[] = {
330 {
331 .tag = HKS_TAG_ALGORITHM,
332 .uint32Param = HKS_ALG_RSA
333 }, {
334 .tag = HKS_TAG_PURPOSE,
335 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
336 }, {
337 .tag = HKS_TAG_KEY_SIZE,
338 .uint32Param = HKS_RSA_KEY_SIZE_512
339 }, {
340 .tag = HKS_TAG_PADDING,
341 .uint32Param = HKS_PADDING_PKCS1_V1_5
342 }, {
343 .tag = HKS_TAG_DIGEST,
344 .uint32Param = HKS_DIGEST_SHA384
345 },
346 };
347 static struct HksParam g_signParamsTest006[] = {
348 {
349 .tag = HKS_TAG_ALGORITHM,
350 .uint32Param = HKS_ALG_RSA
351 }, {
352 .tag = HKS_TAG_PURPOSE,
353 .uint32Param = HKS_KEY_PURPOSE_SIGN
354 }, {
355 .tag = HKS_TAG_KEY_SIZE,
356 .uint32Param = HKS_RSA_KEY_SIZE_512
357 }, {
358 .tag = HKS_TAG_PADDING,
359 .uint32Param = HKS_PADDING_PKCS1_V1_5
360 }, {
361 .tag = HKS_TAG_DIGEST,
362 .uint32Param = HKS_DIGEST_SHA384
363 }
364 };
365 static struct HksParam g_verifyParamsTest006[] = {
366 {
367 .tag = HKS_TAG_ALGORITHM,
368 .uint32Param = HKS_ALG_RSA
369 }, {
370 .tag = HKS_TAG_PURPOSE,
371 .uint32Param = HKS_KEY_PURPOSE_VERIFY
372 }, {
373 .tag = HKS_TAG_KEY_SIZE,
374 .uint32Param = HKS_RSA_KEY_SIZE_512
375 }, {
376 .tag = HKS_TAG_PADDING,
377 .uint32Param = HKS_PADDING_PKCS1_V1_5
378 }, {
379 .tag = HKS_TAG_DIGEST,
380 .uint32Param = HKS_DIGEST_SHA384
381 }
382 };
383
384 static struct HksParam g_genParamsTest007[] = {
385 {
386 .tag = HKS_TAG_ALGORITHM,
387 .uint32Param = HKS_ALG_RSA
388 }, {
389 .tag = HKS_TAG_PURPOSE,
390 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
391 }, {
392 .tag = HKS_TAG_KEY_SIZE,
393 .uint32Param = HKS_RSA_KEY_SIZE_512
394 }, {
395 .tag = HKS_TAG_PADDING,
396 .uint32Param = HKS_PADDING_PKCS1_V1_5
397 }, {
398 .tag = HKS_TAG_DIGEST,
399 .uint32Param = HKS_DIGEST_SHA512
400 },
401 };
402 static struct HksParam g_signParamsTest007[] = {
403 {
404 .tag = HKS_TAG_ALGORITHM,
405 .uint32Param = HKS_ALG_RSA
406 }, {
407 .tag = HKS_TAG_PURPOSE,
408 .uint32Param = HKS_KEY_PURPOSE_SIGN
409 }, {
410 .tag = HKS_TAG_KEY_SIZE,
411 .uint32Param = HKS_RSA_KEY_SIZE_512
412 }, {
413 .tag = HKS_TAG_PADDING,
414 .uint32Param = HKS_PADDING_PKCS1_V1_5
415 }, {
416 .tag = HKS_TAG_DIGEST,
417 .uint32Param = HKS_DIGEST_SHA512
418 }
419 };
420 static struct HksParam g_verifyParamsTest007[] = {
421 {
422 .tag = HKS_TAG_ALGORITHM,
423 .uint32Param = HKS_ALG_RSA
424 }, {
425 .tag = HKS_TAG_PURPOSE,
426 .uint32Param = HKS_KEY_PURPOSE_VERIFY
427 }, {
428 .tag = HKS_TAG_KEY_SIZE,
429 .uint32Param = HKS_RSA_KEY_SIZE_512
430 }, {
431 .tag = HKS_TAG_PADDING,
432 .uint32Param = HKS_PADDING_PKCS1_V1_5
433 }, {
434 .tag = HKS_TAG_DIGEST,
435 .uint32Param = HKS_DIGEST_SHA512
436 }
437 };
438
439 static struct HksParam g_genParamsTest008[] = {
440 {
441 .tag = HKS_TAG_ALGORITHM,
442 .uint32Param = HKS_ALG_RSA
443 }, {
444 .tag = HKS_TAG_PURPOSE,
445 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
446 }, {
447 .tag = HKS_TAG_KEY_SIZE,
448 .uint32Param = HKS_RSA_KEY_SIZE_512
449 }, {
450 .tag = HKS_TAG_PADDING,
451 .uint32Param = HKS_PADDING_PSS
452 }, {
453 .tag = HKS_TAG_DIGEST,
454 .uint32Param = HKS_DIGEST_SHA1
455 },
456 };
457 static struct HksParam g_signParamsTest008[] = {
458 {
459 .tag = HKS_TAG_ALGORITHM,
460 .uint32Param = HKS_ALG_RSA
461 }, {
462 .tag = HKS_TAG_PURPOSE,
463 .uint32Param = HKS_KEY_PURPOSE_SIGN
464 }, {
465 .tag = HKS_TAG_KEY_SIZE,
466 .uint32Param = HKS_RSA_KEY_SIZE_512
467 }, {
468 .tag = HKS_TAG_PADDING,
469 .uint32Param = HKS_PADDING_PSS
470 }, {
471 .tag = HKS_TAG_DIGEST,
472 .uint32Param = HKS_DIGEST_SHA1
473 }
474 };
475 static struct HksParam g_verifyParamsTest008[] = {
476 {
477 .tag = HKS_TAG_ALGORITHM,
478 .uint32Param = HKS_ALG_RSA
479 }, {
480 .tag = HKS_TAG_PURPOSE,
481 .uint32Param = HKS_KEY_PURPOSE_VERIFY
482 }, {
483 .tag = HKS_TAG_KEY_SIZE,
484 .uint32Param = HKS_RSA_KEY_SIZE_512
485 }, {
486 .tag = HKS_TAG_PADDING,
487 .uint32Param = HKS_PADDING_PSS
488 }, {
489 .tag = HKS_TAG_DIGEST,
490 .uint32Param = HKS_DIGEST_SHA1
491 }
492 };
493
494 static struct HksParam g_genParamsTest009[] = {
495 {
496 .tag = HKS_TAG_ALGORITHM,
497 .uint32Param = HKS_ALG_RSA
498 }, {
499 .tag = HKS_TAG_PURPOSE,
500 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
501 }, {
502 .tag = HKS_TAG_KEY_SIZE,
503 .uint32Param = HKS_RSA_KEY_SIZE_512
504 }, {
505 .tag = HKS_TAG_PADDING,
506 .uint32Param = HKS_PADDING_PSS
507 }, {
508 .tag = HKS_TAG_DIGEST,
509 .uint32Param = HKS_DIGEST_SHA224
510 },
511 };
512 static struct HksParam g_signParamsTest009[] = {
513 {
514 .tag = HKS_TAG_ALGORITHM,
515 .uint32Param = HKS_ALG_RSA
516 }, {
517 .tag = HKS_TAG_PURPOSE,
518 .uint32Param = HKS_KEY_PURPOSE_SIGN
519 }, {
520 .tag = HKS_TAG_KEY_SIZE,
521 .uint32Param = HKS_RSA_KEY_SIZE_512
522 }, {
523 .tag = HKS_TAG_PADDING,
524 .uint32Param = HKS_PADDING_PSS
525 }, {
526 .tag = HKS_TAG_DIGEST,
527 .uint32Param = HKS_DIGEST_SHA224
528 }
529 };
530 static struct HksParam g_verifyParamsTest009[] = {
531 {
532 .tag = HKS_TAG_ALGORITHM,
533 .uint32Param = HKS_ALG_RSA
534 }, {
535 .tag = HKS_TAG_PURPOSE,
536 .uint32Param = HKS_KEY_PURPOSE_VERIFY
537 }, {
538 .tag = HKS_TAG_KEY_SIZE,
539 .uint32Param = HKS_RSA_KEY_SIZE_512
540 }, {
541 .tag = HKS_TAG_PADDING,
542 .uint32Param = HKS_PADDING_PSS
543 }, {
544 .tag = HKS_TAG_DIGEST,
545 .uint32Param = HKS_DIGEST_SHA224
546 }
547 };
548
549 static struct HksParam g_genParamsTest010[] = {
550 {
551 .tag = HKS_TAG_ALGORITHM,
552 .uint32Param = HKS_ALG_RSA
553 }, {
554 .tag = HKS_TAG_PURPOSE,
555 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
556 }, {
557 .tag = HKS_TAG_KEY_SIZE,
558 .uint32Param = HKS_RSA_KEY_SIZE_512
559 }, {
560 .tag = HKS_TAG_PADDING,
561 .uint32Param = HKS_PADDING_PSS
562 }, {
563 .tag = HKS_TAG_DIGEST,
564 .uint32Param = HKS_DIGEST_SHA256
565 },
566 };
567 static struct HksParam g_signParamsTest010[] = {
568 {
569 .tag = HKS_TAG_ALGORITHM,
570 .uint32Param = HKS_ALG_RSA
571 }, {
572 .tag = HKS_TAG_PURPOSE,
573 .uint32Param = HKS_KEY_PURPOSE_SIGN
574 }, {
575 .tag = HKS_TAG_KEY_SIZE,
576 .uint32Param = HKS_RSA_KEY_SIZE_512
577 }, {
578 .tag = HKS_TAG_PADDING,
579 .uint32Param = HKS_PADDING_PSS
580 }, {
581 .tag = HKS_TAG_DIGEST,
582 .uint32Param = HKS_DIGEST_SHA256
583 }
584 };
585 static struct HksParam g_verifyParamsTest010[] = {
586 {
587 .tag = HKS_TAG_ALGORITHM,
588 .uint32Param = HKS_ALG_RSA
589 }, {
590 .tag = HKS_TAG_PURPOSE,
591 .uint32Param = HKS_KEY_PURPOSE_VERIFY
592 }, {
593 .tag = HKS_TAG_KEY_SIZE,
594 .uint32Param = HKS_RSA_KEY_SIZE_512
595 }, {
596 .tag = HKS_TAG_PADDING,
597 .uint32Param = HKS_PADDING_PSS
598 }, {
599 .tag = HKS_TAG_DIGEST,
600 .uint32Param = HKS_DIGEST_SHA256
601 }
602 };
603
604 /**
605 * @tc.name: HksRsaSignVerifyPart1Test.HksRsaSignVerifyPart1Test001
606 * @tc.desc: alg-RSA pur-Sign pad-PKCS1_V1_5 digest-MD5.
607 * @tc.type: FUNC
608 */
609 HWTEST_F(HksRsaSignVerifyPart1Test, HksRsaSignVerifyPart1Test001, TestSize.Level0)
610 {
611 int32_t ret = HKS_FAILURE;
612 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest001";
613 struct HksParamSet *genParamSet = nullptr;
614 struct HksParamSet *signParamSet = nullptr;
615 struct HksParamSet *verifyParamSet = nullptr;
616
617 ret = InitParamSet(&genParamSet, g_genParamsTest001, sizeof(g_genParamsTest001)/sizeof(HksParam));
618 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
619 ret = InitParamSet(&signParamSet, g_signParamsTest001, sizeof(g_signParamsTest001)/sizeof(HksParam));
620 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
621 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest001, sizeof(g_verifyParamsTest001)/sizeof(HksParam));
622 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
623
624 /* Generate Key */
625 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
626
627 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
628 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
629 }
630
631 /* Delete Key */
632 ret = HksDeleteKey(&keyAlias, genParamSet);
633 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
634
635 HksFreeParamSet(&genParamSet);
636 HksFreeParamSet(&signParamSet);
637 HksFreeParamSet(&verifyParamSet);
638 }
639
640 /**
641 * @tc.name: HksRsaSignVerifyPart1Test.HksRsaSignVerifyPart1Test002
642 * @tc.desc: alg-RSA pur-Sign pad-PKCS1_V1_5 digest-NONE.
643 * @tc.type: FUNC
644 */
645 HWTEST_F(HksRsaSignVerifyPart1Test, HksRsaSignVerifyPart1Test002, TestSize.Level0)
646 {
647 int32_t ret = HKS_FAILURE;
648 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest002";
649 struct HksParamSet *genParamSet = nullptr;
650 struct HksParamSet *signParamSet = nullptr;
651 struct HksParamSet *verifyParamSet = nullptr;
652
653 ret = InitParamSet(&genParamSet, g_genParamsTest002, sizeof(g_genParamsTest002)/sizeof(HksParam));
654 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
655 ret = InitParamSet(&signParamSet, g_signParamsTest002, sizeof(g_signParamsTest002)/sizeof(HksParam));
656 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
657 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest002, sizeof(g_verifyParamsTest002)/sizeof(HksParam));
658 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
659
660 /* Generate Key */
661 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
662
663 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
664 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
665 }
666
667 /* Delete Key */
668 ret = HksDeleteKey(&keyAlias, genParamSet);
669 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
670
671 HksFreeParamSet(&genParamSet);
672 HksFreeParamSet(&signParamSet);
673 HksFreeParamSet(&verifyParamSet);
674 }
675
676 /**
677 * @tc.name: HksRsaSignVerifyPart1Test.HksRsaSignVerifyPart1Test003
678 * @tc.desc: alg-RSA pur-Sign pad-PKCS1_V1_5 digest-SHA1.
679 * @tc.type: FUNC
680 */
681 HWTEST_F(HksRsaSignVerifyPart1Test, HksRsaSignVerifyPart1Test003, TestSize.Level0)
682 {
683 int32_t ret = HKS_FAILURE;
684 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest003";
685 struct HksParamSet *genParamSet = nullptr;
686 struct HksParamSet *signParamSet = nullptr;
687 struct HksParamSet *verifyParamSet = nullptr;
688
689 ret = InitParamSet(&genParamSet, g_genParamsTest003, sizeof(g_genParamsTest003)/sizeof(HksParam));
690 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
691 ret = InitParamSet(&signParamSet, g_signParamsTest003, sizeof(g_signParamsTest003)/sizeof(HksParam));
692 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
693 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest003, sizeof(g_verifyParamsTest003)/sizeof(HksParam));
694 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
695
696 /* Generate Key */
697 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
698
699 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
700 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
701 }
702
703 /* Delete Key */
704 ret = HksDeleteKey(&keyAlias, genParamSet);
705 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
706
707 HksFreeParamSet(&genParamSet);
708 HksFreeParamSet(&signParamSet);
709 HksFreeParamSet(&verifyParamSet);
710 }
711
712 /**
713 * @tc.name: HksRsaSignVerifyPart1Test.HksRsaSignVerifyPart1Test004
714 * @tc.desc: alg-RSA pur-Sign pad-PKCS1_V1_5 digest-SHA224.
715 * @tc.type: FUNC
716 */
717 HWTEST_F(HksRsaSignVerifyPart1Test, HksRsaSignVerifyPart1Test004, TestSize.Level0)
718 {
719 int32_t ret = HKS_FAILURE;
720 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest004";
721 struct HksParamSet *genParamSet = nullptr;
722 struct HksParamSet *signParamSet = nullptr;
723 struct HksParamSet *verifyParamSet = nullptr;
724
725 ret = InitParamSet(&genParamSet, g_genParamsTest004, sizeof(g_genParamsTest004)/sizeof(HksParam));
726 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
727 ret = InitParamSet(&signParamSet, g_signParamsTest004, sizeof(g_signParamsTest004)/sizeof(HksParam));
728 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
729 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest004, sizeof(g_verifyParamsTest004)/sizeof(HksParam));
730 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
731
732 /* Generate Key */
733 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
734
735 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
736 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
737 }
738
739 /* Delete Key */
740 ret = HksDeleteKey(&keyAlias, genParamSet);
741 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
742
743 HksFreeParamSet(&genParamSet);
744 HksFreeParamSet(&signParamSet);
745 HksFreeParamSet(&verifyParamSet);
746 }
747
748 /**
749 * @tc.name: HksRsaSignVerifyPart1Test.HksRsaSignVerifyPart1Test005
750 * @tc.desc: alg-RSA pur-Sign pad-PKCS1_V1_5 digest-SHA256.
751 * @tc.type: FUNC
752 */
753 HWTEST_F(HksRsaSignVerifyPart1Test, HksRsaSignVerifyPart1Test005, TestSize.Level0)
754 {
755 int32_t ret = HKS_FAILURE;
756 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest005";
757 struct HksParamSet *genParamSet = nullptr;
758 struct HksParamSet *signParamSet = nullptr;
759 struct HksParamSet *verifyParamSet = nullptr;
760
761 ret = InitParamSet(&genParamSet, g_genParamsTest005, sizeof(g_genParamsTest005)/sizeof(HksParam));
762 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
763 ret = InitParamSet(&signParamSet, g_signParamsTest005, sizeof(g_signParamsTest005)/sizeof(HksParam));
764 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
765 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest005, sizeof(g_verifyParamsTest005)/sizeof(HksParam));
766 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
767
768 /* Generate Key */
769 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
770
771 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
772 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
773 }
774
775 /* Delete Key */
776 ret = HksDeleteKey(&keyAlias, genParamSet);
777 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
778
779 HksFreeParamSet(&genParamSet);
780 HksFreeParamSet(&signParamSet);
781 HksFreeParamSet(&verifyParamSet);
782 }
783
784 /**
785 * @tc.name: HksRsaSignVerifyPart1Test.HksRsaSignVerifyPart1Test006
786 * @tc.desc: alg-RSA pur-Sign pad-PKCS1_V1_5 digest-MD5.
787 * @tc.type: FUNC
788 */
789 HWTEST_F(HksRsaSignVerifyPart1Test, HksRsaSignVerifyPart1Test006, TestSize.Level0)
790 {
791 int32_t ret = HKS_FAILURE;
792 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest006";
793 struct HksParamSet *genParamSet = nullptr;
794 struct HksParamSet *signParamSet = nullptr;
795 struct HksParamSet *verifyParamSet = nullptr;
796
797 ret = InitParamSet(&genParamSet, g_genParamsTest006, sizeof(g_genParamsTest006)/sizeof(HksParam));
798 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
799 ret = InitParamSet(&signParamSet, g_signParamsTest006, sizeof(g_signParamsTest006)/sizeof(HksParam));
800 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
801 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest006, sizeof(g_verifyParamsTest006)/sizeof(HksParam));
802 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
803
804 /* Generate Key */
805 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
806
807 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
808 ret = HksRSASignVerifyTestAbnormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
809 }
810
811 /* Delete Key */
812 ret = HksDeleteKey(&keyAlias, genParamSet);
813 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
814
815 HksFreeParamSet(&genParamSet);
816 HksFreeParamSet(&signParamSet);
817 HksFreeParamSet(&verifyParamSet);
818 }
819
820 /**
821 * @tc.name: HksRsaSignVerifyPart1Test.HksRsaSignVerifyPart1Test007
822 * @tc.desc: alg-RSA pur-Sign pad-PKCS1_V1_5 digest-SHA512.
823 * @tc.type: FUNC
824 */
825 HWTEST_F(HksRsaSignVerifyPart1Test, HksRsaSignVerifyPart1Test007, TestSize.Level0)
826 {
827 int32_t ret = HKS_FAILURE;
828 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest007";
829 struct HksParamSet *genParamSet = nullptr;
830 struct HksParamSet *signParamSet = nullptr;
831 struct HksParamSet *verifyParamSet = nullptr;
832
833 ret = InitParamSet(&genParamSet, g_genParamsTest007, sizeof(g_genParamsTest007)/sizeof(HksParam));
834 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
835 ret = InitParamSet(&signParamSet, g_signParamsTest007, sizeof(g_signParamsTest007)/sizeof(HksParam));
836 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
837 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest007, sizeof(g_verifyParamsTest007)/sizeof(HksParam));
838 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
839
840 /* Generate Key */
841 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
842
843 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
844 ret = HksRSASignVerifyTestAbnormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
845 }
846
847 /* Delete Key */
848 ret = HksDeleteKey(&keyAlias, genParamSet);
849 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
850
851 HksFreeParamSet(&genParamSet);
852 HksFreeParamSet(&signParamSet);
853 HksFreeParamSet(&verifyParamSet);
854 }
855
856 /**
857 * @tc.name: HksRsaSignVerifyPart1Test.HksRsaSignVerifyPart1Test008
858 * @tc.desc: alg-RSA pur-Sign pad-PSS digest-SHA1.
859 * @tc.type: FUNC
860 */
861 HWTEST_F(HksRsaSignVerifyPart1Test, HksRsaSignVerifyPart1Test008, TestSize.Level0)
862 {
863 int32_t ret = HKS_FAILURE;
864 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest008";
865 struct HksParamSet *genParamSet = nullptr;
866 struct HksParamSet *signParamSet = nullptr;
867 struct HksParamSet *verifyParamSet = nullptr;
868
869 ret = InitParamSet(&genParamSet, g_genParamsTest008, sizeof(g_genParamsTest008)/sizeof(HksParam));
870 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
871 ret = InitParamSet(&signParamSet, g_signParamsTest008, sizeof(g_signParamsTest008)/sizeof(HksParam));
872 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
873 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest008, sizeof(g_verifyParamsTest008)/sizeof(HksParam));
874 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
875
876 /* Generate Key */
877 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
878
879 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
880 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
881 }
882
883 /* Delete Key */
884 ret = HksDeleteKey(&keyAlias, genParamSet);
885 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
886
887 HksFreeParamSet(&genParamSet);
888 HksFreeParamSet(&signParamSet);
889 HksFreeParamSet(&verifyParamSet);
890 }
891
892 /**
893 * @tc.name: HksRsaSignVerifyPart1Test.HksRsaSignVerifyPart1Test009
894 * @tc.desc: alg-RSA pur-Sign pad-PSS digest-SHA224.
895 * @tc.type: FUNC
896 */
897 HWTEST_F(HksRsaSignVerifyPart1Test, HksRsaSignVerifyPart1Test009, TestSize.Level0)
898 {
899 int32_t ret = HKS_FAILURE;
900 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest009";
901 struct HksParamSet *genParamSet = nullptr;
902 struct HksParamSet *signParamSet = nullptr;
903 struct HksParamSet *verifyParamSet = nullptr;
904
905 ret = InitParamSet(&genParamSet, g_genParamsTest009, sizeof(g_genParamsTest009)/sizeof(HksParam));
906 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
907 ret = InitParamSet(&signParamSet, g_signParamsTest009, sizeof(g_signParamsTest009)/sizeof(HksParam));
908 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
909 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest009, sizeof(g_verifyParamsTest009)/sizeof(HksParam));
910 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
911
912 /* Generate Key */
913 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
914
915 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
916 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
917 }
918
919 /* Delete Key */
920 ret = HksDeleteKey(&keyAlias, genParamSet);
921 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
922
923 HksFreeParamSet(&genParamSet);
924 HksFreeParamSet(&signParamSet);
925 HksFreeParamSet(&verifyParamSet);
926 }
927
928 /**
929 * @tc.name: HksRsaSignVerifyPart1Test.HksRsaSignVerifyPart1Test010
930 * @tc.desc: alg-RSA pur-Sign pad-PKCS1_V1_5 digest-MD5.
931 * @tc.type: FUNC
932 */
933 HWTEST_F(HksRsaSignVerifyPart1Test, HksRsaSignVerifyPart1Test010, TestSize.Level0)
934 {
935 int32_t ret = HKS_FAILURE;
936 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest010";
937 struct HksParamSet *genParamSet = nullptr;
938 struct HksParamSet *signParamSet = nullptr;
939 struct HksParamSet *verifyParamSet = nullptr;
940
941 ret = InitParamSet(&genParamSet, g_genParamsTest010, sizeof(g_genParamsTest010)/sizeof(HksParam));
942 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
943 ret = InitParamSet(&signParamSet, g_signParamsTest010, sizeof(g_signParamsTest010)/sizeof(HksParam));
944 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
945 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest010, sizeof(g_verifyParamsTest010)/sizeof(HksParam));
946 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
947
948 /* Generate Key */
949 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
950
951 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
952 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
953 }
954
955 /* Delete Key */
956 ret = HksDeleteKey(&keyAlias, genParamSet);
957 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
958
959 HksFreeParamSet(&genParamSet);
960 HksFreeParamSet(&signParamSet);
961 HksFreeParamSet(&verifyParamSet);
962 }
963 }