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 "securec.h"
18
19 #include "asy_key_generator.h"
20 #include "ecc_common_param_spec.h"
21 #include "ecdh_openssl.h"
22 #include "key_agreement.h"
23 #include "ecc_key_util.h"
24 #include "memory.h"
25 #include "memory_mock.h"
26 #include "openssl_adapter_mock.h"
27 #include "params_parser.h"
28
29 using namespace std;
30 using namespace testing::ext;
31
32 namespace {
33 class CryptoBrainPoolKeyAgreementTest : public testing::Test {
34 public:
SetUpTestCase()35 static void SetUpTestCase() {};
TearDownTestCase()36 static void TearDownTestCase() {};
37 void SetUp();
38 void TearDown();
39 };
40
SetUp()41 void CryptoBrainPoolKeyAgreementTest::SetUp() {}
TearDown()42 void CryptoBrainPoolKeyAgreementTest::TearDown() {}
43
GetMockClass(void)44 static const char *GetMockClass(void)
45 {
46 return "HcfSymKeyGenerator";
47 }
48
49 static HcfObjectBase obj = {
50 .getClass = GetMockClass,
51 .destroy = nullptr
52 };
53
HcfKeyAgreementCreateTest(const char * algName)54 static HcfResult HcfKeyAgreementCreateTest(const char *algName)
55 {
56 HcfKeyAgreement *keyAgreement = nullptr;
57 HcfResult res = HcfKeyAgreementCreate(algName, &keyAgreement);
58 if (res == HCF_SUCCESS) {
59 HcfObjDestroy(keyAgreement);
60 }
61 return res;
62 }
63
64 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest001, TestSize.Level0)
65 {
66 HcfResult res = HcfKeyAgreementCreateTest("ECC_BrainPoolP160r1");
67 ASSERT_EQ(res, HCF_SUCCESS);
68 }
69
70 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest002, TestSize.Level0)
71 {
72 HcfResult res = HcfKeyAgreementCreateTest(nullptr);
73 ASSERT_NE(res, HCF_SUCCESS);
74 }
75
76 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest003, TestSize.Level0)
77 {
78 HcfResult res = HcfKeyAgreementCreateTest("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD"
79 "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD");
80 ASSERT_NE(res, HCF_SUCCESS);
81 }
82
83 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest004, TestSize.Level0)
84 {
85 HcfResult res = HcfKeyAgreementCreateTest("SM257");
86 ASSERT_NE(res, HCF_SUCCESS);
87 }
88
89 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest005, TestSize.Level0)
90 {
91 HcfResult res = HcfKeyAgreementCreate("ECC_BrainPoolP512t1", nullptr);
92 ASSERT_NE(res, HCF_SUCCESS);
93 }
94
95 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest006, TestSize.Level0)
96 {
97 HcfKeyAgreement *keyAgreement = nullptr;
98 HcfResult res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement);
99
100 ASSERT_EQ(res, HCF_SUCCESS);
101 ASSERT_NE(keyAgreement, nullptr);
102
103 const char *className = keyAgreement->base.getClass();
104 ASSERT_NE(className, nullptr);
105 HcfObjDestroy(keyAgreement);
106 }
107
108 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest007, TestSize.Level0)
109 {
110 HcfKeyAgreement *keyAgreement = nullptr;
111 HcfResult res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement);
112
113 ASSERT_EQ(res, HCF_SUCCESS);
114 ASSERT_NE(keyAgreement, nullptr);
115 keyAgreement->base.destroy((HcfObjectBase *)keyAgreement);
116 }
117
118 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest008, TestSize.Level0)
119 {
120 HcfKeyAgreement *keyAgreement = nullptr;
121 HcfResult res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement);
122
123 ASSERT_EQ(res, HCF_SUCCESS);
124 ASSERT_NE(keyAgreement, nullptr);
125
126 keyAgreement->base.destroy(nullptr);
127 HcfObjDestroy(keyAgreement);
128 }
129
130 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest009, TestSize.Level0)
131 {
132 HcfKeyAgreement *keyAgreement = nullptr;
133 HcfResult res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement);
134
135 ASSERT_EQ(res, HCF_SUCCESS);
136 ASSERT_NE(keyAgreement, nullptr);
137
138 keyAgreement->base.destroy(&obj);
139 HcfObjDestroy(keyAgreement);
140 }
141
142 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest010, TestSize.Level0)
143 {
144 HcfKeyAgreement *keyAgreement = nullptr;
145 HcfResult res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement);
146
147 ASSERT_EQ(res, HCF_SUCCESS);
148 ASSERT_NE(keyAgreement, nullptr);
149
150 const char *algName = keyAgreement->getAlgoName(keyAgreement);
151 ASSERT_NE(algName, nullptr);
152 HcfObjDestroy(keyAgreement);
153 }
154
155 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest011, TestSize.Level0)
156 {
157 HcfKeyAgreement *keyAgreement = nullptr;
158 HcfResult res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement);
159
160 ASSERT_EQ(res, HCF_SUCCESS);
161 ASSERT_NE(keyAgreement, nullptr);
162
163 const char *algName = keyAgreement->getAlgoName(nullptr);
164 ASSERT_EQ(algName, nullptr);
165 HcfObjDestroy(keyAgreement);
166 }
167
168 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest012, TestSize.Level0)
169 {
170 HcfKeyAgreement *keyAgreement = nullptr;
171 HcfResult res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement);
172
173 ASSERT_EQ(res, HCF_SUCCESS);
174 ASSERT_NE(keyAgreement, nullptr);
175
176 const char *algName = keyAgreement->getAlgoName((HcfKeyAgreement *)(&obj));
177 ASSERT_EQ(algName, nullptr);
178 HcfObjDestroy(keyAgreement);
179 }
180
181 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest013, TestSize.Level0)
182 {
183 HcfKeyAgreement *keyAgreement = nullptr;
184 HcfResult res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement);
185
186 ASSERT_EQ(res, HCF_SUCCESS);
187 ASSERT_NE(keyAgreement, nullptr);
188
189 HcfKeyPair *keyPair = nullptr;
190 res = GenerateBrainpoolP160r1KeyPair(&keyPair);
191 ASSERT_EQ(res, HCF_SUCCESS);
192 ASSERT_NE(keyPair, nullptr);
193
194 HcfBlob out = { .data = nullptr, .len = 0 };
195 res = keyAgreement->generateSecret(keyAgreement, keyPair->priKey, keyPair->pubKey, &out);
196
197 ASSERT_EQ(res, HCF_SUCCESS);
198 ASSERT_NE(out.data, nullptr);
199 ASSERT_NE(out.len, (const unsigned int)0);
200
201 HcfFree(out.data);
202 HcfObjDestroy(keyPair);
203 HcfObjDestroy(keyAgreement);
204 }
205
206 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest014, TestSize.Level0)
207 {
208 HcfKeyAgreement *keyAgreement = nullptr;
209 HcfResult res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement);
210
211 ASSERT_EQ(res, HCF_SUCCESS);
212 ASSERT_NE(keyAgreement, nullptr);
213
214 HcfKeyPair *keyPair = nullptr;
215 res = GenerateBrainpoolP160r1KeyPair(&keyPair);
216 ASSERT_EQ(res, HCF_SUCCESS);
217 ASSERT_NE(keyPair, nullptr);
218
219 HcfBlob out = { .data = nullptr, .len = 0 };
220 res = keyAgreement->generateSecret(nullptr, keyPair->priKey, keyPair->pubKey, &out);
221
222 ASSERT_NE(res, HCF_SUCCESS);
223 ASSERT_EQ(out.data, nullptr);
224 ASSERT_EQ(out.len, (const unsigned int)0);
225
226 HcfFree(out.data);
227 HcfObjDestroy(keyPair);
228 HcfObjDestroy(keyAgreement);
229 }
230
231 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest015, TestSize.Level0)
232 {
233 HcfKeyAgreement *keyAgreement = nullptr;
234 HcfResult res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement);
235
236 ASSERT_EQ(res, HCF_SUCCESS);
237 ASSERT_NE(keyAgreement, nullptr);
238
239 HcfKeyPair *keyPair = nullptr;
240 res = GenerateBrainpoolP160r1KeyPair(&keyPair);
241 ASSERT_EQ(res, HCF_SUCCESS);
242 ASSERT_NE(keyPair, nullptr);
243
244 HcfBlob out = { .data = nullptr, .len = 0 };
245 res = keyAgreement->generateSecret(keyAgreement, keyPair->priKey, nullptr, &out);
246
247 ASSERT_NE(res, HCF_SUCCESS);
248 ASSERT_EQ(out.data, nullptr);
249 ASSERT_EQ(out.len, (const unsigned int)0);
250
251 HcfFree(out.data);
252 HcfObjDestroy(keyPair);
253 HcfObjDestroy(keyAgreement);
254 }
255
256 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest016, TestSize.Level0)
257 {
258 HcfKeyAgreement *keyAgreement = nullptr;
259 HcfResult res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement);
260
261 ASSERT_EQ(res, HCF_SUCCESS);
262 ASSERT_NE(keyAgreement, nullptr);
263
264 HcfKeyPair *keyPair = nullptr;
265 res = GenerateBrainpoolP160r1KeyPair(&keyPair);
266 ASSERT_EQ(res, HCF_SUCCESS);
267 ASSERT_NE(keyPair, nullptr);
268
269 HcfBlob out = { .data = nullptr, .len = 0 };
270 res = keyAgreement->generateSecret(keyAgreement, nullptr, keyPair->pubKey, &out);
271
272 ASSERT_NE(res, HCF_SUCCESS);
273 ASSERT_EQ(out.data, nullptr);
274 ASSERT_EQ(out.len, (const unsigned int)0);
275
276 HcfFree(out.data);
277 HcfObjDestroy(keyPair);
278 HcfObjDestroy(keyAgreement);
279 }
280
281 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest017, TestSize.Level0)
282 {
283 HcfKeyAgreement *keyAgreement = nullptr;
284 HcfResult res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement);
285
286 ASSERT_EQ(res, HCF_SUCCESS);
287 ASSERT_NE(keyAgreement, nullptr);
288
289 HcfKeyPair *keyPair = nullptr;
290 res = GenerateBrainpoolP160r1KeyPair(&keyPair);
291 ASSERT_EQ(res, HCF_SUCCESS);
292 ASSERT_NE(keyPair, nullptr);
293
294 res = keyAgreement->generateSecret(keyAgreement, keyPair->priKey, keyPair->pubKey, nullptr);
295 ASSERT_NE(res, HCF_SUCCESS);
296 HcfObjDestroy(keyPair);
297 HcfObjDestroy(keyAgreement);
298 }
299
300 HWTEST_F(CryptoBrainPoolKeyAgreementTest, CryptoBrainPoolKeyAgreementTest018, TestSize.Level0)
301 {
302 HcfAsyKeyGenerator *generator = nullptr;
303 HcfResult res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator);
304 ASSERT_EQ(res, HCF_SUCCESS);
305 ASSERT_NE(generator, nullptr);
306
307 HcfKeyPair *keyPair1 = nullptr;
308 res = generator->generateKeyPair(generator, nullptr, &keyPair1);
309 ASSERT_EQ(res, HCF_SUCCESS);
310 ASSERT_NE(keyPair1, nullptr);
311
312 HcfKeyPair *keyPair2 = nullptr;
313 res = generator->generateKeyPair(generator, nullptr, &keyPair2);
314 ASSERT_EQ(res, HCF_SUCCESS);
315 ASSERT_NE(keyPair2, nullptr);
316
317 HcfKeyAgreement *keyAgreement = nullptr;
318 res = HcfKeyAgreementCreate("ECC_BrainPoolP160r1", &keyAgreement);
319 ASSERT_EQ(res, HCF_SUCCESS);
320 ASSERT_NE(keyAgreement, nullptr);
321
322 HcfBlob outBlob1 = { .data = nullptr, .len = 0 };
323 res = keyAgreement->generateSecret(keyAgreement, keyPair1->priKey, keyPair2->pubKey, &outBlob1);
324 ASSERT_EQ(res, HCF_SUCCESS);
325 ASSERT_NE(outBlob1.data, nullptr);
326 ASSERT_NE(outBlob1.len, (const unsigned int)0);
327
328 HcfBlob outBlob2 = { .data = nullptr, .len = 0 };
329 res = keyAgreement->generateSecret(keyAgreement, keyPair2->priKey, keyPair1->pubKey, &outBlob2);
330 ASSERT_EQ(res, HCF_SUCCESS);
331 ASSERT_NE(outBlob2.data, nullptr);
332 ASSERT_NE(outBlob2.len, (const unsigned int)0);
333
334 bool flag = true;
335 if (*(outBlob1.data) != *(outBlob2.data)) {
336 flag = false;
337 }
338 EXPECT_EQ(flag, true);
339 ASSERT_EQ(outBlob1.len, outBlob2.len);
340
341 HcfObjDestroy(keyAgreement);
342 HcfObjDestroy(generator);
343 HcfObjDestroy(keyPair1);
344 HcfObjDestroy(keyPair2);
345 HcfFree(outBlob1.data);
346 HcfFree(outBlob2.data);
347 }
348 }