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_part1_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 HksRsaCipherPart1Test : 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 HksRsaCipherPart1Test::SetUpTestCase(void)
35 {
36 }
37
TearDownTestCase(void)38 void HksRsaCipherPart1Test::TearDownTestCase(void)
39 {
40 }
41
SetUp()42 void HksRsaCipherPart1Test::SetUp()
43 {
44 }
45
TearDown()46 void HksRsaCipherPart1Test::TearDown()
47 {
48 }
49
50 #ifdef _USE_OPENSSL_
51 static struct HksParam g_genParams001[] = {
52 {
53 .tag = HKS_TAG_ALGORITHM,
54 .uint32Param = HKS_ALG_RSA
55 }, {
56 .tag = HKS_TAG_PURPOSE,
57 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT
58 }, {
59 .tag = HKS_TAG_KEY_SIZE,
60 .uint32Param = HKS_RSA_KEY_SIZE_512
61 }, {
62 .tag = HKS_TAG_PADDING,
63 .uint32Param = HKS_PADDING_NONE
64 }, {
65 .tag = HKS_TAG_DIGEST,
66 .uint32Param = HKS_DIGEST_SHA256
67 }, {
68 .tag = HKS_TAG_BLOCK_MODE,
69 .uint32Param = HKS_MODE_ECB
70 }
71 };
72 static struct HksParam g_encryptParams001[] = {
73 {
74 .tag = HKS_TAG_ALGORITHM,
75 .uint32Param = HKS_ALG_RSA
76 }, {
77 .tag = HKS_TAG_PURPOSE,
78 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT
79 }, {
80 .tag = HKS_TAG_KEY_SIZE,
81 .uint32Param = HKS_RSA_KEY_SIZE_512
82 }, {
83 .tag = HKS_TAG_PADDING,
84 .uint32Param = HKS_PADDING_NONE
85 }, {
86 .tag = HKS_TAG_DIGEST,
87 .uint32Param = HKS_DIGEST_SHA256
88 }, {
89 .tag = HKS_TAG_BLOCK_MODE,
90 .uint32Param = HKS_MODE_ECB
91 }
92 };
93 static struct HksParam g_decryptParams001[] = {
94 {
95 .tag = HKS_TAG_ALGORITHM,
96 .uint32Param = HKS_ALG_RSA
97 }, {
98 .tag = HKS_TAG_PURPOSE,
99 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
100 }, {
101 .tag = HKS_TAG_KEY_SIZE,
102 .uint32Param = HKS_RSA_KEY_SIZE_512
103 }, {
104 .tag = HKS_TAG_PADDING,
105 .uint32Param = HKS_PADDING_NONE
106 }, {
107 .tag = HKS_TAG_DIGEST,
108 .uint32Param = HKS_DIGEST_SHA256
109 }, {
110 .tag = HKS_TAG_BLOCK_MODE,
111 .uint32Param = HKS_MODE_ECB
112 }
113 };
114 #endif
115
116 static struct HksParam g_genParams002[] = {
117 {
118 .tag = HKS_TAG_ALGORITHM,
119 .uint32Param = HKS_ALG_RSA
120 }, {
121 .tag = HKS_TAG_PURPOSE,
122 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT
123 }, {
124 .tag = HKS_TAG_KEY_SIZE,
125 .uint32Param = HKS_RSA_KEY_SIZE_512
126 }, {
127 .tag = HKS_TAG_PADDING,
128 .uint32Param = HKS_PADDING_PKCS1_V1_5
129 }, {
130 .tag = HKS_TAG_DIGEST,
131 .uint32Param = HKS_DIGEST_SHA256
132 }, {
133 .tag = HKS_TAG_BLOCK_MODE,
134 .uint32Param = HKS_MODE_ECB
135 }
136 };
137 static struct HksParam g_encryptParams002[] = {
138 {
139 .tag = HKS_TAG_ALGORITHM,
140 .uint32Param = HKS_ALG_RSA
141 }, {
142 .tag = HKS_TAG_PURPOSE,
143 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT
144 }, {
145 .tag = HKS_TAG_KEY_SIZE,
146 .uint32Param = HKS_RSA_KEY_SIZE_512
147 }, {
148 .tag = HKS_TAG_PADDING,
149 .uint32Param = HKS_PADDING_PKCS1_V1_5
150 }, {
151 .tag = HKS_TAG_DIGEST,
152 .uint32Param = HKS_DIGEST_SHA256
153 }, {
154 .tag = HKS_TAG_BLOCK_MODE,
155 .uint32Param = HKS_MODE_ECB
156 }
157 };
158 static struct HksParam g_decryptParams002[] = {
159 {
160 .tag = HKS_TAG_ALGORITHM,
161 .uint32Param = HKS_ALG_RSA
162 }, {
163 .tag = HKS_TAG_PURPOSE,
164 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
165 }, {
166 .tag = HKS_TAG_KEY_SIZE,
167 .uint32Param = HKS_RSA_KEY_SIZE_512
168 }, {
169 .tag = HKS_TAG_PADDING,
170 .uint32Param = HKS_PADDING_PKCS1_V1_5
171 }, {
172 .tag = HKS_TAG_DIGEST,
173 .uint32Param = HKS_DIGEST_SHA256
174 }, {
175 .tag = HKS_TAG_BLOCK_MODE,
176 .uint32Param = HKS_MODE_ECB
177 }
178 };
179
180 static struct HksParam g_genParams003[] = {
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_512
190 }, {
191 .tag = HKS_TAG_PADDING,
192 .uint32Param = HKS_PADDING_OAEP
193 }, {
194 .tag = HKS_TAG_DIGEST,
195 .uint32Param = HKS_DIGEST_SHA1
196 }, {
197 .tag = HKS_TAG_BLOCK_MODE,
198 .uint32Param = HKS_MODE_ECB
199 }
200 };
201 static struct HksParam g_encryptParams003[] = {
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_512
211 }, {
212 .tag = HKS_TAG_PADDING,
213 .uint32Param = HKS_PADDING_OAEP
214 }, {
215 .tag = HKS_TAG_DIGEST,
216 .uint32Param = HKS_DIGEST_SHA1
217 }, {
218 .tag = HKS_TAG_BLOCK_MODE,
219 .uint32Param = HKS_MODE_ECB
220 }
221 };
222 static struct HksParam g_decryptParams003[] = {
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_512
232 }, {
233 .tag = HKS_TAG_PADDING,
234 .uint32Param = HKS_PADDING_OAEP
235 }, {
236 .tag = HKS_TAG_DIGEST,
237 .uint32Param = HKS_DIGEST_SHA1
238 }, {
239 .tag = HKS_TAG_BLOCK_MODE,
240 .uint32Param = HKS_MODE_ECB
241 }
242 };
243
244 static struct HksParam g_genParams004[] = {
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_512
254 }, {
255 .tag = HKS_TAG_PADDING,
256 .uint32Param = HKS_PADDING_OAEP
257 }, {
258 .tag = HKS_TAG_DIGEST,
259 .uint32Param = HKS_DIGEST_SHA224
260 }, {
261 .tag = HKS_TAG_BLOCK_MODE,
262 .uint32Param = HKS_MODE_ECB
263 }
264 };
265 static struct HksParam g_encryptParams004[] = {
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_512
275 }, {
276 .tag = HKS_TAG_PADDING,
277 .uint32Param = HKS_PADDING_OAEP
278 }, {
279 .tag = HKS_TAG_DIGEST,
280 .uint32Param = HKS_DIGEST_SHA224
281 }, {
282 .tag = HKS_TAG_BLOCK_MODE,
283 .uint32Param = HKS_MODE_ECB
284 }
285 };
286 static struct HksParam g_decryptParams004[] = {
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_512
296 }, {
297 .tag = HKS_TAG_PADDING,
298 .uint32Param = HKS_PADDING_OAEP
299 }, {
300 .tag = HKS_TAG_DIGEST,
301 .uint32Param = HKS_DIGEST_SHA224
302 }, {
303 .tag = HKS_TAG_BLOCK_MODE,
304 .uint32Param = HKS_MODE_ECB
305 }
306 };
307
308 static struct HksParam g_genParams005[] = {
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_512
318 }, {
319 .tag = HKS_TAG_PADDING,
320 .uint32Param = HKS_PADDING_OAEP
321 }, {
322 .tag = HKS_TAG_DIGEST,
323 .uint32Param = HKS_DIGEST_SHA256
324 }, {
325 .tag = HKS_TAG_BLOCK_MODE,
326 .uint32Param = HKS_MODE_ECB
327 }
328 };
329 static struct HksParam g_encryptParams005[] = {
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_512
339 }, {
340 .tag = HKS_TAG_PADDING,
341 .uint32Param = HKS_PADDING_OAEP
342 }, {
343 .tag = HKS_TAG_DIGEST,
344 .uint32Param = HKS_DIGEST_SHA256
345 }, {
346 .tag = HKS_TAG_BLOCK_MODE,
347 .uint32Param = HKS_MODE_ECB
348 }
349 };
350 static struct HksParam g_decryptParams005[] = {
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_512
360 }, {
361 .tag = HKS_TAG_PADDING,
362 .uint32Param = HKS_PADDING_OAEP
363 }, {
364 .tag = HKS_TAG_DIGEST,
365 .uint32Param = HKS_DIGEST_SHA256
366 }, {
367 .tag = HKS_TAG_BLOCK_MODE,
368 .uint32Param = HKS_MODE_ECB
369 }
370 };
371
372 static struct HksParam g_genParams006[] = {
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_512
382 }, {
383 .tag = HKS_TAG_PADDING,
384 .uint32Param = HKS_PADDING_OAEP
385 }, {
386 .tag = HKS_TAG_DIGEST,
387 .uint32Param = HKS_DIGEST_SHA384
388 }, {
389 .tag = HKS_TAG_BLOCK_MODE,
390 .uint32Param = HKS_MODE_ECB
391 }
392 };
393 static struct HksParam g_encryptParams006[] = {
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_512
403 }, {
404 .tag = HKS_TAG_PADDING,
405 .uint32Param = HKS_PADDING_OAEP
406 }, {
407 .tag = HKS_TAG_DIGEST,
408 .uint32Param = HKS_DIGEST_SHA384
409 }, {
410 .tag = HKS_TAG_BLOCK_MODE,
411 .uint32Param = HKS_MODE_ECB
412 }
413 };
414 static struct HksParam g_decryptParams006[] = {
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_512
424 }, {
425 .tag = HKS_TAG_PADDING,
426 .uint32Param = HKS_PADDING_OAEP
427 }, {
428 .tag = HKS_TAG_DIGEST,
429 .uint32Param = HKS_DIGEST_SHA384
430 }, {
431 .tag = HKS_TAG_BLOCK_MODE,
432 .uint32Param = HKS_MODE_ECB
433 }
434 };
435
436 static struct HksParam g_genParams007[] = {
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_512
446 }, {
447 .tag = HKS_TAG_PADDING,
448 .uint32Param = HKS_PADDING_OAEP
449 }, {
450 .tag = HKS_TAG_DIGEST,
451 .uint32Param = HKS_DIGEST_SHA512
452 }, {
453 .tag = HKS_TAG_BLOCK_MODE,
454 .uint32Param = HKS_MODE_ECB
455 }
456 };
457 static struct HksParam g_encryptParams007[] = {
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_512
467 }, {
468 .tag = HKS_TAG_PADDING,
469 .uint32Param = HKS_PADDING_OAEP
470 }, {
471 .tag = HKS_TAG_DIGEST,
472 .uint32Param = HKS_DIGEST_SHA512
473 }, {
474 .tag = HKS_TAG_BLOCK_MODE,
475 .uint32Param = HKS_MODE_ECB
476 }
477 };
478 static struct HksParam g_decryptParams007[] = {
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_512
488 }, {
489 .tag = HKS_TAG_PADDING,
490 .uint32Param = HKS_PADDING_OAEP
491 }, {
492 .tag = HKS_TAG_DIGEST,
493 .uint32Param = HKS_DIGEST_SHA512
494 }, {
495 .tag = HKS_TAG_BLOCK_MODE,
496 .uint32Param = HKS_MODE_ECB
497 }
498 };
499
500 #ifdef _USE_OPENSSL_
501 static struct HksParam g_genParams008[] = {
502 {
503 .tag = HKS_TAG_ALGORITHM,
504 .uint32Param = HKS_ALG_RSA
505 }, {
506 .tag = HKS_TAG_PURPOSE,
507 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT
508 }, {
509 .tag = HKS_TAG_KEY_SIZE,
510 .uint32Param = HKS_RSA_KEY_SIZE_768
511 }, {
512 .tag = HKS_TAG_PADDING,
513 .uint32Param = HKS_PADDING_NONE
514 }, {
515 .tag = HKS_TAG_DIGEST,
516 .uint32Param = HKS_DIGEST_SHA256
517 }, {
518 .tag = HKS_TAG_BLOCK_MODE,
519 .uint32Param = HKS_MODE_ECB
520 }
521 };
522 static struct HksParam g_encryptParams008[] = {
523 {
524 .tag = HKS_TAG_ALGORITHM,
525 .uint32Param = HKS_ALG_RSA
526 }, {
527 .tag = HKS_TAG_PURPOSE,
528 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT
529 }, {
530 .tag = HKS_TAG_KEY_SIZE,
531 .uint32Param = HKS_RSA_KEY_SIZE_768
532 }, {
533 .tag = HKS_TAG_PADDING,
534 .uint32Param = HKS_PADDING_NONE
535 }, {
536 .tag = HKS_TAG_DIGEST,
537 .uint32Param = HKS_DIGEST_SHA256
538 }, {
539 .tag = HKS_TAG_BLOCK_MODE,
540 .uint32Param = HKS_MODE_ECB
541 }
542 };
543 static struct HksParam g_decryptParams008[] = {
544 {
545 .tag = HKS_TAG_ALGORITHM,
546 .uint32Param = HKS_ALG_RSA
547 }, {
548 .tag = HKS_TAG_PURPOSE,
549 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
550 }, {
551 .tag = HKS_TAG_KEY_SIZE,
552 .uint32Param = HKS_RSA_KEY_SIZE_768
553 }, {
554 .tag = HKS_TAG_PADDING,
555 .uint32Param = HKS_PADDING_NONE
556 }, {
557 .tag = HKS_TAG_DIGEST,
558 .uint32Param = HKS_DIGEST_SHA256
559 }, {
560 .tag = HKS_TAG_BLOCK_MODE,
561 .uint32Param = HKS_MODE_ECB
562 }
563 };
564 #endif
565
566 static struct HksParam g_genParams009[] = {
567 {
568 .tag = HKS_TAG_ALGORITHM,
569 .uint32Param = HKS_ALG_RSA
570 }, {
571 .tag = HKS_TAG_PURPOSE,
572 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT
573 }, {
574 .tag = HKS_TAG_KEY_SIZE,
575 .uint32Param = HKS_RSA_KEY_SIZE_768
576 }, {
577 .tag = HKS_TAG_PADDING,
578 .uint32Param = HKS_PADDING_PKCS1_V1_5
579 }, {
580 .tag = HKS_TAG_DIGEST,
581 .uint32Param = HKS_DIGEST_SHA256
582 }, {
583 .tag = HKS_TAG_BLOCK_MODE,
584 .uint32Param = HKS_MODE_ECB
585 }
586 };
587 static struct HksParam g_encryptParams009[] = {
588 {
589 .tag = HKS_TAG_ALGORITHM,
590 .uint32Param = HKS_ALG_RSA
591 }, {
592 .tag = HKS_TAG_PURPOSE,
593 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT
594 }, {
595 .tag = HKS_TAG_KEY_SIZE,
596 .uint32Param = HKS_RSA_KEY_SIZE_768
597 }, {
598 .tag = HKS_TAG_PADDING,
599 .uint32Param = HKS_PADDING_PKCS1_V1_5
600 }, {
601 .tag = HKS_TAG_DIGEST,
602 .uint32Param = HKS_DIGEST_SHA256
603 }, {
604 .tag = HKS_TAG_BLOCK_MODE,
605 .uint32Param = HKS_MODE_ECB
606 }
607 };
608 static struct HksParam g_decryptParams009[] = {
609 {
610 .tag = HKS_TAG_ALGORITHM,
611 .uint32Param = HKS_ALG_RSA
612 }, {
613 .tag = HKS_TAG_PURPOSE,
614 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
615 }, {
616 .tag = HKS_TAG_KEY_SIZE,
617 .uint32Param = HKS_RSA_KEY_SIZE_768
618 }, {
619 .tag = HKS_TAG_PADDING,
620 .uint32Param = HKS_PADDING_PKCS1_V1_5
621 }, {
622 .tag = HKS_TAG_DIGEST,
623 .uint32Param = HKS_DIGEST_SHA256
624 }, {
625 .tag = HKS_TAG_BLOCK_MODE,
626 .uint32Param = HKS_MODE_ECB
627 }
628 };
629
630 static struct HksParam g_genParams010[] = {
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_768
640 }, {
641 .tag = HKS_TAG_PADDING,
642 .uint32Param = HKS_PADDING_OAEP
643 }, {
644 .tag = HKS_TAG_DIGEST,
645 .uint32Param = HKS_DIGEST_SHA1
646 }, {
647 .tag = HKS_TAG_BLOCK_MODE,
648 .uint32Param = HKS_MODE_ECB
649 }
650 };
651 static struct HksParam g_encryptParams010[] = {
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_768
661 }, {
662 .tag = HKS_TAG_PADDING,
663 .uint32Param = HKS_PADDING_OAEP
664 }, {
665 .tag = HKS_TAG_DIGEST,
666 .uint32Param = HKS_DIGEST_SHA1
667 }, {
668 .tag = HKS_TAG_BLOCK_MODE,
669 .uint32Param = HKS_MODE_ECB
670 }
671 };
672 static struct HksParam g_decryptParams010[] = {
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_768
682 }, {
683 .tag = HKS_TAG_PADDING,
684 .uint32Param = HKS_PADDING_OAEP
685 }, {
686 .tag = HKS_TAG_DIGEST,
687 .uint32Param = HKS_DIGEST_SHA1
688 }, {
689 .tag = HKS_TAG_BLOCK_MODE,
690 .uint32Param = HKS_MODE_ECB
691 }
692 };
693
694 #ifdef _USE_OPENSSL_
695 /**
696 * @tc.name: HksRsaCipherPart1Test.HksRsaCipherPart1Test001
697 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-512 pad-NONE mode-ECB.
698 * @tc.type: FUNC
699 */
700 HWTEST_F(HksRsaCipherPart1Test, HksRsaCipherPart1Test001, TestSize.Level0)
701 {
702 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest001";
703 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
704 struct HksBlob inData = { Unittest::RsaCipher::g_inData_64.length(),
705 (uint8_t *)Unittest::RsaCipher::g_inData_64.c_str() };
706
707 struct HksParamSet *genParamSet = nullptr;
708 int32_t ret = InitParamSet(&genParamSet, g_genParams001, sizeof(g_genParams001)/sizeof(HksParam));
709 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
710
711 struct HksParamSet *encryptParamSet = nullptr;
712 ret = InitParamSet(&encryptParamSet, g_encryptParams001, sizeof(g_encryptParams001)/sizeof(HksParam));
713 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
714
715 struct HksParamSet *decryptParamSet = nullptr;
716 ret = InitParamSet(&decryptParamSet, g_decryptParams001, sizeof(g_decryptParams001)/sizeof(HksParam));
717 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
718
719 ret = HksRsaCipherTestCase(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, &inData);
720 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
721
722 HksFreeParamSet(&genParamSet);
723 HksFreeParamSet(&encryptParamSet);
724 HksFreeParamSet(&decryptParamSet);
725 }
726 #endif
727
728 /**
729 * @tc.name: HksRsaCipherPart1Test.HksRsaCipherPart1Test002
730 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-512 pad-PKCS1_V1_5 mode-ECB.
731 * @tc.type: FUNC
732 */
733 HWTEST_F(HksRsaCipherPart1Test, HksRsaCipherPart1Test002, TestSize.Level0)
734 {
735 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest002";
736 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
737 struct HksBlob inData = { Unittest::RsaCipher::g_inData_32.length(),
738 (uint8_t *)Unittest::RsaCipher::g_inData_32.c_str() };
739
740 struct HksParamSet *genParamSet = nullptr;
741 int32_t ret = InitParamSet(&genParamSet, g_genParams002, sizeof(g_genParams002)/sizeof(HksParam));
742 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
743
744 struct HksParamSet *encryptParamSet = nullptr;
745 ret = InitParamSet(&encryptParamSet, g_encryptParams002, sizeof(g_encryptParams002)/sizeof(HksParam));
746 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
747
748 struct HksParamSet *decryptParamSet = nullptr;
749 ret = InitParamSet(&decryptParamSet, g_decryptParams002, sizeof(g_decryptParams002)/sizeof(HksParam));
750 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
751
752 ret = HksRsaCipherTestCase(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, &inData);
753 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
754
755 HksFreeParamSet(&genParamSet);
756 HksFreeParamSet(&encryptParamSet);
757 HksFreeParamSet(&decryptParamSet);
758 }
759
760 /**
761 * @tc.name: HksRsaCipherPart1Test.HksRsaCipherPart1Test003
762 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-512 pad-OAEP dig-SHA1 mode-ECB.
763 * @tc.type: FUNC
764 */
765 HWTEST_F(HksRsaCipherPart1Test, HksRsaCipherPart1Test003, TestSize.Level0)
766 {
767 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest003";
768 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
769 struct HksBlob inData = { Unittest::RsaCipher::g_inData_14.length(),
770 (uint8_t *)Unittest::RsaCipher::g_inData_14.c_str() };
771
772 struct HksParamSet *genParamSet = nullptr;
773 int32_t ret = InitParamSet(&genParamSet, g_genParams003, sizeof(g_genParams003)/sizeof(HksParam));
774 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
775
776 struct HksParamSet *encryptParamSet = nullptr;
777 ret = InitParamSet(&encryptParamSet, g_encryptParams003, sizeof(g_encryptParams003)/sizeof(HksParam));
778 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
779
780 struct HksParamSet *decryptParamSet = nullptr;
781 ret = InitParamSet(&decryptParamSet, g_decryptParams003, sizeof(g_decryptParams003)/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: HksRsaCipherPart1Test.HksRsaCipherPart1Test004
794 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-512 pad-OAEP dig-SHA224 mode-ECB.
795 * @tc.type: FUNC
796 */
797 HWTEST_F(HksRsaCipherPart1Test, HksRsaCipherPart1Test004, TestSize.Level0)
798 {
799 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest004";
800 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
801 struct HksBlob inData = { Unittest::RsaCipher::g_inData_5.length(),
802 (uint8_t *)Unittest::RsaCipher::g_inData_5.c_str() };
803
804 struct HksParamSet *genParamSet = nullptr;
805 int32_t ret = InitParamSet(&genParamSet, g_genParams004, sizeof(g_genParams004)/sizeof(HksParam));
806 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
807
808 struct HksParamSet *encryptParamSet = nullptr;
809 ret = InitParamSet(&encryptParamSet, g_encryptParams004, sizeof(g_encryptParams004)/sizeof(HksParam));
810 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
811
812 struct HksParamSet *decryptParamSet = nullptr;
813 ret = InitParamSet(&decryptParamSet, g_decryptParams004, sizeof(g_decryptParams004)/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: HksRsaCipherPart1Test.HksRsaCipherPart1Test005
826 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-512 pad-OAEP dig-SHA256 mode-ECB.
827 * @tc.type: FUNC
828 */
829 HWTEST_F(HksRsaCipherPart1Test, HksRsaCipherPart1Test005, TestSize.Level0)
830 {
831 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest005";
832 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
833 struct HksBlob inData = { Unittest::RsaCipher::g_inData_20.length(),
834 (uint8_t *)Unittest::RsaCipher::g_inData_20.c_str() };
835
836 struct HksParamSet *genParamSet = nullptr;
837 int32_t ret = InitParamSet(&genParamSet, g_genParams005, sizeof(g_genParams005)/sizeof(HksParam));
838 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
839
840 struct HksParamSet *encryptParamSet = nullptr;
841 ret = InitParamSet(&encryptParamSet, g_encryptParams005, sizeof(g_encryptParams005)/sizeof(HksParam));
842 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
843
844 struct HksParamSet *decryptParamSet = nullptr;
845 ret = InitParamSet(&decryptParamSet, g_decryptParams005, sizeof(g_decryptParams005)/sizeof(HksParam));
846 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
847
848 ret = HksRsaCipherTestCaseAbnormal(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, &inData);
849 EXPECT_EQ(ret, HKS_FAILURE) << "this case should failed.";
850
851 HksFreeParamSet(&genParamSet);
852 HksFreeParamSet(&encryptParamSet);
853 HksFreeParamSet(&decryptParamSet);
854 }
855
856 /**
857 * @tc.name: HksRsaCipherPart1Test.HksRsaCipherPart1Test006
858 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-512 pad-OAEP dig-SHA384 mode-ECB.
859 * @tc.type: FUNC
860 */
861 HWTEST_F(HksRsaCipherPart1Test, HksRsaCipherPart1Test006, TestSize.Level0)
862 {
863 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest006";
864 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
865 struct HksBlob inData = { Unittest::RsaCipher::g_inData_20.length(),
866 (uint8_t *)Unittest::RsaCipher::g_inData_20.c_str() };
867
868 struct HksParamSet *genParamSet = nullptr;
869 int32_t ret = InitParamSet(&genParamSet, g_genParams006, sizeof(g_genParams006)/sizeof(HksParam));
870 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
871
872 struct HksParamSet *encryptParamSet = nullptr;
873 ret = InitParamSet(&encryptParamSet, g_encryptParams006, sizeof(g_encryptParams006)/sizeof(HksParam));
874 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
875
876 struct HksParamSet *decryptParamSet = nullptr;
877 ret = InitParamSet(&decryptParamSet, g_decryptParams006, sizeof(g_decryptParams006)/sizeof(HksParam));
878 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
879
880 ret = HksRsaCipherTestCaseAbnormal(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, &inData);
881 EXPECT_EQ(ret, HKS_FAILURE) << "this case should failed.";
882
883 HksFreeParamSet(&genParamSet);
884 HksFreeParamSet(&encryptParamSet);
885 HksFreeParamSet(&decryptParamSet);
886 }
887
888 /**
889 * @tc.name: HksRsaCipherPart1Test.HksRsaCipherPart1Test007
890 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-512 pad-OAEP dig-SHA512 mode-ECB.
891 * @tc.type: FUNC
892 */
893 HWTEST_F(HksRsaCipherPart1Test, HksRsaCipherPart1Test007, TestSize.Level0)
894 {
895 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest007";
896 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
897 struct HksBlob inData = { Unittest::RsaCipher::g_inData_20.length(),
898 (uint8_t *)Unittest::RsaCipher::g_inData_20.c_str() };
899
900 struct HksParamSet *genParamSet = nullptr;
901 int32_t ret = InitParamSet(&genParamSet, g_genParams007, sizeof(g_genParams007)/sizeof(HksParam));
902 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
903
904 struct HksParamSet *encryptParamSet = nullptr;
905 ret = InitParamSet(&encryptParamSet, g_encryptParams007, sizeof(g_encryptParams007)/sizeof(HksParam));
906 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
907
908 struct HksParamSet *decryptParamSet = nullptr;
909 ret = InitParamSet(&decryptParamSet, g_decryptParams007, sizeof(g_decryptParams007)/sizeof(HksParam));
910 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
911
912 ret = HksRsaCipherTestCaseAbnormal(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, &inData);
913 EXPECT_EQ(ret, HKS_FAILURE) << "this case should failed.";
914
915 HksFreeParamSet(&genParamSet);
916 HksFreeParamSet(&encryptParamSet);
917 HksFreeParamSet(&decryptParamSet);
918 }
919
920 #ifdef _USE_OPENSSL_
921 /**
922 * @tc.name: HksRsaCipherPart1Test.HksRsaCipherPart1Test008
923 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-768 pad-NONE mode-ECB.
924 * @tc.type: FUNC
925 */
926 HWTEST_F(HksRsaCipherPart1Test, HksRsaCipherPart1Test008, TestSize.Level0)
927 {
928 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest008";
929 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
930 struct HksBlob inData = { Unittest::RsaCipher::g_inData_96.length(),
931 (uint8_t *)Unittest::RsaCipher::g_inData_96.c_str() };
932
933 struct HksParamSet *genParamSet = nullptr;
934 int32_t ret = InitParamSet(&genParamSet, g_genParams008, sizeof(g_genParams008)/sizeof(HksParam));
935 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
936
937 struct HksParamSet *encryptParamSet = nullptr;
938 ret = InitParamSet(&encryptParamSet, g_encryptParams008, sizeof(g_encryptParams008)/sizeof(HksParam));
939 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
940
941 struct HksParamSet *decryptParamSet = nullptr;
942 ret = InitParamSet(&decryptParamSet, g_decryptParams008, sizeof(g_decryptParams008)/sizeof(HksParam));
943 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
944
945 ret = HksRsaCipherTestCase(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, &inData);
946 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
947
948 HksFreeParamSet(&genParamSet);
949 HksFreeParamSet(&encryptParamSet);
950 HksFreeParamSet(&decryptParamSet);
951 }
952 #endif
953
954 /**
955 * @tc.name: HksRsaCipherPart1Test.HksRsaCipherPart1Test009
956 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-768 pad-PKCS1_V1_5 mode-ECB.
957 * @tc.type: FUNC
958 */
959 HWTEST_F(HksRsaCipherPart1Test, HksRsaCipherPart1Test009, TestSize.Level0)
960 {
961 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest009";
962 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
963 struct HksBlob inData = { Unittest::RsaCipher::g_inData_32.length(),
964 (uint8_t *)Unittest::RsaCipher::g_inData_32.c_str() };
965
966 struct HksParamSet *genParamSet = nullptr;
967 int32_t ret = InitParamSet(&genParamSet, g_genParams009, sizeof(g_genParams009)/sizeof(HksParam));
968 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
969
970 struct HksParamSet *encryptParamSet = nullptr;
971 ret = InitParamSet(&encryptParamSet, g_encryptParams009, sizeof(g_encryptParams009)/sizeof(HksParam));
972 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
973
974 struct HksParamSet *decryptParamSet = nullptr;
975 ret = InitParamSet(&decryptParamSet, g_decryptParams009, sizeof(g_decryptParams009)/sizeof(HksParam));
976 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
977
978 ret = HksRsaCipherTestCase(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, &inData);
979 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
980
981 HksFreeParamSet(&genParamSet);
982 HksFreeParamSet(&encryptParamSet);
983 HksFreeParamSet(&decryptParamSet);
984 }
985
986 /**
987 * @tc.name: HksRsaCipherPart1Test.HksRsaCipherPart1Test010
988 * @tc.desc: alg-RSA pur-ENCRYPT-DECRYPT size-768 pad-OAEP dig-SHA1 mode-ECB.
989 * @tc.type: FUNC
990 */
991 HWTEST_F(HksRsaCipherPart1Test, HksRsaCipherPart1Test010, TestSize.Level0)
992 {
993 char tmpKeyAlias[] = "HksRSACipherKeyAliasTest018";
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_genParams010, sizeof(g_genParams010)/sizeof(HksParam));
1000 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
1001
1002 struct HksParamSet *encryptParamSet = nullptr;
1003 ret = InitParamSet(&encryptParamSet, g_encryptParams010, sizeof(g_encryptParams010)/sizeof(HksParam));
1004 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
1005
1006 struct HksParamSet *decryptParamSet = nullptr;
1007 ret = InitParamSet(&decryptParamSet, g_decryptParams010, sizeof(g_decryptParams010)/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 }