1 /*
2 * Copyright (C) 2022-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 "key_agreement.h"
21
22 using namespace std;
23 using namespace testing::ext;
24
25 namespace {
26 class CryptoEccKeyAgreementTest : public testing::Test {
27 public:
28 static void SetUpTestCase();
29 static void TearDownTestCase();
30 void SetUp();
31 void TearDown();
32
33 static HcfKeyPair *ecc224KeyPair_;
34 static HcfKeyPair *ecc256KeyPair_;
35 static HcfKeyPair *ecc384KeyPair_;
36 static HcfKeyPair *ecc521KeyPair_;
37 };
38
39 HcfKeyPair *CryptoEccKeyAgreementTest::ecc224KeyPair_ = nullptr;
40 HcfKeyPair *CryptoEccKeyAgreementTest::ecc256KeyPair_ = nullptr;
41 HcfKeyPair *CryptoEccKeyAgreementTest::ecc384KeyPair_ = nullptr;
42 HcfKeyPair *CryptoEccKeyAgreementTest::ecc521KeyPair_ = nullptr;
43
SetUp()44 void CryptoEccKeyAgreementTest::SetUp() {}
TearDown()45 void CryptoEccKeyAgreementTest::TearDown() {}
46
SetUpTestCase()47 void CryptoEccKeyAgreementTest::SetUpTestCase()
48 {
49 HcfAsyKeyGenerator *generator = NULL;
50 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
51 ASSERT_EQ(res, HCF_SUCCESS);
52 ASSERT_NE(generator, nullptr);
53
54 HcfKeyPair *keyPair = NULL;
55 res = generator->generateKeyPair(generator, NULL, &keyPair);
56 ASSERT_EQ(res, HCF_SUCCESS);
57 ASSERT_NE(keyPair, nullptr);
58
59 ecc224KeyPair_ = keyPair;
60
61 HcfObjDestroy(generator);
62
63 HcfAsyKeyGenerator *generator2 = NULL;
64 res = HcfAsyKeyGeneratorCreate("ECC256", &generator2);
65 ASSERT_EQ(res, HCF_SUCCESS);
66 ASSERT_NE(generator2, nullptr);
67
68 HcfKeyPair *keyPair2 = NULL;
69 res = generator2->generateKeyPair(generator2, NULL, &keyPair2);
70 ASSERT_EQ(res, HCF_SUCCESS);
71 ASSERT_NE(keyPair2, nullptr);
72
73 ecc256KeyPair_ = keyPair2;
74
75 HcfObjDestroy(generator2);
76
77 HcfAsyKeyGenerator *generator3 = NULL;
78 res = HcfAsyKeyGeneratorCreate("ECC384", &generator3);
79 ASSERT_EQ(res, HCF_SUCCESS);
80 ASSERT_NE(generator3, nullptr);
81
82 HcfKeyPair *keyPair3 = NULL;
83 res = generator3->generateKeyPair(generator3, NULL, &keyPair3);
84 ASSERT_EQ(res, HCF_SUCCESS);
85 ASSERT_NE(keyPair3, nullptr);
86
87 ecc384KeyPair_ = keyPair3;
88
89 HcfObjDestroy(generator3);
90
91 HcfAsyKeyGenerator *generator4 = NULL;
92 res = HcfAsyKeyGeneratorCreate("ECC521", &generator4);
93 ASSERT_EQ(res, HCF_SUCCESS);
94 ASSERT_NE(generator4, nullptr);
95
96 HcfKeyPair *keyPair4 = NULL;
97 res = generator4->generateKeyPair(generator4, NULL, &keyPair4);
98 ASSERT_EQ(res, HCF_SUCCESS);
99 ASSERT_NE(keyPair4, nullptr);
100
101 ecc521KeyPair_ = keyPair4;
102
103 HcfObjDestroy(generator4);
104 }
105
TearDownTestCase()106 void CryptoEccKeyAgreementTest::TearDownTestCase()
107 {
108 HcfObjDestroy(ecc224KeyPair_);
109 HcfObjDestroy(ecc256KeyPair_);
110 HcfObjDestroy(ecc384KeyPair_);
111 HcfObjDestroy(ecc521KeyPair_);
112 }
113
GetMockClass(void)114 static const char *GetMockClass(void)
115 {
116 return "HcfSymKeyGenerator";
117 }
118
119 static HcfObjectBase obj = {
120 .getClass = GetMockClass,
121 .destroy = NULL
122 };
123
124 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest001, TestSize.Level0)
125 {
126 HcfKeyAgreement *keyAgreement = NULL;
127 int32_t res = HcfKeyAgreementCreate("ECC224", &keyAgreement);
128
129 ASSERT_EQ(res, HCF_SUCCESS);
130 ASSERT_NE(keyAgreement, nullptr);
131
132 HcfObjDestroy(keyAgreement);
133 }
134
135 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest002, TestSize.Level0)
136 {
137 HcfKeyAgreement *keyAgreement = NULL;
138 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
139
140 ASSERT_EQ(res, HCF_SUCCESS);
141 ASSERT_NE(keyAgreement, nullptr);
142
143 HcfObjDestroy(keyAgreement);
144 }
145
146 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest003, TestSize.Level0)
147 {
148 HcfKeyAgreement *keyAgreement = NULL;
149 int32_t res = HcfKeyAgreementCreate("ECC384", &keyAgreement);
150
151 ASSERT_EQ(res, HCF_SUCCESS);
152 ASSERT_NE(keyAgreement, nullptr);
153
154 HcfObjDestroy(keyAgreement);
155 }
156
157 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest004, TestSize.Level0)
158 {
159 HcfKeyAgreement *keyAgreement = NULL;
160 int32_t res = HcfKeyAgreementCreate("ECC521", &keyAgreement);
161
162 ASSERT_EQ(res, HCF_SUCCESS);
163 ASSERT_NE(keyAgreement, nullptr);
164
165 HcfObjDestroy(keyAgreement);
166 }
167
168 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest005, TestSize.Level0)
169 {
170 HcfKeyAgreement *keyAgreement = NULL;
171 int32_t res = HcfKeyAgreementCreate(NULL, &keyAgreement);
172
173 ASSERT_EQ(res, HCF_INVALID_PARAMS);
174 ASSERT_EQ(keyAgreement, nullptr);
175 }
176
177 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest006, TestSize.Level0)
178 {
179 HcfKeyAgreement *keyAgreement = NULL;
180 int32_t res = HcfKeyAgreementCreate("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD"
181 "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", &keyAgreement);
182
183 ASSERT_EQ(res, HCF_INVALID_PARAMS);
184 ASSERT_EQ(keyAgreement, nullptr);
185 }
186
187 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest007, TestSize.Level0)
188 {
189 HcfKeyAgreement *keyAgreement = NULL;
190 int32_t res = HcfKeyAgreementCreate("ECC257", &keyAgreement);
191
192 ASSERT_EQ(res, HCF_INVALID_PARAMS);
193 ASSERT_EQ(keyAgreement, nullptr);
194 }
195
196 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest008, TestSize.Level0)
197 {
198 int32_t res = HcfKeyAgreementCreate("ECC256", NULL);
199
200 ASSERT_EQ(res, HCF_INVALID_PARAMS);
201 }
202
203 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest101, TestSize.Level0)
204 {
205 HcfKeyAgreement *keyAgreement = NULL;
206 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
207
208 ASSERT_EQ(res, HCF_SUCCESS);
209 ASSERT_NE(keyAgreement, nullptr);
210
211 const char *className = keyAgreement->base.getClass();
212
213 ASSERT_NE(className, nullptr);
214
215 HcfObjDestroy(keyAgreement);
216 }
217
218 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest102, TestSize.Level0)
219 {
220 HcfKeyAgreement *keyAgreement = NULL;
221 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
222
223 ASSERT_EQ(res, HCF_SUCCESS);
224 ASSERT_NE(keyAgreement, nullptr);
225
226 keyAgreement->base.destroy((HcfObjectBase *)keyAgreement);
227 }
228
229 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest103, TestSize.Level0)
230 {
231 HcfKeyAgreement *keyAgreement = NULL;
232 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
233
234 ASSERT_EQ(res, HCF_SUCCESS);
235 ASSERT_NE(keyAgreement, nullptr);
236
237 keyAgreement->base.destroy(NULL);
238
239 HcfObjDestroy(keyAgreement);
240 }
241
242 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest104, TestSize.Level0)
243 {
244 HcfKeyAgreement *keyAgreement = NULL;
245 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
246
247 ASSERT_EQ(res, HCF_SUCCESS);
248 ASSERT_NE(keyAgreement, nullptr);
249
250 keyAgreement->base.destroy(&obj);
251
252 HcfObjDestroy(keyAgreement);
253 }
254
255 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest105, TestSize.Level0)
256 {
257 HcfKeyAgreement *keyAgreement = NULL;
258 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
259
260 ASSERT_EQ(res, HCF_SUCCESS);
261 ASSERT_NE(keyAgreement, nullptr);
262
263 const char *algName = keyAgreement->getAlgoName(keyAgreement);
264
265 ASSERT_NE(algName, nullptr);
266
267 HcfObjDestroy(keyAgreement);
268 }
269
270 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest106, TestSize.Level0)
271 {
272 HcfKeyAgreement *keyAgreement = NULL;
273 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
274
275 ASSERT_EQ(res, HCF_SUCCESS);
276 ASSERT_NE(keyAgreement, nullptr);
277
278 const char *algName = keyAgreement->getAlgoName(NULL);
279
280 ASSERT_EQ(algName, nullptr);
281
282 HcfObjDestroy(keyAgreement);
283 }
284
285 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest107, TestSize.Level0)
286 {
287 HcfKeyAgreement *keyAgreement = NULL;
288 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
289
290 ASSERT_EQ(res, HCF_SUCCESS);
291 ASSERT_NE(keyAgreement, nullptr);
292
293 const char *algName = keyAgreement->getAlgoName((HcfKeyAgreement *)(&obj));
294
295 ASSERT_EQ(algName, nullptr);
296
297 HcfObjDestroy(keyAgreement);
298 }
299
300 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest201, TestSize.Level0)
301 {
302 HcfKeyAgreement *keyAgreement = NULL;
303 int32_t res = HcfKeyAgreementCreate("ECC224", &keyAgreement);
304
305 ASSERT_EQ(res, HCF_SUCCESS);
306 ASSERT_NE(keyAgreement, nullptr);
307
308 HcfBlob out = {
309 .data = NULL,
310 .len = 0
311 };
312 res = keyAgreement->generateSecret(keyAgreement, ecc224KeyPair_->priKey, ecc224KeyPair_->pubKey, &out);
313
314 ASSERT_EQ(res, HCF_SUCCESS);
315 ASSERT_NE(out.data, nullptr);
316 ASSERT_NE(out.len, (const unsigned int)0);
317
318 free(out.data);
319 HcfObjDestroy(keyAgreement);
320 }
321
322 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest202, TestSize.Level0)
323 {
324 HcfKeyAgreement *keyAgreement = NULL;
325 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
326
327 ASSERT_EQ(res, HCF_SUCCESS);
328 ASSERT_NE(keyAgreement, nullptr);
329
330 HcfBlob out = {
331 .data = NULL,
332 .len = 0
333 };
334 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
335
336 ASSERT_EQ(res, HCF_SUCCESS);
337 ASSERT_NE(out.data, nullptr);
338 ASSERT_NE(out.len, (const unsigned int)0);
339
340 free(out.data);
341 HcfObjDestroy(keyAgreement);
342 }
343
344 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest203, TestSize.Level0)
345 {
346 HcfKeyAgreement *keyAgreement = NULL;
347 int32_t res = HcfKeyAgreementCreate("ECC384", &keyAgreement);
348
349 ASSERT_EQ(res, HCF_SUCCESS);
350 ASSERT_NE(keyAgreement, nullptr);
351
352 HcfBlob out = {
353 .data = NULL,
354 .len = 0
355 };
356 res = keyAgreement->generateSecret(keyAgreement, ecc384KeyPair_->priKey, ecc384KeyPair_->pubKey, &out);
357
358 ASSERT_EQ(res, HCF_SUCCESS);
359 ASSERT_NE(out.data, nullptr);
360 ASSERT_NE(out.len, (const unsigned int)0);
361
362 free(out.data);
363 HcfObjDestroy(keyAgreement);
364 }
365
366 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest204, TestSize.Level0)
367 {
368 HcfKeyAgreement *keyAgreement = NULL;
369 int32_t res = HcfKeyAgreementCreate("ECC521", &keyAgreement);
370
371 ASSERT_EQ(res, HCF_SUCCESS);
372 ASSERT_NE(keyAgreement, nullptr);
373
374 HcfBlob out = {
375 .data = NULL,
376 .len = 0
377 };
378 res = keyAgreement->generateSecret(keyAgreement, ecc521KeyPair_->priKey, ecc521KeyPair_->pubKey, &out);
379
380 ASSERT_EQ(res, HCF_SUCCESS);
381 ASSERT_NE(out.data, nullptr);
382 ASSERT_NE(out.len, (const unsigned int)0);
383
384 free(out.data);
385 HcfObjDestroy(keyAgreement);
386 }
387
388 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest205, TestSize.Level0)
389 {
390 HcfKeyAgreement *keyAgreement = NULL;
391 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
392
393 ASSERT_EQ(res, HCF_SUCCESS);
394 ASSERT_NE(keyAgreement, nullptr);
395
396 HcfBlob out = {
397 .data = NULL,
398 .len = 0
399 };
400 res = keyAgreement->generateSecret(NULL, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
401
402 ASSERT_EQ(res, HCF_INVALID_PARAMS);
403 ASSERT_EQ(out.data, nullptr);
404 ASSERT_EQ(out.len, 0);
405
406 HcfObjDestroy(keyAgreement);
407 }
408
409 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest206, TestSize.Level0)
410 {
411 HcfKeyAgreement *keyAgreement = NULL;
412 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
413
414 ASSERT_EQ(res, HCF_SUCCESS);
415 ASSERT_NE(keyAgreement, nullptr);
416
417 HcfBlob out = {
418 .data = NULL,
419 .len = 0
420 };
421 res = keyAgreement->generateSecret((HcfKeyAgreement *)(&obj), ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
422
423 ASSERT_EQ(res, HCF_INVALID_PARAMS);
424 ASSERT_EQ(out.data, nullptr);
425 ASSERT_EQ(out.len, 0);
426
427 HcfObjDestroy(keyAgreement);
428 }
429
430 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest207, TestSize.Level0)
431 {
432 HcfKeyAgreement *keyAgreement = NULL;
433 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
434
435 ASSERT_EQ(res, HCF_SUCCESS);
436 ASSERT_NE(keyAgreement, nullptr);
437
438 HcfBlob out = {
439 .data = NULL,
440 .len = 0
441 };
442 res = keyAgreement->generateSecret(keyAgreement, (HcfPriKey *)(&obj), ecc256KeyPair_->pubKey, &out);
443
444 ASSERT_EQ(res, HCF_INVALID_PARAMS);
445 ASSERT_EQ(out.data, nullptr);
446 ASSERT_EQ(out.len, 0);
447
448 HcfObjDestroy(keyAgreement);
449 }
450
451 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest208, TestSize.Level0)
452 {
453 HcfKeyAgreement *keyAgreement = NULL;
454 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
455
456 ASSERT_EQ(res, HCF_SUCCESS);
457 ASSERT_NE(keyAgreement, nullptr);
458
459 HcfBlob out = {
460 .data = NULL,
461 .len = 0
462 };
463 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, (HcfPubKey *)(&obj), &out);
464
465 ASSERT_EQ(res, HCF_INVALID_PARAMS);
466 ASSERT_EQ(out.data, nullptr);
467 ASSERT_EQ(out.len, 0);
468
469 HcfObjDestroy(keyAgreement);
470 }
471
472 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest209, TestSize.Level0)
473 {
474 HcfKeyAgreement *keyAgreement = NULL;
475 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
476
477 ASSERT_EQ(res, HCF_SUCCESS);
478 ASSERT_NE(keyAgreement, nullptr);
479
480 HcfBlob out = {
481 .data = NULL,
482 .len = 0
483 };
484 res = keyAgreement->generateSecret(keyAgreement, NULL, NULL, &out);
485
486 ASSERT_EQ(res, HCF_INVALID_PARAMS);
487 ASSERT_EQ(out.data, nullptr);
488 ASSERT_EQ(out.len, 0);
489
490 HcfObjDestroy(keyAgreement);
491 }
492
493 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest210, TestSize.Level0)
494 {
495 HcfKeyAgreement *keyAgreement = NULL;
496 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
497
498 ASSERT_EQ(res, HCF_SUCCESS);
499 ASSERT_NE(keyAgreement, nullptr);
500
501 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, NULL);
502
503 ASSERT_EQ(res, HCF_INVALID_PARAMS);
504
505 HcfObjDestroy(keyAgreement);
506 }
507 }
508