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