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 <cstring>
18 
19 #include "asy_key_generator.h"
20 #include "ecc_common_param_spec.h"
21 #include "blob.h"
22 #include "ecc_key_util.h"
23 #include "ecc_openssl_common.h"
24 #include "ecc_openssl_common_param_spec.h"
25 #include "ecc_common.h"
26 #include "ecdsa_openssl.h"
27 #include "memory.h"
28 #include "securec.h"
29 #include "memory_mock.h"
30 #include "openssl_adapter_mock.h"
31 #include "openssl_common.h"
32 #include "asy_key_params.h"
33 #include "params_parser.h"
34 #include "ecc_common_param_spec_generator_openssl.h"
35 
36 using namespace std;
37 using namespace testing::ext;
38 
39 namespace {
40 class CryptoEccKeyUtilTest : public testing::Test {
41 public:
SetUpTestCase()42     static void SetUpTestCase() {};
TearDownTestCase()43     static void TearDownTestCase() {};
44     void SetUp();
45     void TearDown();
46 };
47 
48 static string g_brainpool160r1AlgName = "ECC_BrainPoolP160r1";
49 static string g_brainpool160t1AlgName = "ECC_BrainPoolP160t1";
50 static string g_brainpool192r1AlgName = "ECC_BrainPoolP192r1";
51 static string g_brainpool192t1AlgName = "ECC_BrainPoolP192t1";
52 static string g_brainpool224r1AlgName = "ECC_BrainPoolP224r1";
53 static string g_brainpool224t1AlgName = "ECC_BrainPoolP224t1";
54 static string g_brainpool256r1AlgName = "ECC_BrainPoolP256r1";
55 static string g_brainpool256t1AlgName = "ECC_BrainPoolP256t1";
56 static string g_brainpool320r1AlgName = "ECC_BrainPoolP320r1";
57 static string g_brainpool320t1AlgName = "ECC_BrainPoolP320t1";
58 static string g_brainpool384r1AlgName = "ECC_BrainPoolP384r1";
59 static string g_brainpool384t1AlgName = "ECC_BrainPoolP384t1";
60 static string g_brainpool512r1AlgName = "ECC_BrainPoolP512r1";
61 static string g_brainpool512t1AlgName = "ECC_BrainPoolP512t1";
62 
63 HcfEccCommParamsSpec *g_brainpool160r1CommSpec = nullptr;
64 HcfEccCommParamsSpec *g_brainpool160t1CommSpec = nullptr;
65 HcfEccCommParamsSpec *g_brainpool192r1CommSpec = nullptr;
66 HcfEccCommParamsSpec *g_brainpool192t1CommSpec = nullptr;
67 HcfEccCommParamsSpec *g_brainpool224r1CommSpec = nullptr;
68 HcfEccCommParamsSpec *g_brainpool224t1CommSpec = nullptr;
69 HcfEccCommParamsSpec *g_brainpool256r1CommSpec = nullptr;
70 HcfEccCommParamsSpec *g_brainpool256t1CommSpec = nullptr;
71 HcfEccCommParamsSpec *g_brainpool320r1CommSpec = nullptr;
72 HcfEccCommParamsSpec *g_brainpool320t1CommSpec = nullptr;
73 HcfEccCommParamsSpec *g_brainpool384r1CommSpec = nullptr;
74 HcfEccCommParamsSpec *g_brainpool384t1CommSpec = nullptr;
75 HcfEccCommParamsSpec *g_brainpool512r1CommSpec = nullptr;
76 HcfEccCommParamsSpec *g_brainpool512t1CommSpec = nullptr;
77 
SetUp()78 void CryptoEccKeyUtilTest::SetUp() {}
TearDown()79 void CryptoEccKeyUtilTest::TearDown() {}
80 
81 static const char *g_mockMessage = "hello world";
82 static HcfBlob g_mockInput = {
83     .data = (uint8_t *)g_mockMessage,
84     .len = 12
85 };
86 
GetMockClass(void)87 static const char *GetMockClass(void)
88 {
89     return "HcfEcc";
90 }
91 
92 HcfObjectBase g_obj = {
93     .getClass = GetMockClass,
94     .destroy = nullptr
95 };
96 
97 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_1, TestSize.Level0)
98 {
99     HcfEccCommParamsSpec *returnCommonParamSpec;
100     HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP160r1", &returnCommonParamSpec);
101     ASSERT_EQ(res, HCF_SUCCESS);
102     ASSERT_NE(returnCommonParamSpec, nullptr);
103 
104     FreeEccCommParamsSpec(returnCommonParamSpec);
105 }
106 
107 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_2, TestSize.Level0)
108 {
109     HcfEccCommParamsSpec *returnCommonParamSpec;
110     HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP160t1", &returnCommonParamSpec);
111     ASSERT_EQ(res, HCF_SUCCESS);
112     ASSERT_NE(returnCommonParamSpec, nullptr);
113 
114     FreeEccCommParamsSpec(returnCommonParamSpec);
115 }
116 
117 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_3, TestSize.Level0)
118 {
119     HcfEccCommParamsSpec *returnCommonParamSpec;
120     HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP192r1", &returnCommonParamSpec);
121     ASSERT_EQ(res, HCF_SUCCESS);
122     ASSERT_NE(returnCommonParamSpec, nullptr);
123 
124     FreeEccCommParamsSpec(returnCommonParamSpec);
125 }
126 
127 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_4, TestSize.Level0)
128 {
129     HcfEccCommParamsSpec *returnCommonParamSpec;
130     HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP192t1", &returnCommonParamSpec);
131     ASSERT_EQ(res, HCF_SUCCESS);
132     ASSERT_NE(returnCommonParamSpec, nullptr);
133 
134     FreeEccCommParamsSpec(returnCommonParamSpec);
135 }
136 
137 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_5, TestSize.Level0)
138 {
139     HcfEccCommParamsSpec *returnCommonParamSpec;
140     HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP224r1", &returnCommonParamSpec);
141     ASSERT_EQ(res, HCF_SUCCESS);
142     ASSERT_NE(returnCommonParamSpec, nullptr);
143 
144     FreeEccCommParamsSpec(returnCommonParamSpec);
145 }
146 
147 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_6, TestSize.Level0)
148 {
149     HcfEccCommParamsSpec *returnCommonParamSpec;
150     HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP224t1", &returnCommonParamSpec);
151     ASSERT_EQ(res, HCF_SUCCESS);
152     ASSERT_NE(returnCommonParamSpec, nullptr);
153 
154     FreeEccCommParamsSpec(returnCommonParamSpec);
155 }
156 
157 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_7, TestSize.Level0)
158 {
159     HcfEccCommParamsSpec *returnCommonParamSpec;
160     HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP256r1", &returnCommonParamSpec);
161     ASSERT_EQ(res, HCF_SUCCESS);
162     ASSERT_NE(returnCommonParamSpec, nullptr);
163 
164     FreeEccCommParamsSpec(returnCommonParamSpec);
165 }
166 
167 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_8, TestSize.Level0)
168 {
169     HcfEccCommParamsSpec *returnCommonParamSpec;
170     HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP256t1", &returnCommonParamSpec);
171     ASSERT_EQ(res, HCF_SUCCESS);
172     ASSERT_NE(returnCommonParamSpec, nullptr);
173 
174     FreeEccCommParamsSpec(returnCommonParamSpec);
175 }
176 
177 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_9, TestSize.Level0)
178 {
179     HcfEccCommParamsSpec *returnCommonParamSpec;
180     HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP320r1", &returnCommonParamSpec);
181     ASSERT_EQ(res, HCF_SUCCESS);
182     ASSERT_NE(returnCommonParamSpec, nullptr);
183 
184     FreeEccCommParamsSpec(returnCommonParamSpec);
185 }
186 
187 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_10, TestSize.Level0)
188 {
189     HcfEccCommParamsSpec *returnCommonParamSpec;
190     HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP320t1", &returnCommonParamSpec);
191     ASSERT_EQ(res, HCF_SUCCESS);
192     ASSERT_NE(returnCommonParamSpec, nullptr);
193 
194     FreeEccCommParamsSpec(returnCommonParamSpec);
195 }
196 
197 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_11, TestSize.Level0)
198 {
199     HcfEccCommParamsSpec *returnCommonParamSpec;
200     HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP384r1", &returnCommonParamSpec);
201     ASSERT_EQ(res, HCF_SUCCESS);
202     ASSERT_NE(returnCommonParamSpec, nullptr);
203 
204     FreeEccCommParamsSpec(returnCommonParamSpec);
205 }
206 
207 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_12, TestSize.Level0)
208 {
209     HcfEccCommParamsSpec *returnCommonParamSpec;
210     HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP384t1", &returnCommonParamSpec);
211     ASSERT_EQ(res, HCF_SUCCESS);
212     ASSERT_NE(returnCommonParamSpec, nullptr);
213 
214     FreeEccCommParamsSpec(returnCommonParamSpec);
215 }
216 
217 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_13, TestSize.Level0)
218 {
219     HcfEccCommParamsSpec *returnCommonParamSpec;
220     HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP512r1", &returnCommonParamSpec);
221     ASSERT_EQ(res, HCF_SUCCESS);
222     ASSERT_NE(returnCommonParamSpec, nullptr);
223 
224     FreeEccCommParamsSpec(returnCommonParamSpec);
225 }
226 
227 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_14, TestSize.Level0)
228 {
229     HcfEccCommParamsSpec *returnCommonParamSpec;
230     HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP512t1", &returnCommonParamSpec);
231     ASSERT_EQ(res, HCF_SUCCESS);
232     ASSERT_NE(returnCommonParamSpec, nullptr);
233 
234     FreeEccCommParamsSpec(returnCommonParamSpec);
235 }
236 
237 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_15, TestSize.Level0)
238 {
239     HcfEccCommParamsSpec *returnCommonParamSpec;
240     HcfResult res = HcfEccKeyUtilCreate("NID_secp224r1", &returnCommonParamSpec);
241     ASSERT_EQ(res, HCF_SUCCESS);
242     ASSERT_NE(returnCommonParamSpec, nullptr);
243 
244     FreeEccCommParamsSpec(returnCommonParamSpec);
245 }
246 
247 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_16, TestSize.Level0)
248 {
249     HcfEccCommParamsSpec *returnCommonParamSpec;
250     HcfResult res = HcfEccKeyUtilCreate("NID_X9_62_prime256v1", &returnCommonParamSpec);
251     ASSERT_EQ(res, HCF_SUCCESS);
252     ASSERT_NE(returnCommonParamSpec, nullptr);
253 
254     FreeEccCommParamsSpec(returnCommonParamSpec);
255 }
256 
257 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_17, TestSize.Level0)
258 {
259     HcfEccCommParamsSpec *returnCommonParamSpec;
260     HcfResult res = HcfEccKeyUtilCreate("NID_secp384r1", &returnCommonParamSpec);
261     ASSERT_EQ(res, HCF_SUCCESS);
262     ASSERT_NE(returnCommonParamSpec, nullptr);
263 
264     FreeEccCommParamsSpec(returnCommonParamSpec);
265 }
266 
267 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_18, TestSize.Level0)
268 {
269     HcfEccCommParamsSpec *returnCommonParamSpec;
270     HcfResult res = HcfEccKeyUtilCreate("NID_secp521r1", &returnCommonParamSpec);
271     ASSERT_EQ(res, HCF_SUCCESS);
272     ASSERT_NE(returnCommonParamSpec, nullptr);
273 
274     FreeEccCommParamsSpec(returnCommonParamSpec);
275 }
276 
277 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_19, TestSize.Level0)
278 {
279     HcfEccCommParamsSpec *returnCommonParamSpec;
280     HcfResult res = HcfEccKeyUtilCreate("NID_sm2", &returnCommonParamSpec);
281     ASSERT_EQ(res, HCF_SUCCESS);
282     ASSERT_NE(returnCommonParamSpec, nullptr);
283 
284     FreeEccCommParamsSpec(returnCommonParamSpec);
285 }
286 
287 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest002, TestSize.Level0)
288 {
289     HcfEccCommParamsSpec *returnCommonParamSpec;
290     HcfResult res = HcfEccKeyUtilCreate(nullptr, &returnCommonParamSpec);
291     ASSERT_NE(res, HCF_SUCCESS);
292     ASSERT_EQ(returnCommonParamSpec, nullptr);
293 
294     FreeEccCommParamsSpec(returnCommonParamSpec);
295 }
296 
297 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest003, TestSize.Level0)
298 {
299     HcfResult res = HcfEccKeyUtilCreate("ECC_BrainPoolP160r1", nullptr);
300     ASSERT_NE(res, HCF_SUCCESS);
301 }
302 
303 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest004, TestSize.Level0)
304 {
305     HcfEccCommParamsSpec *returnCommonParamSpec;
306     HcfResult res = HcfEccKeyUtilCreate("BrainPoolP999", &returnCommonParamSpec);
307     ASSERT_NE(res, HCF_SUCCESS);
308     ASSERT_EQ(returnCommonParamSpec, nullptr);
309 
310     FreeEccCommParamsSpec(returnCommonParamSpec);
311 }
312 
313 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest005, TestSize.Level0)
314 {
315     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
316     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
317     HcfAsyKeyParamsSpec *paramSpec = nullptr;
318     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
319         g_brainpool160r1CommSpec, &paramSpec);
320     ASSERT_EQ(res, HCF_SUCCESS);
321     ASSERT_NE(paramSpec, nullptr);
322 
323     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
324     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
325     ASSERT_EQ(res, HCF_SUCCESS);
326     ASSERT_NE(returnObj, nullptr);
327 
328     const char *classname = returnObj->base.getClass();
329     ASSERT_EQ(res, HCF_SUCCESS);
330     ASSERT_NE(classname, nullptr);
331 
332     HcfObjDestroy(returnObj);
333     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
334 }
335 
336 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest006, TestSize.Level0)
337 {
338     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
339     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
340     HcfAsyKeyParamsSpec *paramSpec = nullptr;
341     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
342         g_brainpool160r1CommSpec, &paramSpec);
343     ASSERT_EQ(res, HCF_SUCCESS);
344     ASSERT_NE(paramSpec, nullptr);
345 
346     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
347     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
348     ASSERT_EQ(res, HCF_SUCCESS);
349     ASSERT_NE(returnObj, nullptr);
350 
351     returnObj->base.destroy(&g_obj);
352     HcfObjDestroy(returnObj);
353     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
354 }
355 
356 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest007, TestSize.Level0)
357 {
358     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
359     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
360     HcfAsyKeyParamsSpec *paramSpec = nullptr;
361     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
362         g_brainpool160r1CommSpec, &paramSpec);
363     ASSERT_EQ(res, HCF_SUCCESS);
364     ASSERT_NE(paramSpec, nullptr);
365 
366     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
367     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
368     ASSERT_EQ(res, HCF_SUCCESS);
369     ASSERT_NE(returnObj, nullptr);
370 
371     const char *algName = returnObj->getAlgName(returnObj);
372     ASSERT_NE(algName, nullptr);
373     HcfObjDestroy(returnObj);
374     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
375 }
376 
377 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest008, TestSize.Level0)
378 {
379     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
380     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
381     HcfAsyKeyParamsSpec *paramSpec = nullptr;
382     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
383         g_brainpool160r1CommSpec, &paramSpec);
384     ASSERT_EQ(res, HCF_SUCCESS);
385     ASSERT_NE(paramSpec, nullptr);
386 
387     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
388     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
389     ASSERT_EQ(res, HCF_SUCCESS);
390     ASSERT_NE(returnObj, nullptr);
391 
392     HcfKeyPair *returnKeyPair = nullptr;
393     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
394     ASSERT_EQ(res, HCF_SUCCESS);
395     ASSERT_NE(returnKeyPair, nullptr);
396 
397     HcfObjDestroy(returnObj);
398     HcfObjDestroy(returnKeyPair);
399     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
400 }
401 
402 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest009, TestSize.Level0)
403 {
404     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
405     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
406     HcfAsyKeyParamsSpec *paramSpec = nullptr;
407     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
408         g_brainpool160r1CommSpec, &paramSpec);
409     ASSERT_EQ(res, HCF_SUCCESS);
410     ASSERT_NE(paramSpec, nullptr);
411 
412     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
413     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
414     ASSERT_EQ(res, HCF_SUCCESS);
415     ASSERT_NE(returnObj, nullptr);
416 
417     HcfKeyPair *returnKeyPair = nullptr;
418     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
419     const char *classname = returnKeyPair->base.getClass();
420     ASSERT_EQ(res, HCF_SUCCESS);
421     ASSERT_NE(returnKeyPair, nullptr);
422     ASSERT_NE(classname, nullptr);
423 
424     HcfObjDestroy(returnKeyPair);
425     HcfObjDestroy(returnObj);
426     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
427 }
428 
429 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest010, TestSize.Level0)
430 {
431     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
432     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
433     HcfAsyKeyParamsSpec *paramSpec = nullptr;
434     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
435         g_brainpool160r1CommSpec, &paramSpec);
436     ASSERT_EQ(res, HCF_SUCCESS);
437     ASSERT_NE(paramSpec, nullptr);
438 
439     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
440     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
441     ASSERT_EQ(res, HCF_SUCCESS);
442     ASSERT_NE(returnObj, nullptr);
443 
444     HcfKeyPair *returnKeyPair = nullptr;
445     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
446     ASSERT_EQ(res, HCF_SUCCESS);
447     ASSERT_NE(returnKeyPair, nullptr);
448 
449     returnKeyPair->base.destroy(&(returnKeyPair->base));
450     HcfObjDestroy(returnObj);
451     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
452 }
453 
454 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest011, TestSize.Level0)
455 {
456     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
457     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
458     HcfAsyKeyParamsSpec *paramSpec = nullptr;
459     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
460         g_brainpool160r1CommSpec, &paramSpec);
461     ASSERT_EQ(res, HCF_SUCCESS);
462     ASSERT_NE(paramSpec, nullptr);
463 
464     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
465     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
466     ASSERT_EQ(res, HCF_SUCCESS);
467     ASSERT_NE(returnObj, nullptr);
468 
469     HcfKeyPair *returnKeyPair = nullptr;
470     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
471     ASSERT_EQ(res, HCF_SUCCESS);
472     ASSERT_NE(returnKeyPair, nullptr);
473 
474     returnKeyPair->base.destroy(nullptr);
475     HcfObjDestroy(returnKeyPair);
476     HcfObjDestroy(returnObj);
477     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
478 }
479 
480 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest012, TestSize.Level0)
481 {
482     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
483     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
484     HcfAsyKeyParamsSpec *paramSpec = nullptr;
485     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
486         g_brainpool160r1CommSpec, &paramSpec);
487     ASSERT_EQ(res, HCF_SUCCESS);
488     ASSERT_NE(paramSpec, nullptr);
489 
490     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
491     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
492     ASSERT_EQ(res, HCF_SUCCESS);
493     ASSERT_NE(returnObj, nullptr);
494 
495     HcfKeyPair *returnKeyPair = nullptr;
496     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
497     ASSERT_EQ(res, HCF_SUCCESS);
498     ASSERT_NE(returnKeyPair, nullptr);
499 
500     returnKeyPair->base.destroy(&g_obj);
501     HcfObjDestroy(returnKeyPair);
502     HcfObjDestroy(returnObj);
503     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
504 }
505 
506 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest013, TestSize.Level0)
507 {
508     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
509     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
510     HcfAsyKeyParamsSpec *paramSpec = nullptr;
511     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
512         g_brainpool160r1CommSpec, &paramSpec);
513     ASSERT_EQ(res, HCF_SUCCESS);
514     ASSERT_NE(paramSpec, nullptr);
515 
516     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
517     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
518     ASSERT_EQ(res, HCF_SUCCESS);
519     ASSERT_NE(returnObj, nullptr);
520 
521     HcfKeyPair *returnKeyPair = nullptr;
522     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
523     const char *classname = returnKeyPair->pubKey->base.base.getClass();
524     ASSERT_EQ(res, HCF_SUCCESS);
525     ASSERT_NE(returnKeyPair, nullptr);
526     ASSERT_NE(classname, nullptr);
527 
528     HcfObjDestroy(returnKeyPair);
529     HcfObjDestroy(returnObj);
530     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
531 }
532 
533 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest014, TestSize.Level0)
534 {
535     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
536     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
537     HcfAsyKeyParamsSpec *paramSpec = nullptr;
538     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
539         g_brainpool160r1CommSpec, &paramSpec);
540     ASSERT_EQ(res, HCF_SUCCESS);
541     ASSERT_NE(paramSpec, nullptr);
542 
543     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
544     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
545     ASSERT_EQ(res, HCF_SUCCESS);
546     ASSERT_NE(returnObj, nullptr);
547 
548     HcfKeyPair *returnKeyPair = nullptr;
549     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
550     ASSERT_EQ(res, HCF_SUCCESS);
551     ASSERT_NE(returnKeyPair, nullptr);
552 
553     returnKeyPair->pubKey->base.base.destroy(&(returnKeyPair->pubKey->base.base));
554     returnKeyPair->pubKey = nullptr;
555     HcfObjDestroy(returnKeyPair);
556     HcfObjDestroy(returnObj);
557     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
558 }
559 
560 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest015, TestSize.Level0)
561 {
562     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
563     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
564     HcfAsyKeyParamsSpec *paramSpec = nullptr;
565     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
566         g_brainpool160r1CommSpec, &paramSpec);
567     ASSERT_EQ(res, HCF_SUCCESS);
568     ASSERT_NE(paramSpec, nullptr);
569 
570     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
571     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
572     ASSERT_EQ(res, HCF_SUCCESS);
573     ASSERT_NE(returnObj, nullptr);
574 
575     HcfKeyPair *returnKeyPair = nullptr;
576     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
577     ASSERT_EQ(res, HCF_SUCCESS);
578     ASSERT_NE(returnKeyPair, nullptr);
579 
580     returnKeyPair->pubKey->base.base.destroy(nullptr);
581     returnKeyPair->pubKey = nullptr;
582     HcfObjDestroy(returnKeyPair);
583     HcfObjDestroy(returnObj);
584     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
585 }
586 
587 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest016, TestSize.Level0)
588 {
589     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
590     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
591     HcfAsyKeyParamsSpec *paramSpec = nullptr;
592     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
593         g_brainpool160r1CommSpec, &paramSpec);
594     ASSERT_EQ(res, HCF_SUCCESS);
595     ASSERT_NE(paramSpec, nullptr);
596 
597     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
598     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
599     ASSERT_EQ(res, HCF_SUCCESS);
600     ASSERT_NE(returnObj, nullptr);
601 
602     HcfKeyPair *returnKeyPair = nullptr;
603     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
604     ASSERT_EQ(res, HCF_SUCCESS);
605     ASSERT_NE(returnKeyPair, nullptr);
606 
607     returnKeyPair->pubKey->base.base.destroy(&g_obj);
608     HcfObjDestroy(returnKeyPair);
609     HcfObjDestroy(returnObj);
610     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
611 }
612 
613 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest017, TestSize.Level0)
614 {
615     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
616     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
617     HcfAsyKeyParamsSpec *paramSpec = nullptr;
618     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
619         g_brainpool160r1CommSpec, &paramSpec);
620     ASSERT_EQ(res, HCF_SUCCESS);
621     ASSERT_NE(paramSpec, nullptr);
622 
623     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
624     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
625     ASSERT_EQ(res, HCF_SUCCESS);
626     ASSERT_NE(returnObj, nullptr);
627 
628     HcfKeyPair *returnKeyPair = nullptr;
629     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
630     const char * format = returnKeyPair->pubKey->base.getFormat(&(returnKeyPair->pubKey->base));
631     ASSERT_EQ(res, HCF_SUCCESS);
632     ASSERT_NE(returnKeyPair, nullptr);
633     ASSERT_NE(format, nullptr);
634 
635     HcfObjDestroy(returnKeyPair);
636     HcfObjDestroy(returnObj);
637     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
638 }
639 
640 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest018, TestSize.Level0)
641 {
642     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
643     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
644     HcfAsyKeyParamsSpec *paramSpec = nullptr;
645     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
646         g_brainpool160r1CommSpec, &paramSpec);
647     ASSERT_EQ(res, HCF_SUCCESS);
648     ASSERT_NE(paramSpec, nullptr);
649 
650     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
651     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
652     ASSERT_EQ(res, HCF_SUCCESS);
653     ASSERT_NE(returnObj, nullptr);
654 
655     HcfKeyPair *returnKeyPair = nullptr;
656     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
657     const char * algorithm = returnKeyPair->pubKey->base.getAlgorithm(&(returnKeyPair->pubKey->base));
658     ASSERT_EQ(res, HCF_SUCCESS);
659     ASSERT_NE(returnKeyPair, nullptr);
660     ASSERT_NE(algorithm, nullptr);
661 
662     HcfObjDestroy(returnKeyPair);
663     HcfObjDestroy(returnObj);
664     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
665 }
666 
667 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest019, TestSize.Level0)
668 {
669     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
670     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
671     HcfAsyKeyParamsSpec *paramSpec = nullptr;
672     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
673         g_brainpool160r1CommSpec, &paramSpec);
674     ASSERT_EQ(res, HCF_SUCCESS);
675     ASSERT_NE(paramSpec, nullptr);
676 
677     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
678     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
679     ASSERT_EQ(res, HCF_SUCCESS);
680     ASSERT_NE(returnObj, nullptr);
681 
682     HcfKeyPair *returnKeyPair = nullptr;
683     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
684     HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
685     res = returnKeyPair->pubKey->base.getEncoded(&(returnKeyPair->pubKey->base), &pubKeyBlob);
686     ASSERT_EQ(res, HCF_SUCCESS);
687     ASSERT_NE(returnKeyPair, nullptr);
688 
689     HcfObjDestroy(returnKeyPair);
690     HcfObjDestroy(returnObj);
691     HcfBlobDataFree(&pubKeyBlob);
692     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
693 }
694 
695 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest020, TestSize.Level0)
696 {
697     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
698     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
699     HcfAsyKeyParamsSpec *paramSpec = nullptr;
700     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
701         g_brainpool160r1CommSpec, &paramSpec);
702     ASSERT_EQ(res, HCF_SUCCESS);
703     ASSERT_NE(paramSpec, nullptr);
704 
705     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
706     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
707     ASSERT_EQ(res, HCF_SUCCESS);
708     ASSERT_NE(returnObj, nullptr);
709 
710     HcfKeyPair *returnKeyPair = nullptr;
711     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
712     returnKeyPair->priKey->clearMem(returnKeyPair->priKey);
713     ASSERT_EQ(res, HCF_SUCCESS);
714     ASSERT_NE(returnKeyPair, nullptr);
715 
716     HcfObjDestroy(returnKeyPair);
717     HcfObjDestroy(returnObj);
718     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
719 }
720 
721 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest021, TestSize.Level0)
722 {
723     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
724     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
725     HcfAsyKeyParamsSpec *paramSpec = nullptr;
726     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
727         g_brainpool160r1CommSpec, &paramSpec);
728     ASSERT_EQ(res, HCF_SUCCESS);
729     ASSERT_NE(paramSpec, nullptr);
730 
731     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
732     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
733     ASSERT_EQ(res, HCF_SUCCESS);
734     ASSERT_NE(returnObj, nullptr);
735 
736     HcfKeyPair *returnKeyPair = nullptr;
737     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
738     returnKeyPair->priKey->clearMem(nullptr);
739     ASSERT_EQ(res, HCF_SUCCESS);
740     ASSERT_NE(returnKeyPair, nullptr);
741 
742     HcfObjDestroy(returnKeyPair);
743     HcfObjDestroy(returnObj);
744     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
745 }
746 
747 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest022, TestSize.Level0)
748 {
749     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
750     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
751     HcfAsyKeyParamsSpec *paramSpec = nullptr;
752     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
753         g_brainpool160r1CommSpec, &paramSpec);
754     ASSERT_EQ(res, HCF_SUCCESS);
755     ASSERT_NE(paramSpec, nullptr);
756 
757     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
758     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
759     ASSERT_EQ(res, HCF_SUCCESS);
760     ASSERT_NE(returnObj, nullptr);
761 
762     HcfKeyPair *returnKeyPair = nullptr;
763     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
764     returnKeyPair->priKey->clearMem((HcfPriKey *)&g_obj);
765     ASSERT_EQ(res, HCF_SUCCESS);
766     ASSERT_NE(returnKeyPair, nullptr);
767 
768     HcfObjDestroy(returnKeyPair);
769     HcfObjDestroy(returnObj);
770     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
771 }
772 
773 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest023, TestSize.Level0)
774 {
775     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
776     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
777     HcfAsyKeyParamsSpec *paramSpec = nullptr;
778     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
779         g_brainpool160r1CommSpec, &paramSpec);
780     ASSERT_EQ(res, HCF_SUCCESS);
781     ASSERT_NE(paramSpec, nullptr);
782 
783     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
784     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
785     ASSERT_EQ(res, HCF_SUCCESS);
786     ASSERT_NE(returnObj, nullptr);
787 
788     HcfKeyPair *returnKeyPair = nullptr;
789     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
790     const char *classname = returnKeyPair->priKey->base.base.getClass();
791     ASSERT_EQ(res, HCF_SUCCESS);
792     ASSERT_NE(returnKeyPair, nullptr);
793     ASSERT_NE(classname, nullptr);
794 
795     HcfObjDestroy(returnKeyPair);
796     HcfObjDestroy(returnObj);
797     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
798 }
799 
800 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest024, TestSize.Level0)
801 {
802     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
803     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
804     HcfAsyKeyParamsSpec *paramSpec = nullptr;
805     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
806         g_brainpool160r1CommSpec, &paramSpec);
807     ASSERT_EQ(res, HCF_SUCCESS);
808     ASSERT_NE(paramSpec, nullptr);
809 
810     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
811     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
812     ASSERT_EQ(res, HCF_SUCCESS);
813     ASSERT_NE(returnObj, nullptr);
814 
815     HcfKeyPair *returnKeyPair = nullptr;
816     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
817     ASSERT_EQ(res, HCF_SUCCESS);
818     ASSERT_NE(returnKeyPair, nullptr);
819 
820     returnKeyPair->priKey->base.base.destroy(&(returnKeyPair->priKey->base.base));
821     returnKeyPair->priKey = nullptr;
822     HcfObjDestroy(returnKeyPair);
823     HcfObjDestroy(returnObj);
824     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
825 }
826 
827 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest025, TestSize.Level0)
828 {
829     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
830     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
831     HcfAsyKeyParamsSpec *paramSpec = nullptr;
832     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
833         g_brainpool160r1CommSpec, &paramSpec);
834     ASSERT_EQ(res, HCF_SUCCESS);
835     ASSERT_NE(paramSpec, nullptr);
836 
837     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
838     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
839     ASSERT_EQ(res, HCF_SUCCESS);
840     ASSERT_NE(returnObj, nullptr);
841 
842     HcfKeyPair *returnKeyPair = nullptr;
843     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
844     ASSERT_EQ(res, HCF_SUCCESS);
845     ASSERT_NE(returnKeyPair, nullptr);
846 
847     returnKeyPair->priKey->base.base.destroy(nullptr);
848     returnKeyPair->priKey = nullptr;
849     HcfObjDestroy(returnKeyPair);
850     HcfObjDestroy(returnObj);
851     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
852 }
853 
854 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest026, TestSize.Level0)
855 {
856     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
857     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
858     HcfAsyKeyParamsSpec *paramSpec = nullptr;
859     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
860         g_brainpool160r1CommSpec, &paramSpec);
861     ASSERT_EQ(res, HCF_SUCCESS);
862     ASSERT_NE(paramSpec, nullptr);
863 
864     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
865     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
866     ASSERT_EQ(res, HCF_SUCCESS);
867     ASSERT_NE(returnObj, nullptr);
868 
869     HcfKeyPair *returnKeyPair = nullptr;
870     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
871     ASSERT_EQ(res, HCF_SUCCESS);
872     ASSERT_NE(returnKeyPair, nullptr);
873 
874     returnKeyPair->priKey->base.base.destroy(&g_obj);
875     returnKeyPair->priKey = nullptr;
876     HcfObjDestroy(returnKeyPair);
877     HcfObjDestroy(returnObj);
878     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
879 }
880 
881 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest027, TestSize.Level0)
882 {
883     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
884     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
885     HcfAsyKeyParamsSpec *paramSpec = nullptr;
886     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
887         g_brainpool160r1CommSpec, &paramSpec);
888     ASSERT_EQ(res, HCF_SUCCESS);
889     ASSERT_NE(paramSpec, nullptr);
890 
891     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
892     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
893     ASSERT_EQ(res, HCF_SUCCESS);
894     ASSERT_NE(returnObj, nullptr);
895 
896     HcfKeyPair *returnKeyPair = nullptr;
897     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
898     const char *format = returnKeyPair->priKey->base.getFormat(&(returnKeyPair->priKey->base));
899     ASSERT_EQ(res, HCF_SUCCESS);
900     ASSERT_NE(returnKeyPair, nullptr);
901     ASSERT_NE(format, nullptr);
902 
903     HcfObjDestroy(returnKeyPair);
904     HcfObjDestroy(returnObj);
905     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
906 }
907 
908 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest028, TestSize.Level0)
909 {
910     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
911     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
912     HcfAsyKeyParamsSpec *paramSpec = nullptr;
913     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
914         g_brainpool160r1CommSpec, &paramSpec);
915     ASSERT_EQ(res, HCF_SUCCESS);
916     ASSERT_NE(paramSpec, nullptr);
917 
918     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
919     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
920     ASSERT_EQ(res, HCF_SUCCESS);
921     ASSERT_NE(returnObj, nullptr);
922 
923     HcfKeyPair *returnKeyPair = nullptr;
924     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
925     const char *algorithm = returnKeyPair->priKey->base.getAlgorithm(&(returnKeyPair->priKey->base));
926     ASSERT_EQ(res, HCF_SUCCESS);
927     ASSERT_NE(returnKeyPair, nullptr);
928     ASSERT_NE(algorithm, nullptr);
929 
930     HcfObjDestroy(returnKeyPair);
931     HcfObjDestroy(returnObj);
932     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
933 }
934 
935 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest029, TestSize.Level0)
936 {
937     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
938     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
939     HcfAsyKeyParamsSpec *paramSpec = nullptr;
940     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
941         g_brainpool160r1CommSpec, &paramSpec);
942     ASSERT_EQ(res, HCF_SUCCESS);
943     ASSERT_NE(paramSpec, nullptr);
944 
945     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
946     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
947     ASSERT_EQ(res, HCF_SUCCESS);
948     ASSERT_NE(returnObj, nullptr);
949 
950     HcfKeyPair *returnKeyPair = nullptr;
951     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
952     HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
953     res = returnKeyPair->priKey->base.getEncoded(&(returnKeyPair->priKey->base), &priKeyBlob);
954     ASSERT_EQ(res, HCF_SUCCESS);
955     ASSERT_NE(returnKeyPair, nullptr);
956 
957     HcfObjDestroy(returnKeyPair);
958     HcfObjDestroy(returnObj);
959     HcfBlobDataFree(&priKeyBlob);
960     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
961 }
962 
963 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest030, TestSize.Level0)
964 {
965     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
966     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
967     HcfAsyKeyParamsSpec *paramSpec = nullptr;
968     HcfResult res = ConstructEccPubKeyParamsSpec(g_brainpool160r1AlgName.c_str(), g_brainpool160r1CommSpec,
969         &paramSpec);
970     ASSERT_EQ(res, HCF_SUCCESS);
971     ASSERT_NE(paramSpec, nullptr);
972 
973     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
974     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
975     ASSERT_EQ(res, HCF_SUCCESS);
976     ASSERT_NE(returnObj, nullptr);
977 
978     HcfPubKey *returnPubKey = nullptr;
979     res = returnObj->generatePubKey(returnObj, &returnPubKey);
980     ASSERT_NE(res, HCF_INVALID_PARAMS);
981     ASSERT_NE(returnPubKey, nullptr);
982 
983     HcfObjDestroy(returnPubKey);
984     HcfObjDestroy(returnObj);
985     DestroyEccPubKeySpec(reinterpret_cast<HcfEccPubKeyParamsSpec *>(paramSpec));
986 }
987 
988 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest031, TestSize.Level0)
989 {
990     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
991     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
992     HcfAsyKeyParamsSpec *paramSpec = nullptr;
993     HcfResult res = ConstructEccPubKeyParamsSpec(g_brainpool160r1AlgName.c_str(), g_brainpool160r1CommSpec,
994         &paramSpec);
995     ASSERT_EQ(res, HCF_SUCCESS);
996     ASSERT_NE(paramSpec, nullptr);
997 
998     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
999     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1000     ASSERT_EQ(res, HCF_SUCCESS);
1001     ASSERT_NE(returnObj, nullptr);
1002 
1003     HcfPubKey *returnPubKey = nullptr;
1004     res = returnObj->generatePubKey(returnObj, &returnPubKey);
1005     ASSERT_EQ(res, HCF_SUCCESS);
1006     ASSERT_NE(returnPubKey, nullptr);
1007 
1008     returnPubKey->base.base.destroy(&(returnPubKey->base.base));
1009     HcfObjDestroy(returnObj);
1010     DestroyEccPubKeySpec(reinterpret_cast<HcfEccPubKeyParamsSpec *>(paramSpec));
1011 }
1012 
1013 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest032, TestSize.Level0)
1014 {
1015     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
1016     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
1017     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1018     HcfResult res = ConstructEccPubKeyParamsSpec(g_brainpool160r1AlgName.c_str(), g_brainpool160r1CommSpec,
1019         &paramSpec);
1020     ASSERT_EQ(res, HCF_SUCCESS);
1021     ASSERT_NE(paramSpec, nullptr);
1022 
1023     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1024     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1025     ASSERT_EQ(res, HCF_SUCCESS);
1026     ASSERT_NE(returnObj, nullptr);
1027 
1028     HcfPubKey *returnPubKey = nullptr;
1029     res = returnObj->generatePubKey(returnObj, &returnPubKey);
1030     const char *format = returnPubKey->base.getFormat(&(returnPubKey->base));
1031     ASSERT_EQ(res, HCF_SUCCESS);
1032     ASSERT_NE(format, nullptr);
1033 
1034     HcfObjDestroy(returnPubKey);
1035     HcfObjDestroy(returnObj);
1036     DestroyEccPubKeySpec(reinterpret_cast<HcfEccPubKeyParamsSpec *>(paramSpec));
1037 }
1038 
1039 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest033, TestSize.Level0)
1040 {
1041     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
1042     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
1043     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1044     HcfResult res = ConstructEccPubKeyParamsSpec(g_brainpool160r1AlgName.c_str(), g_brainpool160r1CommSpec,
1045         &paramSpec);
1046     ASSERT_EQ(res, HCF_SUCCESS);
1047     ASSERT_NE(paramSpec, nullptr);
1048 
1049     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1050     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1051     ASSERT_EQ(res, HCF_SUCCESS);
1052     ASSERT_NE(returnObj, nullptr);
1053 
1054     HcfPubKey *returnPubKey = nullptr;
1055     res = returnObj->generatePubKey(returnObj, &returnPubKey);
1056     const char *algorithm = returnPubKey->base.getAlgorithm(&(returnPubKey->base));
1057     ASSERT_EQ(res, HCF_SUCCESS);
1058     ASSERT_NE(algorithm, nullptr);
1059 
1060     HcfObjDestroy(returnPubKey);
1061     HcfObjDestroy(returnObj);
1062     DestroyEccPubKeySpec(reinterpret_cast<HcfEccPubKeyParamsSpec *>(paramSpec));
1063 }
1064 
1065 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest034, TestSize.Level0)
1066 {
1067     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
1068     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
1069     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1070     HcfResult res = ConstructEccPubKeyParamsSpec(g_brainpool160r1AlgName.c_str(), g_brainpool160r1CommSpec,
1071         &paramSpec);
1072     ASSERT_EQ(res, HCF_SUCCESS);
1073     ASSERT_NE(paramSpec, nullptr);
1074 
1075     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1076     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1077     ASSERT_EQ(res, HCF_SUCCESS);
1078     ASSERT_NE(returnObj, nullptr);
1079 
1080     HcfPubKey *returnPubKey = nullptr;
1081     res = returnObj->generatePubKey(returnObj, &returnPubKey);
1082 
1083     HcfBlob blob = { .data = nullptr, .len = 0 };
1084     res = returnPubKey->base.getEncoded(&(returnPubKey->base), &blob);
1085     ASSERT_EQ(res, HCF_SUCCESS);
1086     ASSERT_NE(blob.data, nullptr);
1087     ASSERT_NE(blob.len, 0);
1088     HcfFree(blob.data);
1089     HcfObjDestroy(returnPubKey);
1090     HcfObjDestroy(returnObj);
1091     DestroyEccPubKeySpec(reinterpret_cast<HcfEccPubKeyParamsSpec *>(paramSpec));
1092 }
1093 
1094 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest035, TestSize.Level0)
1095 {
1096     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
1097     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
1098     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1099     HcfResult res = ConstructEccPriKeyParamsSpec(g_brainpool160r1AlgName.c_str(), g_brainpool160r1CommSpec,
1100         &paramSpec);
1101     ASSERT_EQ(res, HCF_SUCCESS);
1102     ASSERT_NE(paramSpec, nullptr);
1103 
1104     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1105     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1106     ASSERT_EQ(res, HCF_SUCCESS);
1107     ASSERT_NE(returnObj, nullptr);
1108 
1109     HcfPriKey *returnPriKey = nullptr;
1110     res = returnObj->generatePriKey(returnObj, &returnPriKey);
1111     ASSERT_EQ(res, HCF_SUCCESS);
1112     ASSERT_NE(returnPriKey, nullptr);
1113 
1114     HcfObjDestroy(returnPriKey);
1115     HcfObjDestroy(returnObj);
1116     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
1117 }
1118 
1119 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest036, TestSize.Level0)
1120 {
1121     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
1122     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
1123     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1124     HcfResult res = ConstructEccPriKeyParamsSpec(g_brainpool160r1AlgName.c_str(), g_brainpool160r1CommSpec,
1125         &paramSpec);
1126     ASSERT_EQ(res, HCF_SUCCESS);
1127     ASSERT_NE(paramSpec, nullptr);
1128 
1129     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1130     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1131     ASSERT_EQ(res, HCF_SUCCESS);
1132     ASSERT_NE(returnObj, nullptr);
1133 
1134     HcfPriKey *returnPriKey = nullptr;
1135     res = returnObj->generatePriKey(returnObj, &returnPriKey);
1136     ASSERT_EQ(res, HCF_SUCCESS);
1137     ASSERT_NE(returnPriKey, nullptr);
1138 
1139     returnPriKey->base.base.destroy(&(returnPriKey->base.base));
1140     HcfObjDestroy(returnObj);
1141     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
1142 }
1143 
1144 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest037, TestSize.Level0)
1145 {
1146     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
1147     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
1148     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1149     HcfResult res = ConstructEccPriKeyParamsSpec(g_brainpool160r1AlgName.c_str(), g_brainpool160r1CommSpec,
1150         &paramSpec);
1151     ASSERT_EQ(res, HCF_SUCCESS);
1152     ASSERT_NE(paramSpec, nullptr);
1153 
1154     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1155     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1156     ASSERT_EQ(res, HCF_SUCCESS);
1157     ASSERT_NE(returnObj, nullptr);
1158 
1159     HcfPriKey *returnPriKey = nullptr;
1160     res = returnObj->generatePriKey(returnObj, &returnPriKey);
1161     returnPriKey->clearMem(returnPriKey);
1162     ASSERT_EQ(res, HCF_SUCCESS);
1163     ASSERT_NE(returnPriKey, nullptr);
1164 
1165     HcfObjDestroy(returnPriKey);
1166     HcfObjDestroy(returnObj);
1167     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
1168 }
1169 
1170 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest038, TestSize.Level0)
1171 {
1172     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
1173     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
1174     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1175     HcfResult res = ConstructEccPriKeyParamsSpec(g_brainpool160r1AlgName.c_str(), g_brainpool160r1CommSpec,
1176         &paramSpec);
1177     ASSERT_EQ(res, HCF_SUCCESS);
1178     ASSERT_NE(paramSpec, nullptr);
1179 
1180     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1181     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1182     ASSERT_EQ(res, HCF_SUCCESS);
1183     ASSERT_NE(returnObj, nullptr);
1184 
1185     HcfPriKey *returnPriKey = nullptr;
1186     res = returnObj->generatePriKey(returnObj, &returnPriKey);
1187     ASSERT_EQ(res, HCF_SUCCESS);
1188     ASSERT_NE(returnPriKey, nullptr);
1189     const char *algorithm = returnPriKey->base.getAlgorithm(&(returnPriKey->base));
1190     ASSERT_NE(algorithm, nullptr);
1191 
1192     HcfObjDestroy(returnPriKey);
1193     HcfObjDestroy(returnObj);
1194     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
1195 }
1196 
1197 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_1, TestSize.Level0)
1198 {
1199     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
1200     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
1201     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1202     int32_t res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
1203         g_brainpool160r1CommSpec, &paramSpec);
1204     ASSERT_EQ(res, HCF_SUCCESS);
1205     ASSERT_NE(paramSpec, nullptr);
1206 
1207     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1208     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1209     ASSERT_EQ(res, HCF_SUCCESS);
1210     ASSERT_NE(returnObj, nullptr);
1211 
1212     HcfKeyPair *returnKeyPair = nullptr;
1213     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
1214     ASSERT_EQ(res, HCF_SUCCESS);
1215     ASSERT_NE(returnObj, nullptr);
1216 
1217     HcfSign *sign = nullptr;
1218     res = HcfSignCreate("ECC_BrainPoolP160r1|SHA224", &sign);
1219     ASSERT_EQ(res, HCF_SUCCESS);
1220     ASSERT_NE(sign, nullptr);
1221 
1222     res = sign->init(sign, nullptr, returnKeyPair->priKey);
1223     ASSERT_EQ(res, HCF_SUCCESS);
1224 
1225     HcfBlob out = { .data = nullptr, .len = 0 };
1226     res = sign->sign(sign, &g_mockInput, &out);
1227     ASSERT_EQ(res, HCF_SUCCESS);
1228     ASSERT_NE(out.data, nullptr);
1229     ASSERT_NE(out.len, 0);
1230 
1231     HcfVerify *verify = nullptr;
1232     res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
1233     ASSERT_EQ(res, HCF_SUCCESS);
1234 
1235     res = verify->init(verify, nullptr, returnKeyPair->pubKey);
1236     ASSERT_EQ(res, HCF_SUCCESS);
1237 
1238     res = verify->verify(verify, &g_mockInput, &out);
1239     ASSERT_EQ(res, true);
1240     HcfFree(out.data);
1241     HcfObjDestroy(returnKeyPair);
1242     HcfObjDestroy(returnObj);
1243     HcfObjDestroy(sign);
1244     HcfObjDestroy(verify);
1245     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1246 }
1247 
1248 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_2, TestSize.Level0)
1249 {
1250     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160t1", &g_brainpool160t1CommSpec);
1251     ASSERT_NE(g_brainpool160t1CommSpec, nullptr);
1252     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1253     int32_t res = ConstructEccKeyPairParamsSpec(g_brainpool160t1AlgName.c_str(),
1254         g_brainpool160t1CommSpec, &paramSpec);
1255     ASSERT_EQ(res, HCF_SUCCESS);
1256     ASSERT_NE(paramSpec, nullptr);
1257 
1258     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1259     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1260     ASSERT_EQ(res, HCF_SUCCESS);
1261     ASSERT_NE(returnObj, nullptr);
1262 
1263     HcfKeyPair *returnKeyPair = nullptr;
1264     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
1265     ASSERT_EQ(res, HCF_SUCCESS);
1266     HcfSign *sign = nullptr;
1267     res = HcfSignCreate("ECC_BrainPoolP160t1|SHA224", &sign);
1268     ASSERT_EQ(res, HCF_SUCCESS);
1269     res = sign->init(sign, nullptr, returnKeyPair->priKey);
1270     ASSERT_EQ(res, HCF_SUCCESS);
1271     HcfBlob out = { .data = nullptr, .len = 0 };
1272     res = sign->sign(sign, &g_mockInput, &out);
1273     ASSERT_EQ(res, HCF_SUCCESS);
1274     ASSERT_NE(out.data, nullptr);
1275     ASSERT_NE(out.len, 0);
1276     HcfVerify *verify = nullptr;
1277     res = HcfVerifyCreate("ECC_BrainPoolP160t1|SHA224", &verify);
1278     ASSERT_EQ(res, HCF_SUCCESS);
1279     res = verify->init(verify, nullptr, returnKeyPair->pubKey);
1280     ASSERT_EQ(res, HCF_SUCCESS);
1281     res = verify->verify(verify, &g_mockInput, &out);
1282     ASSERT_EQ(res, true);
1283     HcfFree(out.data);
1284     HcfObjDestroy(returnKeyPair);
1285     HcfObjDestroy(returnObj);
1286     HcfObjDestroy(sign);
1287     HcfObjDestroy(verify);
1288     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1289 }
1290 
1291 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_3, TestSize.Level0)
1292 {
1293     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP192r1", &g_brainpool192r1CommSpec);
1294     ASSERT_NE(g_brainpool192r1CommSpec, nullptr);
1295     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1296     int32_t res = ConstructEccKeyPairParamsSpec(g_brainpool192r1AlgName.c_str(),
1297         g_brainpool192r1CommSpec, &paramSpec);
1298     ASSERT_EQ(res, HCF_SUCCESS);
1299     ASSERT_NE(paramSpec, nullptr);
1300 
1301     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1302     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1303     ASSERT_EQ(res, HCF_SUCCESS);
1304     ASSERT_NE(returnObj, nullptr);
1305 
1306     HcfKeyPair *returnKeyPair = nullptr;
1307     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
1308     ASSERT_EQ(res, HCF_SUCCESS);
1309     HcfSign *sign = nullptr;
1310     res = HcfSignCreate("ECC_BrainPoolP192r1|SHA224", &sign);
1311     ASSERT_EQ(res, HCF_SUCCESS);
1312     res = sign->init(sign, nullptr, returnKeyPair->priKey);
1313     ASSERT_EQ(res, HCF_SUCCESS);
1314     HcfBlob out = { .data = nullptr, .len = 0 };
1315     res = sign->sign(sign, &g_mockInput, &out);
1316     ASSERT_EQ(res, HCF_SUCCESS);
1317     ASSERT_NE(out.data, nullptr);
1318     ASSERT_NE(out.len, 0);
1319     HcfVerify *verify = nullptr;
1320     res = HcfVerifyCreate("ECC_BrainPoolP192r1|SHA224", &verify);
1321     ASSERT_EQ(res, HCF_SUCCESS);
1322     res = verify->init(verify, nullptr, returnKeyPair->pubKey);
1323     ASSERT_EQ(res, HCF_SUCCESS);
1324     res = verify->verify(verify, &g_mockInput, &out);
1325     ASSERT_EQ(res, true);
1326     HcfFree(out.data);
1327     HcfObjDestroy(returnKeyPair);
1328     HcfObjDestroy(returnObj);
1329     HcfObjDestroy(sign);
1330     HcfObjDestroy(verify);
1331     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1332 }
1333 
1334 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_4, TestSize.Level0)
1335 {
1336     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP192t1", &g_brainpool192t1CommSpec);
1337     ASSERT_NE(g_brainpool192t1CommSpec, nullptr);
1338     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1339     int32_t res = ConstructEccKeyPairParamsSpec(g_brainpool192t1AlgName.c_str(),
1340         g_brainpool192t1CommSpec, &paramSpec);
1341     ASSERT_EQ(res, HCF_SUCCESS);
1342     ASSERT_NE(paramSpec, nullptr);
1343 
1344     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1345     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1346     ASSERT_EQ(res, HCF_SUCCESS);
1347     ASSERT_NE(returnObj, nullptr);
1348 
1349     HcfKeyPair *returnKeyPair = nullptr;
1350     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
1351     ASSERT_EQ(res, HCF_SUCCESS);
1352     HcfSign *sign = nullptr;
1353     res = HcfSignCreate("ECC_BrainPoolP192t1|SHA224", &sign);
1354     ASSERT_EQ(res, HCF_SUCCESS);
1355     res = sign->init(sign, nullptr, returnKeyPair->priKey);
1356     ASSERT_EQ(res, HCF_SUCCESS);
1357     HcfBlob out = { .data = nullptr, .len = 0 };
1358     res = sign->sign(sign, &g_mockInput, &out);
1359     ASSERT_EQ(res, HCF_SUCCESS);
1360     ASSERT_NE(out.data, nullptr);
1361     ASSERT_NE(out.len, 0);
1362     HcfVerify *verify = nullptr;
1363     res = HcfVerifyCreate("ECC_BrainPoolP192t1|SHA224", &verify);
1364     ASSERT_EQ(res, HCF_SUCCESS);
1365     res = verify->init(verify, nullptr, returnKeyPair->pubKey);
1366     ASSERT_EQ(res, HCF_SUCCESS);
1367     res = verify->verify(verify, &g_mockInput, &out);
1368     ASSERT_EQ(res, true);
1369     HcfFree(out.data);
1370 
1371     HcfObjDestroy(returnKeyPair);
1372     HcfObjDestroy(returnObj);
1373     HcfObjDestroy(sign);
1374     HcfObjDestroy(verify);
1375     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1376 }
1377 
1378 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_5, TestSize.Level0)
1379 {
1380     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP224r1", &g_brainpool224r1CommSpec);
1381     ASSERT_NE(g_brainpool224r1CommSpec, nullptr);
1382     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1383     int32_t res = ConstructEccKeyPairParamsSpec(g_brainpool224r1AlgName.c_str(),
1384         g_brainpool224r1CommSpec, &paramSpec);
1385     ASSERT_EQ(res, HCF_SUCCESS);
1386     ASSERT_NE(paramSpec, nullptr);
1387 
1388     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1389     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1390     ASSERT_EQ(res, HCF_SUCCESS);
1391     ASSERT_NE(returnObj, nullptr);
1392 
1393     HcfKeyPair *returnKeyPair = nullptr;
1394     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
1395     ASSERT_EQ(res, HCF_SUCCESS);
1396     HcfSign *sign = nullptr;
1397     res = HcfSignCreate("ECC_BrainPoolP224r1|SHA224", &sign);
1398     ASSERT_EQ(res, HCF_SUCCESS);
1399     res = sign->init(sign, nullptr, returnKeyPair->priKey);
1400     ASSERT_EQ(res, HCF_SUCCESS);
1401     HcfBlob out = { .data = nullptr, .len = 0 };
1402     res = sign->sign(sign, &g_mockInput, &out);
1403     ASSERT_EQ(res, HCF_SUCCESS);
1404     ASSERT_NE(out.data, nullptr);
1405     ASSERT_NE(out.len, 0);
1406     HcfVerify *verify = nullptr;
1407     res = HcfVerifyCreate("ECC_BrainPoolP224r1|SHA224", &verify);
1408     ASSERT_EQ(res, HCF_SUCCESS);
1409     res = verify->init(verify, nullptr, returnKeyPair->pubKey);
1410     ASSERT_EQ(res, HCF_SUCCESS);
1411     res = verify->verify(verify, &g_mockInput, &out);
1412     ASSERT_EQ(res, true);
1413     HcfFree(out.data);
1414     HcfObjDestroy(returnKeyPair);
1415     HcfObjDestroy(returnObj);
1416     HcfObjDestroy(sign);
1417     HcfObjDestroy(verify);
1418     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1419 }
1420 
1421 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_6, TestSize.Level0)
1422 {
1423     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP224t1", &g_brainpool224t1CommSpec);
1424     ASSERT_NE(g_brainpool224t1CommSpec, nullptr);
1425     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1426     int32_t res = ConstructEccKeyPairParamsSpec(g_brainpool224t1AlgName.c_str(),
1427         g_brainpool224t1CommSpec, &paramSpec);
1428     ASSERT_EQ(res, HCF_SUCCESS);
1429     ASSERT_NE(paramSpec, nullptr);
1430 
1431     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1432     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1433     ASSERT_EQ(res, HCF_SUCCESS);
1434     ASSERT_NE(returnObj, nullptr);
1435 
1436     HcfKeyPair *returnKeyPair = nullptr;
1437     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
1438     ASSERT_EQ(res, HCF_SUCCESS);
1439     HcfSign *sign = nullptr;
1440     res = HcfSignCreate("ECC_BrainPoolP224t1|SHA224", &sign);
1441     ASSERT_EQ(res, HCF_SUCCESS);
1442     res = sign->init(sign, nullptr, returnKeyPair->priKey);
1443     ASSERT_EQ(res, HCF_SUCCESS);
1444     HcfBlob out = { .data = nullptr, .len = 0 };
1445     res = sign->sign(sign, &g_mockInput, &out);
1446     ASSERT_EQ(res, HCF_SUCCESS);
1447     ASSERT_NE(out.data, nullptr);
1448     ASSERT_NE(out.len, 0);
1449     HcfVerify *verify = nullptr;
1450     res = HcfVerifyCreate("ECC_BrainPoolP224t1|SHA224", &verify);
1451     ASSERT_EQ(res, HCF_SUCCESS);
1452     res = verify->init(verify, nullptr, returnKeyPair->pubKey);
1453     ASSERT_EQ(res, HCF_SUCCESS);
1454     res = verify->verify(verify, &g_mockInput, &out);
1455     ASSERT_EQ(res, true);
1456     HcfFree(out.data);
1457     HcfObjDestroy(returnKeyPair);
1458     HcfObjDestroy(returnObj);
1459     HcfObjDestroy(sign);
1460     HcfObjDestroy(verify);
1461     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1462 }
1463 
1464 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_7, TestSize.Level0)
1465 {
1466     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP256r1", &g_brainpool256r1CommSpec);
1467     ASSERT_NE(g_brainpool256r1CommSpec, nullptr);
1468     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1469     int32_t res = ConstructEccKeyPairParamsSpec(g_brainpool256r1AlgName.c_str(),
1470         g_brainpool256r1CommSpec, &paramSpec);
1471     ASSERT_EQ(res, HCF_SUCCESS);
1472     ASSERT_NE(paramSpec, nullptr);
1473 
1474     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1475     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1476     ASSERT_EQ(res, HCF_SUCCESS);
1477     ASSERT_NE(returnObj, nullptr);
1478 
1479     HcfKeyPair *returnKeyPair = nullptr;
1480     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
1481     HcfSign *sign = nullptr;
1482     res = HcfSignCreate("ECC_BrainPoolP256r1|SHA224", &sign);
1483     ASSERT_EQ(res, HCF_SUCCESS);
1484     res = sign->init(sign, nullptr, returnKeyPair->priKey);
1485     ASSERT_EQ(res, HCF_SUCCESS);
1486     HcfBlob out = { .data = nullptr, .len = 0 };
1487     res = sign->sign(sign, &g_mockInput, &out);
1488     ASSERT_EQ(res, HCF_SUCCESS);
1489     ASSERT_NE(out.data, nullptr);
1490     ASSERT_NE(out.len, 0);
1491     HcfVerify *verify = nullptr;
1492     res = HcfVerifyCreate("ECC_BrainPoolP256r1|SHA224", &verify);
1493     ASSERT_EQ(res, HCF_SUCCESS);
1494     res = verify->init(verify, nullptr, returnKeyPair->pubKey);
1495     ASSERT_EQ(res, HCF_SUCCESS);
1496     res = verify->verify(verify, &g_mockInput, &out);
1497     ASSERT_EQ(res, true);
1498     HcfFree(out.data);
1499     HcfObjDestroy(returnKeyPair);
1500     HcfObjDestroy(returnObj);
1501     HcfObjDestroy(sign);
1502     HcfObjDestroy(verify);
1503     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1504 }
1505 
1506 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_8, TestSize.Level0)
1507 {
1508     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP256t1", &g_brainpool256t1CommSpec);
1509     ASSERT_NE(g_brainpool256t1CommSpec, nullptr);
1510     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1511     int32_t res = ConstructEccKeyPairParamsSpec(g_brainpool256t1AlgName.c_str(),
1512         g_brainpool256t1CommSpec, &paramSpec);
1513     ASSERT_EQ(res, HCF_SUCCESS);
1514     ASSERT_NE(paramSpec, nullptr);
1515 
1516     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1517     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1518     ASSERT_EQ(res, HCF_SUCCESS);
1519     ASSERT_NE(returnObj, nullptr);
1520 
1521     HcfKeyPair *returnKeyPair = nullptr;
1522     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
1523     ASSERT_EQ(res, HCF_SUCCESS);
1524     HcfSign *sign = nullptr;
1525     res = HcfSignCreate("ECC_BrainPoolP256t1|SHA224", &sign);
1526     ASSERT_EQ(res, HCF_SUCCESS);
1527     res = sign->init(sign, nullptr, returnKeyPair->priKey);
1528     ASSERT_EQ(res, HCF_SUCCESS);
1529     HcfBlob out = { .data = nullptr, .len = 0 };
1530     res = sign->sign(sign, &g_mockInput, &out);
1531     ASSERT_EQ(res, HCF_SUCCESS);
1532     ASSERT_NE(out.data, nullptr);
1533     ASSERT_NE(out.len, 0);
1534     HcfVerify *verify = nullptr;
1535     res = HcfVerifyCreate("ECC_BrainPoolP256t1|SHA224", &verify);
1536     ASSERT_EQ(res, HCF_SUCCESS);
1537     res = verify->init(verify, nullptr, returnKeyPair->pubKey);
1538     ASSERT_EQ(res, HCF_SUCCESS);
1539     res = verify->verify(verify, &g_mockInput, &out);
1540     ASSERT_EQ(res, true);
1541     HcfFree(out.data);
1542     HcfObjDestroy(returnKeyPair);
1543     HcfObjDestroy(returnObj);
1544     HcfObjDestroy(sign);
1545     HcfObjDestroy(verify);
1546     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1547 }
1548 
1549 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_9, TestSize.Level0)
1550 {
1551     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP320r1", &g_brainpool320r1CommSpec);
1552     ASSERT_NE(g_brainpool320r1CommSpec, nullptr);
1553     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1554     int32_t res = ConstructEccKeyPairParamsSpec(g_brainpool320r1AlgName.c_str(),
1555         g_brainpool320r1CommSpec, &paramSpec);
1556     ASSERT_EQ(res, HCF_SUCCESS);
1557     ASSERT_NE(paramSpec, nullptr);
1558 
1559     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1560     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1561     ASSERT_EQ(res, HCF_SUCCESS);
1562     ASSERT_NE(returnObj, nullptr);
1563 
1564     HcfKeyPair *returnKeyPair = nullptr;
1565     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
1566     ASSERT_EQ(res, HCF_SUCCESS);
1567     HcfSign *sign = nullptr;
1568     res = HcfSignCreate("ECC_BrainPoolP320r1|SHA224", &sign);
1569     ASSERT_EQ(res, HCF_SUCCESS);
1570     res = sign->init(sign, nullptr, returnKeyPair->priKey);
1571     ASSERT_EQ(res, HCF_SUCCESS);
1572     HcfBlob out = { .data = nullptr, .len = 0 };
1573     res = sign->sign(sign, &g_mockInput, &out);
1574     ASSERT_EQ(res, HCF_SUCCESS);
1575     ASSERT_NE(out.data, nullptr);
1576     ASSERT_NE(out.len, 0);
1577     HcfVerify *verify = nullptr;
1578     res = HcfVerifyCreate("ECC_BrainPoolP320r1|SHA224", &verify);
1579     ASSERT_EQ(res, HCF_SUCCESS);
1580     res = verify->init(verify, nullptr, returnKeyPair->pubKey);
1581     ASSERT_EQ(res, HCF_SUCCESS);
1582     res = verify->verify(verify, &g_mockInput, &out);
1583     ASSERT_EQ(res, true);
1584     HcfFree(out.data);
1585     HcfObjDestroy(returnKeyPair);
1586     HcfObjDestroy(returnObj);
1587     HcfObjDestroy(sign);
1588     HcfObjDestroy(verify);
1589     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1590 }
1591 
1592 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_10, TestSize.Level0)
1593 {
1594     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP320t1", &g_brainpool320t1CommSpec);
1595     ASSERT_NE(g_brainpool320t1CommSpec, nullptr);
1596     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1597     int32_t res = ConstructEccKeyPairParamsSpec(g_brainpool320t1AlgName.c_str(),
1598         g_brainpool320t1CommSpec, &paramSpec);
1599     ASSERT_EQ(res, HCF_SUCCESS);
1600     ASSERT_NE(paramSpec, nullptr);
1601 
1602     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1603     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1604     ASSERT_EQ(res, HCF_SUCCESS);
1605     ASSERT_NE(returnObj, nullptr);
1606 
1607     HcfKeyPair *returnKeyPair = nullptr;
1608     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
1609     ASSERT_EQ(res, HCF_SUCCESS);
1610     HcfSign *sign = nullptr;
1611     res = HcfSignCreate("ECC_BrainPoolP320t1|SHA224", &sign);
1612     ASSERT_EQ(res, HCF_SUCCESS);
1613     res = sign->init(sign, nullptr, returnKeyPair->priKey);
1614     ASSERT_EQ(res, HCF_SUCCESS);
1615     HcfBlob out = { .data = nullptr, .len = 0 };
1616     res = sign->sign(sign, &g_mockInput, &out);
1617     ASSERT_EQ(res, HCF_SUCCESS);
1618     ASSERT_NE(out.data, nullptr);
1619     ASSERT_NE(out.len, 0);
1620     HcfVerify *verify = nullptr;
1621     res = HcfVerifyCreate("ECC_BrainPoolP320t1|SHA224", &verify);
1622     ASSERT_EQ(res, HCF_SUCCESS);
1623     res = verify->init(verify, nullptr, returnKeyPair->pubKey);
1624     ASSERT_EQ(res, HCF_SUCCESS);
1625     res = verify->verify(verify, &g_mockInput, &out);
1626     ASSERT_EQ(res, true);
1627     HcfFree(out.data);
1628     HcfObjDestroy(returnKeyPair);
1629     HcfObjDestroy(returnObj);
1630     HcfObjDestroy(sign);
1631     HcfObjDestroy(verify);
1632     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1633 }
1634 
1635 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_11, TestSize.Level0)
1636 {
1637     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP384r1", &g_brainpool384r1CommSpec);
1638     ASSERT_NE(g_brainpool384r1CommSpec, nullptr);
1639     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1640     int32_t res = ConstructEccKeyPairParamsSpec(g_brainpool384r1AlgName.c_str(),
1641         g_brainpool384r1CommSpec, &paramSpec);
1642     ASSERT_EQ(res, HCF_SUCCESS);
1643     ASSERT_NE(paramSpec, nullptr);
1644 
1645     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1646     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1647     ASSERT_EQ(res, HCF_SUCCESS);
1648     ASSERT_NE(returnObj, nullptr);
1649 
1650     HcfKeyPair *returnKeyPair = nullptr;
1651     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
1652     ASSERT_EQ(res, HCF_SUCCESS);
1653     HcfSign *sign = nullptr;
1654     res = HcfSignCreate("ECC_BrainPoolP384r1|SHA224", &sign);
1655     ASSERT_EQ(res, HCF_SUCCESS);
1656     res = sign->init(sign, nullptr, returnKeyPair->priKey);
1657     ASSERT_EQ(res, HCF_SUCCESS);
1658     HcfBlob out = { .data = nullptr, .len = 0 };
1659     res = sign->sign(sign, &g_mockInput, &out);
1660     ASSERT_EQ(res, HCF_SUCCESS);
1661     ASSERT_NE(out.data, nullptr);
1662     ASSERT_NE(out.len, 0);
1663     HcfVerify *verify = nullptr;
1664     res = HcfVerifyCreate("ECC_BrainPoolP384r1|SHA224", &verify);
1665     ASSERT_EQ(res, HCF_SUCCESS);
1666     res = verify->init(verify, nullptr, returnKeyPair->pubKey);
1667     ASSERT_EQ(res, HCF_SUCCESS);
1668     res = verify->verify(verify, &g_mockInput, &out);
1669     ASSERT_EQ(res, true);
1670     HcfFree(out.data);
1671     HcfObjDestroy(returnKeyPair);
1672     HcfObjDestroy(returnObj);
1673     HcfObjDestroy(sign);
1674     HcfObjDestroy(verify);
1675     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1676 }
1677 
1678 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_12, TestSize.Level0)
1679 {
1680     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP384t1", &g_brainpool384t1CommSpec);
1681     ASSERT_NE(g_brainpool384t1CommSpec, nullptr);
1682     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1683     int32_t res = ConstructEccKeyPairParamsSpec(g_brainpool384t1AlgName.c_str(),
1684         g_brainpool384t1CommSpec, &paramSpec);
1685     ASSERT_EQ(res, HCF_SUCCESS);
1686     ASSERT_NE(paramSpec, nullptr);
1687 
1688     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1689     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1690     ASSERT_EQ(res, HCF_SUCCESS);
1691     ASSERT_NE(returnObj, nullptr);
1692 
1693     HcfKeyPair *returnKeyPair = nullptr;
1694     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
1695     ASSERT_EQ(res, HCF_SUCCESS);
1696     HcfSign *sign = nullptr;
1697     res = HcfSignCreate("ECC_BrainPoolP384t1|SHA224", &sign);
1698     ASSERT_EQ(res, HCF_SUCCESS);
1699     res = sign->init(sign, nullptr, returnKeyPair->priKey);
1700     ASSERT_EQ(res, HCF_SUCCESS);
1701     HcfBlob out = { .data = nullptr, .len = 0 };
1702     res = sign->sign(sign, &g_mockInput, &out);
1703     ASSERT_EQ(res, HCF_SUCCESS);
1704     ASSERT_NE(out.data, nullptr);
1705     ASSERT_NE(out.len, 0);
1706     HcfVerify *verify = nullptr;
1707     res = HcfVerifyCreate("ECC_BrainPoolP384t1|SHA224", &verify);
1708     ASSERT_EQ(res, HCF_SUCCESS);
1709     res = verify->init(verify, nullptr, returnKeyPair->pubKey);
1710     ASSERT_EQ(res, HCF_SUCCESS);
1711     res = verify->verify(verify, &g_mockInput, &out);
1712     ASSERT_EQ(res, true);
1713     HcfFree(out.data);
1714     HcfObjDestroy(returnKeyPair);
1715     HcfObjDestroy(returnObj);
1716     HcfObjDestroy(sign);
1717     HcfObjDestroy(verify);
1718     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1719 }
1720 
1721 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_13, TestSize.Level0)
1722 {
1723     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP512r1", &g_brainpool512r1CommSpec);
1724     ASSERT_NE(g_brainpool512r1CommSpec, nullptr);
1725     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1726     int32_t res = ConstructEccKeyPairParamsSpec(g_brainpool512r1AlgName.c_str(),
1727         g_brainpool512r1CommSpec, &paramSpec);
1728     ASSERT_EQ(res, HCF_SUCCESS);
1729     ASSERT_NE(paramSpec, nullptr);
1730 
1731     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1732     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1733     ASSERT_EQ(res, HCF_SUCCESS);
1734     ASSERT_NE(returnObj, nullptr);
1735 
1736     HcfKeyPair *returnKeyPair = nullptr;
1737     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
1738     ASSERT_EQ(res, HCF_SUCCESS);
1739     HcfSign *sign = nullptr;
1740     res = HcfSignCreate("ECC_BrainPoolP512r1|SHA224", &sign);
1741     ASSERT_EQ(res, HCF_SUCCESS);
1742     res = sign->init(sign, nullptr, returnKeyPair->priKey);
1743     ASSERT_EQ(res, HCF_SUCCESS);
1744     HcfBlob out = { .data = nullptr, .len = 0 };
1745     res = sign->sign(sign, &g_mockInput, &out);
1746     ASSERT_EQ(res, HCF_SUCCESS);
1747     ASSERT_NE(out.data, nullptr);
1748     ASSERT_NE(out.len, 0);
1749     HcfVerify *verify = nullptr;
1750     res = HcfVerifyCreate("ECC_BrainPoolP512r1|SHA224", &verify);
1751     ASSERT_EQ(res, HCF_SUCCESS);
1752     res = verify->init(verify, nullptr, returnKeyPair->pubKey);
1753     ASSERT_EQ(res, HCF_SUCCESS);
1754     res = verify->verify(verify, &g_mockInput, &out);
1755     ASSERT_EQ(res, true);
1756     HcfFree(out.data);
1757     HcfObjDestroy(returnKeyPair);
1758     HcfObjDestroy(returnObj);
1759     HcfObjDestroy(sign);
1760     HcfObjDestroy(verify);
1761     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1762 }
1763 
1764 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest039_14, TestSize.Level0)
1765 {
1766     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP512t1", &g_brainpool512t1CommSpec);
1767     ASSERT_NE(g_brainpool512t1CommSpec, nullptr);
1768     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1769     int32_t res = ConstructEccKeyPairParamsSpec(g_brainpool512t1AlgName.c_str(),
1770         g_brainpool512t1CommSpec, &paramSpec);
1771     ASSERT_EQ(res, HCF_SUCCESS);
1772     ASSERT_NE(paramSpec, nullptr);
1773 
1774     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1775     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1776     ASSERT_EQ(res, HCF_SUCCESS);
1777     ASSERT_NE(returnObj, nullptr);
1778 
1779     HcfKeyPair *returnKeyPair = nullptr;
1780     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
1781     HcfSign *sign = nullptr;
1782     res = HcfSignCreate("ECC_BrainPoolP512t1|SHA224", &sign);
1783     ASSERT_EQ(res, HCF_SUCCESS);
1784     res = sign->init(sign, nullptr, returnKeyPair->priKey);
1785     ASSERT_EQ(res, HCF_SUCCESS);
1786     HcfBlob out = { .data = nullptr, .len = 0 };
1787     res = sign->sign(sign, &g_mockInput, &out);
1788     ASSERT_EQ(res, HCF_SUCCESS);
1789     ASSERT_NE(out.data, nullptr);
1790     ASSERT_NE(out.len, 0);
1791     HcfVerify *verify = nullptr;
1792     res = HcfVerifyCreate("ECC_BrainPoolP512t1|SHA224", &verify);
1793     ASSERT_EQ(res, HCF_SUCCESS);
1794     res = verify->init(verify, nullptr, returnKeyPair->pubKey);
1795     ASSERT_EQ(res, HCF_SUCCESS);
1796     res = verify->verify(verify, &g_mockInput, &out);
1797     ASSERT_EQ(res, true);
1798     HcfFree(out.data);
1799     HcfObjDestroy(returnKeyPair);
1800     HcfObjDestroy(returnObj);
1801     HcfObjDestroy(sign);
1802     HcfObjDestroy(verify);
1803     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1804 }
1805 
1806 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest040, TestSize.Level0)
1807 {
1808     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
1809     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
1810     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1811     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
1812         g_brainpool160r1CommSpec, &paramSpec);
1813     ASSERT_EQ(res, HCF_SUCCESS);
1814     ASSERT_NE(paramSpec, nullptr);
1815 
1816     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1817     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1818     ASSERT_EQ(res, HCF_SUCCESS);
1819     ASSERT_NE(returnObj, nullptr);
1820 
1821     HcfKeyPair *returnKeyPair = nullptr;
1822     res = returnObj->generateKeyPair(returnObj, &returnKeyPair);
1823     ASSERT_EQ(res, HCF_SUCCESS);
1824     ASSERT_NE(returnKeyPair, nullptr);
1825 
1826     HcfObjDestroy(returnKeyPair);
1827     HcfObjDestroy(returnObj);
1828     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1829 }
1830 
1831 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest041, TestSize.Level0)
1832 {
1833     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
1834     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
1835     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1836     HcfResult res = ConstructEccPubKeyParamsSpec(g_brainpool160r1AlgName.c_str(), g_brainpool160r1CommSpec,
1837         &paramSpec);
1838     ASSERT_EQ(res, HCF_SUCCESS);
1839     ASSERT_NE(paramSpec, nullptr);
1840 
1841     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1842     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1843     ASSERT_EQ(res, HCF_SUCCESS);
1844     ASSERT_NE(returnObj, nullptr);
1845 
1846     HcfPubKey *returnPubKey = nullptr;
1847     res = returnObj->generatePubKey(returnObj, &returnPubKey);
1848     ASSERT_EQ(res, HCF_SUCCESS);
1849     ASSERT_NE(returnPubKey, nullptr);
1850 
1851     HcfObjDestroy(returnPubKey);
1852     HcfObjDestroy(returnObj);
1853     DestroyEccPubKeySpec(reinterpret_cast<HcfEccPubKeyParamsSpec *>(paramSpec));
1854 }
1855 
1856 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest042, TestSize.Level0)
1857 {
1858     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
1859     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
1860     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1861     HcfResult res = ConstructEccPriKeyParamsSpec(g_brainpool160r1AlgName.c_str(), g_brainpool160r1CommSpec,
1862         &paramSpec);
1863     ASSERT_EQ(res, HCF_SUCCESS);
1864     ASSERT_NE(paramSpec, nullptr);
1865 
1866     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1867     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1868     ASSERT_EQ(res, HCF_SUCCESS);
1869     ASSERT_NE(returnObj, nullptr);
1870 
1871     HcfPriKey *returnPriKey = nullptr;
1872     res = returnObj->generatePriKey(returnObj, &returnPriKey);
1873     ASSERT_EQ(res, HCF_SUCCESS);
1874     ASSERT_NE(returnPriKey, nullptr);
1875 
1876     HcfObjDestroy(returnPriKey);
1877     HcfObjDestroy(returnObj);
1878     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
1879 }
1880 
1881 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest043, TestSize.Level0)
1882 {
1883     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
1884     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
1885     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1886     HcfResult res = ConstructEccPriKeyParamsSpec(g_brainpool160r1AlgName.c_str(), g_brainpool160r1CommSpec,
1887         &paramSpec);
1888     ASSERT_EQ(res, HCF_SUCCESS);
1889     ASSERT_NE(paramSpec, nullptr);
1890 
1891     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1892     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1893     ASSERT_EQ(res, HCF_SUCCESS);
1894     ASSERT_NE(returnObj, nullptr);
1895 
1896     HcfKeyPair *returnPriKey = nullptr;
1897     res = returnObj->generateKeyPair(returnObj, &returnPriKey);
1898     ASSERT_NE(res, HCF_SUCCESS);
1899     ASSERT_EQ(returnPriKey, nullptr);
1900 
1901     HcfObjDestroy(returnPriKey);
1902     HcfObjDestroy(returnObj);
1903     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
1904 }
1905 
1906 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest044, TestSize.Level0)
1907 {
1908     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
1909     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
1910     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1911     HcfResult res = ConstructEccKeyPairParamsSpec(g_brainpool160r1AlgName.c_str(),
1912         g_brainpool160r1CommSpec, &paramSpec);
1913     ASSERT_EQ(res, HCF_SUCCESS);
1914     ASSERT_NE(paramSpec, nullptr);
1915 
1916     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1917     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1918     ASSERT_EQ(res, HCF_SUCCESS);
1919     ASSERT_NE(returnObj, nullptr);
1920 
1921     HcfPriKey *returnPriKey = nullptr;
1922     res = returnObj->generatePriKey(returnObj, &returnPriKey);
1923     ASSERT_EQ(res, HCF_SUCCESS);
1924     ASSERT_NE(returnPriKey, nullptr);
1925 
1926     HcfObjDestroy(returnPriKey);
1927     HcfObjDestroy(returnObj);
1928     DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1929 }
1930 
1931 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest045, TestSize.Level0)
1932 {
1933     ConstructEccKeyPairCommParamsSpec("NID_brainpoolP160r1", &g_brainpool160r1CommSpec);
1934     ASSERT_NE(g_brainpool160r1CommSpec, nullptr);
1935     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1936     HcfResult res = ConstructEccPriKeyParamsSpec(g_brainpool160r1AlgName.c_str(), g_brainpool160r1CommSpec,
1937         &paramSpec);
1938     ASSERT_EQ(res, HCF_SUCCESS);
1939     ASSERT_NE(paramSpec, nullptr);
1940 
1941     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1942     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1943     ASSERT_EQ(res, HCF_SUCCESS);
1944     ASSERT_NE(returnObj, nullptr);
1945 
1946     HcfPubKey *returnPriKey = nullptr;
1947     res = returnObj->generatePubKey(returnObj, &returnPriKey);
1948     ASSERT_NE(res, HCF_SUCCESS);
1949     ASSERT_EQ(returnPriKey, nullptr);
1950 
1951     HcfObjDestroy(returnPriKey);
1952     HcfObjDestroy(returnObj);
1953     DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
1954 }
1955 
1956 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest046, TestSize.Level0)
1957 {
1958     HcfAsyKeyGenParams params = {
1959         .algo = HCF_ALG_ECC,
1960         .bits = HCF_ALG_ECC_BP160R1,
1961         .primes = HCF_OPENSSL_PRIMES_2
1962     };
1963     HcfEccCommParamsSpecSpi *returnCommonParamSpec = nullptr;
1964     HcfResult res = HcfECCCommonParamSpecCreate(&params, &returnCommonParamSpec);
1965     ASSERT_EQ(res, HCF_SUCCESS);
1966     ASSERT_NE(returnCommonParamSpec, nullptr);
1967 }
1968 
1969 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest047, TestSize.Level0)
1970 {
1971     HcfEccCommParamsSpecSpi *returnCommonParamSpec = nullptr;
1972     HcfResult res = HcfECCCommonParamSpecCreate(nullptr, &returnCommonParamSpec);
1973     ASSERT_NE(res, HCF_SUCCESS);
1974 }
1975 
1976 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest048, TestSize.Level0)
1977 {
1978     HcfAsyKeyGenParams params = {
1979         .algo = HCF_ALG_ECC,
1980         .bits = HCF_ALG_ECC_BP160R1,
1981         .primes = HCF_OPENSSL_PRIMES_2
1982     };
1983     HcfResult res = HcfECCCommonParamSpecCreate(&params, nullptr);
1984     ASSERT_NE(res, HCF_SUCCESS);
1985 }
1986 
1987 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest049, TestSize.Level0)
1988 {
1989     HcfAsyKeyGenParams obj = {
1990         .algo = HCF_ALG_ECC,
1991         .bits = HCF_OPENSSL_RSA_2048,
1992         .primes = HCF_OPENSSL_PRIMES_2
1993     };
1994     HcfEccCommParamsSpecSpi *returnCommonParamSpec = nullptr;
1995     HcfResult res = HcfECCCommonParamSpecCreate(&obj, &returnCommonParamSpec);
1996     ASSERT_NE(res, HCF_SUCCESS);
1997     ASSERT_EQ(returnCommonParamSpec, nullptr);
1998 
1999     HcfObjDestroy(returnCommonParamSpec);
2000 }
2001 
2002 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest050, TestSize.Level0)
2003 {
2004     HcfAsyKeyGenParams obj = {
2005         .algo = HCF_ALG_ECC,
2006         .bits = 0,
2007         .primes = HCF_OPENSSL_PRIMES_2
2008     };
2009     HcfEccCommParamsSpecSpi *returnCommonParamSpec = nullptr;
2010     HcfResult res = HcfECCCommonParamSpecCreate(&obj, &returnCommonParamSpec);
2011     ASSERT_NE(res, HCF_SUCCESS);
2012     ASSERT_EQ(returnCommonParamSpec, nullptr);
2013 
2014     HcfObjDestroy(returnCommonParamSpec);
2015 }
2016 
2017 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest051, TestSize.Level0)
2018 {
2019     HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP160r1", nullptr);
2020     ASSERT_EQ(res, HCF_INVALID_PARAMS);
2021 }
2022 
OpensslMockTestFunc(uint32_t mallocCount,HcfEccCommParamsSpec * returnCommonParamSpec)2023 static void OpensslMockTestFunc(uint32_t mallocCount, HcfEccCommParamsSpec *returnCommonParamSpec)
2024 {
2025     for (uint32_t i = 0; i < mallocCount; i++) {
2026         ResetOpensslCallNum();
2027         SetOpensslCallMockIndex(i);
2028 
2029         HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP160r1", &returnCommonParamSpec);
2030         if (res != HCF_SUCCESS) {
2031             continue;
2032         }
2033 
2034         FreeEccCommParamsSpec(returnCommonParamSpec);
2035     }
2036 }
2037 
2038 HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest052, TestSize.Level0)
2039 {
2040     StartRecordOpensslCallNum();
2041     HcfEccCommParamsSpec *returnCommonParamSpec = nullptr;
2042     HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP160r1", &returnCommonParamSpec);
2043     ASSERT_EQ(res, HCF_SUCCESS);
2044     ASSERT_NE(returnCommonParamSpec, nullptr);
2045 
2046     FreeEccCommParamsSpec(returnCommonParamSpec);
2047 
2048     uint32_t mallocCount = GetOpensslCallNum();
2049     OpensslMockTestFunc(mallocCount, returnCommonParamSpec);
2050 
2051     EndRecordOpensslCallNum();
2052 }
2053 }
2054