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 "memory.h"
22 #include "securec.h"
23 #include "signature.h"
24
25 using namespace std;
26 using namespace testing::ext;
27
28 namespace {
29 class CryptoEccVerifyTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 void SetUp();
34 void TearDown();
35
36 static HcfKeyPair *ecc224KeyPair_;
37 static HcfKeyPair *ecc256KeyPair_;
38 static HcfKeyPair *ecc384KeyPair_;
39 static HcfKeyPair *ecc521KeyPair_;
40 };
41
42 HcfKeyPair *CryptoEccVerifyTest::ecc224KeyPair_ = nullptr;
43 HcfKeyPair *CryptoEccVerifyTest::ecc256KeyPair_ = nullptr;
44 HcfKeyPair *CryptoEccVerifyTest::ecc384KeyPair_ = nullptr;
45 HcfKeyPair *CryptoEccVerifyTest::ecc521KeyPair_ = nullptr;
46
47 static const char *g_mockMessage = "hello world";
48 static HcfBlob mockInput = {
49 .data = (uint8_t *)g_mockMessage,
50 .len = 12
51 };
52
SetUp()53 void CryptoEccVerifyTest::SetUp() {}
TearDown()54 void CryptoEccVerifyTest::TearDown() {}
55
SetUpTestCase()56 void CryptoEccVerifyTest::SetUpTestCase()
57 {
58 HcfAsyKeyGenerator *generator = NULL;
59 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
60 ASSERT_EQ(res, HCF_SUCCESS);
61 ASSERT_NE(generator, nullptr);
62
63 HcfKeyPair *keyPair = NULL;
64 res = generator->generateKeyPair(generator, NULL, &keyPair);
65 ASSERT_EQ(res, HCF_SUCCESS);
66 ASSERT_NE(keyPair, nullptr);
67
68 ecc224KeyPair_ = keyPair;
69
70 HcfObjDestroy(generator);
71
72 HcfAsyKeyGenerator *generator2 = NULL;
73 res = HcfAsyKeyGeneratorCreate("ECC256", &generator2);
74 ASSERT_EQ(res, HCF_SUCCESS);
75 ASSERT_NE(generator2, nullptr);
76
77 HcfKeyPair *keyPair2 = NULL;
78 res = generator2->generateKeyPair(generator2, NULL, &keyPair2);
79 ASSERT_EQ(res, HCF_SUCCESS);
80 ASSERT_NE(keyPair2, nullptr);
81
82 ecc256KeyPair_ = keyPair2;
83
84 HcfObjDestroy(generator2);
85
86 HcfAsyKeyGenerator *generator3 = NULL;
87 res = HcfAsyKeyGeneratorCreate("ECC384", &generator3);
88 ASSERT_EQ(res, HCF_SUCCESS);
89 ASSERT_NE(generator3, nullptr);
90
91 HcfKeyPair *keyPair3 = NULL;
92 res = generator3->generateKeyPair(generator3, NULL, &keyPair3);
93 ASSERT_EQ(res, HCF_SUCCESS);
94 ASSERT_NE(keyPair3, nullptr);
95
96 ecc384KeyPair_ = keyPair3;
97
98 HcfObjDestroy(generator3);
99
100 HcfAsyKeyGenerator *generator4 = NULL;
101 res = HcfAsyKeyGeneratorCreate("ECC521", &generator4);
102 ASSERT_EQ(res, HCF_SUCCESS);
103 ASSERT_NE(generator4, nullptr);
104
105 HcfKeyPair *keyPair4 = NULL;
106 res = generator4->generateKeyPair(generator4, NULL, &keyPair4);
107 ASSERT_EQ(res, HCF_SUCCESS);
108 ASSERT_NE(keyPair4, nullptr);
109
110 ecc521KeyPair_ = keyPair4;
111
112 HcfObjDestroy(generator4);
113 }
114
TearDownTestCase()115 void CryptoEccVerifyTest::TearDownTestCase()
116 {
117 HcfObjDestroy(ecc224KeyPair_);
118 HcfObjDestroy(ecc256KeyPair_);
119 HcfObjDestroy(ecc384KeyPair_);
120 HcfObjDestroy(ecc521KeyPair_);
121 }
122
GetMockClass(void)123 static const char *GetMockClass(void)
124 {
125 return "HcfMock";
126 }
127
128 static HcfObjectBase obj = {
129 .getClass = GetMockClass,
130 .destroy = NULL
131 };
132
133 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest001, TestSize.Level0)
134 {
135 HcfVerify *verify = NULL;
136 int32_t res = HcfVerifyCreate("ECC224|SHA1", &verify);
137
138 ASSERT_EQ(res, HCF_SUCCESS);
139 ASSERT_NE(verify, nullptr);
140
141 HcfObjDestroy(verify);
142 }
143
144 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest002, TestSize.Level0)
145 {
146 HcfVerify *verify = NULL;
147 int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify);
148
149 ASSERT_EQ(res, HCF_SUCCESS);
150 ASSERT_NE(verify, nullptr);
151
152 HcfObjDestroy(verify);
153 }
154
155 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest003, TestSize.Level0)
156 {
157 HcfVerify *verify = NULL;
158 int32_t res = HcfVerifyCreate("ECC224|SHA256", &verify);
159
160 ASSERT_EQ(res, HCF_SUCCESS);
161 ASSERT_NE(verify, nullptr);
162
163 HcfObjDestroy(verify);
164 }
165
166 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest004, TestSize.Level0)
167 {
168 HcfVerify *verify = NULL;
169 int32_t res = HcfVerifyCreate("ECC224|SHA384", &verify);
170
171 ASSERT_EQ(res, HCF_SUCCESS);
172 ASSERT_NE(verify, nullptr);
173
174 HcfObjDestroy(verify);
175 }
176
177 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest005, TestSize.Level0)
178 {
179 HcfVerify *verify = NULL;
180 int32_t res = HcfVerifyCreate("ECC224|SHA512", &verify);
181
182 ASSERT_EQ(res, HCF_SUCCESS);
183 ASSERT_NE(verify, nullptr);
184
185 HcfObjDestroy(verify);
186 }
187
188 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest006, TestSize.Level0)
189 {
190 HcfVerify *verify = NULL;
191 int32_t res = HcfVerifyCreate("ECC256|SHA1", &verify);
192
193 ASSERT_EQ(res, HCF_SUCCESS);
194 ASSERT_NE(verify, nullptr);
195
196 HcfObjDestroy(verify);
197 }
198
199 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest007, TestSize.Level0)
200 {
201 HcfVerify *verify = NULL;
202 int32_t res = HcfVerifyCreate("ECC256|SHA224", &verify);
203
204 ASSERT_EQ(res, HCF_SUCCESS);
205 ASSERT_NE(verify, nullptr);
206
207 HcfObjDestroy(verify);
208 }
209
210 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest008, TestSize.Level0)
211 {
212 HcfVerify *verify = NULL;
213 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
214
215 ASSERT_EQ(res, HCF_SUCCESS);
216 ASSERT_NE(verify, nullptr);
217
218 HcfObjDestroy(verify);
219 }
220
221 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest009, TestSize.Level0)
222 {
223 HcfVerify *verify = NULL;
224 int32_t res = HcfVerifyCreate("ECC256|SHA384", &verify);
225
226 ASSERT_EQ(res, HCF_SUCCESS);
227 ASSERT_NE(verify, nullptr);
228
229 HcfObjDestroy(verify);
230 }
231
232 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest010, TestSize.Level0)
233 {
234 HcfVerify *verify = NULL;
235 int32_t res = HcfVerifyCreate("ECC256|SHA512", &verify);
236
237 ASSERT_EQ(res, HCF_SUCCESS);
238 ASSERT_NE(verify, nullptr);
239
240 HcfObjDestroy(verify);
241 }
242
243 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest011, TestSize.Level0)
244 {
245 HcfVerify *verify = NULL;
246 int32_t res = HcfVerifyCreate("ECC384|SHA1", &verify);
247
248 ASSERT_EQ(res, HCF_SUCCESS);
249 ASSERT_NE(verify, nullptr);
250
251 HcfObjDestroy(verify);
252 }
253
254 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest012, TestSize.Level0)
255 {
256 HcfVerify *verify = NULL;
257 int32_t res = HcfVerifyCreate("ECC384|SHA224", &verify);
258
259 ASSERT_EQ(res, HCF_SUCCESS);
260 ASSERT_NE(verify, nullptr);
261
262 HcfObjDestroy(verify);
263 }
264
265 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest013, TestSize.Level0)
266 {
267 HcfVerify *verify = NULL;
268 int32_t res = HcfVerifyCreate("ECC384|SHA256", &verify);
269
270 ASSERT_EQ(res, HCF_SUCCESS);
271 ASSERT_NE(verify, nullptr);
272
273 HcfObjDestroy(verify);
274 }
275
276 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest014, TestSize.Level0)
277 {
278 HcfVerify *verify = NULL;
279 int32_t res = HcfVerifyCreate("ECC384|SHA384", &verify);
280
281 ASSERT_EQ(res, HCF_SUCCESS);
282 ASSERT_NE(verify, nullptr);
283
284 HcfObjDestroy(verify);
285 }
286
287 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest015, TestSize.Level0)
288 {
289 HcfVerify *verify = NULL;
290 int32_t res = HcfVerifyCreate("ECC384|SHA512", &verify);
291
292 ASSERT_EQ(res, HCF_SUCCESS);
293 ASSERT_NE(verify, nullptr);
294
295 HcfObjDestroy(verify);
296 }
297
298 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest016, TestSize.Level0)
299 {
300 HcfVerify *verify = NULL;
301 int32_t res = HcfVerifyCreate("ECC521|SHA1", &verify);
302
303 ASSERT_EQ(res, HCF_SUCCESS);
304 ASSERT_NE(verify, nullptr);
305
306 HcfObjDestroy(verify);
307 }
308
309 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest017, TestSize.Level0)
310 {
311 HcfVerify *verify = NULL;
312 int32_t res = HcfVerifyCreate("ECC521|SHA224", &verify);
313
314 ASSERT_EQ(res, HCF_SUCCESS);
315 ASSERT_NE(verify, nullptr);
316
317 HcfObjDestroy(verify);
318 }
319
320 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest018, TestSize.Level0)
321 {
322 HcfVerify *verify = NULL;
323 int32_t res = HcfVerifyCreate("ECC521|SHA256", &verify);
324
325 ASSERT_EQ(res, HCF_SUCCESS);
326 ASSERT_NE(verify, nullptr);
327
328 HcfObjDestroy(verify);
329 }
330
331 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest019, TestSize.Level0)
332 {
333 HcfVerify *verify = NULL;
334 int32_t res = HcfVerifyCreate("ECC521|SHA384", &verify);
335
336 ASSERT_EQ(res, HCF_SUCCESS);
337 ASSERT_NE(verify, nullptr);
338
339 HcfObjDestroy(verify);
340 }
341
342 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest020, TestSize.Level0)
343 {
344 HcfVerify *verify = NULL;
345 int32_t res = HcfVerifyCreate("ECC521|SHA512", &verify);
346
347 ASSERT_EQ(res, HCF_SUCCESS);
348 ASSERT_NE(verify, nullptr);
349
350 HcfObjDestroy(verify);
351 }
352
353 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest021, TestSize.Level0)
354 {
355 HcfVerify *verify = NULL;
356 int32_t res = HcfVerifyCreate(NULL, &verify);
357
358 ASSERT_EQ(res, HCF_INVALID_PARAMS);
359 ASSERT_EQ(verify, nullptr);
360 }
361
362 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest022, TestSize.Level0)
363 {
364 HcfVerify *verify = NULL;
365 int32_t res = HcfVerifyCreate("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD"
366 "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", &verify);
367
368 ASSERT_EQ(res, HCF_INVALID_PARAMS);
369 ASSERT_EQ(verify, nullptr);
370 }
371
372 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest023, TestSize.Level0)
373 {
374 HcfVerify *verify = NULL;
375 int32_t res = HcfVerifyCreate("ECC257|SHA256", &verify);
376
377 ASSERT_NE(res, HCF_SUCCESS);
378 ASSERT_EQ(verify, nullptr);
379 }
380
381 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest024, TestSize.Level0)
382 {
383 HcfVerify *verify = NULL;
384 int32_t res = HcfVerifyCreate("ECC256|SHA257", &verify);
385
386 ASSERT_NE(res, HCF_SUCCESS);
387 ASSERT_EQ(verify, nullptr);
388 }
389
390 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest025, TestSize.Level0)
391 {
392 HcfVerify *verify = NULL;
393 int32_t res = HcfVerifyCreate("ECC256|MD5", &verify);
394
395 ASSERT_NE(res, HCF_SUCCESS);
396 ASSERT_EQ(verify, nullptr);
397 }
398
399 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest026, TestSize.Level0)
400 {
401 HcfVerify *verify = NULL;
402 int32_t res = HcfVerifyCreate("ECC256SHA256", &verify);
403
404 ASSERT_NE(res, HCF_SUCCESS);
405 ASSERT_EQ(verify, nullptr);
406 }
407
408 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest027, TestSize.Level0)
409 {
410 int32_t res = HcfVerifyCreate("ECC256|SHA256", NULL);
411
412 ASSERT_EQ(res, HCF_INVALID_PARAMS);
413 }
414
415 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest101, TestSize.Level0)
416 {
417 HcfVerify *verify = NULL;
418 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
419
420 ASSERT_EQ(res, HCF_SUCCESS);
421 ASSERT_NE(verify, nullptr);
422
423 const char *className = verify->base.getClass();
424
425 ASSERT_NE(className, nullptr);
426
427 HcfObjDestroy(verify);
428 }
429
430 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest102, TestSize.Level0)
431 {
432 HcfVerify *verify = NULL;
433 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
434
435 ASSERT_EQ(res, HCF_SUCCESS);
436 ASSERT_NE(verify, nullptr);
437
438 verify->base.destroy((HcfObjectBase *)verify);
439 }
440
441 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest103, TestSize.Level0)
442 {
443 HcfVerify *verify = NULL;
444 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
445
446 ASSERT_EQ(res, HCF_SUCCESS);
447 ASSERT_NE(verify, nullptr);
448
449 verify->base.destroy(NULL);
450
451 HcfObjDestroy(verify);
452 }
453
454 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest104, TestSize.Level0)
455 {
456 HcfVerify *verify = NULL;
457 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
458
459 ASSERT_EQ(res, HCF_SUCCESS);
460 ASSERT_NE(verify, nullptr);
461
462 verify->base.destroy(&obj);
463
464 HcfObjDestroy(verify);
465 }
466
467 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest105, TestSize.Level0)
468 {
469 HcfVerify *verify = NULL;
470 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
471
472 ASSERT_EQ(res, HCF_SUCCESS);
473 ASSERT_NE(verify, nullptr);
474
475 const char *algName = verify->getAlgoName(verify);
476
477 ASSERT_NE(algName, nullptr);
478
479 HcfObjDestroy(verify);
480 }
481
482 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest106, TestSize.Level0)
483 {
484 HcfVerify *verify = NULL;
485 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
486
487 ASSERT_EQ(res, HCF_SUCCESS);
488 ASSERT_NE(verify, nullptr);
489
490 const char *algName = verify->getAlgoName(NULL);
491
492 ASSERT_EQ(algName, nullptr);
493
494 HcfObjDestroy(verify);
495 }
496
497 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest107, TestSize.Level0)
498 {
499 HcfVerify *verify = NULL;
500 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
501
502 ASSERT_EQ(res, HCF_SUCCESS);
503 ASSERT_NE(verify, nullptr);
504
505 const char *algName = verify->getAlgoName((HcfVerify *)(&obj));
506
507 ASSERT_EQ(algName, nullptr);
508
509 HcfObjDestroy(verify);
510 }
511
512 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest201, TestSize.Level0)
513 {
514 HcfVerify *verify = NULL;
515 int32_t res = HcfVerifyCreate("ECC224|SHA1", &verify);
516
517 ASSERT_EQ(res, HCF_SUCCESS);
518 ASSERT_NE(verify, nullptr);
519
520 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
521
522 ASSERT_EQ(res, HCF_SUCCESS);
523
524 HcfObjDestroy(verify);
525 }
526
527 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest202, TestSize.Level0)
528 {
529 HcfVerify *verify = NULL;
530 int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify);
531
532 ASSERT_EQ(res, HCF_SUCCESS);
533 ASSERT_NE(verify, nullptr);
534
535 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
536
537 ASSERT_EQ(res, HCF_SUCCESS);
538
539 HcfObjDestroy(verify);
540 }
541
542 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest203, TestSize.Level0)
543 {
544 HcfVerify *verify = NULL;
545 int32_t res = HcfVerifyCreate("ECC224|SHA256", &verify);
546
547 ASSERT_EQ(res, HCF_SUCCESS);
548 ASSERT_NE(verify, nullptr);
549
550 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
551
552 ASSERT_EQ(res, HCF_SUCCESS);
553
554 HcfObjDestroy(verify);
555 }
556
557 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest204, TestSize.Level0)
558 {
559 HcfVerify *verify = NULL;
560 int32_t res = HcfVerifyCreate("ECC224|SHA384", &verify);
561
562 ASSERT_EQ(res, HCF_SUCCESS);
563 ASSERT_NE(verify, nullptr);
564
565 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
566
567 ASSERT_EQ(res, HCF_SUCCESS);
568
569 HcfObjDestroy(verify);
570 }
571
572 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest205, TestSize.Level0)
573 {
574 HcfVerify *verify = NULL;
575 int32_t res = HcfVerifyCreate("ECC224|SHA512", &verify);
576
577 ASSERT_EQ(res, HCF_SUCCESS);
578 ASSERT_NE(verify, nullptr);
579
580 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
581
582 ASSERT_EQ(res, HCF_SUCCESS);
583
584 HcfObjDestroy(verify);
585 }
586
587 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest206, TestSize.Level0)
588 {
589 HcfVerify *verify = NULL;
590 int32_t res = HcfVerifyCreate("ECC256|SHA1", &verify);
591
592 ASSERT_EQ(res, HCF_SUCCESS);
593 ASSERT_NE(verify, nullptr);
594
595 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
596
597 ASSERT_EQ(res, HCF_SUCCESS);
598
599 HcfObjDestroy(verify);
600 }
601
602 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest207, TestSize.Level0)
603 {
604 HcfVerify *verify = NULL;
605 int32_t res = HcfVerifyCreate("ECC256|SHA224", &verify);
606
607 ASSERT_EQ(res, HCF_SUCCESS);
608 ASSERT_NE(verify, nullptr);
609
610 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
611
612 ASSERT_EQ(res, HCF_SUCCESS);
613
614 HcfObjDestroy(verify);
615 }
616
617 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest208, TestSize.Level0)
618 {
619 HcfVerify *verify = NULL;
620 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
621
622 ASSERT_EQ(res, HCF_SUCCESS);
623 ASSERT_NE(verify, nullptr);
624
625 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
626
627 ASSERT_EQ(res, HCF_SUCCESS);
628
629 HcfObjDestroy(verify);
630 }
631
632 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest209, TestSize.Level0)
633 {
634 HcfVerify *verify = NULL;
635 int32_t res = HcfVerifyCreate("ECC256|SHA384", &verify);
636
637 ASSERT_EQ(res, HCF_SUCCESS);
638 ASSERT_NE(verify, nullptr);
639
640 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
641
642 ASSERT_EQ(res, HCF_SUCCESS);
643
644 HcfObjDestroy(verify);
645 }
646
647 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest210, TestSize.Level0)
648 {
649 HcfVerify *verify = NULL;
650 int32_t res = HcfVerifyCreate("ECC256|SHA512", &verify);
651
652 ASSERT_EQ(res, HCF_SUCCESS);
653 ASSERT_NE(verify, nullptr);
654
655 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
656
657 ASSERT_EQ(res, HCF_SUCCESS);
658
659 HcfObjDestroy(verify);
660 }
661
662 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest211, TestSize.Level0)
663 {
664 HcfVerify *verify = NULL;
665 int32_t res = HcfVerifyCreate("ECC384|SHA1", &verify);
666
667 ASSERT_EQ(res, HCF_SUCCESS);
668 ASSERT_NE(verify, nullptr);
669
670 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
671
672 ASSERT_EQ(res, HCF_SUCCESS);
673
674 HcfObjDestroy(verify);
675 }
676
677 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest212, TestSize.Level0)
678 {
679 HcfVerify *verify = NULL;
680 int32_t res = HcfVerifyCreate("ECC384|SHA224", &verify);
681
682 ASSERT_EQ(res, HCF_SUCCESS);
683 ASSERT_NE(verify, nullptr);
684
685 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
686
687 ASSERT_EQ(res, HCF_SUCCESS);
688
689 HcfObjDestroy(verify);
690 }
691
692 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest213, TestSize.Level0)
693 {
694 HcfVerify *verify = NULL;
695 int32_t res = HcfVerifyCreate("ECC384|SHA256", &verify);
696
697 ASSERT_EQ(res, HCF_SUCCESS);
698 ASSERT_NE(verify, nullptr);
699
700 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
701
702 ASSERT_EQ(res, HCF_SUCCESS);
703
704 HcfObjDestroy(verify);
705 }
706
707 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest214, TestSize.Level0)
708 {
709 HcfVerify *verify = NULL;
710 int32_t res = HcfVerifyCreate("ECC384|SHA384", &verify);
711
712 ASSERT_EQ(res, HCF_SUCCESS);
713 ASSERT_NE(verify, nullptr);
714
715 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
716
717 ASSERT_EQ(res, HCF_SUCCESS);
718
719 HcfObjDestroy(verify);
720 }
721
722 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest215, TestSize.Level0)
723 {
724 HcfVerify *verify = NULL;
725 int32_t res = HcfVerifyCreate("ECC384|SHA512", &verify);
726
727 ASSERT_EQ(res, HCF_SUCCESS);
728 ASSERT_NE(verify, nullptr);
729
730 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
731
732 ASSERT_EQ(res, HCF_SUCCESS);
733
734 HcfObjDestroy(verify);
735 }
736
737 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest216, TestSize.Level0)
738 {
739 HcfVerify *verify = NULL;
740 int32_t res = HcfVerifyCreate("ECC521|SHA1", &verify);
741
742 ASSERT_EQ(res, HCF_SUCCESS);
743 ASSERT_NE(verify, nullptr);
744
745 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
746
747 ASSERT_EQ(res, HCF_SUCCESS);
748
749 HcfObjDestroy(verify);
750 }
751
752 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest217, TestSize.Level0)
753 {
754 HcfVerify *verify = NULL;
755 int32_t res = HcfVerifyCreate("ECC521|SHA224", &verify);
756
757 ASSERT_EQ(res, HCF_SUCCESS);
758 ASSERT_NE(verify, nullptr);
759
760 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
761
762 ASSERT_EQ(res, HCF_SUCCESS);
763
764 HcfObjDestroy(verify);
765 }
766
767 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest218, TestSize.Level0)
768 {
769 HcfVerify *verify = NULL;
770 int32_t res = HcfVerifyCreate("ECC521|SHA256", &verify);
771
772 ASSERT_EQ(res, HCF_SUCCESS);
773 ASSERT_NE(verify, nullptr);
774
775 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
776
777 ASSERT_EQ(res, HCF_SUCCESS);
778
779 HcfObjDestroy(verify);
780 }
781
782 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest219, TestSize.Level0)
783 {
784 HcfVerify *verify = NULL;
785 int32_t res = HcfVerifyCreate("ECC521|SHA384", &verify);
786
787 ASSERT_EQ(res, HCF_SUCCESS);
788 ASSERT_NE(verify, nullptr);
789
790 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
791
792 ASSERT_EQ(res, HCF_SUCCESS);
793
794 HcfObjDestroy(verify);
795 }
796
797 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest220, TestSize.Level0)
798 {
799 HcfVerify *verify = NULL;
800 int32_t res = HcfVerifyCreate("ECC521|SHA512", &verify);
801
802 ASSERT_EQ(res, HCF_SUCCESS);
803 ASSERT_NE(verify, nullptr);
804
805 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
806
807 ASSERT_EQ(res, HCF_SUCCESS);
808
809 HcfObjDestroy(verify);
810 }
811
812 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest221, TestSize.Level0)
813 {
814 HcfVerify *verify = NULL;
815 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
816
817 ASSERT_EQ(res, HCF_SUCCESS);
818 ASSERT_NE(verify, nullptr);
819
820 res = verify->init(NULL, NULL, ecc256KeyPair_->pubKey);
821
822 ASSERT_EQ(res, HCF_INVALID_PARAMS);
823
824 HcfObjDestroy(verify);
825 }
826
827 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest222, TestSize.Level0)
828 {
829 HcfVerify *verify = NULL;
830 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
831
832 ASSERT_EQ(res, HCF_SUCCESS);
833 ASSERT_NE(verify, nullptr);
834
835 res = verify->init((HcfVerify *)(&obj), NULL, ecc256KeyPair_->pubKey);
836
837 ASSERT_EQ(res, HCF_INVALID_PARAMS);
838
839 HcfObjDestroy(verify);
840 }
841
842 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest223, TestSize.Level0)
843 {
844 HcfVerify *verify = NULL;
845 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
846
847 ASSERT_EQ(res, HCF_SUCCESS);
848 ASSERT_NE(verify, nullptr);
849
850 res = verify->init(verify, NULL, NULL);
851
852 ASSERT_EQ(res, HCF_INVALID_PARAMS);
853
854 HcfObjDestroy(verify);
855 }
856
857 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest224, TestSize.Level0)
858 {
859 HcfVerify *verify = NULL;
860 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
861
862 ASSERT_EQ(res, HCF_SUCCESS);
863 ASSERT_NE(verify, nullptr);
864
865 res = verify->init(verify, NULL, (HcfPubKey *)(&obj));
866
867 ASSERT_EQ(res, HCF_INVALID_PARAMS);
868
869 HcfObjDestroy(verify);
870 }
871
872 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest301, TestSize.Level0)
873 {
874 HcfVerify *verify = NULL;
875 int32_t res = HcfVerifyCreate("ECC224|SHA1", &verify);
876
877 ASSERT_EQ(res, HCF_SUCCESS);
878 ASSERT_NE(verify, nullptr);
879
880 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
881
882 ASSERT_EQ(res, HCF_SUCCESS);
883
884 res = verify->update(verify, &mockInput);
885
886 ASSERT_EQ(res, HCF_SUCCESS);
887
888 HcfObjDestroy(verify);
889 }
890
891 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest302, TestSize.Level0)
892 {
893 HcfVerify *verify = NULL;
894 int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify);
895
896 ASSERT_EQ(res, HCF_SUCCESS);
897 ASSERT_NE(verify, nullptr);
898
899 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
900
901 ASSERT_EQ(res, HCF_SUCCESS);
902
903 res = verify->update(verify, &mockInput);
904
905 ASSERT_EQ(res, HCF_SUCCESS);
906
907 HcfObjDestroy(verify);
908 }
909
910 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest303, TestSize.Level0)
911 {
912 HcfVerify *verify = NULL;
913 int32_t res = HcfVerifyCreate("ECC224|SHA256", &verify);
914
915 ASSERT_EQ(res, HCF_SUCCESS);
916 ASSERT_NE(verify, nullptr);
917
918 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
919
920 ASSERT_EQ(res, HCF_SUCCESS);
921
922 res = verify->update(verify, &mockInput);
923
924 ASSERT_EQ(res, HCF_SUCCESS);
925
926 HcfObjDestroy(verify);
927 }
928
929 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest304, TestSize.Level0)
930 {
931 HcfVerify *verify = NULL;
932 int32_t res = HcfVerifyCreate("ECC224|SHA384", &verify);
933
934 ASSERT_EQ(res, HCF_SUCCESS);
935 ASSERT_NE(verify, nullptr);
936
937 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
938
939 ASSERT_EQ(res, HCF_SUCCESS);
940
941 res = verify->update(verify, &mockInput);
942
943 ASSERT_EQ(res, HCF_SUCCESS);
944
945 HcfObjDestroy(verify);
946 }
947
948 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest305, TestSize.Level0)
949 {
950 HcfVerify *verify = NULL;
951 int32_t res = HcfVerifyCreate("ECC224|SHA512", &verify);
952
953 ASSERT_EQ(res, HCF_SUCCESS);
954 ASSERT_NE(verify, nullptr);
955
956 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
957
958 ASSERT_EQ(res, HCF_SUCCESS);
959
960 res = verify->update(verify, &mockInput);
961
962 ASSERT_EQ(res, HCF_SUCCESS);
963
964 HcfObjDestroy(verify);
965 }
966
967 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest306, TestSize.Level0)
968 {
969 HcfVerify *verify = NULL;
970 int32_t res = HcfVerifyCreate("ECC256|SHA1", &verify);
971
972 ASSERT_EQ(res, HCF_SUCCESS);
973 ASSERT_NE(verify, nullptr);
974
975 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
976
977 ASSERT_EQ(res, HCF_SUCCESS);
978
979 res = verify->update(verify, &mockInput);
980
981 ASSERT_EQ(res, HCF_SUCCESS);
982
983 HcfObjDestroy(verify);
984 }
985
986 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest307, TestSize.Level0)
987 {
988 HcfVerify *verify = NULL;
989 int32_t res = HcfVerifyCreate("ECC256|SHA224", &verify);
990
991 ASSERT_EQ(res, HCF_SUCCESS);
992 ASSERT_NE(verify, nullptr);
993
994 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
995
996 ASSERT_EQ(res, HCF_SUCCESS);
997
998 res = verify->update(verify, &mockInput);
999
1000 ASSERT_EQ(res, HCF_SUCCESS);
1001
1002 HcfObjDestroy(verify);
1003 }
1004
1005 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest308, TestSize.Level0)
1006 {
1007 HcfVerify *verify = NULL;
1008 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
1009
1010 ASSERT_EQ(res, HCF_SUCCESS);
1011 ASSERT_NE(verify, nullptr);
1012
1013 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
1014
1015 ASSERT_EQ(res, HCF_SUCCESS);
1016
1017 res = verify->update(verify, &mockInput);
1018
1019 ASSERT_EQ(res, HCF_SUCCESS);
1020
1021 HcfObjDestroy(verify);
1022 }
1023
1024 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest309, TestSize.Level0)
1025 {
1026 HcfVerify *verify = NULL;
1027 int32_t res = HcfVerifyCreate("ECC256|SHA384", &verify);
1028
1029 ASSERT_EQ(res, HCF_SUCCESS);
1030 ASSERT_NE(verify, nullptr);
1031
1032 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
1033
1034 ASSERT_EQ(res, HCF_SUCCESS);
1035
1036 res = verify->update(verify, &mockInput);
1037
1038 ASSERT_EQ(res, HCF_SUCCESS);
1039
1040 HcfObjDestroy(verify);
1041 }
1042
1043 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest310, TestSize.Level0)
1044 {
1045 HcfVerify *verify = NULL;
1046 int32_t res = HcfVerifyCreate("ECC256|SHA512", &verify);
1047
1048 ASSERT_EQ(res, HCF_SUCCESS);
1049 ASSERT_NE(verify, nullptr);
1050
1051 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
1052
1053 ASSERT_EQ(res, HCF_SUCCESS);
1054
1055 res = verify->update(verify, &mockInput);
1056
1057 ASSERT_EQ(res, HCF_SUCCESS);
1058
1059 HcfObjDestroy(verify);
1060 }
1061
1062 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest311, TestSize.Level0)
1063 {
1064 HcfVerify *verify = NULL;
1065 int32_t res = HcfVerifyCreate("ECC384|SHA1", &verify);
1066
1067 ASSERT_EQ(res, HCF_SUCCESS);
1068 ASSERT_NE(verify, nullptr);
1069
1070 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
1071
1072 ASSERT_EQ(res, HCF_SUCCESS);
1073
1074 res = verify->update(verify, &mockInput);
1075
1076 ASSERT_EQ(res, HCF_SUCCESS);
1077
1078 HcfObjDestroy(verify);
1079 }
1080
1081 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest312, TestSize.Level0)
1082 {
1083 HcfVerify *verify = NULL;
1084 int32_t res = HcfVerifyCreate("ECC384|SHA224", &verify);
1085
1086 ASSERT_EQ(res, HCF_SUCCESS);
1087 ASSERT_NE(verify, nullptr);
1088
1089 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
1090
1091 ASSERT_EQ(res, HCF_SUCCESS);
1092
1093 res = verify->update(verify, &mockInput);
1094
1095 ASSERT_EQ(res, HCF_SUCCESS);
1096
1097 HcfObjDestroy(verify);
1098 }
1099
1100 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest313, TestSize.Level0)
1101 {
1102 HcfVerify *verify = NULL;
1103 int32_t res = HcfVerifyCreate("ECC384|SHA256", &verify);
1104
1105 ASSERT_EQ(res, HCF_SUCCESS);
1106 ASSERT_NE(verify, nullptr);
1107
1108 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
1109
1110 ASSERT_EQ(res, HCF_SUCCESS);
1111
1112 res = verify->update(verify, &mockInput);
1113
1114 ASSERT_EQ(res, HCF_SUCCESS);
1115
1116 HcfObjDestroy(verify);
1117 }
1118
1119 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest314, TestSize.Level0)
1120 {
1121 HcfVerify *verify = NULL;
1122 int32_t res = HcfVerifyCreate("ECC384|SHA384", &verify);
1123
1124 ASSERT_EQ(res, HCF_SUCCESS);
1125 ASSERT_NE(verify, nullptr);
1126
1127 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
1128
1129 ASSERT_EQ(res, HCF_SUCCESS);
1130
1131 res = verify->update(verify, &mockInput);
1132
1133 ASSERT_EQ(res, HCF_SUCCESS);
1134
1135 HcfObjDestroy(verify);
1136 }
1137
1138 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest315, TestSize.Level0)
1139 {
1140 HcfVerify *verify = NULL;
1141 int32_t res = HcfVerifyCreate("ECC384|SHA512", &verify);
1142
1143 ASSERT_EQ(res, HCF_SUCCESS);
1144 ASSERT_NE(verify, nullptr);
1145
1146 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
1147
1148 ASSERT_EQ(res, HCF_SUCCESS);
1149
1150 res = verify->update(verify, &mockInput);
1151
1152 ASSERT_EQ(res, HCF_SUCCESS);
1153
1154 HcfObjDestroy(verify);
1155 }
1156
1157 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest316, TestSize.Level0)
1158 {
1159 HcfVerify *verify = NULL;
1160 int32_t res = HcfVerifyCreate("ECC521|SHA1", &verify);
1161
1162 ASSERT_EQ(res, HCF_SUCCESS);
1163 ASSERT_NE(verify, nullptr);
1164
1165 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
1166
1167 ASSERT_EQ(res, HCF_SUCCESS);
1168
1169 res = verify->update(verify, &mockInput);
1170
1171 ASSERT_EQ(res, HCF_SUCCESS);
1172
1173 HcfObjDestroy(verify);
1174 }
1175
1176 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest317, TestSize.Level0)
1177 {
1178 HcfVerify *verify = NULL;
1179 int32_t res = HcfVerifyCreate("ECC521|SHA224", &verify);
1180
1181 ASSERT_EQ(res, HCF_SUCCESS);
1182 ASSERT_NE(verify, nullptr);
1183
1184 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
1185
1186 ASSERT_EQ(res, HCF_SUCCESS);
1187
1188 res = verify->update(verify, &mockInput);
1189
1190 ASSERT_EQ(res, HCF_SUCCESS);
1191
1192 HcfObjDestroy(verify);
1193 }
1194
1195 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest318, TestSize.Level0)
1196 {
1197 HcfVerify *verify = NULL;
1198 int32_t res = HcfVerifyCreate("ECC521|SHA256", &verify);
1199
1200 ASSERT_EQ(res, HCF_SUCCESS);
1201 ASSERT_NE(verify, nullptr);
1202
1203 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
1204
1205 ASSERT_EQ(res, HCF_SUCCESS);
1206
1207 res = verify->update(verify, &mockInput);
1208
1209 ASSERT_EQ(res, HCF_SUCCESS);
1210
1211 HcfObjDestroy(verify);
1212 }
1213
1214 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest319, TestSize.Level0)
1215 {
1216 HcfVerify *verify = NULL;
1217 int32_t res = HcfVerifyCreate("ECC521|SHA384", &verify);
1218
1219 ASSERT_EQ(res, HCF_SUCCESS);
1220 ASSERT_NE(verify, nullptr);
1221
1222 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
1223
1224 ASSERT_EQ(res, HCF_SUCCESS);
1225
1226 res = verify->update(verify, &mockInput);
1227
1228 ASSERT_EQ(res, HCF_SUCCESS);
1229
1230 HcfObjDestroy(verify);
1231 }
1232
1233 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest320, TestSize.Level0)
1234 {
1235 HcfVerify *verify = NULL;
1236 int32_t res = HcfVerifyCreate("ECC521|SHA512", &verify);
1237
1238 ASSERT_EQ(res, HCF_SUCCESS);
1239 ASSERT_NE(verify, nullptr);
1240
1241 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
1242
1243 ASSERT_EQ(res, HCF_SUCCESS);
1244
1245 res = verify->update(verify, &mockInput);
1246
1247 ASSERT_EQ(res, HCF_SUCCESS);
1248
1249 HcfObjDestroy(verify);
1250 }
1251
1252 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest321, TestSize.Level0)
1253 {
1254 HcfVerify *verify = NULL;
1255 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
1256
1257 ASSERT_EQ(res, HCF_SUCCESS);
1258 ASSERT_NE(verify, nullptr);
1259
1260 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
1261
1262 ASSERT_EQ(res, HCF_SUCCESS);
1263
1264 res = verify->update(NULL, &mockInput);
1265
1266 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1267
1268 HcfObjDestroy(verify);
1269 }
1270
1271 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest322, TestSize.Level0)
1272 {
1273 HcfVerify *verify = NULL;
1274 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
1275
1276 ASSERT_EQ(res, HCF_SUCCESS);
1277 ASSERT_NE(verify, nullptr);
1278
1279 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
1280
1281 ASSERT_EQ(res, HCF_SUCCESS);
1282
1283 res = verify->update((HcfVerify *)(&obj), &mockInput);
1284
1285 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1286
1287 HcfObjDestroy(verify);
1288 }
1289
1290 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest323, TestSize.Level0)
1291 {
1292 HcfVerify *verify = NULL;
1293 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
1294
1295 ASSERT_EQ(res, HCF_SUCCESS);
1296 ASSERT_NE(verify, nullptr);
1297
1298 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
1299
1300 ASSERT_EQ(res, HCF_SUCCESS);
1301
1302 res = verify->update(verify, NULL);
1303
1304 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1305
1306 HcfObjDestroy(verify);
1307 }
1308
1309 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest324, TestSize.Level0)
1310 {
1311 HcfVerify *verify = NULL;
1312 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
1313
1314 ASSERT_EQ(res, HCF_SUCCESS);
1315 ASSERT_NE(verify, nullptr);
1316
1317 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
1318
1319 ASSERT_EQ(res, HCF_SUCCESS);
1320
1321 HcfBlob input = {
1322 .data = NULL,
1323 .len = 1
1324 };
1325 res = verify->update(verify, &input);
1326
1327 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1328
1329 HcfObjDestroy(verify);
1330 }
1331
1332 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest325, TestSize.Level0)
1333 {
1334 HcfVerify *verify = NULL;
1335 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
1336
1337 ASSERT_EQ(res, HCF_SUCCESS);
1338 ASSERT_NE(verify, nullptr);
1339
1340 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
1341
1342 ASSERT_EQ(res, HCF_SUCCESS);
1343
1344 HcfBlob input = {
1345 .data = (uint8_t *)g_mockMessage,
1346 .len = 0
1347 };
1348 res = verify->update(verify, &input);
1349
1350 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1351
1352 HcfObjDestroy(verify);
1353 }
1354
1355 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest401, TestSize.Level0)
1356 {
1357 HcfSign *sign = NULL;
1358 int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
1359
1360 ASSERT_EQ(res, HCF_SUCCESS);
1361 ASSERT_NE(sign, nullptr);
1362
1363 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
1364
1365 ASSERT_EQ(res, HCF_SUCCESS);
1366
1367 res = sign->update(sign, &mockInput);
1368
1369 ASSERT_EQ(res, HCF_SUCCESS);
1370
1371 HcfBlob out = {
1372 .data = NULL,
1373 .len = 0
1374 };
1375 res = sign->sign(sign, NULL, &out);
1376
1377 ASSERT_EQ(res, HCF_SUCCESS);
1378 ASSERT_NE(out.data, nullptr);
1379 ASSERT_NE(out.len, (const unsigned int)0);
1380
1381 HcfVerify *verify = NULL;
1382 res = HcfVerifyCreate("ECC224|SHA1", &verify);
1383
1384 ASSERT_EQ(res, HCF_SUCCESS);
1385 ASSERT_NE(verify, nullptr);
1386
1387 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
1388
1389 ASSERT_EQ(res, HCF_SUCCESS);
1390
1391 res = verify->update(verify, &mockInput);
1392
1393 ASSERT_EQ(res, HCF_SUCCESS);
1394
1395 bool flag = verify->verify(verify, NULL, &out);
1396
1397 ASSERT_EQ(flag, true);
1398
1399 free(out.data);
1400 HcfObjDestroy(sign);
1401 HcfObjDestroy(verify);
1402 }
1403
1404 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest402, TestSize.Level0)
1405 {
1406 HcfSign *sign = NULL;
1407 int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
1408
1409 ASSERT_EQ(res, HCF_SUCCESS);
1410 ASSERT_NE(sign, nullptr);
1411
1412 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
1413
1414 ASSERT_EQ(res, HCF_SUCCESS);
1415
1416 res = sign->update(sign, &mockInput);
1417
1418 ASSERT_EQ(res, HCF_SUCCESS);
1419
1420 HcfBlob out = {
1421 .data = NULL,
1422 .len = 0
1423 };
1424 res = sign->sign(sign, NULL, &out);
1425
1426 ASSERT_EQ(res, HCF_SUCCESS);
1427 ASSERT_NE(out.data, nullptr);
1428 ASSERT_NE(out.len, (const unsigned int)0);
1429
1430 HcfVerify *verify = NULL;
1431 res = HcfVerifyCreate("ECC224|SHA224", &verify);
1432
1433 ASSERT_EQ(res, HCF_SUCCESS);
1434 ASSERT_NE(verify, nullptr);
1435
1436 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
1437
1438 ASSERT_EQ(res, HCF_SUCCESS);
1439
1440 res = verify->update(verify, &mockInput);
1441
1442 ASSERT_EQ(res, HCF_SUCCESS);
1443
1444 bool flag = verify->verify(verify, NULL, &out);
1445
1446 ASSERT_EQ(flag, true);
1447
1448 free(out.data);
1449 HcfObjDestroy(sign);
1450 HcfObjDestroy(verify);
1451 }
1452
1453 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest403, TestSize.Level0)
1454 {
1455 HcfSign *sign = NULL;
1456 int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
1457
1458 ASSERT_EQ(res, HCF_SUCCESS);
1459 ASSERT_NE(sign, nullptr);
1460
1461 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
1462
1463 ASSERT_EQ(res, HCF_SUCCESS);
1464
1465 res = sign->update(sign, &mockInput);
1466
1467 ASSERT_EQ(res, HCF_SUCCESS);
1468
1469 HcfBlob out = {
1470 .data = NULL,
1471 .len = 0
1472 };
1473 res = sign->sign(sign, NULL, &out);
1474
1475 ASSERT_EQ(res, HCF_SUCCESS);
1476 ASSERT_NE(out.data, nullptr);
1477 ASSERT_NE(out.len, (const unsigned int)0);
1478
1479 HcfVerify *verify = NULL;
1480 res = HcfVerifyCreate("ECC224|SHA256", &verify);
1481
1482 ASSERT_EQ(res, HCF_SUCCESS);
1483 ASSERT_NE(verify, nullptr);
1484
1485 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
1486
1487 ASSERT_EQ(res, HCF_SUCCESS);
1488
1489 res = verify->update(verify, &mockInput);
1490
1491 ASSERT_EQ(res, HCF_SUCCESS);
1492
1493 bool flag = verify->verify(verify, NULL, &out);
1494
1495 ASSERT_EQ(flag, true);
1496
1497 free(out.data);
1498 HcfObjDestroy(sign);
1499 HcfObjDestroy(verify);
1500 }
1501
1502 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest404, TestSize.Level0)
1503 {
1504 HcfSign *sign = NULL;
1505 int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
1506
1507 ASSERT_EQ(res, HCF_SUCCESS);
1508 ASSERT_NE(sign, nullptr);
1509
1510 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
1511
1512 ASSERT_EQ(res, HCF_SUCCESS);
1513
1514 res = sign->update(sign, &mockInput);
1515
1516 ASSERT_EQ(res, HCF_SUCCESS);
1517
1518 HcfBlob out = {
1519 .data = NULL,
1520 .len = 0
1521 };
1522 res = sign->sign(sign, NULL, &out);
1523
1524 ASSERT_EQ(res, HCF_SUCCESS);
1525 ASSERT_NE(out.data, nullptr);
1526 ASSERT_NE(out.len, (const unsigned int)0);
1527
1528 HcfVerify *verify = NULL;
1529 res = HcfVerifyCreate("ECC224|SHA384", &verify);
1530
1531 ASSERT_EQ(res, HCF_SUCCESS);
1532 ASSERT_NE(verify, nullptr);
1533
1534 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
1535
1536 ASSERT_EQ(res, HCF_SUCCESS);
1537
1538 res = verify->update(verify, &mockInput);
1539
1540 ASSERT_EQ(res, HCF_SUCCESS);
1541
1542 bool flag = verify->verify(verify, NULL, &out);
1543
1544 ASSERT_EQ(flag, true);
1545
1546 free(out.data);
1547 HcfObjDestroy(sign);
1548 HcfObjDestroy(verify);
1549 }
1550
1551 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest405, TestSize.Level0)
1552 {
1553 HcfSign *sign = NULL;
1554 int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
1555
1556 ASSERT_EQ(res, HCF_SUCCESS);
1557 ASSERT_NE(sign, nullptr);
1558
1559 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
1560
1561 ASSERT_EQ(res, HCF_SUCCESS);
1562
1563 res = sign->update(sign, &mockInput);
1564
1565 ASSERT_EQ(res, HCF_SUCCESS);
1566
1567 HcfBlob out = {
1568 .data = NULL,
1569 .len = 0
1570 };
1571 res = sign->sign(sign, NULL, &out);
1572
1573 ASSERT_EQ(res, HCF_SUCCESS);
1574 ASSERT_NE(out.data, nullptr);
1575 ASSERT_NE(out.len, (const unsigned int)0);
1576
1577 HcfVerify *verify = NULL;
1578 res = HcfVerifyCreate("ECC224|SHA512", &verify);
1579
1580 ASSERT_EQ(res, HCF_SUCCESS);
1581 ASSERT_NE(verify, nullptr);
1582
1583 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
1584
1585 ASSERT_EQ(res, HCF_SUCCESS);
1586
1587 res = verify->update(verify, &mockInput);
1588
1589 ASSERT_EQ(res, HCF_SUCCESS);
1590
1591 bool flag = verify->verify(verify, NULL, &out);
1592
1593 ASSERT_EQ(flag, true);
1594
1595 free(out.data);
1596 HcfObjDestroy(sign);
1597 HcfObjDestroy(verify);
1598 }
1599
1600 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest406, TestSize.Level0)
1601 {
1602 HcfSign *sign = NULL;
1603 int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
1604
1605 ASSERT_EQ(res, HCF_SUCCESS);
1606 ASSERT_NE(sign, nullptr);
1607
1608 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1609
1610 ASSERT_EQ(res, HCF_SUCCESS);
1611
1612 res = sign->update(sign, &mockInput);
1613
1614 ASSERT_EQ(res, HCF_SUCCESS);
1615
1616 HcfBlob out = {
1617 .data = NULL,
1618 .len = 0
1619 };
1620 res = sign->sign(sign, NULL, &out);
1621
1622 ASSERT_EQ(res, HCF_SUCCESS);
1623 ASSERT_NE(out.data, nullptr);
1624 ASSERT_NE(out.len, (const unsigned int)0);
1625
1626 HcfVerify *verify = NULL;
1627 res = HcfVerifyCreate("ECC256|SHA1", &verify);
1628
1629 ASSERT_EQ(res, HCF_SUCCESS);
1630 ASSERT_NE(verify, nullptr);
1631
1632 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
1633
1634 ASSERT_EQ(res, HCF_SUCCESS);
1635
1636 res = verify->update(verify, &mockInput);
1637
1638 ASSERT_EQ(res, HCF_SUCCESS);
1639
1640 bool flag = verify->verify(verify, NULL, &out);
1641
1642 ASSERT_EQ(flag, true);
1643
1644 free(out.data);
1645 HcfObjDestroy(sign);
1646 HcfObjDestroy(verify);
1647 }
1648
1649 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest407, TestSize.Level0)
1650 {
1651 HcfSign *sign = NULL;
1652 int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
1653
1654 ASSERT_EQ(res, HCF_SUCCESS);
1655 ASSERT_NE(sign, nullptr);
1656
1657 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1658
1659 ASSERT_EQ(res, HCF_SUCCESS);
1660
1661 res = sign->update(sign, &mockInput);
1662
1663 ASSERT_EQ(res, HCF_SUCCESS);
1664
1665 HcfBlob out = {
1666 .data = NULL,
1667 .len = 0
1668 };
1669 res = sign->sign(sign, NULL, &out);
1670
1671 ASSERT_EQ(res, HCF_SUCCESS);
1672 ASSERT_NE(out.data, nullptr);
1673 ASSERT_NE(out.len, (const unsigned int)0);
1674
1675 HcfVerify *verify = NULL;
1676 res = HcfVerifyCreate("ECC256|SHA224", &verify);
1677
1678 ASSERT_EQ(res, HCF_SUCCESS);
1679 ASSERT_NE(verify, nullptr);
1680
1681 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
1682
1683 ASSERT_EQ(res, HCF_SUCCESS);
1684
1685 res = verify->update(verify, &mockInput);
1686
1687 ASSERT_EQ(res, HCF_SUCCESS);
1688
1689 bool flag = verify->verify(verify, NULL, &out);
1690
1691 ASSERT_EQ(flag, true);
1692
1693 free(out.data);
1694 HcfObjDestroy(sign);
1695 HcfObjDestroy(verify);
1696 }
1697
1698 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest408, TestSize.Level0)
1699 {
1700 HcfSign *sign = NULL;
1701 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1702
1703 ASSERT_EQ(res, HCF_SUCCESS);
1704 ASSERT_NE(sign, nullptr);
1705
1706 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1707
1708 ASSERT_EQ(res, HCF_SUCCESS);
1709
1710 res = sign->update(sign, &mockInput);
1711
1712 ASSERT_EQ(res, HCF_SUCCESS);
1713
1714 HcfBlob out = {
1715 .data = NULL,
1716 .len = 0
1717 };
1718 res = sign->sign(sign, NULL, &out);
1719
1720 ASSERT_EQ(res, HCF_SUCCESS);
1721 ASSERT_NE(out.data, nullptr);
1722 ASSERT_NE(out.len, (const unsigned int)0);
1723
1724 HcfVerify *verify = NULL;
1725 res = HcfVerifyCreate("ECC256|SHA256", &verify);
1726
1727 ASSERT_EQ(res, HCF_SUCCESS);
1728 ASSERT_NE(verify, nullptr);
1729
1730 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
1731
1732 ASSERT_EQ(res, HCF_SUCCESS);
1733
1734 res = verify->update(verify, &mockInput);
1735
1736 ASSERT_EQ(res, HCF_SUCCESS);
1737
1738 bool flag = verify->verify(verify, NULL, &out);
1739
1740 ASSERT_EQ(flag, true);
1741
1742 free(out.data);
1743 HcfObjDestroy(sign);
1744 HcfObjDestroy(verify);
1745 }
1746
1747 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest409, TestSize.Level0)
1748 {
1749 HcfSign *sign = NULL;
1750 int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
1751
1752 ASSERT_EQ(res, HCF_SUCCESS);
1753 ASSERT_NE(sign, nullptr);
1754
1755 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1756
1757 ASSERT_EQ(res, HCF_SUCCESS);
1758
1759 res = sign->update(sign, &mockInput);
1760
1761 ASSERT_EQ(res, HCF_SUCCESS);
1762
1763 HcfBlob out = {
1764 .data = NULL,
1765 .len = 0
1766 };
1767 res = sign->sign(sign, NULL, &out);
1768
1769 ASSERT_EQ(res, HCF_SUCCESS);
1770 ASSERT_NE(out.data, nullptr);
1771 ASSERT_NE(out.len, (const unsigned int)0);
1772
1773 HcfVerify *verify = NULL;
1774 res = HcfVerifyCreate("ECC256|SHA384", &verify);
1775
1776 ASSERT_EQ(res, HCF_SUCCESS);
1777 ASSERT_NE(verify, nullptr);
1778
1779 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
1780
1781 ASSERT_EQ(res, HCF_SUCCESS);
1782
1783 res = verify->update(verify, &mockInput);
1784
1785 ASSERT_EQ(res, HCF_SUCCESS);
1786
1787 bool flag = verify->verify(verify, NULL, &out);
1788
1789 ASSERT_EQ(flag, true);
1790
1791 free(out.data);
1792 HcfObjDestroy(sign);
1793 HcfObjDestroy(verify);
1794 }
1795
1796 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest410, TestSize.Level0)
1797 {
1798 HcfSign *sign = NULL;
1799 int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
1800
1801 ASSERT_EQ(res, HCF_SUCCESS);
1802 ASSERT_NE(sign, nullptr);
1803
1804 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1805
1806 ASSERT_EQ(res, HCF_SUCCESS);
1807
1808 res = sign->update(sign, &mockInput);
1809
1810 ASSERT_EQ(res, HCF_SUCCESS);
1811
1812 HcfBlob out = {
1813 .data = NULL,
1814 .len = 0
1815 };
1816 res = sign->sign(sign, NULL, &out);
1817
1818 ASSERT_EQ(res, HCF_SUCCESS);
1819 ASSERT_NE(out.data, nullptr);
1820 ASSERT_NE(out.len, (const unsigned int)0);
1821
1822 HcfVerify *verify = NULL;
1823 res = HcfVerifyCreate("ECC256|SHA512", &verify);
1824
1825 ASSERT_EQ(res, HCF_SUCCESS);
1826 ASSERT_NE(verify, nullptr);
1827
1828 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
1829
1830 ASSERT_EQ(res, HCF_SUCCESS);
1831
1832 res = verify->update(verify, &mockInput);
1833
1834 ASSERT_EQ(res, HCF_SUCCESS);
1835
1836 bool flag = verify->verify(verify, NULL, &out);
1837
1838 ASSERT_EQ(flag, true);
1839
1840 free(out.data);
1841 HcfObjDestroy(sign);
1842 HcfObjDestroy(verify);
1843 }
1844
1845 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest411, TestSize.Level0)
1846 {
1847 HcfSign *sign = NULL;
1848 int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
1849
1850 ASSERT_EQ(res, HCF_SUCCESS);
1851 ASSERT_NE(sign, nullptr);
1852
1853 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
1854
1855 ASSERT_EQ(res, HCF_SUCCESS);
1856
1857 res = sign->update(sign, &mockInput);
1858
1859 ASSERT_EQ(res, HCF_SUCCESS);
1860
1861 HcfBlob out = {
1862 .data = NULL,
1863 .len = 0
1864 };
1865 res = sign->sign(sign, NULL, &out);
1866
1867 ASSERT_EQ(res, HCF_SUCCESS);
1868 ASSERT_NE(out.data, nullptr);
1869 ASSERT_NE(out.len, (const unsigned int)0);
1870
1871 HcfVerify *verify = NULL;
1872 res = HcfVerifyCreate("ECC384|SHA1", &verify);
1873
1874 ASSERT_EQ(res, HCF_SUCCESS);
1875 ASSERT_NE(verify, nullptr);
1876
1877 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
1878
1879 ASSERT_EQ(res, HCF_SUCCESS);
1880
1881 res = verify->update(verify, &mockInput);
1882
1883 ASSERT_EQ(res, HCF_SUCCESS);
1884
1885 bool flag = verify->verify(verify, NULL, &out);
1886
1887 ASSERT_EQ(flag, true);
1888
1889 free(out.data);
1890 HcfObjDestroy(sign);
1891 HcfObjDestroy(verify);
1892 }
1893
1894 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest412, TestSize.Level0)
1895 {
1896 HcfSign *sign = NULL;
1897 int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
1898
1899 ASSERT_EQ(res, HCF_SUCCESS);
1900 ASSERT_NE(sign, nullptr);
1901
1902 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
1903
1904 ASSERT_EQ(res, HCF_SUCCESS);
1905
1906 res = sign->update(sign, &mockInput);
1907
1908 ASSERT_EQ(res, HCF_SUCCESS);
1909
1910 HcfBlob out = {
1911 .data = NULL,
1912 .len = 0
1913 };
1914 res = sign->sign(sign, NULL, &out);
1915
1916 ASSERT_EQ(res, HCF_SUCCESS);
1917 ASSERT_NE(out.data, nullptr);
1918 ASSERT_NE(out.len, (const unsigned int)0);
1919
1920 HcfVerify *verify = NULL;
1921 res = HcfVerifyCreate("ECC384|SHA224", &verify);
1922
1923 ASSERT_EQ(res, HCF_SUCCESS);
1924 ASSERT_NE(verify, nullptr);
1925
1926 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
1927
1928 ASSERT_EQ(res, HCF_SUCCESS);
1929
1930 res = verify->update(verify, &mockInput);
1931
1932 ASSERT_EQ(res, HCF_SUCCESS);
1933
1934 bool flag = verify->verify(verify, NULL, &out);
1935
1936 ASSERT_EQ(flag, true);
1937
1938 free(out.data);
1939 HcfObjDestroy(sign);
1940 HcfObjDestroy(verify);
1941 }
1942
1943 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest413, TestSize.Level0)
1944 {
1945 HcfSign *sign = NULL;
1946 int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
1947
1948 ASSERT_EQ(res, HCF_SUCCESS);
1949 ASSERT_NE(sign, nullptr);
1950
1951 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
1952
1953 ASSERT_EQ(res, HCF_SUCCESS);
1954
1955 res = sign->update(sign, &mockInput);
1956
1957 ASSERT_EQ(res, HCF_SUCCESS);
1958
1959 HcfBlob out = {
1960 .data = NULL,
1961 .len = 0
1962 };
1963 res = sign->sign(sign, NULL, &out);
1964
1965 ASSERT_EQ(res, HCF_SUCCESS);
1966 ASSERT_NE(out.data, nullptr);
1967 ASSERT_NE(out.len, (const unsigned int)0);
1968
1969 HcfVerify *verify = NULL;
1970 res = HcfVerifyCreate("ECC384|SHA256", &verify);
1971
1972 ASSERT_EQ(res, HCF_SUCCESS);
1973 ASSERT_NE(verify, nullptr);
1974
1975 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
1976
1977 ASSERT_EQ(res, HCF_SUCCESS);
1978
1979 res = verify->update(verify, &mockInput);
1980
1981 ASSERT_EQ(res, HCF_SUCCESS);
1982
1983 bool flag = verify->verify(verify, NULL, &out);
1984
1985 ASSERT_EQ(flag, true);
1986
1987 free(out.data);
1988 HcfObjDestroy(sign);
1989 HcfObjDestroy(verify);
1990 }
1991
1992 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest414, TestSize.Level0)
1993 {
1994 HcfSign *sign = NULL;
1995 int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
1996
1997 ASSERT_EQ(res, HCF_SUCCESS);
1998 ASSERT_NE(sign, nullptr);
1999
2000 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
2001
2002 ASSERT_EQ(res, HCF_SUCCESS);
2003
2004 res = sign->update(sign, &mockInput);
2005
2006 ASSERT_EQ(res, HCF_SUCCESS);
2007
2008 HcfBlob out = {
2009 .data = NULL,
2010 .len = 0
2011 };
2012 res = sign->sign(sign, NULL, &out);
2013
2014 ASSERT_EQ(res, HCF_SUCCESS);
2015 ASSERT_NE(out.data, nullptr);
2016 ASSERT_NE(out.len, (const unsigned int)0);
2017
2018 HcfVerify *verify = NULL;
2019 res = HcfVerifyCreate("ECC384|SHA384", &verify);
2020
2021 ASSERT_EQ(res, HCF_SUCCESS);
2022 ASSERT_NE(verify, nullptr);
2023
2024 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
2025
2026 ASSERT_EQ(res, HCF_SUCCESS);
2027
2028 res = verify->update(verify, &mockInput);
2029
2030 ASSERT_EQ(res, HCF_SUCCESS);
2031
2032 bool flag = verify->verify(verify, NULL, &out);
2033
2034 ASSERT_EQ(flag, true);
2035
2036 free(out.data);
2037 HcfObjDestroy(sign);
2038 HcfObjDestroy(verify);
2039 }
2040
2041 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest415, TestSize.Level0)
2042 {
2043 HcfSign *sign = NULL;
2044 int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
2045
2046 ASSERT_EQ(res, HCF_SUCCESS);
2047 ASSERT_NE(sign, nullptr);
2048
2049 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
2050
2051 ASSERT_EQ(res, HCF_SUCCESS);
2052
2053 res = sign->update(sign, &mockInput);
2054
2055 ASSERT_EQ(res, HCF_SUCCESS);
2056
2057 HcfBlob out = {
2058 .data = NULL,
2059 .len = 0
2060 };
2061 res = sign->sign(sign, NULL, &out);
2062
2063 ASSERT_EQ(res, HCF_SUCCESS);
2064 ASSERT_NE(out.data, nullptr);
2065 ASSERT_NE(out.len, (const unsigned int)0);
2066
2067 HcfVerify *verify = NULL;
2068 res = HcfVerifyCreate("ECC384|SHA512", &verify);
2069
2070 ASSERT_EQ(res, HCF_SUCCESS);
2071 ASSERT_NE(verify, nullptr);
2072
2073 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
2074
2075 ASSERT_EQ(res, HCF_SUCCESS);
2076
2077 res = verify->update(verify, &mockInput);
2078
2079 ASSERT_EQ(res, HCF_SUCCESS);
2080
2081 bool flag = verify->verify(verify, NULL, &out);
2082
2083 ASSERT_EQ(flag, true);
2084
2085 free(out.data);
2086 HcfObjDestroy(sign);
2087 HcfObjDestroy(verify);
2088 }
2089
2090 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest416, TestSize.Level0)
2091 {
2092 HcfSign *sign = NULL;
2093 int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
2094
2095 ASSERT_EQ(res, HCF_SUCCESS);
2096 ASSERT_NE(sign, nullptr);
2097
2098 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
2099
2100 ASSERT_EQ(res, HCF_SUCCESS);
2101
2102 res = sign->update(sign, &mockInput);
2103
2104 ASSERT_EQ(res, HCF_SUCCESS);
2105
2106 HcfBlob out = {
2107 .data = NULL,
2108 .len = 0
2109 };
2110 res = sign->sign(sign, NULL, &out);
2111
2112 ASSERT_EQ(res, HCF_SUCCESS);
2113 ASSERT_NE(out.data, nullptr);
2114 ASSERT_NE(out.len, (const unsigned int)0);
2115
2116 HcfVerify *verify = NULL;
2117 res = HcfVerifyCreate("ECC521|SHA1", &verify);
2118
2119 ASSERT_EQ(res, HCF_SUCCESS);
2120 ASSERT_NE(verify, nullptr);
2121
2122 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
2123
2124 ASSERT_EQ(res, HCF_SUCCESS);
2125
2126 res = verify->update(verify, &mockInput);
2127
2128 ASSERT_EQ(res, HCF_SUCCESS);
2129
2130 bool flag = verify->verify(verify, NULL, &out);
2131
2132 ASSERT_EQ(flag, true);
2133
2134 free(out.data);
2135 HcfObjDestroy(sign);
2136 HcfObjDestroy(verify);
2137 }
2138
2139 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest417, TestSize.Level0)
2140 {
2141 HcfSign *sign = NULL;
2142 int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
2143
2144 ASSERT_EQ(res, HCF_SUCCESS);
2145 ASSERT_NE(sign, nullptr);
2146
2147 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
2148
2149 ASSERT_EQ(res, HCF_SUCCESS);
2150
2151 res = sign->update(sign, &mockInput);
2152
2153 ASSERT_EQ(res, HCF_SUCCESS);
2154
2155 HcfBlob out = {
2156 .data = NULL,
2157 .len = 0
2158 };
2159 res = sign->sign(sign, NULL, &out);
2160
2161 ASSERT_EQ(res, HCF_SUCCESS);
2162 ASSERT_NE(out.data, nullptr);
2163 ASSERT_NE(out.len, (const unsigned int)0);
2164
2165 HcfVerify *verify = NULL;
2166 res = HcfVerifyCreate("ECC521|SHA224", &verify);
2167
2168 ASSERT_EQ(res, HCF_SUCCESS);
2169 ASSERT_NE(verify, nullptr);
2170
2171 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
2172
2173 ASSERT_EQ(res, HCF_SUCCESS);
2174
2175 res = verify->update(verify, &mockInput);
2176
2177 ASSERT_EQ(res, HCF_SUCCESS);
2178
2179 bool flag = verify->verify(verify, NULL, &out);
2180
2181 ASSERT_EQ(flag, true);
2182
2183 free(out.data);
2184 HcfObjDestroy(sign);
2185 HcfObjDestroy(verify);
2186 }
2187
2188 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest418, TestSize.Level0)
2189 {
2190 HcfSign *sign = NULL;
2191 int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
2192
2193 ASSERT_EQ(res, HCF_SUCCESS);
2194 ASSERT_NE(sign, nullptr);
2195
2196 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
2197
2198 ASSERT_EQ(res, HCF_SUCCESS);
2199
2200 res = sign->update(sign, &mockInput);
2201
2202 ASSERT_EQ(res, HCF_SUCCESS);
2203
2204 HcfBlob out = {
2205 .data = NULL,
2206 .len = 0
2207 };
2208 res = sign->sign(sign, NULL, &out);
2209
2210 ASSERT_EQ(res, HCF_SUCCESS);
2211 ASSERT_NE(out.data, nullptr);
2212 ASSERT_NE(out.len, (const unsigned int)0);
2213
2214 HcfVerify *verify = NULL;
2215 res = HcfVerifyCreate("ECC521|SHA256", &verify);
2216
2217 ASSERT_EQ(res, HCF_SUCCESS);
2218 ASSERT_NE(verify, nullptr);
2219
2220 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
2221
2222 ASSERT_EQ(res, HCF_SUCCESS);
2223
2224 res = verify->update(verify, &mockInput);
2225
2226 ASSERT_EQ(res, HCF_SUCCESS);
2227
2228 bool flag = verify->verify(verify, NULL, &out);
2229
2230 ASSERT_EQ(flag, true);
2231
2232 free(out.data);
2233 HcfObjDestroy(sign);
2234 HcfObjDestroy(verify);
2235 }
2236
2237 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest419, TestSize.Level0)
2238 {
2239 HcfSign *sign = NULL;
2240 int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
2241
2242 ASSERT_EQ(res, HCF_SUCCESS);
2243 ASSERT_NE(sign, nullptr);
2244
2245 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
2246
2247 ASSERT_EQ(res, HCF_SUCCESS);
2248
2249 res = sign->update(sign, &mockInput);
2250
2251 ASSERT_EQ(res, HCF_SUCCESS);
2252
2253 HcfBlob out = {
2254 .data = NULL,
2255 .len = 0
2256 };
2257 res = sign->sign(sign, NULL, &out);
2258
2259 ASSERT_EQ(res, HCF_SUCCESS);
2260 ASSERT_NE(out.data, nullptr);
2261 ASSERT_NE(out.len, (const unsigned int)0);
2262
2263 HcfVerify *verify = NULL;
2264 res = HcfVerifyCreate("ECC521|SHA384", &verify);
2265
2266 ASSERT_EQ(res, HCF_SUCCESS);
2267 ASSERT_NE(verify, nullptr);
2268
2269 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
2270
2271 ASSERT_EQ(res, HCF_SUCCESS);
2272
2273 res = verify->update(verify, &mockInput);
2274
2275 ASSERT_EQ(res, HCF_SUCCESS);
2276
2277 bool flag = verify->verify(verify, NULL, &out);
2278
2279 ASSERT_EQ(flag, true);
2280
2281 free(out.data);
2282 HcfObjDestroy(sign);
2283 HcfObjDestroy(verify);
2284 }
2285
2286 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest420, TestSize.Level0)
2287 {
2288 HcfSign *sign = NULL;
2289 int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
2290
2291 ASSERT_EQ(res, HCF_SUCCESS);
2292 ASSERT_NE(sign, nullptr);
2293
2294 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
2295
2296 ASSERT_EQ(res, HCF_SUCCESS);
2297
2298 res = sign->update(sign, &mockInput);
2299
2300 ASSERT_EQ(res, HCF_SUCCESS);
2301
2302 HcfBlob out = {
2303 .data = NULL,
2304 .len = 0
2305 };
2306 res = sign->sign(sign, NULL, &out);
2307
2308 ASSERT_EQ(res, HCF_SUCCESS);
2309 ASSERT_NE(out.data, nullptr);
2310 ASSERT_NE(out.len, (const unsigned int)0);
2311
2312 HcfVerify *verify = NULL;
2313 res = HcfVerifyCreate("ECC521|SHA512", &verify);
2314
2315 ASSERT_EQ(res, HCF_SUCCESS);
2316 ASSERT_NE(verify, nullptr);
2317
2318 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
2319
2320 ASSERT_EQ(res, HCF_SUCCESS);
2321
2322 res = verify->update(verify, &mockInput);
2323
2324 ASSERT_EQ(res, HCF_SUCCESS);
2325
2326 bool flag = verify->verify(verify, NULL, &out);
2327
2328 ASSERT_EQ(flag, true);
2329
2330 free(out.data);
2331 HcfObjDestroy(sign);
2332 HcfObjDestroy(verify);
2333 }
2334
2335 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest421, TestSize.Level0)
2336 {
2337 HcfSign *sign = NULL;
2338 int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
2339
2340 ASSERT_EQ(res, HCF_SUCCESS);
2341 ASSERT_NE(sign, nullptr);
2342
2343 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
2344
2345 ASSERT_EQ(res, HCF_SUCCESS);
2346
2347 HcfBlob out = {
2348 .data = NULL,
2349 .len = 0
2350 };
2351 res = sign->sign(sign, &mockInput, &out);
2352
2353 ASSERT_EQ(res, HCF_SUCCESS);
2354 ASSERT_NE(out.data, nullptr);
2355 ASSERT_NE(out.len, (const unsigned int)0);
2356
2357 HcfVerify *verify = NULL;
2358 res = HcfVerifyCreate("ECC224|SHA1", &verify);
2359
2360 ASSERT_EQ(res, HCF_SUCCESS);
2361 ASSERT_NE(verify, nullptr);
2362
2363 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
2364
2365 ASSERT_EQ(res, HCF_SUCCESS);
2366
2367 bool flag = verify->verify(verify, &mockInput, &out);
2368
2369 ASSERT_EQ(flag, true);
2370
2371 free(out.data);
2372 HcfObjDestroy(sign);
2373 HcfObjDestroy(verify);
2374 }
2375
2376 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest422, TestSize.Level0)
2377 {
2378 HcfSign *sign = NULL;
2379 int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
2380
2381 ASSERT_EQ(res, HCF_SUCCESS);
2382 ASSERT_NE(sign, nullptr);
2383
2384 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
2385
2386 ASSERT_EQ(res, HCF_SUCCESS);
2387
2388 HcfBlob out = {
2389 .data = NULL,
2390 .len = 0
2391 };
2392 res = sign->sign(sign, &mockInput, &out);
2393
2394 ASSERT_EQ(res, HCF_SUCCESS);
2395 ASSERT_NE(out.data, nullptr);
2396 ASSERT_NE(out.len, (const unsigned int)0);
2397
2398 HcfVerify *verify = NULL;
2399 res = HcfVerifyCreate("ECC224|SHA224", &verify);
2400
2401 ASSERT_EQ(res, HCF_SUCCESS);
2402 ASSERT_NE(verify, nullptr);
2403
2404 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
2405
2406 ASSERT_EQ(res, HCF_SUCCESS);
2407
2408 bool flag = verify->verify(verify, &mockInput, &out);
2409
2410 ASSERT_EQ(flag, true);
2411
2412 free(out.data);
2413 HcfObjDestroy(sign);
2414 HcfObjDestroy(verify);
2415 }
2416
2417 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest423, TestSize.Level0)
2418 {
2419 HcfSign *sign = NULL;
2420 int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
2421
2422 ASSERT_EQ(res, HCF_SUCCESS);
2423 ASSERT_NE(sign, nullptr);
2424
2425 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
2426
2427 ASSERT_EQ(res, HCF_SUCCESS);
2428
2429 HcfBlob out = {
2430 .data = NULL,
2431 .len = 0
2432 };
2433 res = sign->sign(sign, &mockInput, &out);
2434
2435 ASSERT_EQ(res, HCF_SUCCESS);
2436 ASSERT_NE(out.data, nullptr);
2437 ASSERT_NE(out.len, (const unsigned int)0);
2438
2439 HcfVerify *verify = NULL;
2440 res = HcfVerifyCreate("ECC224|SHA256", &verify);
2441
2442 ASSERT_EQ(res, HCF_SUCCESS);
2443 ASSERT_NE(verify, nullptr);
2444
2445 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
2446
2447 ASSERT_EQ(res, HCF_SUCCESS);
2448
2449 bool flag = verify->verify(verify, &mockInput, &out);
2450
2451 ASSERT_EQ(flag, true);
2452
2453 free(out.data);
2454 HcfObjDestroy(sign);
2455 HcfObjDestroy(verify);
2456 }
2457
2458 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest424, TestSize.Level0)
2459 {
2460 HcfSign *sign = NULL;
2461 int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
2462
2463 ASSERT_EQ(res, HCF_SUCCESS);
2464 ASSERT_NE(sign, nullptr);
2465
2466 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
2467
2468 ASSERT_EQ(res, HCF_SUCCESS);
2469
2470 HcfBlob out = {
2471 .data = NULL,
2472 .len = 0
2473 };
2474 res = sign->sign(sign, &mockInput, &out);
2475
2476 ASSERT_EQ(res, HCF_SUCCESS);
2477 ASSERT_NE(out.data, nullptr);
2478 ASSERT_NE(out.len, (const unsigned int)0);
2479
2480 HcfVerify *verify = NULL;
2481 res = HcfVerifyCreate("ECC224|SHA384", &verify);
2482
2483 ASSERT_EQ(res, HCF_SUCCESS);
2484 ASSERT_NE(verify, nullptr);
2485
2486 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
2487
2488 ASSERT_EQ(res, HCF_SUCCESS);
2489
2490 bool flag = verify->verify(verify, &mockInput, &out);
2491
2492 ASSERT_EQ(flag, true);
2493
2494 free(out.data);
2495 HcfObjDestroy(sign);
2496 HcfObjDestroy(verify);
2497 }
2498
2499 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest425, TestSize.Level0)
2500 {
2501 HcfSign *sign = NULL;
2502 int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
2503
2504 ASSERT_EQ(res, HCF_SUCCESS);
2505 ASSERT_NE(sign, nullptr);
2506
2507 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
2508
2509 ASSERT_EQ(res, HCF_SUCCESS);
2510
2511 HcfBlob out = {
2512 .data = NULL,
2513 .len = 0
2514 };
2515 res = sign->sign(sign, &mockInput, &out);
2516
2517 ASSERT_EQ(res, HCF_SUCCESS);
2518 ASSERT_NE(out.data, nullptr);
2519 ASSERT_NE(out.len, (const unsigned int)0);
2520
2521 HcfVerify *verify = NULL;
2522 res = HcfVerifyCreate("ECC224|SHA512", &verify);
2523
2524 ASSERT_EQ(res, HCF_SUCCESS);
2525 ASSERT_NE(verify, nullptr);
2526
2527 res = verify->init(verify, NULL, ecc224KeyPair_->pubKey);
2528
2529 ASSERT_EQ(res, HCF_SUCCESS);
2530
2531 bool flag = verify->verify(verify, &mockInput, &out);
2532
2533 ASSERT_EQ(flag, true);
2534
2535 free(out.data);
2536 HcfObjDestroy(sign);
2537 HcfObjDestroy(verify);
2538 }
2539
2540 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest426, TestSize.Level0)
2541 {
2542 HcfSign *sign = NULL;
2543 int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
2544
2545 ASSERT_EQ(res, HCF_SUCCESS);
2546 ASSERT_NE(sign, nullptr);
2547
2548 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2549
2550 ASSERT_EQ(res, HCF_SUCCESS);
2551
2552 HcfBlob out = {
2553 .data = NULL,
2554 .len = 0
2555 };
2556 res = sign->sign(sign, &mockInput, &out);
2557
2558 ASSERT_EQ(res, HCF_SUCCESS);
2559 ASSERT_NE(out.data, nullptr);
2560 ASSERT_NE(out.len, (const unsigned int)0);
2561
2562 HcfVerify *verify = NULL;
2563 res = HcfVerifyCreate("ECC256|SHA1", &verify);
2564
2565 ASSERT_EQ(res, HCF_SUCCESS);
2566 ASSERT_NE(verify, nullptr);
2567
2568 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
2569
2570 ASSERT_EQ(res, HCF_SUCCESS);
2571
2572 bool flag = verify->verify(verify, &mockInput, &out);
2573
2574 ASSERT_EQ(flag, true);
2575
2576 free(out.data);
2577 HcfObjDestroy(sign);
2578 HcfObjDestroy(verify);
2579 }
2580
2581 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest427, TestSize.Level0)
2582 {
2583 HcfSign *sign = NULL;
2584 int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
2585
2586 ASSERT_EQ(res, HCF_SUCCESS);
2587 ASSERT_NE(sign, nullptr);
2588
2589 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2590
2591 ASSERT_EQ(res, HCF_SUCCESS);
2592
2593 HcfBlob out = {
2594 .data = NULL,
2595 .len = 0
2596 };
2597 res = sign->sign(sign, &mockInput, &out);
2598
2599 ASSERT_EQ(res, HCF_SUCCESS);
2600 ASSERT_NE(out.data, nullptr);
2601 ASSERT_NE(out.len, (const unsigned int)0);
2602
2603 HcfVerify *verify = NULL;
2604 res = HcfVerifyCreate("ECC256|SHA224", &verify);
2605
2606 ASSERT_EQ(res, HCF_SUCCESS);
2607 ASSERT_NE(verify, nullptr);
2608
2609 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
2610
2611 ASSERT_EQ(res, HCF_SUCCESS);
2612
2613 bool flag = verify->verify(verify, &mockInput, &out);
2614
2615 ASSERT_EQ(flag, true);
2616
2617 free(out.data);
2618 HcfObjDestroy(sign);
2619 HcfObjDestroy(verify);
2620 }
2621
2622 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest428, TestSize.Level0)
2623 {
2624 HcfSign *sign = NULL;
2625 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
2626
2627 ASSERT_EQ(res, HCF_SUCCESS);
2628 ASSERT_NE(sign, nullptr);
2629
2630 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2631
2632 ASSERT_EQ(res, HCF_SUCCESS);
2633
2634 HcfBlob out = {
2635 .data = NULL,
2636 .len = 0
2637 };
2638 res = sign->sign(sign, &mockInput, &out);
2639
2640 ASSERT_EQ(res, HCF_SUCCESS);
2641 ASSERT_NE(out.data, nullptr);
2642 ASSERT_NE(out.len, (const unsigned int)0);
2643
2644 HcfVerify *verify = NULL;
2645 res = HcfVerifyCreate("ECC256|SHA256", &verify);
2646
2647 ASSERT_EQ(res, HCF_SUCCESS);
2648 ASSERT_NE(verify, nullptr);
2649
2650 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
2651
2652 ASSERT_EQ(res, HCF_SUCCESS);
2653
2654 bool flag = verify->verify(verify, &mockInput, &out);
2655
2656 ASSERT_EQ(flag, true);
2657
2658 free(out.data);
2659 HcfObjDestroy(sign);
2660 HcfObjDestroy(verify);
2661 }
2662
2663 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest429, TestSize.Level0)
2664 {
2665 HcfSign *sign = NULL;
2666 int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
2667
2668 ASSERT_EQ(res, HCF_SUCCESS);
2669 ASSERT_NE(sign, nullptr);
2670
2671 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2672
2673 ASSERT_EQ(res, HCF_SUCCESS);
2674
2675 HcfBlob out = {
2676 .data = NULL,
2677 .len = 0
2678 };
2679 res = sign->sign(sign, &mockInput, &out);
2680
2681 ASSERT_EQ(res, HCF_SUCCESS);
2682 ASSERT_NE(out.data, nullptr);
2683 ASSERT_NE(out.len, (const unsigned int)0);
2684
2685 HcfVerify *verify = NULL;
2686 res = HcfVerifyCreate("ECC256|SHA384", &verify);
2687
2688 ASSERT_EQ(res, HCF_SUCCESS);
2689 ASSERT_NE(verify, nullptr);
2690
2691 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
2692
2693 ASSERT_EQ(res, HCF_SUCCESS);
2694
2695 bool flag = verify->verify(verify, &mockInput, &out);
2696
2697 ASSERT_EQ(flag, true);
2698
2699 free(out.data);
2700 HcfObjDestroy(sign);
2701 HcfObjDestroy(verify);
2702 }
2703
2704 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest430, TestSize.Level0)
2705 {
2706 HcfSign *sign = NULL;
2707 int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
2708
2709 ASSERT_EQ(res, HCF_SUCCESS);
2710 ASSERT_NE(sign, nullptr);
2711
2712 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2713
2714 ASSERT_EQ(res, HCF_SUCCESS);
2715
2716 HcfBlob out = {
2717 .data = NULL,
2718 .len = 0
2719 };
2720 res = sign->sign(sign, &mockInput, &out);
2721
2722 ASSERT_EQ(res, HCF_SUCCESS);
2723 ASSERT_NE(out.data, nullptr);
2724 ASSERT_NE(out.len, (const unsigned int)0);
2725
2726 HcfVerify *verify = NULL;
2727 res = HcfVerifyCreate("ECC256|SHA512", &verify);
2728
2729 ASSERT_EQ(res, HCF_SUCCESS);
2730 ASSERT_NE(verify, nullptr);
2731
2732 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
2733
2734 ASSERT_EQ(res, HCF_SUCCESS);
2735
2736 bool flag = verify->verify(verify, &mockInput, &out);
2737
2738 ASSERT_EQ(flag, true);
2739
2740 free(out.data);
2741 HcfObjDestroy(sign);
2742 HcfObjDestroy(verify);
2743 }
2744
2745 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest431, TestSize.Level0)
2746 {
2747 HcfSign *sign = NULL;
2748 int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
2749
2750 ASSERT_EQ(res, HCF_SUCCESS);
2751 ASSERT_NE(sign, nullptr);
2752
2753 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
2754
2755 ASSERT_EQ(res, HCF_SUCCESS);
2756
2757 HcfBlob out = {
2758 .data = NULL,
2759 .len = 0
2760 };
2761 res = sign->sign(sign, &mockInput, &out);
2762
2763 ASSERT_EQ(res, HCF_SUCCESS);
2764 ASSERT_NE(out.data, nullptr);
2765 ASSERT_NE(out.len, (const unsigned int)0);
2766
2767 HcfVerify *verify = NULL;
2768 res = HcfVerifyCreate("ECC384|SHA1", &verify);
2769
2770 ASSERT_EQ(res, HCF_SUCCESS);
2771 ASSERT_NE(verify, nullptr);
2772
2773 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
2774
2775 ASSERT_EQ(res, HCF_SUCCESS);
2776
2777 bool flag = verify->verify(verify, &mockInput, &out);
2778
2779 ASSERT_EQ(flag, true);
2780
2781 free(out.data);
2782 HcfObjDestroy(sign);
2783 HcfObjDestroy(verify);
2784 }
2785
2786 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest432, TestSize.Level0)
2787 {
2788 HcfSign *sign = NULL;
2789 int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
2790
2791 ASSERT_EQ(res, HCF_SUCCESS);
2792 ASSERT_NE(sign, nullptr);
2793
2794 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
2795
2796 ASSERT_EQ(res, HCF_SUCCESS);
2797
2798 HcfBlob out = {
2799 .data = NULL,
2800 .len = 0
2801 };
2802 res = sign->sign(sign, &mockInput, &out);
2803
2804 ASSERT_EQ(res, HCF_SUCCESS);
2805 ASSERT_NE(out.data, nullptr);
2806 ASSERT_NE(out.len, (const unsigned int)0);
2807
2808 HcfVerify *verify = NULL;
2809 res = HcfVerifyCreate("ECC384|SHA224", &verify);
2810
2811 ASSERT_EQ(res, HCF_SUCCESS);
2812 ASSERT_NE(verify, nullptr);
2813
2814 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
2815
2816 ASSERT_EQ(res, HCF_SUCCESS);
2817
2818 bool flag = verify->verify(verify, &mockInput, &out);
2819
2820 ASSERT_EQ(flag, true);
2821
2822 free(out.data);
2823 HcfObjDestroy(sign);
2824 HcfObjDestroy(verify);
2825 }
2826
2827 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest433, TestSize.Level0)
2828 {
2829 HcfSign *sign = NULL;
2830 int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
2831
2832 ASSERT_EQ(res, HCF_SUCCESS);
2833 ASSERT_NE(sign, nullptr);
2834
2835 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
2836
2837 ASSERT_EQ(res, HCF_SUCCESS);
2838
2839 HcfBlob out = {
2840 .data = NULL,
2841 .len = 0
2842 };
2843 res = sign->sign(sign, &mockInput, &out);
2844
2845 ASSERT_EQ(res, HCF_SUCCESS);
2846 ASSERT_NE(out.data, nullptr);
2847 ASSERT_NE(out.len, (const unsigned int)0);
2848
2849 HcfVerify *verify = NULL;
2850 res = HcfVerifyCreate("ECC384|SHA256", &verify);
2851
2852 ASSERT_EQ(res, HCF_SUCCESS);
2853 ASSERT_NE(verify, nullptr);
2854
2855 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
2856
2857 ASSERT_EQ(res, HCF_SUCCESS);
2858
2859 bool flag = verify->verify(verify, &mockInput, &out);
2860
2861 ASSERT_EQ(flag, true);
2862
2863 free(out.data);
2864 HcfObjDestroy(sign);
2865 HcfObjDestroy(verify);
2866 }
2867
2868 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest434, TestSize.Level0)
2869 {
2870 HcfSign *sign = NULL;
2871 int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
2872
2873 ASSERT_EQ(res, HCF_SUCCESS);
2874 ASSERT_NE(sign, nullptr);
2875
2876 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
2877
2878 ASSERT_EQ(res, HCF_SUCCESS);
2879
2880 HcfBlob out = {
2881 .data = NULL,
2882 .len = 0
2883 };
2884 res = sign->sign(sign, &mockInput, &out);
2885
2886 ASSERT_EQ(res, HCF_SUCCESS);
2887 ASSERT_NE(out.data, nullptr);
2888 ASSERT_NE(out.len, (const unsigned int)0);
2889
2890 HcfVerify *verify = NULL;
2891 res = HcfVerifyCreate("ECC384|SHA384", &verify);
2892
2893 ASSERT_EQ(res, HCF_SUCCESS);
2894 ASSERT_NE(verify, nullptr);
2895
2896 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
2897
2898 ASSERT_EQ(res, HCF_SUCCESS);
2899
2900 bool flag = verify->verify(verify, &mockInput, &out);
2901
2902 ASSERT_EQ(flag, true);
2903
2904 free(out.data);
2905 HcfObjDestroy(sign);
2906 HcfObjDestroy(verify);
2907 }
2908
2909 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest435, TestSize.Level0)
2910 {
2911 HcfSign *sign = NULL;
2912 int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
2913
2914 ASSERT_EQ(res, HCF_SUCCESS);
2915 ASSERT_NE(sign, nullptr);
2916
2917 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
2918
2919 ASSERT_EQ(res, HCF_SUCCESS);
2920
2921 HcfBlob out = {
2922 .data = NULL,
2923 .len = 0
2924 };
2925 res = sign->sign(sign, &mockInput, &out);
2926
2927 ASSERT_EQ(res, HCF_SUCCESS);
2928 ASSERT_NE(out.data, nullptr);
2929 ASSERT_NE(out.len, (const unsigned int)0);
2930
2931 HcfVerify *verify = NULL;
2932 res = HcfVerifyCreate("ECC384|SHA512", &verify);
2933
2934 ASSERT_EQ(res, HCF_SUCCESS);
2935 ASSERT_NE(verify, nullptr);
2936
2937 res = verify->init(verify, NULL, ecc384KeyPair_->pubKey);
2938
2939 ASSERT_EQ(res, HCF_SUCCESS);
2940
2941 bool flag = verify->verify(verify, &mockInput, &out);
2942
2943 ASSERT_EQ(flag, true);
2944
2945 free(out.data);
2946 HcfObjDestroy(sign);
2947 HcfObjDestroy(verify);
2948 }
2949
2950 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest436, TestSize.Level0)
2951 {
2952 HcfSign *sign = NULL;
2953 int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
2954
2955 ASSERT_EQ(res, HCF_SUCCESS);
2956 ASSERT_NE(sign, nullptr);
2957
2958 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
2959
2960 ASSERT_EQ(res, HCF_SUCCESS);
2961
2962 HcfBlob out = {
2963 .data = NULL,
2964 .len = 0
2965 };
2966 res = sign->sign(sign, &mockInput, &out);
2967
2968 ASSERT_EQ(res, HCF_SUCCESS);
2969 ASSERT_NE(out.data, nullptr);
2970 ASSERT_NE(out.len, (const unsigned int)0);
2971
2972 HcfVerify *verify = NULL;
2973 res = HcfVerifyCreate("ECC521|SHA1", &verify);
2974
2975 ASSERT_EQ(res, HCF_SUCCESS);
2976 ASSERT_NE(verify, nullptr);
2977
2978 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
2979
2980 ASSERT_EQ(res, HCF_SUCCESS);
2981
2982 bool flag = verify->verify(verify, &mockInput, &out);
2983
2984 ASSERT_EQ(flag, true);
2985
2986 free(out.data);
2987 HcfObjDestroy(sign);
2988 HcfObjDestroy(verify);
2989 }
2990
2991 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest437, TestSize.Level0)
2992 {
2993 HcfSign *sign = NULL;
2994 int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
2995
2996 ASSERT_EQ(res, HCF_SUCCESS);
2997 ASSERT_NE(sign, nullptr);
2998
2999 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
3000
3001 ASSERT_EQ(res, HCF_SUCCESS);
3002
3003 HcfBlob out = {
3004 .data = NULL,
3005 .len = 0
3006 };
3007 res = sign->sign(sign, &mockInput, &out);
3008
3009 ASSERT_EQ(res, HCF_SUCCESS);
3010 ASSERT_NE(out.data, nullptr);
3011 ASSERT_NE(out.len, (const unsigned int)0);
3012
3013 HcfVerify *verify = NULL;
3014 res = HcfVerifyCreate("ECC521|SHA224", &verify);
3015
3016 ASSERT_EQ(res, HCF_SUCCESS);
3017 ASSERT_NE(verify, nullptr);
3018
3019 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
3020
3021 ASSERT_EQ(res, HCF_SUCCESS);
3022
3023 bool flag = verify->verify(verify, &mockInput, &out);
3024
3025 ASSERT_EQ(flag, true);
3026
3027 free(out.data);
3028 HcfObjDestroy(sign);
3029 HcfObjDestroy(verify);
3030 }
3031
3032 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest438, TestSize.Level0)
3033 {
3034 HcfSign *sign = NULL;
3035 int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
3036
3037 ASSERT_EQ(res, HCF_SUCCESS);
3038 ASSERT_NE(sign, nullptr);
3039
3040 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
3041
3042 ASSERT_EQ(res, HCF_SUCCESS);
3043
3044 HcfBlob out = {
3045 .data = NULL,
3046 .len = 0
3047 };
3048 res = sign->sign(sign, &mockInput, &out);
3049
3050 ASSERT_EQ(res, HCF_SUCCESS);
3051 ASSERT_NE(out.data, nullptr);
3052 ASSERT_NE(out.len, (const unsigned int)0);
3053
3054 HcfVerify *verify = NULL;
3055 res = HcfVerifyCreate("ECC521|SHA256", &verify);
3056
3057 ASSERT_EQ(res, HCF_SUCCESS);
3058 ASSERT_NE(verify, nullptr);
3059
3060 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
3061
3062 ASSERT_EQ(res, HCF_SUCCESS);
3063
3064 bool flag = verify->verify(verify, &mockInput, &out);
3065
3066 ASSERT_EQ(flag, true);
3067
3068 free(out.data);
3069 HcfObjDestroy(sign);
3070 HcfObjDestroy(verify);
3071 }
3072
3073 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest439, TestSize.Level0)
3074 {
3075 HcfSign *sign = NULL;
3076 int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
3077
3078 ASSERT_EQ(res, HCF_SUCCESS);
3079 ASSERT_NE(sign, nullptr);
3080
3081 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
3082
3083 ASSERT_EQ(res, HCF_SUCCESS);
3084
3085 HcfBlob out = {
3086 .data = NULL,
3087 .len = 0
3088 };
3089 res = sign->sign(sign, &mockInput, &out);
3090
3091 ASSERT_EQ(res, HCF_SUCCESS);
3092 ASSERT_NE(out.data, nullptr);
3093 ASSERT_NE(out.len, (const unsigned int)0);
3094
3095 HcfVerify *verify = NULL;
3096 res = HcfVerifyCreate("ECC521|SHA384", &verify);
3097
3098 ASSERT_EQ(res, HCF_SUCCESS);
3099 ASSERT_NE(verify, nullptr);
3100
3101 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
3102
3103 ASSERT_EQ(res, HCF_SUCCESS);
3104
3105 bool flag = verify->verify(verify, &mockInput, &out);
3106
3107 ASSERT_EQ(flag, true);
3108
3109 free(out.data);
3110 HcfObjDestroy(sign);
3111 HcfObjDestroy(verify);
3112 }
3113
3114 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest440, TestSize.Level0)
3115 {
3116 HcfSign *sign = NULL;
3117 int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
3118
3119 ASSERT_EQ(res, HCF_SUCCESS);
3120 ASSERT_NE(sign, nullptr);
3121
3122 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
3123
3124 ASSERT_EQ(res, HCF_SUCCESS);
3125
3126 HcfBlob out = {
3127 .data = NULL,
3128 .len = 0
3129 };
3130 res = sign->sign(sign, &mockInput, &out);
3131
3132 ASSERT_EQ(res, HCF_SUCCESS);
3133 ASSERT_NE(out.data, nullptr);
3134 ASSERT_NE(out.len, (const unsigned int)0);
3135
3136 HcfVerify *verify = NULL;
3137 res = HcfVerifyCreate("ECC521|SHA512", &verify);
3138
3139 ASSERT_EQ(res, HCF_SUCCESS);
3140 ASSERT_NE(verify, nullptr);
3141
3142 res = verify->init(verify, NULL, ecc521KeyPair_->pubKey);
3143
3144 ASSERT_EQ(res, HCF_SUCCESS);
3145
3146 bool flag = verify->verify(verify, &mockInput, &out);
3147
3148 ASSERT_EQ(flag, true);
3149
3150 free(out.data);
3151 HcfObjDestroy(sign);
3152 HcfObjDestroy(verify);
3153 }
3154
3155 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest441, TestSize.Level0)
3156 {
3157 HcfSign *sign = NULL;
3158 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
3159
3160 ASSERT_EQ(res, HCF_SUCCESS);
3161 ASSERT_NE(sign, nullptr);
3162
3163 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
3164
3165 ASSERT_EQ(res, HCF_SUCCESS);
3166
3167 res = sign->update(sign, &mockInput);
3168
3169 ASSERT_EQ(res, HCF_SUCCESS);
3170
3171 HcfBlob out = {
3172 .data = NULL,
3173 .len = 0
3174 };
3175 res = sign->sign(sign, NULL, &out);
3176
3177 ASSERT_EQ(res, HCF_SUCCESS);
3178 ASSERT_NE(out.data, nullptr);
3179 ASSERT_NE(out.len, (const unsigned int)0);
3180
3181 HcfVerify *verify = NULL;
3182 res = HcfVerifyCreate("ECC256|SHA256", &verify);
3183
3184 ASSERT_EQ(res, HCF_SUCCESS);
3185 ASSERT_NE(verify, nullptr);
3186
3187 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
3188
3189 ASSERT_EQ(res, HCF_SUCCESS);
3190
3191 res = verify->update(verify, &mockInput);
3192
3193 ASSERT_EQ(res, HCF_SUCCESS);
3194
3195 bool flag = verify->verify(NULL, NULL, &out);
3196
3197 ASSERT_EQ(flag, false);
3198
3199 free(out.data);
3200 HcfObjDestroy(sign);
3201 HcfObjDestroy(verify);
3202 }
3203
3204 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest442, TestSize.Level0)
3205 {
3206 HcfSign *sign = NULL;
3207 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
3208
3209 ASSERT_EQ(res, HCF_SUCCESS);
3210 ASSERT_NE(sign, nullptr);
3211
3212 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
3213
3214 ASSERT_EQ(res, HCF_SUCCESS);
3215
3216 res = sign->update(sign, &mockInput);
3217
3218 ASSERT_EQ(res, HCF_SUCCESS);
3219
3220 HcfBlob out = {
3221 .data = NULL,
3222 .len = 0
3223 };
3224 res = sign->sign(sign, NULL, &out);
3225
3226 ASSERT_EQ(res, HCF_SUCCESS);
3227 ASSERT_NE(out.data, nullptr);
3228 ASSERT_NE(out.len, (const unsigned int)0);
3229
3230 HcfVerify *verify = NULL;
3231 res = HcfVerifyCreate("ECC256|SHA256", &verify);
3232
3233 ASSERT_EQ(res, HCF_SUCCESS);
3234 ASSERT_NE(verify, nullptr);
3235
3236 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
3237
3238 ASSERT_EQ(res, HCF_SUCCESS);
3239
3240 res = verify->update(verify, &mockInput);
3241
3242 ASSERT_EQ(res, HCF_SUCCESS);
3243
3244 bool flag = verify->verify((HcfVerify *)(&obj), NULL, &out);
3245
3246 ASSERT_EQ(flag, false);
3247
3248 free(out.data);
3249 HcfObjDestroy(sign);
3250 HcfObjDestroy(verify);
3251 }
3252
3253 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest443, TestSize.Level0)
3254 {
3255 HcfSign *sign = NULL;
3256 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
3257
3258 ASSERT_EQ(res, HCF_SUCCESS);
3259 ASSERT_NE(sign, nullptr);
3260
3261 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
3262
3263 ASSERT_EQ(res, HCF_SUCCESS);
3264
3265 res = sign->update(sign, &mockInput);
3266
3267 ASSERT_EQ(res, HCF_SUCCESS);
3268
3269 HcfBlob out = {
3270 .data = NULL,
3271 .len = 0
3272 };
3273 res = sign->sign(sign, NULL, &out);
3274
3275 ASSERT_EQ(res, HCF_SUCCESS);
3276 ASSERT_NE(out.data, nullptr);
3277 ASSERT_NE(out.len, (const unsigned int)0);
3278
3279 HcfVerify *verify = NULL;
3280 res = HcfVerifyCreate("ECC256|SHA256", &verify);
3281
3282 ASSERT_EQ(res, HCF_SUCCESS);
3283 ASSERT_NE(verify, nullptr);
3284
3285 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
3286
3287 ASSERT_EQ(res, HCF_SUCCESS);
3288
3289 bool flag = verify->verify(verify, NULL, &out);
3290
3291 ASSERT_EQ(flag, false);
3292
3293 free(out.data);
3294 HcfObjDestroy(sign);
3295 HcfObjDestroy(verify);
3296 }
3297
3298 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest444, TestSize.Level0)
3299 {
3300 HcfSign *sign = NULL;
3301 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
3302
3303 ASSERT_EQ(res, HCF_SUCCESS);
3304 ASSERT_NE(sign, nullptr);
3305
3306 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
3307
3308 ASSERT_EQ(res, HCF_SUCCESS);
3309
3310 res = sign->update(sign, &mockInput);
3311
3312 ASSERT_EQ(res, HCF_SUCCESS);
3313
3314 HcfBlob out = {
3315 .data = NULL,
3316 .len = 0
3317 };
3318 res = sign->sign(sign, NULL, &out);
3319
3320 ASSERT_EQ(res, HCF_SUCCESS);
3321 ASSERT_NE(out.data, nullptr);
3322 ASSERT_NE(out.len, (const unsigned int)0);
3323
3324 HcfVerify *verify = NULL;
3325 res = HcfVerifyCreate("ECC256|SHA256", &verify);
3326
3327 ASSERT_EQ(res, HCF_SUCCESS);
3328 ASSERT_NE(verify, nullptr);
3329
3330 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
3331
3332 ASSERT_EQ(res, HCF_SUCCESS);
3333
3334 HcfBlob input = {
3335 .data = NULL,
3336 .len = 1
3337 };
3338 bool flag = verify->verify(verify, &input, &out);
3339
3340 ASSERT_EQ(flag, false);
3341
3342 free(out.data);
3343 HcfObjDestroy(sign);
3344 HcfObjDestroy(verify);
3345 }
3346
3347 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest445, TestSize.Level0)
3348 {
3349 HcfSign *sign = NULL;
3350 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
3351
3352 ASSERT_EQ(res, HCF_SUCCESS);
3353 ASSERT_NE(sign, nullptr);
3354
3355 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
3356
3357 ASSERT_EQ(res, HCF_SUCCESS);
3358
3359 res = sign->update(sign, &mockInput);
3360
3361 ASSERT_EQ(res, HCF_SUCCESS);
3362
3363 HcfBlob out = {
3364 .data = NULL,
3365 .len = 0
3366 };
3367 res = sign->sign(sign, NULL, &out);
3368
3369 ASSERT_EQ(res, HCF_SUCCESS);
3370 ASSERT_NE(out.data, nullptr);
3371 ASSERT_NE(out.len, (const unsigned int)0);
3372
3373 HcfVerify *verify = NULL;
3374 res = HcfVerifyCreate("ECC256|SHA256", &verify);
3375
3376 ASSERT_EQ(res, HCF_SUCCESS);
3377 ASSERT_NE(verify, nullptr);
3378
3379 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
3380
3381 ASSERT_EQ(res, HCF_SUCCESS);
3382
3383 HcfBlob input = {
3384 .data = (uint8_t *)g_mockMessage,
3385 .len = 0
3386 };
3387 bool flag = verify->verify(verify, &input, &out);
3388
3389 ASSERT_EQ(flag, false);
3390
3391 free(out.data);
3392 HcfObjDestroy(sign);
3393 HcfObjDestroy(verify);
3394 }
3395
3396 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest446, TestSize.Level0)
3397 {
3398 HcfVerify *verify = NULL;
3399 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
3400
3401 ASSERT_EQ(res, HCF_SUCCESS);
3402 ASSERT_NE(verify, nullptr);
3403
3404 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
3405
3406 ASSERT_EQ(res, HCF_SUCCESS);
3407
3408 res = verify->update(verify, &mockInput);
3409
3410 ASSERT_EQ(res, HCF_SUCCESS);
3411
3412 bool flag = verify->verify(verify, NULL, NULL);
3413
3414 ASSERT_EQ(flag, false);
3415
3416 HcfObjDestroy(verify);
3417 }
3418
3419 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest447, TestSize.Level0)
3420 {
3421 HcfVerify *verify = NULL;
3422 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
3423
3424 ASSERT_EQ(res, HCF_SUCCESS);
3425 ASSERT_NE(verify, nullptr);
3426
3427 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
3428
3429 ASSERT_EQ(res, HCF_SUCCESS);
3430
3431 res = verify->update(verify, &mockInput);
3432
3433 ASSERT_EQ(res, HCF_SUCCESS);
3434
3435 HcfBlob mockOut = {
3436 .data = NULL,
3437 .len = 1
3438 };
3439 bool flag = verify->verify(verify, NULL, &mockOut);
3440
3441 ASSERT_EQ(flag, false);
3442
3443 HcfObjDestroy(verify);
3444 }
3445
3446 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest448, TestSize.Level0)
3447 {
3448 HcfVerify *verify = NULL;
3449 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
3450
3451 ASSERT_EQ(res, HCF_SUCCESS);
3452 ASSERT_NE(verify, nullptr);
3453
3454 res = verify->init(verify, NULL, ecc256KeyPair_->pubKey);
3455
3456 ASSERT_EQ(res, HCF_SUCCESS);
3457
3458 res = verify->update(verify, &mockInput);
3459
3460 ASSERT_EQ(res, HCF_SUCCESS);
3461
3462 HcfBlob mockOut = {
3463 .data = (uint8_t *)g_mockMessage,
3464 .len = 0
3465 };
3466 bool flag = verify->verify(verify, NULL, &mockOut);
3467
3468 ASSERT_EQ(flag, false);
3469
3470 HcfObjDestroy(verify);
3471 }
3472 }
3473