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 <cstring>
18 
19 #include "asy_key_generator.h"
20 #include "blob.h"
21 #include "ecdsa_openssl.h"
22 #include "memory.h"
23 #include "securec.h"
24 #include "signature.h"
25 #include "memory_mock.h"
26 #include "openssl_adapter_mock.h"
27 
28 using namespace std;
29 using namespace testing::ext;
30 
31 namespace {
32 class CryptoEccSignTest : 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 *CryptoEccSignTest::ecc224KeyPair_ = nullptr;
46 HcfKeyPair *CryptoEccSignTest::ecc256KeyPair_ = nullptr;
47 HcfKeyPair *CryptoEccSignTest::ecc384KeyPair_ = nullptr;
48 HcfKeyPair *CryptoEccSignTest::ecc521KeyPair_ = nullptr;
49 
50 static const char *g_mockMessage = "hello world";
51 static HcfBlob g_mockInput = {
52     .data = (uint8_t *)g_mockMessage,
53     .len = 12
54 };
55 
SetUp()56 void CryptoEccSignTest::SetUp() {}
TearDown()57 void CryptoEccSignTest::TearDown() {}
58 
SetUpTestCase()59 void CryptoEccSignTest::SetUpTestCase()
60 {
61     HcfAsyKeyGenerator *generator = nullptr;
62     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
63     ASSERT_EQ(res, HCF_SUCCESS);
64     ASSERT_NE(generator, nullptr);
65 
66     HcfKeyPair *keyPair = nullptr;
67     res = generator->generateKeyPair(generator, nullptr, &keyPair);
68     ASSERT_EQ(res, HCF_SUCCESS);
69     ASSERT_NE(keyPair, nullptr);
70 
71     ecc224KeyPair_ = keyPair;
72 
73     HcfObjDestroy(generator);
74 
75     HcfAsyKeyGenerator *generator2 = nullptr;
76     res = HcfAsyKeyGeneratorCreate("ECC256", &generator2);
77     ASSERT_EQ(res, HCF_SUCCESS);
78     ASSERT_NE(generator2, nullptr);
79 
80     HcfKeyPair *keyPair2 = nullptr;
81     res = generator2->generateKeyPair(generator2, nullptr, &keyPair2);
82     ASSERT_EQ(res, HCF_SUCCESS);
83     ASSERT_NE(keyPair2, nullptr);
84 
85     ecc256KeyPair_ = keyPair2;
86 
87     HcfObjDestroy(generator2);
88 
89     HcfAsyKeyGenerator *generator3 = nullptr;
90     res = HcfAsyKeyGeneratorCreate("ECC384", &generator3);
91     ASSERT_EQ(res, HCF_SUCCESS);
92     ASSERT_NE(generator3, nullptr);
93 
94     HcfKeyPair *keyPair3 = nullptr;
95     res = generator3->generateKeyPair(generator3, nullptr, &keyPair3);
96     ASSERT_EQ(res, HCF_SUCCESS);
97     ASSERT_NE(keyPair3, nullptr);
98 
99     ecc384KeyPair_ = keyPair3;
100 
101     HcfObjDestroy(generator3);
102 
103     HcfAsyKeyGenerator *generator4 = nullptr;
104     res = HcfAsyKeyGeneratorCreate("ECC521", &generator4);
105     ASSERT_EQ(res, HCF_SUCCESS);
106     ASSERT_NE(generator4, nullptr);
107 
108     HcfKeyPair *keyPair4 = nullptr;
109     res = generator4->generateKeyPair(generator4, nullptr, &keyPair4);
110     ASSERT_EQ(res, HCF_SUCCESS);
111     ASSERT_NE(keyPair4, nullptr);
112 
113     ecc521KeyPair_ = keyPair4;
114 
115     HcfObjDestroy(generator4);
116 }
117 
TearDownTestCase()118 void CryptoEccSignTest::TearDownTestCase()
119 {
120     HcfObjDestroy(ecc224KeyPair_);
121     HcfObjDestroy(ecc256KeyPair_);
122     HcfObjDestroy(ecc384KeyPair_);
123     HcfObjDestroy(ecc521KeyPair_);
124 }
125 
GetMockClass(void)126 static const char *GetMockClass(void)
127 {
128     return "HcfMock";
129 }
130 
131 static HcfObjectBase obj = {
132     .getClass = GetMockClass,
133     .destroy = nullptr
134 };
135 
136 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest001, TestSize.Level0)
137 {
138     HcfSign *sign = nullptr;
139     int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
140 
141     ASSERT_EQ(res, HCF_SUCCESS);
142     ASSERT_NE(sign, nullptr);
143 
144     HcfObjDestroy(sign);
145 }
146 
147 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest002, TestSize.Level0)
148 {
149     HcfSign *sign = nullptr;
150     int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
151 
152     ASSERT_EQ(res, HCF_SUCCESS);
153     ASSERT_NE(sign, nullptr);
154 
155     HcfObjDestroy(sign);
156 }
157 
158 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest003, TestSize.Level0)
159 {
160     HcfSign *sign = nullptr;
161     int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
162 
163     ASSERT_EQ(res, HCF_SUCCESS);
164     ASSERT_NE(sign, nullptr);
165 
166     HcfObjDestroy(sign);
167 }
168 
169 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest004, TestSize.Level0)
170 {
171     HcfSign *sign = nullptr;
172     int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
173 
174     ASSERT_EQ(res, HCF_SUCCESS);
175     ASSERT_NE(sign, nullptr);
176 
177     HcfObjDestroy(sign);
178 }
179 
180 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest005, TestSize.Level0)
181 {
182     HcfSign *sign = nullptr;
183     int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
184 
185     ASSERT_EQ(res, HCF_SUCCESS);
186     ASSERT_NE(sign, nullptr);
187 
188     HcfObjDestroy(sign);
189 }
190 
191 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest006, TestSize.Level0)
192 {
193     HcfSign *sign = nullptr;
194     int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
195 
196     ASSERT_EQ(res, HCF_SUCCESS);
197     ASSERT_NE(sign, nullptr);
198 
199     HcfObjDestroy(sign);
200 }
201 
202 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest007, TestSize.Level0)
203 {
204     HcfSign *sign = nullptr;
205     int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
206 
207     ASSERT_EQ(res, HCF_SUCCESS);
208     ASSERT_NE(sign, nullptr);
209 
210     HcfObjDestroy(sign);
211 }
212 
213 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest008, TestSize.Level0)
214 {
215     HcfSign *sign = nullptr;
216     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
217 
218     ASSERT_EQ(res, HCF_SUCCESS);
219     ASSERT_NE(sign, nullptr);
220 
221     HcfObjDestroy(sign);
222 }
223 
224 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest009, TestSize.Level0)
225 {
226     HcfSign *sign = nullptr;
227     int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
228 
229     ASSERT_EQ(res, HCF_SUCCESS);
230     ASSERT_NE(sign, nullptr);
231 
232     HcfObjDestroy(sign);
233 }
234 
235 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest010, TestSize.Level0)
236 {
237     HcfSign *sign = nullptr;
238     int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
239 
240     ASSERT_EQ(res, HCF_SUCCESS);
241     ASSERT_NE(sign, nullptr);
242 
243     HcfObjDestroy(sign);
244 }
245 
246 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest011, TestSize.Level0)
247 {
248     HcfSign *sign = nullptr;
249     int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
250 
251     ASSERT_EQ(res, HCF_SUCCESS);
252     ASSERT_NE(sign, nullptr);
253 
254     HcfObjDestroy(sign);
255 }
256 
257 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest012, TestSize.Level0)
258 {
259     HcfSign *sign = nullptr;
260     int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
261 
262     ASSERT_EQ(res, HCF_SUCCESS);
263     ASSERT_NE(sign, nullptr);
264 
265     HcfObjDestroy(sign);
266 }
267 
268 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest013, TestSize.Level0)
269 {
270     HcfSign *sign = nullptr;
271     int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
272 
273     ASSERT_EQ(res, HCF_SUCCESS);
274     ASSERT_NE(sign, nullptr);
275 
276     HcfObjDestroy(sign);
277 }
278 
279 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest014, TestSize.Level0)
280 {
281     HcfSign *sign = nullptr;
282     int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
283 
284     ASSERT_EQ(res, HCF_SUCCESS);
285     ASSERT_NE(sign, nullptr);
286 
287     HcfObjDestroy(sign);
288 }
289 
290 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest015, TestSize.Level0)
291 {
292     HcfSign *sign = nullptr;
293     int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
294 
295     ASSERT_EQ(res, HCF_SUCCESS);
296     ASSERT_NE(sign, nullptr);
297 
298     HcfObjDestroy(sign);
299 }
300 
301 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest016, TestSize.Level0)
302 {
303     HcfSign *sign = nullptr;
304     int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
305 
306     ASSERT_EQ(res, HCF_SUCCESS);
307     ASSERT_NE(sign, nullptr);
308 
309     HcfObjDestroy(sign);
310 }
311 
312 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest017, TestSize.Level0)
313 {
314     HcfSign *sign = nullptr;
315     int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
316 
317     ASSERT_EQ(res, HCF_SUCCESS);
318     ASSERT_NE(sign, nullptr);
319 
320     HcfObjDestroy(sign);
321 }
322 
323 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest018, TestSize.Level0)
324 {
325     HcfSign *sign = nullptr;
326     int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
327 
328     ASSERT_EQ(res, HCF_SUCCESS);
329     ASSERT_NE(sign, nullptr);
330 
331     HcfObjDestroy(sign);
332 }
333 
334 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest019, TestSize.Level0)
335 {
336     HcfSign *sign = nullptr;
337     int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
338 
339     ASSERT_EQ(res, HCF_SUCCESS);
340     ASSERT_NE(sign, nullptr);
341 
342     HcfObjDestroy(sign);
343 }
344 
345 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest020, TestSize.Level0)
346 {
347     HcfSign *sign = nullptr;
348     int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
349 
350     ASSERT_EQ(res, HCF_SUCCESS);
351     ASSERT_NE(sign, nullptr);
352 
353     HcfObjDestroy(sign);
354 }
355 
356 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest021, TestSize.Level0)
357 {
358     HcfSign *sign = nullptr;
359     int32_t res = HcfSignCreate(nullptr, &sign);
360 
361     ASSERT_EQ(res, HCF_INVALID_PARAMS);
362     ASSERT_EQ(sign, nullptr);
363 }
364 
365 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest022, TestSize.Level0)
366 {
367     HcfSign *sign = nullptr;
368     int32_t res = HcfSignCreate("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD"
369         "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", &sign);
370 
371     ASSERT_EQ(res, HCF_INVALID_PARAMS);
372     ASSERT_EQ(sign, nullptr);
373 }
374 
375 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest023, TestSize.Level0)
376 {
377     HcfSign *sign = nullptr;
378     int32_t res = HcfSignCreate("ECC257|SHA256", &sign);
379 
380     ASSERT_NE(res, HCF_SUCCESS);
381     ASSERT_EQ(sign, nullptr);
382 }
383 
384 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest024, TestSize.Level0)
385 {
386     HcfSign *sign = nullptr;
387     int32_t res = HcfSignCreate("ECC256|SHA257", &sign);
388 
389     ASSERT_NE(res, HCF_SUCCESS);
390     ASSERT_EQ(sign, nullptr);
391 }
392 
393 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest025, TestSize.Level0)
394 {
395     HcfSign *sign = nullptr;
396     int32_t res = HcfSignCreate("ECC256|MD5", &sign);
397 
398     ASSERT_NE(res, HCF_SUCCESS);
399     ASSERT_EQ(sign, nullptr);
400 }
401 
402 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest026, TestSize.Level0)
403 {
404     HcfSign *sign = nullptr;
405     int32_t res = HcfSignCreate("ECC256SHA256", &sign);
406 
407     ASSERT_NE(res, HCF_SUCCESS);
408     ASSERT_EQ(sign, nullptr);
409 }
410 
411 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest027, TestSize.Level0)
412 {
413     int32_t res = HcfSignCreate("ECC256|SHA256", nullptr);
414 
415     ASSERT_EQ(res, HCF_INVALID_PARAMS);
416 }
417 
418 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest101, TestSize.Level0)
419 {
420     HcfSign *sign = nullptr;
421     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
422 
423     ASSERT_EQ(res, HCF_SUCCESS);
424     ASSERT_NE(sign, nullptr);
425 
426     const char *className = sign->base.getClass();
427 
428     ASSERT_NE(className, nullptr);
429 
430     HcfObjDestroy(sign);
431 }
432 
433 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest102, TestSize.Level0)
434 {
435     HcfSign *sign = nullptr;
436     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
437 
438     ASSERT_EQ(res, HCF_SUCCESS);
439     ASSERT_NE(sign, nullptr);
440 
441     sign->base.destroy((HcfObjectBase *)sign);
442 }
443 
444 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest103, TestSize.Level0)
445 {
446     HcfSign *sign = nullptr;
447     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
448 
449     ASSERT_EQ(res, HCF_SUCCESS);
450     ASSERT_NE(sign, nullptr);
451 
452     sign->base.destroy(nullptr);
453 
454     HcfObjDestroy(sign);
455 }
456 
457 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest104, TestSize.Level0)
458 {
459     HcfSign *sign = nullptr;
460     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
461 
462     ASSERT_EQ(res, HCF_SUCCESS);
463     ASSERT_NE(sign, nullptr);
464 
465     sign->base.destroy(&obj);
466 
467     HcfObjDestroy(sign);
468 }
469 
470 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest105, TestSize.Level0)
471 {
472     HcfSign *sign = nullptr;
473     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
474 
475     ASSERT_EQ(res, HCF_SUCCESS);
476     ASSERT_NE(sign, nullptr);
477 
478     const char *algName = sign->getAlgoName(sign);
479 
480     ASSERT_NE(algName, nullptr);
481 
482     HcfObjDestroy(sign);
483 }
484 
485 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest106, TestSize.Level0)
486 {
487     HcfSign *sign = nullptr;
488     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
489 
490     ASSERT_EQ(res, HCF_SUCCESS);
491     ASSERT_NE(sign, nullptr);
492 
493     const char *algName = sign->getAlgoName(nullptr);
494 
495     ASSERT_EQ(algName, nullptr);
496 
497     HcfObjDestroy(sign);
498 }
499 
500 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest107, TestSize.Level0)
501 {
502     HcfSign *sign = nullptr;
503     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
504 
505     ASSERT_EQ(res, HCF_SUCCESS);
506     ASSERT_NE(sign, nullptr);
507 
508     const char *algName = sign->getAlgoName((HcfSign *)(&obj));
509 
510     ASSERT_EQ(algName, nullptr);
511 
512     HcfObjDestroy(sign);
513 }
514 
515 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest201, TestSize.Level0)
516 {
517     HcfSign *sign = nullptr;
518     int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
519 
520     ASSERT_EQ(res, HCF_SUCCESS);
521     ASSERT_NE(sign, nullptr);
522 
523     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
524 
525     ASSERT_EQ(res, HCF_SUCCESS);
526 
527     HcfObjDestroy(sign);
528 }
529 
530 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest202, TestSize.Level0)
531 {
532     HcfSign *sign = nullptr;
533     int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
534 
535     ASSERT_EQ(res, HCF_SUCCESS);
536     ASSERT_NE(sign, nullptr);
537 
538     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
539 
540     ASSERT_EQ(res, HCF_SUCCESS);
541 
542     HcfObjDestroy(sign);
543 }
544 
545 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest203, TestSize.Level0)
546 {
547     HcfSign *sign = nullptr;
548     int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
549 
550     ASSERT_EQ(res, HCF_SUCCESS);
551     ASSERT_NE(sign, nullptr);
552 
553     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
554 
555     ASSERT_EQ(res, HCF_SUCCESS);
556 
557     HcfObjDestroy(sign);
558 }
559 
560 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest204, TestSize.Level0)
561 {
562     HcfSign *sign = nullptr;
563     int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
564 
565     ASSERT_EQ(res, HCF_SUCCESS);
566     ASSERT_NE(sign, nullptr);
567 
568     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
569 
570     ASSERT_EQ(res, HCF_SUCCESS);
571 
572     HcfObjDestroy(sign);
573 }
574 
575 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest205, TestSize.Level0)
576 {
577     HcfSign *sign = nullptr;
578     int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
579 
580     ASSERT_EQ(res, HCF_SUCCESS);
581     ASSERT_NE(sign, nullptr);
582 
583     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
584 
585     ASSERT_EQ(res, HCF_SUCCESS);
586 
587     HcfObjDestroy(sign);
588 }
589 
590 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest206, TestSize.Level0)
591 {
592     HcfSign *sign = nullptr;
593     int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
594 
595     ASSERT_EQ(res, HCF_SUCCESS);
596     ASSERT_NE(sign, nullptr);
597 
598     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
599 
600     ASSERT_EQ(res, HCF_SUCCESS);
601 
602     HcfObjDestroy(sign);
603 }
604 
605 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest207, TestSize.Level0)
606 {
607     HcfSign *sign = nullptr;
608     int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
609 
610     ASSERT_EQ(res, HCF_SUCCESS);
611     ASSERT_NE(sign, nullptr);
612 
613     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
614 
615     ASSERT_EQ(res, HCF_SUCCESS);
616 
617     HcfObjDestroy(sign);
618 }
619 
620 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest208, TestSize.Level0)
621 {
622     HcfSign *sign = nullptr;
623     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
624 
625     ASSERT_EQ(res, HCF_SUCCESS);
626     ASSERT_NE(sign, nullptr);
627 
628     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
629 
630     ASSERT_EQ(res, HCF_SUCCESS);
631 
632     HcfObjDestroy(sign);
633 }
634 
635 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest209, TestSize.Level0)
636 {
637     HcfSign *sign = nullptr;
638     int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
639 
640     ASSERT_EQ(res, HCF_SUCCESS);
641     ASSERT_NE(sign, nullptr);
642 
643     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
644 
645     ASSERT_EQ(res, HCF_SUCCESS);
646 
647     HcfObjDestroy(sign);
648 }
649 
650 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest210, TestSize.Level0)
651 {
652     HcfSign *sign = nullptr;
653     int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
654 
655     ASSERT_EQ(res, HCF_SUCCESS);
656     ASSERT_NE(sign, nullptr);
657 
658     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
659 
660     ASSERT_EQ(res, HCF_SUCCESS);
661 
662     HcfObjDestroy(sign);
663 }
664 
665 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest211, TestSize.Level0)
666 {
667     HcfSign *sign = nullptr;
668     int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
669 
670     ASSERT_EQ(res, HCF_SUCCESS);
671     ASSERT_NE(sign, nullptr);
672 
673     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
674 
675     ASSERT_EQ(res, HCF_SUCCESS);
676 
677     HcfObjDestroy(sign);
678 }
679 
680 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest212, TestSize.Level0)
681 {
682     HcfSign *sign = nullptr;
683     int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
684 
685     ASSERT_EQ(res, HCF_SUCCESS);
686     ASSERT_NE(sign, nullptr);
687 
688     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
689 
690     ASSERT_EQ(res, HCF_SUCCESS);
691 
692     HcfObjDestroy(sign);
693 }
694 
695 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest213, TestSize.Level0)
696 {
697     HcfSign *sign = nullptr;
698     int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
699 
700     ASSERT_EQ(res, HCF_SUCCESS);
701     ASSERT_NE(sign, nullptr);
702 
703     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
704 
705     ASSERT_EQ(res, HCF_SUCCESS);
706 
707     HcfObjDestroy(sign);
708 }
709 
710 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest214, TestSize.Level0)
711 {
712     HcfSign *sign = nullptr;
713     int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
714 
715     ASSERT_EQ(res, HCF_SUCCESS);
716     ASSERT_NE(sign, nullptr);
717 
718     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
719 
720     ASSERT_EQ(res, HCF_SUCCESS);
721 
722     HcfObjDestroy(sign);
723 }
724 
725 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest215, TestSize.Level0)
726 {
727     HcfSign *sign = nullptr;
728     int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
729 
730     ASSERT_EQ(res, HCF_SUCCESS);
731     ASSERT_NE(sign, nullptr);
732 
733     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
734 
735     ASSERT_EQ(res, HCF_SUCCESS);
736 
737     HcfObjDestroy(sign);
738 }
739 
740 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest216, TestSize.Level0)
741 {
742     HcfSign *sign = nullptr;
743     int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
744 
745     ASSERT_EQ(res, HCF_SUCCESS);
746     ASSERT_NE(sign, nullptr);
747 
748     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
749 
750     ASSERT_EQ(res, HCF_SUCCESS);
751 
752     HcfObjDestroy(sign);
753 }
754 
755 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest217, TestSize.Level0)
756 {
757     HcfSign *sign = nullptr;
758     int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
759 
760     ASSERT_EQ(res, HCF_SUCCESS);
761     ASSERT_NE(sign, nullptr);
762 
763     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
764 
765     ASSERT_EQ(res, HCF_SUCCESS);
766 
767     HcfObjDestroy(sign);
768 }
769 
770 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest218, TestSize.Level0)
771 {
772     HcfSign *sign = nullptr;
773     int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
774 
775     ASSERT_EQ(res, HCF_SUCCESS);
776     ASSERT_NE(sign, nullptr);
777 
778     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
779 
780     ASSERT_EQ(res, HCF_SUCCESS);
781 
782     HcfObjDestroy(sign);
783 }
784 
785 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest219, TestSize.Level0)
786 {
787     HcfSign *sign = nullptr;
788     int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
789 
790     ASSERT_EQ(res, HCF_SUCCESS);
791     ASSERT_NE(sign, nullptr);
792 
793     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
794 
795     ASSERT_EQ(res, HCF_SUCCESS);
796 
797     HcfObjDestroy(sign);
798 }
799 
800 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest220, TestSize.Level0)
801 {
802     HcfSign *sign = nullptr;
803     int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
804 
805     ASSERT_EQ(res, HCF_SUCCESS);
806     ASSERT_NE(sign, nullptr);
807 
808     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
809 
810     ASSERT_EQ(res, HCF_SUCCESS);
811 
812     HcfObjDestroy(sign);
813 }
814 
815 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest221, TestSize.Level0)
816 {
817     HcfSign *sign = nullptr;
818     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
819 
820     ASSERT_EQ(res, HCF_SUCCESS);
821     ASSERT_NE(sign, nullptr);
822 
823     res = sign->init(nullptr, nullptr, ecc256KeyPair_->priKey);
824 
825     ASSERT_EQ(res, HCF_INVALID_PARAMS);
826 
827     HcfObjDestroy(sign);
828 }
829 
830 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest222, TestSize.Level0)
831 {
832     HcfSign *sign = nullptr;
833     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
834 
835     ASSERT_EQ(res, HCF_SUCCESS);
836     ASSERT_NE(sign, nullptr);
837 
838     res = sign->init((HcfSign *)(&obj), nullptr, ecc256KeyPair_->priKey);
839 
840     ASSERT_EQ(res, HCF_INVALID_PARAMS);
841 
842     HcfObjDestroy(sign);
843 }
844 
845 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest223, TestSize.Level0)
846 {
847     HcfSign *sign = nullptr;
848     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
849 
850     ASSERT_EQ(res, HCF_SUCCESS);
851     ASSERT_NE(sign, nullptr);
852 
853     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
854 
855     ASSERT_EQ(res, HCF_SUCCESS);
856 
857     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
858 
859     ASSERT_EQ(res, HCF_INVALID_PARAMS);
860 
861     HcfObjDestroy(sign);
862 }
863 
864 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest224, TestSize.Level0)
865 {
866     HcfSign *sign = nullptr;
867     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
868 
869     ASSERT_EQ(res, HCF_SUCCESS);
870     ASSERT_NE(sign, nullptr);
871 
872     res = sign->init(sign, nullptr, nullptr);
873 
874     ASSERT_EQ(res, HCF_INVALID_PARAMS);
875 
876     HcfObjDestroy(sign);
877 }
878 
879 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest225, TestSize.Level0)
880 {
881     HcfSign *sign = nullptr;
882     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
883 
884     ASSERT_EQ(res, HCF_SUCCESS);
885     ASSERT_NE(sign, nullptr);
886 
887     res = sign->init(sign, nullptr, (HcfPriKey *)(&obj));
888 
889     ASSERT_EQ(res, HCF_INVALID_PARAMS);
890 
891     HcfObjDestroy(sign);
892 }
893 
894 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest301, TestSize.Level0)
895 {
896     HcfSign *sign = nullptr;
897     int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
898 
899     ASSERT_EQ(res, HCF_SUCCESS);
900     ASSERT_NE(sign, nullptr);
901 
902     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
903 
904     ASSERT_EQ(res, HCF_SUCCESS);
905 
906     res = sign->update(sign, &g_mockInput);
907 
908     ASSERT_EQ(res, HCF_SUCCESS);
909 
910     HcfObjDestroy(sign);
911 }
912 
913 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest302, TestSize.Level0)
914 {
915     HcfSign *sign = nullptr;
916     int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
917 
918     ASSERT_EQ(res, HCF_SUCCESS);
919     ASSERT_NE(sign, nullptr);
920 
921     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
922 
923     ASSERT_EQ(res, HCF_SUCCESS);
924 
925     res = sign->update(sign, &g_mockInput);
926 
927     ASSERT_EQ(res, HCF_SUCCESS);
928 
929     HcfObjDestroy(sign);
930 }
931 
932 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest303, TestSize.Level0)
933 {
934     HcfSign *sign = nullptr;
935     int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
936 
937     ASSERT_EQ(res, HCF_SUCCESS);
938     ASSERT_NE(sign, nullptr);
939 
940     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
941 
942     ASSERT_EQ(res, HCF_SUCCESS);
943 
944     res = sign->update(sign, &g_mockInput);
945 
946     ASSERT_EQ(res, HCF_SUCCESS);
947 
948     HcfObjDestroy(sign);
949 }
950 
951 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest304, TestSize.Level0)
952 {
953     HcfSign *sign = nullptr;
954     int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
955 
956     ASSERT_EQ(res, HCF_SUCCESS);
957     ASSERT_NE(sign, nullptr);
958 
959     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
960 
961     ASSERT_EQ(res, HCF_SUCCESS);
962 
963     res = sign->update(sign, &g_mockInput);
964 
965     ASSERT_EQ(res, HCF_SUCCESS);
966 
967     HcfObjDestroy(sign);
968 }
969 
970 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest305, TestSize.Level0)
971 {
972     HcfSign *sign = nullptr;
973     int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
974 
975     ASSERT_EQ(res, HCF_SUCCESS);
976     ASSERT_NE(sign, nullptr);
977 
978     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
979 
980     ASSERT_EQ(res, HCF_SUCCESS);
981 
982     res = sign->update(sign, &g_mockInput);
983 
984     ASSERT_EQ(res, HCF_SUCCESS);
985 
986     HcfObjDestroy(sign);
987 }
988 
989 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest306, TestSize.Level0)
990 {
991     HcfSign *sign = nullptr;
992     int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
993 
994     ASSERT_EQ(res, HCF_SUCCESS);
995     ASSERT_NE(sign, nullptr);
996 
997     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
998 
999     ASSERT_EQ(res, HCF_SUCCESS);
1000 
1001     res = sign->update(sign, &g_mockInput);
1002 
1003     ASSERT_EQ(res, HCF_SUCCESS);
1004 
1005     HcfObjDestroy(sign);
1006 }
1007 
1008 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest307, TestSize.Level0)
1009 {
1010     HcfSign *sign = nullptr;
1011     int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
1012 
1013     ASSERT_EQ(res, HCF_SUCCESS);
1014     ASSERT_NE(sign, nullptr);
1015 
1016     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1017 
1018     ASSERT_EQ(res, HCF_SUCCESS);
1019 
1020     res = sign->update(sign, &g_mockInput);
1021 
1022     ASSERT_EQ(res, HCF_SUCCESS);
1023 
1024     HcfObjDestroy(sign);
1025 }
1026 
1027 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest308, TestSize.Level0)
1028 {
1029     HcfSign *sign = nullptr;
1030     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1031 
1032     ASSERT_EQ(res, HCF_SUCCESS);
1033     ASSERT_NE(sign, nullptr);
1034 
1035     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1036 
1037     ASSERT_EQ(res, HCF_SUCCESS);
1038 
1039     res = sign->update(sign, &g_mockInput);
1040 
1041     ASSERT_EQ(res, HCF_SUCCESS);
1042 
1043     HcfObjDestroy(sign);
1044 }
1045 
1046 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest309, TestSize.Level0)
1047 {
1048     HcfSign *sign = nullptr;
1049     int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
1050 
1051     ASSERT_EQ(res, HCF_SUCCESS);
1052     ASSERT_NE(sign, nullptr);
1053 
1054     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1055 
1056     ASSERT_EQ(res, HCF_SUCCESS);
1057 
1058     res = sign->update(sign, &g_mockInput);
1059 
1060     ASSERT_EQ(res, HCF_SUCCESS);
1061 
1062     HcfObjDestroy(sign);
1063 }
1064 
1065 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest310, TestSize.Level0)
1066 {
1067     HcfSign *sign = nullptr;
1068     int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
1069 
1070     ASSERT_EQ(res, HCF_SUCCESS);
1071     ASSERT_NE(sign, nullptr);
1072 
1073     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1074 
1075     ASSERT_EQ(res, HCF_SUCCESS);
1076 
1077     res = sign->update(sign, &g_mockInput);
1078 
1079     ASSERT_EQ(res, HCF_SUCCESS);
1080 
1081     HcfObjDestroy(sign);
1082 }
1083 
1084 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest311, TestSize.Level0)
1085 {
1086     HcfSign *sign = nullptr;
1087     int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
1088 
1089     ASSERT_EQ(res, HCF_SUCCESS);
1090     ASSERT_NE(sign, nullptr);
1091 
1092     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1093 
1094     ASSERT_EQ(res, HCF_SUCCESS);
1095 
1096     res = sign->update(sign, &g_mockInput);
1097 
1098     ASSERT_EQ(res, HCF_SUCCESS);
1099 
1100     HcfObjDestroy(sign);
1101 }
1102 
1103 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest312, TestSize.Level0)
1104 {
1105     HcfSign *sign = nullptr;
1106     int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
1107 
1108     ASSERT_EQ(res, HCF_SUCCESS);
1109     ASSERT_NE(sign, nullptr);
1110 
1111     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1112 
1113     ASSERT_EQ(res, HCF_SUCCESS);
1114 
1115     res = sign->update(sign, &g_mockInput);
1116 
1117     ASSERT_EQ(res, HCF_SUCCESS);
1118 
1119     HcfObjDestroy(sign);
1120 }
1121 
1122 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest313, TestSize.Level0)
1123 {
1124     HcfSign *sign = nullptr;
1125     int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
1126 
1127     ASSERT_EQ(res, HCF_SUCCESS);
1128     ASSERT_NE(sign, nullptr);
1129 
1130     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1131 
1132     ASSERT_EQ(res, HCF_SUCCESS);
1133 
1134     res = sign->update(sign, &g_mockInput);
1135 
1136     ASSERT_EQ(res, HCF_SUCCESS);
1137 
1138     HcfObjDestroy(sign);
1139 }
1140 
1141 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest314, TestSize.Level0)
1142 {
1143     HcfSign *sign = nullptr;
1144     int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
1145 
1146     ASSERT_EQ(res, HCF_SUCCESS);
1147     ASSERT_NE(sign, nullptr);
1148 
1149     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1150 
1151     ASSERT_EQ(res, HCF_SUCCESS);
1152 
1153     res = sign->update(sign, &g_mockInput);
1154 
1155     ASSERT_EQ(res, HCF_SUCCESS);
1156 
1157     HcfObjDestroy(sign);
1158 }
1159 
1160 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest315, TestSize.Level0)
1161 {
1162     HcfSign *sign = nullptr;
1163     int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
1164 
1165     ASSERT_EQ(res, HCF_SUCCESS);
1166     ASSERT_NE(sign, nullptr);
1167 
1168     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1169 
1170     ASSERT_EQ(res, HCF_SUCCESS);
1171 
1172     res = sign->update(sign, &g_mockInput);
1173 
1174     ASSERT_EQ(res, HCF_SUCCESS);
1175 
1176     HcfObjDestroy(sign);
1177 }
1178 
1179 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest316, TestSize.Level0)
1180 {
1181     HcfSign *sign = nullptr;
1182     int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
1183 
1184     ASSERT_EQ(res, HCF_SUCCESS);
1185     ASSERT_NE(sign, nullptr);
1186 
1187     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1188 
1189     ASSERT_EQ(res, HCF_SUCCESS);
1190 
1191     res = sign->update(sign, &g_mockInput);
1192 
1193     ASSERT_EQ(res, HCF_SUCCESS);
1194 
1195     HcfObjDestroy(sign);
1196 }
1197 
1198 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest317, TestSize.Level0)
1199 {
1200     HcfSign *sign = nullptr;
1201     int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
1202 
1203     ASSERT_EQ(res, HCF_SUCCESS);
1204     ASSERT_NE(sign, nullptr);
1205 
1206     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1207 
1208     ASSERT_EQ(res, HCF_SUCCESS);
1209 
1210     res = sign->update(sign, &g_mockInput);
1211 
1212     ASSERT_EQ(res, HCF_SUCCESS);
1213 
1214     HcfObjDestroy(sign);
1215 }
1216 
1217 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest318, TestSize.Level0)
1218 {
1219     HcfSign *sign = nullptr;
1220     int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
1221 
1222     ASSERT_EQ(res, HCF_SUCCESS);
1223     ASSERT_NE(sign, nullptr);
1224 
1225     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1226 
1227     ASSERT_EQ(res, HCF_SUCCESS);
1228 
1229     res = sign->update(sign, &g_mockInput);
1230 
1231     ASSERT_EQ(res, HCF_SUCCESS);
1232 
1233     HcfObjDestroy(sign);
1234 }
1235 
1236 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest319, TestSize.Level0)
1237 {
1238     HcfSign *sign = nullptr;
1239     int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
1240 
1241     ASSERT_EQ(res, HCF_SUCCESS);
1242     ASSERT_NE(sign, nullptr);
1243 
1244     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1245 
1246     ASSERT_EQ(res, HCF_SUCCESS);
1247 
1248     res = sign->update(sign, &g_mockInput);
1249 
1250     ASSERT_EQ(res, HCF_SUCCESS);
1251 
1252     HcfObjDestroy(sign);
1253 }
1254 
1255 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest320, TestSize.Level0)
1256 {
1257     HcfSign *sign = nullptr;
1258     int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
1259 
1260     ASSERT_EQ(res, HCF_SUCCESS);
1261     ASSERT_NE(sign, nullptr);
1262 
1263     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1264 
1265     ASSERT_EQ(res, HCF_SUCCESS);
1266 
1267     res = sign->update(sign, &g_mockInput);
1268 
1269     ASSERT_EQ(res, HCF_SUCCESS);
1270 
1271     HcfObjDestroy(sign);
1272 }
1273 
1274 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest321, TestSize.Level0)
1275 {
1276     HcfSign *sign = nullptr;
1277     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1278 
1279     ASSERT_EQ(res, HCF_SUCCESS);
1280     ASSERT_NE(sign, nullptr);
1281 
1282     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1283 
1284     ASSERT_EQ(res, HCF_SUCCESS);
1285 
1286     res = sign->update(nullptr, &g_mockInput);
1287 
1288     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1289 
1290     HcfObjDestroy(sign);
1291 }
1292 
1293 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest322, TestSize.Level0)
1294 {
1295     HcfSign *sign = nullptr;
1296     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1297 
1298     ASSERT_EQ(res, HCF_SUCCESS);
1299     ASSERT_NE(sign, nullptr);
1300 
1301     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1302 
1303     ASSERT_EQ(res, HCF_SUCCESS);
1304 
1305     res = sign->update((HcfSign *)(&obj), &g_mockInput);
1306 
1307     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1308 
1309     HcfObjDestroy(sign);
1310 }
1311 
1312 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest323, TestSize.Level0)
1313 {
1314     HcfSign *sign = nullptr;
1315     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1316 
1317     ASSERT_EQ(res, HCF_SUCCESS);
1318     ASSERT_NE(sign, nullptr);
1319 
1320     res = sign->update(sign, &g_mockInput);
1321 
1322     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1323 
1324     HcfObjDestroy(sign);
1325 }
1326 
1327 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest324, TestSize.Level0)
1328 {
1329     HcfSign *sign = nullptr;
1330     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1331 
1332     ASSERT_EQ(res, HCF_SUCCESS);
1333     ASSERT_NE(sign, nullptr);
1334 
1335     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1336 
1337     ASSERT_EQ(res, HCF_SUCCESS);
1338 
1339     res = sign->update(sign, nullptr);
1340 
1341     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1342 
1343     HcfObjDestroy(sign);
1344 }
1345 
1346 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest325, TestSize.Level0)
1347 {
1348     HcfSign *sign = nullptr;
1349     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1350 
1351     ASSERT_EQ(res, HCF_SUCCESS);
1352     ASSERT_NE(sign, nullptr);
1353 
1354     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1355 
1356     ASSERT_EQ(res, HCF_SUCCESS);
1357 
1358     HcfBlob input = {
1359         .data = nullptr,
1360         .len = 1
1361     };
1362     res = sign->update(sign, &input);
1363 
1364     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1365 
1366     HcfObjDestroy(sign);
1367 }
1368 
1369 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest326, TestSize.Level0)
1370 {
1371     HcfSign *sign = nullptr;
1372     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1373 
1374     ASSERT_EQ(res, HCF_SUCCESS);
1375     ASSERT_NE(sign, nullptr);
1376 
1377     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1378 
1379     ASSERT_EQ(res, HCF_SUCCESS);
1380 
1381     HcfBlob input = {
1382         .data = (uint8_t *)g_mockMessage,
1383         .len = 0
1384     };
1385     res = sign->update(sign, &input);
1386 
1387     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1388 
1389     HcfObjDestroy(sign);
1390 }
1391 
1392 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest401, TestSize.Level0)
1393 {
1394     HcfSign *sign = nullptr;
1395     int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
1396 
1397     ASSERT_EQ(res, HCF_SUCCESS);
1398     ASSERT_NE(sign, nullptr);
1399 
1400     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1401 
1402     ASSERT_EQ(res, HCF_SUCCESS);
1403 
1404     res = sign->update(sign, &g_mockInput);
1405 
1406     ASSERT_EQ(res, HCF_SUCCESS);
1407 
1408     HcfBlob out = { .data = nullptr, .len = 0 };
1409     res = sign->sign(sign, nullptr, &out);
1410 
1411     ASSERT_EQ(res, HCF_SUCCESS);
1412     ASSERT_NE(out.data, nullptr);
1413     ASSERT_NE(out.len, (const unsigned int)0);
1414 
1415     HcfFree(out.data);
1416     HcfObjDestroy(sign);
1417 }
1418 
1419 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest402, TestSize.Level0)
1420 {
1421     HcfSign *sign = nullptr;
1422     int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
1423 
1424     ASSERT_EQ(res, HCF_SUCCESS);
1425     ASSERT_NE(sign, nullptr);
1426 
1427     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1428 
1429     ASSERT_EQ(res, HCF_SUCCESS);
1430 
1431     res = sign->update(sign, &g_mockInput);
1432 
1433     ASSERT_EQ(res, HCF_SUCCESS);
1434 
1435     HcfBlob out = { .data = nullptr, .len = 0 };
1436     res = sign->sign(sign, nullptr, &out);
1437 
1438     ASSERT_EQ(res, HCF_SUCCESS);
1439     ASSERT_NE(out.data, nullptr);
1440     ASSERT_NE(out.len, (const unsigned int)0);
1441 
1442     HcfFree(out.data);
1443     HcfObjDestroy(sign);
1444 }
1445 
1446 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest403, TestSize.Level0)
1447 {
1448     HcfSign *sign = nullptr;
1449     int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
1450 
1451     ASSERT_EQ(res, HCF_SUCCESS);
1452     ASSERT_NE(sign, nullptr);
1453 
1454     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1455 
1456     ASSERT_EQ(res, HCF_SUCCESS);
1457 
1458     res = sign->update(sign, &g_mockInput);
1459 
1460     ASSERT_EQ(res, HCF_SUCCESS);
1461 
1462     HcfBlob out = { .data = nullptr, .len = 0 };
1463     res = sign->sign(sign, nullptr, &out);
1464 
1465     ASSERT_EQ(res, HCF_SUCCESS);
1466     ASSERT_NE(out.data, nullptr);
1467     ASSERT_NE(out.len, (const unsigned int)0);
1468 
1469     HcfFree(out.data);
1470     HcfObjDestroy(sign);
1471 }
1472 
1473 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest404, TestSize.Level0)
1474 {
1475     HcfSign *sign = nullptr;
1476     int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
1477 
1478     ASSERT_EQ(res, HCF_SUCCESS);
1479     ASSERT_NE(sign, nullptr);
1480 
1481     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1482 
1483     ASSERT_EQ(res, HCF_SUCCESS);
1484 
1485     res = sign->update(sign, &g_mockInput);
1486 
1487     ASSERT_EQ(res, HCF_SUCCESS);
1488 
1489     HcfBlob out = { .data = nullptr, .len = 0 };
1490     res = sign->sign(sign, nullptr, &out);
1491 
1492     ASSERT_EQ(res, HCF_SUCCESS);
1493     ASSERT_NE(out.data, nullptr);
1494     ASSERT_NE(out.len, (const unsigned int)0);
1495 
1496     HcfFree(out.data);
1497     HcfObjDestroy(sign);
1498 }
1499 
1500 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest405, TestSize.Level0)
1501 {
1502     HcfSign *sign = nullptr;
1503     int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
1504 
1505     ASSERT_EQ(res, HCF_SUCCESS);
1506     ASSERT_NE(sign, nullptr);
1507 
1508     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1509 
1510     ASSERT_EQ(res, HCF_SUCCESS);
1511 
1512     res = sign->update(sign, &g_mockInput);
1513 
1514     ASSERT_EQ(res, HCF_SUCCESS);
1515 
1516     HcfBlob out = { .data = nullptr, .len = 0 };
1517     res = sign->sign(sign, nullptr, &out);
1518 
1519     ASSERT_EQ(res, HCF_SUCCESS);
1520     ASSERT_NE(out.data, nullptr);
1521     ASSERT_NE(out.len, (const unsigned int)0);
1522 
1523     HcfFree(out.data);
1524     HcfObjDestroy(sign);
1525 }
1526 
1527 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest406, TestSize.Level0)
1528 {
1529     HcfSign *sign = nullptr;
1530     int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
1531 
1532     ASSERT_EQ(res, HCF_SUCCESS);
1533     ASSERT_NE(sign, nullptr);
1534 
1535     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1536 
1537     ASSERT_EQ(res, HCF_SUCCESS);
1538 
1539     res = sign->update(sign, &g_mockInput);
1540 
1541     ASSERT_EQ(res, HCF_SUCCESS);
1542 
1543     HcfBlob out = { .data = nullptr, .len = 0 };
1544     res = sign->sign(sign, nullptr, &out);
1545 
1546     ASSERT_EQ(res, HCF_SUCCESS);
1547     ASSERT_NE(out.data, nullptr);
1548     ASSERT_NE(out.len, (const unsigned int)0);
1549 
1550     HcfFree(out.data);
1551     HcfObjDestroy(sign);
1552 }
1553 
1554 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest407, TestSize.Level0)
1555 {
1556     HcfSign *sign = nullptr;
1557     int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
1558 
1559     ASSERT_EQ(res, HCF_SUCCESS);
1560     ASSERT_NE(sign, nullptr);
1561 
1562     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1563 
1564     ASSERT_EQ(res, HCF_SUCCESS);
1565 
1566     res = sign->update(sign, &g_mockInput);
1567 
1568     ASSERT_EQ(res, HCF_SUCCESS);
1569 
1570     HcfBlob out = { .data = nullptr, .len = 0 };
1571     res = sign->sign(sign, nullptr, &out);
1572 
1573     ASSERT_EQ(res, HCF_SUCCESS);
1574     ASSERT_NE(out.data, nullptr);
1575     ASSERT_NE(out.len, (const unsigned int)0);
1576 
1577     HcfFree(out.data);
1578     HcfObjDestroy(sign);
1579 }
1580 
1581 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest408, TestSize.Level0)
1582 {
1583     HcfSign *sign = nullptr;
1584     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1585 
1586     ASSERT_EQ(res, HCF_SUCCESS);
1587     ASSERT_NE(sign, nullptr);
1588 
1589     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1590 
1591     ASSERT_EQ(res, HCF_SUCCESS);
1592 
1593     res = sign->update(sign, &g_mockInput);
1594 
1595     ASSERT_EQ(res, HCF_SUCCESS);
1596 
1597     HcfBlob out = { .data = nullptr, .len = 0 };
1598     res = sign->sign(sign, nullptr, &out);
1599 
1600     ASSERT_EQ(res, HCF_SUCCESS);
1601     ASSERT_NE(out.data, nullptr);
1602     ASSERT_NE(out.len, (const unsigned int)0);
1603 
1604     HcfFree(out.data);
1605     HcfObjDestroy(sign);
1606 }
1607 
1608 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest409, TestSize.Level0)
1609 {
1610     HcfSign *sign = nullptr;
1611     int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
1612 
1613     ASSERT_EQ(res, HCF_SUCCESS);
1614     ASSERT_NE(sign, nullptr);
1615 
1616     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1617 
1618     ASSERT_EQ(res, HCF_SUCCESS);
1619 
1620     res = sign->update(sign, &g_mockInput);
1621 
1622     ASSERT_EQ(res, HCF_SUCCESS);
1623 
1624     HcfBlob out = { .data = nullptr, .len = 0 };
1625     res = sign->sign(sign, nullptr, &out);
1626 
1627     ASSERT_EQ(res, HCF_SUCCESS);
1628     ASSERT_NE(out.data, nullptr);
1629     ASSERT_NE(out.len, (const unsigned int)0);
1630 
1631     HcfFree(out.data);
1632     HcfObjDestroy(sign);
1633 }
1634 
1635 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest410, TestSize.Level0)
1636 {
1637     HcfSign *sign = nullptr;
1638     int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
1639 
1640     ASSERT_EQ(res, HCF_SUCCESS);
1641     ASSERT_NE(sign, nullptr);
1642 
1643     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1644 
1645     ASSERT_EQ(res, HCF_SUCCESS);
1646 
1647     res = sign->update(sign, &g_mockInput);
1648 
1649     ASSERT_EQ(res, HCF_SUCCESS);
1650 
1651     HcfBlob out = { .data = nullptr, .len = 0 };
1652     res = sign->sign(sign, nullptr, &out);
1653 
1654     ASSERT_EQ(res, HCF_SUCCESS);
1655     ASSERT_NE(out.data, nullptr);
1656     ASSERT_NE(out.len, (const unsigned int)0);
1657 
1658     HcfFree(out.data);
1659     HcfObjDestroy(sign);
1660 }
1661 
1662 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest411, TestSize.Level0)
1663 {
1664     HcfSign *sign = nullptr;
1665     int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
1666 
1667     ASSERT_EQ(res, HCF_SUCCESS);
1668     ASSERT_NE(sign, nullptr);
1669 
1670     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1671 
1672     ASSERT_EQ(res, HCF_SUCCESS);
1673 
1674     res = sign->update(sign, &g_mockInput);
1675 
1676     ASSERT_EQ(res, HCF_SUCCESS);
1677 
1678     HcfBlob out = { .data = nullptr, .len = 0 };
1679     res = sign->sign(sign, nullptr, &out);
1680 
1681     ASSERT_EQ(res, HCF_SUCCESS);
1682     ASSERT_NE(out.data, nullptr);
1683     ASSERT_NE(out.len, (const unsigned int)0);
1684 
1685     HcfFree(out.data);
1686     HcfObjDestroy(sign);
1687 }
1688 
1689 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest412, TestSize.Level0)
1690 {
1691     HcfSign *sign = nullptr;
1692     int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
1693 
1694     ASSERT_EQ(res, HCF_SUCCESS);
1695     ASSERT_NE(sign, nullptr);
1696 
1697     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1698 
1699     ASSERT_EQ(res, HCF_SUCCESS);
1700 
1701     res = sign->update(sign, &g_mockInput);
1702 
1703     ASSERT_EQ(res, HCF_SUCCESS);
1704 
1705     HcfBlob out = { .data = nullptr, .len = 0 };
1706     res = sign->sign(sign, nullptr, &out);
1707 
1708     ASSERT_EQ(res, HCF_SUCCESS);
1709     ASSERT_NE(out.data, nullptr);
1710     ASSERT_NE(out.len, (const unsigned int)0);
1711 
1712     HcfFree(out.data);
1713     HcfObjDestroy(sign);
1714 }
1715 
1716 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest413, TestSize.Level0)
1717 {
1718     HcfSign *sign = nullptr;
1719     int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
1720 
1721     ASSERT_EQ(res, HCF_SUCCESS);
1722     ASSERT_NE(sign, nullptr);
1723 
1724     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1725 
1726     ASSERT_EQ(res, HCF_SUCCESS);
1727 
1728     res = sign->update(sign, &g_mockInput);
1729 
1730     ASSERT_EQ(res, HCF_SUCCESS);
1731 
1732     HcfBlob out = { .data = nullptr, .len = 0 };
1733     res = sign->sign(sign, nullptr, &out);
1734 
1735     ASSERT_EQ(res, HCF_SUCCESS);
1736     ASSERT_NE(out.data, nullptr);
1737     ASSERT_NE(out.len, (const unsigned int)0);
1738 
1739     HcfFree(out.data);
1740     HcfObjDestroy(sign);
1741 }
1742 
1743 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest414, TestSize.Level0)
1744 {
1745     HcfSign *sign = nullptr;
1746     int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
1747 
1748     ASSERT_EQ(res, HCF_SUCCESS);
1749     ASSERT_NE(sign, nullptr);
1750 
1751     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1752 
1753     ASSERT_EQ(res, HCF_SUCCESS);
1754 
1755     res = sign->update(sign, &g_mockInput);
1756 
1757     ASSERT_EQ(res, HCF_SUCCESS);
1758 
1759     HcfBlob out = { .data = nullptr, .len = 0 };
1760     res = sign->sign(sign, nullptr, &out);
1761 
1762     ASSERT_EQ(res, HCF_SUCCESS);
1763     ASSERT_NE(out.data, nullptr);
1764     ASSERT_NE(out.len, (const unsigned int)0);
1765 
1766     HcfFree(out.data);
1767     HcfObjDestroy(sign);
1768 }
1769 
1770 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest415, TestSize.Level0)
1771 {
1772     HcfSign *sign = nullptr;
1773     int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
1774 
1775     ASSERT_EQ(res, HCF_SUCCESS);
1776     ASSERT_NE(sign, nullptr);
1777 
1778     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1779 
1780     ASSERT_EQ(res, HCF_SUCCESS);
1781 
1782     res = sign->update(sign, &g_mockInput);
1783 
1784     ASSERT_EQ(res, HCF_SUCCESS);
1785 
1786     HcfBlob out = { .data = nullptr, .len = 0 };
1787     res = sign->sign(sign, nullptr, &out);
1788 
1789     ASSERT_EQ(res, HCF_SUCCESS);
1790     ASSERT_NE(out.data, nullptr);
1791     ASSERT_NE(out.len, (const unsigned int)0);
1792 
1793     HcfFree(out.data);
1794     HcfObjDestroy(sign);
1795 }
1796 }
1797