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 *sm2256KeyPair_;
40 };
41
42 HcfKeyPair *CryptoSm2VerifyTest::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 sm2256KeyPair_ = keyPair;
66
67 HcfObjDestroy(generator);
68 }
69
TearDownTestCase()70 void CryptoSm2VerifyTest::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
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, CryptoSm2VerifyTest016, 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, sm2256KeyPair_->pubKey);
249
250 ASSERT_EQ(res, HCF_SUCCESS);
251
252 HcfObjDestroy(verify);
253 }
254
255 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest017, 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, sm2256KeyPair_->pubKey);
264
265 ASSERT_EQ(res, HCF_INVALID_PARAMS);
266
267 HcfObjDestroy(verify);
268 }
269
270 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest019, 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, sm2256KeyPair_->pubKey);
279
280 ASSERT_EQ(res, HCF_SUCCESS);
281
282 res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey);
283
284 ASSERT_EQ(res, HCF_INVALID_PARAMS);
285
286 HcfObjDestroy(verify);
287 }
288
289 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest020, 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, CryptoSm2VerifyTest022, 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, 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, CryptoSm2VerifyTest023, 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, 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, CryptoSm2VerifyTest025, 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, CryptoSm2VerifyTest026, 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, 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, CryptoSm2VerifyTest027, 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, 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, CryptoSm2VerifyTest028, 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, 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, CryptoSm2VerifyTest029, 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, 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, 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 free(out.data);
464 HcfObjDestroy(sign);
465 HcfObjDestroy(verify);
466 }
467
468 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest030, 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, 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, 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 free(out.data);
502 HcfObjDestroy(sign);
503 HcfObjDestroy(verify);
504 }
505
506 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest031, 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, 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, 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 free(out.data);
548 HcfObjDestroy(sign);
549 HcfObjDestroy(verify);
550 }
551
552 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest032, 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, 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, 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 free(out.data);
594 HcfObjDestroy(sign);
595 HcfObjDestroy(verify);
596 }
597
598 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest033, 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, 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, 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 free(out.data);
636 HcfObjDestroy(sign);
637 HcfObjDestroy(verify);
638 }
639
640 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest034, 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, 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, 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 free(out.data);
682 HcfObjDestroy(sign);
683 HcfObjDestroy(verify);
684 }
685
686 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest035, 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, 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, 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 free(out.data);
728 HcfObjDestroy(sign);
729 HcfObjDestroy(verify);
730 }
731
732 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest036, 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, 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, CryptoSm2VerifyTest037, 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, 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, CryptoSm2VerifyTest038, 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, 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, CryptoSm2VerifyTest039, 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, CryptoSm2VerifyTest040, 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, CryptoSm2VerifyTest043, 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, CryptoSm2VerifyTest045, 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, CryptoSm2VerifyTest046, 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, CryptoSm2VerifyTest048, 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::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::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, CryptoSm2VerifyTest050, 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, 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::sm2256KeyPair_->pubKey);
999 if (res != HCF_SUCCESS) {
1000 HcfObjDestroy(verify);
1001 continue;
1002 }
1003 res = verify->update(verify, &g_mockInput);
1004 if (res != HCF_SUCCESS) {
1005 HcfObjDestroy(verify);
1006 continue;
1007 }
1008 (void)verify->verify(verify, &g_mockInput, out);
1009 HcfObjDestroy(verify);
1010 }
1011 }
1012
1013 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest051, TestSize.Level0)
1014 {
1015 HcfBlob out = { .data = nullptr, .len = 0 };
1016 ASSERT_EQ(GetSignTestData(&out), true);
1017 StartRecordOpensslCallNum();
1018
1019 HcfVerify *verify = nullptr;
1020 int32_t res = HcfVerifyCreate("SM2|SM3", &verify);
1021
1022 ASSERT_EQ(res, HCF_SUCCESS);
1023 ASSERT_NE(verify, nullptr);
1024
1025 res = verify->init(verify, nullptr, sm2256KeyPair_->pubKey);
1026
1027 ASSERT_EQ(res, HCF_SUCCESS);
1028
1029 res = verify->update(verify, &g_mockInput);
1030
1031 ASSERT_EQ(res, HCF_SUCCESS);
1032
1033 bool flag = verify->verify(verify, &g_mockInput, &out);
1034
1035 ASSERT_EQ(flag, true);
1036 HcfObjDestroy(verify);
1037
1038 uint32_t mallocCount = GetOpensslCallNum();
1039 OpensslMockTestFunc(mallocCount, &out);
1040 EndRecordOpensslCallNum();
1041 }
1042
1043 // Test verify signData from third-Party
1044 HWTEST_F(CryptoSm2VerifyTest, CryptoSm2VerifyTest052, TestSize.Level0)
1045 {
1046 uint8_t pk[] = {
1047 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A,
1048 0x81, 0x1C, 0xCF, 0x55, 0x01, 0x82, 0x2D, 0x03, 0x42, 0x00, 0x04, 0x5A, 0x98, 0xC1, 0x3F, 0x5F,
1049 0xFF, 0x09, 0x42, 0xAB, 0x56, 0xCF, 0x79, 0x92, 0x50, 0x90, 0xB3, 0x7A, 0x48, 0x79, 0x62, 0xBA,
1050 0xCD, 0x3B, 0xA9, 0xE4, 0xA9, 0x7E, 0x44, 0x51, 0x39, 0xFF, 0x2D, 0xB1, 0xCF, 0x80, 0xA9, 0x12,
1051 0x02, 0x28, 0x09, 0x27, 0x8D, 0x98, 0xC4, 0x0F, 0xEF, 0x46, 0x65, 0x53, 0xD8, 0x86, 0x18, 0xF2,
1052 0x4B, 0x7E, 0x16, 0xE2, 0x63, 0xFB, 0x1E, 0xA8, 0x83, 0x88, 0xEE
1053 };
1054
1055 uint8_t signData[] = {
1056 0x30, 0x45, 0x02, 0x21, 0x00, 0xC2, 0x6E, 0x69, 0x1B, 0xBB, 0xB0, 0xEF, 0xB7, 0x29, 0xB5, 0x37,
1057 0x57, 0x6E, 0xDA, 0x1E, 0x67, 0x84, 0x9C, 0xD7, 0x00, 0x2E, 0x01, 0x85, 0x11, 0x54, 0xC3, 0x1A,
1058 0x58, 0xC6, 0xA9, 0x71, 0xEA, 0x02, 0x20, 0x7E, 0xB3, 0x76, 0x27, 0x84, 0x4F, 0x31, 0x1D, 0x64,
1059 0x71, 0xD7, 0xFE, 0x96, 0xD1, 0x5A, 0x83, 0xA0, 0x89, 0xC6, 0x3B, 0x84, 0xB6, 0x26, 0x88, 0x2A,
1060 0xF0, 0x71, 0x17, 0x6F, 0x06, 0x28, 0x11
1061 };
1062 const char *plainText = "hello world";
1063 HcfBlob plainTextBlob = { .data = (uint8_t *)plainText, strlen(plainText) };
1064 HcfBlob pubKey = { .data = pk, .len = 91 };
1065 HcfBlob signDataBlob = { .data = signData, .len = 71};
1066
1067 HcfAsyKeyGenerator *generator = nullptr;
1068 int32_t res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1069 HcfKeyPair *outKeyPair = nullptr;
1070 res = generator->convertKey(generator, nullptr, &pubKey, nullptr, &outKeyPair);
1071 ASSERT_EQ(res, HCF_SUCCESS);
1072 ASSERT_NE(outKeyPair, nullptr);
1073 HcfObjDestroy(generator);
1074
1075 HcfVerify *verify = nullptr;
1076 res = HcfVerifyCreate("SM2|SM3", &verify);
1077 ASSERT_EQ(res, HCF_SUCCESS);
1078 ASSERT_NE(verify, nullptr);
1079
1080 res = verify->init(verify, nullptr, outKeyPair->pubKey);
1081 ASSERT_EQ(res, HCF_SUCCESS);
1082
1083 res = verify->update(verify, &plainTextBlob);
1084 ASSERT_EQ(res, HCF_SUCCESS);
1085
1086 bool flag = verify->verify(verify, nullptr, &signDataBlob);
1087 ASSERT_EQ(flag, true);
1088 HcfObjDestroy(verify);
1089 HcfObjDestroy(outKeyPair);
1090 }
1091 }
1092