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, ¶mSpec) != HCF_SUCCESS ||
102 HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(paramSpec), &generator)
103 != HCF_SUCCESS) {
104 break;
105 }
106 if (generator->generateKeyPair(generator, &keyPair) != HCF_SUCCESS ||
107 HcfDhKeyUtilCreate(pLen, size, ¶mSpec1) != HCF_SUCCESS) {
108 break;
109 }
110 if (HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(paramSpec1), &generator1)
111 != HCF_SUCCESS) {
112 break;
113 }
114 if (generator1->generateKeyPair(generator1, &keyPair1) != HCF_SUCCESS ||
115 HcfKeyAgreementCreate("DH", &keyAgreement) != HCF_SUCCESS) {
116 break;
117 }
118 if (keyAgreement->generateSecret(keyAgreement, keyPair->priKey, keyPair1->pubKey, &out) != HCF_SUCCESS) {
119 break;
120 }
121 HcfFree(out.data);
122 if (keyAgreement->generateSecret(keyAgreement, keyPair1->priKey, keyPair->pubKey, &out) != HCF_SUCCESS) {
123 break;
124 }
125 res = HCF_SUCCESS;
126 } while (0);
127 HcfFree(out.data);
128 HcfObjDestroy(keyAgreement);
129 HcfObjDestroy(generator);
130 HcfObjDestroy(generator1);
131 HcfObjDestroy(keyPair);
132 HcfObjDestroy(keyPair1);
133 FreeDhCommParamsSpec(paramSpec);
134 HcfFree(paramSpec);
135 FreeDhCommParamsSpec(paramSpec1);
136 HcfFree(paramSpec1);
137 return res;
138 }
139
SetUpTestCase()140 void CryptoDHKeyAgreementTest::SetUpTestCase()
141 {
142 HcfAsyKeyGenerator *generator = nullptr;
143 int32_t res = HcfAsyKeyGeneratorCreate("DH_modp1536", &generator);
144 ASSERT_EQ(res, HCF_SUCCESS);
145 ASSERT_NE(generator, nullptr);
146
147 HcfKeyPair *keyPair = nullptr;
148 res = generator->generateKeyPair(generator, nullptr, &keyPair);
149 ASSERT_EQ(res, HCF_SUCCESS);
150 ASSERT_NE(keyPair, nullptr);
151
152 dh1536KeyPair_ = keyPair;
153 HcfObjDestroy(generator);
154
155 HcfAsyKeyGenerator *generator1 = nullptr;
156 res = HcfAsyKeyGeneratorCreate("DH_modp3072", &generator1);
157 ASSERT_EQ(res, HCF_SUCCESS);
158 ASSERT_NE(generator1, nullptr);
159
160 HcfKeyPair *keyPair1 = nullptr;
161 res = generator1->generateKeyPair(generator1, nullptr, &keyPair1);
162 ASSERT_EQ(res, HCF_SUCCESS);
163 ASSERT_NE(keyPair1, nullptr);
164
165 dh3072KeyPair1_ = keyPair1;
166 HcfObjDestroy(generator1);
167
168 HcfAsyKeyGenerator *generator2 = nullptr;
169 res = HcfAsyKeyGeneratorCreate("DH_modp3072", &generator2);
170 ASSERT_EQ(res, HCF_SUCCESS);
171 ASSERT_NE(generator2, nullptr);
172
173 HcfKeyPair *keyPair2 = nullptr;
174 res = generator2->generateKeyPair(generator2, nullptr, &keyPair2);
175 ASSERT_EQ(res, HCF_SUCCESS);
176 ASSERT_NE(keyPair2, nullptr);
177
178 dh3072KeyPair2_ = keyPair2;
179 HcfObjDestroy(generator2);
180 }
181
TearDownTestCase()182 void CryptoDHKeyAgreementTest::TearDownTestCase()
183 {
184 HcfObjDestroy(dh1536KeyPair_);
185 HcfObjDestroy(dh3072KeyPair1_);
186 HcfObjDestroy(dh3072KeyPair2_);
187 }
188
189 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_1, TestSize.Level0)
190 {
191 HcfResult res = HcfKeyAgreementCreateTest("DH_modp1536");
192 ASSERT_EQ(res, HCF_SUCCESS);
193 }
194
195 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_2, TestSize.Level0)
196 {
197 HcfResult res = HcfKeyAgreementCreateTest("DH_modp2048");
198 ASSERT_EQ(res, HCF_SUCCESS);
199 }
200
201 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_3, TestSize.Level0)
202 {
203 HcfResult res = HcfKeyAgreementCreateTest("DH_modp3072");
204 ASSERT_EQ(res, HCF_SUCCESS);
205 }
206
207 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_4, TestSize.Level0)
208 {
209 HcfResult res = HcfKeyAgreementCreateTest("DH_modp4096");
210 ASSERT_EQ(res, HCF_SUCCESS);
211 }
212
213 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_5, TestSize.Level0)
214 {
215 HcfResult res = HcfKeyAgreementCreateTest("DH_modp6144");
216 ASSERT_EQ(res, HCF_SUCCESS);
217 }
218
219 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_6, TestSize.Level0)
220 {
221 HcfResult res = HcfKeyAgreementCreateTest("DH_modp8192");
222 ASSERT_EQ(res, HCF_SUCCESS);
223 }
224
225 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_7, TestSize.Level0)
226 {
227 HcfResult res = HcfKeyAgreementCreateTest("DH_ffdhe2048");
228 ASSERT_EQ(res, HCF_SUCCESS);
229 }
230
231 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_8, TestSize.Level0)
232 {
233 HcfResult res = HcfKeyAgreementCreateTest("DH_ffdhe3072");
234 ASSERT_EQ(res, HCF_SUCCESS);
235 }
236
237 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_9, TestSize.Level0)
238 {
239 HcfResult res = HcfKeyAgreementCreateTest("DH_ffdhe4096");
240 ASSERT_EQ(res, HCF_SUCCESS);
241 }
242
243 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_10, TestSize.Level0)
244 {
245 HcfResult res = HcfKeyAgreementCreateTest("DH_ffdhe6144");
246 ASSERT_EQ(res, HCF_SUCCESS);
247 }
248
249 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest001_11, TestSize.Level0)
250 {
251 HcfResult res = HcfKeyAgreementCreateTest("DH_ffdhe8192");
252 ASSERT_EQ(res, HCF_SUCCESS);
253 }
254
255 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest002, TestSize.Level0)
256 {
257 HcfKeyAgreement *keyAgreement = nullptr;
258 HcfResult res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
259
260 ASSERT_EQ(res, HCF_SUCCESS);
261 ASSERT_NE(keyAgreement, nullptr);
262
263 const char *className = keyAgreement->base.getClass();
264 ASSERT_NE(className, nullptr);
265 HcfObjDestroy(keyAgreement);
266 }
267
268 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest003, TestSize.Level0)
269 {
270 HcfKeyAgreement *keyAgreement = nullptr;
271 HcfResult res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
272
273 ASSERT_EQ(res, HCF_SUCCESS);
274 ASSERT_NE(keyAgreement, nullptr);
275 keyAgreement->base.destroy((HcfObjectBase *)keyAgreement);
276 }
277
278 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest004, TestSize.Level0)
279 {
280 HcfKeyAgreement *keyAgreement = nullptr;
281 HcfResult res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
282
283 ASSERT_EQ(res, HCF_SUCCESS);
284 ASSERT_NE(keyAgreement, nullptr);
285
286 const char *algName = keyAgreement->getAlgoName(keyAgreement);
287 ASSERT_EQ(algName, g_dh1536AlgoName);
288
289 HcfBlob out = { .data = nullptr, .len = 0 };
290 res = keyAgreement->generateSecret(keyAgreement, dh1536KeyPair_->priKey, dh1536KeyPair_->pubKey, &out);
291
292 ASSERT_EQ(res, HCF_SUCCESS);
293 ASSERT_NE(out.data, nullptr);
294 ASSERT_NE(out.len, (const unsigned int)0);
295
296 HcfFree(out.data);
297 HcfObjDestroy(keyAgreement);
298 }
299
300 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest005, TestSize.Level0)
301 {
302 HcfKeyAgreement *keyAgreement = nullptr;
303 HcfResult res = HcfKeyAgreementCreate("DH_9999", &keyAgreement);
304
305 ASSERT_EQ(res, HCF_INVALID_PARAMS);
306 ASSERT_EQ(keyAgreement, nullptr);
307 HcfObjDestroy(keyAgreement);
308 }
309
310 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest006, TestSize.Level0)
311 {
312 HcfKeyAgreement *keyAgreement = nullptr;
313 HcfResult res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
314
315 ASSERT_EQ(res, HCF_SUCCESS);
316 ASSERT_NE(keyAgreement, nullptr);
317 keyAgreement->base.destroy(nullptr);
318 keyAgreement->base.destroy(&g_obj);
319 HcfObjDestroy(keyAgreement);
320 }
321
322 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest007, TestSize.Level0)
323 {
324 HcfKeyAgreement *keyAgreement = nullptr;
325 HcfResult res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
326
327 ASSERT_EQ(res, HCF_SUCCESS);
328 ASSERT_NE(keyAgreement, nullptr);
329
330 const char *algName1 = keyAgreement->getAlgoName(nullptr);
331 ASSERT_EQ(algName1, nullptr);
332
333 const char *algName2 = keyAgreement->getAlgoName((HcfKeyAgreement *)(&g_obj));
334 ASSERT_EQ(algName2, nullptr);
335 HcfObjDestroy(keyAgreement);
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(¶ms, 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(¶ms, &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, true);
395 EXPECT_NE(pubPKey, nullptr);
396 EVP_PKEY_free(pubPKey);
397 HcfFree(out.data);
398 HcfObjDestroy(spiObj);
399 }
400
401 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest011, TestSize.Level0)
402 {
403 HcfKeyAgreementSpi *spiObj = nullptr;
404 HcfResult res = HcfKeyAgreementSpiDhCreate(¶ms, &spiObj);
405
406 ASSERT_EQ(res, HCF_SUCCESS);
407 ASSERT_NE(spiObj, nullptr);
408
409 spiObj->base.destroy(nullptr);
410
411 HcfObjDestroy(spiObj);
412 }
413
414 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest012, TestSize.Level0)
415 {
416 HcfKeyAgreementSpi *spiObj = nullptr;
417 HcfResult res = HcfKeyAgreementSpiDhCreate(¶ms, &spiObj);
418
419 ASSERT_EQ(res, HCF_SUCCESS);
420 ASSERT_NE(spiObj, nullptr);
421
422 spiObj->base.destroy(&g_obj);
423
424 HcfObjDestroy(spiObj);
425 }
426
427 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest013, TestSize.Level0)
428 {
429 StartRecordMallocNum();
430 HcfKeyAgreement *keyAgreement = nullptr;
431 HcfResult res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
432
433 ASSERT_EQ(res, HCF_SUCCESS);
434 ASSERT_NE(keyAgreement, nullptr);
435
436 HcfBlob out = { .data = nullptr, .len = 0 };
437 res = keyAgreement->generateSecret(keyAgreement, dh1536KeyPair_->priKey, dh1536KeyPair_->pubKey, &out);
438
439 ASSERT_EQ(res, HCF_SUCCESS);
440 HcfFree(out.data);
441 HcfObjDestroy(keyAgreement);
442
443 uint32_t mallocCount = GetMallocNum();
444
445 for (uint32_t i = 0; i < mallocCount; i++) {
446 ResetRecordMallocNum();
447 SetMockMallocIndex(i);
448 keyAgreement = nullptr;
449 res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
450
451 if (res != HCF_SUCCESS) {
452 continue;
453 }
454
455 HcfBlob tmpBlob = {
456 .data = nullptr,
457 .len = 0
458 };
459 res = keyAgreement->generateSecret(keyAgreement, dh1536KeyPair_->priKey, dh1536KeyPair_->pubKey, &tmpBlob);
460
461 if (res != HCF_SUCCESS) {
462 HcfObjDestroy(keyAgreement);
463 continue;
464 }
465
466 HcfObjDestroy(keyAgreement);
467 HcfFree(tmpBlob.data);
468 }
469 EndRecordMallocNum();
470 }
471
472 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest014, TestSize.Level0)
473 {
474 StartRecordOpensslCallNum();
475 HcfKeyAgreement *keyAgreement = nullptr;
476 HcfResult res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
477
478 ASSERT_EQ(res, HCF_SUCCESS);
479 ASSERT_NE(keyAgreement, nullptr);
480
481 HcfBlob out = { .data = nullptr, .len = 0 };
482 res = keyAgreement->generateSecret(keyAgreement, dh1536KeyPair_->priKey, dh1536KeyPair_->pubKey, &out);
483
484 ASSERT_EQ(res, HCF_SUCCESS);
485 HcfFree(out.data);
486 HcfObjDestroy(keyAgreement);
487
488 uint32_t mallocCount = GetOpensslCallNum();
489
490 for (uint32_t i = 0; i < mallocCount; i++) {
491 ResetOpensslCallNum();
492 SetOpensslCallMockIndex(i);
493 keyAgreement = nullptr;
494 res = HcfKeyAgreementCreate(g_dh1536AlgoName.c_str(), &keyAgreement);
495
496 if (res != HCF_SUCCESS) {
497 continue;
498 }
499
500 HcfBlob tmpBlob = {
501 .data = nullptr,
502 .len = 0
503 };
504 res = keyAgreement->generateSecret(keyAgreement, dh1536KeyPair_->priKey, dh1536KeyPair_->pubKey, &tmpBlob);
505
506 if (res != HCF_SUCCESS) {
507 HcfObjDestroy(keyAgreement);
508 continue;
509 }
510
511 HcfObjDestroy(keyAgreement);
512 HcfFree(tmpBlob.data);
513 }
514 EndRecordOpensslCallNum();
515 }
516
517 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest015, TestSize.Level0)
518 {
519 HcfKeyAgreement *keyAgreement = nullptr;
520 HcfResult res = HcfKeyAgreementCreate(g_dh3072AlgoName.c_str(), &keyAgreement);
521
522 ASSERT_EQ(res, HCF_SUCCESS);
523 ASSERT_NE(keyAgreement, nullptr);
524
525 HcfBlob out = { .data = nullptr, .len = 0 };
526 res = keyAgreement->generateSecret(keyAgreement, dh3072KeyPair2_->priKey, dh3072KeyPair1_->pubKey, &out);
527
528 ASSERT_EQ(res, HCF_SUCCESS);
529
530 HcfObjDestroy(keyAgreement);
531 HcfFree(out.data);
532 }
533
534 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest016, TestSize.Level0)
535 {
536 HcfAsyKeyGenerator *generator = nullptr;
537 HcfResult res = HcfAsyKeyGeneratorCreate("DH_ffdhe3072", &generator);
538 ASSERT_EQ(res, HCF_SUCCESS);
539 ASSERT_NE(generator, nullptr);
540
541 HcfKeyPair *ffdhe3072keyPair1 = nullptr;
542 res = generator->generateKeyPair(generator, nullptr, &ffdhe3072keyPair1);
543 ASSERT_EQ(res, HCF_SUCCESS);
544 ASSERT_NE(ffdhe3072keyPair1, nullptr);
545
546 HcfKeyPair *ffdhe3072keyPair2 = nullptr;
547 res = generator->generateKeyPair(generator, nullptr, &ffdhe3072keyPair2);
548 ASSERT_EQ(res, HCF_SUCCESS);
549 ASSERT_NE(ffdhe3072keyPair2, nullptr);
550
551 HcfKeyAgreement *keyAgreement = nullptr;
552 res = HcfKeyAgreementCreate("DH_ffdhe3072", &keyAgreement);
553 ASSERT_EQ(res, HCF_SUCCESS);
554 ASSERT_NE(keyAgreement, nullptr);
555
556 HcfBlob outBlob1 = { .data = nullptr, .len = 0 };
557 res = keyAgreement->generateSecret(keyAgreement, ffdhe3072keyPair1->priKey, ffdhe3072keyPair2->pubKey, &outBlob1);
558 ASSERT_EQ(res, HCF_SUCCESS);
559 ASSERT_NE(outBlob1.data, nullptr);
560 ASSERT_NE(outBlob1.len, (const unsigned int)0);
561
562 HcfBlob outBlob2 = { .data = nullptr, .len = 0 };
563 res = keyAgreement->generateSecret(keyAgreement, ffdhe3072keyPair2->priKey, ffdhe3072keyPair1->pubKey, &outBlob2);
564 ASSERT_EQ(res, HCF_SUCCESS);
565 ASSERT_NE(outBlob2.data, nullptr);
566 ASSERT_NE(outBlob2.len, (const unsigned int)0);
567
568 bool flag = true;
569 if (*(outBlob1.data) != *(outBlob2.data)) {
570 flag = false;
571 }
572 EXPECT_EQ(flag, true);
573 ASSERT_EQ(outBlob1.len, outBlob2.len);
574
575 HcfObjDestroy(keyAgreement);
576 HcfObjDestroy(generator);
577 HcfObjDestroy(ffdhe3072keyPair1);
578 HcfObjDestroy(ffdhe3072keyPair2);
579 HcfFree(outBlob1.data);
580 HcfFree(outBlob2.data);
581 }
582
583 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest017, TestSize.Level0)
584 {
585 HcfDhCommParamsSpec *returnCommonParamSpec = nullptr;
586 HcfResult res = HcfDhKeyUtilCreate(PLEN_DH512, SKLEN_DH128, &returnCommonParamSpec);
587 ASSERT_EQ(res, HCF_SUCCESS);
588
589 HcfAsyKeyGeneratorBySpec *generator = nullptr;
590 res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(returnCommonParamSpec), &generator);
591 ASSERT_EQ(res, HCF_SUCCESS);
592 ASSERT_NE(generator, nullptr);
593
594 HcfKeyPair *dh512KeyPair = nullptr;
595 res = generator->generateKeyPair(generator, &dh512KeyPair);
596 ASSERT_EQ(res, HCF_SUCCESS);
597 ASSERT_NE(dh512KeyPair, nullptr);
598
599 HcfKeyAgreement *keyAgreement = nullptr;
600 res = HcfKeyAgreementCreate("DH", &keyAgreement);
601 ASSERT_EQ(res, HCF_SUCCESS);
602 ASSERT_NE(keyAgreement, nullptr);
603
604 HcfBlob out = { .data = nullptr, .len = 0 };
605 res = keyAgreement->generateSecret(keyAgreement, dh512KeyPair->priKey, dh512KeyPair->pubKey, &out);
606 ASSERT_EQ(res, HCF_SUCCESS);
607 ASSERT_NE(out.data, nullptr);
608 ASSERT_NE(out.len, 0);
609
610 HcfObjDestroy(keyAgreement);
611 HcfObjDestroy(generator);
612 HcfObjDestroy(dh512KeyPair);
613 HcfFree(out.data);
614 FreeDhCommParamsSpec(returnCommonParamSpec);
615 HcfFree(returnCommonParamSpec);
616 }
617
618 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest018, TestSize.Level0)
619 {
620 HcfResult res = ExchangekeyAgreementWithDiffSkLen(PLEN_DH512, SKLEN_DH128, 0);
621 ASSERT_EQ(res, HCF_ERR_CRYPTO_OPERATION);
622 }
623
624 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest019, TestSize.Level0)
625 {
626 HcfDhCommParamsSpec *returnCommonParamSpec = nullptr;
627 HcfResult res = HcfDhKeyUtilCreate(PLEN_DH2048, 0, &returnCommonParamSpec);
628 ASSERT_EQ(res, HCF_SUCCESS);
629
630 HcfAsyKeyGeneratorBySpec *generator = nullptr;
631 res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(returnCommonParamSpec), &generator);
632 ASSERT_EQ(res, HCF_SUCCESS);
633 ASSERT_NE(generator, nullptr);
634
635 HcfKeyPair *dh2048KeyPair = nullptr;
636 res = generator->generateKeyPair(generator, &dh2048KeyPair);
637 ASSERT_EQ(res, HCF_SUCCESS);
638 ASSERT_NE(dh2048KeyPair, nullptr);
639
640 HcfKeyAgreement *keyAgreement = nullptr;
641 res = HcfKeyAgreementCreate("DH", &keyAgreement);
642 ASSERT_EQ(res, HCF_SUCCESS);
643 ASSERT_NE(keyAgreement, nullptr);
644
645 HcfBlob out = { .data = nullptr, .len = 0 };
646 res = keyAgreement->generateSecret(keyAgreement, dh2048KeyPair->priKey, dh2048KeyPair->pubKey, &out);
647 ASSERT_EQ(res, HCF_SUCCESS);
648 ASSERT_NE(out.data, nullptr);
649 ASSERT_NE(out.len, 0);
650
651 HcfFree(out.data);
652 HcfObjDestroy(keyAgreement);
653 HcfObjDestroy(generator);
654 HcfObjDestroy(dh2048KeyPair);
655 FreeDhCommParamsSpec(returnCommonParamSpec);
656 HcfFree(returnCommonParamSpec);
657 }
658
659 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest020, TestSize.Level0)
660 {
661 HcfResult res = ExchangekeyAgreementWithDiffSkLen(PLEN_DH2048, SKLEN_DH1024, SKLEN_DH512);
662 ASSERT_EQ(res, HCF_SUCCESS);
663 }
664
665 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHKeyAgreementTest021, TestSize.Level0)
666 {
667 HcfDhCommParamsSpec *paramSpec = nullptr;
668 HcfResult res = HcfDhKeyUtilCreate(PLEN_DH512, 0, ¶mSpec);
669 ASSERT_EQ(res, HCF_SUCCESS);
670 ASSERT_NE(paramSpec, nullptr);
671
672 HcfAsyKeyGeneratorBySpec *generator = nullptr;
673 res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(paramSpec), &generator);
674 ASSERT_EQ(res, HCF_SUCCESS);
675 ASSERT_NE(generator, nullptr);
676
677 HcfKeyPair *dh512KeyPair = nullptr;
678 res = generator->generateKeyPair(generator, &dh512KeyPair);
679 ASSERT_EQ(res, HCF_SUCCESS);
680 ASSERT_NE(dh512KeyPair, nullptr);
681
682 paramSpec->length = SKLEN_DH128;
683 HcfAsyKeyGeneratorBySpec *generator1 = nullptr;
684 res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(paramSpec), &generator1);
685 ASSERT_EQ(res, HCF_SUCCESS);
686 ASSERT_NE(generator1, nullptr);
687
688 HcfKeyPair *dh512KeyPair1 = nullptr;
689 res = generator1->generateKeyPair(generator1, &dh512KeyPair1);
690 ASSERT_EQ(res, HCF_SUCCESS);
691 ASSERT_NE(dh512KeyPair1, nullptr);
692
693 HcfKeyAgreement *keyAgreement = nullptr;
694 res = HcfKeyAgreementCreate("DH", &keyAgreement);
695 ASSERT_EQ(res, HCF_SUCCESS);
696 ASSERT_NE(keyAgreement, nullptr);
697
698 HcfBlob out = { .data = nullptr, .len = 0 };
699 res = keyAgreement->generateSecret(keyAgreement, dh512KeyPair->priKey, dh512KeyPair1->pubKey, &out);
700 ASSERT_EQ(res, HCF_SUCCESS);
701 ASSERT_NE(out.data, nullptr);
702 ASSERT_NE(out.len, 0);
703
704 HcfBlob out1 = { .data = nullptr, .len = 0 };
705 res = keyAgreement->generateSecret(keyAgreement, dh512KeyPair1->priKey, dh512KeyPair->pubKey, &out1);
706 ASSERT_EQ(res, HCF_SUCCESS);
707 ASSERT_NE(out1.data, nullptr);
708 ASSERT_NE(out1.len, 0);
709
710 HcfFree(out.data);
711 HcfFree(out1.data);
712 HcfObjDestroy(keyAgreement);
713 HcfObjDestroy(generator);
714 HcfObjDestroy(generator1);
715 HcfObjDestroy(dh512KeyPair);
716 HcfObjDestroy(dh512KeyPair1);
717 FreeDhCommParamsSpec(paramSpec);
718 HcfFree(paramSpec);
719 }
720
721 HWTEST_F(CryptoDHKeyAgreementTest, CryptoDHCommonTest01, TestSize.Level0)
722 {
723 int32_t id = -1;
724 EXPECT_EQ(GetNidNameByDhId(id), nullptr);
725 EXPECT_EQ(GetNidNameByDhPLen(id), nullptr);
726 }
727 }
728