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 CryptoEccSignTest : 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 *CryptoEccSignTest::ecc224KeyPair_ = nullptr;
43 HcfKeyPair *CryptoEccSignTest::ecc256KeyPair_ = nullptr;
44 HcfKeyPair *CryptoEccSignTest::ecc384KeyPair_ = nullptr;
45 HcfKeyPair *CryptoEccSignTest::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 CryptoEccSignTest::SetUp() {}
TearDown()54 void CryptoEccSignTest::TearDown() {}
55
SetUpTestCase()56 void CryptoEccSignTest::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 CryptoEccSignTest::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(CryptoEccSignTest, CryptoEccSignTest001, TestSize.Level0)
134 {
135 HcfSign *sign = NULL;
136 int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
137
138 ASSERT_EQ(res, HCF_SUCCESS);
139 ASSERT_NE(sign, nullptr);
140
141 HcfObjDestroy(sign);
142 }
143
144 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest002, TestSize.Level0)
145 {
146 HcfSign *sign = NULL;
147 int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
148
149 ASSERT_EQ(res, HCF_SUCCESS);
150 ASSERT_NE(sign, nullptr);
151
152 HcfObjDestroy(sign);
153 }
154
155 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest003, TestSize.Level0)
156 {
157 HcfSign *sign = NULL;
158 int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
159
160 ASSERT_EQ(res, HCF_SUCCESS);
161 ASSERT_NE(sign, nullptr);
162
163 HcfObjDestroy(sign);
164 }
165
166 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest004, TestSize.Level0)
167 {
168 HcfSign *sign = NULL;
169 int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
170
171 ASSERT_EQ(res, HCF_SUCCESS);
172 ASSERT_NE(sign, nullptr);
173
174 HcfObjDestroy(sign);
175 }
176
177 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest005, TestSize.Level0)
178 {
179 HcfSign *sign = NULL;
180 int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
181
182 ASSERT_EQ(res, HCF_SUCCESS);
183 ASSERT_NE(sign, nullptr);
184
185 HcfObjDestroy(sign);
186 }
187
188 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest006, TestSize.Level0)
189 {
190 HcfSign *sign = NULL;
191 int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
192
193 ASSERT_EQ(res, HCF_SUCCESS);
194 ASSERT_NE(sign, nullptr);
195
196 HcfObjDestroy(sign);
197 }
198
199 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest007, TestSize.Level0)
200 {
201 HcfSign *sign = NULL;
202 int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
203
204 ASSERT_EQ(res, HCF_SUCCESS);
205 ASSERT_NE(sign, nullptr);
206
207 HcfObjDestroy(sign);
208 }
209
210 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest008, TestSize.Level0)
211 {
212 HcfSign *sign = NULL;
213 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
214
215 ASSERT_EQ(res, HCF_SUCCESS);
216 ASSERT_NE(sign, nullptr);
217
218 HcfObjDestroy(sign);
219 }
220
221 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest009, TestSize.Level0)
222 {
223 HcfSign *sign = NULL;
224 int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
225
226 ASSERT_EQ(res, HCF_SUCCESS);
227 ASSERT_NE(sign, nullptr);
228
229 HcfObjDestroy(sign);
230 }
231
232 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest010, TestSize.Level0)
233 {
234 HcfSign *sign = NULL;
235 int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
236
237 ASSERT_EQ(res, HCF_SUCCESS);
238 ASSERT_NE(sign, nullptr);
239
240 HcfObjDestroy(sign);
241 }
242
243 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest011, TestSize.Level0)
244 {
245 HcfSign *sign = NULL;
246 int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
247
248 ASSERT_EQ(res, HCF_SUCCESS);
249 ASSERT_NE(sign, nullptr);
250
251 HcfObjDestroy(sign);
252 }
253
254 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest012, TestSize.Level0)
255 {
256 HcfSign *sign = NULL;
257 int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
258
259 ASSERT_EQ(res, HCF_SUCCESS);
260 ASSERT_NE(sign, nullptr);
261
262 HcfObjDestroy(sign);
263 }
264
265 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest013, TestSize.Level0)
266 {
267 HcfSign *sign = NULL;
268 int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
269
270 ASSERT_EQ(res, HCF_SUCCESS);
271 ASSERT_NE(sign, nullptr);
272
273 HcfObjDestroy(sign);
274 }
275
276 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest014, TestSize.Level0)
277 {
278 HcfSign *sign = NULL;
279 int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
280
281 ASSERT_EQ(res, HCF_SUCCESS);
282 ASSERT_NE(sign, nullptr);
283
284 HcfObjDestroy(sign);
285 }
286
287 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest015, TestSize.Level0)
288 {
289 HcfSign *sign = NULL;
290 int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
291
292 ASSERT_EQ(res, HCF_SUCCESS);
293 ASSERT_NE(sign, nullptr);
294
295 HcfObjDestroy(sign);
296 }
297
298 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest016, TestSize.Level0)
299 {
300 HcfSign *sign = NULL;
301 int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
302
303 ASSERT_EQ(res, HCF_SUCCESS);
304 ASSERT_NE(sign, nullptr);
305
306 HcfObjDestroy(sign);
307 }
308
309 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest017, TestSize.Level0)
310 {
311 HcfSign *sign = NULL;
312 int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
313
314 ASSERT_EQ(res, HCF_SUCCESS);
315 ASSERT_NE(sign, nullptr);
316
317 HcfObjDestroy(sign);
318 }
319
320 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest018, TestSize.Level0)
321 {
322 HcfSign *sign = NULL;
323 int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
324
325 ASSERT_EQ(res, HCF_SUCCESS);
326 ASSERT_NE(sign, nullptr);
327
328 HcfObjDestroy(sign);
329 }
330
331 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest019, TestSize.Level0)
332 {
333 HcfSign *sign = NULL;
334 int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
335
336 ASSERT_EQ(res, HCF_SUCCESS);
337 ASSERT_NE(sign, nullptr);
338
339 HcfObjDestroy(sign);
340 }
341
342 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest020, TestSize.Level0)
343 {
344 HcfSign *sign = NULL;
345 int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
346
347 ASSERT_EQ(res, HCF_SUCCESS);
348 ASSERT_NE(sign, nullptr);
349
350 HcfObjDestroy(sign);
351 }
352
353 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest021, TestSize.Level0)
354 {
355 HcfSign *sign = NULL;
356 int32_t res = HcfSignCreate(NULL, &sign);
357
358 ASSERT_EQ(res, HCF_INVALID_PARAMS);
359 ASSERT_EQ(sign, nullptr);
360 }
361
362 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest022, TestSize.Level0)
363 {
364 HcfSign *sign = NULL;
365 int32_t res = HcfSignCreate("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD"
366 "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", &sign);
367
368 ASSERT_EQ(res, HCF_INVALID_PARAMS);
369 ASSERT_EQ(sign, nullptr);
370 }
371
372 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest023, TestSize.Level0)
373 {
374 HcfSign *sign = NULL;
375 int32_t res = HcfSignCreate("ECC257|SHA256", &sign);
376
377 ASSERT_NE(res, HCF_SUCCESS);
378 ASSERT_EQ(sign, nullptr);
379 }
380
381 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest024, TestSize.Level0)
382 {
383 HcfSign *sign = NULL;
384 int32_t res = HcfSignCreate("ECC256|SHA257", &sign);
385
386 ASSERT_NE(res, HCF_SUCCESS);
387 ASSERT_EQ(sign, nullptr);
388 }
389
390 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest025, TestSize.Level0)
391 {
392 HcfSign *sign = NULL;
393 int32_t res = HcfSignCreate("ECC256|MD5", &sign);
394
395 ASSERT_NE(res, HCF_SUCCESS);
396 ASSERT_EQ(sign, nullptr);
397 }
398
399 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest026, TestSize.Level0)
400 {
401 HcfSign *sign = NULL;
402 int32_t res = HcfSignCreate("ECC256SHA256", &sign);
403
404 ASSERT_NE(res, HCF_SUCCESS);
405 ASSERT_EQ(sign, nullptr);
406 }
407
408 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest027, TestSize.Level0)
409 {
410 int32_t res = HcfSignCreate("ECC256|SHA256", NULL);
411
412 ASSERT_EQ(res, HCF_INVALID_PARAMS);
413 }
414
415 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest101, TestSize.Level0)
416 {
417 HcfSign *sign = NULL;
418 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
419
420 ASSERT_EQ(res, HCF_SUCCESS);
421 ASSERT_NE(sign, nullptr);
422
423 const char *className = sign->base.getClass();
424
425 ASSERT_NE(className, nullptr);
426
427 HcfObjDestroy(sign);
428 }
429
430 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest102, TestSize.Level0)
431 {
432 HcfSign *sign = NULL;
433 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
434
435 ASSERT_EQ(res, HCF_SUCCESS);
436 ASSERT_NE(sign, nullptr);
437
438 sign->base.destroy((HcfObjectBase *)sign);
439 }
440
441 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest103, TestSize.Level0)
442 {
443 HcfSign *sign = NULL;
444 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
445
446 ASSERT_EQ(res, HCF_SUCCESS);
447 ASSERT_NE(sign, nullptr);
448
449 sign->base.destroy(NULL);
450
451 HcfObjDestroy(sign);
452 }
453
454 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest104, TestSize.Level0)
455 {
456 HcfSign *sign = NULL;
457 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
458
459 ASSERT_EQ(res, HCF_SUCCESS);
460 ASSERT_NE(sign, nullptr);
461
462 sign->base.destroy(&obj);
463
464 HcfObjDestroy(sign);
465 }
466
467 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest105, TestSize.Level0)
468 {
469 HcfSign *sign = NULL;
470 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
471
472 ASSERT_EQ(res, HCF_SUCCESS);
473 ASSERT_NE(sign, nullptr);
474
475 const char *algName = sign->getAlgoName(sign);
476
477 ASSERT_NE(algName, nullptr);
478
479 HcfObjDestroy(sign);
480 }
481
482 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest106, TestSize.Level0)
483 {
484 HcfSign *sign = NULL;
485 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
486
487 ASSERT_EQ(res, HCF_SUCCESS);
488 ASSERT_NE(sign, nullptr);
489
490 const char *algName = sign->getAlgoName(NULL);
491
492 ASSERT_EQ(algName, nullptr);
493
494 HcfObjDestroy(sign);
495 }
496
497 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest107, TestSize.Level0)
498 {
499 HcfSign *sign = NULL;
500 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
501
502 ASSERT_EQ(res, HCF_SUCCESS);
503 ASSERT_NE(sign, nullptr);
504
505 const char *algName = sign->getAlgoName((HcfSign *)(&obj));
506
507 ASSERT_EQ(algName, nullptr);
508
509 HcfObjDestroy(sign);
510 }
511
512 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest201, TestSize.Level0)
513 {
514 HcfSign *sign = NULL;
515 int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
516
517 ASSERT_EQ(res, HCF_SUCCESS);
518 ASSERT_NE(sign, nullptr);
519
520 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
521
522 ASSERT_EQ(res, HCF_SUCCESS);
523
524 HcfObjDestroy(sign);
525 }
526
527 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest202, TestSize.Level0)
528 {
529 HcfSign *sign = NULL;
530 int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
531
532 ASSERT_EQ(res, HCF_SUCCESS);
533 ASSERT_NE(sign, nullptr);
534
535 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
536
537 ASSERT_EQ(res, HCF_SUCCESS);
538
539 HcfObjDestroy(sign);
540 }
541
542 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest203, TestSize.Level0)
543 {
544 HcfSign *sign = NULL;
545 int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
546
547 ASSERT_EQ(res, HCF_SUCCESS);
548 ASSERT_NE(sign, nullptr);
549
550 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
551
552 ASSERT_EQ(res, HCF_SUCCESS);
553
554 HcfObjDestroy(sign);
555 }
556
557 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest204, TestSize.Level0)
558 {
559 HcfSign *sign = NULL;
560 int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
561
562 ASSERT_EQ(res, HCF_SUCCESS);
563 ASSERT_NE(sign, nullptr);
564
565 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
566
567 ASSERT_EQ(res, HCF_SUCCESS);
568
569 HcfObjDestroy(sign);
570 }
571
572 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest205, TestSize.Level0)
573 {
574 HcfSign *sign = NULL;
575 int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
576
577 ASSERT_EQ(res, HCF_SUCCESS);
578 ASSERT_NE(sign, nullptr);
579
580 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
581
582 ASSERT_EQ(res, HCF_SUCCESS);
583
584 HcfObjDestroy(sign);
585 }
586
587 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest206, TestSize.Level0)
588 {
589 HcfSign *sign = NULL;
590 int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
591
592 ASSERT_EQ(res, HCF_SUCCESS);
593 ASSERT_NE(sign, nullptr);
594
595 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
596
597 ASSERT_EQ(res, HCF_SUCCESS);
598
599 HcfObjDestroy(sign);
600 }
601
602 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest207, TestSize.Level0)
603 {
604 HcfSign *sign = NULL;
605 int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
606
607 ASSERT_EQ(res, HCF_SUCCESS);
608 ASSERT_NE(sign, nullptr);
609
610 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
611
612 ASSERT_EQ(res, HCF_SUCCESS);
613
614 HcfObjDestroy(sign);
615 }
616
617 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest208, TestSize.Level0)
618 {
619 HcfSign *sign = NULL;
620 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
621
622 ASSERT_EQ(res, HCF_SUCCESS);
623 ASSERT_NE(sign, nullptr);
624
625 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
626
627 ASSERT_EQ(res, HCF_SUCCESS);
628
629 HcfObjDestroy(sign);
630 }
631
632 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest209, TestSize.Level0)
633 {
634 HcfSign *sign = NULL;
635 int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
636
637 ASSERT_EQ(res, HCF_SUCCESS);
638 ASSERT_NE(sign, nullptr);
639
640 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
641
642 ASSERT_EQ(res, HCF_SUCCESS);
643
644 HcfObjDestroy(sign);
645 }
646
647 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest210, TestSize.Level0)
648 {
649 HcfSign *sign = NULL;
650 int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
651
652 ASSERT_EQ(res, HCF_SUCCESS);
653 ASSERT_NE(sign, nullptr);
654
655 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
656
657 ASSERT_EQ(res, HCF_SUCCESS);
658
659 HcfObjDestroy(sign);
660 }
661
662 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest211, TestSize.Level0)
663 {
664 HcfSign *sign = NULL;
665 int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
666
667 ASSERT_EQ(res, HCF_SUCCESS);
668 ASSERT_NE(sign, nullptr);
669
670 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
671
672 ASSERT_EQ(res, HCF_SUCCESS);
673
674 HcfObjDestroy(sign);
675 }
676
677 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest212, TestSize.Level0)
678 {
679 HcfSign *sign = NULL;
680 int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
681
682 ASSERT_EQ(res, HCF_SUCCESS);
683 ASSERT_NE(sign, nullptr);
684
685 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
686
687 ASSERT_EQ(res, HCF_SUCCESS);
688
689 HcfObjDestroy(sign);
690 }
691
692 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest213, TestSize.Level0)
693 {
694 HcfSign *sign = NULL;
695 int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
696
697 ASSERT_EQ(res, HCF_SUCCESS);
698 ASSERT_NE(sign, nullptr);
699
700 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
701
702 ASSERT_EQ(res, HCF_SUCCESS);
703
704 HcfObjDestroy(sign);
705 }
706
707 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest214, TestSize.Level0)
708 {
709 HcfSign *sign = NULL;
710 int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
711
712 ASSERT_EQ(res, HCF_SUCCESS);
713 ASSERT_NE(sign, nullptr);
714
715 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
716
717 ASSERT_EQ(res, HCF_SUCCESS);
718
719 HcfObjDestroy(sign);
720 }
721
722 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest215, TestSize.Level0)
723 {
724 HcfSign *sign = NULL;
725 int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
726
727 ASSERT_EQ(res, HCF_SUCCESS);
728 ASSERT_NE(sign, nullptr);
729
730 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
731
732 ASSERT_EQ(res, HCF_SUCCESS);
733
734 HcfObjDestroy(sign);
735 }
736
737 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest216, TestSize.Level0)
738 {
739 HcfSign *sign = NULL;
740 int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
741
742 ASSERT_EQ(res, HCF_SUCCESS);
743 ASSERT_NE(sign, nullptr);
744
745 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
746
747 ASSERT_EQ(res, HCF_SUCCESS);
748
749 HcfObjDestroy(sign);
750 }
751
752 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest217, TestSize.Level0)
753 {
754 HcfSign *sign = NULL;
755 int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
756
757 ASSERT_EQ(res, HCF_SUCCESS);
758 ASSERT_NE(sign, nullptr);
759
760 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
761
762 ASSERT_EQ(res, HCF_SUCCESS);
763
764 HcfObjDestroy(sign);
765 }
766
767 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest218, TestSize.Level0)
768 {
769 HcfSign *sign = NULL;
770 int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
771
772 ASSERT_EQ(res, HCF_SUCCESS);
773 ASSERT_NE(sign, nullptr);
774
775 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
776
777 ASSERT_EQ(res, HCF_SUCCESS);
778
779 HcfObjDestroy(sign);
780 }
781
782 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest219, TestSize.Level0)
783 {
784 HcfSign *sign = NULL;
785 int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
786
787 ASSERT_EQ(res, HCF_SUCCESS);
788 ASSERT_NE(sign, nullptr);
789
790 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
791
792 ASSERT_EQ(res, HCF_SUCCESS);
793
794 HcfObjDestroy(sign);
795 }
796
797 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest220, TestSize.Level0)
798 {
799 HcfSign *sign = NULL;
800 int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
801
802 ASSERT_EQ(res, HCF_SUCCESS);
803 ASSERT_NE(sign, nullptr);
804
805 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
806
807 ASSERT_EQ(res, HCF_SUCCESS);
808
809 HcfObjDestroy(sign);
810 }
811
812 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest221, TestSize.Level0)
813 {
814 HcfSign *sign = NULL;
815 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
816
817 ASSERT_EQ(res, HCF_SUCCESS);
818 ASSERT_NE(sign, nullptr);
819
820 res = sign->init(NULL, NULL, ecc256KeyPair_->priKey);
821
822 ASSERT_EQ(res, HCF_INVALID_PARAMS);
823
824 HcfObjDestroy(sign);
825 }
826
827 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest222, TestSize.Level0)
828 {
829 HcfSign *sign = NULL;
830 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
831
832 ASSERT_EQ(res, HCF_SUCCESS);
833 ASSERT_NE(sign, nullptr);
834
835 res = sign->init((HcfSign *)(&obj), NULL, ecc256KeyPair_->priKey);
836
837 ASSERT_EQ(res, HCF_INVALID_PARAMS);
838
839 HcfObjDestroy(sign);
840 }
841
842 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest223, TestSize.Level0)
843 {
844 HcfSign *sign = NULL;
845 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
846
847 ASSERT_EQ(res, HCF_SUCCESS);
848 ASSERT_NE(sign, nullptr);
849
850 res = sign->init(sign, NULL, NULL);
851
852 ASSERT_EQ(res, HCF_INVALID_PARAMS);
853
854 HcfObjDestroy(sign);
855 }
856
857 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest224, TestSize.Level0)
858 {
859 HcfSign *sign = NULL;
860 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
861
862 ASSERT_EQ(res, HCF_SUCCESS);
863 ASSERT_NE(sign, nullptr);
864
865 res = sign->init(sign, NULL, (HcfPriKey *)(&obj));
866
867 ASSERT_EQ(res, HCF_INVALID_PARAMS);
868
869 HcfObjDestroy(sign);
870 }
871
872 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest301, TestSize.Level0)
873 {
874 HcfSign *sign = NULL;
875 int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
876
877 ASSERT_EQ(res, HCF_SUCCESS);
878 ASSERT_NE(sign, nullptr);
879
880 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
881
882 ASSERT_EQ(res, HCF_SUCCESS);
883
884 res = sign->update(sign, &mockInput);
885
886 ASSERT_EQ(res, HCF_SUCCESS);
887
888 HcfObjDestroy(sign);
889 }
890
891 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest302, TestSize.Level0)
892 {
893 HcfSign *sign = NULL;
894 int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
895
896 ASSERT_EQ(res, HCF_SUCCESS);
897 ASSERT_NE(sign, nullptr);
898
899 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
900
901 ASSERT_EQ(res, HCF_SUCCESS);
902
903 res = sign->update(sign, &mockInput);
904
905 ASSERT_EQ(res, HCF_SUCCESS);
906
907 HcfObjDestroy(sign);
908 }
909
910 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest303, TestSize.Level0)
911 {
912 HcfSign *sign = NULL;
913 int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
914
915 ASSERT_EQ(res, HCF_SUCCESS);
916 ASSERT_NE(sign, nullptr);
917
918 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
919
920 ASSERT_EQ(res, HCF_SUCCESS);
921
922 res = sign->update(sign, &mockInput);
923
924 ASSERT_EQ(res, HCF_SUCCESS);
925
926 HcfObjDestroy(sign);
927 }
928
929 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest304, TestSize.Level0)
930 {
931 HcfSign *sign = NULL;
932 int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
933
934 ASSERT_EQ(res, HCF_SUCCESS);
935 ASSERT_NE(sign, nullptr);
936
937 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
938
939 ASSERT_EQ(res, HCF_SUCCESS);
940
941 res = sign->update(sign, &mockInput);
942
943 ASSERT_EQ(res, HCF_SUCCESS);
944
945 HcfObjDestroy(sign);
946 }
947
948 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest305, TestSize.Level0)
949 {
950 HcfSign *sign = NULL;
951 int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
952
953 ASSERT_EQ(res, HCF_SUCCESS);
954 ASSERT_NE(sign, nullptr);
955
956 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
957
958 ASSERT_EQ(res, HCF_SUCCESS);
959
960 res = sign->update(sign, &mockInput);
961
962 ASSERT_EQ(res, HCF_SUCCESS);
963
964 HcfObjDestroy(sign);
965 }
966
967 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest306, TestSize.Level0)
968 {
969 HcfSign *sign = NULL;
970 int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
971
972 ASSERT_EQ(res, HCF_SUCCESS);
973 ASSERT_NE(sign, nullptr);
974
975 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
976
977 ASSERT_EQ(res, HCF_SUCCESS);
978
979 res = sign->update(sign, &mockInput);
980
981 ASSERT_EQ(res, HCF_SUCCESS);
982
983 HcfObjDestroy(sign);
984 }
985
986 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest307, TestSize.Level0)
987 {
988 HcfSign *sign = NULL;
989 int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
990
991 ASSERT_EQ(res, HCF_SUCCESS);
992 ASSERT_NE(sign, nullptr);
993
994 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
995
996 ASSERT_EQ(res, HCF_SUCCESS);
997
998 res = sign->update(sign, &mockInput);
999
1000 ASSERT_EQ(res, HCF_SUCCESS);
1001
1002 HcfObjDestroy(sign);
1003 }
1004
1005 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest308, TestSize.Level0)
1006 {
1007 HcfSign *sign = NULL;
1008 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1009
1010 ASSERT_EQ(res, HCF_SUCCESS);
1011 ASSERT_NE(sign, nullptr);
1012
1013 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1014
1015 ASSERT_EQ(res, HCF_SUCCESS);
1016
1017 res = sign->update(sign, &mockInput);
1018
1019 ASSERT_EQ(res, HCF_SUCCESS);
1020
1021 HcfObjDestroy(sign);
1022 }
1023
1024 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest309, TestSize.Level0)
1025 {
1026 HcfSign *sign = NULL;
1027 int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
1028
1029 ASSERT_EQ(res, HCF_SUCCESS);
1030 ASSERT_NE(sign, nullptr);
1031
1032 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1033
1034 ASSERT_EQ(res, HCF_SUCCESS);
1035
1036 res = sign->update(sign, &mockInput);
1037
1038 ASSERT_EQ(res, HCF_SUCCESS);
1039
1040 HcfObjDestroy(sign);
1041 }
1042
1043 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest310, TestSize.Level0)
1044 {
1045 HcfSign *sign = NULL;
1046 int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
1047
1048 ASSERT_EQ(res, HCF_SUCCESS);
1049 ASSERT_NE(sign, nullptr);
1050
1051 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1052
1053 ASSERT_EQ(res, HCF_SUCCESS);
1054
1055 res = sign->update(sign, &mockInput);
1056
1057 ASSERT_EQ(res, HCF_SUCCESS);
1058
1059 HcfObjDestroy(sign);
1060 }
1061
1062 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest311, TestSize.Level0)
1063 {
1064 HcfSign *sign = NULL;
1065 int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
1066
1067 ASSERT_EQ(res, HCF_SUCCESS);
1068 ASSERT_NE(sign, nullptr);
1069
1070 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
1071
1072 ASSERT_EQ(res, HCF_SUCCESS);
1073
1074 res = sign->update(sign, &mockInput);
1075
1076 ASSERT_EQ(res, HCF_SUCCESS);
1077
1078 HcfObjDestroy(sign);
1079 }
1080
1081 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest312, TestSize.Level0)
1082 {
1083 HcfSign *sign = NULL;
1084 int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
1085
1086 ASSERT_EQ(res, HCF_SUCCESS);
1087 ASSERT_NE(sign, nullptr);
1088
1089 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
1090
1091 ASSERT_EQ(res, HCF_SUCCESS);
1092
1093 res = sign->update(sign, &mockInput);
1094
1095 ASSERT_EQ(res, HCF_SUCCESS);
1096
1097 HcfObjDestroy(sign);
1098 }
1099
1100 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest313, TestSize.Level0)
1101 {
1102 HcfSign *sign = NULL;
1103 int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
1104
1105 ASSERT_EQ(res, HCF_SUCCESS);
1106 ASSERT_NE(sign, nullptr);
1107
1108 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
1109
1110 ASSERT_EQ(res, HCF_SUCCESS);
1111
1112 res = sign->update(sign, &mockInput);
1113
1114 ASSERT_EQ(res, HCF_SUCCESS);
1115
1116 HcfObjDestroy(sign);
1117 }
1118
1119 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest314, TestSize.Level0)
1120 {
1121 HcfSign *sign = NULL;
1122 int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
1123
1124 ASSERT_EQ(res, HCF_SUCCESS);
1125 ASSERT_NE(sign, nullptr);
1126
1127 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
1128
1129 ASSERT_EQ(res, HCF_SUCCESS);
1130
1131 res = sign->update(sign, &mockInput);
1132
1133 ASSERT_EQ(res, HCF_SUCCESS);
1134
1135 HcfObjDestroy(sign);
1136 }
1137
1138 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest315, TestSize.Level0)
1139 {
1140 HcfSign *sign = NULL;
1141 int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
1142
1143 ASSERT_EQ(res, HCF_SUCCESS);
1144 ASSERT_NE(sign, nullptr);
1145
1146 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
1147
1148 ASSERT_EQ(res, HCF_SUCCESS);
1149
1150 res = sign->update(sign, &mockInput);
1151
1152 ASSERT_EQ(res, HCF_SUCCESS);
1153
1154 HcfObjDestroy(sign);
1155 }
1156
1157 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest316, TestSize.Level0)
1158 {
1159 HcfSign *sign = NULL;
1160 int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
1161
1162 ASSERT_EQ(res, HCF_SUCCESS);
1163 ASSERT_NE(sign, nullptr);
1164
1165 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
1166
1167 ASSERT_EQ(res, HCF_SUCCESS);
1168
1169 res = sign->update(sign, &mockInput);
1170
1171 ASSERT_EQ(res, HCF_SUCCESS);
1172
1173 HcfObjDestroy(sign);
1174 }
1175
1176 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest317, TestSize.Level0)
1177 {
1178 HcfSign *sign = NULL;
1179 int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
1180
1181 ASSERT_EQ(res, HCF_SUCCESS);
1182 ASSERT_NE(sign, nullptr);
1183
1184 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
1185
1186 ASSERT_EQ(res, HCF_SUCCESS);
1187
1188 res = sign->update(sign, &mockInput);
1189
1190 ASSERT_EQ(res, HCF_SUCCESS);
1191
1192 HcfObjDestroy(sign);
1193 }
1194
1195 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest318, TestSize.Level0)
1196 {
1197 HcfSign *sign = NULL;
1198 int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
1199
1200 ASSERT_EQ(res, HCF_SUCCESS);
1201 ASSERT_NE(sign, nullptr);
1202
1203 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
1204
1205 ASSERT_EQ(res, HCF_SUCCESS);
1206
1207 res = sign->update(sign, &mockInput);
1208
1209 ASSERT_EQ(res, HCF_SUCCESS);
1210
1211 HcfObjDestroy(sign);
1212 }
1213
1214 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest319, TestSize.Level0)
1215 {
1216 HcfSign *sign = NULL;
1217 int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
1218
1219 ASSERT_EQ(res, HCF_SUCCESS);
1220 ASSERT_NE(sign, nullptr);
1221
1222 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
1223
1224 ASSERT_EQ(res, HCF_SUCCESS);
1225
1226 res = sign->update(sign, &mockInput);
1227
1228 ASSERT_EQ(res, HCF_SUCCESS);
1229
1230 HcfObjDestroy(sign);
1231 }
1232
1233 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest320, TestSize.Level0)
1234 {
1235 HcfSign *sign = NULL;
1236 int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
1237
1238 ASSERT_EQ(res, HCF_SUCCESS);
1239 ASSERT_NE(sign, nullptr);
1240
1241 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
1242
1243 ASSERT_EQ(res, HCF_SUCCESS);
1244
1245 res = sign->update(sign, &mockInput);
1246
1247 ASSERT_EQ(res, HCF_SUCCESS);
1248
1249 HcfObjDestroy(sign);
1250 }
1251
1252 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest321, TestSize.Level0)
1253 {
1254 HcfSign *sign = NULL;
1255 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1256
1257 ASSERT_EQ(res, HCF_SUCCESS);
1258 ASSERT_NE(sign, nullptr);
1259
1260 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1261
1262 ASSERT_EQ(res, HCF_SUCCESS);
1263
1264 res = sign->update(NULL, &mockInput);
1265
1266 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1267
1268 HcfObjDestroy(sign);
1269 }
1270
1271 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest322, TestSize.Level0)
1272 {
1273 HcfSign *sign = NULL;
1274 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1275
1276 ASSERT_EQ(res, HCF_SUCCESS);
1277 ASSERT_NE(sign, nullptr);
1278
1279 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1280
1281 ASSERT_EQ(res, HCF_SUCCESS);
1282
1283 res = sign->update((HcfSign *)(&obj), &mockInput);
1284
1285 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1286
1287 HcfObjDestroy(sign);
1288 }
1289
1290 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest323, TestSize.Level0)
1291 {
1292 HcfSign *sign = NULL;
1293 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1294
1295 ASSERT_EQ(res, HCF_SUCCESS);
1296 ASSERT_NE(sign, nullptr);
1297
1298 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1299
1300 ASSERT_EQ(res, HCF_SUCCESS);
1301
1302 res = sign->update(sign, NULL);
1303
1304 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1305
1306 HcfObjDestroy(sign);
1307 }
1308
1309 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest324, TestSize.Level0)
1310 {
1311 HcfSign *sign = NULL;
1312 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1313
1314 ASSERT_EQ(res, HCF_SUCCESS);
1315 ASSERT_NE(sign, nullptr);
1316
1317 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1318
1319 ASSERT_EQ(res, HCF_SUCCESS);
1320
1321 HcfBlob input = {
1322 .data = NULL,
1323 .len = 1
1324 };
1325 res = sign->update(sign, &input);
1326
1327 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1328
1329 HcfObjDestroy(sign);
1330 }
1331
1332 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest325, TestSize.Level0)
1333 {
1334 HcfSign *sign = NULL;
1335 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1336
1337 ASSERT_EQ(res, HCF_SUCCESS);
1338 ASSERT_NE(sign, nullptr);
1339
1340 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1341
1342 ASSERT_EQ(res, HCF_SUCCESS);
1343
1344 HcfBlob input = {
1345 .data = (uint8_t *)g_mockMessage,
1346 .len = 0
1347 };
1348 res = sign->update(sign, &input);
1349
1350 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1351
1352 HcfObjDestroy(sign);
1353 }
1354
1355 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest401, 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 free(out.data);
1382 HcfObjDestroy(sign);
1383 }
1384
1385 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest402, TestSize.Level0)
1386 {
1387 HcfSign *sign = NULL;
1388 int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
1389
1390 ASSERT_EQ(res, HCF_SUCCESS);
1391 ASSERT_NE(sign, nullptr);
1392
1393 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
1394
1395 ASSERT_EQ(res, HCF_SUCCESS);
1396
1397 res = sign->update(sign, &mockInput);
1398
1399 ASSERT_EQ(res, HCF_SUCCESS);
1400
1401 HcfBlob out = {
1402 .data = NULL,
1403 .len = 0
1404 };
1405 res = sign->sign(sign, NULL, &out);
1406
1407 ASSERT_EQ(res, HCF_SUCCESS);
1408 ASSERT_NE(out.data, nullptr);
1409 ASSERT_NE(out.len, (const unsigned int)0);
1410
1411 free(out.data);
1412 HcfObjDestroy(sign);
1413 }
1414
1415 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest403, TestSize.Level0)
1416 {
1417 HcfSign *sign = NULL;
1418 int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
1419
1420 ASSERT_EQ(res, HCF_SUCCESS);
1421 ASSERT_NE(sign, nullptr);
1422
1423 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
1424
1425 ASSERT_EQ(res, HCF_SUCCESS);
1426
1427 res = sign->update(sign, &mockInput);
1428
1429 ASSERT_EQ(res, HCF_SUCCESS);
1430
1431 HcfBlob out = {
1432 .data = NULL,
1433 .len = 0
1434 };
1435 res = sign->sign(sign, NULL, &out);
1436
1437 ASSERT_EQ(res, HCF_SUCCESS);
1438 ASSERT_NE(out.data, nullptr);
1439 ASSERT_NE(out.len, (const unsigned int)0);
1440
1441 free(out.data);
1442 HcfObjDestroy(sign);
1443 }
1444
1445 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest404, TestSize.Level0)
1446 {
1447 HcfSign *sign = NULL;
1448 int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
1449
1450 ASSERT_EQ(res, HCF_SUCCESS);
1451 ASSERT_NE(sign, nullptr);
1452
1453 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
1454
1455 ASSERT_EQ(res, HCF_SUCCESS);
1456
1457 res = sign->update(sign, &mockInput);
1458
1459 ASSERT_EQ(res, HCF_SUCCESS);
1460
1461 HcfBlob out = {
1462 .data = NULL,
1463 .len = 0
1464 };
1465 res = sign->sign(sign, NULL, &out);
1466
1467 ASSERT_EQ(res, HCF_SUCCESS);
1468 ASSERT_NE(out.data, nullptr);
1469 ASSERT_NE(out.len, (const unsigned int)0);
1470
1471 free(out.data);
1472 HcfObjDestroy(sign);
1473 }
1474
1475 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest405, TestSize.Level0)
1476 {
1477 HcfSign *sign = NULL;
1478 int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
1479
1480 ASSERT_EQ(res, HCF_SUCCESS);
1481 ASSERT_NE(sign, nullptr);
1482
1483 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
1484
1485 ASSERT_EQ(res, HCF_SUCCESS);
1486
1487 res = sign->update(sign, &mockInput);
1488
1489 ASSERT_EQ(res, HCF_SUCCESS);
1490
1491 HcfBlob out = {
1492 .data = NULL,
1493 .len = 0
1494 };
1495 res = sign->sign(sign, NULL, &out);
1496
1497 ASSERT_EQ(res, HCF_SUCCESS);
1498 ASSERT_NE(out.data, nullptr);
1499 ASSERT_NE(out.len, (const unsigned int)0);
1500
1501 free(out.data);
1502 HcfObjDestroy(sign);
1503 }
1504
1505 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest406, TestSize.Level0)
1506 {
1507 HcfSign *sign = NULL;
1508 int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
1509
1510 ASSERT_EQ(res, HCF_SUCCESS);
1511 ASSERT_NE(sign, nullptr);
1512
1513 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1514
1515 ASSERT_EQ(res, HCF_SUCCESS);
1516
1517 res = sign->update(sign, &mockInput);
1518
1519 ASSERT_EQ(res, HCF_SUCCESS);
1520
1521 HcfBlob out = {
1522 .data = NULL,
1523 .len = 0
1524 };
1525 res = sign->sign(sign, NULL, &out);
1526
1527 ASSERT_EQ(res, HCF_SUCCESS);
1528 ASSERT_NE(out.data, nullptr);
1529 ASSERT_NE(out.len, (const unsigned int)0);
1530
1531 free(out.data);
1532 HcfObjDestroy(sign);
1533 }
1534
1535 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest407, TestSize.Level0)
1536 {
1537 HcfSign *sign = NULL;
1538 int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
1539
1540 ASSERT_EQ(res, HCF_SUCCESS);
1541 ASSERT_NE(sign, nullptr);
1542
1543 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1544
1545 ASSERT_EQ(res, HCF_SUCCESS);
1546
1547 res = sign->update(sign, &mockInput);
1548
1549 ASSERT_EQ(res, HCF_SUCCESS);
1550
1551 HcfBlob out = {
1552 .data = NULL,
1553 .len = 0
1554 };
1555 res = sign->sign(sign, NULL, &out);
1556
1557 ASSERT_EQ(res, HCF_SUCCESS);
1558 ASSERT_NE(out.data, nullptr);
1559 ASSERT_NE(out.len, (const unsigned int)0);
1560
1561 free(out.data);
1562 HcfObjDestroy(sign);
1563 }
1564
1565 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest408, TestSize.Level0)
1566 {
1567 HcfSign *sign = NULL;
1568 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1569
1570 ASSERT_EQ(res, HCF_SUCCESS);
1571 ASSERT_NE(sign, nullptr);
1572
1573 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1574
1575 ASSERT_EQ(res, HCF_SUCCESS);
1576
1577 res = sign->update(sign, &mockInput);
1578
1579 ASSERT_EQ(res, HCF_SUCCESS);
1580
1581 HcfBlob out = {
1582 .data = NULL,
1583 .len = 0
1584 };
1585 res = sign->sign(sign, NULL, &out);
1586
1587 ASSERT_EQ(res, HCF_SUCCESS);
1588 ASSERT_NE(out.data, nullptr);
1589 ASSERT_NE(out.len, (const unsigned int)0);
1590
1591 free(out.data);
1592 HcfObjDestroy(sign);
1593 }
1594
1595 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest409, TestSize.Level0)
1596 {
1597 HcfSign *sign = NULL;
1598 int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
1599
1600 ASSERT_EQ(res, HCF_SUCCESS);
1601 ASSERT_NE(sign, nullptr);
1602
1603 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1604
1605 ASSERT_EQ(res, HCF_SUCCESS);
1606
1607 res = sign->update(sign, &mockInput);
1608
1609 ASSERT_EQ(res, HCF_SUCCESS);
1610
1611 HcfBlob out = {
1612 .data = NULL,
1613 .len = 0
1614 };
1615 res = sign->sign(sign, NULL, &out);
1616
1617 ASSERT_EQ(res, HCF_SUCCESS);
1618 ASSERT_NE(out.data, nullptr);
1619 ASSERT_NE(out.len, (const unsigned int)0);
1620
1621 free(out.data);
1622 HcfObjDestroy(sign);
1623 }
1624
1625 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest410, TestSize.Level0)
1626 {
1627 HcfSign *sign = NULL;
1628 int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
1629
1630 ASSERT_EQ(res, HCF_SUCCESS);
1631 ASSERT_NE(sign, nullptr);
1632
1633 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
1634
1635 ASSERT_EQ(res, HCF_SUCCESS);
1636
1637 res = sign->update(sign, &mockInput);
1638
1639 ASSERT_EQ(res, HCF_SUCCESS);
1640
1641 HcfBlob out = {
1642 .data = NULL,
1643 .len = 0
1644 };
1645 res = sign->sign(sign, NULL, &out);
1646
1647 ASSERT_EQ(res, HCF_SUCCESS);
1648 ASSERT_NE(out.data, nullptr);
1649 ASSERT_NE(out.len, (const unsigned int)0);
1650
1651 free(out.data);
1652 HcfObjDestroy(sign);
1653 }
1654
1655 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest411, TestSize.Level0)
1656 {
1657 HcfSign *sign = NULL;
1658 int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
1659
1660 ASSERT_EQ(res, HCF_SUCCESS);
1661 ASSERT_NE(sign, nullptr);
1662
1663 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
1664
1665 ASSERT_EQ(res, HCF_SUCCESS);
1666
1667 res = sign->update(sign, &mockInput);
1668
1669 ASSERT_EQ(res, HCF_SUCCESS);
1670
1671 HcfBlob out = {
1672 .data = NULL,
1673 .len = 0
1674 };
1675 res = sign->sign(sign, NULL, &out);
1676
1677 ASSERT_EQ(res, HCF_SUCCESS);
1678 ASSERT_NE(out.data, nullptr);
1679 ASSERT_NE(out.len, (const unsigned int)0);
1680
1681 free(out.data);
1682 HcfObjDestroy(sign);
1683 }
1684
1685 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest412, TestSize.Level0)
1686 {
1687 HcfSign *sign = NULL;
1688 int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
1689
1690 ASSERT_EQ(res, HCF_SUCCESS);
1691 ASSERT_NE(sign, nullptr);
1692
1693 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
1694
1695 ASSERT_EQ(res, HCF_SUCCESS);
1696
1697 res = sign->update(sign, &mockInput);
1698
1699 ASSERT_EQ(res, HCF_SUCCESS);
1700
1701 HcfBlob out = {
1702 .data = NULL,
1703 .len = 0
1704 };
1705 res = sign->sign(sign, NULL, &out);
1706
1707 ASSERT_EQ(res, HCF_SUCCESS);
1708 ASSERT_NE(out.data, nullptr);
1709 ASSERT_NE(out.len, (const unsigned int)0);
1710
1711 free(out.data);
1712 HcfObjDestroy(sign);
1713 }
1714
1715 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest413, TestSize.Level0)
1716 {
1717 HcfSign *sign = NULL;
1718 int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
1719
1720 ASSERT_EQ(res, HCF_SUCCESS);
1721 ASSERT_NE(sign, nullptr);
1722
1723 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
1724
1725 ASSERT_EQ(res, HCF_SUCCESS);
1726
1727 res = sign->update(sign, &mockInput);
1728
1729 ASSERT_EQ(res, HCF_SUCCESS);
1730
1731 HcfBlob out = {
1732 .data = NULL,
1733 .len = 0
1734 };
1735 res = sign->sign(sign, NULL, &out);
1736
1737 ASSERT_EQ(res, HCF_SUCCESS);
1738 ASSERT_NE(out.data, nullptr);
1739 ASSERT_NE(out.len, (const unsigned int)0);
1740
1741 free(out.data);
1742 HcfObjDestroy(sign);
1743 }
1744
1745 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest414, TestSize.Level0)
1746 {
1747 HcfSign *sign = NULL;
1748 int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
1749
1750 ASSERT_EQ(res, HCF_SUCCESS);
1751 ASSERT_NE(sign, nullptr);
1752
1753 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
1754
1755 ASSERT_EQ(res, HCF_SUCCESS);
1756
1757 res = sign->update(sign, &mockInput);
1758
1759 ASSERT_EQ(res, HCF_SUCCESS);
1760
1761 HcfBlob out = {
1762 .data = NULL,
1763 .len = 0
1764 };
1765 res = sign->sign(sign, NULL, &out);
1766
1767 ASSERT_EQ(res, HCF_SUCCESS);
1768 ASSERT_NE(out.data, nullptr);
1769 ASSERT_NE(out.len, (const unsigned int)0);
1770
1771 free(out.data);
1772 HcfObjDestroy(sign);
1773 }
1774
1775 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest415, TestSize.Level0)
1776 {
1777 HcfSign *sign = NULL;
1778 int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
1779
1780 ASSERT_EQ(res, HCF_SUCCESS);
1781 ASSERT_NE(sign, nullptr);
1782
1783 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
1784
1785 ASSERT_EQ(res, HCF_SUCCESS);
1786
1787 res = sign->update(sign, &mockInput);
1788
1789 ASSERT_EQ(res, HCF_SUCCESS);
1790
1791 HcfBlob out = {
1792 .data = NULL,
1793 .len = 0
1794 };
1795 res = sign->sign(sign, NULL, &out);
1796
1797 ASSERT_EQ(res, HCF_SUCCESS);
1798 ASSERT_NE(out.data, nullptr);
1799 ASSERT_NE(out.len, (const unsigned int)0);
1800
1801 free(out.data);
1802 HcfObjDestroy(sign);
1803 }
1804
1805 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest416, TestSize.Level0)
1806 {
1807 HcfSign *sign = NULL;
1808 int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
1809
1810 ASSERT_EQ(res, HCF_SUCCESS);
1811 ASSERT_NE(sign, nullptr);
1812
1813 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
1814
1815 ASSERT_EQ(res, HCF_SUCCESS);
1816
1817 res = sign->update(sign, &mockInput);
1818
1819 ASSERT_EQ(res, HCF_SUCCESS);
1820
1821 HcfBlob out = {
1822 .data = NULL,
1823 .len = 0
1824 };
1825 res = sign->sign(sign, NULL, &out);
1826
1827 ASSERT_EQ(res, HCF_SUCCESS);
1828 ASSERT_NE(out.data, nullptr);
1829 ASSERT_NE(out.len, (const unsigned int)0);
1830
1831 free(out.data);
1832 HcfObjDestroy(sign);
1833 }
1834
1835 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest417, TestSize.Level0)
1836 {
1837 HcfSign *sign = NULL;
1838 int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
1839
1840 ASSERT_EQ(res, HCF_SUCCESS);
1841 ASSERT_NE(sign, nullptr);
1842
1843 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
1844
1845 ASSERT_EQ(res, HCF_SUCCESS);
1846
1847 res = sign->update(sign, &mockInput);
1848
1849 ASSERT_EQ(res, HCF_SUCCESS);
1850
1851 HcfBlob out = {
1852 .data = NULL,
1853 .len = 0
1854 };
1855 res = sign->sign(sign, NULL, &out);
1856
1857 ASSERT_EQ(res, HCF_SUCCESS);
1858 ASSERT_NE(out.data, nullptr);
1859 ASSERT_NE(out.len, (const unsigned int)0);
1860
1861 free(out.data);
1862 HcfObjDestroy(sign);
1863 }
1864
1865 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest418, TestSize.Level0)
1866 {
1867 HcfSign *sign = NULL;
1868 int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
1869
1870 ASSERT_EQ(res, HCF_SUCCESS);
1871 ASSERT_NE(sign, nullptr);
1872
1873 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
1874
1875 ASSERT_EQ(res, HCF_SUCCESS);
1876
1877 res = sign->update(sign, &mockInput);
1878
1879 ASSERT_EQ(res, HCF_SUCCESS);
1880
1881 HcfBlob out = {
1882 .data = NULL,
1883 .len = 0
1884 };
1885 res = sign->sign(sign, NULL, &out);
1886
1887 ASSERT_EQ(res, HCF_SUCCESS);
1888 ASSERT_NE(out.data, nullptr);
1889 ASSERT_NE(out.len, (const unsigned int)0);
1890
1891 free(out.data);
1892 HcfObjDestroy(sign);
1893 }
1894
1895 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest419, TestSize.Level0)
1896 {
1897 HcfSign *sign = NULL;
1898 int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
1899
1900 ASSERT_EQ(res, HCF_SUCCESS);
1901 ASSERT_NE(sign, nullptr);
1902
1903 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
1904
1905 ASSERT_EQ(res, HCF_SUCCESS);
1906
1907 res = sign->update(sign, &mockInput);
1908
1909 ASSERT_EQ(res, HCF_SUCCESS);
1910
1911 HcfBlob out = {
1912 .data = NULL,
1913 .len = 0
1914 };
1915 res = sign->sign(sign, NULL, &out);
1916
1917 ASSERT_EQ(res, HCF_SUCCESS);
1918 ASSERT_NE(out.data, nullptr);
1919 ASSERT_NE(out.len, (const unsigned int)0);
1920
1921 free(out.data);
1922 HcfObjDestroy(sign);
1923 }
1924
1925 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest420, TestSize.Level0)
1926 {
1927 HcfSign *sign = NULL;
1928 int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
1929
1930 ASSERT_EQ(res, HCF_SUCCESS);
1931 ASSERT_NE(sign, nullptr);
1932
1933 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
1934
1935 ASSERT_EQ(res, HCF_SUCCESS);
1936
1937 res = sign->update(sign, &mockInput);
1938
1939 ASSERT_EQ(res, HCF_SUCCESS);
1940
1941 HcfBlob out = {
1942 .data = NULL,
1943 .len = 0
1944 };
1945 res = sign->sign(sign, NULL, &out);
1946
1947 ASSERT_EQ(res, HCF_SUCCESS);
1948 ASSERT_NE(out.data, nullptr);
1949 ASSERT_NE(out.len, (const unsigned int)0);
1950
1951 free(out.data);
1952 HcfObjDestroy(sign);
1953 }
1954
1955 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest421, TestSize.Level0)
1956 {
1957 HcfSign *sign = NULL;
1958 int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
1959
1960 ASSERT_EQ(res, HCF_SUCCESS);
1961 ASSERT_NE(sign, nullptr);
1962
1963 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
1964
1965 ASSERT_EQ(res, HCF_SUCCESS);
1966
1967 HcfBlob out = {
1968 .data = NULL,
1969 .len = 0
1970 };
1971 res = sign->sign(sign, &mockInput, &out);
1972
1973 ASSERT_EQ(res, HCF_SUCCESS);
1974 ASSERT_NE(out.data, nullptr);
1975 ASSERT_NE(out.len, (const unsigned int)0);
1976
1977 free(out.data);
1978 HcfObjDestroy(sign);
1979 }
1980
1981 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest422, TestSize.Level0)
1982 {
1983 HcfSign *sign = NULL;
1984 int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
1985
1986 ASSERT_EQ(res, HCF_SUCCESS);
1987 ASSERT_NE(sign, nullptr);
1988
1989 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
1990
1991 ASSERT_EQ(res, HCF_SUCCESS);
1992
1993 HcfBlob out = {
1994 .data = NULL,
1995 .len = 0
1996 };
1997 res = sign->sign(sign, &mockInput, &out);
1998
1999 ASSERT_EQ(res, HCF_SUCCESS);
2000 ASSERT_NE(out.data, nullptr);
2001 ASSERT_NE(out.len, (const unsigned int)0);
2002
2003 free(out.data);
2004 HcfObjDestroy(sign);
2005 }
2006
2007 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest423, TestSize.Level0)
2008 {
2009 HcfSign *sign = NULL;
2010 int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
2011
2012 ASSERT_EQ(res, HCF_SUCCESS);
2013 ASSERT_NE(sign, nullptr);
2014
2015 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
2016
2017 ASSERT_EQ(res, HCF_SUCCESS);
2018
2019 HcfBlob out = {
2020 .data = NULL,
2021 .len = 0
2022 };
2023 res = sign->sign(sign, &mockInput, &out);
2024
2025 ASSERT_EQ(res, HCF_SUCCESS);
2026 ASSERT_NE(out.data, nullptr);
2027 ASSERT_NE(out.len, (const unsigned int)0);
2028
2029 free(out.data);
2030 HcfObjDestroy(sign);
2031 }
2032
2033 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest424, TestSize.Level0)
2034 {
2035 HcfSign *sign = NULL;
2036 int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
2037
2038 ASSERT_EQ(res, HCF_SUCCESS);
2039 ASSERT_NE(sign, nullptr);
2040
2041 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
2042
2043 ASSERT_EQ(res, HCF_SUCCESS);
2044
2045 HcfBlob out = {
2046 .data = NULL,
2047 .len = 0
2048 };
2049 res = sign->sign(sign, &mockInput, &out);
2050
2051 ASSERT_EQ(res, HCF_SUCCESS);
2052 ASSERT_NE(out.data, nullptr);
2053 ASSERT_NE(out.len, (const unsigned int)0);
2054
2055 free(out.data);
2056 HcfObjDestroy(sign);
2057 }
2058
2059 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest425, TestSize.Level0)
2060 {
2061 HcfSign *sign = NULL;
2062 int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
2063
2064 ASSERT_EQ(res, HCF_SUCCESS);
2065 ASSERT_NE(sign, nullptr);
2066
2067 res = sign->init(sign, NULL, ecc224KeyPair_->priKey);
2068
2069 ASSERT_EQ(res, HCF_SUCCESS);
2070
2071 HcfBlob out = {
2072 .data = NULL,
2073 .len = 0
2074 };
2075 res = sign->sign(sign, &mockInput, &out);
2076
2077 ASSERT_EQ(res, HCF_SUCCESS);
2078 ASSERT_NE(out.data, nullptr);
2079 ASSERT_NE(out.len, (const unsigned int)0);
2080
2081 free(out.data);
2082 HcfObjDestroy(sign);
2083 }
2084
2085 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest426, TestSize.Level0)
2086 {
2087 HcfSign *sign = NULL;
2088 int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
2089
2090 ASSERT_EQ(res, HCF_SUCCESS);
2091 ASSERT_NE(sign, nullptr);
2092
2093 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2094
2095 ASSERT_EQ(res, HCF_SUCCESS);
2096
2097 HcfBlob out = {
2098 .data = NULL,
2099 .len = 0
2100 };
2101 res = sign->sign(sign, &mockInput, &out);
2102
2103 ASSERT_EQ(res, HCF_SUCCESS);
2104 ASSERT_NE(out.data, nullptr);
2105 ASSERT_NE(out.len, (const unsigned int)0);
2106
2107 free(out.data);
2108 HcfObjDestroy(sign);
2109 }
2110
2111 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest427, TestSize.Level0)
2112 {
2113 HcfSign *sign = NULL;
2114 int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
2115
2116 ASSERT_EQ(res, HCF_SUCCESS);
2117 ASSERT_NE(sign, nullptr);
2118
2119 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2120
2121 ASSERT_EQ(res, HCF_SUCCESS);
2122
2123 HcfBlob out = {
2124 .data = NULL,
2125 .len = 0
2126 };
2127 res = sign->sign(sign, &mockInput, &out);
2128
2129 ASSERT_EQ(res, HCF_SUCCESS);
2130 ASSERT_NE(out.data, nullptr);
2131 ASSERT_NE(out.len, (const unsigned int)0);
2132
2133 free(out.data);
2134 HcfObjDestroy(sign);
2135 }
2136
2137 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest428, TestSize.Level0)
2138 {
2139 HcfSign *sign = NULL;
2140 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
2141
2142 ASSERT_EQ(res, HCF_SUCCESS);
2143 ASSERT_NE(sign, nullptr);
2144
2145 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2146
2147 ASSERT_EQ(res, HCF_SUCCESS);
2148
2149 HcfBlob out = {
2150 .data = NULL,
2151 .len = 0
2152 };
2153 res = sign->sign(sign, &mockInput, &out);
2154
2155 ASSERT_EQ(res, HCF_SUCCESS);
2156 ASSERT_NE(out.data, nullptr);
2157 ASSERT_NE(out.len, (const unsigned int)0);
2158
2159 free(out.data);
2160 HcfObjDestroy(sign);
2161 }
2162
2163 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest429, TestSize.Level0)
2164 {
2165 HcfSign *sign = NULL;
2166 int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
2167
2168 ASSERT_EQ(res, HCF_SUCCESS);
2169 ASSERT_NE(sign, nullptr);
2170
2171 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2172
2173 ASSERT_EQ(res, HCF_SUCCESS);
2174
2175 HcfBlob out = {
2176 .data = NULL,
2177 .len = 0
2178 };
2179 res = sign->sign(sign, &mockInput, &out);
2180
2181 ASSERT_EQ(res, HCF_SUCCESS);
2182 ASSERT_NE(out.data, nullptr);
2183 ASSERT_NE(out.len, (const unsigned int)0);
2184
2185 free(out.data);
2186 HcfObjDestroy(sign);
2187 }
2188
2189 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest430, TestSize.Level0)
2190 {
2191 HcfSign *sign = NULL;
2192 int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
2193
2194 ASSERT_EQ(res, HCF_SUCCESS);
2195 ASSERT_NE(sign, nullptr);
2196
2197 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2198
2199 ASSERT_EQ(res, HCF_SUCCESS);
2200
2201 HcfBlob out = {
2202 .data = NULL,
2203 .len = 0
2204 };
2205 res = sign->sign(sign, &mockInput, &out);
2206
2207 ASSERT_EQ(res, HCF_SUCCESS);
2208 ASSERT_NE(out.data, nullptr);
2209 ASSERT_NE(out.len, (const unsigned int)0);
2210
2211 free(out.data);
2212 HcfObjDestroy(sign);
2213 }
2214
2215 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest431, TestSize.Level0)
2216 {
2217 HcfSign *sign = NULL;
2218 int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
2219
2220 ASSERT_EQ(res, HCF_SUCCESS);
2221 ASSERT_NE(sign, nullptr);
2222
2223 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
2224
2225 ASSERT_EQ(res, HCF_SUCCESS);
2226
2227 HcfBlob out = {
2228 .data = NULL,
2229 .len = 0
2230 };
2231 res = sign->sign(sign, &mockInput, &out);
2232
2233 ASSERT_EQ(res, HCF_SUCCESS);
2234 ASSERT_NE(out.data, nullptr);
2235 ASSERT_NE(out.len, (const unsigned int)0);
2236
2237 free(out.data);
2238 HcfObjDestroy(sign);
2239 }
2240
2241 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest432, TestSize.Level0)
2242 {
2243 HcfSign *sign = NULL;
2244 int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
2245
2246 ASSERT_EQ(res, HCF_SUCCESS);
2247 ASSERT_NE(sign, nullptr);
2248
2249 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
2250
2251 ASSERT_EQ(res, HCF_SUCCESS);
2252
2253 HcfBlob out = {
2254 .data = NULL,
2255 .len = 0
2256 };
2257 res = sign->sign(sign, &mockInput, &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 free(out.data);
2264 HcfObjDestroy(sign);
2265 }
2266
2267 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest433, TestSize.Level0)
2268 {
2269 HcfSign *sign = NULL;
2270 int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
2271
2272 ASSERT_EQ(res, HCF_SUCCESS);
2273 ASSERT_NE(sign, nullptr);
2274
2275 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
2276
2277 ASSERT_EQ(res, HCF_SUCCESS);
2278
2279 HcfBlob out = {
2280 .data = NULL,
2281 .len = 0
2282 };
2283 res = sign->sign(sign, &mockInput, &out);
2284
2285 ASSERT_EQ(res, HCF_SUCCESS);
2286 ASSERT_NE(out.data, nullptr);
2287 ASSERT_NE(out.len, (const unsigned int)0);
2288
2289 free(out.data);
2290 HcfObjDestroy(sign);
2291 }
2292
2293 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest434, TestSize.Level0)
2294 {
2295 HcfSign *sign = NULL;
2296 int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
2297
2298 ASSERT_EQ(res, HCF_SUCCESS);
2299 ASSERT_NE(sign, nullptr);
2300
2301 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
2302
2303 ASSERT_EQ(res, HCF_SUCCESS);
2304
2305 HcfBlob out = {
2306 .data = NULL,
2307 .len = 0
2308 };
2309 res = sign->sign(sign, &mockInput, &out);
2310
2311 ASSERT_EQ(res, HCF_SUCCESS);
2312 ASSERT_NE(out.data, nullptr);
2313 ASSERT_NE(out.len, (const unsigned int)0);
2314
2315 free(out.data);
2316 HcfObjDestroy(sign);
2317 }
2318
2319 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest435, TestSize.Level0)
2320 {
2321 HcfSign *sign = NULL;
2322 int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
2323
2324 ASSERT_EQ(res, HCF_SUCCESS);
2325 ASSERT_NE(sign, nullptr);
2326
2327 res = sign->init(sign, NULL, ecc384KeyPair_->priKey);
2328
2329 ASSERT_EQ(res, HCF_SUCCESS);
2330
2331 HcfBlob out = {
2332 .data = NULL,
2333 .len = 0
2334 };
2335 res = sign->sign(sign, &mockInput, &out);
2336
2337 ASSERT_EQ(res, HCF_SUCCESS);
2338 ASSERT_NE(out.data, nullptr);
2339 ASSERT_NE(out.len, (const unsigned int)0);
2340
2341 free(out.data);
2342 HcfObjDestroy(sign);
2343 }
2344
2345 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest436, TestSize.Level0)
2346 {
2347 HcfSign *sign = NULL;
2348 int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
2349
2350 ASSERT_EQ(res, HCF_SUCCESS);
2351 ASSERT_NE(sign, nullptr);
2352
2353 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
2354
2355 ASSERT_EQ(res, HCF_SUCCESS);
2356
2357 HcfBlob out = {
2358 .data = NULL,
2359 .len = 0
2360 };
2361 res = sign->sign(sign, &mockInput, &out);
2362
2363 ASSERT_EQ(res, HCF_SUCCESS);
2364 ASSERT_NE(out.data, nullptr);
2365 ASSERT_NE(out.len, (const unsigned int)0);
2366
2367 free(out.data);
2368 HcfObjDestroy(sign);
2369 }
2370
2371 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest437, TestSize.Level0)
2372 {
2373 HcfSign *sign = NULL;
2374 int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
2375
2376 ASSERT_EQ(res, HCF_SUCCESS);
2377 ASSERT_NE(sign, nullptr);
2378
2379 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
2380
2381 ASSERT_EQ(res, HCF_SUCCESS);
2382
2383 HcfBlob out = {
2384 .data = NULL,
2385 .len = 0
2386 };
2387 res = sign->sign(sign, &mockInput, &out);
2388
2389 ASSERT_EQ(res, HCF_SUCCESS);
2390 ASSERT_NE(out.data, nullptr);
2391 ASSERT_NE(out.len, (const unsigned int)0);
2392
2393 free(out.data);
2394 HcfObjDestroy(sign);
2395 }
2396
2397 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest438, TestSize.Level0)
2398 {
2399 HcfSign *sign = NULL;
2400 int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
2401
2402 ASSERT_EQ(res, HCF_SUCCESS);
2403 ASSERT_NE(sign, nullptr);
2404
2405 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
2406
2407 ASSERT_EQ(res, HCF_SUCCESS);
2408
2409 HcfBlob out = {
2410 .data = NULL,
2411 .len = 0
2412 };
2413 res = sign->sign(sign, &mockInput, &out);
2414
2415 ASSERT_EQ(res, HCF_SUCCESS);
2416 ASSERT_NE(out.data, nullptr);
2417 ASSERT_NE(out.len, (const unsigned int)0);
2418
2419 free(out.data);
2420 HcfObjDestroy(sign);
2421 }
2422
2423 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest439, TestSize.Level0)
2424 {
2425 HcfSign *sign = NULL;
2426 int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
2427
2428 ASSERT_EQ(res, HCF_SUCCESS);
2429 ASSERT_NE(sign, nullptr);
2430
2431 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
2432
2433 ASSERT_EQ(res, HCF_SUCCESS);
2434
2435 HcfBlob out = {
2436 .data = NULL,
2437 .len = 0
2438 };
2439 res = sign->sign(sign, &mockInput, &out);
2440
2441 ASSERT_EQ(res, HCF_SUCCESS);
2442 ASSERT_NE(out.data, nullptr);
2443 ASSERT_NE(out.len, (const unsigned int)0);
2444
2445 free(out.data);
2446 HcfObjDestroy(sign);
2447 }
2448
2449 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest440, TestSize.Level0)
2450 {
2451 HcfSign *sign = NULL;
2452 int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
2453
2454 ASSERT_EQ(res, HCF_SUCCESS);
2455 ASSERT_NE(sign, nullptr);
2456
2457 res = sign->init(sign, NULL, ecc521KeyPair_->priKey);
2458
2459 ASSERT_EQ(res, HCF_SUCCESS);
2460
2461 HcfBlob out = {
2462 .data = NULL,
2463 .len = 0
2464 };
2465 res = sign->sign(sign, &mockInput, &out);
2466
2467 ASSERT_EQ(res, HCF_SUCCESS);
2468 ASSERT_NE(out.data, nullptr);
2469 ASSERT_NE(out.len, (const unsigned int)0);
2470
2471 free(out.data);
2472 HcfObjDestroy(sign);
2473 }
2474
2475 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest441, TestSize.Level0)
2476 {
2477 HcfSign *sign = NULL;
2478 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
2479
2480 ASSERT_EQ(res, HCF_SUCCESS);
2481 ASSERT_NE(sign, nullptr);
2482
2483 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2484
2485 ASSERT_EQ(res, HCF_SUCCESS);
2486
2487 res = sign->update(sign, &mockInput);
2488
2489 ASSERT_EQ(res, HCF_SUCCESS);
2490
2491 HcfBlob out = {
2492 .data = NULL,
2493 .len = 0
2494 };
2495 res = sign->sign(NULL, NULL, &out);
2496
2497 ASSERT_EQ(res, HCF_INVALID_PARAMS);
2498
2499 HcfObjDestroy(sign);
2500 }
2501
2502 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest442, TestSize.Level0)
2503 {
2504 HcfSign *sign = NULL;
2505 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
2506
2507 ASSERT_EQ(res, HCF_SUCCESS);
2508 ASSERT_NE(sign, nullptr);
2509
2510 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2511
2512 ASSERT_EQ(res, HCF_SUCCESS);
2513
2514 res = sign->update(sign, &mockInput);
2515
2516 ASSERT_EQ(res, HCF_SUCCESS);
2517
2518 HcfBlob out = {
2519 .data = NULL,
2520 .len = 0
2521 };
2522 res = sign->sign((HcfSign *)(&obj), NULL, &out);
2523
2524 ASSERT_EQ(res, HCF_INVALID_PARAMS);
2525
2526 HcfObjDestroy(sign);
2527 }
2528
2529 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest443, TestSize.Level0)
2530 {
2531 HcfSign *sign = NULL;
2532 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
2533
2534 ASSERT_EQ(res, HCF_SUCCESS);
2535 ASSERT_NE(sign, nullptr);
2536
2537 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2538
2539 ASSERT_EQ(res, HCF_SUCCESS);
2540
2541 HcfBlob out = {
2542 .data = NULL,
2543 .len = 0
2544 };
2545 res = sign->sign(sign, NULL, &out);
2546
2547 ASSERT_EQ(res, HCF_INVALID_PARAMS);
2548
2549 HcfObjDestroy(sign);
2550 }
2551
2552 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest444, TestSize.Level0)
2553 {
2554 HcfSign *sign = NULL;
2555 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
2556
2557 ASSERT_EQ(res, HCF_SUCCESS);
2558 ASSERT_NE(sign, nullptr);
2559
2560 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2561
2562 ASSERT_EQ(res, HCF_SUCCESS);
2563
2564 HcfBlob input = {
2565 .data = NULL,
2566 .len = 1
2567 };
2568 HcfBlob out = {
2569 .data = NULL,
2570 .len = 0
2571 };
2572 res = sign->sign(sign, &input, &out);
2573
2574 ASSERT_EQ(res, HCF_INVALID_PARAMS);
2575
2576 HcfObjDestroy(sign);
2577 }
2578
2579 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest445, TestSize.Level0)
2580 {
2581 HcfSign *sign = NULL;
2582 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
2583
2584 ASSERT_EQ(res, HCF_SUCCESS);
2585 ASSERT_NE(sign, nullptr);
2586
2587 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2588
2589 ASSERT_EQ(res, HCF_SUCCESS);
2590
2591 HcfBlob input = {
2592 .data = (uint8_t *)g_mockMessage,
2593 .len = 0
2594 };
2595 HcfBlob out = {
2596 .data = NULL,
2597 .len = 0
2598 };
2599 res = sign->sign(sign, &input, &out);
2600
2601 ASSERT_EQ(res, HCF_INVALID_PARAMS);
2602
2603 HcfObjDestroy(sign);
2604 }
2605
2606 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest446, TestSize.Level0)
2607 {
2608 HcfSign *sign = NULL;
2609 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
2610
2611 ASSERT_EQ(res, HCF_SUCCESS);
2612 ASSERT_NE(sign, nullptr);
2613
2614 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2615
2616 ASSERT_EQ(res, HCF_SUCCESS);
2617
2618 res = sign->update(sign, &mockInput);
2619
2620 ASSERT_EQ(res, HCF_SUCCESS);
2621
2622 res = sign->sign(sign, NULL, NULL);
2623
2624 ASSERT_EQ(res, HCF_INVALID_PARAMS);
2625
2626 HcfObjDestroy(sign);
2627 }
2628
2629 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest447, TestSize.Level0)
2630 {
2631 HcfSign *sign = NULL;
2632 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
2633
2634 ASSERT_EQ(res, HCF_SUCCESS);
2635 ASSERT_NE(sign, nullptr);
2636
2637 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2638
2639 ASSERT_EQ(res, HCF_SUCCESS);
2640
2641 const char *message = "hello world";
2642 HcfBlob input = {
2643 .data = (uint8_t *)message,
2644 .len = 12
2645 };
2646 res = sign->update(sign, &input);
2647
2648 ASSERT_EQ(res, HCF_SUCCESS);
2649
2650 HcfBlob out = {
2651 .data = NULL,
2652 .len = 0
2653 };
2654 res = sign->sign(sign, NULL, &out);
2655
2656 ASSERT_EQ(res, HCF_SUCCESS);
2657 ASSERT_NE(out.data, nullptr);
2658 ASSERT_NE(out.len, (const unsigned int)0);
2659
2660 res = sign->update(sign, &input);
2661
2662 ASSERT_EQ(res, HCF_SUCCESS);
2663
2664 HcfBlob out2 = {
2665 .data = NULL,
2666 .len = 0
2667 };
2668 res = sign->sign(sign, NULL, &out2);
2669
2670 HcfVerify *verify = NULL;
2671 res = HcfVerifyCreate("ECC256|SHA256", &verify);
2672 ASSERT_EQ(res, HCF_SUCCESS);
2673 ASSERT_NE(verify, nullptr);
2674
2675 verify->init(verify, NULL, ecc256KeyPair_->pubKey);
2676 ASSERT_EQ(res, HCF_SUCCESS);
2677
2678 verify->update(verify, &input);
2679 ASSERT_EQ(res, HCF_SUCCESS);
2680
2681 bool flag = verify->verify(verify, NULL, &out);
2682 ASSERT_EQ(flag, true);
2683
2684 verify->update(verify, &input);
2685 ASSERT_EQ(res, HCF_SUCCESS);
2686
2687 flag = verify->verify(verify, NULL, &out2);
2688 ASSERT_EQ(flag, true);
2689
2690 free(out.data);
2691 free(out2.data);
2692 HcfObjDestroy(sign);
2693 HcfObjDestroy(verify);
2694 }
2695
2696 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest448, TestSize.Level0)
2697 {
2698 HcfSign *sign = NULL;
2699 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
2700
2701 ASSERT_EQ(res, HCF_SUCCESS);
2702 ASSERT_NE(sign, nullptr);
2703
2704 res = sign->init(sign, NULL, ecc256KeyPair_->priKey);
2705
2706 ASSERT_EQ(res, HCF_SUCCESS);
2707
2708 const char *message = "hello world";
2709 HcfBlob input = {
2710 .data = (uint8_t *)message,
2711 .len = 12
2712 };
2713 res = sign->update(sign, &input);
2714
2715 ASSERT_EQ(res, HCF_SUCCESS);
2716
2717 res = sign->update(sign, &input);
2718
2719 ASSERT_EQ(res, HCF_SUCCESS);
2720
2721 HcfBlob out2 = {
2722 .data = NULL,
2723 .len = 0
2724 };
2725 res = sign->sign(sign, NULL, &out2);
2726
2727 free(out2.data);
2728 HcfObjDestroy(sign);
2729 }
2730
2731 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest927, TestSize.Level0)
2732 {
2733 HcfAsyKeyGenerator *generator = NULL;
2734 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
2735 ASSERT_EQ(res, HCF_SUCCESS);
2736 ASSERT_NE(generator, nullptr);
2737
2738 HcfKeyPair *keyPair = NULL;
2739 res = generator->generateKeyPair(generator, NULL, &keyPair);
2740 ASSERT_EQ(res, HCF_SUCCESS);
2741 ASSERT_NE(keyPair, nullptr);
2742
2743 HcfObjDestroy(generator);
2744
2745 HcfSign *sign = NULL;
2746 res = HcfSignCreate("ECC256|SHA256", &sign);
2747 ASSERT_EQ(res, HCF_SUCCESS);
2748 ASSERT_NE(sign, nullptr);
2749
2750 HcfParamsSpec params;
2751 res = sign->init(sign, ¶ms, keyPair->priKey);
2752 ASSERT_EQ(res, HCF_SUCCESS);
2753
2754 const char *message = "hello world";
2755 HcfBlob input = {
2756 .data = (uint8_t *)message,
2757 .len = 12
2758 };
2759
2760 HcfBlob out = {
2761 .data = NULL,
2762 .len = 0
2763 };
2764 res = sign->sign(sign, &input, &out);
2765 ASSERT_EQ(res, HCF_SUCCESS);
2766 ASSERT_NE(out.data, nullptr);
2767 ASSERT_NE(out.len, (const unsigned int)0);
2768
2769 free(out.data);
2770 HcfObjDestroy(sign);
2771 }
2772
2773 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest928, TestSize.Level0)
2774 {
2775 HcfAsyKeyGenerator *generator = NULL;
2776 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
2777 ASSERT_EQ(res, HCF_SUCCESS);
2778 ASSERT_NE(generator, nullptr);
2779
2780 HcfKeyPair *keyPair = NULL;
2781 res = generator->generateKeyPair(generator, NULL, &keyPair);
2782 ASSERT_EQ(res, HCF_SUCCESS);
2783 ASSERT_NE(keyPair, nullptr);
2784
2785 HcfObjDestroy(generator);
2786
2787 HcfSign *sign = NULL;
2788 res = HcfSignCreate("ECC224|SHA256", &sign);
2789 ASSERT_EQ(res, HCF_SUCCESS);
2790 ASSERT_NE(sign, nullptr);
2791
2792 HcfParamsSpec params;
2793 res = sign->init(sign, ¶ms, keyPair->priKey);
2794 ASSERT_EQ(res, HCF_SUCCESS);
2795
2796 const char *message = "hello world";
2797 HcfBlob input = {
2798 .data = (uint8_t *)message,
2799 .len = 12
2800 };
2801 res = sign->update(sign, &input);
2802 ASSERT_EQ(res, HCF_SUCCESS);
2803
2804 HcfBlob out = {
2805 .data = NULL,
2806 .len = 0
2807 };
2808 res = sign->sign(sign, NULL, &out);
2809 ASSERT_EQ(res, HCF_SUCCESS);
2810 ASSERT_NE(out.data, nullptr);
2811 ASSERT_NE(out.len, (const unsigned int)0);
2812
2813 free(out.data);
2814 HcfObjDestroy(sign);
2815 }
2816 }
2817