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 HcfBlobDataFree(&out);
987 }
988
OpensslMockTestFunc(uint32_t mallocCount,HcfBlob * out)989 static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *out)
990 {
991 for (int i = 0; i < mallocCount; i++) {
992 ResetOpensslCallNum();
993 SetOpensslCallMockIndex(i);
994 HcfVerify *verify = nullptr;
995 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
996 if (res != HCF_SUCCESS) {
997 continue;
998 }
999 res = verify->init(verify, nullptr, CryptoSm2VerifyTest::g_sm2256KeyPair_->pubKey);
1000 if (res != HCF_SUCCESS) {
1001 HcfObjDestroy(verify);
1002 continue;
1003 }
1004 uint8_t pSourceData[] = "1234567812345678\0";
1005 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1006 res = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, pSource);
1007 if (res != HCF_SUCCESS) {
1008 HcfObjDestroy(verify);
1009 continue;
1010 }
1011 res = verify->update(verify, &g_mockInput);
1012 if (res != HCF_SUCCESS) {
1013 HcfObjDestroy(verify);
1014 continue;
1015 }
1016 (void)verify->verify(verify, &g_mockInput, out);
1017 HcfObjDestroy(verify);
1018 }
1019 }
1020
1021 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest042, TestSize.Level0)
1022 {
1023 HcfBlob out = { .data = nullptr, .len = 0 };
1024 ASSERT_EQ(GetSignTestData(&out), true);
1025 StartRecordOpensslCallNum();
1026
1027 HcfVerify *verify = nullptr;
1028 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1029 ASSERT_EQ(res, HCF_SUCCESS);
1030 ASSERT_NE(verify, nullptr);
1031
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
1037 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1038 ASSERT_EQ(res, HCF_SUCCESS);
1039
1040 res = verify->update(verify, &g_mockInput);
1041 ASSERT_EQ(res, HCF_SUCCESS);
1042
1043 bool flag = verify->verify(verify, &g_mockInput, &out);
1044 ASSERT_EQ(flag, true);
1045 HcfObjDestroy(verify);
1046
1047 uint32_t mallocCount = GetOpensslCallNum();
1048 OpensslMockTestFunc(mallocCount, &out);
1049 EndRecordOpensslCallNum();
1050 HcfBlobDataFree(&out);
1051 }
1052
1053 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest043, TestSize.Level0)
1054 {
1055 HcfVerify *verify = nullptr;
1056 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1057
1058 ASSERT_EQ(res, HCF_SUCCESS);
1059 ASSERT_NE(verify, nullptr);
1060
1061 uint8_t pSourceData[] = "1234567812345678\0";
1062 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1063 res = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, pSource);
1064
1065 ASSERT_EQ(res, HCF_SUCCESS);
1066
1067 HcfObjDestroy(verify);
1068 }
1069
1070 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest044, TestSize.Level0)
1071 {
1072 HcfVerify *verify = nullptr;
1073 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1074
1075 ASSERT_EQ(res, HCF_SUCCESS);
1076 ASSERT_NE(verify, nullptr);
1077
1078 HcfBlob pSource = {.data = nullptr, .len = 0};
1079 res = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, pSource);
1080
1081 ASSERT_EQ(res, HCF_SUCCESS);
1082
1083 HcfObjDestroy(verify);
1084 }
1085
1086 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest045, TestSize.Level0)
1087 {
1088 HcfVerify *verify = nullptr;
1089 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1090
1091 ASSERT_EQ(res, HCF_SUCCESS);
1092 ASSERT_NE(verify, nullptr);
1093
1094 uint8_t pSourceData[] = "1234567812345678\0";
1095 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1096 res = verify->setVerifySpecUint8Array(nullptr, SM2_USER_ID_UINT8ARR, pSource);
1097
1098 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1099
1100 HcfObjDestroy(verify);
1101 }
1102
1103 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest046, TestSize.Level0)
1104 {
1105 HcfVerify *verify = nullptr;
1106 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1107
1108 ASSERT_EQ(res, HCF_SUCCESS);
1109 ASSERT_NE(verify, nullptr);
1110
1111 uint8_t pSourceData[] = "1234567812345678\0";
1112 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1113 res = verify->setVerifySpecUint8Array(verify, PSS_SALT_LEN_INT, pSource);
1114
1115 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1116
1117 HcfObjDestroy(verify);
1118 }
1119
1120 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest047, TestSize.Level0)
1121 {
1122 HcfVerify *verify = nullptr;
1123 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1124
1125 ASSERT_EQ(res, HCF_SUCCESS);
1126 ASSERT_NE(verify, nullptr);
1127
1128 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1129 ASSERT_EQ(res, HCF_SUCCESS);
1130
1131 uint8_t pSourceData[] = "1234567812345678\0";
1132 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1133 res = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, pSource);
1134
1135 ASSERT_EQ(res, HCF_SUCCESS);
1136
1137 HcfObjDestroy(verify);
1138 }
1139
1140 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest048, TestSize.Level0)
1141 {
1142 HcfVerify *verify = nullptr;
1143 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1144
1145 ASSERT_EQ(res, HCF_SUCCESS);
1146 ASSERT_NE(verify, nullptr);
1147
1148 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1149 ASSERT_EQ(res, HCF_SUCCESS);
1150
1151 HcfBlob pSource = {.data = nullptr, .len = 0};
1152 res = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, pSource);
1153
1154 ASSERT_EQ(res, HCF_SUCCESS);
1155
1156 HcfObjDestroy(verify);
1157 }
1158
1159 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest049, TestSize.Level0)
1160 {
1161 HcfVerify *verify = nullptr;
1162 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1163
1164 ASSERT_EQ(res, HCF_SUCCESS);
1165 ASSERT_NE(verify, nullptr);
1166
1167 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1168 ASSERT_EQ(res, HCF_SUCCESS);
1169
1170 uint8_t pSourceData[] = "1234567812345678\0";
1171 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1172 res = verify->setVerifySpecUint8Array(nullptr, SM2_USER_ID_UINT8ARR, pSource);
1173
1174 ASSERT_NE(res, HCF_SUCCESS);
1175
1176 HcfObjDestroy(verify);
1177 }
1178
1179 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest050, TestSize.Level0)
1180 {
1181 HcfVerify *verify = nullptr;
1182 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1183
1184 ASSERT_EQ(res, HCF_SUCCESS);
1185 ASSERT_NE(verify, nullptr);
1186
1187 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1188 ASSERT_EQ(res, HCF_SUCCESS);
1189
1190 uint8_t pSourceData[] = "1234567812345678\0";
1191 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1192 res = verify->setVerifySpecUint8Array(verify, PSS_SALT_LEN_INT, pSource);
1193
1194 ASSERT_NE(res, HCF_SUCCESS);
1195
1196 HcfObjDestroy(verify);
1197 }
1198
1199 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest051, TestSize.Level0)
1200 {
1201 HcfVerify *verify = nullptr;
1202 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1203
1204 ASSERT_EQ(res, HCF_SUCCESS);
1205 ASSERT_NE(verify, nullptr);
1206
1207 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1208 ASSERT_EQ(res, HCF_SUCCESS);
1209
1210 int32_t saltlen = 0;
1211 res = verify->setVerifySpecInt(verify, PSS_SALT_LEN_INT, saltlen);
1212
1213 ASSERT_EQ(res, HCF_NOT_SUPPORT);
1214
1215 HcfObjDestroy(verify);
1216 }
1217
1218 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest052, TestSize.Level0)
1219 {
1220 HcfVerify *verify = nullptr;
1221 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1222
1223 ASSERT_EQ(res, HCF_SUCCESS);
1224 ASSERT_NE(verify, nullptr);
1225
1226 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1227 ASSERT_EQ(res, HCF_SUCCESS);
1228
1229 int32_t *returnInt = nullptr;
1230 res = verify->getVerifySpecInt(verify, PSS_SALT_LEN_INT, returnInt);
1231
1232 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1233
1234 HcfObjDestroy(verify);
1235 }
1236
1237 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest053, TestSize.Level0)
1238 {
1239 HcfVerify *verify = nullptr;
1240 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1241
1242 ASSERT_EQ(res, HCF_SUCCESS);
1243 ASSERT_NE(verify, nullptr);
1244
1245 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1246 ASSERT_EQ(res, HCF_SUCCESS);
1247
1248 int32_t returnInt = 0;
1249 res = verify->getVerifySpecInt(verify, PSS_SALT_LEN_INT, &returnInt);
1250
1251 ASSERT_EQ(res, HCF_NOT_SUPPORT);
1252
1253 HcfObjDestroy(verify);
1254 }
1255
1256 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest054, TestSize.Level0)
1257 {
1258 HcfVerify *verify = nullptr;
1259 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1260
1261 ASSERT_EQ(res, HCF_SUCCESS);
1262 ASSERT_NE(verify, nullptr);
1263
1264 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1265 ASSERT_EQ(res, HCF_SUCCESS);
1266
1267 char *returnStr = nullptr;
1268 res = verify->getVerifySpecString(verify, SM2_USER_ID_UINT8ARR, &returnStr);
1269
1270 ASSERT_EQ(res, HCF_NOT_SUPPORT);
1271
1272 HcfObjDestroy(verify);
1273 }
1274
1275 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest055, TestSize.Level0)
1276 {
1277 HcfVerify *verify = nullptr;
1278 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1279
1280 ASSERT_EQ(res, HCF_SUCCESS);
1281 ASSERT_NE(verify, nullptr);
1282
1283 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1284 ASSERT_EQ(res, HCF_SUCCESS);
1285
1286 res = verify->getVerifySpecString(verify, SM2_USER_ID_UINT8ARR, nullptr);
1287
1288 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1289
1290 HcfObjDestroy(verify);
1291 }
1292
1293 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest056, TestSize.Level0)
1294 {
1295 HcfVerify *verify = nullptr;
1296 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1297
1298 ASSERT_EQ(res, HCF_SUCCESS);
1299 ASSERT_NE(verify, nullptr);
1300
1301 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1302 ASSERT_EQ(res, HCF_SUCCESS);
1303
1304 char *returnStr = nullptr;
1305 res = verify->getVerifySpecString(nullptr, SM2_USER_ID_UINT8ARR, &returnStr);
1306
1307 ASSERT_NE(res, HCF_SUCCESS);
1308
1309 HcfObjDestroy(verify);
1310 }
1311
1312 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest057, TestSize.Level0)
1313 {
1314 HcfVerify *verify = nullptr;
1315 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1316
1317 ASSERT_EQ(res, HCF_SUCCESS);
1318 ASSERT_NE(verify, nullptr);
1319
1320 res = verify->init(verify, nullptr, g_sm2256KeyPair_->pubKey);
1321 ASSERT_EQ(res, HCF_SUCCESS);
1322
1323 char *returnStr = nullptr;
1324 res = verify->getVerifySpecString(verify, PSS_MD_NAME_STR, &returnStr);
1325
1326 ASSERT_EQ(res, HCF_NOT_SUPPORT);
1327
1328 HcfObjDestroy(verify);
1329 }
1330
1331 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest058, TestSize.Level0)
1332 {
1333 HcfSignatureParams params = {
1334 .algo = HCF_ALG_SM2,
1335 .md = HCF_OPENSSL_DIGEST_SM3,
1336 };
1337 HcfVerifySpi *spiObj = nullptr;
1338 int32_t res = HcfVerifySpiSm2Create(¶ms, &spiObj);
1339
1340 ASSERT_EQ(res, HCF_SUCCESS);
1341 ASSERT_NE(spiObj, nullptr);
1342 uint8_t pSourceData[] = "1234567812345678\0";
1343 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1344 res = spiObj->engineSetVerifySpecUint8Array(nullptr, SM2_USER_ID_UINT8ARR, pSource);
1345 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1346
1347 HcfObjDestroy(spiObj);
1348 }
1349
1350 // Test verify signData from third-Party
1351 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest059, TestSize.Level0)
1352 {
1353 uint8_t pk[] = {
1354 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A,
1355 0x81, 0x1C, 0xCF, 0x55, 0x01, 0x82, 0x2D, 0x03, 0x42, 0x00, 0x04, 0x5A, 0x98, 0xC1, 0x3F, 0x5F,
1356 0xFF, 0x09, 0x42, 0xAB, 0x56, 0xCF, 0x79, 0x92, 0x50, 0x90, 0xB3, 0x7A, 0x48, 0x79, 0x62, 0xBA,
1357 0xCD, 0x3B, 0xA9, 0xE4, 0xA9, 0x7E, 0x44, 0x51, 0x39, 0xFF, 0x2D, 0xB1, 0xCF, 0x80, 0xA9, 0x12,
1358 0x02, 0x28, 0x09, 0x27, 0x8D, 0x98, 0xC4, 0x0F, 0xEF, 0x46, 0x65, 0x53, 0xD8, 0x86, 0x18, 0xF2,
1359 0x4B, 0x7E, 0x16, 0xE2, 0x63, 0xFB, 0x1E, 0xA8, 0x83, 0x88, 0xEE
1360 };
1361
1362 uint8_t signData[] = {
1363 0x30, 0x45, 0x02, 0x21, 0x00, 0xC2, 0x6E, 0x69, 0x1B, 0xBB, 0xB0, 0xEF, 0xB7, 0x29, 0xB5, 0x37,
1364 0x57, 0x6E, 0xDA, 0x1E, 0x67, 0x84, 0x9C, 0xD7, 0x00, 0x2E, 0x01, 0x85, 0x11, 0x54, 0xC3, 0x1A,
1365 0x58, 0xC6, 0xA9, 0x71, 0xEA, 0x02, 0x20, 0x7E, 0xB3, 0x76, 0x27, 0x84, 0x4F, 0x31, 0x1D, 0x64,
1366 0x71, 0xD7, 0xFE, 0x96, 0xD1, 0x5A, 0x83, 0xA0, 0x89, 0xC6, 0x3B, 0x84, 0xB6, 0x26, 0x88, 0x2A,
1367 0xF0, 0x71, 0x17, 0x6F, 0x06, 0x28, 0x11
1368 };
1369 const char *plainText = "hello world";
1370 HcfBlob plainTextBlob = { .data = (uint8_t *)plainText, strlen(plainText) };
1371 HcfBlob pubKey = { .data = pk, .len = 91 };
1372 HcfBlob signDataBlob = { .data = signData, .len = 71};
1373
1374 HcfAsyKeyGenerator *generator = nullptr;
1375 int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1376 HcfKeyPair *outKeyPair = nullptr;
1377 res = generator->convertKey(generator, nullptr, &pubKey, nullptr, &outKeyPair);
1378 ASSERT_EQ(res, HCF_SUCCESS);
1379 ASSERT_NE(outKeyPair, nullptr);
1380 HcfObjDestroy(generator);
1381
1382 HcfVerify *verify = nullptr;
1383 res = HcfVerifyCreate("SM2|SM3", &verify);
1384 ASSERT_EQ(res, HCF_SUCCESS);
1385 ASSERT_NE(verify, nullptr);
1386
1387 res = verify->init(verify, nullptr, outKeyPair->pubKey);
1388 ASSERT_EQ(res, HCF_SUCCESS);
1389
1390 res = verify->update(verify, &plainTextBlob);
1391 ASSERT_EQ(res, HCF_SUCCESS);
1392
1393 bool flag = verify->verify(verify, nullptr, &signDataBlob);
1394 ASSERT_EQ(flag, true);
1395 HcfObjDestroy(verify);
1396 HcfObjDestroy(outKeyPair);
1397 }
1398 }
1399