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