1 /*
2  * Copyright (C) 2023 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 "sym_common_defines.h"
21 #include "sym_key_generator.h"
22 #include "cipher.h"
23 #include "blob.h"
24 #include "log.h"
25 #include "memory.h"
26 #include "detailed_iv_params.h"
27 #include "detailed_gcm_params.h"
28 #include "detailed_ccm_params.h"
29 #include "aes_openssl.h"
30 
31 using namespace std;
32 using namespace testing::ext;
33 
34 namespace {
35 constexpr int32_t KEY_MATERIAL_LEN = 16;
36 
37 class CryptoSM4GeneratorTest : public testing::Test {
38 public:
39     static void SetUpTestCase();
40     static void TearDownTestCase();
41     void SetUp();
42     void TearDown();
43 };
44 
SetUpTestCase()45 void CryptoSM4GeneratorTest::SetUpTestCase() {}
TearDownTestCase()46 void CryptoSM4GeneratorTest::TearDownTestCase() {}
47 
SetUp()48 void CryptoSM4GeneratorTest::SetUp() // add init here, this will be called before test.
49 {
50 }
51 
TearDown()52 void CryptoSM4GeneratorTest::TearDown() // add destroy here, this will be called when test case done.
53 {
54 }
55 
GenerateSymKey(const char * algoName,HcfSymKey ** key)56 static int32_t GenerateSymKey(const char *algoName, HcfSymKey **key)
57 {
58     HcfSymKeyGenerator *generator = nullptr;
59 
60     int32_t ret = HcfSymKeyGeneratorCreate(algoName, &generator);
61     if (ret != 0) {
62         LOGE("HcfSymKeyGeneratorCreate failed!");
63         return ret;
64     }
65 
66     ret = generator->generateSymKey(generator, key);
67     if (ret != 0) {
68         LOGE("generateSymKey failed!");
69     }
70     HcfObjDestroy((HcfObjectBase *)generator);
71     return ret;
72 }
73 
74 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest001, TestSize.Level0)
75 {
76     int ret = 0;
77     HcfSymKeyGenerator *generator = nullptr;
78     HcfSymKey *key = nullptr;
79     const char *inputAlgoName = "SM4_128";
80     const char *generatorAlgoName = nullptr;
81 
82     ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator);
83     if (ret != 0) {
84         LOGE("HcfSymKeyGeneratorCreate failed!");
85         goto CLEAR_UP;
86     }
87     ret = generator->generateSymKey(generator, &key);
88     if (ret != 0) {
89         LOGE("generateSymKey failed!");
90         goto CLEAR_UP;
91     }
92 
93     // generator getAlgoName
94     generatorAlgoName = generator->getAlgoName(generator);
95     if (generatorAlgoName == nullptr) {
96         LOGE("generator getAlgoName returns nullptr.");
97         ret = HCF_ERR_CRYPTO_OPERATION;
98         goto CLEAR_UP;
99     }
100 
101     ret = strcmp(generatorAlgoName, inputAlgoName);
102     if (ret != 0) {
103         LOGE("generator getAlgoName failed!");
104     }
105 CLEAR_UP:
106     HcfObjDestroy(key);
107     HcfObjDestroy(generator);
108     EXPECT_EQ(ret, 0);
109 }
110 
111 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest002, TestSize.Level0)
112 {
113     int ret = 0;
114     HcfSymKeyGenerator *generator = nullptr;
115     const char *generatorAlgoName = nullptr;
116     const char *inputAlgoName = "SM4_128";
117 
118     ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator);
119     if (ret != 0) {
120         LOGE("HcfSymKeyGeneratorCreate failed!");
121         goto CLEAR_UP;
122     }
123 
124     // generator getAlgoName
125     generatorAlgoName = generator->getAlgoName(nullptr);
126     if (generatorAlgoName == nullptr) {
127         LOGE("generator getAlgoName failed!");
128         ret = HCF_ERR_CRYPTO_OPERATION;
129     }
130 
131 CLEAR_UP:
132     HcfObjDestroy(generator);
133     EXPECT_NE(ret, 0);
134 }
135 
136 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest003, TestSize.Level0)
137 {
138     int ret = 0;
139     HcfSymKeyGenerator *generator = nullptr;
140     HcfSymKey *key = nullptr;
141     const char *generatorAlgoName = nullptr;
142     const char *inputAlgoName = "SM4_128";
143 
144     ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator);
145     if (ret != 0) {
146         LOGE("HcfSymKeyGeneratorCreate failed!");
147         goto CLEAR_UP;
148     }
149     ret = generator->generateSymKey(generator, &key);
150     if (ret != 0) {
151         LOGE("generateSymKey failed!");
152         goto CLEAR_UP;
153     }
154 
155     // generator getAlgoName
156     generatorAlgoName = generator->getAlgoName(reinterpret_cast<HcfSymKeyGenerator *>(key));
157     if (generatorAlgoName == nullptr) {
158         LOGE("generator getAlgoName failed!");
159         ret = HCF_ERR_CRYPTO_OPERATION;
160     }
161 
162 CLEAR_UP:
163     HcfObjDestroy(key);
164     HcfObjDestroy(generator);
165     EXPECT_NE(ret, 0);
166 }
167 
168 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest004, TestSize.Level0)
169 {
170     int ret = 0;
171     HcfSymKey *key = nullptr;
172     const char *inputAlgoName = "SM4_128";
173     const char *keyAlgoName = nullptr;
174 
175     ret = GenerateSymKey(inputAlgoName, &key);
176     if (ret != 0) {
177         LOGE("GenerateSymKey failed!");
178         goto CLEAR_UP;
179     }
180 
181     // key getAlgorithm
182     keyAlgoName = key->key.getAlgorithm(nullptr);
183     if (keyAlgoName == nullptr) {
184         LOGE("key getAlgorithm returns nullptr.");
185         ret = HCF_ERR_CRYPTO_OPERATION;
186     }
187 
188 CLEAR_UP:
189     HcfObjDestroy(key);
190     EXPECT_NE(ret, 0);
191 }
192 
193 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest005, TestSize.Level0)
194 {
195     int ret = 0;
196     HcfSymKeyGenerator *generator = nullptr;
197     HcfSymKey *key = nullptr;
198     const char *inputAlgoName = "SM4_128";
199     const char *keyAlgoName = nullptr;
200 
201     ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator);
202     if (ret != 0) {
203         LOGE("HcfSymKeyGeneratorCreate failed!");
204         goto CLEAR_UP;
205     }
206     ret = generator->generateSymKey(generator, &key);
207     if (ret != 0) {
208         LOGE("generateSymKey failed!");
209         goto CLEAR_UP;
210     }
211 
212     // key getAlgorithm
213     keyAlgoName = key->key.getAlgorithm(reinterpret_cast<HcfKey *>(generator));
214     if (keyAlgoName == nullptr) {
215         LOGE("key getAlgorithm returns nullptr.");
216         ret = HCF_ERR_CRYPTO_OPERATION;
217     }
218 
219 CLEAR_UP:
220     HcfObjDestroy(key);
221     HcfObjDestroy(generator);
222     EXPECT_NE(ret, 0);
223 }
224 
225 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest006, TestSize.Level0)
226 {
227     int ret = 0;
228     HcfSymKey *key = nullptr;
229     const char *retFormat = nullptr;
230 
231     ret = GenerateSymKey("SM4_128", &key);
232     if (ret != 0) {
233         LOGE("GenerateSymKey failed!");
234         goto CLEAR_UP;
235     }
236 
237     // key getFormat
238     retFormat = key->key.getFormat(nullptr);
239     if (retFormat == nullptr) {
240         LOGE("key GetFormat returns nullptr.");
241         ret = HCF_ERR_CRYPTO_OPERATION;
242     }
243 
244 CLEAR_UP:
245     HcfObjDestroy(key);
246     EXPECT_NE(ret, 0);
247 }
248 
249 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest007, TestSize.Level0)
250 {
251     int ret = 0;
252     HcfSymKeyGenerator *generator = nullptr;
253     HcfSymKey *key = nullptr;
254     const char *retFormat = nullptr;
255 
256     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
257     if (ret != 0) {
258         LOGE("HcfSymKeyGeneratorCreate failed!");
259         goto CLEAR_UP;
260     }
261     ret = generator->generateSymKey(generator, &key);
262     if (ret != 0) {
263         LOGE("generateSymKey failed!");
264         goto CLEAR_UP;
265     }
266 
267     // key getFormat
268     retFormat = key->key.getFormat(reinterpret_cast<HcfKey *>(generator));
269     if (retFormat == nullptr) {
270         LOGE("key GetFormat returns nullptr.");
271         ret = HCF_ERR_CRYPTO_OPERATION;
272     }
273 
274 CLEAR_UP:
275     HcfObjDestroy(key);
276     HcfObjDestroy(generator);
277     EXPECT_NE(ret, 0);
278 }
279 
280 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest008, TestSize.Level0)
281 {
282     int ret = 0;
283     HcfSymKeyGenerator *generator = nullptr;
284     HcfSymKey *key = nullptr;
285     HcfBlob encodedBlob = { 0 };
286     uint8_t keyMaterial[] = {
287         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
288         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
289     };
290     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
291 
292     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
293     if (ret != 0) {
294         LOGE("HcfSymKeyGeneratorCreate failed!");
295         goto CLEAR_UP;
296     }
297     ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
298     if (ret != 0) {
299         LOGE("generateSymKey failed!");
300         goto CLEAR_UP;
301     }
302 
303     // key getEncoded
304     ret = key->key.getEncoded(nullptr, &encodedBlob);
305     if (ret != 0) {
306         LOGE("key GetEncoded failed.");
307     }
308 
309 CLEAR_UP:
310     HcfObjDestroy(key);
311     HcfObjDestroy(generator);
312     if (encodedBlob.data != nullptr) {
313         HcfFree(encodedBlob.data);
314         encodedBlob.data = nullptr;
315     }
316     EXPECT_NE(ret, 0);
317 }
318 
319 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest009, TestSize.Level0)
320 {
321     int ret = 0;
322     HcfSymKeyGenerator *generator = nullptr;
323     HcfSymKey *key = nullptr;
324     HcfBlob encodedBlob = { 0 };
325     uint8_t keyMaterial[] = {
326         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
327         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
328     };
329     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
330 
331     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
332     if (ret != 0) {
333         LOGE("HcfSymKeyGeneratorCreate failed!");
334         goto CLEAR_UP;
335     }
336     ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
337     if (ret != 0) {
338         LOGE("generateSymKey failed!");
339         goto CLEAR_UP;
340     }
341 
342     // key getEncoded
343     ret = key->key.getEncoded(reinterpret_cast<HcfKey *>(generator), &encodedBlob);
344     if (ret != 0) {
345         LOGE("key GetEncoded failed.");
346     }
347 
348 CLEAR_UP:
349     HcfObjDestroy(key);
350     HcfObjDestroy(generator);
351     if (encodedBlob.data != nullptr) {
352         HcfFree(encodedBlob.data);
353         encodedBlob.data = nullptr;
354     }
355     EXPECT_NE(ret, 0);
356 }
357 
358 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest010, TestSize.Level0)
359 {
360     int ret = 0;
361     HcfSymKeyGenerator *generator = nullptr;
362     HcfSymKey *key = nullptr;
363     HcfBlob encodedBlob = { 0 };
364     uint8_t keyMaterial[] = {
365         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
366         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
367     };
368     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
369     SymKeyImpl *impl = nullptr;
370     size_t tmpLen = 0;
371 
372     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
373     if (ret != 0) {
374         LOGE("HcfSymKeyGeneratorCreate failed!");
375         goto CLEAR_UP;
376     }
377     ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
378     if (ret != 0) {
379         LOGE("generateSymKey failed!");
380         goto CLEAR_UP;
381     }
382     impl = reinterpret_cast<SymKeyImpl *>(key);
383     tmpLen = impl->keyMaterial.len;
384     impl->keyMaterial.len = 0;
385 
386     // key getEncoded
387     ret = key->key.getEncoded(&(key->key), &encodedBlob);
388     impl->keyMaterial.len = tmpLen;
389     if (ret != 0) {
390         LOGE("key GetEncoded failed.");
391     }
392 
393 CLEAR_UP:
394     HcfObjDestroy(key);
395     HcfObjDestroy(generator);
396     if (encodedBlob.data != nullptr) {
397         HcfFree(encodedBlob.data);
398         encodedBlob.data = nullptr;
399     }
400     EXPECT_NE(ret, 0);
401 }
402 
403 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest011, TestSize.Level0)
404 {
405     int ret = 0;
406     HcfSymKeyGenerator *generator = nullptr;
407     HcfSymKey *key = nullptr;
408     HcfBlob encodedBlob = { 0 };
409     uint8_t keyMaterial[] = {
410         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
411         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
412     };
413     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
414 
415     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
416     if (ret != 0) {
417         LOGE("HcfSymKeyGeneratorCreate failed!");
418         goto CLEAR_UP;
419     }
420     ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
421     if (ret != 0) {
422         LOGE("generateSymKey failed!");
423         goto CLEAR_UP;
424     }
425 
426     key->clearMem(nullptr);
427 
428     ret = key->key.getEncoded(&(key->key), &encodedBlob);
429     if (ret != 0) {
430         LOGE("key GetEncoded failed.");
431         goto CLEAR_UP;
432     }
433     if ((encodedBlob.data != nullptr) && (encodedBlob.data[0] != '\0')) {
434         LOGE("clearMem failed!");
435         ret = HCF_ERR_CRYPTO_OPERATION;
436     }
437 
438 CLEAR_UP:
439     HcfObjDestroy(key);
440     HcfObjDestroy(generator);
441     if (encodedBlob.data != nullptr) {
442         HcfFree(encodedBlob.data);
443         encodedBlob.data = nullptr;
444     }
445     EXPECT_NE(ret, 0);
446 }
447 
448 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest012, TestSize.Level0)
449 {
450     int ret = 0;
451     HcfSymKeyGenerator *generator = nullptr;
452 
453     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
454     if (ret != 0) {
455         LOGE("HcfSymKeyGeneratorCreate failed! Should not select RSA for symKey generator.");
456     }
457 
458     HcfObjDestroy(generator);
459     EXPECT_EQ(ret, 0);
460 }
461 
462 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest013, TestSize.Level0)
463 {
464     int ret = 0;
465     HcfSymKeyGenerator *generator = nullptr;
466 
467     ret = HcfSymKeyGeneratorCreate("", &generator);
468     if (ret != 0) {
469         LOGE("HcfSymKeyGeneratorCreate failed! Should not select empty string for symKey generator.");
470     }
471 
472     HcfObjDestroy(generator);
473     EXPECT_NE(ret, 0);
474 }
475 
476 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest014, TestSize.Level0)
477 {
478     int ret = 0;
479     HcfSymKeyGenerator *generator = nullptr;
480 
481     ret = HcfSymKeyGeneratorCreate(nullptr, &generator);
482     if (ret != 0) {
483         LOGE("HcfSymKeyGeneratorCreate failed! Should not select nullptr for symKey generator.");
484     }
485 
486     HcfObjDestroy(generator);
487     EXPECT_NE(ret, 0);
488 }
489 
490 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest015, TestSize.Level0)
491 {
492     int ret = 0;
493     HcfSymKeyGenerator *generator = nullptr;
494 
495     ret = HcfSymKeyGeneratorSpiCreate(nullptr, nullptr);
496     if (ret != 0) {
497         LOGE("HcfSymKeyGeneratorSpiCreate failed!");
498     }
499 
500     HcfObjDestroy(generator);
501     EXPECT_NE(ret, 0);
502 }
503 
504 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest016, TestSize.Level0)
505 {
506     int ret = 0;
507     HcfSymKeyGenerator *generator = nullptr;
508     HcfSymKey *key = nullptr;
509 
510     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
511     if (ret != 0) {
512         LOGE("HcfSymKeyGeneratorCreate failed!");
513         goto CLEAR_UP;
514     }
515     ret = generator->generateSymKey(nullptr, &key);
516     if (ret != 0) {
517         LOGE("generateSymKey failed!");
518     }
519 
520 CLEAR_UP:
521     HcfObjDestroy(key);
522     HcfObjDestroy(generator);
523     EXPECT_NE(ret, 0);
524 }
525 
526 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest017, TestSize.Level0)
527 {
528     int ret = 0;
529     HcfSymKeyGenerator *generator = nullptr;
530     HcfSymKey *key = nullptr;
531     HcfCipher *cipher = nullptr;
532 
533     ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
534     if (ret != 0) {
535         LOGE("HcfCipherCreate failed!");
536         goto CLEAR_UP;
537     }
538     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
539     if (ret != 0) {
540         LOGE("HcfSymKeyGeneratorCreate failed!");
541         goto CLEAR_UP;
542     }
543     ret = generator->generateSymKey(reinterpret_cast<HcfSymKeyGenerator *>(cipher), &key);
544     if (ret != 0) {
545         LOGE("generateSymKey failed!");
546     }
547 
548 CLEAR_UP:
549     HcfObjDestroy(key);
550     HcfObjDestroy(generator);
551     HcfObjDestroy(cipher);
552     EXPECT_NE(ret, 0);
553 }
554 
555 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest018, TestSize.Level0)
556 {
557     int ret = 0;
558     HcfSymKeyGenerator *generator = nullptr;
559     HcfSymKey *key = nullptr;
560     uint8_t keyMaterial[] = {
561         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
562         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
563     };
564     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
565 
566     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
567     if (ret != 0) {
568         LOGE("HcfSymKeyGeneratorCreate failed!");
569         goto CLEAR_UP;
570     }
571 
572     ret = generator->convertSymKey(nullptr, &keyTmpBlob, &key);
573     if (ret != 0) {
574         LOGE("generateSymKey failed!");
575     }
576 
577 CLEAR_UP:
578     HcfObjDestroy(key);
579     HcfObjDestroy(generator);
580     EXPECT_NE(ret, 0);
581 }
582 
583 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest019, TestSize.Level0)
584 {
585     int ret = 0;
586     HcfSymKeyGenerator *generator = nullptr;
587     HcfSymKey *key = nullptr;
588     uint8_t keyMaterial[] = {
589         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
590         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
591     };
592     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
593     HcfCipher *cipher = nullptr;
594 
595     ret = HcfCipherCreate("SM4_128|ECB|PKCS5", &cipher);
596     if (ret != 0) {
597         LOGE("HcfCipherCreate failed!");
598         goto CLEAR_UP;
599     }
600     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
601     if (ret != 0) {
602         LOGE("HcfSymKeyGeneratorCreate failed!");
603         goto CLEAR_UP;
604     }
605 
606     ret = generator->convertSymKey(reinterpret_cast<HcfSymKeyGenerator *>(cipher), &keyTmpBlob, &key);
607     if (ret != 0) {
608         LOGE("generateSymKey failed!");
609     }
610 
611 CLEAR_UP:
612     HcfObjDestroy(key);
613     HcfObjDestroy(generator);
614     HcfObjDestroy(cipher);
615     EXPECT_NE(ret, 0);
616 }
617 
618 HWTEST_F(CryptoSM4GeneratorTest, CryptoSm4GeneratorTest020, TestSize.Level0)
619 {
620     int ret = 0;
621     HcfSymKeyGenerator *generator = nullptr;
622     HcfSymKey *key = nullptr;
623     uint8_t keyMaterial[] = {
624         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
625         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
626     };
627     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = 0 };
628 
629     ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
630     if (ret != 0) {
631         LOGE("HcfSymKeyGeneratorCreate failed!");
632         goto CLEAR_UP;
633     }
634 
635     ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
636     if (ret != 0) {
637         LOGE("generateSymKey failed!");
638     }
639 
640 CLEAR_UP:
641     HcfObjDestroy(key);
642     HcfObjDestroy(generator);
643     EXPECT_NE(ret, 0);
644 }
645 }