1 /*
2  * Copyright (C) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *    http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 
18 #include "asy_key_generator.h"
19 #include "big_integer.h"
20 #include "detailed_dsa_key_params.h"
21 #include "memory.h"
22 #include "openssl_class.h"
23 #include "openssl_common.h"
24 
25 using namespace std;
26 using namespace testing::ext;
27 
28 namespace {
29 class CryptoDsaAsyKeyGeneratorBySpecTest : public testing::Test {
30 public:
31     static void SetUpTestCase();
32     static void TearDownTestCase();
33     void SetUp();
34     void TearDown();
35 };
36 
SetUpTestCase()37 void CryptoDsaAsyKeyGeneratorBySpecTest::SetUpTestCase() {}
TearDownTestCase()38 void CryptoDsaAsyKeyGeneratorBySpecTest::TearDownTestCase() {}
SetUp()39 void CryptoDsaAsyKeyGeneratorBySpecTest::SetUp() {}
TearDown()40 void CryptoDsaAsyKeyGeneratorBySpecTest::TearDown() {}
41 
42 constexpr uint32_t DSA2048_PRI_SIZE = 20;
43 constexpr uint32_t DSA2048_PUB_SIZE = 256;
44 constexpr uint32_t DSA2048_P_SIZE = 256;
45 constexpr uint32_t DSA2048_Q_SIZE = 20;
46 constexpr uint32_t DSA2048_G_SIZE = 256;
47 
48 static const char *g_algNameDSA = "DSA";
49 static const char *g_asyKeyGeneratorBySpecClass = "HcfAsyKeyGeneratorBySpec";
50 static const char *g_opensslDsaPubKeyFormat = "X.509";
51 static const char *g_opensslDsaPriKeyFormat = "PKCS#8";
52 
53 static const bool IS_BIG_ENDIAN = IsBigEndian();
54 
55 static unsigned char g_dsa2048PrivBigE[] = {
56     0x32, 0x67, 0x92, 0xf6, 0xc4, 0xe2, 0xe2, 0xe8, 0xa0, 0x8b, 0x6b, 0x45,
57     0x0c, 0x8a, 0x76, 0xb0, 0xee, 0xcf, 0x91, 0xa7,
58 };
59 
60 static unsigned char g_dsa2048PrivLittleE[] = {
61     0xa7, 0x91, 0xcf, 0xee, 0xb0, 0x76, 0x8a, 0x0c, 0x45, 0x6b, 0x8b, 0xa0,
62     0xe8, 0xe2, 0xe2, 0xc4, 0xf6, 0x92, 0x67, 0x32,
63 };
64 
65 static unsigned char g_dsa2048PubBigE[] = {
66     0x17, 0x8f, 0xa8, 0x11, 0x84, 0x92, 0xec, 0x83, 0x47, 0xc7, 0x6a, 0xb0,
67     0x92, 0xaf, 0x5a, 0x20, 0x37, 0xa3, 0x64, 0x79, 0xd2, 0xd0, 0x3d, 0xcd,
68     0xe0, 0x61, 0x88, 0x88, 0x21, 0xcc, 0x74, 0x5d, 0xce, 0x4c, 0x51, 0x47,
69     0xf0, 0xc5, 0x5c, 0x4c, 0x82, 0x7a, 0xaf, 0x72, 0xad, 0xb9, 0xe0, 0x53,
70     0xf2, 0x78, 0xb7, 0xf0, 0xb5, 0x48, 0x7f, 0x8a, 0x3a, 0x18, 0xd1, 0x9f,
71     0x8b, 0x7d, 0xa5, 0x47, 0xb7, 0x95, 0xab, 0x98, 0xf8, 0x7b, 0x74, 0x50,
72     0x56, 0x8e, 0x57, 0xf0, 0xee, 0xf5, 0xb7, 0xba, 0xab, 0x85, 0x86, 0xf9,
73     0x2b, 0xef, 0x41, 0x56, 0xa0, 0xa4, 0x9f, 0xb7, 0x38, 0x00, 0x46, 0x0a,
74     0xa6, 0xf1, 0xfc, 0x1f, 0xd8, 0x4e, 0x85, 0x44, 0x92, 0x43, 0x21, 0x5d,
75     0x6e, 0xcc, 0xc2, 0xcb, 0x26, 0x31, 0x0d, 0x21, 0xc4, 0xbd, 0x8d, 0x24,
76     0xbc, 0xd9, 0x18, 0x19, 0xd7, 0xdc, 0xf1, 0xe7, 0x93, 0x50, 0x48, 0x03,
77     0x2c, 0xae, 0x2e, 0xe7, 0x49, 0x88, 0x5f, 0x93, 0x57, 0x27, 0x99, 0x36,
78     0xb4, 0x20, 0xab, 0xfc, 0xa7, 0x2b, 0xf2, 0xd9, 0x98, 0xd7, 0xd4, 0x34,
79     0x9d, 0x96, 0x50, 0x58, 0x9a, 0xea, 0x54, 0xf3, 0xee, 0xf5, 0x63, 0x14,
80     0xee, 0x85, 0x83, 0x74, 0x76, 0xe1, 0x52, 0x95, 0xc3, 0xf7, 0xeb, 0x04,
81     0x04, 0x7b, 0xa7, 0x28, 0x1b, 0xcc, 0xea, 0x4a, 0x4e, 0x84, 0xda, 0xd8,
82     0x9c, 0x79, 0xd8, 0x9b, 0x66, 0x89, 0x2f, 0xcf, 0xac, 0xd7, 0x79, 0xf9,
83     0xa9, 0xd8, 0x45, 0x13, 0x78, 0xb9, 0x00, 0x14, 0xc9, 0x7e, 0x22, 0x51,
84     0x86, 0x67, 0xb0, 0x9f, 0x26, 0x11, 0x23, 0xc8, 0x38, 0xd7, 0x70, 0x1d,
85     0x15, 0x8e, 0x4d, 0x4f, 0x95, 0x97, 0x40, 0xa1, 0xc2, 0x7e, 0x01, 0x18,
86     0x72, 0xf4, 0x10, 0xe6, 0x8d, 0x52, 0x16, 0x7f, 0xf2, 0xc9, 0xf8, 0x33,
87     0x8b, 0x33, 0xb7, 0xce,
88 };
89 
90 static unsigned char g_dsa2048PubLittleE[] = {
91     0xce, 0xb7, 0x33, 0x8b, 0x33, 0xf8, 0xc9, 0xf2, 0x7f, 0x16, 0x52, 0x8d,
92     0xe6, 0x10, 0xf4, 0x72, 0x18, 0x01, 0x7e, 0xc2, 0xa1, 0x40, 0x97, 0x95,
93     0x4f, 0x4d, 0x8e, 0x15, 0x1d, 0x70, 0xd7, 0x38, 0xc8, 0x23, 0x11, 0x26,
94     0x9f, 0xb0, 0x67, 0x86, 0x51, 0x22, 0x7e, 0xc9, 0x14, 0x00, 0xb9, 0x78,
95     0x13, 0x45, 0xd8, 0xa9, 0xf9, 0x79, 0xd7, 0xac, 0xcf, 0x2f, 0x89, 0x66,
96     0x9b, 0xd8, 0x79, 0x9c, 0xd8, 0xda, 0x84, 0x4e, 0x4a, 0xea, 0xcc, 0x1b,
97     0x28, 0xa7, 0x7b, 0x04, 0x04, 0xeb, 0xf7, 0xc3, 0x95, 0x52, 0xe1, 0x76,
98     0x74, 0x83, 0x85, 0xee, 0x14, 0x63, 0xf5, 0xee, 0xf3, 0x54, 0xea, 0x9a,
99     0x58, 0x50, 0x96, 0x9d, 0x34, 0xd4, 0xd7, 0x98, 0xd9, 0xf2, 0x2b, 0xa7,
100     0xfc, 0xab, 0x20, 0xb4, 0x36, 0x99, 0x27, 0x57, 0x93, 0x5f, 0x88, 0x49,
101     0xe7, 0x2e, 0xae, 0x2c, 0x03, 0x48, 0x50, 0x93, 0xe7, 0xf1, 0xdc, 0xd7,
102     0x19, 0x18, 0xd9, 0xbc, 0x24, 0x8d, 0xbd, 0xc4, 0x21, 0x0d, 0x31, 0x26,
103     0xcb, 0xc2, 0xcc, 0x6e, 0x5d, 0x21, 0x43, 0x92, 0x44, 0x85, 0x4e, 0xd8,
104     0x1f, 0xfc, 0xf1, 0xa6, 0x0a, 0x46, 0x00, 0x38, 0xb7, 0x9f, 0xa4, 0xa0,
105     0x56, 0x41, 0xef, 0x2b, 0xf9, 0x86, 0x85, 0xab, 0xba, 0xb7, 0xf5, 0xee,
106     0xf0, 0x57, 0x8e, 0x56, 0x50, 0x74, 0x7b, 0xf8, 0x98, 0xab, 0x95, 0xb7,
107     0x47, 0xa5, 0x7d, 0x8b, 0x9f, 0xd1, 0x18, 0x3a, 0x8a, 0x7f, 0x48, 0xb5,
108     0xf0, 0xb7, 0x78, 0xf2, 0x53, 0xe0, 0xb9, 0xad, 0x72, 0xaf, 0x7a, 0x82,
109     0x4c, 0x5c, 0xc5, 0xf0, 0x47, 0x51, 0x4c, 0xce, 0x5d, 0x74, 0xcc, 0x21,
110     0x88, 0x88, 0x61, 0xe0, 0xcd, 0x3d, 0xd0, 0xd2, 0x79, 0x64, 0xa3, 0x37,
111     0x20, 0x5a, 0xaf, 0x92, 0xb0, 0x6a, 0xc7, 0x47, 0x83, 0xec, 0x92, 0x84,
112     0x11, 0xa8, 0x8f, 0x17,
113 };
114 
115 static unsigned char g_dsa2048PBigE[] = {
116     0xA0, 0x25, 0xFA, 0xAD, 0xF4, 0x8E, 0xB9, 0xE5, 0x99, 0xF3, 0x5D, 0x6F,
117     0x4F, 0x83, 0x34, 0xE2, 0x7E, 0xCF, 0x6F, 0xBF, 0x30, 0xAF, 0x6F, 0x81,
118     0xEB, 0xF8, 0xC4, 0x13, 0xD9, 0xA0, 0x5D, 0x8B, 0x5C, 0x8E, 0xDC, 0xC2,
119     0x1D, 0x0B, 0x41, 0x32, 0xB0, 0x1F, 0xFE, 0xEF, 0x0C, 0xC2, 0xA2, 0x7E,
120     0x68, 0x5C, 0x28, 0x21, 0xE9, 0xF5, 0xB1, 0x58, 0x12, 0x63, 0x4C, 0x19,
121     0x4E, 0xFF, 0x02, 0x4B, 0x92, 0xED, 0xD2, 0x07, 0x11, 0x4D, 0x8C, 0x58,
122     0x16, 0x5C, 0x55, 0x8E, 0xAD, 0xA3, 0x67, 0x7D, 0xB9, 0x86, 0x6E, 0x0B,
123     0xE6, 0x54, 0x6F, 0x40, 0xAE, 0x0E, 0x67, 0x4C, 0xF9, 0x12, 0x5B, 0x3C,
124     0x08, 0x7A, 0xF7, 0xFC, 0x67, 0x86, 0x69, 0xE7, 0x0A, 0x94, 0x40, 0xBF,
125     0x8B, 0x76, 0xFE, 0x26, 0xD1, 0xF2, 0xA1, 0x1A, 0x84, 0xA1, 0x43, 0x56,
126     0x28, 0xBC, 0x9A, 0x5F, 0xD7, 0x3B, 0x69, 0x89, 0x8A, 0x36, 0x2C, 0x51,
127     0xDF, 0x12, 0x77, 0x2F, 0x57, 0x7B, 0xA0, 0xAA, 0xDD, 0x7F, 0xA1, 0x62,
128     0x3B, 0x40, 0x7B, 0x68, 0x1A, 0x8F, 0x0D, 0x38, 0xBB, 0x21, 0x5D, 0x18,
129     0xFC, 0x0F, 0x46, 0xF7, 0xA3, 0xB0, 0x1D, 0x23, 0xC3, 0xD2, 0xC7, 0x72,
130     0x51, 0x18, 0xDF, 0x46, 0x95, 0x79, 0xD9, 0xBD, 0xB5, 0x19, 0x02, 0x2C,
131     0x87, 0xDC, 0xE7, 0x57, 0x82, 0x7E, 0xF1, 0x8B, 0x06, 0x3D, 0x00, 0xA5,
132     0x7B, 0x6B, 0x26, 0x27, 0x91, 0x0F, 0x6A, 0x77, 0xE4, 0xD5, 0x04, 0xE4,
133     0x12, 0x2C, 0x42, 0xFF, 0xD2, 0x88, 0xBB, 0xD3, 0x92, 0xA0, 0xF9, 0xC8,
134     0x51, 0x64, 0x14, 0x5C, 0xD8, 0xF9, 0x6C, 0x47, 0x82, 0xB4, 0x1C, 0x7F,
135     0x09, 0xB8, 0xF0, 0x25, 0x83, 0x1D, 0x3F, 0x3F, 0x05, 0xB3, 0x21, 0x0A,
136     0x5D, 0xA7, 0xD8, 0x54, 0xC3, 0x65, 0x7D, 0xC3, 0xB0, 0x1D, 0xBF, 0xAE,
137     0xF8, 0x68, 0xCF, 0x9B,
138 };
139 
140 static unsigned char g_dsa2048PLittleE[] = {
141     0x9b, 0xcf, 0x68, 0xf8, 0xae, 0xbf, 0x1d, 0xb0, 0xc3, 0x7d, 0x65, 0xc3,
142     0x54, 0xd8, 0xa7, 0x5d, 0x0a, 0x21, 0xb3, 0x05, 0x3f, 0x3f, 0x1d, 0x83,
143     0x25, 0xf0, 0xb8, 0x09, 0x7f, 0x1c, 0xb4, 0x82, 0x47, 0x6c, 0xf9, 0xd8,
144     0x5c, 0x14, 0x64, 0x51, 0xc8, 0xf9, 0xa0, 0x92, 0xd3, 0xbb, 0x88, 0xd2,
145     0xff, 0x42, 0x2c, 0x12, 0xe4, 0x04, 0xd5, 0xe4, 0x77, 0x6a, 0x0f, 0x91,
146     0x27, 0x26, 0x6b, 0x7b, 0xa5, 0x00, 0x3d, 0x06, 0x8b, 0xf1, 0x7e, 0x82,
147     0x57, 0xe7, 0xdc, 0x87, 0x2c, 0x02, 0x19, 0xb5, 0xbd, 0xd9, 0x79, 0x95,
148     0x46, 0xdf, 0x18, 0x51, 0x72, 0xc7, 0xd2, 0xc3, 0x23, 0x1d, 0xb0, 0xa3,
149     0xf7, 0x46, 0x0f, 0xfc, 0x18, 0x5d, 0x21, 0xbb, 0x38, 0x0d, 0x8f, 0x1a,
150     0x68, 0x7b, 0x40, 0x3b, 0x62, 0xa1, 0x7f, 0xdd, 0xaa, 0xa0, 0x7b, 0x57,
151     0x2f, 0x77, 0x12, 0xdf, 0x51, 0x2c, 0x36, 0x8a, 0x89, 0x69, 0x3b, 0xd7,
152     0x5f, 0x9a, 0xbc, 0x28, 0x56, 0x43, 0xa1, 0x84, 0x1a, 0xa1, 0xf2, 0xd1,
153     0x26, 0xfe, 0x76, 0x8b, 0xbf, 0x40, 0x94, 0x0a, 0xe7, 0x69, 0x86, 0x67,
154     0xfc, 0xf7, 0x7a, 0x08, 0x3c, 0x5b, 0x12, 0xf9, 0x4c, 0x67, 0x0e, 0xae,
155     0x40, 0x6f, 0x54, 0xe6, 0x0b, 0x6e, 0x86, 0xb9, 0x7d, 0x67, 0xa3, 0xad,
156     0x8e, 0x55, 0x5c, 0x16, 0x58, 0x8c, 0x4d, 0x11, 0x07, 0xd2, 0xed, 0x92,
157     0x4b, 0x02, 0xff, 0x4e, 0x19, 0x4c, 0x63, 0x12, 0x58, 0xb1, 0xf5, 0xe9,
158     0x21, 0x28, 0x5c, 0x68, 0x7e, 0xa2, 0xc2, 0x0c, 0xef, 0xfe, 0x1f, 0xb0,
159     0x32, 0x41, 0x0b, 0x1d, 0xc2, 0xdc, 0x8e, 0x5c, 0x8b, 0x5d, 0xa0, 0xd9,
160     0x13, 0xc4, 0xf8, 0xeb, 0x81, 0x6f, 0xaf, 0x30, 0xbf, 0x6f, 0xcf, 0x7e,
161     0xe2, 0x34, 0x83, 0x4f, 0x6f, 0x5d, 0xf3, 0x99, 0xe5, 0xb9, 0x8e, 0xf4,
162     0xad, 0xfa, 0x25, 0xa0,
163 };
164 
165 static unsigned char g_dsa2048QBigE[] = {
166     0x97, 0xE7, 0x33, 0x4D, 0xD3, 0x94, 0x3E, 0x0B, 0xDB, 0x62, 0x74, 0xC6,
167     0xA1, 0x08, 0xDD, 0x19, 0xA3, 0x75, 0x17, 0x1B,
168 };
169 
170 static unsigned char g_dsa2048QLittleE[] = {
171     0x1b, 0x17, 0x75, 0xa3, 0x19, 0xdd, 0x08, 0xa1, 0xc6, 0x74, 0x62, 0xdb,
172     0x0b, 0x3e, 0x94, 0xd3, 0x4d, 0x33, 0xe7, 0x97,
173 };
174 
175 static unsigned char g_dsa2048GBigE[] = {
176     0x2C, 0x78, 0x16, 0x59, 0x34, 0x63, 0xF4, 0xF3, 0x92, 0xFC, 0xB5, 0xA5,
177     0x4F, 0x13, 0xDE, 0x2F, 0x1C, 0xA4, 0x3C, 0xAE, 0xAD, 0x38, 0x3F, 0x7E,
178     0x90, 0xBF, 0x96, 0xA6, 0xAE, 0x25, 0x90, 0x72, 0xF5, 0x8E, 0x80, 0x0C,
179     0x39, 0x1C, 0xD9, 0xEC, 0xBA, 0x90, 0x5B, 0x3A, 0xE8, 0x58, 0x6C, 0x9E,
180     0x30, 0x42, 0x37, 0x02, 0x31, 0x82, 0xBC, 0x6A, 0xDF, 0x6A, 0x09, 0x29,
181     0xE3, 0xC0, 0x46, 0xD1, 0xCB, 0x85, 0xEC, 0x0C, 0x30, 0x5E, 0xEA, 0xC8,
182     0x39, 0x8E, 0x22, 0x9F, 0x22, 0x10, 0xD2, 0x34, 0x61, 0x68, 0x37, 0x3D,
183     0x2E, 0x4A, 0x5B, 0x9A, 0xF5, 0xC1, 0x48, 0xC6, 0xF6, 0xDC, 0x63, 0x1A,
184     0xD3, 0x96, 0x64, 0xBA, 0x34, 0xC9, 0xD1, 0xA0, 0xD1, 0xAE, 0x6C, 0x2F,
185     0x48, 0x17, 0x93, 0x14, 0x43, 0xED, 0xF0, 0x21, 0x30, 0x19, 0xC3, 0x1B,
186     0x5F, 0xDE, 0xA3, 0xF0, 0x70, 0x78, 0x18, 0xE1, 0xA8, 0xE4, 0xEE, 0x2E,
187     0x00, 0xA5, 0xE4, 0xB3, 0x17, 0xC8, 0x0C, 0x7D, 0x6E, 0x42, 0xDC, 0xB7,
188     0x46, 0x00, 0x36, 0x4D, 0xD4, 0x46, 0xAA, 0x3D, 0x3C, 0x46, 0x89, 0x40,
189     0xBF, 0x1D, 0x84, 0x77, 0x0A, 0x75, 0xF3, 0x87, 0x1D, 0x08, 0x4C, 0xA6,
190     0xD1, 0xA9, 0x1C, 0x1E, 0x12, 0x1E, 0xE1, 0xC7, 0x30, 0x28, 0x76, 0xA5,
191     0x7F, 0x6C, 0x85, 0x96, 0x2B, 0x6F, 0xDB, 0x80, 0x66, 0x26, 0xAE, 0xF5,
192     0x93, 0xC7, 0x8E, 0xAE, 0x9A, 0xED, 0xE4, 0xCA, 0x04, 0xEA, 0x3B, 0x72,
193     0xEF, 0xDC, 0x87, 0xED, 0x0D, 0xA5, 0x4C, 0x4A, 0xDD, 0x71, 0x22, 0x64,
194     0x59, 0x69, 0x4E, 0x8E, 0xBF, 0x43, 0xDC, 0xAB, 0x8E, 0x66, 0xBB, 0x01,
195     0xB6, 0xF4, 0xE7, 0xFD, 0xD2, 0xAD, 0x9F, 0x36, 0xC1, 0xA0, 0x29, 0x99,
196     0xD1, 0x96, 0x70, 0x59, 0x06, 0x78, 0x35, 0xBD, 0x65, 0x55, 0x52, 0x9E,
197     0xF8, 0xB2, 0xE5, 0x38,
198 };
199 
200 static unsigned char g_dsa2048GLittleE[] = {
201     0x38, 0xe5, 0xb2, 0xf8, 0x9e, 0x52, 0x55, 0x65, 0xbd, 0x35, 0x78, 0x06,
202     0x59, 0x70, 0x96, 0xd1, 0x99, 0x29, 0xa0, 0xc1, 0x36, 0x9f, 0xad, 0xd2,
203     0xfd, 0xe7, 0xf4, 0xb6, 0x01, 0xbb, 0x66, 0x8e, 0xab, 0xdc, 0x43, 0xbf,
204     0x8e, 0x4e, 0x69, 0x59, 0x64, 0x22, 0x71, 0xdd, 0x4a, 0x4c, 0xa5, 0x0d,
205     0xed, 0x87, 0xdc, 0xef, 0x72, 0x3b, 0xea, 0x04, 0xca, 0xe4, 0xed, 0x9a,
206     0xae, 0x8e, 0xc7, 0x93, 0xf5, 0xae, 0x26, 0x66, 0x80, 0xdb, 0x6f, 0x2b,
207     0x96, 0x85, 0x6c, 0x7f, 0xa5, 0x76, 0x28, 0x30, 0xc7, 0xe1, 0x1e, 0x12,
208     0x1e, 0x1c, 0xa9, 0xd1, 0xa6, 0x4c, 0x08, 0x1d, 0x87, 0xf3, 0x75, 0x0a,
209     0x77, 0x84, 0x1d, 0xbf, 0x40, 0x89, 0x46, 0x3c, 0x3d, 0xaa, 0x46, 0xd4,
210     0x4d, 0x36, 0x00, 0x46, 0xb7, 0xdc, 0x42, 0x6e, 0x7d, 0x0c, 0xc8, 0x17,
211     0xb3, 0xe4, 0xa5, 0x00, 0x2e, 0xee, 0xe4, 0xa8, 0xe1, 0x18, 0x78, 0x70,
212     0xf0, 0xa3, 0xde, 0x5f, 0x1b, 0xc3, 0x19, 0x30, 0x21, 0xf0, 0xed, 0x43,
213     0x14, 0x93, 0x17, 0x48, 0x2f, 0x6c, 0xae, 0xd1, 0xa0, 0xd1, 0xc9, 0x34,
214     0xba, 0x64, 0x96, 0xd3, 0x1a, 0x63, 0xdc, 0xf6, 0xc6, 0x48, 0xc1, 0xf5,
215     0x9a, 0x5b, 0x4a, 0x2e, 0x3d, 0x37, 0x68, 0x61, 0x34, 0xd2, 0x10, 0x22,
216     0x9f, 0x22, 0x8e, 0x39, 0xc8, 0xea, 0x5e, 0x30, 0x0c, 0xec, 0x85, 0xcb,
217     0xd1, 0x46, 0xc0, 0xe3, 0x29, 0x09, 0x6a, 0xdf, 0x6a, 0xbc, 0x82, 0x31,
218     0x02, 0x37, 0x42, 0x30, 0x9e, 0x6c, 0x58, 0xe8, 0x3a, 0x5b, 0x90, 0xba,
219     0xec, 0xd9, 0x1c, 0x39, 0x0c, 0x80, 0x8e, 0xf5, 0x72, 0x90, 0x25, 0xae,
220     0xa6, 0x96, 0xbf, 0x90, 0x7e, 0x3f, 0x38, 0xad, 0xae, 0x3c, 0xa4, 0x1c,
221     0x2f, 0xde, 0x13, 0x4f, 0xa5, 0xb5, 0xfc, 0x92, 0xf3, 0xf4, 0x63, 0x34,
222     0x59, 0x16, 0x78, 0x2c,
223 };
224 
225 static HcfBigInteger sk_BN = {
226     .data = IS_BIG_ENDIAN ? g_dsa2048PrivBigE : g_dsa2048PrivLittleE, .len = DSA2048_PRI_SIZE };
227 static HcfBigInteger pk_BN = {
228     .data = IS_BIG_ENDIAN ? g_dsa2048PubBigE : g_dsa2048PubLittleE, .len = DSA2048_PUB_SIZE };
229 static HcfBigInteger p_BN = { .data = IS_BIG_ENDIAN ? g_dsa2048PBigE : g_dsa2048PLittleE, .len = DSA2048_P_SIZE };
230 static HcfBigInteger q_BN = { .data = IS_BIG_ENDIAN ? g_dsa2048QBigE : g_dsa2048QLittleE, .len = DSA2048_Q_SIZE };
231 static HcfBigInteger g_BN = { .data = IS_BIG_ENDIAN ? g_dsa2048GBigE : g_dsa2048GLittleE, .len = DSA2048_G_SIZE };
232 
233 static HcfAsyKeyParamsSpec asySpecComm = {
234     .algName = const_cast<char *>(g_algNameDSA),
235     .specType = HCF_COMMON_PARAMS_SPEC
236 };
237 static HcfAsyKeyParamsSpec asySpecPk = {
238     .algName = const_cast<char *>(g_algNameDSA),
239     .specType = HCF_PUBLIC_KEY_SPEC
240 };
241 static HcfAsyKeyParamsSpec asySpecKeyPair = {
242     .algName = const_cast<char *>(g_algNameDSA),
243     .specType = HCF_KEY_PAIR_SPEC
244 };
245 
246 static HcfDsaCommParamsSpec dsaCommonSpec = { .base = asySpecComm, .p = p_BN, .q = q_BN, .g = g_BN };
247 static HcfDsaPubKeyParamsSpec dsaPkSpec = {
248     .base = {
249         .base = asySpecPk,
250         .p = p_BN,
251         .q = q_BN,
252         .g = g_BN
253     },
254     .pk = pk_BN
255 };
256 static HcfDsaKeyPairParamsSpec dsaKeyPairSpec = {
257     .base = {
258         .base = asySpecKeyPair,
259         .p = p_BN,
260         .q = q_BN,
261         .g = g_BN
262     },
263     .pk = pk_BN,
264     .sk = sk_BN
265 };
266 
267 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest001, TestSize.Level0)
268 {
269     HcfAsyKeyGeneratorBySpec *generator = nullptr;
270     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
271 
272     ASSERT_EQ(ret, HCF_SUCCESS);
273     ASSERT_NE(generator, nullptr);
274 
275     HcfObjDestroy(generator);
276 }
277 
278 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest002, TestSize.Level0)
279 {
280     HcfAsyKeyGeneratorBySpec *generator = nullptr;
281     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaPkSpec), &generator);
282 
283     ASSERT_EQ(ret, HCF_SUCCESS);
284     ASSERT_NE(generator, nullptr);
285 
286     HcfObjDestroy(generator);
287 }
288 
289 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest003, TestSize.Level0)
290 {
291     HcfAsyKeyGeneratorBySpec *generator = nullptr;
292     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
293         &generator);
294 
295     ASSERT_EQ(ret, HCF_SUCCESS);
296     ASSERT_NE(generator, nullptr);
297 
298     HcfObjDestroy(generator);
299 }
300 
301 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest101, TestSize.Level0)
302 {
303     HcfAsyKeyGeneratorBySpec *generator = nullptr;
304     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
305         &generator);
306     ASSERT_EQ(ret, HCF_SUCCESS);
307     ASSERT_NE(generator, nullptr);
308 
309     const char *className = generator->base.getClass();
310     HcfObjDestroy(generator);
311     ASSERT_EQ(className, g_asyKeyGeneratorBySpecClass);
312 }
313 
314 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest102, TestSize.Level0)
315 {
316     HcfAsyKeyGeneratorBySpec *generator = nullptr;
317     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
318         &generator);
319     ASSERT_EQ(ret, HCF_SUCCESS);
320     ASSERT_NE(generator, nullptr);
321 
322     generator->base.destroy(&(generator->base));
323 }
324 
325 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest103, TestSize.Level0)
326 {
327     HcfAsyKeyGeneratorBySpec *generator = nullptr;
328     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
329         &generator);
330     ASSERT_EQ(ret, HCF_SUCCESS);
331     ASSERT_NE(generator, nullptr);
332 
333     const char *algName = generator->getAlgName(generator);
334 
335     EXPECT_STREQ(algName, g_algNameDSA);
336     HcfObjDestroy(generator);
337 }
338 
339 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest104, TestSize.Level0)
340 {
341     HcfAsyKeyGeneratorBySpec *generator = nullptr;
342     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
343     ASSERT_EQ(ret, HCF_SUCCESS);
344     ASSERT_NE(generator, nullptr);
345 
346     HcfKeyPair *keyPair = nullptr;
347     ret = generator->generateKeyPair(generator, &keyPair);
348     HcfObjDestroy(generator);
349     ASSERT_EQ(ret, HCF_SUCCESS);
350     ASSERT_NE(keyPair, nullptr);
351 
352     keyPair->priKey->clearMem(keyPair->priKey);
353     HcfObjDestroy(keyPair);
354 }
355 
356 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest105, TestSize.Level0)
357 {
358     HcfAsyKeyGeneratorBySpec *generator = nullptr;
359     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
360         &generator);
361     ASSERT_EQ(ret, HCF_SUCCESS);
362     ASSERT_NE(generator, nullptr);
363 
364     HcfKeyPair *keyPair = nullptr;
365     ret = generator->generateKeyPair(generator, &keyPair);
366     HcfObjDestroy(generator);
367     ASSERT_EQ(ret, HCF_SUCCESS);
368     ASSERT_NE(keyPair, nullptr);
369 
370     keyPair->priKey->clearMem(keyPair->priKey);
371     HcfObjDestroy(keyPair);
372 }
373 
374 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest106, TestSize.Level1)
375 {
376     HcfAsyKeyGeneratorBySpec *generator = nullptr;
377     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaPkSpec), &generator);
378     ASSERT_EQ(ret, HCF_SUCCESS);
379     ASSERT_NE(generator, nullptr);
380 
381     HcfKeyPair *keyPair = nullptr;
382     ret = generator->generateKeyPair(generator, &keyPair);
383     HcfObjDestroy(generator);
384     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
385     ASSERT_EQ(keyPair, nullptr);
386 }
387 
388 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest107, TestSize.Level0)
389 {
390     HcfAsyKeyGeneratorBySpec *generator = nullptr;
391     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaPkSpec), &generator);
392     ASSERT_EQ(ret, HCF_SUCCESS);
393     ASSERT_NE(generator, nullptr);
394 
395     HcfPubKey *pk = nullptr;
396     ret = generator->generatePubKey(generator, &pk);
397     HcfObjDestroy(generator);
398     ASSERT_EQ(ret, HCF_SUCCESS);
399     ASSERT_NE(pk, nullptr);
400 
401     HcfObjDestroy(pk);
402 }
403 
404 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest108, TestSize.Level0)
405 {
406     HcfAsyKeyGeneratorBySpec *generator = nullptr;
407     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
408         &generator);
409     ASSERT_EQ(ret, HCF_SUCCESS);
410     ASSERT_NE(generator, nullptr);
411 
412     HcfPubKey *pk = nullptr;
413     ret = generator->generatePubKey(generator, &pk);
414     HcfObjDestroy(generator);
415     ASSERT_EQ(ret, HCF_SUCCESS);
416     ASSERT_NE(pk, nullptr);
417 
418     HcfObjDestroy(pk);
419 }
420 
421 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest109, TestSize.Level1)
422 {
423     HcfAsyKeyGeneratorBySpec *generator = nullptr;
424     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
425     ASSERT_EQ(ret, HCF_SUCCESS);
426     ASSERT_NE(generator, nullptr);
427 
428     HcfPubKey *pk = nullptr;
429     ret = generator->generatePubKey(generator, &pk);
430     HcfObjDestroy(generator);
431     ASSERT_EQ(ret, HCF_INVALID_PARAMS);
432     ASSERT_EQ(pk, nullptr);
433 }
434 
435 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest110, TestSize.Level0)
436 {
437     HcfAsyKeyGeneratorBySpec *generator = nullptr;
438     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
439         &generator);
440     ASSERT_EQ(ret, HCF_SUCCESS);
441     ASSERT_NE(generator, nullptr);
442 
443     HcfPriKey *sk = nullptr;
444     ret = generator->generatePriKey(generator, &sk);
445     HcfObjDestroy(generator);
446     ASSERT_EQ(ret, HCF_SUCCESS);
447     ASSERT_NE(sk, nullptr);
448 
449     sk->clearMem(sk);
450     HcfObjDestroy(sk);
451 }
452 
453 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest201, TestSize.Level0)
454 {
455     HcfAsyKeyGeneratorBySpec *generator = nullptr;
456     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
457     ASSERT_EQ(ret, HCF_SUCCESS);
458     ASSERT_NE(generator, nullptr);
459 
460     HcfKeyPair *keyPair = nullptr;
461     ret = generator->generateKeyPair(generator, &keyPair);
462     HcfObjDestroy(generator);
463     ASSERT_EQ(ret, HCF_SUCCESS);
464     ASSERT_NE(keyPair, nullptr);
465 
466     const char *keyPairClassName = keyPair->base.getClass();
467     EXPECT_STREQ(keyPairClassName, OPENSSL_DSA_KEYPAIR_CLASS);
468     HcfObjDestroy(keyPair);
469 }
470 
471 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest202, TestSize.Level0)
472 {
473     HcfAsyKeyGeneratorBySpec *generator = nullptr;
474     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
475     ASSERT_EQ(ret, HCF_SUCCESS);
476     ASSERT_NE(generator, nullptr);
477 
478     HcfKeyPair *keyPair = nullptr;
479     ret = generator->generateKeyPair(generator, &keyPair);
480     HcfObjDestroy(generator);
481     ASSERT_EQ(ret, HCF_SUCCESS);
482     ASSERT_NE(keyPair, nullptr);
483     keyPair->base.destroy(&(keyPair->base));
484 }
485 
486 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest203, TestSize.Level0)
487 {
488     HcfAsyKeyGeneratorBySpec *generator = nullptr;
489     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
490     ASSERT_EQ(ret, HCF_SUCCESS);
491     ASSERT_NE(generator, nullptr);
492 
493     HcfKeyPair *keyPair = nullptr;
494     ret = generator->generateKeyPair(generator, &keyPair);
495     HcfObjDestroy(generator);
496     ASSERT_EQ(ret, HCF_SUCCESS);
497     ASSERT_NE(keyPair, nullptr);
498 
499     const char *pkClassName = keyPair->pubKey->base.base.getClass();
500     EXPECT_STREQ(pkClassName, OPENSSL_DSA_PUBKEY_CLASS);
501     HcfObjDestroy(keyPair);
502 }
503 
504 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest204, TestSize.Level0)
505 {
506     HcfAsyKeyGeneratorBySpec *generator = nullptr;
507     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
508     ASSERT_EQ(ret, HCF_SUCCESS);
509     ASSERT_NE(generator, nullptr);
510 
511     HcfKeyPair *keyPair = nullptr;
512     ret = generator->generateKeyPair(generator, &keyPair);
513     HcfObjDestroy(generator);
514     ASSERT_EQ(ret, HCF_SUCCESS);
515     ASSERT_NE(keyPair, nullptr);
516 
517     keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
518     keyPair->pubKey = nullptr;
519     HcfObjDestroy(keyPair);
520 }
521 
522 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest205, TestSize.Level0)
523 {
524     HcfAsyKeyGeneratorBySpec *generator = nullptr;
525     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
526     ASSERT_EQ(ret, HCF_SUCCESS);
527     ASSERT_NE(generator, nullptr);
528 
529     HcfKeyPair *keyPair = nullptr;
530     ret = generator->generateKeyPair(generator, &keyPair);
531     HcfObjDestroy(generator);
532     ASSERT_EQ(ret, HCF_SUCCESS);
533     ASSERT_NE(keyPair, nullptr);
534 
535     const char *alg = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
536     EXPECT_STREQ(alg, g_algNameDSA);
537     HcfObjDestroy(keyPair);
538 }
539 
540 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest206, TestSize.Level0)
541 {
542     HcfAsyKeyGeneratorBySpec *generator = nullptr;
543     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
544     ASSERT_EQ(ret, HCF_SUCCESS);
545     ASSERT_NE(generator, nullptr);
546 
547     HcfKeyPair *keyPair = nullptr;
548     ret = generator->generateKeyPair(generator, &keyPair);
549     HcfObjDestroy(generator);
550     ASSERT_EQ(ret, HCF_SUCCESS);
551     ASSERT_NE(keyPair, nullptr);
552 
553     HcfBlob blob = { .data = nullptr, .len = 0 };
554     ret = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
555     HcfObjDestroy(keyPair);
556     ASSERT_EQ(ret, HCF_SUCCESS);
557     ASSERT_NE(blob.data, nullptr);
558     ASSERT_NE(blob.len, 0);
559     HcfFree(blob.data);
560 }
561 
562 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest207, TestSize.Level0)
563 {
564     HcfAsyKeyGeneratorBySpec *generator = nullptr;
565     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
566     ASSERT_EQ(ret, HCF_SUCCESS);
567     ASSERT_NE(generator, nullptr);
568 
569     HcfKeyPair *keyPair = nullptr;
570     ret = generator->generateKeyPair(generator, &keyPair);
571     HcfObjDestroy(generator);
572     ASSERT_EQ(ret, HCF_SUCCESS);
573     ASSERT_NE(keyPair, nullptr);
574 
575     const char *pkFormat = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
576     EXPECT_STREQ(pkFormat, g_opensslDsaPubKeyFormat);
577     HcfObjDestroy(keyPair);
578 }
579 
580 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest208, TestSize.Level0)
581 {
582     HcfAsyKeyGeneratorBySpec *generator = nullptr;
583     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
584     ASSERT_EQ(ret, HCF_SUCCESS);
585     ASSERT_NE(generator, nullptr);
586 
587     HcfKeyPair *keyPair = nullptr;
588     ret = generator->generateKeyPair(generator, &keyPair);
589     HcfObjDestroy(generator);
590     ASSERT_EQ(ret, HCF_SUCCESS);
591     ASSERT_NE(keyPair, nullptr);
592 
593     HcfBigInteger p = { .data = nullptr, .len = 0 };
594     ret = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, DSA_P_BN, &p);
595     HcfObjDestroy(keyPair);
596     ASSERT_EQ(ret, HCF_SUCCESS);
597     ASSERT_NE(p.data, nullptr);
598     ASSERT_NE(p.len, 0);
599     HcfFree(p.data);
600 }
601 
602 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest209, TestSize.Level0)
603 {
604     HcfAsyKeyGeneratorBySpec *generator = nullptr;
605     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
606     ASSERT_EQ(ret, HCF_SUCCESS);
607     ASSERT_NE(generator, nullptr);
608 
609     HcfKeyPair *keyPair = nullptr;
610     ret = generator->generateKeyPair(generator, &keyPair);
611     HcfObjDestroy(generator);
612     ASSERT_EQ(ret, HCF_SUCCESS);
613     ASSERT_NE(keyPair, nullptr);
614 
615     HcfBigInteger q = { .data = nullptr, .len = 0 };
616     ret = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, DSA_Q_BN, &q);
617     HcfObjDestroy(keyPair);
618     ASSERT_EQ(ret, HCF_SUCCESS);
619     ASSERT_NE(q.data, nullptr);
620     ASSERT_NE(q.len, 0);
621     HcfFree(q.data);
622 }
623 
624 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest210, TestSize.Level0)
625 {
626     HcfAsyKeyGeneratorBySpec *generator = nullptr;
627     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
628     ASSERT_EQ(ret, HCF_SUCCESS);
629     ASSERT_NE(generator, nullptr);
630 
631     HcfKeyPair *keyPair = nullptr;
632     ret = generator->generateKeyPair(generator, &keyPair);
633     HcfObjDestroy(generator);
634     ASSERT_EQ(ret, HCF_SUCCESS);
635     ASSERT_NE(keyPair, nullptr);
636 
637     HcfBigInteger g = { .data = nullptr, .len = 0 };
638     ret = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, DSA_G_BN, &g);
639     HcfObjDestroy(keyPair);
640     ASSERT_EQ(ret, HCF_SUCCESS);
641     ASSERT_NE(g.data, nullptr);
642     ASSERT_NE(g.len, 0);
643     HcfFree(g.data);
644 }
645 
646 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest211, TestSize.Level0)
647 {
648     HcfAsyKeyGeneratorBySpec *generator = nullptr;
649     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
650     ASSERT_EQ(ret, HCF_SUCCESS);
651     ASSERT_NE(generator, nullptr);
652 
653     HcfKeyPair *keyPair = nullptr;
654     ret = generator->generateKeyPair(generator, &keyPair);
655     HcfObjDestroy(generator);
656     ASSERT_EQ(ret, HCF_SUCCESS);
657     ASSERT_NE(keyPair, nullptr);
658 
659     HcfBigInteger pk = { .data = nullptr, .len = 0 };
660     ret = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, DSA_PK_BN, &pk);
661     HcfObjDestroy(keyPair);
662     ASSERT_EQ(ret, HCF_SUCCESS);
663     ASSERT_NE(pk.data, nullptr);
664     ASSERT_NE(pk.len, 0);
665     HcfFree(pk.data);
666 }
667 
668 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest212, TestSize.Level0)
669 {
670     HcfAsyKeyGeneratorBySpec *generator = nullptr;
671     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
672     ASSERT_EQ(ret, HCF_SUCCESS);
673     ASSERT_NE(generator, nullptr);
674 
675     HcfKeyPair *keyPair = nullptr;
676     ret = generator->generateKeyPair(generator, &keyPair);
677     HcfObjDestroy(generator);
678     ASSERT_EQ(ret, HCF_SUCCESS);
679     ASSERT_NE(keyPair, nullptr);
680 
681     const char *skClassName = keyPair->priKey->base.base.getClass();
682     EXPECT_STREQ(skClassName, OPENSSL_DSA_PRIKEY_CLASS);
683     HcfObjDestroy(keyPair);
684 }
685 
686 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest213, TestSize.Level0)
687 {
688     HcfAsyKeyGeneratorBySpec *generator = nullptr;
689     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
690     ASSERT_EQ(ret, HCF_SUCCESS);
691     ASSERT_NE(generator, nullptr);
692 
693     HcfKeyPair *keyPair = nullptr;
694     ret = generator->generateKeyPair(generator, &keyPair);
695     HcfObjDestroy(generator);
696     ASSERT_EQ(ret, HCF_SUCCESS);
697     ASSERT_NE(keyPair, nullptr);
698 
699     keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
700     keyPair->priKey = nullptr;
701 
702     HcfObjDestroy(keyPair);
703 }
704 
705 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest214, TestSize.Level0)
706 {
707     HcfAsyKeyGeneratorBySpec *generator = nullptr;
708     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
709     ASSERT_EQ(ret, HCF_SUCCESS);
710     ASSERT_NE(generator, nullptr);
711 
712     HcfKeyPair *keyPair = nullptr;
713     ret = generator->generateKeyPair(generator, &keyPair);
714     HcfObjDestroy(generator);
715     ASSERT_EQ(ret, HCF_SUCCESS);
716     ASSERT_NE(keyPair, nullptr);
717 
718     const char *alg = keyPair->priKey->base.getAlgorithm(&(keyPair->priKey->base));
719     EXPECT_STREQ(alg, g_algNameDSA);
720 
721     HcfObjDestroy(keyPair);
722 }
723 
724 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest215, TestSize.Level0)
725 {
726     HcfAsyKeyGeneratorBySpec *generator = nullptr;
727     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
728     ASSERT_EQ(ret, HCF_SUCCESS);
729     ASSERT_NE(generator, nullptr);
730 
731     HcfKeyPair *keyPair = nullptr;
732     ret = generator->generateKeyPair(generator, &keyPair);
733     HcfObjDestroy(generator);
734     ASSERT_EQ(ret, HCF_SUCCESS);
735     ASSERT_NE(keyPair, nullptr);
736 
737     HcfBlob blob = { .data = nullptr, .len = 0 };
738     ret = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
739     HcfObjDestroy(keyPair);
740     ASSERT_EQ(ret, HCF_SUCCESS);
741     ASSERT_NE(blob.data, nullptr);
742     ASSERT_NE(blob.len, 0);
743     HcfFree(blob.data);
744 }
745 
746 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest216, TestSize.Level0)
747 {
748     HcfAsyKeyGeneratorBySpec *generator = nullptr;
749     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
750     ASSERT_EQ(ret, HCF_SUCCESS);
751     ASSERT_NE(generator, nullptr);
752 
753     HcfKeyPair *keyPair = nullptr;
754     ret = generator->generateKeyPair(generator, &keyPair);
755     HcfObjDestroy(generator);
756     ASSERT_EQ(ret, HCF_SUCCESS);
757     ASSERT_NE(keyPair, nullptr);
758 
759     const char *pkFormat = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
760     EXPECT_STREQ(pkFormat, g_opensslDsaPriKeyFormat);
761     HcfObjDestroy(keyPair);
762 }
763 
764 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest217, TestSize.Level0)
765 {
766     HcfAsyKeyGeneratorBySpec *generator = nullptr;
767     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
768     ASSERT_EQ(ret, HCF_SUCCESS);
769     ASSERT_NE(generator, nullptr);
770 
771     HcfKeyPair *keyPair = nullptr;
772     ret = generator->generateKeyPair(generator, &keyPair);
773     HcfObjDestroy(generator);
774     ASSERT_EQ(ret, HCF_SUCCESS);
775     ASSERT_NE(keyPair, nullptr);
776 
777     HcfBigInteger p = { .data = nullptr, .len = 0 };
778     ret = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, DSA_P_BN, &p);
779     HcfObjDestroy(keyPair);
780     ASSERT_EQ(ret, HCF_SUCCESS);
781     ASSERT_NE(p.data, nullptr);
782     ASSERT_NE(p.len, 0);
783     HcfFree(p.data);
784 }
785 
786 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest218, TestSize.Level0)
787 {
788     HcfAsyKeyGeneratorBySpec *generator = nullptr;
789     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
790     ASSERT_EQ(ret, HCF_SUCCESS);
791     ASSERT_NE(generator, nullptr);
792 
793     HcfKeyPair *keyPair = nullptr;
794     ret = generator->generateKeyPair(generator, &keyPair);
795     HcfObjDestroy(generator);
796     ASSERT_EQ(ret, HCF_SUCCESS);
797     ASSERT_NE(keyPair, nullptr);
798 
799     HcfBigInteger q = { .data = nullptr, .len = 0 };
800     ret = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, DSA_Q_BN, &q);
801     HcfObjDestroy(keyPair);
802     ASSERT_EQ(ret, HCF_SUCCESS);
803     ASSERT_NE(q.data, nullptr);
804     ASSERT_NE(q.len, 0);
805     HcfFree(q.data);
806 }
807 
808 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest219, TestSize.Level0)
809 {
810     HcfAsyKeyGeneratorBySpec *generator = nullptr;
811     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
812     ASSERT_EQ(ret, HCF_SUCCESS);
813     ASSERT_NE(generator, nullptr);
814 
815     HcfKeyPair *keyPair = nullptr;
816     ret = generator->generateKeyPair(generator, &keyPair);
817     HcfObjDestroy(generator);
818     ASSERT_EQ(ret, HCF_SUCCESS);
819     ASSERT_NE(keyPair, nullptr);
820 
821     HcfBigInteger g = { .data = nullptr, .len = 0 };
822     ret = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, DSA_G_BN, &g);
823     HcfObjDestroy(keyPair);
824     ASSERT_EQ(ret, HCF_SUCCESS);
825     ASSERT_NE(g.data, nullptr);
826     ASSERT_NE(g.len, 0);
827     HcfFree(g.data);
828 }
829 
830 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest220, TestSize.Level0)
831 {
832     HcfAsyKeyGeneratorBySpec *generator = nullptr;
833     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec), &generator);
834     ASSERT_EQ(ret, HCF_SUCCESS);
835     ASSERT_NE(generator, nullptr);
836 
837     HcfKeyPair *keyPair = nullptr;
838     ret = generator->generateKeyPair(generator, &keyPair);
839     HcfObjDestroy(generator);
840     ASSERT_EQ(ret, HCF_SUCCESS);
841     ASSERT_NE(keyPair, nullptr);
842 
843     HcfBigInteger sk = { .data = nullptr, .len = 0 };
844     ret = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, DSA_SK_BN, &sk);
845     HcfObjDestroy(keyPair);
846     ASSERT_EQ(ret, HCF_SUCCESS);
847     ASSERT_NE(sk.data, nullptr);
848     ASSERT_NE(sk.len, 0);
849     HcfFree(sk.data);
850 }
851 
852 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest301, TestSize.Level0)
853 {
854     HcfAsyKeyGeneratorBySpec *generator = nullptr;
855     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
856         &generator);
857     ASSERT_EQ(ret, HCF_SUCCESS);
858     ASSERT_NE(generator, nullptr);
859 
860     HcfKeyPair *keyPair = nullptr;
861     ret = generator->generateKeyPair(generator, &keyPair);
862     HcfObjDestroy(generator);
863     ASSERT_EQ(ret, HCF_SUCCESS);
864     ASSERT_NE(keyPair, nullptr);
865 
866     const char *keyPairClassName = keyPair->base.getClass();
867     EXPECT_STREQ(keyPairClassName, OPENSSL_DSA_KEYPAIR_CLASS);
868     HcfObjDestroy(keyPair);
869 }
870 
871 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest302, TestSize.Level0)
872 {
873     HcfAsyKeyGeneratorBySpec *generator = nullptr;
874     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
875         &generator);
876     ASSERT_EQ(ret, HCF_SUCCESS);
877     ASSERT_NE(generator, nullptr);
878 
879     HcfKeyPair *keyPair = nullptr;
880     ret = generator->generateKeyPair(generator, &keyPair);
881     HcfObjDestroy(generator);
882     ASSERT_EQ(ret, HCF_SUCCESS);
883     ASSERT_NE(keyPair, nullptr);
884     keyPair->base.destroy(&(keyPair->base));
885 }
886 
887 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest303, TestSize.Level0)
888 {
889     HcfAsyKeyGeneratorBySpec *generator = nullptr;
890     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
891         &generator);
892     ASSERT_EQ(ret, HCF_SUCCESS);
893     ASSERT_NE(generator, nullptr);
894 
895     HcfKeyPair *keyPair = nullptr;
896     ret = generator->generateKeyPair(generator, &keyPair);
897     HcfObjDestroy(generator);
898     ASSERT_EQ(ret, HCF_SUCCESS);
899     ASSERT_NE(keyPair, nullptr);
900 
901     const char *pkClassName = keyPair->pubKey->base.base.getClass();
902     EXPECT_STREQ(pkClassName, OPENSSL_DSA_PUBKEY_CLASS);
903     HcfObjDestroy(keyPair);
904 }
905 
906 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest304, TestSize.Level0)
907 {
908     HcfAsyKeyGeneratorBySpec *generator = nullptr;
909     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
910         &generator);
911     ASSERT_EQ(ret, HCF_SUCCESS);
912     ASSERT_NE(generator, nullptr);
913 
914     HcfKeyPair *keyPair = nullptr;
915     ret = generator->generateKeyPair(generator, &keyPair);
916     HcfObjDestroy(generator);
917     ASSERT_EQ(ret, HCF_SUCCESS);
918     ASSERT_NE(keyPair, nullptr);
919 
920     keyPair->pubKey->base.base.destroy(&(keyPair->priKey->base.base));
921     keyPair->pubKey = nullptr;
922 
923     HcfObjDestroy(keyPair);
924 }
925 
926 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest305, TestSize.Level0)
927 {
928     HcfAsyKeyGeneratorBySpec *generator = nullptr;
929     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
930         &generator);
931     ASSERT_EQ(ret, HCF_SUCCESS);
932     ASSERT_NE(generator, nullptr);
933 
934     HcfKeyPair *keyPair = nullptr;
935     ret = generator->generateKeyPair(generator, &keyPair);
936     HcfObjDestroy(generator);
937     ASSERT_EQ(ret, HCF_SUCCESS);
938     ASSERT_NE(keyPair, nullptr);
939 
940     const char *alg = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
941     EXPECT_STREQ(alg, g_algNameDSA);
942 
943     HcfObjDestroy(keyPair);
944 }
945 
946 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest306, TestSize.Level0)
947 {
948     HcfAsyKeyGeneratorBySpec *generator = nullptr;
949     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
950         &generator);
951     ASSERT_EQ(ret, HCF_SUCCESS);
952     ASSERT_NE(generator, nullptr);
953 
954     HcfKeyPair *keyPair = nullptr;
955     ret = generator->generateKeyPair(generator, &keyPair);
956     HcfObjDestroy(generator);
957     ASSERT_EQ(ret, HCF_SUCCESS);
958     ASSERT_NE(keyPair, nullptr);
959 
960     HcfBlob blob = { .data = nullptr, .len = 0 };
961     ret = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
962     HcfObjDestroy(keyPair);
963     ASSERT_EQ(ret, HCF_SUCCESS);
964     ASSERT_NE(blob.data, nullptr);
965     ASSERT_NE(blob.len, 0);
966     HcfFree(blob.data);
967 }
968 
969 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest307, TestSize.Level0)
970 {
971     HcfAsyKeyGeneratorBySpec *generator = nullptr;
972     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
973         &generator);
974     ASSERT_EQ(ret, HCF_SUCCESS);
975     ASSERT_NE(generator, nullptr);
976 
977     HcfKeyPair *keyPair = nullptr;
978     ret = generator->generateKeyPair(generator, &keyPair);
979     HcfObjDestroy(generator);
980     ASSERT_EQ(ret, HCF_SUCCESS);
981     ASSERT_NE(keyPair, nullptr);
982 
983     const char *pkFormat = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
984     EXPECT_STREQ(pkFormat, g_opensslDsaPubKeyFormat);
985     HcfObjDestroy(keyPair);
986 }
987 
988 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest308, TestSize.Level0)
989 {
990     HcfAsyKeyGeneratorBySpec *generator = nullptr;
991     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
992         &generator);
993     ASSERT_EQ(ret, HCF_SUCCESS);
994     ASSERT_NE(generator, nullptr);
995 
996     HcfKeyPair *keyPair = nullptr;
997     ret = generator->generateKeyPair(generator, &keyPair);
998     HcfObjDestroy(generator);
999     ASSERT_EQ(ret, HCF_SUCCESS);
1000     ASSERT_NE(keyPair, nullptr);
1001 
1002     HcfBigInteger p = { .data = nullptr, .len = 0 };
1003     ret = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, DSA_P_BN, &p);
1004     HcfObjDestroy(keyPair);
1005     ASSERT_EQ(ret, HCF_SUCCESS);
1006     ASSERT_NE(p.data, nullptr);
1007     ASSERT_NE(p.len, 0);
1008     HcfFree(p.data);
1009 }
1010 
1011 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest309, TestSize.Level0)
1012 {
1013     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1014     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1015         &generator);
1016     ASSERT_EQ(ret, HCF_SUCCESS);
1017     ASSERT_NE(generator, nullptr);
1018 
1019     HcfKeyPair *keyPair = nullptr;
1020     ret = generator->generateKeyPair(generator, &keyPair);
1021     HcfObjDestroy(generator);
1022     ASSERT_EQ(ret, HCF_SUCCESS);
1023     ASSERT_NE(keyPair, nullptr);
1024 
1025     HcfBigInteger q = { .data = nullptr, .len = 0 };
1026     ret = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, DSA_Q_BN, &q);
1027     HcfObjDestroy(keyPair);
1028     ASSERT_EQ(ret, HCF_SUCCESS);
1029     ASSERT_NE(q.data, nullptr);
1030     ASSERT_NE(q.len, 0);
1031     HcfFree(q.data);
1032 }
1033 
1034 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest310, TestSize.Level0)
1035 {
1036     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1037     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1038         &generator);
1039     ASSERT_EQ(ret, HCF_SUCCESS);
1040     ASSERT_NE(generator, nullptr);
1041 
1042     HcfKeyPair *keyPair = nullptr;
1043     ret = generator->generateKeyPair(generator, &keyPair);
1044     HcfObjDestroy(generator);
1045     ASSERT_EQ(ret, HCF_SUCCESS);
1046     ASSERT_NE(keyPair, nullptr);
1047 
1048     HcfBigInteger g = { .data = nullptr, .len = 0 };
1049     ret = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, DSA_G_BN, &g);
1050     HcfObjDestroy(keyPair);
1051     ASSERT_EQ(ret, HCF_SUCCESS);
1052     ASSERT_NE(g.data, nullptr);
1053     ASSERT_NE(g.len, 0);
1054     HcfFree(g.data);
1055 }
1056 
1057 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest311, TestSize.Level0)
1058 {
1059     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1060     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1061         &generator);
1062     ASSERT_EQ(ret, HCF_SUCCESS);
1063     ASSERT_NE(generator, nullptr);
1064 
1065     HcfKeyPair *keyPair = nullptr;
1066     ret = generator->generateKeyPair(generator, &keyPair);
1067     HcfObjDestroy(generator);
1068     ASSERT_EQ(ret, HCF_SUCCESS);
1069     ASSERT_NE(keyPair, nullptr);
1070 
1071     HcfBigInteger pk = { .data = nullptr, .len = 0 };
1072     ret = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, DSA_PK_BN, &pk);
1073     HcfObjDestroy(keyPair);
1074     ASSERT_EQ(ret, HCF_SUCCESS);
1075     ASSERT_NE(pk.data, nullptr);
1076     ASSERT_NE(pk.len, 0);
1077     HcfFree(pk.data);
1078 }
1079 
1080 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest312, TestSize.Level0)
1081 {
1082     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1083     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1084         &generator);
1085     ASSERT_EQ(ret, HCF_SUCCESS);
1086     ASSERT_NE(generator, nullptr);
1087 
1088     HcfKeyPair *keyPair = nullptr;
1089     ret = generator->generateKeyPair(generator, &keyPair);
1090     HcfObjDestroy(generator);
1091     ASSERT_EQ(ret, HCF_SUCCESS);
1092     ASSERT_NE(keyPair, nullptr);
1093 
1094     const char *skClassName = keyPair->priKey->base.base.getClass();
1095     EXPECT_STREQ(skClassName, OPENSSL_DSA_PRIKEY_CLASS);
1096     HcfObjDestroy(keyPair);
1097 }
1098 
1099 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest313, TestSize.Level0)
1100 {
1101     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1102     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1103         &generator);
1104     ASSERT_EQ(ret, HCF_SUCCESS);
1105     ASSERT_NE(generator, nullptr);
1106 
1107     HcfKeyPair *keyPair = nullptr;
1108     ret = generator->generateKeyPair(generator, &keyPair);
1109     HcfObjDestroy(generator);
1110     ASSERT_EQ(ret, HCF_SUCCESS);
1111     ASSERT_NE(keyPair, nullptr);
1112 
1113     keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
1114     keyPair->priKey = nullptr;
1115 
1116     HcfObjDestroy(keyPair);
1117 }
1118 
1119 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest314, TestSize.Level0)
1120 {
1121     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1122     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1123         &generator);
1124     ASSERT_EQ(ret, HCF_SUCCESS);
1125     ASSERT_NE(generator, nullptr);
1126 
1127     HcfKeyPair *keyPair = nullptr;
1128     ret = generator->generateKeyPair(generator, &keyPair);
1129     HcfObjDestroy(generator);
1130     ASSERT_EQ(ret, HCF_SUCCESS);
1131     ASSERT_NE(keyPair, nullptr);
1132 
1133     const char *alg = keyPair->priKey->base.getAlgorithm(&(keyPair->priKey->base));
1134     EXPECT_STREQ(alg, g_algNameDSA);
1135 
1136     HcfObjDestroy(keyPair);
1137 }
1138 
1139 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest315, TestSize.Level0)
1140 {
1141     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1142     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1143         &generator);
1144     ASSERT_EQ(ret, HCF_SUCCESS);
1145     ASSERT_NE(generator, nullptr);
1146 
1147     HcfKeyPair *keyPair = nullptr;
1148     ret = generator->generateKeyPair(generator, &keyPair);
1149     HcfObjDestroy(generator);
1150     ASSERT_EQ(ret, HCF_SUCCESS);
1151     ASSERT_NE(keyPair, nullptr);
1152 
1153     HcfBlob blob = { .data = nullptr, .len = 0 };
1154     ret = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
1155     HcfObjDestroy(keyPair);
1156     ASSERT_EQ(ret, HCF_SUCCESS);
1157     ASSERT_NE(blob.data, nullptr);
1158     ASSERT_NE(blob.len, 0);
1159     HcfFree(blob.data);
1160 }
1161 
1162 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest316, TestSize.Level0)
1163 {
1164     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1165     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1166         &generator);
1167     ASSERT_EQ(ret, HCF_SUCCESS);
1168     ASSERT_NE(generator, nullptr);
1169 
1170     HcfKeyPair *keyPair = nullptr;
1171     ret = generator->generateKeyPair(generator, &keyPair);
1172     HcfObjDestroy(generator);
1173     ASSERT_EQ(ret, HCF_SUCCESS);
1174     ASSERT_NE(keyPair, nullptr);
1175 
1176     const char *pkFormat = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
1177     EXPECT_STREQ(pkFormat, g_opensslDsaPriKeyFormat);
1178     HcfObjDestroy(keyPair);
1179 }
1180 
1181 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest317, TestSize.Level0)
1182 {
1183     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1184     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1185         &generator);
1186     ASSERT_EQ(ret, HCF_SUCCESS);
1187     ASSERT_NE(generator, nullptr);
1188 
1189     HcfKeyPair *keyPair = nullptr;
1190     ret = generator->generateKeyPair(generator, &keyPair);
1191     HcfObjDestroy(generator);
1192     ASSERT_EQ(ret, HCF_SUCCESS);
1193     ASSERT_NE(keyPair, nullptr);
1194 
1195     HcfBigInteger p = { .data = nullptr, .len = 0 };
1196     ret = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, DSA_P_BN, &p);
1197     HcfObjDestroy(keyPair);
1198     ASSERT_EQ(ret, HCF_SUCCESS);
1199     ASSERT_NE(p.data, nullptr);
1200     ASSERT_NE(p.len, 0);
1201     HcfFree(p.data);
1202 }
1203 
1204 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest318, TestSize.Level0)
1205 {
1206     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1207     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1208         &generator);
1209     ASSERT_EQ(ret, HCF_SUCCESS);
1210     ASSERT_NE(generator, nullptr);
1211 
1212     HcfKeyPair *keyPair = nullptr;
1213     ret = generator->generateKeyPair(generator, &keyPair);
1214     HcfObjDestroy(generator);
1215     ASSERT_EQ(ret, HCF_SUCCESS);
1216     ASSERT_NE(keyPair, nullptr);
1217 
1218     HcfBigInteger q = { .data = nullptr, .len = 0 };
1219     ret = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, DSA_Q_BN, &q);
1220     HcfObjDestroy(keyPair);
1221     ASSERT_EQ(ret, HCF_SUCCESS);
1222     ASSERT_NE(q.data, nullptr);
1223     ASSERT_NE(q.len, 0);
1224     HcfFree(q.data);
1225 }
1226 
1227 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest319, TestSize.Level0)
1228 {
1229     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1230     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1231         &generator);
1232     ASSERT_EQ(ret, HCF_SUCCESS);
1233     ASSERT_NE(generator, nullptr);
1234 
1235     HcfKeyPair *keyPair = nullptr;
1236     ret = generator->generateKeyPair(generator, &keyPair);
1237     HcfObjDestroy(generator);
1238     ASSERT_EQ(ret, HCF_SUCCESS);
1239     ASSERT_NE(keyPair, nullptr);
1240 
1241     HcfBigInteger g = { .data = nullptr, .len = 0 };
1242     ret = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, DSA_G_BN, &g);
1243     HcfObjDestroy(keyPair);
1244     ASSERT_EQ(ret, HCF_SUCCESS);
1245     ASSERT_NE(g.data, nullptr);
1246     ASSERT_NE(g.len, 0);
1247     HcfFree(g.data);
1248 }
1249 
1250 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest320, TestSize.Level0)
1251 {
1252     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1253     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1254         &generator);
1255     ASSERT_EQ(ret, HCF_SUCCESS);
1256     ASSERT_NE(generator, nullptr);
1257 
1258     HcfKeyPair *keyPair = nullptr;
1259     ret = generator->generateKeyPair(generator, &keyPair);
1260     HcfObjDestroy(generator);
1261     ASSERT_EQ(ret, HCF_SUCCESS);
1262     ASSERT_NE(keyPair, nullptr);
1263 
1264     HcfBigInteger sk = { .data = nullptr, .len = 0 };
1265     ret = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, DSA_SK_BN, &sk);
1266     HcfObjDestroy(keyPair);
1267     ASSERT_EQ(ret, HCF_SUCCESS);
1268     ASSERT_NE(sk.data, nullptr);
1269     ASSERT_NE(sk.len, 0);
1270     HcfFree(sk.data);
1271 }
1272 
1273 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest401, TestSize.Level0)
1274 {
1275     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1276     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaPkSpec), &generator);
1277     ASSERT_EQ(ret, HCF_SUCCESS);
1278     ASSERT_NE(generator, nullptr);
1279 
1280     HcfPubKey *pk = nullptr;
1281     ret = generator->generatePubKey(generator, &pk);
1282     HcfObjDestroy(generator);
1283     ASSERT_EQ(ret, HCF_SUCCESS);
1284     ASSERT_NE(pk, nullptr);
1285 
1286     const char *pkClassName = pk->base.base.getClass();
1287     EXPECT_STREQ(pkClassName, OPENSSL_DSA_PUBKEY_CLASS);
1288     HcfObjDestroy(pk);
1289 }
1290 
1291 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest402, TestSize.Level0)
1292 {
1293     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1294     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaPkSpec), &generator);
1295     ASSERT_EQ(ret, HCF_SUCCESS);
1296     ASSERT_NE(generator, nullptr);
1297 
1298     HcfPubKey *pk = nullptr;
1299     ret = generator->generatePubKey(generator, &pk);
1300     HcfObjDestroy(generator);
1301     ASSERT_EQ(ret, HCF_SUCCESS);
1302     ASSERT_NE(pk, nullptr);
1303 
1304     pk->base.base.destroy(&(pk->base.base));
1305 }
1306 
1307 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest403, TestSize.Level0)
1308 {
1309     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1310     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaPkSpec), &generator);
1311     ASSERT_EQ(ret, HCF_SUCCESS);
1312     ASSERT_NE(generator, nullptr);
1313 
1314     HcfPubKey *pk = nullptr;
1315     ret = generator->generatePubKey(generator, &pk);
1316     HcfObjDestroy(generator);
1317     ASSERT_EQ(ret, HCF_SUCCESS);
1318     ASSERT_NE(pk, nullptr);
1319 
1320     const char *alg = pk->base.getAlgorithm(&(pk->base));
1321     EXPECT_STREQ(alg, g_algNameDSA);
1322 
1323     HcfObjDestroy(pk);
1324 }
1325 
1326 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest404, TestSize.Level0)
1327 {
1328     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1329     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaPkSpec), &generator);
1330     ASSERT_EQ(ret, HCF_SUCCESS);
1331     ASSERT_NE(generator, nullptr);
1332 
1333     HcfPubKey *pk = nullptr;
1334     ret = generator->generatePubKey(generator, &pk);
1335     HcfObjDestroy(generator);
1336     ASSERT_EQ(ret, HCF_SUCCESS);
1337     ASSERT_NE(pk, nullptr);
1338 
1339     HcfBlob blob = { .data = nullptr, .len = 0 };
1340     ret = pk->base.getEncoded(&(pk->base), &blob);
1341     HcfObjDestroy(pk);
1342     ASSERT_EQ(ret, HCF_SUCCESS);
1343     ASSERT_NE(blob.data, nullptr);
1344     ASSERT_NE(blob.len, 0);
1345     HcfFree(blob.data);
1346 }
1347 
1348 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest405, TestSize.Level0)
1349 {
1350     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1351     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaPkSpec), &generator);
1352     ASSERT_EQ(ret, HCF_SUCCESS);
1353     ASSERT_NE(generator, nullptr);
1354 
1355     HcfPubKey *pk = nullptr;
1356     ret = generator->generatePubKey(generator, &pk);
1357     HcfObjDestroy(generator);
1358     ASSERT_EQ(ret, HCF_SUCCESS);
1359     ASSERT_NE(pk, nullptr);
1360 
1361     const char *pkFormat = pk->base.getFormat(&(pk->base));
1362     EXPECT_STREQ(pkFormat, g_opensslDsaPubKeyFormat);
1363     HcfObjDestroy(pk);
1364 }
1365 
1366 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest406, TestSize.Level0)
1367 {
1368     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1369     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaPkSpec), &generator);
1370     ASSERT_EQ(ret, HCF_SUCCESS);
1371     ASSERT_NE(generator, nullptr);
1372 
1373     HcfPubKey *pk = nullptr;
1374     ret = generator->generatePubKey(generator, &pk);
1375     HcfObjDestroy(generator);
1376     ASSERT_EQ(ret, HCF_SUCCESS);
1377     ASSERT_NE(pk, nullptr);
1378 
1379     HcfBigInteger p = { .data = nullptr, .len = 0 };
1380     ret = pk->getAsyKeySpecBigInteger(pk, DSA_P_BN, &p);
1381     HcfObjDestroy(pk);
1382     ASSERT_EQ(ret, HCF_SUCCESS);
1383     ASSERT_NE(p.data, nullptr);
1384     ASSERT_NE(p.len, 0);
1385     HcfFree(p.data);
1386 }
1387 
1388 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest407, TestSize.Level0)
1389 {
1390     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1391     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaPkSpec), &generator);
1392     ASSERT_EQ(ret, HCF_SUCCESS);
1393     ASSERT_NE(generator, nullptr);
1394 
1395     HcfPubKey *pk = nullptr;
1396     ret = generator->generatePubKey(generator, &pk);
1397     HcfObjDestroy(generator);
1398     ASSERT_EQ(ret, HCF_SUCCESS);
1399     ASSERT_NE(pk, nullptr);
1400 
1401     HcfBigInteger q = { .data = nullptr, .len = 0 };
1402     ret = pk->getAsyKeySpecBigInteger(pk, DSA_Q_BN, &q);
1403     HcfObjDestroy(pk);
1404     ASSERT_EQ(ret, HCF_SUCCESS);
1405     ASSERT_NE(q.data, nullptr);
1406     ASSERT_NE(q.len, 0);
1407     HcfFree(q.data);
1408 }
1409 
1410 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest408, TestSize.Level0)
1411 {
1412     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1413     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1414         &generator);
1415     ASSERT_EQ(ret, HCF_SUCCESS);
1416     ASSERT_NE(generator, nullptr);
1417 
1418     HcfPubKey *pk = nullptr;
1419     ret = generator->generatePubKey(generator, &pk);
1420     HcfObjDestroy(generator);
1421     ASSERT_EQ(ret, HCF_SUCCESS);
1422     ASSERT_NE(pk, nullptr);
1423 
1424     HcfBigInteger g = { .data = nullptr, .len = 0 };
1425     ret = pk->getAsyKeySpecBigInteger(pk, DSA_G_BN, &g);
1426     HcfObjDestroy(pk);
1427     ASSERT_EQ(ret, HCF_SUCCESS);
1428     ASSERT_NE(g.data, nullptr);
1429     ASSERT_NE(g.len, 0);
1430     HcfFree(g.data);
1431 }
1432 
1433 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest409, TestSize.Level0)
1434 {
1435     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1436     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1437         &generator);
1438     ASSERT_EQ(ret, HCF_SUCCESS);
1439     ASSERT_NE(generator, nullptr);
1440 
1441     HcfPubKey *pk = nullptr;
1442     ret = generator->generatePubKey(generator, &pk);
1443     HcfObjDestroy(generator);
1444     ASSERT_EQ(ret, HCF_SUCCESS);
1445     ASSERT_NE(pk, nullptr);
1446 
1447     HcfBigInteger pkBn = { .data = nullptr, .len = 0 };
1448     ret = pk->getAsyKeySpecBigInteger(pk, DSA_PK_BN, &pkBn);
1449     HcfObjDestroy(pk);
1450     ASSERT_EQ(ret, HCF_SUCCESS);
1451     ASSERT_NE(pkBn.data, nullptr);
1452     ASSERT_NE(pkBn.len, 0);
1453     HcfFree(pkBn.data);
1454 }
1455 
1456 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest501, TestSize.Level0)
1457 {
1458     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1459     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1460         &generator);
1461     ASSERT_EQ(ret, HCF_SUCCESS);
1462     ASSERT_NE(generator, nullptr);
1463 
1464     HcfPriKey *sk = nullptr;
1465     ret = generator->generatePriKey(generator, &sk);
1466     HcfObjDestroy(generator);
1467     ASSERT_EQ(ret, HCF_SUCCESS);
1468     ASSERT_NE(sk, nullptr);
1469 
1470     const char *skClassName = sk->base.base.getClass();
1471     EXPECT_STREQ(skClassName, OPENSSL_DSA_PRIKEY_CLASS);
1472     HcfObjDestroy(sk);
1473 }
1474 
1475 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest502, TestSize.Level0)
1476 {
1477     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1478     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1479         &generator);
1480     ASSERT_EQ(ret, HCF_SUCCESS);
1481     ASSERT_NE(generator, nullptr);
1482 
1483     HcfPriKey *sk = nullptr;
1484     ret = generator->generatePriKey(generator, &sk);
1485     HcfObjDestroy(generator);
1486     ASSERT_EQ(ret, HCF_SUCCESS);
1487     ASSERT_NE(sk, nullptr);
1488 
1489     sk->base.base.destroy(&(sk->base.base));
1490 }
1491 
1492 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest503, TestSize.Level0)
1493 {
1494     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1495     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1496         &generator);
1497     ASSERT_EQ(ret, HCF_SUCCESS);
1498     ASSERT_NE(generator, nullptr);
1499 
1500     HcfPriKey *sk = nullptr;
1501     ret = generator->generatePriKey(generator, &sk);
1502     HcfObjDestroy(generator);
1503     ASSERT_EQ(ret, HCF_SUCCESS);
1504     ASSERT_NE(sk, nullptr);
1505 
1506     const char *alg = sk->base.getAlgorithm(&(sk->base));
1507     EXPECT_STREQ(alg, g_algNameDSA);
1508 
1509     HcfObjDestroy(sk);
1510 }
1511 
1512 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest504, TestSize.Level0)
1513 {
1514     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1515     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1516         &generator);
1517     ASSERT_EQ(ret, HCF_SUCCESS);
1518     ASSERT_NE(generator, nullptr);
1519 
1520     HcfPriKey *sk = nullptr;
1521     ret = generator->generatePriKey(generator, &sk);
1522     HcfObjDestroy(generator);
1523     ASSERT_EQ(ret, HCF_SUCCESS);
1524     ASSERT_NE(sk, nullptr);
1525 
1526     HcfBlob blob = { .data = nullptr, .len = 0 };
1527     ret = sk->base.getEncoded(&(sk->base), &blob);
1528     HcfObjDestroy(sk);
1529     ASSERT_EQ(ret, HCF_SUCCESS);
1530     ASSERT_NE(blob.data, nullptr);
1531     ASSERT_NE(blob.len, 0);
1532     HcfFree(blob.data);
1533 }
1534 
1535 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest505, TestSize.Level0)
1536 {
1537     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1538     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1539         &generator);
1540     ASSERT_EQ(ret, HCF_SUCCESS);
1541     ASSERT_NE(generator, nullptr);
1542 
1543     HcfPriKey *sk = nullptr;
1544     ret = generator->generatePriKey(generator, &sk);
1545     HcfObjDestroy(generator);
1546     ASSERT_EQ(ret, HCF_SUCCESS);
1547     ASSERT_NE(sk, nullptr);
1548 
1549     const char *skFormat = sk->base.getFormat(&(sk->base));
1550     EXPECT_STREQ(skFormat, g_opensslDsaPriKeyFormat);
1551     HcfObjDestroy(sk);
1552 }
1553 
1554 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest506, TestSize.Level0)
1555 {
1556     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1557     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1558         &generator);
1559     ASSERT_EQ(ret, HCF_SUCCESS);
1560     ASSERT_NE(generator, nullptr);
1561 
1562     HcfPriKey *sk = nullptr;
1563     ret = generator->generatePriKey(generator, &sk);
1564     HcfObjDestroy(generator);
1565     ASSERT_EQ(ret, HCF_SUCCESS);
1566     ASSERT_NE(sk, nullptr);
1567 
1568     HcfBigInteger p = { .data = nullptr, .len = 0 };
1569     ret = sk->getAsyKeySpecBigInteger(sk, DSA_P_BN, &p);
1570     HcfObjDestroy(sk);
1571     ASSERT_EQ(ret, HCF_SUCCESS);
1572     ASSERT_NE(p.data, nullptr);
1573     ASSERT_NE(p.len, 0);
1574     HcfFree(p.data);
1575 }
1576 
1577 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest507, TestSize.Level0)
1578 {
1579     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1580     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1581         &generator);
1582     ASSERT_EQ(ret, HCF_SUCCESS);
1583     ASSERT_NE(generator, nullptr);
1584 
1585     HcfPriKey *sk = nullptr;
1586     ret = generator->generatePriKey(generator, &sk);
1587     HcfObjDestroy(generator);
1588     ASSERT_EQ(ret, HCF_SUCCESS);
1589     ASSERT_NE(sk, nullptr);
1590 
1591     HcfBigInteger q = { .data = nullptr, .len = 0 };
1592     ret = sk->getAsyKeySpecBigInteger(sk, DSA_Q_BN, &q);
1593     HcfObjDestroy(sk);
1594     ASSERT_EQ(ret, HCF_SUCCESS);
1595     ASSERT_NE(q.data, nullptr);
1596     ASSERT_NE(q.len, 0);
1597     HcfFree(q.data);
1598 }
1599 
1600 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest508, TestSize.Level0)
1601 {
1602     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1603     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1604         &generator);
1605     ASSERT_EQ(ret, HCF_SUCCESS);
1606     ASSERT_NE(generator, nullptr);
1607 
1608     HcfPriKey *sk = nullptr;
1609     ret = generator->generatePriKey(generator, &sk);
1610     HcfObjDestroy(generator);
1611     ASSERT_EQ(ret, HCF_SUCCESS);
1612     ASSERT_NE(sk, nullptr);
1613 
1614     HcfBigInteger g = { .data = nullptr, .len = 0 };
1615     ret = sk->getAsyKeySpecBigInteger(sk, DSA_G_BN, &g);
1616     HcfObjDestroy(sk);
1617     ASSERT_EQ(ret, HCF_SUCCESS);
1618     ASSERT_NE(g.data, nullptr);
1619     ASSERT_NE(g.len, 0);
1620     HcfFree(g.data);
1621 }
1622 
1623 HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest509, TestSize.Level0)
1624 {
1625     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1626     HcfResult ret = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1627         &generator);
1628     ASSERT_EQ(ret, HCF_SUCCESS);
1629     ASSERT_NE(generator, nullptr);
1630 
1631     HcfPriKey *sk = nullptr;
1632     ret = generator->generatePriKey(generator, &sk);
1633     HcfObjDestroy(generator);
1634     ASSERT_EQ(ret, HCF_SUCCESS);
1635     ASSERT_NE(sk, nullptr);
1636 
1637     HcfBigInteger skBn = { .data = nullptr, .len = 0 };
1638     ret = sk->getAsyKeySpecBigInteger(sk, DSA_SK_BN, &skBn);
1639     HcfObjDestroy(sk);
1640     ASSERT_EQ(ret, HCF_SUCCESS);
1641     ASSERT_NE(skBn.data, nullptr);
1642     ASSERT_NE(skBn.len, 0);
1643     HcfFree(skBn.data);
1644 }
1645 }