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