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 <cstring>
18
19 #include "asy_key_generator.h"
20 #include "dh_asy_key_generator_openssl.h"
21 #include "blob.h"
22 #include "detailed_ecc_key_params.h"
23 #include "ecc_key_util.h"
24 #include "ecc_openssl_common.h"
25 #include "ecc_openssl_common_param_spec.h"
26 #include "ecc_common.h"
27 #include "ecdsa_openssl.h"
28 #include "memory.h"
29 #include "securec.h"
30 #include "openssl_common.h"
31 #include "asy_key_params.h"
32 #include "params_parser.h"
33 #include "memory_mock.h"
34 #include "openssl_adapter_mock.h"
35
36 using namespace std;
37 using namespace testing::ext;
38
39 namespace {
40 class CryptoDHAsyKeyGeneratorTest : public testing::Test {
41 public:
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 void SetUp();
45 void TearDown();
46 };
47
TearDownTestCase()48 void CryptoDHAsyKeyGeneratorTest::TearDownTestCase() {}
SetUp()49 void CryptoDHAsyKeyGeneratorTest::SetUp() {}
TearDown()50 void CryptoDHAsyKeyGeneratorTest::TearDown() {}
51
52 static string g_dh1536AlgoName = "DH_modp1536";
53 static string g_dhAlgoName = "DH";
54 static string g_dhpubkeyformatName = "X.509";
55 static string g_dhprikeyformatName = "PKCS#8";
56 constexpr int BIT8 = 8;
57 constexpr int BIT4 = 4;
58 constexpr int BIT2 = 2;
59 HcfAsyKeyGenerator *g_dh1536Generator = nullptr;
60 HcfKeyPair *g_dh1536KeyPair = nullptr;
61
GetMockClass(void)62 static const char *GetMockClass(void)
63 {
64 return "HcfEcc";
65 }
66 HcfObjectBase g_obj = {
67 .getClass = GetMockClass,
68 .destroy = nullptr
69 };
70
71 HcfBlob g_mockDH1536PriKeyBlob = {
72 .data = nullptr,
73 .len = 0
74 };
75
76 HcfBlob g_mockDH1536PubKeyBlob = {
77 .data = nullptr,
78 .len = 0
79 };
80
81 HcfBlob g_mockECC_BrainPool160r1PriKeyBlob = {
82 .data = nullptr,
83 .len = 0
84 };
85
86 HcfBlob g_mockECC_BrainPool160r1PubKeyBlob = {
87 .data = nullptr,
88 .len = 0
89 };
90
91 string g_modp_1536_p =
92 "ffffffffffffffffca237327f1746c084abc9804670c354e7096966d9ed52907"
93 "208552bb1c62f356dca3ad9683655d23fd24cf5f69163fa81c55d39a98da4836"
94 "a163bf05c2007cb8ece45b3d492866517c4b1fe6ae9f24115a899fa5ee386bfb"
95 "f406b7ed0bff5cb6a637ed6bf44c42e9625e7ec6e485b5766d51c2454fe1356d"
96 "f25f1437302b0a6dcd3a431bef9519b38e3404dd514a08793b139b22020bbea6"
97 "8a67cc7429024e0880dc1cd1c4c6628b2168c234c90fdaa2ffffffffffffffff";
98
99 string g_modp_2048_p =
100 "ffffffffffffffff8aacaa6815728e5a98fa051015d22618ea956ae53995497c"
101 "95581718de2bcbf66f4c52c9b5c55df0ec07a28f9b2783a2180e8603e39e772c"
102 "2e36ce3b32905e46ca18217cf1746c084abc9804670c354e7096966d9ed52907"
103 "208552bb1c62f356dca3ad9683655d23fd24cf5f69163fa81c55d39a98da4836"
104 "a163bf05c2007cb8ece45b3d492866517c4b1fe6ae9f24115a899fa5ee386bfb"
105 "f406b7ed0bff5cb6a637ed6bf44c42e9625e7ec6e485b5766d51c2454fe1356d"
106 "f25f1437302b0a6dcd3a431bef9519b38e3404dd514a08793b139b22020bbea6"
107 "8a67cc7429024e0880dc1cd1c4c6628b2168c234c90fdaa2ffffffffffffffff";
108
109 string g_modp_3072_p =
110 "ffffffffffffffffa93ad2ca4b82d120e0fd108e43db5bfc74e5ab3108e24fa0"
111 "bad946e2770988c07a615d6cbbe11757177b200c521f2b183ec86a64d8760273"
112 "d98a0864f12ffa061ad2ee6bcee3d2264a25619d1e8c94e0db0933d7abf5ae8c"
113 "a6e1e4c7b3970f855d060c7d8aea715758dbef0aecfb8504df1cba64a85521ab"
114 "04507a33ad33170d8aaac42d15728e5a98fa051015d22618ea956ae53995497c"
115 "95581718de2bcbf66f4c52c9b5c55df0ec07a28f9b2783a2180e8603e39e772c"
116 "2e36ce3b32905e46ca18217cf1746c084abc9804670c354e7096966d9ed52907"
117 "208552bb1c62f356dca3ad9683655d23fd24cf5f69163fa81c55d39a98da4836"
118 "a163bf05c2007cb8ece45b3d492866517c4b1fe6ae9f24115a899fa5ee386bfb"
119 "f406b7ed0bff5cb6a637ed6bf44c42e9625e7ec6e485b5766d51c2454fe1356d"
120 "f25f1437302b0a6dcd3a431bef9519b38e3404dd514a08793b139b22020bbea6"
121 "8a67cc7429024e0880dc1cd1c4c6628b2168c234c90fdaa2ffffffffffffffff";
122
123 string g_modp_4096_p =
124 "ffffffffffffffff340631994df435c990a6c08f86ffb7dc8d8fddc193b4ea98"
125 "d5b05aa9d00691272170481cb81bdd76cee2d7af1f612970515be7ed233ba186"
126 "a090c3a299b2964f4e6bc05d287c59471fbecaa62e8efc1404de8ef9dbbbc2db"
127 "2ad44ce82583e9cab6150bda1a9468346af4e23c99c32718bdba5b2688719a10"
128 "a787e6d71a723c12a92108014b82d120e0fd108e43db5bfc74e5ab3108e24fa0"
129 "bad946e2770988c07a615d6cbbe11757177b200c521f2b183ec86a64d8760273"
130 "d98a0864f12ffa061ad2ee6bcee3d2264a25619d1e8c94e0db0933d7abf5ae8c"
131 "a6e1e4c7b3970f855d060c7d8aea715758dbef0aecfb8504df1cba64a85521ab"
132 "04507a33ad33170d8aaac42d15728e5a98fa051015d22618ea956ae53995497c"
133 "95581718de2bcbf66f4c52c9b5c55df0ec07a28f9b2783a2180e8603e39e772c"
134 "2e36ce3b32905e46ca18217cf1746c084abc9804670c354e7096966d9ed52907"
135 "208552bb1c62f356dca3ad9683655d23fd24cf5f69163fa81c55d39a98da4836"
136 "a163bf05c2007cb8ece45b3d492866517c4b1fe6ae9f24115a899fa5ee386bfb"
137 "f406b7ed0bff5cb6a637ed6bf44c42e9625e7ec6e485b5766d51c2454fe1356d"
138 "f25f1437302b0a6dcd3a431bef9519b38e3404dd514a08793b139b22020bbea6"
139 "8a67cc7429024e0880dc1cd1c4c6628b2168c234c90fdaa2ffffffffffffffff";
140
141 string g_modp_6144_p =
142 "ffffffffffffffff6dcc4024e694f91e0b7474d612bf2d5b3f4860ee043e8f66"
143 "6e3c0468387fe8d72ef29632da56c9eca313d55ceb19ccb18a1fbff0f550aa3d"
144 "b7c5da7606a1d58bf29be328a79715ee0f8037e014cc5ed2bf48e1d8cc8f6d7e"
145 "2b4154aa4bd407b2ff585ac50f1d45b736cc88be23a97a7ebec7e8f359e7c97f"
146 "900b1c9eb5a8403146980c82d55e702f6e74fef6f482d7ced1721d03f032ea15"
147 "c64b92ec5983ca01378cd2bf6fb8f4012bd7af4233205151e6cc254bdb7f1447"
148 "ced4bb1b44ce6cbacf9b14edda3edbeb865a8918179727b09027d831b06a53ed"
149 "413001aee5db382fad9e530ef8ff94063dba37bdc9751e76602646dec1d4dcb2"
150 "d27c702636c3fab4340284924df435c990a6c08f86ffb7dc8d8fddc193b4ea98"
151 "d5b05aa9d00691272170481cb81bdd76cee2d7af1f612970515be7ed233ba186"
152 "a090c3a299b2964f4e6bc05d287c59471fbecaa62e8efc1404de8ef9dbbbc2db"
153 "2ad44ce82583e9cab6150bda1a9468346af4e23c99c32718bdba5b2688719a10"
154 "a787e6d71a723c12a92108014b82d120e0fd108e43db5bfc74e5ab3108e24fa0"
155 "bad946e2770988c07a615d6cbbe11757177b200c521f2b183ec86a64d8760273"
156 "d98a0864f12ffa061ad2ee6bcee3d2264a25619d1e8c94e0db0933d7abf5ae8c"
157 "a6e1e4c7b3970f855d060c7d8aea715758dbef0aecfb8504df1cba64a85521ab"
158 "04507a33ad33170d8aaac42d15728e5a98fa051015d22618ea956ae53995497c"
159 "95581718de2bcbf66f4c52c9b5c55df0ec07a28f9b2783a2180e8603e39e772c"
160 "2e36ce3b32905e46ca18217cf1746c084abc9804670c354e7096966d9ed52907"
161 "208552bb1c62f356dca3ad9683655d23fd24cf5f69163fa81c55d39a98da4836"
162 "a163bf05c2007cb8ece45b3d492866517c4b1fe6ae9f24115a899fa5ee386bfb"
163 "f406b7ed0bff5cb6a637ed6bf44c42e9625e7ec6e485b5766d51c2454fe1356d"
164 "f25f1437302b0a6dcd3a431bef9519b38e3404dd514a08793b139b22020bbea6"
165 "8a67cc7429024e0880dc1cd1c4c6628b2168c234c90fdaa2ffffffffffffffff";
166
167 string g_modp_8192_p =
168 "ffffffffffffffff98edd3df60c980dd80b96e71c81f56e8765694df9e3050e2"
169 "5677e9aa9558e447fc026e47c9190da6d5ee382b889a002e481c6cd74009438b"
170 "eb879f92359046f41ecfa268faf36bc37ee74d73b1d510bd5ded7ea1f9ab4819"
171 "0846851d64f31cc5a0255dc14597e89974ab6a36df310ee03f44f82d6d2a13f8"
172 "b3a278a6062b3cf5ed5bdd3a79683303a2c087e8fa9d4b7f2f8385dd4bcbc886"
173 "6cea306b3473fc641a23f0c713eb57a8a4037c0722222e04fc848ad9e3fdb8be"
174 "e39d652d238f16cb2bf1c9783423b4745ae4f5683aab639c6ba424662576f693"
175 "8afc47ed741fa7bf8d9dd3003bc832b673b931bad8bec4d0a932df8c38777cb6"
176 "12fee5e474a3926f6dbe1159e694f91e0b7474d612bf2d5b3f4860ee043e8f66"
177 "6e3c0468387fe8d72ef29632da56c9eca313d55ceb19ccb18a1fbff0f550aa3d"
178 "b7c5da7606a1d58bf29be328a79715ee0f8037e014cc5ed2bf48e1d8cc8f6d7e"
179 "2b4154aa4bd407b2ff585ac50f1d45b736cc88be23a97a7ebec7e8f359e7c97f"
180 "900b1c9eb5a8403146980c82d55e702f6e74fef6f482d7ced1721d03f032ea15"
181 "c64b92ec5983ca01378cd2bf6fb8f4012bd7af4233205151e6cc254bdb7f1447"
182 "ced4bb1b44ce6cbacf9b14edda3edbeb865a8918179727b09027d831b06a53ed"
183 "413001aee5db382fad9e530ef8ff94063dba37bdc9751e76602646dec1d4dcb2"
184 "d27c702636c3fab4340284924df435c990a6c08f86ffb7dc8d8fddc193b4ea98"
185 "d5b05aa9d00691272170481cb81bdd76cee2d7af1f612970515be7ed233ba186"
186 "a090c3a299b2964f4e6bc05d287c59471fbecaa62e8efc1404de8ef9dbbbc2db"
187 "2ad44ce82583e9cab6150bda1a9468346af4e23c99c32718bdba5b2688719a10"
188 "a787e6d71a723c12a92108014b82d120e0fd108e43db5bfc74e5ab3108e24fa0"
189 "bad946e2770988c07a615d6cbbe11757177b200c521f2b183ec86a64d8760273"
190 "d98a0864f12ffa061ad2ee6bcee3d2264a25619d1e8c94e0db0933d7abf5ae8c"
191 "a6e1e4c7b3970f855d060c7d8aea715758dbef0aecfb8504df1cba64a85521ab"
192 "04507a33ad33170d8aaac42d15728e5a98fa051015d22618ea956ae53995497c"
193 "95581718de2bcbf66f4c52c9b5c55df0ec07a28f9b2783a2180e8603e39e772c"
194 "2e36ce3b32905e46ca18217cf1746c084abc9804670c354e7096966d9ed52907"
195 "208552bb1c62f356dca3ad9683655d23fd24cf5f69163fa81c55d39a98da4836"
196 "a163bf05c2007cb8ece45b3d492866517c4b1fe6ae9f24115a899fa5ee386bfb"
197 "f406b7ed0bff5cb6a637ed6bf44c42e9625e7ec6e485b5766d51c2454fe1356d"
198 "f25f1437302b0a6dcd3a431bef9519b38e3404dd514a08793b139b22020bbea6"
199 "8a67cc7429024e0880dc1cd1c4c6628b2168c234c90fdaa2ffffffffffffffff";
200
201 string g_ffdhe_2048_p =
202 "ffffffffffffffff61285c97886b4238c1b2effac6f34a267d1683b2c58ef183"
203 "2ec220053bb5fcbc4c6fad73c3fe3b1beef281838e4f1232e98583ff9172fe9c"
204 "28342f61c03404cdcdf7e2ec9e02fce1ee0a6d700b07a7c86372bb19ae56ede7"
205 "de394df41d4f42a360d7f468b96adab7b2c8e3fbd108a94bb324fb61bc0ab182"
206 "483a797a30acca4f36ade7351df158a1f3efe872e2a689dae0e68b77984f0c70"
207 "7f57c935b557135e3ded1af3856365555f066ed02433f51fd5fd6561d3df1ed5"
208 "aec4617af681b202630c75d87d2fe363249b3ef9cc939dce146433fba9e13641"
209 "ce2d3695d8b9c583273d3cf1afdc5620a2bb4a9aadf85458ffffffffffffffff";
210
211 string g_ffdhe_3072_p =
212 "ffffffffffffffff66c62e3725e41d2b3fd59d7c3c1b20eefa53ddef0abcd06b"
213 "d5c4484e1dbf9a429b0deadaabc5219722363a0de86d2bc59c9df69e5cae82ab"
214 "71f54bff64f2e21ee2d74dd3f4fd4452bc437944b4130c9385139270aefe1309"
215 "c186d91c598cb0fa91f7f7ee7ad91d26d6e6c90761b46fc9f99c0238bc34f4de"
216 "6519035bde355b3b611fcfdc886b4238c1b2effac6f34a267d1683b2c58ef183"
217 "2ec220053bb5fcbc4c6fad73c3fe3b1beef281838e4f1232e98583ff9172fe9c"
218 "28342f61c03404cdcdf7e2ec9e02fce1ee0a6d700b07a7c86372bb19ae56ede7"
219 "de394df41d4f42a360d7f468b96adab7b2c8e3fbd108a94bb324fb61bc0ab182"
220 "483a797a30acca4f36ade7351df158a1f3efe872e2a689dae0e68b77984f0c70"
221 "7f57c935b557135e3ded1af3856365555f066ed02433f51fd5fd6561d3df1ed5"
222 "aec4617af681b202630c75d87d2fe363249b3ef9cc939dce146433fba9e13641"
223 "ce2d3695d8b9c583273d3cf1afdc5620a2bb4a9aadf85458ffffffffffffffff";
224
225 string g_ffdhe_4096_p =
226 "ffffffffffffffff5e655f6ac68a007ef44182e14db5a8517f88a46b8ec9b55a"
227 "cec97dcf0a8291cdf98d0acc2a4ecea97140003c1a1db93d33cb8b7a092999a3"
228 "71ad00386dc778f9918130c4a907600a2d9e6832ed6a1e01efb4318a7135c886"
229 "7e31cc7a87f55ba5550340047763cf1dd69f6d18ac7d5f42e58857b67930e9e4"
230 "164df4fb6e6f52c3669e1ef125e41d2b3fd59d7c3c1b20eefa53ddef0abcd06b"
231 "d5c4484e1dbf9a429b0deadaabc5219722363a0de86d2bc59c9df69e5cae82ab"
232 "71f54bff64f2e21ee2d74dd3f4fd4452bc437944b4130c9385139270aefe1309"
233 "c186d91c598cb0fa91f7f7ee7ad91d26d6e6c90761b46fc9f99c0238bc34f4de"
234 "6519035bde355b3b611fcfdc886b4238c1b2effac6f34a267d1683b2c58ef183"
235 "2ec220053bb5fcbc4c6fad73c3fe3b1beef281838e4f1232e98583ff9172fe9c"
236 "28342f61c03404cdcdf7e2ec9e02fce1ee0a6d700b07a7c86372bb19ae56ede7"
237 "de394df41d4f42a360d7f468b96adab7b2c8e3fbd108a94bb324fb61bc0ab182"
238 "483a797a30acca4f36ade7351df158a1f3efe872e2a689dae0e68b77984f0c70"
239 "7f57c935b557135e3ded1af3856365555f066ed02433f51fd5fd6561d3df1ed5"
240 "aec4617af681b202630c75d87d2fe363249b3ef9cc939dce146433fba9e13641"
241 "ce2d3695d8b9c583273d3cf1afdc5620a2bb4a9aadf85458ffffffffffffffff";
242
243 string g_ffdhe_6144_p =
244 "ffffffffffffffffd0e40e65a40e329c7938dad4a41d570dd43161c162a69526"
245 "9adb1e693fdd4a8edc6b80d65b3b71f9c6272b04ec9d1810cacef4038ccf2dd5"
246 "c95b9117e49f5235b854338a505dc82d1562a84662292c316ae77f5ed72b0374"
247 "462d538cf9c9091b47a67cbe0ae8db5822611682b3a739c12a281bf6eeaac023"
248 "77caf99294c6651e94b2bbc1763e4e4b0077d9b4587e38da183023c37fb29f8c"
249 "f9e3a26e0abec1ff350511e3a00ef092db6340d8b855322ea9a96910a52471f7"
250 "4cfdb477388147fb4e46041f9b1f5c3efccfec71cdad06574c701c3ab38e8c33"
251 "b1c0fd4c917bdd649b7624c83bb45432caf53ea623ba444238532a3a4e677d2c"
252 "45036c7a0bfd64b65e0dd902c68a007ef44182e14db5a8517f88a46b8ec9b55a"
253 "cec97dcf0a8291cdf98d0acc2a4ecea97140003c1a1db93d33cb8b7a092999a3"
254 "71ad00386dc778f9918130c4a907600a2d9e6832ed6a1e01efb4318a7135c886"
255 "7e31cc7a87f55ba5550340047763cf1dd69f6d18ac7d5f42e58857b67930e9e4"
256 "164df4fb6e6f52c3669e1ef125e41d2b3fd59d7c3c1b20eefa53ddef0abcd06b"
257 "d5c4484e1dbf9a429b0deadaabc5219722363a0de86d2bc59c9df69e5cae82ab"
258 "71f54bff64f2e21ee2d74dd3f4fd4452bc437944b4130c9385139270aefe1309"
259 "c186d91c598cb0fa91f7f7ee7ad91d26d6e6c90761b46fc9f99c0238bc34f4de"
260 "6519035bde355b3b611fcfdc886b4238c1b2effac6f34a267d1683b2c58ef183"
261 "2ec220053bb5fcbc4c6fad73c3fe3b1beef281838e4f1232e98583ff9172fe9c"
262 "28342f61c03404cdcdf7e2ec9e02fce1ee0a6d700b07a7c86372bb19ae56ede7"
263 "de394df41d4f42a360d7f468b96adab7b2c8e3fbd108a94bb324fb61bc0ab182"
264 "483a797a30acca4f36ade7351df158a1f3efe872e2a689dae0e68b77984f0c70"
265 "7f57c935b557135e3ded1af3856365555f066ed02433f51fd5fd6561d3df1ed5"
266 "aec4617af681b202630c75d87d2fe363249b3ef9cc939dce146433fba9e13641"
267 "ce2d3695d8b9c583273d3cf1afdc5620a2bb4a9aadf85458ffffffffffffffff";
268
269 string g_ffdhe_8192_p =
270 "ffffffffffffffffc5c6424cd68c8bb7838ff88c011e2a94a9f4614e0822e506"
271 "f7a8443d97d11d4930677f0da6bbfde5c1fe86fe2f741ef85d71a87efafabe1c"
272 "fbe58a30ded2fbab72b0a66eb6855dfeba8a4fe81efc8ce03f2fa45783f81d4a"
273 "a577e231a1fe307588d9c0a0d5b80194ad9a95f9624816cd50c1217b99e9e316"
274 "0e423cfc51aa691e3826e52c1c217e6c09703fee51a8a9316a460e74bb709987"
275 "9c86b022541fc68c46fd825159160cc035c35f5c2846c0ba8b75828254504ac7"
276 "d2af05e429388839c01bd702cb2c0f1c7c932665555b2f74a3ab882986b63142"
277 "f64b10ef0b8cc3bdedd1cc5e687feb69c9509d43fdb23fced951ae641e425a31"
278 "f600c83836ad004ccff46aaaa40e329c7938dad4a41d570dd43161c162a69526"
279 "9adb1e693fdd4a8edc6b80d65b3b71f9c6272b04ec9d1810cacef4038ccf2dd5"
280 "c95b9117e49f5235b854338a505dc82d1562a84662292c316ae77f5ed72b0374"
281 "462d538cf9c9091b47a67cbe0ae8db5822611682b3a739c12a281bf6eeaac023"
282 "77caf99294c6651e94b2bbc1763e4e4b0077d9b4587e38da183023c37fb29f8c"
283 "f9e3a26e0abec1ff350511e3a00ef092db6340d8b855322ea9a96910a52471f7"
284 "4cfdb477388147fb4e46041f9b1f5c3efccfec71cdad06574c701c3ab38e8c33"
285 "b1c0fd4c917bdd649b7624c83bb45432caf53ea623ba444238532a3a4e677d2c"
286 "45036c7a0bfd64b65e0dd902c68a007ef44182e14db5a8517f88a46b8ec9b55a"
287 "cec97dcf0a8291cdf98d0acc2a4ecea97140003c1a1db93d33cb8b7a092999a3"
288 "71ad00386dc778f9918130c4a907600a2d9e6832ed6a1e01efb4318a7135c886"
289 "7e31cc7a87f55ba5550340047763cf1dd69f6d18ac7d5f42e58857b67930e9e4"
290 "164df4fb6e6f52c3669e1ef125e41d2b3fd59d7c3c1b20eefa53ddef0abcd06b"
291 "d5c4484e1dbf9a429b0deadaabc5219722363a0de86d2bc59c9df69e5cae82ab"
292 "71f54bff64f2e21ee2d74dd3f4fd4452bc437944b4130c9385139270aefe1309"
293 "c186d91c598cb0fa91f7f7ee7ad91d26d6e6c90761b46fc9f99c0238bc34f4de"
294 "6519035bde355b3b611fcfdc886b4238c1b2effac6f34a267d1683b2c58ef183"
295 "2ec220053bb5fcbc4c6fad73c3fe3b1beef281838e4f1232e98583ff9172fe9c"
296 "28342f61c03404cdcdf7e2ec9e02fce1ee0a6d700b07a7c86372bb19ae56ede7"
297 "de394df41d4f42a360d7f468b96adab7b2c8e3fbd108a94bb324fb61bc0ab182"
298 "483a797a30acca4f36ade7351df158a1f3efe872e2a689dae0e68b77984f0c70"
299 "7f57c935b557135e3ded1af3856365555f066ed02433f51fd5fd6561d3df1ed5"
300 "aec4617af681b202630c75d87d2fe363249b3ef9cc939dce146433fba9e13641"
301 "ce2d3695d8b9c583273d3cf1afdc5620a2bb4a9aadf85458ffffffffffffffff";
302
DH1536KeyBlob(HcfBlob * priblob,HcfBlob * pubblob)303 static HcfResult DH1536KeyBlob(HcfBlob * priblob, HcfBlob *pubblob)
304 {
305 HcfKeyPair *keyPair = nullptr;
306 HcfResult res = g_dh1536Generator->generateKeyPair(g_dh1536Generator, nullptr, &keyPair);
307 if (res != HCF_SUCCESS) {
308 return res;
309 }
310 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &g_mockDH1536PriKeyBlob);
311 if (res != HCF_SUCCESS) {
312 HcfObjDestroy(keyPair);
313 return res;
314 }
315 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &g_mockDH1536PubKeyBlob);
316 if (res != HCF_SUCCESS) {
317 HcfObjDestroy(g_dh1536Generator);
318 HcfObjDestroy(keyPair);
319 return res;
320 }
321
322 HcfObjDestroy(keyPair);
323 return HCF_SUCCESS;
324 }
325
ECC_BrainPool160r1KeyBlob(HcfBlob * priblob,HcfBlob * pubblob)326 static HcfResult ECC_BrainPool160r1KeyBlob(HcfBlob * priblob, HcfBlob *pubblob)
327 {
328 HcfAsyKeyGenerator *generator = nullptr;
329 HcfResult res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator);
330 if (res != HCF_SUCCESS) {
331 return res;
332 }
333
334 HcfKeyPair *keyPair = nullptr;
335 res = generator->generateKeyPair(generator, nullptr, &keyPair);
336 if (res != HCF_SUCCESS) {
337 HcfObjDestroy(generator);
338 return res;
339 }
340 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &g_mockECC_BrainPool160r1PriKeyBlob);
341 if (res != HCF_SUCCESS) {
342 HcfObjDestroy(generator);
343 HcfObjDestroy(keyPair);
344 return res;
345 }
346 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &g_mockECC_BrainPool160r1PubKeyBlob);
347 if (res != HCF_SUCCESS) {
348 HcfObjDestroy(generator);
349 HcfObjDestroy(keyPair);
350 return res;
351 }
352
353 HcfObjDestroy(generator);
354 HcfObjDestroy(keyPair);
355 return HCF_SUCCESS;
356 }
357
HcfAsyKeyGeneratorCreateTest(const char * algName)358 static HcfResult HcfAsyKeyGeneratorCreateTest(const char *algName)
359 {
360 HcfAsyKeyGenerator *generator = nullptr;
361 HcfResult res = HcfAsyKeyGeneratorCreate(algName, &generator);
362 if (res == HCF_SUCCESS) {
363 HcfObjDestroy(generator);
364 }
365 return res;
366 }
367
SetUpTestCase()368 void CryptoDHAsyKeyGeneratorTest::SetUpTestCase()
369 {
370 HcfResult res = HcfAsyKeyGeneratorCreate("DH_modp1536", &g_dh1536Generator);
371 ASSERT_EQ(res, HCF_SUCCESS);
372 ASSERT_NE(g_dh1536Generator, nullptr);
373 res = g_dh1536Generator->generateKeyPair(g_dh1536Generator, nullptr, &g_dh1536KeyPair);
374 ASSERT_EQ(res, HCF_SUCCESS);
375 ASSERT_NE(g_dh1536KeyPair, nullptr);
376 res = DH1536KeyBlob(&g_mockDH1536PriKeyBlob, &g_mockDH1536PubKeyBlob);
377 ASSERT_EQ(res, HCF_SUCCESS);
378 res = ECC_BrainPool160r1KeyBlob(&g_mockECC_BrainPool160r1PriKeyBlob, &g_mockECC_BrainPool160r1PubKeyBlob);
379 ASSERT_EQ(res, HCF_SUCCESS);
380 }
381
382 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest001_1, TestSize.Level0)
383 {
384 HcfResult res = HcfAsyKeyGeneratorCreateTest("DH_modp1536");
385 ASSERT_EQ(res, HCF_SUCCESS);
386 }
387
388 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest001_2, TestSize.Level0)
389 {
390 HcfResult res = HcfAsyKeyGeneratorCreateTest("DH_modp2048");
391 ASSERT_EQ(res, HCF_SUCCESS);
392 }
393
394 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest001_3, TestSize.Level0)
395 {
396 HcfResult res = HcfAsyKeyGeneratorCreateTest("DH_modp3072");
397 ASSERT_EQ(res, HCF_SUCCESS);
398 }
399
400 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest001_4, TestSize.Level0)
401 {
402 HcfResult res = HcfAsyKeyGeneratorCreateTest("DH_modp4096");
403 ASSERT_EQ(res, HCF_SUCCESS);
404 }
405
406 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest001_5, TestSize.Level0)
407 {
408 HcfResult res = HcfAsyKeyGeneratorCreateTest("DH_modp6144");
409 ASSERT_EQ(res, HCF_SUCCESS);
410 }
411
412 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest001_6, TestSize.Level0)
413 {
414 HcfResult res = HcfAsyKeyGeneratorCreateTest("DH_modp8192");
415 ASSERT_EQ(res, HCF_SUCCESS);
416 }
417
418 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest001_7, TestSize.Level0)
419 {
420 HcfResult res = HcfAsyKeyGeneratorCreateTest("DH_ffdhe2048");
421 ASSERT_EQ(res, HCF_SUCCESS);
422 }
423
424 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest001_8, TestSize.Level0)
425 {
426 HcfResult res = HcfAsyKeyGeneratorCreateTest("DH_ffdhe3072");
427 ASSERT_EQ(res, HCF_SUCCESS);
428 }
429
430 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest001_9, TestSize.Level0)
431 {
432 HcfResult res = HcfAsyKeyGeneratorCreateTest("DH_ffdhe4096");
433 ASSERT_EQ(res, HCF_SUCCESS);
434 }
435
436 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest001_10, TestSize.Level0)
437 {
438 HcfResult res = HcfAsyKeyGeneratorCreateTest("DH_ffdhe6144");
439 ASSERT_EQ(res, HCF_SUCCESS);
440 }
441
442 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest001_11, TestSize.Level0)
443 {
444 HcfResult res = HcfAsyKeyGeneratorCreateTest("DH_ffdhe8192");
445 ASSERT_EQ(res, HCF_SUCCESS);
446 }
447
448 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest002, TestSize.Level0)
449 {
450 const char *className = g_dh1536Generator->base.getClass();
451 ASSERT_NE(className, nullptr);
452 }
453
454 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest003, TestSize.Level0)
455 {
456 HcfAsyKeyGenerator *generator = nullptr;
457 HcfResult res = HcfAsyKeyGeneratorCreate("DH_modp1536", &generator);
458 ASSERT_EQ(res, HCF_SUCCESS);
459 ASSERT_NE(generator, nullptr);
460
461 generator->base.destroy((HcfObjectBase *)generator);
462 }
463
464 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest004, TestSize.Level0)
465 {
466 const char *algoName = g_dh1536Generator->getAlgoName(g_dh1536Generator);
467 ASSERT_EQ(algoName, g_dh1536AlgoName);
468 }
469
470 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest005, TestSize.Level0)
471 {
472 HcfKeyPair *keyPair = nullptr;
473 HcfResult res = g_dh1536Generator->generateKeyPair(g_dh1536Generator, nullptr, &keyPair);
474 ASSERT_EQ(res, HCF_SUCCESS);
475 ASSERT_NE(keyPair, nullptr);
476
477 HcfObjDestroy(keyPair);
478 }
479
480 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest006, TestSize.Level0)
481 {
482 const char *className = g_dh1536KeyPair->base.getClass();
483 ASSERT_NE(className, nullptr);
484 }
485
486 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest007, TestSize.Level0)
487 {
488 HcfKeyPair *keyPair = nullptr;
489 HcfResult res = g_dh1536Generator->generateKeyPair(g_dh1536Generator, nullptr, &keyPair);
490 ASSERT_EQ(res, HCF_SUCCESS);
491 ASSERT_NE(keyPair, nullptr);
492
493 keyPair->base.destroy(&(keyPair->base));
494 }
495
496 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest008, TestSize.Level0)
497 {
498 const char *className = g_dh1536KeyPair->pubKey->base.base.getClass();
499 ASSERT_NE(className, nullptr);
500 }
501
502 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest009, TestSize.Level0)
503 {
504 HcfKeyPair *keyPair = nullptr;
505 HcfResult res = g_dh1536Generator->generateKeyPair(g_dh1536Generator, nullptr, &keyPair);
506
507 ASSERT_EQ(res, HCF_SUCCESS);
508 ASSERT_NE(keyPair, nullptr);
509
510 keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
511 keyPair->pubKey = nullptr;
512 HcfObjDestroy(keyPair);
513 }
514
515 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest010, TestSize.Level0)
516 {
517 const char *algorithmName = g_dh1536KeyPair->pubKey->base.getAlgorithm(&(g_dh1536KeyPair->pubKey->base));
518 ASSERT_EQ(algorithmName, g_dhAlgoName);
519
520 HcfBlob blob = { .data = nullptr, .len = 0 };
521 HcfResult res = g_dh1536KeyPair->pubKey->base.getEncoded(&(g_dh1536KeyPair->pubKey->base), &blob);
522 ASSERT_EQ(res, HCF_SUCCESS);
523 ASSERT_NE(blob.data, nullptr);
524 ASSERT_NE(blob.len, 0);
525 HcfFree(blob.data);
526 const char *formatName = g_dh1536KeyPair->pubKey->base.getFormat(&(g_dh1536KeyPair->pubKey->base));
527 ASSERT_EQ(formatName, g_dhpubkeyformatName);
528 }
529
530 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest011, TestSize.Level0)
531 {
532 const char *className = g_dh1536KeyPair->priKey->base.base.getClass();
533 ASSERT_NE(className, nullptr);
534 }
535
536 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest012, TestSize.Level0)
537 {
538 HcfKeyPair *keyPair = nullptr;
539 HcfResult res = g_dh1536Generator->generateKeyPair(g_dh1536Generator, nullptr, &keyPair);
540
541 ASSERT_EQ(res, HCF_SUCCESS);
542 ASSERT_NE(keyPair, nullptr);
543
544 keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
545 keyPair->priKey = nullptr;
546 HcfObjDestroy(keyPair);
547 }
548
549 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest013, TestSize.Level0)
550 {
551 const char *algorithmName = g_dh1536KeyPair->priKey->base.getAlgorithm(&(g_dh1536KeyPair->priKey->base));
552 ASSERT_EQ(algorithmName, g_dhAlgoName);
553
554 HcfBlob blob = { .data = nullptr, .len = 0 };
555 HcfResult res = g_dh1536KeyPair->priKey->base.getEncoded(&(g_dh1536KeyPair->priKey->base), &blob);
556 ASSERT_EQ(res, HCF_SUCCESS);
557 ASSERT_NE(blob.data, nullptr);
558 ASSERT_NE(blob.len, 0);
559 HcfFree(blob.data);
560 const char *formatName = g_dh1536KeyPair->priKey->base.getFormat(&(g_dh1536KeyPair->priKey->base));
561 ASSERT_EQ(formatName, g_dhprikeyformatName);
562 }
563
564 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest014, TestSize.Level0)
565 {
566 HcfKeyPair *keyPair = nullptr;
567 HcfResult res = g_dh1536Generator->generateKeyPair(g_dh1536Generator, nullptr, &keyPair);
568
569 ASSERT_EQ(res, HCF_SUCCESS);
570 ASSERT_NE(keyPair, nullptr);
571
572 keyPair->priKey->clearMem(keyPair->priKey);
573 HcfBlob blob = { .data = nullptr, .len = 0 };
574 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
575 ASSERT_EQ(res, HCF_ERR_CRYPTO_OPERATION);
576 ASSERT_EQ(blob.data, nullptr);
577 ASSERT_EQ(blob.len, 0);
578 HcfFree(blob.data);
579 HcfObjDestroy(keyPair);
580 }
581
582 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest015, TestSize.Level0)
583 {
584 HcfKeyPair *keyPair = nullptr;
585 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
586 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
587 ASSERT_EQ(res, HCF_SUCCESS);
588 ASSERT_NE(keyPair, nullptr);
589
590 res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr, nullptr, &g_mockDH1536PriKeyBlob, &keyPair);
591 ASSERT_EQ(res, HCF_SUCCESS);
592 ASSERT_NE(keyPair, nullptr);
593
594 res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr, &g_mockDH1536PubKeyBlob, nullptr, &keyPair);
595 ASSERT_EQ(res, HCF_SUCCESS);
596 ASSERT_NE(keyPair, nullptr);
597
598 HcfObjDestroy(keyPair);
599 }
600
601 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest016, TestSize.Level0)
602 {
603 const char *className = g_dh1536KeyPair->base.getClass();
604 ASSERT_NE(className, nullptr);
605 }
606
607 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest017, TestSize.Level0)
608 {
609 HcfKeyPair *keyPair = nullptr;
610 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
611 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
612
613 ASSERT_EQ(res, HCF_SUCCESS);
614 ASSERT_NE(keyPair, nullptr);
615
616 keyPair->base.destroy(&(keyPair->base));
617 }
618
619 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest018, TestSize.Level0)
620 {
621 const char *className = g_dh1536KeyPair->pubKey->base.base.getClass();
622 ASSERT_NE(className, nullptr);
623 }
624
625 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest019, TestSize.Level0)
626 {
627 HcfKeyPair *keyPair = nullptr;
628 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
629 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
630
631 ASSERT_EQ(res, HCF_SUCCESS);
632 ASSERT_NE(keyPair, nullptr);
633
634 keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
635 keyPair->pubKey = nullptr;
636 HcfObjDestroy(keyPair);
637 }
638
639 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest020, TestSize.Level0)
640 {
641 const char *algorithmName = g_dh1536KeyPair->pubKey->base.getAlgorithm(&(g_dh1536KeyPair->pubKey->base));
642 ASSERT_EQ(algorithmName, g_dhAlgoName);
643
644 HcfBlob blob = { .data = nullptr, .len = 0 };
645 HcfResult res = g_dh1536KeyPair->pubKey->base.getEncoded(&(g_dh1536KeyPair->pubKey->base), &blob);
646 ASSERT_EQ(res, HCF_SUCCESS);
647 ASSERT_NE(blob.data, nullptr);
648 ASSERT_NE(blob.len, 0);
649 HcfFree(blob.data);
650 const char *formatName = g_dh1536KeyPair->pubKey->base.getFormat(&(g_dh1536KeyPair->pubKey->base));
651 ASSERT_EQ(formatName, g_dhpubkeyformatName);
652 }
653
654 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest021, TestSize.Level0)
655 {
656 const char *className = g_dh1536KeyPair->priKey->base.base.getClass();
657 ASSERT_NE(className, nullptr);
658 }
659
660 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest022, TestSize.Level0)
661 {
662 HcfKeyPair *keyPair = nullptr;
663 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
664 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
665
666 ASSERT_EQ(res, HCF_SUCCESS);
667 ASSERT_NE(keyPair, nullptr);
668
669 keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
670 keyPair->priKey = nullptr;
671 HcfObjDestroy(keyPair);
672 }
673
674 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest023, TestSize.Level0)
675 {
676 const char *algorithmName = g_dh1536KeyPair->priKey->base.getAlgorithm(&(g_dh1536KeyPair->priKey->base));
677 ASSERT_EQ(algorithmName, g_dhAlgoName);
678
679 HcfBlob blob = { .data = nullptr, .len = 0 };
680 HcfResult res = g_dh1536KeyPair->priKey->base.getEncoded(&(g_dh1536KeyPair->priKey->base), &blob);
681 ASSERT_EQ(res, HCF_SUCCESS);
682 ASSERT_NE(blob.data, nullptr);
683 ASSERT_NE(blob.len, 0);
684 HcfFree(blob.data);
685 const char *formatName = g_dh1536KeyPair->priKey->base.getFormat(&(g_dh1536KeyPair->priKey->base));
686 ASSERT_EQ(formatName, g_dhprikeyformatName);
687
688 int32_t returnInt = 0;
689 res = g_dh1536KeyPair->priKey->getAsyKeySpecInt(g_dh1536KeyPair->priKey, DH_L_NUM, &returnInt);
690 ASSERT_EQ(res, HCF_SUCCESS);
691 ASSERT_EQ(returnInt, 0);
692 }
693
694 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest024, TestSize.Level0)
695 {
696 HcfKeyPair *keyPair = nullptr;
697 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
698 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
699
700 ASSERT_EQ(res, HCF_SUCCESS);
701 ASSERT_NE(keyPair, nullptr);
702
703 keyPair->priKey->clearMem(keyPair->priKey);
704 HcfBlob blob = { .data = nullptr, .len = 0 };
705 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
706 ASSERT_EQ(res, HCF_ERR_CRYPTO_OPERATION);
707 ASSERT_EQ(blob.data, nullptr);
708 ASSERT_EQ(blob.len, 0);
709 HcfFree(blob.data);
710 HcfObjDestroy(keyPair);
711 }
712
MemoryMallocTestFunc(uint32_t mallocCount)713 static void MemoryMallocTestFunc(uint32_t mallocCount)
714 {
715 for (uint32_t i = 0; i < mallocCount; i++) {
716 ResetRecordMallocNum();
717 SetMockMallocIndex(i);
718 HcfAsyKeyGenerator *tmpGenerator = nullptr;
719 HcfResult res = HcfAsyKeyGeneratorCreate("DH_modp1536", &tmpGenerator);
720 if (res != HCF_SUCCESS) {
721 continue;
722 }
723 HcfKeyPair *tmpKeyPair = nullptr;
724 res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
725 if (res != HCF_SUCCESS) {
726 HcfObjDestroy(tmpGenerator);
727 continue;
728 }
729 HcfBlob tmpPubKeyBlob = {
730 .data = nullptr,
731 .len = 0
732 };
733 res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
734 if (res != HCF_SUCCESS) {
735 HcfObjDestroy(tmpKeyPair);
736 HcfObjDestroy(tmpGenerator);
737 continue;
738 }
739 HcfBlob tmpPriKeyBlob = {
740 .data = nullptr,
741 .len = 0
742 };
743 res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
744 if (res != HCF_SUCCESS) {
745 HcfFree(tmpPubKeyBlob.data);
746 HcfObjDestroy(tmpKeyPair);
747 HcfObjDestroy(tmpGenerator);
748 continue;
749 }
750 HcfKeyPair *tmpOutKeyPair = nullptr;
751 res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
752 HcfFree(tmpPubKeyBlob.data);
753 HcfFree(tmpPriKeyBlob.data);
754 HcfObjDestroy(tmpKeyPair);
755 HcfObjDestroy(tmpGenerator);
756 if (res == HCF_SUCCESS) {
757 HcfObjDestroy(tmpOutKeyPair);
758 }
759 }
760 }
761
762 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest025, TestSize.Level0)
763 {
764 StartRecordMallocNum();
765 HcfAsyKeyGenerator *generator = nullptr;
766 HcfResult res = HcfAsyKeyGeneratorCreate("DH_modp1536", &generator);
767
768 HcfKeyPair *keyPair = nullptr;
769 res = generator->generateKeyPair(generator, nullptr, &keyPair);
770
771 ASSERT_EQ(res, HCF_SUCCESS);
772 ASSERT_NE(keyPair, nullptr);
773
774 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
775 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
776
777 ASSERT_EQ(res, HCF_SUCCESS);
778 ASSERT_NE(pubKeyBlob.data, nullptr);
779 ASSERT_NE(pubKeyBlob.len, 0);
780
781 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
782 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
783
784 ASSERT_EQ(res, HCF_SUCCESS);
785 ASSERT_NE(priKeyBlob.data, nullptr);
786 ASSERT_NE(priKeyBlob.len, 0);
787
788 HcfKeyPair *outKeyPair = nullptr;
789 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
790
791 HcfFree(pubKeyBlob.data);
792 HcfFree(priKeyBlob.data);
793 HcfObjDestroy(outKeyPair);
794 HcfObjDestroy(keyPair);
795 HcfObjDestroy(generator);
796
797 uint32_t mallocCount = GetMallocNum();
798 MemoryMallocTestFunc(mallocCount);
799
800 EndRecordMallocNum();
801 }
802
OpensslMockTestFunc(uint32_t mallocCount)803 static void OpensslMockTestFunc(uint32_t mallocCount)
804 {
805 for (uint32_t i = 0; i < mallocCount; i++) {
806 ResetOpensslCallNum();
807 SetOpensslCallMockIndex(i);
808 HcfAsyKeyGenerator *tmpGenerator = nullptr;
809 HcfResult res = HcfAsyKeyGeneratorCreate("DH_modp1536", &tmpGenerator);
810 if (res != HCF_SUCCESS) {
811 continue;
812 }
813 HcfKeyPair *tmpKeyPair = nullptr;
814 res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
815 if (res != HCF_SUCCESS) {
816 HcfObjDestroy(tmpGenerator);
817 continue;
818 }
819 HcfBlob tmpPubKeyBlob = { .data = nullptr, .len = 0 };
820 res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
821 if (res != HCF_SUCCESS) {
822 HcfObjDestroy(tmpKeyPair);
823 HcfObjDestroy(tmpGenerator);
824 continue;
825 }
826 HcfBlob tmpPriKeyBlob = { .data = nullptr, .len = 0 };
827 res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
828 if (res != HCF_SUCCESS) {
829 HcfFree(tmpPubKeyBlob.data);
830 HcfObjDestroy(tmpKeyPair);
831 HcfObjDestroy(tmpGenerator);
832 continue;
833 }
834 HcfKeyPair *tmpOutKeyPair = nullptr;
835 res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
836 HcfFree(tmpPubKeyBlob.data);
837 HcfFree(tmpPriKeyBlob.data);
838 HcfObjDestroy(tmpKeyPair);
839 HcfObjDestroy(tmpGenerator);
840 if (res == HCF_SUCCESS) {
841 HcfObjDestroy(tmpOutKeyPair);
842 }
843 }
844 }
845
846 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest026, TestSize.Level0)
847 {
848 StartRecordOpensslCallNum();
849 HcfAsyKeyGenerator *generator = nullptr;
850 HcfResult res = HcfAsyKeyGeneratorCreate("DH_modp1536", &generator);
851 ASSERT_EQ(res, HCF_SUCCESS);
852
853 HcfKeyPair *keyPair = nullptr;
854 res = generator->generateKeyPair(generator, nullptr, &keyPair);
855
856 ASSERT_EQ(res, HCF_SUCCESS);
857 ASSERT_NE(keyPair, nullptr);
858
859 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
860 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
861
862 ASSERT_EQ(res, HCF_SUCCESS);
863 ASSERT_NE(pubKeyBlob.data, nullptr);
864 ASSERT_NE(pubKeyBlob.len, 0);
865
866 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
867 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
868
869 ASSERT_EQ(res, HCF_SUCCESS);
870 ASSERT_NE(priKeyBlob.data, nullptr);
871 ASSERT_NE(priKeyBlob.len, 0);
872
873 HcfKeyPair *outKeyPair = nullptr;
874 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
875
876 HcfFree(pubKeyBlob.data);
877 HcfFree(priKeyBlob.data);
878 HcfObjDestroy(outKeyPair);
879 HcfObjDestroy(keyPair);
880 HcfObjDestroy(generator);
881
882 uint32_t mallocCount = GetOpensslCallNum();
883 OpensslMockTestFunc(mallocCount);
884
885 EndRecordOpensslCallNum();
886 }
887
888 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest027, TestSize.Level0)
889 {
890 const char *algoName1 = g_dh1536Generator->getAlgoName(nullptr);
891 ASSERT_EQ(algoName1, nullptr);
892
893 const char *algoName2 = g_dh1536Generator->getAlgoName((HcfAsyKeyGenerator *)&g_obj);
894 ASSERT_EQ(algoName2, nullptr);
895 }
896
897 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest028, TestSize.Level0)
898 {
899 HcfAsyKeyGenerator *generator = nullptr;
900 HcfResult res = HcfAsyKeyGeneratorCreate("DH_modp1536", &generator);
901
902 ASSERT_EQ(res, HCF_SUCCESS);
903 ASSERT_NE(generator, nullptr);
904
905 generator->base.destroy(nullptr);
906 HcfObjDestroy(generator);
907 }
908
909 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest029, TestSize.Level0)
910 {
911 HcfAsyKeyGenerator *generator = nullptr;
912 HcfResult res = HcfAsyKeyGeneratorCreate("DH_modp1536", &generator);
913 ASSERT_EQ(res, HCF_SUCCESS);
914 ASSERT_NE(generator, nullptr);
915
916 generator->base.destroy(&g_obj);
917 HcfObjDestroy(generator);
918 }
919
920 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest030, TestSize.Level0)
921 {
922 HcfKeyPair *keyPair = nullptr;
923 HcfResult res = g_dh1536Generator->convertKey(nullptr, nullptr,
924 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
925 ASSERT_EQ(res, HCF_INVALID_PARAMS);
926 ASSERT_EQ(keyPair, nullptr);
927
928 res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
929 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, nullptr);
930 ASSERT_EQ(res, HCF_INVALID_PARAMS);
931
932 res = g_dh1536Generator->convertKey((HcfAsyKeyGenerator *)&g_obj, nullptr, &g_mockDH1536PubKeyBlob,
933 &g_mockDH1536PriKeyBlob, &keyPair);
934 ASSERT_EQ(res, HCF_INVALID_PARAMS);
935 ASSERT_EQ(keyPair, nullptr);
936
937 res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr, nullptr, nullptr, &keyPair);
938 ASSERT_EQ(res, HCF_INVALID_PARAMS);
939 ASSERT_EQ(keyPair, nullptr);
940
941 res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob,
942 &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair);
943 ASSERT_EQ(res, HCF_ERR_CRYPTO_OPERATION);
944 ASSERT_EQ(keyPair, nullptr);
945
946 HcfObjDestroy(keyPair);
947 }
948
949 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest031, TestSize.Level0)
950 {
951 const char *algorithmName = g_dh1536KeyPair->pubKey->base.getAlgorithm(nullptr);
952 ASSERT_EQ(algorithmName, nullptr);
953
954 const char *algorithmName1 = g_dh1536KeyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj);
955 ASSERT_EQ(algorithmName1, nullptr);
956 }
957
958 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest032, TestSize.Level0)
959 {
960 HcfBlob blob = { .data = nullptr, .len = 0 };
961 HcfResult res = g_dh1536KeyPair->pubKey->base.getEncoded(nullptr, &blob);
962 ASSERT_EQ(res, HCF_INVALID_PARAMS);
963 ASSERT_EQ(blob.data, nullptr);
964 ASSERT_EQ(blob.len, 0);
965
966 res = g_dh1536KeyPair->pubKey->base.getEncoded(&(g_dh1536KeyPair->pubKey->base), nullptr);
967 ASSERT_EQ(res, HCF_INVALID_PARAMS);
968
969 res = g_dh1536KeyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob);
970 ASSERT_EQ(res, HCF_INVALID_PARAMS);
971 ASSERT_EQ(blob.data, nullptr);
972 ASSERT_EQ(blob.len, 0);
973 HcfFree(blob.data);
974 }
975
976 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest033, TestSize.Level0)
977 {
978 const char *formatName = g_dh1536KeyPair->pubKey->base.getFormat(nullptr);
979 ASSERT_EQ(formatName, nullptr);
980
981 const char *formatName1 = g_dh1536KeyPair->pubKey->base.getFormat((HcfKey *)&g_obj);
982 ASSERT_EQ(formatName1, nullptr);
983 }
984
985 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest034, TestSize.Level0)
986 {
987 const char *algorithmName = g_dh1536KeyPair->priKey->base.getAlgorithm(nullptr);
988 ASSERT_EQ(algorithmName, nullptr);
989
990 const char *algorithmName1 = g_dh1536KeyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj);
991 ASSERT_EQ(algorithmName1, nullptr);
992 }
993
994 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest035, TestSize.Level0)
995 {
996 HcfBlob blob = { .data = nullptr, .len = 0 };
997 HcfResult res = g_dh1536KeyPair->priKey->base.getEncoded(nullptr, &blob);
998 ASSERT_EQ(res, HCF_INVALID_PARAMS);
999 ASSERT_EQ(blob.data, nullptr);
1000 ASSERT_EQ(blob.len, 0);
1001
1002 res = g_dh1536KeyPair->priKey->base.getEncoded(&(g_dh1536KeyPair->priKey->base), nullptr);
1003 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1004
1005 res = g_dh1536KeyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob);
1006 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1007 ASSERT_EQ(blob.data, nullptr);
1008 ASSERT_EQ(blob.len, 0);
1009
1010 HcfFree(blob.data);
1011 }
1012
1013 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest036, TestSize.Level0)
1014 {
1015 HcfKeyPair *keyPair = nullptr;
1016 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1017 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1018
1019 ASSERT_EQ(res, HCF_SUCCESS);
1020 ASSERT_NE(keyPair, nullptr);
1021
1022 const char *formatName = formatName = keyPair->priKey->base.getFormat(nullptr);
1023 ASSERT_EQ(formatName, nullptr);
1024
1025 const char *formatName1 = keyPair->priKey->base.getFormat((HcfKey *)&g_obj);
1026 ASSERT_EQ(formatName1, nullptr);
1027
1028 HcfObjDestroy(keyPair);
1029 }
1030
1031 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest037, TestSize.Level0)
1032 {
1033 HcfKeyPair *keyPair = nullptr;
1034 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1035 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1036
1037 ASSERT_EQ(res, HCF_SUCCESS);
1038 ASSERT_NE(keyPair, nullptr);
1039
1040 keyPair->priKey->clearMem(nullptr);
1041 HcfBlob blob = { .data = nullptr, .len = 0 };
1042 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
1043 ASSERT_EQ(res, HCF_SUCCESS);
1044 ASSERT_NE(blob.data, nullptr);
1045 ASSERT_NE(blob.len, 0);
1046 HcfFree(blob.data);
1047 HcfObjDestroy(keyPair);
1048 }
1049
1050 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest038, TestSize.Level0)
1051 {
1052 HcfKeyPair *keyPair = nullptr;
1053 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1054 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1055
1056 ASSERT_EQ(res, HCF_SUCCESS);
1057 ASSERT_NE(keyPair, nullptr);
1058
1059 keyPair->priKey->clearMem((HcfPriKey *)&g_obj);
1060 HcfBlob blob = { .data = nullptr, .len = 0 };
1061 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
1062 ASSERT_EQ(res, HCF_SUCCESS);
1063 ASSERT_NE(blob.data, nullptr);
1064 ASSERT_NE(blob.len, 0);
1065 HcfFree(blob.data);
1066 HcfObjDestroy(keyPair);
1067 }
1068
1069 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest039, TestSize.Level0)
1070 {
1071 HcfKeyPair *keyPair = nullptr;
1072 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1073 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1074
1075 ASSERT_EQ(res, HCF_SUCCESS);
1076 ASSERT_NE(keyPair, nullptr);
1077
1078 keyPair->pubKey->base.base.destroy(nullptr);
1079 HcfObjDestroy(keyPair);
1080 }
1081
1082 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest040, TestSize.Level0)
1083 {
1084 HcfKeyPair *keyPair = nullptr;
1085 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1086 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1087
1088 ASSERT_EQ(res, HCF_SUCCESS);
1089 ASSERT_NE(keyPair, nullptr);
1090
1091 keyPair->pubKey->base.base.destroy(&g_obj);
1092 HcfObjDestroy(keyPair);
1093 }
1094
1095 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest041, TestSize.Level0)
1096 {
1097 HcfKeyPair *keyPair = nullptr;
1098 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1099 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1100
1101 ASSERT_EQ(res, HCF_SUCCESS);
1102 ASSERT_NE(keyPair, nullptr);
1103
1104 keyPair->priKey->base.base.destroy(nullptr);
1105 HcfObjDestroy(keyPair);
1106 }
1107
1108 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest042, TestSize.Level0)
1109 {
1110 HcfKeyPair *keyPair = nullptr;
1111 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1112 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1113
1114 ASSERT_EQ(res, HCF_SUCCESS);
1115 ASSERT_NE(keyPair, nullptr);
1116
1117 keyPair->priKey->base.base.destroy(&g_obj);
1118 HcfObjDestroy(keyPair);
1119 }
1120
1121 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest043, TestSize.Level0)
1122 {
1123 HcfAsyKeyGenParams params = {
1124 .algo = HCF_ALG_DH,
1125 .bits = HCF_OPENSSL_DH_MODP_1536,
1126 .primes = HCF_OPENSSL_PRIMES_2,
1127 };
1128
1129 HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
1130 HcfResult res = HcfAsyKeyGeneratorSpiDhCreate(¶ms, &returnSpi);
1131
1132 ASSERT_EQ(res, HCF_SUCCESS);
1133 ASSERT_NE(returnSpi, nullptr);
1134
1135 HcfKeyPair *keyPair = nullptr;
1136 res = returnSpi->engineConvertKey((HcfAsyKeyGeneratorSpi *)&g_obj, nullptr, &g_mockDH1536PubKeyBlob,
1137 &g_mockDH1536PriKeyBlob, &keyPair);
1138 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1139 ASSERT_EQ(keyPair, nullptr);
1140
1141 HcfObjDestroy(returnSpi);
1142 HcfObjDestroy(keyPair);
1143 }
1144
1145 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest044, TestSize.Level0)
1146 {
1147 HcfAsyKeyGenParams params = {
1148 .algo = HCF_ALG_DH,
1149 .bits = HCF_OPENSSL_DH_MODP_1536,
1150 .primes = HCF_OPENSSL_PRIMES_2,
1151 };
1152
1153 HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
1154 HcfResult res = HcfAsyKeyGeneratorSpiDhCreate(¶ms, &returnSpi);
1155
1156 ASSERT_EQ(res, HCF_SUCCESS);
1157 ASSERT_NE(returnSpi, nullptr);
1158
1159 HcfKeyPair *keyPair = nullptr;
1160 res = returnSpi->engineGenerateKeyPair((HcfAsyKeyGeneratorSpi *)&g_obj, &keyPair);
1161 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1162 ASSERT_EQ(keyPair, nullptr);
1163
1164 HcfObjDestroy(returnSpi);
1165 HcfObjDestroy(keyPair);
1166 }
1167
1168 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest045, TestSize.Level0)
1169 {
1170 HcfAsyKeyGenParams params = {
1171 .algo = HCF_ALG_DH,
1172 .bits = HCF_OPENSSL_DH_MODP_1536,
1173 .primes = HCF_OPENSSL_PRIMES_2,
1174 };
1175
1176 HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
1177 HcfResult res = HcfAsyKeyGeneratorSpiDhCreate(¶ms, &returnSpi);
1178
1179 ASSERT_EQ(res, HCF_SUCCESS);
1180 ASSERT_NE(returnSpi, nullptr);
1181
1182 res = returnSpi->engineGenerateKeyPair(returnSpi, nullptr);
1183 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1184
1185 HcfObjDestroy(returnSpi);
1186 }
1187
1188 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest046, TestSize.Level0)
1189 {
1190 HcfKeyPair *keyPair = nullptr;
1191 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1192 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1193
1194 ASSERT_EQ(res, HCF_SUCCESS);
1195 ASSERT_NE(keyPair, nullptr);
1196
1197 keyPair->base.destroy(nullptr);
1198 HcfObjDestroy(keyPair);
1199 }
1200
1201 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest047, TestSize.Level0)
1202 {
1203 HcfKeyPair *keyPair = nullptr;
1204 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1205 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1206
1207 ASSERT_EQ(res, HCF_SUCCESS);
1208 ASSERT_NE(keyPair, nullptr);
1209
1210 keyPair->base.destroy(&g_obj);
1211 HcfObjDestroy(keyPair);
1212 }
1213
ByteToHexString(unsigned char * byteArray,int byteArrayLen)1214 static char *ByteToHexString(unsigned char *byteArray, int byteArrayLen)
1215 {
1216 char *hexString = static_cast<char *>(malloc(byteArrayLen * BIT2 + 1));
1217 if (hexString == nullptr) {
1218 return nullptr;
1219 }
1220 int i;
1221 for (i = 0; i < byteArrayLen; i++) {
1222 if (sprintf_s(hexString + i * BIT2, (byteArrayLen - i) * BIT2 + 1, "%02x", byteArray[i]) < 0) {
1223 HcfFree(hexString);
1224 return nullptr;
1225 }
1226 }
1227 hexString[byteArrayLen * BIT2] = '\0';
1228
1229 char *reversedString = static_cast<char *>(malloc(byteArrayLen * BIT2 + 1));
1230 if (reversedString == nullptr) {
1231 HcfFree(hexString);
1232 return nullptr;
1233 }
1234 int j = 0;
1235 for (i = 0; i < byteArrayLen * BIT2; i += BIT8) {
1236 char group[BIT8 + 1];
1237 (void)memcpy_s(group, BIT8, hexString + i, BIT8);
1238 group[BIT8] = '\0';
1239 for (int k = 0; k < BIT4; k++) {
1240 char temp = group[BIT2 * k];
1241 group[BIT2 * k] = group[BIT2 * k + 1];
1242 group[BIT2 * k + 1] = temp;
1243 }
1244 (void)memcpy_s(reversedString + j, BIT8, group, BIT8);
1245 j += BIT8;
1246 }
1247 reversedString[j] = '\0';
1248
1249 for (i = 0; i < byteArrayLen * BIT2; i += BIT8) {
1250 int start = i;
1251 int end = i + BIT8 - 1;
1252 if (end >= byteArrayLen * BIT2) {
1253 end = byteArrayLen * BIT2 - 1;
1254 }
1255 for (j = start; j < end; j++, end--) {
1256 char temp = reversedString[j];
1257 reversedString[j] = reversedString[end];
1258 reversedString[end] = temp;
1259 }
1260 }
1261 HcfFree(hexString);
1262 return reversedString;
1263 }
1264
DhPrimeValueCompareWithOpenssl(const char * algName,string OpensslPrime)1265 static HcfResult DhPrimeValueCompareWithOpenssl(const char *algName, string OpensslPrime)
1266 {
1267 HcfAsyKeyGenerator *generator = nullptr;
1268 HcfResult res = HcfAsyKeyGeneratorCreate(algName, &generator);
1269 if (res != HCF_SUCCESS) {
1270 return res;
1271 }
1272
1273 HcfKeyPair *keyPair = nullptr;
1274 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1275 if (res != HCF_SUCCESS) {
1276 HcfObjDestroy(generator);
1277 return res;
1278 }
1279
1280 HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
1281 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, DH_P_BN, &returnBigInteger);
1282 if (res != HCF_SUCCESS) {
1283 HcfObjDestroy(generator);
1284 HcfObjDestroy(keyPair);
1285 return res;
1286 }
1287
1288 char *hexString = ByteToHexString(returnBigInteger.data, returnBigInteger.len);
1289 if (hexString == nullptr) {
1290 HcfFree(returnBigInteger.data);
1291 HcfObjDestroy(generator);
1292 HcfObjDestroy(keyPair);
1293 return HCF_INVALID_PARAMS;
1294 }
1295 int32_t flag = strcmp(hexString, OpensslPrime.data());
1296 if (flag) {
1297 res = HCF_INVALID_PARAMS;
1298 }
1299
1300 HcfFree(hexString);
1301 HcfFree(returnBigInteger.data);
1302 HcfObjDestroy(generator);
1303 HcfObjDestroy(keyPair);
1304 return res;
1305 }
1306
1307 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest048, TestSize.Level0)
1308 {
1309 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_modp1536", g_modp_1536_p);
1310 ASSERT_EQ(res, HCF_SUCCESS);
1311 }
1312
1313 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest049, TestSize.Level0)
1314 {
1315 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_modp2048", g_modp_2048_p);
1316 ASSERT_EQ(res, HCF_SUCCESS);
1317 }
1318
1319 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest050, TestSize.Level0)
1320 {
1321 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_modp3072", g_modp_3072_p);
1322 ASSERT_EQ(res, HCF_SUCCESS);
1323 }
1324
1325 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest051, TestSize.Level0)
1326 {
1327 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_modp4096", g_modp_4096_p);
1328 ASSERT_EQ(res, HCF_SUCCESS);
1329 }
1330
1331 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest052, TestSize.Level0)
1332 {
1333 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_modp6144", g_modp_6144_p);
1334 ASSERT_EQ(res, HCF_SUCCESS);
1335 }
1336
1337 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest053, TestSize.Level0)
1338 {
1339 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_modp8192", g_modp_8192_p);
1340 ASSERT_EQ(res, HCF_SUCCESS);
1341 }
1342
1343 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest054, TestSize.Level0)
1344 {
1345 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_ffdhe2048", g_ffdhe_2048_p);
1346 ASSERT_EQ(res, HCF_SUCCESS);
1347 }
1348
1349 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest055, TestSize.Level0)
1350 {
1351 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_ffdhe3072", g_ffdhe_3072_p);
1352 ASSERT_EQ(res, HCF_SUCCESS);
1353 }
1354
1355 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest056, TestSize.Level0)
1356 {
1357 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_ffdhe4096", g_ffdhe_4096_p);
1358 ASSERT_EQ(res, HCF_SUCCESS);
1359 }
1360
1361 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest057, TestSize.Level0)
1362 {
1363 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_ffdhe6144", g_ffdhe_6144_p);
1364 ASSERT_EQ(res, HCF_SUCCESS);
1365 }
1366
1367 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest058, TestSize.Level0)
1368 {
1369 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_ffdhe8192", g_ffdhe_8192_p);
1370 ASSERT_EQ(res, HCF_SUCCESS);
1371 }
1372 }
1373