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