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 CryptoSm2VerifyTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp();
37 void TearDown();
38
39 static HcfKeyPair *g_sm2256KeyPair_;
40 };
41
42 HcfKeyPair *CryptoSm2VerifyTest::g_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 CryptoSm2VerifyTest::SetUp() {}
TearDown()51 void CryptoSm2VerifyTest::TearDown() {}
52
SetUpTestCase()53 void CryptoSm2VerifyTest::SetUpTestCase()
54 {
55 HcfAsyKeyGenerator *generator = nullptr;
56 int32_t 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 g_sm2256KeyPair_ = keyPair;
66
67 HcfObjDestroy(generator);
68 }
69
TearDownTestCase()70 void CryptoSm2VerifyTest::TearDownTestCase()
71 {
72 HcfObjDestroy(g_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
85 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest001, TestSize.Level0)
86 {
87 HcfVerify *verify = nullptr;
88 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
89
90 ASSERT_EQ(res, HCF_SUCCESS);
91 ASSERT_NE(verify, nullptr);
92
93 HcfObjDestroy(verify);
94 }
95
96 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest002, TestSize.Level0)
97 {
98 HcfVerify *verify = nullptr;
99 int32_t res = HcfVerifyCreate(nullptr, &verify);
100
101 ASSERT_EQ(res, HCF_INVALID_PARAMS);
102 ASSERT_EQ(verify, nullptr);
103 }
104
105 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest003, TestSize.Level0)
106 {
107 HcfVerify *verify = nullptr;
108 int32_t res = HcfVerifyCreate("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD"
109 "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", &verify);
110
111 ASSERT_EQ(res, HCF_INVALID_PARAMS);
112 ASSERT_EQ(verify, nullptr);
113 }
114
115 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest004, TestSize.Level0)
116 {
117 HcfVerify *verify = nullptr;
118 int32_t res = HcfVerifyCreate("SM5|SM3", &verify);
119
120 ASSERT_NE(res, HCF_SUCCESS);
121 ASSERT_EQ(verify, nullptr);
122 }
123
124 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest005, TestSize.Level0)
125 {
126 HcfVerify *verify = nullptr;
127 int32_t res = HcfVerifyCreate("SM2|SM5", &verify);
128
129 ASSERT_NE(res, HCF_SUCCESS);
130 ASSERT_EQ(verify, nullptr);
131 }
132
133 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest006, TestSize.Level0)
134 {
135 HcfVerify *verify = nullptr;
136 int32_t res = HcfVerifyCreate("SM2|MD5", &verify);
137
138 ASSERT_NE(res, HCF_SUCCESS);
139 ASSERT_EQ(verify, nullptr);
140 }
141
142 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest007, TestSize.Level0)
143 {
144 HcfVerify *verify = nullptr;
145 int32_t res = HcfVerifyCreate("SM2SM3", &verify);
146
147 ASSERT_NE(res, HCF_SUCCESS);
148 ASSERT_EQ(verify, nullptr);
149 }
150
151 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest008, TestSize.Level0)
152 {
153 int32_t res = HcfVerifyCreate("SM2|SM3", nullptr);
154
155 ASSERT_EQ(res, HCF_INVALID_PARAMS);
156 }
157
158 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest009, TestSize.Level0)
159 {
160 HcfVerify *verify = nullptr;
161 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
162
163 ASSERT_EQ(res, HCF_SUCCESS);
164 ASSERT_NE(verify, nullptr);
165
166 const char *className = verify->base.getClass();
167
168 ASSERT_NE(className, nullptr);
169
170 HcfObjDestroy(verify);
171 }
172
173 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest010, TestSize.Level0)
174 {
175 HcfVerify *verify = nullptr;
176 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
177
178 ASSERT_EQ(res, HCF_SUCCESS);
179 ASSERT_NE(verify, nullptr);
180
181 verify->base.destroy((HcfObjectBase *)verify);
182 }
183
184 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest011, TestSize.Level0)
185 {
186 HcfVerify *verify = nullptr;
187 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
188
189 ASSERT_EQ(res, HCF_SUCCESS);
190 ASSERT_NE(verify, nullptr);
191
192 verify->base.destroy(nullptr);
193
194 HcfObjDestroy(verify);
195 }
196
197 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest012, TestSize.Level0)
198 {
199 HcfVerify *verify = nullptr;
200 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
201
202 ASSERT_EQ(res, HCF_SUCCESS);
203 ASSERT_NE(verify, nullptr);
204
205 verify->base.destroy(&obj);
206
207 HcfObjDestroy(verify);
208 }
209
210 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest013, TestSize.Level0)
211 {
212 HcfVerify *verify = nullptr;
213 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
214
215 ASSERT_EQ(res, HCF_SUCCESS);
216 ASSERT_NE(verify, nullptr);
217
218 const char *algName = verify->getAlgoName(verify);
219
220 ASSERT_NE(algName, nullptr);
221
222 HcfObjDestroy(verify);
223 }
224
225 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest014, TestSize.Level0)
226 {
227 HcfVerify *verify = nullptr;
228 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
229
230 ASSERT_EQ(res, HCF_SUCCESS);
231 ASSERT_NE(verify, nullptr);
232
233 const char *algName = verify->getAlgoName(nullptr);
234
235 ASSERT_EQ(algName, nullptr);
236
237 HcfObjDestroy(verify);
238 }
239
240 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest015, TestSize.Level0)
241 {
242 HcfVerify *verify = nullptr;
243 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
244
245 ASSERT_EQ(res, HCF_SUCCESS);
246 ASSERT_NE(verify, nullptr);
247
248 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
249
250 ASSERT_EQ(res, HCF_SUCCESS);
251
252 HcfObjDestroy(verify);
253 }
254
255 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest016, TestSize.Level0)
256 {
257 HcfVerify *verify = nullptr;
258 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
259
260 ASSERT_EQ(res, HCF_SUCCESS);
261 ASSERT_NE(verify, nullptr);
262
263 res = verify->init(nullptr, nullptr, g_sm2256KeyPair_->pubKey);
264
265 ASSERT_EQ(res, HCF_INVALID_PARAMS);
266
267 HcfObjDestroy(verify);
268 }
269
270 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest017, TestSize.Level0)
271 {
272 HcfVerify *verify = nullptr;
273 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
274
275 ASSERT_EQ(res, HCF_SUCCESS);
276 ASSERT_NE(verify, nullptr);
277
278 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
279
280 ASSERT_EQ(res, HCF_SUCCESS);
281
282 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
283
284 ASSERT_EQ(res, HCF_INVALID_PARAMS);
285
286 HcfObjDestroy(verify);
287 }
288
289 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest018, TestSize.Level0)
290 {
291 HcfVerify *verify = nullptr;
292 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
293
294 ASSERT_EQ(res, HCF_SUCCESS);
295 ASSERT_NE(verify, nullptr);
296
297 res = verify->init(verify, nullptr, nullptr);
298
299 ASSERT_EQ(res, HCF_INVALID_PARAMS);
300
301 HcfObjDestroy(verify);
302 }
303
304 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest019, TestSize.Level0)
305 {
306 HcfVerify *verify = nullptr;
307 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
308
309 ASSERT_EQ(res, HCF_SUCCESS);
310 ASSERT_NE(verify, nullptr);
311
312 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
313
314 ASSERT_EQ(res, HCF_SUCCESS);
315
316 res = verify->update(verify, &g_mockInput);
317
318 ASSERT_EQ(res, HCF_SUCCESS);
319
320 HcfObjDestroy(verify);
321 }
322
323 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest020, TestSize.Level0)
324 {
325 HcfVerify *verify = nullptr;
326 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
327
328 ASSERT_EQ(res, HCF_SUCCESS);
329 ASSERT_NE(verify, nullptr);
330
331 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
332
333 ASSERT_EQ(res, HCF_SUCCESS);
334
335 res = verify->update(nullptr, &g_mockInput);
336
337 ASSERT_EQ(res, HCF_INVALID_PARAMS);
338
339 HcfObjDestroy(verify);
340 }
341
342 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest021, TestSize.Level0)
343 {
344 HcfVerify *verify = nullptr;
345 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
346
347 ASSERT_EQ(res, HCF_SUCCESS);
348 ASSERT_NE(verify, nullptr);
349
350 res = verify->update(verify, &g_mockInput);
351
352 ASSERT_EQ(res, HCF_INVALID_PARAMS);
353
354 HcfObjDestroy(verify);
355 }
356
357 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest022, TestSize.Level0)
358 {
359 HcfVerify *verify = nullptr;
360 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
361
362 ASSERT_EQ(res, HCF_SUCCESS);
363 ASSERT_NE(verify, nullptr);
364
365 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
366
367 ASSERT_EQ(res, HCF_SUCCESS);
368
369 res = verify->update(verify, nullptr);
370
371 ASSERT_EQ(res, HCF_INVALID_PARAMS);
372
373 HcfObjDestroy(verify);
374 }
375
376 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest023, TestSize.Level0)
377 {
378 HcfVerify *verify = nullptr;
379 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
380
381 ASSERT_EQ(res, HCF_SUCCESS);
382 ASSERT_NE(verify, nullptr);
383
384 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
385
386 ASSERT_EQ(res, HCF_SUCCESS);
387
388 HcfBlob input = {
389 .data = nullptr,
390 .len = 1
391 };
392 res = verify->update(verify, &input);
393
394 ASSERT_EQ(res, HCF_INVALID_PARAMS);
395
396 HcfObjDestroy(verify);
397 }
398
399 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest024, TestSize.Level0)
400 {
401 HcfVerify *verify = nullptr;
402 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
403
404 ASSERT_EQ(res, HCF_SUCCESS);
405 ASSERT_NE(verify, nullptr);
406
407 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
408
409 ASSERT_EQ(res, HCF_SUCCESS);
410
411 HcfBlob input = {
412 .data = (uint8_t *)g_mockMessage,
413 .len = 0
414 };
415 res = verify->update(verify, &input);
416
417 ASSERT_EQ(res, HCF_INVALID_PARAMS);
418
419 HcfObjDestroy(verify);
420 }
421
422 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest025, TestSize.Level0)
423 {
424 HcfSign *sign = nullptr;
425 int32_t res = HcfSignCreate("SM2|SM3", &sign);
426
427 ASSERT_EQ(res, HCF_SUCCESS);
428 ASSERT_NE(sign, nullptr);
429
430 res = sign->init(sign, nullptr, g_sm2256KeyPair_->priKey);
431
432 ASSERT_EQ(res, HCF_SUCCESS);
433
434 res = sign->update(sign, &g_mockInput);
435
436 ASSERT_EQ(res, HCF_SUCCESS);
437
438 HcfBlob out = { .data = nullptr, .len = 0 };
439 res = sign->sign(sign, nullptr, &out);
440
441 ASSERT_EQ(res, HCF_SUCCESS);
442 ASSERT_NE(out.data, nullptr);
443 ASSERT_NE(out.len, (const unsigned int)0);
444
445 HcfVerify *verify = nullptr;
446 res = HcfVerifyCreate("SM2|SM3", &verify);
447
448 ASSERT_EQ(res, HCF_SUCCESS);
449 ASSERT_NE(verify, nullptr);
450
451 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
452
453 ASSERT_EQ(res, HCF_SUCCESS);
454
455 res = verify->update(verify, &g_mockInput);
456
457 ASSERT_EQ(res, HCF_SUCCESS);
458
459 bool flag = verify->verify(verify, nullptr, &out);
460
461 ASSERT_EQ(flag, true);
462
463 HcfFree(out.data);
464 HcfObjDestroy(sign);
465 HcfObjDestroy(verify);
466 }
467
468 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest026, TestSize.Level0)
469 {
470 HcfSign *sign = nullptr;
471 int32_t res = HcfSignCreate("SM2|SM3", &sign);
472
473 ASSERT_EQ(res, HCF_SUCCESS);
474 ASSERT_NE(sign, nullptr);
475
476 res = sign->init(sign, nullptr, g_sm2256KeyPair_->priKey);
477
478 ASSERT_EQ(res, HCF_SUCCESS);
479
480 HcfBlob out = { .data = nullptr, .len = 0 };
481 res = sign->sign(sign, &g_mockInput, &out);
482
483 ASSERT_EQ(res, HCF_SUCCESS);
484 ASSERT_NE(out.data, nullptr);
485 ASSERT_NE(out.len, (const unsigned int)0);
486
487 HcfVerify *verify = nullptr;
488 res = HcfVerifyCreate("SM2|SM3", &verify);
489
490 ASSERT_EQ(res, HCF_SUCCESS);
491 ASSERT_NE(verify, nullptr);
492
493 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
494
495 ASSERT_EQ(res, HCF_SUCCESS);
496
497 bool flag = verify->verify(verify, &g_mockInput, &out);
498
499 ASSERT_EQ(flag, true);
500
501 HcfFree(out.data);
502 HcfObjDestroy(sign);
503 HcfObjDestroy(verify);
504 }
505
506 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest027, TestSize.Level0)
507 {
508 HcfSign *sign = nullptr;
509 int32_t res = HcfSignCreate("SM2|SM3", &sign);
510
511 ASSERT_EQ(res, HCF_SUCCESS);
512 ASSERT_NE(sign, nullptr);
513
514 res = sign->init(sign, nullptr, g_sm2256KeyPair_->priKey);
515
516 ASSERT_EQ(res, HCF_SUCCESS);
517
518 res = sign->update(sign, &g_mockInput);
519
520 ASSERT_EQ(res, HCF_SUCCESS);
521
522 HcfBlob out = { .data = nullptr, .len = 0 };
523 res = sign->sign(sign, nullptr, &out);
524
525 ASSERT_EQ(res, HCF_SUCCESS);
526 ASSERT_NE(out.data, nullptr);
527 ASSERT_NE(out.len, (const unsigned int)0);
528
529 HcfVerify *verify = nullptr;
530 res = HcfVerifyCreate("SM2|SM3", &verify);
531
532 ASSERT_EQ(res, HCF_SUCCESS);
533 ASSERT_NE(verify, nullptr);
534
535 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
536
537 ASSERT_EQ(res, HCF_SUCCESS);
538
539 res = verify->update(verify, &g_mockInput);
540
541 ASSERT_EQ(res, HCF_SUCCESS);
542
543 bool flag = verify->verify(nullptr, nullptr, &out);
544
545 ASSERT_EQ(flag, false);
546
547 HcfFree(out.data);
548 HcfObjDestroy(sign);
549 HcfObjDestroy(verify);
550 }
551
552 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest028, TestSize.Level0)
553 {
554 HcfSign *sign = nullptr;
555 int32_t res = HcfSignCreate("SM2|SM3", &sign);
556
557 ASSERT_EQ(res, HCF_SUCCESS);
558 ASSERT_NE(sign, nullptr);
559
560 res = sign->init(sign, nullptr, g_sm2256KeyPair_->priKey);
561
562 ASSERT_EQ(res, HCF_SUCCESS);
563
564 res = sign->update(sign, &g_mockInput);
565
566 ASSERT_EQ(res, HCF_SUCCESS);
567
568 HcfBlob out = { .data = nullptr, .len = 0 };
569 res = sign->sign(sign, nullptr, &out);
570
571 ASSERT_EQ(res, HCF_SUCCESS);
572 ASSERT_NE(out.data, nullptr);
573 ASSERT_NE(out.len, (const unsigned int)0);
574
575 HcfVerify *verify = nullptr;
576 res = HcfVerifyCreate("SM2|SM3", &verify);
577
578 ASSERT_EQ(res, HCF_SUCCESS);
579 ASSERT_NE(verify, nullptr);
580
581 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
582
583 ASSERT_EQ(res, HCF_SUCCESS);
584
585 res = verify->update(verify, &g_mockInput);
586
587 ASSERT_EQ(res, HCF_SUCCESS);
588
589 bool flag = verify->verify((HcfVerify *)(&obj), nullptr, &out);
590
591 ASSERT_EQ(flag, false);
592
593 HcfFree(out.data);
594 HcfObjDestroy(sign);
595 HcfObjDestroy(verify);
596 }
597
598 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest029, TestSize.Level0)
599 {
600 HcfSign *sign = nullptr;
601 int32_t res = HcfSignCreate("SM2|SM3", &sign);
602
603 ASSERT_EQ(res, HCF_SUCCESS);
604 ASSERT_NE(sign, nullptr);
605
606 res = sign->init(sign, nullptr, g_sm2256KeyPair_->priKey);
607
608 ASSERT_EQ(res, HCF_SUCCESS);
609
610 res = sign->update(sign, &g_mockInput);
611
612 ASSERT_EQ(res, HCF_SUCCESS);
613
614 HcfBlob out = { .data = nullptr, .len = 0 };
615 res = sign->sign(sign, nullptr, &out);
616
617 ASSERT_EQ(res, HCF_SUCCESS);
618 ASSERT_NE(out.data, nullptr);
619 ASSERT_NE(out.len, (const unsigned int)0);
620
621 HcfVerify *verify = nullptr;
622 res = HcfVerifyCreate("SM2|SM3", &verify);
623
624 ASSERT_EQ(res, HCF_SUCCESS);
625 ASSERT_NE(verify, nullptr);
626
627 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
628
629 ASSERT_EQ(res, HCF_SUCCESS);
630
631 bool flag = verify->verify(verify, nullptr, &out);
632
633 ASSERT_EQ(flag, false);
634
635 HcfFree(out.data);
636 HcfObjDestroy(sign);
637 HcfObjDestroy(verify);
638 }
639
640 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest030, TestSize.Level0)
641 {
642 HcfSign *sign = nullptr;
643 int32_t res = HcfSignCreate("SM2|SM3", &sign);
644
645 ASSERT_EQ(res, HCF_SUCCESS);
646 ASSERT_NE(sign, nullptr);
647
648 res = sign->init(sign, nullptr, g_sm2256KeyPair_->priKey);
649
650 ASSERT_EQ(res, HCF_SUCCESS);
651
652 res = sign->update(sign, &g_mockInput);
653
654 ASSERT_EQ(res, HCF_SUCCESS);
655
656 HcfBlob out = { .data = nullptr, .len = 0 };
657 res = sign->sign(sign, nullptr, &out);
658
659 ASSERT_EQ(res, HCF_SUCCESS);
660 ASSERT_NE(out.data, nullptr);
661 ASSERT_NE(out.len, (const unsigned int)0);
662
663 HcfVerify *verify = nullptr;
664 res = HcfVerifyCreate("SM2|SM3", &verify);
665
666 ASSERT_EQ(res, HCF_SUCCESS);
667 ASSERT_NE(verify, nullptr);
668
669 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
670
671 ASSERT_EQ(res, HCF_SUCCESS);
672
673 HcfBlob input = {
674 .data = nullptr,
675 .len = 1
676 };
677 bool flag = verify->verify(verify, &input, &out);
678
679 ASSERT_EQ(flag, false);
680
681 HcfFree(out.data);
682 HcfObjDestroy(sign);
683 HcfObjDestroy(verify);
684 }
685
686 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest031, TestSize.Level0)
687 {
688 HcfSign *sign = nullptr;
689 int32_t res = HcfSignCreate("SM2|SM3", &sign);
690
691 ASSERT_EQ(res, HCF_SUCCESS);
692 ASSERT_NE(sign, nullptr);
693
694 res = sign->init(sign, nullptr, g_sm2256KeyPair_->priKey);
695
696 ASSERT_EQ(res, HCF_SUCCESS);
697
698 res = sign->update(sign, &g_mockInput);
699
700 ASSERT_EQ(res, HCF_SUCCESS);
701
702 HcfBlob out = { .data = nullptr, .len = 0 };
703 res = sign->sign(sign, nullptr, &out);
704
705 ASSERT_EQ(res, HCF_SUCCESS);
706 ASSERT_NE(out.data, nullptr);
707 ASSERT_NE(out.len, (const unsigned int)0);
708
709 HcfVerify *verify = nullptr;
710 res = HcfVerifyCreate("SM2|SM3", &verify);
711
712 ASSERT_EQ(res, HCF_SUCCESS);
713 ASSERT_NE(verify, nullptr);
714
715 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
716
717 ASSERT_EQ(res, HCF_SUCCESS);
718
719 HcfBlob input = {
720 .data = (uint8_t *)g_mockMessage,
721 .len = 0
722 };
723 bool flag = verify->verify(verify, &input, &out);
724
725 ASSERT_EQ(flag, false);
726
727 HcfFree(out.data);
728 HcfObjDestroy(sign);
729 HcfObjDestroy(verify);
730 }
731
732 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest032, TestSize.Level0)
733 {
734 HcfVerify *verify = nullptr;
735 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
736
737 ASSERT_EQ(res, HCF_SUCCESS);
738 ASSERT_NE(verify, nullptr);
739
740 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
741
742 ASSERT_EQ(res, HCF_SUCCESS);
743
744 res = verify->update(verify, &g_mockInput);
745
746 ASSERT_EQ(res, HCF_SUCCESS);
747
748 bool flag = verify->verify(verify, nullptr, nullptr);
749
750 ASSERT_EQ(flag, false);
751
752 HcfObjDestroy(verify);
753 }
754
755 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest033, TestSize.Level0)
756 {
757 HcfVerify *verify = nullptr;
758 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
759
760 ASSERT_EQ(res, HCF_SUCCESS);
761 ASSERT_NE(verify, nullptr);
762
763 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
764
765 ASSERT_EQ(res, HCF_SUCCESS);
766
767 res = verify->update(verify, &g_mockInput);
768
769 ASSERT_EQ(res, HCF_SUCCESS);
770
771 HcfBlob mockOut = {
772 .data = nullptr,
773 .len = 1
774 };
775 bool flag = verify->verify(verify, nullptr, &mockOut);
776
777 ASSERT_EQ(flag, false);
778
779 HcfObjDestroy(verify);
780 }
781
782 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest034, TestSize.Level0)
783 {
784 HcfVerify *verify = nullptr;
785 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
786
787 ASSERT_EQ(res, HCF_SUCCESS);
788 ASSERT_NE(verify, nullptr);
789
790 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
791
792 ASSERT_EQ(res, HCF_SUCCESS);
793
794 res = verify->update(verify, &g_mockInput);
795
796 ASSERT_EQ(res, HCF_SUCCESS);
797
798 HcfBlob mockOut = {
799 .data = (uint8_t *)g_mockMessage,
800 .len = 0
801 };
802 bool flag = verify->verify(verify, nullptr, &mockOut);
803
804 ASSERT_EQ(flag, false);
805
806 HcfObjDestroy(verify);
807 }
808
809 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest035, TestSize.Level0)
810 {
811 HcfVerifySpi *spiObj = nullptr;
812 int32_t res = HcfVerifySpiSm2Create(nullptr, &spiObj);
813
814 ASSERT_EQ(res, HCF_INVALID_PARAMS);
815 ASSERT_EQ(spiObj, nullptr);
816 }
817
818 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest036, TestSize.Level0)
819 {
820 HcfSignatureParams params = {
821 .algo = HCF_ALG_SM2,
822 .md = HCF_OPENSSL_DIGEST_SM3,
823 };
824 int32_t res = HcfVerifySpiSm2Create(¶ms, nullptr);
825
826 ASSERT_EQ(res, HCF_INVALID_PARAMS);
827 }
828
829 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest037, TestSize.Level0)
830 {
831 HcfSignatureParams params = {
832 .algo = HCF_ALG_SM2,
833 .md = HCF_OPENSSL_DIGEST_SM3,
834 };
835 HcfVerifySpi *spiObj = nullptr;
836 int32_t res = HcfVerifySpiSm2Create(¶ms, &spiObj);
837
838 ASSERT_EQ(res, HCF_SUCCESS);
839 ASSERT_NE(spiObj, nullptr);
840
841 const char *message = "hello world";
842 HcfBlob input = {
843 .data = (uint8_t *)message,
844 .len = 12
845 };
846 res = spiObj->engineUpdate(nullptr, &input);
847 ASSERT_EQ(res, HCF_INVALID_PARAMS);
848
849 HcfObjDestroy(spiObj);
850 }
851
852 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest038, TestSize.Level0)
853 {
854 HcfSignatureParams params = {
855 .algo = HCF_ALG_SM2,
856 .md = HCF_OPENSSL_DIGEST_SM3,
857 };
858 HcfVerifySpi *spiObj = nullptr;
859 int32_t res = HcfVerifySpiSm2Create(¶ms, &spiObj);
860
861 ASSERT_EQ(res, HCF_SUCCESS);
862 ASSERT_NE(spiObj, nullptr);
863
864 res = spiObj->engineUpdate(spiObj, nullptr);
865 ASSERT_EQ(res, HCF_INVALID_PARAMS);
866
867 HcfObjDestroy(spiObj);
868 }
869
870 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest039, TestSize.Level0)
871 {
872 HcfSignatureParams params = {
873 .algo = HCF_ALG_SM2,
874 .md = HCF_OPENSSL_DIGEST_SM3,
875 };
876 HcfVerifySpi *spiObj = nullptr;
877 int32_t res = HcfVerifySpiSm2Create(¶ms, &spiObj);
878
879 ASSERT_EQ(res, HCF_SUCCESS);
880 ASSERT_NE(spiObj, nullptr);
881
882 const char *message = "hello world";
883 HcfBlob input = {
884 .data = (uint8_t *)message,
885 .len = 12
886 };
887 HcfBlob out = { .data = nullptr, .len = 0 };
888 bool isOk = spiObj->engineVerify(nullptr, &input, &out);
889 ASSERT_EQ(isOk, false);
890
891 HcfObjDestroy(spiObj);
892 }
893
894 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest040, TestSize.Level0)
895 {
896 HcfSignatureParams params = {
897 .algo = HCF_ALG_SM2,
898 .md = HCF_OPENSSL_DIGEST_SM3,
899 };
900 HcfVerifySpi *spiObj = nullptr;
901 int32_t res = HcfVerifySpiSm2Create(¶ms, &spiObj);
902
903 ASSERT_EQ(res, HCF_SUCCESS);
904 ASSERT_NE(spiObj, nullptr);
905
906 spiObj->base.destroy(nullptr);
907
908 HcfObjDestroy(spiObj);
909 }
910
GetSignTestData(HcfBlob * out)911 static bool GetSignTestData(HcfBlob *out)
912 {
913 HcfSign *sign = nullptr;
914 int32_t res = HcfSignCreate("SM2|SM3", &sign);
915 if (res != HCF_SUCCESS) {
916 return false;
917 }
918 res = sign->init(sign, nullptr, CryptoSm2VerifyTest::g_sm2256KeyPair_->priKey);
919 if (res != HCF_SUCCESS) {
920 HcfObjDestroy(sign);
921 return false;
922 }
923 res = sign->update(sign, &g_mockInput);
924 if (res != HCF_SUCCESS) {
925 HcfObjDestroy(sign);
926 return false;
927 }
928 res = sign->sign(sign, &g_mockInput, out);
929 HcfObjDestroy(sign);
930 return res == HCF_SUCCESS;
931 }
932
MemoryMockTestFunc(uint32_t mallocCount,HcfBlob * out)933 static void MemoryMockTestFunc(uint32_t mallocCount, HcfBlob *out)
934 {
935 for (int i = 0; i < mallocCount; i++) {
936 ResetRecordMallocNum();
937 SetMockMallocIndex(i);
938 HcfVerify *verify = nullptr;
939 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
940 if (res != HCF_SUCCESS) {
941 continue;
942 }
943 res = verify->init(verify, nullptr, CryptoSm2VerifyTest::g_sm2256KeyPair_->pubKey);
944 if (res != HCF_SUCCESS) {
945 HcfObjDestroy(verify);
946 continue;
947 }
948 res = verify->update(verify, &g_mockInput);
949 if (res != HCF_SUCCESS) {
950 HcfObjDestroy(verify);
951 continue;
952 }
953 (void)verify->verify(verify, nullptr, out);
954 HcfObjDestroy(verify);
955 }
956 }
957
958 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest041, TestSize.Level0)
959 {
960 HcfBlob out = { .data = nullptr, .len = 0 };
961 GetSignTestData(&out);
962 StartRecordMallocNum();
963
964 HcfVerify *verify = nullptr;
965 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
966
967 ASSERT_EQ(res, HCF_SUCCESS);
968 ASSERT_NE(verify, nullptr);
969
970 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
971
972 ASSERT_EQ(res, HCF_SUCCESS);
973
974 res = verify->update(verify, &g_mockInput);
975
976 ASSERT_EQ(res, HCF_SUCCESS);
977
978 bool flag = verify->verify(verify, &g_mockInput, &out);
979
980 ASSERT_EQ(flag, true);
981 HcfObjDestroy(verify);
982
983 uint32_t mallocCount = GetMallocNum();
984 MemoryMockTestFunc(mallocCount, &out);
985 EndRecordMallocNum();
986 }
987
OpensslMockTestFunc(uint32_t mallocCount,HcfBlob * out)988 static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *out)
989 {
990 for (int i = 0; i < mallocCount; i++) {
991 ResetOpensslCallNum();
992 SetOpensslCallMockIndex(i);
993 HcfVerify *verify = nullptr;
994 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
995 if (res != HCF_SUCCESS) {
996 continue;
997 }
998 res = verify->init(verify, nullptr, CryptoSm2VerifyTest::g_sm2256KeyPair_->pubKey);
999 if (res != HCF_SUCCESS) {
1000 HcfObjDestroy(verify);
1001 continue;
1002 }
1003 uint8_t pSourceData[] = "1234567812345678\0";
1004 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1005 res = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, pSource);
1006 if (res != HCF_SUCCESS) {
1007 HcfObjDestroy(verify);
1008 continue;
1009 }
1010 res = verify->update(verify, &g_mockInput);
1011 if (res != HCF_SUCCESS) {
1012 HcfObjDestroy(verify);
1013 continue;
1014 }
1015 (void)verify->verify(verify, &g_mockInput, out);
1016 HcfObjDestroy(verify);
1017 }
1018 }
1019
1020 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest042, TestSize.Level0)
1021 {
1022 HcfBlob out = { .data = nullptr, .len = 0 };
1023 ASSERT_EQ(GetSignTestData(&out), true);
1024 StartRecordOpensslCallNum();
1025
1026 HcfVerify *verify = nullptr;
1027 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1028 ASSERT_EQ(res, HCF_SUCCESS);
1029 ASSERT_NE(verify, nullptr);
1030 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1031 ASSERT_EQ(res, HCF_SUCCESS);
1032 uint8_t pSourceData[] = "1234567812345678\0";
1033 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1034 res = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, pSource);
1035 ASSERT_EQ(res, HCF_SUCCESS);
1036 res = verify->update(verify, &g_mockInput);
1037 ASSERT_EQ(res, HCF_SUCCESS);
1038
1039 bool flag = verify->verify(verify, &g_mockInput, &out);
1040 ASSERT_EQ(flag, true);
1041 HcfObjDestroy(verify);
1042
1043 uint32_t mallocCount = GetOpensslCallNum();
1044 OpensslMockTestFunc(mallocCount, &out);
1045 EndRecordOpensslCallNum();
1046 }
1047
1048 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest043, TestSize.Level0)
1049 {
1050 HcfVerify *verify = nullptr;
1051 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1052
1053 ASSERT_EQ(res, HCF_SUCCESS);
1054 ASSERT_NE(verify, nullptr);
1055
1056 uint8_t pSourceData[] = "1234567812345678\0";
1057 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1058 res = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, pSource);
1059
1060 ASSERT_EQ(res, HCF_SUCCESS);
1061
1062 HcfObjDestroy(verify);
1063 }
1064
1065 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest044, TestSize.Level0)
1066 {
1067 HcfVerify *verify = nullptr;
1068 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1069
1070 ASSERT_EQ(res, HCF_SUCCESS);
1071 ASSERT_NE(verify, nullptr);
1072
1073 HcfBlob pSource = {.data = nullptr, .len = 0};
1074 res = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, pSource);
1075
1076 ASSERT_EQ(res, HCF_SUCCESS);
1077
1078 HcfObjDestroy(verify);
1079 }
1080
1081 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest045, TestSize.Level0)
1082 {
1083 HcfVerify *verify = nullptr;
1084 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1085
1086 ASSERT_EQ(res, HCF_SUCCESS);
1087 ASSERT_NE(verify, nullptr);
1088
1089 uint8_t pSourceData[] = "1234567812345678\0";
1090 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1091 res = verify->setVerifySpecUint8Array(nullptr, SM2_USER_ID_UINT8ARR, pSource);
1092
1093 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1094
1095 HcfObjDestroy(verify);
1096 }
1097
1098 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest046, TestSize.Level0)
1099 {
1100 HcfVerify *verify = nullptr;
1101 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1102
1103 ASSERT_EQ(res, HCF_SUCCESS);
1104 ASSERT_NE(verify, nullptr);
1105
1106 uint8_t pSourceData[] = "1234567812345678\0";
1107 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1108 res = verify->setVerifySpecUint8Array(verify, PSS_SALT_LEN_INT, pSource);
1109
1110 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1111
1112 HcfObjDestroy(verify);
1113 }
1114
1115 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest047, TestSize.Level0)
1116 {
1117 HcfVerify *verify = nullptr;
1118 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1119
1120 ASSERT_EQ(res, HCF_SUCCESS);
1121 ASSERT_NE(verify, nullptr);
1122
1123 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1124 ASSERT_EQ(res, HCF_SUCCESS);
1125
1126 uint8_t pSourceData[] = "1234567812345678\0";
1127 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1128 res = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, pSource);
1129
1130 ASSERT_EQ(res, HCF_SUCCESS);
1131
1132 HcfObjDestroy(verify);
1133 }
1134
1135 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest048, TestSize.Level0)
1136 {
1137 HcfVerify *verify = nullptr;
1138 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1139
1140 ASSERT_EQ(res, HCF_SUCCESS);
1141 ASSERT_NE(verify, nullptr);
1142
1143 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1144 ASSERT_EQ(res, HCF_SUCCESS);
1145
1146 HcfBlob pSource = {.data = nullptr, .len = 0};
1147 res = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, pSource);
1148
1149 ASSERT_EQ(res, HCF_SUCCESS);
1150
1151 HcfObjDestroy(verify);
1152 }
1153
1154 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest049, TestSize.Level0)
1155 {
1156 HcfVerify *verify = nullptr;
1157 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1158
1159 ASSERT_EQ(res, HCF_SUCCESS);
1160 ASSERT_NE(verify, nullptr);
1161
1162 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1163 ASSERT_EQ(res, HCF_SUCCESS);
1164
1165 uint8_t pSourceData[] = "1234567812345678\0";
1166 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1167 res = verify->setVerifySpecUint8Array(nullptr, SM2_USER_ID_UINT8ARR, pSource);
1168
1169 ASSERT_NE(res, HCF_SUCCESS);
1170
1171 HcfObjDestroy(verify);
1172 }
1173
1174 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest050, TestSize.Level0)
1175 {
1176 HcfVerify *verify = nullptr;
1177 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1178
1179 ASSERT_EQ(res, HCF_SUCCESS);
1180 ASSERT_NE(verify, nullptr);
1181
1182 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1183 ASSERT_EQ(res, HCF_SUCCESS);
1184
1185 uint8_t pSourceData[] = "1234567812345678\0";
1186 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1187 res = verify->setVerifySpecUint8Array(verify, PSS_SALT_LEN_INT, pSource);
1188
1189 ASSERT_NE(res, HCF_SUCCESS);
1190
1191 HcfObjDestroy(verify);
1192 }
1193
1194 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest051, TestSize.Level0)
1195 {
1196 HcfVerify *verify = nullptr;
1197 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1198
1199 ASSERT_EQ(res, HCF_SUCCESS);
1200 ASSERT_NE(verify, nullptr);
1201
1202 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1203 ASSERT_EQ(res, HCF_SUCCESS);
1204
1205 int32_t saltlen = 0;
1206 res = verify->setVerifySpecInt(verify, PSS_SALT_LEN_INT, saltlen);
1207
1208 ASSERT_EQ(res, HCF_NOT_SUPPORT);
1209
1210 HcfObjDestroy(verify);
1211 }
1212
1213 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest052, TestSize.Level0)
1214 {
1215 HcfVerify *verify = nullptr;
1216 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1217
1218 ASSERT_EQ(res, HCF_SUCCESS);
1219 ASSERT_NE(verify, nullptr);
1220
1221 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1222 ASSERT_EQ(res, HCF_SUCCESS);
1223
1224 int32_t *returnInt = nullptr;
1225 res = verify->getVerifySpecInt(verify, PSS_SALT_LEN_INT, returnInt);
1226
1227 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1228
1229 HcfObjDestroy(verify);
1230 }
1231
1232 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest053, TestSize.Level0)
1233 {
1234 HcfVerify *verify = nullptr;
1235 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1236
1237 ASSERT_EQ(res, HCF_SUCCESS);
1238 ASSERT_NE(verify, nullptr);
1239
1240 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1241 ASSERT_EQ(res, HCF_SUCCESS);
1242
1243 int32_t returnInt = 0;
1244 res = verify->getVerifySpecInt(verify, PSS_SALT_LEN_INT, &returnInt);
1245
1246 ASSERT_EQ(res, HCF_NOT_SUPPORT);
1247
1248 HcfObjDestroy(verify);
1249 }
1250
1251 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest054, TestSize.Level0)
1252 {
1253 HcfVerify *verify = nullptr;
1254 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1255
1256 ASSERT_EQ(res, HCF_SUCCESS);
1257 ASSERT_NE(verify, nullptr);
1258
1259 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1260 ASSERT_EQ(res, HCF_SUCCESS);
1261
1262 char *returnStr = nullptr;
1263 res = verify->getVerifySpecString(verify, SM2_USER_ID_UINT8ARR, &returnStr);
1264
1265 ASSERT_EQ(res, HCF_NOT_SUPPORT);
1266
1267 HcfObjDestroy(verify);
1268 }
1269
1270 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest055, TestSize.Level0)
1271 {
1272 HcfVerify *verify = nullptr;
1273 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1274
1275 ASSERT_EQ(res, HCF_SUCCESS);
1276 ASSERT_NE(verify, nullptr);
1277
1278 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1279 ASSERT_EQ(res, HCF_SUCCESS);
1280
1281 res = verify->getVerifySpecString(verify, SM2_USER_ID_UINT8ARR, nullptr);
1282
1283 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1284
1285 HcfObjDestroy(verify);
1286 }
1287
1288 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest056, TestSize.Level0)
1289 {
1290 HcfVerify *verify = nullptr;
1291 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1292
1293 ASSERT_EQ(res, HCF_SUCCESS);
1294 ASSERT_NE(verify, nullptr);
1295
1296 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1297 ASSERT_EQ(res, HCF_SUCCESS);
1298
1299 char *returnStr = nullptr;
1300 res = verify->getVerifySpecString(nullptr, SM2_USER_ID_UINT8ARR, &returnStr);
1301
1302 ASSERT_NE(res, HCF_SUCCESS);
1303
1304 HcfObjDestroy(verify);
1305 }
1306
1307 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest057, TestSize.Level0)
1308 {
1309 HcfVerify *verify = nullptr;
1310 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1311
1312 ASSERT_EQ(res, HCF_SUCCESS);
1313 ASSERT_NE(verify, nullptr);
1314
1315 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1316 ASSERT_EQ(res, HCF_SUCCESS);
1317
1318 char *returnStr = nullptr;
1319 res = verify->getVerifySpecString(verify, PSS_MD_NAME_STR, &returnStr);
1320
1321 ASSERT_EQ(res, HCF_NOT_SUPPORT);
1322
1323 HcfObjDestroy(verify);
1324 }
1325
1326 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest058, TestSize.Level0)
1327 {
1328 HcfSignatureParams params = {
1329 .algo = HCF_ALG_SM2,
1330 .md = HCF_OPENSSL_DIGEST_SM3,
1331 };
1332 HcfVerifySpi *spiObj = nullptr;
1333 int32_t res = HcfVerifySpiSm2Create(¶ms, &spiObj);
1334
1335 ASSERT_EQ(res, HCF_SUCCESS);
1336 ASSERT_NE(spiObj, nullptr);
1337 uint8_t pSourceData[] = "1234567812345678\0";
1338 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1339 res = spiObj->engineSetVerifySpecUint8Array(nullptr, SM2_USER_ID_UINT8ARR, pSource);
1340 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1341
1342 HcfObjDestroy(spiObj);
1343 }
1344
1345 // Test verify signData from third-Party
1346 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest059, TestSize.Level0)
1347 {
1348 uint8_t pk[] = {
1349 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A,
1350 0x81, 0x1C, 0xCF, 0x55, 0x01, 0x82, 0x2D, 0x03, 0x42, 0x00, 0x04, 0x5A, 0x98, 0xC1, 0x3F, 0x5F,
1351 0xFF, 0x09, 0x42, 0xAB, 0x56, 0xCF, 0x79, 0x92, 0x50, 0x90, 0xB3, 0x7A, 0x48, 0x79, 0x62, 0xBA,
1352 0xCD, 0x3B, 0xA9, 0xE4, 0xA9, 0x7E, 0x44, 0x51, 0x39, 0xFF, 0x2D, 0xB1, 0xCF, 0x80, 0xA9, 0x12,
1353 0x02, 0x28, 0x09, 0x27, 0x8D, 0x98, 0xC4, 0x0F, 0xEF, 0x46, 0x65, 0x53, 0xD8, 0x86, 0x18, 0xF2,
1354 0x4B, 0x7E, 0x16, 0xE2, 0x63, 0xFB, 0x1E, 0xA8, 0x83, 0x88, 0xEE
1355 };
1356
1357 uint8_t signData[] = {
1358 0x30, 0x45, 0x02, 0x21, 0x00, 0xC2, 0x6E, 0x69, 0x1B, 0xBB, 0xB0, 0xEF, 0xB7, 0x29, 0xB5, 0x37,
1359 0x57, 0x6E, 0xDA, 0x1E, 0x67, 0x84, 0x9C, 0xD7, 0x00, 0x2E, 0x01, 0x85, 0x11, 0x54, 0xC3, 0x1A,
1360 0x58, 0xC6, 0xA9, 0x71, 0xEA, 0x02, 0x20, 0x7E, 0xB3, 0x76, 0x27, 0x84, 0x4F, 0x31, 0x1D, 0x64,
1361 0x71, 0xD7, 0xFE, 0x96, 0xD1, 0x5A, 0x83, 0xA0, 0x89, 0xC6, 0x3B, 0x84, 0xB6, 0x26, 0x88, 0x2A,
1362 0xF0, 0x71, 0x17, 0x6F, 0x06, 0x28, 0x11
1363 };
1364 const char *plainText = "hello world";
1365 HcfBlob plainTextBlob = { .data = (uint8_t *)plainText, strlen(plainText) };
1366 HcfBlob pubKey = { .data = pk, .len = 91 };
1367 HcfBlob signDataBlob = { .data = signData, .len = 71};
1368
1369 HcfAsyKeyGenerator *generator = nullptr;
1370 int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1371 HcfKeyPair *outKeyPair = nullptr;
1372 res = generator->convertKey(generator, nullptr, &pubKey, nullptr, &outKeyPair);
1373 ASSERT_EQ(res, HCF_SUCCESS);
1374 ASSERT_NE(outKeyPair, nullptr);
1375 HcfObjDestroy(generator);
1376
1377 HcfVerify *verify = nullptr;
1378 res = HcfVerifyCreate("SM2|SM3", &verify);
1379 ASSERT_EQ(res, HCF_SUCCESS);
1380 ASSERT_NE(verify, nullptr);
1381
1382 res = verify->init(verify, nullptr, outKeyPair->pubKey);
1383 ASSERT_EQ(res, HCF_SUCCESS);
1384
1385 res = verify->update(verify, &plainTextBlob);
1386 ASSERT_EQ(res, HCF_SUCCESS);
1387
1388 bool flag = verify->verify(verify, nullptr, &signDataBlob);
1389 ASSERT_EQ(flag, true);
1390 HcfObjDestroy(verify);
1391 HcfObjDestroy(outKeyPair);
1392 }
1393 }
1394