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 <openssl/dh.h>
18 #include <openssl/evp.h>
19 #include "securec.h"
20 
21 #include "asy_key_generator.h"
22 #include "alg_25519_asy_key_generator_openssl.h"
23 #include "detailed_alg_25519_key_params.h"
24 #include "key_agreement.h"
25 #include "ecc_key_util.h"
26 #include "params_parser.h"
27 #include "dh_asy_key_generator_openssl.h"
28 #include "detailed_dh_key_params.h"
29 #include "dh_key_util.h"
30 #include "dh_openssl.h"
31 #include "memory.h"
32 #include "memory_mock.h"
33 #include "openssl_adapter_mock.h"
34 #include "dh_openssl_common.h"
35 #include "openssl_class.h"
36 
37 using namespace std;
38 using namespace testing::ext;
39 
40 namespace {
41 constexpr int SKLEN_DH128 = 128;
42 constexpr int SKLEN_DH512 = 512;
43 constexpr int SKLEN_DH1024 = 1024;
44 constexpr int PLEN_DH512 = 512;
45 constexpr int PLEN_DH2048 = 2048;
46 
47 class CryptoDHKeyAgreementTest : public testing::Test {
48 public:
49     static void SetUpTestCase();
50     static void TearDownTestCase();
51     void SetUp();
52     void TearDown();
53 
54     static HcfKeyPair *dh1536KeyPair_;
55     static HcfKeyPair *dh3072KeyPair1_;
56     static HcfKeyPair *dh3072KeyPair2_;
57 };
58 
59 HcfKeyPair *CryptoDHKeyAgreementTest::dh1536KeyPair_ = nullptr;
60 HcfKeyPair *CryptoDHKeyAgreementTest::dh3072KeyPair1_ = nullptr;
61 HcfKeyPair *CryptoDHKeyAgreementTest::dh3072KeyPair2_ = nullptr;
62 
63 static string g_dh1536AlgoName = "DH_modp1536";
64 static string g_dh3072AlgoName = "DH_modp3072";
65 
SetUp()66 void CryptoDHKeyAgreementTest::SetUp() {}
TearDown()67 void CryptoDHKeyAgreementTest::TearDown() {}
68 
GetMockClass(void)69 static const char *GetMockClass(void)
70 {
71     return "HcfSymKeyGenerator";
72 }
73 
74 static HcfObjectBase g_obj = {
75     .getClass = GetMockClass,
76     .destroy = nullptr
77 };
78 
HcfKeyAgreementCreateTest(const char * algName)79 static HcfResult HcfKeyAgreementCreateTest(const char *algName)
80 {
81     HcfKeyAgreement *keyAgreement = nullptr;
82     HcfResult res = HcfKeyAgreementCreate(algName, &keyAgreement);
83     if (res == HCF_SUCCESS) {
84         HcfObjDestroy(keyAgreement);
85     }
86     return res;
87 }
88 
ExchangekeyAgreementWithDiffSkLen(const int pLen,const int skLen,const int size)89 static HcfResult ExchangekeyAgreementWithDiffSkLen(const int pLen, const int skLen, const int size)
90 {
91     HcfResult res = HCF_ERR_CRYPTO_OPERATION;
92     HcfDhCommParamsSpec *paramSpec = nullptr;
93     HcfAsyKeyGeneratorBySpec *generator = nullptr;
94     HcfKeyPair *keyPair = nullptr;
95     HcfDhCommParamsSpec *paramSpec1 = nullptr;
96     HcfAsyKeyGeneratorBySpec *generator1 = nullptr;
97     HcfKeyPair *keyPair1 = nullptr;
98     HcfBlob out = { .data = nullptr, .len = 0 };
99     HcfKeyAgreement *keyAgreement = nullptr;
100     do {
101         if (HcfDhKeyUtilCreate(pLen, skLen, &paramSpec) != HCF_SUCCESS) {
102             break;
103         }
104         if (HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(paramSpec), &generator)
105             != HCF_SUCCESS) {
106             break;
107         }
108         if (generator->generateKeyPair(generator, &keyPair) != HCF_SUCCESS) {
109             break;
110         }
111         if (HcfDhKeyUtilCreate(pLen, size, &paramSpec1) != HCF_SUCCESS) {
112             break;
113         }
114         if (HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(paramSpec1), &generator1)
115             != HCF_SUCCESS) {
116             break;
117         }
118         if (generator1->generateKeyPair(generator1, &keyPair1) != HCF_SUCCESS) {
119             break;
120         }
121         if (HcfKeyAgreementCreate("DH", &keyAgreement) != HCF_SUCCESS) {
122             break;
123         }
124         if (keyAgreement->generateSecret(keyAgreement, keyPair->priKey, keyPair1->pubKey, &out) != HCF_SUCCESS) {
125             break;
126         }
127         if (keyAgreement->generateSecret(keyAgreement, keyPair1->priKey, keyPair->pubKey, &out) != HCF_SUCCESS) {
128             break;
129         }
130         res = HCF_SUCCESS;
131     } while (0);
132     HcfFree(out.data);
133     HcfObjDestroy(keyAgreement);
134     HcfObjDestroy(generator);
135     HcfObjDestroy(generator1);
136     HcfObjDestroy(keyPair);
137     HcfObjDestroy(keyPair1);
138     return res;
139 }
140 
SetUpTestCase()141 void CryptoDHKeyAgreementTest::SetUpTestCase()
142 {
143     HcfAsyKeyGenerator *generator = nullptr;
144     int32_t res = HcfAsyKeyGeneratorCreate("DH_modp1536", &generator);
145     ASSERT_EQ(res, HCF_SUCCESS);
146     ASSERT_NE(generator, nullptr);
147 
148     HcfKeyPair *keyPair = nullptr;
149     res = generator->generateKeyPair(generator, nullptr, &keyPair);
150     ASSERT_EQ(res, HCF_SUCCESS);
151     ASSERT_NE(keyPair, nullptr);
152 
153     dh1536KeyPair_ = keyPair;
154     HcfObjDestroy(generator);
155 
156     HcfAsyKeyGenerator *generator1 = nullptr;
157     res = HcfAsyKeyGeneratorCreate("DH_modp3072", &generator1);
158     ASSERT_EQ(res, HCF_SUCCESS);
159     ASSERT_NE(generator1, nullptr);
160 
161     HcfKeyPair *keyPair1 = nullptr;
162     res = generator1->generateKeyPair(generator1, nullptr, &keyPair1);
163     ASSERT_EQ(res, HCF_SUCCESS);
164     ASSERT_NE(keyPair1, nullptr);
165 
166     dh3072KeyPair1_ = keyPair1;
167     HcfObjDestroy(generator1);
168 
169     HcfAsyKeyGenerator *generator2 = nullptr;
170     res = HcfAsyKeyGeneratorCreate("DH_modp3072", &generator2);
171     ASSERT_EQ(res, HCF_SUCCESS);
172     ASSERT_NE(generator2, nullptr);
173 
174     HcfKeyPair *keyPair2 = nullptr;
175     res = generator2->generateKeyPair(generator2, nullptr, &keyPair2);
176     ASSERT_EQ(res, HCF_SUCCESS);
177     ASSERT_NE(keyPair2, nullptr);
178 
179     dh3072KeyPair2_ = keyPair2;
180     HcfObjDestroy(generator2);
181 }
182 
TearDownTestCase()183 void CryptoDHKeyAgreementTest::TearDownTestCase()
184 {
185     HcfObjDestroy(dh1536KeyPair_);
186     HcfObjDestroy(dh3072KeyPair1_);
187     HcfObjDestroy(dh3072KeyPair2_);
188 }
189 
190 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_1, TestSize.Level0)
191 {
192     HcfResult res = HcfKeyAgreementCreateTest("DH_modp1536");
193     ASSERT_EQ(res, HCF_SUCCESS);
194 }
195 
196 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_2, TestSize.Level0)
197 {
198     HcfResult res = HcfKeyAgreementCreateTest("DH_modp2048");
199     ASSERT_EQ(res, HCF_SUCCESS);
200 }
201 
202 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_3, TestSize.Level0)
203 {
204     HcfResult res = HcfKeyAgreementCreateTest("DH_modp3072");
205     ASSERT_EQ(res, HCF_SUCCESS);
206 }
207 
208 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_4, TestSize.Level0)
209 {
210     HcfResult res = HcfKeyAgreementCreateTest("DH_modp4096");
211     ASSERT_EQ(res, HCF_SUCCESS);
212 }
213 
214 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_5, TestSize.Level0)
215 {
216     HcfResult res = HcfKeyAgreementCreateTest("DH_modp6144");
217     ASSERT_EQ(res, HCF_SUCCESS);
218 }
219 
220 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_6, TestSize.Level0)
221 {
222     HcfResult res = HcfKeyAgreementCreateTest("DH_modp8192");
223     ASSERT_EQ(res, HCF_SUCCESS);
224 }
225 
226 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_7, TestSize.Level0)
227 {
228     HcfResult res = HcfKeyAgreementCreateTest("DH_ffdhe2048");
229     ASSERT_EQ(res, HCF_SUCCESS);
230 }
231 
232 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_8, TestSize.Level0)
233 {
234     HcfResult res = HcfKeyAgreementCreateTest("DH_ffdhe3072");
235     ASSERT_EQ(res, HCF_SUCCESS);
236 }
237 
238 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_9, TestSize.Level0)
239 {
240     HcfResult res = HcfKeyAgreementCreateTest("DH_ffdhe4096");
241     ASSERT_EQ(res, HCF_SUCCESS);
242 }
243 
244 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_10, TestSize.Level0)
245 {
246     HcfResult res = HcfKeyAgreementCreateTest("DH_ffdhe6144");
247     ASSERT_EQ(res, HCF_SUCCESS);
248 }
249 
250 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_11, TestSize.Level0)
251 {
252     HcfResult res = HcfKeyAgreementCreateTest("DH_ffdhe8192");
253     ASSERT_EQ(res, HCF_SUCCESS);
254 }
255 
256 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest002, TestSize.Level0)
257 {
258     HcfKeyAgreement *keyAgreement = nullptr;
259     HcfResult res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
260 
261     ASSERT_EQ(res, HCF_SUCCESS);
262     ASSERT_NE(keyAgreement, nullptr);
263 
264     const char *className = keyAgreement->base.getClass();
265     ASSERT_NE(className, nullptr);
266     HcfObjDestroy(keyAgreement);
267 }
268 
269 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest003, TestSize.Level0)
270 {
271     HcfKeyAgreement *keyAgreement = nullptr;
272     HcfResult res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
273 
274     ASSERT_EQ(res, HCF_SUCCESS);
275     ASSERT_NE(keyAgreement, nullptr);
276     keyAgreement->base.destroy((HcfObjectBase *)keyAgreement);
277 }
278 
279 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest004, TestSize.Level0)
280 {
281     HcfKeyAgreement *keyAgreement = nullptr;
282     HcfResult res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
283 
284     ASSERT_EQ(res, HCF_SUCCESS);
285     ASSERT_NE(keyAgreement, nullptr);
286 
287     const char *algName = keyAgreement->getAlgoName(keyAgreement);
288     ASSERT_EQ(algName, g_dh1536AlgoName);
289 
290     HcfBlob out = { .data = nullptr, .len = 0 };
291     res = keyAgreement->generateSecret(keyAgreement, dh1536KeyPair_->priKey, dh1536KeyPair_->pubKey, &out);
292 
293     ASSERT_EQ(res, HCF_SUCCESS);
294     ASSERT_NE(out.data, nullptr);
295     ASSERT_NE(out.len, (const unsigned int)0);
296 
297     HcfFree(out.data);
298     HcfObjDestroy(keyAgreement);
299 }
300 
301 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest005, TestSize.Level0)
302 {
303     HcfKeyAgreement *keyAgreement = nullptr;
304     HcfResult res = HcfKeyAgreementCreate("DH_9999", &keyAgreement);
305 
306     ASSERT_EQ(res, HCF_INVALID_PARAMS);
307     ASSERT_EQ(keyAgreement, nullptr);
308     HcfObjDestroy(keyAgreement);
309 }
310 
311 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest006, TestSize.Level0)
312 {
313     HcfKeyAgreement *keyAgreement = nullptr;
314     HcfResult res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
315 
316     ASSERT_EQ(res, HCF_SUCCESS);
317     ASSERT_NE(keyAgreement, nullptr);
318     keyAgreement->base.destroy(nullptr);
319     keyAgreement->base.destroy(&g_obj);
320     HcfObjDestroy(keyAgreement);
321 }
322 
323 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest007, TestSize.Level0)
324 {
325     HcfKeyAgreement *keyAgreement = nullptr;
326     HcfResult res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
327 
328     ASSERT_EQ(res, HCF_SUCCESS);
329     ASSERT_NE(keyAgreement, nullptr);
330 
331     const char *algName1 = keyAgreement->getAlgoName(nullptr);
332     ASSERT_EQ(algName1, nullptr);
333 
334     const char *algName2 = keyAgreement->getAlgoName((HcfKeyAgreement *)(&g_obj));
335     ASSERT_EQ(algName2, nullptr);
336 }
337 
338 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest008, TestSize.Level0)
339 {
340     HcfKeyAgreement *keyAgreement = nullptr;
341     HcfResult res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
342 
343     ASSERT_EQ(res, HCF_SUCCESS);
344     ASSERT_NE(keyAgreement, nullptr);
345 
346     HcfBlob out = { .data = nullptr, .len = 0 };
347     res = keyAgreement->generateSecret(keyAgreement, dh1536KeyPair_->priKey, nullptr, &out);
348     ASSERT_EQ(res, HCF_INVALID_PARAMS);
349     ASSERT_EQ(out.data, nullptr);
350     ASSERT_EQ(out.len, (const unsigned int)0);
351 
352     res = keyAgreement->generateSecret(keyAgreement, nullptr, dh1536KeyPair_->pubKey, &out);
353     ASSERT_EQ(res, HCF_INVALID_PARAMS);
354     ASSERT_EQ(out.data, nullptr);
355     ASSERT_EQ(out.len, (const unsigned int)0);
356 
357     res = keyAgreement->generateSecret((HcfKeyAgreement *)&g_obj, dh1536KeyPair_->priKey, dh1536KeyPair_->pubKey, &out);
358     ASSERT_EQ(res, HCF_INVALID_PARAMS);
359     ASSERT_EQ(out.data, nullptr);
360     ASSERT_EQ(out.len, (const unsigned int)0);
361 
362     HcfFree(out.data);
363     HcfObjDestroy(keyAgreement);
364 }
365 
366 HcfKeyAgreementParams params = {
367     .algo = HCF_ALG_DH,
368 };
369 
370 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest009, TestSize.Level0)
371 {
372     HcfResult res = HcfKeyAgreementSpiDhCreate(&params, nullptr);
373 
374     ASSERT_EQ(res, HCF_INVALID_PARAMS);
375 }
376 
377 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest010, TestSize.Level0)
378 {
379     HcfKeyAgreementSpi *spiObj = nullptr;
380     HcfResult res = HcfKeyAgreementSpiDhCreate(&params, &spiObj);
381 
382     ASSERT_EQ(res, HCF_SUCCESS);
383     ASSERT_NE(spiObj, nullptr);
384 
385     HcfBlob out = { .data = nullptr, .len = 0 };
386     res = spiObj->engineGenerateSecret((HcfKeyAgreementSpi *)&g_obj, dh1536KeyPair_->priKey, dh1536KeyPair_->pubKey,
387         &out);
388     ASSERT_EQ(res, HCF_INVALID_PARAMS);
389     res = spiObj->engineGenerateSecret(spiObj, (HcfPriKey *)&g_obj, dh1536KeyPair_->pubKey, &out);
390     ASSERT_EQ(res, HCF_INVALID_PARAMS);
391     res = spiObj->engineGenerateSecret(spiObj, dh1536KeyPair_->priKey, (HcfPubKey *)&g_obj, &out);
392     ASSERT_EQ(res, HCF_INVALID_PARAMS);
393 
394     EVP_PKEY *pubPKey = NewEvpPkeyByDh(((HcfOpensslDhPubKey *)dh1536KeyPair_->pubKey)->pk, false);
395     EXPECT_NE(pubPKey, NULL);
396     HcfFree(out.data);
397     HcfObjDestroy(spiObj);
398 }
399 
400 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest011, TestSize.Level0)
401 {
402     HcfKeyAgreementSpi *spiObj = nullptr;
403     HcfResult res = HcfKeyAgreementSpiDhCreate(&params, &spiObj);
404 
405     ASSERT_EQ(res, HCF_SUCCESS);
406     ASSERT_NE(spiObj, nullptr);
407 
408     spiObj->base.destroy(nullptr);
409 
410     HcfObjDestroy(spiObj);
411 }
412 
413 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest012, TestSize.Level0)
414 {
415     HcfKeyAgreementSpi *spiObj = nullptr;
416     HcfResult res = HcfKeyAgreementSpiDhCreate(&params, &spiObj);
417 
418     ASSERT_EQ(res, HCF_SUCCESS);
419     ASSERT_NE(spiObj, nullptr);
420 
421     spiObj->base.destroy(&g_obj);
422 
423     HcfObjDestroy(spiObj);
424 }
425 
426 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest013, TestSize.Level0)
427 {
428     StartRecordMallocNum();
429     HcfKeyAgreement *keyAgreement = nullptr;
430     HcfResult res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
431 
432     ASSERT_EQ(res, HCF_SUCCESS);
433     ASSERT_NE(keyAgreement, nullptr);
434 
435     HcfBlob out = { .data = nullptr, .len = 0 };
436     res = keyAgreement->generateSecret(keyAgreement, dh1536KeyPair_->priKey, dh1536KeyPair_->pubKey, &out);
437 
438     ASSERT_EQ(res, HCF_SUCCESS);
439     HcfFree(out.data);
440     HcfObjDestroy(keyAgreement);
441 
442     uint32_t mallocCount = GetMallocNum();
443 
444     for (uint32_t i = 0; i < mallocCount; i++) {
445         ResetRecordMallocNum();
446         SetMockMallocIndex(i);
447         keyAgreement = nullptr;
448         res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
449 
450         if (res != HCF_SUCCESS) {
451             continue;
452         }
453 
454         HcfBlob tmpBlob = {
455             .data = nullptr,
456             .len = 0
457         };
458         res = keyAgreement->generateSecret(keyAgreement, dh1536KeyPair_->priKey, dh1536KeyPair_->pubKey, &tmpBlob);
459 
460         if (res != HCF_SUCCESS) {
461             HcfObjDestroy(keyAgreement);
462             continue;
463         }
464 
465         HcfObjDestroy(keyAgreement);
466         HcfFree(tmpBlob.data);
467     }
468     EndRecordMallocNum();
469 }
470 
471 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest014, TestSize.Level0)
472 {
473     StartRecordOpensslCallNum();
474     HcfKeyAgreement *keyAgreement = nullptr;
475     HcfResult res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
476 
477     ASSERT_EQ(res, HCF_SUCCESS);
478     ASSERT_NE(keyAgreement, nullptr);
479 
480     HcfBlob out = { .data = nullptr, .len = 0 };
481     res = keyAgreement->generateSecret(keyAgreement, dh1536KeyPair_->priKey, dh1536KeyPair_->pubKey, &out);
482 
483     ASSERT_EQ(res, HCF_SUCCESS);
484     HcfFree(out.data);
485     HcfObjDestroy(keyAgreement);
486 
487     uint32_t mallocCount = GetOpensslCallNum();
488 
489     for (uint32_t i = 0; i < mallocCount; i++) {
490         ResetOpensslCallNum();
491         SetOpensslCallMockIndex(i);
492         keyAgreement = nullptr;
493         res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
494 
495         if (res != HCF_SUCCESS) {
496             continue;
497         }
498 
499         HcfBlob tmpBlob = {
500             .data = nullptr,
501             .len = 0
502         };
503         res = keyAgreement->generateSecret(keyAgreement, dh1536KeyPair_->priKey, dh1536KeyPair_->pubKey, &tmpBlob);
504 
505         if (res != HCF_SUCCESS) {
506             HcfObjDestroy(keyAgreement);
507             continue;
508         }
509 
510         HcfObjDestroy(keyAgreement);
511         HcfFree(tmpBlob.data);
512     }
513     EndRecordOpensslCallNum();
514 }
515 
516 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest015, TestSize.Level0)
517 {
518     HcfKeyAgreement *keyAgreement = nullptr;
519     HcfResult res = HcfKeyAgreementCreate(g_dh3072AlgoName.c_str(), &keyAgreement);
520 
521     ASSERT_EQ(res, HCF_SUCCESS);
522     ASSERT_NE(keyAgreement, nullptr);
523 
524     HcfBlob out = { .data = nullptr, .len = 0 };
525     res = keyAgreement->generateSecret(keyAgreement, dh3072KeyPair2_->priKey, dh3072KeyPair1_->pubKey, &out);
526 
527     ASSERT_EQ(res, HCF_SUCCESS);
528 
529     HcfObjDestroy(keyAgreement);
530     HcfFree(out.data);
531 }
532 
533 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest016, TestSize.Level0)
534 {
535     HcfAsyKeyGenerator *generator = nullptr;
536     HcfResult res = HcfAsyKeyGeneratorCreate("DH_ffdhe3072", &generator);
537     ASSERT_EQ(res, HCF_SUCCESS);
538     ASSERT_NE(generator, nullptr);
539 
540     HcfKeyPair *ffdhe3072keyPair1 = nullptr;
541     res = generator->generateKeyPair(generator, nullptr, &ffdhe3072keyPair1);
542     ASSERT_EQ(res, HCF_SUCCESS);
543     ASSERT_NE(ffdhe3072keyPair1, nullptr);
544 
545     HcfKeyPair *ffdhe3072keyPair2 = nullptr;
546     res = generator->generateKeyPair(generator, nullptr, &ffdhe3072keyPair2);
547     ASSERT_EQ(res, HCF_SUCCESS);
548     ASSERT_NE(ffdhe3072keyPair2, nullptr);
549 
550     HcfKeyAgreement *keyAgreement = nullptr;
551     res = HcfKeyAgreementCreate("DH_ffdhe3072", &keyAgreement);
552     ASSERT_EQ(res, HCF_SUCCESS);
553     ASSERT_NE(keyAgreement, nullptr);
554 
555     HcfBlob outBlob1 = { .data = nullptr, .len = 0 };
556     res = keyAgreement->generateSecret(keyAgreement, ffdhe3072keyPair1->priKey, ffdhe3072keyPair2->pubKey, &outBlob1);
557     ASSERT_EQ(res, HCF_SUCCESS);
558     ASSERT_NE(outBlob1.data, nullptr);
559     ASSERT_NE(outBlob1.len, (const unsigned int)0);
560 
561     HcfBlob outBlob2 = { .data = nullptr, .len = 0 };
562     res = keyAgreement->generateSecret(keyAgreement, ffdhe3072keyPair2->priKey, ffdhe3072keyPair1->pubKey, &outBlob2);
563     ASSERT_EQ(res, HCF_SUCCESS);
564     ASSERT_NE(outBlob2.data, nullptr);
565     ASSERT_NE(outBlob2.len, (const unsigned int)0);
566 
567     bool flag = true;
568     if (*(outBlob1.data) != *(outBlob2.data)) {
569         flag = false;
570     }
571     EXPECT_EQ(flag, true);
572     ASSERT_EQ(outBlob1.len, outBlob2.len);
573 
574     HcfObjDestroy(keyAgreement);
575     HcfObjDestroy(generator);
576     HcfObjDestroy(ffdhe3072keyPair1);
577     HcfObjDestroy(ffdhe3072keyPair2);
578     HcfFree(outBlob1.data);
579     HcfFree(outBlob2.data);
580 }
581 
582 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest017, TestSize.Level0)
583 {
584     HcfDhCommParamsSpec *returnCommonParamSpec = nullptr;
585     HcfResult res = HcfDhKeyUtilCreate(PLEN_DH512, SKLEN_DH128, &returnCommonParamSpec);
586     ASSERT_EQ(res, HCF_SUCCESS);
587 
588     HcfAsyKeyGeneratorBySpec *generator = nullptr;
589     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(returnCommonParamSpec), &generator);
590     ASSERT_EQ(res, HCF_SUCCESS);
591     ASSERT_NE(generator, nullptr);
592 
593     HcfKeyPair *dh512KeyPair = nullptr;
594     res = generator->generateKeyPair(generator, &dh512KeyPair);
595     ASSERT_EQ(res, HCF_SUCCESS);
596     ASSERT_NE(dh512KeyPair, nullptr);
597 
598     HcfKeyAgreement *keyAgreement = nullptr;
599     res = HcfKeyAgreementCreate("DH", &keyAgreement);
600     ASSERT_EQ(res, HCF_SUCCESS);
601     ASSERT_NE(keyAgreement, nullptr);
602 
603     HcfBlob out = { .data = nullptr, .len = 0 };
604     res = keyAgreement->generateSecret(keyAgreement, dh512KeyPair->priKey, dh512KeyPair->pubKey, &out);
605     ASSERT_EQ(res, HCF_SUCCESS);
606     ASSERT_NE(out.data, nullptr);
607     ASSERT_NE(out.len, 0);
608 
609     HcfObjDestroy(keyAgreement);
610     HcfObjDestroy(generator);
611     HcfObjDestroy(dh512KeyPair);
612     HcfFree(out.data);
613 }
614 
615 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest018, TestSize.Level0)
616 {
617     HcfResult res = ExchangekeyAgreementWithDiffSkLen(PLEN_DH512, SKLEN_DH128, 0);
618     ASSERT_EQ(res, HCF_ERR_CRYPTO_OPERATION);
619 }
620 
621 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest019, TestSize.Level0)
622 {
623     HcfDhCommParamsSpec *returnCommonParamSpec = nullptr;
624     HcfResult res = HcfDhKeyUtilCreate(PLEN_DH2048, 0, &returnCommonParamSpec);
625     ASSERT_EQ(res, HCF_SUCCESS);
626 
627     HcfAsyKeyGeneratorBySpec *generator = nullptr;
628     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(returnCommonParamSpec), &generator);
629     ASSERT_EQ(res, HCF_SUCCESS);
630     ASSERT_NE(generator, nullptr);
631 
632     HcfKeyPair *dh2048KeyPair = nullptr;
633     res = generator->generateKeyPair(generator, &dh2048KeyPair);
634     ASSERT_EQ(res, HCF_SUCCESS);
635     ASSERT_NE(dh2048KeyPair, nullptr);
636 
637     HcfKeyAgreement *keyAgreement = nullptr;
638     res = HcfKeyAgreementCreate("DH", &keyAgreement);
639     ASSERT_EQ(res, HCF_SUCCESS);
640     ASSERT_NE(keyAgreement, nullptr);
641 
642     HcfBlob out = { .data = nullptr, .len = 0 };
643     res = keyAgreement->generateSecret(keyAgreement, dh2048KeyPair->priKey, dh2048KeyPair->pubKey, &out);
644     ASSERT_EQ(res, HCF_SUCCESS);
645     ASSERT_NE(out.data, nullptr);
646     ASSERT_NE(out.len, 0);
647 
648     HcfFree(out.data);
649     HcfObjDestroy(keyAgreement);
650     HcfObjDestroy(generator);
651     HcfObjDestroy(dh2048KeyPair);
652 }
653 
654 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest020, TestSize.Level0)
655 {
656     HcfResult res = ExchangekeyAgreementWithDiffSkLen(PLEN_DH2048, SKLEN_DH1024, SKLEN_DH512);
657     ASSERT_EQ(res, HCF_SUCCESS);
658 }
659 
660 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest021, TestSize.Level0)
661 {
662     HcfDhCommParamsSpec *paramSpec = nullptr;
663     HcfResult res = HcfDhKeyUtilCreate(PLEN_DH512, 0, &paramSpec);
664     ASSERT_EQ(res, HCF_SUCCESS);
665     ASSERT_NE(paramSpec, nullptr);
666 
667     HcfAsyKeyGeneratorBySpec *generator = nullptr;
668     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(paramSpec), &generator);
669     ASSERT_EQ(res, HCF_SUCCESS);
670     ASSERT_NE(generator, nullptr);
671 
672     HcfKeyPair *dh512KeyPair = nullptr;
673     res = generator->generateKeyPair(generator, &dh512KeyPair);
674     ASSERT_EQ(res, HCF_SUCCESS);
675     ASSERT_NE(dh512KeyPair, nullptr);
676 
677     paramSpec->length = SKLEN_DH128;
678     HcfAsyKeyGeneratorBySpec *generator1 = nullptr;
679     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(paramSpec), &generator1);
680     ASSERT_EQ(res, HCF_SUCCESS);
681     ASSERT_NE(generator1, nullptr);
682 
683     HcfKeyPair *dh512KeyPair1 = nullptr;
684     res = generator1->generateKeyPair(generator1, &dh512KeyPair1);
685     ASSERT_EQ(res, HCF_SUCCESS);
686     ASSERT_NE(dh512KeyPair1, nullptr);
687 
688     HcfKeyAgreement *keyAgreement = nullptr;
689     res = HcfKeyAgreementCreate("DH", &keyAgreement);
690     ASSERT_EQ(res, HCF_SUCCESS);
691     ASSERT_NE(keyAgreement, nullptr);
692 
693     HcfBlob out = { .data = nullptr, .len = 0 };
694     res = keyAgreement->generateSecret(keyAgreement, dh512KeyPair->priKey, dh512KeyPair1->pubKey, &out);
695     ASSERT_EQ(res, HCF_SUCCESS);
696     ASSERT_NE(out.data, nullptr);
697     ASSERT_NE(out.len, 0);
698 
699     HcfBlob out1 = { .data = nullptr, .len = 0 };
700     res = keyAgreement->generateSecret(keyAgreement, dh512KeyPair1->priKey, dh512KeyPair->pubKey, &out1);
701     ASSERT_EQ(res, HCF_SUCCESS);
702     ASSERT_NE(out1.data, nullptr);
703     ASSERT_NE(out1.len, 0);
704 
705     HcfFree(out.data);
706     HcfFree(out1.data);
707     HcfObjDestroy(keyAgreement);
708     HcfObjDestroy(generator);
709     HcfObjDestroy(generator1);
710     HcfObjDestroy(dh512KeyPair);
711     HcfObjDestroy(dh512KeyPair1);
712 }
713 
714 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHCommonTest01, TestSize.Level0)
715 {
716     int32_t id = -1;
717     EXPECT_EQ(GetNidNameByDhId(id), nullptr);
718     EXPECT_EQ(GetNidNameByDhPLen(id), nullptr);
719 }
720 }
721