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 "ecdh_openssl.h"
21 #include "key_agreement.h"
22 #include "memory.h"
23 #include "memory_mock.h"
24 #include "openssl_adapter_mock.h"
25 #include "params_parser.h"
26 #include "ecc_openssl_common.h"
27
28 using namespace std;
29 using namespace testing::ext;
30
31 namespace {
32 class CryptoEccKeyAgreementTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp();
37 void TearDown();
38
39 static HcfKeyPair *ecc224KeyPair_;
40 static HcfKeyPair *ecc256KeyPair_;
41 static HcfKeyPair *ecc384KeyPair_;
42 static HcfKeyPair *ecc521KeyPair_;
43 };
44
45 HcfKeyPair *CryptoEccKeyAgreementTest::ecc224KeyPair_ = nullptr;
46 HcfKeyPair *CryptoEccKeyAgreementTest::ecc256KeyPair_ = nullptr;
47 HcfKeyPair *CryptoEccKeyAgreementTest::ecc384KeyPair_ = nullptr;
48 HcfKeyPair *CryptoEccKeyAgreementTest::ecc521KeyPair_ = nullptr;
49
SetUp()50 void CryptoEccKeyAgreementTest::SetUp() {}
TearDown()51 void CryptoEccKeyAgreementTest::TearDown() {}
52
SetUpTestCase()53 void CryptoEccKeyAgreementTest::SetUpTestCase()
54 {
55 HcfAsyKeyGenerator *generator = nullptr;
56 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
57 ASSERT_EQ(res, HCF_SUCCESS);
58 ASSERT_NE(generator, nullptr);
59
60 HcfKeyPair *keyPair = nullptr;
61 res = generator->generateKeyPair(generator, nullptr, &keyPair);
62 ASSERT_EQ(res, HCF_SUCCESS);
63 ASSERT_NE(keyPair, nullptr);
64
65 ecc224KeyPair_ = keyPair;
66
67 HcfObjDestroy(generator);
68
69 HcfAsyKeyGenerator *generator2 = nullptr;
70 res = HcfAsyKeyGeneratorCreate("ECC256", &generator2);
71 ASSERT_EQ(res, HCF_SUCCESS);
72 ASSERT_NE(generator2, nullptr);
73
74 HcfKeyPair *keyPair2 = nullptr;
75 res = generator2->generateKeyPair(generator2, nullptr, &keyPair2);
76 ASSERT_EQ(res, HCF_SUCCESS);
77 ASSERT_NE(keyPair2, nullptr);
78
79 ecc256KeyPair_ = keyPair2;
80
81 HcfObjDestroy(generator2);
82
83 HcfAsyKeyGenerator *generator3 = nullptr;
84 res = HcfAsyKeyGeneratorCreate("ECC384", &generator3);
85 ASSERT_EQ(res, HCF_SUCCESS);
86 ASSERT_NE(generator3, nullptr);
87
88 HcfKeyPair *keyPair3 = nullptr;
89 res = generator3->generateKeyPair(generator3, nullptr, &keyPair3);
90 ASSERT_EQ(res, HCF_SUCCESS);
91 ASSERT_NE(keyPair3, nullptr);
92
93 ecc384KeyPair_ = keyPair3;
94
95 HcfObjDestroy(generator3);
96
97 HcfAsyKeyGenerator *generator4 = nullptr;
98 res = HcfAsyKeyGeneratorCreate("ECC521", &generator4);
99 ASSERT_EQ(res, HCF_SUCCESS);
100 ASSERT_NE(generator4, nullptr);
101
102 HcfKeyPair *keyPair4 = nullptr;
103 res = generator4->generateKeyPair(generator4, nullptr, &keyPair4);
104 ASSERT_EQ(res, HCF_SUCCESS);
105 ASSERT_NE(keyPair4, nullptr);
106
107 ecc521KeyPair_ = keyPair4;
108
109 HcfObjDestroy(generator4);
110 }
111
TearDownTestCase()112 void CryptoEccKeyAgreementTest::TearDownTestCase()
113 {
114 HcfObjDestroy(ecc224KeyPair_);
115 HcfObjDestroy(ecc256KeyPair_);
116 HcfObjDestroy(ecc384KeyPair_);
117 HcfObjDestroy(ecc521KeyPair_);
118 }
119
GetMockClass(void)120 static const char *GetMockClass(void)
121 {
122 return "HcfSymKeyGenerator";
123 }
124
125 static HcfObjectBase obj = {
126 .getClass = GetMockClass,
127 .destroy = nullptr
128 };
129
130 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest001, TestSize.Level0)
131 {
132 HcfKeyAgreement *keyAgreement = nullptr;
133 int32_t res = HcfKeyAgreementCreate("ECC224", &keyAgreement);
134
135 ASSERT_EQ(res, HCF_SUCCESS);
136 ASSERT_NE(keyAgreement, nullptr);
137
138 HcfObjDestroy(keyAgreement);
139 }
140
141 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest002, TestSize.Level0)
142 {
143 HcfKeyAgreement *keyAgreement = nullptr;
144 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
145
146 ASSERT_EQ(res, HCF_SUCCESS);
147 ASSERT_NE(keyAgreement, nullptr);
148
149 HcfObjDestroy(keyAgreement);
150 }
151
152 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest003, TestSize.Level0)
153 {
154 HcfKeyAgreement *keyAgreement = nullptr;
155 int32_t res = HcfKeyAgreementCreate("ECC384", &keyAgreement);
156
157 ASSERT_EQ(res, HCF_SUCCESS);
158 ASSERT_NE(keyAgreement, nullptr);
159
160 HcfObjDestroy(keyAgreement);
161 }
162
163 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest004, TestSize.Level0)
164 {
165 HcfKeyAgreement *keyAgreement = nullptr;
166 int32_t res = HcfKeyAgreementCreate("ECC521", &keyAgreement);
167
168 ASSERT_EQ(res, HCF_SUCCESS);
169 ASSERT_NE(keyAgreement, nullptr);
170
171 HcfObjDestroy(keyAgreement);
172 }
173
174 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest005, TestSize.Level0)
175 {
176 HcfKeyAgreement *keyAgreement = nullptr;
177 int32_t res = HcfKeyAgreementCreate(nullptr, &keyAgreement);
178
179 ASSERT_EQ(res, HCF_INVALID_PARAMS);
180 ASSERT_EQ(keyAgreement, nullptr);
181 }
182
183 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest006, TestSize.Level0)
184 {
185 HcfKeyAgreement *keyAgreement = nullptr;
186 int32_t res = HcfKeyAgreementCreate("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD"
187 "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", &keyAgreement);
188
189 ASSERT_EQ(res, HCF_INVALID_PARAMS);
190 ASSERT_EQ(keyAgreement, nullptr);
191 }
192
193 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest007, TestSize.Level0)
194 {
195 HcfKeyAgreement *keyAgreement = nullptr;
196 int32_t res = HcfKeyAgreementCreate("ECC257", &keyAgreement);
197
198 ASSERT_EQ(res, HCF_INVALID_PARAMS);
199 ASSERT_EQ(keyAgreement, nullptr);
200 }
201
202 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest008, TestSize.Level0)
203 {
204 int32_t res = HcfKeyAgreementCreate("ECC256", nullptr);
205
206 ASSERT_EQ(res, HCF_INVALID_PARAMS);
207 }
208
209 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest101, TestSize.Level0)
210 {
211 HcfKeyAgreement *keyAgreement = nullptr;
212 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
213
214 ASSERT_EQ(res, HCF_SUCCESS);
215 ASSERT_NE(keyAgreement, nullptr);
216
217 const char *className = keyAgreement->base.getClass();
218
219 ASSERT_NE(className, nullptr);
220
221 HcfObjDestroy(keyAgreement);
222 }
223
224 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest102, TestSize.Level0)
225 {
226 HcfKeyAgreement *keyAgreement = nullptr;
227 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
228
229 ASSERT_EQ(res, HCF_SUCCESS);
230 ASSERT_NE(keyAgreement, nullptr);
231
232 keyAgreement->base.destroy((HcfObjectBase *)keyAgreement);
233 }
234
235 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest103, TestSize.Level0)
236 {
237 HcfKeyAgreement *keyAgreement = nullptr;
238 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
239
240 ASSERT_EQ(res, HCF_SUCCESS);
241 ASSERT_NE(keyAgreement, nullptr);
242
243 keyAgreement->base.destroy(nullptr);
244
245 HcfObjDestroy(keyAgreement);
246 }
247
248 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest104, TestSize.Level0)
249 {
250 HcfKeyAgreement *keyAgreement = nullptr;
251 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
252
253 ASSERT_EQ(res, HCF_SUCCESS);
254 ASSERT_NE(keyAgreement, nullptr);
255
256 keyAgreement->base.destroy(&obj);
257
258 HcfObjDestroy(keyAgreement);
259 }
260
261 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest105, TestSize.Level0)
262 {
263 HcfKeyAgreement *keyAgreement = nullptr;
264 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
265
266 ASSERT_EQ(res, HCF_SUCCESS);
267 ASSERT_NE(keyAgreement, nullptr);
268
269 const char *algName = keyAgreement->getAlgoName(keyAgreement);
270
271 ASSERT_NE(algName, nullptr);
272
273 HcfObjDestroy(keyAgreement);
274 }
275
276 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest106, TestSize.Level0)
277 {
278 HcfKeyAgreement *keyAgreement = nullptr;
279 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
280
281 ASSERT_EQ(res, HCF_SUCCESS);
282 ASSERT_NE(keyAgreement, nullptr);
283
284 const char *algName = keyAgreement->getAlgoName(nullptr);
285
286 ASSERT_EQ(algName, nullptr);
287
288 HcfObjDestroy(keyAgreement);
289 }
290
291 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest107, TestSize.Level0)
292 {
293 HcfKeyAgreement *keyAgreement = nullptr;
294 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
295
296 ASSERT_EQ(res, HCF_SUCCESS);
297 ASSERT_NE(keyAgreement, nullptr);
298
299 const char *algName = keyAgreement->getAlgoName((HcfKeyAgreement *)(&obj));
300
301 ASSERT_EQ(algName, nullptr);
302
303 HcfObjDestroy(keyAgreement);
304 }
305
306 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest201, TestSize.Level0)
307 {
308 HcfKeyAgreement *keyAgreement = nullptr;
309 int32_t res = HcfKeyAgreementCreate("ECC224", &keyAgreement);
310
311 ASSERT_EQ(res, HCF_SUCCESS);
312 ASSERT_NE(keyAgreement, nullptr);
313
314 HcfBlob out = { .data = nullptr, .len = 0 };
315 res = keyAgreement->generateSecret(keyAgreement, ecc224KeyPair_->priKey, ecc224KeyPair_->pubKey, &out);
316
317 ASSERT_EQ(res, HCF_SUCCESS);
318 ASSERT_NE(out.data, nullptr);
319 ASSERT_NE(out.len, (const unsigned int)0);
320
321 HcfFree(out.data);
322 HcfObjDestroy(keyAgreement);
323 }
324
325 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest202, TestSize.Level0)
326 {
327 HcfKeyAgreement *keyAgreement = nullptr;
328 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
329
330 ASSERT_EQ(res, HCF_SUCCESS);
331 ASSERT_NE(keyAgreement, nullptr);
332
333 HcfBlob out = { .data = nullptr, .len = 0 };
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 HcfFree(out.data);
341 HcfObjDestroy(keyAgreement);
342 }
343
344 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest203, TestSize.Level0)
345 {
346 HcfKeyAgreement *keyAgreement = nullptr;
347 int32_t res = HcfKeyAgreementCreate("ECC384", &keyAgreement);
348
349 ASSERT_EQ(res, HCF_SUCCESS);
350 ASSERT_NE(keyAgreement, nullptr);
351
352 HcfBlob out = { .data = nullptr, .len = 0 };
353 res = keyAgreement->generateSecret(keyAgreement, ecc384KeyPair_->priKey, ecc384KeyPair_->pubKey, &out);
354
355 ASSERT_EQ(res, HCF_SUCCESS);
356 ASSERT_NE(out.data, nullptr);
357 ASSERT_NE(out.len, (const unsigned int)0);
358
359 HcfFree(out.data);
360 HcfObjDestroy(keyAgreement);
361 }
362
363 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest204, TestSize.Level0)
364 {
365 HcfKeyAgreement *keyAgreement = nullptr;
366 int32_t res = HcfKeyAgreementCreate("ECC521", &keyAgreement);
367
368 ASSERT_EQ(res, HCF_SUCCESS);
369 ASSERT_NE(keyAgreement, nullptr);
370
371 HcfBlob out = { .data = nullptr, .len = 0 };
372 res = keyAgreement->generateSecret(keyAgreement, ecc521KeyPair_->priKey, ecc521KeyPair_->pubKey, &out);
373
374 ASSERT_EQ(res, HCF_SUCCESS);
375 ASSERT_NE(out.data, nullptr);
376 ASSERT_NE(out.len, (const unsigned int)0);
377
378 HcfFree(out.data);
379 HcfObjDestroy(keyAgreement);
380 }
381
382 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest205, TestSize.Level0)
383 {
384 HcfKeyAgreement *keyAgreement = nullptr;
385 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
386
387 ASSERT_EQ(res, HCF_SUCCESS);
388 ASSERT_NE(keyAgreement, nullptr);
389
390 HcfBlob out = { .data = nullptr, .len = 0 };
391 res = keyAgreement->generateSecret(nullptr, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
392
393 ASSERT_EQ(res, HCF_INVALID_PARAMS);
394 ASSERT_EQ(out.data, nullptr);
395 ASSERT_EQ(out.len, 0);
396
397 HcfObjDestroy(keyAgreement);
398 }
399
400 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest206, TestSize.Level0)
401 {
402 HcfKeyAgreement *keyAgreement = nullptr;
403 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
404
405 ASSERT_EQ(res, HCF_SUCCESS);
406 ASSERT_NE(keyAgreement, nullptr);
407
408 HcfBlob out = { .data = nullptr, .len = 0 };
409 res = keyAgreement->generateSecret((HcfKeyAgreement *)(&obj), ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
410
411 ASSERT_EQ(res, HCF_INVALID_PARAMS);
412 ASSERT_EQ(out.data, nullptr);
413 ASSERT_EQ(out.len, 0);
414
415 HcfObjDestroy(keyAgreement);
416 }
417
418 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest207, TestSize.Level0)
419 {
420 HcfKeyAgreement *keyAgreement = nullptr;
421 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
422
423 ASSERT_EQ(res, HCF_SUCCESS);
424 ASSERT_NE(keyAgreement, nullptr);
425
426 HcfBlob out = { .data = nullptr, .len = 0 };
427 res = keyAgreement->generateSecret(keyAgreement, (HcfPriKey *)(&obj), ecc256KeyPair_->pubKey, &out);
428
429 ASSERT_EQ(res, HCF_INVALID_PARAMS);
430 ASSERT_EQ(out.data, nullptr);
431 ASSERT_EQ(out.len, 0);
432
433 HcfObjDestroy(keyAgreement);
434 }
435
436 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest208, TestSize.Level0)
437 {
438 HcfKeyAgreement *keyAgreement = nullptr;
439 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
440
441 ASSERT_EQ(res, HCF_SUCCESS);
442 ASSERT_NE(keyAgreement, nullptr);
443
444 HcfBlob out = { .data = nullptr, .len = 0 };
445 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, (HcfPubKey *)(&obj), &out);
446
447 ASSERT_EQ(res, HCF_INVALID_PARAMS);
448 ASSERT_EQ(out.data, nullptr);
449 ASSERT_EQ(out.len, 0);
450
451 HcfObjDestroy(keyAgreement);
452 }
453
454 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest209, TestSize.Level0)
455 {
456 HcfKeyAgreement *keyAgreement = nullptr;
457 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
458
459 ASSERT_EQ(res, HCF_SUCCESS);
460 ASSERT_NE(keyAgreement, nullptr);
461
462 HcfBlob out = { .data = nullptr, .len = 0 };
463 res = keyAgreement->generateSecret(keyAgreement, nullptr, nullptr, &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, CryptoEccKeyAgreementTest210, TestSize.Level0)
473 {
474 HcfKeyAgreement *keyAgreement = nullptr;
475 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
476
477 ASSERT_EQ(res, HCF_SUCCESS);
478 ASSERT_NE(keyAgreement, nullptr);
479
480 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, nullptr);
481
482 ASSERT_EQ(res, HCF_INVALID_PARAMS);
483
484 HcfObjDestroy(keyAgreement);
485 }
486
487 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest301, TestSize.Level0)
488 {
489 HcfKeyAgreementSpi *spiObj = nullptr;
490 int32_t res = HcfKeyAgreementSpiEcdhCreate(nullptr, &spiObj);
491
492 ASSERT_EQ(res, HCF_INVALID_PARAMS);
493 ASSERT_EQ(spiObj, nullptr);
494 }
495
496 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest302, TestSize.Level0)
497 {
498 HcfKeyAgreementParams params = {
499 .algo = HCF_ALG_ECC,
500 };
501
502 int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, nullptr);
503
504 ASSERT_EQ(res, HCF_INVALID_PARAMS);
505 }
506
507 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest304, TestSize.Level0)
508 {
509 HcfKeyAgreementParams params = {
510 .algo = HCF_ALG_ECC,
511 };
512
513 HcfKeyAgreementSpi *spiObj = nullptr;
514 int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj);
515
516 ASSERT_EQ(res, HCF_SUCCESS);
517 ASSERT_NE(spiObj, nullptr);
518
519 HcfBlob out = { .data = nullptr, .len = 0 };
520 res = spiObj->engineGenerateSecret((HcfKeyAgreementSpi *)&obj,
521 ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
522 ASSERT_EQ(res, HCF_INVALID_PARAMS);
523
524 HcfObjDestroy(spiObj);
525 }
526
527 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest305, TestSize.Level0)
528 {
529 HcfKeyAgreementParams params = {
530 .algo = HCF_ALG_ECC,
531 };
532
533 HcfKeyAgreementSpi *spiObj = nullptr;
534 int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj);
535
536 ASSERT_EQ(res, HCF_SUCCESS);
537 ASSERT_NE(spiObj, nullptr);
538
539 HcfBlob out = { .data = nullptr, .len = 0 };
540 res = spiObj->engineGenerateSecret(spiObj, (HcfPriKey *)&obj, ecc256KeyPair_->pubKey, &out);
541 ASSERT_EQ(res, HCF_INVALID_PARAMS);
542
543 HcfObjDestroy(spiObj);
544 }
545
546 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest306, TestSize.Level0)
547 {
548 HcfKeyAgreementParams params = {
549 .algo = HCF_ALG_ECC,
550 };
551
552 HcfKeyAgreementSpi *spiObj = nullptr;
553 int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj);
554
555 ASSERT_EQ(res, HCF_SUCCESS);
556 ASSERT_NE(spiObj, nullptr);
557
558 HcfBlob out = { .data = nullptr, .len = 0 };
559 res = spiObj->engineGenerateSecret(spiObj, ecc256KeyPair_->priKey, (HcfPubKey *)&obj, &out);
560 ASSERT_EQ(res, HCF_INVALID_PARAMS);
561
562 HcfObjDestroy(spiObj);
563 }
564
565 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest307, TestSize.Level0)
566 {
567 HcfKeyAgreementParams params = {
568 .algo = HCF_ALG_ECC,
569 };
570
571 HcfKeyAgreementSpi *spiObj = nullptr;
572 int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj);
573
574 ASSERT_EQ(res, HCF_SUCCESS);
575 ASSERT_NE(spiObj, nullptr);
576
577 spiObj->base.destroy(nullptr);
578
579 HcfObjDestroy(spiObj);
580 }
581
582 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest308, TestSize.Level0)
583 {
584 HcfKeyAgreementParams params = {
585 .algo = HCF_ALG_ECC,
586 };
587
588 HcfKeyAgreementSpi *spiObj = nullptr;
589 int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj);
590
591 ASSERT_EQ(res, HCF_SUCCESS);
592 ASSERT_NE(spiObj, nullptr);
593
594 spiObj->base.destroy(&obj);
595
596 HcfObjDestroy(spiObj);
597 }
598
599 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest309, TestSize.Level0)
600 {
601 HcfKeyAgreementParams params = {
602 .algo = HCF_ALG_ECC,
603 };
604
605 HcfKeyAgreementSpi *spiObj = nullptr;
606 int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj);
607
608 ASSERT_EQ(res, HCF_SUCCESS);
609 ASSERT_NE(spiObj, nullptr);
610
611 HcfBlob out = { .data = nullptr, .len = 0 };
612 res = spiObj->engineGenerateSecret(spiObj, ecc256KeyPair_->priKey, nullptr, &out);
613 ASSERT_EQ(res, HCF_INVALID_PARAMS);
614
615 HcfObjDestroy(spiObj);
616 }
617
618 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest310, TestSize.Level0)
619 {
620 HcfKeyAgreementParams params = {
621 .algo = HCF_ALG_ECC,
622 };
623
624 HcfKeyAgreementSpi *spiObj = nullptr;
625 int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj);
626
627 ASSERT_EQ(res, HCF_SUCCESS);
628 ASSERT_NE(spiObj, nullptr);
629
630 HcfBlob out = { .data = nullptr, .len = 0 };
631 res = spiObj->engineGenerateSecret(nullptr, ecc256KeyPair_->priKey, nullptr, &out);
632 ASSERT_EQ(res, HCF_INVALID_PARAMS);
633
634 HcfObjDestroy(spiObj);
635 }
636
637 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest401, TestSize.Level0)
638 {
639 StartRecordMallocNum();
640 HcfKeyAgreement *keyAgreement = nullptr;
641 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
642
643 ASSERT_EQ(res, HCF_SUCCESS);
644 ASSERT_NE(keyAgreement, nullptr);
645
646 HcfBlob out = { .data = nullptr, .len = 0 };
647 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
648
649 ASSERT_EQ(res, HCF_SUCCESS);
650
651 HcfObjDestroy(keyAgreement);
652
653 uint32_t mallocCount = GetMallocNum();
654
655 for (uint32_t i = 0; i < mallocCount; i++) {
656 ResetRecordMallocNum();
657 SetMockMallocIndex(i);
658 keyAgreement = nullptr;
659 res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
660
661 if (res != HCF_SUCCESS) {
662 continue;
663 }
664
665 out = {
666 .data = nullptr,
667 .len = 0
668 };
669 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
670
671 if (res != HCF_SUCCESS) {
672 HcfObjDestroy(keyAgreement);
673 continue;
674 }
675
676 HcfObjDestroy(keyAgreement);
677 HcfFree(out.data);
678 }
679 EndRecordMallocNum();
680 }
681
682 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest402, TestSize.Level0)
683 {
684 StartRecordOpensslCallNum();
685 HcfKeyAgreement *keyAgreement = nullptr;
686 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
687
688 ASSERT_EQ(res, HCF_SUCCESS);
689 ASSERT_NE(keyAgreement, nullptr);
690
691 HcfBlob out = { .data = nullptr, .len = 0 };
692 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
693
694 ASSERT_EQ(res, HCF_SUCCESS);
695
696 HcfObjDestroy(keyAgreement);
697
698 uint32_t mallocCount = GetOpensslCallNum();
699
700 for (uint32_t i = 0; i < mallocCount; i++) {
701 ResetOpensslCallNum();
702 SetOpensslCallMockIndex(i);
703 keyAgreement = nullptr;
704 res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
705
706 if (res != HCF_SUCCESS) {
707 continue;
708 }
709
710 out = {
711 .data = nullptr,
712 .len = 0
713 };
714 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
715
716 if (res != HCF_SUCCESS) {
717 HcfObjDestroy(keyAgreement);
718 continue;
719 }
720
721 HcfObjDestroy(keyAgreement);
722 HcfFree(out.data);
723 }
724 EndRecordOpensslCallNum();
725 }
726
727 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccCommonTest01, TestSize.Level0)
728 {
729 HcfResult ret = GenerateEcGroupWithParamsSpec(nullptr, nullptr);
730 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
731 }
732
733 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest404, TestSize.Level0)
734 {
735 HcfAsyKeyGenerator *generator = nullptr;
736 int32_t res = HcfAsyKeyGeneratorCreate("ECC_Secp256k1", &generator);
737
738 HcfKeyPair *keyPair1 = nullptr;
739 res = generator->generateKeyPair(generator, nullptr, &keyPair1);
740 ASSERT_EQ(res, HCF_SUCCESS);
741 ASSERT_NE(keyPair1, nullptr);
742
743 HcfKeyPair *keyPair2 = nullptr;
744 res = generator->generateKeyPair(generator, nullptr, &keyPair2);
745 ASSERT_EQ(res, HCF_SUCCESS);
746 ASSERT_NE(keyPair2, nullptr);
747
748 HcfKeyAgreement *keyAgreement = nullptr;
749 res = HcfKeyAgreementCreate("ECC_Secp256k1", &keyAgreement);
750 ASSERT_EQ(res, HCF_SUCCESS);
751 ASSERT_NE(keyAgreement, nullptr);
752
753 HcfBlob out1 = { .data = nullptr, .len = 0 };
754 HcfBlob out2 = { .data = nullptr, .len = 0 };
755 res = keyAgreement->generateSecret(keyAgreement, keyPair1->priKey, keyPair2->pubKey, &out1);
756 ASSERT_EQ(res, HCF_SUCCESS);
757 res = keyAgreement->generateSecret(keyAgreement, keyPair2->priKey, keyPair1->pubKey, &out2);
758 ASSERT_EQ(res, HCF_SUCCESS);
759 ASSERT_EQ(out1.len, out2.len);
760 for (int i = 0; i < out1.len; i++) {
761 ASSERT_EQ(out1.data[i], out2.data[i]);
762 }
763 HcfObjDestroy(keyAgreement);
764 HcfFree(out1.data);
765 HcfFree(out2.data);
766 HcfObjDestroy(keyPair1);
767 HcfObjDestroy(keyPair2);
768 HcfObjDestroy(generator);
769 }
770 }
771