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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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 ¶mSpec);
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 ¶mSpec);
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 ¶mSpec);
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 ¶mSpec);
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 ¶mSpec);
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 ¶mSpec);
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 ¶mSpec);
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 ¶mSpec);
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 ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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 ¶mSpec);
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 ¶mSpec);
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 ¶mSpec);
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, ¶mSpec);
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 ¶mSpec);
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(¶ms, &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(¶ms, 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