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