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