1 /*
2  * Copyright (C) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *    http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 #include "securec.h"
18 
19 #include "alg_25519_common_param_spec.h"
20 #include "blob.h"
21 #include "params_parser.h"
22 #include "key_pair.h"
23 #include "object_base.h"
24 #include "signature.h"
25 #include "alg_25519_asy_key_generator_openssl.h"
26 #include "detailed_alg_25519_key_params.h"
27 #include "memory.h"
28 #include "memory_mock.h"
29 #include "openssl_adapter_mock.h"
30 
31 using namespace std;
32 using namespace testing::ext;
33 
34 namespace {
35 class CryptoEd25519AsyKeyGeneratorTest : public testing::Test {
36 public:
37     static void SetUpTestCase();
38     static void TearDownTestCase();
39     void SetUp();
40     void TearDown();
41 };
42 
TearDownTestCase()43 void CryptoEd25519AsyKeyGeneratorTest::TearDownTestCase() {}
SetUp()44 void CryptoEd25519AsyKeyGeneratorTest::SetUp() {}
TearDown()45 void CryptoEd25519AsyKeyGeneratorTest::TearDown() {}
46 static string g_ed25519AlgoName = "Ed25519";
47 static string g_pubkeyformatName = "X.509";
48 static string g_prikeyformatName = "PKCS#8";
49 
50 HcfBlob g_mockEd25519PriKeyBlob = {
51     .data = nullptr,
52     .len = 0
53 };
54 
55 HcfBlob g_mockEd25519PubKeyBlob = {
56     .data = nullptr,
57     .len = 0
58 };
59 
60 HcfBlob g_mockECC_BrainPool160r1PriKeyBlob = {
61     .data = nullptr,
62     .len = 0
63 };
64 
65 HcfBlob g_mockECC_BrainPool160r1PubKeyBlob = {
66     .data = nullptr,
67     .len = 0
68 };
69 
GetMockClass(void)70 static const char *GetMockClass(void)
71 {
72     return "ed25519generator";
73 }
74 HcfObjectBase g_obj = {
75     .getClass = GetMockClass,
76     .destroy = nullptr
77 };
78 
79 static const char *g_mockMessage = "hello world";
80 static HcfBlob g_mockInput = {
81     .data = (uint8_t *)g_mockMessage,
82     .len = 12
83 };
84 
Ed25519KeyBlob(HcfBlob * priblob,HcfBlob * pubblob)85 static HcfResult Ed25519KeyBlob(HcfBlob * priblob, HcfBlob *pubblob)
86 {
87     HcfAsyKeyGenerator *generator = nullptr;
88     HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
89     if (res != HCF_SUCCESS) {
90         return HCF_INVALID_PARAMS;
91     }
92 
93     HcfKeyPair *keyPair = nullptr;
94     res = generator->generateKeyPair(generator, nullptr, &keyPair);
95     if (res != HCF_SUCCESS) {
96         HcfObjDestroy(generator);
97         return res;
98     }
99     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &g_mockEd25519PriKeyBlob);
100     if (res != HCF_SUCCESS) {
101         HcfObjDestroy(generator);
102         HcfObjDestroy(keyPair);
103         return res;
104     }
105     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &g_mockEd25519PubKeyBlob);
106     if (res != HCF_SUCCESS) {
107         HcfObjDestroy(generator);
108         HcfObjDestroy(keyPair);
109         return res;
110     }
111     HcfObjDestroy(generator);
112     HcfObjDestroy(keyPair);
113     return HCF_SUCCESS;
114 }
115 
ECC_BrainPool160r1KeyBlob(HcfBlob * priblob,HcfBlob * pubblob)116 static HcfResult ECC_BrainPool160r1KeyBlob(HcfBlob * priblob, HcfBlob *pubblob)
117 {
118     HcfAsyKeyGenerator *generator = nullptr;
119     HcfResult res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator);
120     if (res != HCF_SUCCESS) {
121         return res;
122     }
123 
124     HcfKeyPair *keyPair = nullptr;
125     res = generator->generateKeyPair(generator, nullptr, &keyPair);
126     if (res != HCF_SUCCESS) {
127         HcfObjDestroy(generator);
128         return res;
129     }
130     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &g_mockECC_BrainPool160r1PriKeyBlob);
131     if (res != HCF_SUCCESS) {
132         HcfObjDestroy(generator);
133         HcfObjDestroy(keyPair);
134         return res;
135     }
136     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &g_mockECC_BrainPool160r1PubKeyBlob);
137     if (res != HCF_SUCCESS) {
138         HcfObjDestroy(generator);
139         HcfObjDestroy(keyPair);
140         return res;
141     }
142     HcfObjDestroy(generator);
143     HcfObjDestroy(keyPair);
144     return HCF_SUCCESS;
145 }
146 
SetUpTestCase()147 void CryptoEd25519AsyKeyGeneratorTest::SetUpTestCase()
148 {
149     HcfResult res = Ed25519KeyBlob(&g_mockEd25519PriKeyBlob, &g_mockEd25519PubKeyBlob);
150     ASSERT_EQ(res, HCF_SUCCESS);
151     res = ECC_BrainPool160r1KeyBlob(&g_mockECC_BrainPool160r1PriKeyBlob, &g_mockECC_BrainPool160r1PubKeyBlob);
152     ASSERT_EQ(res, HCF_SUCCESS);
153 }
154 
155 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest001, TestSize.Level0)
156 {
157     HcfAsyKeyGenerator *generator = nullptr;
158     HcfResult res = TestHcfAsyKeyGeneratorCreate(g_ed25519AlgoName.c_str(), &generator);
159     ASSERT_EQ(res, HCF_SUCCESS);
160 
161     HcfObjDestroy(generator);
162 }
163 
164 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest002, TestSize.Level0)
165 {
166     HcfAsyKeyGenerator *generator = nullptr;
167     HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
168 
169     const char *className = generator->base.getClass();
170 
171     ASSERT_EQ(res, HCF_SUCCESS);
172     ASSERT_NE(className, nullptr);
173 
174     HcfObjDestroy(generator);
175 }
176 
177 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest003, TestSize.Level0)
178 {
179     HcfAsyKeyGenerator *generator = nullptr;
180     HcfResult res = TestHcfAsyKeyGeneratorCreate(g_ed25519AlgoName.c_str(), &generator);
181     ASSERT_EQ(res, HCF_SUCCESS);
182 
183     generator->base.destroy((HcfObjectBase *)generator);
184 }
185 
186 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest004, TestSize.Level0)
187 {
188     HcfAsyKeyGenerator *generator = nullptr;
189     HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
190 
191     const char *algoName = generator->getAlgoName(generator);
192 
193     ASSERT_EQ(res, HCF_SUCCESS);
194     ASSERT_EQ(algoName, g_ed25519AlgoName);
195 
196     HcfObjDestroy(generator);
197 }
198 
199 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest005, TestSize.Level0)
200 {
201     HcfAsyKeyGenerator *generator = nullptr;
202     HcfKeyPair *keyPair = nullptr;
203     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
204     ASSERT_EQ(res, HCF_SUCCESS);
205 
206     HcfObjDestroy(keyPair);
207     HcfObjDestroy(generator);
208 }
209 
210 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest006, TestSize.Level0)
211 {
212     HcfAsyKeyGenerator *generator = nullptr;
213     HcfKeyPair *keyPair = nullptr;
214 
215     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
216     ASSERT_EQ(res, HCF_SUCCESS);
217 
218     const char *className = keyPair->base.getClass();
219     ASSERT_NE(className, nullptr);
220 
221     HcfObjDestroy(keyPair);
222     HcfObjDestroy(generator);
223 }
224 
225 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest007, TestSize.Level0)
226 {
227     HcfAsyKeyGenerator *generator = nullptr;
228     HcfKeyPair *keyPair = nullptr;
229     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
230     ASSERT_EQ(res, HCF_SUCCESS);
231 
232     keyPair->base.destroy(&(keyPair->base));
233 
234     HcfObjDestroy(generator);
235 }
236 
237 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest008, TestSize.Level0)
238 {
239     HcfAsyKeyGenerator *generator = nullptr;
240     HcfKeyPair *keyPair = nullptr;
241 
242     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
243     ASSERT_EQ(res, HCF_SUCCESS);
244 
245     const char *className = keyPair->pubKey->base.base.getClass();
246     ASSERT_NE(className, nullptr);
247 
248     HcfObjDestroy(keyPair);
249     HcfObjDestroy(generator);
250 }
251 
252 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest009, TestSize.Level0)
253 {
254     HcfAsyKeyGenerator *generator = nullptr;
255     HcfKeyPair *keyPair = nullptr;
256     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
257     ASSERT_EQ(res, HCF_SUCCESS);
258 
259     keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
260     keyPair->pubKey = nullptr;
261 
262     HcfObjDestroy(keyPair);
263     HcfObjDestroy(generator);
264 }
265 
266 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest010, TestSize.Level0)
267 {
268     HcfAsyKeyGenerator *generator = nullptr;
269     HcfKeyPair *keyPair = nullptr;
270 
271     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
272     ASSERT_EQ(res, HCF_SUCCESS);
273 
274     const char *algorithmName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
275     ASSERT_EQ(algorithmName, g_ed25519AlgoName);
276 
277     HcfBlob blob = { .data = nullptr, .len = 0 };
278     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
279     ASSERT_EQ(res, HCF_SUCCESS);
280     ASSERT_NE(blob.data, nullptr);
281     ASSERT_NE(blob.len, 0);
282     HcfFree(blob.data);
283     const char *formatName = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
284     ASSERT_EQ(formatName, g_pubkeyformatName);
285 
286     HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
287     res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ED25519_PK_BN, &returnBigInteger);
288     ASSERT_EQ(res, HCF_SUCCESS);
289     ASSERT_NE(returnBigInteger.data, nullptr);
290     ASSERT_NE(returnBigInteger.len, 0);
291     HcfFree(returnBigInteger.data);
292     HcfObjDestroy(keyPair);
293     HcfObjDestroy(generator);
294 }
295 
296 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest011, TestSize.Level0)
297 {
298     HcfAsyKeyGenerator *generator = nullptr;
299     HcfKeyPair *keyPair = nullptr;
300     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
301     ASSERT_EQ(res, HCF_SUCCESS);
302 
303     const char *className = keyPair->priKey->base.base.getClass();
304     ASSERT_NE(className, nullptr);
305 
306     HcfObjDestroy(keyPair);
307     HcfObjDestroy(generator);
308 }
309 
310 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest012, TestSize.Level0)
311 {
312     HcfAsyKeyGenerator *generator = nullptr;
313     HcfKeyPair *keyPair = nullptr;
314 
315     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
316     ASSERT_EQ(res, HCF_SUCCESS);
317 
318     keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
319     keyPair->priKey = nullptr;
320     HcfObjDestroy(keyPair);
321     HcfObjDestroy(generator);
322 }
323 
324 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest013, TestSize.Level0)
325 {
326     HcfAsyKeyGenerator *generator = nullptr;
327     HcfKeyPair *keyPair = nullptr;
328     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
329     ASSERT_EQ(res, HCF_SUCCESS);
330 
331     const char *algorithmName = keyPair->priKey->base.getAlgorithm(&(keyPair->priKey->base));
332     ASSERT_EQ(algorithmName, g_ed25519AlgoName);
333 
334     HcfBlob blob = { .data = nullptr, .len = 0 };
335     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
336     ASSERT_EQ(res, HCF_SUCCESS);
337     ASSERT_NE(blob.data, nullptr);
338     ASSERT_NE(blob.len, 0);
339     HcfFree(blob.data);
340     const char *formatName = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
341     ASSERT_EQ(formatName, g_prikeyformatName);
342 
343     HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
344     res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ED25519_SK_BN, &returnBigInteger);
345     ASSERT_EQ(res, HCF_SUCCESS);
346     ASSERT_NE(returnBigInteger.data, nullptr);
347     ASSERT_NE(returnBigInteger.len, 0);
348     HcfFree(returnBigInteger.data);
349     HcfObjDestroy(keyPair);
350     HcfObjDestroy(generator);
351 }
352 
353 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest014, TestSize.Level0)
354 {
355     HcfAsyKeyGenerator *generator = nullptr;
356     HcfKeyPair *keyPair = nullptr;
357 
358     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
359     ASSERT_EQ(res, HCF_SUCCESS);
360 
361     keyPair->priKey->clearMem(keyPair->priKey);
362     HcfBlob blob = { .data = nullptr, .len = 0 };
363     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
364     ASSERT_EQ(res, HCF_INVALID_PARAMS);
365     ASSERT_EQ(blob.data, nullptr);
366     ASSERT_EQ(blob.len, 0);
367     HcfFree(blob.data);
368     HcfObjDestroy(keyPair);
369     HcfObjDestroy(generator);
370 }
371 
372 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest015, TestSize.Level0)
373 {
374     HcfAsyKeyGenerator *generator = nullptr;
375     HcfKeyPair *keyPair = nullptr;
376     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
377         &g_mockEd25519PriKeyBlob, &keyPair);
378     ASSERT_EQ(res, HCF_SUCCESS);
379 
380     res = TestGenerateConvertKey(generator, nullptr, &g_mockEd25519PriKeyBlob, &keyPair);
381     ASSERT_EQ(res, HCF_SUCCESS);
382 
383     res = TestGenerateConvertKey(generator, &g_mockEd25519PubKeyBlob, nullptr, &keyPair);
384     ASSERT_EQ(res, HCF_SUCCESS);
385 
386     HcfObjDestroy(keyPair);
387     HcfObjDestroy(generator);
388 }
389 
390 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest016, TestSize.Level0)
391 {
392     HcfAsyKeyGenerator *generator = nullptr;
393     HcfKeyPair *keyPair = nullptr;
394 
395     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
396         &g_mockEd25519PriKeyBlob, &keyPair);
397     ASSERT_EQ(res, HCF_SUCCESS);
398 
399     const char *className = keyPair->base.getClass();
400     ASSERT_NE(className, nullptr);
401 
402     HcfObjDestroy(keyPair);
403     HcfObjDestroy(generator);
404 }
405 
406 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest017, TestSize.Level0)
407 {
408     HcfAsyKeyGenerator *generator = nullptr;
409     HcfKeyPair *keyPair = nullptr;
410     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
411         &g_mockEd25519PriKeyBlob, &keyPair);
412     ASSERT_EQ(res, HCF_SUCCESS);
413 
414     keyPair->base.destroy(&(keyPair->base));
415 
416     HcfObjDestroy(generator);
417 }
418 
419 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest018, TestSize.Level0)
420 {
421     HcfAsyKeyGenerator *generator = nullptr;
422     HcfKeyPair *keyPair = nullptr;
423 
424     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
425         &g_mockEd25519PriKeyBlob, &keyPair);
426     ASSERT_EQ(res, HCF_SUCCESS);
427 
428     const char *className = keyPair->pubKey->base.base.getClass();
429     ASSERT_NE(className, nullptr);
430 
431     HcfObjDestroy(keyPair);
432     HcfObjDestroy(generator);
433 }
434 
435 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest019, TestSize.Level0)
436 {
437     HcfAsyKeyGenerator *generator = nullptr;
438     HcfKeyPair *keyPair = nullptr;
439     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
440         &g_mockEd25519PriKeyBlob, &keyPair);
441     ASSERT_EQ(res, HCF_SUCCESS);
442 
443     keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
444     keyPair->pubKey = nullptr;
445 
446     HcfObjDestroy(keyPair);
447     HcfObjDestroy(generator);
448 }
449 
450 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest020, TestSize.Level0)
451 {
452     HcfAsyKeyGenerator *generator = nullptr;
453     HcfKeyPair *keyPair = nullptr;
454 
455     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
456         &g_mockEd25519PriKeyBlob, &keyPair);
457     ASSERT_EQ(res, HCF_SUCCESS);
458 
459     const char *algorithmName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
460     ASSERT_EQ(algorithmName, g_ed25519AlgoName);
461 
462     HcfBlob blob = { .data = nullptr, .len = 0 };
463     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
464     ASSERT_EQ(res, HCF_SUCCESS);
465     ASSERT_NE(blob.data, nullptr);
466     ASSERT_NE(blob.len, 0);
467     HcfFree(blob.data);
468     const char *formatName = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
469     ASSERT_EQ(formatName, g_pubkeyformatName);
470 
471     HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
472     res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ED25519_PK_BN, &returnBigInteger);
473     ASSERT_EQ(res, HCF_SUCCESS);
474     ASSERT_NE(returnBigInteger.data, nullptr);
475     ASSERT_NE(returnBigInteger.len, 0);
476     HcfFree(returnBigInteger.data);
477     HcfObjDestroy(keyPair);
478     HcfObjDestroy(generator);
479 }
480 
481 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest021, TestSize.Level0)
482 {
483     HcfAsyKeyGenerator *generator = nullptr;
484     HcfKeyPair *keyPair = nullptr;
485     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
486         &g_mockEd25519PriKeyBlob, &keyPair);
487     ASSERT_EQ(res, HCF_SUCCESS);
488 
489     const char *className = keyPair->priKey->base.base.getClass();
490     ASSERT_NE(className, nullptr);
491 
492     HcfObjDestroy(keyPair);
493     HcfObjDestroy(generator);
494 }
495 
496 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest022, TestSize.Level0)
497 {
498     HcfAsyKeyGenerator *generator = nullptr;
499     HcfKeyPair *keyPair = nullptr;
500 
501     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
502         &g_mockEd25519PriKeyBlob, &keyPair);
503     ASSERT_EQ(res, HCF_SUCCESS);
504 
505     keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
506     keyPair->priKey = nullptr;
507     HcfObjDestroy(keyPair);
508     HcfObjDestroy(generator);
509 }
510 
511 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest023, TestSize.Level0)
512 {
513     HcfAsyKeyGenerator *generator = nullptr;
514     HcfKeyPair *keyPair = nullptr;
515     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
516         &g_mockEd25519PriKeyBlob, &keyPair);
517     ASSERT_EQ(res, HCF_SUCCESS);
518 
519     const char *algorithmName = keyPair->priKey->base.getAlgorithm(&(keyPair->priKey->base));
520     ASSERT_EQ(algorithmName, g_ed25519AlgoName);
521 
522     HcfBlob blob = { .data = nullptr, .len = 0 };
523     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
524     ASSERT_EQ(res, HCF_SUCCESS);
525     ASSERT_NE(blob.data, nullptr);
526     ASSERT_NE(blob.len, 0);
527     HcfFree(blob.data);
528     const char *formatName = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
529     ASSERT_EQ(formatName, g_prikeyformatName);
530 
531     HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
532     res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ED25519_SK_BN, &returnBigInteger);
533     ASSERT_EQ(res, HCF_SUCCESS);
534     ASSERT_NE(returnBigInteger.data, nullptr);
535     ASSERT_NE(returnBigInteger.len, 0);
536     HcfFree(returnBigInteger.data);
537     HcfObjDestroy(keyPair);
538     HcfObjDestroy(generator);
539 }
540 
541 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest024, TestSize.Level0)
542 {
543     HcfAsyKeyGenerator *generator = nullptr;
544     HcfKeyPair *keyPair = nullptr;
545 
546     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
547         &g_mockEd25519PriKeyBlob, &keyPair);
548     ASSERT_EQ(res, HCF_SUCCESS);
549 
550     keyPair->priKey->clearMem(keyPair->priKey);
551     HcfBlob blob = { .data = nullptr, .len = 0 };
552     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
553     ASSERT_EQ(res, HCF_INVALID_PARAMS);
554     ASSERT_EQ(blob.data, nullptr);
555     ASSERT_EQ(blob.len, 0);
556     HcfFree(blob.data);
557     HcfObjDestroy(keyPair);
558     HcfObjDestroy(generator);
559 }
560 
MemoryMallocTestFunc(uint32_t mallocCount)561 static void MemoryMallocTestFunc(uint32_t mallocCount)
562 {
563     for (uint32_t i = 0; i < mallocCount; i++) {
564         ResetRecordMallocNum();
565         SetMockMallocIndex(i);
566         HcfAsyKeyGenerator *tmpGenerator = nullptr;
567         HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &tmpGenerator);
568         if (res != HCF_SUCCESS) {
569             continue;
570         }
571         HcfKeyPair *tmpKeyPair = nullptr;
572         res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
573         if (res != HCF_SUCCESS) {
574             HcfObjDestroy(tmpGenerator);
575             continue;
576         }
577         HcfBlob tmpPubKeyBlob = {
578             .data = nullptr,
579             .len = 0
580         };
581         res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
582         if (res != HCF_SUCCESS) {
583             HcfObjDestroy(tmpKeyPair);
584             HcfObjDestroy(tmpGenerator);
585             continue;
586         }
587         HcfBlob tmpPriKeyBlob = {
588             .data = nullptr,
589             .len = 0
590         };
591         res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
592         if (res != HCF_SUCCESS) {
593             HcfFree(tmpPubKeyBlob.data);
594             HcfObjDestroy(tmpKeyPair);
595             HcfObjDestroy(tmpGenerator);
596             continue;
597         }
598         HcfKeyPair *tmpOutKeyPair = nullptr;
599         res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
600         HcfFree(tmpPubKeyBlob.data);
601         HcfFree(tmpPriKeyBlob.data);
602         HcfObjDestroy(tmpKeyPair);
603         HcfObjDestroy(tmpGenerator);
604         if (res == HCF_SUCCESS) {
605             HcfObjDestroy(tmpOutKeyPair);
606         }
607     }
608 }
609 
610 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest025, TestSize.Level0)
611 {
612     StartRecordMallocNum();
613     HcfAsyKeyGenerator *generator = nullptr;
614     HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
615 
616     HcfKeyPair *keyPair = nullptr;
617     res = generator->generateKeyPair(generator, nullptr, &keyPair);
618 
619     ASSERT_EQ(res, HCF_SUCCESS);
620     ASSERT_NE(keyPair, nullptr);
621 
622     HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
623     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
624 
625     ASSERT_EQ(res, HCF_SUCCESS);
626     ASSERT_NE(pubKeyBlob.data, nullptr);
627     ASSERT_NE(pubKeyBlob.len, 0);
628 
629     HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
630     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
631 
632     ASSERT_EQ(res, HCF_SUCCESS);
633     ASSERT_NE(priKeyBlob.data, nullptr);
634     ASSERT_NE(priKeyBlob.len, 0);
635 
636     HcfKeyPair *outKeyPair = nullptr;
637     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
638 
639     HcfFree(pubKeyBlob.data);
640     HcfFree(priKeyBlob.data);
641     HcfObjDestroy(outKeyPair);
642     HcfObjDestroy(keyPair);
643     HcfObjDestroy(generator);
644 
645     uint32_t mallocCount = GetMallocNum();
646     MemoryMallocTestFunc(mallocCount);
647 
648     EndRecordMallocNum();
649 }
650 
OpensslMockTestFunc(uint32_t mallocCount)651 static void OpensslMockTestFunc(uint32_t mallocCount)
652 {
653     for (uint32_t i = 0; i < mallocCount; i++) {
654         ResetOpensslCallNum();
655         SetOpensslCallMockIndex(i);
656         HcfAsyKeyGenerator *tmpGenerator = nullptr;
657         HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &tmpGenerator);
658         if (res != HCF_SUCCESS) {
659             continue;
660         }
661         HcfKeyPair *tmpKeyPair = nullptr;
662         res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
663         if (res != HCF_SUCCESS) {
664             HcfObjDestroy(tmpGenerator);
665             continue;
666         }
667         HcfBlob tmpPubKeyBlob = {
668             .data = nullptr,
669             .len = 0
670         };
671         res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
672         if (res != HCF_SUCCESS) {
673             HcfObjDestroy(tmpKeyPair);
674             HcfObjDestroy(tmpGenerator);
675             continue;
676         }
677         HcfBlob tmpPriKeyBlob = {
678             .data = nullptr,
679             .len = 0
680         };
681         res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
682         if (res != HCF_SUCCESS) {
683             HcfFree(tmpPubKeyBlob.data);
684             HcfObjDestroy(tmpKeyPair);
685             HcfObjDestroy(tmpGenerator);
686             continue;
687         }
688         HcfKeyPair *tmpOutKeyPair = nullptr;
689         res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
690         HcfFree(tmpPubKeyBlob.data);
691         HcfFree(tmpPriKeyBlob.data);
692         HcfObjDestroy(tmpKeyPair);
693         HcfObjDestroy(tmpGenerator);
694         if (res == HCF_SUCCESS) {
695             HcfObjDestroy(tmpOutKeyPair);
696         }
697     }
698 }
699 
700 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest026, TestSize.Level0)
701 {
702     StartRecordOpensslCallNum();
703     HcfAsyKeyGenerator *generator = nullptr;
704     HcfKeyPair *keyPair = nullptr;
705     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
706     ASSERT_EQ(res, HCF_SUCCESS);
707 
708     HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
709     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
710 
711     ASSERT_EQ(res, HCF_SUCCESS);
712     ASSERT_NE(pubKeyBlob.data, nullptr);
713     ASSERT_NE(pubKeyBlob.len, 0);
714 
715     HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
716     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
717 
718     ASSERT_EQ(res, HCF_SUCCESS);
719     ASSERT_NE(priKeyBlob.data, nullptr);
720     ASSERT_NE(priKeyBlob.len, 0);
721 
722     HcfKeyPair *outKeyPair = nullptr;
723     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
724 
725     HcfFree(pubKeyBlob.data);
726     HcfFree(priKeyBlob.data);
727     HcfObjDestroy(outKeyPair);
728     HcfObjDestroy(keyPair);
729     HcfObjDestroy(generator);
730 
731     uint32_t mallocCount = GetOpensslCallNum();
732     OpensslMockTestFunc(mallocCount);
733 
734     EndRecordOpensslCallNum();
735 }
736 
737 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest0027, TestSize.Level0)
738 {
739     HcfAsyKeyGenerator *generator = nullptr;
740 
741     HcfResult res = HcfAsyKeyGeneratorCreate("ED25519", &generator);
742 
743     ASSERT_EQ(res, HCF_INVALID_PARAMS);
744     ASSERT_EQ(generator, nullptr);
745 
746     res = HcfAsyKeyGeneratorCreate(nullptr, &generator);
747 
748     ASSERT_EQ(res, HCF_INVALID_PARAMS);
749     ASSERT_EQ(generator, nullptr);
750 
751     HcfObjDestroy(generator);
752 }
753 
754 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest028, TestSize.Level0)
755 {
756     HcfAsyKeyGenerator *generator = nullptr;
757     HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
758 
759     ASSERT_EQ(res, HCF_SUCCESS);
760     ASSERT_NE(generator, nullptr);
761 
762     const char *algoName = generator->getAlgoName(nullptr);
763     ASSERT_EQ(algoName, nullptr);
764 
765     const char *algoName1 = generator->getAlgoName((HcfAsyKeyGenerator *)&g_obj);
766     ASSERT_EQ(algoName1, nullptr);
767 
768     HcfObjDestroy(generator);
769 }
770 
771 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest029, TestSize.Level0)
772 {
773     HcfAsyKeyGenerator *generator = nullptr;
774     HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
775 
776     ASSERT_EQ(res, HCF_SUCCESS);
777     ASSERT_NE(generator, nullptr);
778 
779     generator->base.destroy(nullptr);
780 
781     HcfObjDestroy(generator);
782 }
783 
784 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest030, TestSize.Level0)
785 {
786     HcfAsyKeyGenerator *generator = nullptr;
787     HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
788     ASSERT_EQ(res, HCF_SUCCESS);
789     ASSERT_NE(generator, nullptr);
790 
791     generator->base.destroy(&g_obj);
792 
793     HcfObjDestroy(generator);
794 }
795 
796 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest031, TestSize.Level0)
797 {
798     HcfAsyKeyGenerator *generator = nullptr;
799     HcfKeyPair *keyPair = nullptr;
800     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
801     ASSERT_EQ(res, HCF_SUCCESS);
802 
803     HcfKeyPair *failKeyPair = nullptr;
804     res = generator->generateKeyPair((HcfAsyKeyGenerator *)&g_obj, nullptr, &failKeyPair);
805     ASSERT_EQ(res, HCF_INVALID_PARAMS);
806     ASSERT_EQ(failKeyPair, nullptr);
807 
808     res = generator->generateKeyPair(generator, nullptr, nullptr);
809     ASSERT_EQ(res, HCF_INVALID_PARAMS);
810 
811     HcfObjDestroy(keyPair);
812     HcfObjDestroy(failKeyPair);
813     HcfObjDestroy(generator);
814 }
815 
816 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest032, TestSize.Level0)
817 {
818     HcfAsyKeyGenerator *generator = nullptr;
819     HcfKeyPair *keyPair = nullptr;
820     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
821     ASSERT_EQ(res, HCF_SUCCESS);
822 
823     const char *algorithmName = keyPair->pubKey->base.getAlgorithm(nullptr);
824     ASSERT_EQ(algorithmName, nullptr);
825 
826     const char *algorithmName1 = keyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj);
827     ASSERT_EQ(algorithmName1, nullptr);
828 
829     HcfObjDestroy(keyPair);
830     HcfObjDestroy(generator);
831 }
832 
833 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest033, TestSize.Level0)
834 {
835     HcfAsyKeyGenerator *generator = nullptr;
836     HcfKeyPair *keyPair = nullptr;
837     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
838     ASSERT_EQ(res, HCF_SUCCESS);
839 
840     HcfBlob blob = { .data = nullptr, .len = 0 };
841     res = keyPair->pubKey->base.getEncoded(nullptr, &blob);
842     ASSERT_EQ(res, HCF_INVALID_PARAMS);
843     ASSERT_EQ(blob.data, nullptr);
844     ASSERT_EQ(blob.len, 0);
845 
846     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), nullptr);
847     ASSERT_EQ(res, HCF_INVALID_PARAMS);
848 
849     res = keyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob);
850     ASSERT_EQ(res, HCF_INVALID_PARAMS);
851     ASSERT_EQ(blob.data, nullptr);
852     ASSERT_EQ(blob.len, 0);
853 
854     HcfFree(blob.data);
855     HcfObjDestroy(keyPair);
856     HcfObjDestroy(generator);
857 }
858 
859 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest034, TestSize.Level0)
860 {
861     HcfAsyKeyGenerator *generator = nullptr;
862     HcfKeyPair *keyPair = nullptr;
863     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
864         &g_mockEd25519PriKeyBlob, &keyPair);
865     ASSERT_EQ(res, HCF_SUCCESS);
866 
867     const char *formatName = keyPair->pubKey->base.getFormat(nullptr);
868     ASSERT_EQ(formatName, nullptr);
869 
870     const char *formatName1 = keyPair->pubKey->base.getFormat((HcfKey *)&g_obj);
871     ASSERT_EQ(formatName1, nullptr);
872 
873     HcfObjDestroy(keyPair);
874     HcfObjDestroy(generator);
875 }
876 
877 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest035, TestSize.Level0)
878 {
879     HcfAsyKeyGenerator *generator = nullptr;
880     HcfKeyPair *keyPair = nullptr;
881     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
882     ASSERT_EQ(res, HCF_SUCCESS);
883 
884     HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
885     res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ED25519_SK_BN, nullptr);
886     ASSERT_EQ(res, HCF_INVALID_PARAMS);
887     ASSERT_EQ(returnBigInteger.data, nullptr);
888     ASSERT_EQ(returnBigInteger.len, 0);
889 
890     res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, DSA_P_BN, &returnBigInteger);
891     ASSERT_EQ(res, HCF_INVALID_PARAMS);
892     ASSERT_EQ(returnBigInteger.data, nullptr);
893     ASSERT_EQ(returnBigInteger.len, 0);
894 
895     res = keyPair->pubKey->getAsyKeySpecInt(keyPair->pubKey, ED25519_PK_BN, nullptr);
896     ASSERT_EQ(res, HCF_NOT_SUPPORT);
897 
898     res = keyPair->pubKey->getAsyKeySpecString(keyPair->pubKey, ED25519_PK_BN, nullptr);
899     ASSERT_EQ(res, HCF_NOT_SUPPORT);
900 
901     HcfFree(returnBigInteger.data);
902     HcfObjDestroy(keyPair);
903     HcfObjDestroy(generator);
904 }
905 
906 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest036, TestSize.Level0)
907 {
908     HcfAsyKeyGenerator *generator = nullptr;
909     HcfKeyPair *keyPair = nullptr;
910     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
911     ASSERT_EQ(res, HCF_SUCCESS);
912 
913     const char *algorithmName = keyPair->priKey->base.getAlgorithm(nullptr);
914     ASSERT_EQ(algorithmName, nullptr);
915 
916     const char *algorithmName1 = keyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj);
917     ASSERT_EQ(algorithmName1, nullptr);
918 
919     HcfObjDestroy(keyPair);
920     HcfObjDestroy(generator);
921 }
922 
923 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest037, TestSize.Level0)
924 {
925     HcfAsyKeyGenerator *generator = nullptr;
926     HcfKeyPair *keyPair = nullptr;
927 
928     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
929     ASSERT_EQ(res, HCF_SUCCESS);
930 
931     HcfBlob blob = { .data = nullptr, .len = 0 };
932     res = keyPair->priKey->base.getEncoded(nullptr, &blob);
933     ASSERT_EQ(res, HCF_INVALID_PARAMS);
934     ASSERT_EQ(blob.data, nullptr);
935     ASSERT_EQ(blob.len, 0);
936 
937     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), nullptr);
938     ASSERT_EQ(res, HCF_INVALID_PARAMS);
939 
940     res = keyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob);
941     ASSERT_EQ(res, HCF_INVALID_PARAMS);
942     ASSERT_EQ(blob.data, nullptr);
943     ASSERT_EQ(blob.len, 0);
944 
945     HcfFree(blob.data);
946     HcfObjDestroy(keyPair);
947     HcfObjDestroy(generator);
948 }
949 
950 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest038, TestSize.Level0)
951 {
952     HcfAsyKeyGenerator *generator = nullptr;
953     HcfKeyPair *keyPair = nullptr;
954 
955     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
956         &g_mockEd25519PriKeyBlob, &keyPair);
957     ASSERT_EQ(res, HCF_SUCCESS);
958 
959     const char *formatName = formatName = keyPair->priKey->base.getFormat(nullptr);
960     ASSERT_EQ(formatName, nullptr);
961 
962     const char *formatName1 = keyPair->priKey->base.getFormat((HcfKey *)&g_obj);
963     ASSERT_EQ(formatName1, nullptr);
964 
965     HcfObjDestroy(keyPair);
966     HcfObjDestroy(generator);
967 }
968 
969 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest039, TestSize.Level0)
970 {
971     HcfAsyKeyGenerator *generator = nullptr;
972     HcfKeyPair *keyPair = nullptr;
973 
974     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
975     ASSERT_EQ(res, HCF_SUCCESS);
976 
977     res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ED25519_PK_BN, nullptr);
978     ASSERT_EQ(res, HCF_INVALID_PARAMS);
979     HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
980     res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, DSA_P_BN, &returnBigInteger);
981     ASSERT_EQ(res, HCF_INVALID_PARAMS);
982     ASSERT_EQ(returnBigInteger.data, nullptr);
983     ASSERT_EQ(returnBigInteger.len, 0);
984     HcfFree(returnBigInteger.data);
985     res = keyPair->priKey->getAsyKeySpecInt(keyPair->priKey, ED25519_SK_BN, nullptr);
986     ASSERT_EQ(res, HCF_NOT_SUPPORT);
987 
988     res = keyPair->priKey->getAsyKeySpecString(keyPair->priKey, ED25519_SK_BN, nullptr);
989     ASSERT_EQ(res, HCF_NOT_SUPPORT);
990 
991     HcfObjDestroy(keyPair);
992     HcfObjDestroy(generator);
993 }
994 
995 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest040, TestSize.Level0)
996 {
997     HcfAsyKeyGenerator *generator = nullptr;
998     HcfKeyPair *keyPair = nullptr;
999     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1000         &g_mockEd25519PriKeyBlob, &keyPair);
1001     ASSERT_EQ(res, HCF_SUCCESS);
1002 
1003     res = generator->convertKey(generator, nullptr, &g_mockEd25519PubKeyBlob, &g_mockEd25519PriKeyBlob, nullptr);
1004     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1005 
1006     HcfKeyPair *failKeyPair = nullptr;
1007     res = generator->convertKey((HcfAsyKeyGenerator *)&g_obj, nullptr, &g_mockEd25519PubKeyBlob,
1008         &g_mockEd25519PriKeyBlob, &failKeyPair);
1009     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1010     ASSERT_EQ(failKeyPair, nullptr);
1011 
1012     res = generator->convertKey(generator, nullptr, nullptr, nullptr, &failKeyPair);
1013     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1014     ASSERT_EQ(failKeyPair, nullptr);
1015 
1016     res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob,
1017         &g_mockECC_BrainPool160r1PriKeyBlob, &failKeyPair);
1018     ASSERT_EQ(res, HCF_ERR_CRYPTO_OPERATION);
1019     ASSERT_EQ(failKeyPair, nullptr);
1020 
1021     HcfObjDestroy(keyPair);
1022     HcfObjDestroy(failKeyPair);
1023     HcfObjDestroy(generator);
1024 }
1025 
1026 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest041, TestSize.Level0)
1027 {
1028     HcfAsyKeyGenerator *generator = nullptr;
1029     HcfKeyPair *keyPair = nullptr;
1030 
1031     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1032         &g_mockEd25519PriKeyBlob, &keyPair);
1033     ASSERT_EQ(res, HCF_SUCCESS);
1034 
1035     const char *algorithmName = keyPair->pubKey->base.getAlgorithm(nullptr);
1036     ASSERT_EQ(algorithmName, nullptr);
1037 
1038     const char *algorithmName1 = keyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj);
1039     ASSERT_EQ(algorithmName1, nullptr);
1040 
1041     HcfObjDestroy(keyPair);
1042     HcfObjDestroy(generator);
1043 }
1044 
1045 
1046 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest042, TestSize.Level0)
1047 {
1048     HcfAsyKeyGenerator *generator = nullptr;
1049     HcfKeyPair *keyPair = nullptr;
1050     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1051         &g_mockEd25519PriKeyBlob, &keyPair);
1052     ASSERT_EQ(res, HCF_SUCCESS);
1053 
1054     HcfBlob blob = { .data = nullptr, .len = 0 };
1055     res = keyPair->pubKey->base.getEncoded(nullptr, &blob);
1056     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1057     ASSERT_EQ(blob.data, nullptr);
1058     ASSERT_EQ(blob.len, 0);
1059 
1060     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), nullptr);
1061     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1062 
1063     res = keyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob);
1064     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1065     ASSERT_EQ(blob.data, nullptr);
1066     ASSERT_EQ(blob.len, 0);
1067     HcfFree(blob.data);
1068     HcfObjDestroy(keyPair);
1069     HcfObjDestroy(generator);
1070 }
1071 
1072 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest043, TestSize.Level0)
1073 {
1074     HcfAsyKeyGenerator *generator = nullptr;
1075     HcfKeyPair *keyPair = nullptr;
1076 
1077     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1078         &g_mockEd25519PriKeyBlob, &keyPair);
1079     ASSERT_EQ(res, HCF_SUCCESS);
1080 
1081     const char *formatName = formatName = keyPair->pubKey->base.getFormat(nullptr);
1082     ASSERT_EQ(formatName, nullptr);
1083 
1084     const char *formatName1 = keyPair->pubKey->base.getFormat((HcfKey *)&g_obj);
1085     ASSERT_EQ(formatName1, nullptr);
1086 
1087     HcfObjDestroy(keyPair);
1088     HcfObjDestroy(generator);
1089 }
1090 
1091 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest044, TestSize.Level0)
1092 {
1093     HcfAsyKeyGenerator *generator = nullptr;
1094     HcfKeyPair *keyPair = nullptr;
1095     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1096         &g_mockEd25519PriKeyBlob, &keyPair);
1097     ASSERT_EQ(res, HCF_SUCCESS);
1098 
1099     const char *algorithmName = keyPair->priKey->base.getAlgorithm(nullptr);
1100     ASSERT_EQ(algorithmName, nullptr);
1101 
1102     const char *algorithmName1 = keyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj);
1103     ASSERT_EQ(algorithmName1, nullptr);
1104 
1105     HcfObjDestroy(keyPair);
1106     HcfObjDestroy(generator);
1107 }
1108 
1109 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest045, TestSize.Level0)
1110 {
1111     HcfAsyKeyGenerator *generator = nullptr;
1112     HcfKeyPair *keyPair = nullptr;
1113 
1114     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1115         &g_mockEd25519PriKeyBlob, &keyPair);
1116     ASSERT_EQ(res, HCF_SUCCESS);
1117 
1118     HcfBlob blob = { .data = nullptr, .len = 0 };
1119     res = keyPair->priKey->base.getEncoded(nullptr, &blob);
1120     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1121     ASSERT_EQ(blob.data, nullptr);
1122     ASSERT_EQ(blob.len, 0);
1123 
1124     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), nullptr);
1125     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1126 
1127     res = keyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob);
1128     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1129     ASSERT_EQ(blob.data, nullptr);
1130     ASSERT_EQ(blob.len, 0);
1131 
1132     HcfFree(blob.data);
1133     HcfObjDestroy(keyPair);
1134     HcfObjDestroy(generator);
1135 }
1136 
1137 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest046, TestSize.Level0)
1138 {
1139     HcfAsyKeyGenerator *generator = nullptr;
1140     HcfKeyPair *keyPair = nullptr;
1141     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1142         &g_mockEd25519PriKeyBlob, &keyPair);
1143     ASSERT_EQ(res, HCF_SUCCESS);
1144 
1145     const char *formatName = formatName = keyPair->priKey->base.getFormat(nullptr);
1146     ASSERT_EQ(formatName, nullptr);
1147 
1148     const char *formatName1 = keyPair->priKey->base.getFormat((HcfKey *)&g_obj);
1149     ASSERT_EQ(formatName1, nullptr);
1150 
1151     HcfObjDestroy(keyPair);
1152     HcfObjDestroy(generator);
1153 }
1154 
1155 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest047, TestSize.Level0)
1156 {
1157     HcfAsyKeyGenerator *generator = nullptr;
1158     HcfKeyPair *keyPair = nullptr;
1159 
1160     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1161         &g_mockEd25519PriKeyBlob, &keyPair);
1162     ASSERT_EQ(res, HCF_SUCCESS);
1163 
1164     keyPair->priKey->clearMem(nullptr);
1165     HcfBlob blob = { .data = nullptr, .len = 0 };
1166     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
1167     ASSERT_EQ(res, HCF_SUCCESS);
1168     ASSERT_NE(blob.data, nullptr);
1169     ASSERT_NE(blob.len, 0);
1170     HcfFree(blob.data);
1171     HcfObjDestroy(keyPair);
1172     HcfObjDestroy(generator);
1173 }
1174 
1175 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest048, TestSize.Level0)
1176 {
1177     HcfAsyKeyGenerator *generator = nullptr;
1178     HcfKeyPair *keyPair = nullptr;
1179     HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1180         &g_mockEd25519PriKeyBlob, &keyPair);
1181     ASSERT_EQ(res, HCF_SUCCESS);
1182 
1183     keyPair->priKey->clearMem((HcfPriKey *)&g_obj);
1184     HcfBlob blob = { .data = nullptr, .len = 0 };
1185     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
1186     ASSERT_EQ(res, HCF_SUCCESS);
1187     ASSERT_NE(blob.data, nullptr);
1188     ASSERT_NE(blob.len, 0);
1189     HcfFree(blob.data);
1190     HcfObjDestroy(keyPair);
1191     HcfObjDestroy(generator);
1192 }
1193 
1194 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest049, TestSize.Level0)
1195 {
1196     HcfAsyKeyGenerator *generator = nullptr;
1197     HcfKeyPair *keyPair = nullptr;
1198 
1199     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
1200     ASSERT_EQ(res, HCF_SUCCESS);
1201 
1202     keyPair->pubKey->base.base.destroy(nullptr);
1203     HcfObjDestroy(keyPair);
1204     HcfObjDestroy(generator);
1205 }
1206 
1207 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest050, TestSize.Level0)
1208 {
1209     HcfAsyKeyGenerator *generator = nullptr;
1210     HcfKeyPair *keyPair = nullptr;
1211     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
1212     ASSERT_EQ(res, HCF_SUCCESS);
1213 
1214     keyPair->pubKey->base.base.destroy(&g_obj);
1215     HcfObjDestroy(keyPair);
1216     HcfObjDestroy(generator);
1217 }
1218 
1219 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest051, TestSize.Level0)
1220 {
1221     HcfAsyKeyGenerator *generator = nullptr;
1222     HcfKeyPair *keyPair = nullptr;
1223 
1224     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
1225     ASSERT_EQ(res, HCF_SUCCESS);
1226 
1227     keyPair->priKey->base.base.destroy(nullptr);
1228     HcfObjDestroy(keyPair);
1229     HcfObjDestroy(generator);
1230 }
1231 
1232 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest052, TestSize.Level0)
1233 {
1234     HcfAsyKeyGenerator *generator = nullptr;
1235     HcfKeyPair *keyPair = nullptr;
1236     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
1237     ASSERT_EQ(res, HCF_SUCCESS);
1238 
1239     keyPair->priKey->base.base.destroy(&g_obj);
1240     HcfObjDestroy(keyPair);
1241     HcfObjDestroy(generator);
1242 }
1243 
1244 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest053, TestSize.Level0)
1245 {
1246     HcfAsyKeyGenerator *generator = nullptr;
1247     HcfKeyPair *keyPair = nullptr;
1248 
1249     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
1250     ASSERT_EQ(res, HCF_SUCCESS);
1251 
1252     HcfSign *sign = nullptr;
1253     res = HcfSignCreate("Ed25519", &sign);
1254     ASSERT_EQ(res, HCF_SUCCESS);
1255     res = sign->init(sign, nullptr, keyPair->priKey);
1256     ASSERT_EQ(res, HCF_SUCCESS);
1257     HcfBlob out = { .data = nullptr, .len = 0 };
1258     res = sign->sign(sign, &g_mockInput, &out);
1259     ASSERT_EQ(res, HCF_SUCCESS);
1260     ASSERT_NE(out.data, nullptr);
1261     ASSERT_NE(out.len, 0);
1262 
1263     HcfVerify *verify = nullptr;
1264     res = HcfVerifyCreate("Ed25519", &verify);
1265     ASSERT_EQ(res, HCF_SUCCESS);
1266     res = verify->init(verify, nullptr, keyPair->pubKey);
1267     ASSERT_EQ(res, HCF_SUCCESS);
1268 
1269     bool flag = verify->verify(verify, &g_mockInput, &out);
1270     ASSERT_EQ(flag, true);
1271     ASSERT_NE(out.data, nullptr);
1272     ASSERT_NE(out.len, 0);
1273     HcfFree(out.data);
1274     HcfObjDestroy(keyPair);
1275     HcfObjDestroy(generator);
1276     HcfObjDestroy(sign);
1277     HcfObjDestroy(verify);
1278 }
1279 }