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 }