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 "asy_key_generator_spi.h"
21 #include "blob.h"
22 #include "signature.h"
23 #include "memory.h"
24 #include "openssl_class.h"
25 #include "openssl_common.h"
26 #include "asy_key_params.h"
27 #include "key_utils.h"
28 #include "key_pair.h"
29 #include "object_base.h"
30 #include "alg_25519_asy_key_generator_openssl.h"
31 
32 using namespace std;
33 using namespace testing::ext;
34 
35 namespace {
36 class CryptoX25519AsyKeyGeneratorBySpecTest : public testing::Test {
37 public:
38     static void SetUpTestCase();
39     static void TearDownTestCase();
40     void SetUp();
41     void TearDown();
42 };
43 
44 static string g_x25519AlgoName = "X25519";
45 static string g_pubkeyformatName = "X.509";
46 static string g_prikeyformatName = "PKCS#8";
47 
SetUp()48 void CryptoX25519AsyKeyGeneratorBySpecTest::SetUp() {}
TearDown()49 void CryptoX25519AsyKeyGeneratorBySpecTest::TearDown() {}
SetUpTestCase()50 void CryptoX25519AsyKeyGeneratorBySpecTest::SetUpTestCase() {}
TearDownTestCase()51 void CryptoX25519AsyKeyGeneratorBySpecTest::TearDownTestCase() {}
52 
53 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest001_1, TestSize.Level0)
54 {
55     HcfAsyKeyParamsSpec *paramSpec = nullptr;
56     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
57     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
58         &paramSpec, &returnObj);
59     ASSERT_EQ(res, HCF_SUCCESS);
60     HcfObjDestroy(returnObj);
61     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
62 }
63 
64 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest001_2, TestSize.Level0)
65 {
66     HcfAsyKeyParamsSpec *paramSpec = nullptr;
67     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
68     HcfResult res = TestCreatePubKeyParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
69         &paramSpec, &returnObj);
70     ASSERT_EQ(res, HCF_SUCCESS);
71     HcfObjDestroy(returnObj);
72     DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramSpec));
73 }
74 
75 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest001_3, TestSize.Level0)
76 {
77     HcfAsyKeyParamsSpec *paramSpec = nullptr;
78     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
79     HcfResult res = TestCreatePriKeyParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
80         &paramSpec, &returnObj);
81     ASSERT_EQ(res, HCF_SUCCESS);
82     HcfObjDestroy(returnObj);
83     DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramSpec));
84 }
85 
86 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest002, TestSize.Level0)
87 {
88     HcfAsyKeyParamsSpec *paramSpec = nullptr;
89     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
90     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
91         &paramSpec, &returnObj);
92     ASSERT_EQ(res, HCF_SUCCESS);
93 
94     const char *className = returnObj->base.getClass();
95     ASSERT_NE(className, nullptr);
96     ASSERT_NE(returnObj, nullptr);
97     HcfObjDestroy(returnObj);
98     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
99 }
100 
101 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest003, TestSize.Level0)
102 {
103     HcfAsyKeyParamsSpec *paramSpec = nullptr;
104     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
105     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
106         &paramSpec, &returnObj);
107     ASSERT_EQ(res, HCF_SUCCESS);
108 
109     returnObj->base.destroy((HcfObjectBase *)returnObj);
110     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
111 }
112 
113 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest004, TestSize.Level0)
114 {
115     HcfAsyKeyParamsSpec *paramSpec = nullptr;
116     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
117     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
118         &paramSpec, &returnObj);
119     ASSERT_EQ(res, HCF_SUCCESS);
120 
121     const char *algoName = returnObj->getAlgName(returnObj);
122     ASSERT_EQ(res, HCF_SUCCESS);
123     ASSERT_EQ(algoName, g_x25519AlgoName);
124 
125     HcfObjDestroy(returnObj);
126     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
127 }
128 
129 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest005, TestSize.Level0)
130 {
131     HcfAsyKeyParamsSpec *paramSpec = nullptr;
132     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
133     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
134         &paramSpec, &returnObj);
135     ASSERT_EQ(res, HCF_SUCCESS);
136 
137     HcfKeyPair *keyPair = nullptr;
138     res = returnObj->generateKeyPair(returnObj, &keyPair);
139 
140     ASSERT_EQ(res, HCF_SUCCESS);
141     ASSERT_NE(keyPair, nullptr);
142 
143     HcfObjDestroy(keyPair);
144     HcfObjDestroy(returnObj);
145     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
146 }
147 
148 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest006, TestSize.Level0)
149 {
150     HcfAsyKeyParamsSpec *paramSpec = nullptr;
151     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
152     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
153         &paramSpec, &returnObj);
154     ASSERT_EQ(res, HCF_SUCCESS);
155 
156     HcfKeyPair *keyPair = nullptr;
157     res = returnObj->generateKeyPair(returnObj, &keyPair);
158 
159     ASSERT_EQ(res, HCF_SUCCESS);
160     ASSERT_NE(keyPair, nullptr);
161 
162     const char *className = keyPair->base.getClass();
163     ASSERT_NE(className, nullptr);
164 
165     HcfObjDestroy(keyPair);
166     HcfObjDestroy(returnObj);
167     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
168 }
169 
170 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest007, TestSize.Level0)
171 {
172     HcfAsyKeyParamsSpec *paramSpec = nullptr;
173     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
174     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
175         &paramSpec, &returnObj);
176     ASSERT_EQ(res, HCF_SUCCESS);
177 
178     HcfKeyPair *keyPair = nullptr;
179     res = returnObj->generateKeyPair(returnObj, &keyPair);
180     ASSERT_EQ(res, HCF_SUCCESS);
181     ASSERT_NE(keyPair, nullptr);
182 
183     keyPair->base.destroy(&(keyPair->base));
184     ASSERT_NE(returnObj, nullptr);
185     HcfObjDestroy(returnObj);
186     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
187 }
188 
189 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest008, TestSize.Level0)
190 {
191     HcfAsyKeyParamsSpec *paramSpec = nullptr;
192     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
193     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
194         &paramSpec, &returnObj);
195     ASSERT_EQ(res, HCF_SUCCESS);
196 
197     HcfKeyPair *keyPair = nullptr;
198     res = returnObj->generateKeyPair(returnObj, &keyPair);
199     ASSERT_EQ(res, HCF_SUCCESS);
200     ASSERT_NE(keyPair, nullptr);
201 
202     const char *className = keyPair->pubKey->base.base.getClass();
203     ASSERT_NE(className, nullptr);
204 
205     HcfObjDestroy(keyPair);
206     HcfObjDestroy(returnObj);
207     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
208 }
209 
210 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest009, TestSize.Level0)
211 {
212     HcfAsyKeyParamsSpec *paramSpec = nullptr;
213     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
214     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
215         &paramSpec, &returnObj);
216     ASSERT_EQ(res, HCF_SUCCESS);
217 
218     HcfKeyPair *keyPair = nullptr;
219     res = returnObj->generateKeyPair(returnObj, &keyPair);
220     ASSERT_EQ(res, HCF_SUCCESS);
221     ASSERT_NE(keyPair, nullptr);
222 
223     keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
224     keyPair->pubKey = nullptr;
225     HcfObjDestroy(keyPair);
226     HcfObjDestroy(returnObj);
227     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
228 }
229 
230 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest010, TestSize.Level0)
231 {
232     HcfAsyKeyParamsSpec *paramSpec = nullptr;
233     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
234     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
235         &paramSpec, &returnObj);
236     ASSERT_EQ(res, HCF_SUCCESS);
237 
238     HcfKeyPair *keyPair = nullptr;
239     res = returnObj->generateKeyPair(returnObj, &keyPair);
240     ASSERT_EQ(res, HCF_SUCCESS);
241     ASSERT_NE(keyPair, nullptr);
242 
243     const char *algorithmName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
244     ASSERT_EQ(algorithmName, g_x25519AlgoName);
245 
246     HcfBlob blob = { .data = nullptr, .len = 0 };
247     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
248     ASSERT_EQ(res, HCF_SUCCESS);
249     ASSERT_NE(blob.data, nullptr);
250     ASSERT_NE(blob.len, 0);
251     HcfFree(blob.data);
252     const char *formatName = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
253     ASSERT_EQ(formatName, g_pubkeyformatName);
254 
255     HcfObjDestroy(keyPair);
256     HcfObjDestroy(returnObj);
257     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
258 }
259 
260 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest011, TestSize.Level0)
261 {
262     HcfAsyKeyParamsSpec *paramSpec = nullptr;
263     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
264     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
265         &paramSpec, &returnObj);
266     ASSERT_EQ(res, HCF_SUCCESS);
267 
268     HcfKeyPair *keyPair = nullptr;
269     res = returnObj->generateKeyPair(returnObj, &keyPair);
270     ASSERT_EQ(res, HCF_SUCCESS);
271     ASSERT_NE(keyPair, nullptr);
272 
273     const char *className = keyPair->priKey->base.base.getClass();
274     ASSERT_NE(className, nullptr);
275 
276     HcfObjDestroy(keyPair);
277     HcfObjDestroy(returnObj);
278     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
279 }
280 
281 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest012, TestSize.Level0)
282 {
283     HcfAsyKeyParamsSpec *paramSpec = nullptr;
284     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
285     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
286         &paramSpec, &returnObj);
287     ASSERT_EQ(res, HCF_SUCCESS);
288 
289     HcfKeyPair *keyPair = nullptr;
290     res = returnObj->generateKeyPair(returnObj, &keyPair);
291     ASSERT_EQ(res, HCF_SUCCESS);
292     ASSERT_NE(keyPair, nullptr);
293 
294     keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
295     keyPair->priKey = nullptr;
296 
297     HcfObjDestroy(keyPair);
298     HcfObjDestroy(returnObj);
299     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
300 }
301 
302 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest013, TestSize.Level0)
303 {
304     HcfAsyKeyParamsSpec *paramSpec = nullptr;
305     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
306     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
307         &paramSpec, &returnObj);
308     ASSERT_EQ(res, HCF_SUCCESS);
309 
310     HcfKeyPair *keyPair = nullptr;
311     res = returnObj->generateKeyPair(returnObj, &keyPair);
312     ASSERT_EQ(res, HCF_SUCCESS);
313     ASSERT_NE(keyPair, nullptr);
314 
315     const char *algorithmName = keyPair->priKey->base.getAlgorithm(&(keyPair->priKey->base));
316     ASSERT_EQ(algorithmName, g_x25519AlgoName);
317 
318     HcfBlob blob = { .data = nullptr, .len = 0 };
319     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
320     ASSERT_EQ(res, HCF_SUCCESS);
321     ASSERT_NE(blob.data, nullptr);
322     ASSERT_NE(blob.len, 0);
323     HcfFree(blob.data);
324     const char *formatName = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
325     ASSERT_EQ(formatName, g_prikeyformatName);
326 
327     HcfObjDestroy(keyPair);
328     HcfObjDestroy(returnObj);
329     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
330 }
331 
332 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest014, TestSize.Level0)
333 {
334     HcfAsyKeyParamsSpec *paramSpec = nullptr;
335     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
336     HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
337         &paramSpec, &returnObj);
338     ASSERT_EQ(res, HCF_SUCCESS);
339 
340     HcfKeyPair *keyPair = nullptr;
341     res = returnObj->generateKeyPair(returnObj, &keyPair);
342     ASSERT_EQ(res, HCF_SUCCESS);
343     ASSERT_NE(keyPair, nullptr);
344 
345     keyPair->priKey->clearMem(keyPair->priKey);
346     HcfBlob blob = { .data = nullptr, .len = 0 };
347     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
348     ASSERT_EQ(res, HCF_INVALID_PARAMS);
349     ASSERT_EQ(blob.data, nullptr);
350     ASSERT_EQ(blob.len, 0);
351     HcfFree(blob.data);
352     HcfObjDestroy(keyPair);
353     HcfObjDestroy(returnObj);
354     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
355 }
356 
357 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest015, TestSize.Level0)
358 {
359     HcfAsyKeyParamsSpec *pubparamSpec = nullptr;
360     HcfAsyKeyGeneratorBySpec *returnpubObj = nullptr;
361     HcfResult res = TestCreatePubKeyParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
362         &pubparamSpec, &returnpubObj);
363     ASSERT_EQ(res, HCF_SUCCESS);
364 
365     HcfAsyKeyParamsSpec *priparamSpec = nullptr;
366     HcfAsyKeyGeneratorBySpec *returnpriObj = nullptr;
367     res = TestCreatePriKeyParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
368         &priparamSpec, &returnpriObj);
369     ASSERT_EQ(res, HCF_SUCCESS);
370 
371     HcfPubKey *pubKey = nullptr;
372     res = returnpubObj->generatePubKey(returnpubObj, &pubKey);
373     ASSERT_EQ(res, HCF_SUCCESS);
374     ASSERT_NE(pubKey, nullptr);
375 
376     HcfPriKey *priKey = nullptr;
377     res = returnpriObj->generatePriKey(returnpriObj, &priKey);
378     ASSERT_EQ(res, HCF_SUCCESS);
379     ASSERT_NE(priKey, nullptr);
380 
381     HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
382     res = pubKey->getAsyKeySpecBigInteger(pubKey, X25519_PK_BN, &returnBigInteger);
383     ASSERT_EQ(res, HCF_SUCCESS);
384     ASSERT_NE(returnBigInteger.data, nullptr);
385     ASSERT_NE(returnBigInteger.len, 0);
386     HcfFree(returnBigInteger.data);
387 
388     HcfBigInteger returnBigInteger1 = { .data = nullptr, .len = 0 };
389     res = priKey->getAsyKeySpecBigInteger(priKey, X25519_SK_BN, &returnBigInteger1);
390     ASSERT_EQ(res, HCF_SUCCESS);
391     ASSERT_NE(returnBigInteger1.data, nullptr);
392     ASSERT_NE(returnBigInteger1.len, 0);
393     HcfFree(returnBigInteger1.data);
394     HcfObjDestroy(pubKey);
395     HcfObjDestroy(priKey);
396     HcfObjDestroy(returnpubObj);
397     HcfObjDestroy(returnpriObj);
398     DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(pubparamSpec));
399     DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(priparamSpec));
400 }
401 
402 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest016, TestSize.Level0)
403 {
404     HcfAsyKeyGenParams params = {
405         .algo = HCF_ALG_X25519,
406         .bits = HCF_ALG_X25519_256,
407         .primes = HCF_OPENSSL_PRIMES_2,
408     };
409 
410     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
411     HcfResult res = HcfAsyKeyGeneratorSpiX25519Create(&params, &returnSpi);
412 
413     ASSERT_EQ(res, HCF_SUCCESS);
414     ASSERT_NE(returnSpi, nullptr);
415     HcfObjDestroy(returnSpi);
416 }
417 
418 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest017, TestSize.Level0)
419 {
420     HcfAsyKeyGenParams params = {
421         .algo = HCF_ALG_X25519,
422         .bits = HCF_ALG_X25519_256,
423         .primes = HCF_OPENSSL_PRIMES_2,
424     };
425 
426     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
427     HcfResult res = HcfAsyKeyGeneratorSpiX25519Create(&params, &returnSpi);
428 
429     ASSERT_EQ(res, HCF_SUCCESS);
430     ASSERT_NE(returnSpi, nullptr);
431 
432     HcfAsyKeyParamsSpec *paramsSpec = nullptr;
433     res = ConstructAlg25519KeyPairParamsSpec(g_x25519AlgoName.c_str(), false, &paramsSpec);
434     ASSERT_EQ(res, HCF_SUCCESS);
435     ASSERT_NE(returnSpi, nullptr);
436 
437     HcfKeyPair *keyPair = nullptr;
438     res = returnSpi->engineGenerateKeyPairBySpec(returnSpi, paramsSpec, &keyPair);
439     ASSERT_EQ(res, HCF_SUCCESS);
440     ASSERT_NE(keyPair, nullptr);
441 
442     HcfObjDestroy(returnSpi);
443     HcfObjDestroy(keyPair);
444     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramsSpec));
445 }
446 
447 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest018, TestSize.Level0)
448 {
449     HcfAsyKeyGenParams params = {
450         .algo = HCF_ALG_X25519,
451         .bits = HCF_ALG_X25519_256,
452         .primes = HCF_OPENSSL_PRIMES_2,
453     };
454 
455     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
456     HcfResult res = HcfAsyKeyGeneratorSpiX25519Create(&params, &returnSpi);
457 
458     ASSERT_EQ(res, HCF_SUCCESS);
459     ASSERT_NE(returnSpi, nullptr);
460 
461     HcfAsyKeyParamsSpec *paramSpec = nullptr;
462     res = ConstructAlg25519PubKeyParamsSpec("X25519", false, &paramSpec);
463     ASSERT_EQ(res, HCF_SUCCESS);
464     ASSERT_NE(returnSpi, nullptr);
465 
466     HcfPubKey *pubKey = nullptr;
467     res = returnSpi->engineGeneratePubKeyBySpec(returnSpi, paramSpec, &pubKey);
468     ASSERT_EQ(res, HCF_SUCCESS);
469     ASSERT_NE(pubKey, nullptr);
470 
471     HcfObjDestroy(returnSpi);
472     HcfObjDestroy(pubKey);
473     DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramSpec));
474 }
475 
476 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest019, TestSize.Level0)
477 {
478     HcfAsyKeyGenParams params = {
479         .algo = HCF_ALG_X25519,
480         .bits = HCF_ALG_X25519_256,
481         .primes = HCF_OPENSSL_PRIMES_2,
482     };
483 
484     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
485     HcfResult res = HcfAsyKeyGeneratorSpiX25519Create(&params, &returnSpi);
486 
487     ASSERT_EQ(res, HCF_SUCCESS);
488     ASSERT_NE(returnSpi, nullptr);
489 
490     HcfAsyKeyParamsSpec *paramSpec = nullptr;
491     res = ConstructAlg25519PriKeyParamsSpec("X25519", false, &paramSpec);
492     ASSERT_EQ(res, HCF_SUCCESS);
493     ASSERT_NE(returnSpi, nullptr);
494 
495     HcfPriKey *priKey = nullptr;
496     res = returnSpi->engineGeneratePriKeyBySpec(returnSpi, paramSpec, &priKey);
497     ASSERT_EQ(res, HCF_SUCCESS);
498     ASSERT_NE(priKey, nullptr);
499 
500     HcfObjDestroy(returnSpi);
501     HcfObjDestroy(priKey);
502     DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramSpec));
503 }
504 
505 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest020, TestSize.Level0)
506 {
507     HcfAsyKeyGenerator *generator = nullptr;
508     HcfKeyPair *keyPair = nullptr;
509     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_x25519AlgoName.c_str(), &generator, &keyPair);
510     ASSERT_EQ(res, HCF_SUCCESS);
511 
512     HcfBlob blob1 = { .data = nullptr, .len = 0 };
513     res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob1);
514     ASSERT_EQ(res, HCF_SUCCESS);
515     ASSERT_NE(blob1.data, nullptr);
516     ASSERT_NE(blob1.len, 0);
517 
518     HcfAsyKeyParamsSpec *paramSpec = nullptr;
519     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
520     res = TestCreatePubKeyParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
521         &paramSpec, &returnObj);
522     ASSERT_EQ(res, HCF_SUCCESS);
523 
524     HcfPubKey *pubKey = nullptr;
525     res = returnObj->generatePubKey(returnObj, &pubKey);
526     ASSERT_EQ(res, HCF_SUCCESS);
527     ASSERT_NE(pubKey, nullptr);
528 
529     HcfBlob blob2 = { .data = nullptr, .len = 0 };
530     res = pubKey->base.getEncoded(&(pubKey->base), &blob2);
531     ASSERT_EQ(res, HCF_SUCCESS);
532     ASSERT_NE(blob2.data, nullptr);
533     ASSERT_NE(blob2.len, 0);
534 
535     ASSERT_EQ(*(blob1.data), *(blob2.data));
536     ASSERT_EQ(blob1.len, blob2.len);
537 
538     HcfFree(blob1.data);
539     HcfFree(blob2.data);
540     HcfObjDestroy(returnObj);
541     HcfObjDestroy(pubKey);
542     HcfObjDestroy(keyPair);
543     DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramSpec));
544 }
545 
546 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest021, TestSize.Level0)
547 {
548     HcfAsyKeyGenerator *generator = nullptr;
549     HcfKeyPair *keyPair = nullptr;
550     HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_x25519AlgoName.c_str(), &generator, &keyPair);
551     ASSERT_EQ(res, HCF_SUCCESS);
552 
553     HcfBlob blob1 = { .data = nullptr, .len = 0 };
554     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob1);
555     ASSERT_EQ(res, HCF_SUCCESS);
556     ASSERT_NE(blob1.data, nullptr);
557     ASSERT_NE(blob1.len, 0);
558 
559     HcfAsyKeyParamsSpec *paramSpec = nullptr;
560     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
561     res = TestCreatePriKeyParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
562         &paramSpec, &returnObj);
563     ASSERT_EQ(res, HCF_SUCCESS);
564 
565     HcfPriKey *priKey = nullptr;
566     res = returnObj->generatePriKey(returnObj, &priKey);
567     ASSERT_EQ(res, HCF_SUCCESS);
568     ASSERT_NE(priKey, nullptr);
569 
570     HcfBlob blob2 = { .data = nullptr, .len = 0 };
571     res = priKey->base.getEncoded(&(priKey->base), &blob2);
572     ASSERT_EQ(res, HCF_SUCCESS);
573     ASSERT_NE(blob2.data, nullptr);
574     ASSERT_NE(blob2.len, 0);
575 
576     ASSERT_EQ(*(blob1.data), *(blob2.data));
577     ASSERT_EQ(blob1.len, blob2.len);
578 
579     HcfFree(blob1.data);
580     HcfFree(blob2.data);
581     HcfObjDestroy(returnObj);
582     HcfObjDestroy(priKey);
583     HcfObjDestroy(keyPair);
584     DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramSpec));
585 }
586 
587 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest022, TestSize.Level0)
588 {
589     HcfAsyKeyParamsSpec *paramSpec = nullptr;
590     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
591     HcfResult res = TestCreatePriKeyParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
592         &paramSpec, &returnObj);
593     ASSERT_EQ(res, HCF_SUCCESS);
594 
595     HcfPriKey *priKey = nullptr;
596     res = returnObj->generatePriKey(returnObj, &priKey);
597     ASSERT_EQ(res, HCF_SUCCESS);
598     ASSERT_NE(priKey, nullptr);
599 
600     HcfBlob blob = { .data = nullptr, .len = 0 };
601     res = priKey->base.getEncoded(&(priKey->base), &blob);
602     ASSERT_EQ(res, HCF_SUCCESS);
603     ASSERT_NE(blob.data, nullptr);
604     ASSERT_NE(blob.len, 0);
605 
606     HcfAsyKeyGenerator *generator;
607     res = HcfAsyKeyGeneratorCreate("X25519", &generator);
608     ASSERT_EQ(res, HCF_SUCCESS);
609 
610     HcfKeyPair *keyPair = nullptr;
611     res = generator->convertKey(generator, nullptr, nullptr, &blob, &keyPair);
612 
613     HcfFree(blob.data);
614     HcfObjDestroy(returnObj);
615     HcfObjDestroy(priKey);
616     HcfObjDestroy(keyPair);
617     DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramSpec));
618 }
619 
620 HWTEST_F(CryptoX25519AsyKeyGeneratorBySpecTest, CryptoX25519AsyKeyGeneratorBySpecTest023, TestSize.Level0)
621 {
622     HcfAsyKeyParamsSpec *paramSpec = nullptr;
623     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
624     HcfResult res = TestCreatePubKeyParamsSpecAndGeneratorBySpec(g_x25519AlgoName.c_str(), false,
625         &paramSpec, &returnObj);
626     ASSERT_EQ(res, HCF_SUCCESS);
627 
628     HcfPubKey *pubKey = nullptr;
629     res = returnObj->generatePubKey(returnObj, &pubKey);
630     ASSERT_EQ(res, HCF_SUCCESS);
631     ASSERT_NE(pubKey, nullptr);
632 
633     HcfBlob blob = { .data = nullptr, .len = 0 };
634     res = pubKey->base.getEncoded(&(pubKey->base), &blob);
635     ASSERT_EQ(res, HCF_SUCCESS);
636     ASSERT_NE(blob.data, nullptr);
637     ASSERT_NE(blob.len, 0);
638 
639     HcfAsyKeyGenerator *generator;
640     res = HcfAsyKeyGeneratorCreate("X25519", &generator);
641     ASSERT_EQ(res, HCF_SUCCESS);
642 
643     HcfKeyPair *keyPair = nullptr;
644     res = generator->convertKey(generator, nullptr, &blob, nullptr, &keyPair);
645 
646     HcfFree(blob.data);
647     HcfObjDestroy(returnObj);
648     HcfObjDestroy(pubKey);
649     HcfObjDestroy(keyPair);
650     DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramSpec));
651 }
652 }