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