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 }