• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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     EXPECT_STREQ(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     EXPECT_STREQ(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     EXPECT_STREQ(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     EXPECT_STREQ(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     EXPECT_STREQ(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     HcfFree(pkBlob.data);
620     HcfFree(skBlob.data);
621 }
622 
623 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest410, TestSize.Level0)
624 {
625     HcfAsyKeyGenerator *generator = nullptr;
626     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
627     ASSERT_EQ(ret, HCF_SUCCESS);
628     ASSERT_NE(generator, nullptr);
629 
630     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
631     HcfBlob skBlob = { .data = nullptr, .len = 0 };
632     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
633 
634     HcfKeyPair *convertKeyPair = nullptr;
635     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
636     EXPECT_EQ(ret, HCF_SUCCESS);
637     EXPECT_NE(convertKeyPair, nullptr);
638 
639     HcfObjDestroy(generator);
640     HcfObjDestroy(convertKeyPair);
641     HcfFree(pkBlob.data);
642     HcfFree(skBlob.data);
643 }
644 
645 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest411, TestSize.Level0)
646 {
647     HcfAsyKeyGenerator *generator = nullptr;
648     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA3072", &generator);
649     ASSERT_EQ(ret, HCF_SUCCESS);
650     ASSERT_NE(generator, nullptr);
651 
652     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
653     HcfBlob skBlob = { .data = nullptr, .len = 0 };
654     EXPECT_EQ(GetKeyEncodedTest(dsa3072KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
655 
656     HcfKeyPair *convertKeyPair = nullptr;
657     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
658     EXPECT_EQ(ret, HCF_SUCCESS);
659     EXPECT_NE(convertKeyPair, nullptr);
660 
661     HcfObjDestroy(generator);
662     HcfObjDestroy(convertKeyPair);
663     HcfFree(pkBlob.data);
664     HcfFree(skBlob.data);
665 }
666 
667 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest501, TestSize.Level0)
668 {
669     HcfAsyKeyGenerator *generator = nullptr;
670     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
671     ASSERT_EQ(ret, HCF_SUCCESS);
672     ASSERT_NE(generator, nullptr);
673 
674     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
675     HcfBlob skBlob = { .data = nullptr, .len = 0 };
676     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
677 
678     HcfKeyPair *convertKeyPair = nullptr;
679     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
680     EXPECT_EQ(ret, HCF_SUCCESS);
681     EXPECT_NE(convertKeyPair, nullptr);
682 
683     const char *keyPairClassName = convertKeyPair->base.getClass();
684     EXPECT_STREQ(keyPairClassName, OPENSSL_DSA_KEYPAIR_CLASS);
685 
686     HcfObjDestroy(generator);
687     HcfObjDestroy(convertKeyPair);
688     HcfFree(pkBlob.data);
689     HcfFree(skBlob.data);
690 }
691 
692 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest502, TestSize.Level0)
693 {
694     HcfAsyKeyGenerator *generator = nullptr;
695     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
696     ASSERT_EQ(ret, HCF_SUCCESS);
697     ASSERT_NE(generator, nullptr);
698 
699     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
700     HcfBlob skBlob = { .data = nullptr, .len = 0 };
701     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
702 
703     HcfKeyPair *convertKeyPair = nullptr;
704     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
705     EXPECT_EQ(ret, HCF_SUCCESS);
706     EXPECT_NE(convertKeyPair, nullptr);
707 
708     convertKeyPair->base.destroy(&(convertKeyPair->base));
709     HcfObjDestroy(generator);
710     HcfFree(pkBlob.data);
711     HcfFree(skBlob.data);
712 }
713 
714 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest503, TestSize.Level0)
715 {
716     HcfAsyKeyGenerator *generator = nullptr;
717     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
718     ASSERT_EQ(ret, HCF_SUCCESS);
719     ASSERT_NE(generator, nullptr);
720 
721     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
722     HcfBlob skBlob = { .data = nullptr, .len = 0 };
723     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
724 
725     HcfKeyPair *convertKeyPair = nullptr;
726     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
727     EXPECT_EQ(ret, HCF_SUCCESS);
728     EXPECT_NE(convertKeyPair, nullptr);
729 
730     const char *pkClassName = convertKeyPair->pubKey->base.base.getClass();
731     EXPECT_STREQ(pkClassName, OPENSSL_DSA_PUBKEY_CLASS);
732 
733     HcfObjDestroy(generator);
734     HcfObjDestroy(convertKeyPair);
735     HcfFree(pkBlob.data);
736     HcfFree(skBlob.data);
737 }
738 
739 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest504, TestSize.Level0)
740 {
741     HcfAsyKeyGenerator *generator = nullptr;
742     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
743     ASSERT_EQ(ret, HCF_SUCCESS);
744     ASSERT_NE(generator, nullptr);
745 
746     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
747     HcfBlob skBlob = { .data = nullptr, .len = 0 };
748     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
749 
750     HcfKeyPair *convertKeyPair = nullptr;
751     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
752     EXPECT_EQ(ret, HCF_SUCCESS);
753     EXPECT_NE(convertKeyPair, nullptr);
754 
755     convertKeyPair->pubKey->base.base.destroy(&(convertKeyPair->pubKey->base.base));
756     convertKeyPair->pubKey = nullptr;
757 
758     HcfObjDestroy(generator);
759     HcfObjDestroy(convertKeyPair);
760     HcfFree(pkBlob.data);
761     HcfFree(skBlob.data);
762 }
763 
764 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest505, TestSize.Level0)
765 {
766     HcfAsyKeyGenerator *generator = nullptr;
767     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
768     ASSERT_EQ(ret, HCF_SUCCESS);
769     ASSERT_NE(generator, nullptr);
770 
771     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
772     HcfBlob skBlob = { .data = nullptr, .len = 0 };
773     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
774 
775     HcfKeyPair *convertKeyPair = nullptr;
776     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
777     EXPECT_EQ(ret, HCF_SUCCESS);
778     EXPECT_NE(convertKeyPair, nullptr);
779 
780     const char *alg = convertKeyPair->pubKey->base.getAlgorithm(&(convertKeyPair->pubKey->base));
781     EXPECT_STREQ(alg, g_algNameDSA);
782 
783     HcfObjDestroy(generator);
784     HcfObjDestroy(convertKeyPair);
785     HcfFree(pkBlob.data);
786     HcfFree(skBlob.data);
787 }
788 
789 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest506, TestSize.Level0)
790 {
791     HcfAsyKeyGenerator *generator = nullptr;
792     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
793     ASSERT_EQ(ret, HCF_SUCCESS);
794     ASSERT_NE(generator, nullptr);
795 
796     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
797     HcfBlob skBlob = { .data = nullptr, .len = 0 };
798     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
799 
800     HcfKeyPair *convertKeyPair = nullptr;
801     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
802     EXPECT_EQ(ret, HCF_SUCCESS);
803     EXPECT_NE(convertKeyPair, nullptr);
804 
805     HcfBlob blob = { .data = nullptr, .len = 0 };
806     ret = convertKeyPair->pubKey->base.getEncoded(&(convertKeyPair->pubKey->base), &blob);
807 
808     HcfObjDestroy(generator);
809     HcfObjDestroy(convertKeyPair);
810     HcfFree(pkBlob.data);
811     HcfFree(skBlob.data);
812     ASSERT_EQ(ret, HCF_SUCCESS);
813     ASSERT_NE(blob.data, nullptr);
814     ASSERT_NE(blob.len, 0);
815     HcfFree(blob.data);
816 }
817 
818 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest507, TestSize.Level0)
819 {
820     HcfAsyKeyGenerator *generator = nullptr;
821     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
822     ASSERT_EQ(ret, HCF_SUCCESS);
823     ASSERT_NE(generator, nullptr);
824 
825     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
826     HcfBlob skBlob = { .data = nullptr, .len = 0 };
827     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
828 
829     HcfKeyPair *convertKeyPair = nullptr;
830     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
831     EXPECT_EQ(ret, HCF_SUCCESS);
832     EXPECT_NE(convertKeyPair, nullptr);
833 
834     const char *pkFormat = convertKeyPair->pubKey->base.getFormat(&(convertKeyPair->pubKey->base));
835     HcfObjDestroy(generator);
836     HcfObjDestroy(convertKeyPair);
837     HcfFree(pkBlob.data);
838     HcfFree(skBlob.data);
839     ASSERT_STREQ(pkFormat, g_opensslDsaPubKeyFormat);
840 }
841 
842 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest508, TestSize.Level0)
843 {
844     HcfAsyKeyGenerator *generator = nullptr;
845     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
846     ASSERT_EQ(ret, HCF_SUCCESS);
847     ASSERT_NE(generator, nullptr);
848 
849     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
850     HcfBlob skBlob = { .data = nullptr, .len = 0 };
851     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
852 
853     HcfKeyPair *convertKeyPair = nullptr;
854     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
855     EXPECT_EQ(ret, HCF_SUCCESS);
856     EXPECT_NE(convertKeyPair, nullptr);
857 
858     HcfBigInteger p = { .data = nullptr, .len = 0 };
859     ret = convertKeyPair->pubKey->getAsyKeySpecBigInteger(convertKeyPair->pubKey, DSA_P_BN, &p);
860     HcfObjDestroy(generator);
861     HcfObjDestroy(convertKeyPair);
862     HcfFree(pkBlob.data);
863     HcfFree(skBlob.data);
864 
865     ASSERT_EQ(ret, HCF_SUCCESS);
866     ASSERT_NE(p.data, nullptr);
867     ASSERT_NE(p.len, 0);
868     HcfFree(p.data);
869 }
870 
871 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest509, TestSize.Level0)
872 {
873     HcfAsyKeyGenerator *generator = nullptr;
874     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
875     ASSERT_EQ(ret, HCF_SUCCESS);
876     ASSERT_NE(generator, nullptr);
877 
878     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
879     HcfBlob skBlob = { .data = nullptr, .len = 0 };
880     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
881 
882     HcfKeyPair *convertKeyPair = nullptr;
883     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
884     EXPECT_EQ(ret, HCF_SUCCESS);
885     EXPECT_NE(convertKeyPair, nullptr);
886 
887     HcfBigInteger q = { .data = nullptr, .len = 0 };
888     ret = convertKeyPair->pubKey->getAsyKeySpecBigInteger(convertKeyPair->pubKey, DSA_Q_BN, &q);
889     HcfObjDestroy(generator);
890     HcfObjDestroy(convertKeyPair);
891     HcfFree(pkBlob.data);
892     HcfFree(skBlob.data);
893 
894     ASSERT_EQ(ret, HCF_SUCCESS);
895     ASSERT_NE(q.data, nullptr);
896     ASSERT_NE(q.len, 0);
897     HcfFree(q.data);
898 }
899 
900 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest510, TestSize.Level0)
901 {
902     HcfAsyKeyGenerator *generator = nullptr;
903     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
904     ASSERT_EQ(ret, HCF_SUCCESS);
905     ASSERT_NE(generator, nullptr);
906 
907     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
908     HcfBlob skBlob = { .data = nullptr, .len = 0 };
909     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
910 
911     HcfKeyPair *convertKeyPair = nullptr;
912     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
913     EXPECT_EQ(ret, HCF_SUCCESS);
914     EXPECT_NE(convertKeyPair, nullptr);
915 
916     HcfBigInteger g = { .data = nullptr, .len = 0 };
917     ret = convertKeyPair->pubKey->getAsyKeySpecBigInteger(convertKeyPair->pubKey, DSA_G_BN, &g);
918     HcfObjDestroy(generator);
919     HcfObjDestroy(convertKeyPair);
920     HcfFree(pkBlob.data);
921     HcfFree(skBlob.data);
922 
923     ASSERT_EQ(ret, HCF_SUCCESS);
924     ASSERT_NE(g.data, nullptr);
925     ASSERT_NE(g.len, 0);
926     HcfFree(g.data);
927 }
928 
929 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest511, TestSize.Level0)
930 {
931     HcfAsyKeyGenerator *generator = nullptr;
932     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
933     ASSERT_EQ(ret, HCF_SUCCESS);
934     ASSERT_NE(generator, nullptr);
935 
936     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
937     HcfBlob skBlob = { .data = nullptr, .len = 0 };
938     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
939 
940     HcfKeyPair *convertKeyPair = nullptr;
941     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
942     EXPECT_EQ(ret, HCF_SUCCESS);
943     EXPECT_NE(convertKeyPair, nullptr);
944 
945     HcfBigInteger pk = { .data = nullptr, .len = 0 };
946     ret = convertKeyPair->pubKey->getAsyKeySpecBigInteger(convertKeyPair->pubKey, DSA_PK_BN, &pk);
947     HcfObjDestroy(generator);
948     HcfObjDestroy(convertKeyPair);
949     HcfFree(pkBlob.data);
950     HcfFree(skBlob.data);
951 
952     ASSERT_EQ(ret, HCF_SUCCESS);
953     ASSERT_NE(pk.data, nullptr);
954     ASSERT_NE(pk.len, 0);
955     HcfFree(pk.data);
956 }
957 
958 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest512, TestSize.Level0)
959 {
960     HcfAsyKeyGenerator *generator = nullptr;
961     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
962     ASSERT_EQ(ret, HCF_SUCCESS);
963     ASSERT_NE(generator, nullptr);
964 
965     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
966     HcfBlob skBlob = { .data = nullptr, .len = 0 };
967     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
968 
969     HcfKeyPair *convertKeyPair = nullptr;
970     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
971     EXPECT_EQ(ret, HCF_SUCCESS);
972     EXPECT_NE(convertKeyPair, nullptr);
973 
974     const char *skClassName = convertKeyPair->priKey->base.base.getClass();
975     EXPECT_STREQ(skClassName, OPENSSL_DSA_PRIKEY_CLASS);
976 
977     HcfObjDestroy(generator);
978     HcfObjDestroy(convertKeyPair);
979     HcfFree(pkBlob.data);
980     HcfFree(skBlob.data);
981 }
982 
983 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest513, TestSize.Level0)
984 {
985     HcfAsyKeyGenerator *generator = nullptr;
986     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
987     ASSERT_EQ(ret, HCF_SUCCESS);
988     ASSERT_NE(generator, nullptr);
989 
990     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
991     HcfBlob skBlob = { .data = nullptr, .len = 0 };
992     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
993 
994     HcfKeyPair *convertKeyPair = nullptr;
995     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
996     EXPECT_EQ(ret, HCF_SUCCESS);
997     EXPECT_NE(convertKeyPair, nullptr);
998 
999     convertKeyPair->priKey->base.base.destroy(&(convertKeyPair->priKey->base.base));
1000     convertKeyPair->priKey = nullptr;
1001     HcfObjDestroy(generator);
1002     HcfObjDestroy(convertKeyPair);
1003     HcfFree(pkBlob.data);
1004     HcfFree(skBlob.data);
1005 }
1006 
1007 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest514, TestSize.Level0)
1008 {
1009     HcfAsyKeyGenerator *generator = nullptr;
1010     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1011     ASSERT_EQ(ret, HCF_SUCCESS);
1012     ASSERT_NE(generator, nullptr);
1013 
1014     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1015     HcfBlob skBlob = { .data = nullptr, .len = 0 };
1016     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1017 
1018     HcfKeyPair *convertKeyPair = nullptr;
1019     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1020     EXPECT_EQ(ret, HCF_SUCCESS);
1021     EXPECT_NE(convertKeyPair, nullptr);
1022 
1023     const char *skAlg = convertKeyPair->priKey->base.getAlgorithm(&(convertKeyPair->priKey->base));
1024     EXPECT_STREQ(skAlg, g_algNameDSA);
1025 
1026     HcfObjDestroy(generator);
1027     HcfObjDestroy(convertKeyPair);
1028     HcfFree(pkBlob.data);
1029     HcfFree(skBlob.data);
1030 }
1031 
1032 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest515, TestSize.Level0)
1033 {
1034     HcfAsyKeyGenerator *generator = nullptr;
1035     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1036     ASSERT_EQ(ret, HCF_SUCCESS);
1037     ASSERT_NE(generator, nullptr);
1038 
1039     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1040     HcfBlob skBlob = { .data = nullptr, .len = 0 };
1041     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1042 
1043     HcfKeyPair *convertKeyPair = nullptr;
1044     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1045     EXPECT_EQ(ret, HCF_SUCCESS);
1046     EXPECT_NE(convertKeyPair, nullptr);
1047 
1048     HcfBlob blob = { .data = nullptr, .len = 0 };
1049     ret = convertKeyPair->priKey->base.getEncoded(&(convertKeyPair->priKey->base), &blob);
1050 
1051     HcfObjDestroy(generator);
1052     HcfObjDestroy(convertKeyPair);
1053     HcfFree(pkBlob.data);
1054     HcfFree(skBlob.data);
1055     ASSERT_EQ(ret, HCF_SUCCESS);
1056     ASSERT_NE(blob.data, nullptr);
1057     ASSERT_NE(blob.len, 0);
1058     HcfFree(blob.data);
1059 }
1060 
1061 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest516, TestSize.Level0)
1062 {
1063     HcfAsyKeyGenerator *generator = nullptr;
1064     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1065     ASSERT_EQ(ret, HCF_SUCCESS);
1066     ASSERT_NE(generator, nullptr);
1067 
1068     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1069     HcfBlob skBlob = { .data = nullptr, .len = 0 };
1070     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1071 
1072     HcfKeyPair *convertKeyPair = nullptr;
1073     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1074     EXPECT_EQ(ret, HCF_SUCCESS);
1075     EXPECT_NE(convertKeyPair, nullptr);
1076 
1077     const char *skFormat = convertKeyPair->priKey->base.getFormat(&(convertKeyPair->priKey->base));
1078     EXPECT_STREQ(skFormat, g_opensslDsaPriKeyFormat);
1079 
1080     HcfObjDestroy(generator);
1081     HcfObjDestroy(convertKeyPair);
1082     HcfFree(pkBlob.data);
1083     HcfFree(skBlob.data);
1084 }
1085 
1086 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest517, TestSize.Level0)
1087 {
1088     HcfAsyKeyGenerator *generator = nullptr;
1089     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1090     ASSERT_EQ(ret, HCF_SUCCESS);
1091     ASSERT_NE(generator, nullptr);
1092 
1093     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1094     HcfBlob skBlob = { .data = nullptr, .len = 0 };
1095     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1096 
1097     HcfKeyPair *convertKeyPair = nullptr;
1098     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1099     EXPECT_EQ(ret, HCF_SUCCESS);
1100     EXPECT_NE(convertKeyPair, nullptr);
1101 
1102     HcfBigInteger p = { .data = nullptr, .len = 0 };
1103     ret = convertKeyPair->priKey->getAsyKeySpecBigInteger(convertKeyPair->priKey, DSA_P_BN, &p);
1104     HcfObjDestroy(generator);
1105     HcfObjDestroy(convertKeyPair);
1106     HcfFree(pkBlob.data);
1107     HcfFree(skBlob.data);
1108 
1109     ASSERT_EQ(ret, HCF_SUCCESS);
1110     ASSERT_NE(p.data, nullptr);
1111     ASSERT_NE(p.len, 0);
1112     HcfFree(p.data);
1113 }
1114 
1115 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest518, TestSize.Level0)
1116 {
1117     HcfAsyKeyGenerator *generator = nullptr;
1118     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1119     ASSERT_EQ(ret, HCF_SUCCESS);
1120     ASSERT_NE(generator, nullptr);
1121 
1122     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1123     HcfBlob skBlob = { .data = nullptr, .len = 0 };
1124     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1125 
1126     HcfKeyPair *convertKeyPair = nullptr;
1127     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1128     EXPECT_EQ(ret, HCF_SUCCESS);
1129     EXPECT_NE(convertKeyPair, nullptr);
1130 
1131     HcfBigInteger q = { .data = nullptr, .len = 0 };
1132     ret = convertKeyPair->priKey->getAsyKeySpecBigInteger(convertKeyPair->priKey, DSA_Q_BN, &q);
1133     HcfObjDestroy(generator);
1134     HcfObjDestroy(convertKeyPair);
1135     HcfFree(pkBlob.data);
1136     HcfFree(skBlob.data);
1137 
1138     ASSERT_EQ(ret, HCF_SUCCESS);
1139     ASSERT_NE(q.data, nullptr);
1140     ASSERT_NE(q.len, 0);
1141     HcfFree(q.data);
1142 }
1143 
1144 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest519, TestSize.Level0)
1145 {
1146     HcfAsyKeyGenerator *generator = nullptr;
1147     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1148     ASSERT_EQ(ret, HCF_SUCCESS);
1149     ASSERT_NE(generator, nullptr);
1150 
1151     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1152     HcfBlob skBlob = { .data = nullptr, .len = 0 };
1153     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1154 
1155     HcfKeyPair *convertKeyPair = nullptr;
1156     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1157     EXPECT_EQ(ret, HCF_SUCCESS);
1158     EXPECT_NE(convertKeyPair, nullptr);
1159 
1160     HcfBigInteger g = { .data = nullptr, .len = 0 };
1161     ret = convertKeyPair->priKey->getAsyKeySpecBigInteger(convertKeyPair->priKey, DSA_G_BN, &g);
1162     HcfObjDestroy(generator);
1163     HcfObjDestroy(convertKeyPair);
1164     HcfFree(pkBlob.data);
1165     HcfFree(skBlob.data);
1166 
1167     ASSERT_EQ(ret, HCF_SUCCESS);
1168     ASSERT_NE(g.data, nullptr);
1169     ASSERT_NE(g.len, 0);
1170     HcfFree(g.data);
1171 }
1172 
1173 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest520, TestSize.Level0)
1174 {
1175     HcfAsyKeyGenerator *generator = nullptr;
1176     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1177     ASSERT_EQ(ret, HCF_SUCCESS);
1178     ASSERT_NE(generator, nullptr);
1179 
1180     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1181     HcfBlob skBlob = { .data = nullptr, .len = 0 };
1182     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1183 
1184     HcfKeyPair *convertKeyPair = nullptr;
1185     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1186     EXPECT_EQ(ret, HCF_SUCCESS);
1187     EXPECT_NE(convertKeyPair, nullptr);
1188 
1189     HcfBigInteger sk = { .data = nullptr, .len = 0 };
1190     ret = convertKeyPair->priKey->getAsyKeySpecBigInteger(convertKeyPair->priKey, DSA_SK_BN, &sk);
1191     HcfObjDestroy(generator);
1192     HcfObjDestroy(convertKeyPair);
1193     HcfFree(pkBlob.data);
1194     HcfFree(skBlob.data);
1195 
1196     ASSERT_EQ(ret, HCF_SUCCESS);
1197     ASSERT_NE(sk.data, nullptr);
1198     ASSERT_NE(sk.len, 0);
1199     HcfFree(sk.data);
1200 }
1201 
1202 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest521, TestSize.Level0)
1203 {
1204     HcfAsyKeyGenerator *generator = nullptr;
1205     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1206     ASSERT_EQ(ret, HCF_SUCCESS);
1207     ASSERT_NE(generator, nullptr);
1208 
1209     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1210     HcfBlob skBlob = { .data = nullptr, .len = 0 };
1211     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1212 
1213     HcfKeyPair *convertKeyPair = nullptr;
1214     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1215     EXPECT_EQ(ret, HCF_SUCCESS);
1216     EXPECT_NE(convertKeyPair, nullptr);
1217 
1218     convertKeyPair->priKey->clearMem(convertKeyPair->priKey);
1219     HcfObjDestroy(generator);
1220     HcfObjDestroy(convertKeyPair);
1221     HcfFree(pkBlob.data);
1222     HcfFree(skBlob.data);
1223 }
1224 
1225 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest522, TestSize.Level0)
1226 {
1227     HcfAsyKeyGenerator *generator = nullptr;
1228     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1229     ASSERT_EQ(ret, HCF_SUCCESS);
1230     ASSERT_NE(generator, nullptr);
1231 
1232     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1233     HcfBlob skBlob = { .data = nullptr, .len = 0 };
1234     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1235 
1236     HcfKeyPair *convertKeyPair = nullptr;
1237     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1238     EXPECT_EQ(ret, HCF_SUCCESS);
1239     EXPECT_NE(convertKeyPair, nullptr);
1240 
1241     int testI;
1242     ret = convertKeyPair->priKey->getAsyKeySpecInt(convertKeyPair->priKey, DSA_P_BN, &testI);
1243     EXPECT_EQ(ret, HCF_NOT_SUPPORT);
1244 
1245     HcfObjDestroy(generator);
1246     HcfObjDestroy(convertKeyPair);
1247     HcfFree(pkBlob.data);
1248     HcfFree(skBlob.data);
1249 }
1250 
1251 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest523, TestSize.Level0)
1252 {
1253     HcfAsyKeyGenerator *generator = nullptr;
1254     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1255     ASSERT_EQ(ret, HCF_SUCCESS);
1256     ASSERT_NE(generator, nullptr);
1257 
1258     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1259     HcfBlob skBlob = { .data = nullptr, .len = 0 };
1260     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1261 
1262     HcfKeyPair *convertKeyPair = nullptr;
1263     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1264     EXPECT_EQ(ret, HCF_SUCCESS);
1265     EXPECT_NE(convertKeyPair, nullptr);
1266 
1267     char *testC;
1268     ret = convertKeyPair->priKey->getAsyKeySpecString(convertKeyPair->priKey, DSA_P_BN, &testC);
1269     HcfObjDestroy(generator);
1270     HcfObjDestroy(convertKeyPair);
1271     HcfFree(pkBlob.data);
1272     HcfFree(skBlob.data);
1273     ASSERT_EQ(ret, HCF_NOT_SUPPORT);
1274 }
1275 
1276 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest524, TestSize.Level0)
1277 {
1278     HcfAsyKeyGenerator *generator = nullptr;
1279     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1280     ASSERT_EQ(ret, HCF_SUCCESS);
1281     ASSERT_NE(generator, nullptr);
1282 
1283     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1284     HcfBlob skBlob = { .data = nullptr, .len = 0 };
1285     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1286 
1287     HcfKeyPair *convertKeyPair = nullptr;
1288     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1289     EXPECT_EQ(ret, HCF_SUCCESS);
1290     EXPECT_NE(convertKeyPair, nullptr);
1291 
1292     int testI;
1293     ret = convertKeyPair->pubKey->getAsyKeySpecInt(convertKeyPair->pubKey, DSA_P_BN, &testI);
1294     HcfObjDestroy(generator);
1295     HcfObjDestroy(convertKeyPair);
1296     HcfFree(pkBlob.data);
1297     HcfFree(skBlob.data);
1298     ASSERT_EQ(ret, HCF_NOT_SUPPORT);
1299 }
1300 
1301 HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest525, TestSize.Level0)
1302 {
1303     HcfAsyKeyGenerator *generator = nullptr;
1304     HcfResult ret = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1305     ASSERT_EQ(ret, HCF_SUCCESS);
1306     ASSERT_NE(generator, nullptr);
1307 
1308     HcfBlob pkBlob = { .data = nullptr, .len = 0 };
1309     HcfBlob skBlob = { .data = nullptr, .len = 0 };
1310     EXPECT_EQ(GetKeyEncodedTest(dsa2048KeyPair_, &pkBlob, &skBlob), HCF_SUCCESS);
1311 
1312     HcfKeyPair *convertKeyPair = nullptr;
1313     ret = generator->convertKey(generator, nullptr, &pkBlob, &skBlob, &convertKeyPair);
1314     EXPECT_EQ(ret, HCF_SUCCESS);
1315     EXPECT_NE(convertKeyPair, nullptr);
1316 
1317     char *testC;
1318     ret = convertKeyPair->pubKey->getAsyKeySpecString(convertKeyPair->pubKey, DSA_P_BN, &testC);
1319     HcfObjDestroy(generator);
1320     HcfObjDestroy(convertKeyPair);
1321     HcfFree(pkBlob.data);
1322     HcfFree(skBlob.data);
1323     ASSERT_EQ(ret, HCF_NOT_SUPPORT);
1324 }
1325 }