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 "securec.h"
18 
19 #include "asy_key_generator.h"
20 #include "sm2_asy_key_generator_openssl.h"
21 #include "blob.h"
22 #include "memory.h"
23 #include "memory_mock.h"
24 #include "openssl_adapter_mock.h"
25 #include "params_parser.h"
26 
27 using namespace std;
28 using namespace testing::ext;
29 
30 namespace {
31 class CryptoSm2AsyKeyGeneratorTest : public testing::Test {
32 public:
33     static void SetUpTestCase();
34     static void TearDownTestCase();
35     void SetUp();
36     void TearDown();
37 };
38 
SetUpTestCase()39 void CryptoSm2AsyKeyGeneratorTest::SetUpTestCase() {}
TearDownTestCase()40 void CryptoSm2AsyKeyGeneratorTest::TearDownTestCase() {}
SetUp()41 void CryptoSm2AsyKeyGeneratorTest::SetUp() {}
TearDown()42 void CryptoSm2AsyKeyGeneratorTest::TearDown() {}
43 
44 const int SM2256_PUB_KEY_LEN = 91;
45 const int SM2256_PRI_KEY_LEN = 51;
46 
47 uint8_t g_mockSm2256PubKeyBlobData[SM2256_PUB_KEY_LEN] = { 48, 89, 48, 19, 6, 7, 42, 134, 72, 206, 61, 2, 1,
48     6, 8, 42, 134, 72, 206, 61, 3, 1, 7, 3, 66, 0, 4, 65, 43, 59, 227, 32, 51, 44, 104, 47, 135, 97, 144, 91, 70,
49     231, 67, 2, 214, 197, 176, 161, 160, 227, 133, 158, 30, 118, 217, 243, 155, 88, 55, 214, 86, 86, 122, 166, 64,
50     111, 2, 226, 93, 163, 194, 210, 74, 18, 63, 173, 113, 249, 196, 126, 165, 222, 230, 190, 101, 241, 95, 102, 174,
51     252, 38 };
52 
53 uint8_t g_mockSm2256PriKeyBlobData[SM2256_PRI_KEY_LEN] = { 48, 49, 2, 1, 1, 4, 32, 223, 134, 255, 219, 45,
54     68, 72, 231, 43, 72, 243, 113, 255, 60, 232, 203, 151, 65, 80, 6, 36, 112, 247, 186, 106, 148, 43, 170, 204,
55     23, 189, 191, 160, 10, 6, 8, 42, 134, 72, 206, 61, 3, 1, 7 };
56 
57 HcfBlob g_mockSm2256PubKeyBlob = {
58     .data = g_mockSm2256PubKeyBlobData,
59     .len = SM2256_PUB_KEY_LEN
60 };
61 
62 HcfBlob g_mockSm2256PriKeyBlob = {
63     .data = g_mockSm2256PriKeyBlobData,
64     .len = SM2256_PRI_KEY_LEN
65 };
66 
GetMockClass(void)67 static const char *GetMockClass(void)
68 {
69     return "HcfSymKeyGenerator";
70 }
71 
72 HcfObjectBase g_obj = {
73     .getClass = GetMockClass,
74     .destroy = nullptr
75 };
76 
77 /**
78  * @tc.name: CryptoSm2AsyKeyGeneratorTest.CryptoSm2AsyKeyGeneratorTest001
79  * @tc.desc: Verify that the creation of the SM2_256 key pair generator is normal.
80  * @tc.type: FUNC
81  * @tc.require: I5QWEI
82  */
83 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest001, TestSize.Level0)
84 {
85     HcfAsyKeyGenerator *generator = nullptr;
86     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
87 
88     ASSERT_EQ(res, HCF_SUCCESS);
89     ASSERT_NE(generator, nullptr);
90 
91     HcfObjDestroy(generator);
92 }
93 
94 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest002, TestSize.Level0)
95 {
96     HcfAsyKeyGenerator *generator = nullptr;
97     int32_t res = HcfAsyKeyGeneratorCreate(nullptr, &generator);
98 
99     ASSERT_EQ(res, HCF_INVALID_PARAMS);
100     ASSERT_EQ(generator, nullptr);
101 }
102 
103 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest003, TestSize.Level0)
104 {
105     HcfAsyKeyGenerator *generator = nullptr;
106     int32_t res = HcfAsyKeyGeneratorCreate("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD"
107         "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", &generator);
108 
109     ASSERT_EQ(res, HCF_INVALID_PARAMS);
110     ASSERT_EQ(generator, nullptr);
111 }
112 
113 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest004, TestSize.Level0)
114 {
115     HcfAsyKeyGenerator *generator = nullptr;
116     int32_t res = HcfAsyKeyGeneratorCreate("SM2_257", &generator);
117 
118     ASSERT_EQ(res, HCF_INVALID_PARAMS);
119     ASSERT_EQ(generator, nullptr);
120 }
121 
122 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest005, TestSize.Level0)
123 {
124     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", nullptr);
125 
126     ASSERT_EQ(res, HCF_INVALID_PARAMS);
127 }
128 
129 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest006, TestSize.Level0)
130 {
131     HcfAsyKeyGenerator *generator = nullptr;
132     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
133 
134     ASSERT_EQ(res, HCF_SUCCESS);
135     ASSERT_NE(generator, nullptr);
136 
137     const char *className = generator->base.getClass();
138     ASSERT_NE(className, nullptr);
139 
140     HcfObjDestroy(generator);
141 }
142 
143 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest007, TestSize.Level0)
144 {
145     HcfAsyKeyGenerator *generator = nullptr;
146     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
147 
148     ASSERT_EQ(res, HCF_SUCCESS);
149     ASSERT_NE(generator, nullptr);
150 
151     generator->base.destroy((HcfObjectBase *)generator);
152 }
153 
154 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest008, TestSize.Level0)
155 {
156     HcfAsyKeyGenerator *generator = nullptr;
157     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
158 
159     ASSERT_EQ(res, HCF_SUCCESS);
160     ASSERT_NE(generator, nullptr);
161 
162     generator->base.destroy(nullptr);
163 
164     HcfObjDestroy(generator);
165 }
166 
167 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest009, TestSize.Level0)
168 {
169     HcfAsyKeyGenerator *generator = nullptr;
170     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
171 
172     ASSERT_EQ(res, HCF_SUCCESS);
173     ASSERT_NE(generator, nullptr);
174 
175     generator->base.destroy(&g_obj);
176 
177     HcfObjDestroy(generator);
178 }
179 
180 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest010, TestSize.Level0)
181 {
182     HcfAsyKeyGenerator *generator = nullptr;
183     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
184 
185     ASSERT_EQ(res, HCF_SUCCESS);
186     ASSERT_NE(generator, nullptr);
187 
188     const char *algName = generator->getAlgoName(generator);
189 
190     ASSERT_NE(algName, nullptr);
191 
192     HcfObjDestroy(generator);
193 }
194 
195 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest011, TestSize.Level0)
196 {
197     HcfAsyKeyGenerator *generator = nullptr;
198     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
199 
200     ASSERT_EQ(res, HCF_SUCCESS);
201     ASSERT_NE(generator, nullptr);
202 
203     const char *algName = generator->getAlgoName(nullptr);
204 
205     ASSERT_EQ(algName, nullptr);
206 
207     HcfObjDestroy(generator);
208 }
209 
210 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest012, TestSize.Level0)
211 {
212     HcfAsyKeyGenerator *generator = nullptr;
213     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
214 
215     ASSERT_EQ(res, HCF_SUCCESS);
216     ASSERT_NE(generator, nullptr);
217 
218     const char *algName = generator->getAlgoName((HcfAsyKeyGenerator *)&g_obj);
219 
220     ASSERT_EQ(algName, nullptr);
221 
222     HcfObjDestroy(generator);
223 }
224 
225 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest013, TestSize.Level0)
226 {
227     HcfAsyKeyGenerator *generator = nullptr;
228     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
229 
230     ASSERT_EQ(res, HCF_SUCCESS);
231     ASSERT_NE(generator, nullptr);
232 
233     HcfKeyPair *keyPair = nullptr;
234     res = generator->generateKeyPair(generator, nullptr, &keyPair);
235 
236     ASSERT_EQ(res, HCF_SUCCESS);
237     ASSERT_NE(keyPair, nullptr);
238 
239     HcfObjDestroy(keyPair);
240     HcfObjDestroy(generator);
241 }
242 
243 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest014, TestSize.Level0)
244 {
245     HcfAsyKeyGenerator *generator = nullptr;
246     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
247 
248     ASSERT_EQ(res, HCF_SUCCESS);
249     ASSERT_NE(generator, nullptr);
250 
251     HcfKeyPair *keyPair = nullptr;
252     res = generator->generateKeyPair(nullptr, nullptr, &keyPair);
253 
254     ASSERT_EQ(res, HCF_INVALID_PARAMS);
255     ASSERT_EQ(keyPair, nullptr);
256 
257     HcfObjDestroy(generator);
258 }
259 
260 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest015, TestSize.Level0)
261 {
262     HcfAsyKeyGenerator *generator = nullptr;
263     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
264 
265     ASSERT_EQ(res, HCF_SUCCESS);
266     ASSERT_NE(generator, nullptr);
267 
268     HcfKeyPair *keyPair = nullptr;
269     res = generator->generateKeyPair((HcfAsyKeyGenerator *)&g_obj, nullptr, &keyPair);
270 
271     ASSERT_EQ(res, HCF_INVALID_PARAMS);
272     ASSERT_EQ(keyPair, nullptr);
273 
274     HcfObjDestroy(generator);
275 }
276 
277 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest016, TestSize.Level0)
278 {
279     HcfAsyKeyGenerator *generator = nullptr;
280     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
281 
282     ASSERT_EQ(res, HCF_SUCCESS);
283     ASSERT_NE(generator, nullptr);
284 
285     res = generator->generateKeyPair(generator, nullptr, nullptr);
286 
287     ASSERT_EQ(res, HCF_INVALID_PARAMS);
288 
289     HcfObjDestroy(generator);
290 }
291 
292 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest017, TestSize.Level0)
293 {
294     HcfAsyKeyGenerator *generator = nullptr;
295     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
296 
297     HcfKeyPair *keyPair = nullptr;
298     res = generator->generateKeyPair(generator, nullptr, &keyPair);
299 
300     ASSERT_EQ(res, HCF_SUCCESS);
301     ASSERT_NE(keyPair, nullptr);
302 
303     const char *className = keyPair->base.getClass();
304 
305     ASSERT_NE(className, nullptr);
306 
307     HcfObjDestroy(keyPair);
308     HcfObjDestroy(generator);
309 }
310 
311 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest018, TestSize.Level0)
312 {
313     HcfAsyKeyGenerator *generator = nullptr;
314     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
315 
316     HcfKeyPair *keyPair = nullptr;
317     res = generator->generateKeyPair(generator, nullptr, &keyPair);
318 
319     ASSERT_EQ(res, HCF_SUCCESS);
320     ASSERT_NE(keyPair, nullptr);
321 
322     keyPair->base.destroy((HcfObjectBase *)(&(keyPair->base)));
323 
324     HcfObjDestroy(generator);
325 }
326 
327 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest019, TestSize.Level0)
328 {
329     HcfAsyKeyGenerator *generator = nullptr;
330     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
331 
332     HcfKeyPair *keyPair = nullptr;
333     res = generator->generateKeyPair(generator, nullptr, &keyPair);
334 
335     ASSERT_EQ(res, HCF_SUCCESS);
336     ASSERT_NE(keyPair, nullptr);
337 
338     keyPair->base.destroy(nullptr);
339 
340     HcfObjDestroy(keyPair);
341     HcfObjDestroy(generator);
342 }
343 
344 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest021, TestSize.Level0)
345 {
346     HcfAsyKeyGenerator *generator = nullptr;
347     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
348 
349     HcfKeyPair *keyPair = nullptr;
350     res = generator->generateKeyPair(generator, nullptr, &keyPair);
351 
352     ASSERT_EQ(res, HCF_SUCCESS);
353     ASSERT_NE(keyPair, nullptr);
354 
355     const char *className = keyPair->pubKey->base.base.getClass();
356     ASSERT_NE(className, nullptr);
357 
358     HcfObjDestroy(keyPair);
359     HcfObjDestroy(generator);
360 }
361 
362 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest022, TestSize.Level0)
363 {
364     HcfAsyKeyGenerator *generator = nullptr;
365     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
366 
367     HcfKeyPair *keyPair = nullptr;
368     res = generator->generateKeyPair(generator, nullptr, &keyPair);
369 
370     ASSERT_EQ(res, HCF_SUCCESS);
371     ASSERT_NE(keyPair, nullptr);
372 
373     keyPair->pubKey->base.base.destroy((HcfObjectBase *)(&(keyPair->pubKey->base.base)));
374     keyPair->pubKey = nullptr;
375 
376     HcfObjDestroy(keyPair);
377     HcfObjDestroy(generator);
378 }
379 
380 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest023, TestSize.Level0)
381 {
382     HcfAsyKeyGenerator *generator = nullptr;
383     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
384 
385     HcfKeyPair *keyPair = nullptr;
386     res = generator->generateKeyPair(generator, nullptr, &keyPair);
387 
388     ASSERT_EQ(res, HCF_SUCCESS);
389     ASSERT_NE(keyPair, nullptr);
390 
391     keyPair->pubKey->base.base.destroy(nullptr);
392 
393     HcfObjDestroy(keyPair);
394     HcfObjDestroy(generator);
395 }
396 
397 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest025, TestSize.Level0)
398 {
399     HcfAsyKeyGenerator *generator = nullptr;
400     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
401 
402     HcfKeyPair *keyPair = nullptr;
403     res = generator->generateKeyPair(generator, nullptr, &keyPair);
404 
405     ASSERT_EQ(res, HCF_SUCCESS);
406     ASSERT_NE(keyPair, nullptr);
407 
408     const char *format = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
409 
410     ASSERT_NE(format, nullptr);
411 
412     HcfObjDestroy(keyPair);
413     HcfObjDestroy(generator);
414 }
415 
416 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest026, TestSize.Level0)
417 {
418     HcfAsyKeyGenerator *generator = nullptr;
419     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
420 
421     HcfKeyPair *keyPair = nullptr;
422     res = generator->generateKeyPair(generator, nullptr, &keyPair);
423 
424     ASSERT_EQ(res, HCF_SUCCESS);
425     ASSERT_NE(keyPair, nullptr);
426 
427     const char *format = keyPair->pubKey->base.getFormat(nullptr);
428 
429     ASSERT_EQ(format, nullptr);
430 
431     HcfObjDestroy(keyPair);
432     HcfObjDestroy(generator);
433 }
434 
435 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest028, TestSize.Level0)
436 {
437     HcfAsyKeyGenerator *generator = nullptr;
438     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
439 
440     HcfKeyPair *keyPair = nullptr;
441     res = generator->generateKeyPair(generator, nullptr, &keyPair);
442 
443     ASSERT_EQ(res, HCF_SUCCESS);
444     ASSERT_NE(keyPair, nullptr);
445 
446     const char *algName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
447 
448     ASSERT_NE(algName, nullptr);
449 
450     HcfObjDestroy(keyPair);
451     HcfObjDestroy(generator);
452 }
453 
454 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest029, TestSize.Level0)
455 {
456     HcfAsyKeyGenerator *generator = nullptr;
457     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
458 
459     HcfKeyPair *keyPair = nullptr;
460     res = generator->generateKeyPair(generator, nullptr, &keyPair);
461 
462     ASSERT_EQ(res, HCF_SUCCESS);
463     ASSERT_NE(keyPair, nullptr);
464 
465     const char *algName = keyPair->pubKey->base.getAlgorithm(nullptr);
466 
467     ASSERT_EQ(algName, nullptr);
468 
469     HcfObjDestroy(keyPair);
470     HcfObjDestroy(generator);
471 }
472 
473 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest031, TestSize.Level0)
474 {
475     HcfAsyKeyGenerator *generator = nullptr;
476     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
477 
478     HcfKeyPair *keyPair = nullptr;
479     res = generator->generateKeyPair(generator, nullptr, &keyPair);
480 
481     ASSERT_EQ(res, HCF_SUCCESS);
482     ASSERT_NE(keyPair, nullptr);
483 
484     HcfBlob blob = { .data = nullptr, .len = 0 };
485     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
486 
487     ASSERT_EQ(res, HCF_SUCCESS);
488     ASSERT_NE(blob.data, nullptr);
489     ASSERT_NE(blob.len, 0);
490 
491     HcfFree(blob.data);
492 
493     HcfObjDestroy(keyPair);
494     HcfObjDestroy(generator);
495 }
496 
497 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest032, TestSize.Level0)
498 {
499     HcfAsyKeyGenerator *generator = nullptr;
500     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
501 
502     HcfKeyPair *keyPair = nullptr;
503     res = generator->generateKeyPair(generator, nullptr, &keyPair);
504 
505     ASSERT_EQ(res, HCF_SUCCESS);
506     ASSERT_NE(keyPair, nullptr);
507 
508     HcfBlob blob = { .data = nullptr, .len = 0 };
509     res = keyPair->pubKey->base.getEncoded(nullptr, &blob);
510 
511     ASSERT_NE(res, HCF_SUCCESS);
512     ASSERT_EQ(blob.data, nullptr);
513     ASSERT_EQ(blob.len, 0);
514 
515     HcfObjDestroy(keyPair);
516     HcfObjDestroy(generator);
517 }
518 
519 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest034, TestSize.Level0)
520 {
521     HcfAsyKeyGenerator *generator = nullptr;
522     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
523 
524     HcfKeyPair *keyPair = nullptr;
525     res = generator->generateKeyPair(generator, nullptr, &keyPair);
526 
527     ASSERT_EQ(res, HCF_SUCCESS);
528     ASSERT_NE(keyPair, nullptr);
529 
530     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), nullptr);
531 
532     ASSERT_NE(res, HCF_SUCCESS);
533 
534     HcfObjDestroy(keyPair);
535     HcfObjDestroy(generator);
536 }
537 
538 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest035, TestSize.Level0)
539 {
540     HcfAsyKeyGenerator *generator = nullptr;
541     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
542 
543     HcfKeyPair *keyPair = nullptr;
544     res = generator->generateKeyPair(generator, nullptr, &keyPair);
545 
546     ASSERT_EQ(res, HCF_SUCCESS);
547     ASSERT_NE(keyPair, nullptr);
548 
549     keyPair->priKey->clearMem(keyPair->priKey);
550 
551     HcfObjDestroy(keyPair);
552     HcfObjDestroy(generator);
553 }
554 
555 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest036, TestSize.Level0)
556 {
557     HcfAsyKeyGenerator *generator = nullptr;
558     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
559 
560     HcfKeyPair *keyPair = nullptr;
561     res = generator->generateKeyPair(generator, nullptr, &keyPair);
562 
563     ASSERT_EQ(res, HCF_SUCCESS);
564     ASSERT_NE(keyPair, nullptr);
565 
566     keyPair->priKey->clearMem(nullptr);
567 
568     HcfObjDestroy(keyPair);
569     HcfObjDestroy(generator);
570 }
571 
572 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest038, TestSize.Level0)
573 {
574     HcfAsyKeyGenerator *generator = nullptr;
575     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
576 
577     HcfKeyPair *keyPair = nullptr;
578     res = generator->generateKeyPair(generator, nullptr, &keyPair);
579 
580     ASSERT_EQ(res, HCF_SUCCESS);
581     ASSERT_NE(keyPair, nullptr);
582 
583     const char *algName = keyPair->priKey->base.base.getClass();
584 
585     ASSERT_NE(algName, nullptr);
586 
587     HcfObjDestroy(keyPair);
588     HcfObjDestroy(generator);
589 }
590 
591 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest039, TestSize.Level0)
592 {
593     HcfAsyKeyGenerator *generator = nullptr;
594     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
595 
596     HcfKeyPair *keyPair = nullptr;
597     res = generator->generateKeyPair(generator, nullptr, &keyPair);
598 
599     ASSERT_EQ(res, HCF_SUCCESS);
600     ASSERT_NE(keyPair, nullptr);
601 
602     keyPair->priKey->base.base.destroy((HcfObjectBase *)(&(keyPair->priKey->base.base)));
603     keyPair->priKey = nullptr;
604 
605     HcfObjDestroy(keyPair);
606     HcfObjDestroy(generator);
607 }
608 
609 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest040, TestSize.Level0)
610 {
611     HcfAsyKeyGenerator *generator = nullptr;
612     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
613 
614     HcfKeyPair *keyPair = nullptr;
615     res = generator->generateKeyPair(generator, nullptr, &keyPair);
616 
617     ASSERT_EQ(res, HCF_SUCCESS);
618     ASSERT_NE(keyPair, nullptr);
619 
620     keyPair->priKey->base.base.destroy(nullptr);
621 
622     HcfObjDestroy(keyPair);
623     HcfObjDestroy(generator);
624 }
625 
626 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest042, TestSize.Level0)
627 {
628     HcfAsyKeyGenerator *generator = nullptr;
629     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
630 
631     HcfKeyPair *keyPair = nullptr;
632     res = generator->generateKeyPair(generator, nullptr, &keyPair);
633 
634     ASSERT_EQ(res, HCF_SUCCESS);
635     ASSERT_NE(keyPair, nullptr);
636 
637     const char *format = keyPair->priKey->base.getFormat(&keyPair->priKey->base);
638 
639     ASSERT_NE(format, nullptr);
640 
641     HcfObjDestroy(keyPair);
642     HcfObjDestroy(generator);
643 }
644 
645 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest043, TestSize.Level0)
646 {
647     HcfAsyKeyGenerator *generator = nullptr;
648     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
649 
650     HcfKeyPair *keyPair = nullptr;
651     res = generator->generateKeyPair(generator, nullptr, &keyPair);
652 
653     ASSERT_EQ(res, HCF_SUCCESS);
654     ASSERT_NE(keyPair, nullptr);
655 
656     const char *format = keyPair->priKey->base.getFormat(nullptr);
657 
658     ASSERT_EQ(format, nullptr);
659 
660     HcfObjDestroy(keyPair);
661     HcfObjDestroy(generator);
662 }
663 
664 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest045, TestSize.Level0)
665 {
666     HcfAsyKeyGenerator *generator = nullptr;
667     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
668 
669     HcfKeyPair *keyPair = nullptr;
670     res = generator->generateKeyPair(generator, nullptr, &keyPair);
671 
672     ASSERT_EQ(res, HCF_SUCCESS);
673     ASSERT_NE(keyPair, nullptr);
674 
675     const char *algName = keyPair->priKey->base.getAlgorithm(&keyPair->priKey->base);
676 
677     ASSERT_NE(algName, nullptr);
678 
679     HcfObjDestroy(keyPair);
680     HcfObjDestroy(generator);
681 }
682 
683 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest046, TestSize.Level0)
684 {
685     HcfAsyKeyGenerator *generator = nullptr;
686     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
687 
688     HcfKeyPair *keyPair = nullptr;
689     res = generator->generateKeyPair(generator, nullptr, &keyPair);
690 
691     ASSERT_EQ(res, HCF_SUCCESS);
692     ASSERT_NE(keyPair, nullptr);
693 
694     const char *algName = keyPair->priKey->base.getAlgorithm(nullptr);
695 
696     ASSERT_EQ(algName, nullptr);
697 
698     HcfObjDestroy(keyPair);
699     HcfObjDestroy(generator);
700 }
701 
702 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest048, TestSize.Level0)
703 {
704     HcfAsyKeyGenerator *generator = nullptr;
705     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
706 
707     HcfKeyPair *keyPair = nullptr;
708     res = generator->generateKeyPair(generator, nullptr, &keyPair);
709 
710     ASSERT_EQ(res, HCF_SUCCESS);
711     ASSERT_NE(keyPair, nullptr);
712 
713     HcfBlob blob = { .data = nullptr, .len = 0 };
714     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
715 
716     ASSERT_EQ(res, HCF_SUCCESS);
717     ASSERT_NE(blob.data, nullptr);
718     ASSERT_NE(blob.len, 0);
719 
720     HcfFree(blob.data);
721 
722     HcfObjDestroy(keyPair);
723     HcfObjDestroy(generator);
724 }
725 
726 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest049, TestSize.Level0)
727 {
728     HcfAsyKeyGenerator *generator = nullptr;
729     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
730 
731     HcfKeyPair *keyPair = nullptr;
732     res = generator->generateKeyPair(generator, nullptr, &keyPair);
733 
734     ASSERT_EQ(res, HCF_SUCCESS);
735     ASSERT_NE(keyPair, nullptr);
736 
737     HcfBlob blob = { .data = nullptr, .len = 0 };
738     res = keyPair->priKey->base.getEncoded(nullptr, &blob);
739 
740     ASSERT_NE(res, HCF_SUCCESS);
741     ASSERT_EQ(blob.data, nullptr);
742     ASSERT_EQ(blob.len, 0);
743 
744     HcfObjDestroy(keyPair);
745     HcfObjDestroy(generator);
746 }
747 
748 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest051, TestSize.Level0)
749 {
750     HcfAsyKeyGenerator *generator = nullptr;
751     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
752 
753     HcfKeyPair *keyPair = nullptr;
754     res = generator->generateKeyPair(generator, nullptr, &keyPair);
755 
756     ASSERT_EQ(res, HCF_SUCCESS);
757     ASSERT_NE(keyPair, nullptr);
758 
759     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), nullptr);
760 
761     ASSERT_NE(res, HCF_SUCCESS);
762 
763     HcfObjDestroy(keyPair);
764     HcfObjDestroy(generator);
765 }
766 
767 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest052, TestSize.Level0)
768 {
769     HcfAsyKeyGenerator *generator = nullptr;
770     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
771 
772     HcfKeyPair *outKeyPair = nullptr;
773     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &outKeyPair);
774 
775     ASSERT_EQ(res, HCF_SUCCESS);
776     ASSERT_NE(outKeyPair, nullptr);
777 
778     HcfObjDestroy(outKeyPair);
779     HcfObjDestroy(generator);
780 }
781 
782 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest053, TestSize.Level0)
783 {
784     HcfAsyKeyGenerator *generator = nullptr;
785     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
786 
787     HcfKeyPair *outKeyPair = nullptr;
788     res = generator->convertKey(nullptr, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &outKeyPair);
789 
790     ASSERT_NE(res, HCF_SUCCESS);
791     ASSERT_EQ(outKeyPair, nullptr);
792 
793     HcfObjDestroy(generator);
794 }
795 
796 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest055, TestSize.Level0)
797 {
798     HcfAsyKeyGenerator *generator = nullptr;
799     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
800 
801     HcfKeyPair *outKeyPair = nullptr;
802     res = generator->convertKey(generator, nullptr, nullptr, &g_mockSm2256PriKeyBlob, &outKeyPair);
803 
804     ASSERT_EQ(res, HCF_SUCCESS);
805     ASSERT_NE(outKeyPair, nullptr);
806 
807     HcfObjDestroy(outKeyPair);
808     HcfObjDestroy(generator);
809 }
810 
811 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest056, TestSize.Level0)
812 {
813     HcfAsyKeyGenerator *generator = nullptr;
814     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
815 
816     HcfKeyPair *outKeyPair = nullptr;
817     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, nullptr, &outKeyPair);
818 
819     ASSERT_EQ(res, HCF_SUCCESS);
820     ASSERT_NE(outKeyPair, nullptr);
821 
822     HcfObjDestroy(outKeyPair);
823     HcfObjDestroy(generator);
824 }
825 
826 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest057, TestSize.Level0)
827 {
828     HcfAsyKeyGenerator *generator = nullptr;
829     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
830 
831     HcfKeyPair *outKeyPair = nullptr;
832     res = generator->convertKey(generator, nullptr, nullptr, nullptr, &outKeyPair);
833 
834     ASSERT_NE(res, HCF_SUCCESS);
835     ASSERT_EQ(outKeyPair, nullptr);
836 
837     HcfObjDestroy(generator);
838 }
839 
840 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest058, TestSize.Level0)
841 {
842     HcfAsyKeyGenerator *generator = nullptr;
843     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
844 
845     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, nullptr);
846 
847     ASSERT_NE(res, HCF_SUCCESS);
848 
849     HcfObjDestroy(generator);
850 }
851 
852 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest059, TestSize.Level0)
853 {
854     HcfAsyKeyGenerator *generator = nullptr;
855     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
856 
857     HcfKeyPair *keyPair = nullptr;
858     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
859 
860     ASSERT_EQ(res, HCF_SUCCESS);
861     ASSERT_NE(keyPair, nullptr);
862 
863     const char *className = keyPair->base.getClass();
864 
865     ASSERT_NE(className, nullptr);
866 
867     HcfObjDestroy(keyPair);
868     HcfObjDestroy(generator);
869 }
870 
871 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest060, TestSize.Level0)
872 {
873     HcfAsyKeyGenerator *generator = nullptr;
874     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
875 
876     HcfKeyPair *keyPair = nullptr;
877     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
878 
879     ASSERT_EQ(res, HCF_SUCCESS);
880     ASSERT_NE(keyPair, nullptr);
881 
882     keyPair->base.destroy((HcfObjectBase *)(&(keyPair->base)));
883 
884     HcfObjDestroy(generator);
885 }
886 
887 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest061, TestSize.Level0)
888 {
889     HcfAsyKeyGenerator *generator = nullptr;
890     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
891 
892     HcfKeyPair *keyPair = nullptr;
893     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
894 
895     ASSERT_EQ(res, HCF_SUCCESS);
896     ASSERT_NE(keyPair, nullptr);
897 
898     keyPair->base.destroy(nullptr);
899 
900     HcfObjDestroy(keyPair);
901     HcfObjDestroy(generator);
902 }
903 
904 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest063, TestSize.Level0)
905 {
906     HcfAsyKeyGenerator *generator = nullptr;
907     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
908 
909     HcfKeyPair *keyPair = nullptr;
910     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
911 
912     ASSERT_EQ(res, HCF_SUCCESS);
913     ASSERT_NE(keyPair, nullptr);
914 
915     const char *className = keyPair->pubKey->base.base.getClass();
916     ASSERT_NE(className, nullptr);
917 
918     HcfObjDestroy(keyPair);
919     HcfObjDestroy(generator);
920 }
921 
922 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest064, TestSize.Level0)
923 {
924     HcfAsyKeyGenerator *generator = nullptr;
925     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
926 
927     HcfKeyPair *keyPair = nullptr;
928     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
929 
930     ASSERT_EQ(res, HCF_SUCCESS);
931     ASSERT_NE(keyPair, nullptr);
932 
933     keyPair->pubKey->base.base.destroy((HcfObjectBase *)(&(keyPair->pubKey->base.base)));
934     keyPair->pubKey = nullptr;
935 
936     HcfObjDestroy(keyPair);
937     HcfObjDestroy(generator);
938 }
939 
940 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest065, TestSize.Level0)
941 {
942     HcfAsyKeyGenerator *generator = nullptr;
943     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
944 
945     HcfKeyPair *keyPair = nullptr;
946     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
947 
948     ASSERT_EQ(res, HCF_SUCCESS);
949     ASSERT_NE(keyPair, nullptr);
950 
951     keyPair->pubKey->base.base.destroy(nullptr);
952 
953     HcfObjDestroy(keyPair);
954     HcfObjDestroy(generator);
955 }
956 
957 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest067, TestSize.Level0)
958 {
959     HcfAsyKeyGenerator *generator = nullptr;
960     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
961 
962     HcfKeyPair *keyPair = nullptr;
963     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
964 
965     ASSERT_EQ(res, HCF_SUCCESS);
966     ASSERT_NE(keyPair, nullptr);
967 
968     const char *format = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
969 
970     ASSERT_NE(format, nullptr);
971 
972     HcfObjDestroy(keyPair);
973     HcfObjDestroy(generator);
974 }
975 
976 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest068, TestSize.Level0)
977 {
978     HcfAsyKeyGenerator *generator = nullptr;
979     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
980 
981     HcfKeyPair *keyPair = nullptr;
982     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
983 
984     ASSERT_EQ(res, HCF_SUCCESS);
985     ASSERT_NE(keyPair, nullptr);
986 
987     const char *format = keyPair->pubKey->base.getFormat(nullptr);
988 
989     ASSERT_EQ(format, nullptr);
990 
991     HcfObjDestroy(keyPair);
992     HcfObjDestroy(generator);
993 }
994 
995 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest070, TestSize.Level0)
996 {
997     HcfAsyKeyGenerator *generator = nullptr;
998     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
999 
1000     HcfKeyPair *keyPair = nullptr;
1001     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
1002 
1003     ASSERT_EQ(res, HCF_SUCCESS);
1004     ASSERT_NE(keyPair, nullptr);
1005 
1006     const char *algName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
1007 
1008     ASSERT_NE(algName, nullptr);
1009 
1010     HcfObjDestroy(keyPair);
1011     HcfObjDestroy(generator);
1012 }
1013 
1014 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest071, TestSize.Level0)
1015 {
1016     HcfAsyKeyGenerator *generator = nullptr;
1017     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1018 
1019     HcfKeyPair *keyPair = nullptr;
1020     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
1021 
1022     ASSERT_EQ(res, HCF_SUCCESS);
1023     ASSERT_NE(keyPair, nullptr);
1024 
1025     const char *algName = keyPair->pubKey->base.getAlgorithm(nullptr);
1026 
1027     ASSERT_EQ(algName, nullptr);
1028 
1029     HcfObjDestroy(keyPair);
1030     HcfObjDestroy(generator);
1031 }
1032 
1033 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest073, TestSize.Level0)
1034 {
1035     HcfAsyKeyGenerator *generator = nullptr;
1036     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1037 
1038     HcfKeyPair *keyPair = nullptr;
1039     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
1040 
1041     ASSERT_EQ(res, HCF_SUCCESS);
1042     ASSERT_NE(keyPair, nullptr);
1043 
1044     HcfBlob blob = { .data = nullptr, .len = 0 };
1045     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
1046 
1047     ASSERT_EQ(res, HCF_SUCCESS);
1048     ASSERT_NE(blob.data, nullptr);
1049     ASSERT_NE(blob.len, 0);
1050 
1051     HcfFree(blob.data);
1052 
1053     HcfObjDestroy(keyPair);
1054     HcfObjDestroy(generator);
1055 }
1056 
1057 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest074, TestSize.Level0)
1058 {
1059     HcfAsyKeyGenerator *generator = nullptr;
1060     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1061 
1062     HcfKeyPair *keyPair = nullptr;
1063     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
1064 
1065     ASSERT_EQ(res, HCF_SUCCESS);
1066     ASSERT_NE(keyPair, nullptr);
1067 
1068     HcfBlob blob = { .data = nullptr, .len = 0 };
1069     res = keyPair->pubKey->base.getEncoded(nullptr, &blob);
1070 
1071     ASSERT_NE(res, HCF_SUCCESS);
1072     ASSERT_EQ(blob.data, nullptr);
1073     ASSERT_EQ(blob.len, 0);
1074 
1075     HcfObjDestroy(keyPair);
1076     HcfObjDestroy(generator);
1077 }
1078 
1079 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest076, TestSize.Level0)
1080 {
1081     HcfAsyKeyGenerator *generator = nullptr;
1082     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1083 
1084     HcfKeyPair *keyPair = nullptr;
1085     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
1086 
1087     ASSERT_EQ(res, HCF_SUCCESS);
1088     ASSERT_NE(keyPair, nullptr);
1089 
1090     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), nullptr);
1091 
1092     ASSERT_NE(res, HCF_SUCCESS);
1093 
1094     HcfObjDestroy(keyPair);
1095     HcfObjDestroy(generator);
1096 }
1097 
1098 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest077, TestSize.Level0)
1099 {
1100     HcfAsyKeyGenerator *generator = nullptr;
1101     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1102 
1103     HcfKeyPair *keyPair = nullptr;
1104     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
1105 
1106     ASSERT_EQ(res, HCF_SUCCESS);
1107     ASSERT_NE(keyPair, nullptr);
1108 
1109     keyPair->priKey->clearMem(keyPair->priKey);
1110 
1111     HcfObjDestroy(keyPair);
1112     HcfObjDestroy(generator);
1113 }
1114 
1115 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest078, TestSize.Level0)
1116 {
1117     HcfAsyKeyGenerator *generator = nullptr;
1118     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1119 
1120     HcfKeyPair *keyPair = nullptr;
1121     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
1122 
1123     ASSERT_EQ(res, HCF_SUCCESS);
1124     ASSERT_NE(keyPair, nullptr);
1125 
1126     keyPair->priKey->clearMem(nullptr);
1127 
1128     HcfObjDestroy(keyPair);
1129     HcfObjDestroy(generator);
1130 }
1131 
1132 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest080, TestSize.Level0)
1133 {
1134     HcfAsyKeyGenerator *generator = nullptr;
1135     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1136 
1137     HcfKeyPair *keyPair = nullptr;
1138     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
1139 
1140     ASSERT_EQ(res, HCF_SUCCESS);
1141     ASSERT_NE(keyPair, nullptr);
1142 
1143     const char *algName = keyPair->priKey->base.base.getClass();
1144 
1145     ASSERT_NE(algName, nullptr);
1146 
1147     HcfObjDestroy(keyPair);
1148     HcfObjDestroy(generator);
1149 }
1150 
1151 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest081, TestSize.Level0)
1152 {
1153     HcfAsyKeyGenerator *generator = nullptr;
1154     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1155 
1156     HcfKeyPair *keyPair = nullptr;
1157     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
1158 
1159     ASSERT_EQ(res, HCF_SUCCESS);
1160     ASSERT_NE(keyPair, nullptr);
1161 
1162     keyPair->priKey->base.base.destroy((HcfObjectBase *)(&(keyPair->priKey->base.base)));
1163     keyPair->priKey = nullptr;
1164 
1165     HcfObjDestroy(keyPair);
1166     HcfObjDestroy(generator);
1167 }
1168 
1169 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest082, TestSize.Level0)
1170 {
1171     HcfAsyKeyGenerator *generator = nullptr;
1172     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1173 
1174     HcfKeyPair *keyPair = nullptr;
1175     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
1176 
1177     ASSERT_EQ(res, HCF_SUCCESS);
1178     ASSERT_NE(keyPair, nullptr);
1179 
1180     keyPair->priKey->base.base.destroy(nullptr);
1181 
1182     HcfObjDestroy(keyPair);
1183     HcfObjDestroy(generator);
1184 }
1185 
1186 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest084, TestSize.Level0)
1187 {
1188     HcfAsyKeyGenerator *generator = nullptr;
1189     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1190 
1191     HcfKeyPair *keyPair = nullptr;
1192     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
1193 
1194     ASSERT_EQ(res, HCF_SUCCESS);
1195     ASSERT_NE(keyPair, nullptr);
1196 
1197     const char *format = keyPair->priKey->base.getFormat(&keyPair->priKey->base);
1198 
1199     ASSERT_NE(format, nullptr);
1200 
1201     HcfObjDestroy(keyPair);
1202     HcfObjDestroy(generator);
1203 }
1204 
1205 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest085, TestSize.Level0)
1206 {
1207     HcfAsyKeyGenerator *generator = nullptr;
1208     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1209 
1210     HcfKeyPair *keyPair = nullptr;
1211     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
1212 
1213     ASSERT_EQ(res, HCF_SUCCESS);
1214     ASSERT_NE(keyPair, nullptr);
1215 
1216     const char *format = keyPair->priKey->base.getFormat(nullptr);
1217 
1218     ASSERT_EQ(format, nullptr);
1219 
1220     HcfObjDestroy(keyPair);
1221     HcfObjDestroy(generator);
1222 }
1223 
1224 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest087, TestSize.Level0)
1225 {
1226     HcfAsyKeyGenerator *generator = nullptr;
1227     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1228 
1229     HcfKeyPair *keyPair = nullptr;
1230     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
1231 
1232     ASSERT_EQ(res, HCF_SUCCESS);
1233     ASSERT_NE(keyPair, nullptr);
1234 
1235     const char *algName = keyPair->priKey->base.getAlgorithm(&keyPair->priKey->base);
1236 
1237     ASSERT_NE(algName, nullptr);
1238 
1239     HcfObjDestroy(keyPair);
1240     HcfObjDestroy(generator);
1241 }
1242 
1243 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest088, TestSize.Level0)
1244 {
1245     HcfAsyKeyGenerator *generator = nullptr;
1246     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1247 
1248     HcfKeyPair *keyPair = nullptr;
1249     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
1250 
1251     ASSERT_EQ(res, HCF_SUCCESS);
1252     ASSERT_NE(keyPair, nullptr);
1253 
1254     const char *algName = keyPair->priKey->base.getAlgorithm(nullptr);
1255 
1256     ASSERT_EQ(algName, nullptr);
1257 
1258     HcfObjDestroy(keyPair);
1259     HcfObjDestroy(generator);
1260 }
1261 
1262 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest090, TestSize.Level0)
1263 {
1264     HcfAsyKeyGenerator *generator = nullptr;
1265     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1266 
1267     HcfKeyPair *keyPair = nullptr;
1268     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
1269 
1270     ASSERT_EQ(res, HCF_SUCCESS);
1271     ASSERT_NE(keyPair, nullptr);
1272 
1273     HcfBlob blob = { .data = nullptr, .len = 0 };
1274     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
1275 
1276     ASSERT_EQ(res, HCF_SUCCESS);
1277     ASSERT_NE(blob.data, nullptr);
1278     ASSERT_NE(blob.len, 0);
1279 
1280     HcfFree(blob.data);
1281 
1282     HcfObjDestroy(keyPair);
1283     HcfObjDestroy(generator);
1284 }
1285 
1286 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest091, TestSize.Level0)
1287 {
1288     HcfAsyKeyGenerator *generator = nullptr;
1289     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1290 
1291     HcfKeyPair *keyPair = nullptr;
1292     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
1293 
1294     ASSERT_EQ(res, HCF_SUCCESS);
1295     ASSERT_NE(keyPair, nullptr);
1296 
1297     HcfBlob blob = { .data = nullptr, .len = 0 };
1298     res = keyPair->priKey->base.getEncoded(nullptr, &blob);
1299 
1300     ASSERT_NE(res, HCF_SUCCESS);
1301     ASSERT_EQ(blob.data, nullptr);
1302     ASSERT_EQ(blob.len, 0);
1303 
1304     HcfObjDestroy(keyPair);
1305     HcfObjDestroy(generator);
1306 }
1307 
1308 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest093, TestSize.Level0)
1309 {
1310     HcfAsyKeyGenerator *generator = nullptr;
1311     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1312 
1313     HcfKeyPair *keyPair = nullptr;
1314     res = generator->convertKey(generator, nullptr, &g_mockSm2256PubKeyBlob, &g_mockSm2256PriKeyBlob, &keyPair);
1315 
1316     ASSERT_EQ(res, HCF_SUCCESS);
1317     ASSERT_NE(keyPair, nullptr);
1318 
1319     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), nullptr);
1320 
1321     ASSERT_NE(res, HCF_SUCCESS);
1322 
1323     HcfObjDestroy(keyPair);
1324     HcfObjDestroy(generator);
1325 }
1326 
1327 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest094, TestSize.Level0)
1328 {
1329     HcfAsyKeyGenerator *generator = nullptr;
1330     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1331 
1332     HcfKeyPair *keyPair = nullptr;
1333     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1334 
1335     ASSERT_EQ(res, HCF_SUCCESS);
1336     ASSERT_NE(keyPair, nullptr);
1337 
1338     HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
1339     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
1340 
1341     ASSERT_EQ(res, HCF_SUCCESS);
1342 
1343     HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
1344     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
1345 
1346     ASSERT_EQ(res, HCF_SUCCESS);
1347 
1348     HcfKeyPair *outKeyPair = nullptr;
1349     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
1350 
1351     ASSERT_EQ(res, HCF_SUCCESS);
1352     ASSERT_NE(outKeyPair, nullptr);
1353 
1354     HcfBlob outPubKeyBlob = { .data = nullptr, .len = 0 };
1355     res = outKeyPair->pubKey->base.getEncoded(&(outKeyPair->pubKey->base), &outPubKeyBlob);
1356 
1357     ASSERT_EQ(res, HCF_SUCCESS);
1358     ASSERT_NE(outPubKeyBlob.data, nullptr);
1359     ASSERT_NE(outPubKeyBlob.len, 0);
1360 
1361     HcfBlob outPriKeyBlob = { .data = nullptr, .len = 0 };
1362     res = outKeyPair->priKey->base.getEncoded(&(outKeyPair->priKey->base), &outPriKeyBlob);
1363 
1364     ASSERT_EQ(res, HCF_SUCCESS);
1365     ASSERT_NE(outPriKeyBlob.data, nullptr);
1366     ASSERT_NE(outPriKeyBlob.len, 0);
1367 
1368     HcfFree(pubKeyBlob.data);
1369     HcfFree(priKeyBlob.data);
1370     HcfFree(outPubKeyBlob.data);
1371     HcfFree(outPriKeyBlob.data);
1372     HcfObjDestroy(outKeyPair);
1373     HcfObjDestroy(keyPair);
1374     HcfObjDestroy(generator);
1375 }
1376 
1377 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest095, TestSize.Level0)
1378 {
1379     HcfAsyKeyGenerator *generator = nullptr;
1380     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1381 
1382     HcfKeyPair *keyPair = nullptr;
1383     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1384 
1385     ASSERT_EQ(res, HCF_SUCCESS);
1386     ASSERT_NE(keyPair, nullptr);
1387 
1388     HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
1389     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
1390 
1391     ASSERT_EQ(res, HCF_SUCCESS);
1392     ASSERT_NE(pubKeyBlob.data, nullptr);
1393     ASSERT_NE(pubKeyBlob.len, 0);
1394 
1395     HcfKeyPair *outKeyPair = nullptr;
1396     res = generator->convertKey(generator, nullptr, &pubKeyBlob, nullptr, &outKeyPair);
1397 
1398     ASSERT_EQ(res, HCF_SUCCESS);
1399     ASSERT_NE(outKeyPair, nullptr);
1400     ASSERT_NE(outKeyPair->pubKey, nullptr);
1401     ASSERT_EQ(outKeyPair->priKey, nullptr);
1402 
1403     HcfBlob outPubKeyBlob = { .data = nullptr, .len = 0 };
1404     res = outKeyPair->pubKey->base.getEncoded(&(outKeyPair->pubKey->base), &outPubKeyBlob);
1405 
1406     ASSERT_EQ(res, HCF_SUCCESS);
1407     ASSERT_NE(outPubKeyBlob.data, nullptr);
1408     ASSERT_NE(outPubKeyBlob.len, 0);
1409 
1410     HcfFree(pubKeyBlob.data);
1411     HcfFree(outPubKeyBlob.data);
1412     HcfObjDestroy(outKeyPair);
1413     HcfObjDestroy(keyPair);
1414     HcfObjDestroy(generator);
1415 }
1416 
1417 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest096, TestSize.Level0)
1418 {
1419     HcfAsyKeyGenerator *generator = nullptr;
1420     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1421 
1422     HcfKeyPair *keyPair = nullptr;
1423     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1424 
1425     ASSERT_EQ(res, HCF_SUCCESS);
1426     ASSERT_NE(keyPair, nullptr);
1427 
1428     HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
1429     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
1430 
1431     ASSERT_EQ(res, HCF_SUCCESS);
1432     ASSERT_NE(priKeyBlob.data, nullptr);
1433     ASSERT_NE(priKeyBlob.len, 0);
1434 
1435     HcfKeyPair *outKeyPair = nullptr;
1436     res = generator->convertKey(generator, nullptr, nullptr, &priKeyBlob, &outKeyPair);
1437 
1438     ASSERT_EQ(res, HCF_SUCCESS);
1439     ASSERT_NE(outKeyPair, nullptr);
1440     ASSERT_EQ(outKeyPair->pubKey, nullptr);
1441     ASSERT_NE(outKeyPair->priKey, nullptr);
1442 
1443     HcfBlob outPriKeyBlob = { .data = nullptr, .len = 0 };
1444     res = outKeyPair->priKey->base.getEncoded(&(outKeyPair->priKey->base), &outPriKeyBlob);
1445 
1446     ASSERT_EQ(res, HCF_SUCCESS);
1447     ASSERT_NE(outPriKeyBlob.data, nullptr);
1448     ASSERT_NE(outPriKeyBlob.len, 0);
1449 
1450     HcfFree(priKeyBlob.data);
1451     HcfFree(outPriKeyBlob.data);
1452     HcfObjDestroy(outKeyPair);
1453     HcfObjDestroy(keyPair);
1454     HcfObjDestroy(generator);
1455 }
1456 
1457 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest097, TestSize.Level0)
1458 {
1459     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1460     int32_t res = HcfAsyKeyGeneratorSpiSm2Create(nullptr, &spiObj);
1461 
1462     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1463     ASSERT_EQ(spiObj, nullptr);
1464 }
1465 
1466 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest098, TestSize.Level0)
1467 {
1468     HcfAsyKeyGenParams params = {
1469         .algo = HCF_ALG_SM2,
1470         .bits = HCF_ALG_SM2_256,
1471         .primes = HCF_OPENSSL_PRIMES_2,
1472     };
1473 
1474     int32_t res = HcfAsyKeyGeneratorSpiSm2Create(&params, nullptr);
1475 
1476     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1477 }
1478 
1479 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest099, TestSize.Level0)
1480 {
1481     HcfAsyKeyGenParams params = {
1482         .algo = HCF_ALG_SM2,
1483         .bits = HCF_ALG_MODE_NONE,
1484         .primes = HCF_OPENSSL_PRIMES_2,
1485     };
1486 
1487     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1488     int32_t res = HcfAsyKeyGeneratorSpiSm2Create(&params, &spiObj);
1489 
1490     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1491     ASSERT_EQ(spiObj, nullptr);
1492 }
1493 
1494 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest101, TestSize.Level0)
1495 {
1496     HcfAsyKeyGenParams params = {
1497         .algo = HCF_ALG_SM2,
1498         .bits = HCF_ALG_SM2_256,
1499         .primes = HCF_OPENSSL_PRIMES_2,
1500     };
1501 
1502     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1503     int32_t res = HcfAsyKeyGeneratorSpiSm2Create(&params, &spiObj);
1504 
1505     ASSERT_EQ(res, HCF_SUCCESS);
1506     ASSERT_NE(spiObj, nullptr);
1507 
1508     HcfKeyPair *keyPair = nullptr;
1509     res = spiObj->engineConvertKey((HcfAsyKeyGeneratorSpi *)&g_obj, nullptr, nullptr, nullptr, &keyPair);
1510     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1511 
1512     HcfObjDestroy(spiObj);
1513 }
1514 
1515 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest102, TestSize.Level0)
1516 {
1517     HcfAsyKeyGenParams params = {
1518         .algo = HCF_ALG_SM2,
1519         .bits = HCF_ALG_SM2_256,
1520         .primes = HCF_OPENSSL_PRIMES_2,
1521     };
1522 
1523     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
1524     int32_t res = HcfAsyKeyGeneratorSpiSm2Create(&params, &spiObj);
1525 
1526     ASSERT_EQ(res, HCF_SUCCESS);
1527     ASSERT_NE(spiObj, nullptr);
1528 
1529     spiObj->base.destroy(nullptr);
1530 
1531     HcfObjDestroy(spiObj);
1532 }
1533 
MemoryMallocTestFunc(uint32_t mallocCount)1534 static void MemoryMallocTestFunc(uint32_t mallocCount)
1535 {
1536     for (int i = 0; i < mallocCount; i++) {
1537         ResetRecordMallocNum();
1538         SetMockMallocIndex(i);
1539         HcfAsyKeyGenerator *tmpGenerator = nullptr;
1540         int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &tmpGenerator);
1541         if (res != HCF_SUCCESS) {
1542             continue;
1543         }
1544         HcfKeyPair *tmpKeyPair = nullptr;
1545         res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
1546         if (res != HCF_SUCCESS) {
1547             HcfObjDestroy(tmpGenerator);
1548             continue;
1549         }
1550         HcfBlob tmpPubKeyBlob = {
1551             .data = nullptr,
1552             .len = 0
1553         };
1554         res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
1555         if (res != HCF_SUCCESS) {
1556             HcfObjDestroy(tmpKeyPair);
1557             HcfObjDestroy(tmpGenerator);
1558             continue;
1559         }
1560         HcfBlob tmpPriKeyBlob = {
1561             .data = nullptr,
1562             .len = 0
1563         };
1564         res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
1565         if (res != HCF_SUCCESS) {
1566             HcfFree(tmpPubKeyBlob.data);
1567             HcfObjDestroy(tmpKeyPair);
1568             HcfObjDestroy(tmpGenerator);
1569             continue;
1570         }
1571         HcfKeyPair *tmpOutKeyPair = nullptr;
1572         res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
1573         HcfFree(tmpPubKeyBlob.data);
1574         HcfFree(tmpPriKeyBlob.data);
1575         HcfObjDestroy(tmpKeyPair);
1576         HcfObjDestroy(tmpGenerator);
1577         if (res == HCF_SUCCESS) {
1578             HcfObjDestroy(tmpOutKeyPair);
1579         }
1580     }
1581 }
1582 
1583 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest104, TestSize.Level0)
1584 {
1585     StartRecordMallocNum();
1586     HcfAsyKeyGenerator *generator = nullptr;
1587     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1588 
1589     HcfKeyPair *keyPair = nullptr;
1590     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1591 
1592     ASSERT_EQ(res, HCF_SUCCESS);
1593     ASSERT_NE(keyPair, nullptr);
1594 
1595     HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
1596     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
1597 
1598     ASSERT_EQ(res, HCF_SUCCESS);
1599     ASSERT_NE(pubKeyBlob.data, nullptr);
1600     ASSERT_NE(pubKeyBlob.len, 0);
1601 
1602     HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
1603     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
1604 
1605     ASSERT_EQ(res, HCF_SUCCESS);
1606     ASSERT_NE(priKeyBlob.data, nullptr);
1607     ASSERT_NE(priKeyBlob.len, 0);
1608 
1609     HcfKeyPair *outKeyPair = nullptr;
1610     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
1611 
1612     HcfFree(pubKeyBlob.data);
1613     HcfFree(priKeyBlob.data);
1614     HcfObjDestroy(outKeyPair);
1615     HcfObjDestroy(keyPair);
1616     HcfObjDestroy(generator);
1617 
1618     uint32_t mallocCount = GetMallocNum();
1619     MemoryMallocTestFunc(mallocCount);
1620 
1621     EndRecordMallocNum();
1622 }
1623 
OpensslMockTestFunc(uint32_t mallocCount)1624 static void OpensslMockTestFunc(uint32_t mallocCount)
1625 {
1626     for (int i = 0; i < mallocCount; i++) {
1627         ResetOpensslCallNum();
1628         SetOpensslCallMockIndex(i);
1629         HcfAsyKeyGenerator *tmpGenerator = nullptr;
1630         int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &tmpGenerator);
1631         if (res != HCF_SUCCESS) {
1632             continue;
1633         }
1634         HcfKeyPair *tmpKeyPair = nullptr;
1635         res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
1636         if (res != HCF_SUCCESS) {
1637             HcfObjDestroy(tmpGenerator);
1638             continue;
1639         }
1640         HcfBlob tmpPubKeyBlob = {
1641             .data = nullptr,
1642             .len = 0
1643         };
1644         res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
1645         if (res != HCF_SUCCESS) {
1646             HcfObjDestroy(tmpKeyPair);
1647             HcfObjDestroy(tmpGenerator);
1648             continue;
1649         }
1650         HcfBlob tmpPriKeyBlob = {
1651             .data = nullptr,
1652             .len = 0
1653         };
1654         res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
1655         if (res != HCF_SUCCESS) {
1656             HcfFree(tmpPubKeyBlob.data);
1657             HcfObjDestroy(tmpKeyPair);
1658             HcfObjDestroy(tmpGenerator);
1659             continue;
1660         }
1661         HcfKeyPair *tmpOutKeyPair = nullptr;
1662         res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
1663         HcfFree(tmpPubKeyBlob.data);
1664         HcfFree(tmpPriKeyBlob.data);
1665         HcfObjDestroy(tmpKeyPair);
1666         HcfObjDestroy(tmpGenerator);
1667         if (res == HCF_SUCCESS) {
1668             HcfObjDestroy(tmpOutKeyPair);
1669         }
1670     }
1671 }
1672 
1673 HWTEST_F(CryptoSm2AsyKeyGeneratorTest, CryptoSm2AsyKeyGeneratorTest105, TestSize.Level0)
1674 {
1675     StartRecordOpensslCallNum();
1676     HcfAsyKeyGenerator *generator = nullptr;
1677     int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1678 
1679     HcfKeyPair *keyPair = nullptr;
1680     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1681 
1682     ASSERT_EQ(res, HCF_SUCCESS);
1683     ASSERT_NE(keyPair, nullptr);
1684 
1685     HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
1686     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
1687 
1688     ASSERT_EQ(res, HCF_SUCCESS);
1689     ASSERT_NE(pubKeyBlob.data, nullptr);
1690     ASSERT_NE(pubKeyBlob.len, 0);
1691 
1692     HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
1693     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
1694 
1695     ASSERT_EQ(res, HCF_SUCCESS);
1696     ASSERT_NE(priKeyBlob.data, nullptr);
1697     ASSERT_NE(priKeyBlob.len, 0);
1698 
1699     HcfKeyPair *outKeyPair = nullptr;
1700     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
1701 
1702     HcfFree(pubKeyBlob.data);
1703     HcfFree(priKeyBlob.data);
1704     HcfObjDestroy(outKeyPair);
1705     HcfObjDestroy(keyPair);
1706     HcfObjDestroy(generator);
1707 
1708     uint32_t mallocCount = GetOpensslCallNum();
1709     OpensslMockTestFunc(mallocCount);
1710 
1711     EndRecordOpensslCallNum();
1712 }
1713 }
1714