1 /*
2  * Copyright (C) 2024 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 <gtest/gtest.h>
17 #include <fstream>
18 #include <iostream>
19 #include "securec.h"
20 
21 #include "aes_common.h"
22 #include "aes_openssl.h"
23 #include "blob.h"
24 #include "cipher.h"
25 #include "detailed_iv_params.h"
26 #include "detailed_gcm_params.h"
27 #include "detailed_ccm_params.h"
28 #include "log.h"
29 #include "memory.h"
30 #include "sym_common_defines.h"
31 #include "sym_key_generator.h"
32 
33 using namespace std;
34 using namespace testing::ext;
35 
36 namespace {
37 class CryptoAesEcbCipherTest : public testing::Test {
38 public:
SetUpTestCase()39     static void SetUpTestCase() {};
TearDownTestCase()40     static void TearDownTestCase() {};
SetUp()41     void SetUp() {};
TearDown()42     void TearDown() {};
43 };
44 
45 /**
46  * @tc.name: CryptoAesEcbCipherTest.CryptoAesEcbCipherTest001
47  * @tc.desc: Verify whether the crypto framework is normal.
48  * @tc.type: FUNC
49  * @tc.require: I5QWEO
50  */
51 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest001, TestSize.Level0)
52 {
53     int ret = 0;
54     uint8_t cipherText[128] = {0};
55     int cipherTextLen = 128;
56 
57     HcfSymKeyGenerator *generator = nullptr;
58     HcfCipher *cipher = nullptr;
59     HcfSymKey *key = nullptr;
60 
61     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
62     if (ret != 0) {
63         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
64         goto CLEAR_UP;
65     }
66 
67     ret = generator->generateSymKey(generator, &key);
68     if (ret != 0) {
69         LOGE("generateSymKey failed!");
70         goto CLEAR_UP;
71     }
72 
73     ret = HcfCipherCreate("AES128|ECB|NoPadding", &cipher);
74     if (ret != 0) {
75         LOGE("HcfCipherCreate failed!");
76         goto CLEAR_UP;
77     }
78 
79     ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
80     if (ret != 0) {
81         LOGE("AesEncrypt failed! %d", ret);
82         goto CLEAR_UP;
83     }
84 
85     ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
86     if (ret != 0) {
87         LOGE("AesDecrypt failed! %d", ret);
88         goto CLEAR_UP;
89     }
90 CLEAR_UP:
91     HcfObjDestroy((HcfObjectBase *)key);
92     HcfObjDestroy((HcfObjectBase *)cipher);
93     HcfObjDestroy((HcfObjectBase *)generator);
94     EXPECT_NE(ret, 0);
95 }
96 
97 /**
98  * @tc.name: CryptoAesEcbCipherTest.CryptoAesEcbCipherTest002
99  * @tc.desc: Verify AES128 cipher algorithm.
100  * @tc.type: FUNC
101  * @tc.require: I5QWEG
102  */
103 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest002, TestSize.Level0)
104 {
105     int ret = 0;
106     uint8_t cipherText[128] = {0};
107     int cipherTextLen = 128;
108 
109     HcfSymKeyGenerator *generator = nullptr;
110     HcfCipher *cipher = nullptr;
111     HcfSymKey *key = nullptr;
112     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
113     if (ret != 0) {
114         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
115         goto CLEAR_UP;
116     }
117 
118     ret = generator->generateSymKey(generator, &key);
119     if (ret != 0) {
120         LOGE("generateSymKey failed!");
121         goto CLEAR_UP;
122     }
123 
124     ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher);
125     if (ret != 0) {
126         LOGE("HcfCipherCreate failed!");
127         goto CLEAR_UP;
128     }
129 
130     ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
131     if (ret != 0) {
132         LOGE("AesEncrypt failed! %d", ret);
133         goto CLEAR_UP;
134     }
135 
136     ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
137     if (ret != 0) {
138         LOGE("AesDecrypt failed! %d", ret);
139         goto CLEAR_UP;
140     }
141 CLEAR_UP:
142     HcfObjDestroy((HcfObjectBase *)key);
143     HcfObjDestroy((HcfObjectBase *)cipher);
144     HcfObjDestroy((HcfObjectBase *)generator);
145     EXPECT_EQ(ret, 0);
146 }
147 
148 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest003, TestSize.Level0)
149 {
150     int ret = 0;
151     uint8_t cipherText[128] = {0};
152     int cipherTextLen = 128;
153 
154     HcfSymKeyGenerator *generator = nullptr;
155     HcfCipher *cipher = nullptr;
156     HcfSymKey *key = nullptr;
157     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
158     if (ret != 0) {
159         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
160         goto CLEAR_UP;
161     }
162 
163     ret = generator->generateSymKey(generator, &key);
164     if (ret != 0) {
165         LOGE("generateSymKey failed!");
166         goto CLEAR_UP;
167     }
168 
169     ret = HcfCipherCreate("AES128|ECB|PKCS7", &cipher);
170     if (ret != 0) {
171         LOGE("HcfCipherCreate failed!");
172         goto CLEAR_UP;
173     }
174 
175     ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
176     if (ret != 0) {
177         LOGE("AesEncrypt failed! %d", ret);
178         goto CLEAR_UP;
179     }
180 
181     ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
182     if (ret != 0) {
183         LOGE("AesDecrypt failed! %d", ret);
184         goto CLEAR_UP;
185     }
186 
187 CLEAR_UP:
188     HcfObjDestroy((HcfObjectBase *)key);
189     HcfObjDestroy((HcfObjectBase *)cipher);
190     HcfObjDestroy((HcfObjectBase *)generator);
191     EXPECT_EQ(ret, 0);
192 }
193 
194 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest004, TestSize.Level0)
195 {
196     int ret = 0;
197     uint8_t cipherText[128] = {0};
198     int cipherTextLen = 128;
199 
200     HcfCipher *cipher = nullptr;
201     HcfSymKey *key = nullptr;
202     uint8_t codeCipherText[] = {
203         0xF5, 0x12, 0xA0, 0x33, 0xCD, 0xCF, 0x0D, 0x32,
204         0x3E, 0xFF, 0x80, 0x53, 0x89, 0xB6, 0xE4, 0xFE
205     };
206 
207     ret = ConvertSymKey("AES128", &key);
208     if (ret != 0) {
209         LOGE("generateSymKey failed!");
210         goto CLEAR_UP;
211     }
212 
213     ret = HcfCipherCreate("AES128|ECB|PKCS7", &cipher);
214     if (ret != 0) {
215         LOGE("HcfCipherCreate failed!");
216         goto CLEAR_UP;
217     }
218 
219     ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
220     if (ret != 0) {
221         LOGE("AesEncrypt failed! %d", ret);
222         goto CLEAR_UP;
223     }
224 
225     ret = memcmp(cipherText, codeCipherText, cipherTextLen);
226     if (ret != 0) {
227         LOGE("cipherText compare failed!");
228         goto CLEAR_UP;
229     }
230 
231     ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
232     if (ret != 0) {
233         LOGE("AesDecrypt failed! %d", ret);
234         goto CLEAR_UP;
235     }
236 
237 CLEAR_UP:
238     HcfObjDestroy((HcfObjectBase *)key);
239     HcfObjDestroy((HcfObjectBase *)cipher);
240     EXPECT_EQ(ret, 0);
241 }
242 
243 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest005, TestSize.Level0)
244 {
245     int ret = 0;
246     uint8_t cipherText[128] = {0};
247     int cipherTextLen = 128;
248 
249     HcfSymKeyGenerator *generator = nullptr;
250     HcfCipher *cipher = nullptr;
251     HcfSymKey *key = nullptr;
252 
253     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
254     if (ret != 0) {
255         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
256         goto CLEAR_UP;
257     }
258 
259     ret = generator->generateSymKey(generator, &key);
260     if (ret != 0) {
261         LOGE("generateSymKey failed!");
262         goto CLEAR_UP;
263     }
264 
265     ret = HcfCipherCreate("AES128|ECB|NoPadding", &cipher);
266     if (ret != 0) {
267         LOGE("HcfCipherCreate failed!");
268         goto CLEAR_UP;
269     }
270 
271     ret = AesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
272     if (ret != 0) {
273         LOGE("AesNoUpdateEncrypt failed! %d", ret);
274         goto CLEAR_UP;
275     }
276 
277     ret = AesNoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
278     if (ret != 0) {
279         LOGE("AesNoUpdateDecrypt failed! %d", ret);
280         goto CLEAR_UP;
281     }
282 CLEAR_UP:
283     HcfObjDestroy((HcfObjectBase *)key);
284     HcfObjDestroy((HcfObjectBase *)cipher);
285     HcfObjDestroy((HcfObjectBase *)generator);
286     EXPECT_NE(ret, 0);
287 }
288 
289 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest006, TestSize.Level0)
290 {
291     int ret = 0;
292     uint8_t cipherText[128] = {0};
293     int cipherTextLen = 128;
294 
295     HcfSymKeyGenerator *generator = nullptr;
296     HcfCipher *cipher = nullptr;
297     HcfSymKey *key = nullptr;
298     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
299     if (ret != 0) {
300         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
301         goto CLEAR_UP;
302     }
303 
304     ret = generator->generateSymKey(generator, &key);
305     if (ret != 0) {
306         LOGE("generateSymKey failed!");
307         goto CLEAR_UP;
308     }
309 
310     ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher);
311     if (ret != 0) {
312         LOGE("HcfCipherCreate failed!");
313         goto CLEAR_UP;
314     }
315 
316     ret = AesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
317     if (ret != 0) {
318         LOGE("AesNoUpdateEncrypt failed! %d", ret);
319         goto CLEAR_UP;
320     }
321 
322     ret = AesNoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
323     if (ret != 0) {
324         LOGE("AesNoUpdateDecrypt failed! %d", ret);
325         goto CLEAR_UP;
326     }
327 CLEAR_UP:
328     HcfObjDestroy((HcfObjectBase *)key);
329     HcfObjDestroy((HcfObjectBase *)cipher);
330     HcfObjDestroy((HcfObjectBase *)generator);
331     EXPECT_EQ(ret, 0);
332 }
333 
334 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest007, TestSize.Level0)
335 {
336     int ret = 0;
337     uint8_t cipherText[128] = {0};
338     int cipherTextLen = 128;
339 
340     HcfSymKeyGenerator *generator = nullptr;
341     HcfCipher *cipher = nullptr;
342     HcfSymKey *key = nullptr;
343     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
344     if (ret != 0) {
345         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
346         goto CLEAR_UP;
347     }
348 
349     ret = generator->generateSymKey(generator, &key);
350     if (ret != 0) {
351         LOGE("generateSymKey failed!");
352         goto CLEAR_UP;
353     }
354 
355     ret = HcfCipherCreate("AES128|ECB|PKCS7", &cipher);
356     if (ret != 0) {
357         LOGE("HcfCipherCreate failed!");
358         goto CLEAR_UP;
359     }
360 
361     ret = AesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
362     if (ret != 0) {
363         LOGE("AesNoUpdateEncrypt failed! %d", ret);
364         goto CLEAR_UP;
365     }
366 
367     ret = AesNoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
368     if (ret != 0) {
369         LOGE("AesNoUpdateDecrypt failed! %d", ret);
370         goto CLEAR_UP;
371     }
372 
373 CLEAR_UP:
374     HcfObjDestroy((HcfObjectBase *)key);
375     HcfObjDestroy((HcfObjectBase *)cipher);
376     HcfObjDestroy((HcfObjectBase *)generator);
377     EXPECT_EQ(ret, 0);
378 }
379 
380 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest008, TestSize.Level0)
381 {
382     int ret = 0;
383     uint8_t cipherText[128] = {0};
384     int cipherTextLen = 128;
385 
386     HcfCipher *cipher = nullptr;
387     HcfSymKey *key = nullptr;
388     uint8_t codeCipherText[] = {
389         0xF5, 0x12, 0xA0, 0x33, 0xCD, 0xCF, 0x0D, 0x32,
390         0x3E, 0xFF, 0x80, 0x53, 0x89, 0xB6, 0xE4, 0xFE
391     };
392 
393     ret = ConvertSymKey("AES128", &key);
394     if (ret != 0) {
395         LOGE("ConvertSymKey failed!");
396         goto CLEAR_UP;
397     }
398 
399     ret = HcfCipherCreate("AES128|ECB|PKCS7", &cipher);
400     if (ret != 0) {
401         LOGE("HcfCipherCreate failed!");
402         goto CLEAR_UP;
403     }
404 
405     ret = AesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
406     if (ret != 0) {
407         LOGE("AesNoUpdateEncrypt failed! %d", ret);
408         goto CLEAR_UP;
409     }
410 
411     ret = memcmp(cipherText, codeCipherText, cipherTextLen);
412     if (ret != 0) {
413         LOGE("cipherText compare failed!");
414         goto CLEAR_UP;
415     }
416 
417     ret = AesNoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
418     if (ret != 0) {
419         LOGE("AesNoUpdateDecrypt failed! %d", ret);
420         goto CLEAR_UP;
421     }
422 
423 CLEAR_UP:
424     HcfObjDestroy((HcfObjectBase *)key);
425     HcfObjDestroy((HcfObjectBase *)cipher);
426     EXPECT_EQ(ret, 0);
427 }
428 
429 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest009, TestSize.Level0)
430 {
431     int ret = 0;
432     HcfCipher *cipher = nullptr;
433     HcfSymKey *key = nullptr;
434 
435     ret = GeneratorFile("/data/test_aes.txt", 10 * FILE_BLOCK_SIZE);
436     if (ret != 0) {
437         LOGE("GeneratorFile failed!");
438         goto CLEAR_UP;
439     }
440     ret = ConvertSymKey("AES128", &key);
441     if (ret != 0) {
442         LOGE("ConvertSymKey failed!");
443         goto CLEAR_UP;
444     }
445 
446     ret = HcfCipherCreate("AES128|ECB|NoPadding", &cipher);
447     if (ret != 0) {
448         LOGE("HcfCipherCreate failed!");
449         goto CLEAR_UP;
450     }
451 
452     ret = AesMultiBlockEncrypt(cipher, key, nullptr);
453     if (ret != 0) {
454         LOGE("AesNoUpdateEncrypt failed! %d", ret);
455         goto CLEAR_UP;
456     }
457 
458     ret = AesMultiBlockDecrypt(cipher, key, nullptr);
459     if (ret != 0) {
460         LOGE("AesNoUpdateDecrypt failed! %d", ret);
461         goto CLEAR_UP;
462     }
463     ret = CompareFileContent();
464     if (ret != 0) {
465         LOGE("CompareFileContent failed!");
466         goto CLEAR_UP;
467     }
468 
469 CLEAR_UP:
470     HcfObjDestroy((HcfObjectBase *)key);
471     HcfObjDestroy((HcfObjectBase *)cipher);
472     EXPECT_EQ(ret, 0);
473 }
474 
475 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest010, TestSize.Level0)
476 {
477     int ret = 0;
478     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
479     int cipherTextLen = CIPHER_TEXT_LEN;
480     HcfCipher *cipher = nullptr;
481     HcfSymKey *key = nullptr;
482 
483     ret = GenerateSymKey("AES192", &key);
484     if (ret != 0) {
485         LOGE("GenerateSymKey failed!");
486         goto CLEAR_UP;
487     }
488 
489     ret = HcfCipherCreate("AES192|ECB|NoPadding", &cipher);
490     if (ret != 0) {
491         LOGE("HcfCipherCreate failed!");
492         goto CLEAR_UP;
493     }
494 
495     ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
496     if (ret != 0) {
497         LOGE("AesEncrypt failed! %d", ret);
498         goto CLEAR_UP;
499     }
500 
501     ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
502     if (ret != 0) {
503         LOGE("AesDecrypt failed! %d", ret);
504     }
505 CLEAR_UP:
506     HcfObjDestroy(key);
507     HcfObjDestroy(cipher);
508     EXPECT_NE(ret, 0);
509 }
510 
511 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest011, TestSize.Level0)
512 {
513     int ret = 0;
514     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
515     int cipherTextLen = CIPHER_TEXT_LEN;
516     HcfCipher *cipher = nullptr;
517     HcfSymKey *key = nullptr;
518 
519     ret = GenerateSymKey("AES192", &key);
520     if (ret != 0) {
521         LOGE("GenerateSymKey failed!");
522         goto CLEAR_UP;
523     }
524 
525     ret = HcfCipherCreate("AES192|ECB|PKCS5", &cipher);
526     if (ret != 0) {
527         LOGE("HcfCipherCreate failed!");
528         goto CLEAR_UP;
529     }
530 
531     ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
532     if (ret != 0) {
533         LOGE("AesEncrypt failed! %d", ret);
534         goto CLEAR_UP;
535     }
536 
537     ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
538     if (ret != 0) {
539         LOGE("AesDecrypt failed! %d", ret);
540     }
541     key->clearMem(key);
542 CLEAR_UP:
543     HcfObjDestroy(key);
544     HcfObjDestroy(cipher);
545     EXPECT_EQ(ret, 0);
546 }
547 
548 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest012, TestSize.Level0)
549 {
550     int ret = 0;
551     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
552     int cipherTextLen = CIPHER_TEXT_LEN;
553     HcfCipher *cipher = nullptr;
554     HcfSymKey *key = nullptr;
555 
556     ret = GenerateSymKey("AES256", &key);
557     if (ret != 0) {
558         LOGE("GenerateSymKey failed!");
559         goto CLEAR_UP;
560     }
561 
562     ret = HcfCipherCreate("AES256|ECB|PKCS7", &cipher);
563     if (ret != 0) {
564         LOGE("HcfCipherCreate failed!");
565         goto CLEAR_UP;
566     }
567 
568     ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
569     if (ret != 0) {
570         LOGE("AesEncrypt failed! %d", ret);
571         goto CLEAR_UP;
572     }
573 
574     ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
575     if (ret != 0) {
576         LOGE("AesDecrypt failed! %d", ret);
577     }
578     key->clearMem(key);
579 CLEAR_UP:
580     HcfObjDestroy(key);
581     HcfObjDestroy(cipher);
582     EXPECT_EQ(ret, 0);
583 }
584 
585 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest013, TestSize.Level0)
586 {
587     int ret = 0;
588     HcfSymKeyGenerator *generator = nullptr;
589     HcfSymKey *key = nullptr;
590     HcfCipher *cipher = nullptr;
591 
592     ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher);
593     if (ret != 0) {
594         LOGE("HcfCipherCreate failed!");
595         goto CLEAR_UP;
596     }
597     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
598     if (ret != 0) {
599         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
600         goto CLEAR_UP;
601     }
602     ret = generator->generateSymKey(reinterpret_cast<HcfSymKeyGenerator *>(cipher), &key);
603     if (ret != 0) {
604         LOGE("generateSymKey failed!");
605     }
606 
607 CLEAR_UP:
608     HcfObjDestroy(key);
609     HcfObjDestroy(generator);
610     HcfObjDestroy(cipher);
611     EXPECT_NE(ret, 0);
612 }
613 
614 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest014, TestSize.Level0)
615 {
616     int ret = 0;
617     HcfSymKeyGenerator *generator = nullptr;
618     HcfSymKey *key = nullptr;
619     uint8_t keyMaterial[] = {
620         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
621         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
622     };
623     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
624     HcfCipher *cipher = nullptr;
625 
626     ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher);
627     if (ret != 0) {
628         LOGE("HcfCipherCreate failed!");
629         goto CLEAR_UP;
630     }
631     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
632     if (ret != 0) {
633         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
634         goto CLEAR_UP;
635     }
636 
637     ret = generator->convertSymKey(reinterpret_cast<HcfSymKeyGenerator *>(cipher), &keyTmpBlob, &key);
638     if (ret != 0) {
639         LOGE("generateSymKey failed!");
640     }
641 
642 CLEAR_UP:
643     HcfObjDestroy(key);
644     HcfObjDestroy(generator);
645     HcfObjDestroy(cipher);
646     EXPECT_NE(ret, 0);
647 }
648 
649 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest015, TestSize.Level0)
650 {
651     int ret = 0;
652     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
653     int cipherTextLen = CIPHER_TEXT_LEN;
654     HcfCipher *cipher = nullptr;
655     HcfSymKey *key = nullptr;
656 
657     ret = GenerateSymKey("AES128", &key);
658     if (ret != 0) {
659         LOGE("GenerateSymKey failed!");
660         goto CLEAR_UP;
661     }
662 
663     // allow input with more than one padding mode. It will pick the last PKCS5.
664     ret = HcfCipherCreate("AES128|ECB|NoPadding|PKCS5", &cipher);
665     if (ret != 0) {
666         LOGE("HcfCipherCreate failed!");
667         goto CLEAR_UP;
668     }
669 
670     ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
671     if (ret != 0) {
672         LOGE("AesEncrypt failed! %d", ret);
673         goto CLEAR_UP;
674     }
675 
676     ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
677     if (ret != 0) {
678         LOGE("AesDecrypt failed! %d", ret);
679     }
680 CLEAR_UP:
681     HcfObjDestroy(key);
682     HcfObjDestroy(cipher);
683     EXPECT_EQ(ret, 0);
684 }
685 
686 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest016, TestSize.Level0)
687 {
688     int ret = 0;
689     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
690     int cipherTextLen = CIPHER_TEXT_LEN;
691     HcfCipher *cipher = nullptr;
692     HcfSymKey *key = nullptr;
693 
694     ret = GenerateSymKey("AES128", &key);
695     if (ret != 0) {
696         LOGE("GenerateSymKey failed!");
697         goto CLEAR_UP;
698     }
699 
700     ret = HcfCipherCreate("AES256|ECB|PKCS5", &cipher);
701     if (ret != 0) {
702         LOGE("HcfCipherCreate failed!");
703         goto CLEAR_UP;
704     }
705 
706     // It is not allowed that AES128 in key is smaller AES256 in cipher. -> now only use the size of input key.
707     ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
708     if (ret != 0) {
709         LOGE("AesEncrypt failed! %d", ret);
710         goto CLEAR_UP;
711     }
712 
713     ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
714     if (ret != 0) {
715         LOGE("AesDecrypt failed! %d", ret);
716     }
717 
718 CLEAR_UP:
719     HcfObjDestroy(key);
720     HcfObjDestroy(cipher);
721     EXPECT_EQ(ret, 0);
722 }
723 
724 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest017, TestSize.Level0)
725 {
726     int ret = 0;
727     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
728     int cipherTextLen = CIPHER_TEXT_LEN;
729     HcfCipher *cipher = nullptr;
730     HcfSymKey *key = nullptr;
731 
732     ret = GenerateSymKey("AES256", &key);
733     if (ret != 0) {
734         LOGE("GenerateSymKey failed!");
735         goto CLEAR_UP;
736     }
737 
738     ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher);
739     if (ret != 0) {
740         LOGE("HcfCipherCreate failed!");
741         goto CLEAR_UP;
742     }
743 
744     ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
745     if (ret != 0) {
746         LOGE("AesEncrypt failed! %d", ret);
747         goto CLEAR_UP;
748     }
749 
750     ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
751     if (ret != 0) {
752         LOGE("AesDecrypt failed! %d", ret);
753     }
754 
755 CLEAR_UP:
756     HcfObjDestroy(key);
757     HcfObjDestroy(cipher);
758     EXPECT_EQ(ret, 0);
759 }
760 
761 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest018, TestSize.Level0)
762 {
763     int ret = 0;
764     HcfCipher *cipher = nullptr;
765     HcfSymKey *key = nullptr;
766 
767     ret = GenerateSymKey("AES128", &key);
768     if (ret != 0) {
769         LOGE("GenerateSymKey failed!");
770         goto CLEAR_UP;
771     }
772 
773     ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher);
774     if (ret != 0) {
775         LOGE("HcfCipherCreate failed!");
776         goto CLEAR_UP;
777     }
778 
779     ret = cipher->init(nullptr, ENCRYPT_MODE, &(key->key), nullptr);
780     if (ret != 0) {
781         LOGE("init failed! Should input cipher when init.");
782     }
783 
784 CLEAR_UP:
785     HcfObjDestroy(key);
786     HcfObjDestroy(cipher);
787     EXPECT_NE(ret, 0);
788 }
789 
790 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest019, TestSize.Level0)
791 {
792     int ret = 0;
793     HcfSymKeyGenerator *generator = nullptr;
794     HcfCipher *cipher = nullptr;
795 
796     ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher);
797     if (ret != 0) {
798         LOGE("HcfCipherCreate failed!");
799         goto CLEAR_UP;
800     }
801 
802     ret = cipher->init(cipher, ENCRYPT_MODE, nullptr, nullptr);
803     if (ret != 0) {
804         LOGE("init failed! Should input key when init.");
805     }
806 
807 CLEAR_UP:
808     HcfObjDestroy(cipher);
809     HcfObjDestroy(generator);
810     EXPECT_NE(ret, 0);
811 }
812 
813 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest020, TestSize.Level0)
814 {
815     int ret = 0;
816     HcfSymKeyGenerator *generator = nullptr;
817     HcfSymKey *key = nullptr;
818     HcfCipher *cipher = nullptr;
819 
820     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
821     if (ret != 0) {
822         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
823         goto CLEAR_UP;
824     }
825     ret = generator->generateSymKey(generator, &key);
826     if (ret != 0) {
827         LOGE("generateSymKey failed!");
828         goto CLEAR_UP;
829     }
830 
831     ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher);
832     if (ret != 0) {
833         LOGE("HcfCipherCreate failed!");
834         goto CLEAR_UP;
835     }
836 
837     ret = cipher->init(reinterpret_cast<HcfCipher *>(generator), ENCRYPT_MODE, &(key->key), nullptr);
838     if (ret != 0) {
839         LOGE("init failed! Should input key when init.");
840     }
841 
842 CLEAR_UP:
843     HcfObjDestroy(key);
844     HcfObjDestroy(cipher);
845     HcfObjDestroy(generator);
846     EXPECT_NE(ret, 0);
847 }
848 
849 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest021, TestSize.Level0)
850 {
851     int ret = 0;
852     HcfCipher *cipher = nullptr;
853     HcfSymKey *key = nullptr;
854     uint8_t plainText[] = "this is test!";
855     HcfBlob input = { .data = plainText, .len = 0 };
856     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
857     int cipherTextLen = CIPHER_TEXT_LEN;
858 
859     ret = GenerateSymKey("AES128", &key);
860     if (ret != 0) {
861         LOGE("generateSymKey failed!");
862         goto CLEAR_UP;
863     }
864     ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher);
865     if (ret != 0) {
866         LOGE("HcfCipherCreate failed!");
867         goto CLEAR_UP;
868     }
869 
870     ret = AesEncryptWithInput(cipher, key, &input, cipherText, &cipherTextLen);
871     if (ret != 0) {
872         LOGE("AesEncrypt failed! %d", ret);
873         goto CLEAR_UP;
874     }
875 
876     ret = AesDecryptEmptyMsg(cipher, key, nullptr, cipherText, cipherTextLen);
877     if (ret != 0) {
878         LOGE("AesDecrypt failed! %d", ret);
879     }
880 
881 CLEAR_UP:
882     HcfObjDestroy(key);
883     HcfObjDestroy(cipher);
884     EXPECT_EQ(ret, 0);
885 }
886 
887 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest022, TestSize.Level0)
888 {
889     int ret = 0;
890     HcfCipher *cipher = nullptr;
891     HcfSymKey *key = nullptr;
892     HcfBlob input = { .data = nullptr, .len = 0 };
893     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
894     int cipherTextLen = CIPHER_TEXT_LEN;
895 
896     ret = GenerateSymKey("AES128", &key);
897     if (ret != 0) {
898         LOGE("generateSymKey failed!");
899         goto CLEAR_UP;
900     }
901     ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher);
902     if (ret != 0) {
903         LOGE("HcfCipherCreate failed!");
904         goto CLEAR_UP;
905     }
906 
907     ret = AesEncryptWithInput(cipher, key, &input, cipherText, &cipherTextLen);
908     if (ret != 0) {
909         LOGE("AesEncrypt failed! %d", ret);
910         goto CLEAR_UP;
911     }
912 
913     ret = AesDecryptEmptyMsg(cipher, key, nullptr, cipherText, cipherTextLen);
914     if (ret != 0) {
915         LOGE("AesDecrypt failed! %d", ret);
916     }
917 
918 CLEAR_UP:
919     HcfObjDestroy(key);
920     HcfObjDestroy(cipher);
921     EXPECT_EQ(ret, 0);
922 }
923 
924 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest023, TestSize.Level0)
925 {
926     int ret = 0;
927     HcfCipher *cipher = nullptr;
928     HcfSymKey *key = nullptr;
929     HcfBlob input = { .data = nullptr, .len = PLAINTEXT_LEN };
930     HcfBlob output = { .data = nullptr, .len = 0 };
931 
932     ret = GenerateSymKey("AES128", &key);
933     if (ret != 0) {
934         LOGE("generateSymKey failed!");
935         goto CLEAR_UP;
936     }
937 
938     ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher);
939     if (ret != 0) {
940         LOGE("HcfCipherCreate failed!");
941         goto CLEAR_UP;
942     }
943 
944     ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr);
945     if (ret != 0) {
946         LOGE("init failed!");
947         goto CLEAR_UP;
948     }
949 
950     ret = cipher->update(nullptr, &input, &output);
951     if (ret != 0) {
952         LOGE("update failed! Blob data should not be nullptr.");
953     }
954 
955 CLEAR_UP:
956     HcfObjDestroy(key);
957     HcfObjDestroy(cipher);
958     if (output.data != nullptr) {
959         HcfFree(output.data);
960         output.data = nullptr;
961     }
962     EXPECT_NE(ret, 0);
963 }
964 
965 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest024, TestSize.Level0)
966 {
967     int ret = 0;
968     HcfCipher *cipher = nullptr;
969     HcfSymKey *key = nullptr;
970     HcfBlob input = { .data = nullptr, .len = PLAINTEXT_LEN };
971     HcfBlob output = { .data = nullptr, .len = 0 };
972 
973     ret = GenerateSymKey("AES128", &key);
974     if (ret != 0) {
975         LOGE("generateSymKey failed!");
976         goto CLEAR_UP;
977     }
978 
979     ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher);
980     if (ret != 0) {
981         LOGE("HcfCipherCreate failed!");
982         goto CLEAR_UP;
983     }
984 
985     ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr);
986     if (ret != 0) {
987         LOGE("init failed!");
988         goto CLEAR_UP;
989     }
990 
991     ret = cipher->update(reinterpret_cast<HcfCipher *>(key), &input, &output);
992     if (ret != 0) {
993         LOGE("update failed! Blob data should not be nullptr.");
994     }
995 
996 CLEAR_UP:
997     HcfObjDestroy(key);
998     HcfObjDestroy(cipher);
999     if (output.data != nullptr) {
1000         HcfFree(output.data);
1001         output.data = nullptr;
1002     }
1003     EXPECT_NE(ret, 0);
1004 }
1005 
1006 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest025, TestSize.Level0)
1007 {
1008     int ret = 0;
1009     HcfCipher *cipher = nullptr;
1010     HcfSymKey *key = nullptr;
1011     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
1012     int cipherTextLen = CIPHER_TEXT_LEN;
1013 
1014     ret = GenerateSymKey("AES128", &key);
1015     if (ret != 0) {
1016         LOGE("generateSymKey failed!");
1017         goto CLEAR_UP;
1018     }
1019 
1020     ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher);
1021     if (ret != 0) {
1022         LOGE("HcfCipherCreate failed!");
1023         goto CLEAR_UP;
1024     }
1025 
1026     ret = AesNoUpdateEncWithInput(cipher, key, nullptr, cipherText, &cipherTextLen);
1027     if (ret != 0) {
1028         LOGE("AesEncrypt failed! %d", ret);
1029         goto CLEAR_UP;
1030     }
1031 
1032     ret = AesDecryptEmptyMsg(cipher, key, nullptr, cipherText, cipherTextLen);
1033     if (ret != 0) {
1034         LOGE("AesDecrypt failed! %d", ret);
1035     }
1036 
1037 CLEAR_UP:
1038     HcfObjDestroy(key);
1039     HcfObjDestroy(cipher);
1040     EXPECT_EQ(ret, 0);
1041 }
1042 
1043 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest026, TestSize.Level0)
1044 {
1045     int ret = 0;
1046     HcfCipher *cipher = nullptr;
1047     HcfSymKey *key = nullptr;
1048     uint8_t plainText[] = "this is test!";
1049     HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN };
1050 
1051     ret = GenerateSymKey("AES128", &key);
1052     if (ret != 0) {
1053         LOGE("generateSymKey failed!");
1054         goto CLEAR_UP;
1055     }
1056 
1057     ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher);
1058     if (ret != 0) {
1059         LOGE("HcfCipherCreate failed!");
1060         goto CLEAR_UP;
1061     }
1062 
1063     ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr);
1064     if (ret != 0) {
1065         LOGE("init failed!");
1066         goto CLEAR_UP;
1067     }
1068 
1069     ret = cipher->doFinal(cipher, &input, nullptr);
1070     if (ret != 0) {
1071         LOGE("update failed! Blob data should not be nullptr.");
1072     }
1073 
1074 CLEAR_UP:
1075     HcfObjDestroy(key);
1076     HcfObjDestroy(cipher);
1077     EXPECT_NE(ret, 0);
1078 }
1079 
1080 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest027, TestSize.Level0)
1081 {
1082     int ret = 0;
1083     HcfCipher *cipher = nullptr;
1084     HcfSymKey *key = nullptr;
1085     uint8_t plainText[] = "this is test!";
1086     HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN };
1087     HcfBlob output = { .data = nullptr, .len = 0 };
1088 
1089     ret = GenerateSymKey("AES128", &key);
1090     if (ret != 0) {
1091         LOGE("generateSymKey failed!");
1092         goto CLEAR_UP;
1093     }
1094 
1095     ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher);
1096     if (ret != 0) {
1097         LOGE("HcfCipherCreate failed!");
1098         goto CLEAR_UP;
1099     }
1100 
1101     ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr);
1102     if (ret != 0) {
1103         LOGE("init failed!");
1104         goto CLEAR_UP;
1105     }
1106 
1107     ret = cipher->doFinal(reinterpret_cast<HcfCipher *>(key), &input, &output);
1108     if (ret != 0) {
1109         LOGE("update failed! Blob data should not be nullptr.");
1110     }
1111 
1112 CLEAR_UP:
1113     HcfObjDestroy(key);
1114     HcfObjDestroy(cipher);
1115     if (output.data != nullptr) {
1116         HcfFree(output.data);
1117         output.data = nullptr;
1118     }
1119     EXPECT_NE(ret, 0);
1120 }
1121 
1122 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest028, TestSize.Level0)
1123 {
1124     int ret = 0;
1125     HcfSymKeyGeneratorSpi *generator = nullptr;
1126     HcfSymKey *key = nullptr;
1127     HcfCipher *cipher = nullptr;
1128     SymKeyAttr attr = { .algo = HCF_ALG_AES, .keySize = AES_KEY_SIZE };
1129 
1130     ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher);
1131     if (ret != 0) {
1132         LOGE("HcfCipherCreate failed!");
1133         goto CLEAR_UP;
1134     }
1135     ret = HcfSymKeyGeneratorSpiCreate(&attr, &generator);
1136     if (ret != 0) {
1137         LOGE("HcfSymKeyGeneratorSpiCreate failed!%d", ret);
1138         goto CLEAR_UP;
1139     }
1140     ret = generator->engineGenerateSymmKey(reinterpret_cast<HcfSymKeyGeneratorSpi *>(cipher), &key);
1141     if (ret != 0) {
1142         LOGE("engineGenerateSymmKey failed!");
1143     }
1144 
1145 CLEAR_UP:
1146     HcfObjDestroy(key);
1147     HcfObjDestroy(generator);
1148     HcfObjDestroy(cipher);
1149     EXPECT_NE(ret, 0);
1150 }
1151 
1152 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest029, TestSize.Level0)
1153 {
1154     int ret = 0;
1155     HcfSymKeyGeneratorSpi *generator = nullptr;
1156     HcfSymKey *key = nullptr;
1157     uint8_t keyMaterial[] = {
1158         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
1159         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
1160     };
1161     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
1162     HcfCipher *cipher = nullptr;
1163     SymKeyAttr attr = { .algo = HCF_ALG_AES, .keySize = AES_KEY_SIZE };
1164 
1165     ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher);
1166     if (ret != 0) {
1167         LOGE("HcfCipherCreate failed!");
1168         goto CLEAR_UP;
1169     }
1170     ret = HcfSymKeyGeneratorSpiCreate(&attr, &generator);
1171     if (ret != 0) {
1172         LOGE("HcfSymKeyGeneratorSpiCreate failed!%d", ret);
1173         goto CLEAR_UP;
1174     }
1175     ret = generator->engineConvertSymmKey(reinterpret_cast<HcfSymKeyGeneratorSpi *>(cipher), &keyTmpBlob, &key);
1176     if (ret != 0) {
1177         LOGE("engineConvertSymmKey failed!");
1178     }
1179 
1180 CLEAR_UP:
1181     HcfObjDestroy(key);
1182     HcfObjDestroy(generator);
1183     HcfObjDestroy(cipher);
1184     EXPECT_NE(ret, 0);
1185 }
1186 }