1 /*
2  * Copyright (C) 2023-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *    http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 #include "securec.h"
18 
19 #include "asy_key_generator.h"
20 #include "ecc_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 CryptoEccAsyKeyGeneratorTest : public testing::Test {
32 public:
33     static void SetUpTestCase();
34     static void TearDownTestCase();
35     void SetUp();
36     void TearDown();
37 };
38 
SetUpTestCase()39 void CryptoEccAsyKeyGeneratorTest::SetUpTestCase() {}
TearDownTestCase()40 void CryptoEccAsyKeyGeneratorTest::TearDownTestCase() {}
SetUp()41 void CryptoEccAsyKeyGeneratorTest::SetUp() {}
TearDown()42 void CryptoEccAsyKeyGeneratorTest::TearDown() {}
43 
44 const int ECC224_PUB_KEY_LEN = 80;
45 const int ECC224_PRI_KEY_LEN = 44;
46 const int ECC256_PUB_KEY_LEN = 91;
47 const int ECC256_PRI_KEY_LEN = 51;
48 const int ECC384_PUB_KEY_LEN = 120;
49 const int ECC384_PRI_KEY_LEN = 64;
50 const int ECC521_PUB_KEY_LEN = 158;
51 const int ECC521_PRI_KEY_LEN = 82;
52 
53 uint8_t g_mockEcc224PubKeyBlobData[ECC224_PUB_KEY_LEN] = { 48, 78, 48, 16, 6, 7, 42, 134, 72, 206, 61, 2, 1,
54     6, 5, 43, 129, 4, 0, 33, 3, 58, 0, 4, 252, 171, 11, 115, 79, 252, 109, 120, 46, 97, 131, 145, 207, 141, 146,
55     235, 133, 37, 218, 180, 8, 149, 47, 244, 137, 238, 207, 95, 153, 65, 250, 32, 77, 184, 249, 181, 172, 192, 2,
56     99, 194, 170, 25, 44, 255, 87, 246, 42, 133, 83, 66, 197, 97, 95, 12, 84 };
57 
58 uint8_t g_mockEcc224PriKeyBlobData[ECC224_PRI_KEY_LEN] = { 48, 42, 2, 1, 1, 4, 28, 250, 86, 6, 147, 222, 43,
59     252, 139, 90, 139, 5, 33, 184, 230, 26, 68, 94, 57, 145, 229, 146, 49, 221, 119, 206, 32, 198, 19, 160, 7, 6,
60     5, 43, 129, 4, 0, 33 };
61 
62 uint8_t g_mockEcc256PubKeyBlobData[ECC256_PUB_KEY_LEN] = { 48, 89, 48, 19, 6, 7, 42, 134, 72, 206, 61, 2, 1,
63     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,
64     231, 67, 2, 214, 197, 176, 161, 160, 227, 133, 158, 30, 118, 217, 243, 155, 88, 55, 214, 86, 86, 122, 166, 64,
65     111, 2, 226, 93, 163, 194, 210, 74, 18, 63, 173, 113, 249, 196, 126, 165, 222, 230, 190, 101, 241, 95, 102, 174,
66     252, 38 };
67 
68 uint8_t g_mockEcc256PriKeyBlobData[ECC256_PRI_KEY_LEN] = { 48, 49, 2, 1, 1, 4, 32, 223, 134, 255, 219, 45,
69     68, 72, 231, 43, 72, 243, 113, 255, 60, 232, 203, 151, 65, 80, 6, 36, 112, 247, 186, 106, 148, 43, 170, 204,
70     23, 189, 191, 160, 10, 6, 8, 42, 134, 72, 206, 61, 3, 1, 7 };
71 
72 uint8_t g_mockEcc384PubKeyBlobData[ECC384_PUB_KEY_LEN] = { 48, 118, 48, 16, 6, 7, 42, 134, 72, 206, 61, 2,
73     1, 6, 5, 43, 129, 4, 0, 34, 3, 98, 0, 4, 149, 237, 84, 7, 62, 114, 48, 106, 64, 227, 243, 253, 90, 170, 184,
74     80, 174, 159, 72, 117, 16, 24, 213, 146, 184, 159, 33, 209, 36, 143, 227, 11, 113, 228, 128, 13, 181, 195, 235,
75     12, 255, 85, 187, 197, 109, 82, 242, 226, 186, 53, 128, 9, 133, 4, 170, 96, 150, 94, 197, 196, 107, 120, 55,
76     159, 181, 208, 249, 176, 108, 6, 166, 253, 221, 156, 139, 140, 124, 240, 11, 194, 154, 139, 62, 218, 170, 61,
77     12, 147, 7, 146, 243, 158, 103, 195, 123, 156 };
78 
79 uint8_t g_mockEcc384PriKeyBlobData[ECC384_PRI_KEY_LEN] = { 48, 62, 2, 1, 1, 4, 48, 137, 184, 12, 183, 201,
80     211, 124, 203, 165, 9, 229, 68, 46, 17, 14, 14, 109, 195, 0, 206, 248, 21, 53, 72, 66, 3, 244, 165, 248,
81     217, 176, 121, 155, 225, 222, 134, 155, 241, 59, 16, 253, 237, 158, 11, 221, 252, 58, 251, 160, 7, 6, 5,
82     43, 129, 4, 0, 34 };
83 
84 uint8_t g_mockEcc521PubKeyBlobData[ECC521_PUB_KEY_LEN] = { 48, 129, 155, 48, 16, 6, 7, 42, 134, 72, 206,
85     61, 2, 1, 6, 5, 43, 129, 4, 0, 35, 3, 129, 134, 0, 4, 0, 149, 60, 46, 252, 220, 227, 253, 219, 250, 60, 232,
86     80, 190, 119, 38, 79, 202, 173, 35, 126, 228, 244, 207, 174, 191, 250, 147, 188, 22, 132, 125, 44, 26, 57, 242,
87     203, 192, 100, 65, 185, 250, 80, 246, 76, 37, 242, 78, 64, 152, 47, 172, 165, 229, 99, 247, 61, 91, 152, 144,
88     67, 34, 38, 130, 198, 22, 0, 179, 69, 69, 147, 72, 154, 76, 134, 28, 158, 33, 251, 94, 63, 77, 44, 100, 132,
89     207, 159, 210, 113, 194, 174, 170, 194, 129, 215, 209, 50, 217, 204, 48, 53, 92, 231, 57, 179, 170, 6, 26, 77,
90     187, 181, 35, 254, 17, 216, 205, 118, 104, 89, 155, 145, 28, 61, 169, 113, 195, 55, 13, 125, 6, 168, 156 };
91 
92 uint8_t g_mockEcc521PriKeyBlobData[ECC521_PRI_KEY_LEN] = { 48, 80, 2, 1, 1, 4, 66, 0, 210, 135, 140, 70,
93     98, 28, 121, 169, 5, 202, 132, 165, 11, 56, 9, 110, 32, 9, 146, 185, 239, 69, 113, 79, 213, 24, 165, 194, 147,
94     209, 223, 187, 100, 6, 149, 4, 56, 235, 120, 152, 146, 252, 92, 21, 222, 3, 182, 68, 39, 222, 49, 192, 154, 126,
95     126, 243, 18, 99, 136, 199, 234, 134, 232, 13, 128, 160, 7, 6, 5, 43, 129, 4, 0, 35 };
96 
97 HcfBlob g_mockEcc224PubKeyBlob = {
98     .data = g_mockEcc224PubKeyBlobData,
99     .len = ECC224_PUB_KEY_LEN
100 };
101 
102 HcfBlob g_mockEcc224PriKeyBlob = {
103     .data = g_mockEcc224PriKeyBlobData,
104     .len = ECC224_PRI_KEY_LEN
105 };
106 
107 HcfBlob g_mockEcc256PubKeyBlob = {
108     .data = g_mockEcc256PubKeyBlobData,
109     .len = ECC256_PUB_KEY_LEN
110 };
111 
112 HcfBlob g_mockEcc256PriKeyBlob = {
113     .data = g_mockEcc256PriKeyBlobData,
114     .len = ECC256_PRI_KEY_LEN
115 };
116 
117 HcfBlob g_mockEcc384PubKeyBlob = {
118     .data = g_mockEcc384PubKeyBlobData,
119     .len = ECC384_PUB_KEY_LEN
120 };
121 
122 HcfBlob g_mockEcc384PriKeyBlob = {
123     .data = g_mockEcc384PriKeyBlobData,
124     .len = ECC384_PRI_KEY_LEN
125 };
126 
127 HcfBlob g_mockEcc521PubKeyBlob = {
128     .data = g_mockEcc521PubKeyBlobData,
129     .len = ECC521_PUB_KEY_LEN
130 };
131 
132 HcfBlob g_mockEcc521PriKeyBlob = {
133     .data = g_mockEcc521PriKeyBlobData,
134     .len = ECC521_PRI_KEY_LEN
135 };
136 
GetMockClass(void)137 static const char *GetMockClass(void)
138 {
139     return "HcfSymKeyGenerator";
140 }
141 
142 HcfObjectBase g_obj = {
143     .getClass = GetMockClass,
144     .destroy = nullptr
145 };
146 
147 /**
148  * @tc.name: CryptoEccAsyKeyGeneratorTest.CryptoEccAsyKeyGeneratorTest001
149  * @tc.desc: Verify that the creation of the ECC224 key pair generator is normal.
150  * @tc.type: FUNC
151  * @tc.require: I5QWEI
152  */
153 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest001, TestSize.Level0)
154 {
155     HcfAsyKeyGenerator *generator = nullptr;
156     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
157 
158     ASSERT_EQ(res, HCF_SUCCESS);
159     ASSERT_NE(generator, nullptr);
160 
161     HcfObjDestroy(generator);
162 }
163 
164 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest002, TestSize.Level0)
165 {
166     HcfAsyKeyGenerator *generator = nullptr;
167     int32_t res = HcfAsyKeyGeneratorCreate("ECC256", &generator);
168 
169     ASSERT_EQ(res, HCF_SUCCESS);
170     ASSERT_NE(generator, nullptr);
171 
172     HcfObjDestroy(generator);
173 }
174 
175 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest003, TestSize.Level0)
176 {
177     HcfAsyKeyGenerator *generator = nullptr;
178     int32_t res = HcfAsyKeyGeneratorCreate("ECC384", &generator);
179 
180     ASSERT_EQ(res, HCF_SUCCESS);
181     ASSERT_NE(generator, nullptr);
182 
183     HcfObjDestroy(generator);
184 }
185 
186 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest004, TestSize.Level0)
187 {
188     HcfAsyKeyGenerator *generator = nullptr;
189     int32_t res = HcfAsyKeyGeneratorCreate("ECC521", &generator);
190 
191     ASSERT_EQ(res, HCF_SUCCESS);
192     ASSERT_NE(generator, nullptr);
193 
194     HcfObjDestroy(generator);
195 }
196 
197 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest005, TestSize.Level0)
198 {
199     HcfAsyKeyGenerator *generator = nullptr;
200     int32_t res = HcfAsyKeyGeneratorCreate(nullptr, &generator);
201 
202     ASSERT_EQ(res, HCF_INVALID_PARAMS);
203     ASSERT_EQ(generator, nullptr);
204 }
205 
206 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest006, TestSize.Level0)
207 {
208     HcfAsyKeyGenerator *generator = nullptr;
209     int32_t res = HcfAsyKeyGeneratorCreate("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD"
210         "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", &generator);
211 
212     ASSERT_EQ(res, HCF_INVALID_PARAMS);
213     ASSERT_EQ(generator, nullptr);
214 }
215 
216 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest007, TestSize.Level0)
217 {
218     HcfAsyKeyGenerator *generator = nullptr;
219     int32_t res = HcfAsyKeyGeneratorCreate("ECC225", &generator);
220 
221     ASSERT_EQ(res, HCF_INVALID_PARAMS);
222     ASSERT_EQ(generator, nullptr);
223 }
224 
225 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest008, TestSize.Level0)
226 {
227     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", nullptr);
228 
229     ASSERT_EQ(res, HCF_INVALID_PARAMS);
230 }
231 
232 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest101, TestSize.Level0)
233 {
234     HcfAsyKeyGenerator *generator = nullptr;
235     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
236 
237     ASSERT_EQ(res, HCF_SUCCESS);
238     ASSERT_NE(generator, nullptr);
239 
240     const char *className = generator->base.getClass();
241     ASSERT_NE(className, nullptr);
242 
243     HcfObjDestroy(generator);
244 }
245 
246 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest102, TestSize.Level0)
247 {
248     HcfAsyKeyGenerator *generator = nullptr;
249     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
250 
251     ASSERT_EQ(res, HCF_SUCCESS);
252     ASSERT_NE(generator, nullptr);
253 
254     generator->base.destroy((HcfObjectBase *)generator);
255 }
256 
257 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest103, TestSize.Level0)
258 {
259     HcfAsyKeyGenerator *generator = nullptr;
260     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
261 
262     ASSERT_EQ(res, HCF_SUCCESS);
263     ASSERT_NE(generator, nullptr);
264 
265     generator->base.destroy(nullptr);
266 
267     HcfObjDestroy(generator);
268 }
269 
270 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest104, TestSize.Level0)
271 {
272     HcfAsyKeyGenerator *generator = nullptr;
273     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
274 
275     ASSERT_EQ(res, HCF_SUCCESS);
276     ASSERT_NE(generator, nullptr);
277 
278     generator->base.destroy(&g_obj);
279 
280     HcfObjDestroy(generator);
281 }
282 
283 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest105, TestSize.Level0)
284 {
285     HcfAsyKeyGenerator *generator = nullptr;
286     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
287 
288     ASSERT_EQ(res, HCF_SUCCESS);
289     ASSERT_NE(generator, nullptr);
290 
291     const char *algName = generator->getAlgoName(generator);
292 
293     ASSERT_NE(algName, nullptr);
294 
295     HcfObjDestroy(generator);
296 }
297 
298 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest106, TestSize.Level0)
299 {
300     HcfAsyKeyGenerator *generator = nullptr;
301     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
302 
303     ASSERT_EQ(res, HCF_SUCCESS);
304     ASSERT_NE(generator, nullptr);
305 
306     const char *algName = generator->getAlgoName(nullptr);
307 
308     ASSERT_EQ(algName, nullptr);
309 
310     HcfObjDestroy(generator);
311 }
312 
313 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest107, TestSize.Level0)
314 {
315     HcfAsyKeyGenerator *generator = nullptr;
316     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
317 
318     ASSERT_EQ(res, HCF_SUCCESS);
319     ASSERT_NE(generator, nullptr);
320 
321     const char *algName = generator->getAlgoName((HcfAsyKeyGenerator *)&g_obj);
322 
323     ASSERT_EQ(algName, nullptr);
324 
325     HcfObjDestroy(generator);
326 }
327 
328 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest201, TestSize.Level0)
329 {
330     HcfAsyKeyGenerator *generator = nullptr;
331     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
332 
333     ASSERT_EQ(res, HCF_SUCCESS);
334     ASSERT_NE(generator, nullptr);
335 
336     HcfKeyPair *keyPair = nullptr;
337     res = generator->generateKeyPair(generator, nullptr, &keyPair);
338 
339     ASSERT_EQ(res, HCF_SUCCESS);
340     ASSERT_NE(keyPair, nullptr);
341 
342     HcfObjDestroy(keyPair);
343     HcfObjDestroy(generator);
344 }
345 
346 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest202, TestSize.Level0)
347 {
348     HcfAsyKeyGenerator *generator = nullptr;
349     int32_t res = HcfAsyKeyGeneratorCreate("ECC256", &generator);
350 
351     ASSERT_EQ(res, HCF_SUCCESS);
352     ASSERT_NE(generator, nullptr);
353 
354     HcfKeyPair *keyPair = nullptr;
355     res = generator->generateKeyPair(generator, nullptr, &keyPair);
356 
357     ASSERT_EQ(res, HCF_SUCCESS);
358     ASSERT_NE(keyPair, nullptr);
359 
360     HcfObjDestroy(keyPair);
361     HcfObjDestroy(generator);
362 }
363 
364 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest203, TestSize.Level0)
365 {
366     HcfAsyKeyGenerator *generator = nullptr;
367     int32_t res = HcfAsyKeyGeneratorCreate("ECC384", &generator);
368 
369     ASSERT_EQ(res, HCF_SUCCESS);
370     ASSERT_NE(generator, nullptr);
371 
372     HcfKeyPair *keyPair = nullptr;
373     res = generator->generateKeyPair(generator, nullptr, &keyPair);
374 
375     ASSERT_EQ(res, HCF_SUCCESS);
376     ASSERT_NE(keyPair, nullptr);
377 
378     HcfObjDestroy(keyPair);
379     HcfObjDestroy(generator);
380 }
381 
382 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest204, TestSize.Level0)
383 {
384     HcfAsyKeyGenerator *generator = nullptr;
385     int32_t res = HcfAsyKeyGeneratorCreate("ECC521", &generator);
386 
387     ASSERT_EQ(res, HCF_SUCCESS);
388     ASSERT_NE(generator, nullptr);
389 
390     HcfKeyPair *keyPair = nullptr;
391     res = generator->generateKeyPair(generator, nullptr, &keyPair);
392 
393     ASSERT_EQ(res, HCF_SUCCESS);
394     ASSERT_NE(keyPair, nullptr);
395 
396     HcfObjDestroy(keyPair);
397     HcfObjDestroy(generator);
398 }
399 
400 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest205, TestSize.Level0)
401 {
402     HcfAsyKeyGenerator *generator = nullptr;
403     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
404 
405     ASSERT_EQ(res, HCF_SUCCESS);
406     ASSERT_NE(generator, nullptr);
407 
408     HcfKeyPair *keyPair = nullptr;
409     res = generator->generateKeyPair(nullptr, nullptr, &keyPair);
410 
411     ASSERT_EQ(res, HCF_INVALID_PARAMS);
412     ASSERT_EQ(keyPair, nullptr);
413 
414     HcfObjDestroy(generator);
415 }
416 
417 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest206, TestSize.Level0)
418 {
419     HcfAsyKeyGenerator *generator = nullptr;
420     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
421 
422     ASSERT_EQ(res, HCF_SUCCESS);
423     ASSERT_NE(generator, nullptr);
424 
425     HcfKeyPair *keyPair = nullptr;
426     res = generator->generateKeyPair((HcfAsyKeyGenerator *)&g_obj, nullptr, &keyPair);
427 
428     ASSERT_EQ(res, HCF_INVALID_PARAMS);
429     ASSERT_EQ(keyPair, nullptr);
430 
431     HcfObjDestroy(generator);
432 }
433 
434 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest207, TestSize.Level0)
435 {
436     HcfAsyKeyGenerator *generator = nullptr;
437     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
438 
439     ASSERT_EQ(res, HCF_SUCCESS);
440     ASSERT_NE(generator, nullptr);
441 
442     res = generator->generateKeyPair(generator, nullptr, nullptr);
443 
444     ASSERT_EQ(res, HCF_INVALID_PARAMS);
445 
446     HcfObjDestroy(generator);
447 }
448 
449 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest301, TestSize.Level0)
450 {
451     HcfAsyKeyGenerator *generator = nullptr;
452     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
453 
454     HcfKeyPair *keyPair = nullptr;
455     res = generator->generateKeyPair(generator, nullptr, &keyPair);
456 
457     ASSERT_EQ(res, HCF_SUCCESS);
458     ASSERT_NE(keyPair, nullptr);
459 
460     const char *className = keyPair->base.getClass();
461 
462     ASSERT_NE(className, nullptr);
463 
464     HcfObjDestroy(keyPair);
465     HcfObjDestroy(generator);
466 }
467 
468 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest302, TestSize.Level0)
469 {
470     HcfAsyKeyGenerator *generator = nullptr;
471     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
472 
473     HcfKeyPair *keyPair = nullptr;
474     res = generator->generateKeyPair(generator, nullptr, &keyPair);
475 
476     ASSERT_EQ(res, HCF_SUCCESS);
477     ASSERT_NE(keyPair, nullptr);
478 
479     keyPair->base.destroy((HcfObjectBase *)(&(keyPair->base)));
480 
481     HcfObjDestroy(generator);
482 }
483 
484 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest303, TestSize.Level0)
485 {
486     HcfAsyKeyGenerator *generator = nullptr;
487     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
488 
489     HcfKeyPair *keyPair = nullptr;
490     res = generator->generateKeyPair(generator, nullptr, &keyPair);
491 
492     ASSERT_EQ(res, HCF_SUCCESS);
493     ASSERT_NE(keyPair, nullptr);
494 
495     keyPair->base.destroy(nullptr);
496 
497     HcfObjDestroy(keyPair);
498     HcfObjDestroy(generator);
499 }
500 
501 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest304, TestSize.Level0)
502 {
503     HcfAsyKeyGenerator *generator = nullptr;
504     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
505 
506     HcfKeyPair *keyPair = nullptr;
507     res = generator->generateKeyPair(generator, nullptr, &keyPair);
508 
509     ASSERT_EQ(res, HCF_SUCCESS);
510     ASSERT_NE(keyPair, nullptr);
511 
512     keyPair->base.destroy(&g_obj);
513 
514     HcfObjDestroy(keyPair);
515     HcfObjDestroy(generator);
516 }
517 
518 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest305, TestSize.Level0)
519 {
520     HcfAsyKeyGenerator *generator = nullptr;
521     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
522 
523     HcfKeyPair *keyPair = nullptr;
524     res = generator->generateKeyPair(generator, nullptr, &keyPair);
525 
526     ASSERT_EQ(res, HCF_SUCCESS);
527     ASSERT_NE(keyPair, nullptr);
528 
529     const char *className = keyPair->pubKey->base.base.getClass();
530     ASSERT_NE(className, nullptr);
531 
532     HcfObjDestroy(keyPair);
533     HcfObjDestroy(generator);
534 }
535 
536 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest306, TestSize.Level0)
537 {
538     HcfAsyKeyGenerator *generator = nullptr;
539     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
540 
541     HcfKeyPair *keyPair = nullptr;
542     res = generator->generateKeyPair(generator, nullptr, &keyPair);
543 
544     ASSERT_EQ(res, HCF_SUCCESS);
545     ASSERT_NE(keyPair, nullptr);
546 
547     keyPair->pubKey->base.base.destroy((HcfObjectBase *)(&(keyPair->pubKey->base.base)));
548     keyPair->pubKey = nullptr;
549 
550     HcfObjDestroy(keyPair);
551     HcfObjDestroy(generator);
552 }
553 
554 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest307, TestSize.Level0)
555 {
556     HcfAsyKeyGenerator *generator = nullptr;
557     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
558 
559     HcfKeyPair *keyPair = nullptr;
560     res = generator->generateKeyPair(generator, nullptr, &keyPair);
561 
562     ASSERT_EQ(res, HCF_SUCCESS);
563     ASSERT_NE(keyPair, nullptr);
564 
565     keyPair->pubKey->base.base.destroy(nullptr);
566 
567     HcfObjDestroy(keyPair);
568     HcfObjDestroy(generator);
569 }
570 
571 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest308, TestSize.Level0)
572 {
573     HcfAsyKeyGenerator *generator = nullptr;
574     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
575 
576     HcfKeyPair *keyPair = nullptr;
577     res = generator->generateKeyPair(generator, nullptr, &keyPair);
578 
579     ASSERT_EQ(res, HCF_SUCCESS);
580     ASSERT_NE(keyPair, nullptr);
581 
582     keyPair->pubKey->base.base.destroy(&g_obj);
583 
584     HcfObjDestroy(keyPair);
585     HcfObjDestroy(generator);
586 }
587 
588 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest309, TestSize.Level0)
589 {
590     HcfAsyKeyGenerator *generator = nullptr;
591     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
592 
593     HcfKeyPair *keyPair = nullptr;
594     res = generator->generateKeyPair(generator, nullptr, &keyPair);
595 
596     ASSERT_EQ(res, HCF_SUCCESS);
597     ASSERT_NE(keyPair, nullptr);
598 
599     const char *format = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
600 
601     ASSERT_NE(format, nullptr);
602 
603     HcfObjDestroy(keyPair);
604     HcfObjDestroy(generator);
605 }
606 
607 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest310, TestSize.Level0)
608 {
609     HcfAsyKeyGenerator *generator = nullptr;
610     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
611 
612     HcfKeyPair *keyPair = nullptr;
613     res = generator->generateKeyPair(generator, nullptr, &keyPair);
614 
615     ASSERT_EQ(res, HCF_SUCCESS);
616     ASSERT_NE(keyPair, nullptr);
617 
618     const char *format = keyPair->pubKey->base.getFormat(nullptr);
619 
620     ASSERT_EQ(format, nullptr);
621 
622     HcfObjDestroy(keyPair);
623     HcfObjDestroy(generator);
624 }
625 
626 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest311, TestSize.Level0)
627 {
628     HcfAsyKeyGenerator *generator = nullptr;
629     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &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->pubKey->base.getFormat((HcfKey *)&g_obj);
638 
639     ASSERT_EQ(format, nullptr);
640 
641     HcfObjDestroy(keyPair);
642     HcfObjDestroy(generator);
643 }
644 
645 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest312, TestSize.Level0)
646 {
647     HcfAsyKeyGenerator *generator = nullptr;
648     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &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 *algName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
657 
658     ASSERT_NE(algName, nullptr);
659 
660     HcfObjDestroy(keyPair);
661     HcfObjDestroy(generator);
662 }
663 
664 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest313, TestSize.Level0)
665 {
666     HcfAsyKeyGenerator *generator = nullptr;
667     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &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->pubKey->base.getAlgorithm(nullptr);
676 
677     ASSERT_EQ(algName, nullptr);
678 
679     HcfObjDestroy(keyPair);
680     HcfObjDestroy(generator);
681 }
682 
683 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest314, TestSize.Level0)
684 {
685     HcfAsyKeyGenerator *generator = nullptr;
686     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &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->pubKey->base.getAlgorithm((HcfKey *)&g_obj);
695 
696     ASSERT_EQ(algName, nullptr);
697 
698     HcfObjDestroy(keyPair);
699     HcfObjDestroy(generator);
700 }
701 
702 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest315, TestSize.Level0)
703 {
704     HcfAsyKeyGenerator *generator = nullptr;
705     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &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->pubKey->base.getEncoded(&(keyPair->pubKey->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(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest316, TestSize.Level0)
727 {
728     HcfAsyKeyGenerator *generator = nullptr;
729     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &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->pubKey->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(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest317, TestSize.Level0)
749 {
750     HcfAsyKeyGenerator *generator = nullptr;
751     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &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     HcfBlob blob = { .data = nullptr, .len = 0 };
760     res = keyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob);
761 
762     ASSERT_NE(res, HCF_SUCCESS);
763     ASSERT_EQ(blob.data, nullptr);
764     ASSERT_EQ(blob.len, 0);
765 
766     HcfObjDestroy(keyPair);
767     HcfObjDestroy(generator);
768 }
769 
770 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest318, TestSize.Level0)
771 {
772     HcfAsyKeyGenerator *generator = nullptr;
773     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
774 
775     HcfKeyPair *keyPair = nullptr;
776     res = generator->generateKeyPair(generator, nullptr, &keyPair);
777 
778     ASSERT_EQ(res, HCF_SUCCESS);
779     ASSERT_NE(keyPair, nullptr);
780 
781     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), nullptr);
782 
783     ASSERT_NE(res, HCF_SUCCESS);
784 
785     HcfObjDestroy(keyPair);
786     HcfObjDestroy(generator);
787 }
788 
789 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest319, TestSize.Level0)
790 {
791     HcfAsyKeyGenerator *generator = nullptr;
792     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
793 
794     HcfKeyPair *keyPair = nullptr;
795     res = generator->generateKeyPair(generator, nullptr, &keyPair);
796 
797     ASSERT_EQ(res, HCF_SUCCESS);
798     ASSERT_NE(keyPair, nullptr);
799 
800     keyPair->priKey->clearMem(keyPair->priKey);
801 
802     HcfObjDestroy(keyPair);
803     HcfObjDestroy(generator);
804 }
805 
806 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest320, TestSize.Level0)
807 {
808     HcfAsyKeyGenerator *generator = nullptr;
809     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
810 
811     HcfKeyPair *keyPair = nullptr;
812     res = generator->generateKeyPair(generator, nullptr, &keyPair);
813 
814     ASSERT_EQ(res, HCF_SUCCESS);
815     ASSERT_NE(keyPair, nullptr);
816 
817     keyPair->priKey->clearMem(nullptr);
818 
819     HcfObjDestroy(keyPair);
820     HcfObjDestroy(generator);
821 }
822 
823 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest321, TestSize.Level0)
824 {
825     HcfAsyKeyGenerator *generator = nullptr;
826     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
827 
828     HcfKeyPair *keyPair = nullptr;
829     res = generator->generateKeyPair(generator, nullptr, &keyPair);
830 
831     ASSERT_EQ(res, HCF_SUCCESS);
832     ASSERT_NE(keyPair, nullptr);
833 
834     keyPair->priKey->clearMem((HcfPriKey *)&g_obj);
835 
836     HcfObjDestroy(keyPair);
837     HcfObjDestroy(generator);
838 }
839 
840 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest322, TestSize.Level0)
841 {
842     HcfAsyKeyGenerator *generator = nullptr;
843     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
844 
845     HcfKeyPair *keyPair = nullptr;
846     res = generator->generateKeyPair(generator, nullptr, &keyPair);
847 
848     ASSERT_EQ(res, HCF_SUCCESS);
849     ASSERT_NE(keyPair, nullptr);
850 
851     const char *algName = keyPair->priKey->base.base.getClass();
852 
853     ASSERT_NE(algName, nullptr);
854 
855     HcfObjDestroy(keyPair);
856     HcfObjDestroy(generator);
857 }
858 
859 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest323, TestSize.Level0)
860 {
861     HcfAsyKeyGenerator *generator = nullptr;
862     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
863 
864     HcfKeyPair *keyPair = nullptr;
865     res = generator->generateKeyPair(generator, nullptr, &keyPair);
866 
867     ASSERT_EQ(res, HCF_SUCCESS);
868     ASSERT_NE(keyPair, nullptr);
869 
870     keyPair->priKey->base.base.destroy((HcfObjectBase *)(&(keyPair->priKey->base.base)));
871     keyPair->priKey = nullptr;
872 
873     HcfObjDestroy(keyPair);
874     HcfObjDestroy(generator);
875 }
876 
877 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest324, TestSize.Level0)
878 {
879     HcfAsyKeyGenerator *generator = nullptr;
880     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
881 
882     HcfKeyPair *keyPair = nullptr;
883     res = generator->generateKeyPair(generator, nullptr, &keyPair);
884 
885     ASSERT_EQ(res, HCF_SUCCESS);
886     ASSERT_NE(keyPair, nullptr);
887 
888     keyPair->priKey->base.base.destroy(nullptr);
889 
890     HcfObjDestroy(keyPair);
891     HcfObjDestroy(generator);
892 }
893 
894 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest325, TestSize.Level0)
895 {
896     HcfAsyKeyGenerator *generator = nullptr;
897     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
898 
899     HcfKeyPair *keyPair = nullptr;
900     res = generator->generateKeyPair(generator, nullptr, &keyPair);
901 
902     ASSERT_EQ(res, HCF_SUCCESS);
903     ASSERT_NE(keyPair, nullptr);
904 
905     keyPair->priKey->base.base.destroy(&g_obj);
906 
907     HcfObjDestroy(keyPair);
908     HcfObjDestroy(generator);
909 }
910 
911 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest326, TestSize.Level0)
912 {
913     HcfAsyKeyGenerator *generator = nullptr;
914     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
915 
916     HcfKeyPair *keyPair = nullptr;
917     res = generator->generateKeyPair(generator, nullptr, &keyPair);
918 
919     ASSERT_EQ(res, HCF_SUCCESS);
920     ASSERT_NE(keyPair, nullptr);
921 
922     const char *format = keyPair->priKey->base.getFormat(&keyPair->priKey->base);
923 
924     ASSERT_NE(format, nullptr);
925 
926     HcfObjDestroy(keyPair);
927     HcfObjDestroy(generator);
928 }
929 
930 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest327, TestSize.Level0)
931 {
932     HcfAsyKeyGenerator *generator = nullptr;
933     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
934 
935     HcfKeyPair *keyPair = nullptr;
936     res = generator->generateKeyPair(generator, nullptr, &keyPair);
937 
938     ASSERT_EQ(res, HCF_SUCCESS);
939     ASSERT_NE(keyPair, nullptr);
940 
941     const char *format = keyPair->priKey->base.getFormat(nullptr);
942 
943     ASSERT_EQ(format, nullptr);
944 
945     HcfObjDestroy(keyPair);
946     HcfObjDestroy(generator);
947 }
948 
949 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest328, TestSize.Level0)
950 {
951     HcfAsyKeyGenerator *generator = nullptr;
952     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
953 
954     HcfKeyPair *keyPair = nullptr;
955     res = generator->generateKeyPair(generator, nullptr, &keyPair);
956 
957     ASSERT_EQ(res, HCF_SUCCESS);
958     ASSERT_NE(keyPair, nullptr);
959 
960     const char *format = keyPair->priKey->base.getFormat((HcfKey *)&g_obj);
961 
962     ASSERT_EQ(format, nullptr);
963 
964     HcfObjDestroy(keyPair);
965     HcfObjDestroy(generator);
966 }
967 
968 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest329, TestSize.Level0)
969 {
970     HcfAsyKeyGenerator *generator = nullptr;
971     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
972 
973     HcfKeyPair *keyPair = nullptr;
974     res = generator->generateKeyPair(generator, nullptr, &keyPair);
975 
976     ASSERT_EQ(res, HCF_SUCCESS);
977     ASSERT_NE(keyPair, nullptr);
978 
979     const char *algName = keyPair->priKey->base.getAlgorithm(&keyPair->priKey->base);
980 
981     ASSERT_NE(algName, nullptr);
982 
983     HcfObjDestroy(keyPair);
984     HcfObjDestroy(generator);
985 }
986 
987 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest330, TestSize.Level0)
988 {
989     HcfAsyKeyGenerator *generator = nullptr;
990     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
991 
992     HcfKeyPair *keyPair = nullptr;
993     res = generator->generateKeyPair(generator, nullptr, &keyPair);
994 
995     ASSERT_EQ(res, HCF_SUCCESS);
996     ASSERT_NE(keyPair, nullptr);
997 
998     const char *algName = keyPair->priKey->base.getAlgorithm(nullptr);
999 
1000     ASSERT_EQ(algName, nullptr);
1001 
1002     HcfObjDestroy(keyPair);
1003     HcfObjDestroy(generator);
1004 }
1005 
1006 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest331, TestSize.Level0)
1007 {
1008     HcfAsyKeyGenerator *generator = nullptr;
1009     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1010 
1011     HcfKeyPair *keyPair = nullptr;
1012     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1013 
1014     ASSERT_EQ(res, HCF_SUCCESS);
1015     ASSERT_NE(keyPair, nullptr);
1016 
1017     const char *algName = keyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj);
1018 
1019     ASSERT_EQ(algName, nullptr);
1020 
1021     HcfObjDestroy(keyPair);
1022     HcfObjDestroy(generator);
1023 }
1024 
1025 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest332, TestSize.Level0)
1026 {
1027     HcfAsyKeyGenerator *generator = nullptr;
1028     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1029 
1030     HcfKeyPair *keyPair = nullptr;
1031     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1032 
1033     ASSERT_EQ(res, HCF_SUCCESS);
1034     ASSERT_NE(keyPair, nullptr);
1035 
1036     HcfBlob blob = { .data = nullptr, .len = 0 };
1037     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
1038 
1039     ASSERT_EQ(res, HCF_SUCCESS);
1040     ASSERT_NE(blob.data, nullptr);
1041     ASSERT_NE(blob.len, 0);
1042 
1043     HcfFree(blob.data);
1044 
1045     HcfObjDestroy(keyPair);
1046     HcfObjDestroy(generator);
1047 }
1048 
1049 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest333, TestSize.Level0)
1050 {
1051     HcfAsyKeyGenerator *generator = nullptr;
1052     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1053 
1054     HcfKeyPair *keyPair = nullptr;
1055     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1056 
1057     ASSERT_EQ(res, HCF_SUCCESS);
1058     ASSERT_NE(keyPair, nullptr);
1059 
1060     HcfBlob blob = { .data = nullptr, .len = 0 };
1061     res = keyPair->priKey->base.getEncoded(nullptr, &blob);
1062 
1063     ASSERT_NE(res, HCF_SUCCESS);
1064     ASSERT_EQ(blob.data, nullptr);
1065     ASSERT_EQ(blob.len, 0);
1066 
1067     HcfObjDestroy(keyPair);
1068     HcfObjDestroy(generator);
1069 }
1070 
1071 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest334, TestSize.Level0)
1072 {
1073     HcfAsyKeyGenerator *generator = nullptr;
1074     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1075 
1076     HcfKeyPair *keyPair = nullptr;
1077     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1078 
1079     ASSERT_EQ(res, HCF_SUCCESS);
1080     ASSERT_NE(keyPair, nullptr);
1081 
1082     HcfBlob blob = { .data = nullptr, .len = 0 };
1083     res = keyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob);
1084 
1085     ASSERT_NE(res, HCF_SUCCESS);
1086     ASSERT_EQ(blob.data, nullptr);
1087     ASSERT_EQ(blob.len, 0);
1088 
1089     HcfObjDestroy(keyPair);
1090     HcfObjDestroy(generator);
1091 }
1092 
1093 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest335, TestSize.Level0)
1094 {
1095     HcfAsyKeyGenerator *generator = nullptr;
1096     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1097 
1098     HcfKeyPair *keyPair = nullptr;
1099     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1100 
1101     ASSERT_EQ(res, HCF_SUCCESS);
1102     ASSERT_NE(keyPair, nullptr);
1103 
1104     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), nullptr);
1105 
1106     ASSERT_NE(res, HCF_SUCCESS);
1107 
1108     HcfObjDestroy(keyPair);
1109     HcfObjDestroy(generator);
1110 }
1111 
1112 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest401, TestSize.Level0)
1113 {
1114     HcfAsyKeyGenerator *generator = nullptr;
1115     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1116 
1117     HcfKeyPair *outKeyPair = nullptr;
1118     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &outKeyPair);
1119 
1120     ASSERT_EQ(res, HCF_SUCCESS);
1121     ASSERT_NE(outKeyPair, nullptr);
1122 
1123     HcfObjDestroy(outKeyPair);
1124     HcfObjDestroy(generator);
1125 }
1126 
1127 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest402, TestSize.Level0)
1128 {
1129     HcfAsyKeyGenerator *generator = nullptr;
1130     int32_t res = HcfAsyKeyGeneratorCreate("ECC256", &generator);
1131 
1132     HcfKeyPair *outKeyPair = nullptr;
1133     res = generator->convertKey(generator, nullptr, &g_mockEcc256PubKeyBlob, &g_mockEcc256PriKeyBlob, &outKeyPair);
1134 
1135     ASSERT_EQ(res, HCF_SUCCESS);
1136     ASSERT_NE(outKeyPair, nullptr);
1137 
1138     HcfObjDestroy(outKeyPair);
1139     HcfObjDestroy(generator);
1140 }
1141 
1142 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest403, TestSize.Level0)
1143 {
1144     HcfAsyKeyGenerator *generator = nullptr;
1145     int32_t res = HcfAsyKeyGeneratorCreate("ECC384", &generator);
1146 
1147     HcfKeyPair *outKeyPair = nullptr;
1148     res = generator->convertKey(generator, nullptr, &g_mockEcc384PubKeyBlob, &g_mockEcc384PriKeyBlob, &outKeyPair);
1149 
1150     ASSERT_EQ(res, HCF_SUCCESS);
1151     ASSERT_NE(outKeyPair, nullptr);
1152 
1153     HcfObjDestroy(outKeyPair);
1154     HcfObjDestroy(generator);
1155 }
1156 
1157 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest404, TestSize.Level0)
1158 {
1159     HcfAsyKeyGenerator *generator = nullptr;
1160     int32_t res = HcfAsyKeyGeneratorCreate("ECC521", &generator);
1161 
1162     HcfKeyPair *outKeyPair = nullptr;
1163     res = generator->convertKey(generator, nullptr, &g_mockEcc521PubKeyBlob, &g_mockEcc521PriKeyBlob, &outKeyPair);
1164 
1165     ASSERT_EQ(res, HCF_SUCCESS);
1166     ASSERT_NE(outKeyPair, nullptr);
1167 
1168     HcfObjDestroy(outKeyPair);
1169     HcfObjDestroy(generator);
1170 }
1171 
1172 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest405, TestSize.Level0)
1173 {
1174     HcfAsyKeyGenerator *generator = nullptr;
1175     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1176 
1177     HcfKeyPair *outKeyPair = nullptr;
1178     res = generator->convertKey(nullptr, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &outKeyPair);
1179 
1180     ASSERT_NE(res, HCF_SUCCESS);
1181     ASSERT_EQ(outKeyPair, nullptr);
1182 
1183     HcfObjDestroy(generator);
1184 }
1185 
1186 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest406, TestSize.Level0)
1187 {
1188     HcfAsyKeyGenerator *generator = nullptr;
1189     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1190 
1191     HcfKeyPair *outKeyPair = nullptr;
1192     res = generator->convertKey((HcfAsyKeyGenerator *)&g_obj, nullptr,
1193         &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &outKeyPair);
1194 
1195     ASSERT_NE(res, HCF_SUCCESS);
1196     ASSERT_EQ(outKeyPair, nullptr);
1197 
1198     HcfObjDestroy(generator);
1199 }
1200 
1201 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest407, TestSize.Level0)
1202 {
1203     HcfAsyKeyGenerator *generator = nullptr;
1204     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1205 
1206     HcfKeyPair *outKeyPair = nullptr;
1207     res = generator->convertKey(generator, nullptr, nullptr, &g_mockEcc224PriKeyBlob, &outKeyPair);
1208 
1209     ASSERT_EQ(res, HCF_SUCCESS);
1210     ASSERT_NE(outKeyPair, nullptr);
1211 
1212     HcfObjDestroy(outKeyPair);
1213     HcfObjDestroy(generator);
1214 }
1215 
1216 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest408, TestSize.Level0)
1217 {
1218     HcfAsyKeyGenerator *generator = nullptr;
1219     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1220 
1221     HcfKeyPair *outKeyPair = nullptr;
1222     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, nullptr, &outKeyPair);
1223 
1224     ASSERT_EQ(res, HCF_SUCCESS);
1225     ASSERT_NE(outKeyPair, nullptr);
1226 
1227     HcfObjDestroy(outKeyPair);
1228     HcfObjDestroy(generator);
1229 }
1230 
1231 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest409, TestSize.Level0)
1232 {
1233     HcfAsyKeyGenerator *generator = nullptr;
1234     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1235 
1236     HcfKeyPair *outKeyPair = nullptr;
1237     res = generator->convertKey(generator, nullptr, nullptr, nullptr, &outKeyPair);
1238 
1239     ASSERT_NE(res, HCF_SUCCESS);
1240     ASSERT_EQ(outKeyPair, nullptr);
1241 
1242     HcfObjDestroy(generator);
1243 }
1244 
1245 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest410, TestSize.Level0)
1246 {
1247     HcfAsyKeyGenerator *generator = nullptr;
1248     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1249 
1250     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, nullptr);
1251 
1252     ASSERT_NE(res, HCF_SUCCESS);
1253 
1254     HcfObjDestroy(generator);
1255 }
1256 
1257 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest501, TestSize.Level0)
1258 {
1259     HcfAsyKeyGenerator *generator = nullptr;
1260     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1261 
1262     HcfKeyPair *keyPair = nullptr;
1263     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1264 
1265     ASSERT_EQ(res, HCF_SUCCESS);
1266     ASSERT_NE(keyPair, nullptr);
1267 
1268     const char *className = keyPair->base.getClass();
1269 
1270     ASSERT_NE(className, nullptr);
1271 
1272     HcfObjDestroy(keyPair);
1273     HcfObjDestroy(generator);
1274 }
1275 
1276 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest502, TestSize.Level0)
1277 {
1278     HcfAsyKeyGenerator *generator = nullptr;
1279     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1280 
1281     HcfKeyPair *keyPair = nullptr;
1282     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1283 
1284     ASSERT_EQ(res, HCF_SUCCESS);
1285     ASSERT_NE(keyPair, nullptr);
1286 
1287     keyPair->base.destroy((HcfObjectBase *)(&(keyPair->base)));
1288 
1289     HcfObjDestroy(generator);
1290 }
1291 
1292 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest503, TestSize.Level0)
1293 {
1294     HcfAsyKeyGenerator *generator = nullptr;
1295     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1296 
1297     HcfKeyPair *keyPair = nullptr;
1298     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1299 
1300     ASSERT_EQ(res, HCF_SUCCESS);
1301     ASSERT_NE(keyPair, nullptr);
1302 
1303     keyPair->base.destroy(nullptr);
1304 
1305     HcfObjDestroy(keyPair);
1306     HcfObjDestroy(generator);
1307 }
1308 
1309 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest504, TestSize.Level0)
1310 {
1311     HcfAsyKeyGenerator *generator = nullptr;
1312     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1313 
1314     HcfKeyPair *keyPair = nullptr;
1315     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1316 
1317     ASSERT_EQ(res, HCF_SUCCESS);
1318     ASSERT_NE(keyPair, nullptr);
1319 
1320     keyPair->base.destroy(&g_obj);
1321 
1322     HcfObjDestroy(keyPair);
1323     HcfObjDestroy(generator);
1324 }
1325 
1326 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest505, TestSize.Level0)
1327 {
1328     HcfAsyKeyGenerator *generator = nullptr;
1329     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1330 
1331     HcfKeyPair *keyPair = nullptr;
1332     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1333 
1334     ASSERT_EQ(res, HCF_SUCCESS);
1335     ASSERT_NE(keyPair, nullptr);
1336 
1337     const char *className = keyPair->pubKey->base.base.getClass();
1338     ASSERT_NE(className, nullptr);
1339 
1340     HcfObjDestroy(keyPair);
1341     HcfObjDestroy(generator);
1342 }
1343 
1344 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest506, TestSize.Level0)
1345 {
1346     HcfAsyKeyGenerator *generator = nullptr;
1347     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1348 
1349     HcfKeyPair *keyPair = nullptr;
1350     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1351 
1352     ASSERT_EQ(res, HCF_SUCCESS);
1353     ASSERT_NE(keyPair, nullptr);
1354 
1355     keyPair->pubKey->base.base.destroy((HcfObjectBase *)(&(keyPair->pubKey->base.base)));
1356     keyPair->pubKey = nullptr;
1357 
1358     HcfObjDestroy(keyPair);
1359     HcfObjDestroy(generator);
1360 }
1361 
1362 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest507, TestSize.Level0)
1363 {
1364     HcfAsyKeyGenerator *generator = nullptr;
1365     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1366 
1367     HcfKeyPair *keyPair = nullptr;
1368     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1369 
1370     ASSERT_EQ(res, HCF_SUCCESS);
1371     ASSERT_NE(keyPair, nullptr);
1372 
1373     keyPair->pubKey->base.base.destroy(nullptr);
1374 
1375     HcfObjDestroy(keyPair);
1376     HcfObjDestroy(generator);
1377 }
1378 
1379 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest508, TestSize.Level0)
1380 {
1381     HcfAsyKeyGenerator *generator = nullptr;
1382     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1383 
1384     HcfKeyPair *keyPair = nullptr;
1385     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1386 
1387     ASSERT_EQ(res, HCF_SUCCESS);
1388     ASSERT_NE(keyPair, nullptr);
1389 
1390     keyPair->pubKey->base.base.destroy(&g_obj);
1391 
1392     HcfObjDestroy(keyPair);
1393     HcfObjDestroy(generator);
1394 }
1395 
1396 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest509, TestSize.Level0)
1397 {
1398     HcfAsyKeyGenerator *generator = nullptr;
1399     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1400 
1401     HcfKeyPair *keyPair = nullptr;
1402     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1403 
1404     ASSERT_EQ(res, HCF_SUCCESS);
1405     ASSERT_NE(keyPair, nullptr);
1406 
1407     const char *format = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
1408 
1409     ASSERT_NE(format, nullptr);
1410 
1411     HcfObjDestroy(keyPair);
1412     HcfObjDestroy(generator);
1413 }
1414 
1415 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest510, TestSize.Level0)
1416 {
1417     HcfAsyKeyGenerator *generator = nullptr;
1418     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1419 
1420     HcfKeyPair *keyPair = nullptr;
1421     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1422 
1423     ASSERT_EQ(res, HCF_SUCCESS);
1424     ASSERT_NE(keyPair, nullptr);
1425 
1426     const char *format = keyPair->pubKey->base.getFormat(nullptr);
1427 
1428     ASSERT_EQ(format, nullptr);
1429 
1430     HcfObjDestroy(keyPair);
1431     HcfObjDestroy(generator);
1432 }
1433 
1434 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest511, TestSize.Level0)
1435 {
1436     HcfAsyKeyGenerator *generator = nullptr;
1437     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1438 
1439     HcfKeyPair *keyPair = nullptr;
1440     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1441 
1442     ASSERT_EQ(res, HCF_SUCCESS);
1443     ASSERT_NE(keyPair, nullptr);
1444 
1445     const char *format = keyPair->pubKey->base.getFormat((HcfKey *)&g_obj);
1446 
1447     ASSERT_EQ(format, nullptr);
1448 
1449     HcfObjDestroy(keyPair);
1450     HcfObjDestroy(generator);
1451 }
1452 
1453 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest512, TestSize.Level0)
1454 {
1455     HcfAsyKeyGenerator *generator = nullptr;
1456     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1457 
1458     HcfKeyPair *keyPair = nullptr;
1459     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1460 
1461     ASSERT_EQ(res, HCF_SUCCESS);
1462     ASSERT_NE(keyPair, nullptr);
1463 
1464     const char *algName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
1465 
1466     ASSERT_NE(algName, nullptr);
1467 
1468     HcfObjDestroy(keyPair);
1469     HcfObjDestroy(generator);
1470 }
1471 
1472 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest513, TestSize.Level0)
1473 {
1474     HcfAsyKeyGenerator *generator = nullptr;
1475     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1476 
1477     HcfKeyPair *keyPair = nullptr;
1478     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1479 
1480     ASSERT_EQ(res, HCF_SUCCESS);
1481     ASSERT_NE(keyPair, nullptr);
1482 
1483     const char *algName = keyPair->pubKey->base.getAlgorithm(nullptr);
1484 
1485     ASSERT_EQ(algName, nullptr);
1486 
1487     HcfObjDestroy(keyPair);
1488     HcfObjDestroy(generator);
1489 }
1490 
1491 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest514, TestSize.Level0)
1492 {
1493     HcfAsyKeyGenerator *generator = nullptr;
1494     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1495 
1496     HcfKeyPair *keyPair = nullptr;
1497     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1498 
1499     ASSERT_EQ(res, HCF_SUCCESS);
1500     ASSERT_NE(keyPair, nullptr);
1501 
1502     const char *algName = keyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj);
1503 
1504     ASSERT_EQ(algName, nullptr);
1505 
1506     HcfObjDestroy(keyPair);
1507     HcfObjDestroy(generator);
1508 }
1509 
1510 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest515, TestSize.Level0)
1511 {
1512     HcfAsyKeyGenerator *generator = nullptr;
1513     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1514 
1515     HcfKeyPair *keyPair = nullptr;
1516     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1517 
1518     ASSERT_EQ(res, HCF_SUCCESS);
1519     ASSERT_NE(keyPair, nullptr);
1520 
1521     HcfBlob blob = { .data = nullptr, .len = 0 };
1522     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
1523 
1524     ASSERT_EQ(res, HCF_SUCCESS);
1525     ASSERT_NE(blob.data, nullptr);
1526     ASSERT_NE(blob.len, 0);
1527 
1528     HcfFree(blob.data);
1529 
1530     HcfObjDestroy(keyPair);
1531     HcfObjDestroy(generator);
1532 }
1533 
1534 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest516, TestSize.Level0)
1535 {
1536     HcfAsyKeyGenerator *generator = nullptr;
1537     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1538 
1539     HcfKeyPair *keyPair = nullptr;
1540     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1541 
1542     ASSERT_EQ(res, HCF_SUCCESS);
1543     ASSERT_NE(keyPair, nullptr);
1544 
1545     HcfBlob blob = { .data = nullptr, .len = 0 };
1546     res = keyPair->pubKey->base.getEncoded(nullptr, &blob);
1547 
1548     ASSERT_NE(res, HCF_SUCCESS);
1549     ASSERT_EQ(blob.data, nullptr);
1550     ASSERT_EQ(blob.len, 0);
1551 
1552     HcfObjDestroy(keyPair);
1553     HcfObjDestroy(generator);
1554 }
1555 
1556 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest517, TestSize.Level0)
1557 {
1558     HcfAsyKeyGenerator *generator = nullptr;
1559     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1560 
1561     HcfKeyPair *keyPair = nullptr;
1562     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1563 
1564     ASSERT_EQ(res, HCF_SUCCESS);
1565     ASSERT_NE(keyPair, nullptr);
1566 
1567     HcfBlob blob = { .data = nullptr, .len = 0 };
1568     res = keyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob);
1569 
1570     ASSERT_NE(res, HCF_SUCCESS);
1571     ASSERT_EQ(blob.data, nullptr);
1572     ASSERT_EQ(blob.len, 0);
1573 
1574     HcfObjDestroy(keyPair);
1575     HcfObjDestroy(generator);
1576 }
1577 
1578 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest518, TestSize.Level0)
1579 {
1580     HcfAsyKeyGenerator *generator = nullptr;
1581     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1582 
1583     HcfKeyPair *keyPair = nullptr;
1584     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1585 
1586     ASSERT_EQ(res, HCF_SUCCESS);
1587     ASSERT_NE(keyPair, nullptr);
1588 
1589     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), nullptr);
1590 
1591     ASSERT_NE(res, HCF_SUCCESS);
1592 
1593     HcfObjDestroy(keyPair);
1594     HcfObjDestroy(generator);
1595 }
1596 
1597 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest519, TestSize.Level0)
1598 {
1599     HcfAsyKeyGenerator *generator = nullptr;
1600     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1601 
1602     HcfKeyPair *keyPair = nullptr;
1603     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1604 
1605     ASSERT_EQ(res, HCF_SUCCESS);
1606     ASSERT_NE(keyPair, nullptr);
1607 
1608     keyPair->priKey->clearMem(keyPair->priKey);
1609 
1610     HcfObjDestroy(keyPair);
1611     HcfObjDestroy(generator);
1612 }
1613 
1614 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest520, TestSize.Level0)
1615 {
1616     HcfAsyKeyGenerator *generator = nullptr;
1617     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1618 
1619     HcfKeyPair *keyPair = nullptr;
1620     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1621 
1622     ASSERT_EQ(res, HCF_SUCCESS);
1623     ASSERT_NE(keyPair, nullptr);
1624 
1625     keyPair->priKey->clearMem(nullptr);
1626 
1627     HcfObjDestroy(keyPair);
1628     HcfObjDestroy(generator);
1629 }
1630 
1631 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest521, TestSize.Level0)
1632 {
1633     HcfAsyKeyGenerator *generator = nullptr;
1634     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1635 
1636     HcfKeyPair *keyPair = nullptr;
1637     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1638 
1639     ASSERT_EQ(res, HCF_SUCCESS);
1640     ASSERT_NE(keyPair, nullptr);
1641 
1642     keyPair->priKey->clearMem((HcfPriKey *)&g_obj);
1643 
1644     HcfObjDestroy(keyPair);
1645     HcfObjDestroy(generator);
1646 }
1647 
1648 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest522, TestSize.Level0)
1649 {
1650     HcfAsyKeyGenerator *generator = nullptr;
1651     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1652 
1653     HcfKeyPair *keyPair = nullptr;
1654     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1655 
1656     ASSERT_EQ(res, HCF_SUCCESS);
1657     ASSERT_NE(keyPair, nullptr);
1658 
1659     const char *algName = keyPair->priKey->base.base.getClass();
1660 
1661     ASSERT_NE(algName, nullptr);
1662 
1663     HcfObjDestroy(keyPair);
1664     HcfObjDestroy(generator);
1665 }
1666 
1667 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest523, TestSize.Level0)
1668 {
1669     HcfAsyKeyGenerator *generator = nullptr;
1670     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1671 
1672     HcfKeyPair *keyPair = nullptr;
1673     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1674 
1675     ASSERT_EQ(res, HCF_SUCCESS);
1676     ASSERT_NE(keyPair, nullptr);
1677 
1678     keyPair->priKey->base.base.destroy((HcfObjectBase *)(&(keyPair->priKey->base.base)));
1679     keyPair->priKey = nullptr;
1680 
1681     HcfObjDestroy(keyPair);
1682     HcfObjDestroy(generator);
1683 }
1684 
1685 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest524, TestSize.Level0)
1686 {
1687     HcfAsyKeyGenerator *generator = nullptr;
1688     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1689 
1690     HcfKeyPair *keyPair = nullptr;
1691     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1692 
1693     ASSERT_EQ(res, HCF_SUCCESS);
1694     ASSERT_NE(keyPair, nullptr);
1695 
1696     keyPair->priKey->base.base.destroy(nullptr);
1697 
1698     HcfObjDestroy(keyPair);
1699     HcfObjDestroy(generator);
1700 }
1701 
1702 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest525, TestSize.Level0)
1703 {
1704     HcfAsyKeyGenerator *generator = nullptr;
1705     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1706 
1707     HcfKeyPair *keyPair = nullptr;
1708     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1709 
1710     ASSERT_EQ(res, HCF_SUCCESS);
1711     ASSERT_NE(keyPair, nullptr);
1712 
1713     keyPair->priKey->base.base.destroy(&g_obj);
1714 
1715     HcfObjDestroy(keyPair);
1716     HcfObjDestroy(generator);
1717 }
1718 
1719 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest526, TestSize.Level0)
1720 {
1721     HcfAsyKeyGenerator *generator = nullptr;
1722     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1723 
1724     HcfKeyPair *keyPair = nullptr;
1725     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1726 
1727     ASSERT_EQ(res, HCF_SUCCESS);
1728     ASSERT_NE(keyPair, nullptr);
1729 
1730     const char *format = keyPair->priKey->base.getFormat(&keyPair->priKey->base);
1731 
1732     ASSERT_NE(format, nullptr);
1733 
1734     HcfObjDestroy(keyPair);
1735     HcfObjDestroy(generator);
1736 }
1737 
1738 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest527, TestSize.Level0)
1739 {
1740     HcfAsyKeyGenerator *generator = nullptr;
1741     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1742 
1743     HcfKeyPair *keyPair = nullptr;
1744     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1745 
1746     ASSERT_EQ(res, HCF_SUCCESS);
1747     ASSERT_NE(keyPair, nullptr);
1748 
1749     const char *format = keyPair->priKey->base.getFormat(nullptr);
1750 
1751     ASSERT_EQ(format, nullptr);
1752 
1753     HcfObjDestroy(keyPair);
1754     HcfObjDestroy(generator);
1755 }
1756 
1757 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest528, TestSize.Level0)
1758 {
1759     HcfAsyKeyGenerator *generator = nullptr;
1760     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1761 
1762     HcfKeyPair *keyPair = nullptr;
1763     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1764 
1765     ASSERT_EQ(res, HCF_SUCCESS);
1766     ASSERT_NE(keyPair, nullptr);
1767 
1768     const char *format = keyPair->priKey->base.getFormat((HcfKey *)&g_obj);
1769 
1770     ASSERT_EQ(format, nullptr);
1771 
1772     HcfObjDestroy(keyPair);
1773     HcfObjDestroy(generator);
1774 }
1775 
1776 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest529, TestSize.Level0)
1777 {
1778     HcfAsyKeyGenerator *generator = nullptr;
1779     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1780 
1781     HcfKeyPair *keyPair = nullptr;
1782     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1783 
1784     ASSERT_EQ(res, HCF_SUCCESS);
1785     ASSERT_NE(keyPair, nullptr);
1786 
1787     const char *algName = keyPair->priKey->base.getAlgorithm(&keyPair->priKey->base);
1788 
1789     ASSERT_NE(algName, nullptr);
1790 
1791     HcfObjDestroy(keyPair);
1792     HcfObjDestroy(generator);
1793 }
1794 
1795 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest530, TestSize.Level0)
1796 {
1797     HcfAsyKeyGenerator *generator = nullptr;
1798     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1799 
1800     HcfKeyPair *keyPair = nullptr;
1801     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1802 
1803     ASSERT_EQ(res, HCF_SUCCESS);
1804     ASSERT_NE(keyPair, nullptr);
1805 
1806     const char *algName = keyPair->priKey->base.getAlgorithm(nullptr);
1807 
1808     ASSERT_EQ(algName, nullptr);
1809 
1810     HcfObjDestroy(keyPair);
1811     HcfObjDestroy(generator);
1812 }
1813 
1814 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest531, TestSize.Level0)
1815 {
1816     HcfAsyKeyGenerator *generator = nullptr;
1817     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1818 
1819     HcfKeyPair *keyPair = nullptr;
1820     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1821 
1822     ASSERT_EQ(res, HCF_SUCCESS);
1823     ASSERT_NE(keyPair, nullptr);
1824 
1825     const char *algName = keyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj);
1826 
1827     ASSERT_EQ(algName, nullptr);
1828 
1829     HcfObjDestroy(keyPair);
1830     HcfObjDestroy(generator);
1831 }
1832 
1833 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest532, TestSize.Level0)
1834 {
1835     HcfAsyKeyGenerator *generator = nullptr;
1836     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1837 
1838     HcfKeyPair *keyPair = nullptr;
1839     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1840 
1841     ASSERT_EQ(res, HCF_SUCCESS);
1842     ASSERT_NE(keyPair, nullptr);
1843 
1844     HcfBlob blob = { .data = nullptr, .len = 0 };
1845     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
1846 
1847     ASSERT_EQ(res, HCF_SUCCESS);
1848     ASSERT_NE(blob.data, nullptr);
1849     ASSERT_NE(blob.len, 0);
1850 
1851     HcfFree(blob.data);
1852 
1853     HcfObjDestroy(keyPair);
1854     HcfObjDestroy(generator);
1855 }
1856 
1857 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest533, TestSize.Level0)
1858 {
1859     HcfAsyKeyGenerator *generator = nullptr;
1860     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1861 
1862     HcfKeyPair *keyPair = nullptr;
1863     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1864 
1865     ASSERT_EQ(res, HCF_SUCCESS);
1866     ASSERT_NE(keyPair, nullptr);
1867 
1868     HcfBlob blob = { .data = nullptr, .len = 0 };
1869     res = keyPair->priKey->base.getEncoded(nullptr, &blob);
1870 
1871     ASSERT_NE(res, HCF_SUCCESS);
1872     ASSERT_EQ(blob.data, nullptr);
1873     ASSERT_EQ(blob.len, 0);
1874 
1875     HcfObjDestroy(keyPair);
1876     HcfObjDestroy(generator);
1877 }
1878 
1879 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest534, TestSize.Level0)
1880 {
1881     HcfAsyKeyGenerator *generator = nullptr;
1882     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1883 
1884     HcfKeyPair *keyPair = nullptr;
1885     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1886 
1887     ASSERT_EQ(res, HCF_SUCCESS);
1888     ASSERT_NE(keyPair, nullptr);
1889 
1890     HcfBlob blob = { .data = nullptr, .len = 0 };
1891     res = keyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob);
1892 
1893     ASSERT_NE(res, HCF_SUCCESS);
1894     ASSERT_EQ(blob.data, nullptr);
1895     ASSERT_EQ(blob.len, 0);
1896 
1897     HcfObjDestroy(keyPair);
1898     HcfObjDestroy(generator);
1899 }
1900 
1901 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest535, TestSize.Level0)
1902 {
1903     HcfAsyKeyGenerator *generator = nullptr;
1904     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1905 
1906     HcfKeyPair *keyPair = nullptr;
1907     res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1908 
1909     ASSERT_EQ(res, HCF_SUCCESS);
1910     ASSERT_NE(keyPair, nullptr);
1911 
1912     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), nullptr);
1913 
1914     ASSERT_NE(res, HCF_SUCCESS);
1915 
1916     HcfObjDestroy(keyPair);
1917     HcfObjDestroy(generator);
1918 }
1919 
1920 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest536, TestSize.Level0)
1921 {
1922     HcfAsyKeyGenerator *generator = nullptr;
1923     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1924 
1925     HcfKeyPair *keyPair = nullptr;
1926     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1927 
1928     ASSERT_EQ(res, HCF_SUCCESS);
1929     ASSERT_NE(keyPair, nullptr);
1930 
1931     HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
1932     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
1933 
1934     ASSERT_EQ(res, HCF_SUCCESS);
1935 
1936     HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
1937     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
1938 
1939     ASSERT_EQ(res, HCF_SUCCESS);
1940 
1941     HcfKeyPair *outKeyPair = nullptr;
1942     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
1943 
1944     ASSERT_EQ(res, HCF_SUCCESS);
1945     ASSERT_NE(outKeyPair, nullptr);
1946 
1947     HcfBlob outPubKeyBlob = { .data = nullptr, .len = 0 };
1948     res = outKeyPair->pubKey->base.getEncoded(&(outKeyPair->pubKey->base), &outPubKeyBlob);
1949 
1950     ASSERT_EQ(res, HCF_SUCCESS);
1951     ASSERT_NE(outPubKeyBlob.data, nullptr);
1952     ASSERT_NE(outPubKeyBlob.len, 0);
1953 
1954     HcfBlob outPriKeyBlob = { .data = nullptr, .len = 0 };
1955     res = outKeyPair->priKey->base.getEncoded(&(outKeyPair->priKey->base), &outPriKeyBlob);
1956 
1957     ASSERT_EQ(res, HCF_SUCCESS);
1958     ASSERT_NE(outPriKeyBlob.data, nullptr);
1959     ASSERT_NE(outPriKeyBlob.len, 0);
1960 
1961     HcfFree(pubKeyBlob.data);
1962     HcfFree(priKeyBlob.data);
1963     HcfFree(outPubKeyBlob.data);
1964     HcfFree(outPriKeyBlob.data);
1965     HcfObjDestroy(outKeyPair);
1966     HcfObjDestroy(keyPair);
1967     HcfObjDestroy(generator);
1968 }
1969 
1970 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest537, TestSize.Level0)
1971 {
1972     HcfAsyKeyGenerator *generator = nullptr;
1973     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1974 
1975     HcfKeyPair *keyPair = nullptr;
1976     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1977 
1978     ASSERT_EQ(res, HCF_SUCCESS);
1979     ASSERT_NE(keyPair, nullptr);
1980 
1981     HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
1982     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
1983 
1984     ASSERT_EQ(res, HCF_SUCCESS);
1985     ASSERT_NE(pubKeyBlob.data, nullptr);
1986     ASSERT_NE(pubKeyBlob.len, 0);
1987 
1988     HcfKeyPair *outKeyPair = nullptr;
1989     res = generator->convertKey(generator, nullptr, &pubKeyBlob, nullptr, &outKeyPair);
1990 
1991     ASSERT_EQ(res, HCF_SUCCESS);
1992     ASSERT_NE(outKeyPair, nullptr);
1993     ASSERT_NE(outKeyPair->pubKey, nullptr);
1994     ASSERT_EQ(outKeyPair->priKey, nullptr);
1995 
1996     HcfBlob outPubKeyBlob = { .data = nullptr, .len = 0 };
1997     res = outKeyPair->pubKey->base.getEncoded(&(outKeyPair->pubKey->base), &outPubKeyBlob);
1998 
1999     ASSERT_EQ(res, HCF_SUCCESS);
2000     ASSERT_NE(outPubKeyBlob.data, nullptr);
2001     ASSERT_NE(outPubKeyBlob.len, 0);
2002 
2003     HcfFree(pubKeyBlob.data);
2004     HcfFree(outPubKeyBlob.data);
2005     HcfObjDestroy(outKeyPair);
2006     HcfObjDestroy(keyPair);
2007     HcfObjDestroy(generator);
2008 }
2009 
2010 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest538, TestSize.Level0)
2011 {
2012     HcfAsyKeyGenerator *generator = nullptr;
2013     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
2014 
2015     HcfKeyPair *keyPair = nullptr;
2016     res = generator->generateKeyPair(generator, nullptr, &keyPair);
2017 
2018     ASSERT_EQ(res, HCF_SUCCESS);
2019     ASSERT_NE(keyPair, nullptr);
2020 
2021     HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
2022     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
2023 
2024     ASSERT_EQ(res, HCF_SUCCESS);
2025     ASSERT_NE(priKeyBlob.data, nullptr);
2026     ASSERT_NE(priKeyBlob.len, 0);
2027 
2028     HcfKeyPair *outKeyPair = nullptr;
2029     res = generator->convertKey(generator, nullptr, nullptr, &priKeyBlob, &outKeyPair);
2030 
2031     ASSERT_EQ(res, HCF_SUCCESS);
2032     ASSERT_NE(outKeyPair, nullptr);
2033     ASSERT_EQ(outKeyPair->pubKey, nullptr);
2034     ASSERT_NE(outKeyPair->priKey, nullptr);
2035 
2036     HcfBlob outPriKeyBlob = { .data = nullptr, .len = 0 };
2037     res = outKeyPair->priKey->base.getEncoded(&(outKeyPair->priKey->base), &outPriKeyBlob);
2038 
2039     ASSERT_EQ(res, HCF_SUCCESS);
2040     ASSERT_NE(outPriKeyBlob.data, nullptr);
2041     ASSERT_NE(outPriKeyBlob.len, 0);
2042 
2043     HcfFree(priKeyBlob.data);
2044     HcfFree(outPriKeyBlob.data);
2045     HcfObjDestroy(outKeyPair);
2046     HcfObjDestroy(keyPair);
2047     HcfObjDestroy(generator);
2048 }
2049 
2050 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest601, TestSize.Level0)
2051 {
2052     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
2053     int32_t res = HcfAsyKeyGeneratorSpiEccCreate(nullptr, &spiObj);
2054 
2055     ASSERT_EQ(res, HCF_INVALID_PARAMS);
2056     ASSERT_EQ(spiObj, nullptr);
2057 }
2058 
2059 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest602, TestSize.Level0)
2060 {
2061     HcfAsyKeyGenParams params = {
2062         .algo = HCF_ALG_ECC,
2063         .bits = HCF_ALG_ECC_256,
2064         .primes = HCF_OPENSSL_PRIMES_2,
2065     };
2066 
2067     int32_t res = HcfAsyKeyGeneratorSpiEccCreate(&params, nullptr);
2068 
2069     ASSERT_EQ(res, HCF_INVALID_PARAMS);
2070 }
2071 
2072 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest603, TestSize.Level0)
2073 {
2074     HcfAsyKeyGenParams params = {
2075         .algo = HCF_ALG_ECC,
2076         .bits = HCF_ALG_MODE_NONE,
2077         .primes = HCF_OPENSSL_PRIMES_2,
2078     };
2079 
2080     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
2081     int32_t res = HcfAsyKeyGeneratorSpiEccCreate(&params, &spiObj);
2082 
2083     ASSERT_EQ(res, HCF_INVALID_PARAMS);
2084     ASSERT_EQ(spiObj, nullptr);
2085 }
2086 
2087 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest604, TestSize.Level0)
2088 {
2089     HcfAsyKeyGenParams params = {
2090         .algo = HCF_ALG_ECC,
2091         .bits = HCF_ALG_ECC_256,
2092         .primes = HCF_OPENSSL_PRIMES_2,
2093     };
2094 
2095     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
2096     int32_t res = HcfAsyKeyGeneratorSpiEccCreate(&params, &spiObj);
2097 
2098     ASSERT_EQ(res, HCF_SUCCESS);
2099     ASSERT_NE(spiObj, nullptr);
2100 
2101     HcfKeyPair *keyPair = nullptr;
2102     res = spiObj->engineGenerateKeyPair((HcfAsyKeyGeneratorSpi *)&g_obj, &keyPair);
2103     ASSERT_EQ(res, HCF_INVALID_PARAMS);
2104 
2105     HcfObjDestroy(spiObj);
2106 }
2107 
2108 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest605, TestSize.Level0)
2109 {
2110     HcfAsyKeyGenParams params = {
2111         .algo = HCF_ALG_ECC,
2112         .bits = HCF_ALG_ECC_256,
2113         .primes = HCF_OPENSSL_PRIMES_2,
2114     };
2115 
2116     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
2117     int32_t res = HcfAsyKeyGeneratorSpiEccCreate(&params, &spiObj);
2118 
2119     ASSERT_EQ(res, HCF_SUCCESS);
2120     ASSERT_NE(spiObj, nullptr);
2121 
2122     HcfKeyPair *keyPair = nullptr;
2123     res = spiObj->engineConvertKey((HcfAsyKeyGeneratorSpi *)&g_obj, nullptr, nullptr, nullptr, &keyPair);
2124     ASSERT_EQ(res, HCF_INVALID_PARAMS);
2125 
2126     HcfObjDestroy(spiObj);
2127 }
2128 
2129 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest606, TestSize.Level0)
2130 {
2131     HcfAsyKeyGenParams params = {
2132         .algo = HCF_ALG_ECC,
2133         .bits = HCF_ALG_ECC_256,
2134         .primes = HCF_OPENSSL_PRIMES_2,
2135     };
2136 
2137     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
2138     int32_t res = HcfAsyKeyGeneratorSpiEccCreate(&params, &spiObj);
2139 
2140     ASSERT_EQ(res, HCF_SUCCESS);
2141     ASSERT_NE(spiObj, nullptr);
2142 
2143     spiObj->base.destroy(nullptr);
2144 
2145     HcfObjDestroy(spiObj);
2146 }
2147 
2148 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest607, TestSize.Level0)
2149 {
2150     HcfAsyKeyGenParams params = {
2151         .algo = HCF_ALG_ECC,
2152         .bits = HCF_ALG_ECC_256,
2153         .primes = HCF_OPENSSL_PRIMES_2,
2154     };
2155 
2156     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
2157     int32_t res = HcfAsyKeyGeneratorSpiEccCreate(&params, &spiObj);
2158 
2159     ASSERT_EQ(res, HCF_SUCCESS);
2160     ASSERT_NE(spiObj, nullptr);
2161 
2162     spiObj->base.destroy(&g_obj);
2163 
2164     HcfObjDestroy(spiObj);
2165 }
2166 
MemoryMallocTestFunc(uint32_t mallocCount)2167 static void MemoryMallocTestFunc(uint32_t mallocCount)
2168 {
2169     for (int i = 0; i < mallocCount; i++) {
2170         ResetRecordMallocNum();
2171         SetMockMallocIndex(i);
2172         HcfAsyKeyGenerator *tmpGenerator = nullptr;
2173         int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &tmpGenerator);
2174         if (res != HCF_SUCCESS) {
2175             continue;
2176         }
2177         HcfKeyPair *tmpKeyPair = nullptr;
2178         res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
2179         if (res != HCF_SUCCESS) {
2180             HcfObjDestroy(tmpGenerator);
2181             continue;
2182         }
2183         HcfBlob tmpPubKeyBlob = {
2184             .data = nullptr,
2185             .len = 0
2186         };
2187         res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
2188         if (res != HCF_SUCCESS) {
2189             HcfObjDestroy(tmpKeyPair);
2190             HcfObjDestroy(tmpGenerator);
2191             continue;
2192         }
2193         HcfBlob tmpPriKeyBlob = {
2194             .data = nullptr,
2195             .len = 0
2196         };
2197         res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
2198         if (res != HCF_SUCCESS) {
2199             HcfFree(tmpPubKeyBlob.data);
2200             HcfObjDestroy(tmpKeyPair);
2201             HcfObjDestroy(tmpGenerator);
2202             continue;
2203         }
2204         HcfKeyPair *tmpOutKeyPair = nullptr;
2205         res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
2206         HcfFree(tmpPubKeyBlob.data);
2207         HcfFree(tmpPriKeyBlob.data);
2208         HcfObjDestroy(tmpKeyPair);
2209         HcfObjDestroy(tmpGenerator);
2210         if (res == HCF_SUCCESS) {
2211             HcfObjDestroy(tmpOutKeyPair);
2212         }
2213     }
2214 }
2215 
2216 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest701, TestSize.Level0)
2217 {
2218     StartRecordMallocNum();
2219     HcfAsyKeyGenerator *generator = nullptr;
2220     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
2221 
2222     HcfKeyPair *keyPair = nullptr;
2223     res = generator->generateKeyPair(generator, nullptr, &keyPair);
2224 
2225     ASSERT_EQ(res, HCF_SUCCESS);
2226     ASSERT_NE(keyPair, nullptr);
2227 
2228     HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
2229     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
2230 
2231     ASSERT_EQ(res, HCF_SUCCESS);
2232     ASSERT_NE(pubKeyBlob.data, nullptr);
2233     ASSERT_NE(pubKeyBlob.len, 0);
2234 
2235     HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
2236     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
2237 
2238     ASSERT_EQ(res, HCF_SUCCESS);
2239     ASSERT_NE(priKeyBlob.data, nullptr);
2240     ASSERT_NE(priKeyBlob.len, 0);
2241 
2242     HcfKeyPair *outKeyPair = nullptr;
2243     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
2244 
2245     HcfFree(pubKeyBlob.data);
2246     HcfFree(priKeyBlob.data);
2247     HcfObjDestroy(outKeyPair);
2248     HcfObjDestroy(keyPair);
2249     HcfObjDestroy(generator);
2250 
2251     uint32_t mallocCount = GetMallocNum();
2252     MemoryMallocTestFunc(mallocCount);
2253 
2254     EndRecordMallocNum();
2255 }
2256 
OpensslMockTestFunc(uint32_t mallocCount)2257 static void OpensslMockTestFunc(uint32_t mallocCount)
2258 {
2259     for (int i = 0; i < mallocCount; i++) {
2260         ResetOpensslCallNum();
2261         SetOpensslCallMockIndex(i);
2262         HcfAsyKeyGenerator *tmpGenerator = nullptr;
2263         int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &tmpGenerator);
2264         if (res != HCF_SUCCESS) {
2265             continue;
2266         }
2267         HcfKeyPair *tmpKeyPair = nullptr;
2268         res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
2269         if (res != HCF_SUCCESS) {
2270             HcfObjDestroy(tmpGenerator);
2271             continue;
2272         }
2273         HcfBlob tmpPubKeyBlob = {
2274             .data = nullptr,
2275             .len = 0
2276         };
2277         res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
2278         if (res != HCF_SUCCESS) {
2279             HcfObjDestroy(tmpKeyPair);
2280             HcfObjDestroy(tmpGenerator);
2281             continue;
2282         }
2283         HcfBlob tmpPriKeyBlob = {
2284             .data = nullptr,
2285             .len = 0
2286         };
2287         res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
2288         if (res != HCF_SUCCESS) {
2289             HcfFree(tmpPubKeyBlob.data);
2290             HcfObjDestroy(tmpKeyPair);
2291             HcfObjDestroy(tmpGenerator);
2292             continue;
2293         }
2294         HcfKeyPair *tmpOutKeyPair = nullptr;
2295         res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
2296         HcfFree(tmpPubKeyBlob.data);
2297         HcfFree(tmpPriKeyBlob.data);
2298         HcfObjDestroy(tmpKeyPair);
2299         HcfObjDestroy(tmpGenerator);
2300         if (res == HCF_SUCCESS) {
2301             HcfObjDestroy(tmpOutKeyPair);
2302         }
2303     }
2304 }
2305 
2306 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest702, TestSize.Level0)
2307 {
2308     StartRecordOpensslCallNum();
2309     HcfAsyKeyGenerator *generator = nullptr;
2310     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
2311 
2312     HcfKeyPair *keyPair = nullptr;
2313     res = generator->generateKeyPair(generator, nullptr, &keyPair);
2314 
2315     ASSERT_EQ(res, HCF_SUCCESS);
2316     ASSERT_NE(keyPair, nullptr);
2317 
2318     HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
2319     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
2320 
2321     ASSERT_EQ(res, HCF_SUCCESS);
2322     ASSERT_NE(pubKeyBlob.data, nullptr);
2323     ASSERT_NE(pubKeyBlob.len, 0);
2324 
2325     HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
2326     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
2327 
2328     ASSERT_EQ(res, HCF_SUCCESS);
2329     ASSERT_NE(priKeyBlob.data, nullptr);
2330     ASSERT_NE(priKeyBlob.len, 0);
2331 
2332     HcfKeyPair *outKeyPair = nullptr;
2333     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
2334 
2335     HcfFree(pubKeyBlob.data);
2336     HcfFree(priKeyBlob.data);
2337     HcfObjDestroy(outKeyPair);
2338     HcfObjDestroy(keyPair);
2339     HcfObjDestroy(generator);
2340 
2341     uint32_t mallocCount = GetOpensslCallNum();
2342     OpensslMockTestFunc(mallocCount);
2343 
2344     EndRecordOpensslCallNum();
2345 }
2346 
2347 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccPrvKeyDerConvertTest801, TestSize.Level0)
2348 {
2349     HcfAsyKeyGenerator *generator = nullptr;
2350     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
2351     const char *wrongFormat = "PKCS7";
2352     const char *format = "PKCS8";
2353     HcfKeyPair *keyPair = nullptr;
2354     res = generator->generateKeyPair(generator, nullptr, &keyPair);
2355 
2356     ASSERT_EQ(res, HCF_SUCCESS);
2357     ASSERT_NE(keyPair, nullptr);
2358 
2359     HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
2360     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
2361     ASSERT_EQ(res, HCF_SUCCESS);
2362     ASSERT_NE(pubKeyBlob.data, nullptr);
2363     ASSERT_NE(pubKeyBlob.len, 0);
2364 
2365     HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
2366     res = keyPair->priKey->getEncodedDer(keyPair->priKey, wrongFormat, &priKeyBlob);
2367     ASSERT_EQ(res, HCF_INVALID_PARAMS);
2368     ASSERT_EQ(priKeyBlob.data, nullptr);
2369     ASSERT_EQ(priKeyBlob.len, 0);
2370 
2371     res = keyPair->priKey->getEncodedDer(nullptr, format, nullptr);
2372     ASSERT_EQ(res, HCF_INVALID_PARAMS);
2373     ASSERT_EQ(priKeyBlob.data, nullptr);
2374     ASSERT_EQ(priKeyBlob.len, 0);
2375 
2376     res = keyPair->priKey->getEncodedDer(keyPair->priKey, format, &priKeyBlob);
2377     ASSERT_EQ(res, HCF_SUCCESS);
2378     ASSERT_NE(priKeyBlob.data, nullptr);
2379     ASSERT_NE(priKeyBlob.len, 0);
2380 
2381     HcfKeyPair *outKeyPair = nullptr;
2382     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
2383     ASSERT_EQ(res, HCF_SUCCESS);
2384 
2385     HcfFree(pubKeyBlob.data);
2386     HcfFree(priKeyBlob.data);
2387     HcfObjDestroy(outKeyPair);
2388     HcfObjDestroy(keyPair);
2389     HcfObjDestroy(generator);
2390 
2391     EndRecordMallocNum();
2392 }
2393 
2394 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest901, TestSize.Level0)
2395 {
2396     HcfAsyKeyGenerator *generator = nullptr;
2397     int32_t res = HcfAsyKeyGeneratorCreate("ECC_Secp256k1", &generator);
2398 
2399     HcfKeyPair *keyPair = nullptr;
2400     res = generator->generateKeyPair(generator, nullptr, &keyPair);
2401     ASSERT_EQ(res, HCF_SUCCESS);
2402     ASSERT_NE(keyPair, nullptr);
2403 
2404     HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
2405     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
2406     ASSERT_EQ(res, HCF_SUCCESS);
2407 
2408     HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
2409     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
2410     ASSERT_EQ(res, HCF_SUCCESS);
2411 
2412     HcfKeyPair *outKeyPair = nullptr;
2413     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
2414     ASSERT_EQ(res, HCF_SUCCESS);
2415     ASSERT_NE(outKeyPair, nullptr);
2416 
2417     HcfBlob outPubKeyBlob = { .data = nullptr, .len = 0 };
2418     res = outKeyPair->pubKey->base.getEncoded(&(outKeyPair->pubKey->base), &outPubKeyBlob);
2419     ASSERT_EQ(res, HCF_SUCCESS);
2420     ASSERT_NE(outPubKeyBlob.data, nullptr);
2421     ASSERT_NE(outPubKeyBlob.len, 0);
2422 
2423     HcfBlob outPriKeyBlob = { .data = nullptr, .len = 0 };
2424     res = outKeyPair->priKey->base.getEncoded(&(outKeyPair->priKey->base), &outPriKeyBlob);
2425     ASSERT_EQ(res, HCF_SUCCESS);
2426     ASSERT_NE(outPriKeyBlob.data, nullptr);
2427     ASSERT_NE(outPriKeyBlob.len, 0);
2428 
2429     HcfFree(pubKeyBlob.data);
2430     HcfFree(priKeyBlob.data);
2431     HcfFree(outPubKeyBlob.data);
2432     HcfFree(outPriKeyBlob.data);
2433     HcfObjDestroy(outKeyPair);
2434     HcfObjDestroy(keyPair);
2435     HcfObjDestroy(generator);
2436 }
2437 
2438 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest902, TestSize.Level0)
2439 {
2440     HcfAsyKeyGenParams params = {
2441         .algo = HCF_ALG_ECC,
2442         .bits = HCF_ALG_ECC_SECP256K1,
2443         .primes = HCF_OPENSSL_PRIMES_2,
2444     };
2445 
2446     HcfAsyKeyGeneratorSpi *spiObj = nullptr;
2447     int32_t res = HcfAsyKeyGeneratorSpiEccCreate(&params, &spiObj);
2448     ASSERT_EQ(res, HCF_SUCCESS);
2449     ASSERT_NE(spiObj, nullptr);
2450 
2451     spiObj->base.destroy(&g_obj);
2452     HcfObjDestroy(spiObj);
2453 }
2454 
2455 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest903, TestSize.Level0)
2456 {
2457     HcfAsyKeyGenerator *generator = nullptr;
2458     int32_t res = HcfAsyKeyGeneratorCreate("ECC_secp256k1", &generator);
2459     ASSERT_NE(res, HCF_SUCCESS);
2460     ASSERT_EQ(generator, nullptr);
2461 }
2462 }
2463