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_part2_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 HksRsaCipherPart2Test : 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 HksRsaCipherPart2Test::SetUpTestCase(void)
35 {
36 }
37
TearDownTestCase(void)38 void HksRsaCipherPart2Test::TearDownTestCase(void)
39 {
40 }
41
SetUp()42 void HksRsaCipherPart2Test::SetUp()
43 {
44 }
45
TearDown()46 void HksRsaCipherPart2Test::TearDown()
47 {
48 }
49
50 static struct HksParam g_genParams011[] = {
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_768
60 }, {
61 .tag = HKS_TAG_PADDING,
62 .uint32Param = HKS_PADDING_OAEP
63 }, {
64 .tag = HKS_TAG_DIGEST,
65 .uint32Param = HKS_DIGEST_SHA224
66 }, {
67 .tag = HKS_TAG_BLOCK_MODE,
68 .uint32Param = HKS_MODE_ECB
69 }
70 };
71 static struct HksParam g_encryptParams011[] = {
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_768
81 }, {
82 .tag = HKS_TAG_PADDING,
83 .uint32Param = HKS_PADDING_OAEP
84 }, {
85 .tag = HKS_TAG_DIGEST,
86 .uint32Param = HKS_DIGEST_SHA224
87 }, {
88 .tag = HKS_TAG_BLOCK_MODE,
89 .uint32Param = HKS_MODE_ECB
90 }
91 };
92 static struct HksParam g_decryptParams011[] = {
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_768
102 }, {
103 .tag = HKS_TAG_PADDING,
104 .uint32Param = HKS_PADDING_OAEP
105 }, {
106 .tag = HKS_TAG_DIGEST,
107 .uint32Param = HKS_DIGEST_SHA224
108 }, {
109 .tag = HKS_TAG_BLOCK_MODE,
110 .uint32Param = HKS_MODE_ECB
111 }
112 };
113
114 static struct HksParam g_genParams012[] = {
115 {
116 .tag = HKS_TAG_ALGORITHM,
117 .uint32Param = HKS_ALG_RSA
118 }, {
119 .tag = HKS_TAG_PURPOSE,
120 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT
121 }, {
122 .tag = HKS_TAG_KEY_SIZE,
123 .uint32Param = HKS_RSA_KEY_SIZE_768
124 }, {
125 .tag = HKS_TAG_PADDING,
126 .uint32Param = HKS_PADDING_OAEP
127 }, {
128 .tag = HKS_TAG_DIGEST,
129 .uint32Param = HKS_DIGEST_SHA256
130 }, {
131 .tag = HKS_TAG_BLOCK_MODE,
132 .uint32Param = HKS_MODE_ECB
133 }
134 };
135 static struct HksParam g_encryptParams012[] = {
136 {
137 .tag = HKS_TAG_ALGORITHM,
138 .uint32Param = HKS_ALG_RSA
139 }, {
140 .tag = HKS_TAG_PURPOSE,
141 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT
142 }, {
143 .tag = HKS_TAG_KEY_SIZE,
144 .uint32Param = HKS_RSA_KEY_SIZE_768
145 }, {
146 .tag = HKS_TAG_PADDING,
147 .uint32Param = HKS_PADDING_OAEP
148 }, {
149 .tag = HKS_TAG_DIGEST,
150 .uint32Param = HKS_DIGEST_SHA256
151 }, {
152 .tag = HKS_TAG_BLOCK_MODE,
153 .uint32Param = HKS_MODE_ECB
154 }
155 };
156 static struct HksParam g_decryptParams012[] = {
157 {
158 .tag = HKS_TAG_ALGORITHM,
159 .uint32Param = HKS_ALG_RSA
160 }, {
161 .tag = HKS_TAG_PURPOSE,
162 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
163 }, {
164 .tag = HKS_TAG_KEY_SIZE,
165 .uint32Param = HKS_RSA_KEY_SIZE_768
166 }, {
167 .tag = HKS_TAG_PADDING,
168 .uint32Param = HKS_PADDING_OAEP
169 }, {
170 .tag = HKS_TAG_DIGEST,
171 .uint32Param = HKS_DIGEST_SHA256
172 }, {
173 .tag = HKS_TAG_BLOCK_MODE,
174 .uint32Param = HKS_MODE_ECB
175 }
176 };
177
178 static struct HksParam g_genParams013[] = {
179 {
180 .tag = HKS_TAG_ALGORITHM,
181 .uint32Param = HKS_ALG_RSA
182 }, {
183 .tag = HKS_TAG_PURPOSE,
184 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT
185 }, {
186 .tag = HKS_TAG_KEY_SIZE,
187 .uint32Param = HKS_RSA_KEY_SIZE_768
188 }, {
189 .tag = HKS_TAG_PADDING,
190 .uint32Param = HKS_PADDING_OAEP
191 }, {
192 .tag = HKS_TAG_DIGEST,
193 .uint32Param = HKS_DIGEST_SHA384
194 }, {
195 .tag = HKS_TAG_BLOCK_MODE,
196 .uint32Param = HKS_MODE_ECB
197 }
198 };
199 static struct HksParam g_encryptParams013[] = {
200 {
201 .tag = HKS_TAG_ALGORITHM,
202 .uint32Param = HKS_ALG_RSA
203 }, {
204 .tag = HKS_TAG_PURPOSE,
205 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT
206 }, {
207 .tag = HKS_TAG_KEY_SIZE,
208 .uint32Param = HKS_RSA_KEY_SIZE_768
209 }, {
210 .tag = HKS_TAG_PADDING,
211 .uint32Param = HKS_PADDING_OAEP
212 }, {
213 .tag = HKS_TAG_DIGEST,
214 .uint32Param = HKS_DIGEST_SHA384
215 }, {
216 .tag = HKS_TAG_BLOCK_MODE,
217 .uint32Param = HKS_MODE_ECB
218 }
219 };
220 static struct HksParam g_decryptParams013[] = {
221 {
222 .tag = HKS_TAG_ALGORITHM,
223 .uint32Param = HKS_ALG_RSA
224 }, {
225 .tag = HKS_TAG_PURPOSE,
226 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
227 }, {
228 .tag = HKS_TAG_KEY_SIZE,
229 .uint32Param = HKS_RSA_KEY_SIZE_768
230 }, {
231 .tag = HKS_TAG_PADDING,
232 .uint32Param = HKS_PADDING_OAEP
233 }, {
234 .tag = HKS_TAG_DIGEST,
235 .uint32Param = HKS_DIGEST_SHA384
236 }, {
237 .tag = HKS_TAG_BLOCK_MODE,
238 .uint32Param = HKS_MODE_ECB
239 }
240 };
241
242 static struct HksParam g_genParams014[] = {
243 {
244 .tag = HKS_TAG_ALGORITHM,
245 .uint32Param = HKS_ALG_RSA
246 }, {
247 .tag = HKS_TAG_PURPOSE,
248 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT
249 }, {
250 .tag = HKS_TAG_KEY_SIZE,
251 .uint32Param = HKS_RSA_KEY_SIZE_768
252 }, {
253 .tag = HKS_TAG_PADDING,
254 .uint32Param = HKS_PADDING_OAEP
255 }, {
256 .tag = HKS_TAG_DIGEST,
257 .uint32Param = HKS_DIGEST_SHA512
258 }, {
259 .tag = HKS_TAG_BLOCK_MODE,
260 .uint32Param = HKS_MODE_ECB
261 }
262 };
263 static struct HksParam g_encryptParams014[] = {
264 {
265 .tag = HKS_TAG_ALGORITHM,
266 .uint32Param = HKS_ALG_RSA
267 }, {
268 .tag = HKS_TAG_PURPOSE,
269 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT
270 }, {
271 .tag = HKS_TAG_KEY_SIZE,
272 .uint32Param = HKS_RSA_KEY_SIZE_768
273 }, {
274 .tag = HKS_TAG_PADDING,
275 .uint32Param = HKS_PADDING_OAEP
276 }, {
277 .tag = HKS_TAG_DIGEST,
278 .uint32Param = HKS_DIGEST_SHA512
279 }, {
280 .tag = HKS_TAG_BLOCK_MODE,
281 .uint32Param = HKS_MODE_ECB
282 }
283 };
284 static struct HksParam g_decryptParams014[] = {
285 {
286 .tag = HKS_TAG_ALGORITHM,
287 .uint32Param = HKS_ALG_RSA
288 }, {
289 .tag = HKS_TAG_PURPOSE,
290 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
291 }, {
292 .tag = HKS_TAG_KEY_SIZE,
293 .uint32Param = HKS_RSA_KEY_SIZE_768
294 }, {
295 .tag = HKS_TAG_PADDING,
296 .uint32Param = HKS_PADDING_OAEP
297 }, {
298 .tag = HKS_TAG_DIGEST,
299 .uint32Param = HKS_DIGEST_SHA512
300 }, {
301 .tag = HKS_TAG_BLOCK_MODE,
302 .uint32Param = HKS_MODE_ECB
303 }
304 };
305
306 #ifdef _USE_OPENSSL_
307 static struct HksParam g_genParams015[] = {
308 {
309 .tag = HKS_TAG_ALGORITHM,
310 .uint32Param = HKS_ALG_RSA
311 }, {
312 .tag = HKS_TAG_PURPOSE,
313 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT
314 }, {
315 .tag = HKS_TAG_KEY_SIZE,
316 .uint32Param = HKS_RSA_KEY_SIZE_1024
317 }, {
318 .tag = HKS_TAG_PADDING,
319 .uint32Param = HKS_PADDING_NONE
320 }, {
321 .tag = HKS_TAG_DIGEST,
322 .uint32Param = HKS_DIGEST_SHA256
323 }, {
324 .tag = HKS_TAG_BLOCK_MODE,
325 .uint32Param = HKS_MODE_ECB
326 }
327 };
328 static struct HksParam g_encryptParams015[] = {
329 {
330 .tag = HKS_TAG_ALGORITHM,
331 .uint32Param = HKS_ALG_RSA
332 }, {
333 .tag = HKS_TAG_PURPOSE,
334 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT
335 }, {
336 .tag = HKS_TAG_KEY_SIZE,
337 .uint32Param = HKS_RSA_KEY_SIZE_1024
338 }, {
339 .tag = HKS_TAG_PADDING,
340 .uint32Param = HKS_PADDING_NONE
341 }, {
342 .tag = HKS_TAG_DIGEST,
343 .uint32Param = HKS_DIGEST_SHA256
344 }, {
345 .tag = HKS_TAG_BLOCK_MODE,
346 .uint32Param = HKS_MODE_ECB
347 }
348 };
349 static struct HksParam g_decryptParams015[] = {
350 {
351 .tag = HKS_TAG_ALGORITHM,
352 .uint32Param = HKS_ALG_RSA
353 }, {
354 .tag = HKS_TAG_PURPOSE,
355 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
356 }, {
357 .tag = HKS_TAG_KEY_SIZE,
358 .uint32Param = HKS_RSA_KEY_SIZE_1024
359 }, {
360 .tag = HKS_TAG_PADDING,
361 .uint32Param = HKS_PADDING_NONE
362 }, {
363 .tag = HKS_TAG_DIGEST,
364 .uint32Param = HKS_DIGEST_SHA256
365 }, {
366 .tag = HKS_TAG_BLOCK_MODE,
367 .uint32Param = HKS_MODE_ECB
368 }
369 };
370 #endif
371
372 static struct HksParam g_genParams016[] = {
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_1024
382 }, {
383 .tag = HKS_TAG_PADDING,
384 .uint32Param = HKS_PADDING_PKCS1_V1_5
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_encryptParams016[] = {
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_1024
403 }, {
404 .tag = HKS_TAG_PADDING,
405 .uint32Param = HKS_PADDING_PKCS1_V1_5
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_decryptParams016[] = {
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_1024
424 }, {
425 .tag = HKS_TAG_PADDING,
426 .uint32Param = HKS_PADDING_PKCS1_V1_5
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_genParams017[] = {
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_1024
446 }, {
447 .tag = HKS_TAG_PADDING,
448 .uint32Param = HKS_PADDING_OAEP
449 }, {
450 .tag = HKS_TAG_DIGEST,
451 .uint32Param = HKS_DIGEST_SHA1
452 }, {
453 .tag = HKS_TAG_BLOCK_MODE,
454 .uint32Param = HKS_MODE_ECB
455 }
456 };
457 static struct HksParam g_encryptParams017[] = {
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_1024
467 }, {
468 .tag = HKS_TAG_PADDING,
469 .uint32Param = HKS_PADDING_OAEP
470 }, {
471 .tag = HKS_TAG_DIGEST,
472 .uint32Param = HKS_DIGEST_SHA1
473 }, {
474 .tag = HKS_TAG_BLOCK_MODE,
475 .uint32Param = HKS_MODE_ECB
476 }
477 };
478 static struct HksParam g_decryptParams017[] = {
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_1024
488 }, {
489 .tag = HKS_TAG_PADDING,
490 .uint32Param = HKS_PADDING_OAEP
491 }, {
492 .tag = HKS_TAG_DIGEST,
493 .uint32Param = HKS_DIGEST_SHA1
494 }, {
495 .tag = HKS_TAG_BLOCK_MODE,
496 .uint32Param = HKS_MODE_ECB
497 }
498 };
499
500 static struct HksParam g_genParams018[] = {
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_1024
510 }, {
511 .tag = HKS_TAG_PADDING,
512 .uint32Param = HKS_PADDING_OAEP
513 }, {
514 .tag = HKS_TAG_DIGEST,
515 .uint32Param = HKS_DIGEST_SHA224
516 }, {
517 .tag = HKS_TAG_BLOCK_MODE,
518 .uint32Param = HKS_MODE_ECB
519 }
520 };
521 static struct HksParam g_encryptParams018[] = {
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_1024
531 }, {
532 .tag = HKS_TAG_PADDING,
533 .uint32Param = HKS_PADDING_OAEP
534 }, {
535 .tag = HKS_TAG_DIGEST,
536 .uint32Param = HKS_DIGEST_SHA224
537 }, {
538 .tag = HKS_TAG_BLOCK_MODE,
539 .uint32Param = HKS_MODE_ECB
540 }
541 };
542 static struct HksParam g_decryptParams018[] = {
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_1024
552 }, {
553 .tag = HKS_TAG_PADDING,
554 .uint32Param = HKS_PADDING_OAEP
555 }, {
556 .tag = HKS_TAG_DIGEST,
557 .uint32Param = HKS_DIGEST_SHA224
558 }, {
559 .tag = HKS_TAG_BLOCK_MODE,
560 .uint32Param = HKS_MODE_ECB
561 }
562 };
563
564 static struct HksParam g_genParams019[] = {
565 {
566 .tag = HKS_TAG_ALGORITHM,
567 .uint32Param = HKS_ALG_RSA
568 }, {
569 .tag = HKS_TAG_PURPOSE,
570 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT
571 }, {
572 .tag = HKS_TAG_KEY_SIZE,
573 .uint32Param = HKS_RSA_KEY_SIZE_1024
574 }, {
575 .tag = HKS_TAG_PADDING,
576 .uint32Param = HKS_PADDING_OAEP
577 }, {
578 .tag = HKS_TAG_DIGEST,
579 .uint32Param = HKS_DIGEST_SHA256
580 }, {
581 .tag = HKS_TAG_BLOCK_MODE,
582 .uint32Param = HKS_MODE_ECB
583 }
584 };
585 static struct HksParam g_encryptParams019[] = {
586 {
587 .tag = HKS_TAG_ALGORITHM,
588 .uint32Param = HKS_ALG_RSA
589 }, {
590 .tag = HKS_TAG_PURPOSE,
591 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT
592 }, {
593 .tag = HKS_TAG_KEY_SIZE,
594 .uint32Param = HKS_RSA_KEY_SIZE_1024
595 }, {
596 .tag = HKS_TAG_PADDING,
597 .uint32Param = HKS_PADDING_OAEP
598 }, {
599 .tag = HKS_TAG_DIGEST,
600 .uint32Param = HKS_DIGEST_SHA256
601 }, {
602 .tag = HKS_TAG_BLOCK_MODE,
603 .uint32Param = HKS_MODE_ECB
604 }
605 };
606 static struct HksParam g_decryptParams019[] = {
607 {
608 .tag = HKS_TAG_ALGORITHM,
609 .uint32Param = HKS_ALG_RSA
610 }, {
611 .tag = HKS_TAG_PURPOSE,
612 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
613 }, {
614 .tag = HKS_TAG_KEY_SIZE,
615 .uint32Param = HKS_RSA_KEY_SIZE_1024
616 }, {
617 .tag = HKS_TAG_PADDING,
618 .uint32Param = HKS_PADDING_OAEP
619 }, {
620 .tag = HKS_TAG_DIGEST,
621 .uint32Param = HKS_DIGEST_SHA256
622 }, {
623 .tag = HKS_TAG_BLOCK_MODE,
624 .uint32Param = HKS_MODE_ECB
625 }
626 };
627
628 static struct HksParam g_genParams020[] = {
629 {
630 .tag = HKS_TAG_ALGORITHM,
631 .uint32Param = HKS_ALG_RSA
632 }, {
633 .tag = HKS_TAG_PURPOSE,
634 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT
635 }, {
636 .tag = HKS_TAG_KEY_SIZE,
637 .uint32Param = HKS_RSA_KEY_SIZE_1024
638 }, {
639 .tag = HKS_TAG_PADDING,
640 .uint32Param = HKS_PADDING_OAEP
641 }, {
642 .tag = HKS_TAG_DIGEST,
643 .uint32Param = HKS_DIGEST_SHA384
644 }, {
645 .tag = HKS_TAG_BLOCK_MODE,
646 .uint32Param = HKS_MODE_ECB
647 }
648 };
649 static struct HksParam g_encryptParams020[] = {
650 {
651 .tag = HKS_TAG_ALGORITHM,
652 .uint32Param = HKS_ALG_RSA
653 }, {
654 .tag = HKS_TAG_PURPOSE,
655 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT
656 }, {
657 .tag = HKS_TAG_KEY_SIZE,
658 .uint32Param = HKS_RSA_KEY_SIZE_1024
659 }, {
660 .tag = HKS_TAG_PADDING,
661 .uint32Param = HKS_PADDING_OAEP
662 }, {
663 .tag = HKS_TAG_DIGEST,
664 .uint32Param = HKS_DIGEST_SHA384
665 }, {
666 .tag = HKS_TAG_BLOCK_MODE,
667 .uint32Param = HKS_MODE_ECB
668 }
669 };
670 static struct HksParam g_decryptParams020[] = {
671 {
672 .tag = HKS_TAG_ALGORITHM,
673 .uint32Param = HKS_ALG_RSA
674 }, {
675 .tag = HKS_TAG_PURPOSE,
676 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
677 }, {
678 .tag = HKS_TAG_KEY_SIZE,
679 .uint32Param = HKS_RSA_KEY_SIZE_1024
680 }, {
681 .tag = HKS_TAG_PADDING,
682 .uint32Param = HKS_PADDING_OAEP
683 }, {
684 .tag = HKS_TAG_DIGEST,
685 .uint32Param = HKS_DIGEST_SHA384
686 }, {
687 .tag = HKS_TAG_BLOCK_MODE,
688 .uint32Param = HKS_MODE_ECB
689 }
690 };
691
692 /**
693 * @tc.name: HksRsaCipherPart2Test.HksRsaCipherPart2Test011
694 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-768 pad-OAEP dig-SHA224 mode-ECB.
695 * @tc.type: FUNC
696 */
697 HWTEST_F(HksRsaCipherPart2Test, HksRsaCipherPart2Test011, TestSize.Level0)
698 {
699 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest019";
700 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
701 struct HksBlob inData = { Unittest::RsaCipher::g_inData_32.length(),
702 (uint8_t *)Unittest::RsaCipher::g_inData_32.c_str() };
703
704 struct HksParamSet *genParamSet = nullptr;
705 int32_t ret = InitParamSet(&genParamSet, g_genParams011, sizeof(g_genParams011)/sizeof(HksParam));
706 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
707
708 struct HksParamSet *encryptParamSet = nullptr;
709 ret = InitParamSet(&encryptParamSet, g_encryptParams011, sizeof(g_encryptParams011)/sizeof(HksParam));
710 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
711
712 struct HksParamSet *decryptParamSet = nullptr;
713 ret = InitParamSet(&decryptParamSet, g_decryptParams011, sizeof(g_decryptParams011)/sizeof(HksParam));
714 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
715
716 ret = HksRsaCipherTestCase(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, &inData);
717 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
718
719 HksFreeParamSet(&genParamSet);
720 HksFreeParamSet(&encryptParamSet);
721 HksFreeParamSet(&decryptParamSet);
722 }
723
724 /**
725 * @tc.name: HksRsaCipherPart2Test.HksRsaCipherPart2Test012
726 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-768 pad-OAEP dig-SHA256 mode-ECB.
727 * @tc.type: FUNC
728 */
729 HWTEST_F(HksRsaCipherPart2Test, HksRsaCipherPart2Test012, TestSize.Level0)
730 {
731 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest012";
732 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
733 struct HksBlob inData = { Unittest::RsaCipher::g_inData_12.length(),
734 (uint8_t *)Unittest::RsaCipher::g_inData_12.c_str() };
735
736 struct HksParamSet *genParamSet = nullptr;
737 int32_t ret = InitParamSet(&genParamSet, g_genParams012, sizeof(g_genParams012)/sizeof(HksParam));
738 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
739
740 struct HksParamSet *encryptParamSet = nullptr;
741 ret = InitParamSet(&encryptParamSet, g_encryptParams012, sizeof(g_encryptParams012)/sizeof(HksParam));
742 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
743
744 struct HksParamSet *decryptParamSet = nullptr;
745 ret = InitParamSet(&decryptParamSet, g_decryptParams012, sizeof(g_decryptParams012)/sizeof(HksParam));
746 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
747
748 ret = HksRsaCipherTestCase(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, &inData);
749 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
750
751 HksFreeParamSet(&genParamSet);
752 HksFreeParamSet(&encryptParamSet);
753 HksFreeParamSet(&decryptParamSet);
754 }
755
756 /**
757 * @tc.name: HksRsaCipherPart2Test.HksRsaCipherPart2Test013
758 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-768 pad-OAEP dig-SHA384 mode-ECB.
759 * @tc.type: FUNC
760 */
761 HWTEST_F(HksRsaCipherPart2Test, HksRsaCipherPart2Test013, TestSize.Level0)
762 {
763 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest013";
764 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
765 struct HksBlob inData = { Unittest::RsaCipher::g_inData_32.length(),
766 (uint8_t *)Unittest::RsaCipher::g_inData_32.c_str() };
767
768 struct HksParamSet *genParamSet = nullptr;
769 int32_t ret = InitParamSet(&genParamSet, g_genParams013, sizeof(g_genParams013)/sizeof(HksParam));
770 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
771
772 struct HksParamSet *encryptParamSet = nullptr;
773 ret = InitParamSet(&encryptParamSet, g_encryptParams013, sizeof(g_encryptParams013)/sizeof(HksParam));
774 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
775
776 struct HksParamSet *decryptParamSet = nullptr;
777 ret = InitParamSet(&decryptParamSet, g_decryptParams013, sizeof(g_decryptParams013)/sizeof(HksParam));
778 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
779
780 ret = HksRsaCipherTestCaseAbnormal(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, &inData);
781 EXPECT_EQ(ret, HKS_FAILURE) << "this case should failed.";
782
783 HksFreeParamSet(&genParamSet);
784 HksFreeParamSet(&encryptParamSet);
785 HksFreeParamSet(&decryptParamSet);
786 }
787
788 /**
789 * @tc.name: HksRsaCipherPart2Test.HksRsaCipherPart2Test014
790 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-768 pad-OAEP dig-SHA512 mode-ECB.
791 * @tc.type: FUNC
792 */
793 HWTEST_F(HksRsaCipherPart2Test, HksRsaCipherPart2Test014, TestSize.Level0)
794 {
795 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest014";
796 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
797 struct HksBlob inData = { Unittest::RsaCipher::g_inData_5.length(),
798 (uint8_t *)Unittest::RsaCipher::g_inData_5.c_str() };
799
800 struct HksParamSet *genParamSet = nullptr;
801 int32_t ret = InitParamSet(&genParamSet, g_genParams014, sizeof(g_genParams014)/sizeof(HksParam));
802 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
803
804 struct HksParamSet *encryptParamSet = nullptr;
805 ret = InitParamSet(&encryptParamSet, g_encryptParams014, sizeof(g_encryptParams014)/sizeof(HksParam));
806 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
807
808 struct HksParamSet *decryptParamSet = nullptr;
809 ret = InitParamSet(&decryptParamSet, g_decryptParams014, sizeof(g_decryptParams014)/sizeof(HksParam));
810 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
811
812 ret = HksRsaCipherTestCaseAbnormal(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, &inData);
813 EXPECT_EQ(ret, HKS_FAILURE) << "this case should failed.";
814
815 HksFreeParamSet(&genParamSet);
816 HksFreeParamSet(&encryptParamSet);
817 HksFreeParamSet(&decryptParamSet);
818 }
819
820 #ifdef _USE_OPENSSL_
821 /**
822 * @tc.name: HksRsaCipherPart2Test.HksRsaCipherPart2Test015
823 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-1024 pad-NONE mode-ECB.
824 * @tc.type: FUNC
825 */
826 HWTEST_F(HksRsaCipherPart2Test, HksRsaCipherPart2Test015, TestSize.Level0)
827 {
828 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest015";
829 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
830 struct HksBlob inData = { Unittest::RsaCipher::g_inData_128.length(),
831 (uint8_t *)Unittest::RsaCipher::g_inData_128.c_str() };
832
833 struct HksParamSet *genParamSet = nullptr;
834 int32_t ret = InitParamSet(&genParamSet, g_genParams015, sizeof(g_genParams015)/sizeof(HksParam));
835 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
836
837 struct HksParamSet *encryptParamSet = nullptr;
838 ret = InitParamSet(&encryptParamSet, g_encryptParams015, sizeof(g_encryptParams015)/sizeof(HksParam));
839 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
840
841 struct HksParamSet *decryptParamSet = nullptr;
842 ret = InitParamSet(&decryptParamSet, g_decryptParams015, sizeof(g_decryptParams015)/sizeof(HksParam));
843 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
844
845 ret = HksRsaCipherTestCase(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, &inData);
846 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
847
848 HksFreeParamSet(&genParamSet);
849 HksFreeParamSet(&encryptParamSet);
850 HksFreeParamSet(&decryptParamSet);
851 }
852 #endif
853
854 /**
855 * @tc.name: HksRsaCipherPart2Test.HksRsaCipherPart2Test016
856 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-1024 pad-PKCS1_V1_5 mode-ECB.
857 * @tc.type: FUNC
858 */
859 HWTEST_F(HksRsaCipherPart2Test, HksRsaCipherPart2Test016, TestSize.Level0)
860 {
861 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest017";
862 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
863 struct HksBlob inData = { Unittest::RsaCipher::g_inData_32.length(),
864 (uint8_t *)Unittest::RsaCipher::g_inData_32.c_str() };
865
866 struct HksParamSet *genParamSet = nullptr;
867 int32_t ret = InitParamSet(&genParamSet, g_genParams016, sizeof(g_genParams016)/sizeof(HksParam));
868 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
869
870 struct HksParamSet *encryptParamSet = nullptr;
871 ret = InitParamSet(&encryptParamSet, g_encryptParams016, sizeof(g_encryptParams016)/sizeof(HksParam));
872 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
873
874 struct HksParamSet *decryptParamSet = nullptr;
875 ret = InitParamSet(&decryptParamSet, g_decryptParams016, sizeof(g_decryptParams016)/sizeof(HksParam));
876 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
877
878 ret = HksRsaCipherTestCase(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, &inData);
879 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
880
881 HksFreeParamSet(&genParamSet);
882 HksFreeParamSet(&encryptParamSet);
883 HksFreeParamSet(&decryptParamSet);
884 }
885
886 /**
887 * @tc.name: HksRsaCipherPart2Test.HksRsaCipherPart2Test017
888 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-1024 pad-OAEP dig-SHA1 mode-ECB.
889 * @tc.type: FUNC
890 */
891 HWTEST_F(HksRsaCipherPart2Test, HksRsaCipherPart2Test017, TestSize.Level0)
892 {
893 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest017";
894 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
895 struct HksBlob inData = { Unittest::RsaCipher::g_inData_32.length(),
896 (uint8_t *)Unittest::RsaCipher::g_inData_32.c_str() };
897
898 struct HksParamSet *genParamSet = nullptr;
899 int32_t ret = InitParamSet(&genParamSet, g_genParams017, sizeof(g_genParams017)/sizeof(HksParam));
900 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
901
902 struct HksParamSet *encryptParamSet = nullptr;
903 ret = InitParamSet(&encryptParamSet, g_encryptParams017, sizeof(g_encryptParams017)/sizeof(HksParam));
904 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
905
906 struct HksParamSet *decryptParamSet = nullptr;
907 ret = InitParamSet(&decryptParamSet, g_decryptParams017, sizeof(g_decryptParams017)/sizeof(HksParam));
908 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
909
910 ret = HksRsaCipherTestCase(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, &inData);
911 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
912
913 HksFreeParamSet(&genParamSet);
914 HksFreeParamSet(&encryptParamSet);
915 HksFreeParamSet(&decryptParamSet);
916 }
917
918 /**
919 * @tc.name: HksRsaCipherPart2Test.HksRsaCipherPart2Test018
920 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-1024 pad-OAEP dig-SHA224 mode-ECB.
921 * @tc.type: FUNC
922 */
923 HWTEST_F(HksRsaCipherPart2Test, HksRsaCipherPart2Test018, TestSize.Level0)
924 {
925 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest018";
926 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
927 struct HksBlob inData = { Unittest::RsaCipher::g_inData_32.length(),
928 (uint8_t *)Unittest::RsaCipher::g_inData_32.c_str() };
929
930 struct HksParamSet *genParamSet = nullptr;
931 int32_t ret = InitParamSet(&genParamSet, g_genParams018, sizeof(g_genParams018)/sizeof(HksParam));
932 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
933
934 struct HksParamSet *encryptParamSet = nullptr;
935 ret = InitParamSet(&encryptParamSet, g_encryptParams018, sizeof(g_encryptParams018)/sizeof(HksParam));
936 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
937
938 struct HksParamSet *decryptParamSet = nullptr;
939 ret = InitParamSet(&decryptParamSet, g_decryptParams018, sizeof(g_decryptParams018)/sizeof(HksParam));
940 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
941
942 ret = HksRsaCipherTestCase(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, &inData);
943 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
944
945 HksFreeParamSet(&genParamSet);
946 HksFreeParamSet(&encryptParamSet);
947 HksFreeParamSet(&decryptParamSet);
948 }
949
950 /**
951 * @tc.name: HksRsaCipherPart2Test.HksRsaCipherPart2Test019
952 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-1024 pad-OAEP dig-SHA256 mode-ECB.
953 * @tc.type: FUNC
954 */
955 HWTEST_F(HksRsaCipherPart2Test, HksRsaCipherPart2Test019, TestSize.Level0)
956 {
957 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest019";
958 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
959 struct HksBlob inData = { Unittest::RsaCipher::g_inData_32.length(),
960 (uint8_t *)Unittest::RsaCipher::g_inData_32.c_str() };
961
962 struct HksParamSet *genParamSet = nullptr;
963 int32_t ret = InitParamSet(&genParamSet, g_genParams019, sizeof(g_genParams019)/sizeof(HksParam));
964 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
965
966 struct HksParamSet *encryptParamSet = nullptr;
967 ret = InitParamSet(&encryptParamSet, g_encryptParams019, sizeof(g_encryptParams019)/sizeof(HksParam));
968 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
969
970 struct HksParamSet *decryptParamSet = nullptr;
971 ret = InitParamSet(&decryptParamSet, g_decryptParams019, sizeof(g_decryptParams019)/sizeof(HksParam));
972 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
973
974 ret = HksRsaCipherTestCase(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, &inData);
975 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
976
977 HksFreeParamSet(&genParamSet);
978 HksFreeParamSet(&encryptParamSet);
979 HksFreeParamSet(&decryptParamSet);
980 }
981
982 /**
983 * @tc.name: HksRsaCipherPart2Test.HksRsaCipherPart2Test020
984 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-1024 pad-OAEP dig-SHA384 mode-ECB.
985 * @tc.type: FUNC
986 */
987 HWTEST_F(HksRsaCipherPart2Test, HksRsaCipherPart2Test020, TestSize.Level0)
988 {
989 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest020";
990 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
991 struct HksBlob inData = { Unittest::RsaCipher::g_inData_5.length(),
992 (uint8_t *)Unittest::RsaCipher::g_inData_5.c_str() };
993
994 struct HksParamSet *genParamSet = nullptr;
995 int32_t ret = InitParamSet(&genParamSet, g_genParams020, sizeof(g_genParams020)/sizeof(HksParam));
996 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
997
998 struct HksParamSet *encryptParamSet = nullptr;
999 ret = InitParamSet(&encryptParamSet, g_encryptParams020, sizeof(g_encryptParams020)/sizeof(HksParam));
1000 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
1001
1002 struct HksParamSet *decryptParamSet = nullptr;
1003 ret = InitParamSet(&decryptParamSet, g_decryptParams020, sizeof(g_decryptParams020)/sizeof(HksParam));
1004 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
1005
1006 ret = HksRsaCipherTestCase(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, &inData);
1007 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
1008
1009 HksFreeParamSet(&genParamSet);
1010 HksFreeParamSet(&encryptParamSet);
1011 HksFreeParamSet(&decryptParamSet);
1012 }
1013 }