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 CryptoEccSignSubTest : 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 *CryptoEccSignSubTest::ecc224KeyPair_ = nullptr;
46 HcfKeyPair *CryptoEccSignSubTest::ecc256KeyPair_ = nullptr;
47 HcfKeyPair *CryptoEccSignSubTest::ecc384KeyPair_ = nullptr;
48 HcfKeyPair *CryptoEccSignSubTest::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 CryptoEccSignSubTest::SetUp() {}
TearDown()57 void CryptoEccSignSubTest::TearDown() {}
58
SetUpTestCase()59 void CryptoEccSignSubTest::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 CryptoEccSignSubTest::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(CryptoEccSignSubTest, CryptoEccSignSubTest416, TestSize.Level0)
137 {
138 HcfSign *sign = nullptr;
139 int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
140
141 ASSERT_EQ(res, HCF_SUCCESS);
142 ASSERT_NE(sign, nullptr);
143
144 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
145
146 ASSERT_EQ(res, HCF_SUCCESS);
147
148 res = sign->update(sign, &g_mockInput);
149
150 ASSERT_EQ(res, HCF_SUCCESS);
151
152 HcfBlob out = { .data = nullptr, .len = 0 };
153 res = sign->sign(sign, nullptr, &out);
154
155 ASSERT_EQ(res, HCF_SUCCESS);
156 ASSERT_NE(out.data, nullptr);
157 ASSERT_NE(out.len, (const unsigned int)0);
158
159 HcfFree(out.data);
160 HcfObjDestroy(sign);
161 }
162
163 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest417, TestSize.Level0)
164 {
165 HcfSign *sign = nullptr;
166 int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
167
168 ASSERT_EQ(res, HCF_SUCCESS);
169 ASSERT_NE(sign, nullptr);
170
171 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
172
173 ASSERT_EQ(res, HCF_SUCCESS);
174
175 res = sign->update(sign, &g_mockInput);
176
177 ASSERT_EQ(res, HCF_SUCCESS);
178
179 HcfBlob out = { .data = nullptr, .len = 0 };
180 res = sign->sign(sign, nullptr, &out);
181
182 ASSERT_EQ(res, HCF_SUCCESS);
183 ASSERT_NE(out.data, nullptr);
184 ASSERT_NE(out.len, (const unsigned int)0);
185
186 HcfFree(out.data);
187 HcfObjDestroy(sign);
188 }
189
190 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest418, TestSize.Level0)
191 {
192 HcfSign *sign = nullptr;
193 int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
194
195 ASSERT_EQ(res, HCF_SUCCESS);
196 ASSERT_NE(sign, nullptr);
197
198 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
199
200 ASSERT_EQ(res, HCF_SUCCESS);
201
202 res = sign->update(sign, &g_mockInput);
203
204 ASSERT_EQ(res, HCF_SUCCESS);
205
206 HcfBlob out = { .data = nullptr, .len = 0 };
207 res = sign->sign(sign, nullptr, &out);
208
209 ASSERT_EQ(res, HCF_SUCCESS);
210 ASSERT_NE(out.data, nullptr);
211 ASSERT_NE(out.len, (const unsigned int)0);
212
213 HcfFree(out.data);
214 HcfObjDestroy(sign);
215 }
216
217 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest419, TestSize.Level0)
218 {
219 HcfSign *sign = nullptr;
220 int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
221
222 ASSERT_EQ(res, HCF_SUCCESS);
223 ASSERT_NE(sign, nullptr);
224
225 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
226
227 ASSERT_EQ(res, HCF_SUCCESS);
228
229 res = sign->update(sign, &g_mockInput);
230
231 ASSERT_EQ(res, HCF_SUCCESS);
232
233 HcfBlob out = { .data = nullptr, .len = 0 };
234 res = sign->sign(sign, nullptr, &out);
235
236 ASSERT_EQ(res, HCF_SUCCESS);
237 ASSERT_NE(out.data, nullptr);
238 ASSERT_NE(out.len, (const unsigned int)0);
239
240 HcfFree(out.data);
241 HcfObjDestroy(sign);
242 }
243
244 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest420, TestSize.Level0)
245 {
246 HcfSign *sign = nullptr;
247 int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
248
249 ASSERT_EQ(res, HCF_SUCCESS);
250 ASSERT_NE(sign, nullptr);
251
252 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
253
254 ASSERT_EQ(res, HCF_SUCCESS);
255
256 res = sign->update(sign, &g_mockInput);
257
258 ASSERT_EQ(res, HCF_SUCCESS);
259
260 HcfBlob out = { .data = nullptr, .len = 0 };
261 res = sign->sign(sign, nullptr, &out);
262
263 ASSERT_EQ(res, HCF_SUCCESS);
264 ASSERT_NE(out.data, nullptr);
265 ASSERT_NE(out.len, (const unsigned int)0);
266
267 HcfFree(out.data);
268 HcfObjDestroy(sign);
269 }
270
271 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest421, TestSize.Level0)
272 {
273 HcfSign *sign = nullptr;
274 int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
275
276 ASSERT_EQ(res, HCF_SUCCESS);
277 ASSERT_NE(sign, nullptr);
278
279 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
280
281 ASSERT_EQ(res, HCF_SUCCESS);
282
283 HcfBlob out = { .data = nullptr, .len = 0 };
284 res = sign->sign(sign, &g_mockInput, &out);
285
286 ASSERT_EQ(res, HCF_SUCCESS);
287 ASSERT_NE(out.data, nullptr);
288 ASSERT_NE(out.len, (const unsigned int)0);
289
290 HcfFree(out.data);
291 HcfObjDestroy(sign);
292 }
293
294 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest422, TestSize.Level0)
295 {
296 HcfSign *sign = nullptr;
297 int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
298
299 ASSERT_EQ(res, HCF_SUCCESS);
300 ASSERT_NE(sign, nullptr);
301
302 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
303
304 ASSERT_EQ(res, HCF_SUCCESS);
305
306 HcfBlob out = { .data = nullptr, .len = 0 };
307 res = sign->sign(sign, &g_mockInput, &out);
308
309 ASSERT_EQ(res, HCF_SUCCESS);
310 ASSERT_NE(out.data, nullptr);
311 ASSERT_NE(out.len, (const unsigned int)0);
312
313 HcfFree(out.data);
314 HcfObjDestroy(sign);
315 }
316
317 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest423, TestSize.Level0)
318 {
319 HcfSign *sign = nullptr;
320 int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
321
322 ASSERT_EQ(res, HCF_SUCCESS);
323 ASSERT_NE(sign, nullptr);
324
325 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
326
327 ASSERT_EQ(res, HCF_SUCCESS);
328
329 HcfBlob out = { .data = nullptr, .len = 0 };
330 res = sign->sign(sign, &g_mockInput, &out);
331
332 ASSERT_EQ(res, HCF_SUCCESS);
333 ASSERT_NE(out.data, nullptr);
334 ASSERT_NE(out.len, (const unsigned int)0);
335
336 HcfFree(out.data);
337 HcfObjDestroy(sign);
338 }
339
340 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest424, TestSize.Level0)
341 {
342 HcfSign *sign = nullptr;
343 int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
344
345 ASSERT_EQ(res, HCF_SUCCESS);
346 ASSERT_NE(sign, nullptr);
347
348 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
349
350 ASSERT_EQ(res, HCF_SUCCESS);
351
352 HcfBlob out = { .data = nullptr, .len = 0 };
353 res = sign->sign(sign, &g_mockInput, &out);
354
355 ASSERT_EQ(res, HCF_SUCCESS);
356 ASSERT_NE(out.data, nullptr);
357 ASSERT_NE(out.len, (const unsigned int)0);
358
359 HcfFree(out.data);
360 HcfObjDestroy(sign);
361 }
362
363 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest425, TestSize.Level0)
364 {
365 HcfSign *sign = nullptr;
366 int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
367
368 ASSERT_EQ(res, HCF_SUCCESS);
369 ASSERT_NE(sign, nullptr);
370
371 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
372
373 ASSERT_EQ(res, HCF_SUCCESS);
374
375 HcfBlob out = { .data = nullptr, .len = 0 };
376 res = sign->sign(sign, &g_mockInput, &out);
377
378 ASSERT_EQ(res, HCF_SUCCESS);
379 ASSERT_NE(out.data, nullptr);
380 ASSERT_NE(out.len, (const unsigned int)0);
381
382 HcfFree(out.data);
383 HcfObjDestroy(sign);
384 }
385
386 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest426, TestSize.Level0)
387 {
388 HcfSign *sign = nullptr;
389 int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
390
391 ASSERT_EQ(res, HCF_SUCCESS);
392 ASSERT_NE(sign, nullptr);
393
394 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
395
396 ASSERT_EQ(res, HCF_SUCCESS);
397
398 HcfBlob out = { .data = nullptr, .len = 0 };
399 res = sign->sign(sign, &g_mockInput, &out);
400
401 ASSERT_EQ(res, HCF_SUCCESS);
402 ASSERT_NE(out.data, nullptr);
403 ASSERT_NE(out.len, (const unsigned int)0);
404
405 HcfFree(out.data);
406 HcfObjDestroy(sign);
407 }
408
409 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest427, TestSize.Level0)
410 {
411 HcfSign *sign = nullptr;
412 int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
413
414 ASSERT_EQ(res, HCF_SUCCESS);
415 ASSERT_NE(sign, nullptr);
416
417 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
418
419 ASSERT_EQ(res, HCF_SUCCESS);
420
421 HcfBlob out = { .data = nullptr, .len = 0 };
422 res = sign->sign(sign, &g_mockInput, &out);
423
424 ASSERT_EQ(res, HCF_SUCCESS);
425 ASSERT_NE(out.data, nullptr);
426 ASSERT_NE(out.len, (const unsigned int)0);
427
428 HcfFree(out.data);
429 HcfObjDestroy(sign);
430 }
431
432 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest428, TestSize.Level0)
433 {
434 HcfSign *sign = nullptr;
435 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
436
437 ASSERT_EQ(res, HCF_SUCCESS);
438 ASSERT_NE(sign, nullptr);
439
440 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
441
442 ASSERT_EQ(res, HCF_SUCCESS);
443
444 HcfBlob out = { .data = nullptr, .len = 0 };
445 res = sign->sign(sign, &g_mockInput, &out);
446
447 ASSERT_EQ(res, HCF_SUCCESS);
448 ASSERT_NE(out.data, nullptr);
449 ASSERT_NE(out.len, (const unsigned int)0);
450
451 HcfFree(out.data);
452 HcfObjDestroy(sign);
453 }
454
455 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest429, TestSize.Level0)
456 {
457 HcfSign *sign = nullptr;
458 int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
459
460 ASSERT_EQ(res, HCF_SUCCESS);
461 ASSERT_NE(sign, nullptr);
462
463 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
464
465 ASSERT_EQ(res, HCF_SUCCESS);
466
467 HcfBlob out = { .data = nullptr, .len = 0 };
468 res = sign->sign(sign, &g_mockInput, &out);
469
470 ASSERT_EQ(res, HCF_SUCCESS);
471 ASSERT_NE(out.data, nullptr);
472 ASSERT_NE(out.len, (const unsigned int)0);
473
474 HcfFree(out.data);
475 HcfObjDestroy(sign);
476 }
477
478 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest430, TestSize.Level0)
479 {
480 HcfSign *sign = nullptr;
481 int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
482
483 ASSERT_EQ(res, HCF_SUCCESS);
484 ASSERT_NE(sign, nullptr);
485
486 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
487
488 ASSERT_EQ(res, HCF_SUCCESS);
489
490 HcfBlob out = { .data = nullptr, .len = 0 };
491 res = sign->sign(sign, &g_mockInput, &out);
492
493 ASSERT_EQ(res, HCF_SUCCESS);
494 ASSERT_NE(out.data, nullptr);
495 ASSERT_NE(out.len, (const unsigned int)0);
496
497 HcfFree(out.data);
498 HcfObjDestroy(sign);
499 }
500
501 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest431, TestSize.Level0)
502 {
503 HcfSign *sign = nullptr;
504 int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
505
506 ASSERT_EQ(res, HCF_SUCCESS);
507 ASSERT_NE(sign, nullptr);
508
509 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
510
511 ASSERT_EQ(res, HCF_SUCCESS);
512
513 HcfBlob out = { .data = nullptr, .len = 0 };
514 res = sign->sign(sign, &g_mockInput, &out);
515
516 ASSERT_EQ(res, HCF_SUCCESS);
517 ASSERT_NE(out.data, nullptr);
518 ASSERT_NE(out.len, (const unsigned int)0);
519
520 HcfFree(out.data);
521 HcfObjDestroy(sign);
522 }
523
524 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest432, TestSize.Level0)
525 {
526 HcfSign *sign = nullptr;
527 int32_t res = HcfSignCreate("ECC384|SHA224", &sign);
528
529 ASSERT_EQ(res, HCF_SUCCESS);
530 ASSERT_NE(sign, nullptr);
531
532 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
533
534 ASSERT_EQ(res, HCF_SUCCESS);
535
536 HcfBlob out = { .data = nullptr, .len = 0 };
537 res = sign->sign(sign, &g_mockInput, &out);
538
539 ASSERT_EQ(res, HCF_SUCCESS);
540 ASSERT_NE(out.data, nullptr);
541 ASSERT_NE(out.len, (const unsigned int)0);
542
543 HcfFree(out.data);
544 HcfObjDestroy(sign);
545 }
546
547 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest433, TestSize.Level0)
548 {
549 HcfSign *sign = nullptr;
550 int32_t res = HcfSignCreate("ECC384|SHA256", &sign);
551
552 ASSERT_EQ(res, HCF_SUCCESS);
553 ASSERT_NE(sign, nullptr);
554
555 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
556
557 ASSERT_EQ(res, HCF_SUCCESS);
558
559 HcfBlob out = { .data = nullptr, .len = 0 };
560 res = sign->sign(sign, &g_mockInput, &out);
561
562 ASSERT_EQ(res, HCF_SUCCESS);
563 ASSERT_NE(out.data, nullptr);
564 ASSERT_NE(out.len, (const unsigned int)0);
565
566 HcfFree(out.data);
567 HcfObjDestroy(sign);
568 }
569
570 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest434, TestSize.Level0)
571 {
572 HcfSign *sign = nullptr;
573 int32_t res = HcfSignCreate("ECC384|SHA384", &sign);
574
575 ASSERT_EQ(res, HCF_SUCCESS);
576 ASSERT_NE(sign, nullptr);
577
578 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
579
580 ASSERT_EQ(res, HCF_SUCCESS);
581
582 HcfBlob out = { .data = nullptr, .len = 0 };
583 res = sign->sign(sign, &g_mockInput, &out);
584
585 ASSERT_EQ(res, HCF_SUCCESS);
586 ASSERT_NE(out.data, nullptr);
587 ASSERT_NE(out.len, (const unsigned int)0);
588
589 HcfFree(out.data);
590 HcfObjDestroy(sign);
591 }
592
593 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest435, TestSize.Level0)
594 {
595 HcfSign *sign = nullptr;
596 int32_t res = HcfSignCreate("ECC384|SHA512", &sign);
597
598 ASSERT_EQ(res, HCF_SUCCESS);
599 ASSERT_NE(sign, nullptr);
600
601 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
602
603 ASSERT_EQ(res, HCF_SUCCESS);
604
605 HcfBlob out = { .data = nullptr, .len = 0 };
606 res = sign->sign(sign, &g_mockInput, &out);
607
608 ASSERT_EQ(res, HCF_SUCCESS);
609 ASSERT_NE(out.data, nullptr);
610 ASSERT_NE(out.len, (const unsigned int)0);
611
612 HcfFree(out.data);
613 HcfObjDestroy(sign);
614 }
615
616 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest436, TestSize.Level0)
617 {
618 HcfSign *sign = nullptr;
619 int32_t res = HcfSignCreate("ECC521|SHA1", &sign);
620
621 ASSERT_EQ(res, HCF_SUCCESS);
622 ASSERT_NE(sign, nullptr);
623
624 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
625
626 ASSERT_EQ(res, HCF_SUCCESS);
627
628 HcfBlob out = { .data = nullptr, .len = 0 };
629 res = sign->sign(sign, &g_mockInput, &out);
630
631 ASSERT_EQ(res, HCF_SUCCESS);
632 ASSERT_NE(out.data, nullptr);
633 ASSERT_NE(out.len, (const unsigned int)0);
634
635 HcfFree(out.data);
636 HcfObjDestroy(sign);
637 }
638
639 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest437, TestSize.Level0)
640 {
641 HcfSign *sign = nullptr;
642 int32_t res = HcfSignCreate("ECC521|SHA224", &sign);
643
644 ASSERT_EQ(res, HCF_SUCCESS);
645 ASSERT_NE(sign, nullptr);
646
647 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
648
649 ASSERT_EQ(res, HCF_SUCCESS);
650
651 HcfBlob out = { .data = nullptr, .len = 0 };
652 res = sign->sign(sign, &g_mockInput, &out);
653
654 ASSERT_EQ(res, HCF_SUCCESS);
655 ASSERT_NE(out.data, nullptr);
656 ASSERT_NE(out.len, (const unsigned int)0);
657
658 HcfFree(out.data);
659 HcfObjDestroy(sign);
660 }
661
662 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest438, TestSize.Level0)
663 {
664 HcfSign *sign = nullptr;
665 int32_t res = HcfSignCreate("ECC521|SHA256", &sign);
666
667 ASSERT_EQ(res, HCF_SUCCESS);
668 ASSERT_NE(sign, nullptr);
669
670 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
671
672 ASSERT_EQ(res, HCF_SUCCESS);
673
674 HcfBlob out = { .data = nullptr, .len = 0 };
675 res = sign->sign(sign, &g_mockInput, &out);
676
677 ASSERT_EQ(res, HCF_SUCCESS);
678 ASSERT_NE(out.data, nullptr);
679 ASSERT_NE(out.len, (const unsigned int)0);
680
681 HcfFree(out.data);
682 HcfObjDestroy(sign);
683 }
684
685 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest439, TestSize.Level0)
686 {
687 HcfSign *sign = nullptr;
688 int32_t res = HcfSignCreate("ECC521|SHA384", &sign);
689
690 ASSERT_EQ(res, HCF_SUCCESS);
691 ASSERT_NE(sign, nullptr);
692
693 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
694
695 ASSERT_EQ(res, HCF_SUCCESS);
696
697 HcfBlob out = { .data = nullptr, .len = 0 };
698 res = sign->sign(sign, &g_mockInput, &out);
699
700 ASSERT_EQ(res, HCF_SUCCESS);
701 ASSERT_NE(out.data, nullptr);
702 ASSERT_NE(out.len, (const unsigned int)0);
703
704 HcfFree(out.data);
705 HcfObjDestroy(sign);
706 }
707
708 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest440, TestSize.Level0)
709 {
710 HcfSign *sign = nullptr;
711 int32_t res = HcfSignCreate("ECC521|SHA512", &sign);
712
713 ASSERT_EQ(res, HCF_SUCCESS);
714 ASSERT_NE(sign, nullptr);
715
716 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
717
718 ASSERT_EQ(res, HCF_SUCCESS);
719
720 HcfBlob out = { .data = nullptr, .len = 0 };
721 res = sign->sign(sign, &g_mockInput, &out);
722
723 ASSERT_EQ(res, HCF_SUCCESS);
724 ASSERT_NE(out.data, nullptr);
725 ASSERT_NE(out.len, (const unsigned int)0);
726
727 HcfFree(out.data);
728 HcfObjDestroy(sign);
729 }
730
731 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest441, TestSize.Level0)
732 {
733 HcfSign *sign = nullptr;
734 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
735
736 ASSERT_EQ(res, HCF_SUCCESS);
737 ASSERT_NE(sign, nullptr);
738
739 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
740
741 ASSERT_EQ(res, HCF_SUCCESS);
742
743 res = sign->update(sign, &g_mockInput);
744
745 ASSERT_EQ(res, HCF_SUCCESS);
746
747 HcfBlob out = { .data = nullptr, .len = 0 };
748 res = sign->sign(nullptr, nullptr, &out);
749
750 ASSERT_EQ(res, HCF_INVALID_PARAMS);
751
752 HcfObjDestroy(sign);
753 }
754
755 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest442, TestSize.Level0)
756 {
757 HcfSign *sign = nullptr;
758 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
759
760 ASSERT_EQ(res, HCF_SUCCESS);
761 ASSERT_NE(sign, nullptr);
762
763 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
764
765 ASSERT_EQ(res, HCF_SUCCESS);
766
767 res = sign->update(sign, &g_mockInput);
768
769 ASSERT_EQ(res, HCF_SUCCESS);
770
771 HcfBlob out = { .data = nullptr, .len = 0 };
772 res = sign->sign((HcfSign *)(&obj), nullptr, &out);
773
774 ASSERT_EQ(res, HCF_INVALID_PARAMS);
775
776 HcfObjDestroy(sign);
777 }
778
779 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest443, TestSize.Level0)
780 {
781 HcfSign *sign = nullptr;
782 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
783
784 ASSERT_EQ(res, HCF_SUCCESS);
785 ASSERT_NE(sign, nullptr);
786
787 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
788
789 ASSERT_EQ(res, HCF_SUCCESS);
790
791 HcfBlob out = { .data = nullptr, .len = 0 };
792 res = sign->sign(sign, nullptr, &out);
793
794 ASSERT_EQ(res, HCF_INVALID_PARAMS);
795
796 HcfObjDestroy(sign);
797 }
798
799 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest444, TestSize.Level0)
800 {
801 HcfSign *sign = nullptr;
802 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
803
804 ASSERT_EQ(res, HCF_SUCCESS);
805 ASSERT_NE(sign, nullptr);
806
807 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
808
809 ASSERT_EQ(res, HCF_SUCCESS);
810
811 HcfBlob input = {
812 .data = nullptr,
813 .len = 1
814 };
815 HcfBlob out = { .data = nullptr, .len = 0 };
816 res = sign->sign(sign, &input, &out);
817
818 ASSERT_EQ(res, HCF_INVALID_PARAMS);
819
820 HcfObjDestroy(sign);
821 }
822
823 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest445, TestSize.Level0)
824 {
825 HcfSign *sign = nullptr;
826 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
827
828 ASSERT_EQ(res, HCF_SUCCESS);
829 ASSERT_NE(sign, nullptr);
830
831 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
832
833 ASSERT_EQ(res, HCF_SUCCESS);
834
835 HcfBlob input = {
836 .data = (uint8_t *)g_mockMessage,
837 .len = 0
838 };
839 HcfBlob out = { .data = nullptr, .len = 0 };
840 res = sign->sign(sign, &input, &out);
841
842 ASSERT_EQ(res, HCF_INVALID_PARAMS);
843
844 HcfObjDestroy(sign);
845 }
846
847 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest446, TestSize.Level0)
848 {
849 HcfSign *sign = nullptr;
850 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
851
852 ASSERT_EQ(res, HCF_SUCCESS);
853 ASSERT_NE(sign, nullptr);
854
855 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
856
857 ASSERT_EQ(res, HCF_SUCCESS);
858
859 res = sign->update(sign, &g_mockInput);
860
861 ASSERT_EQ(res, HCF_SUCCESS);
862
863 res = sign->sign(sign, nullptr, nullptr);
864
865 ASSERT_EQ(res, HCF_INVALID_PARAMS);
866
867 HcfObjDestroy(sign);
868 }
869
870 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest447, TestSize.Level0)
871 {
872 HcfSign *sign = nullptr;
873 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
874
875 ASSERT_EQ(res, HCF_SUCCESS);
876 ASSERT_NE(sign, nullptr);
877
878 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
879
880 ASSERT_EQ(res, HCF_SUCCESS);
881
882 const char *message = "hello world";
883 HcfBlob input = {
884 .data = (uint8_t *)message,
885 .len = 12
886 };
887 res = sign->update(sign, &input);
888
889 ASSERT_EQ(res, HCF_SUCCESS);
890
891 HcfBlob out = { .data = nullptr, .len = 0 };
892 res = sign->sign(sign, nullptr, &out);
893
894 ASSERT_EQ(res, HCF_SUCCESS);
895 ASSERT_NE(out.data, nullptr);
896 ASSERT_NE(out.len, (const unsigned int)0);
897
898 res = sign->update(sign, &input);
899
900 ASSERT_EQ(res, HCF_SUCCESS);
901
902 HcfBlob out2 = { .data = nullptr, .len = 0 };
903 res = sign->sign(sign, nullptr, &out2);
904
905 HcfVerify *verify = nullptr;
906 res = HcfVerifyCreate("ECC256|SHA256", &verify);
907 ASSERT_EQ(res, HCF_SUCCESS);
908 ASSERT_NE(verify, nullptr);
909
910 verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
911 ASSERT_EQ(res, HCF_SUCCESS);
912
913 verify->update(verify, &input);
914 ASSERT_EQ(res, HCF_SUCCESS);
915
916 bool flag = verify->verify(verify, nullptr, &out);
917 ASSERT_EQ(flag, true);
918
919 verify->update(verify, &input);
920 ASSERT_EQ(res, HCF_SUCCESS);
921
922 flag = verify->verify(verify, nullptr, &out2);
923 ASSERT_EQ(flag, true);
924
925 HcfFree(out.data);
926 HcfFree(out2.data);
927 HcfObjDestroy(sign);
928 HcfObjDestroy(verify);
929 }
930
931 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest448, TestSize.Level0)
932 {
933 HcfSign *sign = nullptr;
934 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
935
936 ASSERT_EQ(res, HCF_SUCCESS);
937 ASSERT_NE(sign, nullptr);
938
939 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
940
941 ASSERT_EQ(res, HCF_SUCCESS);
942
943 const char *message = "hello world";
944 HcfBlob input = {
945 .data = (uint8_t *)message,
946 .len = 12
947 };
948 res = sign->update(sign, &input);
949
950 ASSERT_EQ(res, HCF_SUCCESS);
951
952 res = sign->update(sign, &input);
953
954 ASSERT_EQ(res, HCF_SUCCESS);
955
956 HcfBlob out2 = { .data = nullptr, .len = 0 };
957 res = sign->sign(sign, nullptr, &out2);
958
959 HcfFree(out2.data);
960 HcfObjDestroy(sign);
961 }
962
963 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest927, TestSize.Level0)
964 {
965 HcfAsyKeyGenerator *generator = nullptr;
966 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
967 ASSERT_EQ(res, HCF_SUCCESS);
968 ASSERT_NE(generator, nullptr);
969
970 HcfKeyPair *keyPair = nullptr;
971 res = generator->generateKeyPair(generator, nullptr, &keyPair);
972 ASSERT_EQ(res, HCF_SUCCESS);
973 ASSERT_NE(keyPair, nullptr);
974
975 HcfObjDestroy(generator);
976
977 HcfSign *sign = nullptr;
978 res = HcfSignCreate("ECC256|SHA256", &sign);
979 ASSERT_EQ(res, HCF_SUCCESS);
980 ASSERT_NE(sign, nullptr);
981
982 HcfParamsSpec params;
983 res = sign->init(sign, ¶ms, keyPair->priKey);
984 ASSERT_EQ(res, HCF_SUCCESS);
985
986 const char *message = "hello world";
987 HcfBlob input = {
988 .data = (uint8_t *)message,
989 .len = 12
990 };
991
992 HcfBlob out = { .data = nullptr, .len = 0 };
993 res = sign->sign(sign, &input, &out);
994 ASSERT_EQ(res, HCF_SUCCESS);
995 ASSERT_NE(out.data, nullptr);
996 ASSERT_NE(out.len, (const unsigned int)0);
997
998 HcfFree(out.data);
999 HcfObjDestroy(sign);
1000 }
1001
1002 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest928, TestSize.Level0)
1003 {
1004 HcfAsyKeyGenerator *generator = nullptr;
1005 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1006 ASSERT_EQ(res, HCF_SUCCESS);
1007 ASSERT_NE(generator, nullptr);
1008
1009 HcfKeyPair *keyPair = nullptr;
1010 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1011 ASSERT_EQ(res, HCF_SUCCESS);
1012 ASSERT_NE(keyPair, nullptr);
1013
1014 HcfObjDestroy(generator);
1015
1016 HcfSign *sign = nullptr;
1017 res = HcfSignCreate("ECC224|SHA256", &sign);
1018 ASSERT_EQ(res, HCF_SUCCESS);
1019 ASSERT_NE(sign, nullptr);
1020
1021 HcfParamsSpec params;
1022 res = sign->init(sign, ¶ms, keyPair->priKey);
1023 ASSERT_EQ(res, HCF_SUCCESS);
1024
1025 const char *message = "hello world";
1026 HcfBlob input = {
1027 .data = (uint8_t *)message,
1028 .len = 12
1029 };
1030 res = sign->update(sign, &input);
1031 ASSERT_EQ(res, HCF_SUCCESS);
1032
1033 HcfBlob out = { .data = nullptr, .len = 0 };
1034 res = sign->sign(sign, nullptr, &out);
1035 ASSERT_EQ(res, HCF_SUCCESS);
1036 ASSERT_NE(out.data, nullptr);
1037 ASSERT_NE(out.len, (const unsigned int)0);
1038
1039 HcfFree(out.data);
1040 HcfObjDestroy(sign);
1041 }
1042
1043 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1001, TestSize.Level0)
1044 {
1045 HcfSignSpi *spiObj = nullptr;
1046 int32_t res = HcfSignSpiEcdsaCreate(nullptr, &spiObj);
1047
1048 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1049 ASSERT_EQ(spiObj, nullptr);
1050 }
1051
1052 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1002, TestSize.Level0)
1053 {
1054 HcfSignatureParams params = {
1055 .algo = HCF_ALG_ECC,
1056 .padding = HCF_ALG_NOPADDING,
1057 .md = HCF_OPENSSL_DIGEST_SHA256,
1058 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1059 };
1060 int32_t res = HcfSignSpiEcdsaCreate(¶ms, nullptr);
1061
1062 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1063 }
1064
1065 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1004, TestSize.Level0)
1066 {
1067 HcfSignatureParams params = {
1068 .algo = HCF_ALG_ECC,
1069 .padding = HCF_ALG_NOPADDING,
1070 .md = HCF_OPENSSL_DIGEST_SHA256,
1071 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1072 };
1073 HcfSignSpi *spiObj = nullptr;
1074 int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj);
1075
1076 ASSERT_EQ(res, HCF_SUCCESS);
1077 ASSERT_NE(spiObj, nullptr);
1078
1079 res = spiObj->engineInit((HcfSignSpi *)&obj, nullptr, ecc256KeyPair_->priKey);
1080 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1081
1082 HcfObjDestroy(spiObj);
1083 }
1084
1085 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1005, TestSize.Level0)
1086 {
1087 HcfSignatureParams params = {
1088 .algo = HCF_ALG_ECC,
1089 .padding = HCF_ALG_NOPADDING,
1090 .md = HCF_OPENSSL_DIGEST_SHA256,
1091 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1092 };
1093 HcfSignSpi *spiObj = nullptr;
1094 int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj);
1095
1096 ASSERT_EQ(res, HCF_SUCCESS);
1097 ASSERT_NE(spiObj, nullptr);
1098
1099 res = spiObj->engineInit(spiObj, nullptr, (HcfPriKey *)&obj);
1100 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1101
1102 HcfObjDestroy(spiObj);
1103 }
1104
1105 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1006, TestSize.Level0)
1106 {
1107 HcfSignatureParams params = {
1108 .algo = HCF_ALG_ECC,
1109 .padding = HCF_ALG_NOPADDING,
1110 .md = HCF_OPENSSL_DIGEST_SHA256,
1111 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1112 };
1113 HcfSignSpi *spiObj = nullptr;
1114 int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj);
1115
1116 ASSERT_EQ(res, HCF_SUCCESS);
1117 ASSERT_NE(spiObj, nullptr);
1118
1119 const char *message = "hello world";
1120 HcfBlob input = {
1121 .data = (uint8_t *)message,
1122 .len = 12
1123 };
1124 res = spiObj->engineUpdate(nullptr, &input);
1125 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1126
1127 HcfObjDestroy(spiObj);
1128 }
1129
1130 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1007, TestSize.Level0)
1131 {
1132 HcfSignatureParams params = {
1133 .algo = HCF_ALG_ECC,
1134 .padding = HCF_ALG_NOPADDING,
1135 .md = HCF_OPENSSL_DIGEST_SHA256,
1136 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1137 };
1138 HcfSignSpi *spiObj = nullptr;
1139 int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj);
1140
1141 ASSERT_EQ(res, HCF_SUCCESS);
1142 ASSERT_NE(spiObj, nullptr);
1143
1144 const char *message = "hello world";
1145 HcfBlob input = {
1146 .data = (uint8_t *)message,
1147 .len = 12
1148 };
1149 res = spiObj->engineUpdate((HcfSignSpi *)&obj, &input);
1150 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1151
1152 HcfObjDestroy(spiObj);
1153 }
1154
1155 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1008, TestSize.Level0)
1156 {
1157 HcfSignatureParams params = {
1158 .algo = HCF_ALG_ECC,
1159 .padding = HCF_ALG_NOPADDING,
1160 .md = HCF_OPENSSL_DIGEST_SHA256,
1161 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1162 };
1163 HcfSignSpi *spiObj = nullptr;
1164 int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj);
1165
1166 ASSERT_EQ(res, HCF_SUCCESS);
1167 ASSERT_NE(spiObj, nullptr);
1168
1169 res = spiObj->engineUpdate(spiObj, nullptr);
1170 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1171
1172 HcfObjDestroy(spiObj);
1173 }
1174
1175 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1009, TestSize.Level0)
1176 {
1177 HcfSignatureParams params = {
1178 .algo = HCF_ALG_ECC,
1179 .padding = HCF_ALG_NOPADDING,
1180 .md = HCF_OPENSSL_DIGEST_SHA256,
1181 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1182 };
1183 HcfSignSpi *spiObj = nullptr;
1184 int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj);
1185
1186 ASSERT_EQ(res, HCF_SUCCESS);
1187 ASSERT_NE(spiObj, nullptr);
1188
1189 const char *message = "hello world";
1190 HcfBlob input = {
1191 .data = (uint8_t *)message,
1192 .len = 12
1193 };
1194 HcfBlob out = { .data = nullptr, .len = 0 };
1195 res = spiObj->engineSign((HcfSignSpi *)&obj, &input, &out);
1196 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1197
1198 HcfObjDestroy(spiObj);
1199 }
1200
1201 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1010, TestSize.Level0)
1202 {
1203 HcfSignatureParams params = {
1204 .algo = HCF_ALG_ECC,
1205 .padding = HCF_ALG_NOPADDING,
1206 .md = HCF_OPENSSL_DIGEST_SHA256,
1207 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1208 };
1209 HcfSignSpi *spiObj = nullptr;
1210 int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj);
1211
1212 ASSERT_EQ(res, HCF_SUCCESS);
1213 ASSERT_NE(spiObj, nullptr);
1214
1215 spiObj->base.destroy(nullptr);
1216
1217 HcfObjDestroy(spiObj);
1218 }
1219
1220 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1011, TestSize.Level0)
1221 {
1222 HcfSignatureParams params = {
1223 .algo = HCF_ALG_ECC,
1224 .padding = HCF_ALG_NOPADDING,
1225 .md = HCF_OPENSSL_DIGEST_SHA256,
1226 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1227 };
1228 HcfSignSpi *spiObj = nullptr;
1229 int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj);
1230
1231 ASSERT_EQ(res, HCF_SUCCESS);
1232 ASSERT_NE(spiObj, nullptr);
1233
1234 spiObj->base.destroy(&obj);
1235
1236 HcfObjDestroy(spiObj);
1237 }
1238
MemoryMallocTestFunc(uint32_t mallocCount,HcfBlob * input)1239 static void MemoryMallocTestFunc(uint32_t mallocCount, HcfBlob *input)
1240 {
1241 for (uint32_t i = 0; i < mallocCount; i++) {
1242 ResetRecordMallocNum();
1243 SetMockMallocIndex(i);
1244 HcfAsyKeyGenerator *generator = nullptr;
1245 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1246 if (res != HCF_SUCCESS) {
1247 continue;
1248 }
1249 HcfKeyPair *keyPair = nullptr;
1250 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1251 HcfObjDestroy(generator);
1252 if (res != HCF_SUCCESS) {
1253 continue;
1254 }
1255 HcfSign *sign = nullptr;
1256 res = HcfSignCreate("ECC224|SHA256", &sign);
1257 if (res != HCF_SUCCESS) {
1258 HcfObjDestroy(keyPair);
1259 continue;
1260 }
1261 res = sign->init(sign, nullptr, keyPair->priKey);
1262 if (res != HCF_SUCCESS) {
1263 HcfObjDestroy(sign);
1264 HcfObjDestroy(keyPair);
1265 continue;
1266 }
1267 res = sign->update(sign, input);
1268 if (res != HCF_SUCCESS) {
1269 HcfObjDestroy(sign);
1270 HcfObjDestroy(keyPair);
1271 continue;
1272 }
1273 HcfBlob out = {
1274 .data = nullptr,
1275 .len = 0
1276 };
1277 res = sign->sign(sign, nullptr, &out);
1278 HcfObjDestroy(sign);
1279 HcfObjDestroy(keyPair);
1280 if (res == HCF_SUCCESS) {
1281 HcfFree(out.data);
1282 }
1283 }
1284 }
1285
1286 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1101, TestSize.Level0)
1287 {
1288 StartRecordMallocNum();
1289 HcfAsyKeyGenerator *generator = nullptr;
1290 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1291 ASSERT_EQ(res, HCF_SUCCESS);
1292 ASSERT_NE(generator, nullptr);
1293
1294 HcfKeyPair *keyPair = nullptr;
1295 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1296 ASSERT_EQ(res, HCF_SUCCESS);
1297 ASSERT_NE(keyPair, nullptr);
1298
1299 HcfObjDestroy(generator);
1300
1301 HcfSign *sign = nullptr;
1302 res = HcfSignCreate("ECC224|SHA256", &sign);
1303 ASSERT_EQ(res, HCF_SUCCESS);
1304 ASSERT_NE(sign, nullptr);
1305
1306 HcfParamsSpec params;
1307 res = sign->init(sign, ¶ms, keyPair->priKey);
1308 ASSERT_EQ(res, HCF_SUCCESS);
1309
1310 const char *message = "hello world";
1311 HcfBlob input = {
1312 .data = (uint8_t *)message,
1313 .len = 12
1314 };
1315 res = sign->update(sign, &input);
1316 ASSERT_EQ(res, HCF_SUCCESS);
1317
1318 HcfBlob out = { .data = nullptr, .len = 0 };
1319 res = sign->sign(sign, nullptr, &out);
1320 ASSERT_EQ(res, HCF_SUCCESS);
1321 ASSERT_NE(out.data, nullptr);
1322 ASSERT_NE(out.len, (const unsigned int)0);
1323
1324 HcfFree(out.data);
1325 HcfObjDestroy(sign);
1326
1327 uint32_t mallocCount = GetMallocNum();
1328 MemoryMallocTestFunc(mallocCount, &input);
1329
1330 EndRecordMallocNum();
1331 }
1332
OpensslMockTestFunc(uint32_t mallocCount,HcfBlob * input)1333 static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *input)
1334 {
1335 for (uint32_t i = 0; i < mallocCount; i++) {
1336 ResetOpensslCallNum();
1337 SetOpensslCallMockIndex(i);
1338 HcfAsyKeyGenerator *generator = nullptr;
1339 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1340 if (res != HCF_SUCCESS) {
1341 continue;
1342 }
1343 HcfKeyPair *keyPair = nullptr;
1344 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1345 HcfObjDestroy(generator);
1346 if (res != HCF_SUCCESS) {
1347 continue;
1348 }
1349 HcfSign *sign = nullptr;
1350 res = HcfSignCreate("ECC224|SHA256", &sign);
1351 if (res != HCF_SUCCESS) {
1352 HcfObjDestroy(keyPair);
1353 continue;
1354 }
1355 res = sign->init(sign, nullptr, keyPair->priKey);
1356 if (res != HCF_SUCCESS) {
1357 HcfObjDestroy(sign);
1358 HcfObjDestroy(keyPair);
1359 continue;
1360 }
1361 res = sign->update(sign, input);
1362 if (res != HCF_SUCCESS) {
1363 HcfObjDestroy(sign);
1364 HcfObjDestroy(keyPair);
1365 continue;
1366 }
1367 HcfBlob out = {
1368 .data = nullptr,
1369 .len = 0
1370 };
1371 res = sign->sign(sign, input, &out);
1372 HcfObjDestroy(sign);
1373 HcfObjDestroy(keyPair);
1374 if (res == HCF_SUCCESS) {
1375 HcfFree(out.data);
1376 }
1377 }
1378 }
1379
1380 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1102, TestSize.Level0)
1381 {
1382 StartRecordOpensslCallNum();
1383 HcfAsyKeyGenerator *generator = nullptr;
1384 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1385 ASSERT_EQ(res, HCF_SUCCESS);
1386 ASSERT_NE(generator, nullptr);
1387
1388 HcfKeyPair *keyPair = nullptr;
1389 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1390 ASSERT_EQ(res, HCF_SUCCESS);
1391 ASSERT_NE(keyPair, nullptr);
1392
1393 HcfObjDestroy(generator);
1394
1395 HcfSign *sign = nullptr;
1396 res = HcfSignCreate("ECC224|SHA256", &sign);
1397 ASSERT_EQ(res, HCF_SUCCESS);
1398 ASSERT_NE(sign, nullptr);
1399
1400 HcfParamsSpec params;
1401 res = sign->init(sign, ¶ms, keyPair->priKey);
1402 ASSERT_EQ(res, HCF_SUCCESS);
1403
1404 const char *message = "hello world";
1405 HcfBlob input = {
1406 .data = (uint8_t *)message,
1407 .len = 12
1408 };
1409 res = sign->update(sign, &input);
1410 ASSERT_EQ(res, HCF_SUCCESS);
1411
1412 HcfBlob out = { .data = nullptr, .len = 0 };
1413 res = sign->sign(sign, &input, &out);
1414 ASSERT_EQ(res, HCF_SUCCESS);
1415 ASSERT_NE(out.data, nullptr);
1416 ASSERT_NE(out.len, (const unsigned int)0);
1417
1418 HcfFree(out.data);
1419 HcfObjDestroy(sign);
1420
1421 uint32_t mallocCount = GetOpensslCallNum();
1422 OpensslMockTestFunc(mallocCount, &input);
1423
1424 EndRecordOpensslCallNum();
1425 }
1426 }
1427