1 /*
2 * Copyright (C) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <cstring>
18
19 #include "asy_key_generator.h"
20 #include "blob.h"
21 #include "ecdsa_openssl.h"
22 #include "memory.h"
23 #include "securec.h"
24 #include "signature.h"
25 #include "memory_mock.h"
26 #include "openssl_adapter_mock.h"
27
28 using namespace std;
29 using namespace testing::ext;
30
31 namespace {
32 class CryptoEccSignTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp();
37 void TearDown();
38
39 static HcfKeyPair *ecc224KeyPair_;
40 static HcfKeyPair *ecc256KeyPair_;
41 static HcfKeyPair *ecc384KeyPair_;
42 static HcfKeyPair *ecc521KeyPair_;
43 };
44
45 HcfKeyPair *CryptoEccSignTest::ecc224KeyPair_ = nullptr;
46 HcfKeyPair *CryptoEccSignTest::ecc256KeyPair_ = nullptr;
47 HcfKeyPair *CryptoEccSignTest::ecc384KeyPair_ = nullptr;
48 HcfKeyPair *CryptoEccSignTest::ecc521KeyPair_ = nullptr;
49
50 static const char *g_mockMessage = "hello world";
51 static HcfBlob g_mockInput = {
52 .data = (uint8_t *)g_mockMessage,
53 .len = 12
54 };
55
SetUp()56 void CryptoEccSignTest::SetUp() {}
TearDown()57 void CryptoEccSignTest::TearDown() {}
58
SetUpTestCase()59 void CryptoEccSignTest::SetUpTestCase()
60 {
61 HcfAsyKeyGenerator *generator = nullptr;
62 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
63 ASSERT_EQ(res, HCF_SUCCESS);
64 ASSERT_NE(generator, nullptr);
65
66 HcfKeyPair *keyPair = nullptr;
67 res = generator->generateKeyPair(generator, nullptr, &keyPair);
68 ASSERT_EQ(res, HCF_SUCCESS);
69 ASSERT_NE(keyPair, nullptr);
70
71 ecc224KeyPair_ = keyPair;
72
73 HcfObjDestroy(generator);
74
75 HcfAsyKeyGenerator *generator2 = nullptr;
76 res = HcfAsyKeyGeneratorCreate("ECC256", &generator2);
77 ASSERT_EQ(res, HCF_SUCCESS);
78 ASSERT_NE(generator2, nullptr);
79
80 HcfKeyPair *keyPair2 = nullptr;
81 res = generator2->generateKeyPair(generator2, nullptr, &keyPair2);
82 ASSERT_EQ(res, HCF_SUCCESS);
83 ASSERT_NE(keyPair2, nullptr);
84
85 ecc256KeyPair_ = keyPair2;
86
87 HcfObjDestroy(generator2);
88
89 HcfAsyKeyGenerator *generator3 = nullptr;
90 res = HcfAsyKeyGeneratorCreate("ECC384", &generator3);
91 ASSERT_EQ(res, HCF_SUCCESS);
92 ASSERT_NE(generator3, nullptr);
93
94 HcfKeyPair *keyPair3 = nullptr;
95 res = generator3->generateKeyPair(generator3, nullptr, &keyPair3);
96 ASSERT_EQ(res, HCF_SUCCESS);
97 ASSERT_NE(keyPair3, nullptr);
98
99 ecc384KeyPair_ = keyPair3;
100
101 HcfObjDestroy(generator3);
102
103 HcfAsyKeyGenerator *generator4 = nullptr;
104 res = HcfAsyKeyGeneratorCreate("ECC521", &generator4);
105 ASSERT_EQ(res, HCF_SUCCESS);
106 ASSERT_NE(generator4, nullptr);
107
108 HcfKeyPair *keyPair4 = nullptr;
109 res = generator4->generateKeyPair(generator4, nullptr, &keyPair4);
110 ASSERT_EQ(res, HCF_SUCCESS);
111 ASSERT_NE(keyPair4, nullptr);
112
113 ecc521KeyPair_ = keyPair4;
114
115 HcfObjDestroy(generator4);
116 }
117
TearDownTestCase()118 void CryptoEccSignTest::TearDownTestCase()
119 {
120 HcfObjDestroy(ecc224KeyPair_);
121 HcfObjDestroy(ecc256KeyPair_);
122 HcfObjDestroy(ecc384KeyPair_);
123 HcfObjDestroy(ecc521KeyPair_);
124 }
125
GetMockClass(void)126 static const char *GetMockClass(void)
127 {
128 return "HcfMock";
129 }
130
131 static HcfObjectBase obj = {
132 .getClass = GetMockClass,
133 .destroy = nullptr
134 };
135
136 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest001, TestSize.Level0)
137 {
138 HcfSign *sign = nullptr;
139 int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
140
141 ASSERT_EQ(res, HCF_SUCCESS);
142 ASSERT_NE(sign, nullptr);
143
144 HcfObjDestroy(sign);
145 }
146
147 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest002, TestSize.Level0)
148 {
149 HcfSign *sign = nullptr;
150 int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
151
152 ASSERT_EQ(res, HCF_SUCCESS);
153 ASSERT_NE(sign, nullptr);
154
155 HcfObjDestroy(sign);
156 }
157
158 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest003, TestSize.Level0)
159 {
160 HcfSign *sign = nullptr;
161 int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
162
163 ASSERT_EQ(res, HCF_SUCCESS);
164 ASSERT_NE(sign, nullptr);
165
166 HcfObjDestroy(sign);
167 }
168
169 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest004, TestSize.Level0)
170 {
171 HcfSign *sign = nullptr;
172 int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
173
174 ASSERT_EQ(res, HCF_SUCCESS);
175 ASSERT_NE(sign, nullptr);
176
177 HcfObjDestroy(sign);
178 }
179
180 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest005, TestSize.Level0)
181 {
182 HcfSign *sign = nullptr;
183 int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
184
185 ASSERT_EQ(res, HCF_SUCCESS);
186 ASSERT_NE(sign, nullptr);
187
188 HcfObjDestroy(sign);
189 }
190
191 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest006, TestSize.Level0)
192 {
193 HcfSign *sign = nullptr;
194 int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
195
196 ASSERT_EQ(res, HCF_SUCCESS);
197 ASSERT_NE(sign, nullptr);
198
199 HcfObjDestroy(sign);
200 }
201
202 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest007, TestSize.Level0)
203 {
204 HcfSign *sign = nullptr;
205 int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
206
207 ASSERT_EQ(res, HCF_SUCCESS);
208 ASSERT_NE(sign, nullptr);
209
210 HcfObjDestroy(sign);
211 }
212
213 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest008, TestSize.Level0)
214 {
215 HcfSign *sign = nullptr;
216 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
217
218 ASSERT_EQ(res, HCF_SUCCESS);
219 ASSERT_NE(sign, nullptr);
220
221 HcfObjDestroy(sign);
222 }
223
224 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest009, TestSize.Level0)
225 {
226 HcfSign *sign = nullptr;
227 int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
228
229 ASSERT_EQ(res, HCF_SUCCESS);
230 ASSERT_NE(sign, nullptr);
231
232 HcfObjDestroy(sign);
233 }
234
235 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest010, TestSize.Level0)
236 {
237 HcfSign *sign = nullptr;
238 int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
239
240 ASSERT_EQ(res, HCF_SUCCESS);
241 ASSERT_NE(sign, nullptr);
242
243 HcfObjDestroy(sign);
244 }
245
246 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest011, TestSize.Level0)
247 {
248 HcfSign *sign = nullptr;
249 int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
250
251 ASSERT_EQ(res, HCF_SUCCESS);
252 ASSERT_NE(sign, nullptr);
253
254 HcfObjDestroy(sign);
255 }
256
257 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest012, TestSize.Level0)
258 {
259 HcfSign *sign = nullptr;
260 int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
261
262 ASSERT_EQ(res, HCF_SUCCESS);
263 ASSERT_NE(sign, nullptr);
264
265 HcfObjDestroy(sign);
266 }
267
268 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest013, TestSize.Level0)
269 {
270 HcfSign *sign = nullptr;
271 int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
272
273 ASSERT_EQ(res, HCF_SUCCESS);
274 ASSERT_NE(sign, nullptr);
275
276 HcfObjDestroy(sign);
277 }
278
279 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest014, TestSize.Level0)
280 {
281 HcfSign *sign = nullptr;
282 int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
283
284 ASSERT_EQ(res, HCF_SUCCESS);
285 ASSERT_NE(sign, nullptr);
286
287 HcfObjDestroy(sign);
288 }
289
290 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest015, TestSize.Level0)
291 {
292 HcfSign *sign = nullptr;
293 int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
294
295 ASSERT_EQ(res, HCF_SUCCESS);
296 ASSERT_NE(sign, nullptr);
297
298 HcfObjDestroy(sign);
299 }
300
301 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest016, TestSize.Level0)
302 {
303 HcfSign *sign = nullptr;
304 int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
305
306 ASSERT_EQ(res, HCF_SUCCESS);
307 ASSERT_NE(sign, nullptr);
308
309 HcfObjDestroy(sign);
310 }
311
312 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest017, TestSize.Level0)
313 {
314 HcfSign *sign = nullptr;
315 int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
316
317 ASSERT_EQ(res, HCF_SUCCESS);
318 ASSERT_NE(sign, nullptr);
319
320 HcfObjDestroy(sign);
321 }
322
323 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest018, TestSize.Level0)
324 {
325 HcfSign *sign = nullptr;
326 int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
327
328 ASSERT_EQ(res, HCF_SUCCESS);
329 ASSERT_NE(sign, nullptr);
330
331 HcfObjDestroy(sign);
332 }
333
334 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest019, TestSize.Level0)
335 {
336 HcfSign *sign = nullptr;
337 int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
338
339 ASSERT_EQ(res, HCF_SUCCESS);
340 ASSERT_NE(sign, nullptr);
341
342 HcfObjDestroy(sign);
343 }
344
345 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest020, TestSize.Level0)
346 {
347 HcfSign *sign = nullptr;
348 int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
349
350 ASSERT_EQ(res, HCF_SUCCESS);
351 ASSERT_NE(sign, nullptr);
352
353 HcfObjDestroy(sign);
354 }
355
356 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest021, TestSize.Level0)
357 {
358 HcfSign *sign = nullptr;
359 int32_t res = HcfSignCreate(nullptr, &sign);
360
361 ASSERT_EQ(res, HCF_INVALID_PARAMS);
362 ASSERT_EQ(sign, nullptr);
363 }
364
365 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest022, TestSize.Level0)
366 {
367 HcfSign *sign = nullptr;
368 int32_t res = HcfSignCreate("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD"
369 "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", &sign);
370
371 ASSERT_EQ(res, HCF_INVALID_PARAMS);
372 ASSERT_EQ(sign, nullptr);
373 }
374
375 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest023, TestSize.Level0)
376 {
377 HcfSign *sign = nullptr;
378 int32_t res = HcfSignCreate("ECC257|SHA256", &sign);
379
380 ASSERT_NE(res, HCF_SUCCESS);
381 ASSERT_EQ(sign, nullptr);
382 }
383
384 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest024, TestSize.Level0)
385 {
386 HcfSign *sign = nullptr;
387 int32_t res = HcfSignCreate("ECC256|SHA257", &sign);
388
389 ASSERT_NE(res, HCF_SUCCESS);
390 ASSERT_EQ(sign, nullptr);
391 }
392
393 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest025, TestSize.Level0)
394 {
395 HcfSign *sign = nullptr;
396 int32_t res = HcfSignCreate("ECC256|MD5", &sign);
397
398 ASSERT_NE(res, HCF_SUCCESS);
399 ASSERT_EQ(sign, nullptr);
400 }
401
402 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest026, TestSize.Level0)
403 {
404 HcfSign *sign = nullptr;
405 int32_t res = HcfSignCreate("ECC256SHA256", &sign);
406
407 ASSERT_NE(res, HCF_SUCCESS);
408 ASSERT_EQ(sign, nullptr);
409 }
410
411 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest027, TestSize.Level0)
412 {
413 int32_t res = HcfSignCreate("ECC256|SHA256", nullptr);
414
415 ASSERT_EQ(res, HCF_INVALID_PARAMS);
416 }
417
418 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest101, TestSize.Level0)
419 {
420 HcfSign *sign = nullptr;
421 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
422
423 ASSERT_EQ(res, HCF_SUCCESS);
424 ASSERT_NE(sign, nullptr);
425
426 const char *className = sign->base.getClass();
427
428 ASSERT_NE(className, nullptr);
429
430 HcfObjDestroy(sign);
431 }
432
433 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest102, TestSize.Level0)
434 {
435 HcfSign *sign = nullptr;
436 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
437
438 ASSERT_EQ(res, HCF_SUCCESS);
439 ASSERT_NE(sign, nullptr);
440
441 sign->base.destroy((HcfObjectBase *)sign);
442 }
443
444 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest103, TestSize.Level0)
445 {
446 HcfSign *sign = nullptr;
447 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
448
449 ASSERT_EQ(res, HCF_SUCCESS);
450 ASSERT_NE(sign, nullptr);
451
452 sign->base.destroy(nullptr);
453
454 HcfObjDestroy(sign);
455 }
456
457 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest104, TestSize.Level0)
458 {
459 HcfSign *sign = nullptr;
460 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
461
462 ASSERT_EQ(res, HCF_SUCCESS);
463 ASSERT_NE(sign, nullptr);
464
465 sign->base.destroy(&obj);
466
467 HcfObjDestroy(sign);
468 }
469
470 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest105, TestSize.Level0)
471 {
472 HcfSign *sign = nullptr;
473 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
474
475 ASSERT_EQ(res, HCF_SUCCESS);
476 ASSERT_NE(sign, nullptr);
477
478 const char *algName = sign->getAlgoName(sign);
479
480 ASSERT_NE(algName, nullptr);
481
482 HcfObjDestroy(sign);
483 }
484
485 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest106, TestSize.Level0)
486 {
487 HcfSign *sign = nullptr;
488 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
489
490 ASSERT_EQ(res, HCF_SUCCESS);
491 ASSERT_NE(sign, nullptr);
492
493 const char *algName = sign->getAlgoName(nullptr);
494
495 ASSERT_EQ(algName, nullptr);
496
497 HcfObjDestroy(sign);
498 }
499
500 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest107, TestSize.Level0)
501 {
502 HcfSign *sign = nullptr;
503 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
504
505 ASSERT_EQ(res, HCF_SUCCESS);
506 ASSERT_NE(sign, nullptr);
507
508 const char *algName = sign->getAlgoName((HcfSign *)(&obj));
509
510 ASSERT_EQ(algName, nullptr);
511
512 HcfObjDestroy(sign);
513 }
514
515 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest201, TestSize.Level0)
516 {
517 HcfSign *sign = nullptr;
518 int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
519
520 ASSERT_EQ(res, HCF_SUCCESS);
521 ASSERT_NE(sign, nullptr);
522
523 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
524
525 ASSERT_EQ(res, HCF_SUCCESS);
526
527 HcfObjDestroy(sign);
528 }
529
530 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest202, TestSize.Level0)
531 {
532 HcfSign *sign = nullptr;
533 int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
534
535 ASSERT_EQ(res, HCF_SUCCESS);
536 ASSERT_NE(sign, nullptr);
537
538 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
539
540 ASSERT_EQ(res, HCF_SUCCESS);
541
542 HcfObjDestroy(sign);
543 }
544
545 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest203, TestSize.Level0)
546 {
547 HcfSign *sign = nullptr;
548 int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
549
550 ASSERT_EQ(res, HCF_SUCCESS);
551 ASSERT_NE(sign, nullptr);
552
553 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
554
555 ASSERT_EQ(res, HCF_SUCCESS);
556
557 HcfObjDestroy(sign);
558 }
559
560 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest204, TestSize.Level0)
561 {
562 HcfSign *sign = nullptr;
563 int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
564
565 ASSERT_EQ(res, HCF_SUCCESS);
566 ASSERT_NE(sign, nullptr);
567
568 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
569
570 ASSERT_EQ(res, HCF_SUCCESS);
571
572 HcfObjDestroy(sign);
573 }
574
575 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest205, TestSize.Level0)
576 {
577 HcfSign *sign = nullptr;
578 int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
579
580 ASSERT_EQ(res, HCF_SUCCESS);
581 ASSERT_NE(sign, nullptr);
582
583 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
584
585 ASSERT_EQ(res, HCF_SUCCESS);
586
587 HcfObjDestroy(sign);
588 }
589
590 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest206, TestSize.Level0)
591 {
592 HcfSign *sign = nullptr;
593 int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
594
595 ASSERT_EQ(res, HCF_SUCCESS);
596 ASSERT_NE(sign, nullptr);
597
598 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
599
600 ASSERT_EQ(res, HCF_SUCCESS);
601
602 HcfObjDestroy(sign);
603 }
604
605 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest207, TestSize.Level0)
606 {
607 HcfSign *sign = nullptr;
608 int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
609
610 ASSERT_EQ(res, HCF_SUCCESS);
611 ASSERT_NE(sign, nullptr);
612
613 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
614
615 ASSERT_EQ(res, HCF_SUCCESS);
616
617 HcfObjDestroy(sign);
618 }
619
620 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest208, TestSize.Level0)
621 {
622 HcfSign *sign = nullptr;
623 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
624
625 ASSERT_EQ(res, HCF_SUCCESS);
626 ASSERT_NE(sign, nullptr);
627
628 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
629
630 ASSERT_EQ(res, HCF_SUCCESS);
631
632 HcfObjDestroy(sign);
633 }
634
635 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest209, TestSize.Level0)
636 {
637 HcfSign *sign = nullptr;
638 int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
639
640 ASSERT_EQ(res, HCF_SUCCESS);
641 ASSERT_NE(sign, nullptr);
642
643 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
644
645 ASSERT_EQ(res, HCF_SUCCESS);
646
647 HcfObjDestroy(sign);
648 }
649
650 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest210, TestSize.Level0)
651 {
652 HcfSign *sign = nullptr;
653 int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
654
655 ASSERT_EQ(res, HCF_SUCCESS);
656 ASSERT_NE(sign, nullptr);
657
658 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
659
660 ASSERT_EQ(res, HCF_SUCCESS);
661
662 HcfObjDestroy(sign);
663 }
664
665 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest211, TestSize.Level0)
666 {
667 HcfSign *sign = nullptr;
668 int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
669
670 ASSERT_EQ(res, HCF_SUCCESS);
671 ASSERT_NE(sign, nullptr);
672
673 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
674
675 ASSERT_EQ(res, HCF_SUCCESS);
676
677 HcfObjDestroy(sign);
678 }
679
680 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest212, TestSize.Level0)
681 {
682 HcfSign *sign = nullptr;
683 int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
684
685 ASSERT_EQ(res, HCF_SUCCESS);
686 ASSERT_NE(sign, nullptr);
687
688 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
689
690 ASSERT_EQ(res, HCF_SUCCESS);
691
692 HcfObjDestroy(sign);
693 }
694
695 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest213, TestSize.Level0)
696 {
697 HcfSign *sign = nullptr;
698 int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
699
700 ASSERT_EQ(res, HCF_SUCCESS);
701 ASSERT_NE(sign, nullptr);
702
703 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
704
705 ASSERT_EQ(res, HCF_SUCCESS);
706
707 HcfObjDestroy(sign);
708 }
709
710 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest214, TestSize.Level0)
711 {
712 HcfSign *sign = nullptr;
713 int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
714
715 ASSERT_EQ(res, HCF_SUCCESS);
716 ASSERT_NE(sign, nullptr);
717
718 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
719
720 ASSERT_EQ(res, HCF_SUCCESS);
721
722 HcfObjDestroy(sign);
723 }
724
725 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest215, TestSize.Level0)
726 {
727 HcfSign *sign = nullptr;
728 int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
729
730 ASSERT_EQ(res, HCF_SUCCESS);
731 ASSERT_NE(sign, nullptr);
732
733 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
734
735 ASSERT_EQ(res, HCF_SUCCESS);
736
737 HcfObjDestroy(sign);
738 }
739
740 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest216, TestSize.Level0)
741 {
742 HcfSign *sign = nullptr;
743 int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
744
745 ASSERT_EQ(res, HCF_SUCCESS);
746 ASSERT_NE(sign, nullptr);
747
748 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
749
750 ASSERT_EQ(res, HCF_SUCCESS);
751
752 HcfObjDestroy(sign);
753 }
754
755 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest217, TestSize.Level0)
756 {
757 HcfSign *sign = nullptr;
758 int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
759
760 ASSERT_EQ(res, HCF_SUCCESS);
761 ASSERT_NE(sign, nullptr);
762
763 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
764
765 ASSERT_EQ(res, HCF_SUCCESS);
766
767 HcfObjDestroy(sign);
768 }
769
770 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest218, TestSize.Level0)
771 {
772 HcfSign *sign = nullptr;
773 int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
774
775 ASSERT_EQ(res, HCF_SUCCESS);
776 ASSERT_NE(sign, nullptr);
777
778 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
779
780 ASSERT_EQ(res, HCF_SUCCESS);
781
782 HcfObjDestroy(sign);
783 }
784
785 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest219, TestSize.Level0)
786 {
787 HcfSign *sign = nullptr;
788 int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
789
790 ASSERT_EQ(res, HCF_SUCCESS);
791 ASSERT_NE(sign, nullptr);
792
793 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
794
795 ASSERT_EQ(res, HCF_SUCCESS);
796
797 HcfObjDestroy(sign);
798 }
799
800 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest220, TestSize.Level0)
801 {
802 HcfSign *sign = nullptr;
803 int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
804
805 ASSERT_EQ(res, HCF_SUCCESS);
806 ASSERT_NE(sign, nullptr);
807
808 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
809
810 ASSERT_EQ(res, HCF_SUCCESS);
811
812 HcfObjDestroy(sign);
813 }
814
815 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest221, TestSize.Level0)
816 {
817 HcfSign *sign = nullptr;
818 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
819
820 ASSERT_EQ(res, HCF_SUCCESS);
821 ASSERT_NE(sign, nullptr);
822
823 res = sign->init(nullptr, nullptr, ecc256KeyPair_->priKey);
824
825 ASSERT_EQ(res, HCF_INVALID_PARAMS);
826
827 HcfObjDestroy(sign);
828 }
829
830 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest222, TestSize.Level0)
831 {
832 HcfSign *sign = nullptr;
833 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
834
835 ASSERT_EQ(res, HCF_SUCCESS);
836 ASSERT_NE(sign, nullptr);
837
838 res = sign->init((HcfSign *)(&obj), nullptr, ecc256KeyPair_->priKey);
839
840 ASSERT_EQ(res, HCF_INVALID_PARAMS);
841
842 HcfObjDestroy(sign);
843 }
844
845 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest223, TestSize.Level0)
846 {
847 HcfSign *sign = nullptr;
848 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
849
850 ASSERT_EQ(res, HCF_SUCCESS);
851 ASSERT_NE(sign, nullptr);
852
853 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
854
855 ASSERT_EQ(res, HCF_SUCCESS);
856
857 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
858
859 ASSERT_EQ(res, HCF_INVALID_PARAMS);
860
861 HcfObjDestroy(sign);
862 }
863
864 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest224, TestSize.Level0)
865 {
866 HcfSign *sign = nullptr;
867 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
868
869 ASSERT_EQ(res, HCF_SUCCESS);
870 ASSERT_NE(sign, nullptr);
871
872 res = sign->init(sign, nullptr, nullptr);
873
874 ASSERT_EQ(res, HCF_INVALID_PARAMS);
875
876 HcfObjDestroy(sign);
877 }
878
879 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest225, TestSize.Level0)
880 {
881 HcfSign *sign = nullptr;
882 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
883
884 ASSERT_EQ(res, HCF_SUCCESS);
885 ASSERT_NE(sign, nullptr);
886
887 res = sign->init(sign, nullptr, (HcfPriKey *)(&obj));
888
889 ASSERT_EQ(res, HCF_INVALID_PARAMS);
890
891 HcfObjDestroy(sign);
892 }
893
894 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest301, TestSize.Level0)
895 {
896 HcfSign *sign = nullptr;
897 int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
898
899 ASSERT_EQ(res, HCF_SUCCESS);
900 ASSERT_NE(sign, nullptr);
901
902 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
903
904 ASSERT_EQ(res, HCF_SUCCESS);
905
906 res = sign->update(sign, &g_mockInput);
907
908 ASSERT_EQ(res, HCF_SUCCESS);
909
910 HcfObjDestroy(sign);
911 }
912
913 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest302, TestSize.Level0)
914 {
915 HcfSign *sign = nullptr;
916 int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
917
918 ASSERT_EQ(res, HCF_SUCCESS);
919 ASSERT_NE(sign, nullptr);
920
921 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
922
923 ASSERT_EQ(res, HCF_SUCCESS);
924
925 res = sign->update(sign, &g_mockInput);
926
927 ASSERT_EQ(res, HCF_SUCCESS);
928
929 HcfObjDestroy(sign);
930 }
931
932 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest303, TestSize.Level0)
933 {
934 HcfSign *sign = nullptr;
935 int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
936
937 ASSERT_EQ(res, HCF_SUCCESS);
938 ASSERT_NE(sign, nullptr);
939
940 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
941
942 ASSERT_EQ(res, HCF_SUCCESS);
943
944 res = sign->update(sign, &g_mockInput);
945
946 ASSERT_EQ(res, HCF_SUCCESS);
947
948 HcfObjDestroy(sign);
949 }
950
951 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest304, TestSize.Level0)
952 {
953 HcfSign *sign = nullptr;
954 int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
955
956 ASSERT_EQ(res, HCF_SUCCESS);
957 ASSERT_NE(sign, nullptr);
958
959 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
960
961 ASSERT_EQ(res, HCF_SUCCESS);
962
963 res = sign->update(sign, &g_mockInput);
964
965 ASSERT_EQ(res, HCF_SUCCESS);
966
967 HcfObjDestroy(sign);
968 }
969
970 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest305, TestSize.Level0)
971 {
972 HcfSign *sign = nullptr;
973 int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
974
975 ASSERT_EQ(res, HCF_SUCCESS);
976 ASSERT_NE(sign, nullptr);
977
978 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
979
980 ASSERT_EQ(res, HCF_SUCCESS);
981
982 res = sign->update(sign, &g_mockInput);
983
984 ASSERT_EQ(res, HCF_SUCCESS);
985
986 HcfObjDestroy(sign);
987 }
988
989 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest306, TestSize.Level0)
990 {
991 HcfSign *sign = nullptr;
992 int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
993
994 ASSERT_EQ(res, HCF_SUCCESS);
995 ASSERT_NE(sign, nullptr);
996
997 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
998
999 ASSERT_EQ(res, HCF_SUCCESS);
1000
1001 res = sign->update(sign, &g_mockInput);
1002
1003 ASSERT_EQ(res, HCF_SUCCESS);
1004
1005 HcfObjDestroy(sign);
1006 }
1007
1008 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest307, TestSize.Level0)
1009 {
1010 HcfSign *sign = nullptr;
1011 int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
1012
1013 ASSERT_EQ(res, HCF_SUCCESS);
1014 ASSERT_NE(sign, nullptr);
1015
1016 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1017
1018 ASSERT_EQ(res, HCF_SUCCESS);
1019
1020 res = sign->update(sign, &g_mockInput);
1021
1022 ASSERT_EQ(res, HCF_SUCCESS);
1023
1024 HcfObjDestroy(sign);
1025 }
1026
1027 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest308, TestSize.Level0)
1028 {
1029 HcfSign *sign = nullptr;
1030 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1031
1032 ASSERT_EQ(res, HCF_SUCCESS);
1033 ASSERT_NE(sign, nullptr);
1034
1035 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1036
1037 ASSERT_EQ(res, HCF_SUCCESS);
1038
1039 res = sign->update(sign, &g_mockInput);
1040
1041 ASSERT_EQ(res, HCF_SUCCESS);
1042
1043 HcfObjDestroy(sign);
1044 }
1045
1046 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest309, TestSize.Level0)
1047 {
1048 HcfSign *sign = nullptr;
1049 int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
1050
1051 ASSERT_EQ(res, HCF_SUCCESS);
1052 ASSERT_NE(sign, nullptr);
1053
1054 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1055
1056 ASSERT_EQ(res, HCF_SUCCESS);
1057
1058 res = sign->update(sign, &g_mockInput);
1059
1060 ASSERT_EQ(res, HCF_SUCCESS);
1061
1062 HcfObjDestroy(sign);
1063 }
1064
1065 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest310, TestSize.Level0)
1066 {
1067 HcfSign *sign = nullptr;
1068 int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
1069
1070 ASSERT_EQ(res, HCF_SUCCESS);
1071 ASSERT_NE(sign, nullptr);
1072
1073 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1074
1075 ASSERT_EQ(res, HCF_SUCCESS);
1076
1077 res = sign->update(sign, &g_mockInput);
1078
1079 ASSERT_EQ(res, HCF_SUCCESS);
1080
1081 HcfObjDestroy(sign);
1082 }
1083
1084 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest311, TestSize.Level0)
1085 {
1086 HcfSign *sign = nullptr;
1087 int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
1088
1089 ASSERT_EQ(res, HCF_SUCCESS);
1090 ASSERT_NE(sign, nullptr);
1091
1092 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1093
1094 ASSERT_EQ(res, HCF_SUCCESS);
1095
1096 res = sign->update(sign, &g_mockInput);
1097
1098 ASSERT_EQ(res, HCF_SUCCESS);
1099
1100 HcfObjDestroy(sign);
1101 }
1102
1103 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest312, TestSize.Level0)
1104 {
1105 HcfSign *sign = nullptr;
1106 int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
1107
1108 ASSERT_EQ(res, HCF_SUCCESS);
1109 ASSERT_NE(sign, nullptr);
1110
1111 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1112
1113 ASSERT_EQ(res, HCF_SUCCESS);
1114
1115 res = sign->update(sign, &g_mockInput);
1116
1117 ASSERT_EQ(res, HCF_SUCCESS);
1118
1119 HcfObjDestroy(sign);
1120 }
1121
1122 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest313, TestSize.Level0)
1123 {
1124 HcfSign *sign = nullptr;
1125 int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
1126
1127 ASSERT_EQ(res, HCF_SUCCESS);
1128 ASSERT_NE(sign, nullptr);
1129
1130 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1131
1132 ASSERT_EQ(res, HCF_SUCCESS);
1133
1134 res = sign->update(sign, &g_mockInput);
1135
1136 ASSERT_EQ(res, HCF_SUCCESS);
1137
1138 HcfObjDestroy(sign);
1139 }
1140
1141 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest314, TestSize.Level0)
1142 {
1143 HcfSign *sign = nullptr;
1144 int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
1145
1146 ASSERT_EQ(res, HCF_SUCCESS);
1147 ASSERT_NE(sign, nullptr);
1148
1149 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1150
1151 ASSERT_EQ(res, HCF_SUCCESS);
1152
1153 res = sign->update(sign, &g_mockInput);
1154
1155 ASSERT_EQ(res, HCF_SUCCESS);
1156
1157 HcfObjDestroy(sign);
1158 }
1159
1160 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest315, TestSize.Level0)
1161 {
1162 HcfSign *sign = nullptr;
1163 int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
1164
1165 ASSERT_EQ(res, HCF_SUCCESS);
1166 ASSERT_NE(sign, nullptr);
1167
1168 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1169
1170 ASSERT_EQ(res, HCF_SUCCESS);
1171
1172 res = sign->update(sign, &g_mockInput);
1173
1174 ASSERT_EQ(res, HCF_SUCCESS);
1175
1176 HcfObjDestroy(sign);
1177 }
1178
1179 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest316, TestSize.Level0)
1180 {
1181 HcfSign *sign = nullptr;
1182 int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
1183
1184 ASSERT_EQ(res, HCF_SUCCESS);
1185 ASSERT_NE(sign, nullptr);
1186
1187 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1188
1189 ASSERT_EQ(res, HCF_SUCCESS);
1190
1191 res = sign->update(sign, &g_mockInput);
1192
1193 ASSERT_EQ(res, HCF_SUCCESS);
1194
1195 HcfObjDestroy(sign);
1196 }
1197
1198 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest317, TestSize.Level0)
1199 {
1200 HcfSign *sign = nullptr;
1201 int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
1202
1203 ASSERT_EQ(res, HCF_SUCCESS);
1204 ASSERT_NE(sign, nullptr);
1205
1206 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1207
1208 ASSERT_EQ(res, HCF_SUCCESS);
1209
1210 res = sign->update(sign, &g_mockInput);
1211
1212 ASSERT_EQ(res, HCF_SUCCESS);
1213
1214 HcfObjDestroy(sign);
1215 }
1216
1217 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest318, TestSize.Level0)
1218 {
1219 HcfSign *sign = nullptr;
1220 int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
1221
1222 ASSERT_EQ(res, HCF_SUCCESS);
1223 ASSERT_NE(sign, nullptr);
1224
1225 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1226
1227 ASSERT_EQ(res, HCF_SUCCESS);
1228
1229 res = sign->update(sign, &g_mockInput);
1230
1231 ASSERT_EQ(res, HCF_SUCCESS);
1232
1233 HcfObjDestroy(sign);
1234 }
1235
1236 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest319, TestSize.Level0)
1237 {
1238 HcfSign *sign = nullptr;
1239 int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
1240
1241 ASSERT_EQ(res, HCF_SUCCESS);
1242 ASSERT_NE(sign, nullptr);
1243
1244 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1245
1246 ASSERT_EQ(res, HCF_SUCCESS);
1247
1248 res = sign->update(sign, &g_mockInput);
1249
1250 ASSERT_EQ(res, HCF_SUCCESS);
1251
1252 HcfObjDestroy(sign);
1253 }
1254
1255 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest320, TestSize.Level0)
1256 {
1257 HcfSign *sign = nullptr;
1258 int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
1259
1260 ASSERT_EQ(res, HCF_SUCCESS);
1261 ASSERT_NE(sign, nullptr);
1262
1263 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1264
1265 ASSERT_EQ(res, HCF_SUCCESS);
1266
1267 res = sign->update(sign, &g_mockInput);
1268
1269 ASSERT_EQ(res, HCF_SUCCESS);
1270
1271 HcfObjDestroy(sign);
1272 }
1273
1274 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest321, TestSize.Level0)
1275 {
1276 HcfSign *sign = nullptr;
1277 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1278
1279 ASSERT_EQ(res, HCF_SUCCESS);
1280 ASSERT_NE(sign, nullptr);
1281
1282 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1283
1284 ASSERT_EQ(res, HCF_SUCCESS);
1285
1286 res = sign->update(nullptr, &g_mockInput);
1287
1288 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1289
1290 HcfObjDestroy(sign);
1291 }
1292
1293 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest322, TestSize.Level0)
1294 {
1295 HcfSign *sign = nullptr;
1296 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1297
1298 ASSERT_EQ(res, HCF_SUCCESS);
1299 ASSERT_NE(sign, nullptr);
1300
1301 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1302
1303 ASSERT_EQ(res, HCF_SUCCESS);
1304
1305 res = sign->update((HcfSign *)(&obj), &g_mockInput);
1306
1307 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1308
1309 HcfObjDestroy(sign);
1310 }
1311
1312 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest323, TestSize.Level0)
1313 {
1314 HcfSign *sign = nullptr;
1315 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1316
1317 ASSERT_EQ(res, HCF_SUCCESS);
1318 ASSERT_NE(sign, nullptr);
1319
1320 res = sign->update(sign, &g_mockInput);
1321
1322 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1323
1324 HcfObjDestroy(sign);
1325 }
1326
1327 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest324, TestSize.Level0)
1328 {
1329 HcfSign *sign = nullptr;
1330 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1331
1332 ASSERT_EQ(res, HCF_SUCCESS);
1333 ASSERT_NE(sign, nullptr);
1334
1335 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1336
1337 ASSERT_EQ(res, HCF_SUCCESS);
1338
1339 res = sign->update(sign, nullptr);
1340
1341 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1342
1343 HcfObjDestroy(sign);
1344 }
1345
1346 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest325, TestSize.Level0)
1347 {
1348 HcfSign *sign = nullptr;
1349 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1350
1351 ASSERT_EQ(res, HCF_SUCCESS);
1352 ASSERT_NE(sign, nullptr);
1353
1354 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1355
1356 ASSERT_EQ(res, HCF_SUCCESS);
1357
1358 HcfBlob input = {
1359 .data = nullptr,
1360 .len = 1
1361 };
1362 res = sign->update(sign, &input);
1363
1364 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1365
1366 HcfObjDestroy(sign);
1367 }
1368
1369 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest326, TestSize.Level0)
1370 {
1371 HcfSign *sign = nullptr;
1372 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1373
1374 ASSERT_EQ(res, HCF_SUCCESS);
1375 ASSERT_NE(sign, nullptr);
1376
1377 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1378
1379 ASSERT_EQ(res, HCF_SUCCESS);
1380
1381 HcfBlob input = {
1382 .data = (uint8_t *)g_mockMessage,
1383 .len = 0
1384 };
1385 res = sign->update(sign, &input);
1386
1387 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1388
1389 HcfObjDestroy(sign);
1390 }
1391
1392 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest401, TestSize.Level0)
1393 {
1394 HcfSign *sign = nullptr;
1395 int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
1396
1397 ASSERT_EQ(res, HCF_SUCCESS);
1398 ASSERT_NE(sign, nullptr);
1399
1400 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1401
1402 ASSERT_EQ(res, HCF_SUCCESS);
1403
1404 res = sign->update(sign, &g_mockInput);
1405
1406 ASSERT_EQ(res, HCF_SUCCESS);
1407
1408 HcfBlob out = { .data = nullptr, .len = 0 };
1409 res = sign->sign(sign, nullptr, &out);
1410
1411 ASSERT_EQ(res, HCF_SUCCESS);
1412 ASSERT_NE(out.data, nullptr);
1413 ASSERT_NE(out.len, (const unsigned int)0);
1414
1415 HcfFree(out.data);
1416 HcfObjDestroy(sign);
1417 }
1418
1419 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest402, TestSize.Level0)
1420 {
1421 HcfSign *sign = nullptr;
1422 int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
1423
1424 ASSERT_EQ(res, HCF_SUCCESS);
1425 ASSERT_NE(sign, nullptr);
1426
1427 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1428
1429 ASSERT_EQ(res, HCF_SUCCESS);
1430
1431 res = sign->update(sign, &g_mockInput);
1432
1433 ASSERT_EQ(res, HCF_SUCCESS);
1434
1435 HcfBlob out = { .data = nullptr, .len = 0 };
1436 res = sign->sign(sign, nullptr, &out);
1437
1438 ASSERT_EQ(res, HCF_SUCCESS);
1439 ASSERT_NE(out.data, nullptr);
1440 ASSERT_NE(out.len, (const unsigned int)0);
1441
1442 HcfFree(out.data);
1443 HcfObjDestroy(sign);
1444 }
1445
1446 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest403, TestSize.Level0)
1447 {
1448 HcfSign *sign = nullptr;
1449 int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
1450
1451 ASSERT_EQ(res, HCF_SUCCESS);
1452 ASSERT_NE(sign, nullptr);
1453
1454 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1455
1456 ASSERT_EQ(res, HCF_SUCCESS);
1457
1458 res = sign->update(sign, &g_mockInput);
1459
1460 ASSERT_EQ(res, HCF_SUCCESS);
1461
1462 HcfBlob out = { .data = nullptr, .len = 0 };
1463 res = sign->sign(sign, nullptr, &out);
1464
1465 ASSERT_EQ(res, HCF_SUCCESS);
1466 ASSERT_NE(out.data, nullptr);
1467 ASSERT_NE(out.len, (const unsigned int)0);
1468
1469 HcfFree(out.data);
1470 HcfObjDestroy(sign);
1471 }
1472
1473 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest404, TestSize.Level0)
1474 {
1475 HcfSign *sign = nullptr;
1476 int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
1477
1478 ASSERT_EQ(res, HCF_SUCCESS);
1479 ASSERT_NE(sign, nullptr);
1480
1481 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1482
1483 ASSERT_EQ(res, HCF_SUCCESS);
1484
1485 res = sign->update(sign, &g_mockInput);
1486
1487 ASSERT_EQ(res, HCF_SUCCESS);
1488
1489 HcfBlob out = { .data = nullptr, .len = 0 };
1490 res = sign->sign(sign, nullptr, &out);
1491
1492 ASSERT_EQ(res, HCF_SUCCESS);
1493 ASSERT_NE(out.data, nullptr);
1494 ASSERT_NE(out.len, (const unsigned int)0);
1495
1496 HcfFree(out.data);
1497 HcfObjDestroy(sign);
1498 }
1499
1500 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest405, TestSize.Level0)
1501 {
1502 HcfSign *sign = nullptr;
1503 int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
1504
1505 ASSERT_EQ(res, HCF_SUCCESS);
1506 ASSERT_NE(sign, nullptr);
1507
1508 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1509
1510 ASSERT_EQ(res, HCF_SUCCESS);
1511
1512 res = sign->update(sign, &g_mockInput);
1513
1514 ASSERT_EQ(res, HCF_SUCCESS);
1515
1516 HcfBlob out = { .data = nullptr, .len = 0 };
1517 res = sign->sign(sign, nullptr, &out);
1518
1519 ASSERT_EQ(res, HCF_SUCCESS);
1520 ASSERT_NE(out.data, nullptr);
1521 ASSERT_NE(out.len, (const unsigned int)0);
1522
1523 HcfFree(out.data);
1524 HcfObjDestroy(sign);
1525 }
1526
1527 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest406, TestSize.Level0)
1528 {
1529 HcfSign *sign = nullptr;
1530 int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
1531
1532 ASSERT_EQ(res, HCF_SUCCESS);
1533 ASSERT_NE(sign, nullptr);
1534
1535 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1536
1537 ASSERT_EQ(res, HCF_SUCCESS);
1538
1539 res = sign->update(sign, &g_mockInput);
1540
1541 ASSERT_EQ(res, HCF_SUCCESS);
1542
1543 HcfBlob out = { .data = nullptr, .len = 0 };
1544 res = sign->sign(sign, nullptr, &out);
1545
1546 ASSERT_EQ(res, HCF_SUCCESS);
1547 ASSERT_NE(out.data, nullptr);
1548 ASSERT_NE(out.len, (const unsigned int)0);
1549
1550 HcfFree(out.data);
1551 HcfObjDestroy(sign);
1552 }
1553
1554 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest407, TestSize.Level0)
1555 {
1556 HcfSign *sign = nullptr;
1557 int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
1558
1559 ASSERT_EQ(res, HCF_SUCCESS);
1560 ASSERT_NE(sign, nullptr);
1561
1562 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1563
1564 ASSERT_EQ(res, HCF_SUCCESS);
1565
1566 res = sign->update(sign, &g_mockInput);
1567
1568 ASSERT_EQ(res, HCF_SUCCESS);
1569
1570 HcfBlob out = { .data = nullptr, .len = 0 };
1571 res = sign->sign(sign, nullptr, &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 HcfFree(out.data);
1578 HcfObjDestroy(sign);
1579 }
1580
1581 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest408, TestSize.Level0)
1582 {
1583 HcfSign *sign = nullptr;
1584 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1585
1586 ASSERT_EQ(res, HCF_SUCCESS);
1587 ASSERT_NE(sign, nullptr);
1588
1589 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1590
1591 ASSERT_EQ(res, HCF_SUCCESS);
1592
1593 res = sign->update(sign, &g_mockInput);
1594
1595 ASSERT_EQ(res, HCF_SUCCESS);
1596
1597 HcfBlob out = { .data = nullptr, .len = 0 };
1598 res = sign->sign(sign, nullptr, &out);
1599
1600 ASSERT_EQ(res, HCF_SUCCESS);
1601 ASSERT_NE(out.data, nullptr);
1602 ASSERT_NE(out.len, (const unsigned int)0);
1603
1604 HcfFree(out.data);
1605 HcfObjDestroy(sign);
1606 }
1607
1608 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest409, TestSize.Level0)
1609 {
1610 HcfSign *sign = nullptr;
1611 int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
1612
1613 ASSERT_EQ(res, HCF_SUCCESS);
1614 ASSERT_NE(sign, nullptr);
1615
1616 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1617
1618 ASSERT_EQ(res, HCF_SUCCESS);
1619
1620 res = sign->update(sign, &g_mockInput);
1621
1622 ASSERT_EQ(res, HCF_SUCCESS);
1623
1624 HcfBlob out = { .data = nullptr, .len = 0 };
1625 res = sign->sign(sign, nullptr, &out);
1626
1627 ASSERT_EQ(res, HCF_SUCCESS);
1628 ASSERT_NE(out.data, nullptr);
1629 ASSERT_NE(out.len, (const unsigned int)0);
1630
1631 HcfFree(out.data);
1632 HcfObjDestroy(sign);
1633 }
1634
1635 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest410, TestSize.Level0)
1636 {
1637 HcfSign *sign = nullptr;
1638 int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
1639
1640 ASSERT_EQ(res, HCF_SUCCESS);
1641 ASSERT_NE(sign, nullptr);
1642
1643 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1644
1645 ASSERT_EQ(res, HCF_SUCCESS);
1646
1647 res = sign->update(sign, &g_mockInput);
1648
1649 ASSERT_EQ(res, HCF_SUCCESS);
1650
1651 HcfBlob out = { .data = nullptr, .len = 0 };
1652 res = sign->sign(sign, nullptr, &out);
1653
1654 ASSERT_EQ(res, HCF_SUCCESS);
1655 ASSERT_NE(out.data, nullptr);
1656 ASSERT_NE(out.len, (const unsigned int)0);
1657
1658 HcfFree(out.data);
1659 HcfObjDestroy(sign);
1660 }
1661
1662 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest411, TestSize.Level0)
1663 {
1664 HcfSign *sign = nullptr;
1665 int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
1666
1667 ASSERT_EQ(res, HCF_SUCCESS);
1668 ASSERT_NE(sign, nullptr);
1669
1670 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1671
1672 ASSERT_EQ(res, HCF_SUCCESS);
1673
1674 res = sign->update(sign, &g_mockInput);
1675
1676 ASSERT_EQ(res, HCF_SUCCESS);
1677
1678 HcfBlob out = { .data = nullptr, .len = 0 };
1679 res = sign->sign(sign, nullptr, &out);
1680
1681 ASSERT_EQ(res, HCF_SUCCESS);
1682 ASSERT_NE(out.data, nullptr);
1683 ASSERT_NE(out.len, (const unsigned int)0);
1684
1685 HcfFree(out.data);
1686 HcfObjDestroy(sign);
1687 }
1688
1689 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest412, TestSize.Level0)
1690 {
1691 HcfSign *sign = nullptr;
1692 int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
1693
1694 ASSERT_EQ(res, HCF_SUCCESS);
1695 ASSERT_NE(sign, nullptr);
1696
1697 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1698
1699 ASSERT_EQ(res, HCF_SUCCESS);
1700
1701 res = sign->update(sign, &g_mockInput);
1702
1703 ASSERT_EQ(res, HCF_SUCCESS);
1704
1705 HcfBlob out = { .data = nullptr, .len = 0 };
1706 res = sign->sign(sign, nullptr, &out);
1707
1708 ASSERT_EQ(res, HCF_SUCCESS);
1709 ASSERT_NE(out.data, nullptr);
1710 ASSERT_NE(out.len, (const unsigned int)0);
1711
1712 HcfFree(out.data);
1713 HcfObjDestroy(sign);
1714 }
1715
1716 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest413, TestSize.Level0)
1717 {
1718 HcfSign *sign = nullptr;
1719 int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
1720
1721 ASSERT_EQ(res, HCF_SUCCESS);
1722 ASSERT_NE(sign, nullptr);
1723
1724 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1725
1726 ASSERT_EQ(res, HCF_SUCCESS);
1727
1728 res = sign->update(sign, &g_mockInput);
1729
1730 ASSERT_EQ(res, HCF_SUCCESS);
1731
1732 HcfBlob out = { .data = nullptr, .len = 0 };
1733 res = sign->sign(sign, nullptr, &out);
1734
1735 ASSERT_EQ(res, HCF_SUCCESS);
1736 ASSERT_NE(out.data, nullptr);
1737 ASSERT_NE(out.len, (const unsigned int)0);
1738
1739 HcfFree(out.data);
1740 HcfObjDestroy(sign);
1741 }
1742
1743 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest414, TestSize.Level0)
1744 {
1745 HcfSign *sign = nullptr;
1746 int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
1747
1748 ASSERT_EQ(res, HCF_SUCCESS);
1749 ASSERT_NE(sign, nullptr);
1750
1751 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1752
1753 ASSERT_EQ(res, HCF_SUCCESS);
1754
1755 res = sign->update(sign, &g_mockInput);
1756
1757 ASSERT_EQ(res, HCF_SUCCESS);
1758
1759 HcfBlob out = { .data = nullptr, .len = 0 };
1760 res = sign->sign(sign, nullptr, &out);
1761
1762 ASSERT_EQ(res, HCF_SUCCESS);
1763 ASSERT_NE(out.data, nullptr);
1764 ASSERT_NE(out.len, (const unsigned int)0);
1765
1766 HcfFree(out.data);
1767 HcfObjDestroy(sign);
1768 }
1769
1770 HWTEST_F(CryptoEccSignTest, CryptoEccSignTest415, TestSize.Level0)
1771 {
1772 HcfSign *sign = nullptr;
1773 int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
1774
1775 ASSERT_EQ(res, HCF_SUCCESS);
1776 ASSERT_NE(sign, nullptr);
1777
1778 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1779
1780 ASSERT_EQ(res, HCF_SUCCESS);
1781
1782 res = sign->update(sign, &g_mockInput);
1783
1784 ASSERT_EQ(res, HCF_SUCCESS);
1785
1786 HcfBlob out = { .data = nullptr, .len = 0 };
1787 res = sign->sign(sign, nullptr, &out);
1788
1789 ASSERT_EQ(res, HCF_SUCCESS);
1790 ASSERT_NE(out.data, nullptr);
1791 ASSERT_NE(out.len, (const unsigned int)0);
1792
1793 HcfFree(out.data);
1794 HcfObjDestroy(sign);
1795 }
1796 }
1797