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 #include "aes_openssl.h"
21 #include "aes_common.h"
22 #include "blob.h"
23 #include "cipher.h"
24 #include "detailed_iv_params.h"
25 #include "detailed_gcm_params.h"
26 #include "detailed_ccm_params.h"
27 #include "log.h"
28 #include "memory.h"
29 #include "sym_common_defines.h"
30 #include "sym_key_generator.h"
31 #include "sm4_common.h"
32 #include "sm4_openssl.h"
33 
34 using namespace std;
35 using namespace testing::ext;
36 
37 namespace {
38 class CryptoSM4CfbCipherTest : public testing::Test {
39 public:
SetUpTestCase()40     static void SetUpTestCase() {};
TearDownTestCase()41     static void TearDownTestCase() {};
SetUp()42     void SetUp() {};
TearDown()43     void TearDown() {};
44 };
45 
46 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest010, TestSize.Level0)
47 {
48     int ret = 0;
49     uint8_t cipherText[128] = {0};
50     int cipherTextLen = 128;
51 
52     HcfSymKeyGenerator *generator = nullptr;
53     HcfCipher *cipher = nullptr;
54     HcfSymKey *key = nullptr;
55 
56 
57     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
58     if (ret != 0) {
59         LOGE("HcfSymKeyGeneratorCreate failed!");
60         goto clearup;
61     }
62 
63     ret = generator->generateSymKey(generator, &key);
64     if (ret != 0) {
65         LOGE("generateSymKey failed!");
66         goto clearup;
67     }
68 
69     ret = HcfCipherCreate("SM4_128|CFB|NoPadding", &cipher);
70     if (ret != 0) {
71         LOGE("HcfCipherCreate failed!");
72         goto clearup;
73     }
74 
75     ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
76     if (ret != 0) {
77         LOGE("Sm4Encrypt failed! ");
78         goto clearup;
79     }
80 
81     ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen);
82     if (ret != 0) {
83         LOGE("Sm4Decrypt failed! ");
84         goto clearup;
85     }
86 
87 clearup:
88     HcfObjDestroy((HcfObjectBase *)key);
89     HcfObjDestroy((HcfObjectBase *)cipher);
90     HcfObjDestroy((HcfObjectBase *)generator);
91     EXPECT_EQ(ret, 0);
92 }
93 
94 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest011, TestSize.Level0)
95 {
96     int ret = 0;
97     uint8_t cipherText[128] = {0};
98     int cipherTextLen = 128;
99 
100     HcfSymKeyGenerator *generator = nullptr;
101     HcfCipher *cipher = nullptr;
102     HcfSymKey *key = nullptr;
103 
104 
105     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
106     if (ret != 0) {
107         LOGE("HcfSymKeyGeneratorCreate failed!");
108         goto clearup;
109     }
110 
111     ret = generator->generateSymKey(generator, &key);
112     if (ret != 0) {
113         LOGE("generateSymKey failed!");
114         goto clearup;
115     }
116 
117     ret = HcfCipherCreate("SM4_128|CFB|PKCS5", &cipher);
118     if (ret != 0) {
119         LOGE("HcfCipherCreate failed!");
120         goto clearup;
121     }
122 
123     ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
124     if (ret != 0) {
125         LOGE("Sm4Encrypt failed! ");
126         goto clearup;
127     }
128 
129     ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen);
130     if (ret != 0) {
131         LOGE("Sm4Decrypt failed! ");
132         goto clearup;
133     }
134 
135 clearup:
136     HcfObjDestroy((HcfObjectBase *)key);
137     HcfObjDestroy((HcfObjectBase *)cipher);
138     HcfObjDestroy((HcfObjectBase *)generator);
139     EXPECT_EQ(ret, 0);
140 }
141 
142 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest012, TestSize.Level0)
143 {
144     int ret = 0;
145     uint8_t cipherText[128] = {0};
146     int cipherTextLen = 128;
147 
148     HcfSymKeyGenerator *generator = nullptr;
149     HcfCipher *cipher = nullptr;
150     HcfSymKey *key = nullptr;
151 
152 
153     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
154     if (ret != 0) {
155         LOGE("HcfSymKeyGeneratorCreate failed!");
156         goto clearup;
157     }
158 
159     ret = generator->generateSymKey(generator, &key);
160     if (ret != 0) {
161         LOGE("generateSymKey failed!");
162         goto clearup;
163     }
164 
165     ret = HcfCipherCreate("SM4_128|CFB|PKCS7", &cipher);
166     if (ret != 0) {
167         LOGE("HcfCipherCreate failed!");
168         goto clearup;
169     }
170 
171     ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
172     if (ret != 0) {
173         LOGE("Sm4Encrypt failed! ");
174         goto clearup;
175     }
176 
177     ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen);
178     if (ret != 0) {
179         LOGE("Sm4Decrypt failed! ");
180         goto clearup;
181     }
182 
183 clearup:
184     HcfObjDestroy((HcfObjectBase *)key);
185     HcfObjDestroy((HcfObjectBase *)cipher);
186     HcfObjDestroy((HcfObjectBase *)generator);
187     EXPECT_EQ(ret, 0);
188 }
189 
190 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest013, TestSize.Level0)
191 {
192     int ret = 0;
193     uint8_t cipherText[128] = {0};
194     int cipherTextLen = 128;
195 
196     HcfSymKeyGenerator *generator = nullptr;
197     HcfCipher *cipher = nullptr;
198     HcfSymKey *key = nullptr;
199 
200 
201     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
202     if (ret != 0) {
203         LOGE("HcfSymKeyGeneratorCreate failed!");
204         goto clearup;
205     }
206 
207     ret = generator->generateSymKey(generator, &key);
208     if (ret != 0) {
209         LOGE("generateSymKey failed!");
210         goto clearup;
211     }
212 
213     ret = HcfCipherCreate("SM4_128|CFB128|NoPadding", &cipher);
214     if (ret != 0) {
215         LOGE("HcfCipherCreate failed!");
216         goto clearup;
217     }
218 
219     ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
220     if (ret != 0) {
221         LOGE("Sm4Encrypt failed! ");
222         goto clearup;
223     }
224 
225     ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen);
226     if (ret != 0) {
227         LOGE("Sm4Decrypt failed! ");
228         goto clearup;
229     }
230 
231 clearup:
232     HcfObjDestroy((HcfObjectBase *)key);
233     HcfObjDestroy((HcfObjectBase *)cipher);
234     HcfObjDestroy((HcfObjectBase *)generator);
235     EXPECT_EQ(ret, 0);
236 }
237 
238 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest014, TestSize.Level0)
239 {
240     int ret = 0;
241     uint8_t cipherText[128] = {0};
242     int cipherTextLen = 128;
243 
244     HcfSymKeyGenerator *generator = nullptr;
245     HcfCipher *cipher = nullptr;
246     HcfSymKey *key = nullptr;
247 
248 
249     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
250     if (ret != 0) {
251         LOGE("HcfSymKeyGeneratorCreate failed!");
252         goto clearup;
253     }
254 
255     ret = generator->generateSymKey(generator, &key);
256     if (ret != 0) {
257         LOGE("generateSymKey failed!");
258         goto clearup;
259     }
260 
261     ret = HcfCipherCreate("SM4_128|CFB128|PKCS5", &cipher);
262     if (ret != 0) {
263         LOGE("HcfCipherCreate failed!");
264         goto clearup;
265     }
266 
267     ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
268     if (ret != 0) {
269         LOGE("Sm4Encrypt failed! ");
270         goto clearup;
271     }
272 
273     ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen);
274     if (ret != 0) {
275         LOGE("Sm4Decrypt failed! ");
276         goto clearup;
277     }
278 
279 clearup:
280     HcfObjDestroy((HcfObjectBase *)key);
281     HcfObjDestroy((HcfObjectBase *)cipher);
282     HcfObjDestroy((HcfObjectBase *)generator);
283     EXPECT_EQ(ret, 0);
284 }
285 
286 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest015, TestSize.Level0)
287 {
288     int ret = 0;
289     uint8_t cipherText[128] = {0};
290     int cipherTextLen = 128;
291 
292     HcfSymKeyGenerator *generator = nullptr;
293     HcfCipher *cipher = nullptr;
294     HcfSymKey *key = nullptr;
295 
296 
297     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
298     if (ret != 0) {
299         LOGE("HcfSymKeyGeneratorCreate failed!");
300         goto clearup;
301     }
302 
303     ret = generator->generateSymKey(generator, &key);
304     if (ret != 0) {
305         LOGE("generateSymKey failed!");
306         goto clearup;
307     }
308 
309     ret = HcfCipherCreate("SM4_128|CFB128|PKCS7", &cipher);
310     if (ret != 0) {
311         LOGE("HcfCipherCreate failed!");
312         goto clearup;
313     }
314 
315     ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
316     if (ret != 0) {
317         LOGE("Sm4Encrypt failed! ");
318         goto clearup;
319     }
320 
321     ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen);
322     if (ret != 0) {
323         LOGE("Sm4Decrypt failed! ");
324         goto clearup;
325     }
326 
327 clearup:
328     HcfObjDestroy((HcfObjectBase *)key);
329     HcfObjDestroy((HcfObjectBase *)cipher);
330     HcfObjDestroy((HcfObjectBase *)generator);
331     EXPECT_EQ(ret, 0);
332 }
333 
334 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest028, 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 
344     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
345     if (ret != 0) {
346         LOGE("HcfSymKeyGeneratorCreate failed!");
347         goto clearup;
348     }
349 
350     ret = generator->generateSymKey(generator, &key);
351     if (ret != 0) {
352         LOGE("generateSymKey failed!");
353         goto clearup;
354     }
355 
356     ret = HcfCipherCreate("SM4_128|CFB|NoPadding", &cipher);
357     if (ret != 0) {
358         LOGE("HcfCipherCreate failed!");
359         goto clearup;
360     }
361 
362     ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
363     if (ret != 0) {
364         LOGE("Sm4NoUpdateEncrypt failed! ");
365         goto clearup;
366     }
367 
368     ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
369     if (ret != 0) {
370         LOGE("Sm4NoUpdateDecrypt failed! ");
371         goto clearup;
372     }
373 
374 clearup:
375     HcfObjDestroy((HcfObjectBase *)key);
376     HcfObjDestroy((HcfObjectBase *)cipher);
377     HcfObjDestroy((HcfObjectBase *)generator);
378     EXPECT_EQ(ret, 0);
379 }
380 
381 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest029, TestSize.Level0)
382 {
383     int ret = 0;
384     uint8_t cipherText[128] = {0};
385     int cipherTextLen = 128;
386 
387     HcfSymKeyGenerator *generator = nullptr;
388     HcfCipher *cipher = nullptr;
389     HcfSymKey *key = nullptr;
390 
391 
392     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
393     if (ret != 0) {
394         LOGE("HcfSymKeyGeneratorCreate failed!");
395         goto clearup;
396     }
397 
398     ret = generator->generateSymKey(generator, &key);
399     if (ret != 0) {
400         LOGE("generateSymKey failed!");
401         goto clearup;
402     }
403 
404     ret = HcfCipherCreate("SM4_128|CFB|PKCS5", &cipher);
405     if (ret != 0) {
406         LOGE("HcfCipherCreate failed!");
407         goto clearup;
408     }
409 
410     ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
411     if (ret != 0) {
412         LOGE("Sm4NoUpdateEncrypt failed! ");
413         goto clearup;
414     }
415 
416     ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
417     if (ret != 0) {
418         LOGE("Sm4NoUpdateDecrypt failed! ");
419         goto clearup;
420     }
421 
422 clearup:
423     HcfObjDestroy((HcfObjectBase *)key);
424     HcfObjDestroy((HcfObjectBase *)cipher);
425     HcfObjDestroy((HcfObjectBase *)generator);
426     EXPECT_EQ(ret, 0);
427 }
428 
429 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest030, TestSize.Level0)
430 {
431     int ret = 0;
432     uint8_t cipherText[128] = {0};
433     int cipherTextLen = 128;
434 
435     HcfSymKeyGenerator *generator = nullptr;
436     HcfCipher *cipher = nullptr;
437     HcfSymKey *key = nullptr;
438 
439 
440     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
441     if (ret != 0) {
442         LOGE("HcfSymKeyGeneratorCreate failed!");
443         goto clearup;
444     }
445 
446     ret = generator->generateSymKey(generator, &key);
447     if (ret != 0) {
448         LOGE("generateSymKey failed!");
449         goto clearup;
450     }
451 
452     ret = HcfCipherCreate("SM4_128|CFB|PKCS7", &cipher);
453     if (ret != 0) {
454         LOGE("HcfCipherCreate failed!");
455         goto clearup;
456     }
457 
458     ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
459     if (ret != 0) {
460         LOGE("Sm4NoUpdateEncrypt failed! ");
461         goto clearup;
462     }
463 
464     ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
465     if (ret != 0) {
466         LOGE("Sm4NoUpdateDecrypt failed! ");
467         goto clearup;
468     }
469 
470 clearup:
471     HcfObjDestroy((HcfObjectBase *)key);
472     HcfObjDestroy((HcfObjectBase *)cipher);
473     HcfObjDestroy((HcfObjectBase *)generator);
474     EXPECT_EQ(ret, 0);
475 }
476 
477 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest031, TestSize.Level0)
478 {
479     int ret = 0;
480     uint8_t cipherText[128] = {0};
481     int cipherTextLen = 128;
482 
483     HcfSymKeyGenerator *generator = nullptr;
484     HcfCipher *cipher = nullptr;
485     HcfSymKey *key = nullptr;
486 
487 
488     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
489     if (ret != 0) {
490         LOGE("HcfSymKeyGeneratorCreate failed!");
491         goto clearup;
492     }
493 
494     ret = generator->generateSymKey(generator, &key);
495     if (ret != 0) {
496         LOGE("generateSymKey failed!");
497         goto clearup;
498     }
499 
500     ret = HcfCipherCreate("SM4_128|CFB128|NoPadding", &cipher);
501     if (ret != 0) {
502         LOGE("HcfCipherCreate failed!");
503         goto clearup;
504     }
505 
506     ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
507     if (ret != 0) {
508         LOGE("Sm4NoUpdateEncrypt failed! ");
509         goto clearup;
510     }
511 
512     ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
513     if (ret != 0) {
514         LOGE("Sm4NoUpdateDecrypt failed! ");
515         goto clearup;
516     }
517 
518 clearup:
519     HcfObjDestroy((HcfObjectBase *)key);
520     HcfObjDestroy((HcfObjectBase *)cipher);
521     HcfObjDestroy((HcfObjectBase *)generator);
522     EXPECT_EQ(ret, 0);
523 }
524 
525 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest032, TestSize.Level0)
526 {
527     int ret = 0;
528     uint8_t cipherText[128] = {0};
529     int cipherTextLen = 128;
530 
531     HcfSymKeyGenerator *generator = nullptr;
532     HcfCipher *cipher = nullptr;
533     HcfSymKey *key = nullptr;
534 
535 
536     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
537     if (ret != 0) {
538         LOGE("HcfSymKeyGeneratorCreate failed!");
539         goto clearup;
540     }
541 
542     ret = generator->generateSymKey(generator, &key);
543     if (ret != 0) {
544         LOGE("generateSymKey failed!");
545         goto clearup;
546     }
547 
548     ret = HcfCipherCreate("SM4_128|CFB128|PKCS5", &cipher);
549     if (ret != 0) {
550         LOGE("HcfCipherCreate failed!");
551         goto clearup;
552     }
553 
554     ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
555     if (ret != 0) {
556         LOGE("Sm4NoUpdateEncrypt failed! ");
557         goto clearup;
558     }
559 
560     ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
561     if (ret != 0) {
562         LOGE("Sm4NoUpdateDecrypt failed! ");
563         goto clearup;
564     }
565 
566 clearup:
567     HcfObjDestroy((HcfObjectBase *)key);
568     HcfObjDestroy((HcfObjectBase *)cipher);
569     HcfObjDestroy((HcfObjectBase *)generator);
570     EXPECT_EQ(ret, 0);
571 }
572 
573 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest033, TestSize.Level0)
574 {
575     int ret = 0;
576     uint8_t cipherText[128] = {0};
577     int cipherTextLen = 128;
578 
579     HcfSymKeyGenerator *generator = nullptr;
580     HcfCipher *cipher = nullptr;
581     HcfSymKey *key = nullptr;
582 
583     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
584     if (ret != 0) {
585         LOGE("HcfSymKeyGeneratorCreate failed!");
586         goto clearup;
587     }
588 
589     ret = generator->generateSymKey(generator, &key);
590     if (ret != 0) {
591         LOGE("generateSymKey failed!");
592         goto clearup;
593     }
594 
595     ret = HcfCipherCreate("SM4_128|CFB128|PKCS7", &cipher);
596     if (ret != 0) {
597         LOGE("HcfCipherCreate failed!");
598         goto clearup;
599     }
600 
601     ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
602     if (ret != 0) {
603         LOGE("Sm4NoUpdateEncrypt failed! ");
604         goto clearup;
605     }
606 
607     ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
608     if (ret != 0) {
609         LOGE("Sm4NoUpdateDecrypt failed! ");
610         goto clearup;
611     }
612 
613 clearup:
614     HcfObjDestroy((HcfObjectBase *)key);
615     HcfObjDestroy((HcfObjectBase *)cipher);
616     HcfObjDestroy((HcfObjectBase *)generator);
617     EXPECT_EQ(ret, 0);
618 }
619 
620 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest040, TestSize.Level0)
621 {
622     int ret = 0;
623     HcfCipher *cipher = nullptr;
624     const char *cipherName = "SM4_128|CFB|NoPadding";
625     const char *retAlgo = nullptr;
626     ret = HcfCipherCreate(cipherName, &cipher);
627     if (ret != 0) {
628         LOGE("HcfCipherCreate failed!");
629         goto CLEAR_UP;
630     }
631 
632     retAlgo = cipher->getAlgorithm(nullptr);
633     if (retAlgo == nullptr) {
634         LOGE("cipher getAlgorithm failed!");
635         ret = HCF_ERR_CRYPTO_OPERATION;
636     }
637 
638 CLEAR_UP:
639     HcfObjDestroy(cipher);
640     EXPECT_NE(ret, 0);
641 }
642 
643 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest041, TestSize.Level0)
644 {
645     int ret = 0;
646     HcfCipher *cipher = nullptr;
647     HcfSymKeyGenerator *generator = nullptr;
648     const char *cipherName = "SM4_128|CFB|NoPadding";
649     const char *retAlgo = nullptr;
650 
651     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
652     if (ret != 0) {
653         LOGE("HcfSymKeyGeneratorCreate failed!");
654         goto CLEAR_UP;
655     }
656 
657     ret = HcfCipherCreate(cipherName, &cipher);
658     if (ret != 0) {
659         LOGE("HcfCipherCreate failed!");
660         goto CLEAR_UP;
661     }
662 
663     retAlgo = cipher->getAlgorithm(reinterpret_cast<HcfCipher *>(generator));
664     if (retAlgo == nullptr) {
665         LOGE("cipher getAlgorithm failed!");
666         ret = HCF_ERR_CRYPTO_OPERATION;
667     }
668 
669 CLEAR_UP:
670     HcfObjDestroy(generator);
671     HcfObjDestroy(cipher);
672     EXPECT_NE(ret, 0);
673 }
674 
675 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest042, TestSize.Level0)
676 {
677     int ret = 0;
678     HcfCipher *cipher = nullptr;
679 
680     ret = HcfCipherCreate("SM3|CFB|NoPadding", &cipher);
681     if (ret != 0) {
682         LOGE("HcfCipherCreate failed! Should not select SM3 for CFB generator.");
683     }
684 
685     HcfObjDestroy(cipher);
686     EXPECT_NE(ret, 0);
687 }
688 
689 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest043, TestSize.Level0)
690 {
691     int ret = 0;
692     HcfCipher *cipher = nullptr;
693 
694     // not allow '|' without content, because findAbility will fail for "" input
695     ret = HcfCipherCreate("SM4_128|CFB|", &cipher);
696     if (ret != 0) {
697         LOGE("HcfCipherCreate failed! Should select padding mode for SM4_128 generator.");
698     }
699 
700     HcfObjDestroy(cipher);
701     EXPECT_NE(ret, 0);
702 }
703 
704 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest047, TestSize.Level0)
705 {
706     int ret = 0;
707 
708     ret = HcfCipherCreate(nullptr, nullptr);
709     if (ret != 0) {
710         LOGE("HcfCipherCreate failed! Should not select SM3 for CFB generator.");
711     }
712 
713     EXPECT_NE(ret, 0);
714 }
715 
716 HWTEST_F(CryptoSM4CfbCipherTest, CryptoAesCipherTest050, TestSize.Level0)
717 {
718     int ret = 0;
719     uint8_t aad[8] = {0};
720     uint8_t tag[12] = {0};
721     uint8_t iv[7] = {0};
722     uint8_t cipherText[128] = {0};
723     int cipherTextLen = 128;
724 
725     HcfCipher *cipher = nullptr;
726     HcfSymKey *key = nullptr;
727     HcfCcmParamsSpec spec = {};
728     spec.aad.data = aad;
729     spec.aad.len = sizeof(aad);
730     spec.tag.data = tag;
731     spec.tag.len = sizeof(tag);
732     spec.iv.data = iv;
733     spec.iv.len = sizeof(iv);
734 
735     ret = GenerateSymKeyForSm4("SM4_128", &key);
736     if (ret != 0) {
737         LOGE("generateSymKey failed!");
738         goto CLEAR_UP;
739     }
740 
741     ret = HcfCipherCreate("SM4_128|CFB|PKCS5", &cipher);
742     if (ret != 0) {
743         LOGE("HcfCipherCreate failed!");
744         goto CLEAR_UP;
745     }
746 
747     ret = Sm4Encrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, &cipherTextLen);
748     if (ret != 0) {
749         LOGE("Sm4Encrypt failed!");
750         goto CLEAR_UP;
751     }
752 
753     (void)memcpy_s(spec.tag.data, 12, cipherText + cipherTextLen - 12, 12);
754 
755     cipherTextLen -= 12;
756 
757     ret = Sm4Decrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, cipherTextLen);
758     if (ret != 0) {
759         LOGE("Sm4Decrypt failed!");
760         goto CLEAR_UP;
761     }
762 
763 CLEAR_UP:
764     HcfObjDestroy((HcfObjectBase *)key);
765     HcfObjDestroy((HcfObjectBase *)cipher);
766     EXPECT_NE(ret, 0);
767 }
768 
769 HWTEST_F(CryptoSM4CfbCipherTest, CryptoAesCipherTest051, TestSize.Level0)
770 {
771     int ret = 0;
772     HcfCipher *cipher = nullptr;
773     const char *cipherName = "SM4_128|CFB|NoPadding";
774     const char *retAlgo = nullptr;
775     ret = HcfCipherCreate(cipherName, &cipher);
776     if (ret != 0) {
777         LOGE("HcfCipherCreate failed!");
778         goto CLEAR_UP;
779     }
780 
781     retAlgo = cipher->getAlgorithm(cipher);
782     if (retAlgo == nullptr) {
783         LOGE("cipher getAlgorithm failed!");
784         ret = HCF_ERR_CRYPTO_OPERATION;
785         goto CLEAR_UP;
786     }
787 
788     ret = strcmp(retAlgo, cipherName);
789     if (ret != 0) {
790         LOGE("cipher getAlgorithm failed!");
791     }
792 CLEAR_UP:
793     HcfObjDestroy(cipher);
794     EXPECT_EQ(ret, 0);
795 }
796 
797 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest082, TestSize.Level0)
798 {
799     int ret = 0;
800     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
801     int cipherTextLen = CIPHER_TEXT_LEN;
802     HcfCipher *cipher = nullptr;
803     HcfSymKey *key = nullptr;
804 
805     ret = GenerateSymKeyForSm4("AES256", &key);
806     if (ret != 0) {
807         LOGE("GenerateSymKey failed!");
808         goto CLEAR_UP;
809     }
810 
811     ret = HcfCipherCreate("SM4_128|CFB|PKCS5", &cipher);
812     if (ret != 0) {
813         LOGE("HcfCipherCreate failed!");
814         goto CLEAR_UP;
815     }
816 
817     // It is not allowed that AES128 in key is smaller AES256 in cipher. -> now only use the size of input key.
818     ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
819     if (ret != 0) {
820         LOGE("AesEncrypt failed! %d", ret);
821         goto CLEAR_UP;
822     }
823 
824     ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen);
825     if (ret != 0) {
826         LOGE("AesDecrypt failed! %d", ret);
827     }
828 
829 CLEAR_UP:
830     HcfObjDestroy(key);
831     HcfObjDestroy(cipher);
832     EXPECT_NE(ret, 0);
833 }
834 
835 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest083, TestSize.Level0)
836 {
837     int ret = 0;
838     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
839     int cipherTextLen = CIPHER_TEXT_LEN;
840     HcfCipher *cipher = nullptr;
841     HcfSymKey *key = nullptr;
842 
843     ret = GenerateSymKeyForSm4("AES256", &key);
844     if (ret != 0) {
845         LOGE("GenerateSymKey failed!");
846         goto CLEAR_UP;
847     }
848 
849     ret = HcfCipherCreate("SM4_128|CFB128|PKCS5", &cipher);
850     if (ret != 0) {
851         LOGE("HcfCipherCreate failed!");
852         goto CLEAR_UP;
853     }
854 
855     // It is not allowed that AES128 in key is smaller AES256 in cipher. -> now only use the size of input key.
856     ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
857     if (ret != 0) {
858         LOGE("AesEncrypt failed! %d", ret);
859         goto CLEAR_UP;
860     }
861 
862     ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen);
863     if (ret != 0) {
864         LOGE("AesDecrypt failed! %d", ret);
865     }
866 
867 CLEAR_UP:
868     HcfObjDestroy(key);
869     HcfObjDestroy(cipher);
870     EXPECT_NE(ret, 0);
871 }
872 }