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