1 /*
2 * Copyright (C) 2022-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 "ecdsa_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 static string eccSecp256k1PriKey = "-----BEGIN EC PRIVATE KEY-----\n"
32 "MHQCAQEEIIlLPqrfBGECZ65uHJTzZIjFipExXkecVOQnOggDaNXfoAcGBSuBBAAK\n"
33 "oUQDQgAEkgV8IqJK1j4GpX8+yXy+Rqx+SLB+bOJ1uCCTyoz/4RyMYC+xHS0klwV2\n"
34 "xHI1vy8cakfczw/yK4GYfm8a3OXKIA==\n"
35 "-----END EC PRIVATE KEY-----\n";
36
37 static string eccSecp256k1PubKey = "-----BEGIN PUBLIC KEY-----\n"
38 "MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEkgV8IqJK1j4GpX8+yXy+Rqx+SLB+bOJ1\n"
39 "uCCTyoz/4RyMYC+xHS0klwV2xHI1vy8cakfczw/yK4GYfm8a3OXKIA==\n"
40 "-----END PUBLIC KEY-----\n";
41
42 static uint8_t sig[] = {0x30, 0x44, 0x02, 0x20, 0x0F, 0xC8, 0xD8, 0x71, 0xE2, 0x61, 0x36, 0xA1, 0x07, 0x57, 0xDB, 0x00,
43 0xE7, 0x89, 0x98, 0x95, 0xC7, 0xFF, 0x70, 0x71, 0xDD, 0x39, 0x82, 0x61, 0x0D, 0x71, 0xD3, 0x5E,
44 0xB9, 0x36, 0x70, 0xDE, 0x02, 0x20, 0x54, 0xA9, 0x93, 0x6E, 0x14, 0xCC, 0x06, 0x4D, 0xD8, 0x42,
45 0x51, 0x93, 0x47, 0x23, 0x9E, 0x6A, 0xA0, 0xD9, 0x8A, 0x4A, 0xA1, 0x74, 0x47, 0x83, 0xE3, 0xEF,
46 0x07, 0x0B, 0x50, 0x9E, 0x43, 0x27};
47
48 static const char *g_message = "hello world";
49 static HcfBlob input = {
50 .data = (uint8_t *)g_message,
51 .len = 11
52 };
53
54 namespace {
55 class CryptoEccVerifyTest : public testing::Test {
56 public:
57 static void SetUpTestCase();
58 static void TearDownTestCase();
59 void SetUp();
60 void TearDown();
61
62 static HcfKeyPair *ecc224KeyPair_;
63 static HcfKeyPair *ecc256KeyPair_;
64 static HcfKeyPair *ecc384KeyPair_;
65 static HcfKeyPair *ecc521KeyPair_;
66 };
67
68 HcfKeyPair *CryptoEccVerifyTest::ecc224KeyPair_ = nullptr;
69 HcfKeyPair *CryptoEccVerifyTest::ecc256KeyPair_ = nullptr;
70 HcfKeyPair *CryptoEccVerifyTest::ecc384KeyPair_ = nullptr;
71 HcfKeyPair *CryptoEccVerifyTest::ecc521KeyPair_ = nullptr;
72
73 static const char *g_mockMessage = "hello world";
74 static HcfBlob g_mockInput = {
75 .data = (uint8_t *)g_mockMessage,
76 .len = 12
77 };
78
SetUp()79 void CryptoEccVerifyTest::SetUp() {}
TearDown()80 void CryptoEccVerifyTest::TearDown() {}
81
SetUpTestCase()82 void CryptoEccVerifyTest::SetUpTestCase()
83 {
84 HcfAsyKeyGenerator *generator = nullptr;
85 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
86 ASSERT_EQ(res, HCF_SUCCESS);
87 ASSERT_NE(generator, nullptr);
88
89 HcfKeyPair *keyPair = nullptr;
90 res = generator->generateKeyPair(generator, nullptr, &keyPair);
91 ASSERT_EQ(res, HCF_SUCCESS);
92 ASSERT_NE(keyPair, nullptr);
93
94 ecc224KeyPair_ = keyPair;
95
96 HcfObjDestroy(generator);
97
98 HcfAsyKeyGenerator *generator2 = nullptr;
99 res = HcfAsyKeyGeneratorCreate("ECC256", &generator2);
100 ASSERT_EQ(res, HCF_SUCCESS);
101 ASSERT_NE(generator2, nullptr);
102
103 HcfKeyPair *keyPair2 = nullptr;
104 res = generator2->generateKeyPair(generator2, nullptr, &keyPair2);
105 ASSERT_EQ(res, HCF_SUCCESS);
106 ASSERT_NE(keyPair2, nullptr);
107
108 ecc256KeyPair_ = keyPair2;
109
110 HcfObjDestroy(generator2);
111
112 HcfAsyKeyGenerator *generator3 = nullptr;
113 res = HcfAsyKeyGeneratorCreate("ECC384", &generator3);
114 ASSERT_EQ(res, HCF_SUCCESS);
115 ASSERT_NE(generator3, nullptr);
116
117 HcfKeyPair *keyPair3 = nullptr;
118 res = generator3->generateKeyPair(generator3, nullptr, &keyPair3);
119 ASSERT_EQ(res, HCF_SUCCESS);
120 ASSERT_NE(keyPair3, nullptr);
121
122 ecc384KeyPair_ = keyPair3;
123
124 HcfObjDestroy(generator3);
125
126 HcfAsyKeyGenerator *generator4 = nullptr;
127 res = HcfAsyKeyGeneratorCreate("ECC521", &generator4);
128 ASSERT_EQ(res, HCF_SUCCESS);
129 ASSERT_NE(generator4, nullptr);
130
131 HcfKeyPair *keyPair4 = nullptr;
132 res = generator4->generateKeyPair(generator4, nullptr, &keyPair4);
133 ASSERT_EQ(res, HCF_SUCCESS);
134 ASSERT_NE(keyPair4, nullptr);
135
136 ecc521KeyPair_ = keyPair4;
137
138 HcfObjDestroy(generator4);
139 }
140
TearDownTestCase()141 void CryptoEccVerifyTest::TearDownTestCase()
142 {
143 HcfObjDestroy(ecc224KeyPair_);
144 HcfObjDestroy(ecc256KeyPair_);
145 HcfObjDestroy(ecc384KeyPair_);
146 HcfObjDestroy(ecc521KeyPair_);
147 }
148
GetMockClass(void)149 static const char *GetMockClass(void)
150 {
151 return "HcfMock";
152 }
153
154 static HcfObjectBase obj = {
155 .getClass = GetMockClass,
156 .destroy = nullptr
157 };
158
159 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest001, TestSize.Level0)
160 {
161 HcfVerify *verify = nullptr;
162 int32_t res = HcfVerifyCreate("ECC224|SHA1", &verify);
163
164 ASSERT_EQ(res, HCF_SUCCESS);
165 ASSERT_NE(verify, nullptr);
166
167 HcfObjDestroy(verify);
168 }
169
170 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest002, TestSize.Level0)
171 {
172 HcfVerify *verify = nullptr;
173 int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify);
174
175 ASSERT_EQ(res, HCF_SUCCESS);
176 ASSERT_NE(verify, nullptr);
177
178 HcfObjDestroy(verify);
179 }
180
181 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest003, TestSize.Level0)
182 {
183 HcfVerify *verify = nullptr;
184 int32_t res = HcfVerifyCreate("ECC224|SHA256", &verify);
185
186 ASSERT_EQ(res, HCF_SUCCESS);
187 ASSERT_NE(verify, nullptr);
188
189 HcfObjDestroy(verify);
190 }
191
192 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest004, TestSize.Level0)
193 {
194 HcfVerify *verify = nullptr;
195 int32_t res = HcfVerifyCreate("ECC224|SHA384", &verify);
196
197 ASSERT_EQ(res, HCF_SUCCESS);
198 ASSERT_NE(verify, nullptr);
199
200 HcfObjDestroy(verify);
201 }
202
203 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest005, TestSize.Level0)
204 {
205 HcfVerify *verify = nullptr;
206 int32_t res = HcfVerifyCreate("ECC224|SHA512", &verify);
207
208 ASSERT_EQ(res, HCF_SUCCESS);
209 ASSERT_NE(verify, nullptr);
210
211 HcfObjDestroy(verify);
212 }
213
214 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest006, TestSize.Level0)
215 {
216 HcfVerify *verify = nullptr;
217 int32_t res = HcfVerifyCreate("ECC256|SHA1", &verify);
218
219 ASSERT_EQ(res, HCF_SUCCESS);
220 ASSERT_NE(verify, nullptr);
221
222 HcfObjDestroy(verify);
223 }
224
225 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest007, TestSize.Level0)
226 {
227 HcfVerify *verify = nullptr;
228 int32_t res = HcfVerifyCreate("ECC256|SHA224", &verify);
229
230 ASSERT_EQ(res, HCF_SUCCESS);
231 ASSERT_NE(verify, nullptr);
232
233 HcfObjDestroy(verify);
234 }
235
236 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest008, TestSize.Level0)
237 {
238 HcfVerify *verify = nullptr;
239 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
240
241 ASSERT_EQ(res, HCF_SUCCESS);
242 ASSERT_NE(verify, nullptr);
243
244 HcfObjDestroy(verify);
245 }
246
247 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest009, TestSize.Level0)
248 {
249 HcfVerify *verify = nullptr;
250 int32_t res = HcfVerifyCreate("ECC256|SHA384", &verify);
251
252 ASSERT_EQ(res, HCF_SUCCESS);
253 ASSERT_NE(verify, nullptr);
254
255 HcfObjDestroy(verify);
256 }
257
258 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest010, TestSize.Level0)
259 {
260 HcfVerify *verify = nullptr;
261 int32_t res = HcfVerifyCreate("ECC256|SHA512", &verify);
262
263 ASSERT_EQ(res, HCF_SUCCESS);
264 ASSERT_NE(verify, nullptr);
265
266 HcfObjDestroy(verify);
267 }
268
269 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest011, TestSize.Level0)
270 {
271 HcfVerify *verify = nullptr;
272 int32_t res = HcfVerifyCreate("ECC384|SHA1", &verify);
273
274 ASSERT_EQ(res, HCF_SUCCESS);
275 ASSERT_NE(verify, nullptr);
276
277 HcfObjDestroy(verify);
278 }
279
280 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest012, TestSize.Level0)
281 {
282 HcfVerify *verify = nullptr;
283 int32_t res = HcfVerifyCreate("ECC384|SHA224", &verify);
284
285 ASSERT_EQ(res, HCF_SUCCESS);
286 ASSERT_NE(verify, nullptr);
287
288 HcfObjDestroy(verify);
289 }
290
291 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest013, TestSize.Level0)
292 {
293 HcfVerify *verify = nullptr;
294 int32_t res = HcfVerifyCreate("ECC384|SHA256", &verify);
295
296 ASSERT_EQ(res, HCF_SUCCESS);
297 ASSERT_NE(verify, nullptr);
298
299 HcfObjDestroy(verify);
300 }
301
302 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest014, TestSize.Level0)
303 {
304 HcfVerify *verify = nullptr;
305 int32_t res = HcfVerifyCreate("ECC384|SHA384", &verify);
306
307 ASSERT_EQ(res, HCF_SUCCESS);
308 ASSERT_NE(verify, nullptr);
309
310 HcfObjDestroy(verify);
311 }
312
313 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest015, TestSize.Level0)
314 {
315 HcfVerify *verify = nullptr;
316 int32_t res = HcfVerifyCreate("ECC384|SHA512", &verify);
317
318 ASSERT_EQ(res, HCF_SUCCESS);
319 ASSERT_NE(verify, nullptr);
320
321 HcfObjDestroy(verify);
322 }
323
324 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest016, TestSize.Level0)
325 {
326 HcfVerify *verify = nullptr;
327 int32_t res = HcfVerifyCreate("ECC521|SHA1", &verify);
328
329 ASSERT_EQ(res, HCF_SUCCESS);
330 ASSERT_NE(verify, nullptr);
331
332 HcfObjDestroy(verify);
333 }
334
335 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest017, TestSize.Level0)
336 {
337 HcfVerify *verify = nullptr;
338 int32_t res = HcfVerifyCreate("ECC521|SHA224", &verify);
339
340 ASSERT_EQ(res, HCF_SUCCESS);
341 ASSERT_NE(verify, nullptr);
342
343 HcfObjDestroy(verify);
344 }
345
346 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest018, TestSize.Level0)
347 {
348 HcfVerify *verify = nullptr;
349 int32_t res = HcfVerifyCreate("ECC521|SHA256", &verify);
350
351 ASSERT_EQ(res, HCF_SUCCESS);
352 ASSERT_NE(verify, nullptr);
353
354 HcfObjDestroy(verify);
355 }
356
357 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest019, TestSize.Level0)
358 {
359 HcfVerify *verify = nullptr;
360 int32_t res = HcfVerifyCreate("ECC521|SHA384", &verify);
361
362 ASSERT_EQ(res, HCF_SUCCESS);
363 ASSERT_NE(verify, nullptr);
364
365 HcfObjDestroy(verify);
366 }
367
368 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest020, TestSize.Level0)
369 {
370 HcfVerify *verify = nullptr;
371 int32_t res = HcfVerifyCreate("ECC521|SHA512", &verify);
372
373 ASSERT_EQ(res, HCF_SUCCESS);
374 ASSERT_NE(verify, nullptr);
375
376 HcfObjDestroy(verify);
377 }
378
379 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest021, TestSize.Level0)
380 {
381 HcfVerify *verify = nullptr;
382 int32_t res = HcfVerifyCreate(nullptr, &verify);
383
384 ASSERT_EQ(res, HCF_INVALID_PARAMS);
385 ASSERT_EQ(verify, nullptr);
386 }
387
388 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest022, TestSize.Level0)
389 {
390 HcfVerify *verify = nullptr;
391 int32_t res = HcfVerifyCreate("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD"
392 "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", &verify);
393
394 ASSERT_EQ(res, HCF_INVALID_PARAMS);
395 ASSERT_EQ(verify, nullptr);
396 }
397
398 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest023, TestSize.Level0)
399 {
400 HcfVerify *verify = nullptr;
401 int32_t res = HcfVerifyCreate("ECC257|SHA256", &verify);
402
403 ASSERT_NE(res, HCF_SUCCESS);
404 ASSERT_EQ(verify, nullptr);
405 }
406
407 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest024, TestSize.Level0)
408 {
409 HcfVerify *verify = nullptr;
410 int32_t res = HcfVerifyCreate("ECC256|SHA257", &verify);
411
412 ASSERT_NE(res, HCF_SUCCESS);
413 ASSERT_EQ(verify, nullptr);
414 }
415
416 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest025, TestSize.Level0)
417 {
418 HcfVerify *verify = nullptr;
419 int32_t res = HcfVerifyCreate("ECC256|MD5", &verify);
420
421 ASSERT_NE(res, HCF_SUCCESS);
422 ASSERT_EQ(verify, nullptr);
423 }
424
425 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest026, TestSize.Level0)
426 {
427 HcfVerify *verify = nullptr;
428 int32_t res = HcfVerifyCreate("ECC256SHA256", &verify);
429
430 ASSERT_NE(res, HCF_SUCCESS);
431 ASSERT_EQ(verify, nullptr);
432 }
433
434 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest027, TestSize.Level0)
435 {
436 int32_t res = HcfVerifyCreate("ECC256|SHA256", nullptr);
437
438 ASSERT_EQ(res, HCF_INVALID_PARAMS);
439 }
440
441 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest101, TestSize.Level0)
442 {
443 HcfVerify *verify = nullptr;
444 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
445
446 ASSERT_EQ(res, HCF_SUCCESS);
447 ASSERT_NE(verify, nullptr);
448
449 const char *className = verify->base.getClass();
450
451 ASSERT_NE(className, nullptr);
452
453 HcfObjDestroy(verify);
454 }
455
456 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest102, TestSize.Level0)
457 {
458 HcfVerify *verify = nullptr;
459 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
460
461 ASSERT_EQ(res, HCF_SUCCESS);
462 ASSERT_NE(verify, nullptr);
463
464 verify->base.destroy((HcfObjectBase *)verify);
465 }
466
467 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest103, TestSize.Level0)
468 {
469 HcfVerify *verify = nullptr;
470 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
471
472 ASSERT_EQ(res, HCF_SUCCESS);
473 ASSERT_NE(verify, nullptr);
474
475 verify->base.destroy(nullptr);
476
477 HcfObjDestroy(verify);
478 }
479
480 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest104, TestSize.Level0)
481 {
482 HcfVerify *verify = nullptr;
483 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
484
485 ASSERT_EQ(res, HCF_SUCCESS);
486 ASSERT_NE(verify, nullptr);
487
488 verify->base.destroy(&obj);
489
490 HcfObjDestroy(verify);
491 }
492
493 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest105, TestSize.Level0)
494 {
495 HcfVerify *verify = nullptr;
496 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
497
498 ASSERT_EQ(res, HCF_SUCCESS);
499 ASSERT_NE(verify, nullptr);
500
501 const char *algName = verify->getAlgoName(verify);
502
503 ASSERT_NE(algName, nullptr);
504
505 HcfObjDestroy(verify);
506 }
507
508 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest106, TestSize.Level0)
509 {
510 HcfVerify *verify = nullptr;
511 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
512
513 ASSERT_EQ(res, HCF_SUCCESS);
514 ASSERT_NE(verify, nullptr);
515
516 const char *algName = verify->getAlgoName(nullptr);
517
518 ASSERT_EQ(algName, nullptr);
519
520 HcfObjDestroy(verify);
521 }
522
523 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest107, TestSize.Level0)
524 {
525 HcfVerify *verify = nullptr;
526 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
527
528 ASSERT_EQ(res, HCF_SUCCESS);
529 ASSERT_NE(verify, nullptr);
530
531 const char *algName = verify->getAlgoName((HcfVerify *)(&obj));
532
533 ASSERT_EQ(algName, nullptr);
534
535 HcfObjDestroy(verify);
536 }
537
538 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest201, TestSize.Level0)
539 {
540 HcfVerify *verify = nullptr;
541 int32_t res = HcfVerifyCreate("ECC224|SHA1", &verify);
542
543 ASSERT_EQ(res, HCF_SUCCESS);
544 ASSERT_NE(verify, nullptr);
545
546 res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
547
548 ASSERT_EQ(res, HCF_SUCCESS);
549
550 HcfObjDestroy(verify);
551 }
552
553 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest202, TestSize.Level0)
554 {
555 HcfVerify *verify = nullptr;
556 int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify);
557
558 ASSERT_EQ(res, HCF_SUCCESS);
559 ASSERT_NE(verify, nullptr);
560
561 res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
562
563 ASSERT_EQ(res, HCF_SUCCESS);
564
565 HcfObjDestroy(verify);
566 }
567
568 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest203, TestSize.Level0)
569 {
570 HcfVerify *verify = nullptr;
571 int32_t res = HcfVerifyCreate("ECC224|SHA256", &verify);
572
573 ASSERT_EQ(res, HCF_SUCCESS);
574 ASSERT_NE(verify, nullptr);
575
576 res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
577
578 ASSERT_EQ(res, HCF_SUCCESS);
579
580 HcfObjDestroy(verify);
581 }
582
583 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest204, TestSize.Level0)
584 {
585 HcfVerify *verify = nullptr;
586 int32_t res = HcfVerifyCreate("ECC224|SHA384", &verify);
587
588 ASSERT_EQ(res, HCF_SUCCESS);
589 ASSERT_NE(verify, nullptr);
590
591 res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
592
593 ASSERT_EQ(res, HCF_SUCCESS);
594
595 HcfObjDestroy(verify);
596 }
597
598 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest205, TestSize.Level0)
599 {
600 HcfVerify *verify = nullptr;
601 int32_t res = HcfVerifyCreate("ECC224|SHA512", &verify);
602
603 ASSERT_EQ(res, HCF_SUCCESS);
604 ASSERT_NE(verify, nullptr);
605
606 res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
607
608 ASSERT_EQ(res, HCF_SUCCESS);
609
610 HcfObjDestroy(verify);
611 }
612
613 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest206, TestSize.Level0)
614 {
615 HcfVerify *verify = nullptr;
616 int32_t res = HcfVerifyCreate("ECC256|SHA1", &verify);
617
618 ASSERT_EQ(res, HCF_SUCCESS);
619 ASSERT_NE(verify, nullptr);
620
621 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
622
623 ASSERT_EQ(res, HCF_SUCCESS);
624
625 HcfObjDestroy(verify);
626 }
627
628 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest207, TestSize.Level0)
629 {
630 HcfVerify *verify = nullptr;
631 int32_t res = HcfVerifyCreate("ECC256|SHA224", &verify);
632
633 ASSERT_EQ(res, HCF_SUCCESS);
634 ASSERT_NE(verify, nullptr);
635
636 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
637
638 ASSERT_EQ(res, HCF_SUCCESS);
639
640 HcfObjDestroy(verify);
641 }
642
643 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest208, TestSize.Level0)
644 {
645 HcfVerify *verify = nullptr;
646 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
647
648 ASSERT_EQ(res, HCF_SUCCESS);
649 ASSERT_NE(verify, nullptr);
650
651 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
652
653 ASSERT_EQ(res, HCF_SUCCESS);
654
655 HcfObjDestroy(verify);
656 }
657
658 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest209, TestSize.Level0)
659 {
660 HcfVerify *verify = nullptr;
661 int32_t res = HcfVerifyCreate("ECC256|SHA384", &verify);
662
663 ASSERT_EQ(res, HCF_SUCCESS);
664 ASSERT_NE(verify, nullptr);
665
666 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
667
668 ASSERT_EQ(res, HCF_SUCCESS);
669
670 HcfObjDestroy(verify);
671 }
672
673 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest210, TestSize.Level0)
674 {
675 HcfVerify *verify = nullptr;
676 int32_t res = HcfVerifyCreate("ECC256|SHA512", &verify);
677
678 ASSERT_EQ(res, HCF_SUCCESS);
679 ASSERT_NE(verify, nullptr);
680
681 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
682
683 ASSERT_EQ(res, HCF_SUCCESS);
684
685 HcfObjDestroy(verify);
686 }
687
688 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest211, TestSize.Level0)
689 {
690 HcfVerify *verify = nullptr;
691 int32_t res = HcfVerifyCreate("ECC384|SHA1", &verify);
692
693 ASSERT_EQ(res, HCF_SUCCESS);
694 ASSERT_NE(verify, nullptr);
695
696 res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
697
698 ASSERT_EQ(res, HCF_SUCCESS);
699
700 HcfObjDestroy(verify);
701 }
702
703 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest212, TestSize.Level0)
704 {
705 HcfVerify *verify = nullptr;
706 int32_t res = HcfVerifyCreate("ECC384|SHA224", &verify);
707
708 ASSERT_EQ(res, HCF_SUCCESS);
709 ASSERT_NE(verify, nullptr);
710
711 res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
712
713 ASSERT_EQ(res, HCF_SUCCESS);
714
715 HcfObjDestroy(verify);
716 }
717
718 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest213, TestSize.Level0)
719 {
720 HcfVerify *verify = nullptr;
721 int32_t res = HcfVerifyCreate("ECC384|SHA256", &verify);
722
723 ASSERT_EQ(res, HCF_SUCCESS);
724 ASSERT_NE(verify, nullptr);
725
726 res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
727
728 ASSERT_EQ(res, HCF_SUCCESS);
729
730 HcfObjDestroy(verify);
731 }
732
733 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest214, TestSize.Level0)
734 {
735 HcfVerify *verify = nullptr;
736 int32_t res = HcfVerifyCreate("ECC384|SHA384", &verify);
737
738 ASSERT_EQ(res, HCF_SUCCESS);
739 ASSERT_NE(verify, nullptr);
740
741 res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
742
743 ASSERT_EQ(res, HCF_SUCCESS);
744
745 HcfObjDestroy(verify);
746 }
747
748 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest215, TestSize.Level0)
749 {
750 HcfVerify *verify = nullptr;
751 int32_t res = HcfVerifyCreate("ECC384|SHA512", &verify);
752
753 ASSERT_EQ(res, HCF_SUCCESS);
754 ASSERT_NE(verify, nullptr);
755
756 res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
757
758 ASSERT_EQ(res, HCF_SUCCESS);
759
760 HcfObjDestroy(verify);
761 }
762
763 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest216, TestSize.Level0)
764 {
765 HcfVerify *verify = nullptr;
766 int32_t res = HcfVerifyCreate("ECC521|SHA1", &verify);
767
768 ASSERT_EQ(res, HCF_SUCCESS);
769 ASSERT_NE(verify, nullptr);
770
771 res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
772
773 ASSERT_EQ(res, HCF_SUCCESS);
774
775 HcfObjDestroy(verify);
776 }
777
778 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest217, TestSize.Level0)
779 {
780 HcfVerify *verify = nullptr;
781 int32_t res = HcfVerifyCreate("ECC521|SHA224", &verify);
782
783 ASSERT_EQ(res, HCF_SUCCESS);
784 ASSERT_NE(verify, nullptr);
785
786 res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
787
788 ASSERT_EQ(res, HCF_SUCCESS);
789
790 HcfObjDestroy(verify);
791 }
792
793 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest218, TestSize.Level0)
794 {
795 HcfVerify *verify = nullptr;
796 int32_t res = HcfVerifyCreate("ECC521|SHA256", &verify);
797
798 ASSERT_EQ(res, HCF_SUCCESS);
799 ASSERT_NE(verify, nullptr);
800
801 res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
802
803 ASSERT_EQ(res, HCF_SUCCESS);
804
805 HcfObjDestroy(verify);
806 }
807
808 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest219, TestSize.Level0)
809 {
810 HcfVerify *verify = nullptr;
811 int32_t res = HcfVerifyCreate("ECC521|SHA384", &verify);
812
813 ASSERT_EQ(res, HCF_SUCCESS);
814 ASSERT_NE(verify, nullptr);
815
816 res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
817
818 ASSERT_EQ(res, HCF_SUCCESS);
819
820 HcfObjDestroy(verify);
821 }
822
823 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest220, TestSize.Level0)
824 {
825 HcfVerify *verify = nullptr;
826 int32_t res = HcfVerifyCreate("ECC521|SHA512", &verify);
827
828 ASSERT_EQ(res, HCF_SUCCESS);
829 ASSERT_NE(verify, nullptr);
830
831 res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
832
833 ASSERT_EQ(res, HCF_SUCCESS);
834
835 HcfObjDestroy(verify);
836 }
837
838 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest221, TestSize.Level0)
839 {
840 HcfVerify *verify = nullptr;
841 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
842
843 ASSERT_EQ(res, HCF_SUCCESS);
844 ASSERT_NE(verify, nullptr);
845
846 res = verify->init(nullptr, nullptr, ecc256KeyPair_->pubKey);
847
848 ASSERT_EQ(res, HCF_INVALID_PARAMS);
849
850 HcfObjDestroy(verify);
851 }
852
853 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest222, TestSize.Level0)
854 {
855 HcfVerify *verify = nullptr;
856 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
857
858 ASSERT_EQ(res, HCF_SUCCESS);
859 ASSERT_NE(verify, nullptr);
860
861 res = verify->init((HcfVerify *)(&obj), nullptr, ecc256KeyPair_->pubKey);
862
863 ASSERT_EQ(res, HCF_INVALID_PARAMS);
864
865 HcfObjDestroy(verify);
866 }
867
868 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest223, TestSize.Level0)
869 {
870 HcfVerify *verify = nullptr;
871 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
872
873 ASSERT_EQ(res, HCF_SUCCESS);
874 ASSERT_NE(verify, nullptr);
875
876 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
877
878 ASSERT_EQ(res, HCF_SUCCESS);
879
880 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
881
882 ASSERT_EQ(res, HCF_INVALID_PARAMS);
883
884 HcfObjDestroy(verify);
885 }
886
887 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest224, TestSize.Level0)
888 {
889 HcfVerify *verify = nullptr;
890 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
891
892 ASSERT_EQ(res, HCF_SUCCESS);
893 ASSERT_NE(verify, nullptr);
894
895 res = verify->init(verify, nullptr, nullptr);
896
897 ASSERT_EQ(res, HCF_INVALID_PARAMS);
898
899 HcfObjDestroy(verify);
900 }
901
902 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest225, TestSize.Level0)
903 {
904 HcfVerify *verify = nullptr;
905 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
906
907 ASSERT_EQ(res, HCF_SUCCESS);
908 ASSERT_NE(verify, nullptr);
909
910 res = verify->init(verify, nullptr, (HcfPubKey *)(&obj));
911
912 ASSERT_EQ(res, HCF_INVALID_PARAMS);
913
914 HcfObjDestroy(verify);
915 }
916
917 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest301, TestSize.Level0)
918 {
919 HcfVerify *verify = nullptr;
920 int32_t res = HcfVerifyCreate("ECC224|SHA1", &verify);
921
922 ASSERT_EQ(res, HCF_SUCCESS);
923 ASSERT_NE(verify, nullptr);
924
925 res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
926
927 ASSERT_EQ(res, HCF_SUCCESS);
928
929 res = verify->update(verify, &g_mockInput);
930
931 ASSERT_EQ(res, HCF_SUCCESS);
932
933 HcfObjDestroy(verify);
934 }
935
936 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest302, TestSize.Level0)
937 {
938 HcfVerify *verify = nullptr;
939 int32_t res = HcfVerifyCreate("ECC224|SHA224", &verify);
940
941 ASSERT_EQ(res, HCF_SUCCESS);
942 ASSERT_NE(verify, nullptr);
943
944 res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
945
946 ASSERT_EQ(res, HCF_SUCCESS);
947
948 res = verify->update(verify, &g_mockInput);
949
950 ASSERT_EQ(res, HCF_SUCCESS);
951
952 HcfObjDestroy(verify);
953 }
954
955 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest303, TestSize.Level0)
956 {
957 HcfVerify *verify = nullptr;
958 int32_t res = HcfVerifyCreate("ECC224|SHA256", &verify);
959
960 ASSERT_EQ(res, HCF_SUCCESS);
961 ASSERT_NE(verify, nullptr);
962
963 res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
964
965 ASSERT_EQ(res, HCF_SUCCESS);
966
967 res = verify->update(verify, &g_mockInput);
968
969 ASSERT_EQ(res, HCF_SUCCESS);
970
971 HcfObjDestroy(verify);
972 }
973
974 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest304, TestSize.Level0)
975 {
976 HcfVerify *verify = nullptr;
977 int32_t res = HcfVerifyCreate("ECC224|SHA384", &verify);
978
979 ASSERT_EQ(res, HCF_SUCCESS);
980 ASSERT_NE(verify, nullptr);
981
982 res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
983
984 ASSERT_EQ(res, HCF_SUCCESS);
985
986 res = verify->update(verify, &g_mockInput);
987
988 ASSERT_EQ(res, HCF_SUCCESS);
989
990 HcfObjDestroy(verify);
991 }
992
993 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest305, TestSize.Level0)
994 {
995 HcfVerify *verify = nullptr;
996 int32_t res = HcfVerifyCreate("ECC224|SHA512", &verify);
997
998 ASSERT_EQ(res, HCF_SUCCESS);
999 ASSERT_NE(verify, nullptr);
1000
1001 res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
1002
1003 ASSERT_EQ(res, HCF_SUCCESS);
1004
1005 res = verify->update(verify, &g_mockInput);
1006
1007 ASSERT_EQ(res, HCF_SUCCESS);
1008
1009 HcfObjDestroy(verify);
1010 }
1011
1012 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest306, TestSize.Level0)
1013 {
1014 HcfVerify *verify = nullptr;
1015 int32_t res = HcfVerifyCreate("ECC256|SHA1", &verify);
1016
1017 ASSERT_EQ(res, HCF_SUCCESS);
1018 ASSERT_NE(verify, nullptr);
1019
1020 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1021
1022 ASSERT_EQ(res, HCF_SUCCESS);
1023
1024 res = verify->update(verify, &g_mockInput);
1025
1026 ASSERT_EQ(res, HCF_SUCCESS);
1027
1028 HcfObjDestroy(verify);
1029 }
1030
1031 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest307, TestSize.Level0)
1032 {
1033 HcfVerify *verify = nullptr;
1034 int32_t res = HcfVerifyCreate("ECC256|SHA224", &verify);
1035
1036 ASSERT_EQ(res, HCF_SUCCESS);
1037 ASSERT_NE(verify, nullptr);
1038
1039 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1040
1041 ASSERT_EQ(res, HCF_SUCCESS);
1042
1043 res = verify->update(verify, &g_mockInput);
1044
1045 ASSERT_EQ(res, HCF_SUCCESS);
1046
1047 HcfObjDestroy(verify);
1048 }
1049
1050 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest308, TestSize.Level0)
1051 {
1052 HcfVerify *verify = nullptr;
1053 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
1054
1055 ASSERT_EQ(res, HCF_SUCCESS);
1056 ASSERT_NE(verify, nullptr);
1057
1058 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1059
1060 ASSERT_EQ(res, HCF_SUCCESS);
1061
1062 res = verify->update(verify, &g_mockInput);
1063
1064 ASSERT_EQ(res, HCF_SUCCESS);
1065
1066 HcfObjDestroy(verify);
1067 }
1068
1069 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest309, TestSize.Level0)
1070 {
1071 HcfVerify *verify = nullptr;
1072 int32_t res = HcfVerifyCreate("ECC256|SHA384", &verify);
1073
1074 ASSERT_EQ(res, HCF_SUCCESS);
1075 ASSERT_NE(verify, nullptr);
1076
1077 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1078
1079 ASSERT_EQ(res, HCF_SUCCESS);
1080
1081 res = verify->update(verify, &g_mockInput);
1082
1083 ASSERT_EQ(res, HCF_SUCCESS);
1084
1085 HcfObjDestroy(verify);
1086 }
1087
1088 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest310, TestSize.Level0)
1089 {
1090 HcfVerify *verify = nullptr;
1091 int32_t res = HcfVerifyCreate("ECC256|SHA512", &verify);
1092
1093 ASSERT_EQ(res, HCF_SUCCESS);
1094 ASSERT_NE(verify, nullptr);
1095
1096 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1097
1098 ASSERT_EQ(res, HCF_SUCCESS);
1099
1100 res = verify->update(verify, &g_mockInput);
1101
1102 ASSERT_EQ(res, HCF_SUCCESS);
1103
1104 HcfObjDestroy(verify);
1105 }
1106
1107 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest311, TestSize.Level0)
1108 {
1109 HcfVerify *verify = nullptr;
1110 int32_t res = HcfVerifyCreate("ECC384|SHA1", &verify);
1111
1112 ASSERT_EQ(res, HCF_SUCCESS);
1113 ASSERT_NE(verify, nullptr);
1114
1115 res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
1116
1117 ASSERT_EQ(res, HCF_SUCCESS);
1118
1119 res = verify->update(verify, &g_mockInput);
1120
1121 ASSERT_EQ(res, HCF_SUCCESS);
1122
1123 HcfObjDestroy(verify);
1124 }
1125
1126 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest312, TestSize.Level0)
1127 {
1128 HcfVerify *verify = nullptr;
1129 int32_t res = HcfVerifyCreate("ECC384|SHA224", &verify);
1130
1131 ASSERT_EQ(res, HCF_SUCCESS);
1132 ASSERT_NE(verify, nullptr);
1133
1134 res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
1135
1136 ASSERT_EQ(res, HCF_SUCCESS);
1137
1138 res = verify->update(verify, &g_mockInput);
1139
1140 ASSERT_EQ(res, HCF_SUCCESS);
1141
1142 HcfObjDestroy(verify);
1143 }
1144
1145 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest313, TestSize.Level0)
1146 {
1147 HcfVerify *verify = nullptr;
1148 int32_t res = HcfVerifyCreate("ECC384|SHA256", &verify);
1149
1150 ASSERT_EQ(res, HCF_SUCCESS);
1151 ASSERT_NE(verify, nullptr);
1152
1153 res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
1154
1155 ASSERT_EQ(res, HCF_SUCCESS);
1156
1157 res = verify->update(verify, &g_mockInput);
1158
1159 ASSERT_EQ(res, HCF_SUCCESS);
1160
1161 HcfObjDestroy(verify);
1162 }
1163
1164 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest314, TestSize.Level0)
1165 {
1166 HcfVerify *verify = nullptr;
1167 int32_t res = HcfVerifyCreate("ECC384|SHA384", &verify);
1168
1169 ASSERT_EQ(res, HCF_SUCCESS);
1170 ASSERT_NE(verify, nullptr);
1171
1172 res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
1173
1174 ASSERT_EQ(res, HCF_SUCCESS);
1175
1176 res = verify->update(verify, &g_mockInput);
1177
1178 ASSERT_EQ(res, HCF_SUCCESS);
1179
1180 HcfObjDestroy(verify);
1181 }
1182
1183 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest315, TestSize.Level0)
1184 {
1185 HcfVerify *verify = nullptr;
1186 int32_t res = HcfVerifyCreate("ECC384|SHA512", &verify);
1187
1188 ASSERT_EQ(res, HCF_SUCCESS);
1189 ASSERT_NE(verify, nullptr);
1190
1191 res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
1192
1193 ASSERT_EQ(res, HCF_SUCCESS);
1194
1195 res = verify->update(verify, &g_mockInput);
1196
1197 ASSERT_EQ(res, HCF_SUCCESS);
1198
1199 HcfObjDestroy(verify);
1200 }
1201
1202 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest316, TestSize.Level0)
1203 {
1204 HcfVerify *verify = nullptr;
1205 int32_t res = HcfVerifyCreate("ECC521|SHA1", &verify);
1206
1207 ASSERT_EQ(res, HCF_SUCCESS);
1208 ASSERT_NE(verify, nullptr);
1209
1210 res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
1211
1212 ASSERT_EQ(res, HCF_SUCCESS);
1213
1214 res = verify->update(verify, &g_mockInput);
1215
1216 ASSERT_EQ(res, HCF_SUCCESS);
1217
1218 HcfObjDestroy(verify);
1219 }
1220
1221 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest317, TestSize.Level0)
1222 {
1223 HcfVerify *verify = nullptr;
1224 int32_t res = HcfVerifyCreate("ECC521|SHA224", &verify);
1225
1226 ASSERT_EQ(res, HCF_SUCCESS);
1227 ASSERT_NE(verify, nullptr);
1228
1229 res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
1230
1231 ASSERT_EQ(res, HCF_SUCCESS);
1232
1233 res = verify->update(verify, &g_mockInput);
1234
1235 ASSERT_EQ(res, HCF_SUCCESS);
1236
1237 HcfObjDestroy(verify);
1238 }
1239
1240 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest318, TestSize.Level0)
1241 {
1242 HcfVerify *verify = nullptr;
1243 int32_t res = HcfVerifyCreate("ECC521|SHA256", &verify);
1244
1245 ASSERT_EQ(res, HCF_SUCCESS);
1246 ASSERT_NE(verify, nullptr);
1247
1248 res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
1249
1250 ASSERT_EQ(res, HCF_SUCCESS);
1251
1252 res = verify->update(verify, &g_mockInput);
1253
1254 ASSERT_EQ(res, HCF_SUCCESS);
1255
1256 HcfObjDestroy(verify);
1257 }
1258
1259 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest319, TestSize.Level0)
1260 {
1261 HcfVerify *verify = nullptr;
1262 int32_t res = HcfVerifyCreate("ECC521|SHA384", &verify);
1263
1264 ASSERT_EQ(res, HCF_SUCCESS);
1265 ASSERT_NE(verify, nullptr);
1266
1267 res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
1268
1269 ASSERT_EQ(res, HCF_SUCCESS);
1270
1271 res = verify->update(verify, &g_mockInput);
1272
1273 ASSERT_EQ(res, HCF_SUCCESS);
1274
1275 HcfObjDestroy(verify);
1276 }
1277
1278 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest320, TestSize.Level0)
1279 {
1280 HcfVerify *verify = nullptr;
1281 int32_t res = HcfVerifyCreate("ECC521|SHA512", &verify);
1282
1283 ASSERT_EQ(res, HCF_SUCCESS);
1284 ASSERT_NE(verify, nullptr);
1285
1286 res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
1287
1288 ASSERT_EQ(res, HCF_SUCCESS);
1289
1290 res = verify->update(verify, &g_mockInput);
1291
1292 ASSERT_EQ(res, HCF_SUCCESS);
1293
1294 HcfObjDestroy(verify);
1295 }
1296
1297 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest321, TestSize.Level0)
1298 {
1299 HcfVerify *verify = nullptr;
1300 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
1301
1302 ASSERT_EQ(res, HCF_SUCCESS);
1303 ASSERT_NE(verify, nullptr);
1304
1305 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1306
1307 ASSERT_EQ(res, HCF_SUCCESS);
1308
1309 res = verify->update(nullptr, &g_mockInput);
1310
1311 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1312
1313 HcfObjDestroy(verify);
1314 }
1315
1316 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest322, TestSize.Level0)
1317 {
1318 HcfVerify *verify = nullptr;
1319 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
1320
1321 ASSERT_EQ(res, HCF_SUCCESS);
1322 ASSERT_NE(verify, nullptr);
1323
1324 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1325
1326 ASSERT_EQ(res, HCF_SUCCESS);
1327
1328 res = verify->update((HcfVerify *)(&obj), &g_mockInput);
1329
1330 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1331
1332 HcfObjDestroy(verify);
1333 }
1334
1335 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest323, TestSize.Level0)
1336 {
1337 HcfVerify *verify = nullptr;
1338 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
1339
1340 ASSERT_EQ(res, HCF_SUCCESS);
1341 ASSERT_NE(verify, nullptr);
1342
1343 res = verify->update(verify, &g_mockInput);
1344
1345 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1346
1347 HcfObjDestroy(verify);
1348 }
1349
1350 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest324, TestSize.Level0)
1351 {
1352 HcfVerify *verify = nullptr;
1353 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
1354
1355 ASSERT_EQ(res, HCF_SUCCESS);
1356 ASSERT_NE(verify, nullptr);
1357
1358 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1359
1360 ASSERT_EQ(res, HCF_SUCCESS);
1361
1362 res = verify->update(verify, nullptr);
1363
1364 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1365
1366 HcfObjDestroy(verify);
1367 }
1368
1369 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest325, TestSize.Level0)
1370 {
1371 HcfVerify *verify = nullptr;
1372 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
1373
1374 ASSERT_EQ(res, HCF_SUCCESS);
1375 ASSERT_NE(verify, nullptr);
1376
1377 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1378
1379 ASSERT_EQ(res, HCF_SUCCESS);
1380
1381 HcfBlob input = {
1382 .data = nullptr,
1383 .len = 1
1384 };
1385 res = verify->update(verify, &input);
1386
1387 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1388
1389 HcfObjDestroy(verify);
1390 }
1391
1392 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest326, TestSize.Level0)
1393 {
1394 HcfVerify *verify = nullptr;
1395 int32_t res = HcfVerifyCreate("ECC256|SHA256", &verify);
1396
1397 ASSERT_EQ(res, HCF_SUCCESS);
1398 ASSERT_NE(verify, nullptr);
1399
1400 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1401
1402 ASSERT_EQ(res, HCF_SUCCESS);
1403
1404 HcfBlob input = {
1405 .data = (uint8_t *)g_mockMessage,
1406 .len = 0
1407 };
1408 res = verify->update(verify, &input);
1409
1410 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1411
1412 HcfObjDestroy(verify);
1413 }
1414
1415 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest401, TestSize.Level0)
1416 {
1417 HcfSign *sign = nullptr;
1418 int32_t res = HcfSignCreate("ECC224|SHA1", &sign);
1419
1420 ASSERT_EQ(res, HCF_SUCCESS);
1421 ASSERT_NE(sign, nullptr);
1422
1423 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1424
1425 ASSERT_EQ(res, HCF_SUCCESS);
1426
1427 res = sign->update(sign, &g_mockInput);
1428
1429 ASSERT_EQ(res, HCF_SUCCESS);
1430
1431 HcfBlob out = { .data = nullptr, .len = 0 };
1432 res = sign->sign(sign, nullptr, &out);
1433
1434 ASSERT_EQ(res, HCF_SUCCESS);
1435 ASSERT_NE(out.data, nullptr);
1436 ASSERT_NE(out.len, (const unsigned int)0);
1437
1438 HcfVerify *verify = nullptr;
1439 res = HcfVerifyCreate("ECC224|SHA1", &verify);
1440
1441 ASSERT_EQ(res, HCF_SUCCESS);
1442 ASSERT_NE(verify, nullptr);
1443
1444 res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
1445
1446 ASSERT_EQ(res, HCF_SUCCESS);
1447
1448 res = verify->update(verify, &g_mockInput);
1449
1450 ASSERT_EQ(res, HCF_SUCCESS);
1451
1452 bool flag = verify->verify(verify, nullptr, &out);
1453
1454 ASSERT_EQ(flag, true);
1455
1456 HcfFree(out.data);
1457 HcfObjDestroy(sign);
1458 HcfObjDestroy(verify);
1459 }
1460
1461 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest402, TestSize.Level0)
1462 {
1463 HcfSign *sign = nullptr;
1464 int32_t res = HcfSignCreate("ECC224|SHA224", &sign);
1465
1466 ASSERT_EQ(res, HCF_SUCCESS);
1467 ASSERT_NE(sign, nullptr);
1468
1469 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1470
1471 ASSERT_EQ(res, HCF_SUCCESS);
1472
1473 res = sign->update(sign, &g_mockInput);
1474
1475 ASSERT_EQ(res, HCF_SUCCESS);
1476
1477 HcfBlob out = { .data = nullptr, .len = 0 };
1478 res = sign->sign(sign, nullptr, &out);
1479
1480 ASSERT_EQ(res, HCF_SUCCESS);
1481 ASSERT_NE(out.data, nullptr);
1482 ASSERT_NE(out.len, (const unsigned int)0);
1483
1484 HcfVerify *verify = nullptr;
1485 res = HcfVerifyCreate("ECC224|SHA224", &verify);
1486
1487 ASSERT_EQ(res, HCF_SUCCESS);
1488 ASSERT_NE(verify, nullptr);
1489
1490 res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
1491
1492 ASSERT_EQ(res, HCF_SUCCESS);
1493
1494 res = verify->update(verify, &g_mockInput);
1495
1496 ASSERT_EQ(res, HCF_SUCCESS);
1497
1498 bool flag = verify->verify(verify, nullptr, &out);
1499
1500 ASSERT_EQ(flag, true);
1501
1502 HcfFree(out.data);
1503 HcfObjDestroy(sign);
1504 HcfObjDestroy(verify);
1505 }
1506
1507 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest403, TestSize.Level0)
1508 {
1509 HcfSign *sign = nullptr;
1510 int32_t res = HcfSignCreate("ECC224|SHA256", &sign);
1511
1512 ASSERT_EQ(res, HCF_SUCCESS);
1513 ASSERT_NE(sign, nullptr);
1514
1515 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1516
1517 ASSERT_EQ(res, HCF_SUCCESS);
1518
1519 res = sign->update(sign, &g_mockInput);
1520
1521 ASSERT_EQ(res, HCF_SUCCESS);
1522
1523 HcfBlob out = { .data = nullptr, .len = 0 };
1524 res = sign->sign(sign, nullptr, &out);
1525
1526 ASSERT_EQ(res, HCF_SUCCESS);
1527 ASSERT_NE(out.data, nullptr);
1528 ASSERT_NE(out.len, (const unsigned int)0);
1529
1530 HcfVerify *verify = nullptr;
1531 res = HcfVerifyCreate("ECC224|SHA256", &verify);
1532
1533 ASSERT_EQ(res, HCF_SUCCESS);
1534 ASSERT_NE(verify, nullptr);
1535
1536 res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
1537
1538 ASSERT_EQ(res, HCF_SUCCESS);
1539
1540 res = verify->update(verify, &g_mockInput);
1541
1542 ASSERT_EQ(res, HCF_SUCCESS);
1543
1544 bool flag = verify->verify(verify, nullptr, &out);
1545
1546 ASSERT_EQ(flag, true);
1547
1548 HcfFree(out.data);
1549 HcfObjDestroy(sign);
1550 HcfObjDestroy(verify);
1551 }
1552
1553 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest404, TestSize.Level0)
1554 {
1555 HcfSign *sign = nullptr;
1556 int32_t res = HcfSignCreate("ECC224|SHA384", &sign);
1557
1558 ASSERT_EQ(res, HCF_SUCCESS);
1559 ASSERT_NE(sign, nullptr);
1560
1561 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1562
1563 ASSERT_EQ(res, HCF_SUCCESS);
1564
1565 res = sign->update(sign, &g_mockInput);
1566
1567 ASSERT_EQ(res, HCF_SUCCESS);
1568
1569 HcfBlob out = { .data = nullptr, .len = 0 };
1570 res = sign->sign(sign, nullptr, &out);
1571
1572 ASSERT_EQ(res, HCF_SUCCESS);
1573 ASSERT_NE(out.data, nullptr);
1574 ASSERT_NE(out.len, (const unsigned int)0);
1575
1576 HcfVerify *verify = nullptr;
1577 res = HcfVerifyCreate("ECC224|SHA384", &verify);
1578
1579 ASSERT_EQ(res, HCF_SUCCESS);
1580 ASSERT_NE(verify, nullptr);
1581
1582 res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
1583
1584 ASSERT_EQ(res, HCF_SUCCESS);
1585
1586 res = verify->update(verify, &g_mockInput);
1587
1588 ASSERT_EQ(res, HCF_SUCCESS);
1589
1590 bool flag = verify->verify(verify, nullptr, &out);
1591
1592 ASSERT_EQ(flag, true);
1593
1594 HcfFree(out.data);
1595 HcfObjDestroy(sign);
1596 HcfObjDestroy(verify);
1597 }
1598
1599 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest405, TestSize.Level0)
1600 {
1601 HcfSign *sign = nullptr;
1602 int32_t res = HcfSignCreate("ECC224|SHA512", &sign);
1603
1604 ASSERT_EQ(res, HCF_SUCCESS);
1605 ASSERT_NE(sign, nullptr);
1606
1607 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1608
1609 ASSERT_EQ(res, HCF_SUCCESS);
1610
1611 res = sign->update(sign, &g_mockInput);
1612
1613 ASSERT_EQ(res, HCF_SUCCESS);
1614
1615 HcfBlob out = { .data = nullptr, .len = 0 };
1616 res = sign->sign(sign, nullptr, &out);
1617
1618 ASSERT_EQ(res, HCF_SUCCESS);
1619 ASSERT_NE(out.data, nullptr);
1620 ASSERT_NE(out.len, (const unsigned int)0);
1621
1622 HcfVerify *verify = nullptr;
1623 res = HcfVerifyCreate("ECC224|SHA512", &verify);
1624
1625 ASSERT_EQ(res, HCF_SUCCESS);
1626 ASSERT_NE(verify, nullptr);
1627
1628 res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
1629
1630 ASSERT_EQ(res, HCF_SUCCESS);
1631
1632 res = verify->update(verify, &g_mockInput);
1633
1634 ASSERT_EQ(res, HCF_SUCCESS);
1635
1636 bool flag = verify->verify(verify, nullptr, &out);
1637
1638 ASSERT_EQ(flag, true);
1639
1640 HcfFree(out.data);
1641 HcfObjDestroy(sign);
1642 HcfObjDestroy(verify);
1643 }
1644
1645 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest406, TestSize.Level0)
1646 {
1647 HcfSign *sign = nullptr;
1648 int32_t res = HcfSignCreate("ECC256|SHA1", &sign);
1649
1650 ASSERT_EQ(res, HCF_SUCCESS);
1651 ASSERT_NE(sign, nullptr);
1652
1653 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1654
1655 ASSERT_EQ(res, HCF_SUCCESS);
1656
1657 res = sign->update(sign, &g_mockInput);
1658
1659 ASSERT_EQ(res, HCF_SUCCESS);
1660
1661 HcfBlob out = { .data = nullptr, .len = 0 };
1662 res = sign->sign(sign, nullptr, &out);
1663
1664 ASSERT_EQ(res, HCF_SUCCESS);
1665 ASSERT_NE(out.data, nullptr);
1666 ASSERT_NE(out.len, (const unsigned int)0);
1667
1668 HcfVerify *verify = nullptr;
1669 res = HcfVerifyCreate("ECC256|SHA1", &verify);
1670
1671 ASSERT_EQ(res, HCF_SUCCESS);
1672 ASSERT_NE(verify, nullptr);
1673
1674 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1675
1676 ASSERT_EQ(res, HCF_SUCCESS);
1677
1678 res = verify->update(verify, &g_mockInput);
1679
1680 ASSERT_EQ(res, HCF_SUCCESS);
1681
1682 bool flag = verify->verify(verify, nullptr, &out);
1683
1684 ASSERT_EQ(flag, true);
1685
1686 HcfFree(out.data);
1687 HcfObjDestroy(sign);
1688 HcfObjDestroy(verify);
1689 }
1690
1691 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest407, TestSize.Level0)
1692 {
1693 HcfSign *sign = nullptr;
1694 int32_t res = HcfSignCreate("ECC256|SHA224", &sign);
1695
1696 ASSERT_EQ(res, HCF_SUCCESS);
1697 ASSERT_NE(sign, nullptr);
1698
1699 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1700
1701 ASSERT_EQ(res, HCF_SUCCESS);
1702
1703 res = sign->update(sign, &g_mockInput);
1704
1705 ASSERT_EQ(res, HCF_SUCCESS);
1706
1707 HcfBlob out = { .data = nullptr, .len = 0 };
1708 res = sign->sign(sign, nullptr, &out);
1709
1710 ASSERT_EQ(res, HCF_SUCCESS);
1711 ASSERT_NE(out.data, nullptr);
1712 ASSERT_NE(out.len, (const unsigned int)0);
1713
1714 HcfVerify *verify = nullptr;
1715 res = HcfVerifyCreate("ECC256|SHA224", &verify);
1716
1717 ASSERT_EQ(res, HCF_SUCCESS);
1718 ASSERT_NE(verify, nullptr);
1719
1720 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1721
1722 ASSERT_EQ(res, HCF_SUCCESS);
1723
1724 res = verify->update(verify, &g_mockInput);
1725
1726 ASSERT_EQ(res, HCF_SUCCESS);
1727
1728 bool flag = verify->verify(verify, nullptr, &out);
1729
1730 ASSERT_EQ(flag, true);
1731
1732 HcfFree(out.data);
1733 HcfObjDestroy(sign);
1734 HcfObjDestroy(verify);
1735 }
1736
1737 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest408, TestSize.Level0)
1738 {
1739 HcfSign *sign = nullptr;
1740 int32_t res = HcfSignCreate("ECC256|SHA256", &sign);
1741
1742 ASSERT_EQ(res, HCF_SUCCESS);
1743 ASSERT_NE(sign, nullptr);
1744
1745 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1746
1747 ASSERT_EQ(res, HCF_SUCCESS);
1748
1749 res = sign->update(sign, &g_mockInput);
1750
1751 ASSERT_EQ(res, HCF_SUCCESS);
1752
1753 HcfBlob out = { .data = nullptr, .len = 0 };
1754 res = sign->sign(sign, nullptr, &out);
1755
1756 ASSERT_EQ(res, HCF_SUCCESS);
1757 ASSERT_NE(out.data, nullptr);
1758 ASSERT_NE(out.len, (const unsigned int)0);
1759
1760 HcfVerify *verify = nullptr;
1761 res = HcfVerifyCreate("ECC256|SHA256", &verify);
1762
1763 ASSERT_EQ(res, HCF_SUCCESS);
1764 ASSERT_NE(verify, nullptr);
1765
1766 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1767
1768 ASSERT_EQ(res, HCF_SUCCESS);
1769
1770 res = verify->update(verify, &g_mockInput);
1771
1772 ASSERT_EQ(res, HCF_SUCCESS);
1773
1774 bool flag = verify->verify(verify, nullptr, &out);
1775
1776 ASSERT_EQ(flag, true);
1777
1778 HcfFree(out.data);
1779 HcfObjDestroy(sign);
1780 HcfObjDestroy(verify);
1781 }
1782
1783 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest409, TestSize.Level0)
1784 {
1785 HcfSign *sign = nullptr;
1786 int32_t res = HcfSignCreate("ECC256|SHA384", &sign);
1787
1788 ASSERT_EQ(res, HCF_SUCCESS);
1789 ASSERT_NE(sign, nullptr);
1790
1791 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1792
1793 ASSERT_EQ(res, HCF_SUCCESS);
1794
1795 res = sign->update(sign, &g_mockInput);
1796
1797 ASSERT_EQ(res, HCF_SUCCESS);
1798
1799 HcfBlob out = { .data = nullptr, .len = 0 };
1800 res = sign->sign(sign, nullptr, &out);
1801
1802 ASSERT_EQ(res, HCF_SUCCESS);
1803 ASSERT_NE(out.data, nullptr);
1804 ASSERT_NE(out.len, (const unsigned int)0);
1805
1806 HcfVerify *verify = nullptr;
1807 res = HcfVerifyCreate("ECC256|SHA384", &verify);
1808
1809 ASSERT_EQ(res, HCF_SUCCESS);
1810 ASSERT_NE(verify, nullptr);
1811
1812 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1813
1814 ASSERT_EQ(res, HCF_SUCCESS);
1815
1816 res = verify->update(verify, &g_mockInput);
1817
1818 ASSERT_EQ(res, HCF_SUCCESS);
1819
1820 bool flag = verify->verify(verify, nullptr, &out);
1821
1822 ASSERT_EQ(flag, true);
1823
1824 HcfFree(out.data);
1825 HcfObjDestroy(sign);
1826 HcfObjDestroy(verify);
1827 }
1828
1829 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest410, TestSize.Level0)
1830 {
1831 HcfSign *sign = nullptr;
1832 int32_t res = HcfSignCreate("ECC256|SHA512", &sign);
1833
1834 ASSERT_EQ(res, HCF_SUCCESS);
1835 ASSERT_NE(sign, nullptr);
1836
1837 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1838
1839 ASSERT_EQ(res, HCF_SUCCESS);
1840
1841 res = sign->update(sign, &g_mockInput);
1842
1843 ASSERT_EQ(res, HCF_SUCCESS);
1844
1845 HcfBlob out = { .data = nullptr, .len = 0 };
1846 res = sign->sign(sign, nullptr, &out);
1847
1848 ASSERT_EQ(res, HCF_SUCCESS);
1849 ASSERT_NE(out.data, nullptr);
1850 ASSERT_NE(out.len, (const unsigned int)0);
1851
1852 HcfVerify *verify = nullptr;
1853 res = HcfVerifyCreate("ECC256|SHA512", &verify);
1854
1855 ASSERT_EQ(res, HCF_SUCCESS);
1856 ASSERT_NE(verify, nullptr);
1857
1858 res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1859
1860 ASSERT_EQ(res, HCF_SUCCESS);
1861
1862 res = verify->update(verify, &g_mockInput);
1863
1864 ASSERT_EQ(res, HCF_SUCCESS);
1865
1866 bool flag = verify->verify(verify, nullptr, &out);
1867
1868 ASSERT_EQ(flag, true);
1869
1870 HcfFree(out.data);
1871 HcfObjDestroy(sign);
1872 HcfObjDestroy(verify);
1873 }
1874
1875 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest411, TestSize.Level0)
1876 {
1877 HcfSign *sign = nullptr;
1878 int32_t res = HcfSignCreate("ECC384|SHA1", &sign);
1879
1880 ASSERT_EQ(res, HCF_SUCCESS);
1881 ASSERT_NE(sign, nullptr);
1882
1883 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1884
1885 ASSERT_EQ(res, HCF_SUCCESS);
1886
1887 res = sign->update(sign, &g_mockInput);
1888
1889 ASSERT_EQ(res, HCF_SUCCESS);
1890
1891 HcfBlob out = { .data = nullptr, .len = 0 };
1892 res = sign->sign(sign, nullptr, &out);
1893
1894 ASSERT_EQ(res, HCF_SUCCESS);
1895 ASSERT_NE(out.data, nullptr);
1896 ASSERT_NE(out.len, (const unsigned int)0);
1897
1898 HcfVerify *verify = nullptr;
1899 res = HcfVerifyCreate("ECC384|SHA1", &verify);
1900
1901 ASSERT_EQ(res, HCF_SUCCESS);
1902 ASSERT_NE(verify, nullptr);
1903
1904 res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
1905
1906 ASSERT_EQ(res, HCF_SUCCESS);
1907
1908 res = verify->update(verify, &g_mockInput);
1909
1910 ASSERT_EQ(res, HCF_SUCCESS);
1911
1912 bool flag = verify->verify(verify, nullptr, &out);
1913
1914 ASSERT_EQ(flag, true);
1915
1916 HcfFree(out.data);
1917 HcfObjDestroy(sign);
1918 HcfObjDestroy(verify);
1919 }
1920
1921 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest412, TestSize.Level0)
1922 {
1923 HcfKeyPair *eccSecp256k1KeyPair = nullptr;
1924 HcfAsyKeyGenerator *generator = nullptr;
1925 int32_t res = HcfAsyKeyGeneratorCreate("ECC_Secp256k1", &generator);
1926 ASSERT_EQ(res, HCF_SUCCESS);
1927 ASSERT_NE(generator, nullptr);
1928
1929 res = generator->convertPemKey(generator, nullptr, eccSecp256k1PubKey.c_str(),
1930 eccSecp256k1PriKey.c_str(), &eccSecp256k1KeyPair);
1931 ASSERT_EQ(res, HCF_SUCCESS);
1932 ASSERT_NE(eccSecp256k1KeyPair, nullptr);
1933
1934 HcfSign *sign = nullptr;
1935 res = HcfSignCreate("ECC_Secp256k1|SHA256", &sign);
1936 ASSERT_EQ(res, HCF_SUCCESS);
1937 ASSERT_NE(sign, nullptr);
1938
1939 res = sign->init(sign, nullptr, eccSecp256k1KeyPair->priKey);
1940 ASSERT_EQ(res, HCF_SUCCESS);
1941
1942 res = sign->update(sign, &g_mockInput);
1943 ASSERT_EQ(res, HCF_SUCCESS);
1944
1945 HcfBlob out = { .data = nullptr, .len = 0 };
1946 res = sign->sign(sign, nullptr, &out);
1947 ASSERT_EQ(res, HCF_SUCCESS);
1948 ASSERT_NE(out.data, nullptr);
1949 ASSERT_NE(out.len, (const unsigned int)0);
1950
1951 HcfVerify *verify = nullptr;
1952 res = HcfVerifyCreate("ECC_Secp256k1|SHA256", &verify);
1953 ASSERT_EQ(res, HCF_SUCCESS);
1954 ASSERT_NE(verify, nullptr);
1955
1956 res = verify->init(verify, nullptr, eccSecp256k1KeyPair->pubKey);
1957 ASSERT_EQ(res, HCF_SUCCESS);
1958
1959 res = verify->update(verify, &g_mockInput);
1960 ASSERT_EQ(res, HCF_SUCCESS);
1961
1962 bool flag = verify->verify(verify, nullptr, &out);
1963 ASSERT_EQ(flag, true);
1964
1965 HcfFree(out.data);
1966 HcfObjDestroy(sign);
1967 HcfObjDestroy(verify);
1968 HcfObjDestroy(eccSecp256k1KeyPair);
1969 HcfObjDestroy(generator);
1970 }
1971
1972 HWTEST_F(CryptoEccVerifyTest, CryptoEccVerifyTest413, TestSize.Level0)
1973 {
1974 HcfKeyPair *eccSecp256k1KeyPair = nullptr;
1975 HcfAsyKeyGenerator *generator = nullptr;
1976 int32_t res = HcfAsyKeyGeneratorCreate("ECC_Secp256k1", &generator);
1977 ASSERT_EQ(res, HCF_SUCCESS);
1978 ASSERT_NE(generator, nullptr);
1979
1980 res = generator->convertPemKey(generator, nullptr, eccSecp256k1PubKey.c_str(),
1981 eccSecp256k1PriKey.c_str(), &eccSecp256k1KeyPair);
1982 ASSERT_EQ(res, HCF_SUCCESS);
1983 ASSERT_NE(eccSecp256k1KeyPair, nullptr);
1984
1985 HcfBlob out = { .data = sig, .len = sizeof(sig) };
1986 HcfVerify *verify = nullptr;
1987 res = HcfVerifyCreate("ECC_Secp256k1|SHA256", &verify);
1988 ASSERT_EQ(res, HCF_SUCCESS);
1989 ASSERT_NE(verify, nullptr);
1990
1991 res = verify->init(verify, nullptr, eccSecp256k1KeyPair->pubKey);
1992 ASSERT_EQ(res, HCF_SUCCESS);
1993
1994 res = verify->update(verify, &input);
1995 ASSERT_EQ(res, HCF_SUCCESS);
1996
1997 bool flag = verify->verify(verify, nullptr, &out);
1998 ASSERT_EQ(flag, true);
1999
2000 HcfObjDestroy(verify);
2001 HcfObjDestroy(eccSecp256k1KeyPair);
2002 HcfObjDestroy(generator);
2003 }
2004 }
2005