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 CryptoAesCfbCipherTest : 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 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest001, TestSize.Level0)
46 {
47     int ret = 0;
48     uint8_t iv[16] = {0};
49     uint8_t cipherText[128] = {0};
50     int cipherTextLen = 128;
51 
52     HcfIvParamsSpec ivSpec = {};
53     HcfSymKeyGenerator *generator = nullptr;
54     HcfCipher *cipher = nullptr;
55     HcfSymKey *key = nullptr;
56     ivSpec.iv.data = iv;
57     ivSpec.iv.len = 16;
58 
59     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
60     if (ret != 0) {
61         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
62         goto CLEAR_UP;
63     }
64 
65     ret = generator->generateSymKey(generator, &key);
66     if (ret != 0) {
67         LOGE("generateSymKey failed!");
68         goto CLEAR_UP;
69     }
70 
71     ret = HcfCipherCreate("AES128|CFB|NoPadding", &cipher);
72     if (ret != 0) {
73         LOGE("HcfCipherCreate failed!");
74         goto CLEAR_UP;
75     }
76 
77     ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
78     if (ret != 0) {
79         LOGE("AesEncrypt failed! %d", ret);
80         goto CLEAR_UP;
81     }
82 
83     ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
84     if (ret != 0) {
85         LOGE("AesDecrypt failed! %d", ret);
86         goto CLEAR_UP;
87     }
88 
89 CLEAR_UP:
90     HcfObjDestroy((HcfObjectBase *)key);
91     HcfObjDestroy((HcfObjectBase *)cipher);
92     HcfObjDestroy((HcfObjectBase *)generator);
93     EXPECT_EQ(ret, 0);
94 }
95 
96 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest002, TestSize.Level0)
97 {
98     int ret = 0;
99     uint8_t iv[16] = {0};
100     uint8_t cipherText[128] = {0};
101     int cipherTextLen = 128;
102 
103     HcfIvParamsSpec ivSpec = {};
104     HcfSymKeyGenerator *generator = nullptr;
105     HcfCipher *cipher = nullptr;
106     HcfSymKey *key = nullptr;
107     ivSpec.iv.data = iv;
108     ivSpec.iv.len = 16;
109 
110     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
111     if (ret != 0) {
112         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
113         goto CLEAR_UP;
114     }
115 
116     ret = generator->generateSymKey(generator, &key);
117     if (ret != 0) {
118         LOGE("generateSymKey failed!");
119         goto CLEAR_UP;
120     }
121 
122     ret = HcfCipherCreate("AES128|CFB|PKCS5", &cipher);
123     if (ret != 0) {
124         LOGE("HcfCipherCreate failed!");
125         goto CLEAR_UP;
126     }
127 
128     ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
129     if (ret != 0) {
130         LOGE("AesEncrypt failed! %d", ret);
131         goto CLEAR_UP;
132     }
133 
134     ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
135     if (ret != 0) {
136         LOGE("AesDecrypt failed! %d", ret);
137         goto CLEAR_UP;
138     }
139 
140 CLEAR_UP:
141     HcfObjDestroy((HcfObjectBase *)key);
142     HcfObjDestroy((HcfObjectBase *)cipher);
143     HcfObjDestroy((HcfObjectBase *)generator);
144     EXPECT_EQ(ret, 0);
145 }
146 
147 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest003, TestSize.Level0)
148 {
149     int ret = 0;
150     uint8_t iv[16] = {0};
151     uint8_t cipherText[128] = {0};
152     int cipherTextLen = 128;
153 
154     HcfIvParamsSpec ivSpec = {};
155     HcfSymKeyGenerator *generator = nullptr;
156     HcfCipher *cipher = nullptr;
157     HcfSymKey *key = nullptr;
158     ivSpec.iv.data = iv;
159     ivSpec.iv.len = 16;
160 
161     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
162     if (ret != 0) {
163         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
164         goto CLEAR_UP;
165     }
166 
167     ret = generator->generateSymKey(generator, &key);
168     if (ret != 0) {
169         LOGE("generateSymKey failed!");
170         goto CLEAR_UP;
171     }
172 
173     ret = HcfCipherCreate("AES128|CFB|PKCS7", &cipher);
174     if (ret != 0) {
175         LOGE("HcfCipherCreate failed!");
176         goto CLEAR_UP;
177     }
178 
179     ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
180     if (ret != 0) {
181         LOGE("AesEncrypt failed! %d", ret);
182         goto CLEAR_UP;
183     }
184 
185     ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
186     if (ret != 0) {
187         LOGE("AesDecrypt failed! %d", ret);
188         goto CLEAR_UP;
189     }
190 
191 CLEAR_UP:
192     HcfObjDestroy((HcfObjectBase *)key);
193     HcfObjDestroy((HcfObjectBase *)cipher);
194     HcfObjDestroy((HcfObjectBase *)generator);
195     EXPECT_EQ(ret, 0);
196 }
197 
198 
199 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest004, TestSize.Level0)
200 {
201     int ret = 0;
202     uint8_t iv[16] = {0};
203     uint8_t cipherText[128] = {0};
204     int cipherTextLen = 128;
205 
206     HcfIvParamsSpec ivSpec = {};
207     HcfSymKeyGenerator *generator = nullptr;
208     HcfCipher *cipher = nullptr;
209     HcfSymKey *key = nullptr;
210     ivSpec.iv.data = iv;
211     ivSpec.iv.len = 16;
212 
213     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
214     if (ret != 0) {
215         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
216         goto CLEAR_UP;
217     }
218 
219     ret = generator->generateSymKey(generator, &key);
220     if (ret != 0) {
221         LOGE("generateSymKey failed!");
222         goto CLEAR_UP;
223     }
224 
225     ret = HcfCipherCreate("AES128|CFB1|NoPadding", &cipher);
226     if (ret != 0) {
227         LOGE("HcfCipherCreate failed!");
228         goto CLEAR_UP;
229     }
230 
231     ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
232     if (ret != 0) {
233         LOGE("AesEncrypt failed! %d", ret);
234         goto CLEAR_UP;
235     }
236 
237     ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
238     if (ret != 0) {
239         LOGE("AesDecrypt failed! %d", ret);
240         goto CLEAR_UP;
241     }
242 
243 CLEAR_UP:
244     HcfObjDestroy((HcfObjectBase *)key);
245     HcfObjDestroy((HcfObjectBase *)cipher);
246     HcfObjDestroy((HcfObjectBase *)generator);
247     EXPECT_EQ(ret, 0);
248 }
249 
250 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest005, TestSize.Level0)
251 {
252     int ret = 0;
253     uint8_t iv[16] = {0};
254     uint8_t cipherText[128] = {0};
255     int cipherTextLen = 128;
256 
257     HcfIvParamsSpec ivSpec = {};
258     HcfSymKeyGenerator *generator = nullptr;
259     HcfCipher *cipher = nullptr;
260     HcfSymKey *key = nullptr;
261     ivSpec.iv.data = iv;
262     ivSpec.iv.len = 16;
263 
264     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
265     if (ret != 0) {
266         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
267         goto CLEAR_UP;
268     }
269 
270     ret = generator->generateSymKey(generator, &key);
271     if (ret != 0) {
272         LOGE("generateSymKey failed!");
273         goto CLEAR_UP;
274     }
275 
276     ret = HcfCipherCreate("AES128|CFB1|PKCS5", &cipher);
277     if (ret != 0) {
278         LOGE("HcfCipherCreate failed!");
279         goto CLEAR_UP;
280     }
281 
282     ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
283     if (ret != 0) {
284         LOGE("AesEncrypt failed! %d", ret);
285         goto CLEAR_UP;
286     }
287 
288     ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
289     if (ret != 0) {
290         LOGE("AesDecrypt failed! %d", ret);
291         goto CLEAR_UP;
292     }
293 
294 CLEAR_UP:
295     HcfObjDestroy((HcfObjectBase *)key);
296     HcfObjDestroy((HcfObjectBase *)cipher);
297     HcfObjDestroy((HcfObjectBase *)generator);
298     EXPECT_EQ(ret, 0);
299 }
300 
301 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest006, TestSize.Level0)
302 {
303     int ret = 0;
304     uint8_t iv[16] = {0};
305     uint8_t cipherText[128] = {0};
306     int cipherTextLen = 128;
307 
308     HcfIvParamsSpec ivSpec = {};
309     HcfSymKeyGenerator *generator = nullptr;
310     HcfCipher *cipher = nullptr;
311     HcfSymKey *key = nullptr;
312     ivSpec.iv.data = iv;
313     ivSpec.iv.len = 16;
314 
315     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
316     if (ret != 0) {
317         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
318         goto CLEAR_UP;
319     }
320 
321     ret = generator->generateSymKey(generator, &key);
322     if (ret != 0) {
323         LOGE("generateSymKey failed!");
324     }
325 
326     ret = HcfCipherCreate("AES128|CFB1|PKCS7", &cipher);    // CFB1/CFB8/CFB128 bit
327     if (ret != 0) {
328         LOGE("HcfCipherCreate failed!");
329         goto CLEAR_UP;
330     }
331 
332     ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
333     if (ret != 0) {
334         LOGE("AesEncrypt failed! %d", ret);
335         goto CLEAR_UP;
336     }
337 
338     ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
339     if (ret != 0) {
340         LOGE("AesDecrypt failed! %d", ret);
341         goto CLEAR_UP;
342     }
343 
344 CLEAR_UP:
345     HcfObjDestroy((HcfObjectBase *)key);
346     HcfObjDestroy((HcfObjectBase *)cipher);
347     HcfObjDestroy((HcfObjectBase *)generator);
348     EXPECT_EQ(ret, 0);
349 }
350 
351 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest007, TestSize.Level0)
352 {
353     int ret = 0;
354     uint8_t iv[16] = {0};
355     uint8_t cipherText[128] = {0};
356     int cipherTextLen = 128;
357 
358     HcfIvParamsSpec ivSpec = {};
359     HcfSymKeyGenerator *generator = nullptr;
360     HcfCipher *cipher = nullptr;
361     HcfSymKey *key = nullptr;
362     ivSpec.iv.data = iv;
363     ivSpec.iv.len = 16;
364 
365     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
366     if (ret != 0) {
367         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
368         goto CLEAR_UP;
369     }
370 
371     ret = generator->generateSymKey(generator, &key);
372     if (ret != 0) {
373         LOGE("generateSymKey failed!");
374     }
375 
376     ret = HcfCipherCreate("AES128|CFB8|NoPadding", &cipher);    // CFB1/CFB8/CFB128 bit
377     if (ret != 0) {
378         LOGE("HcfCipherCreate failed!");
379         goto CLEAR_UP;
380     }
381 
382     ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
383     if (ret != 0) {
384         LOGE("AesEncrypt failed! %d", ret);
385         goto CLEAR_UP;
386     }
387 
388     ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
389     if (ret != 0) {
390         LOGE("AesDecrypt failed! %d", ret);
391         goto CLEAR_UP;
392     }
393 
394 CLEAR_UP:
395     HcfObjDestroy((HcfObjectBase *)key);
396     HcfObjDestroy((HcfObjectBase *)cipher);
397     HcfObjDestroy((HcfObjectBase *)generator);
398     EXPECT_EQ(ret, 0);
399 }
400 
401 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest008, TestSize.Level0)
402 {
403     int ret = 0;
404     uint8_t iv[16] = {0};
405     uint8_t cipherText[128] = {0};
406     int cipherTextLen = 128;
407 
408     HcfIvParamsSpec ivSpec = {};
409     HcfSymKeyGenerator *generator = nullptr;
410     HcfCipher *cipher = nullptr;
411     HcfSymKey *key = nullptr;
412     ivSpec.iv.data = iv;
413     ivSpec.iv.len = 16;
414 
415     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
416     if (ret != 0) {
417         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
418         goto CLEAR_UP;
419     }
420 
421     ret = generator->generateSymKey(generator, &key);
422     if (ret != 0) {
423         LOGE("generateSymKey failed!");
424     }
425 
426     ret = HcfCipherCreate("AES128|CFB8|PKCS5", &cipher);    // CFB1/CFB8/CFB128 bit
427     if (ret != 0) {
428         LOGE("HcfCipherCreate failed!");
429         goto CLEAR_UP;
430     }
431 
432     ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
433     if (ret != 0) {
434         LOGE("AesEncrypt failed! %d", ret);
435         goto CLEAR_UP;
436     }
437 
438     ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
439     if (ret != 0) {
440         LOGE("AesDecrypt failed! %d", ret);
441         goto CLEAR_UP;
442     }
443 
444 CLEAR_UP:
445     HcfObjDestroy((HcfObjectBase *)key);
446     HcfObjDestroy((HcfObjectBase *)cipher);
447     HcfObjDestroy((HcfObjectBase *)generator);
448     EXPECT_EQ(ret, 0);
449 }
450 
451 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest009, TestSize.Level0)
452 {
453     int ret = 0;
454     uint8_t iv[16] = {0};
455     uint8_t cipherText[128] = {0};
456     int cipherTextLen = 128;
457 
458     HcfIvParamsSpec ivSpec = {};
459     HcfSymKeyGenerator *generator = nullptr;
460     HcfCipher *cipher = nullptr;
461     HcfSymKey *key = nullptr;
462     ivSpec.iv.data = iv;
463     ivSpec.iv.len = 16;
464 
465     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
466     if (ret != 0) {
467         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
468         goto CLEAR_UP;
469     }
470 
471     ret = generator->generateSymKey(generator, &key);
472     if (ret != 0) {
473         LOGE("generateSymKey failed!");
474     }
475 
476     ret = HcfCipherCreate("AES128|CFB8|PKCS7", &cipher);    // CFB1/CFB8/CFB128 bit
477     if (ret != 0) {
478         LOGE("HcfCipherCreate failed!");
479         goto CLEAR_UP;
480     }
481 
482     ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
483     if (ret != 0) {
484         LOGE("AesEncrypt failed! %d", ret);
485         goto CLEAR_UP;
486     }
487 
488     ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
489     if (ret != 0) {
490         LOGE("AesDecrypt failed! %d", ret);
491         goto CLEAR_UP;
492     }
493 
494 CLEAR_UP:
495     HcfObjDestroy((HcfObjectBase *)key);
496     HcfObjDestroy((HcfObjectBase *)cipher);
497     HcfObjDestroy((HcfObjectBase *)generator);
498     EXPECT_EQ(ret, 0);
499 }
500 
501 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest010, TestSize.Level0)
502 {
503     int ret = 0;
504     uint8_t iv[16] = {0};
505     uint8_t cipherText[128] = {0};
506     int cipherTextLen = 128;
507 
508     HcfIvParamsSpec ivSpec = {};
509     HcfSymKeyGenerator *generator = nullptr;
510     HcfCipher *cipher = nullptr;
511     HcfSymKey *key = nullptr;
512     ivSpec.iv.data = iv;
513     ivSpec.iv.len = 16;
514 
515     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
516     if (ret != 0) {
517         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
518         goto CLEAR_UP;
519     }
520 
521     ret = generator->generateSymKey(generator, &key);
522     if (ret != 0) {
523         LOGE("generateSymKey failed!");
524     }
525 
526     ret = HcfCipherCreate("AES128|CFB128|NoPadding", &cipher);  // CFB1/CFB8/CFB128 bit
527     if (ret != 0) {
528         LOGE("HcfCipherCreate failed!");
529         goto CLEAR_UP;
530     }
531 
532     ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
533     if (ret != 0) {
534         LOGE("AesEncrypt failed! %d", ret);
535         goto CLEAR_UP;
536     }
537 
538     ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
539     if (ret != 0) {
540         LOGE("AesDecrypt failed! %d", ret);
541         goto CLEAR_UP;
542     }
543 
544 CLEAR_UP:
545     HcfObjDestroy((HcfObjectBase *)key);
546     HcfObjDestroy((HcfObjectBase *)cipher);
547     HcfObjDestroy((HcfObjectBase *)generator);
548     EXPECT_EQ(ret, 0);
549 }
550 
551 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest011, TestSize.Level0)
552 {
553     int ret = 0;
554     uint8_t iv[16] = {0};
555     uint8_t cipherText[128] = {0};
556     int cipherTextLen = 128;
557 
558     HcfIvParamsSpec ivSpec = {};
559     HcfSymKeyGenerator *generator = nullptr;
560     HcfCipher *cipher = nullptr;
561     HcfSymKey *key = nullptr;
562     ivSpec.iv.data = iv;
563     ivSpec.iv.len = 16;
564 
565     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
566     if (ret != 0) {
567         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
568         goto CLEAR_UP;
569     }
570 
571     ret = generator->generateSymKey(generator, &key);
572     if (ret != 0) {
573         LOGE("generateSymKey failed!");
574     }
575 
576     ret = HcfCipherCreate("AES128|CFB128|PKCS5", &cipher);  // CFB1/CFB8/CFB128 bit
577     if (ret != 0) {
578         LOGE("HcfCipherCreate failed!");
579         goto CLEAR_UP;
580     }
581 
582     ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
583     if (ret != 0) {
584         LOGE("AesEncrypt failed! %d", ret);
585         goto CLEAR_UP;
586     }
587 
588     ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
589     if (ret != 0) {
590         LOGE("AesDecrypt failed! %d", ret);
591         goto CLEAR_UP;
592     }
593 
594 CLEAR_UP:
595     HcfObjDestroy((HcfObjectBase *)key);
596     HcfObjDestroy((HcfObjectBase *)cipher);
597     HcfObjDestroy((HcfObjectBase *)generator);
598     EXPECT_EQ(ret, 0);
599 }
600 
601 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest012, TestSize.Level0)
602 {
603     int ret = 0;
604     uint8_t iv[16] = {0};
605     uint8_t cipherText[128] = {0};
606     int cipherTextLen = 128;
607 
608     HcfIvParamsSpec ivSpec = {};
609     HcfSymKeyGenerator *generator = nullptr;
610     HcfCipher *cipher = nullptr;
611     HcfSymKey *key = nullptr;
612     ivSpec.iv.data = iv;
613     ivSpec.iv.len = 16;
614 
615     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
616     if (ret != 0) {
617         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
618         goto CLEAR_UP;
619     }
620 
621     ret = generator->generateSymKey(generator, &key);
622     if (ret != 0) {
623         LOGE("generateSymKey failed!");
624     }
625 
626     ret = HcfCipherCreate("AES128|CFB128|PKCS7", &cipher);  // CFB1/CFB8/CFB128 bit
627     if (ret != 0) {
628         LOGE("HcfCipherCreate failed!");
629         goto CLEAR_UP;
630     }
631 
632     ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
633     if (ret != 0) {
634         LOGE("AesEncrypt failed! %d", ret);
635         goto CLEAR_UP;
636     }
637 
638     ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
639     if (ret != 0) {
640         LOGE("AesDecrypt failed! %d", ret);
641         goto CLEAR_UP;
642     }
643 
644 CLEAR_UP:
645     HcfObjDestroy((HcfObjectBase *)key);
646     HcfObjDestroy((HcfObjectBase *)cipher);
647     HcfObjDestroy((HcfObjectBase *)generator);
648     EXPECT_EQ(ret, 0);
649 }
650 
651 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest013, TestSize.Level0)
652 {
653     int ret = 0;
654     uint8_t iv[16] = {0};
655     uint8_t cipherText[128] = {0};
656     int cipherTextLen = 128;
657 
658     HcfIvParamsSpec ivSpec = {};
659     HcfSymKeyGenerator *generator = nullptr;
660     HcfCipher *cipher = nullptr;
661     HcfSymKey *key = nullptr;
662     ivSpec.iv.data = iv;
663     ivSpec.iv.len = 16;
664 
665     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
666     if (ret != 0) {
667         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
668         goto CLEAR_UP;
669     }
670 
671     ret = generator->generateSymKey(generator, &key);
672     if (ret != 0) {
673         LOGE("generateSymKey failed!");
674         goto CLEAR_UP;
675     }
676 
677     ret = HcfCipherCreate("AES128|CFB|NoPadding", &cipher);
678     if (ret != 0) {
679         LOGE("HcfCipherCreate failed!");
680         goto CLEAR_UP;
681     }
682 
683     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
684     if (ret != 0) {
685         LOGE("AesNoUpdateEncrypt failed! %d", ret);
686         goto CLEAR_UP;
687     }
688 
689     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
690     if (ret != 0) {
691         LOGE("AesNoUpdateDecrypt failed! %d", ret);
692         goto CLEAR_UP;
693     }
694 
695 CLEAR_UP:
696     HcfObjDestroy((HcfObjectBase *)key);
697     HcfObjDestroy((HcfObjectBase *)cipher);
698     HcfObjDestroy((HcfObjectBase *)generator);
699     EXPECT_EQ(ret, 0);
700 }
701 
702 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest014, TestSize.Level0)
703 {
704     int ret = 0;
705     uint8_t iv[16] = {0};
706     uint8_t cipherText[128] = {0};
707     int cipherTextLen = 128;
708 
709     HcfIvParamsSpec ivSpec = {};
710     HcfSymKeyGenerator *generator = nullptr;
711     HcfCipher *cipher = nullptr;
712     HcfSymKey *key = nullptr;
713     ivSpec.iv.data = iv;
714     ivSpec.iv.len = 16;
715 
716     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
717     if (ret != 0) {
718         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
719         goto CLEAR_UP;
720     }
721 
722     ret = generator->generateSymKey(generator, &key);
723     if (ret != 0) {
724         LOGE("generateSymKey failed!");
725         goto CLEAR_UP;
726     }
727 
728     ret = HcfCipherCreate("AES128|CFB|PKCS5", &cipher);
729     if (ret != 0) {
730         LOGE("HcfCipherCreate failed!");
731         goto CLEAR_UP;
732     }
733 
734     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
735     if (ret != 0) {
736         LOGE("AesNoUpdateEncrypt failed! %d", ret);
737         goto CLEAR_UP;
738     }
739 
740     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
741     if (ret != 0) {
742         LOGE("AesNoUpdateDecrypt failed! %d", ret);
743         goto CLEAR_UP;
744     }
745 
746 CLEAR_UP:
747     HcfObjDestroy((HcfObjectBase *)key);
748     HcfObjDestroy((HcfObjectBase *)cipher);
749     HcfObjDestroy((HcfObjectBase *)generator);
750     EXPECT_EQ(ret, 0);
751 }
752 
753 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest015, TestSize.Level0)
754 {
755     int ret = 0;
756     uint8_t iv[16] = {0};
757     uint8_t cipherText[128] = {0};
758     int cipherTextLen = 128;
759 
760     HcfIvParamsSpec ivSpec = {};
761     HcfSymKeyGenerator *generator = nullptr;
762     HcfCipher *cipher = nullptr;
763     HcfSymKey *key = nullptr;
764     ivSpec.iv.data = iv;
765     ivSpec.iv.len = 16;
766 
767     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
768     if (ret != 0) {
769         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
770         goto CLEAR_UP;
771     }
772 
773     ret = generator->generateSymKey(generator, &key);
774     if (ret != 0) {
775         LOGE("generateSymKey failed!");
776         goto CLEAR_UP;
777     }
778 
779     ret = HcfCipherCreate("AES128|CFB|PKCS7", &cipher);
780     if (ret != 0) {
781         LOGE("HcfCipherCreate failed!");
782         goto CLEAR_UP;
783     }
784 
785     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
786     if (ret != 0) {
787         LOGE("AesNoUpdateEncrypt failed! %d", ret);
788         goto CLEAR_UP;
789     }
790 
791     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
792     if (ret != 0) {
793         LOGE("AesNoUpdateDecrypt failed! %d", ret);
794         goto CLEAR_UP;
795     }
796 
797 CLEAR_UP:
798     HcfObjDestroy((HcfObjectBase *)key);
799     HcfObjDestroy((HcfObjectBase *)cipher);
800     HcfObjDestroy((HcfObjectBase *)generator);
801     EXPECT_EQ(ret, 0);
802 }
803 
804 
805 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest016, TestSize.Level0)
806 {
807     int ret = 0;
808     uint8_t iv[16] = {0};
809     uint8_t cipherText[128] = {0};
810     int cipherTextLen = 128;
811 
812     HcfIvParamsSpec ivSpec = {};
813     HcfSymKeyGenerator *generator = nullptr;
814     HcfCipher *cipher = nullptr;
815     HcfSymKey *key = nullptr;
816     ivSpec.iv.data = iv;
817     ivSpec.iv.len = 16;
818 
819     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
820     if (ret != 0) {
821         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
822         goto CLEAR_UP;
823     }
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|CFB1|NoPadding", &cipher);
832     if (ret != 0) {
833         LOGE("HcfCipherCreate failed!");
834         goto CLEAR_UP;
835     }
836 
837     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
838     if (ret != 0) {
839         LOGE("AesNoUpdateEncrypt failed! %d", ret);
840         goto CLEAR_UP;
841     }
842 
843     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
844     if (ret != 0) {
845         LOGE("AesNoUpdateDecrypt failed! %d", ret);
846         goto CLEAR_UP;
847     }
848 
849 CLEAR_UP:
850     HcfObjDestroy((HcfObjectBase *)key);
851     HcfObjDestroy((HcfObjectBase *)cipher);
852     HcfObjDestroy((HcfObjectBase *)generator);
853     EXPECT_EQ(ret, 0);
854 }
855 
856 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest017, TestSize.Level0)
857 {
858     int ret = 0;
859     uint8_t iv[16] = {0};
860     uint8_t cipherText[128] = {0};
861     int cipherTextLen = 128;
862 
863     HcfIvParamsSpec ivSpec = {};
864     HcfSymKeyGenerator *generator = nullptr;
865     HcfCipher *cipher = nullptr;
866     HcfSymKey *key = nullptr;
867     ivSpec.iv.data = iv;
868     ivSpec.iv.len = 16;
869 
870     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
871     if (ret != 0) {
872         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
873         goto CLEAR_UP;
874     }
875 
876     ret = generator->generateSymKey(generator, &key);
877     if (ret != 0) {
878         LOGE("generateSymKey failed!");
879         goto CLEAR_UP;
880     }
881 
882     ret = HcfCipherCreate("AES128|CFB1|PKCS5", &cipher);
883     if (ret != 0) {
884         LOGE("HcfCipherCreate failed!");
885         goto CLEAR_UP;
886     }
887 
888     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
889     if (ret != 0) {
890         LOGE("AesNoUpdateEncrypt failed! %d", ret);
891         goto CLEAR_UP;
892     }
893 
894     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
895     if (ret != 0) {
896         LOGE("AesNoUpdateDecrypt failed! %d", ret);
897         goto CLEAR_UP;
898     }
899 
900 CLEAR_UP:
901     HcfObjDestroy((HcfObjectBase *)key);
902     HcfObjDestroy((HcfObjectBase *)cipher);
903     HcfObjDestroy((HcfObjectBase *)generator);
904     EXPECT_EQ(ret, 0);
905 }
906 
907 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest018, TestSize.Level0)
908 {
909     int ret = 0;
910     uint8_t iv[16] = {0};
911     uint8_t cipherText[128] = {0};
912     int cipherTextLen = 128;
913 
914     HcfIvParamsSpec ivSpec = {};
915     HcfSymKeyGenerator *generator = nullptr;
916     HcfCipher *cipher = nullptr;
917     HcfSymKey *key = nullptr;
918     ivSpec.iv.data = iv;
919     ivSpec.iv.len = 16;
920 
921     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
922     if (ret != 0) {
923         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
924         goto CLEAR_UP;
925     }
926 
927     ret = generator->generateSymKey(generator, &key);
928     if (ret != 0) {
929         LOGE("generateSymKey failed!");
930     }
931 
932     ret = HcfCipherCreate("AES128|CFB1|PKCS7", &cipher);    // CFB1/CFB8/CFB128 bit
933     if (ret != 0) {
934         LOGE("HcfCipherCreate failed!");
935         goto CLEAR_UP;
936     }
937 
938     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
939     if (ret != 0) {
940         LOGE("AesNoUpdateEncrypt failed! %d", ret);
941         goto CLEAR_UP;
942     }
943 
944     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
945     if (ret != 0) {
946         LOGE("AesNoUpdateDecrypt failed! %d", ret);
947         goto CLEAR_UP;
948     }
949 
950 CLEAR_UP:
951     HcfObjDestroy((HcfObjectBase *)key);
952     HcfObjDestroy((HcfObjectBase *)cipher);
953     HcfObjDestroy((HcfObjectBase *)generator);
954     EXPECT_EQ(ret, 0);
955 }
956 
957 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest019, TestSize.Level0)
958 {
959     int ret = 0;
960     uint8_t iv[16] = {0};
961     uint8_t cipherText[128] = {0};
962     int cipherTextLen = 128;
963 
964     HcfIvParamsSpec ivSpec = {};
965     HcfSymKeyGenerator *generator = nullptr;
966     HcfCipher *cipher = nullptr;
967     HcfSymKey *key = nullptr;
968     ivSpec.iv.data = iv;
969     ivSpec.iv.len = 16;
970 
971     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
972     if (ret != 0) {
973         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
974         goto CLEAR_UP;
975     }
976 
977     ret = generator->generateSymKey(generator, &key);
978     if (ret != 0) {
979         LOGE("generateSymKey failed!");
980     }
981 
982     ret = HcfCipherCreate("AES128|CFB8|NoPadding", &cipher);    // CFB1/CFB8/CFB128 bit
983     if (ret != 0) {
984         LOGE("HcfCipherCreate failed!");
985         goto CLEAR_UP;
986     }
987 
988     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
989     if (ret != 0) {
990         LOGE("AesNoUpdateEncrypt failed! %d", ret);
991         goto CLEAR_UP;
992     }
993 
994     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
995     if (ret != 0) {
996         LOGE("AesNoUpdateDecrypt failed! %d", ret);
997         goto CLEAR_UP;
998     }
999 
1000 CLEAR_UP:
1001     HcfObjDestroy((HcfObjectBase *)key);
1002     HcfObjDestroy((HcfObjectBase *)cipher);
1003     HcfObjDestroy((HcfObjectBase *)generator);
1004     EXPECT_EQ(ret, 0);
1005 }
1006 
1007 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest020, TestSize.Level0)
1008 {
1009     int ret = 0;
1010     uint8_t iv[16] = {0};
1011     uint8_t cipherText[128] = {0};
1012     int cipherTextLen = 128;
1013 
1014     HcfIvParamsSpec ivSpec = {};
1015     HcfSymKeyGenerator *generator = nullptr;
1016     HcfCipher *cipher = nullptr;
1017     HcfSymKey *key = nullptr;
1018     ivSpec.iv.data = iv;
1019     ivSpec.iv.len = 16;
1020 
1021     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
1022     if (ret != 0) {
1023         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
1024         goto CLEAR_UP;
1025     }
1026 
1027     ret = generator->generateSymKey(generator, &key);
1028     if (ret != 0) {
1029         LOGE("generateSymKey failed!");
1030     }
1031 
1032     ret = HcfCipherCreate("AES128|CFB8|PKCS5", &cipher);    // CFB1/CFB8/CFB128 bit
1033     if (ret != 0) {
1034         LOGE("HcfCipherCreate failed!");
1035         goto CLEAR_UP;
1036     }
1037 
1038     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
1039     if (ret != 0) {
1040         LOGE("AesNoUpdateEncrypt failed! %d", ret);
1041         goto CLEAR_UP;
1042     }
1043 
1044     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
1045     if (ret != 0) {
1046         LOGE("AesNoUpdateDecrypt failed! %d", ret);
1047         goto CLEAR_UP;
1048     }
1049 
1050 CLEAR_UP:
1051     HcfObjDestroy((HcfObjectBase *)key);
1052     HcfObjDestroy((HcfObjectBase *)cipher);
1053     HcfObjDestroy((HcfObjectBase *)generator);
1054     EXPECT_EQ(ret, 0);
1055 }
1056 
1057 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest021, TestSize.Level0)
1058 {
1059     int ret = 0;
1060     uint8_t iv[16] = {0};
1061     uint8_t cipherText[128] = {0};
1062     int cipherTextLen = 128;
1063 
1064     HcfIvParamsSpec ivSpec = {};
1065     HcfSymKeyGenerator *generator = nullptr;
1066     HcfCipher *cipher = nullptr;
1067     HcfSymKey *key = nullptr;
1068     ivSpec.iv.data = iv;
1069     ivSpec.iv.len = 16;
1070 
1071     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
1072     if (ret != 0) {
1073         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
1074         goto CLEAR_UP;
1075     }
1076 
1077     ret = generator->generateSymKey(generator, &key);
1078     if (ret != 0) {
1079         LOGE("generateSymKey failed!");
1080     }
1081 
1082     ret = HcfCipherCreate("AES128|CFB8|PKCS7", &cipher);    // CFB1/CFB8/CFB128 bit
1083     if (ret != 0) {
1084         LOGE("HcfCipherCreate failed!");
1085         goto CLEAR_UP;
1086     }
1087     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
1088     if (ret != 0) {
1089         LOGE("AesNoUpdateEncrypt failed! %d", ret);
1090         goto CLEAR_UP;
1091     }
1092 
1093     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
1094     if (ret != 0) {
1095         LOGE("AesNoUpdateDecrypt failed! %d", ret);
1096         goto CLEAR_UP;
1097     }
1098 
1099 CLEAR_UP:
1100     HcfObjDestroy((HcfObjectBase *)key);
1101     HcfObjDestroy((HcfObjectBase *)cipher);
1102     HcfObjDestroy((HcfObjectBase *)generator);
1103     EXPECT_EQ(ret, 0);
1104 }
1105 
1106 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest022, TestSize.Level0)
1107 {
1108     int ret = 0;
1109     uint8_t iv[16] = {0};
1110     uint8_t cipherText[128] = {0};
1111     int cipherTextLen = 128;
1112 
1113     HcfIvParamsSpec ivSpec = {};
1114     HcfSymKeyGenerator *generator = nullptr;
1115     HcfCipher *cipher = nullptr;
1116     HcfSymKey *key = nullptr;
1117     ivSpec.iv.data = iv;
1118     ivSpec.iv.len = 16;
1119 
1120     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
1121     if (ret != 0) {
1122         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
1123         goto CLEAR_UP;
1124     }
1125 
1126     ret = generator->generateSymKey(generator, &key);
1127     if (ret != 0) {
1128         LOGE("generateSymKey failed!");
1129     }
1130 
1131     ret = HcfCipherCreate("AES128|CFB128|NoPadding", &cipher);  // CFB1/CFB8/CFB128 bit
1132     if (ret != 0) {
1133         LOGE("HcfCipherCreate failed!");
1134         goto CLEAR_UP;
1135     }
1136     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
1137     if (ret != 0) {
1138         LOGE("AesNoUpdateEncrypt failed! %d", ret);
1139         goto CLEAR_UP;
1140     }
1141 
1142     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
1143     if (ret != 0) {
1144         LOGE("AesNoUpdateDecrypt failed! %d", ret);
1145         goto CLEAR_UP;
1146     }
1147 
1148 CLEAR_UP:
1149     HcfObjDestroy((HcfObjectBase *)key);
1150     HcfObjDestroy((HcfObjectBase *)cipher);
1151     HcfObjDestroy((HcfObjectBase *)generator);
1152     EXPECT_EQ(ret, 0);
1153 }
1154 
1155 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest023, TestSize.Level0)
1156 {
1157     int ret = 0;
1158     uint8_t iv[16] = {0};
1159     uint8_t cipherText[128] = {0};
1160     int cipherTextLen = 128;
1161 
1162     HcfIvParamsSpec ivSpec = {};
1163     HcfSymKeyGenerator *generator = nullptr;
1164     HcfCipher *cipher = nullptr;
1165     HcfSymKey *key = nullptr;
1166     ivSpec.iv.data = iv;
1167     ivSpec.iv.len = 16;
1168 
1169     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
1170     if (ret != 0) {
1171         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
1172         goto CLEAR_UP;
1173     }
1174 
1175     ret = generator->generateSymKey(generator, &key);
1176     if (ret != 0) {
1177         LOGE("generateSymKey failed!");
1178     }
1179 
1180     ret = HcfCipherCreate("AES128|CFB128|PKCS5", &cipher);  // CFB1/CFB8/CFB128 bit
1181     if (ret != 0) {
1182         LOGE("HcfCipherCreate failed!");
1183         goto CLEAR_UP;
1184     }
1185     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
1186     if (ret != 0) {
1187         LOGE("AesNoUpdateEncrypt failed! %d", ret);
1188         goto CLEAR_UP;
1189     }
1190 
1191     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
1192     if (ret != 0) {
1193         LOGE("AesNoUpdateDecrypt failed! %d", ret);
1194         goto CLEAR_UP;
1195     }
1196 
1197 CLEAR_UP:
1198     HcfObjDestroy((HcfObjectBase *)key);
1199     HcfObjDestroy((HcfObjectBase *)cipher);
1200     HcfObjDestroy((HcfObjectBase *)generator);
1201     EXPECT_EQ(ret, 0);
1202 }
1203 
1204 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest024, TestSize.Level0)
1205 {
1206     int ret = 0;
1207     uint8_t iv[16] = {0};
1208     uint8_t cipherText[128] = {0};
1209     int cipherTextLen = 128;
1210 
1211     HcfIvParamsSpec ivSpec = {};
1212     HcfSymKeyGenerator *generator = nullptr;
1213     HcfCipher *cipher = nullptr;
1214     HcfSymKey *key = nullptr;
1215     ivSpec.iv.data = iv;
1216     ivSpec.iv.len = 16;
1217 
1218     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
1219     if (ret != 0) {
1220         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
1221         goto CLEAR_UP;
1222     }
1223 
1224     ret = generator->generateSymKey(generator, &key);
1225     if (ret != 0) {
1226         LOGE("generateSymKey failed!");
1227     }
1228 
1229     ret = HcfCipherCreate("AES128|CFB128|PKCS7", &cipher);  // CFB1/CFB8/CFB128 bit
1230     if (ret != 0) {
1231         LOGE("HcfCipherCreate failed!");
1232         goto CLEAR_UP;
1233     }
1234     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
1235     if (ret != 0) {
1236         LOGE("AesNoUpdateEncrypt failed! %d", ret);
1237         goto CLEAR_UP;
1238     }
1239 
1240     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
1241     if (ret != 0) {
1242         LOGE("AesNoUpdateDecrypt failed! %d", ret);
1243         goto CLEAR_UP;
1244     }
1245 
1246 CLEAR_UP:
1247     HcfObjDestroy((HcfObjectBase *)key);
1248     HcfObjDestroy((HcfObjectBase *)cipher);
1249     HcfObjDestroy((HcfObjectBase *)generator);
1250     EXPECT_EQ(ret, 0);
1251 }
1252 
1253 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest025, TestSize.Level0)
1254 {
1255     int ret = 0;
1256     uint8_t iv[16] = {0};
1257 
1258     HcfIvParamsSpec ivSpec = {};
1259     HcfCipher *cipher = nullptr;
1260     HcfSymKey *key = nullptr;
1261     ivSpec.iv.data = iv;
1262     ivSpec.iv.len = 16;
1263 
1264     ret = GenerateSymKey("AES128", &key);
1265     if (ret != 0) {
1266         LOGE("GenerateSymKey failed!");
1267         goto CLEAR_UP;
1268     }
1269 
1270     ret = HcfCipherCreate("AES128|CFB|NoPadding", &cipher);
1271     if (ret != 0) {
1272         LOGE("HcfCipherCreate failed!");
1273         goto CLEAR_UP;
1274     }
1275     ret = GeneratorFile("/data/test_aes.txt", 10 * FILE_BLOCK_SIZE);
1276     if (ret != 0) {
1277         LOGE("GeneratorFile failed!");
1278         goto CLEAR_UP;
1279     }
1280 
1281     ret = AesMultiBlockEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec);
1282     if (ret != 0) {
1283         LOGE("AesNoUpdateEncrypt failed! %d", ret);
1284         goto CLEAR_UP;
1285     }
1286 
1287     ret = AesMultiBlockDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec);
1288     if (ret != 0) {
1289         LOGE("AesNoUpdateDecrypt failed! %d", ret);
1290         goto CLEAR_UP;
1291     }
1292     ret = CompareFileContent();
1293     if (ret != 0) {
1294         LOGE("CompareFileContent failed!");
1295         goto CLEAR_UP;
1296     }
1297 
1298 CLEAR_UP:
1299     HcfObjDestroy((HcfObjectBase *)key);
1300     HcfObjDestroy((HcfObjectBase *)cipher);
1301     EXPECT_EQ(ret, 0);
1302 }
1303 
1304 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest026, TestSize.Level0)
1305 {
1306     int ret = 0;
1307     uint8_t iv[AES_IV_LEN] = { 0 };
1308     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
1309     int cipherTextLen = CIPHER_TEXT_LEN;
1310 
1311     HcfIvParamsSpec ivSpec = {};
1312     HcfCipher *cipher = nullptr;
1313     HcfSymKey *key = nullptr;
1314     ivSpec.iv.data = iv;
1315     ivSpec.iv.len = AES_IV_LEN;
1316 
1317     ret = GenerateSymKey("AES192", &key);
1318     if (ret != 0) {
1319         LOGE("GenerateSymKey failed!");
1320         goto CLEAR_UP;
1321     }
1322 
1323     ret = HcfCipherCreate("AES192|CFB|PKCS5", &cipher);
1324     if (ret != 0) {
1325         LOGE("HcfCipherCreate failed!");
1326         goto CLEAR_UP;
1327     }
1328 
1329     ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen);
1330     if (ret != 0) {
1331         LOGE("AesEncrypt failed! %d", ret);
1332         goto CLEAR_UP;
1333     }
1334 
1335     ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen);
1336     if (ret != 0) {
1337         LOGE("AesDecrypt failed! %d", ret);
1338     }
1339 
1340 CLEAR_UP:
1341     HcfObjDestroy(key);
1342     HcfObjDestroy(cipher);
1343     EXPECT_EQ(ret, 0);
1344 }
1345 
1346 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest027, TestSize.Level0)
1347 {
1348     int ret = 0;
1349     uint8_t iv[AES_IV_LEN] = { 0 };
1350     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
1351     int cipherTextLen = CIPHER_TEXT_LEN;
1352 
1353     HcfIvParamsSpec ivSpec = {};
1354     HcfCipher *cipher = nullptr;
1355     HcfSymKey *key = nullptr;
1356     ivSpec.iv.data = iv;
1357     ivSpec.iv.len = AES_IV_LEN;
1358 
1359     ret = GenerateSymKey("AES256", &key);
1360     if (ret != 0) {
1361         LOGE("GenerateSymKey failed!");
1362         goto CLEAR_UP;
1363     }
1364 
1365     ret = HcfCipherCreate("AES256|CFB|PKCS5", &cipher);
1366     if (ret != 0) {
1367         LOGE("HcfCipherCreate failed!");
1368         goto CLEAR_UP;
1369     }
1370 
1371     ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen);
1372     if (ret != 0) {
1373         LOGE("AesEncrypt failed! %d", ret);
1374         goto CLEAR_UP;
1375     }
1376 
1377     ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen);
1378     if (ret != 0) {
1379         LOGE("AesDecrypt failed! %d", ret);
1380     }
1381 
1382 CLEAR_UP:
1383     HcfObjDestroy(key);
1384     HcfObjDestroy(cipher);
1385     EXPECT_EQ(ret, 0);
1386 }
1387 
1388 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest028, TestSize.Level0)
1389 {
1390     int ret = 0;
1391     uint8_t iv[AES_IV_LEN] = { 0 };
1392     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
1393     int cipherTextLen = CIPHER_TEXT_LEN;
1394 
1395     HcfIvParamsSpec ivSpec = {};
1396     HcfCipher *cipher = nullptr;
1397     HcfSymKey *key = nullptr;
1398     ivSpec.iv.data = iv;
1399     ivSpec.iv.len = AES_IV_LEN;
1400 
1401     ret = GenerateSymKey("AES192", &key);
1402     if (ret != 0) {
1403         LOGE("GenerateSymKey failed!");
1404         goto CLEAR_UP;
1405     }
1406 
1407     ret = HcfCipherCreate("AES192|CFB1|PKCS5", &cipher);
1408     if (ret != 0) {
1409         LOGE("HcfCipherCreate failed!");
1410         goto CLEAR_UP;
1411     }
1412 
1413     ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen);
1414     if (ret != 0) {
1415         LOGE("AesEncrypt failed! %d", ret);
1416         goto CLEAR_UP;
1417     }
1418 
1419     ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen);
1420     if (ret != 0) {
1421         LOGE("AesDecrypt failed! %d", ret);
1422     }
1423 
1424 CLEAR_UP:
1425     HcfObjDestroy(key);
1426     HcfObjDestroy(cipher);
1427     EXPECT_EQ(ret, 0);
1428 }
1429 
1430 
1431 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest029, TestSize.Level0)
1432 {
1433     int ret = 0;
1434     uint8_t iv[AES_IV_LEN] = { 0 };
1435     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
1436     int cipherTextLen = CIPHER_TEXT_LEN;
1437 
1438     HcfIvParamsSpec ivSpec = {};
1439     HcfCipher *cipher = nullptr;
1440     HcfSymKey *key = nullptr;
1441     ivSpec.iv.data = iv;
1442     ivSpec.iv.len = AES_IV_LEN;
1443 
1444     ret = GenerateSymKey("AES256", &key);
1445     if (ret != 0) {
1446         LOGE("GenerateSymKey failed!");
1447         goto CLEAR_UP;
1448     }
1449 
1450     ret = HcfCipherCreate("AES256|CFB1|PKCS5", &cipher);
1451     if (ret != 0) {
1452         LOGE("HcfCipherCreate failed!");
1453         goto CLEAR_UP;
1454     }
1455 
1456     ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen);
1457     if (ret != 0) {
1458         LOGE("AesEncrypt failed! %d", ret);
1459         goto CLEAR_UP;
1460     }
1461 
1462     ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen);
1463     if (ret != 0) {
1464         LOGE("AesDecrypt failed! %d", ret);
1465     }
1466 
1467 CLEAR_UP:
1468     HcfObjDestroy(key);
1469     HcfObjDestroy(cipher);
1470     EXPECT_EQ(ret, 0);
1471 }
1472 
1473 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest030, TestSize.Level0)
1474 {
1475     int ret = 0;
1476     uint8_t iv[AES_IV_LEN] = { 0 };
1477     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
1478     int cipherTextLen = CIPHER_TEXT_LEN;
1479 
1480     HcfIvParamsSpec ivSpec = {};
1481     HcfCipher *cipher = nullptr;
1482     HcfSymKey *key = nullptr;
1483     ivSpec.iv.data = iv;
1484     ivSpec.iv.len = AES_IV_LEN;
1485 
1486     ret = GenerateSymKey("AES192", &key);
1487     if (ret != 0) {
1488         LOGE("GenerateSymKey failed!");
1489         goto CLEAR_UP;
1490     }
1491 
1492     ret = HcfCipherCreate("AES192|CFB8|PKCS5", &cipher);    // CFB1/CFB8/CFB128 bit
1493     if (ret != 0) {
1494         LOGE("HcfCipherCreate failed!");
1495         goto CLEAR_UP;
1496     }
1497 
1498     ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen);
1499     if (ret != 0) {
1500         LOGE("AesEncrypt failed! %d", ret);
1501         goto CLEAR_UP;
1502     }
1503 
1504     ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen);
1505     if (ret != 0) {
1506         LOGE("AesDecrypt failed! %d", ret);
1507     }
1508 
1509 CLEAR_UP:
1510     HcfObjDestroy(key);
1511     HcfObjDestroy(cipher);
1512     EXPECT_EQ(ret, 0);
1513 }
1514 
1515 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest031, TestSize.Level0)
1516 {
1517     int ret = 0;
1518     uint8_t iv[AES_IV_LEN] = { 0 };
1519     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
1520     int cipherTextLen = CIPHER_TEXT_LEN;
1521 
1522     HcfIvParamsSpec ivSpec = {};
1523     HcfCipher *cipher = nullptr;
1524     HcfSymKey *key = nullptr;
1525     ivSpec.iv.data = iv;
1526     ivSpec.iv.len = AES_IV_LEN;
1527 
1528     ret = GenerateSymKey("AES256", &key);
1529     if (ret != 0) {
1530         LOGE("GenerateSymKey failed!");
1531         goto CLEAR_UP;
1532     }
1533 
1534     ret = HcfCipherCreate("AES256|CFB8|PKCS5", &cipher);    // CFB1/CFB8/CFB128 bit
1535     if (ret != 0) {
1536         LOGE("HcfCipherCreate failed!");
1537         goto CLEAR_UP;
1538     }
1539 
1540     ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen);
1541     if (ret != 0) {
1542         LOGE("AesEncrypt failed! %d", ret);
1543         goto CLEAR_UP;
1544     }
1545 
1546     ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen);
1547     if (ret != 0) {
1548         LOGE("AesDecrypt failed! %d", ret);
1549     }
1550 
1551 CLEAR_UP:
1552     HcfObjDestroy(key);
1553     HcfObjDestroy(cipher);
1554     EXPECT_EQ(ret, 0);
1555 }
1556 
1557 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest032, TestSize.Level0)
1558 {
1559     int ret = 0;
1560     uint8_t iv[AES_IV_LEN] = { 0 };
1561     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
1562     int cipherTextLen = CIPHER_TEXT_LEN;
1563 
1564     HcfIvParamsSpec ivSpec = {};
1565     HcfCipher *cipher = nullptr;
1566     HcfSymKey *key = nullptr;
1567     ivSpec.iv.data = iv;
1568     ivSpec.iv.len = AES_IV_LEN;
1569 
1570     ret = GenerateSymKey("AES192", &key);
1571     if (ret != 0) {
1572         LOGE("GenerateSymKey failed!");
1573         goto CLEAR_UP;
1574     }
1575 
1576     ret = HcfCipherCreate("AES192|CFB128|PKCS5", &cipher);    // CFB1/CFB8/CFB128 bit
1577     if (ret != 0) {
1578         LOGE("HcfCipherCreate failed!");
1579         goto CLEAR_UP;
1580     }
1581 
1582     ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen);
1583     if (ret != 0) {
1584         LOGE("AesEncrypt failed! %d", ret);
1585         goto CLEAR_UP;
1586     }
1587 
1588     ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen);
1589     if (ret != 0) {
1590         LOGE("AesDecrypt failed! %d", ret);
1591     }
1592 
1593 CLEAR_UP:
1594     HcfObjDestroy(key);
1595     HcfObjDestroy(cipher);
1596     EXPECT_EQ(ret, 0);
1597 }
1598 
1599 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest033, TestSize.Level0)
1600 {
1601     int ret = 0;
1602     uint8_t iv[AES_IV_LEN] = { 0 };
1603     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
1604     int cipherTextLen = CIPHER_TEXT_LEN;
1605 
1606     HcfIvParamsSpec ivSpec = {};
1607     HcfCipher *cipher = nullptr;
1608     HcfSymKey *key = nullptr;
1609     ivSpec.iv.data = iv;
1610     ivSpec.iv.len = AES_IV_LEN;
1611 
1612     ret = GenerateSymKey("AES256", &key);
1613     if (ret != 0) {
1614         LOGE("GenerateSymKey failed!");
1615         goto CLEAR_UP;
1616     }
1617 
1618     ret = HcfCipherCreate("AES256|CFB128|PKCS5", &cipher);    // CFB1/CFB8/CFB128 bit
1619     if (ret != 0) {
1620         LOGE("HcfCipherCreate failed!");
1621         goto CLEAR_UP;
1622     }
1623 
1624     ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen);
1625     if (ret != 0) {
1626         LOGE("AesEncrypt failed! %d", ret);
1627         goto CLEAR_UP;
1628     }
1629 
1630     ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen);
1631     if (ret != 0) {
1632         LOGE("AesDecrypt failed! %d", ret);
1633     }
1634 
1635 CLEAR_UP:
1636     HcfObjDestroy(key);
1637     HcfObjDestroy(cipher);
1638     EXPECT_EQ(ret, 0);
1639 }
1640 
1641 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest034, TestSize.Level0)
1642 {
1643     int ret = 0;
1644     HcfCipher *cipher = nullptr;
1645     const char *cipherName = "AES128|CFB|NoPadding";
1646     const char *retAlgo = nullptr;
1647     ret = HcfCipherCreate(cipherName, &cipher);
1648     if (ret != 0) {
1649         LOGE("HcfCipherCreate failed!");
1650         goto CLEAR_UP;
1651     }
1652 
1653     retAlgo = cipher->getAlgorithm(cipher);
1654     if (retAlgo == nullptr) {
1655         LOGE("cipher getAlgorithm failed!");
1656         ret = HCF_ERR_CRYPTO_OPERATION;
1657         goto CLEAR_UP;
1658     }
1659 
1660     ret = strcmp(retAlgo, cipherName);
1661     if (ret != 0) {
1662         LOGE("cipher getAlgorithm failed!");
1663     }
1664 CLEAR_UP:
1665     HcfObjDestroy(cipher);
1666     EXPECT_EQ(ret, 0);
1667 }
1668 
1669 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest035, TestSize.Level0)
1670 {
1671     int ret = 0;
1672     HcfCipher *cipher = nullptr;
1673     const char *cipherName = "AES128|CFB|NoPadding";
1674     const char *retAlgo = nullptr;
1675     ret = HcfCipherCreate(cipherName, &cipher);
1676     if (ret != 0) {
1677         LOGE("HcfCipherCreate failed!");
1678         goto CLEAR_UP;
1679     }
1680 
1681     retAlgo = cipher->getAlgorithm(nullptr);
1682     if (retAlgo == nullptr) {
1683         LOGE("cipher getAlgorithm failed!");
1684         ret = HCF_ERR_CRYPTO_OPERATION;
1685     }
1686 
1687 CLEAR_UP:
1688     HcfObjDestroy(cipher);
1689     EXPECT_NE(ret, 0);
1690 }
1691 
1692 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest036, TestSize.Level0)
1693 {
1694     int ret = 0;
1695     HcfCipher *cipher = nullptr;
1696     HcfSymKeyGenerator *generator = nullptr;
1697     const char *cipherName = "AES128|CFB|NoPadding";
1698     const char *retAlgo = nullptr;
1699 
1700     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
1701     if (ret != 0) {
1702         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
1703         goto CLEAR_UP;
1704     }
1705 
1706     ret = HcfCipherCreate(cipherName, &cipher);
1707     if (ret != 0) {
1708         LOGE("HcfCipherCreate failed!");
1709         goto CLEAR_UP;
1710     }
1711 
1712     retAlgo = cipher->getAlgorithm(reinterpret_cast<HcfCipher *>(generator));
1713     if (retAlgo == nullptr) {
1714         LOGE("cipher getAlgorithm failed!");
1715         ret = HCF_ERR_CRYPTO_OPERATION;
1716     }
1717 
1718 CLEAR_UP:
1719     HcfObjDestroy(generator);
1720     HcfObjDestroy(cipher);
1721     EXPECT_NE(ret, 0);
1722 }
1723 
1724 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest037, TestSize.Level0)
1725 {
1726     int ret = 0;
1727     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
1728     int cipherTextLen = CIPHER_TEXT_LEN;
1729     HcfSymKey *key = nullptr;
1730     HcfCipher *cipher = nullptr;
1731 
1732     ret = GenerateSymKey("AES256", &key);
1733     if (ret != 0) {
1734         LOGE("GenerateSymKey failed!");
1735         goto CLEAR_UP;
1736     }
1737 
1738     ret = HcfCipherCreate("AES256|CFB128|PKCS5", &cipher);
1739     if (ret != 0) {
1740         LOGE("HcfCipherCreate failed!");
1741         goto CLEAR_UP;
1742     }
1743 
1744     ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
1745     if (ret != 0) {
1746         LOGE("AesEncrypt failed! %d", ret);
1747         goto CLEAR_UP;
1748     }
1749 
1750     ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
1751     if (ret != 0) {
1752         LOGE("AesDecrypt failed! %d", ret);
1753     }
1754 
1755 CLEAR_UP:
1756     HcfObjDestroy(key);
1757     HcfObjDestroy(cipher);
1758     EXPECT_NE(ret, 0);
1759 }
1760 }