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