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 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, ¶mSpec1) != 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(¶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, 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(¶ms, &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(¶ms, &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, ¶mSpec);
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