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