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_aes_cipher_part1_test.h"
17 #include "hks_aes_cipher_test_common.h"
18
19 #include <gtest/gtest.h>
20
21 using namespace testing::ext;
22 namespace Unittest::AesCipher {
23 class HksAesCipherPart1Test : 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 HksAesCipherPart1Test::SetUpTestCase(void)
35 {
36 }
37
TearDownTestCase(void)38 void HksAesCipherPart1Test::TearDownTestCase(void)
39 {
40 }
41
SetUp()42 void HksAesCipherPart1Test::SetUp()
43 {
44 }
45
TearDown()46 void HksAesCipherPart1Test::TearDown()
47 {
48 }
49
50 static struct HksParam g_genParams001[] = {
51 {
52 .tag = HKS_TAG_ALGORITHM,
53 .uint32Param = HKS_ALG_AES
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_AES_KEY_SIZE_128
60 }, {
61 .tag = HKS_TAG_PADDING,
62 .uint32Param = HKS_PADDING_NONE
63 }, {
64 .tag = HKS_TAG_BLOCK_MODE,
65 .uint32Param = HKS_MODE_CBC
66 }
67 };
68 static struct HksParam g_encryptParams001[] = {
69 {
70 .tag = HKS_TAG_ALGORITHM,
71 .uint32Param = HKS_ALG_AES
72 }, {
73 .tag = HKS_TAG_PURPOSE,
74 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT
75 }, {
76 .tag = HKS_TAG_KEY_SIZE,
77 .uint32Param = HKS_AES_KEY_SIZE_128
78 }, {
79 .tag = HKS_TAG_PADDING,
80 .uint32Param = HKS_PADDING_NONE
81 }, {
82 .tag = HKS_TAG_BLOCK_MODE,
83 .uint32Param = HKS_MODE_CBC
84 }, {
85 .tag = HKS_TAG_DIGEST,
86 .uint32Param = HKS_DIGEST_NONE
87 }, {
88 .tag = HKS_TAG_IV,
89 .blob = {
90 .size = Unittest::AesCipher::IV_SIZE,
91 .data = (uint8_t *)Unittest::AesCipher::IV
92 }
93 }
94 };
95 static struct HksParam g_decryptParams001[] = {
96 {
97 .tag = HKS_TAG_ALGORITHM,
98 .uint32Param = HKS_ALG_AES
99 }, {
100 .tag = HKS_TAG_PURPOSE,
101 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
102 }, {
103 .tag = HKS_TAG_KEY_SIZE,
104 .uint32Param = HKS_AES_KEY_SIZE_128
105 }, {
106 .tag = HKS_TAG_PADDING,
107 .uint32Param = HKS_PADDING_NONE
108 }, {
109 .tag = HKS_TAG_BLOCK_MODE,
110 .uint32Param = HKS_MODE_CBC
111 }, {
112 .tag = HKS_TAG_DIGEST,
113 .uint32Param = HKS_DIGEST_NONE
114 }, {
115 .tag = HKS_TAG_IV,
116 .blob = {
117 .size = Unittest::AesCipher::IV_SIZE,
118 .data = (uint8_t *)Unittest::AesCipher::IV
119 }
120 }
121 };
122
123 static struct HksParam g_genParams002[] = {
124 {
125 .tag = HKS_TAG_ALGORITHM,
126 .uint32Param = HKS_ALG_AES
127 }, {
128 .tag = HKS_TAG_PURPOSE,
129 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT
130 }, {
131 .tag = HKS_TAG_KEY_SIZE,
132 .uint32Param = HKS_AES_KEY_SIZE_128
133 }, {
134 .tag = HKS_TAG_PADDING,
135 .uint32Param = HKS_PADDING_PKCS7
136 }, {
137 .tag = HKS_TAG_BLOCK_MODE,
138 .uint32Param = HKS_MODE_CBC
139 }
140 };
141 static struct HksParam g_encryptParams002[] = {
142 {
143 .tag = HKS_TAG_ALGORITHM,
144 .uint32Param = HKS_ALG_AES
145 }, {
146 .tag = HKS_TAG_PURPOSE,
147 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT
148 }, {
149 .tag = HKS_TAG_KEY_SIZE,
150 .uint32Param = HKS_AES_KEY_SIZE_128
151 }, {
152 .tag = HKS_TAG_PADDING,
153 .uint32Param = HKS_PADDING_PKCS7
154 }, {
155 .tag = HKS_TAG_BLOCK_MODE,
156 .uint32Param = HKS_MODE_CBC
157 }, {
158 .tag = HKS_TAG_DIGEST,
159 .uint32Param = HKS_DIGEST_NONE
160 }, {
161 .tag = HKS_TAG_IV,
162 .blob = {
163 .size = Unittest::AesCipher::IV_SIZE,
164 .data = (uint8_t *)Unittest::AesCipher::IV
165 }
166 }
167 };
168 static struct HksParam g_decryptParams002[] = {
169 {
170 .tag = HKS_TAG_ALGORITHM,
171 .uint32Param = HKS_ALG_AES
172 }, {
173 .tag = HKS_TAG_PURPOSE,
174 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
175 }, {
176 .tag = HKS_TAG_KEY_SIZE,
177 .uint32Param = HKS_AES_KEY_SIZE_128
178 }, {
179 .tag = HKS_TAG_PADDING,
180 .uint32Param = HKS_PADDING_PKCS7
181 }, {
182 .tag = HKS_TAG_BLOCK_MODE,
183 .uint32Param = HKS_MODE_CBC
184 }, {
185 .tag = HKS_TAG_DIGEST,
186 .uint32Param = HKS_DIGEST_NONE
187 }, {
188 .tag = HKS_TAG_IV,
189 .blob = {
190 .size = Unittest::AesCipher::IV_SIZE,
191 .data = (uint8_t *)Unittest::AesCipher::IV
192 }
193 }
194 };
195
196 #if defined(_USE_OPENSSL_) && defined(_USE_MBEDTLS_)
197 static struct HksParam g_genParams003[] = {
198 {
199 .tag = HKS_TAG_ALGORITHM,
200 .uint32Param = HKS_ALG_AES
201 }, {
202 .tag = HKS_TAG_PURPOSE,
203 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT
204 }, {
205 .tag = HKS_TAG_KEY_SIZE,
206 .uint32Param = HKS_AES_KEY_SIZE_128
207 }, {
208 .tag = HKS_TAG_PADDING,
209 .uint32Param = HKS_PADDING_NONE
210 }, {
211 .tag = HKS_TAG_BLOCK_MODE,
212 .uint32Param = HKS_MODE_CCM
213 }
214 };
215 static struct HksParam g_encryptParams003[] = {
216 {
217 .tag = HKS_TAG_ALGORITHM,
218 .uint32Param = HKS_ALG_AES
219 }, {
220 .tag = HKS_TAG_PURPOSE,
221 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT
222 }, {
223 .tag = HKS_TAG_KEY_SIZE,
224 .uint32Param = HKS_AES_KEY_SIZE_128
225 }, {
226 .tag = HKS_TAG_PADDING,
227 .uint32Param = HKS_PADDING_NONE
228 }, {
229 .tag = HKS_TAG_BLOCK_MODE,
230 .uint32Param = HKS_MODE_CCM
231 }, {
232 .tag = HKS_TAG_DIGEST,
233 .uint32Param = HKS_DIGEST_NONE
234 }, {
235 .tag = HKS_TAG_ASSOCIATED_DATA,
236 .blob = {
237 .size = Unittest::AesCipher::AAD_SIZE,
238 .data = (uint8_t *)Unittest::AesCipher::AAD
239 }
240 }, {
241 .tag = HKS_TAG_NONCE,
242 .blob = {
243 .size = Unittest::AesCipher::NONCE_SIZE,
244 .data = (uint8_t *)Unittest::AesCipher::NONCE
245 }
246 }, {
247 .tag = HKS_TAG_AE_TAG,
248 .blob = {
249 .size = Unittest::AesCipher::AEAD_SIZE,
250 .data = (uint8_t *)Unittest::AesCipher::AEAD
251 }
252 }
253 };
254 static struct HksParam g_decryptParams003[] = {
255 {
256 .tag = HKS_TAG_ALGORITHM,
257 .uint32Param = HKS_ALG_AES
258 }, {
259 .tag = HKS_TAG_PURPOSE,
260 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
261 }, {
262 .tag = HKS_TAG_KEY_SIZE,
263 .uint32Param = HKS_AES_KEY_SIZE_128
264 }, {
265 .tag = HKS_TAG_PADDING,
266 .uint32Param = HKS_PADDING_NONE
267 }, {
268 .tag = HKS_TAG_BLOCK_MODE,
269 .uint32Param = HKS_MODE_CCM
270 }, {
271 .tag = HKS_TAG_DIGEST,
272 .uint32Param = HKS_DIGEST_NONE
273 }, {
274 .tag = HKS_TAG_ASSOCIATED_DATA,
275 .blob = {
276 .size = Unittest::AesCipher::AAD_SIZE,
277 .data = (uint8_t *)Unittest::AesCipher::AAD
278 }
279 }, {
280 .tag = HKS_TAG_NONCE,
281 .blob = {
282 .size = Unittest::AesCipher::NONCE_SIZE,
283 .data = (uint8_t *)Unittest::AesCipher::NONCE
284 }
285 }, {
286 .tag = HKS_TAG_AE_TAG,
287 .blob = {
288 .size = Unittest::AesCipher::AEAD_SIZE,
289 .data = (uint8_t *)Unittest::AesCipher::AEAD
290 }
291 }
292 };
293 #endif
294
295 static struct HksParam g_genParams004[] = {
296 {
297 .tag = HKS_TAG_ALGORITHM,
298 .uint32Param = HKS_ALG_AES
299 }, {
300 .tag = HKS_TAG_PURPOSE,
301 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT
302 }, {
303 .tag = HKS_TAG_KEY_SIZE,
304 .uint32Param = HKS_AES_KEY_SIZE_128
305 }, {
306 .tag = HKS_TAG_PADDING,
307 .uint32Param = HKS_PADDING_NONE
308 }, {
309 .tag = HKS_TAG_BLOCK_MODE,
310 .uint32Param = HKS_MODE_GCM
311 }
312 };
313 static struct HksParam g_encryptParams004[] = {
314 {
315 .tag = HKS_TAG_ALGORITHM,
316 .uint32Param = HKS_ALG_AES
317 }, {
318 .tag = HKS_TAG_PURPOSE,
319 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT
320 }, {
321 .tag = HKS_TAG_KEY_SIZE,
322 .uint32Param = HKS_AES_KEY_SIZE_128
323 }, {
324 .tag = HKS_TAG_PADDING,
325 .uint32Param = HKS_PADDING_NONE
326 }, {
327 .tag = HKS_TAG_BLOCK_MODE,
328 .uint32Param = HKS_MODE_GCM
329 }, {
330 .tag = HKS_TAG_DIGEST,
331 .uint32Param = HKS_DIGEST_NONE
332 }, {
333 .tag = HKS_TAG_ASSOCIATED_DATA,
334 .blob = {
335 .size = Unittest::AesCipher::AAD_SIZE,
336 .data = (uint8_t *)Unittest::AesCipher::AAD
337 }
338 }, {
339 .tag = HKS_TAG_NONCE,
340 .blob = {
341 .size = Unittest::AesCipher::NONCE_SIZE,
342 .data = (uint8_t *)Unittest::AesCipher::NONCE
343 }
344 }, {
345 .tag = HKS_TAG_AE_TAG,
346 .blob = {
347 .size = Unittest::AesCipher::AEAD_SIZE,
348 .data = (uint8_t *)Unittest::AesCipher::AEAD
349 }
350 }
351 };
352 static struct HksParam g_decryptParams004[] = {
353 {
354 .tag = HKS_TAG_ALGORITHM,
355 .uint32Param = HKS_ALG_AES
356 }, {
357 .tag = HKS_TAG_PURPOSE,
358 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
359 }, {
360 .tag = HKS_TAG_KEY_SIZE,
361 .uint32Param = HKS_AES_KEY_SIZE_128
362 }, {
363 .tag = HKS_TAG_PADDING,
364 .uint32Param = HKS_PADDING_NONE
365 }, {
366 .tag = HKS_TAG_BLOCK_MODE,
367 .uint32Param = HKS_MODE_GCM
368 }, {
369 .tag = HKS_TAG_DIGEST,
370 .uint32Param = HKS_DIGEST_NONE
371 }, {
372 .tag = HKS_TAG_ASSOCIATED_DATA,
373 .blob = {
374 .size = Unittest::AesCipher::AAD_SIZE,
375 .data = (uint8_t *)Unittest::AesCipher::AAD
376 }
377 }, {
378 .tag = HKS_TAG_NONCE,
379 .blob = {
380 .size = Unittest::AesCipher::NONCE_SIZE,
381 .data = (uint8_t *)Unittest::AesCipher::NONCE
382 }
383 }, {
384 .tag = HKS_TAG_AE_TAG,
385 .blob = {
386 .size = Unittest::AesCipher::AEAD_SIZE,
387 .data = (uint8_t *)Unittest::AesCipher::AEAD
388 }
389 }
390 };
391 static struct HksParam g_decrypt1Params004[] = {
392 {
393 .tag = HKS_TAG_ALGORITHM,
394 .uint32Param = HKS_ALG_AES
395 }, {
396 .tag = HKS_TAG_PURPOSE,
397 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
398 }, {
399 .tag = HKS_TAG_KEY_SIZE,
400 .uint32Param = HKS_AES_KEY_SIZE_128
401 }, {
402 .tag = HKS_TAG_PADDING,
403 .uint32Param = HKS_PADDING_NONE
404 }, {
405 .tag = HKS_TAG_BLOCK_MODE,
406 .uint32Param = HKS_MODE_GCM
407 }, {
408 .tag = HKS_TAG_DIGEST,
409 .uint32Param = HKS_DIGEST_NONE
410 }, {
411 .tag = HKS_TAG_ASSOCIATED_DATA,
412 .blob = {
413 .size = Unittest::AesCipher::AAD_SIZE,
414 .data = (uint8_t *)Unittest::AesCipher::AAD
415 }
416 }, {
417 .tag = HKS_TAG_NONCE,
418 .blob = {
419 .size = Unittest::AesCipher::NONCE_SIZE,
420 .data = (uint8_t *)Unittest::AesCipher::NONCE
421 }
422 }
423 };
424
425 static struct HksParam g_genParams005[] = {
426 {
427 .tag = HKS_TAG_ALGORITHM,
428 .uint32Param = HKS_ALG_AES
429 }, {
430 .tag = HKS_TAG_PURPOSE,
431 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT
432 }, {
433 .tag = HKS_TAG_KEY_SIZE,
434 .uint32Param = HKS_AES_KEY_SIZE_128
435 }, {
436 .tag = HKS_TAG_PADDING,
437 .uint32Param = HKS_PADDING_NONE
438 }, {
439 .tag = HKS_TAG_BLOCK_MODE,
440 .uint32Param = HKS_MODE_CTR
441 }
442 };
443 static struct HksParam g_encryptParams005[] = {
444 {
445 .tag = HKS_TAG_ALGORITHM,
446 .uint32Param = HKS_ALG_AES
447 }, {
448 .tag = HKS_TAG_PURPOSE,
449 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT
450 }, {
451 .tag = HKS_TAG_KEY_SIZE,
452 .uint32Param = HKS_AES_KEY_SIZE_128
453 }, {
454 .tag = HKS_TAG_PADDING,
455 .uint32Param = HKS_PADDING_NONE
456 }, {
457 .tag = HKS_TAG_BLOCK_MODE,
458 .uint32Param = HKS_MODE_CTR
459 }, {
460 .tag = HKS_TAG_DIGEST,
461 .uint32Param = HKS_DIGEST_NONE
462 }, {
463 .tag = HKS_TAG_IV,
464 .blob = {
465 .size = Unittest::AesCipher::IV_SIZE,
466 .data = (uint8_t *)Unittest::AesCipher::IV
467 }
468 }
469 };
470 static struct HksParam g_decryptParams005[] = {
471 {
472 .tag = HKS_TAG_ALGORITHM,
473 .uint32Param = HKS_ALG_AES
474 }, {
475 .tag = HKS_TAG_PURPOSE,
476 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
477 }, {
478 .tag = HKS_TAG_KEY_SIZE,
479 .uint32Param = HKS_AES_KEY_SIZE_128
480 }, {
481 .tag = HKS_TAG_PADDING,
482 .uint32Param = HKS_PADDING_NONE
483 }, {
484 .tag = HKS_TAG_BLOCK_MODE,
485 .uint32Param = HKS_MODE_CTR
486 }, {
487 .tag = HKS_TAG_DIGEST,
488 .uint32Param = HKS_DIGEST_NONE
489 }, {
490 .tag = HKS_TAG_IV,
491 .blob = {
492 .size = Unittest::AesCipher::IV_SIZE,
493 .data = (uint8_t *)Unittest::AesCipher::IV
494 }
495 }
496 };
497
498 static struct HksParam g_genParams006[] = {
499 {
500 .tag = HKS_TAG_ALGORITHM,
501 .uint32Param = HKS_ALG_AES
502 }, {
503 .tag = HKS_TAG_PURPOSE,
504 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT
505 }, {
506 .tag = HKS_TAG_KEY_SIZE,
507 .uint32Param = HKS_AES_KEY_SIZE_128
508 }, {
509 .tag = HKS_TAG_PADDING,
510 .uint32Param = HKS_PADDING_NONE
511 }, {
512 .tag = HKS_TAG_BLOCK_MODE,
513 .uint32Param = HKS_MODE_ECB
514 }
515 };
516 static struct HksParam g_encryptParams006[] = {
517 {
518 .tag = HKS_TAG_ALGORITHM,
519 .uint32Param = HKS_ALG_AES
520 }, {
521 .tag = HKS_TAG_PURPOSE,
522 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT
523 }, {
524 .tag = HKS_TAG_KEY_SIZE,
525 .uint32Param = HKS_AES_KEY_SIZE_128
526 }, {
527 .tag = HKS_TAG_PADDING,
528 .uint32Param = HKS_PADDING_NONE
529 }, {
530 .tag = HKS_TAG_BLOCK_MODE,
531 .uint32Param = HKS_MODE_ECB
532 }, {
533 .tag = HKS_TAG_DIGEST,
534 .uint32Param = HKS_DIGEST_NONE
535 }, {
536 .tag = HKS_TAG_IV,
537 .blob = {
538 .size = Unittest::AesCipher::IV_SIZE,
539 .data = (uint8_t *)Unittest::AesCipher::IV
540 }
541 }
542 };
543 static struct HksParam g_decryptParams006[] = {
544 {
545 .tag = HKS_TAG_ALGORITHM,
546 .uint32Param = HKS_ALG_AES
547 }, {
548 .tag = HKS_TAG_PURPOSE,
549 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
550 }, {
551 .tag = HKS_TAG_KEY_SIZE,
552 .uint32Param = HKS_AES_KEY_SIZE_128
553 }, {
554 .tag = HKS_TAG_PADDING,
555 .uint32Param = HKS_PADDING_NONE
556 }, {
557 .tag = HKS_TAG_BLOCK_MODE,
558 .uint32Param = HKS_MODE_ECB
559 }, {
560 .tag = HKS_TAG_DIGEST,
561 .uint32Param = HKS_DIGEST_NONE
562 }, {
563 .tag = HKS_TAG_IV,
564 .blob = {
565 .size = Unittest::AesCipher::IV_SIZE,
566 .data = (uint8_t *)Unittest::AesCipher::IV
567 }
568 }
569 };
570
571 #ifdef _USE_OPENSSL_
572 static struct HksParam g_genParams007[] = {
573 {
574 .tag = HKS_TAG_ALGORITHM,
575 .uint32Param = HKS_ALG_AES
576 }, {
577 .tag = HKS_TAG_PURPOSE,
578 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT
579 }, {
580 .tag = HKS_TAG_KEY_SIZE,
581 .uint32Param = HKS_AES_KEY_SIZE_128
582 }, {
583 .tag = HKS_TAG_PADDING,
584 .uint32Param = HKS_PADDING_PKCS7
585 }, {
586 .tag = HKS_TAG_BLOCK_MODE,
587 .uint32Param = HKS_MODE_ECB
588 }
589 };
590 static struct HksParam g_encryptParams007[] = {
591 {
592 .tag = HKS_TAG_ALGORITHM,
593 .uint32Param = HKS_ALG_AES
594 }, {
595 .tag = HKS_TAG_PURPOSE,
596 .uint32Param = HKS_KEY_PURPOSE_ENCRYPT
597 }, {
598 .tag = HKS_TAG_KEY_SIZE,
599 .uint32Param = HKS_AES_KEY_SIZE_128
600 }, {
601 .tag = HKS_TAG_PADDING,
602 .uint32Param = HKS_PADDING_PKCS7
603 }, {
604 .tag = HKS_TAG_BLOCK_MODE,
605 .uint32Param = HKS_MODE_ECB
606 }, {
607 .tag = HKS_TAG_DIGEST,
608 .uint32Param = HKS_DIGEST_NONE
609 }, {
610 .tag = HKS_TAG_IV,
611 .blob = {
612 .size = Unittest::AesCipher::IV_SIZE,
613 .data = (uint8_t *)Unittest::AesCipher::IV
614 }
615 }
616 };
617 static struct HksParam g_decryptParams007[] = {
618 {
619 .tag = HKS_TAG_ALGORITHM,
620 .uint32Param = HKS_ALG_AES
621 }, {
622 .tag = HKS_TAG_PURPOSE,
623 .uint32Param = HKS_KEY_PURPOSE_DECRYPT
624 }, {
625 .tag = HKS_TAG_KEY_SIZE,
626 .uint32Param = HKS_AES_KEY_SIZE_128
627 }, {
628 .tag = HKS_TAG_PADDING,
629 .uint32Param = HKS_PADDING_PKCS7
630 }, {
631 .tag = HKS_TAG_BLOCK_MODE,
632 .uint32Param = HKS_MODE_ECB
633 }, {
634 .tag = HKS_TAG_DIGEST,
635 .uint32Param = HKS_DIGEST_NONE
636 }, {
637 .tag = HKS_TAG_IV,
638 .blob = {
639 .size = Unittest::AesCipher::IV_SIZE,
640 .data = (uint8_t *)Unittest::AesCipher::IV
641 }
642 }
643 };
644 #endif
645
646 /**
647 * @tc.name: HksAesCipherPart1Test.HksAesCipherPart1Test001
648 * @tc.desc: alg-AES pur-ENCRYPT&DECRYPT mod-CBC pad-NONE size-128.
649 * @tc.type: FUNC
650 */
651 HWTEST_F(HksAesCipherPart1Test, HksAesCipherPart1Test001, TestSize.Level0)
652 {
653 char tmpKeyAlias[] = "HksAESCipherKeyAliasTest001";
654 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
655
656 struct HksParamSet *genParamSet = nullptr;
657 int32_t ret = InitParamSet(&genParamSet, g_genParams001, sizeof(g_genParams001)/sizeof(HksParam));
658 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
659
660 struct HksParamSet *encryptParamSet = nullptr;
661 ret = InitParamSet(&encryptParamSet, g_encryptParams001, sizeof(g_encryptParams001)/sizeof(HksParam));
662 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
663
664 struct HksParamSet *decryptParamSet = nullptr;
665 ret = InitParamSet(&decryptParamSet, g_decryptParams001, sizeof(g_decryptParams001)/sizeof(HksParam));
666 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
667
668 ret = HksAesCipherTestCaseOther(&keyAlias, genParamSet, encryptParamSet, decryptParamSet);
669 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
670
671 HksFreeParamSet(&genParamSet);
672 HksFreeParamSet(&encryptParamSet);
673 HksFreeParamSet(&decryptParamSet);
674 }
675
676 /**
677 * @tc.name: HksAesCipherPart1Test.HksAesCipherPart1Test002
678 * @tc.desc: alg-AES pur-ENCRYPT&DECRYPT mod-CBC pad-PKCS7 size-128.
679 * @tc.type: FUNC
680 */
681 HWTEST_F(HksAesCipherPart1Test, HksAesCipherPart1Test002, TestSize.Level0)
682 {
683 char tmpKeyAlias[] = "HksAESCipherKeyAliasTest002";
684 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
685
686 struct HksParamSet *genParamSet = nullptr;
687 int32_t ret = InitParamSet(&genParamSet, g_genParams002, sizeof(g_genParams002)/sizeof(HksParam));
688 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
689
690 struct HksParamSet *encryptParamSet = nullptr;
691 ret = InitParamSet(&encryptParamSet, g_encryptParams002, sizeof(g_encryptParams002)/sizeof(HksParam));
692 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
693
694 struct HksParamSet *decryptParamSet = nullptr;
695 ret = InitParamSet(&decryptParamSet, g_decryptParams002, sizeof(g_decryptParams002)/sizeof(HksParam));
696 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
697
698 ret = HksAesCipherTestCaseOther(&keyAlias, genParamSet, encryptParamSet, decryptParamSet);
699 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
700
701 HksFreeParamSet(&genParamSet);
702 HksFreeParamSet(&encryptParamSet);
703 HksFreeParamSet(&decryptParamSet);
704 }
705
706 #if defined(_USE_OPENSSL_) && defined(_USE_MBEDTLS_)
707 /**
708 * @tc.name: HksAesCipherPart1Test.HksAesCipherPart1Test003
709 * @tc.desc: alg-AES pur-ENCRYPT&DECRYPT mod-CCM pad-NONE size-128.
710 * @tc.type: FUNC
711 */
712 HWTEST_F(HksAesCipherPart1Test, HksAesCipherPart1Test003, TestSize.Level0)
713 {
714 char tmpKeyAlias[] = "HksAESCipherKeyAliasTest003";
715 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
716
717 struct HksParamSet *genParamSet = nullptr;
718 int32_t ret = InitParamSet(&genParamSet, g_genParams003, sizeof(g_genParams003)/sizeof(HksParam));
719 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
720
721 struct HksParamSet *encryptParamSet = nullptr;
722 ret = InitParamSet(&encryptParamSet, g_encryptParams003, sizeof(g_encryptParams003)/sizeof(HksParam));
723 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
724
725 struct HksParamSet *decryptParamSet = nullptr;
726 ret = InitParamSet(&decryptParamSet, g_decryptParams003, sizeof(g_decryptParams003)/sizeof(HksParam));
727 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
728
729 ret = HksAESCipherTestCaseCcm(&keyAlias, genParamSet, encryptParamSet, decryptParamSet);
730 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
731
732 HksFreeParamSet(&genParamSet);
733 HksFreeParamSet(&encryptParamSet);
734 HksFreeParamSet(&decryptParamSet);
735 }
736 #endif
737
738 /**
739 * @tc.name: HksAesCipherPart1Test.HksAesCipherPart1Test004
740 * @tc.desc: alg-AES pur-ENCRYPT&DECRYPT mod-GCM pad-NONE size-128.
741 * @tc.type: FUNC
742 */
743 HWTEST_F(HksAesCipherPart1Test, HksAesCipherPart1Test004, TestSize.Level0)
744 {
745 char tmpKeyAlias[] = "HksAESCipherKeyAliasTest004";
746 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
747
748 struct HksParamSet *genParamSet = nullptr;
749 int32_t ret = InitParamSet(&genParamSet, g_genParams004, sizeof(g_genParams004)/sizeof(HksParam));
750 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
751
752 struct HksParamSet *encryptParamSet = nullptr;
753 ret = InitParamSet(&encryptParamSet, g_encryptParams004, sizeof(g_encryptParams004)/sizeof(HksParam));
754 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
755
756 struct HksParamSet *decryptParamSet = nullptr;
757 ret = InitParamSet(&decryptParamSet, g_decryptParams004, sizeof(g_decryptParams004)/sizeof(HksParam));
758 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
759
760 struct HksParamSet *decrypt1ParamSet = nullptr;
761 ret = InitParamSet(&decrypt1ParamSet, g_decrypt1Params004, sizeof(g_decrypt1Params004)/sizeof(HksParam));
762 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt1) failed.";
763
764 ret = HksAesCipherTestCaseGcm(&keyAlias, genParamSet, encryptParamSet, decryptParamSet, decrypt1ParamSet);
765 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
766
767 HksFreeParamSet(&genParamSet);
768 HksFreeParamSet(&encryptParamSet);
769 HksFreeParamSet(&decryptParamSet);
770 }
771
772 /**
773 * @tc.name: HksAesCipherPart1Test.HksAesCipherPart1Test005
774 * @tc.desc: alg-AES pur-ENCRYPT&DECRYPT mod-CTR pad-NONE size-128.
775 * @tc.type: FUNC
776 */
777 HWTEST_F(HksAesCipherPart1Test, HksAesCipherPart1Test005, TestSize.Level0)
778 {
779 char tmpKeyAlias[] = "HksAESCipherKeyAliasTest005";
780 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
781
782 struct HksParamSet *genParamSet = nullptr;
783 int32_t ret = InitParamSet(&genParamSet, g_genParams005, sizeof(g_genParams005)/sizeof(HksParam));
784 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
785
786 struct HksParamSet *encryptParamSet = nullptr;
787 ret = InitParamSet(&encryptParamSet, g_encryptParams005, sizeof(g_encryptParams005)/sizeof(HksParam));
788 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
789
790 struct HksParamSet *decryptParamSet = nullptr;
791 ret = InitParamSet(&decryptParamSet, g_decryptParams005, sizeof(g_decryptParams005)/sizeof(HksParam));
792 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
793
794 ret = HksAesCipherTestCaseOther(&keyAlias, genParamSet, encryptParamSet, decryptParamSet);
795 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
796
797 HksFreeParamSet(&genParamSet);
798 HksFreeParamSet(&encryptParamSet);
799 HksFreeParamSet(&decryptParamSet);
800 }
801
802 /**
803 * @tc.name: HksAesCipherPart1Test.HksAesCipherPart1Test006
804 * @tc.desc: alg-AES pur-ENCRYPT&DECRYPT mod-ECB pad-NONE size-128.
805 * @tc.type: FUNC
806 */
807 HWTEST_F(HksAesCipherPart1Test, HksAesCipherPart1Test006, TestSize.Level0)
808 {
809 char tmpKeyAlias[] = "HksAESCipherKeyAliasTest006";
810 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
811
812 struct HksParamSet *genParamSet = nullptr;
813 int32_t ret = InitParamSet(&genParamSet, g_genParams006, sizeof(g_genParams006)/sizeof(HksParam));
814 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
815
816 struct HksParamSet *encryptParamSet = nullptr;
817 ret = InitParamSet(&encryptParamSet, g_encryptParams006, sizeof(g_encryptParams006)/sizeof(HksParam));
818 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
819
820 struct HksParamSet *decryptParamSet = nullptr;
821 ret = InitParamSet(&decryptParamSet, g_decryptParams006, sizeof(g_decryptParams006)/sizeof(HksParam));
822 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
823
824 ret = HksAesCipherTestCaseOther(&keyAlias, genParamSet, encryptParamSet, decryptParamSet);
825 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
826
827 HksFreeParamSet(&genParamSet);
828 HksFreeParamSet(&encryptParamSet);
829 HksFreeParamSet(&decryptParamSet);
830 }
831 #ifdef _USE_OPENSSL_
832 /**
833 * @tc.name: HksAesCipherPart1Test.HksAesCipherPart1Test007
834 * @tc.desc: alg-AES pur-ENCRYPT&DECRYPT mod-ECB pad-PKCS7 size-128.
835 * @tc.type: FUNC
836 */
837 HWTEST_F(HksAesCipherPart1Test, HksAesCipherPart1Test007, TestSize.Level0)
838 {
839 char tmpKeyAlias[] = "HksAESCipherKeyAliasTest007";
840 struct HksBlob keyAlias = { strlen(tmpKeyAlias), (uint8_t *)tmpKeyAlias };
841
842 struct HksParamSet *genParamSet = nullptr;
843 int32_t ret = InitParamSet(&genParamSet, g_genParams007, sizeof(g_genParams007)/sizeof(HksParam));
844 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(gen) failed.";
845
846 struct HksParamSet *encryptParamSet = nullptr;
847 ret = InitParamSet(&encryptParamSet, g_encryptParams007, sizeof(g_encryptParams007)/sizeof(HksParam));
848 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(encrypt) failed.";
849
850 struct HksParamSet *decryptParamSet = nullptr;
851 ret = InitParamSet(&decryptParamSet, g_decryptParams007, sizeof(g_decryptParams007)/sizeof(HksParam));
852 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet(decrypt) failed.";
853
854 ret = HksAesCipherTestCaseOther(&keyAlias, genParamSet, encryptParamSet, decryptParamSet);
855 EXPECT_EQ(ret, HKS_SUCCESS) << "this case failed.";
856
857 HksFreeParamSet(&genParamSet);
858 HksFreeParamSet(&encryptParamSet);
859 HksFreeParamSet(&decryptParamSet);
860 }
861 #endif
862 }