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