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 <cstring>
18 
19 #include "alg_25519_common_param_spec.h"
20 #include "blob.h"
21 #include "ecdsa_openssl.h"
22 #include "memory.h"
23 #include "securec.h"
24 #include "openssl_common.h"
25 #include "asy_key_params.h"
26 #include "params_parser.h"
27 #include "alg_25519_asy_key_generator_openssl.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 CryptoEd25519AsyKeyGeneratorBySpecTest : public testing::Test {
36 public:
SetUpTestCase()37     static void SetUpTestCase() {};
TearDownTestCase()38     static void TearDownTestCase() {};
39     void SetUp();
40     void TearDown();
41 };
42 
43 static string g_ed25519AlgoName = "Ed25519";
44 static string g_pubkeyformatName = "X.509";
45 static string g_prikeyformatName = "PKCS#8";
46 
SetUp()47 void CryptoEd25519AsyKeyGeneratorBySpecTest::SetUp() {}
TearDown()48 void CryptoEd25519AsyKeyGeneratorBySpecTest::TearDown() {}
49 
50 static const char *g_mockMessage = "hello world";
51 static HcfBlob g_mockInput = {
52     .data = (uint8_t *)g_mockMessage,
53     .len = 12
54 };
55 
GetMockClass(void)56 static const char *GetMockClass(void)
57 {
58     return "ed25519generator";
59 }
60 HcfObjectBase g_obj = {
61     .getClass = GetMockClass,
62     .destroy = nullptr
63 };
64 
65 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest001_1, TestSize.Level0)
66 {
67     HcfAsyKeyParamsSpec *paramSpec = nullptr;
68     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
69     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
70         &paramSpec, &returnObj);
71     ASSERT_EQ(res, HCF_SUCCESS);
72     HcfObjDestroy(returnObj);
73     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
74 }
75 
76 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest001_2, TestSize.Level0)
77 {
78     HcfAsyKeyParamsSpec *paramSpec = nullptr;
79     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
80     HcfResult res = TestCreatePubKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
81         &paramSpec, &returnObj);
82     ASSERT_EQ(res, HCF_SUCCESS);
83     HcfObjDestroy(returnObj);
84     DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramSpec));
85 }
86 
87 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest001_3, TestSize.Level0)
88 {
89     HcfAsyKeyParamsSpec *paramSpec = nullptr;
90     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
91     HcfResult res = TestCreatePriKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
92         &paramSpec, &returnObj);
93     ASSERT_EQ(res, HCF_SUCCESS);
94     HcfObjDestroy(returnObj);
95     DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramSpec));
96 }
97 
98 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest002, TestSize.Level0)
99 {
100     HcfAsyKeyParamsSpec *paramSpec = nullptr;
101     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
102     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
103         &paramSpec, &returnObj);
104     ASSERT_EQ(res, HCF_SUCCESS);
105 
106     const char *className = returnObj->base.getClass();
107     ASSERT_NE(className, nullptr);
108     ASSERT_NE(returnObj, nullptr);
109     HcfObjDestroy(returnObj);
110     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
111 }
112 
113 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest003, TestSize.Level0)
114 {
115     HcfAsyKeyParamsSpec *paramSpec = nullptr;
116     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
117 
118     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
119         &paramSpec, &returnObj);
120     ASSERT_EQ(res, HCF_SUCCESS);
121 
122     returnObj->base.destroy(&g_obj);
123     HcfObjDestroy(returnObj);
124     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
125 }
126 
127 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest004, TestSize.Level0)
128 {
129     HcfAsyKeyParamsSpec *paramSpec = nullptr;
130     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
131     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
132         &paramSpec, &returnObj);
133     ASSERT_EQ(res, HCF_SUCCESS);
134 
135     const char *algoName = returnObj->getAlgName(returnObj);
136     ASSERT_EQ(res, HCF_SUCCESS);
137     ASSERT_EQ(algoName, g_ed25519AlgoName);
138 
139     HcfObjDestroy(returnObj);
140     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
141 }
142 
143 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest005, TestSize.Level0)
144 {
145     HcfAsyKeyParamsSpec *paramSpec = nullptr;
146     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
147 
148     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
149         &paramSpec, &returnObj);
150     ASSERT_EQ(res, HCF_SUCCESS);
151 
152     HcfKeyPair *keyPair = nullptr;
153     res = returnObj->generateKeyPair(returnObj, &keyPair);
154 
155     ASSERT_EQ(res, HCF_SUCCESS);
156     ASSERT_NE(keyPair, nullptr);
157 
158     HcfObjDestroy(keyPair);
159     HcfObjDestroy(returnObj);
160     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
161 }
162 
163 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest006, TestSize.Level0)
164 {
165     HcfAsyKeyParamsSpec *paramSpec = nullptr;
166     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
167     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
168         &paramSpec, &returnObj);
169     ASSERT_EQ(res, HCF_SUCCESS);
170 
171     HcfKeyPair *keyPair = nullptr;
172     res = returnObj->generateKeyPair(returnObj, &keyPair);
173 
174     ASSERT_EQ(res, HCF_SUCCESS);
175     ASSERT_NE(keyPair, nullptr);
176 
177     const char *className = keyPair->base.getClass();
178     ASSERT_NE(className, nullptr);
179 
180     HcfObjDestroy(keyPair);
181     HcfObjDestroy(returnObj);
182     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
183 }
184 
185 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest007, TestSize.Level0)
186 {
187     HcfAsyKeyParamsSpec *paramSpec = nullptr;
188     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
189 
190     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
191         &paramSpec, &returnObj);
192     ASSERT_EQ(res, HCF_SUCCESS);
193 
194     HcfKeyPair *keyPair = nullptr;
195     res = returnObj->generateKeyPair(returnObj, &keyPair);
196 
197     ASSERT_EQ(res, HCF_SUCCESS);
198     ASSERT_NE(keyPair, nullptr);
199 
200     keyPair->base.destroy(&(keyPair->base));
201     HcfObjDestroy(returnObj);
202     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
203 }
204 
205 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest008, TestSize.Level0)
206 {
207     HcfAsyKeyParamsSpec *paramSpec = nullptr;
208     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
209     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
210         &paramSpec, &returnObj);
211     ASSERT_EQ(res, HCF_SUCCESS);
212 
213     HcfKeyPair *keyPair = nullptr;
214     res = returnObj->generateKeyPair(returnObj, &keyPair);
215     ASSERT_EQ(res, HCF_SUCCESS);
216     ASSERT_NE(keyPair, nullptr);
217 
218     const char *className = keyPair->pubKey->base.base.getClass();
219     ASSERT_NE(className, nullptr);
220 
221     HcfObjDestroy(keyPair);
222     HcfObjDestroy(returnObj);
223     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
224 }
225 
226 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest009, TestSize.Level0)
227 {
228     HcfAsyKeyParamsSpec *paramSpec = nullptr;
229     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
230 
231     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
232         &paramSpec, &returnObj);
233     ASSERT_EQ(res, HCF_SUCCESS);
234 
235     HcfKeyPair *keyPair = nullptr;
236     res = returnObj->generateKeyPair(returnObj, &keyPair);
237     ASSERT_EQ(res, HCF_SUCCESS);
238     ASSERT_NE(keyPair, nullptr);
239 
240     keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
241     keyPair->pubKey = nullptr;
242     HcfObjDestroy(keyPair);
243     HcfObjDestroy(returnObj);
244     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
245 }
246 
247 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest010, TestSize.Level0)
248 {
249     HcfAsyKeyParamsSpec *paramSpec = nullptr;
250     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
251     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
252         &paramSpec, &returnObj);
253     ASSERT_EQ(res, HCF_SUCCESS);
254 
255     HcfKeyPair *keyPair = nullptr;
256     res = returnObj->generateKeyPair(returnObj, &keyPair);
257     ASSERT_EQ(res, HCF_SUCCESS);
258     ASSERT_NE(keyPair, nullptr);
259 
260     const char *algorithmName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
261     ASSERT_EQ(algorithmName, g_ed25519AlgoName);
262 
263     HcfBlob blob = { .data = nullptr, .len = 0 };
264     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
265     ASSERT_EQ(res, HCF_SUCCESS);
266     ASSERT_NE(blob.data, nullptr);
267     ASSERT_NE(blob.len, 0);
268     HcfFree(blob.data);
269     const char *formatName = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
270     ASSERT_EQ(formatName, g_pubkeyformatName);
271 
272     HcfObjDestroy(keyPair);
273     HcfObjDestroy(returnObj);
274     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
275 }
276 
277 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest011, TestSize.Level0)
278 {
279     HcfAsyKeyParamsSpec *paramSpec = nullptr;
280     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
281 
282     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
283         &paramSpec, &returnObj);
284     ASSERT_EQ(res, HCF_SUCCESS);
285 
286     HcfKeyPair *keyPair = nullptr;
287     res = returnObj->generateKeyPair(returnObj, &keyPair);
288     ASSERT_EQ(res, HCF_SUCCESS);
289     ASSERT_NE(keyPair, nullptr);
290 
291     const char *className = keyPair->priKey->base.base.getClass();
292     ASSERT_NE(className, nullptr);
293 
294     HcfObjDestroy(keyPair);
295     HcfObjDestroy(returnObj);
296     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
297 }
298 
299 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest012, TestSize.Level0)
300 {
301     HcfAsyKeyParamsSpec *paramSpec = nullptr;
302     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
303     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
304         &paramSpec, &returnObj);
305     ASSERT_EQ(res, HCF_SUCCESS);
306 
307     HcfKeyPair *keyPair = nullptr;
308     res = returnObj->generateKeyPair(returnObj, &keyPair);
309     ASSERT_EQ(res, HCF_SUCCESS);
310     ASSERT_NE(keyPair, nullptr);
311 
312     keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
313     keyPair->priKey = nullptr;
314     HcfObjDestroy(keyPair);
315     HcfObjDestroy(returnObj);
316     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
317 }
318 
319 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest013, TestSize.Level0)
320 {
321     HcfAsyKeyParamsSpec *paramSpec = nullptr;
322     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
323 
324     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
325         &paramSpec, &returnObj);
326     ASSERT_EQ(res, HCF_SUCCESS);
327 
328     HcfKeyPair *keyPair = nullptr;
329     res = returnObj->generateKeyPair(returnObj, &keyPair);
330     ASSERT_EQ(res, HCF_SUCCESS);
331     ASSERT_NE(keyPair, nullptr);
332 
333     const char *algorithmName = keyPair->priKey->base.getAlgorithm(&(keyPair->priKey->base));
334     ASSERT_EQ(algorithmName, g_ed25519AlgoName);
335 
336     HcfBlob blob = { .data = nullptr, .len = 0 };
337     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
338     ASSERT_EQ(res, HCF_SUCCESS);
339     ASSERT_NE(blob.data, nullptr);
340     ASSERT_NE(blob.len, 0);
341     HcfFree(blob.data);
342     const char *formatName = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
343     ASSERT_EQ(formatName, g_prikeyformatName);
344 
345     HcfObjDestroy(keyPair);
346     HcfObjDestroy(returnObj);
347     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
348 }
349 
350 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest014, TestSize.Level0)
351 {
352     HcfAsyKeyParamsSpec *paramSpec = nullptr;
353     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
354     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
355         &paramSpec, &returnObj);
356     ASSERT_EQ(res, HCF_SUCCESS);
357 
358     HcfKeyPair *keyPair = nullptr;
359     res = returnObj->generateKeyPair(returnObj, &keyPair);
360     ASSERT_EQ(res, HCF_SUCCESS);
361     ASSERT_NE(keyPair, nullptr);
362 
363     keyPair->priKey->clearMem(keyPair->priKey);
364     HcfBlob blob = { .data = nullptr, .len = 0 };
365     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
366     ASSERT_EQ(res, HCF_INVALID_PARAMS);
367     ASSERT_EQ(blob.data, nullptr);
368     ASSERT_EQ(blob.len, 0);
369     HcfFree(blob.data);
370     HcfObjDestroy(keyPair);
371     HcfObjDestroy(returnObj);
372     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
373 }
374 
375 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest015, TestSize.Level0)
376 {
377     HcfAsyKeyParamsSpec *pubparamSpec = nullptr;
378     HcfAsyKeyGeneratorBySpec *returnpubObj = nullptr;
379     HcfResult res = TestCreatePubKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
380         &pubparamSpec, &returnpubObj);
381     ASSERT_EQ(res, HCF_SUCCESS);
382 
383     HcfAsyKeyParamsSpec *priparamSpec = nullptr;
384     HcfAsyKeyGeneratorBySpec *returnpriObj = nullptr;
385     res = TestCreatePriKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
386         &priparamSpec, &returnpriObj);
387     ASSERT_EQ(res, HCF_SUCCESS);
388 
389     HcfPubKey *pubKey = nullptr;
390     res = returnpubObj->generatePubKey(returnpubObj, &pubKey);
391     ASSERT_EQ(res, HCF_SUCCESS);
392     ASSERT_NE(pubKey, nullptr);
393 
394     HcfPriKey *priKey = nullptr;
395     res = returnpriObj->generatePriKey(returnpriObj, &priKey);
396     ASSERT_EQ(res, HCF_SUCCESS);
397     ASSERT_NE(priKey, nullptr);
398 
399     HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
400     res = pubKey->getAsyKeySpecBigInteger(pubKey, ED25519_PK_BN, &returnBigInteger);
401     ASSERT_EQ(res, HCF_SUCCESS);
402     ASSERT_NE(returnBigInteger.data, nullptr);
403     ASSERT_NE(returnBigInteger.len, 0);
404 
405     res = priKey->getAsyKeySpecBigInteger(priKey, ED25519_SK_BN, &returnBigInteger);
406     ASSERT_EQ(res, HCF_SUCCESS);
407     ASSERT_NE(returnBigInteger.data, nullptr);
408     ASSERT_NE(returnBigInteger.len, 0);
409     HcfFree(returnBigInteger.data);
410     HcfObjDestroy(pubKey);
411     HcfObjDestroy(priKey);
412     HcfObjDestroy(returnpubObj);
413     HcfObjDestroy(returnpriObj);
414     DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(pubparamSpec));
415     DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(priparamSpec));
416 }
417 
418 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest016, TestSize.Level0)
419 {
420     HcfAsyKeyParamsSpec *paramSpec = nullptr;
421     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
422     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
423         &paramSpec, &returnObj);
424     ASSERT_EQ(res, HCF_SUCCESS);
425 
426     HcfKeyPair *keyPair = nullptr;
427     res = returnObj->generateKeyPair(returnObj, &keyPair);
428     ASSERT_EQ(res, HCF_SUCCESS);
429     ASSERT_NE(keyPair, nullptr);
430 
431     HcfSign *sign = nullptr;
432     res = HcfSignCreate("Ed25519", &sign);
433     ASSERT_EQ(res, HCF_SUCCESS);
434     res = sign->init(sign, nullptr, keyPair->priKey);
435     ASSERT_EQ(res, HCF_SUCCESS);
436     HcfBlob out = { .data = nullptr, .len = 0 };
437     res = sign->sign(sign, &g_mockInput, &out);
438     ASSERT_EQ(res, HCF_SUCCESS);
439     ASSERT_NE(out.data, nullptr);
440     ASSERT_NE(out.len, 0);
441 
442     HcfVerify *verify = nullptr;
443     res = HcfVerifyCreate("Ed25519", &verify);
444     ASSERT_EQ(res, HCF_SUCCESS);
445     res = verify->init(verify, nullptr, keyPair->pubKey);
446     ASSERT_EQ(res, HCF_SUCCESS);
447 
448     bool flag = verify->verify(verify, &g_mockInput, &out);
449     ASSERT_EQ(flag, true);
450     ASSERT_NE(out.data, nullptr);
451     ASSERT_NE(out.len, 0);
452 
453     HcfFree(out.data);
454     HcfObjDestroy(sign);
455     HcfObjDestroy(verify);
456     HcfObjDestroy(keyPair);
457     HcfObjDestroy(returnObj);
458     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
459 }
460 
461 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest017, TestSize.Level0)
462 {
463     HcfAsyKeyGenParams params = {
464         .algo = HCF_ALG_ED25519,
465         .bits = HCF_ALG_ED25519_256,
466         .primes = HCF_OPENSSL_PRIMES_2,
467     };
468 
469     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
470     HcfResult res = HcfAsyKeyGeneratorSpiEd25519Create(&params, &returnSpi);
471 
472     ASSERT_EQ(res, HCF_SUCCESS);
473     ASSERT_NE(returnSpi, nullptr);
474     HcfObjDestroy(returnSpi);
475 }
476 
477 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest018, TestSize.Level0)
478 {
479     HcfAsyKeyGenParams params = {
480         .algo = HCF_ALG_ED25519,
481         .bits = HCF_ALG_ED25519_256,
482         .primes = HCF_OPENSSL_PRIMES_2,
483     };
484 
485     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
486     HcfResult res = HcfAsyKeyGeneratorSpiEd25519Create(&params, &returnSpi);
487 
488     ASSERT_EQ(res, HCF_SUCCESS);
489     ASSERT_NE(returnSpi, nullptr);
490 
491     HcfAsyKeyParamsSpec *paramsSpec = nullptr;
492     res = ConstructAlg25519KeyPairParamsSpec(g_ed25519AlgoName.c_str(), true, &paramsSpec);
493     ASSERT_EQ(res, HCF_SUCCESS);
494     ASSERT_NE(returnSpi, nullptr);
495 
496     HcfKeyPair *keyPair = nullptr;
497     res = returnSpi->engineGenerateKeyPairBySpec(returnSpi, paramsSpec, &keyPair);
498     ASSERT_EQ(res, HCF_SUCCESS);
499     ASSERT_NE(keyPair, nullptr);
500 
501     HcfObjDestroy(returnSpi);
502     HcfObjDestroy(keyPair);
503     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramsSpec));
504 }
505 
506 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest019, TestSize.Level0)
507 {
508     HcfAsyKeyGenParams params = {
509         .algo = HCF_ALG_ED25519,
510         .bits = HCF_ALG_ED25519_256,
511         .primes = HCF_OPENSSL_PRIMES_2,
512     };
513 
514     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
515     HcfResult res = HcfAsyKeyGeneratorSpiEd25519Create(&params, &returnSpi);
516 
517     ASSERT_EQ(res, HCF_SUCCESS);
518     ASSERT_NE(returnSpi, nullptr);
519 
520     HcfAsyKeyParamsSpec *paramsSpec = nullptr;
521     res = ConstructAlg25519PubKeyParamsSpec(g_ed25519AlgoName.c_str(), true, &paramsSpec);
522     ASSERT_EQ(res, HCF_SUCCESS);
523     ASSERT_NE(returnSpi, nullptr);
524 
525     HcfPubKey *pubKey = nullptr;
526     res = returnSpi->engineGeneratePubKeyBySpec(returnSpi, paramsSpec, &pubKey);
527     ASSERT_EQ(res, HCF_SUCCESS);
528     ASSERT_NE(pubKey, nullptr);
529 
530     HcfObjDestroy(returnSpi);
531     HcfObjDestroy(pubKey);
532     DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramsSpec));
533 }
534 
535 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest020, TestSize.Level0)
536 {
537     HcfAsyKeyGenParams params = {
538         .algo = HCF_ALG_ED25519,
539         .bits = HCF_ALG_ED25519_256,
540         .primes = HCF_OPENSSL_PRIMES_2,
541     };
542 
543     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
544     HcfResult res = HcfAsyKeyGeneratorSpiEd25519Create(&params, &returnSpi);
545 
546     ASSERT_EQ(res, HCF_SUCCESS);
547     ASSERT_NE(returnSpi, nullptr);
548 
549     HcfAsyKeyParamsSpec *paramsSpec = nullptr;
550     res = ConstructAlg25519PriKeyParamsSpec(g_ed25519AlgoName.c_str(), true, &paramsSpec);
551     ASSERT_EQ(res, HCF_SUCCESS);
552     ASSERT_NE(returnSpi, nullptr);
553 
554     HcfPriKey *priKey = nullptr;
555     res = returnSpi->engineGeneratePriKeyBySpec(returnSpi, paramsSpec, &priKey);
556     ASSERT_EQ(res, HCF_SUCCESS);
557     ASSERT_NE(priKey, nullptr);
558 
559     HcfObjDestroy(returnSpi);
560     HcfObjDestroy(priKey);
561     DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramsSpec));
562 }
563 
564 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest021, TestSize.Level0)
565 {
566     HcfAsyKeyParamsSpec *paramSpec = nullptr;
567     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
568     HcfResult res = TestCreatePubKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
569         &paramSpec, &returnObj);
570     ASSERT_EQ(res, HCF_SUCCESS);
571 
572     HcfPriKey *priKey = nullptr;
573     res = returnObj->generatePriKey(returnObj, &priKey);
574     ASSERT_EQ(res, HCF_INVALID_PARAMS);
575     ASSERT_EQ(priKey, nullptr);
576 
577     HcfKeyPair *keyPair = nullptr;
578     res = returnObj->generateKeyPair(returnObj, &keyPair);
579     ASSERT_EQ(res, HCF_INVALID_PARAMS);
580     ASSERT_EQ(keyPair, nullptr);
581 
582     HcfObjDestroy(returnObj);
583     HcfObjDestroy(priKey);
584     HcfObjDestroy(keyPair);
585     DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramSpec));
586 }
587 
588 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest022, TestSize.Level0)
589 {
590     HcfAsyKeyParamsSpec *paramSpec = nullptr;
591     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
592 
593     HcfResult res = TestCreatePriKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
594         &paramSpec, &returnObj);
595     ASSERT_EQ(res, HCF_SUCCESS);
596 
597     HcfKeyPair *keyPair = nullptr;
598     res = returnObj->generateKeyPair(returnObj, &keyPair);
599     ASSERT_EQ(res, HCF_INVALID_PARAMS);
600     ASSERT_EQ(keyPair, nullptr);
601 
602     HcfPubKey *pubKey = nullptr;
603     res = returnObj->generatePubKey(returnObj, &pubKey);
604     ASSERT_EQ(res, HCF_INVALID_PARAMS);
605     ASSERT_EQ(pubKey, nullptr);
606 
607     HcfObjDestroy(returnObj);
608     HcfObjDestroy(keyPair);
609     HcfObjDestroy(pubKey);
610     DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramSpec));
611 }
612 
613 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest023, TestSize.Level0)
614 {
615     HcfAsyKeyGenerator *generator;
616     HcfResult res = HcfAsyKeyGeneratorCreate(g_ed25519AlgoName.c_str(), &generator);
617     ASSERT_EQ(res, HCF_SUCCESS);
618 
619     HcfKeyPair *keyPair = nullptr;
620     res = generator->generateKeyPair(generator, nullptr, &keyPair);
621 
622     ASSERT_EQ(res, HCF_SUCCESS);
623     ASSERT_NE(keyPair, nullptr);
624 
625     HcfBlob blob1 = { .data = nullptr, .len = 0 };
626     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob1);
627     ASSERT_EQ(res, HCF_SUCCESS);
628     ASSERT_NE(blob1.data, nullptr);
629     ASSERT_NE(blob1.len, 0);
630 
631     HcfAsyKeyParamsSpec *paramSpec = nullptr;
632     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
633     res = TestCreatePubKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
634         &paramSpec, &returnObj);
635     ASSERT_EQ(res, HCF_SUCCESS);
636 
637     HcfPubKey *pubKey = nullptr;
638     res = returnObj->generatePubKey(returnObj, &pubKey);
639     ASSERT_EQ(res, HCF_SUCCESS);
640     ASSERT_NE(pubKey, nullptr);
641 
642     HcfBlob blob2 = { .data = nullptr, .len = 0 };
643     res = pubKey->base.getEncoded(&(pubKey->base), &blob2);
644     ASSERT_EQ(res, HCF_SUCCESS);
645     ASSERT_NE(blob2.data, nullptr);
646     ASSERT_NE(blob2.len, 0);
647 
648     ASSERT_EQ(*(blob1.data), *(blob2.data));
649     ASSERT_EQ(blob1.len, blob2.len);
650 
651     HcfFree(blob1.data);
652     HcfFree(blob2.data);
653     HcfObjDestroy(returnObj);
654     HcfObjDestroy(pubKey);
655     HcfObjDestroy(keyPair);
656     DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramSpec));
657 }
658 
659 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest024, TestSize.Level0)
660 {
661     HcfAsyKeyGenerator *generator;
662     HcfResult res = HcfAsyKeyGeneratorCreate(g_ed25519AlgoName.c_str(), &generator);
663     ASSERT_EQ(res, HCF_SUCCESS);
664 
665     HcfKeyPair *keyPair = nullptr;
666     res = generator->generateKeyPair(generator, nullptr, &keyPair);
667 
668     ASSERT_EQ(res, HCF_SUCCESS);
669     ASSERT_NE(keyPair, nullptr);
670 
671     HcfBlob blob1 = { .data = nullptr, .len = 0 };
672     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob1);
673     ASSERT_EQ(res, HCF_SUCCESS);
674     ASSERT_NE(blob1.data, nullptr);
675     ASSERT_NE(blob1.len, 0);
676 
677     HcfAsyKeyParamsSpec *paramSpec = nullptr;
678     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
679 
680     res = TestCreatePriKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
681         &paramSpec, &returnObj);
682     ASSERT_EQ(res, HCF_SUCCESS);
683 
684     HcfPriKey *priKey = nullptr;
685     res = returnObj->generatePriKey(returnObj, &priKey);
686     ASSERT_EQ(res, HCF_SUCCESS);
687     ASSERT_NE(priKey, nullptr);
688 
689     HcfBlob blob2 = { .data = nullptr, .len = 0 };
690     res = priKey->base.getEncoded(&(priKey->base), &blob2);
691     ASSERT_EQ(res, HCF_SUCCESS);
692     ASSERT_NE(blob2.data, nullptr);
693     ASSERT_NE(blob2.len, 0);
694 
695     ASSERT_EQ(*(blob1.data), *(blob2.data));
696     ASSERT_EQ(blob1.len, blob2.len);
697 
698     HcfFree(blob1.data);
699     HcfFree(blob2.data);
700     HcfObjDestroy(returnObj);
701     HcfObjDestroy(priKey);
702     HcfObjDestroy(keyPair);
703     DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramSpec));
704 }
705 
706 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest025, TestSize.Level0)
707 {
708     HcfAsyKeyParamsSpec *paramSpec = nullptr;
709     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
710     HcfResult res = TestCreatePriKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
711         &paramSpec, &returnObj);
712     ASSERT_EQ(res, HCF_SUCCESS);
713 
714     HcfPriKey *priKey = nullptr;
715     res = returnObj->generatePriKey(returnObj, &priKey);
716     ASSERT_EQ(res, HCF_SUCCESS);
717     ASSERT_NE(priKey, nullptr);
718 
719     HcfBlob blob = { .data = nullptr, .len = 0 };
720     res = priKey->base.getEncoded(&(priKey->base), &blob);
721     ASSERT_EQ(res, HCF_SUCCESS);
722     ASSERT_NE(blob.data, nullptr);
723     ASSERT_NE(blob.len, 0);
724 
725     HcfAsyKeyGenerator *generator;
726     res = HcfAsyKeyGeneratorCreate(g_ed25519AlgoName.c_str(), &generator);
727     ASSERT_EQ(res, HCF_SUCCESS);
728 
729     HcfKeyPair *keyPair = nullptr;
730     res = generator->convertKey(generator, nullptr, nullptr, &blob, &keyPair);
731 
732     HcfFree(blob.data);
733     HcfObjDestroy(returnObj);
734     HcfObjDestroy(priKey);
735     HcfObjDestroy(keyPair);
736     DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramSpec));
737 }
738 
739 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest026, TestSize.Level0)
740 {
741     HcfAsyKeyParamsSpec *paramSpec = nullptr;
742     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
743 
744     HcfResult res = TestCreatePubKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
745         &paramSpec, &returnObj);
746     ASSERT_EQ(res, HCF_SUCCESS);
747 
748     HcfPubKey *pubKey = nullptr;
749     res = returnObj->generatePubKey(returnObj, &pubKey);
750     ASSERT_EQ(res, HCF_SUCCESS);
751     ASSERT_NE(pubKey, nullptr);
752 
753     HcfBlob blob = { .data = nullptr, .len = 0 };
754     res = pubKey->base.getEncoded(&(pubKey->base), &blob);
755     ASSERT_EQ(res, HCF_SUCCESS);
756     ASSERT_NE(blob.data, nullptr);
757     ASSERT_NE(blob.len, 0);
758 
759     HcfAsyKeyGenerator *generator;
760     res = HcfAsyKeyGeneratorCreate(g_ed25519AlgoName.c_str(), &generator);
761     ASSERT_EQ(res, HCF_SUCCESS);
762 
763     HcfKeyPair *keyPair = nullptr;
764     res = generator->convertKey(generator, nullptr, &blob, nullptr, &keyPair);
765     HcfFree(blob.data);
766     HcfObjDestroy(returnObj);
767     HcfObjDestroy(pubKey);
768     HcfObjDestroy(keyPair);
769     DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramSpec));
770 }
771 }