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 EXPECT 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 <string>
18 #include "securec.h"
19
20 #include "asy_key_generator.h"
21 #include "big_integer.h"
22 #include "key.h"
23 #include "memory.h"
24 #include "openssl_class.h"
25
26 using namespace std;
27 using namespace testing::ext;
28
29 namespace {
30 class CryptoDsaAsyKeyGeneratorTest : public testing::Test {
31 public:
32 static void SetUpTestCase();
33 static void TearDownTestCase();
34 void SetUp();
35 void TearDown();
36
37 static HcfKeyPair *dsa1024KeyPair_;
38 static HcfKeyPair *dsa2048KeyPair_;
39 static HcfKeyPair *dsa3072KeyPair_;
40 };
41
42 HcfKeyPair *CryptoDsaAsyKeyGeneratorTest::dsa1024KeyPair_ = nullptr;
43 HcfKeyPair *CryptoDsaAsyKeyGeneratorTest::dsa2048KeyPair_ = nullptr;
44 HcfKeyPair *CryptoDsaAsyKeyGeneratorTest::dsa3072KeyPair_ = nullptr;
45
GenerateDsa1024KeyPair(HcfKeyPair ** returnKeyPair)46 static HcfResult GenerateDsa1024KeyPair(HcfKeyPair **returnKeyPair)
47 {
48 HcfAsyKeyGenerator *generator = nullptr;
49 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA1024", &generator);
50 if (ret != HCF_SUCCESS) {
51 return ret;
52 }
53 HcfKeyPair *keyPair = nullptr;
54 ret = generator->generateKeyPair(generator, nullptr, &keyPair);
55 HcfObjDestroy(generator);
56 if (ret != HCF_SUCCESS) {
57 return ret;
58 }
59 *returnKeyPair = keyPair;
60 return HCF_SUCCESS;
61 }
62
GenerateDsa2048KeyPair(HcfKeyPair ** returnKeyPair)63 static HcfResult GenerateDsa2048KeyPair(HcfKeyPair **returnKeyPair)
64 {
65 HcfAsyKeyGenerator *generator = nullptr;
66 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
67 if (ret != HCF_SUCCESS) {
68 return ret;
69 }
70 HcfKeyPair *keyPair = nullptr;
71 ret = generator->generateKeyPair(generator, nullptr, &keyPair);
72 HcfObjDestroy(generator);
73 if (ret != HCF_SUCCESS) {
74 return ret;
75 }
76 *returnKeyPair = keyPair;
77 return HCF_SUCCESS;
78 }
79
GenerateDsa3072KeyPair(HcfKeyPair ** returnKeyPair)80 static HcfResult GenerateDsa3072KeyPair(HcfKeyPair **returnKeyPair)
81 {
82 HcfAsyKeyGenerator *generator = nullptr;
83 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA3072", &generator);
84 if (ret != HCF_SUCCESS) {
85 return ret;
86 }
87 HcfKeyPair *keyPair = nullptr;
88 ret = generator->generateKeyPair(generator, nullptr, &keyPair);
89 HcfObjDestroy(generator);
90 if (ret != HCF_SUCCESS) {
91 return ret;
92 }
93 *returnKeyPair = keyPair;
94 return HCF_SUCCESS;
95 }
96
SetUpTestCase()97 void CryptoDsaAsyKeyGeneratorTest::SetUpTestCase()
98 {
99 HcfKeyPair *keyPair1024 = nullptr;
100 HcfKeyPair *keyPair2048 = nullptr;
101 HcfKeyPair *keyPair3072 = nullptr;
102 EXPECT_EQ(GenerateDsa1024KeyPair(&keyPair1024), HCF_SUCCESS);
103 EXPECT_EQ(GenerateDsa2048KeyPair(&keyPair2048), HCF_SUCCESS);
104 EXPECT_EQ(GenerateDsa3072KeyPair(&keyPair3072), HCF_SUCCESS);
105 dsa1024KeyPair_ = keyPair1024;
106 dsa2048KeyPair_ = keyPair2048;
107 dsa3072KeyPair_ = keyPair3072;
108 }
109
TearDownTestCase()110 void CryptoDsaAsyKeyGeneratorTest::TearDownTestCase()
111 {
112 HcfObjDestroy(dsa1024KeyPair_);
113 HcfObjDestroy(dsa2048KeyPair_);
114 HcfObjDestroy(dsa3072KeyPair_);
115 }
SetUp()116 void CryptoDsaAsyKeyGeneratorTest::SetUp() {}
TearDown()117 void CryptoDsaAsyKeyGeneratorTest::TearDown() {}
118
119 static const char *g_algNameDSA = "DSA";
120 static const char *g_opensslDsaPubKeyFormat = "X.509";
121 static const char *g_opensslDsaPriKeyFormat = "PKCS#8";
122
GetMockClass(void)123 static const char *GetMockClass(void)
124 {
125 return "HcfSymKeyGenerator";
126 }
127
128 HcfObjectBase g_obj = {
129 .getClass = GetMockClass,
130 .destroy = nullptr
131 };
132
GetKeyEncodedTest(HcfKeyPair * keyPair,HcfBlob * pkBlob,HcfBlob * skBlob)133 static HcfResult GetKeyEncodedTest(HcfKeyPair *keyPair, HcfBlob *pkBlob, HcfBlob *skBlob)
134 {
135 HcfResult ret = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), pkBlob);
136 if (ret != HCF_SUCCESS) {
137 return ret;
138 }
139 ret = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), skBlob);
140 if (ret != HCF_SUCCESS) {
141 HcfFree(pkBlob->data);
142 return ret;
143 }
144 return HCF_SUCCESS;
145 }
146
147 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest009, TestSize.Level0)
148 {
149 HcfAsyKeyGenerator *generator = nullptr;
150 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA1024", &generator);
151
152 ASSERT_EQ(ret, HCF_SUCCESS);
153 ASSERT_NE(generator, nullptr);
154
155 HcfObjDestroy(generator);
156 }
157
158 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest010, TestSize.Level0)
159 {
160 HcfAsyKeyGenerator *generator = nullptr;
161 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
162
163 ASSERT_EQ(ret, HCF_SUCCESS);
164 ASSERT_NE(generator, nullptr);
165
166 HcfObjDestroy(generator);
167 }
168
169 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest011, TestSize.Level0)
170 {
171 HcfAsyKeyGenerator *generator = nullptr;
172 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA3072", &generator);
173
174 ASSERT_EQ(ret, HCF_SUCCESS);
175 ASSERT_NE(generator, nullptr);
176
177 HcfObjDestroy(generator);
178 }
179
180 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest012, TestSize.Level1)
181 {
182 HcfAsyKeyGenerator *generator = nullptr;
183 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA", &generator);
184
185 ASSERT_EQ(ret, HCF_INVALID_PARAMS);
186 }
187
188 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest013, TestSize.Level1)
189 {
190 HcfAsyKeyGenerator *generator = nullptr;
191 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA4096", &generator);
192
193 ASSERT_EQ(ret, HCF_INVALID_PARAMS);
194 }
195
196 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest101, TestSize.Level0)
197 {
198 HcfAsyKeyGenerator *generator = nullptr;
199 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA1024", &generator);
200
201 ASSERT_EQ(ret, HCF_SUCCESS);
202 ASSERT_NE(generator, nullptr);
203
204 const char *className = generator->base.getClass();
205 ASSERT_NE(className, nullptr);
206
207 HcfObjDestroy(generator);
208 }
209
210 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest102, TestSize.Level0)
211 {
212 HcfAsyKeyGenerator *generator = nullptr;
213 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA1024", &generator);
214
215 ASSERT_EQ(ret, HCF_SUCCESS);
216 ASSERT_NE(generator, nullptr);
217
218 generator->base.destroy(&(generator->base));
219 }
220
221 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest103, TestSize.Level0)
222 {
223 HcfAsyKeyGenerator *generator = nullptr;
224 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA1024", &generator);
225
226 ASSERT_EQ(ret, HCF_SUCCESS);
227 ASSERT_NE(generator, nullptr);
228
229 generator->base.destroy(&(generator->base));
230 }
231
232 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest104, TestSize.Level0)
233 {
234 HcfAsyKeyGenerator *generator = nullptr;
235 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
236
237 ASSERT_EQ(ret, HCF_SUCCESS);
238 ASSERT_NE(generator, nullptr);
239
240 const char *algName = generator->getAlgoName(generator);
241
242 EXPECT_STREQ(algName, "DSA2048");
243 HcfObjDestroy(generator);
244 }
245
246 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest201, TestSize.Level1)
247 {
248 HcfAsyKeyGenerator *generator = nullptr;
249 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
250
251 ASSERT_EQ(ret, HCF_SUCCESS);
252 ASSERT_NE(generator, nullptr);
253
254 HcfKeyPair *keyPair = nullptr;
255 ret = generator->generateKeyPair(nullptr, nullptr, &keyPair);
256
257 HcfObjDestroy(generator);
258 ASSERT_EQ(ret, HCF_INVALID_PARAMS);
259 ASSERT_EQ(keyPair, nullptr);
260 }
261
262 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest202, TestSize.Level1)
263 {
264 HcfAsyKeyGenerator *generator = nullptr;
265 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
266
267 ASSERT_EQ(ret, HCF_SUCCESS);
268 ASSERT_NE(generator, nullptr);
269
270 ret = generator->generateKeyPair(generator, nullptr, nullptr);
271
272 HcfObjDestroy(generator);
273 ASSERT_EQ(ret, HCF_INVALID_PARAMS);
274 }
275
276 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest203, TestSize.Level1)
277 {
278 HcfAsyKeyGenerator *generator = nullptr;
279 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
280
281 ASSERT_EQ(ret, HCF_SUCCESS);
282 ASSERT_NE(generator, nullptr);
283
284 HcfKeyPair *keyPair = nullptr;
285 ret = generator->generateKeyPair((HcfAsyKeyGenerator *)&g_obj, nullptr, &keyPair);
286
287 HcfObjDestroy(generator);
288 ASSERT_EQ(ret, HCF_INVALID_PARAMS);
289 ASSERT_EQ(keyPair, nullptr);
290 }
291
292 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest301, TestSize.Level0)
293 {
294 const char *className = dsa2048KeyPair_->base.getClass();
295 ASSERT_EQ(className, OPENSSL_DSA_KEYPAIR_CLASS);
296 }
297
298 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest302, TestSize.Level0)
299 {
300 HcfAsyKeyGenerator *generator = nullptr;
301 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA1024", &generator);
302
303 ASSERT_EQ(ret, HCF_SUCCESS);
304 ASSERT_NE(generator, nullptr);
305
306 HcfKeyPair *keyPair = nullptr;
307 ret = generator->generateKeyPair(generator, nullptr, &keyPair);
308
309 HcfObjDestroy(generator);
310 ASSERT_EQ(ret, HCF_SUCCESS);
311 ASSERT_NE(keyPair, nullptr);
312
313 keyPair->base.destroy(&(keyPair->base));
314 }
315
316 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest305, TestSize.Level0)
317 {
318 dsa2048KeyPair_->base.destroy(nullptr);
319 dsa2048KeyPair_->base.destroy((HcfObjectBase *)&g_obj);
320
321 const char *pkClassName = dsa2048KeyPair_->pubKey->base.base.getClass();
322 ASSERT_EQ(pkClassName, OPENSSL_DSA_PUBKEY_CLASS);
323 }
324
325 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest306, TestSize.Level0)
326 {
327 HcfAsyKeyGenerator *generator = nullptr;
328 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
329
330 ASSERT_EQ(ret, HCF_SUCCESS);
331 ASSERT_NE(generator, nullptr);
332
333 HcfKeyPair *keyPair = nullptr;
334 ret = generator->generateKeyPair(generator, nullptr, &keyPair);
335
336 HcfObjDestroy(generator);
337 ASSERT_EQ(ret, HCF_SUCCESS);
338 ASSERT_NE(keyPair, nullptr);
339
340 keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
341 keyPair->pubKey = nullptr;
342 HcfObjDestroy(keyPair);
343 }
344
345 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest309, TestSize.Level0)
346 {
347 dsa2048KeyPair_->pubKey->base.base.destroy(nullptr);
348 dsa2048KeyPair_->pubKey->base.base.destroy((HcfObjectBase *)&g_obj);
349
350 const char *alg = dsa2048KeyPair_->pubKey->base.getAlgorithm(&(dsa2048KeyPair_->pubKey->base));
351 ASSERT_EQ(alg, g_algNameDSA);
352 }
353
354 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest310, TestSize.Level1)
355 {
356 const char *alg = dsa2048KeyPair_->pubKey->base.getAlgorithm(nullptr);
357 ASSERT_EQ(alg, nullptr);
358 }
359
360 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest311, TestSize.Level1)
361 {
362 const char *alg = dsa2048KeyPair_->pubKey->base.getAlgorithm((HcfKey *)&g_obj);
363 ASSERT_EQ(alg, nullptr);
364 }
365
366 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest312, TestSize.Level0)
367 {
368 HcfBlob blob = { .data = nullptr, .len = 0 };
369 HcfResult ret = dsa2048KeyPair_->pubKey->base.getEncoded(&(dsa2048KeyPair_->pubKey->base), &blob);
370
371 ASSERT_EQ(ret, HCF_SUCCESS);
372 ASSERT_NE(blob.data, nullptr);
373 ASSERT_NE(blob.len, 0);
374 HcfFree(blob.data);
375 }
376
377 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest313, TestSize.Level1)
378 {
379 HcfBlob blob = { .data = nullptr, .len = 0 };
380 HcfResult ret = dsa2048KeyPair_->pubKey->base.getEncoded(nullptr, &blob);
381
382 ASSERT_EQ(ret, HCF_INVALID_PARAMS);
383 ASSERT_EQ(blob.data, nullptr);
384 ASSERT_EQ(blob.len, 0);
385 }
386
387 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest314, TestSize.Level1)
388 {
389 HcfResult ret = dsa2048KeyPair_->pubKey->base.getEncoded(&(dsa2048KeyPair_->pubKey->base), nullptr);
390 ASSERT_EQ(ret, HCF_INVALID_PARAMS);
391 }
392
393 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest315, TestSize.Level1)
394 {
395 HcfBlob blob = { .data = nullptr, .len = 0 };
396 HcfResult ret = dsa2048KeyPair_->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob);
397
398 ASSERT_EQ(ret, HCF_INVALID_PARAMS);
399 ASSERT_EQ(blob.data, nullptr);
400 ASSERT_EQ(blob.len, 0);
401 }
402
403 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest316, TestSize.Level0)
404 {
405 const char *pkFormat = dsa2048KeyPair_->pubKey->base.getFormat(&(dsa2048KeyPair_->pubKey->base));
406 ASSERT_STREQ(pkFormat, g_opensslDsaPubKeyFormat);
407 }
408
409 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest317, TestSize.Level1)
410 {
411 const char *pkFormat = dsa2048KeyPair_->pubKey->base.getFormat(nullptr);
412 ASSERT_EQ(pkFormat, nullptr);
413 }
414
415 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest318, TestSize.Level0)
416 {
417 HcfBigInteger p = { .data = nullptr, .len = 0 };
418 HcfResult ret = dsa2048KeyPair_->pubKey->getAsyKeySpecBigInteger(dsa2048KeyPair_->pubKey, DSA_P_BN, &p);
419
420 ASSERT_EQ(ret, HCF_SUCCESS);
421 ASSERT_NE(p.data, nullptr);
422 ASSERT_NE(p.len, 0);
423 HcfFree(p.data);
424 }
425
426 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest319, TestSize.Level0)
427 {
428 HcfBigInteger q = { .data = nullptr, .len = 0 };
429 HcfResult ret = dsa2048KeyPair_->pubKey->getAsyKeySpecBigInteger(dsa2048KeyPair_->pubKey, DSA_Q_BN, &q);
430
431 ASSERT_EQ(ret, HCF_SUCCESS);
432 ASSERT_NE(q.data, nullptr);
433 ASSERT_NE(q.len, 0);
434 HcfFree(q.data);
435 }
436
437 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest320, TestSize.Level0)
438 {
439 HcfBigInteger g = { .data = nullptr, .len = 0 };
440 HcfResult ret = dsa2048KeyPair_->pubKey->getAsyKeySpecBigInteger(dsa2048KeyPair_->pubKey, DSA_G_BN, &g);
441
442 ASSERT_EQ(ret, HCF_SUCCESS);
443 ASSERT_NE(g.data, nullptr);
444 ASSERT_NE(g.len, 0);
445 HcfFree(g.data);
446 }
447
448 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest321, TestSize.Level0)
449 {
450 HcfBigInteger pk = { .data = nullptr, .len = 0 };
451 HcfResult ret = dsa2048KeyPair_->pubKey->getAsyKeySpecBigInteger(dsa2048KeyPair_->pubKey, DSA_PK_BN, &pk);
452
453 ASSERT_EQ(ret, HCF_SUCCESS);
454 ASSERT_NE(pk.data, nullptr);
455 ASSERT_NE(pk.len, 0);
456 HcfFree(pk.data);
457 }
458
459 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest322, TestSize.Level0)
460 {
461 int testI;
462 HcfResult ret = dsa2048KeyPair_->pubKey->getAsyKeySpecInt(dsa2048KeyPair_->pubKey, DSA_P_BN, &testI);
463 ASSERT_EQ(ret, HCF_NOT_SUPPORT);
464 }
465
466 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest323, TestSize.Level0)
467 {
468 char *testC = nullptr;
469 HcfResult ret = dsa2048KeyPair_->pubKey->getAsyKeySpecString(dsa2048KeyPair_->pubKey, DSA_P_BN, &testC);
470
471 ASSERT_EQ(ret, HCF_NOT_SUPPORT);
472 ASSERT_EQ(testC, nullptr);
473 }
474
475 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest324, TestSize.Level0)
476 {
477 const char *skClassName = dsa2048KeyPair_->priKey->base.base.getClass();
478 ASSERT_EQ(skClassName, OPENSSL_DSA_PRIKEY_CLASS);
479 }
480
481 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest325, TestSize.Level0)
482 {
483 HcfAsyKeyGenerator *generator = nullptr;
484 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
485
486 ASSERT_EQ(ret, HCF_SUCCESS);
487 ASSERT_NE(generator, nullptr);
488
489 HcfKeyPair *keyPair = nullptr;
490 ret = generator->generateKeyPair(generator, nullptr, &keyPair);
491
492 HcfObjDestroy(generator);
493 ASSERT_EQ(ret, HCF_SUCCESS);
494 ASSERT_NE(keyPair, nullptr);
495
496 keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
497 keyPair->priKey = nullptr;
498 HcfObjDestroy(keyPair);
499 }
500
501 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest326, TestSize.Level0)
502 {
503 const char *alg = dsa2048KeyPair_->priKey->base.getAlgorithm(&(dsa2048KeyPair_->priKey->base));
504 ASSERT_EQ(alg, g_algNameDSA);
505 }
506
507 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest327, TestSize.Level0)
508 {
509 HcfBlob blob = { .data = nullptr, .len = 0 };
510 HcfResult ret = dsa2048KeyPair_->priKey->base.getEncoded(&(dsa2048KeyPair_->priKey->base), &blob);
511
512 ASSERT_EQ(ret, HCF_SUCCESS);
513 ASSERT_NE(blob.data, nullptr);
514 ASSERT_NE(blob.len, 0);
515 HcfFree(blob.data);
516 }
517
518 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest328, TestSize.Level0)
519 {
520 const char *skFormat = dsa2048KeyPair_->priKey->base.getFormat(&(dsa2048KeyPair_->priKey->base));
521 ASSERT_STREQ(skFormat, g_opensslDsaPriKeyFormat);
522 }
523
524 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest329, TestSize.Level0)
525 {
526 HcfBigInteger p = { .data = nullptr, .len = 0 };
527 HcfResult ret = dsa2048KeyPair_->priKey->getAsyKeySpecBigInteger(dsa2048KeyPair_->priKey, DSA_P_BN, &p);
528
529 ASSERT_EQ(ret, HCF_SUCCESS);
530 ASSERT_NE(p.data, nullptr);
531 ASSERT_NE(p.len, 0);
532 HcfFree(p.data);
533 }
534
535 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest330, TestSize.Level0)
536 {
537 HcfBigInteger q = { .data = nullptr, .len = 0 };
538 HcfResult ret = dsa2048KeyPair_->priKey->getAsyKeySpecBigInteger(dsa2048KeyPair_->priKey, DSA_Q_BN, &q);
539
540 ASSERT_EQ(ret, HCF_SUCCESS);
541 ASSERT_NE(q.data, nullptr);
542 ASSERT_NE(q.len, 0);
543 HcfFree(q.data);
544 }
545
546 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest331, TestSize.Level0)
547 {
548 HcfBigInteger g = { .data = nullptr, .len = 0 };
549 HcfResult ret = dsa2048KeyPair_->priKey->getAsyKeySpecBigInteger(dsa2048KeyPair_->priKey, DSA_G_BN, &g);
550
551 ASSERT_EQ(ret, HCF_SUCCESS);
552 ASSERT_NE(g.data, nullptr);
553 ASSERT_NE(g.len, 0);
554 HcfFree(g.data);
555 }
556
557 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest332, TestSize.Level0)
558 {
559 HcfBigInteger sk = { .data = nullptr, .len = 0 };
560 HcfResult ret = dsa2048KeyPair_->priKey->getAsyKeySpecBigInteger(dsa2048KeyPair_->priKey, DSA_SK_BN, &sk);
561
562 ASSERT_EQ(ret, HCF_SUCCESS);
563 ASSERT_NE(sk.data, nullptr);
564 ASSERT_NE(sk.len, 0);
565 HcfFree(sk.data);
566 }
567
568 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest333, TestSize.Level0)
569 {
570 int testI;
571 HcfResult ret = dsa2048KeyPair_->priKey->getAsyKeySpecInt(dsa2048KeyPair_->priKey, DSA_P_BN, &testI);
572 ASSERT_EQ(ret, HCF_NOT_SUPPORT);
573 }
574
575 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest334, TestSize.Level0)
576 {
577 char *testC;
578 HcfResult ret = dsa2048KeyPair_->priKey->getAsyKeySpecString(dsa2048KeyPair_->priKey, DSA_P_BN, &testC);
579 ASSERT_EQ(ret, HCF_NOT_SUPPORT);
580 }
581
582 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest335, TestSize.Level0)
583 {
584 HcfAsyKeyGenerator *generator = nullptr;
585 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
586
587 ASSERT_EQ(ret, HCF_SUCCESS);
588 ASSERT_NE(generator, nullptr);
589
590 HcfKeyPair *keyPair = nullptr;
591 ret = generator->generateKeyPair(generator, nullptr, &keyPair);
592
593 HcfObjDestroy(generator);
594 ASSERT_EQ(ret, HCF_SUCCESS);
595 ASSERT_NE(keyPair, nullptr);
596
597 keyPair->priKey->clearMem(keyPair->priKey);
598 HcfObjDestroy(keyPair);
599 }
600
601 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest409, TestSize.Level0)
602 {
603 HcfAsyKeyGenerator *generator = nullptr;
604 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA1024", &generator);
605 ASSERT_EQ(ret, HCF_SUCCESS);
606 ASSERT_NE(generator, nullptr);
607
608 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
609 HcfBlob skBlob = { .data = nullptr, .len = 0 };
610 EXPECT_EQ(GetKeyEncodedTest(dsa1024KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
611
612 HcfKeyPair *convertKeyPair = nullptr;
613 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
614 EXPECT_EQ(ret, HCF_SUCCESS);
615 EXPECT_NE(convertKeyPair, nullptr);
616
617 HcfObjDestroy(generator);
618 HcfObjDestroy(convertKeyPair);
619 }
620
621 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest410, TestSize.Level0)
622 {
623 HcfAsyKeyGenerator *generator = nullptr;
624 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
625 ASSERT_EQ(ret, HCF_SUCCESS);
626 ASSERT_NE(generator, nullptr);
627
628 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
629 HcfBlob skBlob = { .data = nullptr, .len = 0 };
630 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
631
632 HcfKeyPair *convertKeyPair = nullptr;
633 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
634 EXPECT_EQ(ret, HCF_SUCCESS);
635 EXPECT_NE(convertKeyPair, nullptr);
636
637 HcfObjDestroy(generator);
638 HcfObjDestroy(convertKeyPair);
639 }
640
641 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest411, TestSize.Level0)
642 {
643 HcfAsyKeyGenerator *generator = nullptr;
644 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA3072", &generator);
645 ASSERT_EQ(ret, HCF_SUCCESS);
646 ASSERT_NE(generator, nullptr);
647
648 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
649 HcfBlob skBlob = { .data = nullptr, .len = 0 };
650 EXPECT_EQ(GetKeyEncodedTest(dsa3072KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
651
652 HcfKeyPair *convertKeyPair = nullptr;
653 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
654 EXPECT_EQ(ret, HCF_SUCCESS);
655 EXPECT_NE(convertKeyPair, nullptr);
656
657 HcfObjDestroy(generator);
658 HcfObjDestroy(convertKeyPair);
659 }
660
661 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest501, TestSize.Level0)
662 {
663 HcfAsyKeyGenerator *generator = nullptr;
664 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
665 ASSERT_EQ(ret, HCF_SUCCESS);
666 ASSERT_NE(generator, nullptr);
667
668 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
669 HcfBlob skBlob = { .data = nullptr, .len = 0 };
670 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
671
672 HcfKeyPair *convertKeyPair = nullptr;
673 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
674 EXPECT_EQ(ret, HCF_SUCCESS);
675 EXPECT_NE(convertKeyPair, nullptr);
676
677 const char *keyPairClassName = convertKeyPair->base.getClass();
678 EXPECT_EQ(keyPairClassName, OPENSSL_DSA_KEYPAIR_CLASS);
679
680 HcfObjDestroy(generator);
681 HcfObjDestroy(convertKeyPair);
682 }
683
684 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest502, TestSize.Level0)
685 {
686 HcfAsyKeyGenerator *generator = nullptr;
687 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
688 ASSERT_EQ(ret, HCF_SUCCESS);
689 ASSERT_NE(generator, nullptr);
690
691 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
692 HcfBlob skBlob = { .data = nullptr, .len = 0 };
693 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
694
695 HcfKeyPair *convertKeyPair = nullptr;
696 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
697 EXPECT_EQ(ret, HCF_SUCCESS);
698 EXPECT_NE(convertKeyPair, nullptr);
699
700 convertKeyPair->base.destroy(&(convertKeyPair->base));
701 HcfObjDestroy(generator);
702 }
703
704 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest503, TestSize.Level0)
705 {
706 HcfAsyKeyGenerator *generator = nullptr;
707 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
708 ASSERT_EQ(ret, HCF_SUCCESS);
709 ASSERT_NE(generator, nullptr);
710
711 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
712 HcfBlob skBlob = { .data = nullptr, .len = 0 };
713 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
714
715 HcfKeyPair *convertKeyPair = nullptr;
716 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
717 EXPECT_EQ(ret, HCF_SUCCESS);
718 EXPECT_NE(convertKeyPair, nullptr);
719
720 const char *pkClassName = convertKeyPair->pubKey->base.base.getClass();
721 EXPECT_EQ(pkClassName, OPENSSL_DSA_PUBKEY_CLASS);
722
723 HcfObjDestroy(generator);
724 HcfObjDestroy(convertKeyPair);
725 }
726
727 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest504, TestSize.Level0)
728 {
729 HcfAsyKeyGenerator *generator = nullptr;
730 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
731 ASSERT_EQ(ret, HCF_SUCCESS);
732 ASSERT_NE(generator, nullptr);
733
734 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
735 HcfBlob skBlob = { .data = nullptr, .len = 0 };
736 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
737
738 HcfKeyPair *convertKeyPair = nullptr;
739 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
740 EXPECT_EQ(ret, HCF_SUCCESS);
741 EXPECT_NE(convertKeyPair, nullptr);
742
743 convertKeyPair->pubKey->base.base.destroy(&(convertKeyPair->pubKey->base.base));
744 convertKeyPair->pubKey = nullptr;
745
746 HcfObjDestroy(generator);
747 HcfObjDestroy(convertKeyPair);
748 }
749
750 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest505, TestSize.Level0)
751 {
752 HcfAsyKeyGenerator *generator = nullptr;
753 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
754 ASSERT_EQ(ret, HCF_SUCCESS);
755 ASSERT_NE(generator, nullptr);
756
757 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
758 HcfBlob skBlob = { .data = nullptr, .len = 0 };
759 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
760
761 HcfKeyPair *convertKeyPair = nullptr;
762 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
763 EXPECT_EQ(ret, HCF_SUCCESS);
764 EXPECT_NE(convertKeyPair, nullptr);
765
766 const char *alg = convertKeyPair->pubKey->base.getAlgorithm(&(convertKeyPair->pubKey->base));
767 EXPECT_EQ(alg, g_algNameDSA);
768
769 HcfObjDestroy(generator);
770 HcfObjDestroy(convertKeyPair);
771 }
772
773 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest506, TestSize.Level0)
774 {
775 HcfAsyKeyGenerator *generator = nullptr;
776 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
777 ASSERT_EQ(ret, HCF_SUCCESS);
778 ASSERT_NE(generator, nullptr);
779
780 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
781 HcfBlob skBlob = { .data = nullptr, .len = 0 };
782 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
783
784 HcfKeyPair *convertKeyPair = nullptr;
785 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
786 EXPECT_EQ(ret, HCF_SUCCESS);
787 EXPECT_NE(convertKeyPair, nullptr);
788
789 HcfBlob blob = { .data = nullptr, .len = 0 };
790 ret = convertKeyPair->pubKey->base.getEncoded(&(convertKeyPair->pubKey->base), &blob);
791
792 HcfObjDestroy(generator);
793 HcfObjDestroy(convertKeyPair);
794 ASSERT_EQ(ret, HCF_SUCCESS);
795 ASSERT_NE(blob.data, nullptr);
796 ASSERT_NE(blob.len, 0);
797 HcfFree(blob.data);
798 }
799
800 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest507, TestSize.Level0)
801 {
802 HcfAsyKeyGenerator *generator = nullptr;
803 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
804 ASSERT_EQ(ret, HCF_SUCCESS);
805 ASSERT_NE(generator, nullptr);
806
807 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
808 HcfBlob skBlob = { .data = nullptr, .len = 0 };
809 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
810
811 HcfKeyPair *convertKeyPair = nullptr;
812 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
813 EXPECT_EQ(ret, HCF_SUCCESS);
814 EXPECT_NE(convertKeyPair, nullptr);
815
816 const char *pkFormat = convertKeyPair->pubKey->base.getFormat(&(convertKeyPair->pubKey->base));
817 HcfObjDestroy(generator);
818 HcfObjDestroy(convertKeyPair);
819 ASSERT_STREQ(pkFormat, g_opensslDsaPubKeyFormat);
820 }
821
822 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest508, TestSize.Level0)
823 {
824 HcfAsyKeyGenerator *generator = nullptr;
825 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
826 ASSERT_EQ(ret, HCF_SUCCESS);
827 ASSERT_NE(generator, nullptr);
828
829 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
830 HcfBlob skBlob = { .data = nullptr, .len = 0 };
831 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
832
833 HcfKeyPair *convertKeyPair = nullptr;
834 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
835 EXPECT_EQ(ret, HCF_SUCCESS);
836 EXPECT_NE(convertKeyPair, nullptr);
837
838 HcfBigInteger p = { .data = nullptr, .len = 0 };
839 ret = convertKeyPair->pubKey->getAsyKeySpecBigInteger(convertKeyPair->pubKey, DSA_P_BN, &p);
840 HcfObjDestroy(generator);
841 HcfObjDestroy(convertKeyPair);
842
843 ASSERT_EQ(ret, HCF_SUCCESS);
844 ASSERT_NE(p.data, nullptr);
845 ASSERT_NE(p.len, 0);
846 HcfFree(p.data);
847 }
848
849 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest509, TestSize.Level0)
850 {
851 HcfAsyKeyGenerator *generator = nullptr;
852 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
853 ASSERT_EQ(ret, HCF_SUCCESS);
854 ASSERT_NE(generator, nullptr);
855
856 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
857 HcfBlob skBlob = { .data = nullptr, .len = 0 };
858 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
859
860 HcfKeyPair *convertKeyPair = nullptr;
861 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
862 EXPECT_EQ(ret, HCF_SUCCESS);
863 EXPECT_NE(convertKeyPair, nullptr);
864
865 HcfBigInteger q = { .data = nullptr, .len = 0 };
866 ret = convertKeyPair->pubKey->getAsyKeySpecBigInteger(convertKeyPair->pubKey, DSA_Q_BN, &q);
867 HcfObjDestroy(generator);
868 HcfObjDestroy(convertKeyPair);
869
870 ASSERT_EQ(ret, HCF_SUCCESS);
871 ASSERT_NE(q.data, nullptr);
872 ASSERT_NE(q.len, 0);
873 HcfFree(q.data);
874 }
875
876 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest510, TestSize.Level0)
877 {
878 HcfAsyKeyGenerator *generator = nullptr;
879 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
880 ASSERT_EQ(ret, HCF_SUCCESS);
881 ASSERT_NE(generator, nullptr);
882
883 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
884 HcfBlob skBlob = { .data = nullptr, .len = 0 };
885 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
886
887 HcfKeyPair *convertKeyPair = nullptr;
888 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
889 EXPECT_EQ(ret, HCF_SUCCESS);
890 EXPECT_NE(convertKeyPair, nullptr);
891
892 HcfBigInteger g = { .data = nullptr, .len = 0 };
893 ret = convertKeyPair->pubKey->getAsyKeySpecBigInteger(convertKeyPair->pubKey, DSA_G_BN, &g);
894 HcfObjDestroy(generator);
895 HcfObjDestroy(convertKeyPair);
896
897 ASSERT_EQ(ret, HCF_SUCCESS);
898 ASSERT_NE(g.data, nullptr);
899 ASSERT_NE(g.len, 0);
900 HcfFree(g.data);
901 }
902
903 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest511, TestSize.Level0)
904 {
905 HcfAsyKeyGenerator *generator = nullptr;
906 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
907 ASSERT_EQ(ret, HCF_SUCCESS);
908 ASSERT_NE(generator, nullptr);
909
910 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
911 HcfBlob skBlob = { .data = nullptr, .len = 0 };
912 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
913
914 HcfKeyPair *convertKeyPair = nullptr;
915 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
916 EXPECT_EQ(ret, HCF_SUCCESS);
917 EXPECT_NE(convertKeyPair, nullptr);
918
919 HcfBigInteger pk = { .data = nullptr, .len = 0 };
920 ret = convertKeyPair->pubKey->getAsyKeySpecBigInteger(convertKeyPair->pubKey, DSA_PK_BN, &pk);
921 HcfObjDestroy(generator);
922 HcfObjDestroy(convertKeyPair);
923
924 ASSERT_EQ(ret, HCF_SUCCESS);
925 ASSERT_NE(pk.data, nullptr);
926 ASSERT_NE(pk.len, 0);
927 HcfFree(pk.data);
928 }
929
930 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest512, TestSize.Level0)
931 {
932 HcfAsyKeyGenerator *generator = nullptr;
933 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
934 ASSERT_EQ(ret, HCF_SUCCESS);
935 ASSERT_NE(generator, nullptr);
936
937 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
938 HcfBlob skBlob = { .data = nullptr, .len = 0 };
939 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
940
941 HcfKeyPair *convertKeyPair = nullptr;
942 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
943 EXPECT_EQ(ret, HCF_SUCCESS);
944 EXPECT_NE(convertKeyPair, nullptr);
945
946 const char *skClassName = convertKeyPair->priKey->base.base.getClass();
947 EXPECT_EQ(skClassName, OPENSSL_DSA_PRIKEY_CLASS);
948
949 HcfObjDestroy(generator);
950 HcfObjDestroy(convertKeyPair);
951 }
952
953 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest513, TestSize.Level0)
954 {
955 HcfAsyKeyGenerator *generator = nullptr;
956 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
957 ASSERT_EQ(ret, HCF_SUCCESS);
958 ASSERT_NE(generator, nullptr);
959
960 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
961 HcfBlob skBlob = { .data = nullptr, .len = 0 };
962 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
963
964 HcfKeyPair *convertKeyPair = nullptr;
965 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
966 EXPECT_EQ(ret, HCF_SUCCESS);
967 EXPECT_NE(convertKeyPair, nullptr);
968
969 convertKeyPair->priKey->base.base.destroy(&(convertKeyPair->priKey->base.base));
970 convertKeyPair->priKey = nullptr;
971 HcfObjDestroy(generator);
972 HcfObjDestroy(convertKeyPair);
973 }
974
975 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest514, TestSize.Level0)
976 {
977 HcfAsyKeyGenerator *generator = nullptr;
978 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
979 ASSERT_EQ(ret, HCF_SUCCESS);
980 ASSERT_NE(generator, nullptr);
981
982 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
983 HcfBlob skBlob = { .data = nullptr, .len = 0 };
984 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
985
986 HcfKeyPair *convertKeyPair = nullptr;
987 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
988 EXPECT_EQ(ret, HCF_SUCCESS);
989 EXPECT_NE(convertKeyPair, nullptr);
990
991 const char *skAlg = convertKeyPair->priKey->base.getAlgorithm(&(convertKeyPair->priKey->base));
992 EXPECT_EQ(skAlg, g_algNameDSA);
993
994 HcfObjDestroy(generator);
995 HcfObjDestroy(convertKeyPair);
996 }
997
998 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest515, TestSize.Level0)
999 {
1000 HcfAsyKeyGenerator *generator = nullptr;
1001 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1002 ASSERT_EQ(ret, HCF_SUCCESS);
1003 ASSERT_NE(generator, nullptr);
1004
1005 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1006 HcfBlob skBlob = { .data = nullptr, .len = 0 };
1007 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1008
1009 HcfKeyPair *convertKeyPair = nullptr;
1010 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1011 EXPECT_EQ(ret, HCF_SUCCESS);
1012 EXPECT_NE(convertKeyPair, nullptr);
1013
1014 HcfBlob blob = { .data = nullptr, .len = 0 };
1015 ret = convertKeyPair->priKey->base.getEncoded(&(convertKeyPair->priKey->base), &blob);
1016
1017 HcfObjDestroy(generator);
1018 HcfObjDestroy(convertKeyPair);
1019 ASSERT_EQ(ret, HCF_SUCCESS);
1020 ASSERT_NE(blob.data, nullptr);
1021 ASSERT_NE(blob.len, 0);
1022 HcfFree(blob.data);
1023 }
1024
1025 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest516, TestSize.Level0)
1026 {
1027 HcfAsyKeyGenerator *generator = nullptr;
1028 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1029 ASSERT_EQ(ret, HCF_SUCCESS);
1030 ASSERT_NE(generator, nullptr);
1031
1032 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1033 HcfBlob skBlob = { .data = nullptr, .len = 0 };
1034 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1035
1036 HcfKeyPair *convertKeyPair = nullptr;
1037 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1038 EXPECT_EQ(ret, HCF_SUCCESS);
1039 EXPECT_NE(convertKeyPair, nullptr);
1040
1041 const char *skFormat = convertKeyPair->priKey->base.getFormat(&(convertKeyPair->priKey->base));
1042 EXPECT_STREQ(skFormat, g_opensslDsaPriKeyFormat);
1043
1044 HcfObjDestroy(generator);
1045 HcfObjDestroy(convertKeyPair);
1046 }
1047
1048 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest517, TestSize.Level0)
1049 {
1050 HcfAsyKeyGenerator *generator = nullptr;
1051 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1052 ASSERT_EQ(ret, HCF_SUCCESS);
1053 ASSERT_NE(generator, nullptr);
1054
1055 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1056 HcfBlob skBlob = { .data = nullptr, .len = 0 };
1057 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1058
1059 HcfKeyPair *convertKeyPair = nullptr;
1060 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1061 EXPECT_EQ(ret, HCF_SUCCESS);
1062 EXPECT_NE(convertKeyPair, nullptr);
1063
1064 HcfBigInteger p = { .data = nullptr, .len = 0 };
1065 ret = convertKeyPair->priKey->getAsyKeySpecBigInteger(convertKeyPair->priKey, DSA_P_BN, &p);
1066 HcfObjDestroy(generator);
1067 HcfObjDestroy(convertKeyPair);
1068
1069 ASSERT_EQ(ret, HCF_SUCCESS);
1070 ASSERT_NE(p.data, nullptr);
1071 ASSERT_NE(p.len, 0);
1072 HcfFree(p.data);
1073 }
1074
1075 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest518, TestSize.Level0)
1076 {
1077 HcfAsyKeyGenerator *generator = nullptr;
1078 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1079 ASSERT_EQ(ret, HCF_SUCCESS);
1080 ASSERT_NE(generator, nullptr);
1081
1082 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1083 HcfBlob skBlob = { .data = nullptr, .len = 0 };
1084 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1085
1086 HcfKeyPair *convertKeyPair = nullptr;
1087 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1088 EXPECT_EQ(ret, HCF_SUCCESS);
1089 EXPECT_NE(convertKeyPair, nullptr);
1090
1091 HcfBigInteger q = { .data = nullptr, .len = 0 };
1092 ret = convertKeyPair->priKey->getAsyKeySpecBigInteger(convertKeyPair->priKey, DSA_Q_BN, &q);
1093 HcfObjDestroy(generator);
1094 HcfObjDestroy(convertKeyPair);
1095
1096 ASSERT_EQ(ret, HCF_SUCCESS);
1097 ASSERT_NE(q.data, nullptr);
1098 ASSERT_NE(q.len, 0);
1099 HcfFree(q.data);
1100 }
1101
1102 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest519, TestSize.Level0)
1103 {
1104 HcfAsyKeyGenerator *generator = nullptr;
1105 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1106 ASSERT_EQ(ret, HCF_SUCCESS);
1107 ASSERT_NE(generator, nullptr);
1108
1109 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1110 HcfBlob skBlob = { .data = nullptr, .len = 0 };
1111 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1112
1113 HcfKeyPair *convertKeyPair = nullptr;
1114 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1115 EXPECT_EQ(ret, HCF_SUCCESS);
1116 EXPECT_NE(convertKeyPair, nullptr);
1117
1118 HcfBigInteger g = { .data = nullptr, .len = 0 };
1119 ret = convertKeyPair->priKey->getAsyKeySpecBigInteger(convertKeyPair->priKey, DSA_G_BN, &g);
1120 HcfObjDestroy(generator);
1121 HcfObjDestroy(convertKeyPair);
1122
1123 ASSERT_EQ(ret, HCF_SUCCESS);
1124 ASSERT_NE(g.data, nullptr);
1125 ASSERT_NE(g.len, 0);
1126 HcfFree(g.data);
1127 }
1128
1129 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest520, TestSize.Level0)
1130 {
1131 HcfAsyKeyGenerator *generator = nullptr;
1132 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1133 ASSERT_EQ(ret, HCF_SUCCESS);
1134 ASSERT_NE(generator, nullptr);
1135
1136 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1137 HcfBlob skBlob = { .data = nullptr, .len = 0 };
1138 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1139
1140 HcfKeyPair *convertKeyPair = nullptr;
1141 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1142 EXPECT_EQ(ret, HCF_SUCCESS);
1143 EXPECT_NE(convertKeyPair, nullptr);
1144
1145 HcfBigInteger sk = { .data = nullptr, .len = 0 };
1146 ret = convertKeyPair->priKey->getAsyKeySpecBigInteger(convertKeyPair->priKey, DSA_SK_BN, &sk);
1147 HcfObjDestroy(generator);
1148 HcfObjDestroy(convertKeyPair);
1149
1150 ASSERT_EQ(ret, HCF_SUCCESS);
1151 ASSERT_NE(sk.data, nullptr);
1152 ASSERT_NE(sk.len, 0);
1153 HcfFree(sk.data);
1154 }
1155
1156 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest521, TestSize.Level0)
1157 {
1158 HcfAsyKeyGenerator *generator = nullptr;
1159 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1160 ASSERT_EQ(ret, HCF_SUCCESS);
1161 ASSERT_NE(generator, nullptr);
1162
1163 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1164 HcfBlob skBlob = { .data = nullptr, .len = 0 };
1165 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1166
1167 HcfKeyPair *convertKeyPair = nullptr;
1168 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1169 EXPECT_EQ(ret, HCF_SUCCESS);
1170 EXPECT_NE(convertKeyPair, nullptr);
1171
1172 convertKeyPair->priKey->clearMem(convertKeyPair->priKey);
1173 HcfObjDestroy(generator);
1174 HcfObjDestroy(convertKeyPair);
1175 }
1176
1177 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest522, TestSize.Level0)
1178 {
1179 HcfAsyKeyGenerator *generator = nullptr;
1180 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1181 ASSERT_EQ(ret, HCF_SUCCESS);
1182 ASSERT_NE(generator, nullptr);
1183
1184 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1185 HcfBlob skBlob = { .data = nullptr, .len = 0 };
1186 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1187
1188 HcfKeyPair *convertKeyPair = nullptr;
1189 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1190 EXPECT_EQ(ret, HCF_SUCCESS);
1191 EXPECT_NE(convertKeyPair, nullptr);
1192
1193 int testI;
1194 ret = convertKeyPair->priKey->getAsyKeySpecInt(convertKeyPair->priKey, DSA_P_BN, &testI);
1195 EXPECT_EQ(ret, HCF_NOT_SUPPORT);
1196
1197 HcfObjDestroy(generator);
1198 HcfObjDestroy(convertKeyPair);
1199 }
1200
1201 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest523, TestSize.Level0)
1202 {
1203 HcfAsyKeyGenerator *generator = nullptr;
1204 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1205 ASSERT_EQ(ret, HCF_SUCCESS);
1206 ASSERT_NE(generator, nullptr);
1207
1208 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1209 HcfBlob skBlob = { .data = nullptr, .len = 0 };
1210 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1211
1212 HcfKeyPair *convertKeyPair = nullptr;
1213 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1214 EXPECT_EQ(ret, HCF_SUCCESS);
1215 EXPECT_NE(convertKeyPair, nullptr);
1216
1217 char *testC;
1218 ret = convertKeyPair->priKey->getAsyKeySpecString(convertKeyPair->priKey, DSA_P_BN, &testC);
1219 HcfObjDestroy(generator);
1220 HcfObjDestroy(convertKeyPair);
1221 ASSERT_EQ(ret, HCF_NOT_SUPPORT);
1222 }
1223
1224 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest524, TestSize.Level0)
1225 {
1226 HcfAsyKeyGenerator *generator = nullptr;
1227 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1228 ASSERT_EQ(ret, HCF_SUCCESS);
1229 ASSERT_NE(generator, nullptr);
1230
1231 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1232 HcfBlob skBlob = { .data = nullptr, .len = 0 };
1233 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1234
1235 HcfKeyPair *convertKeyPair = nullptr;
1236 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1237 EXPECT_EQ(ret, HCF_SUCCESS);
1238 EXPECT_NE(convertKeyPair, nullptr);
1239
1240 int testI;
1241 ret = convertKeyPair->pubKey->getAsyKeySpecInt(convertKeyPair->pubKey, DSA_P_BN, &testI);
1242 HcfObjDestroy(generator);
1243 HcfObjDestroy(convertKeyPair);
1244 ASSERT_EQ(ret, HCF_NOT_SUPPORT);
1245 }
1246
1247 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest525, TestSize.Level0)
1248 {
1249 HcfAsyKeyGenerator *generator = nullptr;
1250 HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1251 ASSERT_EQ(ret, HCF_SUCCESS);
1252 ASSERT_NE(generator, nullptr);
1253
1254 HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1255 HcfBlob skBlob = { .data = nullptr, .len = 0 };
1256 EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1257
1258 HcfKeyPair *convertKeyPair = nullptr;
1259 ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1260 EXPECT_EQ(ret, HCF_SUCCESS);
1261 EXPECT_NE(convertKeyPair, nullptr);
1262
1263 char *testC;
1264 ret = convertKeyPair->pubKey->getAsyKeySpecString(convertKeyPair->pubKey, DSA_P_BN, &testC);
1265 HcfObjDestroy(generator);
1266 HcfObjDestroy(convertKeyPair);
1267 ASSERT_EQ(ret, HCF_NOT_SUPPORT);
1268 }
1269 }