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 CryptoAesCipherTest : 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(CryptoAesCipherTest, CryptoAesCipherTest001, TestSize.Level0)
46 {
47     int ret = 0;
48     HcfSymKeyGenerator *generator = nullptr;
49     HcfSymKey *key = nullptr;
50     const char *inputAlgoName = "AES128";
51     const char *generatorAlgoName = nullptr;
52 
53     ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator);
54     if (ret != 0) {
55         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
56         goto CLEAR_UP;
57     }
58     ret = generator->generateSymKey(generator, &key);
59     if (ret != 0) {
60         LOGE("generateSymKey failed!");
61         goto CLEAR_UP;
62     }
63 
64     // generator getAlgoName
65     generatorAlgoName = generator->getAlgoName(generator);
66     if (generatorAlgoName == nullptr) {
67         LOGE("generator getAlgoName returns nullptr.");
68         ret = HCF_ERR_CRYPTO_OPERATION;
69         goto CLEAR_UP;
70     }
71 
72     ret = strcmp(generatorAlgoName, inputAlgoName);
73     if (ret != 0) {
74         LOGE("generator getAlgoName failed!");
75     }
76 CLEAR_UP:
77     HcfObjDestroy(key);
78     HcfObjDestroy(generator);
79     EXPECT_EQ(ret, 0);
80 }
81 
82 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest002, TestSize.Level0)
83 {
84     int ret = 0;
85     HcfSymKeyGenerator *generator = nullptr;
86     const char *generatorAlgoName = nullptr;
87     const char *inputAlgoName = "AES128";
88 
89     ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator);
90     if (ret != 0) {
91         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
92         goto CLEAR_UP;
93     }
94 
95     // generator getAlgoName
96     generatorAlgoName = generator->getAlgoName(nullptr);
97     if (generatorAlgoName == nullptr) {
98         LOGE("generator getAlgoName failed!");
99         ret = HCF_ERR_CRYPTO_OPERATION;
100     }
101 
102 CLEAR_UP:
103     HcfObjDestroy(generator);
104     EXPECT_NE(ret, 0);
105 }
106 
107 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest003, TestSize.Level0)
108 {
109     int ret = 0;
110     HcfSymKeyGenerator *generator = nullptr;
111     HcfSymKey *key = nullptr;
112     const char *generatorAlgoName = nullptr;
113     const char *inputAlgoName = "AES128";
114 
115     ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator);
116     if (ret != 0) {
117         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
118         goto CLEAR_UP;
119     }
120     ret = generator->generateSymKey(generator, &key);
121     if (ret != 0) {
122         LOGE("generateSymKey failed!");
123         goto CLEAR_UP;
124     }
125 
126     // generator getAlgoName
127     generatorAlgoName = generator->getAlgoName(reinterpret_cast<HcfSymKeyGenerator *>(key));
128     if (generatorAlgoName == nullptr) {
129         LOGE("generator getAlgoName failed!");
130         ret = HCF_ERR_CRYPTO_OPERATION;
131     }
132 
133 CLEAR_UP:
134     HcfObjDestroy(key);
135     HcfObjDestroy(generator);
136     EXPECT_NE(ret, 0);
137 }
138 
139 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest004, TestSize.Level0)
140 {
141     int ret = 0;
142     HcfSymKey *key = nullptr;
143     const char *inputAlgoName = "AES128";
144     const char *keyAlgoName = nullptr;
145 
146     ret = GenerateSymKey(inputAlgoName, &key);
147     if (ret != 0) {
148         LOGE("GenerateSymKey failed!");
149         goto CLEAR_UP;
150     }
151 
152     // key getAlgorithm
153     keyAlgoName = key->key.getAlgorithm(&(key->key));
154     if (keyAlgoName == nullptr) {
155         LOGE("key getAlgorithm returns nullptr.");
156         ret = HCF_ERR_CRYPTO_OPERATION;
157         goto CLEAR_UP;
158     }
159 
160     ret = strcmp(keyAlgoName, inputAlgoName);
161     if (ret != 0) {
162         LOGE("key getAlgorithm failed!");
163     }
164 CLEAR_UP:
165     HcfObjDestroy(key);
166     EXPECT_EQ(ret, 0);
167 }
168 
169 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest005, TestSize.Level0)
170 {
171     int ret = 0;
172     HcfSymKey *key = nullptr;
173     const char *inputAlgoName = "AES128";
174     const char *keyAlgoName = nullptr;
175 
176     ret = GenerateSymKey(inputAlgoName, &key);
177     if (ret != 0) {
178         LOGE("GenerateSymKey failed!");
179         goto CLEAR_UP;
180     }
181 
182     // key getAlgorithm
183     keyAlgoName = key->key.getAlgorithm(nullptr);
184     if (keyAlgoName == nullptr) {
185         LOGE("key getAlgorithm returns nullptr.");
186         ret = HCF_ERR_CRYPTO_OPERATION;
187     }
188 
189 CLEAR_UP:
190     HcfObjDestroy(key);
191     EXPECT_NE(ret, 0);
192 }
193 
194 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest006, TestSize.Level0)
195 {
196     int ret = 0;
197     HcfSymKeyGenerator *generator = nullptr;
198     HcfSymKey *key = nullptr;
199     const char *inputAlgoName = "AES128";
200     const char *keyAlgoName = nullptr;
201 
202     ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator);
203     if (ret != 0) {
204         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
205         goto CLEAR_UP;
206     }
207     ret = generator->generateSymKey(generator, &key);
208     if (ret != 0) {
209         LOGE("generateSymKey failed!");
210         goto CLEAR_UP;
211     }
212 
213     // key getAlgorithm
214     keyAlgoName = key->key.getAlgorithm(reinterpret_cast<HcfKey *>(generator));
215     if (keyAlgoName == nullptr) {
216         LOGE("key getAlgorithm returns nullptr.");
217         ret = HCF_ERR_CRYPTO_OPERATION;
218     }
219 
220 CLEAR_UP:
221     HcfObjDestroy(key);
222     HcfObjDestroy(generator);
223     EXPECT_NE(ret, 0);
224 }
225 
226 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest007, TestSize.Level0)
227 {
228     int ret = 0;
229     HcfSymKey *key = nullptr;
230     const char *keyFormat = "PKCS#8";
231     const char *retFormat = nullptr;
232 
233     ret = GenerateSymKey("AES128", &key);
234     if (ret != 0) {
235         LOGE("GenerateSymKey failed!");
236         goto CLEAR_UP;
237     }
238 
239     // key GetFormat
240     retFormat = key->key.getFormat(&(key->key));
241     if (retFormat == nullptr) {
242         LOGE("key GetFormat returns nullptr.");
243         ret = HCF_ERR_CRYPTO_OPERATION;
244         goto CLEAR_UP;
245     }
246 
247     ret = strcmp(retFormat, keyFormat);
248     if (ret != 0) {
249         LOGE("key GetFormat failed!");
250     }
251 
252 CLEAR_UP:
253     HcfObjDestroy(key);
254     EXPECT_EQ(ret, 0);
255 }
256 
257 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest008, TestSize.Level0)
258 {
259     int ret = 0;
260     HcfSymKey *key = nullptr;
261     const char *retFormat = nullptr;
262 
263     ret = GenerateSymKey("AES128", &key);
264     if (ret != 0) {
265         LOGE("GenerateSymKey failed!");
266         goto CLEAR_UP;
267     }
268 
269     // key getFormat
270     retFormat = key->key.getFormat(nullptr);
271     if (retFormat == nullptr) {
272         LOGE("key GetFormat returns nullptr.");
273         ret = HCF_ERR_CRYPTO_OPERATION;
274     }
275 
276 CLEAR_UP:
277     HcfObjDestroy(key);
278     EXPECT_NE(ret, 0);
279 }
280 
281 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest009, TestSize.Level0)
282 {
283     int ret = 0;
284     HcfSymKeyGenerator *generator = nullptr;
285     HcfSymKey *key = nullptr;
286     const char *retFormat = nullptr;
287 
288     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
289     if (ret != 0) {
290         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
291         goto CLEAR_UP;
292     }
293     ret = generator->generateSymKey(generator, &key);
294     if (ret != 0) {
295         LOGE("generateSymKey failed!");
296         goto CLEAR_UP;
297     }
298 
299     // key getFormat
300     retFormat = key->key.getFormat(reinterpret_cast<HcfKey *>(generator));
301     if (retFormat == nullptr) {
302         LOGE("key GetFormat returns nullptr.");
303         ret = HCF_ERR_CRYPTO_OPERATION;
304     }
305 
306 CLEAR_UP:
307     HcfObjDestroy(key);
308     HcfObjDestroy(generator);
309     EXPECT_NE(ret, 0);
310 }
311 
312 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest010, TestSize.Level0)
313 {
314     int ret = 0;
315     HcfSymKeyGenerator *generator = nullptr;
316     HcfSymKey *key = nullptr;
317     HcfBlob encodedBlob = { 0 };
318     uint8_t keyMaterial[] = {
319         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
320         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
321     };
322     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
323 
324     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
325     if (ret != 0) {
326         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
327         goto CLEAR_UP;
328     }
329     ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
330     if (ret != 0) {
331         LOGE("generateSymKey failed!");
332         goto CLEAR_UP;
333     }
334 
335     // key getEncoded
336     ret = key->key.getEncoded(&(key->key), &encodedBlob);
337     if (ret != 0) {
338         LOGE("key GetEncoded failed.");
339         goto CLEAR_UP;
340     }
341 
342     if (encodedBlob.len != keyTmpBlob.len) {
343         LOGE("key GetEncoded failed!");
344         ret = HCF_ERR_CRYPTO_OPERATION;
345         goto CLEAR_UP;
346     }
347     ret = memcmp(encodedBlob.data, keyTmpBlob.data, keyTmpBlob.len);
348 
349 CLEAR_UP:
350     HcfObjDestroy(key);
351     HcfObjDestroy(generator);
352     if (encodedBlob.data != nullptr) {
353         HcfFree(encodedBlob.data);
354         encodedBlob.data = nullptr;
355     }
356     EXPECT_EQ(ret, 0);
357 }
358 
359 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest011, TestSize.Level0)
360 {
361     int ret = 0;
362     HcfSymKeyGenerator *generator = nullptr;
363     HcfSymKey *key = nullptr;
364     HcfBlob encodedBlob = { 0 };
365     uint8_t keyMaterial[] = {
366         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
367         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
368     };
369     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
370 
371     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
372     if (ret != 0) {
373         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
374         goto CLEAR_UP;
375     }
376     ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
377     if (ret != 0) {
378         LOGE("generateSymKey failed!");
379         goto CLEAR_UP;
380     }
381 
382     // key getEncoded
383     ret = key->key.getEncoded(nullptr, &encodedBlob);
384     if (ret != 0) {
385         LOGE("key GetEncoded failed.");
386     }
387 
388 CLEAR_UP:
389     HcfObjDestroy(key);
390     HcfObjDestroy(generator);
391     if (encodedBlob.data != nullptr) {
392         HcfFree(encodedBlob.data);
393         encodedBlob.data = nullptr;
394     }
395     EXPECT_NE(ret, 0);
396 }
397 
398 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest012, TestSize.Level0)
399 {
400     int ret = 0;
401     HcfSymKeyGenerator *generator = nullptr;
402     HcfSymKey *key = nullptr;
403     HcfBlob encodedBlob = { 0 };
404     uint8_t keyMaterial[] = {
405         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
406         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
407     };
408     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
409 
410     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
411     if (ret != 0) {
412         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
413         goto CLEAR_UP;
414     }
415     ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
416     if (ret != 0) {
417         LOGE("generateSymKey failed!");
418         goto CLEAR_UP;
419     }
420 
421     // key getEncoded
422     ret = key->key.getEncoded(reinterpret_cast<HcfKey *>(generator), &encodedBlob);
423     if (ret != 0) {
424         LOGE("key GetEncoded failed.");
425     }
426 
427 CLEAR_UP:
428     HcfObjDestroy(key);
429     HcfObjDestroy(generator);
430     if (encodedBlob.data != nullptr) {
431         HcfFree(encodedBlob.data);
432         encodedBlob.data = nullptr;
433     }
434     EXPECT_NE(ret, 0);
435 }
436 
437 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest013, TestSize.Level0)
438 {
439     int ret = 0;
440     HcfSymKeyGenerator *generator = nullptr;
441     HcfSymKey *key = nullptr;
442     HcfBlob encodedBlob = { 0 };
443     uint8_t keyMaterial[] = {
444         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
445         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
446     };
447     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
448     SymKeyImpl *impl = nullptr;
449     size_t tmpLen = 0;
450 
451     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
452     if (ret != 0) {
453         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
454         goto CLEAR_UP;
455     }
456     ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
457     if (ret != 0) {
458         LOGE("generateSymKey failed!");
459         goto CLEAR_UP;
460     }
461     impl = reinterpret_cast<SymKeyImpl *>(key);
462     tmpLen = impl->keyMaterial.len;
463     impl->keyMaterial.len = 0;
464 
465     // key getEncoded
466     ret = key->key.getEncoded(&(key->key), &encodedBlob);
467     impl->keyMaterial.len = tmpLen;
468     if (ret != 0) {
469         LOGE("key GetEncoded failed.");
470     }
471 
472 CLEAR_UP:
473     HcfObjDestroy(key);
474     HcfObjDestroy(generator);
475     if (encodedBlob.data != nullptr) {
476         HcfFree(encodedBlob.data);
477         encodedBlob.data = nullptr;
478     }
479     EXPECT_NE(ret, 0);
480 }
481 
482 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest014, TestSize.Level0)
483 {
484     int ret = 0;
485     HcfSymKeyGenerator *generator = nullptr;
486     HcfSymKey *key = nullptr;
487     HcfBlob encodedBlob = { 0 };
488     uint8_t keyMaterial[] = {
489         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
490         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
491     };
492     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
493 
494     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
495     if (ret != 0) {
496         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
497         goto CLEAR_UP;
498     }
499     ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
500     if (ret != 0) {
501         LOGE("generateSymKey failed!");
502         goto CLEAR_UP;
503     }
504 
505     key->clearMem(nullptr);
506 
507     ret = key->key.getEncoded(&(key->key), &encodedBlob);
508     if (ret != 0) {
509         LOGE("key GetEncoded failed.");
510         goto CLEAR_UP;
511     }
512     if ((encodedBlob.data != nullptr) && (encodedBlob.data[0] != '\0')) {
513         LOGE("clearMem failed!");
514         ret = HCF_ERR_CRYPTO_OPERATION;
515     }
516 
517 CLEAR_UP:
518     HcfObjDestroy(key);
519     HcfObjDestroy(generator);
520     if (encodedBlob.data != nullptr) {
521         HcfFree(encodedBlob.data);
522         encodedBlob.data = nullptr;
523     }
524     EXPECT_NE(ret, 0);
525 }
526 
527 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest015, TestSize.Level0)
528 {
529     int ret = 0;
530     HcfSymKeyGenerator *generator = nullptr;
531 
532     ret = HcfSymKeyGeneratorCreate("RSA128", &generator);
533     if (ret != 0) {
534         LOGE("HcfSymKeyGeneratorCreate failed! Should not select RSA for symKey generator.");
535     }
536 
537     HcfObjDestroy(generator);
538     EXPECT_NE(ret, 0);
539 }
540 
541 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest016, TestSize.Level0)
542 {
543     int ret = 0;
544     HcfSymKeyGenerator *generator = nullptr;
545 
546     ret = HcfSymKeyGeneratorCreate("RSA512", &generator);
547     if (ret != 0) {
548         LOGE("HcfSymKeyGeneratorCreate failed! Should not select RSA for symKey generator.");
549     }
550 
551     HcfObjDestroy(generator);
552     EXPECT_NE(ret, 0);
553 }
554 
555 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest017, TestSize.Level0)
556 {
557     int ret = 0;
558     HcfSymKeyGenerator *generator = nullptr;
559 
560     ret = HcfSymKeyGeneratorCreate("", &generator);
561     if (ret != 0) {
562         LOGE("HcfSymKeyGeneratorCreate failed! Should not select empty string for symKey generator.");
563     }
564 
565     HcfObjDestroy(generator);
566     EXPECT_NE(ret, 0);
567 }
568 
569 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest018, TestSize.Level0)
570 {
571     int ret = 0;
572     HcfSymKeyGenerator *generator = nullptr;
573 
574     ret = HcfSymKeyGeneratorCreate(nullptr, &generator);
575     if (ret != 0) {
576         LOGE("HcfSymKeyGeneratorCreate failed! Should not select nullptr for symKey generator.");
577     }
578 
579     HcfObjDestroy(generator);
580     EXPECT_NE(ret, 0);
581 }
582 
583 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest019, TestSize.Level0)
584 {
585     int ret = 0;
586     HcfSymKeyGenerator *generator = nullptr;
587 
588     ret = HcfSymKeyGeneratorSpiCreate(nullptr, nullptr);
589     if (ret != 0) {
590         LOGE("HcfSymKeyGeneratorSpiCreate failed!");
591     }
592 
593     HcfObjDestroy(generator);
594     EXPECT_NE(ret, 0);
595 }
596 
597 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest020, TestSize.Level0)
598 {
599     int ret = 0;
600     HcfSymKeyGenerator *generator = nullptr;
601     HcfSymKey *key = nullptr;
602 
603     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
604     if (ret != 0) {
605         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
606         goto CLEAR_UP;
607     }
608     ret = generator->generateSymKey(nullptr, &key);
609     if (ret != 0) {
610         LOGE("generateSymKey failed!");
611     }
612 
613 CLEAR_UP:
614     HcfObjDestroy(key);
615     HcfObjDestroy(generator);
616     EXPECT_NE(ret, 0);
617 }
618 
619 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest021, TestSize.Level0)
620 {
621     int ret = 0;
622     HcfSymKeyGenerator *generator = nullptr;
623     HcfSymKey *key = nullptr;
624     uint8_t keyMaterial[] = {
625         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
626         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
627     };
628     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
629 
630     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
631     if (ret != 0) {
632         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
633         goto CLEAR_UP;
634     }
635 
636     ret = generator->convertSymKey(nullptr, &keyTmpBlob, &key);
637     if (ret != 0) {
638         LOGE("generateSymKey failed!");
639     }
640 
641 CLEAR_UP:
642     HcfObjDestroy(key);
643     HcfObjDestroy(generator);
644     EXPECT_NE(ret, 0);
645 }
646 
647 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest022, TestSize.Level0)
648 {
649     int ret = 0;
650     HcfSymKeyGenerator *generator = nullptr;
651     HcfSymKey *key = nullptr;
652     uint8_t keyMaterial[] = {
653         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
654         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
655     };
656     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = 0 };
657 
658     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
659     if (ret != 0) {
660         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
661         goto CLEAR_UP;
662     }
663 
664     ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
665     if (ret != 0) {
666         LOGE("generateSymKey failed!");
667     }
668 
669 CLEAR_UP:
670     HcfObjDestroy(key);
671     HcfObjDestroy(generator);
672     EXPECT_NE(ret, 0);
673 }
674 
675 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest023, TestSize.Level0)
676 {
677     int ret = 0;
678     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
679     int cipherTextLen = CIPHER_TEXT_LEN;
680     HcfCipher *cipher = nullptr;
681     HcfSymKey *key = nullptr;
682 
683     ret = GenerateSymKey("AES128", &key);
684     if (ret != 0) {
685         LOGE("GenerateSymKey failed!");
686         goto CLEAR_UP;
687     }
688 
689     // allow input without encryption mode. It will pick the last PKCS5, and use default aes128ecb.
690     ret = HcfCipherCreate("AES128|NoPadding|PKCS5", &cipher);
691     if (ret != 0) {
692         LOGE("HcfCipherCreate failed!");
693         goto CLEAR_UP;
694     }
695 
696     ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
697     if (ret != 0) {
698         LOGE("AesEncrypt failed! %d", ret);
699         goto CLEAR_UP;
700     }
701 
702     ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
703     if (ret != 0) {
704         LOGE("AesDecrypt failed! %d", ret);
705     }
706 CLEAR_UP:
707     HcfObjDestroy(key);
708     HcfObjDestroy(cipher);
709     EXPECT_EQ(ret, 0);
710 }
711 
712 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest024, TestSize.Level0)
713 {
714     int ret = 0;
715     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
716     int cipherTextLen = CIPHER_TEXT_LEN;
717     HcfCipher *cipher = nullptr;
718     HcfSymKey *key = nullptr;
719 
720     ret = GenerateSymKey("AES128", &key);
721     if (ret != 0) {
722         LOGE("GenerateSymKey failed!");
723         goto CLEAR_UP;
724     }
725 
726     // allow input without encryption mode. It will use default aes128ecb.
727     ret = HcfCipherCreate("AES128|PKCS5", &cipher);
728     if (ret != 0) {
729         LOGE("HcfCipherCreate failed!");
730         goto CLEAR_UP;
731     }
732 
733     ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
734     if (ret != 0) {
735         LOGE("AesEncrypt failed! %d", ret);
736         goto CLEAR_UP;
737     }
738 
739     ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
740     if (ret != 0) {
741         LOGE("AesDecrypt failed! %d", ret);
742     }
743 CLEAR_UP:
744     HcfObjDestroy(key);
745     HcfObjDestroy(cipher);
746     EXPECT_EQ(ret, 0);
747 }
748 
749 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest025, TestSize.Level0)
750 {
751     int ret = 0;
752     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
753     int cipherTextLen = CIPHER_TEXT_LEN;
754     HcfCipher *cipher = nullptr;
755     HcfSymKey *key = nullptr;
756 
757     ret = GenerateSymKey("AES128", &key);
758     if (ret != 0) {
759         LOGE("GenerateSymKey failed!");
760         goto CLEAR_UP;
761     }
762 
763     // allow input without encryption mode. It will use default aes128ecb.
764     ret = HcfCipherCreate("AES128", &cipher);
765     if (ret != 0) {
766         LOGE("HcfCipherCreate failed!");
767         goto CLEAR_UP;
768     }
769 
770     ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
771     if (ret != 0) {
772         LOGE("AesEncrypt failed! %d", ret);
773         goto CLEAR_UP;
774     }
775 
776     ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
777     if (ret != 0) {
778         LOGE("AesDecrypt failed! %d", ret);
779     }
780 CLEAR_UP:
781     HcfObjDestroy(key);
782     HcfObjDestroy(cipher);
783     EXPECT_EQ(ret, 0);
784 }
785 
786 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest026, TestSize.Level0)
787 {
788     int ret = 0;
789     HcfCipher *cipher = nullptr;
790 
791     ret = HcfCipherCreate("", &cipher);
792     if (ret != 0) {
793         LOGE("HcfCipherCreate failed!");
794     }
795 
796     HcfObjDestroy(cipher);
797     EXPECT_NE(ret, 0);
798 }
799 
800 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest027, TestSize.Level0)
801 {
802     int ret = 0;
803     HcfCipher *cipher = nullptr;
804 
805     ret = HcfCipherCreate(nullptr, &cipher);
806     if (ret != 0) {
807         LOGE("HcfCipherCreate failed!");
808     }
809 
810     HcfObjDestroy(cipher);
811     EXPECT_NE(ret, 0);
812 }
813 
814 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest028, TestSize.Level0)
815 {
816     int ret = HcfCipherAesGeneratorSpiCreate(nullptr, nullptr);
817     if (ret != 0) {
818         LOGE("HcfCipherAesGeneratorSpiCreate failed!");
819     }
820     EXPECT_NE(ret, 0);
821 
822     HcfCipherGeneratorSpi *cipher = nullptr;
823     CipherAttr params = {
824         .algo = HCF_ALG_AES,
825         .mode = HCF_ALG_MODE_ECB,
826         .paddingMode = HCF_ALG_PADDING_PKCS5,
827     };
828     ret = HcfCipherAesGeneratorSpiCreate(&params, &cipher);
829     EXPECT_EQ(ret, HCF_SUCCESS);
830 
831     ret = cipher->init(nullptr, ENCRYPT_MODE, nullptr, nullptr);
832     EXPECT_EQ(ret, HCF_INVALID_PARAMS);
833 
834     ret = cipher->update(nullptr, nullptr, nullptr);
835     EXPECT_EQ(ret, HCF_INVALID_PARAMS);
836 
837     ret = cipher->doFinal(nullptr, nullptr, nullptr);
838     EXPECT_EQ(ret, HCF_INVALID_PARAMS);
839 
840     HcfBlob dataArray = { .data = nullptr, .len = 0 };
841     ret = cipher->getCipherSpecString(nullptr, OAEP_MGF1_MD_STR, nullptr);
842     EXPECT_EQ(ret, HCF_NOT_SUPPORT);
843 
844     ret = cipher->getCipherSpecUint8Array(nullptr, OAEP_MGF1_MD_STR, &dataArray);
845     EXPECT_EQ(ret, HCF_NOT_SUPPORT);
846 
847     HcfBlob dataUint8 = { .data = nullptr, .len = 0 };
848     ret = cipher->setCipherSpecUint8Array(nullptr, OAEP_MGF1_MD_STR, dataUint8);
849     EXPECT_EQ(ret, HCF_NOT_SUPPORT);
850 
851     (void)cipher->base.destroy(nullptr);
852 
853     HcfObjDestroy(cipher);
854     HcfBlobDataFree(&dataArray);
855 }
856 
857 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest029, TestSize.Level0)
858 {
859     int ret = 0;
860     HcfSymKeyGeneratorSpi *generator = nullptr;
861     HcfSymKey *key = nullptr;
862     SymKeyAttr attr = { .algo = HCF_ALG_AES, .keySize = AES_KEY_SIZE };
863 
864     ret = HcfSymKeyGeneratorSpiCreate(&attr, &generator);
865     if (ret != 0) {
866         LOGE("HcfSymKeyGeneratorSpiCreate failed!%d", ret);
867         goto CLEAR_UP;
868     }
869     ret = generator->engineGenerateSymmKey(nullptr, &key);
870     if (ret != 0) {
871         LOGE("engineGenerateSymmKey failed!");
872     }
873 
874 CLEAR_UP:
875     HcfObjDestroy(key);
876     HcfObjDestroy(generator);
877     EXPECT_NE(ret, 0);
878 }
879 
880 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest030, TestSize.Level0)
881 {
882     int ret = 0;
883     HcfSymKeyGeneratorSpi *generator = nullptr;
884     HcfSymKey *key = nullptr;
885     uint8_t keyMaterial[] = {
886         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
887         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
888     };
889     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
890     SymKeyAttr attr = { .algo = HCF_ALG_AES, .keySize = AES_KEY_SIZE };
891 
892     ret = HcfSymKeyGeneratorSpiCreate(&attr, &generator);
893     if (ret != 0) {
894         LOGE("HcfSymKeyGeneratorSpiCreate failed!%d", ret);
895         goto CLEAR_UP;
896     }
897     ret = generator->engineConvertSymmKey(nullptr, &keyTmpBlob, &key);
898     if (ret != 0) {
899         LOGE("engineConvertSymmKey failed!");
900     }
901 
902 CLEAR_UP:
903     HcfObjDestroy(key);
904     HcfObjDestroy(generator);
905     EXPECT_NE(ret, 0);
906 }
907 }