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