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