1 /*
2 * Copyright (C) 2023-2024 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 "ecc_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 CryptoEccAsyKeyGeneratorTest : public testing::Test {
32 public:
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp();
36 void TearDown();
37 };
38
SetUpTestCase()39 void CryptoEccAsyKeyGeneratorTest::SetUpTestCase() {}
TearDownTestCase()40 void CryptoEccAsyKeyGeneratorTest::TearDownTestCase() {}
SetUp()41 void CryptoEccAsyKeyGeneratorTest::SetUp() {}
TearDown()42 void CryptoEccAsyKeyGeneratorTest::TearDown() {}
43
44 const int ECC224_PUB_KEY_LEN = 80;
45 const int ECC224_PRI_KEY_LEN = 44;
46 const int ECC256_PUB_KEY_LEN = 91;
47 const int ECC256_PRI_KEY_LEN = 51;
48 const int ECC384_PUB_KEY_LEN = 120;
49 const int ECC384_PRI_KEY_LEN = 64;
50 const int ECC521_PUB_KEY_LEN = 158;
51 const int ECC521_PRI_KEY_LEN = 82;
52
53 uint8_t g_mockEcc224PubKeyBlobData[ECC224_PUB_KEY_LEN] = { 48, 78, 48, 16, 6, 7, 42, 134, 72, 206, 61, 2, 1,
54 6, 5, 43, 129, 4, 0, 33, 3, 58, 0, 4, 252, 171, 11, 115, 79, 252, 109, 120, 46, 97, 131, 145, 207, 141, 146,
55 235, 133, 37, 218, 180, 8, 149, 47, 244, 137, 238, 207, 95, 153, 65, 250, 32, 77, 184, 249, 181, 172, 192, 2,
56 99, 194, 170, 25, 44, 255, 87, 246, 42, 133, 83, 66, 197, 97, 95, 12, 84 };
57
58 uint8_t g_mockEcc224PriKeyBlobData[ECC224_PRI_KEY_LEN] = { 48, 42, 2, 1, 1, 4, 28, 250, 86, 6, 147, 222, 43,
59 252, 139, 90, 139, 5, 33, 184, 230, 26, 68, 94, 57, 145, 229, 146, 49, 221, 119, 206, 32, 198, 19, 160, 7, 6,
60 5, 43, 129, 4, 0, 33 };
61
62 uint8_t g_mockEcc256PubKeyBlobData[ECC256_PUB_KEY_LEN] = { 48, 89, 48, 19, 6, 7, 42, 134, 72, 206, 61, 2, 1,
63 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,
64 231, 67, 2, 214, 197, 176, 161, 160, 227, 133, 158, 30, 118, 217, 243, 155, 88, 55, 214, 86, 86, 122, 166, 64,
65 111, 2, 226, 93, 163, 194, 210, 74, 18, 63, 173, 113, 249, 196, 126, 165, 222, 230, 190, 101, 241, 95, 102, 174,
66 252, 38 };
67
68 uint8_t g_mockEcc256PriKeyBlobData[ECC256_PRI_KEY_LEN] = { 48, 49, 2, 1, 1, 4, 32, 223, 134, 255, 219, 45,
69 68, 72, 231, 43, 72, 243, 113, 255, 60, 232, 203, 151, 65, 80, 6, 36, 112, 247, 186, 106, 148, 43, 170, 204,
70 23, 189, 191, 160, 10, 6, 8, 42, 134, 72, 206, 61, 3, 1, 7 };
71
72 uint8_t g_mockEcc384PubKeyBlobData[ECC384_PUB_KEY_LEN] = { 48, 118, 48, 16, 6, 7, 42, 134, 72, 206, 61, 2,
73 1, 6, 5, 43, 129, 4, 0, 34, 3, 98, 0, 4, 149, 237, 84, 7, 62, 114, 48, 106, 64, 227, 243, 253, 90, 170, 184,
74 80, 174, 159, 72, 117, 16, 24, 213, 146, 184, 159, 33, 209, 36, 143, 227, 11, 113, 228, 128, 13, 181, 195, 235,
75 12, 255, 85, 187, 197, 109, 82, 242, 226, 186, 53, 128, 9, 133, 4, 170, 96, 150, 94, 197, 196, 107, 120, 55,
76 159, 181, 208, 249, 176, 108, 6, 166, 253, 221, 156, 139, 140, 124, 240, 11, 194, 154, 139, 62, 218, 170, 61,
77 12, 147, 7, 146, 243, 158, 103, 195, 123, 156 };
78
79 uint8_t g_mockEcc384PriKeyBlobData[ECC384_PRI_KEY_LEN] = { 48, 62, 2, 1, 1, 4, 48, 137, 184, 12, 183, 201,
80 211, 124, 203, 165, 9, 229, 68, 46, 17, 14, 14, 109, 195, 0, 206, 248, 21, 53, 72, 66, 3, 244, 165, 248,
81 217, 176, 121, 155, 225, 222, 134, 155, 241, 59, 16, 253, 237, 158, 11, 221, 252, 58, 251, 160, 7, 6, 5,
82 43, 129, 4, 0, 34 };
83
84 uint8_t g_mockEcc521PubKeyBlobData[ECC521_PUB_KEY_LEN] = { 48, 129, 155, 48, 16, 6, 7, 42, 134, 72, 206,
85 61, 2, 1, 6, 5, 43, 129, 4, 0, 35, 3, 129, 134, 0, 4, 0, 149, 60, 46, 252, 220, 227, 253, 219, 250, 60, 232,
86 80, 190, 119, 38, 79, 202, 173, 35, 126, 228, 244, 207, 174, 191, 250, 147, 188, 22, 132, 125, 44, 26, 57, 242,
87 203, 192, 100, 65, 185, 250, 80, 246, 76, 37, 242, 78, 64, 152, 47, 172, 165, 229, 99, 247, 61, 91, 152, 144,
88 67, 34, 38, 130, 198, 22, 0, 179, 69, 69, 147, 72, 154, 76, 134, 28, 158, 33, 251, 94, 63, 77, 44, 100, 132,
89 207, 159, 210, 113, 194, 174, 170, 194, 129, 215, 209, 50, 217, 204, 48, 53, 92, 231, 57, 179, 170, 6, 26, 77,
90 187, 181, 35, 254, 17, 216, 205, 118, 104, 89, 155, 145, 28, 61, 169, 113, 195, 55, 13, 125, 6, 168, 156 };
91
92 uint8_t g_mockEcc521PriKeyBlobData[ECC521_PRI_KEY_LEN] = { 48, 80, 2, 1, 1, 4, 66, 0, 210, 135, 140, 70,
93 98, 28, 121, 169, 5, 202, 132, 165, 11, 56, 9, 110, 32, 9, 146, 185, 239, 69, 113, 79, 213, 24, 165, 194, 147,
94 209, 223, 187, 100, 6, 149, 4, 56, 235, 120, 152, 146, 252, 92, 21, 222, 3, 182, 68, 39, 222, 49, 192, 154, 126,
95 126, 243, 18, 99, 136, 199, 234, 134, 232, 13, 128, 160, 7, 6, 5, 43, 129, 4, 0, 35 };
96
97 HcfBlob g_mockEcc224PubKeyBlob = {
98 .data = g_mockEcc224PubKeyBlobData,
99 .len = ECC224_PUB_KEY_LEN
100 };
101
102 HcfBlob g_mockEcc224PriKeyBlob = {
103 .data = g_mockEcc224PriKeyBlobData,
104 .len = ECC224_PRI_KEY_LEN
105 };
106
107 HcfBlob g_mockEcc256PubKeyBlob = {
108 .data = g_mockEcc256PubKeyBlobData,
109 .len = ECC256_PUB_KEY_LEN
110 };
111
112 HcfBlob g_mockEcc256PriKeyBlob = {
113 .data = g_mockEcc256PriKeyBlobData,
114 .len = ECC256_PRI_KEY_LEN
115 };
116
117 HcfBlob g_mockEcc384PubKeyBlob = {
118 .data = g_mockEcc384PubKeyBlobData,
119 .len = ECC384_PUB_KEY_LEN
120 };
121
122 HcfBlob g_mockEcc384PriKeyBlob = {
123 .data = g_mockEcc384PriKeyBlobData,
124 .len = ECC384_PRI_KEY_LEN
125 };
126
127 HcfBlob g_mockEcc521PubKeyBlob = {
128 .data = g_mockEcc521PubKeyBlobData,
129 .len = ECC521_PUB_KEY_LEN
130 };
131
132 HcfBlob g_mockEcc521PriKeyBlob = {
133 .data = g_mockEcc521PriKeyBlobData,
134 .len = ECC521_PRI_KEY_LEN
135 };
136
GetMockClass(void)137 static const char *GetMockClass(void)
138 {
139 return "HcfSymKeyGenerator";
140 }
141
142 HcfObjectBase g_obj = {
143 .getClass = GetMockClass,
144 .destroy = nullptr
145 };
146
147 /**
148 * @tc.name: CryptoEccAsyKeyGeneratorTest.CryptoEccAsyKeyGeneratorTest001
149 * @tc.desc: Verify that the creation of the ECC224 key pair generator is normal.
150 * @tc.type: FUNC
151 * @tc.require: I5QWEI
152 */
153 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest001, TestSize.Level0)
154 {
155 HcfAsyKeyGenerator *generator = nullptr;
156 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
157
158 ASSERT_EQ(res, HCF_SUCCESS);
159 ASSERT_NE(generator, nullptr);
160
161 HcfObjDestroy(generator);
162 }
163
164 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest002, TestSize.Level0)
165 {
166 HcfAsyKeyGenerator *generator = nullptr;
167 int32_t res = HcfAsyKeyGeneratorCreate("ECC256", &generator);
168
169 ASSERT_EQ(res, HCF_SUCCESS);
170 ASSERT_NE(generator, nullptr);
171
172 HcfObjDestroy(generator);
173 }
174
175 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest003, TestSize.Level0)
176 {
177 HcfAsyKeyGenerator *generator = nullptr;
178 int32_t res = HcfAsyKeyGeneratorCreate("ECC384", &generator);
179
180 ASSERT_EQ(res, HCF_SUCCESS);
181 ASSERT_NE(generator, nullptr);
182
183 HcfObjDestroy(generator);
184 }
185
186 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest004, TestSize.Level0)
187 {
188 HcfAsyKeyGenerator *generator = nullptr;
189 int32_t res = HcfAsyKeyGeneratorCreate("ECC521", &generator);
190
191 ASSERT_EQ(res, HCF_SUCCESS);
192 ASSERT_NE(generator, nullptr);
193
194 HcfObjDestroy(generator);
195 }
196
197 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest005, TestSize.Level0)
198 {
199 HcfAsyKeyGenerator *generator = nullptr;
200 int32_t res = HcfAsyKeyGeneratorCreate(nullptr, &generator);
201
202 ASSERT_EQ(res, HCF_INVALID_PARAMS);
203 ASSERT_EQ(generator, nullptr);
204 }
205
206 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest006, TestSize.Level0)
207 {
208 HcfAsyKeyGenerator *generator = nullptr;
209 int32_t res = HcfAsyKeyGeneratorCreate("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD"
210 "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", &generator);
211
212 ASSERT_EQ(res, HCF_INVALID_PARAMS);
213 ASSERT_EQ(generator, nullptr);
214 }
215
216 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest007, TestSize.Level0)
217 {
218 HcfAsyKeyGenerator *generator = nullptr;
219 int32_t res = HcfAsyKeyGeneratorCreate("ECC225", &generator);
220
221 ASSERT_EQ(res, HCF_INVALID_PARAMS);
222 ASSERT_EQ(generator, nullptr);
223 }
224
225 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest008, TestSize.Level0)
226 {
227 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", nullptr);
228
229 ASSERT_EQ(res, HCF_INVALID_PARAMS);
230 }
231
232 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest101, TestSize.Level0)
233 {
234 HcfAsyKeyGenerator *generator = nullptr;
235 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
236
237 ASSERT_EQ(res, HCF_SUCCESS);
238 ASSERT_NE(generator, nullptr);
239
240 const char *className = generator->base.getClass();
241 ASSERT_NE(className, nullptr);
242
243 HcfObjDestroy(generator);
244 }
245
246 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest102, TestSize.Level0)
247 {
248 HcfAsyKeyGenerator *generator = nullptr;
249 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
250
251 ASSERT_EQ(res, HCF_SUCCESS);
252 ASSERT_NE(generator, nullptr);
253
254 generator->base.destroy((HcfObjectBase *)generator);
255 }
256
257 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest103, TestSize.Level0)
258 {
259 HcfAsyKeyGenerator *generator = nullptr;
260 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
261
262 ASSERT_EQ(res, HCF_SUCCESS);
263 ASSERT_NE(generator, nullptr);
264
265 generator->base.destroy(nullptr);
266
267 HcfObjDestroy(generator);
268 }
269
270 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest104, TestSize.Level0)
271 {
272 HcfAsyKeyGenerator *generator = nullptr;
273 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
274
275 ASSERT_EQ(res, HCF_SUCCESS);
276 ASSERT_NE(generator, nullptr);
277
278 generator->base.destroy(&g_obj);
279
280 HcfObjDestroy(generator);
281 }
282
283 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest105, TestSize.Level0)
284 {
285 HcfAsyKeyGenerator *generator = nullptr;
286 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
287
288 ASSERT_EQ(res, HCF_SUCCESS);
289 ASSERT_NE(generator, nullptr);
290
291 const char *algName = generator->getAlgoName(generator);
292
293 ASSERT_NE(algName, nullptr);
294
295 HcfObjDestroy(generator);
296 }
297
298 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest106, TestSize.Level0)
299 {
300 HcfAsyKeyGenerator *generator = nullptr;
301 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
302
303 ASSERT_EQ(res, HCF_SUCCESS);
304 ASSERT_NE(generator, nullptr);
305
306 const char *algName = generator->getAlgoName(nullptr);
307
308 ASSERT_EQ(algName, nullptr);
309
310 HcfObjDestroy(generator);
311 }
312
313 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest107, TestSize.Level0)
314 {
315 HcfAsyKeyGenerator *generator = nullptr;
316 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
317
318 ASSERT_EQ(res, HCF_SUCCESS);
319 ASSERT_NE(generator, nullptr);
320
321 const char *algName = generator->getAlgoName((HcfAsyKeyGenerator *)&g_obj);
322
323 ASSERT_EQ(algName, nullptr);
324
325 HcfObjDestroy(generator);
326 }
327
328 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest201, TestSize.Level0)
329 {
330 HcfAsyKeyGenerator *generator = nullptr;
331 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
332
333 ASSERT_EQ(res, HCF_SUCCESS);
334 ASSERT_NE(generator, nullptr);
335
336 HcfKeyPair *keyPair = nullptr;
337 res = generator->generateKeyPair(generator, nullptr, &keyPair);
338
339 ASSERT_EQ(res, HCF_SUCCESS);
340 ASSERT_NE(keyPair, nullptr);
341
342 HcfObjDestroy(keyPair);
343 HcfObjDestroy(generator);
344 }
345
346 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest202, TestSize.Level0)
347 {
348 HcfAsyKeyGenerator *generator = nullptr;
349 int32_t res = HcfAsyKeyGeneratorCreate("ECC256", &generator);
350
351 ASSERT_EQ(res, HCF_SUCCESS);
352 ASSERT_NE(generator, nullptr);
353
354 HcfKeyPair *keyPair = nullptr;
355 res = generator->generateKeyPair(generator, nullptr, &keyPair);
356
357 ASSERT_EQ(res, HCF_SUCCESS);
358 ASSERT_NE(keyPair, nullptr);
359
360 HcfObjDestroy(keyPair);
361 HcfObjDestroy(generator);
362 }
363
364 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest203, TestSize.Level0)
365 {
366 HcfAsyKeyGenerator *generator = nullptr;
367 int32_t res = HcfAsyKeyGeneratorCreate("ECC384", &generator);
368
369 ASSERT_EQ(res, HCF_SUCCESS);
370 ASSERT_NE(generator, nullptr);
371
372 HcfKeyPair *keyPair = nullptr;
373 res = generator->generateKeyPair(generator, nullptr, &keyPair);
374
375 ASSERT_EQ(res, HCF_SUCCESS);
376 ASSERT_NE(keyPair, nullptr);
377
378 HcfObjDestroy(keyPair);
379 HcfObjDestroy(generator);
380 }
381
382 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest204, TestSize.Level0)
383 {
384 HcfAsyKeyGenerator *generator = nullptr;
385 int32_t res = HcfAsyKeyGeneratorCreate("ECC521", &generator);
386
387 ASSERT_EQ(res, HCF_SUCCESS);
388 ASSERT_NE(generator, nullptr);
389
390 HcfKeyPair *keyPair = nullptr;
391 res = generator->generateKeyPair(generator, nullptr, &keyPair);
392
393 ASSERT_EQ(res, HCF_SUCCESS);
394 ASSERT_NE(keyPair, nullptr);
395
396 HcfObjDestroy(keyPair);
397 HcfObjDestroy(generator);
398 }
399
400 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest205, TestSize.Level0)
401 {
402 HcfAsyKeyGenerator *generator = nullptr;
403 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
404
405 ASSERT_EQ(res, HCF_SUCCESS);
406 ASSERT_NE(generator, nullptr);
407
408 HcfKeyPair *keyPair = nullptr;
409 res = generator->generateKeyPair(nullptr, nullptr, &keyPair);
410
411 ASSERT_EQ(res, HCF_INVALID_PARAMS);
412 ASSERT_EQ(keyPair, nullptr);
413
414 HcfObjDestroy(generator);
415 }
416
417 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest206, TestSize.Level0)
418 {
419 HcfAsyKeyGenerator *generator = nullptr;
420 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
421
422 ASSERT_EQ(res, HCF_SUCCESS);
423 ASSERT_NE(generator, nullptr);
424
425 HcfKeyPair *keyPair = nullptr;
426 res = generator->generateKeyPair((HcfAsyKeyGenerator *)&g_obj, nullptr, &keyPair);
427
428 ASSERT_EQ(res, HCF_INVALID_PARAMS);
429 ASSERT_EQ(keyPair, nullptr);
430
431 HcfObjDestroy(generator);
432 }
433
434 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest207, TestSize.Level0)
435 {
436 HcfAsyKeyGenerator *generator = nullptr;
437 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
438
439 ASSERT_EQ(res, HCF_SUCCESS);
440 ASSERT_NE(generator, nullptr);
441
442 res = generator->generateKeyPair(generator, nullptr, nullptr);
443
444 ASSERT_EQ(res, HCF_INVALID_PARAMS);
445
446 HcfObjDestroy(generator);
447 }
448
449 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest301, TestSize.Level0)
450 {
451 HcfAsyKeyGenerator *generator = nullptr;
452 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
453
454 HcfKeyPair *keyPair = nullptr;
455 res = generator->generateKeyPair(generator, nullptr, &keyPair);
456
457 ASSERT_EQ(res, HCF_SUCCESS);
458 ASSERT_NE(keyPair, nullptr);
459
460 const char *className = keyPair->base.getClass();
461
462 ASSERT_NE(className, nullptr);
463
464 HcfObjDestroy(keyPair);
465 HcfObjDestroy(generator);
466 }
467
468 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest302, TestSize.Level0)
469 {
470 HcfAsyKeyGenerator *generator = nullptr;
471 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
472
473 HcfKeyPair *keyPair = nullptr;
474 res = generator->generateKeyPair(generator, nullptr, &keyPair);
475
476 ASSERT_EQ(res, HCF_SUCCESS);
477 ASSERT_NE(keyPair, nullptr);
478
479 keyPair->base.destroy((HcfObjectBase *)(&(keyPair->base)));
480
481 HcfObjDestroy(generator);
482 }
483
484 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest303, TestSize.Level0)
485 {
486 HcfAsyKeyGenerator *generator = nullptr;
487 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
488
489 HcfKeyPair *keyPair = nullptr;
490 res = generator->generateKeyPair(generator, nullptr, &keyPair);
491
492 ASSERT_EQ(res, HCF_SUCCESS);
493 ASSERT_NE(keyPair, nullptr);
494
495 keyPair->base.destroy(nullptr);
496
497 HcfObjDestroy(keyPair);
498 HcfObjDestroy(generator);
499 }
500
501 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest304, TestSize.Level0)
502 {
503 HcfAsyKeyGenerator *generator = nullptr;
504 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
505
506 HcfKeyPair *keyPair = nullptr;
507 res = generator->generateKeyPair(generator, nullptr, &keyPair);
508
509 ASSERT_EQ(res, HCF_SUCCESS);
510 ASSERT_NE(keyPair, nullptr);
511
512 keyPair->base.destroy(&g_obj);
513
514 HcfObjDestroy(keyPair);
515 HcfObjDestroy(generator);
516 }
517
518 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest305, TestSize.Level0)
519 {
520 HcfAsyKeyGenerator *generator = nullptr;
521 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
522
523 HcfKeyPair *keyPair = nullptr;
524 res = generator->generateKeyPair(generator, nullptr, &keyPair);
525
526 ASSERT_EQ(res, HCF_SUCCESS);
527 ASSERT_NE(keyPair, nullptr);
528
529 const char *className = keyPair->pubKey->base.base.getClass();
530 ASSERT_NE(className, nullptr);
531
532 HcfObjDestroy(keyPair);
533 HcfObjDestroy(generator);
534 }
535
536 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest306, TestSize.Level0)
537 {
538 HcfAsyKeyGenerator *generator = nullptr;
539 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
540
541 HcfKeyPair *keyPair = nullptr;
542 res = generator->generateKeyPair(generator, nullptr, &keyPair);
543
544 ASSERT_EQ(res, HCF_SUCCESS);
545 ASSERT_NE(keyPair, nullptr);
546
547 keyPair->pubKey->base.base.destroy((HcfObjectBase *)(&(keyPair->pubKey->base.base)));
548 keyPair->pubKey = nullptr;
549
550 HcfObjDestroy(keyPair);
551 HcfObjDestroy(generator);
552 }
553
554 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest307, TestSize.Level0)
555 {
556 HcfAsyKeyGenerator *generator = nullptr;
557 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
558
559 HcfKeyPair *keyPair = nullptr;
560 res = generator->generateKeyPair(generator, nullptr, &keyPair);
561
562 ASSERT_EQ(res, HCF_SUCCESS);
563 ASSERT_NE(keyPair, nullptr);
564
565 keyPair->pubKey->base.base.destroy(nullptr);
566
567 HcfObjDestroy(keyPair);
568 HcfObjDestroy(generator);
569 }
570
571 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest308, TestSize.Level0)
572 {
573 HcfAsyKeyGenerator *generator = nullptr;
574 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
575
576 HcfKeyPair *keyPair = nullptr;
577 res = generator->generateKeyPair(generator, nullptr, &keyPair);
578
579 ASSERT_EQ(res, HCF_SUCCESS);
580 ASSERT_NE(keyPair, nullptr);
581
582 keyPair->pubKey->base.base.destroy(&g_obj);
583
584 HcfObjDestroy(keyPair);
585 HcfObjDestroy(generator);
586 }
587
588 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest309, TestSize.Level0)
589 {
590 HcfAsyKeyGenerator *generator = nullptr;
591 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
592
593 HcfKeyPair *keyPair = nullptr;
594 res = generator->generateKeyPair(generator, nullptr, &keyPair);
595
596 ASSERT_EQ(res, HCF_SUCCESS);
597 ASSERT_NE(keyPair, nullptr);
598
599 const char *format = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
600
601 ASSERT_NE(format, nullptr);
602
603 HcfObjDestroy(keyPair);
604 HcfObjDestroy(generator);
605 }
606
607 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest310, TestSize.Level0)
608 {
609 HcfAsyKeyGenerator *generator = nullptr;
610 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
611
612 HcfKeyPair *keyPair = nullptr;
613 res = generator->generateKeyPair(generator, nullptr, &keyPair);
614
615 ASSERT_EQ(res, HCF_SUCCESS);
616 ASSERT_NE(keyPair, nullptr);
617
618 const char *format = keyPair->pubKey->base.getFormat(nullptr);
619
620 ASSERT_EQ(format, nullptr);
621
622 HcfObjDestroy(keyPair);
623 HcfObjDestroy(generator);
624 }
625
626 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest311, TestSize.Level0)
627 {
628 HcfAsyKeyGenerator *generator = nullptr;
629 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &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->pubKey->base.getFormat((HcfKey *)&g_obj);
638
639 ASSERT_EQ(format, nullptr);
640
641 HcfObjDestroy(keyPair);
642 HcfObjDestroy(generator);
643 }
644
645 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest312, TestSize.Level0)
646 {
647 HcfAsyKeyGenerator *generator = nullptr;
648 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &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 *algName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
657
658 ASSERT_NE(algName, nullptr);
659
660 HcfObjDestroy(keyPair);
661 HcfObjDestroy(generator);
662 }
663
664 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest313, TestSize.Level0)
665 {
666 HcfAsyKeyGenerator *generator = nullptr;
667 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &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->pubKey->base.getAlgorithm(nullptr);
676
677 ASSERT_EQ(algName, nullptr);
678
679 HcfObjDestroy(keyPair);
680 HcfObjDestroy(generator);
681 }
682
683 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest314, TestSize.Level0)
684 {
685 HcfAsyKeyGenerator *generator = nullptr;
686 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &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->pubKey->base.getAlgorithm((HcfKey *)&g_obj);
695
696 ASSERT_EQ(algName, nullptr);
697
698 HcfObjDestroy(keyPair);
699 HcfObjDestroy(generator);
700 }
701
702 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest315, TestSize.Level0)
703 {
704 HcfAsyKeyGenerator *generator = nullptr;
705 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &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->pubKey->base.getEncoded(&(keyPair->pubKey->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(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest316, TestSize.Level0)
727 {
728 HcfAsyKeyGenerator *generator = nullptr;
729 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &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->pubKey->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(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest317, TestSize.Level0)
749 {
750 HcfAsyKeyGenerator *generator = nullptr;
751 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &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 HcfBlob blob = { .data = nullptr, .len = 0 };
760 res = keyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob);
761
762 ASSERT_NE(res, HCF_SUCCESS);
763 ASSERT_EQ(blob.data, nullptr);
764 ASSERT_EQ(blob.len, 0);
765
766 HcfObjDestroy(keyPair);
767 HcfObjDestroy(generator);
768 }
769
770 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest318, TestSize.Level0)
771 {
772 HcfAsyKeyGenerator *generator = nullptr;
773 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
774
775 HcfKeyPair *keyPair = nullptr;
776 res = generator->generateKeyPair(generator, nullptr, &keyPair);
777
778 ASSERT_EQ(res, HCF_SUCCESS);
779 ASSERT_NE(keyPair, nullptr);
780
781 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), nullptr);
782
783 ASSERT_NE(res, HCF_SUCCESS);
784
785 HcfObjDestroy(keyPair);
786 HcfObjDestroy(generator);
787 }
788
789 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest319, TestSize.Level0)
790 {
791 HcfAsyKeyGenerator *generator = nullptr;
792 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
793
794 HcfKeyPair *keyPair = nullptr;
795 res = generator->generateKeyPair(generator, nullptr, &keyPair);
796
797 ASSERT_EQ(res, HCF_SUCCESS);
798 ASSERT_NE(keyPair, nullptr);
799
800 keyPair->priKey->clearMem(keyPair->priKey);
801
802 HcfObjDestroy(keyPair);
803 HcfObjDestroy(generator);
804 }
805
806 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest320, TestSize.Level0)
807 {
808 HcfAsyKeyGenerator *generator = nullptr;
809 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
810
811 HcfKeyPair *keyPair = nullptr;
812 res = generator->generateKeyPair(generator, nullptr, &keyPair);
813
814 ASSERT_EQ(res, HCF_SUCCESS);
815 ASSERT_NE(keyPair, nullptr);
816
817 keyPair->priKey->clearMem(nullptr);
818
819 HcfObjDestroy(keyPair);
820 HcfObjDestroy(generator);
821 }
822
823 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest321, TestSize.Level0)
824 {
825 HcfAsyKeyGenerator *generator = nullptr;
826 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
827
828 HcfKeyPair *keyPair = nullptr;
829 res = generator->generateKeyPair(generator, nullptr, &keyPair);
830
831 ASSERT_EQ(res, HCF_SUCCESS);
832 ASSERT_NE(keyPair, nullptr);
833
834 keyPair->priKey->clearMem((HcfPriKey *)&g_obj);
835
836 HcfObjDestroy(keyPair);
837 HcfObjDestroy(generator);
838 }
839
840 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest322, TestSize.Level0)
841 {
842 HcfAsyKeyGenerator *generator = nullptr;
843 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
844
845 HcfKeyPair *keyPair = nullptr;
846 res = generator->generateKeyPair(generator, nullptr, &keyPair);
847
848 ASSERT_EQ(res, HCF_SUCCESS);
849 ASSERT_NE(keyPair, nullptr);
850
851 const char *algName = keyPair->priKey->base.base.getClass();
852
853 ASSERT_NE(algName, nullptr);
854
855 HcfObjDestroy(keyPair);
856 HcfObjDestroy(generator);
857 }
858
859 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest323, TestSize.Level0)
860 {
861 HcfAsyKeyGenerator *generator = nullptr;
862 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
863
864 HcfKeyPair *keyPair = nullptr;
865 res = generator->generateKeyPair(generator, nullptr, &keyPair);
866
867 ASSERT_EQ(res, HCF_SUCCESS);
868 ASSERT_NE(keyPair, nullptr);
869
870 keyPair->priKey->base.base.destroy((HcfObjectBase *)(&(keyPair->priKey->base.base)));
871 keyPair->priKey = nullptr;
872
873 HcfObjDestroy(keyPair);
874 HcfObjDestroy(generator);
875 }
876
877 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest324, TestSize.Level0)
878 {
879 HcfAsyKeyGenerator *generator = nullptr;
880 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
881
882 HcfKeyPair *keyPair = nullptr;
883 res = generator->generateKeyPair(generator, nullptr, &keyPair);
884
885 ASSERT_EQ(res, HCF_SUCCESS);
886 ASSERT_NE(keyPair, nullptr);
887
888 keyPair->priKey->base.base.destroy(nullptr);
889
890 HcfObjDestroy(keyPair);
891 HcfObjDestroy(generator);
892 }
893
894 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest325, TestSize.Level0)
895 {
896 HcfAsyKeyGenerator *generator = nullptr;
897 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
898
899 HcfKeyPair *keyPair = nullptr;
900 res = generator->generateKeyPair(generator, nullptr, &keyPair);
901
902 ASSERT_EQ(res, HCF_SUCCESS);
903 ASSERT_NE(keyPair, nullptr);
904
905 keyPair->priKey->base.base.destroy(&g_obj);
906
907 HcfObjDestroy(keyPair);
908 HcfObjDestroy(generator);
909 }
910
911 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest326, TestSize.Level0)
912 {
913 HcfAsyKeyGenerator *generator = nullptr;
914 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
915
916 HcfKeyPair *keyPair = nullptr;
917 res = generator->generateKeyPair(generator, nullptr, &keyPair);
918
919 ASSERT_EQ(res, HCF_SUCCESS);
920 ASSERT_NE(keyPair, nullptr);
921
922 const char *format = keyPair->priKey->base.getFormat(&keyPair->priKey->base);
923
924 ASSERT_NE(format, nullptr);
925
926 HcfObjDestroy(keyPair);
927 HcfObjDestroy(generator);
928 }
929
930 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest327, TestSize.Level0)
931 {
932 HcfAsyKeyGenerator *generator = nullptr;
933 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
934
935 HcfKeyPair *keyPair = nullptr;
936 res = generator->generateKeyPair(generator, nullptr, &keyPair);
937
938 ASSERT_EQ(res, HCF_SUCCESS);
939 ASSERT_NE(keyPair, nullptr);
940
941 const char *format = keyPair->priKey->base.getFormat(nullptr);
942
943 ASSERT_EQ(format, nullptr);
944
945 HcfObjDestroy(keyPair);
946 HcfObjDestroy(generator);
947 }
948
949 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest328, TestSize.Level0)
950 {
951 HcfAsyKeyGenerator *generator = nullptr;
952 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
953
954 HcfKeyPair *keyPair = nullptr;
955 res = generator->generateKeyPair(generator, nullptr, &keyPair);
956
957 ASSERT_EQ(res, HCF_SUCCESS);
958 ASSERT_NE(keyPair, nullptr);
959
960 const char *format = keyPair->priKey->base.getFormat((HcfKey *)&g_obj);
961
962 ASSERT_EQ(format, nullptr);
963
964 HcfObjDestroy(keyPair);
965 HcfObjDestroy(generator);
966 }
967
968 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest329, TestSize.Level0)
969 {
970 HcfAsyKeyGenerator *generator = nullptr;
971 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
972
973 HcfKeyPair *keyPair = nullptr;
974 res = generator->generateKeyPair(generator, nullptr, &keyPair);
975
976 ASSERT_EQ(res, HCF_SUCCESS);
977 ASSERT_NE(keyPair, nullptr);
978
979 const char *algName = keyPair->priKey->base.getAlgorithm(&keyPair->priKey->base);
980
981 ASSERT_NE(algName, nullptr);
982
983 HcfObjDestroy(keyPair);
984 HcfObjDestroy(generator);
985 }
986
987 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest330, TestSize.Level0)
988 {
989 HcfAsyKeyGenerator *generator = nullptr;
990 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
991
992 HcfKeyPair *keyPair = nullptr;
993 res = generator->generateKeyPair(generator, nullptr, &keyPair);
994
995 ASSERT_EQ(res, HCF_SUCCESS);
996 ASSERT_NE(keyPair, nullptr);
997
998 const char *algName = keyPair->priKey->base.getAlgorithm(nullptr);
999
1000 ASSERT_EQ(algName, nullptr);
1001
1002 HcfObjDestroy(keyPair);
1003 HcfObjDestroy(generator);
1004 }
1005
1006 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest331, TestSize.Level0)
1007 {
1008 HcfAsyKeyGenerator *generator = nullptr;
1009 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1010
1011 HcfKeyPair *keyPair = nullptr;
1012 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1013
1014 ASSERT_EQ(res, HCF_SUCCESS);
1015 ASSERT_NE(keyPair, nullptr);
1016
1017 const char *algName = keyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj);
1018
1019 ASSERT_EQ(algName, nullptr);
1020
1021 HcfObjDestroy(keyPair);
1022 HcfObjDestroy(generator);
1023 }
1024
1025 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest332, TestSize.Level0)
1026 {
1027 HcfAsyKeyGenerator *generator = nullptr;
1028 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1029
1030 HcfKeyPair *keyPair = nullptr;
1031 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1032
1033 ASSERT_EQ(res, HCF_SUCCESS);
1034 ASSERT_NE(keyPair, nullptr);
1035
1036 HcfBlob blob = { .data = nullptr, .len = 0 };
1037 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
1038
1039 ASSERT_EQ(res, HCF_SUCCESS);
1040 ASSERT_NE(blob.data, nullptr);
1041 ASSERT_NE(blob.len, 0);
1042
1043 HcfFree(blob.data);
1044
1045 HcfObjDestroy(keyPair);
1046 HcfObjDestroy(generator);
1047 }
1048
1049 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest333, TestSize.Level0)
1050 {
1051 HcfAsyKeyGenerator *generator = nullptr;
1052 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1053
1054 HcfKeyPair *keyPair = nullptr;
1055 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1056
1057 ASSERT_EQ(res, HCF_SUCCESS);
1058 ASSERT_NE(keyPair, nullptr);
1059
1060 HcfBlob blob = { .data = nullptr, .len = 0 };
1061 res = keyPair->priKey->base.getEncoded(nullptr, &blob);
1062
1063 ASSERT_NE(res, HCF_SUCCESS);
1064 ASSERT_EQ(blob.data, nullptr);
1065 ASSERT_EQ(blob.len, 0);
1066
1067 HcfObjDestroy(keyPair);
1068 HcfObjDestroy(generator);
1069 }
1070
1071 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest334, TestSize.Level0)
1072 {
1073 HcfAsyKeyGenerator *generator = nullptr;
1074 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1075
1076 HcfKeyPair *keyPair = nullptr;
1077 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1078
1079 ASSERT_EQ(res, HCF_SUCCESS);
1080 ASSERT_NE(keyPair, nullptr);
1081
1082 HcfBlob blob = { .data = nullptr, .len = 0 };
1083 res = keyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob);
1084
1085 ASSERT_NE(res, HCF_SUCCESS);
1086 ASSERT_EQ(blob.data, nullptr);
1087 ASSERT_EQ(blob.len, 0);
1088
1089 HcfObjDestroy(keyPair);
1090 HcfObjDestroy(generator);
1091 }
1092
1093 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest335, TestSize.Level0)
1094 {
1095 HcfAsyKeyGenerator *generator = nullptr;
1096 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1097
1098 HcfKeyPair *keyPair = nullptr;
1099 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1100
1101 ASSERT_EQ(res, HCF_SUCCESS);
1102 ASSERT_NE(keyPair, nullptr);
1103
1104 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), nullptr);
1105
1106 ASSERT_NE(res, HCF_SUCCESS);
1107
1108 HcfObjDestroy(keyPair);
1109 HcfObjDestroy(generator);
1110 }
1111
1112 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest401, TestSize.Level0)
1113 {
1114 HcfAsyKeyGenerator *generator = nullptr;
1115 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1116
1117 HcfKeyPair *outKeyPair = nullptr;
1118 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &outKeyPair);
1119
1120 ASSERT_EQ(res, HCF_SUCCESS);
1121 ASSERT_NE(outKeyPair, nullptr);
1122
1123 HcfObjDestroy(outKeyPair);
1124 HcfObjDestroy(generator);
1125 }
1126
1127 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest402, TestSize.Level0)
1128 {
1129 HcfAsyKeyGenerator *generator = nullptr;
1130 int32_t res = HcfAsyKeyGeneratorCreate("ECC256", &generator);
1131
1132 HcfKeyPair *outKeyPair = nullptr;
1133 res = generator->convertKey(generator, nullptr, &g_mockEcc256PubKeyBlob, &g_mockEcc256PriKeyBlob, &outKeyPair);
1134
1135 ASSERT_EQ(res, HCF_SUCCESS);
1136 ASSERT_NE(outKeyPair, nullptr);
1137
1138 HcfObjDestroy(outKeyPair);
1139 HcfObjDestroy(generator);
1140 }
1141
1142 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest403, TestSize.Level0)
1143 {
1144 HcfAsyKeyGenerator *generator = nullptr;
1145 int32_t res = HcfAsyKeyGeneratorCreate("ECC384", &generator);
1146
1147 HcfKeyPair *outKeyPair = nullptr;
1148 res = generator->convertKey(generator, nullptr, &g_mockEcc384PubKeyBlob, &g_mockEcc384PriKeyBlob, &outKeyPair);
1149
1150 ASSERT_EQ(res, HCF_SUCCESS);
1151 ASSERT_NE(outKeyPair, nullptr);
1152
1153 HcfObjDestroy(outKeyPair);
1154 HcfObjDestroy(generator);
1155 }
1156
1157 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest404, TestSize.Level0)
1158 {
1159 HcfAsyKeyGenerator *generator = nullptr;
1160 int32_t res = HcfAsyKeyGeneratorCreate("ECC521", &generator);
1161
1162 HcfKeyPair *outKeyPair = nullptr;
1163 res = generator->convertKey(generator, nullptr, &g_mockEcc521PubKeyBlob, &g_mockEcc521PriKeyBlob, &outKeyPair);
1164
1165 ASSERT_EQ(res, HCF_SUCCESS);
1166 ASSERT_NE(outKeyPair, nullptr);
1167
1168 HcfObjDestroy(outKeyPair);
1169 HcfObjDestroy(generator);
1170 }
1171
1172 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest405, TestSize.Level0)
1173 {
1174 HcfAsyKeyGenerator *generator = nullptr;
1175 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1176
1177 HcfKeyPair *outKeyPair = nullptr;
1178 res = generator->convertKey(nullptr, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &outKeyPair);
1179
1180 ASSERT_NE(res, HCF_SUCCESS);
1181 ASSERT_EQ(outKeyPair, nullptr);
1182
1183 HcfObjDestroy(generator);
1184 }
1185
1186 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest406, TestSize.Level0)
1187 {
1188 HcfAsyKeyGenerator *generator = nullptr;
1189 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1190
1191 HcfKeyPair *outKeyPair = nullptr;
1192 res = generator->convertKey((HcfAsyKeyGenerator *)&g_obj, nullptr,
1193 &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &outKeyPair);
1194
1195 ASSERT_NE(res, HCF_SUCCESS);
1196 ASSERT_EQ(outKeyPair, nullptr);
1197
1198 HcfObjDestroy(generator);
1199 }
1200
1201 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest407, TestSize.Level0)
1202 {
1203 HcfAsyKeyGenerator *generator = nullptr;
1204 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1205
1206 HcfKeyPair *outKeyPair = nullptr;
1207 res = generator->convertKey(generator, nullptr, nullptr, &g_mockEcc224PriKeyBlob, &outKeyPair);
1208
1209 ASSERT_EQ(res, HCF_SUCCESS);
1210 ASSERT_NE(outKeyPair, nullptr);
1211
1212 HcfObjDestroy(outKeyPair);
1213 HcfObjDestroy(generator);
1214 }
1215
1216 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest408, TestSize.Level0)
1217 {
1218 HcfAsyKeyGenerator *generator = nullptr;
1219 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1220
1221 HcfKeyPair *outKeyPair = nullptr;
1222 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, nullptr, &outKeyPair);
1223
1224 ASSERT_EQ(res, HCF_SUCCESS);
1225 ASSERT_NE(outKeyPair, nullptr);
1226
1227 HcfObjDestroy(outKeyPair);
1228 HcfObjDestroy(generator);
1229 }
1230
1231 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest409, TestSize.Level0)
1232 {
1233 HcfAsyKeyGenerator *generator = nullptr;
1234 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1235
1236 HcfKeyPair *outKeyPair = nullptr;
1237 res = generator->convertKey(generator, nullptr, nullptr, nullptr, &outKeyPair);
1238
1239 ASSERT_NE(res, HCF_SUCCESS);
1240 ASSERT_EQ(outKeyPair, nullptr);
1241
1242 HcfObjDestroy(generator);
1243 }
1244
1245 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest410, TestSize.Level0)
1246 {
1247 HcfAsyKeyGenerator *generator = nullptr;
1248 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1249
1250 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, nullptr);
1251
1252 ASSERT_NE(res, HCF_SUCCESS);
1253
1254 HcfObjDestroy(generator);
1255 }
1256
1257 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest501, TestSize.Level0)
1258 {
1259 HcfAsyKeyGenerator *generator = nullptr;
1260 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1261
1262 HcfKeyPair *keyPair = nullptr;
1263 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1264
1265 ASSERT_EQ(res, HCF_SUCCESS);
1266 ASSERT_NE(keyPair, nullptr);
1267
1268 const char *className = keyPair->base.getClass();
1269
1270 ASSERT_NE(className, nullptr);
1271
1272 HcfObjDestroy(keyPair);
1273 HcfObjDestroy(generator);
1274 }
1275
1276 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest502, TestSize.Level0)
1277 {
1278 HcfAsyKeyGenerator *generator = nullptr;
1279 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1280
1281 HcfKeyPair *keyPair = nullptr;
1282 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1283
1284 ASSERT_EQ(res, HCF_SUCCESS);
1285 ASSERT_NE(keyPair, nullptr);
1286
1287 keyPair->base.destroy((HcfObjectBase *)(&(keyPair->base)));
1288
1289 HcfObjDestroy(generator);
1290 }
1291
1292 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest503, TestSize.Level0)
1293 {
1294 HcfAsyKeyGenerator *generator = nullptr;
1295 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1296
1297 HcfKeyPair *keyPair = nullptr;
1298 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1299
1300 ASSERT_EQ(res, HCF_SUCCESS);
1301 ASSERT_NE(keyPair, nullptr);
1302
1303 keyPair->base.destroy(nullptr);
1304
1305 HcfObjDestroy(keyPair);
1306 HcfObjDestroy(generator);
1307 }
1308
1309 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest504, TestSize.Level0)
1310 {
1311 HcfAsyKeyGenerator *generator = nullptr;
1312 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1313
1314 HcfKeyPair *keyPair = nullptr;
1315 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1316
1317 ASSERT_EQ(res, HCF_SUCCESS);
1318 ASSERT_NE(keyPair, nullptr);
1319
1320 keyPair->base.destroy(&g_obj);
1321
1322 HcfObjDestroy(keyPair);
1323 HcfObjDestroy(generator);
1324 }
1325
1326 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest505, TestSize.Level0)
1327 {
1328 HcfAsyKeyGenerator *generator = nullptr;
1329 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1330
1331 HcfKeyPair *keyPair = nullptr;
1332 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1333
1334 ASSERT_EQ(res, HCF_SUCCESS);
1335 ASSERT_NE(keyPair, nullptr);
1336
1337 const char *className = keyPair->pubKey->base.base.getClass();
1338 ASSERT_NE(className, nullptr);
1339
1340 HcfObjDestroy(keyPair);
1341 HcfObjDestroy(generator);
1342 }
1343
1344 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest506, TestSize.Level0)
1345 {
1346 HcfAsyKeyGenerator *generator = nullptr;
1347 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1348
1349 HcfKeyPair *keyPair = nullptr;
1350 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1351
1352 ASSERT_EQ(res, HCF_SUCCESS);
1353 ASSERT_NE(keyPair, nullptr);
1354
1355 keyPair->pubKey->base.base.destroy((HcfObjectBase *)(&(keyPair->pubKey->base.base)));
1356 keyPair->pubKey = nullptr;
1357
1358 HcfObjDestroy(keyPair);
1359 HcfObjDestroy(generator);
1360 }
1361
1362 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest507, TestSize.Level0)
1363 {
1364 HcfAsyKeyGenerator *generator = nullptr;
1365 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1366
1367 HcfKeyPair *keyPair = nullptr;
1368 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1369
1370 ASSERT_EQ(res, HCF_SUCCESS);
1371 ASSERT_NE(keyPair, nullptr);
1372
1373 keyPair->pubKey->base.base.destroy(nullptr);
1374
1375 HcfObjDestroy(keyPair);
1376 HcfObjDestroy(generator);
1377 }
1378
1379 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest508, TestSize.Level0)
1380 {
1381 HcfAsyKeyGenerator *generator = nullptr;
1382 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1383
1384 HcfKeyPair *keyPair = nullptr;
1385 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1386
1387 ASSERT_EQ(res, HCF_SUCCESS);
1388 ASSERT_NE(keyPair, nullptr);
1389
1390 keyPair->pubKey->base.base.destroy(&g_obj);
1391
1392 HcfObjDestroy(keyPair);
1393 HcfObjDestroy(generator);
1394 }
1395
1396 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest509, TestSize.Level0)
1397 {
1398 HcfAsyKeyGenerator *generator = nullptr;
1399 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1400
1401 HcfKeyPair *keyPair = nullptr;
1402 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1403
1404 ASSERT_EQ(res, HCF_SUCCESS);
1405 ASSERT_NE(keyPair, nullptr);
1406
1407 const char *format = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
1408
1409 ASSERT_NE(format, nullptr);
1410
1411 HcfObjDestroy(keyPair);
1412 HcfObjDestroy(generator);
1413 }
1414
1415 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest510, TestSize.Level0)
1416 {
1417 HcfAsyKeyGenerator *generator = nullptr;
1418 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1419
1420 HcfKeyPair *keyPair = nullptr;
1421 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1422
1423 ASSERT_EQ(res, HCF_SUCCESS);
1424 ASSERT_NE(keyPair, nullptr);
1425
1426 const char *format = keyPair->pubKey->base.getFormat(nullptr);
1427
1428 ASSERT_EQ(format, nullptr);
1429
1430 HcfObjDestroy(keyPair);
1431 HcfObjDestroy(generator);
1432 }
1433
1434 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest511, TestSize.Level0)
1435 {
1436 HcfAsyKeyGenerator *generator = nullptr;
1437 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1438
1439 HcfKeyPair *keyPair = nullptr;
1440 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1441
1442 ASSERT_EQ(res, HCF_SUCCESS);
1443 ASSERT_NE(keyPair, nullptr);
1444
1445 const char *format = keyPair->pubKey->base.getFormat((HcfKey *)&g_obj);
1446
1447 ASSERT_EQ(format, nullptr);
1448
1449 HcfObjDestroy(keyPair);
1450 HcfObjDestroy(generator);
1451 }
1452
1453 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest512, TestSize.Level0)
1454 {
1455 HcfAsyKeyGenerator *generator = nullptr;
1456 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1457
1458 HcfKeyPair *keyPair = nullptr;
1459 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1460
1461 ASSERT_EQ(res, HCF_SUCCESS);
1462 ASSERT_NE(keyPair, nullptr);
1463
1464 const char *algName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
1465
1466 ASSERT_NE(algName, nullptr);
1467
1468 HcfObjDestroy(keyPair);
1469 HcfObjDestroy(generator);
1470 }
1471
1472 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest513, TestSize.Level0)
1473 {
1474 HcfAsyKeyGenerator *generator = nullptr;
1475 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1476
1477 HcfKeyPair *keyPair = nullptr;
1478 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1479
1480 ASSERT_EQ(res, HCF_SUCCESS);
1481 ASSERT_NE(keyPair, nullptr);
1482
1483 const char *algName = keyPair->pubKey->base.getAlgorithm(nullptr);
1484
1485 ASSERT_EQ(algName, nullptr);
1486
1487 HcfObjDestroy(keyPair);
1488 HcfObjDestroy(generator);
1489 }
1490
1491 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest514, TestSize.Level0)
1492 {
1493 HcfAsyKeyGenerator *generator = nullptr;
1494 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1495
1496 HcfKeyPair *keyPair = nullptr;
1497 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1498
1499 ASSERT_EQ(res, HCF_SUCCESS);
1500 ASSERT_NE(keyPair, nullptr);
1501
1502 const char *algName = keyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj);
1503
1504 ASSERT_EQ(algName, nullptr);
1505
1506 HcfObjDestroy(keyPair);
1507 HcfObjDestroy(generator);
1508 }
1509
1510 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest515, TestSize.Level0)
1511 {
1512 HcfAsyKeyGenerator *generator = nullptr;
1513 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1514
1515 HcfKeyPair *keyPair = nullptr;
1516 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1517
1518 ASSERT_EQ(res, HCF_SUCCESS);
1519 ASSERT_NE(keyPair, nullptr);
1520
1521 HcfBlob blob = { .data = nullptr, .len = 0 };
1522 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
1523
1524 ASSERT_EQ(res, HCF_SUCCESS);
1525 ASSERT_NE(blob.data, nullptr);
1526 ASSERT_NE(blob.len, 0);
1527
1528 HcfFree(blob.data);
1529
1530 HcfObjDestroy(keyPair);
1531 HcfObjDestroy(generator);
1532 }
1533
1534 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest516, TestSize.Level0)
1535 {
1536 HcfAsyKeyGenerator *generator = nullptr;
1537 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1538
1539 HcfKeyPair *keyPair = nullptr;
1540 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1541
1542 ASSERT_EQ(res, HCF_SUCCESS);
1543 ASSERT_NE(keyPair, nullptr);
1544
1545 HcfBlob blob = { .data = nullptr, .len = 0 };
1546 res = keyPair->pubKey->base.getEncoded(nullptr, &blob);
1547
1548 ASSERT_NE(res, HCF_SUCCESS);
1549 ASSERT_EQ(blob.data, nullptr);
1550 ASSERT_EQ(blob.len, 0);
1551
1552 HcfObjDestroy(keyPair);
1553 HcfObjDestroy(generator);
1554 }
1555
1556 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest517, TestSize.Level0)
1557 {
1558 HcfAsyKeyGenerator *generator = nullptr;
1559 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1560
1561 HcfKeyPair *keyPair = nullptr;
1562 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1563
1564 ASSERT_EQ(res, HCF_SUCCESS);
1565 ASSERT_NE(keyPair, nullptr);
1566
1567 HcfBlob blob = { .data = nullptr, .len = 0 };
1568 res = keyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob);
1569
1570 ASSERT_NE(res, HCF_SUCCESS);
1571 ASSERT_EQ(blob.data, nullptr);
1572 ASSERT_EQ(blob.len, 0);
1573
1574 HcfObjDestroy(keyPair);
1575 HcfObjDestroy(generator);
1576 }
1577
1578 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest518, TestSize.Level0)
1579 {
1580 HcfAsyKeyGenerator *generator = nullptr;
1581 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1582
1583 HcfKeyPair *keyPair = nullptr;
1584 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1585
1586 ASSERT_EQ(res, HCF_SUCCESS);
1587 ASSERT_NE(keyPair, nullptr);
1588
1589 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), nullptr);
1590
1591 ASSERT_NE(res, HCF_SUCCESS);
1592
1593 HcfObjDestroy(keyPair);
1594 HcfObjDestroy(generator);
1595 }
1596
1597 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest519, TestSize.Level0)
1598 {
1599 HcfAsyKeyGenerator *generator = nullptr;
1600 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1601
1602 HcfKeyPair *keyPair = nullptr;
1603 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1604
1605 ASSERT_EQ(res, HCF_SUCCESS);
1606 ASSERT_NE(keyPair, nullptr);
1607
1608 keyPair->priKey->clearMem(keyPair->priKey);
1609
1610 HcfObjDestroy(keyPair);
1611 HcfObjDestroy(generator);
1612 }
1613
1614 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest520, TestSize.Level0)
1615 {
1616 HcfAsyKeyGenerator *generator = nullptr;
1617 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1618
1619 HcfKeyPair *keyPair = nullptr;
1620 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1621
1622 ASSERT_EQ(res, HCF_SUCCESS);
1623 ASSERT_NE(keyPair, nullptr);
1624
1625 keyPair->priKey->clearMem(nullptr);
1626
1627 HcfObjDestroy(keyPair);
1628 HcfObjDestroy(generator);
1629 }
1630
1631 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest521, TestSize.Level0)
1632 {
1633 HcfAsyKeyGenerator *generator = nullptr;
1634 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1635
1636 HcfKeyPair *keyPair = nullptr;
1637 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1638
1639 ASSERT_EQ(res, HCF_SUCCESS);
1640 ASSERT_NE(keyPair, nullptr);
1641
1642 keyPair->priKey->clearMem((HcfPriKey *)&g_obj);
1643
1644 HcfObjDestroy(keyPair);
1645 HcfObjDestroy(generator);
1646 }
1647
1648 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest522, TestSize.Level0)
1649 {
1650 HcfAsyKeyGenerator *generator = nullptr;
1651 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1652
1653 HcfKeyPair *keyPair = nullptr;
1654 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1655
1656 ASSERT_EQ(res, HCF_SUCCESS);
1657 ASSERT_NE(keyPair, nullptr);
1658
1659 const char *algName = keyPair->priKey->base.base.getClass();
1660
1661 ASSERT_NE(algName, nullptr);
1662
1663 HcfObjDestroy(keyPair);
1664 HcfObjDestroy(generator);
1665 }
1666
1667 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest523, TestSize.Level0)
1668 {
1669 HcfAsyKeyGenerator *generator = nullptr;
1670 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1671
1672 HcfKeyPair *keyPair = nullptr;
1673 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1674
1675 ASSERT_EQ(res, HCF_SUCCESS);
1676 ASSERT_NE(keyPair, nullptr);
1677
1678 keyPair->priKey->base.base.destroy((HcfObjectBase *)(&(keyPair->priKey->base.base)));
1679 keyPair->priKey = nullptr;
1680
1681 HcfObjDestroy(keyPair);
1682 HcfObjDestroy(generator);
1683 }
1684
1685 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest524, TestSize.Level0)
1686 {
1687 HcfAsyKeyGenerator *generator = nullptr;
1688 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1689
1690 HcfKeyPair *keyPair = nullptr;
1691 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1692
1693 ASSERT_EQ(res, HCF_SUCCESS);
1694 ASSERT_NE(keyPair, nullptr);
1695
1696 keyPair->priKey->base.base.destroy(nullptr);
1697
1698 HcfObjDestroy(keyPair);
1699 HcfObjDestroy(generator);
1700 }
1701
1702 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest525, TestSize.Level0)
1703 {
1704 HcfAsyKeyGenerator *generator = nullptr;
1705 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1706
1707 HcfKeyPair *keyPair = nullptr;
1708 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1709
1710 ASSERT_EQ(res, HCF_SUCCESS);
1711 ASSERT_NE(keyPair, nullptr);
1712
1713 keyPair->priKey->base.base.destroy(&g_obj);
1714
1715 HcfObjDestroy(keyPair);
1716 HcfObjDestroy(generator);
1717 }
1718
1719 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest526, TestSize.Level0)
1720 {
1721 HcfAsyKeyGenerator *generator = nullptr;
1722 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1723
1724 HcfKeyPair *keyPair = nullptr;
1725 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1726
1727 ASSERT_EQ(res, HCF_SUCCESS);
1728 ASSERT_NE(keyPair, nullptr);
1729
1730 const char *format = keyPair->priKey->base.getFormat(&keyPair->priKey->base);
1731
1732 ASSERT_NE(format, nullptr);
1733
1734 HcfObjDestroy(keyPair);
1735 HcfObjDestroy(generator);
1736 }
1737
1738 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest527, TestSize.Level0)
1739 {
1740 HcfAsyKeyGenerator *generator = nullptr;
1741 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1742
1743 HcfKeyPair *keyPair = nullptr;
1744 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1745
1746 ASSERT_EQ(res, HCF_SUCCESS);
1747 ASSERT_NE(keyPair, nullptr);
1748
1749 const char *format = keyPair->priKey->base.getFormat(nullptr);
1750
1751 ASSERT_EQ(format, nullptr);
1752
1753 HcfObjDestroy(keyPair);
1754 HcfObjDestroy(generator);
1755 }
1756
1757 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest528, TestSize.Level0)
1758 {
1759 HcfAsyKeyGenerator *generator = nullptr;
1760 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1761
1762 HcfKeyPair *keyPair = nullptr;
1763 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1764
1765 ASSERT_EQ(res, HCF_SUCCESS);
1766 ASSERT_NE(keyPair, nullptr);
1767
1768 const char *format = keyPair->priKey->base.getFormat((HcfKey *)&g_obj);
1769
1770 ASSERT_EQ(format, nullptr);
1771
1772 HcfObjDestroy(keyPair);
1773 HcfObjDestroy(generator);
1774 }
1775
1776 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest529, TestSize.Level0)
1777 {
1778 HcfAsyKeyGenerator *generator = nullptr;
1779 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1780
1781 HcfKeyPair *keyPair = nullptr;
1782 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1783
1784 ASSERT_EQ(res, HCF_SUCCESS);
1785 ASSERT_NE(keyPair, nullptr);
1786
1787 const char *algName = keyPair->priKey->base.getAlgorithm(&keyPair->priKey->base);
1788
1789 ASSERT_NE(algName, nullptr);
1790
1791 HcfObjDestroy(keyPair);
1792 HcfObjDestroy(generator);
1793 }
1794
1795 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest530, TestSize.Level0)
1796 {
1797 HcfAsyKeyGenerator *generator = nullptr;
1798 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1799
1800 HcfKeyPair *keyPair = nullptr;
1801 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1802
1803 ASSERT_EQ(res, HCF_SUCCESS);
1804 ASSERT_NE(keyPair, nullptr);
1805
1806 const char *algName = keyPair->priKey->base.getAlgorithm(nullptr);
1807
1808 ASSERT_EQ(algName, nullptr);
1809
1810 HcfObjDestroy(keyPair);
1811 HcfObjDestroy(generator);
1812 }
1813
1814 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest531, TestSize.Level0)
1815 {
1816 HcfAsyKeyGenerator *generator = nullptr;
1817 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1818
1819 HcfKeyPair *keyPair = nullptr;
1820 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1821
1822 ASSERT_EQ(res, HCF_SUCCESS);
1823 ASSERT_NE(keyPair, nullptr);
1824
1825 const char *algName = keyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj);
1826
1827 ASSERT_EQ(algName, nullptr);
1828
1829 HcfObjDestroy(keyPair);
1830 HcfObjDestroy(generator);
1831 }
1832
1833 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest532, TestSize.Level0)
1834 {
1835 HcfAsyKeyGenerator *generator = nullptr;
1836 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1837
1838 HcfKeyPair *keyPair = nullptr;
1839 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1840
1841 ASSERT_EQ(res, HCF_SUCCESS);
1842 ASSERT_NE(keyPair, nullptr);
1843
1844 HcfBlob blob = { .data = nullptr, .len = 0 };
1845 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
1846
1847 ASSERT_EQ(res, HCF_SUCCESS);
1848 ASSERT_NE(blob.data, nullptr);
1849 ASSERT_NE(blob.len, 0);
1850
1851 HcfFree(blob.data);
1852
1853 HcfObjDestroy(keyPair);
1854 HcfObjDestroy(generator);
1855 }
1856
1857 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest533, TestSize.Level0)
1858 {
1859 HcfAsyKeyGenerator *generator = nullptr;
1860 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1861
1862 HcfKeyPair *keyPair = nullptr;
1863 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1864
1865 ASSERT_EQ(res, HCF_SUCCESS);
1866 ASSERT_NE(keyPair, nullptr);
1867
1868 HcfBlob blob = { .data = nullptr, .len = 0 };
1869 res = keyPair->priKey->base.getEncoded(nullptr, &blob);
1870
1871 ASSERT_NE(res, HCF_SUCCESS);
1872 ASSERT_EQ(blob.data, nullptr);
1873 ASSERT_EQ(blob.len, 0);
1874
1875 HcfObjDestroy(keyPair);
1876 HcfObjDestroy(generator);
1877 }
1878
1879 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest534, TestSize.Level0)
1880 {
1881 HcfAsyKeyGenerator *generator = nullptr;
1882 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1883
1884 HcfKeyPair *keyPair = nullptr;
1885 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1886
1887 ASSERT_EQ(res, HCF_SUCCESS);
1888 ASSERT_NE(keyPair, nullptr);
1889
1890 HcfBlob blob = { .data = nullptr, .len = 0 };
1891 res = keyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob);
1892
1893 ASSERT_NE(res, HCF_SUCCESS);
1894 ASSERT_EQ(blob.data, nullptr);
1895 ASSERT_EQ(blob.len, 0);
1896
1897 HcfObjDestroy(keyPair);
1898 HcfObjDestroy(generator);
1899 }
1900
1901 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest535, TestSize.Level0)
1902 {
1903 HcfAsyKeyGenerator *generator = nullptr;
1904 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1905
1906 HcfKeyPair *keyPair = nullptr;
1907 res = generator->convertKey(generator, nullptr, &g_mockEcc224PubKeyBlob, &g_mockEcc224PriKeyBlob, &keyPair);
1908
1909 ASSERT_EQ(res, HCF_SUCCESS);
1910 ASSERT_NE(keyPair, nullptr);
1911
1912 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), nullptr);
1913
1914 ASSERT_NE(res, HCF_SUCCESS);
1915
1916 HcfObjDestroy(keyPair);
1917 HcfObjDestroy(generator);
1918 }
1919
1920 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest536, TestSize.Level0)
1921 {
1922 HcfAsyKeyGenerator *generator = nullptr;
1923 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1924
1925 HcfKeyPair *keyPair = nullptr;
1926 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1927
1928 ASSERT_EQ(res, HCF_SUCCESS);
1929 ASSERT_NE(keyPair, nullptr);
1930
1931 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
1932 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
1933
1934 ASSERT_EQ(res, HCF_SUCCESS);
1935
1936 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
1937 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
1938
1939 ASSERT_EQ(res, HCF_SUCCESS);
1940
1941 HcfKeyPair *outKeyPair = nullptr;
1942 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
1943
1944 ASSERT_EQ(res, HCF_SUCCESS);
1945 ASSERT_NE(outKeyPair, nullptr);
1946
1947 HcfBlob outPubKeyBlob = { .data = nullptr, .len = 0 };
1948 res = outKeyPair->pubKey->base.getEncoded(&(outKeyPair->pubKey->base), &outPubKeyBlob);
1949
1950 ASSERT_EQ(res, HCF_SUCCESS);
1951 ASSERT_NE(outPubKeyBlob.data, nullptr);
1952 ASSERT_NE(outPubKeyBlob.len, 0);
1953
1954 HcfBlob outPriKeyBlob = { .data = nullptr, .len = 0 };
1955 res = outKeyPair->priKey->base.getEncoded(&(outKeyPair->priKey->base), &outPriKeyBlob);
1956
1957 ASSERT_EQ(res, HCF_SUCCESS);
1958 ASSERT_NE(outPriKeyBlob.data, nullptr);
1959 ASSERT_NE(outPriKeyBlob.len, 0);
1960
1961 HcfFree(pubKeyBlob.data);
1962 HcfFree(priKeyBlob.data);
1963 HcfFree(outPubKeyBlob.data);
1964 HcfFree(outPriKeyBlob.data);
1965 HcfObjDestroy(outKeyPair);
1966 HcfObjDestroy(keyPair);
1967 HcfObjDestroy(generator);
1968 }
1969
1970 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest537, TestSize.Level0)
1971 {
1972 HcfAsyKeyGenerator *generator = nullptr;
1973 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1974
1975 HcfKeyPair *keyPair = nullptr;
1976 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1977
1978 ASSERT_EQ(res, HCF_SUCCESS);
1979 ASSERT_NE(keyPair, nullptr);
1980
1981 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
1982 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
1983
1984 ASSERT_EQ(res, HCF_SUCCESS);
1985 ASSERT_NE(pubKeyBlob.data, nullptr);
1986 ASSERT_NE(pubKeyBlob.len, 0);
1987
1988 HcfKeyPair *outKeyPair = nullptr;
1989 res = generator->convertKey(generator, nullptr, &pubKeyBlob, nullptr, &outKeyPair);
1990
1991 ASSERT_EQ(res, HCF_SUCCESS);
1992 ASSERT_NE(outKeyPair, nullptr);
1993 ASSERT_NE(outKeyPair->pubKey, nullptr);
1994 ASSERT_EQ(outKeyPair->priKey, nullptr);
1995
1996 HcfBlob outPubKeyBlob = { .data = nullptr, .len = 0 };
1997 res = outKeyPair->pubKey->base.getEncoded(&(outKeyPair->pubKey->base), &outPubKeyBlob);
1998
1999 ASSERT_EQ(res, HCF_SUCCESS);
2000 ASSERT_NE(outPubKeyBlob.data, nullptr);
2001 ASSERT_NE(outPubKeyBlob.len, 0);
2002
2003 HcfFree(pubKeyBlob.data);
2004 HcfFree(outPubKeyBlob.data);
2005 HcfObjDestroy(outKeyPair);
2006 HcfObjDestroy(keyPair);
2007 HcfObjDestroy(generator);
2008 }
2009
2010 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest538, TestSize.Level0)
2011 {
2012 HcfAsyKeyGenerator *generator = nullptr;
2013 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
2014
2015 HcfKeyPair *keyPair = nullptr;
2016 res = generator->generateKeyPair(generator, nullptr, &keyPair);
2017
2018 ASSERT_EQ(res, HCF_SUCCESS);
2019 ASSERT_NE(keyPair, nullptr);
2020
2021 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
2022 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
2023
2024 ASSERT_EQ(res, HCF_SUCCESS);
2025 ASSERT_NE(priKeyBlob.data, nullptr);
2026 ASSERT_NE(priKeyBlob.len, 0);
2027
2028 HcfKeyPair *outKeyPair = nullptr;
2029 res = generator->convertKey(generator, nullptr, nullptr, &priKeyBlob, &outKeyPair);
2030
2031 ASSERT_EQ(res, HCF_SUCCESS);
2032 ASSERT_NE(outKeyPair, nullptr);
2033 ASSERT_EQ(outKeyPair->pubKey, nullptr);
2034 ASSERT_NE(outKeyPair->priKey, nullptr);
2035
2036 HcfBlob outPriKeyBlob = { .data = nullptr, .len = 0 };
2037 res = outKeyPair->priKey->base.getEncoded(&(outKeyPair->priKey->base), &outPriKeyBlob);
2038
2039 ASSERT_EQ(res, HCF_SUCCESS);
2040 ASSERT_NE(outPriKeyBlob.data, nullptr);
2041 ASSERT_NE(outPriKeyBlob.len, 0);
2042
2043 HcfFree(priKeyBlob.data);
2044 HcfFree(outPriKeyBlob.data);
2045 HcfObjDestroy(outKeyPair);
2046 HcfObjDestroy(keyPair);
2047 HcfObjDestroy(generator);
2048 }
2049
2050 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest601, TestSize.Level0)
2051 {
2052 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
2053 int32_t res = HcfAsyKeyGeneratorSpiEccCreate(nullptr, &spiObj);
2054
2055 ASSERT_EQ(res, HCF_INVALID_PARAMS);
2056 ASSERT_EQ(spiObj, nullptr);
2057 }
2058
2059 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest602, TestSize.Level0)
2060 {
2061 HcfAsyKeyGenParams params = {
2062 .algo = HCF_ALG_ECC,
2063 .bits = HCF_ALG_ECC_256,
2064 .primes = HCF_OPENSSL_PRIMES_2,
2065 };
2066
2067 int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, nullptr);
2068
2069 ASSERT_EQ(res, HCF_INVALID_PARAMS);
2070 }
2071
2072 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest603, TestSize.Level0)
2073 {
2074 HcfAsyKeyGenParams params = {
2075 .algo = HCF_ALG_ECC,
2076 .bits = HCF_ALG_MODE_NONE,
2077 .primes = HCF_OPENSSL_PRIMES_2,
2078 };
2079
2080 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
2081 int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj);
2082
2083 ASSERT_EQ(res, HCF_INVALID_PARAMS);
2084 ASSERT_EQ(spiObj, nullptr);
2085 }
2086
2087 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest604, TestSize.Level0)
2088 {
2089 HcfAsyKeyGenParams params = {
2090 .algo = HCF_ALG_ECC,
2091 .bits = HCF_ALG_ECC_256,
2092 .primes = HCF_OPENSSL_PRIMES_2,
2093 };
2094
2095 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
2096 int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj);
2097
2098 ASSERT_EQ(res, HCF_SUCCESS);
2099 ASSERT_NE(spiObj, nullptr);
2100
2101 HcfKeyPair *keyPair = nullptr;
2102 res = spiObj->engineGenerateKeyPair((HcfAsyKeyGeneratorSpi *)&g_obj, &keyPair);
2103 ASSERT_EQ(res, HCF_INVALID_PARAMS);
2104
2105 HcfObjDestroy(spiObj);
2106 }
2107
2108 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest605, TestSize.Level0)
2109 {
2110 HcfAsyKeyGenParams params = {
2111 .algo = HCF_ALG_ECC,
2112 .bits = HCF_ALG_ECC_256,
2113 .primes = HCF_OPENSSL_PRIMES_2,
2114 };
2115
2116 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
2117 int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj);
2118
2119 ASSERT_EQ(res, HCF_SUCCESS);
2120 ASSERT_NE(spiObj, nullptr);
2121
2122 HcfKeyPair *keyPair = nullptr;
2123 res = spiObj->engineConvertKey((HcfAsyKeyGeneratorSpi *)&g_obj, nullptr, nullptr, nullptr, &keyPair);
2124 ASSERT_EQ(res, HCF_INVALID_PARAMS);
2125
2126 HcfObjDestroy(spiObj);
2127 }
2128
2129 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest606, TestSize.Level0)
2130 {
2131 HcfAsyKeyGenParams params = {
2132 .algo = HCF_ALG_ECC,
2133 .bits = HCF_ALG_ECC_256,
2134 .primes = HCF_OPENSSL_PRIMES_2,
2135 };
2136
2137 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
2138 int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj);
2139
2140 ASSERT_EQ(res, HCF_SUCCESS);
2141 ASSERT_NE(spiObj, nullptr);
2142
2143 spiObj->base.destroy(nullptr);
2144
2145 HcfObjDestroy(spiObj);
2146 }
2147
2148 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest607, TestSize.Level0)
2149 {
2150 HcfAsyKeyGenParams params = {
2151 .algo = HCF_ALG_ECC,
2152 .bits = HCF_ALG_ECC_256,
2153 .primes = HCF_OPENSSL_PRIMES_2,
2154 };
2155
2156 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
2157 int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj);
2158
2159 ASSERT_EQ(res, HCF_SUCCESS);
2160 ASSERT_NE(spiObj, nullptr);
2161
2162 spiObj->base.destroy(&g_obj);
2163
2164 HcfObjDestroy(spiObj);
2165 }
2166
MemoryMallocTestFunc(uint32_t mallocCount)2167 static void MemoryMallocTestFunc(uint32_t mallocCount)
2168 {
2169 for (int i = 0; i < mallocCount; i++) {
2170 ResetRecordMallocNum();
2171 SetMockMallocIndex(i);
2172 HcfAsyKeyGenerator *tmpGenerator = nullptr;
2173 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &tmpGenerator);
2174 if (res != HCF_SUCCESS) {
2175 continue;
2176 }
2177 HcfKeyPair *tmpKeyPair = nullptr;
2178 res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
2179 if (res != HCF_SUCCESS) {
2180 HcfObjDestroy(tmpGenerator);
2181 continue;
2182 }
2183 HcfBlob tmpPubKeyBlob = {
2184 .data = nullptr,
2185 .len = 0
2186 };
2187 res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
2188 if (res != HCF_SUCCESS) {
2189 HcfObjDestroy(tmpKeyPair);
2190 HcfObjDestroy(tmpGenerator);
2191 continue;
2192 }
2193 HcfBlob tmpPriKeyBlob = {
2194 .data = nullptr,
2195 .len = 0
2196 };
2197 res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
2198 if (res != HCF_SUCCESS) {
2199 HcfFree(tmpPubKeyBlob.data);
2200 HcfObjDestroy(tmpKeyPair);
2201 HcfObjDestroy(tmpGenerator);
2202 continue;
2203 }
2204 HcfKeyPair *tmpOutKeyPair = nullptr;
2205 res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
2206 HcfFree(tmpPubKeyBlob.data);
2207 HcfFree(tmpPriKeyBlob.data);
2208 HcfObjDestroy(tmpKeyPair);
2209 HcfObjDestroy(tmpGenerator);
2210 if (res == HCF_SUCCESS) {
2211 HcfObjDestroy(tmpOutKeyPair);
2212 }
2213 }
2214 }
2215
2216 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest701, TestSize.Level0)
2217 {
2218 StartRecordMallocNum();
2219 HcfAsyKeyGenerator *generator = nullptr;
2220 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
2221
2222 HcfKeyPair *keyPair = nullptr;
2223 res = generator->generateKeyPair(generator, nullptr, &keyPair);
2224
2225 ASSERT_EQ(res, HCF_SUCCESS);
2226 ASSERT_NE(keyPair, nullptr);
2227
2228 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
2229 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
2230
2231 ASSERT_EQ(res, HCF_SUCCESS);
2232 ASSERT_NE(pubKeyBlob.data, nullptr);
2233 ASSERT_NE(pubKeyBlob.len, 0);
2234
2235 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
2236 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
2237
2238 ASSERT_EQ(res, HCF_SUCCESS);
2239 ASSERT_NE(priKeyBlob.data, nullptr);
2240 ASSERT_NE(priKeyBlob.len, 0);
2241
2242 HcfKeyPair *outKeyPair = nullptr;
2243 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
2244
2245 HcfFree(pubKeyBlob.data);
2246 HcfFree(priKeyBlob.data);
2247 HcfObjDestroy(outKeyPair);
2248 HcfObjDestroy(keyPair);
2249 HcfObjDestroy(generator);
2250
2251 uint32_t mallocCount = GetMallocNum();
2252 MemoryMallocTestFunc(mallocCount);
2253
2254 EndRecordMallocNum();
2255 }
2256
OpensslMockTestFunc(uint32_t mallocCount)2257 static void OpensslMockTestFunc(uint32_t mallocCount)
2258 {
2259 for (int i = 0; i < mallocCount; i++) {
2260 ResetOpensslCallNum();
2261 SetOpensslCallMockIndex(i);
2262 HcfAsyKeyGenerator *tmpGenerator = nullptr;
2263 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &tmpGenerator);
2264 if (res != HCF_SUCCESS) {
2265 continue;
2266 }
2267 HcfKeyPair *tmpKeyPair = nullptr;
2268 res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
2269 if (res != HCF_SUCCESS) {
2270 HcfObjDestroy(tmpGenerator);
2271 continue;
2272 }
2273 HcfBlob tmpPubKeyBlob = {
2274 .data = nullptr,
2275 .len = 0
2276 };
2277 res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
2278 if (res != HCF_SUCCESS) {
2279 HcfObjDestroy(tmpKeyPair);
2280 HcfObjDestroy(tmpGenerator);
2281 continue;
2282 }
2283 HcfBlob tmpPriKeyBlob = {
2284 .data = nullptr,
2285 .len = 0
2286 };
2287 res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
2288 if (res != HCF_SUCCESS) {
2289 HcfFree(tmpPubKeyBlob.data);
2290 HcfObjDestroy(tmpKeyPair);
2291 HcfObjDestroy(tmpGenerator);
2292 continue;
2293 }
2294 HcfKeyPair *tmpOutKeyPair = nullptr;
2295 res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
2296 HcfFree(tmpPubKeyBlob.data);
2297 HcfFree(tmpPriKeyBlob.data);
2298 HcfObjDestroy(tmpKeyPair);
2299 HcfObjDestroy(tmpGenerator);
2300 if (res == HCF_SUCCESS) {
2301 HcfObjDestroy(tmpOutKeyPair);
2302 }
2303 }
2304 }
2305
2306 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest702, TestSize.Level0)
2307 {
2308 StartRecordOpensslCallNum();
2309 HcfAsyKeyGenerator *generator = nullptr;
2310 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
2311
2312 HcfKeyPair *keyPair = nullptr;
2313 res = generator->generateKeyPair(generator, nullptr, &keyPair);
2314
2315 ASSERT_EQ(res, HCF_SUCCESS);
2316 ASSERT_NE(keyPair, nullptr);
2317
2318 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
2319 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
2320
2321 ASSERT_EQ(res, HCF_SUCCESS);
2322 ASSERT_NE(pubKeyBlob.data, nullptr);
2323 ASSERT_NE(pubKeyBlob.len, 0);
2324
2325 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
2326 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
2327
2328 ASSERT_EQ(res, HCF_SUCCESS);
2329 ASSERT_NE(priKeyBlob.data, nullptr);
2330 ASSERT_NE(priKeyBlob.len, 0);
2331
2332 HcfKeyPair *outKeyPair = nullptr;
2333 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
2334
2335 HcfFree(pubKeyBlob.data);
2336 HcfFree(priKeyBlob.data);
2337 HcfObjDestroy(outKeyPair);
2338 HcfObjDestroy(keyPair);
2339 HcfObjDestroy(generator);
2340
2341 uint32_t mallocCount = GetOpensslCallNum();
2342 OpensslMockTestFunc(mallocCount);
2343
2344 EndRecordOpensslCallNum();
2345 }
2346
2347 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccPrvKeyDerConvertTest801, TestSize.Level0)
2348 {
2349 HcfAsyKeyGenerator *generator = nullptr;
2350 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
2351 const char *wrongFormat = "PKCS7";
2352 const char *format = "PKCS8";
2353 HcfKeyPair *keyPair = nullptr;
2354 res = generator->generateKeyPair(generator, nullptr, &keyPair);
2355
2356 ASSERT_EQ(res, HCF_SUCCESS);
2357 ASSERT_NE(keyPair, nullptr);
2358
2359 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
2360 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
2361 ASSERT_EQ(res, HCF_SUCCESS);
2362 ASSERT_NE(pubKeyBlob.data, nullptr);
2363 ASSERT_NE(pubKeyBlob.len, 0);
2364
2365 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
2366 res = keyPair->priKey->getEncodedDer(keyPair->priKey, wrongFormat, &priKeyBlob);
2367 ASSERT_EQ(res, HCF_INVALID_PARAMS);
2368 ASSERT_EQ(priKeyBlob.data, nullptr);
2369 ASSERT_EQ(priKeyBlob.len, 0);
2370
2371 res = keyPair->priKey->getEncodedDer(nullptr, format, nullptr);
2372 ASSERT_EQ(res, HCF_INVALID_PARAMS);
2373 ASSERT_EQ(priKeyBlob.data, nullptr);
2374 ASSERT_EQ(priKeyBlob.len, 0);
2375
2376 res = keyPair->priKey->getEncodedDer(keyPair->priKey, format, &priKeyBlob);
2377 ASSERT_EQ(res, HCF_SUCCESS);
2378 ASSERT_NE(priKeyBlob.data, nullptr);
2379 ASSERT_NE(priKeyBlob.len, 0);
2380
2381 HcfKeyPair *outKeyPair = nullptr;
2382 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
2383 ASSERT_EQ(res, HCF_SUCCESS);
2384
2385 HcfFree(pubKeyBlob.data);
2386 HcfFree(priKeyBlob.data);
2387 HcfObjDestroy(outKeyPair);
2388 HcfObjDestroy(keyPair);
2389 HcfObjDestroy(generator);
2390
2391 EndRecordMallocNum();
2392 }
2393
2394 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest901, TestSize.Level0)
2395 {
2396 HcfAsyKeyGenerator *generator = nullptr;
2397 int32_t res = HcfAsyKeyGeneratorCreate("ECC_Secp256k1", &generator);
2398
2399 HcfKeyPair *keyPair = nullptr;
2400 res = generator->generateKeyPair(generator, nullptr, &keyPair);
2401 ASSERT_EQ(res, HCF_SUCCESS);
2402 ASSERT_NE(keyPair, nullptr);
2403
2404 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
2405 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
2406 ASSERT_EQ(res, HCF_SUCCESS);
2407
2408 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
2409 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
2410 ASSERT_EQ(res, HCF_SUCCESS);
2411
2412 HcfKeyPair *outKeyPair = nullptr;
2413 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
2414 ASSERT_EQ(res, HCF_SUCCESS);
2415 ASSERT_NE(outKeyPair, nullptr);
2416
2417 HcfBlob outPubKeyBlob = { .data = nullptr, .len = 0 };
2418 res = outKeyPair->pubKey->base.getEncoded(&(outKeyPair->pubKey->base), &outPubKeyBlob);
2419 ASSERT_EQ(res, HCF_SUCCESS);
2420 ASSERT_NE(outPubKeyBlob.data, nullptr);
2421 ASSERT_NE(outPubKeyBlob.len, 0);
2422
2423 HcfBlob outPriKeyBlob = { .data = nullptr, .len = 0 };
2424 res = outKeyPair->priKey->base.getEncoded(&(outKeyPair->priKey->base), &outPriKeyBlob);
2425 ASSERT_EQ(res, HCF_SUCCESS);
2426 ASSERT_NE(outPriKeyBlob.data, nullptr);
2427 ASSERT_NE(outPriKeyBlob.len, 0);
2428
2429 HcfFree(pubKeyBlob.data);
2430 HcfFree(priKeyBlob.data);
2431 HcfFree(outPubKeyBlob.data);
2432 HcfFree(outPriKeyBlob.data);
2433 HcfObjDestroy(outKeyPair);
2434 HcfObjDestroy(keyPair);
2435 HcfObjDestroy(generator);
2436 }
2437
2438 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest902, TestSize.Level0)
2439 {
2440 HcfAsyKeyGenParams params = {
2441 .algo = HCF_ALG_ECC,
2442 .bits = HCF_ALG_ECC_SECP256K1,
2443 .primes = HCF_OPENSSL_PRIMES_2,
2444 };
2445
2446 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
2447 int32_t res = HcfAsyKeyGeneratorSpiEccCreate(¶ms, &spiObj);
2448 ASSERT_EQ(res, HCF_SUCCESS);
2449 ASSERT_NE(spiObj, nullptr);
2450
2451 spiObj->base.destroy(&g_obj);
2452 HcfObjDestroy(spiObj);
2453 }
2454
2455 HWTEST_F(CryptoEccAsyKeyGeneratorTest, CryptoEccAsyKeyGeneratorTest903, TestSize.Level0)
2456 {
2457 HcfAsyKeyGenerator *generator = nullptr;
2458 int32_t res = HcfAsyKeyGeneratorCreate("ECC_secp256k1", &generator);
2459 ASSERT_NE(res, HCF_SUCCESS);
2460 ASSERT_EQ(generator, nullptr);
2461 }
2462 }
2463