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 "ecdsa_openssl.h"
22 #include "memory.h"
23 #include "securec.h"
24 #include "openssl_common.h"
25 #include "asy_key_params.h"
26 #include "params_parser.h"
27 #include "detailed_alg_25519_key_params.h"
28 #include "alg_25519_asy_key_generator_openssl.h"
29 #include "ed25519_openssl.h"
30 #include "memory_mock.h"
31 #include "openssl_adapter_mock.h"
32
33 using namespace std;
34 using namespace testing::ext;
35
36 namespace {
37 class CryptoEd25519VerifyTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41 void SetUp();
42 void TearDown();
43 static HcfKeyPair *ed25519KeyPair_;
44 static HcfKeyPair *x25519KeyPair_;
45 };
46
47 HcfKeyPair *CryptoEd25519VerifyTest::ed25519KeyPair_ = nullptr;
48 HcfKeyPair *CryptoEd25519VerifyTest::x25519KeyPair_ = nullptr;
49
50 static string g_ed25519AlgoName = "Ed25519";
51 static string g_x25519AlgoName = "X25519";
52
SetUp()53 void CryptoEd25519VerifyTest::SetUp() {}
TearDown()54 void CryptoEd25519VerifyTest::TearDown() {}
55
56 static const char *g_mockMessage = "hello world";
57 static HcfBlob g_mockInput = {
58 .data = (uint8_t *)g_mockMessage,
59 .len = 12
60 };
61
GetMockClass(void)62 static const char *GetMockClass(void)
63 {
64 return "Ed25519Verifytest";
65 }
66 HcfObjectBase g_obj = {
67 .getClass = GetMockClass,
68 .destroy = nullptr
69 };
70
71 static const char *g_mock64Message = "ABCDABCDACBDABCDABCDABCDACBDABCDABCDABCDACBDABCDABCDABCDACBDABCD";
72 static HcfBlob g_mock64Input = {
73 .data = (uint8_t *)g_mock64Message,
74 .len = 65
75 };
76
SetUpTestCase()77 void CryptoEd25519VerifyTest::SetUpTestCase()
78 {
79 HcfAsyKeyGenerator *generator = nullptr;
80 HcfResult ret = HcfAsyKeyGeneratorCreate(g_ed25519AlgoName.c_str(), &generator);
81 ASSERT_EQ(ret, HCF_SUCCESS);
82 ASSERT_NE(generator, nullptr);
83
84 HcfKeyPair *keyPair = nullptr;
85 ret = generator->generateKeyPair(generator, nullptr, &keyPair);
86 ASSERT_EQ(ret, HCF_SUCCESS);
87 ASSERT_NE(keyPair, nullptr);
88
89 ed25519KeyPair_ = keyPair;
90
91 ret = HcfAsyKeyGeneratorCreate(g_x25519AlgoName.c_str(), &generator);
92 ASSERT_EQ(ret, HCF_SUCCESS);
93 ASSERT_NE(generator, nullptr);
94
95 ret = generator->generateKeyPair(generator, nullptr, &keyPair);
96 ASSERT_EQ(ret, HCF_SUCCESS);
97 ASSERT_NE(keyPair, nullptr);
98
99 x25519KeyPair_ = keyPair;
100
101 HcfObjDestroy(generator);
102 }
103
TearDownTestCase()104 void CryptoEd25519VerifyTest::TearDownTestCase()
105 {
106 HcfObjDestroy(ed25519KeyPair_);
107 HcfObjDestroy(x25519KeyPair_);
108 }
109
110 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest001, TestSize.Level0)
111 {
112 HcfVerify *verify = nullptr;
113 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
114 ASSERT_EQ(ret, HCF_SUCCESS);
115 ASSERT_NE(verify, nullptr);
116
117 HcfObjDestroy(verify);
118 }
119
120 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest002, TestSize.Level0)
121 {
122 HcfVerify *verify = nullptr;
123 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
124 ASSERT_EQ(ret, HCF_SUCCESS);
125 ASSERT_NE(verify, nullptr);
126
127 const char *className = verify->base.getClass();
128 ASSERT_NE(className, nullptr);
129
130 HcfObjDestroy(verify);
131 }
132
133 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest003, TestSize.Level0)
134 {
135 HcfVerify *verify = nullptr;
136 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
137 ASSERT_EQ(ret, HCF_SUCCESS);
138 ASSERT_NE(verify, nullptr);
139
140 verify->base.destroy((HcfObjectBase *)verify);
141 }
142
143 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest004, TestSize.Level0)
144 {
145 HcfVerify *verify = nullptr;
146 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
147 ASSERT_EQ(ret, HCF_SUCCESS);
148 ASSERT_NE(verify, nullptr);
149
150 const char *algName = verify->getAlgoName(verify);
151 ASSERT_EQ(algName, g_ed25519AlgoName);
152
153 HcfObjDestroy(verify);
154 }
155
156 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest005, TestSize.Level0)
157 {
158 HcfVerify *verify = nullptr;
159 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
160 ASSERT_EQ(ret, HCF_SUCCESS);
161 ASSERT_NE(verify, nullptr);
162
163 ret = verify->init(verify, nullptr, ed25519KeyPair_->pubKey);
164 ASSERT_EQ(ret, HCF_SUCCESS);
165
166 HcfObjDestroy(verify);
167 }
168
169 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest006, TestSize.Level0)
170 {
171 HcfSign *sign = nullptr;
172 HcfResult ret = HcfSignCreate("Ed25519", &sign);
173 ASSERT_EQ(ret, HCF_SUCCESS);
174 ASSERT_NE(sign, nullptr);
175
176 ret = sign->init(sign, nullptr, ed25519KeyPair_->priKey);
177 ASSERT_EQ(ret, HCF_SUCCESS);
178
179 HcfBlob out = { .data = nullptr, .len = 0 };
180 ret = sign->sign(sign, &g_mockInput, &out);
181 ASSERT_EQ(ret, HCF_SUCCESS);
182 ASSERT_NE(out.data, nullptr);
183 ASSERT_NE(out.len, (const unsigned int)0);
184
185 HcfVerify *verify = nullptr;
186 ret = HcfVerifyCreate("Ed25519", &verify);
187 ASSERT_EQ(ret, HCF_SUCCESS);
188 ASSERT_NE(verify, nullptr);
189
190 ret = verify->init(verify, nullptr, ed25519KeyPair_->pubKey);
191 ASSERT_EQ(ret, HCF_SUCCESS);
192
193 bool flag = verify->verify(verify, &g_mockInput, &out);
194 ASSERT_EQ(flag, true);
195 ASSERT_NE(out.data, nullptr);
196 ASSERT_NE(out.len, (const unsigned int)0);
197
198 HcfFree(out.data);
199 HcfObjDestroy(sign);
200 HcfObjDestroy(verify);
201 }
202
203 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest007, TestSize.Level0)
204 {
205 HcfSign *sign = nullptr;
206 HcfResult ret = HcfSignCreate("Ed25519", &sign);
207 ASSERT_EQ(ret, HCF_SUCCESS);
208 ASSERT_NE(sign, nullptr);
209
210 ret = sign->init(sign, nullptr, ed25519KeyPair_->priKey);
211 ASSERT_EQ(ret, HCF_SUCCESS);
212
213 HcfBlob out = { .data = nullptr, .len = 0 };
214 ret = sign->sign(sign, &g_mockInput, &out);
215 ASSERT_EQ(ret, HCF_SUCCESS);
216 ASSERT_NE(out.data, nullptr);
217 ASSERT_NE(out.len, (const unsigned int)0);
218
219 HcfVerify *verify = nullptr;
220 ret = HcfVerifyCreate("Ed25519", &verify);
221 ASSERT_EQ(ret, HCF_SUCCESS);
222 ASSERT_NE(verify, nullptr);
223
224 ret = verify->init(verify, nullptr, ed25519KeyPair_->pubKey);
225 ASSERT_EQ(ret, HCF_SUCCESS);
226
227 bool flag = verify->verify(verify, &g_mockInput, &out);
228 ASSERT_EQ(flag, true);
229
230 HcfFree(out.data);
231 HcfObjDestroy(sign);
232 HcfObjDestroy(verify);
233 }
234
GetSignTestData(HcfBlob * out)235 static bool GetSignTestData(HcfBlob *out)
236 {
237 HcfSign *sign = nullptr;
238 int32_t res = HcfSignCreate("Ed25519", &sign);
239 if (res != HCF_SUCCESS) {
240 return false;
241 }
242 res = sign->init(sign, nullptr, CryptoEd25519VerifyTest::ed25519KeyPair_->priKey);
243 if (res != HCF_SUCCESS) {
244 HcfObjDestroy(sign);
245 return false;
246 }
247 res = sign->sign(sign, &g_mockInput, out);
248 HcfObjDestroy(sign);
249 return res == HCF_SUCCESS;
250 }
251
OpensslMockTestFunc(uint32_t mallocCount,HcfBlob * out)252 static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *out)
253 {
254 for (uint32_t i = 0; i < mallocCount; i++) {
255 ResetOpensslCallNum();
256 SetOpensslCallMockIndex(i);
257 HcfVerify *verify = nullptr;
258 int32_t res = HcfVerifyCreate("Ed25519", &verify);
259 if (res != HCF_SUCCESS) {
260 continue;
261 }
262 res = verify->init(verify, nullptr, CryptoEd25519VerifyTest::ed25519KeyPair_->pubKey);
263 if (res != HCF_SUCCESS) {
264 HcfObjDestroy(verify);
265 continue;
266 }
267 res = verify->verify(verify, &g_mockInput, out);
268 if (res != HCF_SUCCESS) {
269 HcfObjDestroy(verify);
270 continue;
271 }
272 HcfObjDestroy(verify);
273 }
274 }
275
276 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest008, TestSize.Level0)
277 {
278 HcfBlob out = { .data = nullptr, .len = 0 };
279 ASSERT_EQ(GetSignTestData(&out), true);
280 StartRecordOpensslCallNum();
281
282 HcfVerify *verify = nullptr;
283 int32_t res = HcfVerifyCreate("Ed25519", &verify);
284 ASSERT_EQ(res, HCF_SUCCESS);
285 ASSERT_NE(verify, nullptr);
286 res = verify->init(verify, nullptr, ed25519KeyPair_->pubKey);
287 ASSERT_EQ(res, HCF_SUCCESS);
288 bool flag = verify->verify(verify, &g_mockInput, &out);
289 ASSERT_EQ(flag, true);
290 HcfObjDestroy(verify);
291
292 uint32_t mallocCount = GetOpensslCallNum();
293 OpensslMockTestFunc(mallocCount, &out);
294 EndRecordOpensslCallNum();
295 }
296
297 HcfSignatureParams g_params = {
298 .algo = HCF_ALG_ED25519,
299 };
300
301 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest009, TestSize.Level0)
302 {
303 HcfVerifySpi *verify = nullptr;
304 HcfResult ret = HcfVerifySpiEd25519Create(nullptr, &verify);
305 ASSERT_EQ(ret, HCF_INVALID_PARAMS);
306 ASSERT_EQ(verify, nullptr);
307 ret = HcfVerifySpiEd25519Create(&g_params, &verify);
308 ASSERT_EQ(ret, HCF_SUCCESS);
309 ASSERT_NE(verify, nullptr);
310
311 HcfObjDestroy(verify);
312 }
313
314 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest010, TestSize.Level0)
315 {
316 HcfVerifySpi *verify = nullptr;
317 HcfResult ret = HcfVerifySpiEd25519Create(&g_params, &verify);
318 ASSERT_EQ(ret, HCF_SUCCESS);
319 ASSERT_NE(verify, nullptr);
320
321 verify->base.destroy(nullptr);
322 HcfObjDestroy(verify);
323 }
324
325 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest011, TestSize.Level0)
326 {
327 HcfVerifySpi *verify = nullptr;
328 HcfResult ret = HcfVerifySpiEd25519Create(&g_params, &verify);
329 ASSERT_EQ(ret, HCF_SUCCESS);
330 ASSERT_NE(verify, nullptr);
331
332 ret = verify->engineInit(verify, nullptr, nullptr);
333 ASSERT_EQ(ret, HCF_INVALID_PARAMS);
334 HcfObjDestroy(verify);
335 }
336
337 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest012, TestSize.Level0)
338 {
339 HcfVerifySpi *verify = nullptr;
340 int32_t ret = HcfVerifySpiEd25519Create(&g_params, &verify);
341 ASSERT_EQ(ret, HCF_SUCCESS);
342 ASSERT_NE(verify, nullptr);
343
344 ret = verify->engineVerify(verify, &g_mockInput, &g_mockInput);
345 ASSERT_EQ(ret, false);
346 ret = verify->engineVerify(verify, nullptr, &g_mockInput);
347 ASSERT_EQ(ret, false);
348 HcfObjDestroy(verify);
349 }
350
351 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest013, TestSize.Level0)
352 {
353 HcfVerify *verify = nullptr;
354 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
355 ASSERT_EQ(ret, HCF_SUCCESS);
356 ASSERT_NE(verify, nullptr);
357
358 int32_t returnInt = 0;
359 ret = verify->setVerifySpecInt(verify, SM2_USER_ID_UINT8ARR, returnInt);
360 ASSERT_EQ(ret, HCF_NOT_SUPPORT);
361 ret = verify->getVerifySpecInt(verify, SM2_USER_ID_UINT8ARR, &returnInt);
362 ASSERT_EQ(ret, HCF_NOT_SUPPORT);
363 HcfBlob returnBlob = { .data = nullptr, .len = 0};
364 ret = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, returnBlob);
365 ASSERT_EQ(ret, HCF_NOT_SUPPORT);
366 char *itemName = nullptr;
367 ret = verify->getVerifySpecString(verify, SM2_USER_ID_UINT8ARR, &itemName);
368 ASSERT_EQ(ret, HCF_NOT_SUPPORT);
369 ret = verify->update(verify, &g_mockInput);
370 ASSERT_EQ(ret, HCF_INVALID_PARAMS);
371
372 HcfObjDestroy(verify);
373 }
374
375 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyErrTest01, TestSize.Level0)
376 {
377 HcfVerify *verify = nullptr;
378 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
379 ASSERT_EQ(ret, HCF_SUCCESS);
380 ASSERT_NE(verify, nullptr);
381
382 int32_t returnInt = 0;
383 ret = verify->setVerifySpecInt(nullptr, SM2_USER_ID_UINT8ARR, returnInt);
384 ASSERT_EQ(ret, HCF_INVALID_PARAMS);
385 HcfObjDestroy(verify);
386 }
387
388 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest014, TestSize.Level0)
389 {
390 HcfVerify *verify = nullptr;
391 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
392 ASSERT_EQ(ret, HCF_SUCCESS);
393 ASSERT_NE(verify, nullptr);
394
395 verify->base.destroy(nullptr);
396 HcfObjDestroy(verify);
397 }
398
399 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest015, TestSize.Level0)
400 {
401 HcfVerify *verify = nullptr;
402 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
403 ASSERT_EQ(ret, HCF_SUCCESS);
404 ASSERT_NE(verify, nullptr);
405
406 verify->base.destroy(&g_obj);
407 HcfObjDestroy(verify);
408 }
409
410 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest016, TestSize.Level0)
411 {
412 HcfVerify *verify = nullptr;
413 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
414 ASSERT_EQ(ret, HCF_SUCCESS);
415 ASSERT_NE(verify, nullptr);
416
417 const char *algoName = verify->getAlgoName(nullptr);
418 ASSERT_EQ(algoName, nullptr);
419
420 algoName = verify->getAlgoName((HcfVerify *)&g_obj);
421 ASSERT_EQ(algoName, nullptr);
422
423 HcfObjDestroy(verify);
424 }
425
426 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest017, TestSize.Level0)
427 {
428 HcfVerify *verify = nullptr;
429 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
430 ASSERT_EQ(ret, HCF_SUCCESS);
431 ASSERT_NE(verify, nullptr);
432
433 ret = verify->init(nullptr, nullptr, ed25519KeyPair_->pubKey);
434 ASSERT_EQ(ret, HCF_INVALID_PARAMS);
435
436 HcfObjDestroy(verify);
437 }
438
439 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest018, TestSize.Level0)
440 {
441 HcfVerify *verify = nullptr;
442 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
443 ASSERT_EQ(ret, HCF_SUCCESS);
444 ASSERT_NE(verify, nullptr);
445
446 ret = verify->init((HcfVerify *)&g_obj, nullptr, ed25519KeyPair_->pubKey);
447 ASSERT_EQ(ret, HCF_INVALID_PARAMS);
448
449 HcfObjDestroy(verify);
450 }
451
452 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest019, TestSize.Level0)
453 {
454 HcfVerify *verify = nullptr;
455 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
456 ASSERT_EQ(ret, HCF_SUCCESS);
457 ASSERT_NE(verify, nullptr);
458
459 ret = verify->init(verify, nullptr, x25519KeyPair_->pubKey);
460 ASSERT_EQ(ret, HCF_ERR_CRYPTO_OPERATION);
461
462 HcfObjDestroy(verify);
463 }
464
465 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest020, TestSize.Level0)
466 {
467 HcfVerify *verify = nullptr;
468 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
469 ASSERT_EQ(ret, HCF_SUCCESS);
470 ASSERT_NE(verify, nullptr);
471
472 ret = verify->init(verify, nullptr, ed25519KeyPair_->pubKey);
473 ret = verify->init(verify, nullptr, ed25519KeyPair_->pubKey);
474 ASSERT_NE(ret, HCF_SUCCESS);
475
476 HcfObjDestroy(verify);
477 }
478
479 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest021, TestSize.Level0)
480 {
481 HcfVerify *verify = nullptr;
482 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
483 ASSERT_EQ(ret, HCF_SUCCESS);
484 ASSERT_NE(verify, nullptr);
485
486 HcfBlob out = { .data = nullptr, .len = 0 };
487 bool flag = verify->verify(verify, &g_mockInput, &out);
488 ASSERT_EQ(flag, false);
489
490 HcfFree(out.data);
491 HcfObjDestroy(verify);
492 }
493
494 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest022, TestSize.Level0)
495 {
496 HcfVerify *verify = nullptr;
497 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
498 ASSERT_EQ(ret, HCF_SUCCESS);
499 ASSERT_NE(verify, nullptr);
500
501 ret = verify->init(verify, nullptr, ed25519KeyPair_->pubKey);
502 ASSERT_EQ(ret, HCF_SUCCESS);
503 HcfBlob out = { .data = nullptr, .len = 0 };
504 bool flag = verify->verify(verify, nullptr, &out);
505 ASSERT_EQ(flag, false);
506
507 HcfFree(out.data);
508 HcfObjDestroy(verify);
509 }
510
511 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest023, TestSize.Level0)
512 {
513 HcfVerify *verify = nullptr;
514 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
515 ASSERT_EQ(ret, HCF_SUCCESS);
516 ASSERT_NE(verify, nullptr);
517
518 ret = verify->init(verify, nullptr, ed25519KeyPair_->pubKey);
519 ASSERT_EQ(ret, HCF_SUCCESS);
520 bool flag = verify->verify(verify, &g_mockInput, nullptr);
521 ASSERT_EQ(flag, false);
522
523 HcfObjDestroy(verify);
524 }
525
526 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest024, TestSize.Level0)
527 {
528 HcfVerify *verify = nullptr;
529 HcfResult ret = HcfVerifyCreate("Ed25519", &verify);
530 ASSERT_EQ(ret, HCF_SUCCESS);
531 ASSERT_NE(verify, nullptr);
532
533 ret = verify->init(verify, nullptr, ed25519KeyPair_->pubKey);
534 ASSERT_EQ(ret, HCF_SUCCESS);
535 bool flag = verify->verify(verify, &g_mockInput, &g_mockInput);
536 ASSERT_EQ(flag, false);
537
538 HcfObjDestroy(verify);
539 }
540
541 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest025, TestSize.Level0)
542 {
543 HcfSign *sign = nullptr;
544 HcfResult ret = HcfSignCreate("Ed25519", &sign);
545 ASSERT_EQ(ret, HCF_SUCCESS);
546 ASSERT_NE(sign, nullptr);
547
548 ret = sign->init(sign, nullptr, ed25519KeyPair_->priKey);
549 ASSERT_EQ(ret, HCF_SUCCESS);
550
551 HcfBlob out = { .data = nullptr, .len = 0 };
552 ret = sign->sign(sign, &g_mockInput, &out);
553 ASSERT_EQ(ret, HCF_SUCCESS);
554 ASSERT_NE(out.data, nullptr);
555 ASSERT_NE(out.len, (const unsigned int)0);
556
557 HcfVerify *verify = nullptr;
558 ret = HcfVerifyCreate("Ed25519", &verify);
559 ASSERT_EQ(ret, HCF_SUCCESS);
560 ASSERT_NE(verify, nullptr);
561
562 ret = verify->init(verify, nullptr, ed25519KeyPair_->pubKey);
563 ASSERT_EQ(ret, HCF_SUCCESS);
564
565 bool flag = verify->verify(verify, &g_mockInput, &out);
566 flag = verify->verify(verify, &g_mockInput, &out);
567 ASSERT_EQ(flag, true);
568 ASSERT_NE(out.data, nullptr);
569 ASSERT_NE(out.len, (const unsigned int)0);
570
571 HcfFree(out.data);
572 HcfObjDestroy(sign);
573 HcfObjDestroy(verify);
574 }
575
576 HWTEST_F(CryptoEd25519VerifyTest, CryptoEd25519VerifyTest026, TestSize.Level0)
577 {
578 HcfSign *sign = nullptr;
579 HcfResult ret = HcfSignCreate("Ed25519", &sign);
580 ASSERT_EQ(ret, HCF_SUCCESS);
581 ASSERT_NE(sign, nullptr);
582
583 ret = sign->init(sign, nullptr, ed25519KeyPair_->priKey);
584 ASSERT_EQ(ret, HCF_SUCCESS);
585
586 HcfBlob out = { .data = nullptr, .len = 0 };
587 ret = sign->sign(sign, &g_mock64Input, &out);
588 ASSERT_EQ(ret, HCF_SUCCESS);
589 ASSERT_NE(out.data, nullptr);
590 ASSERT_NE(out.len, (const unsigned int)0);
591
592 HcfVerify *verify = nullptr;
593 ret = HcfVerifyCreate("Ed25519", &verify);
594 ASSERT_EQ(ret, HCF_SUCCESS);
595 ASSERT_NE(verify, nullptr);
596
597 ret = verify->init(verify, nullptr, ed25519KeyPair_->pubKey);
598 ASSERT_EQ(ret, HCF_SUCCESS);
599
600 bool flag = verify->verify(verify, &g_mock64Input, &out);
601 ASSERT_EQ(flag, true);
602 ASSERT_NE(out.data, nullptr);
603 ASSERT_NE(out.len, (const unsigned int)0);
604
605 HcfFree(out.data);
606 HcfObjDestroy(sign);
607 HcfObjDestroy(verify);
608 }
609 }