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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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(¶ms, &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(¶ms, &returnSpi);
827 ASSERT_EQ(res, HCF_SUCCESS);
828 ASSERT_NE(returnSpi, nullptr);
829
830 HcfAsyKeyParamsSpec *paramSpec = nullptr;
831 res = ConstructDHKeyPairParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, ¶mSpec);
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(¶ms, &returnSpi);
855 ASSERT_EQ(res, HCF_SUCCESS);
856 ASSERT_NE(returnSpi, nullptr);
857
858 HcfAsyKeyParamsSpec *paramSpec = nullptr;
859 res = ConstructDHPubKeyParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, ¶mSpec);
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(¶ms, &returnSpi);
883 ASSERT_EQ(res, HCF_SUCCESS);
884 ASSERT_NE(returnSpi, nullptr);
885
886 HcfAsyKeyParamsSpec *paramSpec = nullptr;
887 res = ConstructDHPriKeyParamsSpec(g_dh1536AlgoName, g_dh1536CommSpec, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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, ¶mSpec);
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(¶ms, &returnSpi);
1212 ASSERT_EQ(res, HCF_SUCCESS);
1213 ASSERT_NE(returnSpi, nullptr);
1214
1215 HcfAsyKeyParamsSpec *paramSpec = nullptr;
1216 res = ConstructDHKeyPairParamsCommonSpec(g_dh1536AlgoName, g_dh1536CommSpec, ¶mSpec);
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(¶ms, &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(¶ms, &returnSpi);
1259 ASSERT_EQ(res, HCF_SUCCESS);
1260 ASSERT_NE(returnSpi, nullptr);
1261
1262 HcfAsyKeyParamsSpec *paramSpec = nullptr;
1263 res = ConstructDHKeyPairParamsCommonSpec(g_dh1536AlgoName, g_dh1536CommSpec, ¶mSpec);
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, ¶mSpec1);
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(¶ms, &returnSpi);
1302 ASSERT_EQ(res, HCF_SUCCESS);
1303 ASSERT_NE(returnSpi, nullptr);
1304
1305 HcfAsyKeyParamsSpec *paramSpec = nullptr;
1306 res = ConstructDHPubKeyParamsSpec(g_dh2048AlgoName, g_dh2048CommSpec, ¶mSpec);
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, ¶mSpec1);
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(¶ms, &returnSpi);
1345 ASSERT_EQ(res, HCF_SUCCESS);
1346 ASSERT_NE(returnSpi, nullptr);
1347
1348 HcfAsyKeyParamsSpec *paramSpec = nullptr;
1349 res = ConstructDHPriKeyParamsSpec(g_dh3072AlgoName, g_dh3072CommSpec, ¶mSpec);
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, ¶mSpec1);
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, ¶mSpec);
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, ¶mSpec);
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 }