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 }