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 CryptoSM4EcbCipherTest : 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(CryptoSM4EcbCipherTest, CryptoSm4CipherTest001, 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     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
57     if (ret != 0) {
58         LOGE("HcfSymKeyGeneratorCreate failed!");
59         goto clearup;
60     }
61 
62     ret = generator->generateSymKey(generator, &key);
63     if (ret != 0) {
64         LOGE("generateSymKey failed!");
65         goto clearup;
66     }
67 
68     ret = HcfCipherCreate("SM4_128|ECB|NoPadding", &cipher);
69     if (ret != 0) {
70         LOGE("HcfCipherCreate failed!");
71         goto clearup;
72     }
73 
74     ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
75     if (ret != 0) {
76         LOGE("Sm4Encrypt failed! ");
77         goto clearup;
78     }
79 
80     ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen);
81     if (ret != 0) {
82         LOGE("Sm4Decrypt failed! ");
83         goto clearup;
84     }
85 
86 clearup:
87     HcfObjDestroy((HcfObjectBase *)key);
88     HcfObjDestroy((HcfObjectBase *)cipher);
89     HcfObjDestroy((HcfObjectBase *)generator);
90     EXPECT_NE(ret, 0);
91 }
92 
93 HWTEST_F(CryptoSM4EcbCipherTest, CryptoSm4CipherTest002, TestSize.Level0)
94 {
95     int ret = 0;
96     uint8_t cipherText[128] = {0};
97     int cipherTextLen = 128;
98 
99     HcfSymKeyGenerator *generator = nullptr;
100     HcfCipher *cipher = nullptr;
101     HcfSymKey *key = nullptr;
102 
103     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
104     if (ret != 0) {
105         LOGE("HcfSymKeyGeneratorCreate failed!");
106         goto clearup;
107     }
108 
109     ret = generator->generateSymKey(generator, &key);
110     if (ret != 0) {
111         LOGE("generateSymKey failed!");
112         goto clearup;
113     }
114 
115     ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
116     if (ret != 0) {
117         LOGE("HcfCipherCreate failed!");
118         goto clearup;
119     }
120 
121     ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
122     if (ret != 0) {
123         LOGE("Sm4Encrypt failed! ");
124         goto clearup;
125     }
126 
127     ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen);
128     if (ret != 0) {
129         LOGE("Sm4Decrypt failed! ");
130         goto clearup;
131     }
132 
133 
134 clearup:
135     HcfObjDestroy((HcfObjectBase *)key);
136     HcfObjDestroy((HcfObjectBase *)cipher);
137     HcfObjDestroy((HcfObjectBase *)generator);
138     EXPECT_EQ(ret, 0);
139 }
140 
141 HWTEST_F(CryptoSM4EcbCipherTest, CryptoSm4CipherTest003, TestSize.Level0)
142 {
143     int ret = 0;
144     uint8_t cipherText[128] = {0};
145     int cipherTextLen = 128;
146 
147     HcfSymKeyGenerator *generator = nullptr;
148     HcfCipher *cipher = nullptr;
149     HcfSymKey *key = nullptr;
150 
151     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
152     if (ret != 0) {
153         LOGE("HcfSymKeyGeneratorCreate failed!");
154         goto clearup;
155     }
156 
157     ret = generator->generateSymKey(generator, &key);
158     if (ret != 0) {
159         LOGE("generateSymKey failed!");
160         goto clearup;
161     }
162 
163     ret = HcfCipherCreate("SM4_128|ECB|PKCS7", &cipher);
164     if (ret != 0) {
165         LOGE("HcfCipherCreate failed!");
166         goto clearup;
167     }
168 
169     ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
170     if (ret != 0) {
171         LOGE("Sm4Encrypt failed! ");
172         goto clearup;
173     }
174 
175     ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen);
176     if (ret != 0) {
177         LOGE("Sm4Decrypt failed! ");
178         goto clearup;
179     }
180 
181 clearup:
182     HcfObjDestroy((HcfObjectBase *)key);
183     HcfObjDestroy((HcfObjectBase *)cipher);
184     HcfObjDestroy((HcfObjectBase *)generator);
185     EXPECT_EQ(ret, 0);
186 }
187 
188 HWTEST_F(CryptoSM4EcbCipherTest, CryptoSm4CipherTest019, TestSize.Level0)
189 {
190     int ret = 0;
191     uint8_t cipherText[128] = {0};
192     int cipherTextLen = 128;
193 
194     HcfSymKeyGenerator *generator = nullptr;
195     HcfCipher *cipher = nullptr;
196     HcfSymKey *key = nullptr;
197 
198     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
199     if (ret != 0) {
200         LOGE("HcfSymKeyGeneratorCreate failed!");
201         goto clearup;
202     }
203 
204     ret = generator->generateSymKey(generator, &key);
205     if (ret != 0) {
206         LOGE("generateSymKey failed!");
207         goto clearup;
208     }
209 
210     ret = HcfCipherCreate("SM4_128|ECB|NoPadding", &cipher);
211     if (ret != 0) {
212         LOGE("HcfCipherCreate failed!");
213         goto clearup;
214     }
215 
216     ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
217     if (ret != 0) {
218         LOGE("Sm4NoUpdateEncrypt failed! ");
219         goto clearup;
220     }
221 
222     ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
223     if (ret != 0) {
224         LOGE("Sm4NoUpdateDecrypt failed! ");
225         goto clearup;
226     }
227 
228 clearup:
229     HcfObjDestroy((HcfObjectBase *)key);
230     HcfObjDestroy((HcfObjectBase *)cipher);
231     HcfObjDestroy((HcfObjectBase *)generator);
232     EXPECT_NE(ret, 0);
233 }
234 
235 HWTEST_F(CryptoSM4EcbCipherTest, CryptoSm4CipherTest020, TestSize.Level0)
236 {
237     int ret = 0;
238     uint8_t cipherText[128] = {0};
239     int cipherTextLen = 128;
240 
241     HcfSymKeyGenerator *generator = nullptr;
242     HcfCipher *cipher = nullptr;
243     HcfSymKey *key = nullptr;
244 
245     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
246     if (ret != 0) {
247         LOGE("HcfSymKeyGeneratorCreate failed!");
248         goto clearup;
249     }
250 
251     ret = generator->generateSymKey(generator, &key);
252     if (ret != 0) {
253         LOGE("generateSymKey failed!");
254         goto clearup;
255     }
256 
257     ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
258     if (ret != 0) {
259         LOGE("HcfCipherCreate failed!");
260         goto clearup;
261     }
262 
263     ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
264     if (ret != 0) {
265         LOGE("Sm4NoUpdateEncrypt failed! ");
266         goto clearup;
267     }
268 
269     ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
270     if (ret != 0) {
271         LOGE("Sm4NoUpdateDecrypt failed! ");
272         goto clearup;
273     }
274 
275 
276 clearup:
277     HcfObjDestroy((HcfObjectBase *)key);
278     HcfObjDestroy((HcfObjectBase *)cipher);
279     HcfObjDestroy((HcfObjectBase *)generator);
280     EXPECT_EQ(ret, 0);
281 }
282 
283 HWTEST_F(CryptoSM4EcbCipherTest, CryptoSm4CipherTest021, TestSize.Level0)
284 {
285     int ret = 0;
286     uint8_t cipherText[128] = {0};
287     int cipherTextLen = 128;
288 
289     HcfSymKeyGenerator *generator = nullptr;
290     HcfCipher *cipher = nullptr;
291     HcfSymKey *key = nullptr;
292 
293     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
294     if (ret != 0) {
295         LOGE("HcfSymKeyGeneratorCreate failed!");
296         goto clearup;
297     }
298 
299     ret = generator->generateSymKey(generator, &key);
300     if (ret != 0) {
301         LOGE("generateSymKey failed!");
302         goto clearup;
303     }
304 
305     ret = HcfCipherCreate("SM4_128|ECB|PKCS7", &cipher);
306     if (ret != 0) {
307         LOGE("HcfCipherCreate failed!");
308         goto clearup;
309     }
310 
311     ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
312     if (ret != 0) {
313         LOGE("Sm4NoUpdateEncrypt failed! ");
314         goto clearup;
315     }
316 
317     ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
318     if (ret != 0) {
319         LOGE("Sm4NoUpdateDecrypt failed! ");
320         goto clearup;
321     }
322 
323 clearup:
324     HcfObjDestroy((HcfObjectBase *)key);
325     HcfObjDestroy((HcfObjectBase *)cipher);
326     HcfObjDestroy((HcfObjectBase *)generator);
327     EXPECT_EQ(ret, 0);
328 }
329 
330 HWTEST_F(CryptoSM4EcbCipherTest, CryptoSm4CipherTest034, TestSize.Level0)
331 {
332     int ret = 0;
333     HcfCipher *cipher = nullptr;
334     HcfSymKey *key = nullptr;
335 
336     ret = GenerateSm4SymKey(&key);
337     if (ret != 0) {
338         LOGE("generateSymKey failed!");
339         goto clearup;
340     }
341 
342     ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
343     if (ret != 0) {
344         LOGE("HcfCipherCreate failed!");
345         goto clearup;
346     }
347 
348     ret = cipher->init(nullptr, ENCRYPT_MODE, &(key->key), nullptr);
349     if (ret != 0) {
350         LOGE("init failed! ");
351     }
352 
353 clearup:
354     HcfObjDestroy(key);
355     HcfObjDestroy(cipher);
356     EXPECT_NE(ret, 0);
357 }
358 
359 HWTEST_F(CryptoSM4EcbCipherTest, CryptoSm4CipherTest035, TestSize.Level0)
360 {
361     int ret = 0;
362     HcfCipher *cipher = nullptr;
363     HcfSymKey *key = nullptr;
364 
365     ret = GenerateSm4SymKey(&key);
366     if (ret != 0) {
367         LOGE("generateSymKey failed!");
368         goto clearup;
369     }
370 
371     ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
372     if (ret != 0) {
373         LOGE("HcfCipherCreate failed!");
374         goto clearup;
375     }
376 
377     ret = cipher->init(cipher, ENCRYPT_MODE, reinterpret_cast<HcfKey *>(cipher), nullptr);
378     if (ret != 0) {
379         LOGE("init failed! ");
380     }
381 
382 clearup:
383     HcfObjDestroy(key);
384     HcfObjDestroy(cipher);
385     EXPECT_NE(ret, 0);
386 }
387 
388 HWTEST_F(CryptoSM4EcbCipherTest, CryptoSm4CipherTest036, TestSize.Level0)
389 {
390     int ret = 0;
391     HcfCipher *cipher = nullptr;
392     HcfSymKey *key = nullptr;
393     uint8_t plainText[] = "this is test!";
394     HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN };
395     HcfBlob output = { .data = nullptr, .len = 0 };
396 
397     ret = GenerateSm4SymKey(&key);
398     if (ret != 0) {
399         LOGE("generateSymKey failed!");
400         goto clearup;
401     }
402 
403     ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
404     if (ret != 0) {
405         LOGE("HcfCipherCreate failed!");
406         goto clearup;
407     }
408 
409     ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr);
410     if (ret != 0) {
411         LOGE("init failed! ");
412         goto clearup;
413     }
414     ret = cipher->update(nullptr, &input, &output);
415     if (ret != 0) {
416         LOGE("update failed!");
417     }
418 clearup:
419     HcfObjDestroy(key);
420     HcfObjDestroy(cipher);
421     if (output.data != nullptr) {
422         HcfFree(output.data);
423         output.data = nullptr;
424     }
425     EXPECT_NE(ret, 0);
426 }
427 
428 HWTEST_F(CryptoSM4EcbCipherTest, CryptoSm4CipherTest037, TestSize.Level0)
429 {
430     int ret = 0;
431     HcfCipher *cipher = nullptr;
432     HcfSymKey *key = nullptr;
433     uint8_t plainText[] = "this is test!";
434     HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN };
435     HcfBlob output = { .data = nullptr, .len = 0 };
436 
437     ret = GenerateSm4SymKey(&key);
438     if (ret != 0) {
439         LOGE("generateSymKey failed!");
440         goto clearup;
441     }
442 
443     ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
444     if (ret != 0) {
445         LOGE("HcfCipherCreate failed!");
446         goto clearup;
447     }
448 
449     ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr);
450     if (ret != 0) {
451         LOGE("init failed! ");
452         goto clearup;
453     }
454     ret = cipher->update(reinterpret_cast<HcfCipher *>(key), &input, &output);
455     if (ret != 0) {
456         LOGE("update failed!");
457     }
458 clearup:
459     HcfObjDestroy(key);
460     HcfObjDestroy(cipher);
461     if (output.data != nullptr) {
462         HcfFree(output.data);
463         output.data = nullptr;
464     }
465     EXPECT_NE(ret, 0);
466 }
467 
468 HWTEST_F(CryptoSM4EcbCipherTest, CryptoSm4CipherTest038, TestSize.Level0)
469 {
470     int ret = 0;
471     HcfCipher *cipher = nullptr;
472     HcfSymKey *key = nullptr;
473     uint8_t plainText[] = "this is test!";
474     HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN };
475     HcfBlob output = { .data = nullptr, .len = 0 };
476 
477     ret = GenerateSm4SymKey(&key);
478     if (ret != 0) {
479         LOGE("generateSymKey failed!");
480         goto clearup;
481     }
482 
483     ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
484     if (ret != 0) {
485         LOGE("HcfCipherCreate failed!");
486         goto clearup;
487     }
488 
489     ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr);
490     if (ret != 0) {
491         LOGE("init failed! ");
492         goto clearup;
493     }
494     ret = cipher->doFinal(nullptr, &input, &output);
495     if (ret != 0) {
496         LOGE("doFinal failed!");
497     }
498 clearup:
499     HcfObjDestroy(key);
500     HcfObjDestroy(cipher);
501     if (output.data != nullptr) {
502         HcfFree(output.data);
503         output.data = nullptr;
504     }
505     EXPECT_NE(ret, 0);
506 }
507 
508 HWTEST_F(CryptoSM4EcbCipherTest, CryptoSm4CipherTest039, TestSize.Level0)
509 {
510     int ret = 0;
511     HcfCipher *cipher = nullptr;
512     HcfSymKey *key = nullptr;
513     uint8_t plainText[] = "this is test!";
514     HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN };
515     HcfBlob output = { .data = nullptr, .len = 0 };
516 
517     ret = GenerateSm4SymKey(&key);
518     if (ret != 0) {
519         LOGE("generateSymKey failed!");
520         goto clearup;
521     }
522 
523     ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
524     if (ret != 0) {
525         LOGE("HcfCipherCreate failed!");
526         goto clearup;
527     }
528 
529     ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr);
530     if (ret != 0) {
531         LOGE("init failed! ");
532         goto clearup;
533     }
534     ret = cipher->doFinal(reinterpret_cast<HcfCipher *>(key), &input, &output);
535     if (ret != 0) {
536         LOGE("doFinal failed!");
537     }
538 clearup:
539     HcfObjDestroy(key);
540     HcfObjDestroy(cipher);
541     if (output.data != nullptr) {
542         HcfFree(output.data);
543         output.data = nullptr;
544     }
545     EXPECT_NE(ret, 0);
546 }
547 
548 HWTEST_F(CryptoSM4EcbCipherTest, CryptoSm4CipherTest046, TestSize.Level0)
549 {
550     int ret = 0;
551     HcfSymKeyGenerator *generator = nullptr;
552     HcfCipher *cipher = nullptr;
553 
554     ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
555     if (ret != 0) {
556         LOGE("HcfCipherCreate failed!");
557         goto CLEAR_UP;
558     }
559 
560     ret = cipher->init(cipher, ENCRYPT_MODE, nullptr, nullptr);
561     if (ret != 0) {
562         LOGE("init failed! Should input key when init.");
563     }
564 
565 CLEAR_UP:
566     HcfObjDestroy(cipher);
567     HcfObjDestroy(generator);
568     EXPECT_NE(ret, 0);
569 }
570 
571 HWTEST_F(CryptoSM4EcbCipherTest, CryptoAesCipherTest048, TestSize.Level0)
572 {
573     int ret = 0;
574     HcfCipher *cipher = nullptr;
575     HcfSymKey *key = nullptr;
576     uint8_t plainText[] = "this is test!";
577     HcfBlob input = { .data = plainText, .len = 0 };
578     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
579     int cipherTextLen = CIPHER_TEXT_LEN;
580 
581     ret = GenerateSymKeyForSm4("SM4_128", &key);
582     if (ret != 0) {
583         LOGE("generateSymKey failed!");
584         goto CLEAR_UP;
585     }
586     ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
587     if (ret != 0) {
588         LOGE("HcfCipherCreate failed!");
589         goto CLEAR_UP;
590     }
591 
592     ret = Sm4EncryptWithInput(cipher, key, &input, cipherText, &cipherTextLen);
593     if (ret != 0) {
594         LOGE("Sm4EncryptWithInput failed! %d", ret);
595         goto CLEAR_UP;
596     }
597 
598     ret = Sm4DecryptEmptyMsg(cipher, key, nullptr, cipherText, cipherTextLen);
599     if (ret != 0) {
600         LOGE("Sm4EncryptWithInput failed! %d", ret);
601     }
602 
603 CLEAR_UP:
604     HcfObjDestroy(key);
605     HcfObjDestroy(cipher);
606     EXPECT_EQ(ret, 0);
607 }
608 
609 HWTEST_F(CryptoSM4EcbCipherTest, CryptoAesCipherTest049, TestSize.Level0)
610 {
611     int ret = 0;
612     HcfCipher *cipher = nullptr;
613     HcfSymKey *key = nullptr;
614     HcfBlob input = { .data = nullptr, .len = 0 };
615     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
616     int cipherTextLen = CIPHER_TEXT_LEN;
617 
618     ret = GenerateSymKeyForSm4("SM4_128", &key);
619     if (ret != 0) {
620         LOGE("generateSymKey failed!");
621         goto CLEAR_UP;
622     }
623     ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
624     if (ret != 0) {
625         LOGE("HcfCipherCreate failed!");
626         goto CLEAR_UP;
627     }
628 
629     ret = Sm4EncryptWithInput(cipher, key, &input, cipherText, &cipherTextLen);
630     if (ret != 0) {
631         LOGE("Sm4EncryptWithInput failed! %d", ret);
632         goto CLEAR_UP;
633     }
634 
635     ret = Sm4DecryptEmptyMsg(cipher, key, nullptr, cipherText, cipherTextLen);
636     if (ret != 0) {
637         LOGE("Sm4DecryptEmptyMsg failed! %d", ret);
638     }
639 
640 CLEAR_UP:
641     HcfObjDestroy(key);
642     HcfObjDestroy(cipher);
643     EXPECT_EQ(ret, 0);
644 }
645 
646 HWTEST_F(CryptoSM4EcbCipherTest, CryptoSm4CipherTest053, TestSize.Level0)
647 {
648     int ret = 0;
649     HcfSymKeyGenerator *generator = nullptr;
650     HcfSymKey *key = nullptr;
651     HcfCipher *cipher = nullptr;
652 
653     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
654     if (ret != 0) {
655         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
656         goto CLEAR_UP;
657     }
658     ret = generator->generateSymKey(generator, &key);
659     if (ret != 0) {
660         LOGE("generateSymKey failed!");
661         goto CLEAR_UP;
662     }
663 
664     ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
665     if (ret != 0) {
666         LOGE("HcfCipherCreate failed!");
667         goto CLEAR_UP;
668     }
669 
670     ret = cipher->init(reinterpret_cast<HcfCipher *>(generator), ENCRYPT_MODE, &(key->key), nullptr);
671     if (ret != 0) {
672         LOGE("init failed! Should input key when init.");
673     }
674 
675 CLEAR_UP:
676     HcfObjDestroy(key);
677     HcfObjDestroy(cipher);
678     HcfObjDestroy(generator);
679     EXPECT_NE(ret, 0);
680 }
681 
682 HWTEST_F(CryptoSM4EcbCipherTest, CryptoSm4CipherTest054, TestSize.Level0)
683 {
684     int ret = 0;
685     HcfCipher *cipher = nullptr;
686     HcfSymKey *key = nullptr;
687     uint8_t plainText[] = "this is test!";
688     HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN };
689 
690     ret = GenerateSymKeyForSm4("SM4_128", &key);
691     if (ret != 0) {
692         LOGE("generateSymKey failed!");
693         goto CLEAR_UP;
694     }
695 
696     ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
697     if (ret != 0) {
698         LOGE("HcfCipherCreate failed!");
699         goto CLEAR_UP;
700     }
701 
702     ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr);
703     if (ret != 0) {
704         LOGE("init failed!");
705         goto CLEAR_UP;
706     }
707 
708     ret = cipher->doFinal(cipher, &input, nullptr);
709     if (ret != 0) {
710         LOGE("update failed! Blob data should not be nullptr.");
711     }
712 
713 CLEAR_UP:
714     HcfObjDestroy(key);
715     HcfObjDestroy(cipher);
716     EXPECT_NE(ret, 0);
717 }
718 
719 HWTEST_F(CryptoSM4EcbCipherTest, CryptoSm4CipherTest058, TestSize.Level0)
720 {
721     int ret = 0;
722     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
723     int cipherTextLen = CIPHER_TEXT_LEN;
724     HcfCipher *cipher = nullptr;
725     HcfSymKey *key = nullptr;
726 
727     ret = GenerateSymKeyForSm4("SM4_128", &key);
728     if (ret != 0) {
729         LOGE("GenerateSymKeyForSm4 failed!");
730         goto CLEAR_UP;
731     }
732 
733     // allow input with more than one padding mode. It will pick the last PKCS5.
734     ret = HcfCipherCreate("SM4_128|ECB|NoPadding|PKCS5", &cipher);
735     if (ret != 0) {
736         LOGE("HcfCipherCreate failed!");
737         goto CLEAR_UP;
738     }
739 
740     ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
741     if (ret != 0) {
742         LOGE("AesEncrypt failed! %d", ret);
743         goto CLEAR_UP;
744     }
745 
746     ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen);
747     if (ret != 0) {
748         LOGE("AesDecrypt failed! %d", ret);
749     }
750 CLEAR_UP:
751     HcfObjDestroy(key);
752     HcfObjDestroy(cipher);
753     EXPECT_EQ(ret, 0);
754 }
755 
756 HWTEST_F(CryptoSM4EcbCipherTest, CryptoSm4CipherTest059, TestSize.Level0)
757 {
758     int ret = 0;
759     HcfSymKeyGenerator *generator = nullptr;
760     HcfSymKey *key = nullptr;
761     HcfCipher *cipher = nullptr;
762 
763     ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
764     if (ret != 0) {
765         LOGE("HcfCipherCreate failed!");
766         goto CLEAR_UP;
767     }
768     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
769     if (ret != 0) {
770         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
771         goto CLEAR_UP;
772     }
773     ret = generator->generateSymKey(reinterpret_cast<HcfSymKeyGenerator *>(cipher), &key);
774     if (ret != 0) {
775         LOGE("generateSymKey failed!");
776     }
777 
778 CLEAR_UP:
779     HcfObjDestroy(key);
780     HcfObjDestroy(generator);
781     HcfObjDestroy(cipher);
782     EXPECT_NE(ret, 0);
783 }
784 
785 HWTEST_F(CryptoSM4EcbCipherTest, CryptoSm4CipherTest061, TestSize.Level0)
786 {
787     int ret = 0;
788     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
789     int cipherTextLen = CIPHER_TEXT_LEN;
790     HcfCipher *cipher = nullptr;
791     HcfSymKey *key = nullptr;
792 
793     ret = GenerateSymKeyForSm4("AES256", &key);
794     if (ret != 0) {
795         LOGE("GenerateSymKeyForSm4 failed!");
796         goto CLEAR_UP;
797     }
798 
799     ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
800     if (ret != 0) {
801         LOGE("HcfCipherCreate failed!");
802         goto CLEAR_UP;
803     }
804 
805     // It is not allowed that AES128 in key is smaller AES256 in cipher. -> now only use the size of input key.
806     ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
807     if (ret != 0) {
808         LOGE("AesEncrypt failed! %d", ret);
809         goto CLEAR_UP;
810     }
811 
812     ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen);
813     if (ret != 0) {
814         LOGE("AesDecrypt failed! %d", ret);
815     }
816 
817 CLEAR_UP:
818     HcfObjDestroy(key);
819     HcfObjDestroy(cipher);
820     EXPECT_NE(ret, 0);
821 }
822 }