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 CryptoEccSignSubTest : 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 *CryptoEccSignSubTest::ecc224KeyPair_ = nullptr;
46 HcfKeyPair *CryptoEccSignSubTest::ecc256KeyPair_ = nullptr;
47 HcfKeyPair *CryptoEccSignSubTest::ecc384KeyPair_ = nullptr;
48 HcfKeyPair *CryptoEccSignSubTest::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 CryptoEccSignSubTest::SetUp() {}
TearDown()57 void CryptoEccSignSubTest::TearDown() {}
58 
SetUpTestCase()59 void CryptoEccSignSubTest::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 CryptoEccSignSubTest::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(CryptoEccSignSubTest, CryptoEccSignSubTest416, TestSize.Level0)
137 {
138     HcfSign *sign = nullptr;
139     int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
140 
141     ASSERT_EQ(res, HCF_SUCCESS);
142     ASSERT_NE(sign, nullptr);
143 
144     res = sign->init(sign, nullptr, ecc521KeyPair_->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     HcfFree(out.data);
160     HcfObjDestroy(sign);
161 }
162 
163 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest417, TestSize.Level0)
164 {
165     HcfSign *sign = nullptr;
166     int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
167 
168     ASSERT_EQ(res, HCF_SUCCESS);
169     ASSERT_NE(sign, nullptr);
170 
171     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
172 
173     ASSERT_EQ(res, HCF_SUCCESS);
174 
175     res = sign->update(sign, &g_mockInput);
176 
177     ASSERT_EQ(res, HCF_SUCCESS);
178 
179     HcfBlob out = { .data = nullptr, .len = 0 };
180     res = sign->sign(sign, nullptr, &out);
181 
182     ASSERT_EQ(res, HCF_SUCCESS);
183     ASSERT_NE(out.data, nullptr);
184     ASSERT_NE(out.len, (const unsigned int)0);
185 
186     HcfFree(out.data);
187     HcfObjDestroy(sign);
188 }
189 
190 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest418, TestSize.Level0)
191 {
192     HcfSign *sign = nullptr;
193     int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
194 
195     ASSERT_EQ(res, HCF_SUCCESS);
196     ASSERT_NE(sign, nullptr);
197 
198     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
199 
200     ASSERT_EQ(res, HCF_SUCCESS);
201 
202     res = sign->update(sign, &g_mockInput);
203 
204     ASSERT_EQ(res, HCF_SUCCESS);
205 
206     HcfBlob out = { .data = nullptr, .len = 0 };
207     res = sign->sign(sign, nullptr, &out);
208 
209     ASSERT_EQ(res, HCF_SUCCESS);
210     ASSERT_NE(out.data, nullptr);
211     ASSERT_NE(out.len, (const unsigned int)0);
212 
213     HcfFree(out.data);
214     HcfObjDestroy(sign);
215 }
216 
217 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest419, TestSize.Level0)
218 {
219     HcfSign *sign = nullptr;
220     int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
221 
222     ASSERT_EQ(res, HCF_SUCCESS);
223     ASSERT_NE(sign, nullptr);
224 
225     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
226 
227     ASSERT_EQ(res, HCF_SUCCESS);
228 
229     res = sign->update(sign, &g_mockInput);
230 
231     ASSERT_EQ(res, HCF_SUCCESS);
232 
233     HcfBlob out = { .data = nullptr, .len = 0 };
234     res = sign->sign(sign, nullptr, &out);
235 
236     ASSERT_EQ(res, HCF_SUCCESS);
237     ASSERT_NE(out.data, nullptr);
238     ASSERT_NE(out.len, (const unsigned int)0);
239 
240     HcfFree(out.data);
241     HcfObjDestroy(sign);
242 }
243 
244 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest420, TestSize.Level0)
245 {
246     HcfSign *sign = nullptr;
247     int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
248 
249     ASSERT_EQ(res, HCF_SUCCESS);
250     ASSERT_NE(sign, nullptr);
251 
252     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
253 
254     ASSERT_EQ(res, HCF_SUCCESS);
255 
256     res = sign->update(sign, &g_mockInput);
257 
258     ASSERT_EQ(res, HCF_SUCCESS);
259 
260     HcfBlob out = { .data = nullptr, .len = 0 };
261     res = sign->sign(sign, nullptr, &out);
262 
263     ASSERT_EQ(res, HCF_SUCCESS);
264     ASSERT_NE(out.data, nullptr);
265     ASSERT_NE(out.len, (const unsigned int)0);
266 
267     HcfFree(out.data);
268     HcfObjDestroy(sign);
269 }
270 
271 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest421, TestSize.Level0)
272 {
273     HcfSign *sign = nullptr;
274     int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
275 
276     ASSERT_EQ(res, HCF_SUCCESS);
277     ASSERT_NE(sign, nullptr);
278 
279     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
280 
281     ASSERT_EQ(res, HCF_SUCCESS);
282 
283     HcfBlob out = { .data = nullptr, .len = 0 };
284     res = sign->sign(sign, &g_mockInput, &out);
285 
286     ASSERT_EQ(res, HCF_SUCCESS);
287     ASSERT_NE(out.data, nullptr);
288     ASSERT_NE(out.len, (const unsigned int)0);
289 
290     HcfFree(out.data);
291     HcfObjDestroy(sign);
292 }
293 
294 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest422, TestSize.Level0)
295 {
296     HcfSign *sign = nullptr;
297     int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
298 
299     ASSERT_EQ(res, HCF_SUCCESS);
300     ASSERT_NE(sign, nullptr);
301 
302     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
303 
304     ASSERT_EQ(res, HCF_SUCCESS);
305 
306     HcfBlob out = { .data = nullptr, .len = 0 };
307     res = sign->sign(sign, &g_mockInput, &out);
308 
309     ASSERT_EQ(res, HCF_SUCCESS);
310     ASSERT_NE(out.data, nullptr);
311     ASSERT_NE(out.len, (const unsigned int)0);
312 
313     HcfFree(out.data);
314     HcfObjDestroy(sign);
315 }
316 
317 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest423, TestSize.Level0)
318 {
319     HcfSign *sign = nullptr;
320     int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
321 
322     ASSERT_EQ(res, HCF_SUCCESS);
323     ASSERT_NE(sign, nullptr);
324 
325     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
326 
327     ASSERT_EQ(res, HCF_SUCCESS);
328 
329     HcfBlob out = { .data = nullptr, .len = 0 };
330     res = sign->sign(sign, &g_mockInput, &out);
331 
332     ASSERT_EQ(res, HCF_SUCCESS);
333     ASSERT_NE(out.data, nullptr);
334     ASSERT_NE(out.len, (const unsigned int)0);
335 
336     HcfFree(out.data);
337     HcfObjDestroy(sign);
338 }
339 
340 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest424, TestSize.Level0)
341 {
342     HcfSign *sign = nullptr;
343     int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
344 
345     ASSERT_EQ(res, HCF_SUCCESS);
346     ASSERT_NE(sign, nullptr);
347 
348     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
349 
350     ASSERT_EQ(res, HCF_SUCCESS);
351 
352     HcfBlob out = { .data = nullptr, .len = 0 };
353     res = sign->sign(sign, &g_mockInput, &out);
354 
355     ASSERT_EQ(res, HCF_SUCCESS);
356     ASSERT_NE(out.data, nullptr);
357     ASSERT_NE(out.len, (const unsigned int)0);
358 
359     HcfFree(out.data);
360     HcfObjDestroy(sign);
361 }
362 
363 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest425, TestSize.Level0)
364 {
365     HcfSign *sign = nullptr;
366     int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
367 
368     ASSERT_EQ(res, HCF_SUCCESS);
369     ASSERT_NE(sign, nullptr);
370 
371     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
372 
373     ASSERT_EQ(res, HCF_SUCCESS);
374 
375     HcfBlob out = { .data = nullptr, .len = 0 };
376     res = sign->sign(sign, &g_mockInput, &out);
377 
378     ASSERT_EQ(res, HCF_SUCCESS);
379     ASSERT_NE(out.data, nullptr);
380     ASSERT_NE(out.len, (const unsigned int)0);
381 
382     HcfFree(out.data);
383     HcfObjDestroy(sign);
384 }
385 
386 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest426, TestSize.Level0)
387 {
388     HcfSign *sign = nullptr;
389     int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
390 
391     ASSERT_EQ(res, HCF_SUCCESS);
392     ASSERT_NE(sign, nullptr);
393 
394     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
395 
396     ASSERT_EQ(res, HCF_SUCCESS);
397 
398     HcfBlob out = { .data = nullptr, .len = 0 };
399     res = sign->sign(sign, &g_mockInput, &out);
400 
401     ASSERT_EQ(res, HCF_SUCCESS);
402     ASSERT_NE(out.data, nullptr);
403     ASSERT_NE(out.len, (const unsigned int)0);
404 
405     HcfFree(out.data);
406     HcfObjDestroy(sign);
407 }
408 
409 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest427, TestSize.Level0)
410 {
411     HcfSign *sign = nullptr;
412     int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
413 
414     ASSERT_EQ(res, HCF_SUCCESS);
415     ASSERT_NE(sign, nullptr);
416 
417     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
418 
419     ASSERT_EQ(res, HCF_SUCCESS);
420 
421     HcfBlob out = { .data = nullptr, .len = 0 };
422     res = sign->sign(sign, &g_mockInput, &out);
423 
424     ASSERT_EQ(res, HCF_SUCCESS);
425     ASSERT_NE(out.data, nullptr);
426     ASSERT_NE(out.len, (const unsigned int)0);
427 
428     HcfFree(out.data);
429     HcfObjDestroy(sign);
430 }
431 
432 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest428, TestSize.Level0)
433 {
434     HcfSign *sign = nullptr;
435     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
436 
437     ASSERT_EQ(res, HCF_SUCCESS);
438     ASSERT_NE(sign, nullptr);
439 
440     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
441 
442     ASSERT_EQ(res, HCF_SUCCESS);
443 
444     HcfBlob out = { .data = nullptr, .len = 0 };
445     res = sign->sign(sign, &g_mockInput, &out);
446 
447     ASSERT_EQ(res, HCF_SUCCESS);
448     ASSERT_NE(out.data, nullptr);
449     ASSERT_NE(out.len, (const unsigned int)0);
450 
451     HcfFree(out.data);
452     HcfObjDestroy(sign);
453 }
454 
455 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest429, TestSize.Level0)
456 {
457     HcfSign *sign = nullptr;
458     int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
459 
460     ASSERT_EQ(res, HCF_SUCCESS);
461     ASSERT_NE(sign, nullptr);
462 
463     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
464 
465     ASSERT_EQ(res, HCF_SUCCESS);
466 
467     HcfBlob out = { .data = nullptr, .len = 0 };
468     res = sign->sign(sign, &g_mockInput, &out);
469 
470     ASSERT_EQ(res, HCF_SUCCESS);
471     ASSERT_NE(out.data, nullptr);
472     ASSERT_NE(out.len, (const unsigned int)0);
473 
474     HcfFree(out.data);
475     HcfObjDestroy(sign);
476 }
477 
478 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest430, TestSize.Level0)
479 {
480     HcfSign *sign = nullptr;
481     int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
482 
483     ASSERT_EQ(res, HCF_SUCCESS);
484     ASSERT_NE(sign, nullptr);
485 
486     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
487 
488     ASSERT_EQ(res, HCF_SUCCESS);
489 
490     HcfBlob out = { .data = nullptr, .len = 0 };
491     res = sign->sign(sign, &g_mockInput, &out);
492 
493     ASSERT_EQ(res, HCF_SUCCESS);
494     ASSERT_NE(out.data, nullptr);
495     ASSERT_NE(out.len, (const unsigned int)0);
496 
497     HcfFree(out.data);
498     HcfObjDestroy(sign);
499 }
500 
501 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest431, TestSize.Level0)
502 {
503     HcfSign *sign = nullptr;
504     int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
505 
506     ASSERT_EQ(res, HCF_SUCCESS);
507     ASSERT_NE(sign, nullptr);
508 
509     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
510 
511     ASSERT_EQ(res, HCF_SUCCESS);
512 
513     HcfBlob out = { .data = nullptr, .len = 0 };
514     res = sign->sign(sign, &g_mockInput, &out);
515 
516     ASSERT_EQ(res, HCF_SUCCESS);
517     ASSERT_NE(out.data, nullptr);
518     ASSERT_NE(out.len, (const unsigned int)0);
519 
520     HcfFree(out.data);
521     HcfObjDestroy(sign);
522 }
523 
524 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest432, TestSize.Level0)
525 {
526     HcfSign *sign = nullptr;
527     int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
528 
529     ASSERT_EQ(res, HCF_SUCCESS);
530     ASSERT_NE(sign, nullptr);
531 
532     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
533 
534     ASSERT_EQ(res, HCF_SUCCESS);
535 
536     HcfBlob out = { .data = nullptr, .len = 0 };
537     res = sign->sign(sign, &g_mockInput, &out);
538 
539     ASSERT_EQ(res, HCF_SUCCESS);
540     ASSERT_NE(out.data, nullptr);
541     ASSERT_NE(out.len, (const unsigned int)0);
542 
543     HcfFree(out.data);
544     HcfObjDestroy(sign);
545 }
546 
547 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest433, TestSize.Level0)
548 {
549     HcfSign *sign = nullptr;
550     int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
551 
552     ASSERT_EQ(res, HCF_SUCCESS);
553     ASSERT_NE(sign, nullptr);
554 
555     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
556 
557     ASSERT_EQ(res, HCF_SUCCESS);
558 
559     HcfBlob out = { .data = nullptr, .len = 0 };
560     res = sign->sign(sign, &g_mockInput, &out);
561 
562     ASSERT_EQ(res, HCF_SUCCESS);
563     ASSERT_NE(out.data, nullptr);
564     ASSERT_NE(out.len, (const unsigned int)0);
565 
566     HcfFree(out.data);
567     HcfObjDestroy(sign);
568 }
569 
570 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest434, TestSize.Level0)
571 {
572     HcfSign *sign = nullptr;
573     int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
574 
575     ASSERT_EQ(res, HCF_SUCCESS);
576     ASSERT_NE(sign, nullptr);
577 
578     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
579 
580     ASSERT_EQ(res, HCF_SUCCESS);
581 
582     HcfBlob out = { .data = nullptr, .len = 0 };
583     res = sign->sign(sign, &g_mockInput, &out);
584 
585     ASSERT_EQ(res, HCF_SUCCESS);
586     ASSERT_NE(out.data, nullptr);
587     ASSERT_NE(out.len, (const unsigned int)0);
588 
589     HcfFree(out.data);
590     HcfObjDestroy(sign);
591 }
592 
593 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest435, TestSize.Level0)
594 {
595     HcfSign *sign = nullptr;
596     int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
597 
598     ASSERT_EQ(res, HCF_SUCCESS);
599     ASSERT_NE(sign, nullptr);
600 
601     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
602 
603     ASSERT_EQ(res, HCF_SUCCESS);
604 
605     HcfBlob out = { .data = nullptr, .len = 0 };
606     res = sign->sign(sign, &g_mockInput, &out);
607 
608     ASSERT_EQ(res, HCF_SUCCESS);
609     ASSERT_NE(out.data, nullptr);
610     ASSERT_NE(out.len, (const unsigned int)0);
611 
612     HcfFree(out.data);
613     HcfObjDestroy(sign);
614 }
615 
616 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest436, TestSize.Level0)
617 {
618     HcfSign *sign = nullptr;
619     int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
620 
621     ASSERT_EQ(res, HCF_SUCCESS);
622     ASSERT_NE(sign, nullptr);
623 
624     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
625 
626     ASSERT_EQ(res, HCF_SUCCESS);
627 
628     HcfBlob out = { .data = nullptr, .len = 0 };
629     res = sign->sign(sign, &g_mockInput, &out);
630 
631     ASSERT_EQ(res, HCF_SUCCESS);
632     ASSERT_NE(out.data, nullptr);
633     ASSERT_NE(out.len, (const unsigned int)0);
634 
635     HcfFree(out.data);
636     HcfObjDestroy(sign);
637 }
638 
639 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest437, TestSize.Level0)
640 {
641     HcfSign *sign = nullptr;
642     int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
643 
644     ASSERT_EQ(res, HCF_SUCCESS);
645     ASSERT_NE(sign, nullptr);
646 
647     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
648 
649     ASSERT_EQ(res, HCF_SUCCESS);
650 
651     HcfBlob out = { .data = nullptr, .len = 0 };
652     res = sign->sign(sign, &g_mockInput, &out);
653 
654     ASSERT_EQ(res, HCF_SUCCESS);
655     ASSERT_NE(out.data, nullptr);
656     ASSERT_NE(out.len, (const unsigned int)0);
657 
658     HcfFree(out.data);
659     HcfObjDestroy(sign);
660 }
661 
662 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest438, TestSize.Level0)
663 {
664     HcfSign *sign = nullptr;
665     int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
666 
667     ASSERT_EQ(res, HCF_SUCCESS);
668     ASSERT_NE(sign, nullptr);
669 
670     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
671 
672     ASSERT_EQ(res, HCF_SUCCESS);
673 
674     HcfBlob out = { .data = nullptr, .len = 0 };
675     res = sign->sign(sign, &g_mockInput, &out);
676 
677     ASSERT_EQ(res, HCF_SUCCESS);
678     ASSERT_NE(out.data, nullptr);
679     ASSERT_NE(out.len, (const unsigned int)0);
680 
681     HcfFree(out.data);
682     HcfObjDestroy(sign);
683 }
684 
685 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest439, TestSize.Level0)
686 {
687     HcfSign *sign = nullptr;
688     int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
689 
690     ASSERT_EQ(res, HCF_SUCCESS);
691     ASSERT_NE(sign, nullptr);
692 
693     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
694 
695     ASSERT_EQ(res, HCF_SUCCESS);
696 
697     HcfBlob out = { .data = nullptr, .len = 0 };
698     res = sign->sign(sign, &g_mockInput, &out);
699 
700     ASSERT_EQ(res, HCF_SUCCESS);
701     ASSERT_NE(out.data, nullptr);
702     ASSERT_NE(out.len, (const unsigned int)0);
703 
704     HcfFree(out.data);
705     HcfObjDestroy(sign);
706 }
707 
708 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest440, TestSize.Level0)
709 {
710     HcfSign *sign = nullptr;
711     int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
712 
713     ASSERT_EQ(res, HCF_SUCCESS);
714     ASSERT_NE(sign, nullptr);
715 
716     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
717 
718     ASSERT_EQ(res, HCF_SUCCESS);
719 
720     HcfBlob out = { .data = nullptr, .len = 0 };
721     res = sign->sign(sign, &g_mockInput, &out);
722 
723     ASSERT_EQ(res, HCF_SUCCESS);
724     ASSERT_NE(out.data, nullptr);
725     ASSERT_NE(out.len, (const unsigned int)0);
726 
727     HcfFree(out.data);
728     HcfObjDestroy(sign);
729 }
730 
731 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest441, TestSize.Level0)
732 {
733     HcfSign *sign = nullptr;
734     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
735 
736     ASSERT_EQ(res, HCF_SUCCESS);
737     ASSERT_NE(sign, nullptr);
738 
739     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
740 
741     ASSERT_EQ(res, HCF_SUCCESS);
742 
743     res = sign->update(sign, &g_mockInput);
744 
745     ASSERT_EQ(res, HCF_SUCCESS);
746 
747     HcfBlob out = { .data = nullptr, .len = 0 };
748     res = sign->sign(nullptr, nullptr, &out);
749 
750     ASSERT_EQ(res, HCF_INVALID_PARAMS);
751 
752     HcfObjDestroy(sign);
753 }
754 
755 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest442, TestSize.Level0)
756 {
757     HcfSign *sign = nullptr;
758     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
759 
760     ASSERT_EQ(res, HCF_SUCCESS);
761     ASSERT_NE(sign, nullptr);
762 
763     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
764 
765     ASSERT_EQ(res, HCF_SUCCESS);
766 
767     res = sign->update(sign, &g_mockInput);
768 
769     ASSERT_EQ(res, HCF_SUCCESS);
770 
771     HcfBlob out = { .data = nullptr, .len = 0 };
772     res = sign->sign((HcfSign *)(&obj), nullptr, &out);
773 
774     ASSERT_EQ(res, HCF_INVALID_PARAMS);
775 
776     HcfObjDestroy(sign);
777 }
778 
779 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest443, TestSize.Level0)
780 {
781     HcfSign *sign = nullptr;
782     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
783 
784     ASSERT_EQ(res, HCF_SUCCESS);
785     ASSERT_NE(sign, nullptr);
786 
787     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
788 
789     ASSERT_EQ(res, HCF_SUCCESS);
790 
791     HcfBlob out = { .data = nullptr, .len = 0 };
792     res = sign->sign(sign, nullptr, &out);
793 
794     ASSERT_EQ(res, HCF_INVALID_PARAMS);
795 
796     HcfObjDestroy(sign);
797 }
798 
799 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest444, TestSize.Level0)
800 {
801     HcfSign *sign = nullptr;
802     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
803 
804     ASSERT_EQ(res, HCF_SUCCESS);
805     ASSERT_NE(sign, nullptr);
806 
807     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
808 
809     ASSERT_EQ(res, HCF_SUCCESS);
810 
811     HcfBlob input = {
812         .data = nullptr,
813         .len = 1
814     };
815     HcfBlob out = { .data = nullptr, .len = 0 };
816     res = sign->sign(sign, &input, &out);
817 
818     ASSERT_EQ(res, HCF_INVALID_PARAMS);
819 
820     HcfObjDestroy(sign);
821 }
822 
823 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest445, TestSize.Level0)
824 {
825     HcfSign *sign = nullptr;
826     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
827 
828     ASSERT_EQ(res, HCF_SUCCESS);
829     ASSERT_NE(sign, nullptr);
830 
831     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
832 
833     ASSERT_EQ(res, HCF_SUCCESS);
834 
835     HcfBlob input = {
836         .data = (uint8_t *)g_mockMessage,
837         .len = 0
838     };
839     HcfBlob out = { .data = nullptr, .len = 0 };
840     res = sign->sign(sign, &input, &out);
841 
842     ASSERT_EQ(res, HCF_INVALID_PARAMS);
843 
844     HcfObjDestroy(sign);
845 }
846 
847 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest446, TestSize.Level0)
848 {
849     HcfSign *sign = nullptr;
850     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
851 
852     ASSERT_EQ(res, HCF_SUCCESS);
853     ASSERT_NE(sign, nullptr);
854 
855     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
856 
857     ASSERT_EQ(res, HCF_SUCCESS);
858 
859     res = sign->update(sign, &g_mockInput);
860 
861     ASSERT_EQ(res, HCF_SUCCESS);
862 
863     res = sign->sign(sign, nullptr, nullptr);
864 
865     ASSERT_EQ(res, HCF_INVALID_PARAMS);
866 
867     HcfObjDestroy(sign);
868 }
869 
870 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest447, TestSize.Level0)
871 {
872     HcfSign *sign = nullptr;
873     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
874 
875     ASSERT_EQ(res, HCF_SUCCESS);
876     ASSERT_NE(sign, nullptr);
877 
878     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
879 
880     ASSERT_EQ(res, HCF_SUCCESS);
881 
882     const char *message = "hello world";
883     HcfBlob input = {
884         .data = (uint8_t *)message,
885         .len = 12
886     };
887     res = sign->update(sign, &input);
888 
889     ASSERT_EQ(res, HCF_SUCCESS);
890 
891     HcfBlob out = { .data = nullptr, .len = 0 };
892     res = sign->sign(sign, nullptr, &out);
893 
894     ASSERT_EQ(res, HCF_SUCCESS);
895     ASSERT_NE(out.data, nullptr);
896     ASSERT_NE(out.len, (const unsigned int)0);
897 
898     res = sign->update(sign, &input);
899 
900     ASSERT_EQ(res, HCF_SUCCESS);
901 
902     HcfBlob out2 = { .data = nullptr, .len = 0 };
903     res = sign->sign(sign, nullptr, &out2);
904 
905     HcfVerify *verify = nullptr;
906     res = HcfVerifyCreate("ECC256|SHA256", &verify);
907     ASSERT_EQ(res, HCF_SUCCESS);
908     ASSERT_NE(verify, nullptr);
909 
910     verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
911     ASSERT_EQ(res, HCF_SUCCESS);
912 
913     verify->update(verify, &input);
914     ASSERT_EQ(res, HCF_SUCCESS);
915 
916     bool flag = verify->verify(verify, nullptr, &out);
917     ASSERT_EQ(flag, true);
918 
919     verify->update(verify, &input);
920     ASSERT_EQ(res, HCF_SUCCESS);
921 
922     flag = verify->verify(verify, nullptr, &out2);
923     ASSERT_EQ(flag, true);
924 
925     HcfFree(out.data);
926     HcfFree(out2.data);
927     HcfObjDestroy(sign);
928     HcfObjDestroy(verify);
929 }
930 
931 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest448, TestSize.Level0)
932 {
933     HcfSign *sign = nullptr;
934     int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
935 
936     ASSERT_EQ(res, HCF_SUCCESS);
937     ASSERT_NE(sign, nullptr);
938 
939     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
940 
941     ASSERT_EQ(res, HCF_SUCCESS);
942 
943     const char *message = "hello world";
944     HcfBlob input = {
945         .data = (uint8_t *)message,
946         .len = 12
947     };
948     res = sign->update(sign, &input);
949 
950     ASSERT_EQ(res, HCF_SUCCESS);
951 
952     res = sign->update(sign, &input);
953 
954     ASSERT_EQ(res, HCF_SUCCESS);
955 
956     HcfBlob out2 = { .data = nullptr, .len = 0 };
957     res = sign->sign(sign, nullptr, &out2);
958 
959     HcfFree(out2.data);
960     HcfObjDestroy(sign);
961 }
962 
963 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest927, TestSize.Level0)
964 {
965     HcfAsyKeyGenerator *generator = nullptr;
966     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
967     ASSERT_EQ(res, HCF_SUCCESS);
968     ASSERT_NE(generator, nullptr);
969 
970     HcfKeyPair *keyPair = nullptr;
971     res = generator->generateKeyPair(generator, nullptr, &keyPair);
972     ASSERT_EQ(res, HCF_SUCCESS);
973     ASSERT_NE(keyPair, nullptr);
974 
975     HcfObjDestroy(generator);
976 
977     HcfSign *sign = nullptr;
978     res = HcfSignCreate("ECC256|SHA256", &sign);
979     ASSERT_EQ(res, HCF_SUCCESS);
980     ASSERT_NE(sign, nullptr);
981 
982     HcfParamsSpec params;
983     res = sign->init(sign, &params, keyPair->priKey);
984     ASSERT_EQ(res, HCF_SUCCESS);
985 
986     const char *message = "hello world";
987     HcfBlob input = {
988         .data = (uint8_t *)message,
989         .len = 12
990     };
991 
992     HcfBlob out = { .data = nullptr, .len = 0 };
993     res = sign->sign(sign, &input, &out);
994     ASSERT_EQ(res, HCF_SUCCESS);
995     ASSERT_NE(out.data, nullptr);
996     ASSERT_NE(out.len, (const unsigned int)0);
997 
998     HcfFree(out.data);
999     HcfObjDestroy(sign);
1000 }
1001 
1002 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest928, TestSize.Level0)
1003 {
1004     HcfAsyKeyGenerator *generator = nullptr;
1005     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1006     ASSERT_EQ(res, HCF_SUCCESS);
1007     ASSERT_NE(generator, nullptr);
1008 
1009     HcfKeyPair *keyPair = nullptr;
1010     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1011     ASSERT_EQ(res, HCF_SUCCESS);
1012     ASSERT_NE(keyPair, nullptr);
1013 
1014     HcfObjDestroy(generator);
1015 
1016     HcfSign *sign = nullptr;
1017     res = HcfSignCreate("ECC224|SHA256", &sign);
1018     ASSERT_EQ(res, HCF_SUCCESS);
1019     ASSERT_NE(sign, nullptr);
1020 
1021     HcfParamsSpec params;
1022     res = sign->init(sign, &params, keyPair->priKey);
1023     ASSERT_EQ(res, HCF_SUCCESS);
1024 
1025     const char *message = "hello world";
1026     HcfBlob input = {
1027         .data = (uint8_t *)message,
1028         .len = 12
1029     };
1030     res = sign->update(sign, &input);
1031     ASSERT_EQ(res, HCF_SUCCESS);
1032 
1033     HcfBlob out = { .data = nullptr, .len = 0 };
1034     res = sign->sign(sign, nullptr, &out);
1035     ASSERT_EQ(res, HCF_SUCCESS);
1036     ASSERT_NE(out.data, nullptr);
1037     ASSERT_NE(out.len, (const unsigned int)0);
1038 
1039     HcfFree(out.data);
1040     HcfObjDestroy(sign);
1041 }
1042 
1043 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1001, TestSize.Level0)
1044 {
1045     HcfSignSpi *spiObj = nullptr;
1046     int32_t res = HcfSignSpiEcdsaCreate(nullptr, &spiObj);
1047 
1048     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1049     ASSERT_EQ(spiObj, nullptr);
1050 }
1051 
1052 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1002, TestSize.Level0)
1053 {
1054     HcfSignatureParams params = {
1055         .algo = HCF_ALG_ECC,
1056         .padding = HCF_ALG_NOPADDING,
1057         .md = HCF_OPENSSL_DIGEST_SHA256,
1058         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1059     };
1060     int32_t res = HcfSignSpiEcdsaCreate(&params, nullptr);
1061 
1062     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1063 }
1064 
1065 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1004, TestSize.Level0)
1066 {
1067     HcfSignatureParams params = {
1068         .algo = HCF_ALG_ECC,
1069         .padding = HCF_ALG_NOPADDING,
1070         .md = HCF_OPENSSL_DIGEST_SHA256,
1071         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1072     };
1073     HcfSignSpi *spiObj = nullptr;
1074     int32_t res = HcfSignSpiEcdsaCreate(&params, &spiObj);
1075 
1076     ASSERT_EQ(res, HCF_SUCCESS);
1077     ASSERT_NE(spiObj, nullptr);
1078 
1079     res = spiObj->engineInit((HcfSignSpi *)&obj, nullptr, ecc256KeyPair_->priKey);
1080     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1081 
1082     HcfObjDestroy(spiObj);
1083 }
1084 
1085 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1005, TestSize.Level0)
1086 {
1087     HcfSignatureParams params = {
1088         .algo = HCF_ALG_ECC,
1089         .padding = HCF_ALG_NOPADDING,
1090         .md = HCF_OPENSSL_DIGEST_SHA256,
1091         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1092     };
1093     HcfSignSpi *spiObj = nullptr;
1094     int32_t res = HcfSignSpiEcdsaCreate(&params, &spiObj);
1095 
1096     ASSERT_EQ(res, HCF_SUCCESS);
1097     ASSERT_NE(spiObj, nullptr);
1098 
1099     res = spiObj->engineInit(spiObj, nullptr, (HcfPriKey *)&obj);
1100     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1101 
1102     HcfObjDestroy(spiObj);
1103 }
1104 
1105 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1006, TestSize.Level0)
1106 {
1107     HcfSignatureParams params = {
1108         .algo = HCF_ALG_ECC,
1109         .padding = HCF_ALG_NOPADDING,
1110         .md = HCF_OPENSSL_DIGEST_SHA256,
1111         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1112     };
1113     HcfSignSpi *spiObj = nullptr;
1114     int32_t res = HcfSignSpiEcdsaCreate(&params, &spiObj);
1115 
1116     ASSERT_EQ(res, HCF_SUCCESS);
1117     ASSERT_NE(spiObj, nullptr);
1118 
1119     const char *message = "hello world";
1120     HcfBlob input = {
1121         .data = (uint8_t *)message,
1122         .len = 12
1123     };
1124     res = spiObj->engineUpdate(nullptr, &input);
1125     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1126 
1127     HcfObjDestroy(spiObj);
1128 }
1129 
1130 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1007, TestSize.Level0)
1131 {
1132     HcfSignatureParams params = {
1133         .algo = HCF_ALG_ECC,
1134         .padding = HCF_ALG_NOPADDING,
1135         .md = HCF_OPENSSL_DIGEST_SHA256,
1136         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1137     };
1138     HcfSignSpi *spiObj = nullptr;
1139     int32_t res = HcfSignSpiEcdsaCreate(&params, &spiObj);
1140 
1141     ASSERT_EQ(res, HCF_SUCCESS);
1142     ASSERT_NE(spiObj, nullptr);
1143 
1144     const char *message = "hello world";
1145     HcfBlob input = {
1146         .data = (uint8_t *)message,
1147         .len = 12
1148     };
1149     res = spiObj->engineUpdate((HcfSignSpi *)&obj, &input);
1150     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1151 
1152     HcfObjDestroy(spiObj);
1153 }
1154 
1155 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1008, TestSize.Level0)
1156 {
1157     HcfSignatureParams params = {
1158         .algo = HCF_ALG_ECC,
1159         .padding = HCF_ALG_NOPADDING,
1160         .md = HCF_OPENSSL_DIGEST_SHA256,
1161         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1162     };
1163     HcfSignSpi *spiObj = nullptr;
1164     int32_t res = HcfSignSpiEcdsaCreate(&params, &spiObj);
1165 
1166     ASSERT_EQ(res, HCF_SUCCESS);
1167     ASSERT_NE(spiObj, nullptr);
1168 
1169     res = spiObj->engineUpdate(spiObj, nullptr);
1170     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1171 
1172     HcfObjDestroy(spiObj);
1173 }
1174 
1175 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1009, TestSize.Level0)
1176 {
1177     HcfSignatureParams params = {
1178         .algo = HCF_ALG_ECC,
1179         .padding = HCF_ALG_NOPADDING,
1180         .md = HCF_OPENSSL_DIGEST_SHA256,
1181         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1182     };
1183     HcfSignSpi *spiObj = nullptr;
1184     int32_t res = HcfSignSpiEcdsaCreate(&params, &spiObj);
1185 
1186     ASSERT_EQ(res, HCF_SUCCESS);
1187     ASSERT_NE(spiObj, nullptr);
1188 
1189     const char *message = "hello world";
1190     HcfBlob input = {
1191         .data = (uint8_t *)message,
1192         .len = 12
1193     };
1194     HcfBlob out = { .data = nullptr, .len = 0 };
1195     res = spiObj->engineSign((HcfSignSpi *)&obj, &input, &out);
1196     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1197 
1198     HcfObjDestroy(spiObj);
1199 }
1200 
1201 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1010, TestSize.Level0)
1202 {
1203     HcfSignatureParams params = {
1204         .algo = HCF_ALG_ECC,
1205         .padding = HCF_ALG_NOPADDING,
1206         .md = HCF_OPENSSL_DIGEST_SHA256,
1207         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1208     };
1209     HcfSignSpi *spiObj = nullptr;
1210     int32_t res = HcfSignSpiEcdsaCreate(&params, &spiObj);
1211 
1212     ASSERT_EQ(res, HCF_SUCCESS);
1213     ASSERT_NE(spiObj, nullptr);
1214 
1215     spiObj->base.destroy(nullptr);
1216 
1217     HcfObjDestroy(spiObj);
1218 }
1219 
1220 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1011, TestSize.Level0)
1221 {
1222     HcfSignatureParams params = {
1223         .algo = HCF_ALG_ECC,
1224         .padding = HCF_ALG_NOPADDING,
1225         .md = HCF_OPENSSL_DIGEST_SHA256,
1226         .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1227     };
1228     HcfSignSpi *spiObj = nullptr;
1229     int32_t res = HcfSignSpiEcdsaCreate(&params, &spiObj);
1230 
1231     ASSERT_EQ(res, HCF_SUCCESS);
1232     ASSERT_NE(spiObj, nullptr);
1233 
1234     spiObj->base.destroy(&obj);
1235 
1236     HcfObjDestroy(spiObj);
1237 }
1238 
MemoryMallocTestFunc(uint32_t mallocCount,HcfBlob * input)1239 static void MemoryMallocTestFunc(uint32_t mallocCount, HcfBlob *input)
1240 {
1241     for (uint32_t i = 0; i < mallocCount; i++) {
1242         ResetRecordMallocNum();
1243         SetMockMallocIndex(i);
1244         HcfAsyKeyGenerator *generator = nullptr;
1245         int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1246         if (res != HCF_SUCCESS) {
1247             continue;
1248         }
1249         HcfKeyPair *keyPair = nullptr;
1250         res = generator->generateKeyPair(generator, nullptr, &keyPair);
1251         HcfObjDestroy(generator);
1252         if (res != HCF_SUCCESS) {
1253             continue;
1254         }
1255         HcfSign *sign = nullptr;
1256         res = HcfSignCreate("ECC224|SHA256", &sign);
1257         if (res != HCF_SUCCESS) {
1258             HcfObjDestroy(keyPair);
1259             continue;
1260         }
1261         res = sign->init(sign, nullptr, keyPair->priKey);
1262         if (res != HCF_SUCCESS) {
1263             HcfObjDestroy(sign);
1264             HcfObjDestroy(keyPair);
1265             continue;
1266         }
1267         res = sign->update(sign, input);
1268         if (res != HCF_SUCCESS) {
1269             HcfObjDestroy(sign);
1270             HcfObjDestroy(keyPair);
1271             continue;
1272         }
1273         HcfBlob out = {
1274             .data = nullptr,
1275             .len = 0
1276         };
1277         res = sign->sign(sign, nullptr, &out);
1278         HcfObjDestroy(sign);
1279         HcfObjDestroy(keyPair);
1280         if (res == HCF_SUCCESS) {
1281             HcfFree(out.data);
1282         }
1283     }
1284 }
1285 
1286 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1101, TestSize.Level0)
1287 {
1288     StartRecordMallocNum();
1289     HcfAsyKeyGenerator *generator = nullptr;
1290     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1291     ASSERT_EQ(res, HCF_SUCCESS);
1292     ASSERT_NE(generator, nullptr);
1293 
1294     HcfKeyPair *keyPair = nullptr;
1295     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1296     ASSERT_EQ(res, HCF_SUCCESS);
1297     ASSERT_NE(keyPair, nullptr);
1298 
1299     HcfObjDestroy(generator);
1300 
1301     HcfSign *sign = nullptr;
1302     res = HcfSignCreate("ECC224|SHA256", &sign);
1303     ASSERT_EQ(res, HCF_SUCCESS);
1304     ASSERT_NE(sign, nullptr);
1305 
1306     HcfParamsSpec params;
1307     res = sign->init(sign, &params, keyPair->priKey);
1308     ASSERT_EQ(res, HCF_SUCCESS);
1309 
1310     const char *message = "hello world";
1311     HcfBlob input = {
1312         .data = (uint8_t *)message,
1313         .len = 12
1314     };
1315     res = sign->update(sign, &input);
1316     ASSERT_EQ(res, HCF_SUCCESS);
1317 
1318     HcfBlob out = { .data = nullptr, .len = 0 };
1319     res = sign->sign(sign, nullptr, &out);
1320     ASSERT_EQ(res, HCF_SUCCESS);
1321     ASSERT_NE(out.data, nullptr);
1322     ASSERT_NE(out.len, (const unsigned int)0);
1323 
1324     HcfFree(out.data);
1325     HcfObjDestroy(sign);
1326 
1327     uint32_t mallocCount = GetMallocNum();
1328     MemoryMallocTestFunc(mallocCount, &input);
1329 
1330     EndRecordMallocNum();
1331 }
1332 
OpensslMockTestFunc(uint32_t mallocCount,HcfBlob * input)1333 static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *input)
1334 {
1335     for (uint32_t i = 0; i < mallocCount; i++) {
1336         ResetOpensslCallNum();
1337         SetOpensslCallMockIndex(i);
1338         HcfAsyKeyGenerator *generator = nullptr;
1339         int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1340         if (res != HCF_SUCCESS) {
1341             continue;
1342         }
1343         HcfKeyPair *keyPair = nullptr;
1344         res = generator->generateKeyPair(generator, nullptr, &keyPair);
1345         HcfObjDestroy(generator);
1346         if (res != HCF_SUCCESS) {
1347             continue;
1348         }
1349         HcfSign *sign = nullptr;
1350         res = HcfSignCreate("ECC224|SHA256", &sign);
1351         if (res != HCF_SUCCESS) {
1352             HcfObjDestroy(keyPair);
1353             continue;
1354         }
1355         res = sign->init(sign, nullptr, keyPair->priKey);
1356         if (res != HCF_SUCCESS) {
1357             HcfObjDestroy(sign);
1358             HcfObjDestroy(keyPair);
1359             continue;
1360         }
1361         res = sign->update(sign, input);
1362         if (res != HCF_SUCCESS) {
1363             HcfObjDestroy(sign);
1364             HcfObjDestroy(keyPair);
1365             continue;
1366         }
1367         HcfBlob out = {
1368             .data = nullptr,
1369             .len = 0
1370         };
1371         res = sign->sign(sign, input, &out);
1372         HcfObjDestroy(sign);
1373         HcfObjDestroy(keyPair);
1374         if (res == HCF_SUCCESS) {
1375             HcfFree(out.data);
1376         }
1377     }
1378 }
1379 
1380 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1102, TestSize.Level0)
1381 {
1382     StartRecordOpensslCallNum();
1383     HcfAsyKeyGenerator *generator = nullptr;
1384     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1385     ASSERT_EQ(res, HCF_SUCCESS);
1386     ASSERT_NE(generator, nullptr);
1387 
1388     HcfKeyPair *keyPair = nullptr;
1389     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1390     ASSERT_EQ(res, HCF_SUCCESS);
1391     ASSERT_NE(keyPair, nullptr);
1392 
1393     HcfObjDestroy(generator);
1394 
1395     HcfSign *sign = nullptr;
1396     res = HcfSignCreate("ECC224|SHA256", &sign);
1397     ASSERT_EQ(res, HCF_SUCCESS);
1398     ASSERT_NE(sign, nullptr);
1399 
1400     HcfParamsSpec params;
1401     res = sign->init(sign, &params, keyPair->priKey);
1402     ASSERT_EQ(res, HCF_SUCCESS);
1403 
1404     const char *message = "hello world";
1405     HcfBlob input = {
1406         .data = (uint8_t *)message,
1407         .len = 12
1408     };
1409     res = sign->update(sign, &input);
1410     ASSERT_EQ(res, HCF_SUCCESS);
1411 
1412     HcfBlob out = { .data = nullptr, .len = 0 };
1413     res = sign->sign(sign, &input, &out);
1414     ASSERT_EQ(res, HCF_SUCCESS);
1415     ASSERT_NE(out.data, nullptr);
1416     ASSERT_NE(out.len, (const unsigned int)0);
1417 
1418     HcfFree(out.data);
1419     HcfObjDestroy(sign);
1420 
1421     uint32_t mallocCount = GetOpensslCallNum();
1422     OpensslMockTestFunc(mallocCount, &input);
1423 
1424     EndRecordOpensslCallNum();
1425 }
1426 }
1427