1 /*
2 * Copyright (C) 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 "sm2_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 CryptoSm2SignTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp();
37 void TearDown();
38
39 static HcfKeyPair *sm2256KeyPair_;
40 };
41
42 HcfKeyPair *CryptoSm2SignTest::sm2256KeyPair_ = nullptr;
43
44 static const char *g_mockMessage = "hello world";
45 static HcfBlob g_mockInput = {
46 .data = (uint8_t *)g_mockMessage,
47 .len = 12
48 };
49
SetUp()50 void CryptoSm2SignTest::SetUp() {}
TearDown()51 void CryptoSm2SignTest::TearDown() {}
52
SetUpTestCase()53 void CryptoSm2SignTest::SetUpTestCase()
54 {
55 HcfAsyKeyGenerator *generator = nullptr;
56 HcfResult res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
57 ASSERT_EQ(res, HCF_SUCCESS);
58 ASSERT_NE(generator, nullptr);
59
60 HcfKeyPair *keyPair = nullptr;
61 res = generator->generateKeyPair(generator, nullptr, &keyPair);
62 ASSERT_EQ(res, HCF_SUCCESS);
63 ASSERT_NE(keyPair, nullptr);
64
65 sm2256KeyPair_ = keyPair;
66
67 HcfObjDestroy(generator);
68 }
69
TearDownTestCase()70 void CryptoSm2SignTest::TearDownTestCase()
71 {
72 HcfObjDestroy(sm2256KeyPair_);
73 }
74
GetMockClass(void)75 static const char *GetMockClass(void)
76 {
77 return "HcfMock";
78 }
79
80 static HcfObjectBase obj = {
81 .getClass = GetMockClass,
82 .destroy = nullptr
83 };
84
HcfSignCreateTest(const char * algName)85 static HcfResult HcfSignCreateTest(const char *algName)
86 {
87 HcfSign *sign = nullptr;
88 HcfResult res = HcfSignCreate(algName, &sign);
89 if (res == HCF_SUCCESS) {
90 HcfObjDestroy(sign);
91 }
92 return res;
93 }
94
95 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest001, TestSize.Level0)
96 {
97 HcfResult res = HcfSignCreateTest("SM2|SM3");
98 ASSERT_EQ(res, HCF_SUCCESS);
99 }
100
101 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest002, TestSize.Level0)
102 {
103 HcfResult res = HcfSignCreateTest(nullptr);
104 ASSERT_EQ(res, HCF_INVALID_PARAMS);
105 }
106
107 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest003, TestSize.Level0)
108 {
109 HcfResult res = HcfSignCreateTest("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD"
110 "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD");
111 ASSERT_EQ(res, HCF_INVALID_PARAMS);
112 }
113
114 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest004, TestSize.Level0)
115 {
116 HcfResult res = HcfSignCreateTest("SM5|SM3");
117 ASSERT_NE(res, HCF_SUCCESS);
118 }
119
120 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest005, TestSize.Level0)
121 {
122 HcfResult res = HcfSignCreateTest("SM2|SM5");
123 ASSERT_NE(res, HCF_SUCCESS);
124 }
125
126 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest006, TestSize.Level0)
127 {
128 HcfResult res = HcfSignCreateTest("SM2|MD5");
129 ASSERT_NE(res, HCF_SUCCESS);
130 }
131
132 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest007, TestSize.Level0)
133 {
134 HcfResult res = HcfSignCreateTest("SM2SM3");
135 ASSERT_NE(res, HCF_SUCCESS);
136 }
137
138 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest008, TestSize.Level0)
139 {
140 HcfResult res = HcfSignCreate("SM2|SM3", nullptr);
141
142 ASSERT_EQ(res, HCF_INVALID_PARAMS);
143 }
144
145 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest009, TestSize.Level0)
146 {
147 HcfSign *sign = nullptr;
148 int32_t res = HcfSignCreate("SM2|SM3", &sign);
149
150 ASSERT_EQ(res, HCF_SUCCESS);
151 ASSERT_NE(sign, nullptr);
152
153 const char *className = sign->base.getClass();
154
155 ASSERT_NE(className, nullptr);
156
157 HcfObjDestroy(sign);
158 }
159
160 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest010, TestSize.Level0)
161 {
162 HcfSign *sign = nullptr;
163 int32_t res = HcfSignCreate("SM2|SM3", &sign);
164
165 ASSERT_EQ(res, HCF_SUCCESS);
166 ASSERT_NE(sign, nullptr);
167
168 sign->base.destroy((HcfObjectBase *)sign);
169 }
170
171 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest011, TestSize.Level0)
172 {
173 HcfSign *sign = nullptr;
174 int32_t res = HcfSignCreate("SM2|SM3", &sign);
175
176 ASSERT_EQ(res, HCF_SUCCESS);
177 ASSERT_NE(sign, nullptr);
178
179 sign->base.destroy(nullptr);
180
181 HcfObjDestroy(sign);
182 }
183
184 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest012, TestSize.Level0)
185 {
186 HcfSign *sign = nullptr;
187 int32_t res = HcfSignCreate("SM2|SM3", &sign);
188
189 ASSERT_EQ(res, HCF_SUCCESS);
190 ASSERT_NE(sign, nullptr);
191
192 sign->base.destroy(&obj);
193
194 HcfObjDestroy(sign);
195 }
196
197 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest013, TestSize.Level0)
198 {
199 HcfSign *sign = nullptr;
200 int32_t res = HcfSignCreate("SM2|SM3", &sign);
201
202 ASSERT_EQ(res, HCF_SUCCESS);
203 ASSERT_NE(sign, nullptr);
204
205 const char *algName = sign->getAlgoName(sign);
206
207 ASSERT_NE(algName, nullptr);
208
209 HcfObjDestroy(sign);
210 }
211
212 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest014, TestSize.Level0)
213 {
214 HcfSign *sign = nullptr;
215 int32_t res = HcfSignCreate("SM2|SM3", &sign);
216
217 ASSERT_EQ(res, HCF_SUCCESS);
218 ASSERT_NE(sign, nullptr);
219
220 const char *algName = sign->getAlgoName(nullptr);
221
222 ASSERT_EQ(algName, nullptr);
223
224 HcfObjDestroy(sign);
225 }
226
227 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest015, TestSize.Level0)
228 {
229 HcfSign *sign = nullptr;
230 int32_t res = HcfSignCreate("SM2|SM3", &sign);
231
232 ASSERT_EQ(res, HCF_SUCCESS);
233 ASSERT_NE(sign, nullptr);
234
235 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
236
237 ASSERT_EQ(res, HCF_SUCCESS);
238
239 HcfObjDestroy(sign);
240 }
241
242 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest016, TestSize.Level0)
243 {
244 HcfSign *sign = nullptr;
245 int32_t res = HcfSignCreate("SM2|SM3", &sign);
246
247 ASSERT_EQ(res, HCF_SUCCESS);
248 ASSERT_NE(sign, nullptr);
249
250 res = sign->init(nullptr, nullptr, sm2256KeyPair_->priKey);
251
252 ASSERT_EQ(res, HCF_INVALID_PARAMS);
253
254 HcfObjDestroy(sign);
255 }
256
257 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest017, TestSize.Level0)
258 {
259 HcfSign *sign = nullptr;
260 int32_t res = HcfSignCreate("SM2|SM3", &sign);
261
262 ASSERT_EQ(res, HCF_SUCCESS);
263 ASSERT_NE(sign, nullptr);
264
265 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
266
267 ASSERT_EQ(res, HCF_SUCCESS);
268
269 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
270
271 ASSERT_EQ(res, HCF_INVALID_PARAMS);
272
273 HcfObjDestroy(sign);
274 }
275
276 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest018, TestSize.Level0)
277 {
278 HcfSign *sign = nullptr;
279 int32_t res = HcfSignCreate("SM2|SM3", &sign);
280
281 ASSERT_EQ(res, HCF_SUCCESS);
282 ASSERT_NE(sign, nullptr);
283
284 res = sign->init(sign, nullptr, nullptr);
285
286 ASSERT_EQ(res, HCF_INVALID_PARAMS);
287
288 HcfObjDestroy(sign);
289 }
290
291 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest019, TestSize.Level0)
292 {
293 HcfSign *sign = nullptr;
294 int32_t res = HcfSignCreate("SM2|SM3", &sign);
295
296 ASSERT_EQ(res, HCF_SUCCESS);
297 ASSERT_NE(sign, nullptr);
298
299 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
300
301 ASSERT_EQ(res, HCF_SUCCESS);
302
303 res = sign->update(sign, &g_mockInput);
304
305 ASSERT_EQ(res, HCF_SUCCESS);
306
307 HcfObjDestroy(sign);
308 }
309
310 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest020, TestSize.Level0)
311 {
312 HcfSign *sign = nullptr;
313 int32_t res = HcfSignCreate("SM2|SM3", &sign);
314
315 ASSERT_EQ(res, HCF_SUCCESS);
316 ASSERT_NE(sign, nullptr);
317
318 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
319
320 ASSERT_EQ(res, HCF_SUCCESS);
321
322 res = sign->update(nullptr, &g_mockInput);
323
324 ASSERT_EQ(res, HCF_INVALID_PARAMS);
325
326 HcfObjDestroy(sign);
327 }
328
329 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest021, TestSize.Level0)
330 {
331 HcfSign *sign = nullptr;
332 int32_t res = HcfSignCreate("SM2|SM3", &sign);
333
334 ASSERT_EQ(res, HCF_SUCCESS);
335 ASSERT_NE(sign, nullptr);
336
337 res = sign->update(sign, &g_mockInput);
338
339 ASSERT_EQ(res, HCF_INVALID_PARAMS);
340
341 HcfObjDestroy(sign);
342 }
343
344 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest022, TestSize.Level0)
345 {
346 HcfSign *sign = nullptr;
347 int32_t res = HcfSignCreate("SM2|SM3", &sign);
348
349 ASSERT_EQ(res, HCF_SUCCESS);
350 ASSERT_NE(sign, nullptr);
351
352 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
353
354 ASSERT_EQ(res, HCF_SUCCESS);
355
356 res = sign->update(sign, nullptr);
357
358 ASSERT_EQ(res, HCF_INVALID_PARAMS);
359
360 HcfObjDestroy(sign);
361 }
362
363 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest023, TestSize.Level0)
364 {
365 HcfSign *sign = nullptr;
366 int32_t res = HcfSignCreate("SM2|SM3", &sign);
367
368 ASSERT_EQ(res, HCF_SUCCESS);
369 ASSERT_NE(sign, nullptr);
370
371 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
372
373 ASSERT_EQ(res, HCF_SUCCESS);
374
375 HcfBlob input = {
376 .data = nullptr,
377 .len = 1
378 };
379 res = sign->update(sign, &input);
380
381 ASSERT_EQ(res, HCF_INVALID_PARAMS);
382
383 HcfObjDestroy(sign);
384 }
385
386 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest024, TestSize.Level0)
387 {
388 HcfSign *sign = nullptr;
389 int32_t res = HcfSignCreate("SM2|SM3", &sign);
390
391 ASSERT_EQ(res, HCF_SUCCESS);
392 ASSERT_NE(sign, nullptr);
393
394 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
395
396 ASSERT_EQ(res, HCF_SUCCESS);
397
398 HcfBlob input = {
399 .data = (uint8_t *)g_mockMessage,
400 .len = 0
401 };
402 res = sign->update(sign, &input);
403
404 ASSERT_EQ(res, HCF_INVALID_PARAMS);
405
406 HcfObjDestroy(sign);
407 }
408
409 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest025, TestSize.Level0)
410 {
411 HcfSign *sign = nullptr;
412 int32_t res = HcfSignCreate("SM2|SM3", &sign);
413
414 ASSERT_EQ(res, HCF_SUCCESS);
415 ASSERT_NE(sign, nullptr);
416
417 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
418
419 ASSERT_EQ(res, HCF_SUCCESS);
420
421 res = sign->update(sign, &g_mockInput);
422
423 ASSERT_EQ(res, HCF_SUCCESS);
424
425 HcfBlob out = { .data = nullptr, .len = 0 };
426 res = sign->sign(sign, nullptr, &out);
427
428 ASSERT_EQ(res, HCF_SUCCESS);
429 ASSERT_NE(out.data, nullptr);
430 ASSERT_NE(out.len, (const unsigned int)0);
431
432 HcfFree(out.data);
433 HcfObjDestroy(sign);
434 }
435
436 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest026, TestSize.Level0)
437 {
438 HcfSign *sign = nullptr;
439 int32_t res = HcfSignCreate("SM2|SM3", &sign);
440
441 ASSERT_EQ(res, HCF_SUCCESS);
442 ASSERT_NE(sign, nullptr);
443
444 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
445
446 ASSERT_EQ(res, HCF_SUCCESS);
447
448 HcfBlob out = { .data = nullptr, .len = 0 };
449 res = sign->sign(sign, &g_mockInput, &out);
450
451 ASSERT_EQ(res, HCF_SUCCESS);
452 ASSERT_NE(out.data, nullptr);
453 ASSERT_NE(out.len, (const unsigned int)0);
454
455 HcfFree(out.data);
456 HcfObjDestroy(sign);
457 }
458
459 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest027, TestSize.Level0)
460 {
461 HcfSign *sign = nullptr;
462 int32_t res = HcfSignCreate("SM2|SM3", &sign);
463
464 ASSERT_EQ(res, HCF_SUCCESS);
465 ASSERT_NE(sign, nullptr);
466
467 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
468
469 ASSERT_EQ(res, HCF_SUCCESS);
470
471 res = sign->update(sign, &g_mockInput);
472
473 ASSERT_EQ(res, HCF_SUCCESS);
474
475 HcfBlob out = { .data = nullptr, .len = 0 };
476 res = sign->sign(nullptr, nullptr, &out);
477
478 ASSERT_EQ(res, HCF_INVALID_PARAMS);
479
480 HcfObjDestroy(sign);
481 }
482
483 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest028, TestSize.Level0)
484 {
485 HcfSign *sign = nullptr;
486 int32_t res = HcfSignCreate("SM2|SM3", &sign);
487
488 ASSERT_EQ(res, HCF_SUCCESS);
489 ASSERT_NE(sign, nullptr);
490
491 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
492
493 ASSERT_EQ(res, HCF_SUCCESS);
494
495 HcfBlob out = { .data = nullptr, .len = 0 };
496 res = sign->sign(sign, nullptr, &out);
497
498 ASSERT_EQ(res, HCF_INVALID_PARAMS);
499
500 HcfObjDestroy(sign);
501 }
502
503 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest029, TestSize.Level0)
504 {
505 HcfSign *sign = nullptr;
506 int32_t res = HcfSignCreate("SM2|SM3", &sign);
507
508 ASSERT_EQ(res, HCF_SUCCESS);
509 ASSERT_NE(sign, nullptr);
510
511 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
512
513 ASSERT_EQ(res, HCF_SUCCESS);
514
515 HcfBlob input = {
516 .data = nullptr,
517 .len = 1
518 };
519 HcfBlob out = { .data = nullptr, .len = 0 };
520 res = sign->sign(sign, &input, &out);
521
522 ASSERT_EQ(res, HCF_INVALID_PARAMS);
523
524 HcfObjDestroy(sign);
525 }
526
527 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest030, TestSize.Level0)
528 {
529 HcfSign *sign = nullptr;
530 int32_t res = HcfSignCreate("SM2|SM3", &sign);
531
532 ASSERT_EQ(res, HCF_SUCCESS);
533 ASSERT_NE(sign, nullptr);
534
535 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
536
537 ASSERT_EQ(res, HCF_SUCCESS);
538
539 HcfBlob input = {
540 .data = (uint8_t *)g_mockMessage,
541 .len = 0
542 };
543 HcfBlob out = { .data = nullptr, .len = 0 };
544 res = sign->sign(sign, &input, &out);
545
546 ASSERT_EQ(res, HCF_INVALID_PARAMS);
547
548 HcfObjDestroy(sign);
549 }
550
551 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest031, TestSize.Level0)
552 {
553 HcfSign *sign = nullptr;
554 int32_t res = HcfSignCreate("SM2|SM3", &sign);
555
556 ASSERT_EQ(res, HCF_SUCCESS);
557 ASSERT_NE(sign, nullptr);
558
559 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
560
561 ASSERT_EQ(res, HCF_SUCCESS);
562
563 res = sign->update(sign, &g_mockInput);
564
565 ASSERT_EQ(res, HCF_SUCCESS);
566
567 res = sign->sign(sign, nullptr, nullptr);
568
569 ASSERT_EQ(res, HCF_INVALID_PARAMS);
570
571 HcfObjDestroy(sign);
572 }
573
574 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest032, TestSize.Level0)
575 {
576 HcfSign *sign = nullptr;
577 int32_t res = HcfSignCreate("SM2|SM3", &sign);
578
579 ASSERT_EQ(res, HCF_SUCCESS);
580 ASSERT_NE(sign, nullptr);
581
582 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
583
584 ASSERT_EQ(res, HCF_SUCCESS);
585
586 const char *message = "hello world";
587 HcfBlob input = {
588 .data = (uint8_t *)message,
589 .len = 12
590 };
591 res = sign->update(sign, &input);
592
593 ASSERT_EQ(res, HCF_SUCCESS);
594
595 HcfBlob out = { .data = nullptr, .len = 0 };
596 res = sign->sign(sign, nullptr, &out);
597
598 ASSERT_EQ(res, HCF_SUCCESS);
599 ASSERT_NE(out.data, nullptr);
600 ASSERT_NE(out.len, (const unsigned int)0);
601
602 res = sign->update(sign, &input);
603
604 ASSERT_EQ(res, HCF_SUCCESS);
605
606 HcfBlob out2 = { .data = nullptr, .len = 0 };
607 res = sign->sign(sign, nullptr, &out2);
608
609 HcfVerify *verify = nullptr;
610 res = HcfVerifyCreate("SM2|SM3", &verify);
611 ASSERT_EQ(res, HCF_SUCCESS);
612 ASSERT_NE(verify, nullptr);
613
614 verify->init(verify, nullptr, sm2256KeyPair_->pubKey);
615 ASSERT_EQ(res, HCF_SUCCESS);
616
617 verify->update(verify, &input);
618 ASSERT_EQ(res, HCF_SUCCESS);
619
620 bool flag = verify->verify(verify, nullptr, &out);
621 ASSERT_EQ(flag, true);
622
623 verify->update(verify, &input);
624 ASSERT_EQ(res, HCF_SUCCESS);
625
626 flag = verify->verify(verify, nullptr, &out2);
627 ASSERT_EQ(flag, true);
628
629 HcfFree(out.data);
630 HcfFree(out2.data);
631 HcfObjDestroy(sign);
632 HcfObjDestroy(verify);
633 }
634
635 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest033, TestSize.Level0)
636 {
637 HcfSign *sign = nullptr;
638 int32_t res = HcfSignCreate("SM2|SM3", &sign);
639
640 ASSERT_EQ(res, HCF_SUCCESS);
641 ASSERT_NE(sign, nullptr);
642
643 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
644
645 ASSERT_EQ(res, HCF_SUCCESS);
646
647 const char *message = "hello world";
648 HcfBlob input = {
649 .data = (uint8_t *)message,
650 .len = 12
651 };
652 res = sign->update(sign, &input);
653
654 ASSERT_EQ(res, HCF_SUCCESS);
655
656 res = sign->update(sign, &input);
657
658 ASSERT_EQ(res, HCF_SUCCESS);
659
660 HcfBlob out2 = { .data = nullptr, .len = 0 };
661 res = sign->sign(sign, nullptr, &out2);
662
663 HcfFree(out2.data);
664 HcfObjDestroy(sign);
665 }
666
667 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest034, TestSize.Level0)
668 {
669 HcfSign *sign = nullptr;
670 HcfResult res = HcfSignCreate("SM2|SM3", &sign);
671 ASSERT_EQ(res, HCF_SUCCESS);
672 ASSERT_NE(sign, nullptr);
673
674 HcfParamsSpec params;
675 res = sign->init(sign, ¶ms, sm2256KeyPair_->priKey);
676 ASSERT_EQ(res, HCF_SUCCESS);
677
678 const char *message = "hello world";
679 HcfBlob input = {
680 .data = (uint8_t *)message,
681 .len = 12
682 };
683
684 HcfBlob out = { .data = nullptr, .len = 0 };
685 res = sign->sign(sign, &input, &out);
686 ASSERT_EQ(res, HCF_SUCCESS);
687 ASSERT_NE(out.data, nullptr);
688 ASSERT_NE(out.len, (const unsigned int)0);
689
690 HcfFree(out.data);
691 HcfObjDestroy(sign);
692 }
693
694 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest035, TestSize.Level0)
695 {
696 HcfSign *sign = nullptr;
697 HcfResult res = HcfSignCreate("SM2|SM3", &sign);
698 ASSERT_EQ(res, HCF_SUCCESS);
699 ASSERT_NE(sign, nullptr);
700
701 HcfParamsSpec params;
702 res = sign->init(sign, ¶ms, sm2256KeyPair_->priKey);
703 ASSERT_EQ(res, HCF_SUCCESS);
704
705 const char *message = "hello world";
706 HcfBlob input = {
707 .data = (uint8_t *)message,
708 .len = 12
709 };
710 res = sign->update(sign, &input);
711 ASSERT_EQ(res, HCF_SUCCESS);
712
713 HcfBlob out = { .data = nullptr, .len = 0 };
714 res = sign->sign(sign, nullptr, &out);
715 ASSERT_EQ(res, HCF_SUCCESS);
716 ASSERT_NE(out.data, nullptr);
717 ASSERT_NE(out.len, (const unsigned int)0);
718
719 HcfFree(out.data);
720 HcfObjDestroy(sign);
721 }
722
723 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest036, TestSize.Level0)
724 {
725 HcfSignSpi *spiObj = nullptr;
726 HcfResult res = HcfSignSpiSm2Create(nullptr, &spiObj);
727
728 ASSERT_EQ(res, HCF_INVALID_PARAMS);
729 ASSERT_EQ(spiObj, nullptr);
730 }
731
732 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest037, TestSize.Level0)
733 {
734 HcfSignatureParams params = {
735 .algo = HCF_ALG_SM2,
736 .md = HCF_OPENSSL_DIGEST_SM3,
737 };
738 HcfResult res = HcfSignSpiSm2Create(¶ms, nullptr);
739 ASSERT_EQ(res, HCF_INVALID_PARAMS);
740 }
741
742 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest038, TestSize.Level0)
743 {
744 HcfSignatureParams params = {
745 .algo = HCF_ALG_SM2,
746 .md = HCF_OPENSSL_DIGEST_SM3,
747 };
748 HcfSignSpi *spiObj = nullptr;
749 HcfResult res = HcfSignSpiSm2Create(¶ms, &spiObj);
750
751 ASSERT_EQ(res, HCF_SUCCESS);
752 ASSERT_NE(spiObj, nullptr);
753
754 res = spiObj->engineInit((HcfSignSpi *)&obj, nullptr, sm2256KeyPair_->priKey);
755 ASSERT_EQ(res, HCF_INVALID_PARAMS);
756
757 HcfObjDestroy(spiObj);
758 }
759
760 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest039, TestSize.Level0)
761 {
762 HcfSignatureParams params = {
763 .algo = HCF_ALG_SM2,
764 .md = HCF_OPENSSL_DIGEST_SM3,
765 };
766 HcfSignSpi *spiObj = nullptr;
767 HcfResult res = HcfSignSpiSm2Create(¶ms, &spiObj);
768
769 ASSERT_EQ(res, HCF_SUCCESS);
770 ASSERT_NE(spiObj, nullptr);
771
772 const char *message = "hello world";
773 HcfBlob input = {
774 .data = (uint8_t *)message,
775 .len = 12
776 };
777 res = spiObj->engineUpdate(nullptr, &input);
778 ASSERT_EQ(res, HCF_INVALID_PARAMS);
779
780 HcfObjDestroy(spiObj);
781 }
782
783 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest040, TestSize.Level0)
784 {
785 HcfSignatureParams params = {
786 .algo = HCF_ALG_SM2,
787 .md = HCF_OPENSSL_DIGEST_SM3,
788 };
789 HcfSignSpi *spiObj = nullptr;
790 int32_t res = HcfSignSpiSm2Create(¶ms, &spiObj);
791
792 ASSERT_EQ(res, HCF_SUCCESS);
793 ASSERT_NE(spiObj, nullptr);
794
795 res = spiObj->engineUpdate(spiObj, nullptr);
796 ASSERT_EQ(res, HCF_INVALID_PARAMS);
797
798 HcfObjDestroy(spiObj);
799 }
800
801 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest041, TestSize.Level0)
802 {
803 HcfSignatureParams params = {
804 .algo = HCF_ALG_SM2,
805 .md = HCF_OPENSSL_DIGEST_SM3,
806 };
807 HcfSignSpi *spiObj = nullptr;
808 int32_t res = HcfSignSpiSm2Create(¶ms, &spiObj);
809
810 ASSERT_EQ(res, HCF_SUCCESS);
811 ASSERT_NE(spiObj, nullptr);
812
813 spiObj->base.destroy(nullptr);
814
815 HcfObjDestroy(spiObj);
816 }
817
MemoryMallocTestFunc(uint32_t mallocCount,HcfBlob * input)818 static void MemoryMallocTestFunc(uint32_t mallocCount, HcfBlob *input)
819 {
820 for (uint32_t i = 0; i < mallocCount; i++) {
821 ResetRecordMallocNum();
822 SetMockMallocIndex(i);
823 HcfAsyKeyGenerator *generator = nullptr;
824 int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
825 if (res != HCF_SUCCESS) {
826 continue;
827 }
828 HcfKeyPair *keyPair = nullptr;
829 res = generator->generateKeyPair(generator, nullptr, &keyPair);
830 HcfObjDestroy(generator);
831 if (res != HCF_SUCCESS) {
832 continue;
833 }
834 HcfSign *sign = nullptr;
835 res = HcfSignCreate("SM2|SM3", &sign);
836 if (res != HCF_SUCCESS) {
837 HcfObjDestroy(keyPair);
838 continue;
839 }
840 res = sign->init(sign, nullptr, keyPair->priKey);
841 if (res != HCF_SUCCESS) {
842 HcfObjDestroy(sign);
843 HcfObjDestroy(keyPair);
844 continue;
845 }
846 res = sign->update(sign, input);
847 if (res != HCF_SUCCESS) {
848 HcfObjDestroy(sign);
849 HcfObjDestroy(keyPair);
850 continue;
851 }
852 HcfBlob out = {
853 .data = nullptr,
854 .len = 0
855 };
856 res = sign->sign(sign, nullptr, &out);
857 HcfObjDestroy(sign);
858 HcfObjDestroy(keyPair);
859 if (res == HCF_SUCCESS) {
860 HcfFree(out.data);
861 }
862 }
863 }
864
865 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest042, TestSize.Level0)
866 {
867 StartRecordMallocNum();
868 HcfAsyKeyGenerator *generator = nullptr;
869 int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
870 ASSERT_EQ(res, HCF_SUCCESS);
871 ASSERT_NE(generator, nullptr);
872
873 HcfKeyPair *keyPair = nullptr;
874 res = generator->generateKeyPair(generator, nullptr, &keyPair);
875 ASSERT_EQ(res, HCF_SUCCESS);
876 ASSERT_NE(keyPair, nullptr);
877
878 HcfObjDestroy(generator);
879
880 HcfSign *sign = nullptr;
881 res = HcfSignCreate("SM2|SM3", &sign);
882 ASSERT_EQ(res, HCF_SUCCESS);
883 ASSERT_NE(sign, nullptr);
884
885 HcfParamsSpec params;
886 res = sign->init(sign, ¶ms, keyPair->priKey);
887 ASSERT_EQ(res, HCF_SUCCESS);
888
889 const char *message = "hello world";
890 HcfBlob input = {
891 .data = (uint8_t *)message,
892 .len = 12
893 };
894 res = sign->update(sign, &input);
895 ASSERT_EQ(res, HCF_SUCCESS);
896
897 HcfBlob out = { .data = nullptr, .len = 0 };
898 res = sign->sign(sign, nullptr, &out);
899 ASSERT_EQ(res, HCF_SUCCESS);
900 ASSERT_NE(out.data, nullptr);
901 ASSERT_NE(out.len, (const unsigned int)0);
902
903 HcfFree(out.data);
904 HcfObjDestroy(keyPair);
905 HcfObjDestroy(sign);
906
907 uint32_t mallocCount = GetMallocNum();
908 MemoryMallocTestFunc(mallocCount, &input);
909
910 EndRecordMallocNum();
911 }
912
OpensslMockTestFunc(uint32_t mallocCount,HcfBlob * input)913 static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *input)
914 {
915 for (uint32_t i = 0; i < mallocCount; i++) {
916 ResetOpensslCallNum();
917 SetOpensslCallMockIndex(i);
918 HcfAsyKeyGenerator *generator = nullptr;
919 int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
920 if (res != HCF_SUCCESS) {
921 continue;
922 }
923 HcfKeyPair *keyPair = nullptr;
924 res = generator->generateKeyPair(generator, nullptr, &keyPair);
925 HcfObjDestroy(generator);
926 if (res != HCF_SUCCESS) {
927 continue;
928 }
929 HcfSign *sign = nullptr;
930 res = HcfSignCreate("SM2|SM3", &sign);
931 if (res != HCF_SUCCESS) {
932 HcfObjDestroy(keyPair);
933 continue;
934 }
935 res = sign->init(sign, nullptr, keyPair->priKey);
936 if (res != HCF_SUCCESS) {
937 HcfObjDestroy(sign);
938 HcfObjDestroy(keyPair);
939 continue;
940 }
941 uint8_t pSourceData[] = "1234567812345678\0";
942 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
943 res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource);
944 if (res != HCF_SUCCESS) {
945 HcfObjDestroy(sign);
946 continue;
947 }
948 res = sign->update(sign, input);
949 if (res != HCF_SUCCESS) {
950 HcfObjDestroy(sign);
951 HcfObjDestroy(keyPair);
952 continue;
953 }
954 HcfBlob out = {
955 .data = nullptr,
956 .len = 0
957 };
958 res = sign->sign(sign, input, &out);
959 HcfObjDestroy(sign);
960 HcfObjDestroy(keyPair);
961 if (res == HCF_SUCCESS) {
962 HcfFree(out.data);
963 }
964 }
965 }
966
967 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest043, TestSize.Level0)
968 {
969 StartRecordOpensslCallNum();
970 HcfAsyKeyGenerator *generator = nullptr;
971 int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
972 ASSERT_EQ(res, HCF_SUCCESS);
973 ASSERT_NE(generator, nullptr);
974
975 HcfKeyPair *keyPair = nullptr;
976 res = generator->generateKeyPair(generator, nullptr, &keyPair);
977 ASSERT_EQ(res, HCF_SUCCESS);
978 ASSERT_NE(keyPair, nullptr);
979
980 HcfObjDestroy(generator);
981
982 HcfSign *sign = nullptr;
983 res = HcfSignCreate("SM2|SM3", &sign);
984 ASSERT_EQ(res, HCF_SUCCESS);
985 ASSERT_NE(sign, nullptr);
986
987 HcfParamsSpec params;
988 res = sign->init(sign, ¶ms, keyPair->priKey);
989 ASSERT_EQ(res, HCF_SUCCESS);
990
991 uint8_t pSourceData[] = "1234567812345678\0";
992 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
993 res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource);
994 ASSERT_EQ(res, HCF_SUCCESS);
995 const char *message = "hello world";
996 HcfBlob input = {
997 .data = (uint8_t *)message,
998 .len = 12
999 };
1000 res = sign->update(sign, &input);
1001 ASSERT_EQ(res, HCF_SUCCESS);
1002
1003 HcfBlob out = { .data = nullptr, .len = 0 };
1004 res = sign->sign(sign, &input, &out);
1005 ASSERT_EQ(res, HCF_SUCCESS);
1006 ASSERT_NE(out.data, nullptr);
1007 ASSERT_NE(out.len, (const unsigned int)0);
1008
1009 HcfFree(out.data);
1010 HcfObjDestroy(sign);
1011 HcfObjDestroy(keyPair);
1012
1013 uint32_t mallocCount = GetOpensslCallNum();
1014 OpensslMockTestFunc(mallocCount, &input);
1015
1016 EndRecordOpensslCallNum();
1017 }
1018
1019 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest044, TestSize.Level0)
1020 {
1021 HcfSign *sign = nullptr;
1022 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1023
1024 ASSERT_EQ(res, HCF_SUCCESS);
1025 ASSERT_NE(sign, nullptr);
1026
1027 uint8_t pSourceData[] = "1234567812345678\0";
1028 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1029 res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource);
1030
1031 ASSERT_EQ(res, HCF_SUCCESS);
1032
1033 HcfObjDestroy(sign);
1034 }
1035
1036 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest045, TestSize.Level0)
1037 {
1038 HcfSign *sign = nullptr;
1039 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1040
1041 ASSERT_EQ(res, HCF_SUCCESS);
1042 ASSERT_NE(sign, nullptr);
1043
1044 HcfBlob pSource = {.data = nullptr, .len = 0};
1045 res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource);
1046
1047 ASSERT_EQ(res, HCF_SUCCESS);
1048
1049 HcfObjDestroy(sign);
1050 }
1051
1052 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest046, TestSize.Level0)
1053 {
1054 HcfSign *sign = nullptr;
1055 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1056
1057 ASSERT_EQ(res, HCF_SUCCESS);
1058 ASSERT_NE(sign, nullptr);
1059
1060 uint8_t pSourceData[] = "1234567812345678\0";
1061 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1062 res = sign->setSignSpecUint8Array(nullptr, SM2_USER_ID_UINT8ARR, pSource);
1063
1064 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1065
1066 HcfObjDestroy(sign);
1067 }
1068
1069 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest047, TestSize.Level0)
1070 {
1071 HcfSign *sign = nullptr;
1072 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1073
1074 ASSERT_EQ(res, HCF_SUCCESS);
1075 ASSERT_NE(sign, nullptr);
1076
1077 uint8_t pSourceData[] = "1234567812345678\0";
1078 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1079 res = sign->setSignSpecUint8Array(sign, PSS_SALT_LEN_INT, pSource);
1080
1081 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1082
1083 HcfObjDestroy(sign);
1084 }
1085
1086 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest048, TestSize.Level0)
1087 {
1088 HcfSign *sign = nullptr;
1089 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1090
1091 ASSERT_EQ(res, HCF_SUCCESS);
1092 ASSERT_NE(sign, nullptr);
1093
1094 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1095 ASSERT_EQ(res, HCF_SUCCESS);
1096
1097 uint8_t pSourceData[] = "1234567812345678\0";
1098 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1099 res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource);
1100
1101 ASSERT_EQ(res, HCF_SUCCESS);
1102
1103 HcfObjDestroy(sign);
1104 }
1105
1106 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest049, TestSize.Level0)
1107 {
1108 HcfSign *sign = nullptr;
1109 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1110
1111 ASSERT_EQ(res, HCF_SUCCESS);
1112 ASSERT_NE(sign, nullptr);
1113
1114 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1115 ASSERT_EQ(res, HCF_SUCCESS);
1116
1117 HcfBlob pSource = {.data = nullptr, .len = 0};
1118 res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource);
1119
1120 ASSERT_EQ(res, HCF_SUCCESS);
1121
1122 HcfObjDestroy(sign);
1123 }
1124
1125 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest050, TestSize.Level0)
1126 {
1127 HcfSign *sign = nullptr;
1128 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1129
1130 ASSERT_EQ(res, HCF_SUCCESS);
1131 ASSERT_NE(sign, nullptr);
1132
1133 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1134 ASSERT_EQ(res, HCF_SUCCESS);
1135
1136 uint8_t pSourceData[] = "1234567812345678\0";
1137 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1138 res = sign->setSignSpecUint8Array(nullptr, SM2_USER_ID_UINT8ARR, pSource);
1139
1140 ASSERT_NE(res, HCF_SUCCESS);
1141
1142 HcfObjDestroy(sign);
1143 }
1144
1145 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest051, TestSize.Level0)
1146 {
1147 HcfSign *sign = nullptr;
1148 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1149
1150 ASSERT_EQ(res, HCF_SUCCESS);
1151 ASSERT_NE(sign, nullptr);
1152
1153 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1154 ASSERT_EQ(res, HCF_SUCCESS);
1155
1156 uint8_t pSourceData[] = "1234567812345678\0";
1157 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1158 res = sign->setSignSpecUint8Array(sign, PSS_SALT_LEN_INT, pSource);
1159
1160 ASSERT_NE(res, HCF_SUCCESS);
1161
1162 HcfObjDestroy(sign);
1163 }
1164
1165 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest052, TestSize.Level0)
1166 {
1167 HcfSign *sign = nullptr;
1168 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1169
1170 ASSERT_EQ(res, HCF_SUCCESS);
1171 ASSERT_NE(sign, nullptr);
1172
1173 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1174 ASSERT_EQ(res, HCF_SUCCESS);
1175
1176 int32_t saltlen = 0;
1177 res = sign->setSignSpecInt(sign, PSS_SALT_LEN_INT, saltlen);
1178
1179 ASSERT_EQ(res, HCF_NOT_SUPPORT);
1180
1181 HcfObjDestroy(sign);
1182 }
1183
1184 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest053, TestSize.Level0)
1185 {
1186 HcfSign *sign = nullptr;
1187 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1188
1189 ASSERT_EQ(res, HCF_SUCCESS);
1190 ASSERT_NE(sign, nullptr);
1191
1192 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1193 ASSERT_EQ(res, HCF_SUCCESS);
1194
1195 int32_t returnInt = 0;
1196 res = sign->getSignSpecInt(sign, PSS_SALT_LEN_INT, &returnInt);
1197
1198 ASSERT_EQ(res, HCF_NOT_SUPPORT);
1199
1200 HcfObjDestroy(sign);
1201 }
1202
1203 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest054, TestSize.Level0)
1204 {
1205 HcfSign *sign = nullptr;
1206 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1207
1208 ASSERT_EQ(res, HCF_SUCCESS);
1209 ASSERT_NE(sign, nullptr);
1210
1211 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1212 ASSERT_EQ(res, HCF_SUCCESS);
1213
1214 res = sign->getSignSpecInt(sign, PSS_SALT_LEN_INT, nullptr);
1215
1216 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1217
1218 HcfObjDestroy(sign);
1219 }
1220
1221 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest055, TestSize.Level0)
1222 {
1223 HcfSign *sign = nullptr;
1224 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1225
1226 ASSERT_EQ(res, HCF_SUCCESS);
1227 ASSERT_NE(sign, nullptr);
1228
1229 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1230 ASSERT_EQ(res, HCF_SUCCESS);
1231
1232 char *returnStr = nullptr;
1233 res = sign->getSignSpecString(sign, SM2_USER_ID_UINT8ARR, &returnStr);
1234
1235 ASSERT_EQ(res, HCF_NOT_SUPPORT);
1236
1237 HcfObjDestroy(sign);
1238 }
1239
1240 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest056, TestSize.Level0)
1241 {
1242 HcfSign *sign = nullptr;
1243 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1244
1245 ASSERT_EQ(res, HCF_SUCCESS);
1246 ASSERT_NE(sign, nullptr);
1247
1248 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1249 ASSERT_EQ(res, HCF_SUCCESS);
1250
1251 res = sign->getSignSpecString(sign, SM2_USER_ID_UINT8ARR, nullptr);
1252
1253 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1254
1255 HcfObjDestroy(sign);
1256 }
1257
1258 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest057, TestSize.Level0)
1259 {
1260 HcfSign *sign = nullptr;
1261 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1262
1263 ASSERT_EQ(res, HCF_SUCCESS);
1264 ASSERT_NE(sign, nullptr);
1265
1266 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1267 ASSERT_EQ(res, HCF_SUCCESS);
1268
1269 char *returnStr = nullptr;
1270 res = sign->getSignSpecString(nullptr, SM2_USER_ID_UINT8ARR, &returnStr);
1271
1272 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1273
1274 HcfObjDestroy(sign);
1275 }
1276
1277 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest058, TestSize.Level0)
1278 {
1279 HcfSign *sign = nullptr;
1280 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1281
1282 ASSERT_EQ(res, HCF_SUCCESS);
1283 ASSERT_NE(sign, nullptr);
1284
1285 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1286 ASSERT_EQ(res, HCF_SUCCESS);
1287
1288 char *returnStr = nullptr;
1289 res = sign->getSignSpecString(sign, PSS_MD_NAME_STR, &returnStr);
1290 ASSERT_EQ(res, HCF_NOT_SUPPORT);
1291 HcfObjDestroy(sign);
1292 }
1293
1294 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest059, TestSize.Level0)
1295 {
1296 HcfSignatureParams params = {
1297 .algo = HCF_ALG_SM2,
1298 .md = HCF_OPENSSL_DIGEST_SM3,
1299 };
1300 HcfSignSpi *spiObj = nullptr;
1301 int32_t res = HcfSignSpiSm2Create(¶ms, &spiObj);
1302
1303 ASSERT_EQ(res, HCF_SUCCESS);
1304 ASSERT_NE(spiObj, nullptr);
1305
1306 uint8_t pSourceData[] = "1234567812345678\0";
1307 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1308 res = spiObj->engineSetSignSpecUint8Array(nullptr, SM2_USER_ID_UINT8ARR, pSource);
1309 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1310
1311 HcfObjDestroy(spiObj);
1312 }
1313
1314 // sign设置userid参数，进行签名，verify不设置参数进行验签
1315 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest060, TestSize.Level0)
1316 {
1317 HcfSign *sign = nullptr;
1318 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1319
1320 ASSERT_EQ(res, HCF_SUCCESS);
1321 ASSERT_NE(sign, nullptr);
1322
1323 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1324 ASSERT_EQ(res, HCF_SUCCESS);
1325
1326 uint8_t pSourceData[] = "1234567812345678\0";
1327 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1328 res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource);
1329 ASSERT_EQ(res, HCF_SUCCESS);
1330
1331 HcfBlob out = { .data = nullptr, .len = 0 };
1332 res = sign->sign(sign, &g_mockInput, &out);
1333
1334 ASSERT_EQ(res, HCF_SUCCESS);
1335 ASSERT_NE(out.data, nullptr);
1336 ASSERT_NE(out.len, (const unsigned int)0);
1337
1338 HcfVerify *verify = nullptr;
1339 res = HcfVerifyCreate("SM2|SM3", &verify);
1340
1341 ASSERT_EQ(res, HCF_SUCCESS);
1342 ASSERT_NE(verify, nullptr);
1343
1344 res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey);
1345
1346 ASSERT_EQ(res, HCF_SUCCESS);
1347
1348 bool flag = verify->verify(verify, &g_mockInput, &out);
1349
1350 ASSERT_EQ(flag, true);
1351
1352 HcfFree(out.data);
1353 HcfObjDestroy(sign);
1354 HcfObjDestroy(verify);
1355 }
1356 }
1357