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