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, CryptoSm2SignTest039, 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 const char *message = "hello world";
755 HcfBlob input = {
756 .data = (uint8_t *)message,
757 .len = 12
758 };
759 res = spiObj->engineUpdate(nullptr, &input);
760 ASSERT_EQ(res, HCF_INVALID_PARAMS);
761
762 HcfObjDestroy(spiObj);
763 }
764
765 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest040, TestSize.Level0)
766 {
767 HcfSignatureParams params = {
768 .algo = HCF_ALG_SM2,
769 .md = HCF_OPENSSL_DIGEST_SM3,
770 };
771 HcfSignSpi *spiObj = nullptr;
772 int32_t res = HcfSignSpiSm2Create(¶ms, &spiObj);
773
774 ASSERT_EQ(res, HCF_SUCCESS);
775 ASSERT_NE(spiObj, nullptr);
776
777 res = spiObj->engineUpdate(spiObj, nullptr);
778 ASSERT_EQ(res, HCF_INVALID_PARAMS);
779
780 HcfObjDestroy(spiObj);
781 }
782
783 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest041, 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 spiObj->base.destroy(nullptr);
796
797 HcfObjDestroy(spiObj);
798 }
799
MemoryMallocTestFunc(uint32_t mallocCount,HcfBlob * input)800 static void MemoryMallocTestFunc(uint32_t mallocCount, HcfBlob *input)
801 {
802 for (uint32_t i = 0; i < mallocCount; i++) {
803 ResetRecordMallocNum();
804 SetMockMallocIndex(i);
805 HcfAsyKeyGenerator *generator = nullptr;
806 int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
807 if (res != HCF_SUCCESS) {
808 continue;
809 }
810 HcfKeyPair *keyPair = nullptr;
811 res = generator->generateKeyPair(generator, nullptr, &keyPair);
812 HcfObjDestroy(generator);
813 if (res != HCF_SUCCESS) {
814 continue;
815 }
816 HcfSign *sign = nullptr;
817 res = HcfSignCreate("SM2|SM3", &sign);
818 if (res != HCF_SUCCESS) {
819 HcfObjDestroy(keyPair);
820 continue;
821 }
822 res = sign->init(sign, nullptr, keyPair->priKey);
823 if (res != HCF_SUCCESS) {
824 HcfObjDestroy(sign);
825 HcfObjDestroy(keyPair);
826 continue;
827 }
828 res = sign->update(sign, input);
829 if (res != HCF_SUCCESS) {
830 HcfObjDestroy(sign);
831 HcfObjDestroy(keyPair);
832 continue;
833 }
834 HcfBlob out = {
835 .data = nullptr,
836 .len = 0
837 };
838 res = sign->sign(sign, nullptr, &out);
839 HcfObjDestroy(sign);
840 HcfObjDestroy(keyPair);
841 if (res == HCF_SUCCESS) {
842 HcfFree(out.data);
843 }
844 }
845 }
846
847 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest042, TestSize.Level0)
848 {
849 StartRecordMallocNum();
850 HcfAsyKeyGenerator *generator = nullptr;
851 int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
852 ASSERT_EQ(res, HCF_SUCCESS);
853 ASSERT_NE(generator, nullptr);
854
855 HcfKeyPair *keyPair = nullptr;
856 res = generator->generateKeyPair(generator, nullptr, &keyPair);
857 ASSERT_EQ(res, HCF_SUCCESS);
858 ASSERT_NE(keyPair, nullptr);
859
860 HcfObjDestroy(generator);
861
862 HcfSign *sign = nullptr;
863 res = HcfSignCreate("SM2|SM3", &sign);
864 ASSERT_EQ(res, HCF_SUCCESS);
865 ASSERT_NE(sign, nullptr);
866
867 HcfParamsSpec params;
868 res = sign->init(sign, ¶ms, keyPair->priKey);
869 ASSERT_EQ(res, HCF_SUCCESS);
870
871 const char *message = "hello world";
872 HcfBlob input = {
873 .data = (uint8_t *)message,
874 .len = 12
875 };
876 res = sign->update(sign, &input);
877 ASSERT_EQ(res, HCF_SUCCESS);
878
879 HcfBlob out = { .data = nullptr, .len = 0 };
880 res = sign->sign(sign, nullptr, &out);
881 ASSERT_EQ(res, HCF_SUCCESS);
882 ASSERT_NE(out.data, nullptr);
883 ASSERT_NE(out.len, (const unsigned int)0);
884
885 HcfFree(out.data);
886 HcfObjDestroy(keyPair);
887 HcfObjDestroy(sign);
888
889 uint32_t mallocCount = GetMallocNum();
890 MemoryMallocTestFunc(mallocCount, &input);
891
892 EndRecordMallocNum();
893 }
894
OpensslMockTestFunc(uint32_t mallocCount,HcfBlob * input)895 static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *input)
896 {
897 for (uint32_t i = 0; i < mallocCount; i++) {
898 ResetOpensslCallNum();
899 SetOpensslCallMockIndex(i);
900 HcfAsyKeyGenerator *generator = nullptr;
901 int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
902 if (res != HCF_SUCCESS) {
903 continue;
904 }
905 HcfKeyPair *keyPair = nullptr;
906 res = generator->generateKeyPair(generator, nullptr, &keyPair);
907 HcfObjDestroy(generator);
908 if (res != HCF_SUCCESS) {
909 continue;
910 }
911 HcfSign *sign = nullptr;
912 res = HcfSignCreate("SM2|SM3", &sign);
913 if (res != HCF_SUCCESS) {
914 HcfObjDestroy(keyPair);
915 continue;
916 }
917 res = sign->init(sign, nullptr, keyPair->priKey);
918 if (res != HCF_SUCCESS) {
919 HcfObjDestroy(sign);
920 HcfObjDestroy(keyPair);
921 continue;
922 }
923 uint8_t pSourceData[] = "1234567812345678\0";
924 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
925 res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource);
926 if (res != HCF_SUCCESS) {
927 HcfObjDestroy(sign);
928 HcfObjDestroy(keyPair);
929 continue;
930 }
931 res = sign->update(sign, input);
932 if (res != HCF_SUCCESS) {
933 HcfObjDestroy(sign);
934 HcfObjDestroy(keyPair);
935 continue;
936 }
937 HcfBlob out = { .data = nullptr, .len = 0 };
938 res = sign->sign(sign, input, &out);
939 HcfObjDestroy(sign);
940 HcfObjDestroy(keyPair);
941 HcfFree(out.data);
942 }
943 }
944
945 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest043, TestSize.Level0)
946 {
947 StartRecordOpensslCallNum();
948 HcfAsyKeyGenerator *generator = nullptr;
949 int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
950 ASSERT_EQ(res, HCF_SUCCESS);
951 ASSERT_NE(generator, nullptr);
952
953 HcfKeyPair *keyPair = nullptr;
954 res = generator->generateKeyPair(generator, nullptr, &keyPair);
955 ASSERT_EQ(res, HCF_SUCCESS);
956 ASSERT_NE(keyPair, nullptr);
957
958 HcfObjDestroy(generator);
959
960 HcfSign *sign = nullptr;
961 res = HcfSignCreate("SM2|SM3", &sign);
962 ASSERT_EQ(res, HCF_SUCCESS);
963 ASSERT_NE(sign, nullptr);
964
965 HcfParamsSpec params;
966 res = sign->init(sign, ¶ms, keyPair->priKey);
967 ASSERT_EQ(res, HCF_SUCCESS);
968
969 uint8_t pSourceData[] = "1234567812345678\0";
970 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
971 res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource);
972 ASSERT_EQ(res, HCF_SUCCESS);
973 const char *message = "hello world";
974 HcfBlob input = {
975 .data = (uint8_t *)message,
976 .len = 12
977 };
978 res = sign->update(sign, &input);
979 ASSERT_EQ(res, HCF_SUCCESS);
980
981 HcfBlob out = { .data = nullptr, .len = 0 };
982 res = sign->sign(sign, &input, &out);
983 ASSERT_EQ(res, HCF_SUCCESS);
984 ASSERT_NE(out.data, nullptr);
985 ASSERT_NE(out.len, (const unsigned int)0);
986
987 HcfFree(out.data);
988 HcfObjDestroy(sign);
989 HcfObjDestroy(keyPair);
990
991 uint32_t mallocCount = GetOpensslCallNum();
992 OpensslMockTestFunc(mallocCount, &input);
993
994 EndRecordOpensslCallNum();
995 }
996
997 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest044, TestSize.Level0)
998 {
999 HcfSign *sign = nullptr;
1000 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1001
1002 ASSERT_EQ(res, HCF_SUCCESS);
1003 ASSERT_NE(sign, nullptr);
1004
1005 uint8_t pSourceData[] = "1234567812345678\0";
1006 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1007 res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource);
1008
1009 ASSERT_EQ(res, HCF_SUCCESS);
1010
1011 HcfObjDestroy(sign);
1012 }
1013
1014 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest045, TestSize.Level0)
1015 {
1016 HcfSign *sign = nullptr;
1017 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1018
1019 ASSERT_EQ(res, HCF_SUCCESS);
1020 ASSERT_NE(sign, nullptr);
1021
1022 HcfBlob pSource = {.data = nullptr, .len = 0};
1023 res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource);
1024
1025 ASSERT_EQ(res, HCF_SUCCESS);
1026
1027 HcfObjDestroy(sign);
1028 }
1029
1030 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest046, TestSize.Level0)
1031 {
1032 HcfSign *sign = nullptr;
1033 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1034
1035 ASSERT_EQ(res, HCF_SUCCESS);
1036 ASSERT_NE(sign, nullptr);
1037
1038 uint8_t pSourceData[] = "1234567812345678\0";
1039 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1040 res = sign->setSignSpecUint8Array(nullptr, SM2_USER_ID_UINT8ARR, pSource);
1041
1042 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1043
1044 HcfObjDestroy(sign);
1045 }
1046
1047 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest047, TestSize.Level0)
1048 {
1049 HcfSign *sign = nullptr;
1050 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1051
1052 ASSERT_EQ(res, HCF_SUCCESS);
1053 ASSERT_NE(sign, nullptr);
1054
1055 uint8_t pSourceData[] = "1234567812345678\0";
1056 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1057 res = sign->setSignSpecUint8Array(sign, PSS_SALT_LEN_INT, pSource);
1058
1059 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1060
1061 HcfObjDestroy(sign);
1062 }
1063
1064 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest048, TestSize.Level0)
1065 {
1066 HcfSign *sign = nullptr;
1067 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1068
1069 ASSERT_EQ(res, HCF_SUCCESS);
1070 ASSERT_NE(sign, nullptr);
1071
1072 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1073 ASSERT_EQ(res, HCF_SUCCESS);
1074
1075 uint8_t pSourceData[] = "1234567812345678\0";
1076 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1077 res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource);
1078
1079 ASSERT_EQ(res, HCF_SUCCESS);
1080
1081 HcfObjDestroy(sign);
1082 }
1083
1084 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest049, TestSize.Level0)
1085 {
1086 HcfSign *sign = nullptr;
1087 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1088
1089 ASSERT_EQ(res, HCF_SUCCESS);
1090 ASSERT_NE(sign, nullptr);
1091
1092 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1093 ASSERT_EQ(res, HCF_SUCCESS);
1094
1095 HcfBlob pSource = {.data = nullptr, .len = 0};
1096 res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource);
1097
1098 ASSERT_EQ(res, HCF_SUCCESS);
1099
1100 HcfObjDestroy(sign);
1101 }
1102
1103 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest050, TestSize.Level0)
1104 {
1105 HcfSign *sign = nullptr;
1106 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1107
1108 ASSERT_EQ(res, HCF_SUCCESS);
1109 ASSERT_NE(sign, nullptr);
1110
1111 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1112 ASSERT_EQ(res, HCF_SUCCESS);
1113
1114 uint8_t pSourceData[] = "1234567812345678\0";
1115 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1116 res = sign->setSignSpecUint8Array(nullptr, SM2_USER_ID_UINT8ARR, pSource);
1117
1118 ASSERT_NE(res, HCF_SUCCESS);
1119
1120 HcfObjDestroy(sign);
1121 }
1122
1123 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest051, TestSize.Level0)
1124 {
1125 HcfSign *sign = nullptr;
1126 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1127
1128 ASSERT_EQ(res, HCF_SUCCESS);
1129 ASSERT_NE(sign, nullptr);
1130
1131 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1132 ASSERT_EQ(res, HCF_SUCCESS);
1133
1134 uint8_t pSourceData[] = "1234567812345678\0";
1135 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1136 res = sign->setSignSpecUint8Array(sign, PSS_SALT_LEN_INT, pSource);
1137
1138 ASSERT_NE(res, HCF_SUCCESS);
1139
1140 HcfObjDestroy(sign);
1141 }
1142
1143 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest052, TestSize.Level0)
1144 {
1145 HcfSign *sign = nullptr;
1146 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1147
1148 ASSERT_EQ(res, HCF_SUCCESS);
1149 ASSERT_NE(sign, nullptr);
1150
1151 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1152 ASSERT_EQ(res, HCF_SUCCESS);
1153
1154 int32_t saltlen = 0;
1155 res = sign->setSignSpecInt(sign, PSS_SALT_LEN_INT, saltlen);
1156
1157 ASSERT_EQ(res, HCF_NOT_SUPPORT);
1158
1159 HcfObjDestroy(sign);
1160 }
1161
1162 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest053, TestSize.Level0)
1163 {
1164 HcfSign *sign = nullptr;
1165 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1166
1167 ASSERT_EQ(res, HCF_SUCCESS);
1168 ASSERT_NE(sign, nullptr);
1169
1170 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1171 ASSERT_EQ(res, HCF_SUCCESS);
1172
1173 int32_t returnInt = 0;
1174 res = sign->getSignSpecInt(sign, PSS_SALT_LEN_INT, &returnInt);
1175
1176 ASSERT_EQ(res, HCF_NOT_SUPPORT);
1177
1178 HcfObjDestroy(sign);
1179 }
1180
1181 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest054, TestSize.Level0)
1182 {
1183 HcfSign *sign = nullptr;
1184 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1185
1186 ASSERT_EQ(res, HCF_SUCCESS);
1187 ASSERT_NE(sign, nullptr);
1188
1189 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1190 ASSERT_EQ(res, HCF_SUCCESS);
1191
1192 res = sign->getSignSpecInt(sign, PSS_SALT_LEN_INT, nullptr);
1193
1194 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1195
1196 HcfObjDestroy(sign);
1197 }
1198
1199 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest055, TestSize.Level0)
1200 {
1201 HcfSign *sign = nullptr;
1202 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1203
1204 ASSERT_EQ(res, HCF_SUCCESS);
1205 ASSERT_NE(sign, nullptr);
1206
1207 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1208 ASSERT_EQ(res, HCF_SUCCESS);
1209
1210 char *returnStr = nullptr;
1211 res = sign->getSignSpecString(sign, SM2_USER_ID_UINT8ARR, &returnStr);
1212
1213 ASSERT_EQ(res, HCF_NOT_SUPPORT);
1214
1215 HcfObjDestroy(sign);
1216 }
1217
1218 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest056, TestSize.Level0)
1219 {
1220 HcfSign *sign = nullptr;
1221 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1222
1223 ASSERT_EQ(res, HCF_SUCCESS);
1224 ASSERT_NE(sign, nullptr);
1225
1226 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1227 ASSERT_EQ(res, HCF_SUCCESS);
1228
1229 res = sign->getSignSpecString(sign, SM2_USER_ID_UINT8ARR, nullptr);
1230
1231 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1232
1233 HcfObjDestroy(sign);
1234 }
1235
1236 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest057, TestSize.Level0)
1237 {
1238 HcfSign *sign = nullptr;
1239 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1240
1241 ASSERT_EQ(res, HCF_SUCCESS);
1242 ASSERT_NE(sign, nullptr);
1243
1244 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1245 ASSERT_EQ(res, HCF_SUCCESS);
1246
1247 char *returnStr = nullptr;
1248 res = sign->getSignSpecString(nullptr, SM2_USER_ID_UINT8ARR, &returnStr);
1249
1250 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1251
1252 HcfObjDestroy(sign);
1253 }
1254
1255 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest058, TestSize.Level0)
1256 {
1257 HcfSign *sign = nullptr;
1258 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1259
1260 ASSERT_EQ(res, HCF_SUCCESS);
1261 ASSERT_NE(sign, nullptr);
1262
1263 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1264 ASSERT_EQ(res, HCF_SUCCESS);
1265
1266 char *returnStr = nullptr;
1267 res = sign->getSignSpecString(sign, PSS_MD_NAME_STR, &returnStr);
1268 ASSERT_EQ(res, HCF_NOT_SUPPORT);
1269 HcfObjDestroy(sign);
1270 }
1271
1272 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest059, TestSize.Level0)
1273 {
1274 HcfSignatureParams params = {
1275 .algo = HCF_ALG_SM2,
1276 .md = HCF_OPENSSL_DIGEST_SM3,
1277 };
1278 HcfSignSpi *spiObj = nullptr;
1279 int32_t res = HcfSignSpiSm2Create(¶ms, &spiObj);
1280
1281 ASSERT_EQ(res, HCF_SUCCESS);
1282 ASSERT_NE(spiObj, nullptr);
1283
1284 uint8_t pSourceData[] = "1234567812345678\0";
1285 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1286 res = spiObj->engineSetSignSpecUint8Array(nullptr, SM2_USER_ID_UINT8ARR, pSource);
1287 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1288
1289 HcfObjDestroy(spiObj);
1290 }
1291
1292 // sign设置userid参数，进行签名，verify不设置参数进行验签
1293 HWTEST_F(CryptoSm2SignTest, CryptoSm2SignTest060, TestSize.Level0)
1294 {
1295 HcfSign *sign = nullptr;
1296 int32_t res = HcfSignCreate("SM2|SM3", &sign);
1297
1298 ASSERT_EQ(res, HCF_SUCCESS);
1299 ASSERT_NE(sign, nullptr);
1300
1301 res = sign->init(sign, nullptr, sm2256KeyPair_->priKey);
1302 ASSERT_EQ(res, HCF_SUCCESS);
1303
1304 uint8_t pSourceData[] = "1234567812345678\0";
1305 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1306 res = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, pSource);
1307 ASSERT_EQ(res, HCF_SUCCESS);
1308
1309 HcfBlob out = { .data = nullptr, .len = 0 };
1310 res = sign->sign(sign, &g_mockInput, &out);
1311
1312 ASSERT_EQ(res, HCF_SUCCESS);
1313 ASSERT_NE(out.data, nullptr);
1314 ASSERT_NE(out.len, (const unsigned int)0);
1315
1316 HcfVerify *verify = nullptr;
1317 res = HcfVerifyCreate("SM2|SM3", &verify);
1318
1319 ASSERT_EQ(res, HCF_SUCCESS);
1320 ASSERT_NE(verify, nullptr);
1321
1322 res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey);
1323
1324 ASSERT_EQ(res, HCF_SUCCESS);
1325
1326 bool flag = verify->verify(verify, &g_mockInput, &out);
1327
1328 ASSERT_EQ(flag, true);
1329
1330 HcfFree(out.data);
1331 HcfObjDestroy(sign);
1332 HcfObjDestroy(verify);
1333 }
1334 }
1335