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