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 CryptoEccVerifySubTest : 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 *CryptoEccVerifySubTest::ecc224KeyPair_ = nullptr;
46 HcfKeyPair *CryptoEccVerifySubTest::ecc256KeyPair_ = nullptr;
47 HcfKeyPair *CryptoEccVerifySubTest::ecc384KeyPair_ = nullptr;
48 HcfKeyPair *CryptoEccVerifySubTest::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 CryptoEccVerifySubTest::SetUp() {}
TearDown()57 void CryptoEccVerifySubTest::TearDown() {}
58 
SetUpTestCase()59 void CryptoEccVerifySubTest::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 CryptoEccVerifySubTest::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(CryptoEccVerifySubTest, CryptoEccVerifySubTest412, TestSize.Level0)
137 {
138     HcfSign *sign = nullptr;
139     int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
140 
141     ASSERT_EQ(res, HCF_SUCCESS);
142     ASSERT_NE(sign, nullptr);
143 
144     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
145 
146     ASSERT_EQ(res, HCF_SUCCESS);
147 
148     res = sign->update(sign, &g_mockInput);
149 
150     ASSERT_EQ(res, HCF_SUCCESS);
151 
152     HcfBlob out = { .data = nullptr, .len = 0 };
153     res = sign->sign(sign, nullptr, &out);
154 
155     ASSERT_EQ(res, HCF_SUCCESS);
156     ASSERT_NE(out.data, nullptr);
157     ASSERT_NE(out.len, (const unsigned int)0);
158 
159     HcfVerify *verify = nullptr;
160     res = HcfVerifyCreate("ECC384|SHA224", &verify);
161 
162     ASSERT_EQ(res, HCF_SUCCESS);
163     ASSERT_NE(verify, nullptr);
164 
165     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
166 
167     ASSERT_EQ(res, HCF_SUCCESS);
168 
169     res = verify->update(verify, &g_mockInput);
170 
171     ASSERT_EQ(res, HCF_SUCCESS);
172 
173     bool flag = verify->verify(verify, nullptr, &out);
174 
175     ASSERT_EQ(flag, true);
176 
177     HcfFree(out.data);
178     HcfObjDestroy(sign);
179     HcfObjDestroy(verify);
180 }
181 
182 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest413, TestSize.Level0)
183 {
184     HcfSign *sign = nullptr;
185     int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
186 
187     ASSERT_EQ(res, HCF_SUCCESS);
188     ASSERT_NE(sign, nullptr);
189 
190     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
191 
192     ASSERT_EQ(res, HCF_SUCCESS);
193 
194     res = sign->update(sign, &g_mockInput);
195 
196     ASSERT_EQ(res, HCF_SUCCESS);
197 
198     HcfBlob out = { .data = nullptr, .len = 0 };
199     res = sign->sign(sign, nullptr, &out);
200 
201     ASSERT_EQ(res, HCF_SUCCESS);
202     ASSERT_NE(out.data, nullptr);
203     ASSERT_NE(out.len, (const unsigned int)0);
204 
205     HcfVerify *verify = nullptr;
206     res = HcfVerifyCreate("ECC384|SHA256", &verify);
207 
208     ASSERT_EQ(res, HCF_SUCCESS);
209     ASSERT_NE(verify, nullptr);
210 
211     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
212 
213     ASSERT_EQ(res, HCF_SUCCESS);
214 
215     res = verify->update(verify, &g_mockInput);
216 
217     ASSERT_EQ(res, HCF_SUCCESS);
218 
219     bool flag = verify->verify(verify, nullptr, &out);
220 
221     ASSERT_EQ(flag, true);
222 
223     HcfFree(out.data);
224     HcfObjDestroy(sign);
225     HcfObjDestroy(verify);
226 }
227 
228 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest414, TestSize.Level0)
229 {
230     HcfSign *sign = nullptr;
231     int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
232 
233     ASSERT_EQ(res, HCF_SUCCESS);
234     ASSERT_NE(sign, nullptr);
235 
236     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
237 
238     ASSERT_EQ(res, HCF_SUCCESS);
239 
240     res = sign->update(sign, &g_mockInput);
241 
242     ASSERT_EQ(res, HCF_SUCCESS);
243 
244     HcfBlob out = { .data = nullptr, .len = 0 };
245     res = sign->sign(sign, nullptr, &out);
246 
247     ASSERT_EQ(res, HCF_SUCCESS);
248     ASSERT_NE(out.data, nullptr);
249     ASSERT_NE(out.len, (const unsigned int)0);
250 
251     HcfVerify *verify = nullptr;
252     res = HcfVerifyCreate("ECC384|SHA384", &verify);
253 
254     ASSERT_EQ(res, HCF_SUCCESS);
255     ASSERT_NE(verify, nullptr);
256 
257     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
258 
259     ASSERT_EQ(res, HCF_SUCCESS);
260 
261     res = verify->update(verify, &g_mockInput);
262 
263     ASSERT_EQ(res, HCF_SUCCESS);
264 
265     bool flag = verify->verify(verify, nullptr, &out);
266 
267     ASSERT_EQ(flag, true);
268 
269     HcfFree(out.data);
270     HcfObjDestroy(sign);
271     HcfObjDestroy(verify);
272 }
273 
274 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest415, TestSize.Level0)
275 {
276     HcfSign *sign = nullptr;
277     int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
278 
279     ASSERT_EQ(res, HCF_SUCCESS);
280     ASSERT_NE(sign, nullptr);
281 
282     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
283 
284     ASSERT_EQ(res, HCF_SUCCESS);
285 
286     res = sign->update(sign, &g_mockInput);
287 
288     ASSERT_EQ(res, HCF_SUCCESS);
289 
290     HcfBlob out = { .data = nullptr, .len = 0 };
291     res = sign->sign(sign, nullptr, &out);
292 
293     ASSERT_EQ(res, HCF_SUCCESS);
294     ASSERT_NE(out.data, nullptr);
295     ASSERT_NE(out.len, (const unsigned int)0);
296 
297     HcfVerify *verify = nullptr;
298     res = HcfVerifyCreate("ECC384|SHA512", &verify);
299 
300     ASSERT_EQ(res, HCF_SUCCESS);
301     ASSERT_NE(verify, nullptr);
302 
303     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
304 
305     ASSERT_EQ(res, HCF_SUCCESS);
306 
307     res = verify->update(verify, &g_mockInput);
308 
309     ASSERT_EQ(res, HCF_SUCCESS);
310 
311     bool flag = verify->verify(verify, nullptr, &out);
312 
313     ASSERT_EQ(flag, true);
314 
315     HcfFree(out.data);
316     HcfObjDestroy(sign);
317     HcfObjDestroy(verify);
318 }
319 
320 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest416, TestSize.Level0)
321 {
322     HcfSign *sign = nullptr;
323     int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
324 
325     ASSERT_EQ(res, HCF_SUCCESS);
326     ASSERT_NE(sign, nullptr);
327 
328     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
329 
330     ASSERT_EQ(res, HCF_SUCCESS);
331 
332     res = sign->update(sign, &g_mockInput);
333 
334     ASSERT_EQ(res, HCF_SUCCESS);
335 
336     HcfBlob out = { .data = nullptr, .len = 0 };
337     res = sign->sign(sign, nullptr, &out);
338 
339     ASSERT_EQ(res, HCF_SUCCESS);
340     ASSERT_NE(out.data, nullptr);
341     ASSERT_NE(out.len, (const unsigned int)0);
342 
343     HcfVerify *verify = nullptr;
344     res = HcfVerifyCreate("ECC521|SHA1", &verify);
345 
346     ASSERT_EQ(res, HCF_SUCCESS);
347     ASSERT_NE(verify, nullptr);
348 
349     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
350 
351     ASSERT_EQ(res, HCF_SUCCESS);
352 
353     res = verify->update(verify, &g_mockInput);
354 
355     ASSERT_EQ(res, HCF_SUCCESS);
356 
357     bool flag = verify->verify(verify, nullptr, &out);
358 
359     ASSERT_EQ(flag, true);
360 
361     HcfFree(out.data);
362     HcfObjDestroy(sign);
363     HcfObjDestroy(verify);
364 }
365 
366 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest417, TestSize.Level0)
367 {
368     HcfSign *sign = nullptr;
369     int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
370 
371     ASSERT_EQ(res, HCF_SUCCESS);
372     ASSERT_NE(sign, nullptr);
373 
374     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
375 
376     ASSERT_EQ(res, HCF_SUCCESS);
377 
378     res = sign->update(sign, &g_mockInput);
379 
380     ASSERT_EQ(res, HCF_SUCCESS);
381 
382     HcfBlob out = { .data = nullptr, .len = 0 };
383     res = sign->sign(sign, nullptr, &out);
384 
385     ASSERT_EQ(res, HCF_SUCCESS);
386     ASSERT_NE(out.data, nullptr);
387     ASSERT_NE(out.len, (const unsigned int)0);
388 
389     HcfVerify *verify = nullptr;
390     res = HcfVerifyCreate("ECC521|SHA224", &verify);
391 
392     ASSERT_EQ(res, HCF_SUCCESS);
393     ASSERT_NE(verify, nullptr);
394 
395     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
396 
397     ASSERT_EQ(res, HCF_SUCCESS);
398 
399     res = verify->update(verify, &g_mockInput);
400 
401     ASSERT_EQ(res, HCF_SUCCESS);
402 
403     bool flag = verify->verify(verify, nullptr, &out);
404 
405     ASSERT_EQ(flag, true);
406 
407     HcfFree(out.data);
408     HcfObjDestroy(sign);
409     HcfObjDestroy(verify);
410 }
411 
412 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest418, TestSize.Level0)
413 {
414     HcfSign *sign = nullptr;
415     int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
416 
417     ASSERT_EQ(res, HCF_SUCCESS);
418     ASSERT_NE(sign, nullptr);
419 
420     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
421 
422     ASSERT_EQ(res, HCF_SUCCESS);
423 
424     res = sign->update(sign, &g_mockInput);
425 
426     ASSERT_EQ(res, HCF_SUCCESS);
427 
428     HcfBlob out = { .data = nullptr, .len = 0 };
429     res = sign->sign(sign, nullptr, &out);
430 
431     ASSERT_EQ(res, HCF_SUCCESS);
432     ASSERT_NE(out.data, nullptr);
433     ASSERT_NE(out.len, (const unsigned int)0);
434 
435     HcfVerify *verify = nullptr;
436     res = HcfVerifyCreate("ECC521|SHA256", &verify);
437 
438     ASSERT_EQ(res, HCF_SUCCESS);
439     ASSERT_NE(verify, nullptr);
440 
441     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
442 
443     ASSERT_EQ(res, HCF_SUCCESS);
444 
445     res = verify->update(verify, &g_mockInput);
446 
447     ASSERT_EQ(res, HCF_SUCCESS);
448 
449     bool flag = verify->verify(verify, nullptr, &out);
450 
451     ASSERT_EQ(flag, true);
452 
453     HcfFree(out.data);
454     HcfObjDestroy(sign);
455     HcfObjDestroy(verify);
456 }
457 
458 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest419, TestSize.Level0)
459 {
460     HcfSign *sign = nullptr;
461     int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
462 
463     ASSERT_EQ(res, HCF_SUCCESS);
464     ASSERT_NE(sign, nullptr);
465 
466     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
467 
468     ASSERT_EQ(res, HCF_SUCCESS);
469 
470     res = sign->update(sign, &g_mockInput);
471 
472     ASSERT_EQ(res, HCF_SUCCESS);
473 
474     HcfBlob out = { .data = nullptr, .len = 0 };
475     res = sign->sign(sign, nullptr, &out);
476 
477     ASSERT_EQ(res, HCF_SUCCESS);
478     ASSERT_NE(out.data, nullptr);
479     ASSERT_NE(out.len, (const unsigned int)0);
480 
481     HcfVerify *verify = nullptr;
482     res = HcfVerifyCreate("ECC521|SHA384", &verify);
483 
484     ASSERT_EQ(res, HCF_SUCCESS);
485     ASSERT_NE(verify, nullptr);
486 
487     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
488 
489     ASSERT_EQ(res, HCF_SUCCESS);
490 
491     res = verify->update(verify, &g_mockInput);
492 
493     ASSERT_EQ(res, HCF_SUCCESS);
494 
495     bool flag = verify->verify(verify, nullptr, &out);
496 
497     ASSERT_EQ(flag, true);
498 
499     HcfFree(out.data);
500     HcfObjDestroy(sign);
501     HcfObjDestroy(verify);
502 }
503 
504 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest420, TestSize.Level0)
505 {
506     HcfSign *sign = nullptr;
507     int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
508 
509     ASSERT_EQ(res, HCF_SUCCESS);
510     ASSERT_NE(sign, nullptr);
511 
512     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
513 
514     ASSERT_EQ(res, HCF_SUCCESS);
515 
516     res = sign->update(sign, &g_mockInput);
517 
518     ASSERT_EQ(res, HCF_SUCCESS);
519 
520     HcfBlob out = { .data = nullptr, .len = 0 };
521     res = sign->sign(sign, nullptr, &out);
522 
523     ASSERT_EQ(res, HCF_SUCCESS);
524     ASSERT_NE(out.data, nullptr);
525     ASSERT_NE(out.len, (const unsigned int)0);
526 
527     HcfVerify *verify = nullptr;
528     res = HcfVerifyCreate("ECC521|SHA512", &verify);
529 
530     ASSERT_EQ(res, HCF_SUCCESS);
531     ASSERT_NE(verify, nullptr);
532 
533     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
534 
535     ASSERT_EQ(res, HCF_SUCCESS);
536 
537     res = verify->update(verify, &g_mockInput);
538 
539     ASSERT_EQ(res, HCF_SUCCESS);
540 
541     bool flag = verify->verify(verify, nullptr, &out);
542 
543     ASSERT_EQ(flag, true);
544 
545     HcfFree(out.data);
546     HcfObjDestroy(sign);
547     HcfObjDestroy(verify);
548 }
549 
550 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest421, TestSize.Level0)
551 {
552     HcfSign *sign = nullptr;
553     int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
554 
555     ASSERT_EQ(res, HCF_SUCCESS);
556     ASSERT_NE(sign, nullptr);
557 
558     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
559 
560     ASSERT_EQ(res, HCF_SUCCESS);
561 
562     HcfBlob out = { .data = nullptr, .len = 0 };
563     res = sign->sign(sign, &g_mockInput, &out);
564 
565     ASSERT_EQ(res, HCF_SUCCESS);
566     ASSERT_NE(out.data, nullptr);
567     ASSERT_NE(out.len, (const unsigned int)0);
568 
569     HcfVerify *verify = nullptr;
570     res = HcfVerifyCreate("ECC224|SHA1", &verify);
571 
572     ASSERT_EQ(res, HCF_SUCCESS);
573     ASSERT_NE(verify, nullptr);
574 
575     res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
576 
577     ASSERT_EQ(res, HCF_SUCCESS);
578 
579     bool flag = verify->verify(verify, &g_mockInput, &out);
580 
581     ASSERT_EQ(flag, true);
582 
583     HcfFree(out.data);
584     HcfObjDestroy(sign);
585     HcfObjDestroy(verify);
586 }
587 
588 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest422, TestSize.Level0)
589 {
590     HcfSign *sign = nullptr;
591     int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
592 
593     ASSERT_EQ(res, HCF_SUCCESS);
594     ASSERT_NE(sign, nullptr);
595 
596     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
597 
598     ASSERT_EQ(res, HCF_SUCCESS);
599 
600     HcfBlob out = { .data = nullptr, .len = 0 };
601     res = sign->sign(sign, &g_mockInput, &out);
602 
603     ASSERT_EQ(res, HCF_SUCCESS);
604     ASSERT_NE(out.data, nullptr);
605     ASSERT_NE(out.len, (const unsigned int)0);
606 
607     HcfVerify *verify = nullptr;
608     res = HcfVerifyCreate("ECC224|SHA224", &verify);
609 
610     ASSERT_EQ(res, HCF_SUCCESS);
611     ASSERT_NE(verify, nullptr);
612 
613     res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
614 
615     ASSERT_EQ(res, HCF_SUCCESS);
616 
617     bool flag = verify->verify(verify, &g_mockInput, &out);
618 
619     ASSERT_EQ(flag, true);
620 
621     HcfFree(out.data);
622     HcfObjDestroy(sign);
623     HcfObjDestroy(verify);
624 }
625 
626 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest423, TestSize.Level0)
627 {
628     HcfSign *sign = nullptr;
629     int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
630 
631     ASSERT_EQ(res, HCF_SUCCESS);
632     ASSERT_NE(sign, nullptr);
633 
634     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
635 
636     ASSERT_EQ(res, HCF_SUCCESS);
637 
638     HcfBlob out = { .data = nullptr, .len = 0 };
639     res = sign->sign(sign, &g_mockInput, &out);
640 
641     ASSERT_EQ(res, HCF_SUCCESS);
642     ASSERT_NE(out.data, nullptr);
643     ASSERT_NE(out.len, (const unsigned int)0);
644 
645     HcfVerify *verify = nullptr;
646     res = HcfVerifyCreate("ECC224|SHA256", &verify);
647 
648     ASSERT_EQ(res, HCF_SUCCESS);
649     ASSERT_NE(verify, nullptr);
650 
651     res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
652 
653     ASSERT_EQ(res, HCF_SUCCESS);
654 
655     bool flag = verify->verify(verify, &g_mockInput, &out);
656 
657     ASSERT_EQ(flag, true);
658 
659     HcfFree(out.data);
660     HcfObjDestroy(sign);
661     HcfObjDestroy(verify);
662 }
663 
664 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest424, TestSize.Level0)
665 {
666     HcfSign *sign = nullptr;
667     int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
668 
669     ASSERT_EQ(res, HCF_SUCCESS);
670     ASSERT_NE(sign, nullptr);
671 
672     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
673 
674     ASSERT_EQ(res, HCF_SUCCESS);
675 
676     HcfBlob out = { .data = nullptr, .len = 0 };
677     res = sign->sign(sign, &g_mockInput, &out);
678 
679     ASSERT_EQ(res, HCF_SUCCESS);
680     ASSERT_NE(out.data, nullptr);
681     ASSERT_NE(out.len, (const unsigned int)0);
682 
683     HcfVerify *verify = nullptr;
684     res = HcfVerifyCreate("ECC224|SHA384", &verify);
685 
686     ASSERT_EQ(res, HCF_SUCCESS);
687     ASSERT_NE(verify, nullptr);
688 
689     res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
690 
691     ASSERT_EQ(res, HCF_SUCCESS);
692 
693     bool flag = verify->verify(verify, &g_mockInput, &out);
694 
695     ASSERT_EQ(flag, true);
696 
697     HcfFree(out.data);
698     HcfObjDestroy(sign);
699     HcfObjDestroy(verify);
700 }
701 
702 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest425, TestSize.Level0)
703 {
704     HcfSign *sign = nullptr;
705     int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
706 
707     ASSERT_EQ(res, HCF_SUCCESS);
708     ASSERT_NE(sign, nullptr);
709 
710     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
711 
712     ASSERT_EQ(res, HCF_SUCCESS);
713 
714     HcfBlob out = { .data = nullptr, .len = 0 };
715     res = sign->sign(sign, &g_mockInput, &out);
716 
717     ASSERT_EQ(res, HCF_SUCCESS);
718     ASSERT_NE(out.data, nullptr);
719     ASSERT_NE(out.len, (const unsigned int)0);
720 
721     HcfVerify *verify = nullptr;
722     res = HcfVerifyCreate("ECC224|SHA512", &verify);
723 
724     ASSERT_EQ(res, HCF_SUCCESS);
725     ASSERT_NE(verify, nullptr);
726 
727     res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
728 
729     ASSERT_EQ(res, HCF_SUCCESS);
730 
731     bool flag = verify->verify(verify, &g_mockInput, &out);
732 
733     ASSERT_EQ(flag, true);
734 
735     HcfFree(out.data);
736     HcfObjDestroy(sign);
737     HcfObjDestroy(verify);
738 }
739 
740 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest426, TestSize.Level0)
741 {
742     HcfSign *sign = nullptr;
743     int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
744 
745     ASSERT_EQ(res, HCF_SUCCESS);
746     ASSERT_NE(sign, nullptr);
747 
748     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
749 
750     ASSERT_EQ(res, HCF_SUCCESS);
751 
752     HcfBlob out = { .data = nullptr, .len = 0 };
753     res = sign->sign(sign, &g_mockInput, &out);
754 
755     ASSERT_EQ(res, HCF_SUCCESS);
756     ASSERT_NE(out.data, nullptr);
757     ASSERT_NE(out.len, (const unsigned int)0);
758 
759     HcfVerify *verify = nullptr;
760     res = HcfVerifyCreate("ECC256|SHA1", &verify);
761 
762     ASSERT_EQ(res, HCF_SUCCESS);
763     ASSERT_NE(verify, nullptr);
764 
765     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
766 
767     ASSERT_EQ(res, HCF_SUCCESS);
768 
769     bool flag = verify->verify(verify, &g_mockInput, &out);
770 
771     ASSERT_EQ(flag, true);
772 
773     HcfFree(out.data);
774     HcfObjDestroy(sign);
775     HcfObjDestroy(verify);
776 }
777 
778 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest427, TestSize.Level0)
779 {
780     HcfSign *sign = nullptr;
781     int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
782 
783     ASSERT_EQ(res, HCF_SUCCESS);
784     ASSERT_NE(sign, nullptr);
785 
786     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
787 
788     ASSERT_EQ(res, HCF_SUCCESS);
789 
790     HcfBlob out = { .data = nullptr, .len = 0 };
791     res = sign->sign(sign, &g_mockInput, &out);
792 
793     ASSERT_EQ(res, HCF_SUCCESS);
794     ASSERT_NE(out.data, nullptr);
795     ASSERT_NE(out.len, (const unsigned int)0);
796 
797     HcfVerify *verify = nullptr;
798     res = HcfVerifyCreate("ECC256|SHA224", &verify);
799 
800     ASSERT_EQ(res, HCF_SUCCESS);
801     ASSERT_NE(verify, nullptr);
802 
803     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
804 
805     ASSERT_EQ(res, HCF_SUCCESS);
806 
807     bool flag = verify->verify(verify, &g_mockInput, &out);
808 
809     ASSERT_EQ(flag, true);
810 
811     HcfFree(out.data);
812     HcfObjDestroy(sign);
813     HcfObjDestroy(verify);
814 }
815 
816 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest428, TestSize.Level0)
817 {
818     HcfSign *sign = nullptr;
819     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
820 
821     ASSERT_EQ(res, HCF_SUCCESS);
822     ASSERT_NE(sign, nullptr);
823 
824     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
825 
826     ASSERT_EQ(res, HCF_SUCCESS);
827 
828     HcfBlob out = { .data = nullptr, .len = 0 };
829     res = sign->sign(sign, &g_mockInput, &out);
830 
831     ASSERT_EQ(res, HCF_SUCCESS);
832     ASSERT_NE(out.data, nullptr);
833     ASSERT_NE(out.len, (const unsigned int)0);
834 
835     HcfVerify *verify = nullptr;
836     res = HcfVerifyCreate("ECC256|SHA256", &verify);
837 
838     ASSERT_EQ(res, HCF_SUCCESS);
839     ASSERT_NE(verify, nullptr);
840 
841     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
842 
843     ASSERT_EQ(res, HCF_SUCCESS);
844 
845     bool flag = verify->verify(verify, &g_mockInput, &out);
846 
847     ASSERT_EQ(flag, true);
848 
849     HcfFree(out.data);
850     HcfObjDestroy(sign);
851     HcfObjDestroy(verify);
852 }
853 
854 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest429, TestSize.Level0)
855 {
856     HcfSign *sign = nullptr;
857     int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
858 
859     ASSERT_EQ(res, HCF_SUCCESS);
860     ASSERT_NE(sign, nullptr);
861 
862     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
863 
864     ASSERT_EQ(res, HCF_SUCCESS);
865 
866     HcfBlob out = { .data = nullptr, .len = 0 };
867     res = sign->sign(sign, &g_mockInput, &out);
868 
869     ASSERT_EQ(res, HCF_SUCCESS);
870     ASSERT_NE(out.data, nullptr);
871     ASSERT_NE(out.len, (const unsigned int)0);
872 
873     HcfVerify *verify = nullptr;
874     res = HcfVerifyCreate("ECC256|SHA384", &verify);
875 
876     ASSERT_EQ(res, HCF_SUCCESS);
877     ASSERT_NE(verify, nullptr);
878 
879     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
880 
881     ASSERT_EQ(res, HCF_SUCCESS);
882 
883     bool flag = verify->verify(verify, &g_mockInput, &out);
884 
885     ASSERT_EQ(flag, true);
886 
887     HcfFree(out.data);
888     HcfObjDestroy(sign);
889     HcfObjDestroy(verify);
890 }
891 
892 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest430, TestSize.Level0)
893 {
894     HcfSign *sign = nullptr;
895     int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
896 
897     ASSERT_EQ(res, HCF_SUCCESS);
898     ASSERT_NE(sign, nullptr);
899 
900     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
901 
902     ASSERT_EQ(res, HCF_SUCCESS);
903 
904     HcfBlob out = { .data = nullptr, .len = 0 };
905     res = sign->sign(sign, &g_mockInput, &out);
906 
907     ASSERT_EQ(res, HCF_SUCCESS);
908     ASSERT_NE(out.data, nullptr);
909     ASSERT_NE(out.len, (const unsigned int)0);
910 
911     HcfVerify *verify = nullptr;
912     res = HcfVerifyCreate("ECC256|SHA512", &verify);
913 
914     ASSERT_EQ(res, HCF_SUCCESS);
915     ASSERT_NE(verify, nullptr);
916 
917     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
918 
919     ASSERT_EQ(res, HCF_SUCCESS);
920 
921     bool flag = verify->verify(verify, &g_mockInput, &out);
922 
923     ASSERT_EQ(flag, true);
924 
925     HcfFree(out.data);
926     HcfObjDestroy(sign);
927     HcfObjDestroy(verify);
928 }
929 
930 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest431, TestSize.Level0)
931 {
932     HcfSign *sign = nullptr;
933     int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
934 
935     ASSERT_EQ(res, HCF_SUCCESS);
936     ASSERT_NE(sign, nullptr);
937 
938     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
939 
940     ASSERT_EQ(res, HCF_SUCCESS);
941 
942     HcfBlob out = { .data = nullptr, .len = 0 };
943     res = sign->sign(sign, &g_mockInput, &out);
944 
945     ASSERT_EQ(res, HCF_SUCCESS);
946     ASSERT_NE(out.data, nullptr);
947     ASSERT_NE(out.len, (const unsigned int)0);
948 
949     HcfVerify *verify = nullptr;
950     res = HcfVerifyCreate("ECC384|SHA1", &verify);
951 
952     ASSERT_EQ(res, HCF_SUCCESS);
953     ASSERT_NE(verify, nullptr);
954 
955     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
956 
957     ASSERT_EQ(res, HCF_SUCCESS);
958 
959     bool flag = verify->verify(verify, &g_mockInput, &out);
960 
961     ASSERT_EQ(flag, true);
962 
963     HcfFree(out.data);
964     HcfObjDestroy(sign);
965     HcfObjDestroy(verify);
966 }
967 
968 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest432, TestSize.Level0)
969 {
970     HcfSign *sign = nullptr;
971     int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
972 
973     ASSERT_EQ(res, HCF_SUCCESS);
974     ASSERT_NE(sign, nullptr);
975 
976     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
977 
978     ASSERT_EQ(res, HCF_SUCCESS);
979 
980     HcfBlob out = { .data = nullptr, .len = 0 };
981     res = sign->sign(sign, &g_mockInput, &out);
982 
983     ASSERT_EQ(res, HCF_SUCCESS);
984     ASSERT_NE(out.data, nullptr);
985     ASSERT_NE(out.len, (const unsigned int)0);
986 
987     HcfVerify *verify = nullptr;
988     res = HcfVerifyCreate("ECC384|SHA224", &verify);
989 
990     ASSERT_EQ(res, HCF_SUCCESS);
991     ASSERT_NE(verify, nullptr);
992 
993     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
994 
995     ASSERT_EQ(res, HCF_SUCCESS);
996 
997     bool flag = verify->verify(verify, &g_mockInput, &out);
998 
999     ASSERT_EQ(flag, true);
1000 
1001     HcfFree(out.data);
1002     HcfObjDestroy(sign);
1003     HcfObjDestroy(verify);
1004 }
1005 
1006 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest433, TestSize.Level0)
1007 {
1008     HcfSign *sign = nullptr;
1009     int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
1010 
1011     ASSERT_EQ(res, HCF_SUCCESS);
1012     ASSERT_NE(sign, nullptr);
1013 
1014     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1015 
1016     ASSERT_EQ(res, HCF_SUCCESS);
1017 
1018     HcfBlob out = { .data = nullptr, .len = 0 };
1019     res = sign->sign(sign, &g_mockInput, &out);
1020 
1021     ASSERT_EQ(res, HCF_SUCCESS);
1022     ASSERT_NE(out.data, nullptr);
1023     ASSERT_NE(out.len, (const unsigned int)0);
1024 
1025     HcfVerify *verify = nullptr;
1026     res = HcfVerifyCreate("ECC384|SHA256", &verify);
1027 
1028     ASSERT_EQ(res, HCF_SUCCESS);
1029     ASSERT_NE(verify, nullptr);
1030 
1031     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
1032 
1033     ASSERT_EQ(res, HCF_SUCCESS);
1034 
1035     bool flag = verify->verify(verify, &g_mockInput, &out);
1036 
1037     ASSERT_EQ(flag, true);
1038 
1039     HcfFree(out.data);
1040     HcfObjDestroy(sign);
1041     HcfObjDestroy(verify);
1042 }
1043 
1044 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest434, TestSize.Level0)
1045 {
1046     HcfSign *sign = nullptr;
1047     int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
1048 
1049     ASSERT_EQ(res, HCF_SUCCESS);
1050     ASSERT_NE(sign, nullptr);
1051 
1052     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1053 
1054     ASSERT_EQ(res, HCF_SUCCESS);
1055 
1056     HcfBlob out = { .data = nullptr, .len = 0 };
1057     res = sign->sign(sign, &g_mockInput, &out);
1058 
1059     ASSERT_EQ(res, HCF_SUCCESS);
1060     ASSERT_NE(out.data, nullptr);
1061     ASSERT_NE(out.len, (const unsigned int)0);
1062 
1063     HcfVerify *verify = nullptr;
1064     res = HcfVerifyCreate("ECC384|SHA384", &verify);
1065 
1066     ASSERT_EQ(res, HCF_SUCCESS);
1067     ASSERT_NE(verify, nullptr);
1068 
1069     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
1070 
1071     ASSERT_EQ(res, HCF_SUCCESS);
1072 
1073     bool flag = verify->verify(verify, &g_mockInput, &out);
1074 
1075     ASSERT_EQ(flag, true);
1076 
1077     HcfFree(out.data);
1078     HcfObjDestroy(sign);
1079     HcfObjDestroy(verify);
1080 }
1081 
1082 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest435, TestSize.Level0)
1083 {
1084     HcfSign *sign = nullptr;
1085     int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
1086 
1087     ASSERT_EQ(res, HCF_SUCCESS);
1088     ASSERT_NE(sign, nullptr);
1089 
1090     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1091 
1092     ASSERT_EQ(res, HCF_SUCCESS);
1093 
1094     HcfBlob out = { .data = nullptr, .len = 0 };
1095     res = sign->sign(sign, &g_mockInput, &out);
1096 
1097     ASSERT_EQ(res, HCF_SUCCESS);
1098     ASSERT_NE(out.data, nullptr);
1099     ASSERT_NE(out.len, (const unsigned int)0);
1100 
1101     HcfVerify *verify = nullptr;
1102     res = HcfVerifyCreate("ECC384|SHA512", &verify);
1103 
1104     ASSERT_EQ(res, HCF_SUCCESS);
1105     ASSERT_NE(verify, nullptr);
1106 
1107     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
1108 
1109     ASSERT_EQ(res, HCF_SUCCESS);
1110 
1111     bool flag = verify->verify(verify, &g_mockInput, &out);
1112 
1113     ASSERT_EQ(flag, true);
1114 
1115     HcfFree(out.data);
1116     HcfObjDestroy(sign);
1117     HcfObjDestroy(verify);
1118 }
1119 
1120 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest436, TestSize.Level0)
1121 {
1122     HcfSign *sign = nullptr;
1123     int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
1124 
1125     ASSERT_EQ(res, HCF_SUCCESS);
1126     ASSERT_NE(sign, nullptr);
1127 
1128     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1129 
1130     ASSERT_EQ(res, HCF_SUCCESS);
1131 
1132     HcfBlob out = { .data = nullptr, .len = 0 };
1133     res = sign->sign(sign, &g_mockInput, &out);
1134 
1135     ASSERT_EQ(res, HCF_SUCCESS);
1136     ASSERT_NE(out.data, nullptr);
1137     ASSERT_NE(out.len, (const unsigned int)0);
1138 
1139     HcfVerify *verify = nullptr;
1140     res = HcfVerifyCreate("ECC521|SHA1", &verify);
1141 
1142     ASSERT_EQ(res, HCF_SUCCESS);
1143     ASSERT_NE(verify, nullptr);
1144 
1145     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
1146 
1147     ASSERT_EQ(res, HCF_SUCCESS);
1148 
1149     bool flag = verify->verify(verify, &g_mockInput, &out);
1150 
1151     ASSERT_EQ(flag, true);
1152 
1153     HcfFree(out.data);
1154     HcfObjDestroy(sign);
1155     HcfObjDestroy(verify);
1156 }
1157 
1158 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest437, TestSize.Level0)
1159 {
1160     HcfSign *sign = nullptr;
1161     int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
1162 
1163     ASSERT_EQ(res, HCF_SUCCESS);
1164     ASSERT_NE(sign, nullptr);
1165 
1166     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1167 
1168     ASSERT_EQ(res, HCF_SUCCESS);
1169 
1170     HcfBlob out = { .data = nullptr, .len = 0 };
1171     res = sign->sign(sign, &g_mockInput, &out);
1172 
1173     ASSERT_EQ(res, HCF_SUCCESS);
1174     ASSERT_NE(out.data, nullptr);
1175     ASSERT_NE(out.len, (const unsigned int)0);
1176 
1177     HcfVerify *verify = nullptr;
1178     res = HcfVerifyCreate("ECC521|SHA224", &verify);
1179 
1180     ASSERT_EQ(res, HCF_SUCCESS);
1181     ASSERT_NE(verify, nullptr);
1182 
1183     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
1184 
1185     ASSERT_EQ(res, HCF_SUCCESS);
1186 
1187     bool flag = verify->verify(verify, &g_mockInput, &out);
1188 
1189     ASSERT_EQ(flag, true);
1190 
1191     HcfFree(out.data);
1192     HcfObjDestroy(sign);
1193     HcfObjDestroy(verify);
1194 }
1195 
1196 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest438, TestSize.Level0)
1197 {
1198     HcfSign *sign = nullptr;
1199     int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
1200 
1201     ASSERT_EQ(res, HCF_SUCCESS);
1202     ASSERT_NE(sign, nullptr);
1203 
1204     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1205 
1206     ASSERT_EQ(res, HCF_SUCCESS);
1207 
1208     HcfBlob out = { .data = nullptr, .len = 0 };
1209     res = sign->sign(sign, &g_mockInput, &out);
1210 
1211     ASSERT_EQ(res, HCF_SUCCESS);
1212     ASSERT_NE(out.data, nullptr);
1213     ASSERT_NE(out.len, (const unsigned int)0);
1214 
1215     HcfVerify *verify = nullptr;
1216     res = HcfVerifyCreate("ECC521|SHA256", &verify);
1217 
1218     ASSERT_EQ(res, HCF_SUCCESS);
1219     ASSERT_NE(verify, nullptr);
1220 
1221     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
1222 
1223     ASSERT_EQ(res, HCF_SUCCESS);
1224 
1225     bool flag = verify->verify(verify, &g_mockInput, &out);
1226 
1227     ASSERT_EQ(flag, true);
1228 
1229     HcfFree(out.data);
1230     HcfObjDestroy(sign);
1231     HcfObjDestroy(verify);
1232 }
1233 
1234 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest439, TestSize.Level0)
1235 {
1236     HcfSign *sign = nullptr;
1237     int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
1238 
1239     ASSERT_EQ(res, HCF_SUCCESS);
1240     ASSERT_NE(sign, nullptr);
1241 
1242     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1243 
1244     ASSERT_EQ(res, HCF_SUCCESS);
1245 
1246     HcfBlob out = { .data = nullptr, .len = 0 };
1247     res = sign->sign(sign, &g_mockInput, &out);
1248 
1249     ASSERT_EQ(res, HCF_SUCCESS);
1250     ASSERT_NE(out.data, nullptr);
1251     ASSERT_NE(out.len, (const unsigned int)0);
1252 
1253     HcfVerify *verify = nullptr;
1254     res = HcfVerifyCreate("ECC521|SHA384", &verify);
1255 
1256     ASSERT_EQ(res, HCF_SUCCESS);
1257     ASSERT_NE(verify, nullptr);
1258 
1259     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
1260 
1261     ASSERT_EQ(res, HCF_SUCCESS);
1262 
1263     bool flag = verify->verify(verify, &g_mockInput, &out);
1264 
1265     ASSERT_EQ(flag, true);
1266 
1267     HcfFree(out.data);
1268     HcfObjDestroy(sign);
1269     HcfObjDestroy(verify);
1270 }
1271 
1272 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest440, TestSize.Level0)
1273 {
1274     HcfSign *sign = nullptr;
1275     int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
1276 
1277     ASSERT_EQ(res, HCF_SUCCESS);
1278     ASSERT_NE(sign, nullptr);
1279 
1280     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1281 
1282     ASSERT_EQ(res, HCF_SUCCESS);
1283 
1284     HcfBlob out = { .data = nullptr, .len = 0 };
1285     res = sign->sign(sign, &g_mockInput, &out);
1286 
1287     ASSERT_EQ(res, HCF_SUCCESS);
1288     ASSERT_NE(out.data, nullptr);
1289     ASSERT_NE(out.len, (const unsigned int)0);
1290 
1291     HcfVerify *verify = nullptr;
1292     res = HcfVerifyCreate("ECC521|SHA512", &verify);
1293 
1294     ASSERT_EQ(res, HCF_SUCCESS);
1295     ASSERT_NE(verify, nullptr);
1296 
1297     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
1298 
1299     ASSERT_EQ(res, HCF_SUCCESS);
1300 
1301     bool flag = verify->verify(verify, &g_mockInput, &out);
1302 
1303     ASSERT_EQ(flag, true);
1304 
1305     HcfFree(out.data);
1306     HcfObjDestroy(sign);
1307     HcfObjDestroy(verify);
1308 }
1309 
1310 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest441, TestSize.Level0)
1311 {
1312     HcfSign *sign = nullptr;
1313     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1314 
1315     ASSERT_EQ(res, HCF_SUCCESS);
1316     ASSERT_NE(sign, nullptr);
1317 
1318     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1319 
1320     ASSERT_EQ(res, HCF_SUCCESS);
1321 
1322     res = sign->update(sign, &g_mockInput);
1323 
1324     ASSERT_EQ(res, HCF_SUCCESS);
1325 
1326     HcfBlob out = { .data = nullptr, .len = 0 };
1327     res = sign->sign(sign, nullptr, &out);
1328 
1329     ASSERT_EQ(res, HCF_SUCCESS);
1330     ASSERT_NE(out.data, nullptr);
1331     ASSERT_NE(out.len, (const unsigned int)0);
1332 
1333     HcfVerify *verify = nullptr;
1334     res = HcfVerifyCreate("ECC256|SHA256", &verify);
1335 
1336     ASSERT_EQ(res, HCF_SUCCESS);
1337     ASSERT_NE(verify, nullptr);
1338 
1339     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1340 
1341     ASSERT_EQ(res, HCF_SUCCESS);
1342 
1343     res = verify->update(verify, &g_mockInput);
1344 
1345     ASSERT_EQ(res, HCF_SUCCESS);
1346 
1347     bool flag = verify->verify(nullptr, nullptr, &out);
1348 
1349     ASSERT_EQ(flag, false);
1350 
1351     HcfFree(out.data);
1352     HcfObjDestroy(sign);
1353     HcfObjDestroy(verify);
1354 }
1355 
1356 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest442, TestSize.Level0)
1357 {
1358     HcfSign *sign = nullptr;
1359     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1360 
1361     ASSERT_EQ(res, HCF_SUCCESS);
1362     ASSERT_NE(sign, nullptr);
1363 
1364     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1365 
1366     ASSERT_EQ(res, HCF_SUCCESS);
1367 
1368     res = sign->update(sign, &g_mockInput);
1369 
1370     ASSERT_EQ(res, HCF_SUCCESS);
1371 
1372     HcfBlob out = { .data = nullptr, .len = 0 };
1373     res = sign->sign(sign, nullptr, &out);
1374 
1375     ASSERT_EQ(res, HCF_SUCCESS);
1376     ASSERT_NE(out.data, nullptr);
1377     ASSERT_NE(out.len, (const unsigned int)0);
1378 
1379     HcfVerify *verify = nullptr;
1380     res = HcfVerifyCreate("ECC256|SHA256", &verify);
1381 
1382     ASSERT_EQ(res, HCF_SUCCESS);
1383     ASSERT_NE(verify, nullptr);
1384 
1385     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1386 
1387     ASSERT_EQ(res, HCF_SUCCESS);
1388 
1389     res = verify->update(verify, &g_mockInput);
1390 
1391     ASSERT_EQ(res, HCF_SUCCESS);
1392 
1393     bool flag = verify->verify((HcfVerify *)(&obj), nullptr, &out);
1394 
1395     ASSERT_EQ(flag, false);
1396 
1397     HcfFree(out.data);
1398     HcfObjDestroy(sign);
1399     HcfObjDestroy(verify);
1400 }
1401 
1402 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest443, TestSize.Level0)
1403 {
1404     HcfSign *sign = nullptr;
1405     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1406 
1407     ASSERT_EQ(res, HCF_SUCCESS);
1408     ASSERT_NE(sign, nullptr);
1409 
1410     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1411 
1412     ASSERT_EQ(res, HCF_SUCCESS);
1413 
1414     res = sign->update(sign, &g_mockInput);
1415 
1416     ASSERT_EQ(res, HCF_SUCCESS);
1417 
1418     HcfBlob out = { .data = nullptr, .len = 0 };
1419     res = sign->sign(sign, nullptr, &out);
1420 
1421     ASSERT_EQ(res, HCF_SUCCESS);
1422     ASSERT_NE(out.data, nullptr);
1423     ASSERT_NE(out.len, (const unsigned int)0);
1424 
1425     HcfVerify *verify = nullptr;
1426     res = HcfVerifyCreate("ECC256|SHA256", &verify);
1427 
1428     ASSERT_EQ(res, HCF_SUCCESS);
1429     ASSERT_NE(verify, nullptr);
1430 
1431     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1432 
1433     ASSERT_EQ(res, HCF_SUCCESS);
1434 
1435     bool flag = verify->verify(verify, nullptr, &out);
1436 
1437     ASSERT_EQ(flag, false);
1438 
1439     HcfFree(out.data);
1440     HcfObjDestroy(sign);
1441     HcfObjDestroy(verify);
1442 }
1443 
1444 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest444, TestSize.Level0)
1445 {
1446     HcfSign *sign = nullptr;
1447     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1448 
1449     ASSERT_EQ(res, HCF_SUCCESS);
1450     ASSERT_NE(sign, nullptr);
1451 
1452     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1453 
1454     ASSERT_EQ(res, HCF_SUCCESS);
1455 
1456     res = sign->update(sign, &g_mockInput);
1457 
1458     ASSERT_EQ(res, HCF_SUCCESS);
1459 
1460     HcfBlob out = { .data = nullptr, .len = 0 };
1461     res = sign->sign(sign, nullptr, &out);
1462 
1463     ASSERT_EQ(res, HCF_SUCCESS);
1464     ASSERT_NE(out.data, nullptr);
1465     ASSERT_NE(out.len, (const unsigned int)0);
1466 
1467     HcfVerify *verify = nullptr;
1468     res = HcfVerifyCreate("ECC256|SHA256", &verify);
1469 
1470     ASSERT_EQ(res, HCF_SUCCESS);
1471     ASSERT_NE(verify, nullptr);
1472 
1473     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1474 
1475     ASSERT_EQ(res, HCF_SUCCESS);
1476 
1477     HcfBlob input = {
1478         .data = nullptr,
1479         .len = 1
1480     };
1481     bool flag = verify->verify(verify, &input, &out);
1482 
1483     ASSERT_EQ(flag, false);
1484 
1485     HcfFree(out.data);
1486     HcfObjDestroy(sign);
1487     HcfObjDestroy(verify);
1488 }
1489 
1490 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest445, TestSize.Level0)
1491 {
1492     HcfSign *sign = nullptr;
1493     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1494 
1495     ASSERT_EQ(res, HCF_SUCCESS);
1496     ASSERT_NE(sign, nullptr);
1497 
1498     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1499 
1500     ASSERT_EQ(res, HCF_SUCCESS);
1501 
1502     res = sign->update(sign, &g_mockInput);
1503 
1504     ASSERT_EQ(res, HCF_SUCCESS);
1505 
1506     HcfBlob out = { .data = nullptr, .len = 0 };
1507     res = sign->sign(sign, nullptr, &out);
1508 
1509     ASSERT_EQ(res, HCF_SUCCESS);
1510     ASSERT_NE(out.data, nullptr);
1511     ASSERT_NE(out.len, (const unsigned int)0);
1512 
1513     HcfVerify *verify = nullptr;
1514     res = HcfVerifyCreate("ECC256|SHA256", &verify);
1515 
1516     ASSERT_EQ(res, HCF_SUCCESS);
1517     ASSERT_NE(verify, nullptr);
1518 
1519     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1520 
1521     ASSERT_EQ(res, HCF_SUCCESS);
1522 
1523     HcfBlob input = {
1524         .data = (uint8_t *)g_mockMessage,
1525         .len = 0
1526     };
1527     bool flag = verify->verify(verify, &input, &out);
1528 
1529     ASSERT_EQ(flag, false);
1530 
1531     HcfFree(out.data);
1532     HcfObjDestroy(sign);
1533     HcfObjDestroy(verify);
1534 }
1535 
1536 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest446, TestSize.Level0)
1537 {
1538     HcfVerify *verify = nullptr;
1539     int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
1540 
1541     ASSERT_EQ(res, HCF_SUCCESS);
1542     ASSERT_NE(verify, nullptr);
1543 
1544     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1545 
1546     ASSERT_EQ(res, HCF_SUCCESS);
1547 
1548     res = verify->update(verify, &g_mockInput);
1549 
1550     ASSERT_EQ(res, HCF_SUCCESS);
1551 
1552     bool flag = verify->verify(verify, nullptr, nullptr);
1553 
1554     ASSERT_EQ(flag, false);
1555 
1556     HcfObjDestroy(verify);
1557 }
1558 
1559 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest447, TestSize.Level0)
1560 {
1561     HcfVerify *verify = nullptr;
1562     int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
1563 
1564     ASSERT_EQ(res, HCF_SUCCESS);
1565     ASSERT_NE(verify, nullptr);
1566 
1567     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1568 
1569     ASSERT_EQ(res, HCF_SUCCESS);
1570 
1571     res = verify->update(verify, &g_mockInput);
1572 
1573     ASSERT_EQ(res, HCF_SUCCESS);
1574 
1575     HcfBlob mockOut = {
1576         .data = nullptr,
1577         .len = 1
1578     };
1579     bool flag = verify->verify(verify, nullptr, &mockOut);
1580 
1581     ASSERT_EQ(flag, false);
1582 
1583     HcfObjDestroy(verify);
1584 }
1585 
1586 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest448, TestSize.Level0)
1587 {
1588     HcfVerify *verify = nullptr;
1589     int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
1590 
1591     ASSERT_EQ(res, HCF_SUCCESS);
1592     ASSERT_NE(verify, nullptr);
1593 
1594     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1595 
1596     ASSERT_EQ(res, HCF_SUCCESS);
1597 
1598     res = verify->update(verify, &g_mockInput);
1599 
1600     ASSERT_EQ(res, HCF_SUCCESS);
1601 
1602     HcfBlob mockOut = {
1603         .data = (uint8_t *)g_mockMessage,
1604         .len = 0
1605     };
1606     bool flag = verify->verify(verify, nullptr, &mockOut);
1607 
1608     ASSERT_EQ(flag, false);
1609 
1610     HcfObjDestroy(verify);
1611 }
1612 
1613 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest501, TestSize.Level0)
1614 {
1615     HcfVerifySpi *spiObj = nullptr;
1616     int32_t res = HcfVerifySpiEcdsaCreate(nullptr, &spiObj);
1617 
1618     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1619     ASSERT_EQ(spiObj, nullptr);
1620 }
1621 
1622 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest502, TestSize.Level0)
1623 {
1624     HcfSignatureParams params = {
1625         .algo = HCF_ALG_ECC,
1626         .padding = HCF_ALG_NOPADDING,
1627         .md = HCF_OPENSSL_DIGEST_SHA256,
1628         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1629     };
1630     int32_t res = HcfVerifySpiEcdsaCreate(&params, nullptr);
1631 
1632     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1633 }
1634 
1635 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest504, TestSize.Level0)
1636 {
1637     HcfSignatureParams params = {
1638         .algo = HCF_ALG_ECC,
1639         .padding = HCF_ALG_NOPADDING,
1640         .md = HCF_OPENSSL_DIGEST_SHA256,
1641         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1642     };
1643     HcfVerifySpi *spiObj = nullptr;
1644     int32_t res = HcfVerifySpiEcdsaCreate(&params, &spiObj);
1645 
1646     ASSERT_EQ(res, HCF_SUCCESS);
1647     ASSERT_NE(spiObj, nullptr);
1648 
1649     res = spiObj->engineInit((HcfVerifySpi *)&obj, nullptr, ecc256KeyPair_->pubKey);
1650     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1651 
1652     HcfObjDestroy(spiObj);
1653 }
1654 
1655 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest505, TestSize.Level0)
1656 {
1657     HcfSignatureParams params = {
1658         .algo = HCF_ALG_ECC,
1659         .padding = HCF_ALG_NOPADDING,
1660         .md = HCF_OPENSSL_DIGEST_SHA256,
1661         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1662     };
1663     HcfVerifySpi *spiObj = nullptr;
1664     int32_t res = HcfVerifySpiEcdsaCreate(&params, &spiObj);
1665 
1666     ASSERT_EQ(res, HCF_SUCCESS);
1667     ASSERT_NE(spiObj, nullptr);
1668 
1669     res = spiObj->engineInit(spiObj, nullptr, (HcfPubKey *)&obj);
1670     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1671 
1672     HcfObjDestroy(spiObj);
1673 }
1674 
1675 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest506, TestSize.Level0)
1676 {
1677     HcfSignatureParams params = {
1678         .algo = HCF_ALG_ECC,
1679         .padding = HCF_ALG_NOPADDING,
1680         .md = HCF_OPENSSL_DIGEST_SHA256,
1681         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1682     };
1683     HcfVerifySpi *spiObj = nullptr;
1684     int32_t res = HcfVerifySpiEcdsaCreate(&params, &spiObj);
1685 
1686     ASSERT_EQ(res, HCF_SUCCESS);
1687     ASSERT_NE(spiObj, nullptr);
1688 
1689     const char *message = "hello world";
1690     HcfBlob input = {
1691         .data = (uint8_t *)message,
1692         .len = 12
1693     };
1694     res = spiObj->engineUpdate(nullptr, &input);
1695     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1696 
1697     HcfObjDestroy(spiObj);
1698 }
1699 
1700 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest507, TestSize.Level0)
1701 {
1702     HcfSignatureParams params = {
1703         .algo = HCF_ALG_ECC,
1704         .padding = HCF_ALG_NOPADDING,
1705         .md = HCF_OPENSSL_DIGEST_SHA256,
1706         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1707     };
1708     HcfVerifySpi *spiObj = nullptr;
1709     int32_t res = HcfVerifySpiEcdsaCreate(&params, &spiObj);
1710 
1711     ASSERT_EQ(res, HCF_SUCCESS);
1712     ASSERT_NE(spiObj, nullptr);
1713 
1714     const char *message = "hello world";
1715     HcfBlob input = {
1716         .data = (uint8_t *)message,
1717         .len = 12
1718     };
1719     res = spiObj->engineUpdate((HcfVerifySpi *)&obj, &input);
1720     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1721 
1722     HcfObjDestroy(spiObj);
1723 }
1724 
1725 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest508, TestSize.Level0)
1726 {
1727     HcfSignatureParams params = {
1728         .algo = HCF_ALG_ECC,
1729         .padding = HCF_ALG_NOPADDING,
1730         .md = HCF_OPENSSL_DIGEST_SHA256,
1731         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1732     };
1733     HcfVerifySpi *spiObj = nullptr;
1734     int32_t res = HcfVerifySpiEcdsaCreate(&params, &spiObj);
1735 
1736     ASSERT_EQ(res, HCF_SUCCESS);
1737     ASSERT_NE(spiObj, nullptr);
1738 
1739     res = spiObj->engineUpdate(spiObj, nullptr);
1740     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1741 
1742     HcfObjDestroy(spiObj);
1743 }
1744 
1745 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest509, TestSize.Level0)
1746 {
1747     HcfSignatureParams params = {
1748         .algo = HCF_ALG_ECC,
1749         .padding = HCF_ALG_NOPADDING,
1750         .md = HCF_OPENSSL_DIGEST_SHA256,
1751         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1752     };
1753     HcfVerifySpi *spiObj = nullptr;
1754     int32_t res = HcfVerifySpiEcdsaCreate(&params, &spiObj);
1755 
1756     ASSERT_EQ(res, HCF_SUCCESS);
1757     ASSERT_NE(spiObj, nullptr);
1758 
1759     const char *message = "hello world";
1760     HcfBlob input = {
1761         .data = (uint8_t *)message,
1762         .len = 12
1763     };
1764     HcfBlob out = { .data = nullptr, .len = 0 };
1765     bool isOk = spiObj->engineVerify(nullptr, &input, &out);
1766     ASSERT_EQ(isOk, false);
1767 
1768     HcfObjDestroy(spiObj);
1769 }
1770 
1771 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest510, TestSize.Level0)
1772 {
1773     HcfSignatureParams params = {
1774         .algo = HCF_ALG_ECC,
1775         .padding = HCF_ALG_NOPADDING,
1776         .md = HCF_OPENSSL_DIGEST_SHA256,
1777         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1778     };
1779     HcfVerifySpi *spiObj = nullptr;
1780     int32_t res = HcfVerifySpiEcdsaCreate(&params, &spiObj);
1781 
1782     ASSERT_EQ(res, HCF_SUCCESS);
1783     ASSERT_NE(spiObj, nullptr);
1784 
1785     const char *message = "hello world";
1786     HcfBlob input = {
1787         .data = (uint8_t *)message,
1788         .len = 12
1789     };
1790     bool isOk = spiObj->engineVerify((HcfVerifySpi *)&obj, &input, &input);
1791     ASSERT_EQ(isOk, false);
1792 
1793     HcfObjDestroy(spiObj);
1794 }
1795 
1796 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest511, TestSize.Level0)
1797 {
1798     HcfSignatureParams params = {
1799         .algo = HCF_ALG_ECC,
1800         .padding = HCF_ALG_NOPADDING,
1801         .md = HCF_OPENSSL_DIGEST_SHA256,
1802         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1803     };
1804     HcfVerifySpi *spiObj = nullptr;
1805     int32_t res = HcfVerifySpiEcdsaCreate(&params, &spiObj);
1806 
1807     ASSERT_EQ(res, HCF_SUCCESS);
1808     ASSERT_NE(spiObj, nullptr);
1809 
1810     spiObj->base.destroy(nullptr);
1811 
1812     HcfObjDestroy(spiObj);
1813 }
1814 
1815 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest512, TestSize.Level0)
1816 {
1817     HcfSignatureParams params = {
1818         .algo = HCF_ALG_ECC,
1819         .padding = HCF_ALG_NOPADDING,
1820         .md = HCF_OPENSSL_DIGEST_SHA256,
1821         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1822     };
1823     HcfVerifySpi *spiObj = nullptr;
1824     int32_t res = HcfVerifySpiEcdsaCreate(&params, &spiObj);
1825 
1826     ASSERT_EQ(res, HCF_SUCCESS);
1827     ASSERT_NE(spiObj, nullptr);
1828 
1829     spiObj->base.destroy(&obj);
1830 
1831     HcfObjDestroy(spiObj);
1832 }
1833 
GetSignTestData(HcfBlob * out)1834 static bool GetSignTestData(HcfBlob *out)
1835 {
1836     HcfSign *sign = nullptr;
1837     int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
1838     if (res != HCF_SUCCESS) {
1839         return false;
1840     }
1841     res = sign->init(sign, nullptr, CryptoEccVerifySubTest::ecc224KeyPair_->priKey);
1842     if (res != HCF_SUCCESS) {
1843         HcfObjDestroy(sign);
1844         return false;
1845     }
1846     res = sign->update(sign, &g_mockInput);
1847     if (res != HCF_SUCCESS) {
1848         HcfObjDestroy(sign);
1849         return false;
1850     }
1851     res = sign->sign(sign, &g_mockInput, out);
1852     HcfObjDestroy(sign);
1853     return res == HCF_SUCCESS;
1854 }
1855 
MemoryMockTestFunc(uint32_t mallocCount,HcfBlob * out)1856 static void MemoryMockTestFunc(uint32_t mallocCount, HcfBlob *out)
1857 {
1858     for (int i = 0; i < mallocCount; i++) {
1859         ResetRecordMallocNum();
1860         SetMockMallocIndex(i);
1861         HcfVerify *verify = nullptr;
1862         int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify);
1863         if (res != HCF_SUCCESS) {
1864             continue;
1865         }
1866         res = verify->init(verify, nullptr, CryptoEccVerifySubTest::ecc224KeyPair_->pubKey);
1867         if (res != HCF_SUCCESS) {
1868             HcfObjDestroy(verify);
1869             continue;
1870         }
1871         res = verify->update(verify, &g_mockInput);
1872         if (res != HCF_SUCCESS) {
1873             HcfObjDestroy(verify);
1874             continue;
1875         }
1876         (void)verify->verify(verify, nullptr, out);
1877         HcfObjDestroy(verify);
1878     }
1879 }
1880 
1881 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest601, TestSize.Level0)
1882 {
1883     HcfBlob out = { .data = nullptr, .len = 0 };
1884     GetSignTestData(&out);
1885     StartRecordMallocNum();
1886 
1887     HcfVerify *verify = nullptr;
1888     int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify);
1889 
1890     ASSERT_EQ(res, HCF_SUCCESS);
1891     ASSERT_NE(verify, nullptr);
1892 
1893     res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
1894 
1895     ASSERT_EQ(res, HCF_SUCCESS);
1896 
1897     res = verify->update(verify, &g_mockInput);
1898 
1899     ASSERT_EQ(res, HCF_SUCCESS);
1900 
1901     bool flag = verify->verify(verify, &g_mockInput, &out);
1902 
1903     ASSERT_EQ(flag, true);
1904     HcfObjDestroy(verify);
1905 
1906     uint32_t mallocCount = GetMallocNum();
1907     MemoryMockTestFunc(mallocCount, &out);
1908     EndRecordMallocNum();
1909 }
1910 
OpensslMockTestFunc(uint32_t mallocCount,HcfBlob * out)1911 static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *out)
1912 {
1913     for (int i = 0; i < mallocCount; i++) {
1914         ResetOpensslCallNum();
1915         SetOpensslCallMockIndex(i);
1916         HcfVerify *verify = nullptr;
1917         int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify);
1918         if (res != HCF_SUCCESS) {
1919             continue;
1920         }
1921         res = verify->init(verify, nullptr, CryptoEccVerifySubTest::ecc224KeyPair_->pubKey);
1922         if (res != HCF_SUCCESS) {
1923             HcfObjDestroy(verify);
1924             continue;
1925         }
1926         res = verify->update(verify, &g_mockInput);
1927         if (res != HCF_SUCCESS) {
1928             HcfObjDestroy(verify);
1929             continue;
1930         }
1931         (void)verify->verify(verify, &g_mockInput, out);
1932         HcfObjDestroy(verify);
1933     }
1934 }
1935 
1936 HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest602, TestSize.Level0)
1937 {
1938     HcfBlob out = { .data = nullptr, .len = 0 };
1939     ASSERT_EQ(GetSignTestData(&out), true);
1940     StartRecordOpensslCallNum();
1941 
1942     HcfVerify *verify = nullptr;
1943     int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify);
1944 
1945     ASSERT_EQ(res, HCF_SUCCESS);
1946     ASSERT_NE(verify, nullptr);
1947 
1948     res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
1949 
1950     ASSERT_EQ(res, HCF_SUCCESS);
1951 
1952     res = verify->update(verify, &g_mockInput);
1953 
1954     ASSERT_EQ(res, HCF_SUCCESS);
1955 
1956     bool flag = verify->verify(verify, &g_mockInput, &out);
1957 
1958     ASSERT_EQ(flag, true);
1959     HcfObjDestroy(verify);
1960 
1961     uint32_t mallocCount = GetOpensslCallNum();
1962     OpensslMockTestFunc(mallocCount, &out);
1963     EndRecordOpensslCallNum();
1964 }
1965 }
1966