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