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(¶ms, 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(¶ms, &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(¶ms, &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(¶ms, &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(¶ms, &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(¶ms, &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(¶ms, &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(¶ms, &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(¶ms, &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(¶ms, &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