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_part3_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 HksRsaSignVerifyPart3Test : 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 HksRsaSignVerifyPart3Test::SetUpTestCase(void)
35 {
36 }
37
TearDownTestCase(void)38 void HksRsaSignVerifyPart3Test::TearDownTestCase(void)
39 {
40 }
41
SetUp()42 void HksRsaSignVerifyPart3Test::SetUp()
43 {
44 }
45
TearDown()46 void HksRsaSignVerifyPart3Test::TearDown()
47 {
48 }
49
50 static struct HksParam g_genParamsTest021[] = {
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_768
60 }, {
61 .tag = HKS_TAG_PADDING,
62 .uint32Param = HKS_PADDING_PSS
63 }, {
64 .tag = HKS_TAG_DIGEST,
65 .uint32Param = HKS_DIGEST_SHA224
66 },
67 };
68 static struct HksParam g_signParamsTest021[] = {
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_768
78 }, {
79 .tag = HKS_TAG_PADDING,
80 .uint32Param = HKS_PADDING_PSS
81 }, {
82 .tag = HKS_TAG_DIGEST,
83 .uint32Param = HKS_DIGEST_SHA224
84 }
85 };
86 static struct HksParam g_verifyParamsTest021[] = {
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_768
96 }, {
97 .tag = HKS_TAG_PADDING,
98 .uint32Param = HKS_PADDING_PSS
99 }, {
100 .tag = HKS_TAG_DIGEST,
101 .uint32Param = HKS_DIGEST_SHA224
102 }
103 };
104 static struct HksParam g_genParamsTest022[] = {
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_768
114 }, {
115 .tag = HKS_TAG_PADDING,
116 .uint32Param = HKS_PADDING_PSS
117 }, {
118 .tag = HKS_TAG_DIGEST,
119 .uint32Param = HKS_DIGEST_SHA256
120 },
121 };
122 static struct HksParam g_signParamsTest022[] = {
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_768
132 }, {
133 .tag = HKS_TAG_PADDING,
134 .uint32Param = HKS_PADDING_PSS
135 }, {
136 .tag = HKS_TAG_DIGEST,
137 .uint32Param = HKS_DIGEST_SHA256
138 }
139 };
140 static struct HksParam g_verifyParamsTest022[] = {
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_768
150 }, {
151 .tag = HKS_TAG_PADDING,
152 .uint32Param = HKS_PADDING_PSS
153 }, {
154 .tag = HKS_TAG_DIGEST,
155 .uint32Param = HKS_DIGEST_SHA256
156 }
157 };
158 static struct HksParam g_genParamsTest023[] = {
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_768
168 }, {
169 .tag = HKS_TAG_PADDING,
170 .uint32Param = HKS_PADDING_PSS
171 }, {
172 .tag = HKS_TAG_DIGEST,
173 .uint32Param = HKS_DIGEST_SHA384
174 },
175 };
176 static struct HksParam g_signParamsTest023[] = {
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_768
186 }, {
187 .tag = HKS_TAG_PADDING,
188 .uint32Param = HKS_PADDING_PSS
189 }, {
190 .tag = HKS_TAG_DIGEST,
191 .uint32Param = HKS_DIGEST_SHA384
192 }
193 };
194 static struct HksParam g_verifyParamsTest023[] = {
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_768
204 }, {
205 .tag = HKS_TAG_PADDING,
206 .uint32Param = HKS_PADDING_PSS
207 }, {
208 .tag = HKS_TAG_DIGEST,
209 .uint32Param = HKS_DIGEST_SHA384
210 }
211 };
212 #ifdef _USE_OPENSSL_
213 static struct HksParam g_genParamsTest024[] = {
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_768
223 }, {
224 .tag = HKS_TAG_PADDING,
225 .uint32Param = HKS_PADDING_PSS
226 }, {
227 .tag = HKS_TAG_DIGEST,
228 .uint32Param = HKS_DIGEST_SHA512
229 },
230 };
231 static struct HksParam g_signParamsTest024[] = {
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_768
241 }, {
242 .tag = HKS_TAG_PADDING,
243 .uint32Param = HKS_PADDING_PSS
244 }, {
245 .tag = HKS_TAG_DIGEST,
246 .uint32Param = HKS_DIGEST_SHA512
247 }
248 };
249 static struct HksParam g_verifyParamsTest024[] = {
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_768
259 }, {
260 .tag = HKS_TAG_PADDING,
261 .uint32Param = HKS_PADDING_PSS
262 }, {
263 .tag = HKS_TAG_DIGEST,
264 .uint32Param = HKS_DIGEST_SHA512
265 }
266 };
267 #endif
268 static struct HksParam g_genParamsTest025[] = {
269 {
270 .tag = HKS_TAG_ALGORITHM,
271 .uint32Param = HKS_ALG_RSA
272 }, {
273 .tag = HKS_TAG_PURPOSE,
274 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
275 }, {
276 .tag = HKS_TAG_KEY_SIZE,
277 .uint32Param = HKS_RSA_KEY_SIZE_1024
278 }, {
279 .tag = HKS_TAG_PADDING,
280 .uint32Param = HKS_PADDING_PKCS1_V1_5
281 }, {
282 .tag = HKS_TAG_DIGEST,
283 .uint32Param = HKS_DIGEST_MD5
284 },
285 };
286 static struct HksParam g_signParamsTest025[] = {
287 {
288 .tag = HKS_TAG_ALGORITHM,
289 .uint32Param = HKS_ALG_RSA
290 }, {
291 .tag = HKS_TAG_PURPOSE,
292 .uint32Param = HKS_KEY_PURPOSE_SIGN
293 }, {
294 .tag = HKS_TAG_KEY_SIZE,
295 .uint32Param = HKS_RSA_KEY_SIZE_1024
296 }, {
297 .tag = HKS_TAG_PADDING,
298 .uint32Param = HKS_PADDING_PKCS1_V1_5
299 }, {
300 .tag = HKS_TAG_DIGEST,
301 .uint32Param = HKS_DIGEST_MD5
302 }
303 };
304 static struct HksParam g_verifyParamsTest025[] = {
305 {
306 .tag = HKS_TAG_ALGORITHM,
307 .uint32Param = HKS_ALG_RSA
308 }, {
309 .tag = HKS_TAG_PURPOSE,
310 .uint32Param = HKS_KEY_PURPOSE_VERIFY
311 }, {
312 .tag = HKS_TAG_KEY_SIZE,
313 .uint32Param = HKS_RSA_KEY_SIZE_1024
314 }, {
315 .tag = HKS_TAG_PADDING,
316 .uint32Param = HKS_PADDING_PKCS1_V1_5
317 }, {
318 .tag = HKS_TAG_DIGEST,
319 .uint32Param = HKS_DIGEST_MD5
320 }
321 };
322 static struct HksParam g_genParamsTest026[] = {
323 {
324 .tag = HKS_TAG_ALGORITHM,
325 .uint32Param = HKS_ALG_RSA
326 }, {
327 .tag = HKS_TAG_PURPOSE,
328 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
329 }, {
330 .tag = HKS_TAG_KEY_SIZE,
331 .uint32Param = HKS_RSA_KEY_SIZE_1024
332 }, {
333 .tag = HKS_TAG_PADDING,
334 .uint32Param = HKS_PADDING_PKCS1_V1_5
335 }, {
336 .tag = HKS_TAG_DIGEST,
337 .uint32Param = HKS_DIGEST_NONE
338 },
339 };
340 static struct HksParam g_signParamsTest026[] = {
341 {
342 .tag = HKS_TAG_ALGORITHM,
343 .uint32Param = HKS_ALG_RSA
344 }, {
345 .tag = HKS_TAG_PURPOSE,
346 .uint32Param = HKS_KEY_PURPOSE_SIGN
347 }, {
348 .tag = HKS_TAG_KEY_SIZE,
349 .uint32Param = HKS_RSA_KEY_SIZE_1024
350 }, {
351 .tag = HKS_TAG_PADDING,
352 .uint32Param = HKS_PADDING_PKCS1_V1_5
353 }, {
354 .tag = HKS_TAG_DIGEST,
355 .uint32Param = HKS_DIGEST_NONE
356 }
357 };
358 static struct HksParam g_verifyParamsTest026[] = {
359 {
360 .tag = HKS_TAG_ALGORITHM,
361 .uint32Param = HKS_ALG_RSA
362 }, {
363 .tag = HKS_TAG_PURPOSE,
364 .uint32Param = HKS_KEY_PURPOSE_VERIFY
365 }, {
366 .tag = HKS_TAG_KEY_SIZE,
367 .uint32Param = HKS_RSA_KEY_SIZE_1024
368 }, {
369 .tag = HKS_TAG_PADDING,
370 .uint32Param = HKS_PADDING_PKCS1_V1_5
371 }, {
372 .tag = HKS_TAG_DIGEST,
373 .uint32Param = HKS_DIGEST_NONE
374 }
375 };
376 static struct HksParam g_genParamsTest027[] = {
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_1024
386 }, {
387 .tag = HKS_TAG_PADDING,
388 .uint32Param = HKS_PADDING_PKCS1_V1_5
389 }, {
390 .tag = HKS_TAG_DIGEST,
391 .uint32Param = HKS_DIGEST_SHA1
392 },
393 };
394 static struct HksParam g_signParamsTest027[] = {
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_1024
404 }, {
405 .tag = HKS_TAG_PADDING,
406 .uint32Param = HKS_PADDING_PKCS1_V1_5
407 }, {
408 .tag = HKS_TAG_DIGEST,
409 .uint32Param = HKS_DIGEST_SHA1
410 }
411 };
412 static struct HksParam g_verifyParamsTest027[] = {
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_1024
422 }, {
423 .tag = HKS_TAG_PADDING,
424 .uint32Param = HKS_PADDING_PKCS1_V1_5
425 }, {
426 .tag = HKS_TAG_DIGEST,
427 .uint32Param = HKS_DIGEST_SHA1
428 }
429 };
430
431 static struct HksParam g_genParamsTest028[] = {
432 {
433 .tag = HKS_TAG_ALGORITHM,
434 .uint32Param = HKS_ALG_RSA
435 }, {
436 .tag = HKS_TAG_PURPOSE,
437 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
438 }, {
439 .tag = HKS_TAG_KEY_SIZE,
440 .uint32Param = HKS_RSA_KEY_SIZE_1024
441 }, {
442 .tag = HKS_TAG_PADDING,
443 .uint32Param = HKS_PADDING_PKCS1_V1_5
444 }, {
445 .tag = HKS_TAG_DIGEST,
446 .uint32Param = HKS_DIGEST_SHA224
447 },
448 };
449 static struct HksParam g_signParamsTest028[] = {
450 {
451 .tag = HKS_TAG_ALGORITHM,
452 .uint32Param = HKS_ALG_RSA
453 }, {
454 .tag = HKS_TAG_PURPOSE,
455 .uint32Param = HKS_KEY_PURPOSE_SIGN
456 }, {
457 .tag = HKS_TAG_KEY_SIZE,
458 .uint32Param = HKS_RSA_KEY_SIZE_1024
459 }, {
460 .tag = HKS_TAG_PADDING,
461 .uint32Param = HKS_PADDING_PKCS1_V1_5
462 }, {
463 .tag = HKS_TAG_DIGEST,
464 .uint32Param = HKS_DIGEST_SHA224
465 }
466 };
467 static struct HksParam g_verifyParamsTest028[] = {
468 {
469 .tag = HKS_TAG_ALGORITHM,
470 .uint32Param = HKS_ALG_RSA
471 }, {
472 .tag = HKS_TAG_PURPOSE,
473 .uint32Param = HKS_KEY_PURPOSE_VERIFY
474 }, {
475 .tag = HKS_TAG_KEY_SIZE,
476 .uint32Param = HKS_RSA_KEY_SIZE_1024
477 }, {
478 .tag = HKS_TAG_PADDING,
479 .uint32Param = HKS_PADDING_PKCS1_V1_5
480 }, {
481 .tag = HKS_TAG_DIGEST,
482 .uint32Param = HKS_DIGEST_SHA224
483 }
484 };
485 static struct HksParam g_genParamsTest029[] = {
486 {
487 .tag = HKS_TAG_ALGORITHM,
488 .uint32Param = HKS_ALG_RSA
489 }, {
490 .tag = HKS_TAG_PURPOSE,
491 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
492 }, {
493 .tag = HKS_TAG_KEY_SIZE,
494 .uint32Param = HKS_RSA_KEY_SIZE_1024
495 }, {
496 .tag = HKS_TAG_PADDING,
497 .uint32Param = HKS_PADDING_PKCS1_V1_5
498 }, {
499 .tag = HKS_TAG_DIGEST,
500 .uint32Param = HKS_DIGEST_SHA256
501 },
502 };
503 static struct HksParam g_signParamsTest029[] = {
504 {
505 .tag = HKS_TAG_ALGORITHM,
506 .uint32Param = HKS_ALG_RSA
507 }, {
508 .tag = HKS_TAG_PURPOSE,
509 .uint32Param = HKS_KEY_PURPOSE_SIGN
510 }, {
511 .tag = HKS_TAG_KEY_SIZE,
512 .uint32Param = HKS_RSA_KEY_SIZE_1024
513 }, {
514 .tag = HKS_TAG_PADDING,
515 .uint32Param = HKS_PADDING_PKCS1_V1_5
516 }, {
517 .tag = HKS_TAG_DIGEST,
518 .uint32Param = HKS_DIGEST_SHA256
519 }
520 };
521 static struct HksParam g_verifyParamsTest029[] = {
522 {
523 .tag = HKS_TAG_ALGORITHM,
524 .uint32Param = HKS_ALG_RSA
525 }, {
526 .tag = HKS_TAG_PURPOSE,
527 .uint32Param = HKS_KEY_PURPOSE_VERIFY
528 }, {
529 .tag = HKS_TAG_KEY_SIZE,
530 .uint32Param = HKS_RSA_KEY_SIZE_1024
531 }, {
532 .tag = HKS_TAG_PADDING,
533 .uint32Param = HKS_PADDING_PKCS1_V1_5
534 }, {
535 .tag = HKS_TAG_DIGEST,
536 .uint32Param = HKS_DIGEST_SHA256
537 }
538 };
539
540 static struct HksParam g_genParamsTest030[] = {
541 {
542 .tag = HKS_TAG_ALGORITHM,
543 .uint32Param = HKS_ALG_RSA
544 }, {
545 .tag = HKS_TAG_PURPOSE,
546 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
547 }, {
548 .tag = HKS_TAG_KEY_SIZE,
549 .uint32Param = HKS_RSA_KEY_SIZE_1024
550 }, {
551 .tag = HKS_TAG_PADDING,
552 .uint32Param = HKS_PADDING_PKCS1_V1_5
553 }, {
554 .tag = HKS_TAG_DIGEST,
555 .uint32Param = HKS_DIGEST_SHA384
556 },
557 };
558 static struct HksParam g_signParamsTest030[] = {
559 {
560 .tag = HKS_TAG_ALGORITHM,
561 .uint32Param = HKS_ALG_RSA
562 }, {
563 .tag = HKS_TAG_PURPOSE,
564 .uint32Param = HKS_KEY_PURPOSE_SIGN
565 }, {
566 .tag = HKS_TAG_KEY_SIZE,
567 .uint32Param = HKS_RSA_KEY_SIZE_1024
568 }, {
569 .tag = HKS_TAG_PADDING,
570 .uint32Param = HKS_PADDING_PKCS1_V1_5
571 }, {
572 .tag = HKS_TAG_DIGEST,
573 .uint32Param = HKS_DIGEST_SHA384
574 }
575 };
576 static struct HksParam g_verifyParamsTest030[] = {
577 {
578 .tag = HKS_TAG_ALGORITHM,
579 .uint32Param = HKS_ALG_RSA
580 }, {
581 .tag = HKS_TAG_PURPOSE,
582 .uint32Param = HKS_KEY_PURPOSE_VERIFY
583 }, {
584 .tag = HKS_TAG_KEY_SIZE,
585 .uint32Param = HKS_RSA_KEY_SIZE_1024
586 }, {
587 .tag = HKS_TAG_PADDING,
588 .uint32Param = HKS_PADDING_PKCS1_V1_5
589 }, {
590 .tag = HKS_TAG_DIGEST,
591 .uint32Param = HKS_DIGEST_SHA384
592 }
593 };
594
595 /**
596 * @tc.name: HksRsaSignVerifyPart3Test.HksRsaSignVerifyPart3Test021
597 * @tc.desc: alg-RSA pur-Sign pad-PSS digest-SHA224.
598 * @tc.type: FUNC
599 */
600 HWTEST_F(HksRsaSignVerifyPart3Test, HksRsaSignVerifyPart3Test021, TestSize.Level0)
601 {
602 int32_t ret = HKS_FAILURE;
603 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest021";
604 struct HksParamSet *genParamSet = nullptr;
605 struct HksParamSet *signParamSet = nullptr;
606 struct HksParamSet *verifyParamSet = nullptr;
607
608 ret = InitParamSet(&genParamSet, g_genParamsTest021, sizeof(g_genParamsTest021)/sizeof(HksParam));
609 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
610 ret = InitParamSet(&signParamSet, g_signParamsTest021, sizeof(g_signParamsTest021)/sizeof(HksParam));
611 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
612 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest021, sizeof(g_verifyParamsTest021)/sizeof(HksParam));
613 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
614
615 /* Generate Key */
616 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
617
618 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
619 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
620 }
621
622 /* Delete Key */
623 ret = HksDeleteKey(&keyAlias, genParamSet);
624 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
625
626 HksFreeParamSet(&genParamSet);
627 HksFreeParamSet(&signParamSet);
628 HksFreeParamSet(&verifyParamSet);
629 }
630
631 /**
632 * @tc.name: HksRsaSignVerifyPart3Test.HksRsaSignVerifyPart3Test022
633 * @tc.desc: alg-RSA pur-Sign pad-PKCS1_V1_5 digest-MD5.
634 * @tc.type: FUNC
635 */
636 HWTEST_F(HksRsaSignVerifyPart3Test, HksRsaSignVerifyPart3Test022, TestSize.Level0)
637 {
638 int32_t ret = HKS_FAILURE;
639 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest022";
640 struct HksParamSet *genParamSet = nullptr;
641 struct HksParamSet *signParamSet = nullptr;
642 struct HksParamSet *verifyParamSet = nullptr;
643
644 ret = InitParamSet(&genParamSet, g_genParamsTest022, sizeof(g_genParamsTest022)/sizeof(HksParam));
645 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
646 ret = InitParamSet(&signParamSet, g_signParamsTest022, sizeof(g_signParamsTest022)/sizeof(HksParam));
647 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
648 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest022, sizeof(g_verifyParamsTest022)/sizeof(HksParam));
649 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
650
651 /* Generate Key */
652 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
653
654 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
655 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
656 }
657
658 /* Delete Key */
659 ret = HksDeleteKey(&keyAlias, genParamSet);
660 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
661
662 HksFreeParamSet(&genParamSet);
663 HksFreeParamSet(&signParamSet);
664 HksFreeParamSet(&verifyParamSet);
665 }
666
667 /**
668 * @tc.name: HksRsaSignVerifyPart3Test.HksRsaSignVerifyPart3Test023
669 * @tc.desc: alg-RSA pur-Sign pad-PKCS1_V1_5 digest-MD5.
670 * @tc.type: FUNC
671 */
672 HWTEST_F(HksRsaSignVerifyPart3Test, HksRsaSignVerifyPart3Test023, TestSize.Level0)
673 {
674 int32_t ret = HKS_FAILURE;
675 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest023";
676 struct HksParamSet *genParamSet = nullptr;
677 struct HksParamSet *signParamSet = nullptr;
678 struct HksParamSet *verifyParamSet = nullptr;
679
680 ret = InitParamSet(&genParamSet, g_genParamsTest023, sizeof(g_genParamsTest023)/sizeof(HksParam));
681 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
682 ret = InitParamSet(&signParamSet, g_signParamsTest023, sizeof(g_signParamsTest023)/sizeof(HksParam));
683 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
684 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest023, sizeof(g_verifyParamsTest023)/sizeof(HksParam));
685 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
686
687 /* Generate Key */
688 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
689
690 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
691 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
692 }
693
694 /* Delete Key */
695 ret = HksDeleteKey(&keyAlias, genParamSet);
696 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
697
698 HksFreeParamSet(&genParamSet);
699 HksFreeParamSet(&signParamSet);
700 HksFreeParamSet(&verifyParamSet);
701 }
702 #ifdef _USE_OPENSSL_
703 /**
704 * @tc.name: HksRsaSignVerifyPart3Test.HksRsaSignVerifyPart3Test024
705 * @tc.desc: alg-RSA pur-Sign pad-PKCS1_V1_5 digest-MD5.
706 * @tc.type: FUNC
707 */
708 HWTEST_F(HksRsaSignVerifyPart3Test, HksRsaSignVerifyPart3Test024, TestSize.Level0)
709 {
710 int32_t ret = HKS_FAILURE;
711 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest024";
712 struct HksParamSet *genParamSet = nullptr;
713 struct HksParamSet *signParamSet = nullptr;
714 struct HksParamSet *verifyParamSet = nullptr;
715
716 ret = InitParamSet(&genParamSet, g_genParamsTest024, sizeof(g_genParamsTest024)/sizeof(HksParam));
717 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
718 ret = InitParamSet(&signParamSet, g_signParamsTest024, sizeof(g_signParamsTest024)/sizeof(HksParam));
719 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
720 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest024, sizeof(g_verifyParamsTest024)/sizeof(HksParam));
721 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
722
723 /* Generate Key */
724 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
725
726 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
727 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
728 }
729
730 /* Delete Key */
731 ret = HksDeleteKey(&keyAlias, genParamSet);
732 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
733
734 HksFreeParamSet(&genParamSet);
735 HksFreeParamSet(&signParamSet);
736 HksFreeParamSet(&verifyParamSet);
737 }
738 #endif
739
740 /**
741 * @tc.name: HksRsaSignVerifyPart3Test.HksRsaSignVerifyPart3Test025
742 * @tc.desc: alg-RSA pur-Sign pad-PKCS1_V1_5 digest-MD5.
743 * @tc.type: FUNC
744 */
745 HWTEST_F(HksRsaSignVerifyPart3Test, HksRsaSignVerifyPart3Test025, TestSize.Level0)
746 {
747 int32_t ret = HKS_FAILURE;
748 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest025";
749 struct HksParamSet *genParamSet = nullptr;
750 struct HksParamSet *signParamSet = nullptr;
751 struct HksParamSet *verifyParamSet = nullptr;
752
753 ret = InitParamSet(&genParamSet, g_genParamsTest025, sizeof(g_genParamsTest025)/sizeof(HksParam));
754 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
755 ret = InitParamSet(&signParamSet, g_signParamsTest025, sizeof(g_signParamsTest025)/sizeof(HksParam));
756 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
757 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest025, sizeof(g_verifyParamsTest025)/sizeof(HksParam));
758 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
759
760 /* Generate Key */
761 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
762
763 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
764 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
765 }
766
767 /* Delete Key */
768 ret = HksDeleteKey(&keyAlias, genParamSet);
769 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
770
771 HksFreeParamSet(&genParamSet);
772 HksFreeParamSet(&signParamSet);
773 HksFreeParamSet(&verifyParamSet);
774 }
775
776 /**
777 * @tc.name: HksRsaSignVerifyPart3Test.HksRsaSignVerifyPart3Test026
778 * @tc.desc: alg-RSA pur-Sign pad-PKCS1_V1_5 digest-NONE.
779 * @tc.type: FUNC
780 */
781 HWTEST_F(HksRsaSignVerifyPart3Test, HksRsaSignVerifyPart3Test026, TestSize.Level0)
782 {
783 int32_t ret = HKS_FAILURE;
784 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest026";
785 struct HksParamSet *genParamSet = nullptr;
786 struct HksParamSet *signParamSet = nullptr;
787 struct HksParamSet *verifyParamSet = nullptr;
788
789 ret = InitParamSet(&genParamSet, g_genParamsTest026, sizeof(g_genParamsTest026)/sizeof(HksParam));
790 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
791 ret = InitParamSet(&signParamSet, g_signParamsTest026, sizeof(g_signParamsTest026)/sizeof(HksParam));
792 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
793 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest026, sizeof(g_verifyParamsTest026)/sizeof(HksParam));
794 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
795
796 /* Generate Key */
797 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
798
799 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
800 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
801 }
802
803 /* Delete Key */
804 ret = HksDeleteKey(&keyAlias, genParamSet);
805 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
806
807 HksFreeParamSet(&genParamSet);
808 HksFreeParamSet(&signParamSet);
809 HksFreeParamSet(&verifyParamSet);
810 }
811
812 /**
813 * @tc.name: HksRsaSignVerifyPart3Test.HksRsaSignVerifyPart3Test027
814 * @tc.desc: alg-RSA pur-Sign pad-PKCS1_V1_5 digest-SHA1.
815 * @tc.type: FUNC
816 */
817 HWTEST_F(HksRsaSignVerifyPart3Test, HksRsaSignVerifyPart3Test027, TestSize.Level0)
818 {
819 int32_t ret = HKS_FAILURE;
820 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest027";
821 struct HksParamSet *genParamSet = nullptr;
822 struct HksParamSet *signParamSet = nullptr;
823 struct HksParamSet *verifyParamSet = nullptr;
824
825 ret = InitParamSet(&genParamSet, g_genParamsTest027, sizeof(g_genParamsTest027)/sizeof(HksParam));
826 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
827 ret = InitParamSet(&signParamSet, g_signParamsTest027, sizeof(g_signParamsTest027)/sizeof(HksParam));
828 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
829 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest027, sizeof(g_verifyParamsTest027)/sizeof(HksParam));
830 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
831
832 /* Generate Key */
833 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
834
835 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
836 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
837 }
838
839 /* Delete Key */
840 ret = HksDeleteKey(&keyAlias, genParamSet);
841 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
842
843 HksFreeParamSet(&genParamSet);
844 HksFreeParamSet(&signParamSet);
845 HksFreeParamSet(&verifyParamSet);
846 }
847
848 /**
849 * @tc.name: HksRsaSignVerifyPart3Test.HksRsaSignVerifyPart3Test028
850 * @tc.desc: alg-RSA pur-Sign pad-PKCS1_V1_5 digest-SHA224.
851 * @tc.type: FUNC
852 */
853 HWTEST_F(HksRsaSignVerifyPart3Test, HksRsaSignVerifyPart3Test028, TestSize.Level0)
854 {
855 int32_t ret = HKS_FAILURE;
856 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest028";
857 struct HksParamSet *genParamSet = nullptr;
858 struct HksParamSet *signParamSet = nullptr;
859 struct HksParamSet *verifyParamSet = nullptr;
860
861 ret = InitParamSet(&genParamSet, g_genParamsTest028, sizeof(g_genParamsTest028)/sizeof(HksParam));
862 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
863 ret = InitParamSet(&signParamSet, g_signParamsTest028, sizeof(g_signParamsTest028)/sizeof(HksParam));
864 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
865 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest028, sizeof(g_verifyParamsTest028)/sizeof(HksParam));
866 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
867
868 /* Generate Key */
869 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
870
871 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
872 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
873 }
874
875 /* Delete Key */
876 ret = HksDeleteKey(&keyAlias, genParamSet);
877 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
878
879 HksFreeParamSet(&genParamSet);
880 HksFreeParamSet(&signParamSet);
881 HksFreeParamSet(&verifyParamSet);
882 }
883
884 /**
885 * @tc.name: HksRsaSignVerifyPart3Test.HksRsaSignVerifyPart3Test029
886 * @tc.desc: alg-RSA pur-Sign pad-PKCS1_V1_5 digest-SHA256.
887 * @tc.type: FUNC
888 */
889 HWTEST_F(HksRsaSignVerifyPart3Test, HksRsaSignVerifyPart3Test029, TestSize.Level0)
890 {
891 int32_t ret = HKS_FAILURE;
892 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest029";
893 struct HksParamSet *genParamSet = nullptr;
894 struct HksParamSet *signParamSet = nullptr;
895 struct HksParamSet *verifyParamSet = nullptr;
896
897 ret = InitParamSet(&genParamSet, g_genParamsTest029, sizeof(g_genParamsTest029)/sizeof(HksParam));
898 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
899 ret = InitParamSet(&signParamSet, g_signParamsTest029, sizeof(g_signParamsTest029)/sizeof(HksParam));
900 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
901 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest029, sizeof(g_verifyParamsTest029)/sizeof(HksParam));
902 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
903
904 /* Generate Key */
905 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
906
907 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
908 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
909 }
910
911 /* Delete Key */
912 ret = HksDeleteKey(&keyAlias, genParamSet);
913 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
914
915 HksFreeParamSet(&genParamSet);
916 HksFreeParamSet(&signParamSet);
917 HksFreeParamSet(&verifyParamSet);
918 }
919
920 /**
921 * @tc.name: HksRsaSignVerifyPart3Test.HksRsaSignVerifyPart3Test030
922 * @tc.desc: alg-RSA pur-Sign pad-PKCS1_V1_5 digest-MD5.
923 * @tc.type: FUNC
924 */
925 HWTEST_F(HksRsaSignVerifyPart3Test, HksRsaSignVerifyPart3Test030, TestSize.Level0)
926 {
927 int32_t ret = HKS_FAILURE;
928 const char *keyAliasString = "HksRSASignVerifyKeyAliasTest030";
929 struct HksParamSet *genParamSet = nullptr;
930 struct HksParamSet *signParamSet = nullptr;
931 struct HksParamSet *verifyParamSet = nullptr;
932
933 ret = InitParamSet(&genParamSet, g_genParamsTest030, sizeof(g_genParamsTest030)/sizeof(HksParam));
934 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
935 ret = InitParamSet(&signParamSet, g_signParamsTest030, sizeof(g_signParamsTest030)/sizeof(HksParam));
936 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
937 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest030, sizeof(g_verifyParamsTest030)/sizeof(HksParam));
938 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
939
940 /* Generate Key */
941 struct HksBlob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
942
943 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
944 ret = HksRsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
945 }
946
947 /* Delete Key */
948 ret = HksDeleteKey(&keyAlias, genParamSet);
949 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
950
951 HksFreeParamSet(&genParamSet);
952 HksFreeParamSet(&signParamSet);
953 HksFreeParamSet(&verifyParamSet);
954 }
955 }