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 "asy_key_generator.h"
21 #include "blob.h"
22 #include "dh_key_util.h"
23 #include "ecdsa_openssl.h"
24 #include "memory.h"
25 #include "securec.h"
26 #include "openssl_common.h"
27 #include "asy_key_params.h"
28 #include "params_parser.h"
29 #include "dh_asy_key_generator_openssl.h"
30 #include "detailed_dh_key_params.h"
31 #include "alg_25519_asy_key_generator_openssl.h"
32 #include "dh_common_param_spec_generator_openssl.h"
33 #include "memory_mock.h"
34 #include "openssl_adapter_mock.h"
35 #include "detailed_ecc_key_params.h"
36 #include "sm2_crypto_params.h"
37 
38 using namespace std;
39 using namespace testing::ext;
40 
41 namespace {
42 constexpr int SKLEN_DH128 = 128;
43 constexpr int SKLEN_DH223 = 223;
44 constexpr int SKLEN_DH255 = 255;
45 constexpr int SKLEN_DH303 = 303;
46 constexpr int SKLEN_DH351 = 351;
47 constexpr int SKLEN_DH399 = 399;
48 constexpr int SKLEN_DH1024 = 1024;
49 constexpr int SKLEN_EQZERO = 0;
50 constexpr int PLEN_DH511 = 511;
51 constexpr int PLEN_DH512 = 512;
52 constexpr int PLEN_DH1536 = 1536;
53 constexpr int PLEN_DH2048 = 2048;
54 constexpr int PLEN_DH3072 = 3072;
55 constexpr int PLEN_DH4096 = 4096;
56 constexpr int PLEN_DH6144 = 6144;
57 constexpr int PLEN_DH8192 = 8192;
58 constexpr int PLEN_DH10001 = 10001;
59 constexpr int PLEN_LTSK = 20;
60 
61 class CryptoDHAsyKeyGeneratorBySpecTest : public testing::Test {
62 public:
63     static void SetUpTestCase();
64     static void TearDownTestCase();
65     void SetUp();
66     void TearDown();
67 };
68 
69 static string g_dh1536AlgoName = "DH_modp1536";
70 static string g_dh2048AlgoName = "DH_modp2048";
71 static string g_dh3072AlgoName = "DH_modp3072";
72 static string g_dh4096AlgoName = "DH_modp4096";
73 static string g_dh6144AlgoName = "DH_modp6144";
74 static string g_dh8192AlgoName = "DH_modp8192";
75 
76 static string g_dhAlgoName = "DH";
77 static string g_dhpubkeyformatName = "X.509";
78 static string g_dhprikeyformatName = "PKCS#8";
79 
80 HcfDhCommParamsSpec *g_dh1536CommSpec = nullptr;
81 HcfDhCommParamsSpec *g_dh2048CommSpec = nullptr;
82 HcfDhCommParamsSpec *g_dh3072CommSpec = nullptr;
83 HcfDhCommParamsSpec *g_dh4096CommSpec = nullptr;
84 HcfDhCommParamsSpec *g_dh6144CommSpec = nullptr;
85 HcfDhCommParamsSpec *g_dh8192CommSpec = nullptr;
86 HcfKeyPair *g_dhKeyPair = nullptr;
87 
SetUp()88 void CryptoDHAsyKeyGeneratorBySpecTest::SetUp() {}
TearDown()89 void CryptoDHAsyKeyGeneratorBySpecTest::TearDown() {}
90 
GetMockClass(void)91 static const char *GetMockClass(void)
92 {
93     return "HcfEcc";
94 }
95 HcfObjectBase g_obj = {
96     .getClass = GetMockClass,
97     .destroy = nullptr
98 };
99 
DestroyTestDhPriKeySpec(HcfDhPriKeyParamsSpec * spec)100 static void DestroyTestDhPriKeySpec(HcfDhPriKeyParamsSpec *spec)
101 {
102     if (spec == nullptr) {
103         return;
104     }
105     if (spec->sk.data != nullptr) {
106         (void)memset_s(spec->sk.data, spec->sk.len, 0, spec->sk.len);
107         HcfFree(spec->sk.data);
108         spec->sk.data = nullptr;
109     }
110     HcfFree(spec);
111 }
112 
DestroyTestDhPubKeySpec(HcfDhPubKeyParamsSpec * spec)113 static void DestroyTestDhPubKeySpec(HcfDhPubKeyParamsSpec *spec)
114 {
115     if (spec == nullptr) {
116         return;
117     }
118     HcfFree(spec->pk.data);
119     spec->pk.data = nullptr;
120     HcfFree(spec);
121 }
122 
DestroyTestDhKeyPairSpec(HcfDhKeyPairParamsSpec * spec)123 static void DestroyTestDhKeyPairSpec(HcfDhKeyPairParamsSpec *spec)
124 {
125     if (spec == nullptr) {
126         return;
127     }
128     HcfFree(spec->pk.data);
129     spec->pk.data = nullptr;
130     if (spec->sk.data != nullptr) {
131         (void)memset_s(spec->sk.data, spec->sk.len, 0, spec->sk.len);
132         HcfFree(spec->sk.data);
133         spec->sk.data = nullptr;
134     }
135     HcfFree(spec);
136 }
137 
ConstructDHKeyCommParamsSpec(int32_t pLen,int32_t skLen,HcfDhCommParamsSpec ** spec)138 static HcfResult ConstructDHKeyCommParamsSpec(int32_t pLen, int32_t skLen, HcfDhCommParamsSpec **spec)
139 {
140     HcfDhCommParamsSpec *dhCommSpec = nullptr;
141     HcfResult res = HcfDhKeyUtilCreate(pLen, skLen, &dhCommSpec);
142     if (res != HCF_SUCCESS) {
143         return HCF_INVALID_PARAMS;
144     }
145     *spec = dhCommSpec;
146     return HCF_SUCCESS;
147 }
148 
ConstructDhKeyPairBigInt(HcfKeyPair * keyPair,HcfDhKeyPairParamsSpec * dhKeyPairSpec)149 static HcfResult ConstructDhKeyPairBigInt(HcfKeyPair *keyPair, HcfDhKeyPairParamsSpec *dhKeyPairSpec)
150 {
151     HcfBigInteger retBigInt = { .data = nullptr, .len = 0 };
152     HcfResult res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, DH_PK_BN, &retBigInt);
153     if (res != HCF_SUCCESS) {
154         return res;
155     }
156     dhKeyPairSpec->pk.data = retBigInt.data;
157     dhKeyPairSpec->pk.len = retBigInt.len;
158 
159     res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, DH_SK_BN, &retBigInt);
160     if (res != HCF_SUCCESS) {
161         HcfFree(dhKeyPairSpec->pk.data);
162         dhKeyPairSpec->pk.data = nullptr;
163         dhKeyPairSpec->pk.len = 0;
164         return res;
165     }
166     dhKeyPairSpec->sk.data = retBigInt.data;
167     dhKeyPairSpec->sk.len = retBigInt.len;
168     return HCF_SUCCESS;
169 }
170 
ConstructDHKeyPairParamsCommonSpec(const std::string & algoName,HcfDhCommParamsSpec * dhCommParamsSpec,HcfAsyKeyParamsSpec ** spec)171 static HcfResult ConstructDHKeyPairParamsCommonSpec(const std::string &algoName,
172     HcfDhCommParamsSpec *dhCommParamsSpec, HcfAsyKeyParamsSpec **spec)
173 {
174     HcfAsyKeyGenerator *generator = nullptr;
175     HcfResult res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator);
176     if (res != HCF_SUCCESS) {
177         return res;
178     }
179 
180     HcfKeyPair *keyPair = nullptr;
181     res = generator->generateKeyPair(generator, nullptr, &keyPair);
182     if (res != HCF_SUCCESS) {
183         HcfObjDestroy(generator);
184         return res;
185     }
186 
187     HcfDhKeyPairParamsSpec *dhKeyPairSpec =
188         reinterpret_cast<HcfDhKeyPairParamsSpec*>(HcfMalloc(sizeof(HcfDhKeyPairParamsSpec), 0));
189     if (dhKeyPairSpec != nullptr) {
190         dhKeyPairSpec->base.base.algName = dhCommParamsSpec->base.algName;
191         dhKeyPairSpec->base.base.specType = HCF_COMMON_PARAMS_SPEC;
192         dhKeyPairSpec->base.p.data = dhCommParamsSpec->p.data;
193         dhKeyPairSpec->base.p.len = dhCommParamsSpec->p.len;
194         dhKeyPairSpec->base.g.data = dhCommParamsSpec->g.data;
195         dhKeyPairSpec->base.g.len = dhCommParamsSpec->g.len;
196         dhKeyPairSpec->base.length = dhCommParamsSpec->length;
197         res = ConstructDhKeyPairBigInt(keyPair, dhKeyPairSpec);
198         if (res != HCF_SUCCESS) {
199             HcfObjDestroy(generator);
200             HcfObjDestroy(keyPair);
201             HcfFree(dhKeyPairSpec);
202             return res;
203         }
204         *spec = reinterpret_cast<HcfAsyKeyParamsSpec *>(dhKeyPairSpec);
205     }
206 
207     HcfObjDestroy(generator);
208     HcfObjDestroy(keyPair);
209     return HCF_SUCCESS;
210 }
211 
ConstructDHKeyPairParamsSpec(const std::string & algoName,HcfDhCommParamsSpec * dhCommParamsSpec,HcfAsyKeyParamsSpec ** spec)212 static HcfResult ConstructDHKeyPairParamsSpec(const std::string &algoName,
213     HcfDhCommParamsSpec *dhCommParamsSpec, HcfAsyKeyParamsSpec **spec)
214 {
215     HcfAsyKeyGenerator *generator = nullptr;
216     HcfResult res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator);
217     if (res != HCF_SUCCESS) {
218         return res;
219     }
220 
221     HcfKeyPair *keyPair = nullptr;
222     res = generator->generateKeyPair(generator, nullptr, &keyPair);
223     if (res != HCF_SUCCESS) {
224         HcfObjDestroy(generator);
225         return res;
226     }
227 
228     HcfDhKeyPairParamsSpec *dhKeyPairSpec =
229         reinterpret_cast<HcfDhKeyPairParamsSpec*>(HcfMalloc(sizeof(HcfDhKeyPairParamsSpec), 0));
230     if (dhKeyPairSpec != nullptr) {
231         dhKeyPairSpec->base.base.algName = dhCommParamsSpec->base.algName;
232         dhKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
233         dhKeyPairSpec->base.p.data = dhCommParamsSpec->p.data;
234         dhKeyPairSpec->base.p.len = dhCommParamsSpec->p.len;
235         dhKeyPairSpec->base.g.data = dhCommParamsSpec->g.data;
236         dhKeyPairSpec->base.g.len = dhCommParamsSpec->g.len;
237         dhKeyPairSpec->base.length = dhCommParamsSpec->length;
238         res = ConstructDhKeyPairBigInt(keyPair, dhKeyPairSpec);
239         if (res != HCF_SUCCESS) {
240             HcfObjDestroy(generator);
241             HcfObjDestroy(keyPair);
242             HcfFree(dhKeyPairSpec);
243             return res;
244         }
245         *spec = reinterpret_cast<HcfAsyKeyParamsSpec *>(dhKeyPairSpec);
246     }
247 
248     HcfObjDestroy(generator);
249     HcfObjDestroy(keyPair);
250     return HCF_SUCCESS;
251 }
252 
ConstructDHPubKeyParamsSpec(const string & algoName,HcfDhCommParamsSpec * comSpec,HcfAsyKeyParamsSpec ** spec)253 static HcfResult ConstructDHPubKeyParamsSpec(const string &algoName, HcfDhCommParamsSpec *comSpec,
254     HcfAsyKeyParamsSpec **spec)
255 {
256     if (comSpec == nullptr) {
257         return HCF_INVALID_PARAMS;
258     }
259     HcfDhPubKeyParamsSpec *dhPubKeySpec = (HcfDhPubKeyParamsSpec*)HcfMalloc(sizeof(HcfDhPubKeyParamsSpec), 0);
260     if (dhPubKeySpec == nullptr) {
261         return HCF_ERR_MALLOC;
262     }
263     HcfAsyKeyGenerator *generator = nullptr;
264     HcfResult res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator);
265     if (res != HCF_SUCCESS) {
266         HcfFree(dhPubKeySpec);
267         return res;
268     }
269     HcfKeyPair *keyPair = nullptr;
270     res = generator->generateKeyPair(generator, nullptr, &keyPair);
271     if (res != HCF_SUCCESS) {
272         HcfObjDestroy(generator);
273         HcfFree(dhPubKeySpec);
274         return res;
275     }
276     HcfBigInteger retBigInt = { .data = nullptr, .len = 0 };
277     dhPubKeySpec->base.base.algName = comSpec->base.algName;
278     dhPubKeySpec->base.base.specType = HCF_PUBLIC_KEY_SPEC;
279     dhPubKeySpec->base.g = comSpec->g;
280     dhPubKeySpec->base.length = comSpec->length;
281     dhPubKeySpec->base.p = comSpec->p;
282     res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, DH_PK_BN, &retBigInt);
283     if (res != HCF_SUCCESS) {
284         HcfObjDestroy(generator);
285         HcfObjDestroy(keyPair);
286         HcfFree(dhPubKeySpec);
287         return res;
288     }
289     dhPubKeySpec->pk.data = retBigInt.data;
290     dhPubKeySpec->pk.len = retBigInt.len;
291 
292     *spec = reinterpret_cast<HcfAsyKeyParamsSpec *>(dhPubKeySpec);
293     HcfObjDestroy(generator);
294     HcfObjDestroy(keyPair);
295     return HCF_SUCCESS;
296 }
297 
ConstructDHPriKeyParamsSpec(const string & algoName,HcfDhCommParamsSpec * comSpec,HcfAsyKeyParamsSpec ** spec)298 static HcfResult ConstructDHPriKeyParamsSpec(const string &algoName, HcfDhCommParamsSpec *comSpec,
299     HcfAsyKeyParamsSpec **spec)
300 {
301     if (comSpec == nullptr) {
302         return HCF_INVALID_PARAMS;
303     }
304     HcfDhPriKeyParamsSpec *dhPriKeySpec = (HcfDhPriKeyParamsSpec*)HcfMalloc(sizeof(HcfDhPriKeyParamsSpec), 0);
305     if (dhPriKeySpec == nullptr) {
306         return HCF_ERR_MALLOC;
307     }
308     HcfAsyKeyGenerator *generator = nullptr;
309     HcfResult res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator);
310     if (res != HCF_SUCCESS) {
311         HcfFree(dhPriKeySpec);
312         return res;
313     }
314 
315     HcfKeyPair *keyPair = nullptr;
316     res = generator->generateKeyPair(generator, nullptr, &keyPair);
317     if (res != HCF_SUCCESS) {
318         HcfObjDestroy(generator);
319         HcfFree(dhPriKeySpec);
320         return res;
321     }
322     HcfBigInteger retBigInt = { .data = nullptr, .len = 0 };
323     dhPriKeySpec->base.base.algName = comSpec->base.algName;
324     dhPriKeySpec->base.base.specType = HCF_PRIVATE_KEY_SPEC;
325     dhPriKeySpec->base.g = comSpec->g;
326     dhPriKeySpec->base.length = comSpec->length;
327     dhPriKeySpec->base.p = comSpec->p;
328     res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, DH_SK_BN, &retBigInt);
329     if (res != HCF_SUCCESS) {
330         HcfObjDestroy(generator);
331         HcfObjDestroy(keyPair);
332         HcfFree(dhPriKeySpec);
333         return res;
334     }
335     dhPriKeySpec->sk.data = retBigInt.data;
336     dhPriKeySpec->sk.len = retBigInt.len;
337 
338     *spec = reinterpret_cast<HcfAsyKeyParamsSpec *>(dhPriKeySpec);
339     HcfObjDestroy(generator);
340     HcfObjDestroy(keyPair);
341     return HCF_SUCCESS;
342 }
343 
HcfDhKeyUtilCreateTest(const int pLen,const int skLen)344 static HcfResult HcfDhKeyUtilCreateTest(const int pLen, const int skLen)
345 {
346     HcfDhCommParamsSpec *returnCommonParamSpec = nullptr;
347     HcfResult res = HcfDhKeyUtilCreate(pLen, skLen, &returnCommonParamSpec);
348     if (res == HCF_SUCCESS) {
349         FreeDhCommParamsSpec(returnCommonParamSpec);
350     }
351     return res;
352 }
353 
HcfDhKeyUtilErrBranch()354 static void HcfDhKeyUtilErrBranch()
355 {
356     FreeDhCommParamsSpec(nullptr);
357     DestroyDhPubKeySpec(nullptr);
358     DestroyDhPriKeySpec(nullptr);
359     DestroyDhKeyPairSpec(nullptr);
360     FreeEcPointMem(nullptr);
361     DestroyAlg25519PubKeySpec(nullptr);
362     DestroyAlg25519PriKeySpec(nullptr);
363     DestroyAlg25519KeyPairSpec(nullptr);
364     DestroySm2CipherTextSpec(nullptr);
365 }
366 
generateKeyPairTest(HcfKeyPair ** keyPair)367 static HcfResult generateKeyPairTest(HcfKeyPair **keyPair)
368 {
369     HcfAsyKeyParamsSpec *paramSpec = nullptr;
370     HcfResult res = ConstructDHKeyPairParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
371     if (res != HCF_SUCCESS) {
372         return res;
373     }
374     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
375     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
376     if (res != HCF_SUCCESS) {
377         return res;
378     }
379     res = returnObj->generateKeyPair(returnObj, keyPair);
380     if (res != HCF_SUCCESS) {
381         return res;
382     }
383     HcfObjDestroy(returnObj);
384     DestroyTestDhKeyPairSpec(reinterpret_cast<HcfDhKeyPairParamsSpec *>(paramSpec));
385     return HCF_SUCCESS;
386 }
387 
SetUpTestCase()388 void CryptoDHAsyKeyGeneratorBySpecTest::SetUpTestCase()
389 {
390     HcfResult res = ConstructDHKeyCommParamsSpec(PLEN_DH1536, SKLEN_DH1024, &g_dh1536CommSpec);
391     ASSERT_EQ(res, HCF_SUCCESS);
392     res = ConstructDHKeyCommParamsSpec(PLEN_DH2048, SKLEN_DH1024, &g_dh2048CommSpec);
393     ASSERT_EQ(res, HCF_SUCCESS);
394     res = ConstructDHKeyCommParamsSpec(PLEN_DH3072, SKLEN_DH1024, &g_dh3072CommSpec);
395     ASSERT_EQ(res, HCF_SUCCESS);
396     res = ConstructDHKeyCommParamsSpec(PLEN_DH4096, SKLEN_DH1024, &g_dh4096CommSpec);
397     ASSERT_EQ(res, HCF_SUCCESS);
398     res = ConstructDHKeyCommParamsSpec(PLEN_DH6144, SKLEN_DH1024, &g_dh6144CommSpec);
399     ASSERT_EQ(res, HCF_SUCCESS);
400     res = ConstructDHKeyCommParamsSpec(PLEN_DH8192, SKLEN_DH1024, &g_dh8192CommSpec);
401     ASSERT_EQ(res, HCF_SUCCESS);
402     res = generateKeyPairTest(&g_dhKeyPair);
403 }
404 
TearDownTestCase()405 void CryptoDHAsyKeyGeneratorBySpecTest::TearDownTestCase()
406 {
407     FreeDhCommParamsSpec(g_dh1536CommSpec);
408     FreeDhCommParamsSpec(g_dh2048CommSpec);
409     FreeDhCommParamsSpec(g_dh3072CommSpec);
410     FreeDhCommParamsSpec(g_dh4096CommSpec);
411     FreeDhCommParamsSpec(g_dh6144CommSpec);
412     FreeDhCommParamsSpec(g_dh8192CommSpec);
413     HcfObjDestroy(g_dhKeyPair);
414 }
415 
416 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest001_1, TestSize.Level0)
417 {
418     HcfResult res = HcfDhKeyUtilCreateTest(PLEN_DH2048, SKLEN_DH1024);
419     ASSERT_EQ(res, HCF_SUCCESS);
420 }
421 
422 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest001_2, TestSize.Level0)
423 {
424     HcfResult res = HcfDhKeyUtilCreateTest(PLEN_DH3072, SKLEN_DH1024);
425     ASSERT_EQ(res, HCF_SUCCESS);
426 }
427 
428 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest001_3, TestSize.Level0)
429 {
430     HcfResult res = HcfDhKeyUtilCreateTest(PLEN_DH4096, SKLEN_DH1024);
431     ASSERT_EQ(res, HCF_SUCCESS);
432 }
433 
434 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest001_4, TestSize.Level0)
435 {
436     HcfResult res = HcfDhKeyUtilCreateTest(PLEN_DH6144, SKLEN_DH1024);
437     ASSERT_EQ(res, HCF_SUCCESS);
438 }
439 
440 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest001_5, TestSize.Level0)
441 {
442     HcfResult res = HcfDhKeyUtilCreateTest(PLEN_DH8192, SKLEN_DH1024);
443     ASSERT_EQ(res, HCF_SUCCESS);
444 }
445 
446 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest001_6, TestSize.Level0)
447 {
448     HcfResult res = HcfDhKeyUtilCreateTest(PLEN_DH8192, SKLEN_EQZERO);
449     ASSERT_EQ(res, HCF_SUCCESS);
450 }
451 
452 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest002_1, TestSize.Level0)
453 {
454     HcfAsyKeyParamsSpec *paramSpec = nullptr;
455     HcfResult res = ConstructDHKeyPairParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
456     ASSERT_EQ(res, HCF_SUCCESS);
457     ASSERT_NE(paramSpec, nullptr);
458 
459     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
460     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
461     ASSERT_EQ(res, HCF_SUCCESS);
462     ASSERT_NE(returnObj, nullptr);
463 
464     HcfObjDestroy(returnObj);
465     DestroyTestDhKeyPairSpec(reinterpret_cast<HcfDhKeyPairParamsSpec *>(paramSpec));
466 }
467 
468 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest002_2, TestSize.Level0)
469 {
470     HcfAsyKeyParamsSpec *paramSpec = nullptr;
471     HcfResult res = ConstructDHKeyPairParamsSpec(g_dh2048AlgoName, g_dh2048CommSpec, &paramSpec);
472     ASSERT_EQ(res, HCF_SUCCESS);
473     ASSERT_NE(paramSpec, nullptr);
474 
475     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
476     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
477     ASSERT_EQ(res, HCF_SUCCESS);
478     ASSERT_NE(returnObj, nullptr);
479 
480     HcfObjDestroy(returnObj);
481     DestroyTestDhKeyPairSpec(reinterpret_cast<HcfDhKeyPairParamsSpec *>(paramSpec));
482 }
483 
484 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest002_3, TestSize.Level0)
485 {
486     HcfAsyKeyParamsSpec *paramSpec = nullptr;
487     HcfResult res = ConstructDHKeyPairParamsSpec(g_dh3072AlgoName, g_dh3072CommSpec, &paramSpec);
488     ASSERT_EQ(res, HCF_SUCCESS);
489     ASSERT_NE(paramSpec, nullptr);
490 
491     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
492     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
493     ASSERT_EQ(res, HCF_SUCCESS);
494     ASSERT_NE(returnObj, nullptr);
495 
496     HcfObjDestroy(returnObj);
497     DestroyTestDhKeyPairSpec(reinterpret_cast<HcfDhKeyPairParamsSpec *>(paramSpec));
498 }
499 
500 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest002_4, TestSize.Level0)
501 {
502     HcfAsyKeyParamsSpec *paramSpec = nullptr;
503     HcfResult res = ConstructDHKeyPairParamsSpec(g_dh4096AlgoName, g_dh4096CommSpec, &paramSpec);
504     ASSERT_EQ(res, HCF_SUCCESS);
505     ASSERT_NE(paramSpec, nullptr);
506 
507     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
508     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
509     ASSERT_EQ(res, HCF_SUCCESS);
510     ASSERT_NE(returnObj, nullptr);
511 
512     HcfObjDestroy(returnObj);
513     DestroyTestDhKeyPairSpec(reinterpret_cast<HcfDhKeyPairParamsSpec *>(paramSpec));
514 }
515 
516 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest002_5, TestSize.Level0)
517 {
518     HcfAsyKeyParamsSpec *paramSpec = nullptr;
519     HcfResult res = ConstructDHKeyPairParamsSpec(g_dh6144AlgoName, g_dh6144CommSpec, &paramSpec);
520     ASSERT_EQ(res, HCF_SUCCESS);
521     ASSERT_NE(paramSpec, nullptr);
522 
523     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
524     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
525     ASSERT_EQ(res, HCF_SUCCESS);
526     ASSERT_NE(returnObj, nullptr);
527 
528     HcfObjDestroy(returnObj);
529     DestroyTestDhKeyPairSpec(reinterpret_cast<HcfDhKeyPairParamsSpec *>(paramSpec));
530 }
531 
532 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest002_6, TestSize.Level0)
533 {
534     HcfAsyKeyParamsSpec *paramSpec = nullptr;
535     HcfResult res = ConstructDHKeyPairParamsSpec(g_dh8192AlgoName, g_dh8192CommSpec, &paramSpec);
536     ASSERT_EQ(res, HCF_SUCCESS);
537     ASSERT_NE(paramSpec, nullptr);
538 
539     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
540     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
541     ASSERT_EQ(res, HCF_SUCCESS);
542     ASSERT_NE(returnObj, nullptr);
543 
544     HcfObjDestroy(returnObj);
545     DestroyTestDhKeyPairSpec(reinterpret_cast<HcfDhKeyPairParamsSpec *>(paramSpec));
546 }
547 
548 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest003, TestSize.Level0)
549 {
550     HcfAsyKeyParamsSpec *paramSpec = nullptr;
551     HcfResult res = ConstructDHKeyPairParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
552     ASSERT_EQ(res, HCF_SUCCESS);
553     ASSERT_NE(paramSpec, nullptr);
554 
555     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
556     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
557     ASSERT_EQ(res, HCF_SUCCESS);
558     ASSERT_NE(returnObj, nullptr);
559 
560     const char *className = returnObj->base.getClass();
561     ASSERT_NE(className, nullptr);
562 
563     HcfObjDestroy(returnObj);
564     DestroyTestDhKeyPairSpec(reinterpret_cast<HcfDhKeyPairParamsSpec *>(paramSpec));
565 }
566 
567 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest004, TestSize.Level0)
568 {
569     HcfAsyKeyParamsSpec *paramSpec = nullptr;
570     HcfResult res = ConstructDHKeyPairParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
571     ASSERT_EQ(res, HCF_SUCCESS);
572     ASSERT_NE(paramSpec, nullptr);
573 
574     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
575     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
576     ASSERT_EQ(res, HCF_SUCCESS);
577     ASSERT_NE(returnObj, nullptr);
578 
579     returnObj->base.destroy(&(returnObj->base));
580     DestroyTestDhKeyPairSpec(reinterpret_cast<HcfDhKeyPairParamsSpec *>(paramSpec));
581 }
582 
583 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest005, TestSize.Level0)
584 {
585     HcfAsyKeyParamsSpec *paramSpec = nullptr;
586     HcfResult res = ConstructDHKeyPairParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
587     ASSERT_EQ(res, HCF_SUCCESS);
588     ASSERT_NE(paramSpec, nullptr);
589 
590     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
591     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
592     ASSERT_EQ(res, HCF_SUCCESS);
593     ASSERT_NE(returnObj, nullptr);
594 
595     const char * algName = returnObj->getAlgName(returnObj);
596     ASSERT_EQ(algName, g_dhAlgoName);
597 
598     HcfObjDestroy(returnObj);
599     DestroyTestDhKeyPairSpec(reinterpret_cast<HcfDhKeyPairParamsSpec *>(paramSpec));
600 }
601 
602 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest006, TestSize.Level0)
603 {
604     HcfKeyPair *keyPair = nullptr;
605     HcfResult res = generateKeyPairTest(&keyPair);
606     ASSERT_EQ(res, HCF_SUCCESS);
607     ASSERT_NE(keyPair, nullptr);
608 
609     HcfObjDestroy(keyPair);
610 }
611 
612 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest007, TestSize.Level0)
613 {
614     const char *className = g_dhKeyPair->base.getClass();
615     ASSERT_NE(className, nullptr);
616 }
617 
618 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest008, TestSize.Level0)
619 {
620     HcfKeyPair *keyPair = nullptr;
621     HcfResult res = generateKeyPairTest(&keyPair);
622     ASSERT_EQ(res, HCF_SUCCESS);
623     ASSERT_NE(keyPair, nullptr);
624 
625     keyPair->base.destroy(&(keyPair->base));
626 }
627 
628 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest009, TestSize.Level0)
629 {
630     const char *className = g_dhKeyPair->pubKey->base.base.getClass();
631     ASSERT_NE(className, nullptr);
632 }
633 
634 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest010, TestSize.Level0)
635 {
636     HcfKeyPair *keyPair = nullptr;
637     HcfResult res = generateKeyPairTest(&keyPair);
638     ASSERT_EQ(res, HCF_SUCCESS);
639     ASSERT_NE(keyPair, nullptr);
640 
641     keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
642     keyPair->pubKey = nullptr;
643 
644     HcfObjDestroy(keyPair);
645 }
646 
647 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest011, TestSize.Level0)
648 {
649     const char *algorithmName = g_dhKeyPair->pubKey->base.getAlgorithm(&(g_dhKeyPair->pubKey->base));
650     ASSERT_EQ(algorithmName, g_dhAlgoName);
651 
652     HcfBlob blob = { .data = nullptr, .len = 0 };
653     HcfResult res = g_dhKeyPair->pubKey->base.getEncoded(&(g_dhKeyPair->pubKey->base), &blob);
654     ASSERT_EQ(res, HCF_SUCCESS);
655     ASSERT_NE(blob.data, nullptr);
656     ASSERT_NE(blob.len, 0);
657 
658     HcfFree(blob.data);
659     const char *formatName = g_dhKeyPair->pubKey->base.getFormat(&(g_dhKeyPair->pubKey->base));
660     ASSERT_EQ(formatName, g_dhpubkeyformatName);
661 }
662 
663 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest012, TestSize.Level0)
664 {
665     const char *className = g_dhKeyPair->priKey->base.base.getClass();
666     ASSERT_NE(className, nullptr);
667 }
668 
669 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest013, TestSize.Level0)
670 {
671     HcfKeyPair *keyPair = nullptr;
672     HcfResult res = generateKeyPairTest(&keyPair);
673     ASSERT_EQ(res, HCF_SUCCESS);
674     ASSERT_NE(keyPair, nullptr);
675 
676     keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
677     keyPair->priKey = nullptr;
678 
679     HcfObjDestroy(keyPair);
680 }
681 
682 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest014, TestSize.Level0)
683 {
684     const char *algorithmName = g_dhKeyPair->priKey->base.getAlgorithm(&(g_dhKeyPair->priKey->base));
685     ASSERT_EQ(algorithmName, g_dhAlgoName);
686 
687     HcfBlob blob = { .data = nullptr, .len = 0 };
688     HcfResult res = g_dhKeyPair->priKey->base.getEncoded(&(g_dhKeyPair->priKey->base), &blob);
689     ASSERT_EQ(res, HCF_SUCCESS);
690     ASSERT_NE(blob.data, nullptr);
691     ASSERT_NE(blob.len, 0);
692     HcfFree(blob.data);
693     const char *formatName = g_dhKeyPair->priKey->base.getFormat(&(g_dhKeyPair->priKey->base));
694     ASSERT_EQ(formatName, g_dhprikeyformatName);
695 }
696 
697 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest015, TestSize.Level0)
698 {
699     HcfKeyPair *keyPair = nullptr;
700     HcfResult res = generateKeyPairTest(&keyPair);
701     ASSERT_EQ(res, HCF_SUCCESS);
702     ASSERT_NE(keyPair, nullptr);
703 
704     keyPair->priKey->clearMem(keyPair->priKey);
705     HcfBlob blob = { .data = nullptr, .len = 0 };
706     res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
707     ASSERT_EQ(res, HCF_ERR_CRYPTO_OPERATION);
708     ASSERT_EQ(blob.data, nullptr);
709     ASSERT_EQ(blob.len, 0);
710     HcfFree(blob.data);
711     HcfObjDestroy(keyPair);
712 }
713 
714 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest016, TestSize.Level0)
715 {
716     HcfAsyKeyParamsSpec *paramSpec = nullptr;
717     HcfResult res = ConstructDHPubKeyParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
718     ASSERT_EQ(res, HCF_SUCCESS);
719     ASSERT_NE(paramSpec, nullptr);
720 
721     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
722     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
723     ASSERT_EQ(res, HCF_SUCCESS);
724     ASSERT_NE(returnObj, nullptr);
725 
726     HcfPubKey *pubKey = nullptr;
727     res = returnObj->generatePubKey(returnObj, &pubKey);
728     ASSERT_EQ(res, HCF_SUCCESS);
729     ASSERT_NE(pubKey, nullptr);
730 
731     HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
732     res = pubKey->getAsyKeySpecBigInteger(pubKey, DH_P_BN, &returnBigInteger);
733     ASSERT_EQ(res, HCF_SUCCESS);
734     ASSERT_NE(returnBigInteger.data, nullptr);
735     ASSERT_NE(returnBigInteger.len, 0);
736 
737     res = pubKey->getAsyKeySpecBigInteger(pubKey, DH_G_BN, &returnBigInteger);
738     ASSERT_EQ(res, HCF_SUCCESS);
739     ASSERT_NE(returnBigInteger.data, nullptr);
740     ASSERT_NE(returnBigInteger.len, 0);
741 
742     res = pubKey->getAsyKeySpecBigInteger(pubKey, DH_PK_BN, &returnBigInteger);
743     ASSERT_EQ(res, HCF_SUCCESS);
744     ASSERT_NE(returnBigInteger.data, nullptr);
745     ASSERT_NE(returnBigInteger.len, 0);
746     HcfFree(returnBigInteger.data);
747     int32_t returnInt = 0;
748     res = pubKey->getAsyKeySpecInt(pubKey, DH_L_NUM, &returnInt);
749     ASSERT_EQ(res, HCF_NOT_SUPPORT);
750     ASSERT_EQ(returnInt, 0);
751 
752     HcfObjDestroy(pubKey);
753     HcfObjDestroy(returnObj);
754     DestroyTestDhPubKeySpec(reinterpret_cast<HcfDhPubKeyParamsSpec *>(paramSpec));
755 }
756 
757 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest017, TestSize.Level0)
758 {
759     HcfAsyKeyParamsSpec *paramSpec = nullptr;
760     HcfResult res = ConstructDHPriKeyParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
761     ASSERT_EQ(res, HCF_SUCCESS);
762     ASSERT_NE(paramSpec, nullptr);
763 
764     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
765     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
766     ASSERT_EQ(res, HCF_SUCCESS);
767     ASSERT_NE(returnObj, nullptr);
768 
769     HcfPriKey *priKey = nullptr;
770     res = returnObj->generatePriKey(returnObj, &priKey);
771     ASSERT_EQ(res, HCF_SUCCESS);
772     ASSERT_NE(priKey, nullptr);
773 
774     HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
775     res = priKey->getAsyKeySpecBigInteger(priKey, DH_P_BN, &returnBigInteger);
776     ASSERT_EQ(res, HCF_SUCCESS);
777     ASSERT_NE(returnBigInteger.data, nullptr);
778     ASSERT_NE(returnBigInteger.len, 0);
779 
780     res = priKey->getAsyKeySpecBigInteger(priKey, DH_G_BN, &returnBigInteger);
781     ASSERT_EQ(res, HCF_SUCCESS);
782     ASSERT_NE(returnBigInteger.data, nullptr);
783     ASSERT_NE(returnBigInteger.len, 0);
784 
785     res = priKey->getAsyKeySpecBigInteger(priKey, DH_SK_BN, &returnBigInteger);
786     ASSERT_EQ(res, HCF_SUCCESS);
787     ASSERT_NE(returnBigInteger.data, nullptr);
788     ASSERT_NE(returnBigInteger.len, 0);
789     HcfFree(returnBigInteger.data);
790     int32_t returnInt = 0;
791     res = priKey->getAsyKeySpecInt(priKey, DH_L_NUM, &returnInt);
792     ASSERT_EQ(res, HCF_SUCCESS);
793     ASSERT_NE(returnInt, 0);
794 
795     HcfObjDestroy(priKey);
796     HcfObjDestroy(returnObj);
797     DestroyTestDhPriKeySpec(reinterpret_cast<HcfDhPriKeyParamsSpec *>(paramSpec));
798 }
799 
800 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest018, TestSize.Level0)
801 {
802     HcfAsyKeyGenParams params = {
803         .algo = HCF_ALG_DH,
804         .bits = HCF_OPENSSL_DH_MODP_1536,
805         .primes = HCF_OPENSSL_PRIMES_2,
806     };
807 
808     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
809     HcfResult res = HcfAsyKeyGeneratorSpiDhCreate(&params, &returnSpi);
810 
811     ASSERT_EQ(res, HCF_SUCCESS);
812     ASSERT_NE(returnSpi, nullptr);
813 
814     HcfObjDestroy(returnSpi);
815 }
816 
817 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest019, TestSize.Level0)
818 {
819     HcfAsyKeyGenParams params = {
820         .algo = HCF_ALG_DH,
821         .bits = HCF_OPENSSL_DH_MODP_1536,
822         .primes = HCF_OPENSSL_PRIMES_2,
823     };
824 
825     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
826     HcfResult res = HcfAsyKeyGeneratorSpiDhCreate(&params, &returnSpi);
827     ASSERT_EQ(res, HCF_SUCCESS);
828     ASSERT_NE(returnSpi, nullptr);
829 
830     HcfAsyKeyParamsSpec *paramSpec = nullptr;
831     res = ConstructDHKeyPairParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
832     ASSERT_EQ(res, HCF_SUCCESS);
833     ASSERT_NE(paramSpec, nullptr);
834 
835     HcfKeyPair *keyPair = nullptr;
836     res = returnSpi->engineGenerateKeyPairBySpec(returnSpi, paramSpec, &keyPair);
837     ASSERT_EQ(res, HCF_SUCCESS);
838     ASSERT_NE(keyPair, nullptr);
839 
840     HcfObjDestroy(returnSpi);
841     HcfObjDestroy(keyPair);
842     DestroyTestDhKeyPairSpec(reinterpret_cast<HcfDhKeyPairParamsSpec *>(paramSpec));
843 }
844 
845 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest020, TestSize.Level0)
846 {
847     HcfAsyKeyGenParams params = {
848         .algo = HCF_ALG_DH,
849         .bits = HCF_OPENSSL_DH_MODP_1536,
850         .primes = HCF_OPENSSL_PRIMES_2,
851     };
852 
853     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
854     HcfResult res = HcfAsyKeyGeneratorSpiDhCreate(&params, &returnSpi);
855     ASSERT_EQ(res, HCF_SUCCESS);
856     ASSERT_NE(returnSpi, nullptr);
857 
858     HcfAsyKeyParamsSpec *paramSpec = nullptr;
859     res = ConstructDHPubKeyParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
860     ASSERT_EQ(res, HCF_SUCCESS);
861     ASSERT_NE(paramSpec, nullptr);
862 
863     HcfPubKey *pubKey = nullptr;
864     res = returnSpi->engineGeneratePubKeyBySpec(returnSpi, paramSpec, &pubKey);
865     ASSERT_EQ(res, HCF_SUCCESS);
866     ASSERT_NE(pubKey, nullptr);
867 
868     HcfObjDestroy(returnSpi);
869     HcfObjDestroy(pubKey);
870     DestroyTestDhPubKeySpec(reinterpret_cast<HcfDhPubKeyParamsSpec *>(paramSpec));
871 }
872 
873 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest021, TestSize.Level0)
874 {
875     HcfAsyKeyGenParams params = {
876         .algo = HCF_ALG_DH,
877         .bits = HCF_OPENSSL_DH_MODP_1536,
878         .primes = HCF_OPENSSL_PRIMES_2,
879     };
880 
881     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
882     HcfResult res = HcfAsyKeyGeneratorSpiDhCreate(&params, &returnSpi);
883     ASSERT_EQ(res, HCF_SUCCESS);
884     ASSERT_NE(returnSpi, nullptr);
885 
886     HcfAsyKeyParamsSpec *paramSpec = nullptr;
887     res = ConstructDHPriKeyParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
888     ASSERT_EQ(res, HCF_SUCCESS);
889     ASSERT_NE(paramSpec, nullptr);
890 
891     HcfPriKey *priKey = nullptr;
892     res = returnSpi->engineGeneratePriKeyBySpec(returnSpi, paramSpec, &priKey);
893     ASSERT_EQ(res, HCF_SUCCESS);
894     ASSERT_NE(priKey, nullptr);
895 
896     HcfObjDestroy(returnSpi);
897     HcfObjDestroy(priKey);
898     DestroyTestDhPriKeySpec(reinterpret_cast<HcfDhPriKeyParamsSpec *>(paramSpec));
899 }
900 
901 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest022, TestSize.Level0)
902 {
903     HcfAsyKeyParamsSpec *paramSpec = nullptr;
904     HcfResult res = ConstructDHKeyPairParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
905     ASSERT_EQ(res, HCF_SUCCESS);
906     ASSERT_NE(paramSpec, nullptr);
907 
908     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
909     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
910     ASSERT_EQ(res, HCF_SUCCESS);
911     ASSERT_NE(returnObj, nullptr);
912 
913     const char *algName1 = returnObj->getAlgName(nullptr);
914     ASSERT_NE(algName1, g_dhAlgoName.data());
915 
916     const char *algName2 = returnObj->getAlgName((HcfAsyKeyGeneratorBySpec *)&g_obj);
917     ASSERT_NE(algName2, g_dhAlgoName.data());
918 
919     HcfObjDestroy(returnObj);
920     DestroyTestDhKeyPairSpec(reinterpret_cast<HcfDhKeyPairParamsSpec *>(paramSpec));
921 }
922 
923 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest023, TestSize.Level0)
924 {
925     HcfAsyKeyParamsSpec *paramSpec = nullptr;
926     HcfResult res = ConstructDHKeyPairParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
927     ASSERT_EQ(res, HCF_SUCCESS);
928     ASSERT_NE(paramSpec, nullptr);
929 
930     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
931     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
932     ASSERT_EQ(res, HCF_SUCCESS);
933     ASSERT_NE(returnObj, nullptr);
934 
935     HcfKeyPair *keyPair = nullptr;
936     res = returnObj->generateKeyPair(nullptr, &keyPair);
937     ASSERT_EQ(res, HCF_INVALID_PARAMS);
938     ASSERT_EQ(keyPair, nullptr);
939 
940     res = returnObj->generateKeyPair((HcfAsyKeyGeneratorBySpec *)&g_obj, &keyPair);
941     ASSERT_EQ(res, HCF_INVALID_PARAMS);
942     ASSERT_EQ(keyPair, nullptr);
943 
944     HcfObjDestroy(returnObj);
945     HcfObjDestroy(keyPair);
946     DestroyTestDhKeyPairSpec(reinterpret_cast<HcfDhKeyPairParamsSpec *>(paramSpec));
947 }
948 
949 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest024, TestSize.Level0)
950 {
951     const char *algorithmName = g_dhKeyPair->pubKey->base.getAlgorithm(nullptr);
952     ASSERT_EQ(algorithmName, nullptr);
953 
954     const char *algorithmName1 = g_dhKeyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj);
955     ASSERT_EQ(algorithmName1, nullptr);
956 }
957 
958 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest025, TestSize.Level0)
959 {
960     HcfBlob blob = { .data = nullptr, .len = 0 };
961     HcfResult res = g_dhKeyPair->pubKey->base.getEncoded(nullptr, &blob);
962     ASSERT_EQ(res, HCF_INVALID_PARAMS);
963     ASSERT_EQ(blob.data, nullptr);
964     ASSERT_EQ(blob.len, 0);
965 
966     res = g_dhKeyPair->pubKey->base.getEncoded(&(g_dhKeyPair->pubKey->base), nullptr);
967     ASSERT_EQ(res, HCF_INVALID_PARAMS);
968 
969     res = g_dhKeyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob);
970     ASSERT_EQ(res, HCF_INVALID_PARAMS);
971     ASSERT_EQ(blob.data, nullptr);
972     ASSERT_EQ(blob.len, 0);
973     HcfFree(blob.data);
974 }
975 
976 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest026, TestSize.Level0)
977 {
978     const char *formatName = g_dhKeyPair->pubKey->base.getFormat(nullptr);
979     ASSERT_EQ(formatName, nullptr);
980 
981     const char *formatName1 = g_dhKeyPair->pubKey->base.getFormat((HcfKey *)&g_obj);
982     ASSERT_EQ(formatName1, nullptr);
983 }
984 
985 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest027, TestSize.Level0)
986 {
987     const char *algorithmName = g_dhKeyPair->priKey->base.getAlgorithm(nullptr);
988     ASSERT_EQ(algorithmName, nullptr);
989 
990     const char *algorithmName1 = g_dhKeyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj);
991     ASSERT_EQ(algorithmName1, nullptr);
992 }
993 
994 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest028, TestSize.Level0)
995 {
996     HcfBlob blob = { .data = nullptr, .len = 0 };
997     HcfResult res = g_dhKeyPair->priKey->base.getEncoded(nullptr, &blob);
998     ASSERT_EQ(res, HCF_INVALID_PARAMS);
999     ASSERT_EQ(blob.data, nullptr);
1000     ASSERT_EQ(blob.len, 0);
1001 
1002     res = g_dhKeyPair->priKey->base.getEncoded(&(g_dhKeyPair->priKey->base), nullptr);
1003     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1004 
1005     res = g_dhKeyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob);
1006     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1007     ASSERT_EQ(blob.data, nullptr);
1008     ASSERT_EQ(blob.len, 0);
1009     HcfFree(blob.data);
1010 }
1011 
1012 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest029, TestSize.Level0)
1013 {
1014     const char *formatName = g_dhKeyPair->priKey->base.getFormat(nullptr);
1015     ASSERT_EQ(formatName, nullptr);
1016 
1017     const char *formatName1 = g_dhKeyPair->priKey->base.getFormat((HcfKey *)&g_obj);
1018     ASSERT_EQ(formatName1, nullptr);
1019 }
1020 
1021 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest030, TestSize.Level0)
1022 {
1023     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1024     HcfResult res = ConstructDHPubKeyParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
1025     ASSERT_EQ(res, HCF_SUCCESS);
1026     ASSERT_NE(paramSpec, nullptr);
1027 
1028     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1029     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1030     ASSERT_EQ(res, HCF_SUCCESS);
1031     ASSERT_NE(returnObj, nullptr);
1032 
1033     HcfPubKey *pubKey = nullptr;
1034     res = returnObj->generatePubKey(returnObj, &pubKey);
1035     ASSERT_EQ(res, HCF_SUCCESS);
1036     ASSERT_NE(pubKey, nullptr);
1037 
1038     res = pubKey->getAsyKeySpecBigInteger(pubKey, DH_PK_BN, nullptr);
1039     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1040 
1041     HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
1042     res = pubKey->getAsyKeySpecBigInteger(pubKey, X25519_PK_BN, &returnBigInteger);
1043     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1044     ASSERT_EQ(returnBigInteger.data, nullptr);
1045     ASSERT_EQ(returnBigInteger.len, 0);
1046 
1047     res = pubKey->getAsyKeySpecBigInteger((HcfPubKey *)&g_obj, DH_PK_BN, &returnBigInteger);
1048     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1049     ASSERT_EQ(returnBigInteger.data, nullptr);
1050     ASSERT_EQ(returnBigInteger.len, 0);
1051     HcfFree(returnBigInteger.data);
1052     res = pubKey->getAsyKeySpecInt(pubKey, DH_L_NUM, nullptr);
1053     ASSERT_EQ(res, HCF_NOT_SUPPORT);
1054 
1055     int32_t returnInt = 0;
1056     res = pubKey->getAsyKeySpecInt(pubKey, X25519_PK_BN, &returnInt);
1057     ASSERT_EQ(res, HCF_NOT_SUPPORT);
1058     ASSERT_EQ(returnInt, 0);
1059 
1060     res = pubKey->getAsyKeySpecInt((HcfPubKey *)&g_obj, DH_L_NUM, &returnInt);
1061     ASSERT_EQ(res, HCF_NOT_SUPPORT);
1062     ASSERT_EQ(returnInt, 0);
1063 
1064     char *returnString = nullptr;
1065     res = pubKey->getAsyKeySpecString(pubKey, ED25519_SK_BN, &returnString);
1066     ASSERT_EQ(res, HCF_NOT_SUPPORT);
1067     ASSERT_EQ(returnString, nullptr);
1068 
1069     res = pubKey->getAsyKeySpecString(pubKey, ECC_CURVE_NAME_STR, &returnString);
1070     ASSERT_EQ(res, HCF_NOT_SUPPORT);
1071     ASSERT_EQ(returnString, nullptr);
1072 
1073     HcfObjDestroy(pubKey);
1074     HcfObjDestroy(returnObj);
1075     DestroyTestDhPubKeySpec(reinterpret_cast<HcfDhPubKeyParamsSpec *>(paramSpec));
1076 }
1077 
1078 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest031, TestSize.Level0)
1079 {
1080     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1081     HcfResult res = ConstructDHPriKeyParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
1082     ASSERT_EQ(res, HCF_SUCCESS);
1083     ASSERT_NE(paramSpec, nullptr);
1084 
1085     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1086     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1087     ASSERT_EQ(res, HCF_SUCCESS);
1088     ASSERT_NE(returnObj, nullptr);
1089 
1090     HcfPriKey *priKey = nullptr;
1091     res = returnObj->generatePriKey(returnObj, &priKey);
1092     ASSERT_EQ(res, HCF_SUCCESS);
1093     ASSERT_NE(priKey, nullptr);
1094 
1095     res = priKey->getAsyKeySpecBigInteger(priKey, DH_PK_BN, nullptr);
1096     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1097 
1098     HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
1099     res = priKey->getAsyKeySpecBigInteger(priKey, X25519_PK_BN, &returnBigInteger);
1100     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1101     ASSERT_EQ(returnBigInteger.data, nullptr);
1102     ASSERT_EQ(returnBigInteger.len, 0);
1103 
1104     res = priKey->getAsyKeySpecBigInteger((HcfPriKey *)&g_obj, DH_PK_BN, &returnBigInteger);
1105     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1106     ASSERT_EQ(returnBigInteger.data, nullptr);
1107     ASSERT_EQ(returnBigInteger.len, 0);
1108     HcfFree(returnBigInteger.data);
1109     res = priKey->getAsyKeySpecInt(priKey, DH_L_NUM, nullptr);
1110     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1111 
1112     int32_t returnInt = 0;
1113     res = priKey->getAsyKeySpecInt(priKey, X25519_PK_BN, &returnInt);
1114     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1115     ASSERT_EQ(returnInt, 0);
1116 
1117     res = priKey->getAsyKeySpecInt((HcfPriKey *)&g_obj, DH_L_NUM, &returnInt);
1118     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1119     ASSERT_EQ(returnInt, 0);
1120 
1121     char *returnString = nullptr;
1122     res = priKey->getAsyKeySpecString(priKey, ED25519_SK_BN, &returnString);
1123     ASSERT_EQ(res, HCF_NOT_SUPPORT);
1124     ASSERT_EQ(returnString, nullptr);
1125 
1126     res = priKey->getAsyKeySpecString(priKey, ECC_CURVE_NAME_STR, &returnString);
1127     ASSERT_EQ(res, HCF_NOT_SUPPORT);
1128     ASSERT_EQ(returnString, nullptr);
1129 
1130     HcfObjDestroy(priKey);
1131     HcfObjDestroy(returnObj);
1132     DestroyTestDhPriKeySpec(reinterpret_cast<HcfDhPriKeyParamsSpec *>(paramSpec));
1133 }
1134 
1135 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest032, TestSize.Level0)
1136 {
1137     HcfDhCommParamsSpec *returnCommonParamSpec = nullptr;
1138     HcfResult res = HcfDhKeyUtilCreate(INT_MAX, SKLEN_DH1024, &returnCommonParamSpec);
1139     ASSERT_EQ(res, HCF_ERR_MALLOC);
1140 
1141     res = HcfDhKeyUtilCreate(PLEN_LTSK, SKLEN_DH1024, &returnCommonParamSpec);
1142     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1143 
1144     res = HcfDhKeyUtilCreate(INT_MAX, SKLEN_DH1024, nullptr);
1145     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1146 }
1147 
1148 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest033, TestSize.Level0)
1149 {
1150     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1151     HcfResult res = ConstructDHPubKeyParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
1152     ASSERT_EQ(res, HCF_SUCCESS);
1153     ASSERT_NE(paramSpec, nullptr);
1154 
1155     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1156     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1157     ASSERT_EQ(res, HCF_SUCCESS);
1158     ASSERT_NE(returnObj, nullptr);
1159 
1160     HcfKeyPair *keyPair = nullptr;
1161     res = returnObj->generateKeyPair(returnObj, &keyPair);
1162     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1163     ASSERT_EQ(keyPair, nullptr);
1164 
1165     HcfPriKey *priKey = nullptr;
1166     res = returnObj->generatePriKey(returnObj, &priKey);
1167     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1168     ASSERT_EQ(priKey, nullptr);
1169 
1170     HcfObjDestroy(returnObj);
1171     HcfObjDestroy(keyPair);
1172     DestroyTestDhPubKeySpec(reinterpret_cast<HcfDhPubKeyParamsSpec *>(paramSpec));
1173 }
1174 
1175 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest034, TestSize.Level0)
1176 {
1177     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1178     HcfResult res = ConstructDHPriKeyParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
1179     ASSERT_EQ(res, HCF_SUCCESS);
1180     ASSERT_NE(paramSpec, nullptr);
1181 
1182     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1183     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1184     ASSERT_EQ(res, HCF_SUCCESS);
1185     ASSERT_NE(returnObj, nullptr);
1186 
1187     HcfKeyPair *keyPair = nullptr;
1188     res = returnObj->generateKeyPair(returnObj, &keyPair);
1189     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1190     ASSERT_EQ(keyPair, nullptr);
1191 
1192     HcfPubKey *pubKey = nullptr;
1193     res = returnObj->generatePubKey(returnObj, &pubKey);
1194     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1195     ASSERT_EQ(pubKey, nullptr);
1196 
1197     HcfObjDestroy(returnObj);
1198     HcfObjDestroy(keyPair);
1199     DestroyTestDhPriKeySpec(reinterpret_cast<HcfDhPriKeyParamsSpec *>(paramSpec));
1200 }
1201 
1202 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest035, TestSize.Level0)
1203 {
1204     HcfAsyKeyGenParams params = {
1205         .algo = HCF_ALG_DH,
1206         .bits = HCF_OPENSSL_DH_MODP_1536,
1207         .primes = HCF_OPENSSL_PRIMES_2,
1208     };
1209 
1210     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
1211     HcfResult res = HcfAsyKeyGeneratorSpiDhCreate(&params, &returnSpi);
1212     ASSERT_EQ(res, HCF_SUCCESS);
1213     ASSERT_NE(returnSpi, nullptr);
1214 
1215     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1216     res = ConstructDHKeyPairParamsCommonSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
1217     ASSERT_EQ(res, HCF_SUCCESS);
1218     ASSERT_NE(paramSpec, nullptr);
1219 
1220     HcfKeyPair *keyPair = nullptr;
1221     res = returnSpi->engineGenerateKeyPairBySpec(returnSpi, paramSpec, &keyPair);
1222     ASSERT_EQ(res, HCF_SUCCESS);
1223     ASSERT_NE(keyPair, nullptr);
1224 
1225     HcfObjDestroy(returnSpi);
1226     HcfObjDestroy(keyPair);
1227     DestroyTestDhKeyPairSpec(reinterpret_cast<HcfDhKeyPairParamsSpec *>(paramSpec));
1228 }
1229 
1230 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest036, TestSize.Level0)
1231 {
1232     HcfAsyKeyGenParams params = {
1233         .algo = HCF_ALG_DH,
1234         .bits = HCF_OPENSSL_DH_MODP_1536,
1235         .primes = HCF_OPENSSL_PRIMES_2,
1236     };
1237 
1238     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
1239     HcfResult res = HcfAsyKeyGeneratorSpiDhCreate(&params, &returnSpi);
1240 
1241     ASSERT_EQ(res, HCF_SUCCESS);
1242     ASSERT_NE(returnSpi, nullptr);
1243 
1244     returnSpi->base.destroy(nullptr);
1245     returnSpi->base.destroy(&g_obj);
1246     HcfObjDestroy(returnSpi);
1247 }
1248 
1249 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest037, TestSize.Level0)
1250 {
1251     HcfAsyKeyGenParams params = {
1252         .algo = HCF_ALG_DH,
1253         .bits = HCF_OPENSSL_DH_MODP_1536,
1254         .primes = HCF_OPENSSL_PRIMES_2,
1255     };
1256 
1257     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
1258     HcfResult res = HcfAsyKeyGeneratorSpiDhCreate(&params, &returnSpi);
1259     ASSERT_EQ(res, HCF_SUCCESS);
1260     ASSERT_NE(returnSpi, nullptr);
1261 
1262     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1263     res = ConstructDHKeyPairParamsCommonSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
1264     ASSERT_EQ(res, HCF_SUCCESS);
1265     ASSERT_NE(paramSpec, nullptr);
1266 
1267     res = returnSpi->engineGenerateKeyPairBySpec(returnSpi, paramSpec, nullptr);
1268     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1269 
1270     HcfKeyPair *keyPair = nullptr;
1271     res = returnSpi->engineGenerateKeyPairBySpec((HcfAsyKeyGeneratorSpi *)&g_obj, paramSpec, &keyPair);
1272     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1273     ASSERT_EQ(keyPair, nullptr);
1274 
1275     HcfAsyKeyParamsSpec *paramSpec1 = nullptr;
1276     res = ConstructAlg25519KeyPairParamsSpec("Ed25519", true, &paramSpec1);
1277     ASSERT_EQ(res, HCF_SUCCESS);
1278     ASSERT_NE(paramSpec1, nullptr);
1279 
1280     HcfKeyPair *keyPair1 = nullptr;
1281     res = returnSpi->engineGenerateKeyPairBySpec(returnSpi, paramSpec1, &keyPair1);
1282     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1283     ASSERT_EQ(keyPair1, nullptr);
1284 
1285     HcfObjDestroy(returnSpi);
1286     HcfObjDestroy(keyPair);
1287     HcfObjDestroy(keyPair1);
1288     DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec1));
1289     DestroyTestDhKeyPairSpec(reinterpret_cast<HcfDhKeyPairParamsSpec *>(paramSpec));
1290 }
1291 
1292 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest038, TestSize.Level0)
1293 {
1294     HcfAsyKeyGenParams params = {
1295         .algo = HCF_ALG_DH,
1296         .bits = HCF_OPENSSL_DH_MODP_2048,
1297         .primes = HCF_OPENSSL_PRIMES_2,
1298     };
1299 
1300     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
1301     HcfResult res = HcfAsyKeyGeneratorSpiDhCreate(&params, &returnSpi);
1302     ASSERT_EQ(res, HCF_SUCCESS);
1303     ASSERT_NE(returnSpi, nullptr);
1304 
1305     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1306     res = ConstructDHPubKeyParamsSpec(g_dh2048AlgoName, g_dh2048CommSpec, &paramSpec);
1307     ASSERT_EQ(res, HCF_SUCCESS);
1308     ASSERT_NE(paramSpec, nullptr);
1309 
1310     res = returnSpi->engineGeneratePubKeyBySpec(returnSpi, paramSpec, nullptr);
1311     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1312 
1313     HcfPubKey *pubKey = nullptr;
1314     res = returnSpi->engineGeneratePubKeyBySpec((HcfAsyKeyGeneratorSpi *)&g_obj, paramSpec, &pubKey);
1315     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1316     ASSERT_EQ(pubKey, nullptr);
1317 
1318     HcfAsyKeyParamsSpec *paramSpec1 = nullptr;
1319     res = ConstructAlg25519PubKeyParamsSpec("Ed25519", true, &paramSpec1);
1320     ASSERT_EQ(res, HCF_SUCCESS);
1321     ASSERT_NE(paramSpec1, nullptr);
1322 
1323     HcfPubKey *pubKey1 = nullptr;
1324     res = returnSpi->engineGeneratePubKeyBySpec(returnSpi, paramSpec1, &pubKey1);
1325     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1326     ASSERT_EQ(pubKey1, nullptr);
1327 
1328     HcfObjDestroy(returnSpi);
1329     HcfObjDestroy(pubKey);
1330     HcfObjDestroy(pubKey1);
1331     DestroyTestDhPubKeySpec(reinterpret_cast<HcfDhPubKeyParamsSpec *>(paramSpec));
1332     DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramSpec1));
1333 }
1334 
1335 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest039, TestSize.Level0)
1336 {
1337     HcfAsyKeyGenParams params = {
1338         .algo = HCF_ALG_DH,
1339         .bits = HCF_OPENSSL_DH_MODP_3072,
1340         .primes = HCF_OPENSSL_PRIMES_2,
1341     };
1342 
1343     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
1344     HcfResult res = HcfAsyKeyGeneratorSpiDhCreate(&params, &returnSpi);
1345     ASSERT_EQ(res, HCF_SUCCESS);
1346     ASSERT_NE(returnSpi, nullptr);
1347 
1348     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1349     res = ConstructDHPriKeyParamsSpec(g_dh3072AlgoName, g_dh3072CommSpec, &paramSpec);
1350     ASSERT_EQ(res, HCF_SUCCESS);
1351     ASSERT_NE(paramSpec, nullptr);
1352 
1353     res = returnSpi->engineGeneratePriKeyBySpec(returnSpi, paramSpec, nullptr);
1354     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1355 
1356     HcfPriKey *priKey = nullptr;
1357     res = returnSpi->engineGeneratePriKeyBySpec((HcfAsyKeyGeneratorSpi *)&g_obj, paramSpec, &priKey);
1358     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1359     ASSERT_EQ(priKey, nullptr);
1360 
1361     HcfAsyKeyParamsSpec *paramSpec1 = nullptr;
1362     res = ConstructAlg25519PriKeyParamsSpec("Ed25519", true, &paramSpec1);
1363     ASSERT_EQ(res, HCF_SUCCESS);
1364     ASSERT_NE(paramSpec1, nullptr);
1365 
1366     HcfPriKey *priKey1 = nullptr;
1367     res = returnSpi->engineGeneratePriKeyBySpec(returnSpi, paramSpec1, &priKey1);
1368     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1369     ASSERT_EQ(priKey1, nullptr);
1370 
1371     HcfObjDestroy(returnSpi);
1372     HcfObjDestroy(priKey);
1373     HcfObjDestroy(priKey1);
1374     DestroyTestDhPriKeySpec(reinterpret_cast<HcfDhPriKeyParamsSpec *>(paramSpec));
1375     DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramSpec1));
1376 }
1377 
1378 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest040, TestSize.Level0)
1379 {
1380     HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
1381     HcfResult res = HcfAsyKeyGeneratorSpiDhCreate(nullptr, &returnSpi);
1382 
1383     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1384     ASSERT_EQ(returnSpi, nullptr);
1385 
1386     HcfObjDestroy(returnSpi);
1387 }
1388 
OpensslMockTestFunc(uint32_t mallocCount,HcfAsyKeyParamsSpec * paramSpec)1389 static void OpensslMockTestFunc(uint32_t mallocCount, HcfAsyKeyParamsSpec *paramSpec)
1390 {
1391     for (uint32_t i = 0; i < mallocCount; i++) {
1392         ResetOpensslCallNum();
1393         SetOpensslCallMockIndex(i);
1394         HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1395         HcfResult res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1396         if (res != HCF_SUCCESS) {
1397             continue;
1398         }
1399 
1400         HcfKeyPair *keyPair = nullptr;
1401         res = returnObj->generateKeyPair(returnObj, &keyPair);
1402         if (res != HCF_SUCCESS) {
1403             continue;
1404         }
1405 
1406         HcfObjDestroy(returnObj);
1407         HcfObjDestroy(keyPair);
1408     }
1409 }
1410 
1411 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest041, TestSize.Level0)
1412 {
1413     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1414     HcfResult res = ConstructDHKeyPairParamsCommonSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
1415     ASSERT_EQ(res, HCF_SUCCESS);
1416     ASSERT_NE(paramSpec, nullptr);
1417     StartRecordOpensslCallNum();
1418 
1419     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1420     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1421     ASSERT_EQ(res, HCF_SUCCESS);
1422     ASSERT_NE(returnObj, nullptr);
1423 
1424     HcfKeyPair *keyPair = nullptr;
1425     res = returnObj->generateKeyPair(returnObj, &keyPair);
1426     ASSERT_EQ(res, HCF_SUCCESS);
1427     ASSERT_NE(keyPair, nullptr);
1428 
1429     HcfObjDestroy(returnObj);
1430     HcfObjDestroy(keyPair);
1431 
1432     uint32_t mallocCount = GetOpensslCallNum();
1433     OpensslMockTestFunc(mallocCount, paramSpec);
1434 
1435     EndRecordOpensslCallNum();
1436     DestroyTestDhKeyPairSpec(reinterpret_cast<HcfDhKeyPairParamsSpec *>(paramSpec));
1437 }
1438 
OpensslMockTestFunc1(uint32_t mallocCount)1439 static void OpensslMockTestFunc1(uint32_t mallocCount)
1440 {
1441     for (uint32_t i = 0; i < mallocCount; i++) {
1442         ResetOpensslCallNum();
1443         SetOpensslCallMockIndex(i);
1444 
1445         HcfResult res = HcfDhKeyUtilCreateTest(PLEN_DH4096, SKLEN_DH1024);
1446         if (res != HCF_SUCCESS) {
1447             continue;
1448         }
1449     }
1450 }
1451 
1452 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest042, TestSize.Level0)
1453 {
1454     StartRecordOpensslCallNum();
1455     HcfResult res = HcfDhKeyUtilCreateTest(PLEN_DH4096, SKLEN_DH1024);
1456     ASSERT_EQ(res, HCF_SUCCESS);
1457 
1458     uint32_t mallocCount = GetOpensslCallNum();
1459     OpensslMockTestFunc1(mallocCount);
1460 
1461     EndRecordOpensslCallNum();
1462 }
1463 
1464 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest043, TestSize.Level0)
1465 {
1466     HcfResult res = HcfDhCommonParamSpecCreate(PLEN_DH4096, SKLEN_DH1024, nullptr);
1467     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1468 }
1469 
OpensslMockTestFunc2(uint32_t mallocCount)1470 static void OpensslMockTestFunc2(uint32_t mallocCount)
1471 {
1472     for (uint32_t i = 0; i < mallocCount; i++) {
1473         ResetOpensslCallNum();
1474         SetOpensslCallMockIndex(i);
1475 
1476         HcfResult res = HcfDhKeyUtilCreateTest(PLEN_DH512, SKLEN_DH128);
1477         if (res != HCF_SUCCESS) {
1478             continue;
1479         }
1480     }
1481 }
1482 
1483 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest044, TestSize.Level0)
1484 {
1485     StartRecordOpensslCallNum();
1486     HcfResult res = HcfDhKeyUtilCreateTest(PLEN_DH512, SKLEN_DH128);
1487     ASSERT_EQ(res, HCF_SUCCESS);
1488 
1489     uint32_t mallocCount = GetOpensslCallNum();
1490     OpensslMockTestFunc2(mallocCount);
1491 
1492     EndRecordOpensslCallNum();
1493 }
1494 
1495 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest045, TestSize.Level0)
1496 {
1497     HcfResult res = HcfDhKeyUtilCreateTest(PLEN_DH2048, SKLEN_DH223);
1498     ASSERT_EQ(res, HCF_ERR_MALLOC);
1499 
1500     res = HcfDhKeyUtilCreateTest(PLEN_DH3072, SKLEN_DH255);
1501     ASSERT_EQ(res, HCF_ERR_MALLOC);
1502 
1503     res = HcfDhKeyUtilCreateTest(PLEN_DH4096, SKLEN_DH303);
1504     ASSERT_EQ(res, HCF_ERR_MALLOC);
1505 
1506     res = HcfDhKeyUtilCreateTest(PLEN_DH6144, SKLEN_DH351);
1507     ASSERT_EQ(res, HCF_ERR_MALLOC);
1508 
1509     res = HcfDhKeyUtilCreateTest(PLEN_DH8192, SKLEN_DH399);
1510     ASSERT_EQ(res, HCF_ERR_MALLOC);
1511 }
1512 
1513 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest046, TestSize.Level0)
1514 {
1515     HcfAsyKeyParamsSpec *paramSpec = nullptr;
1516     HcfResult res = ConstructDHPriKeyParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, &paramSpec);
1517     ASSERT_EQ(res, HCF_SUCCESS);
1518     ASSERT_NE(paramSpec, nullptr);
1519 
1520     HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
1521     res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &returnObj);
1522     ASSERT_EQ(res, HCF_SUCCESS);
1523     ASSERT_NE(returnObj, nullptr);
1524 
1525     HcfPriKey *priKey = nullptr;
1526     res = returnObj->generatePriKey(returnObj, &priKey);
1527     ASSERT_EQ(res, HCF_SUCCESS);
1528     ASSERT_NE(priKey, nullptr);
1529 
1530     HcfBlob blob = { .data = nullptr, .len = 0 };
1531     res = priKey->base.getEncoded(&(priKey->base), &blob);
1532     ASSERT_EQ(res, HCF_SUCCESS);
1533     ASSERT_NE(blob.data, nullptr);
1534     ASSERT_NE(blob.len, 0);
1535 
1536     HcfAsyKeyGenerator *generator = nullptr;
1537     res = HcfAsyKeyGeneratorCreate("DH_modp1536", &generator);
1538     ASSERT_EQ(res, HCF_SUCCESS);
1539 
1540     HcfKeyPair *keyPair = nullptr;
1541     res = generator->convertKey(generator, nullptr, nullptr, &blob, &keyPair);
1542     ASSERT_EQ(res, HCF_SUCCESS);
1543     ASSERT_NE(keyPair, nullptr);
1544 
1545     HcfFree(blob.data);
1546     HcfObjDestroy(returnObj);
1547     HcfObjDestroy(generator);
1548     HcfObjDestroy(priKey);
1549     HcfObjDestroy(keyPair);
1550     DestroyTestDhPriKeySpec(reinterpret_cast<HcfDhPriKeyParamsSpec *>(paramSpec));
1551 }
1552 
1553 HWTEST_F(CryptoDHAsyKeyGeneratorBySpecTest, CryptoDHAsyKeyGeneratorBySpecTest047, TestSize.Level0)
1554 {
1555     HcfDhKeyUtilErrBranch();
1556     HcfResult res = HcfDhKeyUtilCreateTest(PLEN_DH10001, SKLEN_EQZERO);
1557     ASSERT_EQ(res, HCF_ERR_MALLOC);
1558 
1559     res = HcfDhKeyUtilCreateTest(PLEN_DH511, SKLEN_EQZERO);
1560     ASSERT_EQ(res, HCF_ERR_MALLOC);
1561 }
1562 }