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 HcfObjDestroy(keyPair);
1001 }
1002
1003 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest928, TestSize.Level0)
1004 {
1005 HcfAsyKeyGenerator *generator = nullptr;
1006 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1007 ASSERT_EQ(res, HCF_SUCCESS);
1008 ASSERT_NE(generator, nullptr);
1009
1010 HcfKeyPair *keyPair = nullptr;
1011 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1012 ASSERT_EQ(res, HCF_SUCCESS);
1013 ASSERT_NE(keyPair, nullptr);
1014
1015 HcfObjDestroy(generator);
1016
1017 HcfSign *sign = nullptr;
1018 res = HcfSignCreate("ECC224|SHA256", &sign);
1019 ASSERT_EQ(res, HCF_SUCCESS);
1020 ASSERT_NE(sign, nullptr);
1021
1022 HcfParamsSpec params;
1023 res = sign->init(sign, ¶ms, keyPair->priKey);
1024 ASSERT_EQ(res, HCF_SUCCESS);
1025
1026 const char *message = "hello world";
1027 HcfBlob input = {
1028 .data = (uint8_t *)message,
1029 .len = 12
1030 };
1031 res = sign->update(sign, &input);
1032 ASSERT_EQ(res, HCF_SUCCESS);
1033
1034 HcfBlob out = { .data = nullptr, .len = 0 };
1035 res = sign->sign(sign, nullptr, &out);
1036 ASSERT_EQ(res, HCF_SUCCESS);
1037 ASSERT_NE(out.data, nullptr);
1038 ASSERT_NE(out.len, (const unsigned int)0);
1039
1040 HcfFree(out.data);
1041 HcfObjDestroy(sign);
1042 HcfObjDestroy(keyPair);
1043 }
1044
1045 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1001, TestSize.Level0)
1046 {
1047 HcfSignSpi *spiObj = nullptr;
1048 int32_t res = HcfSignSpiEcdsaCreate(nullptr, &spiObj);
1049
1050 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1051 ASSERT_EQ(spiObj, nullptr);
1052 }
1053
1054 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1002, TestSize.Level0)
1055 {
1056 HcfSignatureParams params = {
1057 .algo = HCF_ALG_ECC,
1058 .padding = HCF_ALG_NOPADDING,
1059 .md = HCF_OPENSSL_DIGEST_SHA256,
1060 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1061 };
1062 int32_t res = HcfSignSpiEcdsaCreate(¶ms, nullptr);
1063
1064 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1065 }
1066
1067 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1004, TestSize.Level0)
1068 {
1069 HcfSignatureParams params = {
1070 .algo = HCF_ALG_ECC,
1071 .padding = HCF_ALG_NOPADDING,
1072 .md = HCF_OPENSSL_DIGEST_SHA256,
1073 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1074 };
1075 HcfSignSpi *spiObj = nullptr;
1076 int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj);
1077
1078 ASSERT_EQ(res, HCF_SUCCESS);
1079 ASSERT_NE(spiObj, nullptr);
1080
1081 res = spiObj->engineInit((HcfSignSpi *)&obj, nullptr, ecc256KeyPair_->priKey);
1082 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1083
1084 HcfObjDestroy(spiObj);
1085 }
1086
1087 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1005, TestSize.Level0)
1088 {
1089 HcfSignatureParams params = {
1090 .algo = HCF_ALG_ECC,
1091 .padding = HCF_ALG_NOPADDING,
1092 .md = HCF_OPENSSL_DIGEST_SHA256,
1093 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1094 };
1095 HcfSignSpi *spiObj = nullptr;
1096 int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj);
1097
1098 ASSERT_EQ(res, HCF_SUCCESS);
1099 ASSERT_NE(spiObj, nullptr);
1100
1101 res = spiObj->engineInit(spiObj, nullptr, (HcfPriKey *)&obj);
1102 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1103
1104 HcfObjDestroy(spiObj);
1105 }
1106
1107 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1006, TestSize.Level0)
1108 {
1109 HcfSignatureParams params = {
1110 .algo = HCF_ALG_ECC,
1111 .padding = HCF_ALG_NOPADDING,
1112 .md = HCF_OPENSSL_DIGEST_SHA256,
1113 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1114 };
1115 HcfSignSpi *spiObj = nullptr;
1116 int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj);
1117
1118 ASSERT_EQ(res, HCF_SUCCESS);
1119 ASSERT_NE(spiObj, nullptr);
1120
1121 const char *message = "hello world";
1122 HcfBlob input = {
1123 .data = (uint8_t *)message,
1124 .len = 12
1125 };
1126 res = spiObj->engineUpdate(nullptr, &input);
1127 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1128
1129 HcfObjDestroy(spiObj);
1130 }
1131
1132 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1007, TestSize.Level0)
1133 {
1134 HcfSignatureParams params = {
1135 .algo = HCF_ALG_ECC,
1136 .padding = HCF_ALG_NOPADDING,
1137 .md = HCF_OPENSSL_DIGEST_SHA256,
1138 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1139 };
1140 HcfSignSpi *spiObj = nullptr;
1141 int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj);
1142
1143 ASSERT_EQ(res, HCF_SUCCESS);
1144 ASSERT_NE(spiObj, nullptr);
1145
1146 const char *message = "hello world";
1147 HcfBlob input = {
1148 .data = (uint8_t *)message,
1149 .len = 12
1150 };
1151 res = spiObj->engineUpdate((HcfSignSpi *)&obj, &input);
1152 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1153
1154 HcfObjDestroy(spiObj);
1155 }
1156
1157 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1008, TestSize.Level0)
1158 {
1159 HcfSignatureParams params = {
1160 .algo = HCF_ALG_ECC,
1161 .padding = HCF_ALG_NOPADDING,
1162 .md = HCF_OPENSSL_DIGEST_SHA256,
1163 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1164 };
1165 HcfSignSpi *spiObj = nullptr;
1166 int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj);
1167
1168 ASSERT_EQ(res, HCF_SUCCESS);
1169 ASSERT_NE(spiObj, nullptr);
1170
1171 res = spiObj->engineUpdate(spiObj, nullptr);
1172 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1173
1174 HcfObjDestroy(spiObj);
1175 }
1176
1177 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1009, TestSize.Level0)
1178 {
1179 HcfSignatureParams params = {
1180 .algo = HCF_ALG_ECC,
1181 .padding = HCF_ALG_NOPADDING,
1182 .md = HCF_OPENSSL_DIGEST_SHA256,
1183 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1184 };
1185 HcfSignSpi *spiObj = nullptr;
1186 int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj);
1187
1188 ASSERT_EQ(res, HCF_SUCCESS);
1189 ASSERT_NE(spiObj, nullptr);
1190
1191 const char *message = "hello world";
1192 HcfBlob input = {
1193 .data = (uint8_t *)message,
1194 .len = 12
1195 };
1196 HcfBlob out = { .data = nullptr, .len = 0 };
1197 res = spiObj->engineSign((HcfSignSpi *)&obj, &input, &out);
1198 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1199
1200 HcfObjDestroy(spiObj);
1201 }
1202
1203 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1010, TestSize.Level0)
1204 {
1205 HcfSignatureParams params = {
1206 .algo = HCF_ALG_ECC,
1207 .padding = HCF_ALG_NOPADDING,
1208 .md = HCF_OPENSSL_DIGEST_SHA256,
1209 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1210 };
1211 HcfSignSpi *spiObj = nullptr;
1212 int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj);
1213
1214 ASSERT_EQ(res, HCF_SUCCESS);
1215 ASSERT_NE(spiObj, nullptr);
1216
1217 spiObj->base.destroy(nullptr);
1218
1219 HcfObjDestroy(spiObj);
1220 }
1221
1222 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1011, TestSize.Level0)
1223 {
1224 HcfSignatureParams params = {
1225 .algo = HCF_ALG_ECC,
1226 .padding = HCF_ALG_NOPADDING,
1227 .md = HCF_OPENSSL_DIGEST_SHA256,
1228 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1229 };
1230 HcfSignSpi *spiObj = nullptr;
1231 int32_t res = HcfSignSpiEcdsaCreate(¶ms, &spiObj);
1232
1233 ASSERT_EQ(res, HCF_SUCCESS);
1234 ASSERT_NE(spiObj, nullptr);
1235
1236 spiObj->base.destroy(&obj);
1237
1238 HcfObjDestroy(spiObj);
1239 }
1240
MemoryMallocTestFunc(uint32_t mallocCount,HcfBlob * input)1241 static void MemoryMallocTestFunc(uint32_t mallocCount, HcfBlob *input)
1242 {
1243 for (uint32_t i = 0; i < mallocCount; i++) {
1244 ResetRecordMallocNum();
1245 SetMockMallocIndex(i);
1246 HcfAsyKeyGenerator *generator = nullptr;
1247 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1248 if (res != HCF_SUCCESS) {
1249 continue;
1250 }
1251 HcfKeyPair *keyPair = nullptr;
1252 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1253 HcfObjDestroy(generator);
1254 if (res != HCF_SUCCESS) {
1255 continue;
1256 }
1257 HcfSign *sign = nullptr;
1258 res = HcfSignCreate("ECC224|SHA256", &sign);
1259 if (res != HCF_SUCCESS) {
1260 HcfObjDestroy(keyPair);
1261 continue;
1262 }
1263 res = sign->init(sign, nullptr, keyPair->priKey);
1264 if (res != HCF_SUCCESS) {
1265 HcfObjDestroy(sign);
1266 HcfObjDestroy(keyPair);
1267 continue;
1268 }
1269 res = sign->update(sign, input);
1270 if (res != HCF_SUCCESS) {
1271 HcfObjDestroy(sign);
1272 HcfObjDestroy(keyPair);
1273 continue;
1274 }
1275 HcfBlob out = {
1276 .data = nullptr,
1277 .len = 0
1278 };
1279 res = sign->sign(sign, nullptr, &out);
1280 HcfObjDestroy(sign);
1281 HcfObjDestroy(keyPair);
1282 if (res == HCF_SUCCESS) {
1283 HcfFree(out.data);
1284 }
1285 }
1286 }
1287
1288 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1101, TestSize.Level0)
1289 {
1290 StartRecordMallocNum();
1291 HcfAsyKeyGenerator *generator = nullptr;
1292 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1293 ASSERT_EQ(res, HCF_SUCCESS);
1294 ASSERT_NE(generator, nullptr);
1295
1296 HcfKeyPair *keyPair = nullptr;
1297 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1298 ASSERT_EQ(res, HCF_SUCCESS);
1299 ASSERT_NE(keyPair, nullptr);
1300
1301 HcfObjDestroy(generator);
1302
1303 HcfSign *sign = nullptr;
1304 res = HcfSignCreate("ECC224|SHA256", &sign);
1305 ASSERT_EQ(res, HCF_SUCCESS);
1306 ASSERT_NE(sign, nullptr);
1307
1308 HcfParamsSpec params;
1309 res = sign->init(sign, ¶ms, keyPair->priKey);
1310 ASSERT_EQ(res, HCF_SUCCESS);
1311
1312 const char *message = "hello world";
1313 HcfBlob input = {
1314 .data = (uint8_t *)message,
1315 .len = 12
1316 };
1317 res = sign->update(sign, &input);
1318 ASSERT_EQ(res, HCF_SUCCESS);
1319
1320 HcfBlob out = { .data = nullptr, .len = 0 };
1321 res = sign->sign(sign, nullptr, &out);
1322 ASSERT_EQ(res, HCF_SUCCESS);
1323 ASSERT_NE(out.data, nullptr);
1324 ASSERT_NE(out.len, (const unsigned int)0);
1325
1326 HcfFree(out.data);
1327 HcfObjDestroy(sign);
1328 HcfObjDestroy(keyPair);
1329
1330 uint32_t mallocCount = GetMallocNum();
1331 MemoryMallocTestFunc(mallocCount, &input);
1332
1333 EndRecordMallocNum();
1334 }
1335
OpensslMockTestFunc(uint32_t mallocCount,HcfBlob * input)1336 static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *input)
1337 {
1338 for (uint32_t i = 0; i < mallocCount; i++) {
1339 ResetOpensslCallNum();
1340 SetOpensslCallMockIndex(i);
1341 HcfAsyKeyGenerator *generator = nullptr;
1342 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1343 if (res != HCF_SUCCESS) {
1344 continue;
1345 }
1346 HcfKeyPair *keyPair = nullptr;
1347 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1348 HcfObjDestroy(generator);
1349 if (res != HCF_SUCCESS) {
1350 continue;
1351 }
1352 HcfSign *sign = nullptr;
1353 res = HcfSignCreate("ECC224|SHA256", &sign);
1354 if (res != HCF_SUCCESS) {
1355 HcfObjDestroy(keyPair);
1356 continue;
1357 }
1358 res = sign->init(sign, nullptr, keyPair->priKey);
1359 if (res != HCF_SUCCESS) {
1360 HcfObjDestroy(sign);
1361 HcfObjDestroy(keyPair);
1362 continue;
1363 }
1364 res = sign->update(sign, input);
1365 if (res != HCF_SUCCESS) {
1366 HcfObjDestroy(sign);
1367 HcfObjDestroy(keyPair);
1368 continue;
1369 }
1370 HcfBlob out = {
1371 .data = nullptr,
1372 .len = 0
1373 };
1374 res = sign->sign(sign, input, &out);
1375 HcfObjDestroy(sign);
1376 HcfObjDestroy(keyPair);
1377 if (res == HCF_SUCCESS) {
1378 HcfFree(out.data);
1379 }
1380 }
1381 }
1382
1383 HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1102, TestSize.Level0)
1384 {
1385 StartRecordOpensslCallNum();
1386 HcfAsyKeyGenerator *generator = nullptr;
1387 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1388 ASSERT_EQ(res, HCF_SUCCESS);
1389 ASSERT_NE(generator, nullptr);
1390
1391 HcfKeyPair *keyPair = nullptr;
1392 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1393 ASSERT_EQ(res, HCF_SUCCESS);
1394 ASSERT_NE(keyPair, nullptr);
1395
1396 HcfObjDestroy(generator);
1397
1398 HcfSign *sign = nullptr;
1399 res = HcfSignCreate("ECC224|SHA256", &sign);
1400 ASSERT_EQ(res, HCF_SUCCESS);
1401 ASSERT_NE(sign, nullptr);
1402
1403 HcfParamsSpec params;
1404 res = sign->init(sign, ¶ms, keyPair->priKey);
1405 ASSERT_EQ(res, HCF_SUCCESS);
1406
1407 const char *message = "hello world";
1408 HcfBlob input = {
1409 .data = (uint8_t *)message,
1410 .len = 12
1411 };
1412 res = sign->update(sign, &input);
1413 ASSERT_EQ(res, HCF_SUCCESS);
1414
1415 HcfBlob out = { .data = nullptr, .len = 0 };
1416 res = sign->sign(sign, &input, &out);
1417 ASSERT_EQ(res, HCF_SUCCESS);
1418 ASSERT_NE(out.data, nullptr);
1419 ASSERT_NE(out.len, (const unsigned int)0);
1420
1421 HcfFree(out.data);
1422 HcfObjDestroy(sign);
1423 HcfObjDestroy(keyPair);
1424
1425 uint32_t mallocCount = GetOpensslCallNum();
1426 OpensslMockTestFunc(mallocCount, &input);
1427
1428 EndRecordOpensslCallNum();
1429 }
1430 }
1431