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