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(&params, &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(&params, &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(&params, &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