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 HcfObjDestroy(keyPair);
590
591 res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr, nullptr, &g_mockDH1536PriKeyBlob, &keyPair);
592 ASSERT_EQ(res, HCF_SUCCESS);
593 ASSERT_NE(keyPair, nullptr);
594 HcfObjDestroy(keyPair);
595
596 res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr, &g_mockDH1536PubKeyBlob, nullptr, &keyPair);
597 ASSERT_EQ(res, HCF_SUCCESS);
598 ASSERT_NE(keyPair, nullptr);
599
600 HcfObjDestroy(keyPair);
601 }
602
603 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest016, TestSize.Level0)
604 {
605 const char *className = g_dh1536KeyPair->base.getClass();
606 ASSERT_NE(className, nullptr);
607 }
608
609 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest017, TestSize.Level0)
610 {
611 HcfKeyPair *keyPair = nullptr;
612 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
613 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
614
615 ASSERT_EQ(res, HCF_SUCCESS);
616 ASSERT_NE(keyPair, nullptr);
617
618 keyPair->base.destroy(&(keyPair->base));
619 }
620
621 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest018, TestSize.Level0)
622 {
623 const char *className = g_dh1536KeyPair->pubKey->base.base.getClass();
624 ASSERT_NE(className, nullptr);
625 }
626
627 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest019, TestSize.Level0)
628 {
629 HcfKeyPair *keyPair = nullptr;
630 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
631 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
632
633 ASSERT_EQ(res, HCF_SUCCESS);
634 ASSERT_NE(keyPair, nullptr);
635
636 keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
637 keyPair->pubKey = nullptr;
638 HcfObjDestroy(keyPair);
639 }
640
641 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest020, TestSize.Level0)
642 {
643 const char *algorithmName = g_dh1536KeyPair->pubKey->base.getAlgorithm(&(g_dh1536KeyPair->pubKey->base));
644 ASSERT_EQ(algorithmName, g_dhAlgoName);
645
646 HcfBlob blob = { .data = nullptr, .len = 0 };
647 HcfResult res = g_dh1536KeyPair->pubKey->base.getEncoded(&(g_dh1536KeyPair->pubKey->base), &blob);
648 ASSERT_EQ(res, HCF_SUCCESS);
649 ASSERT_NE(blob.data, nullptr);
650 ASSERT_NE(blob.len, 0);
651 HcfFree(blob.data);
652 const char *formatName = g_dh1536KeyPair->pubKey->base.getFormat(&(g_dh1536KeyPair->pubKey->base));
653 ASSERT_EQ(formatName, g_dhpubkeyformatName);
654 }
655
656 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest021, TestSize.Level0)
657 {
658 const char *className = g_dh1536KeyPair->priKey->base.base.getClass();
659 ASSERT_NE(className, nullptr);
660 }
661
662 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest022, TestSize.Level0)
663 {
664 HcfKeyPair *keyPair = nullptr;
665 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
666 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
667
668 ASSERT_EQ(res, HCF_SUCCESS);
669 ASSERT_NE(keyPair, nullptr);
670
671 keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
672 keyPair->priKey = nullptr;
673 HcfObjDestroy(keyPair);
674 }
675
676 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest023, TestSize.Level0)
677 {
678 const char *algorithmName = g_dh1536KeyPair->priKey->base.getAlgorithm(&(g_dh1536KeyPair->priKey->base));
679 ASSERT_EQ(algorithmName, g_dhAlgoName);
680
681 HcfBlob blob = { .data = nullptr, .len = 0 };
682 HcfResult res = g_dh1536KeyPair->priKey->base.getEncoded(&(g_dh1536KeyPair->priKey->base), &blob);
683 ASSERT_EQ(res, HCF_SUCCESS);
684 ASSERT_NE(blob.data, nullptr);
685 ASSERT_NE(blob.len, 0);
686 HcfFree(blob.data);
687 const char *formatName = g_dh1536KeyPair->priKey->base.getFormat(&(g_dh1536KeyPair->priKey->base));
688 ASSERT_EQ(formatName, g_dhprikeyformatName);
689
690 int32_t returnInt = 0;
691 res = g_dh1536KeyPair->priKey->getAsyKeySpecInt(g_dh1536KeyPair->priKey, DH_L_NUM, &returnInt);
692 ASSERT_EQ(res, HCF_SUCCESS);
693 ASSERT_EQ(returnInt, 0);
694 }
695
696 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest024, TestSize.Level0)
697 {
698 HcfKeyPair *keyPair = nullptr;
699 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
700 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
701
702 ASSERT_EQ(res, HCF_SUCCESS);
703 ASSERT_NE(keyPair, nullptr);
704
705 keyPair->priKey->clearMem(keyPair->priKey);
706 HcfBlob blob = { .data = nullptr, .len = 0 };
707 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
708 ASSERT_EQ(res, HCF_ERR_CRYPTO_OPERATION);
709 ASSERT_EQ(blob.data, nullptr);
710 ASSERT_EQ(blob.len, 0);
711 HcfFree(blob.data);
712 HcfObjDestroy(keyPair);
713 }
714
MemoryMallocTestFunc(uint32_t mallocCount)715 static void MemoryMallocTestFunc(uint32_t mallocCount)
716 {
717 for (uint32_t i = 0; i < mallocCount; i++) {
718 ResetRecordMallocNum();
719 SetMockMallocIndex(i);
720 HcfAsyKeyGenerator *tmpGenerator = nullptr;
721 HcfResult res = HcfAsyKeyGeneratorCreate("DH_modp1536", &tmpGenerator);
722 if (res != HCF_SUCCESS) {
723 continue;
724 }
725 HcfKeyPair *tmpKeyPair = nullptr;
726 res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
727 if (res != HCF_SUCCESS) {
728 HcfObjDestroy(tmpGenerator);
729 continue;
730 }
731 HcfBlob tmpPubKeyBlob = {
732 .data = nullptr,
733 .len = 0
734 };
735 res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
736 if (res != HCF_SUCCESS) {
737 HcfObjDestroy(tmpKeyPair);
738 HcfObjDestroy(tmpGenerator);
739 continue;
740 }
741 HcfBlob tmpPriKeyBlob = {
742 .data = nullptr,
743 .len = 0
744 };
745 res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
746 if (res != HCF_SUCCESS) {
747 HcfFree(tmpPubKeyBlob.data);
748 HcfObjDestroy(tmpKeyPair);
749 HcfObjDestroy(tmpGenerator);
750 continue;
751 }
752 HcfKeyPair *tmpOutKeyPair = nullptr;
753 res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
754 HcfFree(tmpPubKeyBlob.data);
755 HcfFree(tmpPriKeyBlob.data);
756 HcfObjDestroy(tmpKeyPair);
757 HcfObjDestroy(tmpGenerator);
758 if (res == HCF_SUCCESS) {
759 HcfObjDestroy(tmpOutKeyPair);
760 }
761 }
762 }
763
764 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest025, TestSize.Level0)
765 {
766 StartRecordMallocNum();
767 HcfAsyKeyGenerator *generator = nullptr;
768 HcfResult res = HcfAsyKeyGeneratorCreate("DH_modp1536", &generator);
769
770 HcfKeyPair *keyPair = nullptr;
771 res = generator->generateKeyPair(generator, nullptr, &keyPair);
772
773 ASSERT_EQ(res, HCF_SUCCESS);
774 ASSERT_NE(keyPair, nullptr);
775
776 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
777 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
778
779 ASSERT_EQ(res, HCF_SUCCESS);
780 ASSERT_NE(pubKeyBlob.data, nullptr);
781 ASSERT_NE(pubKeyBlob.len, 0);
782
783 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
784 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
785
786 ASSERT_EQ(res, HCF_SUCCESS);
787 ASSERT_NE(priKeyBlob.data, nullptr);
788 ASSERT_NE(priKeyBlob.len, 0);
789
790 HcfKeyPair *outKeyPair = nullptr;
791 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
792
793 HcfFree(pubKeyBlob.data);
794 HcfFree(priKeyBlob.data);
795 HcfObjDestroy(outKeyPair);
796 HcfObjDestroy(keyPair);
797 HcfObjDestroy(generator);
798
799 uint32_t mallocCount = GetMallocNum();
800 MemoryMallocTestFunc(mallocCount);
801
802 EndRecordMallocNum();
803 }
804
OpensslMockTestFunc(uint32_t mallocCount)805 static void OpensslMockTestFunc(uint32_t mallocCount)
806 {
807 for (uint32_t i = 0; i < mallocCount; i++) {
808 ResetOpensslCallNum();
809 SetOpensslCallMockIndex(i);
810 HcfAsyKeyGenerator *tmpGenerator = nullptr;
811 HcfResult res = HcfAsyKeyGeneratorCreate("DH_modp1536", &tmpGenerator);
812 if (res != HCF_SUCCESS) {
813 continue;
814 }
815 HcfKeyPair *tmpKeyPair = nullptr;
816 res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
817 if (res != HCF_SUCCESS) {
818 HcfObjDestroy(tmpGenerator);
819 continue;
820 }
821 HcfBlob tmpPubKeyBlob = { .data = nullptr, .len = 0 };
822 res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
823 if (res != HCF_SUCCESS) {
824 HcfObjDestroy(tmpKeyPair);
825 HcfObjDestroy(tmpGenerator);
826 continue;
827 }
828 HcfBlob tmpPriKeyBlob = { .data = nullptr, .len = 0 };
829 res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
830 if (res != HCF_SUCCESS) {
831 HcfFree(tmpPubKeyBlob.data);
832 HcfObjDestroy(tmpKeyPair);
833 HcfObjDestroy(tmpGenerator);
834 continue;
835 }
836 HcfKeyPair *tmpOutKeyPair = nullptr;
837 res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
838 HcfFree(tmpPubKeyBlob.data);
839 HcfFree(tmpPriKeyBlob.data);
840 HcfObjDestroy(tmpKeyPair);
841 HcfObjDestroy(tmpGenerator);
842 if (res == HCF_SUCCESS) {
843 HcfObjDestroy(tmpOutKeyPair);
844 }
845 }
846 }
847
848 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest026, TestSize.Level0)
849 {
850 StartRecordOpensslCallNum();
851 HcfAsyKeyGenerator *generator = nullptr;
852 HcfResult res = HcfAsyKeyGeneratorCreate("DH_modp1536", &generator);
853 ASSERT_EQ(res, HCF_SUCCESS);
854
855 HcfKeyPair *keyPair = nullptr;
856 res = generator->generateKeyPair(generator, nullptr, &keyPair);
857
858 ASSERT_EQ(res, HCF_SUCCESS);
859 ASSERT_NE(keyPair, nullptr);
860
861 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
862 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
863
864 ASSERT_EQ(res, HCF_SUCCESS);
865 ASSERT_NE(pubKeyBlob.data, nullptr);
866 ASSERT_NE(pubKeyBlob.len, 0);
867
868 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
869 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
870
871 ASSERT_EQ(res, HCF_SUCCESS);
872 ASSERT_NE(priKeyBlob.data, nullptr);
873 ASSERT_NE(priKeyBlob.len, 0);
874
875 HcfKeyPair *outKeyPair = nullptr;
876 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
877
878 HcfFree(pubKeyBlob.data);
879 HcfFree(priKeyBlob.data);
880 HcfObjDestroy(outKeyPair);
881 HcfObjDestroy(keyPair);
882 HcfObjDestroy(generator);
883
884 uint32_t mallocCount = GetOpensslCallNum();
885 OpensslMockTestFunc(mallocCount);
886
887 EndRecordOpensslCallNum();
888 }
889
890 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest027, TestSize.Level0)
891 {
892 const char *algoName1 = g_dh1536Generator->getAlgoName(nullptr);
893 ASSERT_EQ(algoName1, nullptr);
894
895 const char *algoName2 = g_dh1536Generator->getAlgoName((HcfAsyKeyGenerator *)&g_obj);
896 ASSERT_EQ(algoName2, nullptr);
897 }
898
899 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest028, TestSize.Level0)
900 {
901 HcfAsyKeyGenerator *generator = nullptr;
902 HcfResult res = HcfAsyKeyGeneratorCreate("DH_modp1536", &generator);
903
904 ASSERT_EQ(res, HCF_SUCCESS);
905 ASSERT_NE(generator, nullptr);
906
907 generator->base.destroy(nullptr);
908 HcfObjDestroy(generator);
909 }
910
911 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest029, TestSize.Level0)
912 {
913 HcfAsyKeyGenerator *generator = nullptr;
914 HcfResult res = HcfAsyKeyGeneratorCreate("DH_modp1536", &generator);
915 ASSERT_EQ(res, HCF_SUCCESS);
916 ASSERT_NE(generator, nullptr);
917
918 generator->base.destroy(&g_obj);
919 HcfObjDestroy(generator);
920 }
921
922 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest030, TestSize.Level0)
923 {
924 HcfKeyPair *keyPair = nullptr;
925 HcfResult res = g_dh1536Generator->convertKey(nullptr, nullptr,
926 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
927 ASSERT_EQ(res, HCF_INVALID_PARAMS);
928 ASSERT_EQ(keyPair, nullptr);
929
930 res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
931 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, nullptr);
932 ASSERT_EQ(res, HCF_INVALID_PARAMS);
933
934 res = g_dh1536Generator->convertKey((HcfAsyKeyGenerator *)&g_obj, nullptr, &g_mockDH1536PubKeyBlob,
935 &g_mockDH1536PriKeyBlob, &keyPair);
936 ASSERT_EQ(res, HCF_INVALID_PARAMS);
937 ASSERT_EQ(keyPair, nullptr);
938
939 res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr, nullptr, nullptr, &keyPair);
940 ASSERT_EQ(res, HCF_INVALID_PARAMS);
941 ASSERT_EQ(keyPair, nullptr);
942
943 res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob,
944 &g_mockECC_BrainPool160r1PriKeyBlob, &keyPair);
945 ASSERT_EQ(res, HCF_ERR_CRYPTO_OPERATION);
946 ASSERT_EQ(keyPair, nullptr);
947
948 HcfObjDestroy(keyPair);
949 }
950
951 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest031, TestSize.Level0)
952 {
953 const char *algorithmName = g_dh1536KeyPair->pubKey->base.getAlgorithm(nullptr);
954 ASSERT_EQ(algorithmName, nullptr);
955
956 const char *algorithmName1 = g_dh1536KeyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj);
957 ASSERT_EQ(algorithmName1, nullptr);
958 }
959
960 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest032, TestSize.Level0)
961 {
962 HcfBlob blob = { .data = nullptr, .len = 0 };
963 HcfResult res = g_dh1536KeyPair->pubKey->base.getEncoded(nullptr, &blob);
964 ASSERT_EQ(res, HCF_INVALID_PARAMS);
965 ASSERT_EQ(blob.data, nullptr);
966 ASSERT_EQ(blob.len, 0);
967
968 res = g_dh1536KeyPair->pubKey->base.getEncoded(&(g_dh1536KeyPair->pubKey->base), nullptr);
969 ASSERT_EQ(res, HCF_INVALID_PARAMS);
970
971 res = g_dh1536KeyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob);
972 ASSERT_EQ(res, HCF_INVALID_PARAMS);
973 ASSERT_EQ(blob.data, nullptr);
974 ASSERT_EQ(blob.len, 0);
975 HcfFree(blob.data);
976 }
977
978 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest033, TestSize.Level0)
979 {
980 const char *formatName = g_dh1536KeyPair->pubKey->base.getFormat(nullptr);
981 ASSERT_EQ(formatName, nullptr);
982
983 const char *formatName1 = g_dh1536KeyPair->pubKey->base.getFormat((HcfKey *)&g_obj);
984 ASSERT_EQ(formatName1, nullptr);
985 }
986
987 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest034, TestSize.Level0)
988 {
989 const char *algorithmName = g_dh1536KeyPair->priKey->base.getAlgorithm(nullptr);
990 ASSERT_EQ(algorithmName, nullptr);
991
992 const char *algorithmName1 = g_dh1536KeyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj);
993 ASSERT_EQ(algorithmName1, nullptr);
994 }
995
996 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest035, TestSize.Level0)
997 {
998 HcfBlob blob = { .data = nullptr, .len = 0 };
999 HcfResult res = g_dh1536KeyPair->priKey->base.getEncoded(nullptr, &blob);
1000 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1001 ASSERT_EQ(blob.data, nullptr);
1002 ASSERT_EQ(blob.len, 0);
1003
1004 res = g_dh1536KeyPair->priKey->base.getEncoded(&(g_dh1536KeyPair->priKey->base), nullptr);
1005 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1006
1007 res = g_dh1536KeyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob);
1008 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1009 ASSERT_EQ(blob.data, nullptr);
1010 ASSERT_EQ(blob.len, 0);
1011
1012 HcfFree(blob.data);
1013 }
1014
1015 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest036, TestSize.Level0)
1016 {
1017 HcfKeyPair *keyPair = nullptr;
1018 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1019 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1020
1021 ASSERT_EQ(res, HCF_SUCCESS);
1022 ASSERT_NE(keyPair, nullptr);
1023
1024 const char *formatName = formatName = keyPair->priKey->base.getFormat(nullptr);
1025 ASSERT_EQ(formatName, nullptr);
1026
1027 const char *formatName1 = keyPair->priKey->base.getFormat((HcfKey *)&g_obj);
1028 ASSERT_EQ(formatName1, nullptr);
1029
1030 HcfObjDestroy(keyPair);
1031 }
1032
1033 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest037, TestSize.Level0)
1034 {
1035 HcfKeyPair *keyPair = nullptr;
1036 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1037 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1038
1039 ASSERT_EQ(res, HCF_SUCCESS);
1040 ASSERT_NE(keyPair, nullptr);
1041
1042 keyPair->priKey->clearMem(nullptr);
1043 HcfBlob blob = { .data = nullptr, .len = 0 };
1044 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
1045 ASSERT_EQ(res, HCF_SUCCESS);
1046 ASSERT_NE(blob.data, nullptr);
1047 ASSERT_NE(blob.len, 0);
1048 HcfFree(blob.data);
1049 HcfObjDestroy(keyPair);
1050 }
1051
1052 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest038, TestSize.Level0)
1053 {
1054 HcfKeyPair *keyPair = nullptr;
1055 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1056 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1057
1058 ASSERT_EQ(res, HCF_SUCCESS);
1059 ASSERT_NE(keyPair, nullptr);
1060
1061 keyPair->priKey->clearMem((HcfPriKey *)&g_obj);
1062 HcfBlob blob = { .data = nullptr, .len = 0 };
1063 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
1064 ASSERT_EQ(res, HCF_SUCCESS);
1065 ASSERT_NE(blob.data, nullptr);
1066 ASSERT_NE(blob.len, 0);
1067 HcfFree(blob.data);
1068 HcfObjDestroy(keyPair);
1069 }
1070
1071 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest039, TestSize.Level0)
1072 {
1073 HcfKeyPair *keyPair = nullptr;
1074 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1075 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1076
1077 ASSERT_EQ(res, HCF_SUCCESS);
1078 ASSERT_NE(keyPair, nullptr);
1079
1080 keyPair->pubKey->base.base.destroy(nullptr);
1081 HcfObjDestroy(keyPair);
1082 }
1083
1084 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest040, TestSize.Level0)
1085 {
1086 HcfKeyPair *keyPair = nullptr;
1087 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1088 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1089
1090 ASSERT_EQ(res, HCF_SUCCESS);
1091 ASSERT_NE(keyPair, nullptr);
1092
1093 keyPair->pubKey->base.base.destroy(&g_obj);
1094 HcfObjDestroy(keyPair);
1095 }
1096
1097 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest041, TestSize.Level0)
1098 {
1099 HcfKeyPair *keyPair = nullptr;
1100 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1101 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1102
1103 ASSERT_EQ(res, HCF_SUCCESS);
1104 ASSERT_NE(keyPair, nullptr);
1105
1106 keyPair->priKey->base.base.destroy(nullptr);
1107 HcfObjDestroy(keyPair);
1108 }
1109
1110 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest042, TestSize.Level0)
1111 {
1112 HcfKeyPair *keyPair = nullptr;
1113 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1114 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1115
1116 ASSERT_EQ(res, HCF_SUCCESS);
1117 ASSERT_NE(keyPair, nullptr);
1118
1119 keyPair->priKey->base.base.destroy(&g_obj);
1120 HcfObjDestroy(keyPair);
1121 }
1122
1123 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest043, TestSize.Level0)
1124 {
1125 HcfAsyKeyGenParams params = {
1126 .algo = HCF_ALG_DH,
1127 .bits = HCF_OPENSSL_DH_MODP_1536,
1128 .primes = HCF_OPENSSL_PRIMES_2,
1129 };
1130
1131 HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
1132 HcfResult res = HcfAsyKeyGeneratorSpiDhCreate(¶ms, &returnSpi);
1133
1134 ASSERT_EQ(res, HCF_SUCCESS);
1135 ASSERT_NE(returnSpi, nullptr);
1136
1137 HcfKeyPair *keyPair = nullptr;
1138 res = returnSpi->engineConvertKey((HcfAsyKeyGeneratorSpi *)&g_obj, nullptr, &g_mockDH1536PubKeyBlob,
1139 &g_mockDH1536PriKeyBlob, &keyPair);
1140 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1141 ASSERT_EQ(keyPair, nullptr);
1142
1143 HcfObjDestroy(returnSpi);
1144 HcfObjDestroy(keyPair);
1145 }
1146
1147 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest044, TestSize.Level0)
1148 {
1149 HcfAsyKeyGenParams params = {
1150 .algo = HCF_ALG_DH,
1151 .bits = HCF_OPENSSL_DH_MODP_1536,
1152 .primes = HCF_OPENSSL_PRIMES_2,
1153 };
1154
1155 HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
1156 HcfResult res = HcfAsyKeyGeneratorSpiDhCreate(¶ms, &returnSpi);
1157
1158 ASSERT_EQ(res, HCF_SUCCESS);
1159 ASSERT_NE(returnSpi, nullptr);
1160
1161 HcfKeyPair *keyPair = nullptr;
1162 res = returnSpi->engineGenerateKeyPair((HcfAsyKeyGeneratorSpi *)&g_obj, &keyPair);
1163 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1164 ASSERT_EQ(keyPair, nullptr);
1165
1166 HcfObjDestroy(returnSpi);
1167 HcfObjDestroy(keyPair);
1168 }
1169
1170 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest045, TestSize.Level0)
1171 {
1172 HcfAsyKeyGenParams params = {
1173 .algo = HCF_ALG_DH,
1174 .bits = HCF_OPENSSL_DH_MODP_1536,
1175 .primes = HCF_OPENSSL_PRIMES_2,
1176 };
1177
1178 HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
1179 HcfResult res = HcfAsyKeyGeneratorSpiDhCreate(¶ms, &returnSpi);
1180
1181 ASSERT_EQ(res, HCF_SUCCESS);
1182 ASSERT_NE(returnSpi, nullptr);
1183
1184 res = returnSpi->engineGenerateKeyPair(returnSpi, nullptr);
1185 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1186
1187 HcfObjDestroy(returnSpi);
1188 }
1189
1190 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest046, TestSize.Level0)
1191 {
1192 HcfKeyPair *keyPair = nullptr;
1193 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1194 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1195
1196 ASSERT_EQ(res, HCF_SUCCESS);
1197 ASSERT_NE(keyPair, nullptr);
1198
1199 keyPair->base.destroy(nullptr);
1200 HcfObjDestroy(keyPair);
1201 }
1202
1203 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest047, TestSize.Level0)
1204 {
1205 HcfKeyPair *keyPair = nullptr;
1206 HcfResult res = g_dh1536Generator->convertKey(g_dh1536Generator, nullptr,
1207 &g_mockDH1536PubKeyBlob, &g_mockDH1536PriKeyBlob, &keyPair);
1208
1209 ASSERT_EQ(res, HCF_SUCCESS);
1210 ASSERT_NE(keyPair, nullptr);
1211
1212 keyPair->base.destroy(&g_obj);
1213 HcfObjDestroy(keyPair);
1214 }
1215
ByteToHexString(unsigned char * byteArray,int byteArrayLen)1216 static char *ByteToHexString(unsigned char *byteArray, int byteArrayLen)
1217 {
1218 char *hexString = static_cast<char *>(malloc(byteArrayLen * BIT2 + 1));
1219 if (hexString == nullptr) {
1220 return nullptr;
1221 }
1222 int i;
1223 for (i = 0; i < byteArrayLen; i++) {
1224 if (sprintf_s(hexString + i * BIT2, (byteArrayLen - i) * BIT2 + 1, "%02x", byteArray[i]) < 0) {
1225 HcfFree(hexString);
1226 return nullptr;
1227 }
1228 }
1229 hexString[byteArrayLen * BIT2] = '\0';
1230
1231 char *reversedString = static_cast<char *>(malloc(byteArrayLen * BIT2 + 1));
1232 if (reversedString == nullptr) {
1233 HcfFree(hexString);
1234 return nullptr;
1235 }
1236 int j = 0;
1237 for (i = 0; i < byteArrayLen * BIT2; i += BIT8) {
1238 char group[BIT8 + 1];
1239 (void)memcpy_s(group, BIT8, hexString + i, BIT8);
1240 group[BIT8] = '\0';
1241 for (int k = 0; k < BIT4; k++) {
1242 char temp = group[BIT2 * k];
1243 group[BIT2 * k] = group[BIT2 * k + 1];
1244 group[BIT2 * k + 1] = temp;
1245 }
1246 (void)memcpy_s(reversedString + j, BIT8, group, BIT8);
1247 j += BIT8;
1248 }
1249 reversedString[j] = '\0';
1250
1251 for (i = 0; i < byteArrayLen * BIT2; i += BIT8) {
1252 int start = i;
1253 int end = i + BIT8 - 1;
1254 if (end >= byteArrayLen * BIT2) {
1255 end = byteArrayLen * BIT2 - 1;
1256 }
1257 for (j = start; j < end; j++, end--) {
1258 char temp = reversedString[j];
1259 reversedString[j] = reversedString[end];
1260 reversedString[end] = temp;
1261 }
1262 }
1263 HcfFree(hexString);
1264 return reversedString;
1265 }
1266
DhPrimeValueCompareWithOpenssl(const char * algName,string OpensslPrime)1267 static HcfResult DhPrimeValueCompareWithOpenssl(const char *algName, string OpensslPrime)
1268 {
1269 HcfAsyKeyGenerator *generator = nullptr;
1270 HcfResult res = HcfAsyKeyGeneratorCreate(algName, &generator);
1271 if (res != HCF_SUCCESS) {
1272 return res;
1273 }
1274
1275 HcfKeyPair *keyPair = nullptr;
1276 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1277 if (res != HCF_SUCCESS) {
1278 HcfObjDestroy(generator);
1279 return res;
1280 }
1281
1282 HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
1283 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, DH_P_BN, &returnBigInteger);
1284 if (res != HCF_SUCCESS) {
1285 HcfObjDestroy(generator);
1286 HcfObjDestroy(keyPair);
1287 return res;
1288 }
1289
1290 char *hexString = ByteToHexString(returnBigInteger.data, returnBigInteger.len);
1291 if (hexString == nullptr) {
1292 HcfFree(returnBigInteger.data);
1293 HcfObjDestroy(generator);
1294 HcfObjDestroy(keyPair);
1295 return HCF_INVALID_PARAMS;
1296 }
1297 int32_t flag = strcmp(hexString, OpensslPrime.data());
1298 if (flag) {
1299 res = HCF_INVALID_PARAMS;
1300 }
1301
1302 HcfFree(hexString);
1303 HcfFree(returnBigInteger.data);
1304 HcfObjDestroy(generator);
1305 HcfObjDestroy(keyPair);
1306 return res;
1307 }
1308
1309 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest048, TestSize.Level0)
1310 {
1311 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_modp1536", g_modp_1536_p);
1312 ASSERT_EQ(res, HCF_SUCCESS);
1313 }
1314
1315 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest049, TestSize.Level0)
1316 {
1317 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_modp2048", g_modp_2048_p);
1318 ASSERT_EQ(res, HCF_SUCCESS);
1319 }
1320
1321 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest050, TestSize.Level0)
1322 {
1323 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_modp3072", g_modp_3072_p);
1324 ASSERT_EQ(res, HCF_SUCCESS);
1325 }
1326
1327 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest051, TestSize.Level0)
1328 {
1329 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_modp4096", g_modp_4096_p);
1330 ASSERT_EQ(res, HCF_SUCCESS);
1331 }
1332
1333 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest052, TestSize.Level0)
1334 {
1335 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_modp6144", g_modp_6144_p);
1336 ASSERT_EQ(res, HCF_SUCCESS);
1337 }
1338
1339 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest053, TestSize.Level0)
1340 {
1341 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_modp8192", g_modp_8192_p);
1342 ASSERT_EQ(res, HCF_SUCCESS);
1343 }
1344
1345 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest054, TestSize.Level0)
1346 {
1347 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_ffdhe2048", g_ffdhe_2048_p);
1348 ASSERT_EQ(res, HCF_SUCCESS);
1349 }
1350
1351 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest055, TestSize.Level0)
1352 {
1353 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_ffdhe3072", g_ffdhe_3072_p);
1354 ASSERT_EQ(res, HCF_SUCCESS);
1355 }
1356
1357 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest056, TestSize.Level0)
1358 {
1359 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_ffdhe4096", g_ffdhe_4096_p);
1360 ASSERT_EQ(res, HCF_SUCCESS);
1361 }
1362
1363 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest057, TestSize.Level0)
1364 {
1365 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_ffdhe6144", g_ffdhe_6144_p);
1366 ASSERT_EQ(res, HCF_SUCCESS);
1367 }
1368
1369 HWTEST_F(CryptoDHAsyKeyGeneratorTest, CryptoDHAsyKeyGeneratorTest058, TestSize.Level0)
1370 {
1371 HcfResult res = DhPrimeValueCompareWithOpenssl("DH_ffdhe8192", g_ffdhe_8192_p);
1372 ASSERT_EQ(res, HCF_SUCCESS);
1373 }
1374 }
1375