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 "securec.h"
18
19 #include "alg_25519_common_param_spec.h"
20 #include "blob.h"
21 #include "params_parser.h"
22 #include "key_pair.h"
23 #include "object_base.h"
24 #include "signature.h"
25 #include "alg_25519_asy_key_generator_openssl.h"
26 #include "detailed_alg_25519_key_params.h"
27 #include "memory.h"
28 #include "memory_mock.h"
29 #include "openssl_adapter_mock.h"
30
31 using namespace std;
32 using namespace testing::ext;
33
34 namespace {
35 class CryptoEd25519AsyKeyGeneratorTest : public testing::Test {
36 public:
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 void SetUp();
40 void TearDown();
41 };
42
TearDownTestCase()43 void CryptoEd25519AsyKeyGeneratorTest::TearDownTestCase() {}
SetUp()44 void CryptoEd25519AsyKeyGeneratorTest::SetUp() {}
TearDown()45 void CryptoEd25519AsyKeyGeneratorTest::TearDown() {}
46 static string g_ed25519AlgoName = "Ed25519";
47 static string g_pubkeyformatName = "X.509";
48 static string g_prikeyformatName = "PKCS#8";
49
50 HcfBlob g_mockEd25519PriKeyBlob = {
51 .data = nullptr,
52 .len = 0
53 };
54
55 HcfBlob g_mockEd25519PubKeyBlob = {
56 .data = nullptr,
57 .len = 0
58 };
59
60 HcfBlob g_mockECC_BrainPool160r1PriKeyBlob = {
61 .data = nullptr,
62 .len = 0
63 };
64
65 HcfBlob g_mockECC_BrainPool160r1PubKeyBlob = {
66 .data = nullptr,
67 .len = 0
68 };
69
GetMockClass(void)70 static const char *GetMockClass(void)
71 {
72 return "ed25519generator";
73 }
74 HcfObjectBase g_obj = {
75 .getClass = GetMockClass,
76 .destroy = nullptr
77 };
78
79 static const char *g_mockMessage = "hello world";
80 static HcfBlob g_mockInput = {
81 .data = (uint8_t *)g_mockMessage,
82 .len = 12
83 };
84
Ed25519KeyBlob(HcfBlob * priblob,HcfBlob * pubblob)85 static HcfResult Ed25519KeyBlob(HcfBlob * priblob, HcfBlob *pubblob)
86 {
87 HcfAsyKeyGenerator *generator = nullptr;
88 HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
89 if (res != HCF_SUCCESS) {
90 return HCF_INVALID_PARAMS;
91 }
92
93 HcfKeyPair *keyPair = nullptr;
94 res = generator->generateKeyPair(generator, nullptr, &keyPair);
95 if (res != HCF_SUCCESS) {
96 HcfObjDestroy(generator);
97 return res;
98 }
99 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &g_mockEd25519PriKeyBlob);
100 if (res != HCF_SUCCESS) {
101 HcfObjDestroy(generator);
102 HcfObjDestroy(keyPair);
103 return res;
104 }
105 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &g_mockEd25519PubKeyBlob);
106 if (res != HCF_SUCCESS) {
107 HcfObjDestroy(generator);
108 HcfObjDestroy(keyPair);
109 return res;
110 }
111 HcfObjDestroy(generator);
112 HcfObjDestroy(keyPair);
113 return HCF_SUCCESS;
114 }
115
ECC_BrainPool160r1KeyBlob(HcfBlob * priblob,HcfBlob * pubblob)116 static HcfResult ECC_BrainPool160r1KeyBlob(HcfBlob * priblob, HcfBlob *pubblob)
117 {
118 HcfAsyKeyGenerator *generator = nullptr;
119 HcfResult res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator);
120 if (res != HCF_SUCCESS) {
121 return res;
122 }
123
124 HcfKeyPair *keyPair = nullptr;
125 res = generator->generateKeyPair(generator, nullptr, &keyPair);
126 if (res != HCF_SUCCESS) {
127 HcfObjDestroy(generator);
128 return res;
129 }
130 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &g_mockECC_BrainPool160r1PriKeyBlob);
131 if (res != HCF_SUCCESS) {
132 HcfObjDestroy(generator);
133 HcfObjDestroy(keyPair);
134 return res;
135 }
136 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &g_mockECC_BrainPool160r1PubKeyBlob);
137 if (res != HCF_SUCCESS) {
138 HcfObjDestroy(generator);
139 HcfObjDestroy(keyPair);
140 return res;
141 }
142 HcfObjDestroy(generator);
143 HcfObjDestroy(keyPair);
144 return HCF_SUCCESS;
145 }
146
SetUpTestCase()147 void CryptoEd25519AsyKeyGeneratorTest::SetUpTestCase()
148 {
149 HcfResult res = Ed25519KeyBlob(&g_mockEd25519PriKeyBlob, &g_mockEd25519PubKeyBlob);
150 ASSERT_EQ(res, HCF_SUCCESS);
151 res = ECC_BrainPool160r1KeyBlob(&g_mockECC_BrainPool160r1PriKeyBlob, &g_mockECC_BrainPool160r1PubKeyBlob);
152 ASSERT_EQ(res, HCF_SUCCESS);
153 }
154
155 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest001, TestSize.Level0)
156 {
157 HcfAsyKeyGenerator *generator = nullptr;
158 HcfResult res = TestHcfAsyKeyGeneratorCreate(g_ed25519AlgoName.c_str(), &generator);
159 ASSERT_EQ(res, HCF_SUCCESS);
160
161 HcfObjDestroy(generator);
162 }
163
164 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest002, TestSize.Level0)
165 {
166 HcfAsyKeyGenerator *generator = nullptr;
167 HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
168
169 const char *className = generator->base.getClass();
170
171 ASSERT_EQ(res, HCF_SUCCESS);
172 ASSERT_NE(className, nullptr);
173
174 HcfObjDestroy(generator);
175 }
176
177 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest003, TestSize.Level0)
178 {
179 HcfAsyKeyGenerator *generator = nullptr;
180 HcfResult res = TestHcfAsyKeyGeneratorCreate(g_ed25519AlgoName.c_str(), &generator);
181 ASSERT_EQ(res, HCF_SUCCESS);
182
183 generator->base.destroy((HcfObjectBase *)generator);
184 }
185
186 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest004, TestSize.Level0)
187 {
188 HcfAsyKeyGenerator *generator = nullptr;
189 HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
190
191 const char *algoName = generator->getAlgoName(generator);
192
193 ASSERT_EQ(res, HCF_SUCCESS);
194 ASSERT_EQ(algoName, g_ed25519AlgoName);
195
196 HcfObjDestroy(generator);
197 }
198
199 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest005, TestSize.Level0)
200 {
201 HcfAsyKeyGenerator *generator = nullptr;
202 HcfKeyPair *keyPair = nullptr;
203 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
204 ASSERT_EQ(res, HCF_SUCCESS);
205
206 HcfObjDestroy(keyPair);
207 HcfObjDestroy(generator);
208 }
209
210 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest006, TestSize.Level0)
211 {
212 HcfAsyKeyGenerator *generator = nullptr;
213 HcfKeyPair *keyPair = nullptr;
214
215 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
216 ASSERT_EQ(res, HCF_SUCCESS);
217
218 const char *className = keyPair->base.getClass();
219 ASSERT_NE(className, nullptr);
220
221 HcfObjDestroy(keyPair);
222 HcfObjDestroy(generator);
223 }
224
225 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest007, TestSize.Level0)
226 {
227 HcfAsyKeyGenerator *generator = nullptr;
228 HcfKeyPair *keyPair = nullptr;
229 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
230 ASSERT_EQ(res, HCF_SUCCESS);
231
232 keyPair->base.destroy(&(keyPair->base));
233
234 HcfObjDestroy(generator);
235 }
236
237 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest008, TestSize.Level0)
238 {
239 HcfAsyKeyGenerator *generator = nullptr;
240 HcfKeyPair *keyPair = nullptr;
241
242 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
243 ASSERT_EQ(res, HCF_SUCCESS);
244
245 const char *className = keyPair->pubKey->base.base.getClass();
246 ASSERT_NE(className, nullptr);
247
248 HcfObjDestroy(keyPair);
249 HcfObjDestroy(generator);
250 }
251
252 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest009, TestSize.Level0)
253 {
254 HcfAsyKeyGenerator *generator = nullptr;
255 HcfKeyPair *keyPair = nullptr;
256 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
257 ASSERT_EQ(res, HCF_SUCCESS);
258
259 keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
260 keyPair->pubKey = nullptr;
261
262 HcfObjDestroy(keyPair);
263 HcfObjDestroy(generator);
264 }
265
266 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest010, TestSize.Level0)
267 {
268 HcfAsyKeyGenerator *generator = nullptr;
269 HcfKeyPair *keyPair = nullptr;
270
271 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
272 ASSERT_EQ(res, HCF_SUCCESS);
273
274 const char *algorithmName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
275 ASSERT_EQ(algorithmName, g_ed25519AlgoName);
276
277 HcfBlob blob = { .data = nullptr, .len = 0 };
278 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
279 ASSERT_EQ(res, HCF_SUCCESS);
280 ASSERT_NE(blob.data, nullptr);
281 ASSERT_NE(blob.len, 0);
282 HcfFree(blob.data);
283 const char *formatName = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
284 ASSERT_EQ(formatName, g_pubkeyformatName);
285
286 HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
287 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ED25519_PK_BN, &returnBigInteger);
288 ASSERT_EQ(res, HCF_SUCCESS);
289 ASSERT_NE(returnBigInteger.data, nullptr);
290 ASSERT_NE(returnBigInteger.len, 0);
291 HcfFree(returnBigInteger.data);
292 HcfObjDestroy(keyPair);
293 HcfObjDestroy(generator);
294 }
295
296 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest011, TestSize.Level0)
297 {
298 HcfAsyKeyGenerator *generator = nullptr;
299 HcfKeyPair *keyPair = nullptr;
300 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
301 ASSERT_EQ(res, HCF_SUCCESS);
302
303 const char *className = keyPair->priKey->base.base.getClass();
304 ASSERT_NE(className, nullptr);
305
306 HcfObjDestroy(keyPair);
307 HcfObjDestroy(generator);
308 }
309
310 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest012, TestSize.Level0)
311 {
312 HcfAsyKeyGenerator *generator = nullptr;
313 HcfKeyPair *keyPair = nullptr;
314
315 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
316 ASSERT_EQ(res, HCF_SUCCESS);
317
318 keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
319 keyPair->priKey = nullptr;
320 HcfObjDestroy(keyPair);
321 HcfObjDestroy(generator);
322 }
323
324 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest013, TestSize.Level0)
325 {
326 HcfAsyKeyGenerator *generator = nullptr;
327 HcfKeyPair *keyPair = nullptr;
328 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
329 ASSERT_EQ(res, HCF_SUCCESS);
330
331 const char *algorithmName = keyPair->priKey->base.getAlgorithm(&(keyPair->priKey->base));
332 ASSERT_EQ(algorithmName, g_ed25519AlgoName);
333
334 HcfBlob blob = { .data = nullptr, .len = 0 };
335 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
336 ASSERT_EQ(res, HCF_SUCCESS);
337 ASSERT_NE(blob.data, nullptr);
338 ASSERT_NE(blob.len, 0);
339 HcfFree(blob.data);
340 const char *formatName = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
341 ASSERT_EQ(formatName, g_prikeyformatName);
342
343 HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
344 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ED25519_SK_BN, &returnBigInteger);
345 ASSERT_EQ(res, HCF_SUCCESS);
346 ASSERT_NE(returnBigInteger.data, nullptr);
347 ASSERT_NE(returnBigInteger.len, 0);
348 HcfFree(returnBigInteger.data);
349 HcfObjDestroy(keyPair);
350 HcfObjDestroy(generator);
351 }
352
353 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest014, TestSize.Level0)
354 {
355 HcfAsyKeyGenerator *generator = nullptr;
356 HcfKeyPair *keyPair = nullptr;
357
358 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
359 ASSERT_EQ(res, HCF_SUCCESS);
360
361 keyPair->priKey->clearMem(keyPair->priKey);
362 HcfBlob blob = { .data = nullptr, .len = 0 };
363 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
364 ASSERT_EQ(res, HCF_INVALID_PARAMS);
365 ASSERT_EQ(blob.data, nullptr);
366 ASSERT_EQ(blob.len, 0);
367 HcfFree(blob.data);
368 HcfObjDestroy(keyPair);
369 HcfObjDestroy(generator);
370 }
371
372 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest015, TestSize.Level0)
373 {
374 HcfAsyKeyGenerator *generator = nullptr;
375 HcfKeyPair *keyPair = nullptr;
376 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
377 &g_mockEd25519PriKeyBlob, &keyPair);
378 ASSERT_EQ(res, HCF_SUCCESS);
379
380 res = TestGenerateConvertKey(generator, nullptr, &g_mockEd25519PriKeyBlob, &keyPair);
381 ASSERT_EQ(res, HCF_SUCCESS);
382
383 res = TestGenerateConvertKey(generator, &g_mockEd25519PubKeyBlob, nullptr, &keyPair);
384 ASSERT_EQ(res, HCF_SUCCESS);
385
386 HcfObjDestroy(keyPair);
387 HcfObjDestroy(generator);
388 }
389
390 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest016, TestSize.Level0)
391 {
392 HcfAsyKeyGenerator *generator = nullptr;
393 HcfKeyPair *keyPair = nullptr;
394
395 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
396 &g_mockEd25519PriKeyBlob, &keyPair);
397 ASSERT_EQ(res, HCF_SUCCESS);
398
399 const char *className = keyPair->base.getClass();
400 ASSERT_NE(className, nullptr);
401
402 HcfObjDestroy(keyPair);
403 HcfObjDestroy(generator);
404 }
405
406 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest017, TestSize.Level0)
407 {
408 HcfAsyKeyGenerator *generator = nullptr;
409 HcfKeyPair *keyPair = nullptr;
410 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
411 &g_mockEd25519PriKeyBlob, &keyPair);
412 ASSERT_EQ(res, HCF_SUCCESS);
413
414 keyPair->base.destroy(&(keyPair->base));
415
416 HcfObjDestroy(generator);
417 }
418
419 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest018, TestSize.Level0)
420 {
421 HcfAsyKeyGenerator *generator = nullptr;
422 HcfKeyPair *keyPair = nullptr;
423
424 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
425 &g_mockEd25519PriKeyBlob, &keyPair);
426 ASSERT_EQ(res, HCF_SUCCESS);
427
428 const char *className = keyPair->pubKey->base.base.getClass();
429 ASSERT_NE(className, nullptr);
430
431 HcfObjDestroy(keyPair);
432 HcfObjDestroy(generator);
433 }
434
435 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest019, TestSize.Level0)
436 {
437 HcfAsyKeyGenerator *generator = nullptr;
438 HcfKeyPair *keyPair = nullptr;
439 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
440 &g_mockEd25519PriKeyBlob, &keyPair);
441 ASSERT_EQ(res, HCF_SUCCESS);
442
443 keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
444 keyPair->pubKey = nullptr;
445
446 HcfObjDestroy(keyPair);
447 HcfObjDestroy(generator);
448 }
449
450 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest020, TestSize.Level0)
451 {
452 HcfAsyKeyGenerator *generator = nullptr;
453 HcfKeyPair *keyPair = nullptr;
454
455 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
456 &g_mockEd25519PriKeyBlob, &keyPair);
457 ASSERT_EQ(res, HCF_SUCCESS);
458
459 const char *algorithmName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
460 ASSERT_EQ(algorithmName, g_ed25519AlgoName);
461
462 HcfBlob blob = { .data = nullptr, .len = 0 };
463 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
464 ASSERT_EQ(res, HCF_SUCCESS);
465 ASSERT_NE(blob.data, nullptr);
466 ASSERT_NE(blob.len, 0);
467 HcfFree(blob.data);
468 const char *formatName = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
469 ASSERT_EQ(formatName, g_pubkeyformatName);
470
471 HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
472 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ED25519_PK_BN, &returnBigInteger);
473 ASSERT_EQ(res, HCF_SUCCESS);
474 ASSERT_NE(returnBigInteger.data, nullptr);
475 ASSERT_NE(returnBigInteger.len, 0);
476 HcfFree(returnBigInteger.data);
477 HcfObjDestroy(keyPair);
478 HcfObjDestroy(generator);
479 }
480
481 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest021, TestSize.Level0)
482 {
483 HcfAsyKeyGenerator *generator = nullptr;
484 HcfKeyPair *keyPair = nullptr;
485 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
486 &g_mockEd25519PriKeyBlob, &keyPair);
487 ASSERT_EQ(res, HCF_SUCCESS);
488
489 const char *className = keyPair->priKey->base.base.getClass();
490 ASSERT_NE(className, nullptr);
491
492 HcfObjDestroy(keyPair);
493 HcfObjDestroy(generator);
494 }
495
496 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest022, TestSize.Level0)
497 {
498 HcfAsyKeyGenerator *generator = nullptr;
499 HcfKeyPair *keyPair = nullptr;
500
501 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
502 &g_mockEd25519PriKeyBlob, &keyPair);
503 ASSERT_EQ(res, HCF_SUCCESS);
504
505 keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
506 keyPair->priKey = nullptr;
507 HcfObjDestroy(keyPair);
508 HcfObjDestroy(generator);
509 }
510
511 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest023, TestSize.Level0)
512 {
513 HcfAsyKeyGenerator *generator = nullptr;
514 HcfKeyPair *keyPair = nullptr;
515 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
516 &g_mockEd25519PriKeyBlob, &keyPair);
517 ASSERT_EQ(res, HCF_SUCCESS);
518
519 const char *algorithmName = keyPair->priKey->base.getAlgorithm(&(keyPair->priKey->base));
520 ASSERT_EQ(algorithmName, g_ed25519AlgoName);
521
522 HcfBlob blob = { .data = nullptr, .len = 0 };
523 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
524 ASSERT_EQ(res, HCF_SUCCESS);
525 ASSERT_NE(blob.data, nullptr);
526 ASSERT_NE(blob.len, 0);
527 HcfFree(blob.data);
528 const char *formatName = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
529 ASSERT_EQ(formatName, g_prikeyformatName);
530
531 HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
532 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ED25519_SK_BN, &returnBigInteger);
533 ASSERT_EQ(res, HCF_SUCCESS);
534 ASSERT_NE(returnBigInteger.data, nullptr);
535 ASSERT_NE(returnBigInteger.len, 0);
536 HcfFree(returnBigInteger.data);
537 HcfObjDestroy(keyPair);
538 HcfObjDestroy(generator);
539 }
540
541 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest024, TestSize.Level0)
542 {
543 HcfAsyKeyGenerator *generator = nullptr;
544 HcfKeyPair *keyPair = nullptr;
545
546 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
547 &g_mockEd25519PriKeyBlob, &keyPair);
548 ASSERT_EQ(res, HCF_SUCCESS);
549
550 keyPair->priKey->clearMem(keyPair->priKey);
551 HcfBlob blob = { .data = nullptr, .len = 0 };
552 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
553 ASSERT_EQ(res, HCF_INVALID_PARAMS);
554 ASSERT_EQ(blob.data, nullptr);
555 ASSERT_EQ(blob.len, 0);
556 HcfFree(blob.data);
557 HcfObjDestroy(keyPair);
558 HcfObjDestroy(generator);
559 }
560
MemoryMallocTestFunc(uint32_t mallocCount)561 static void MemoryMallocTestFunc(uint32_t mallocCount)
562 {
563 for (uint32_t i = 0; i < mallocCount; i++) {
564 ResetRecordMallocNum();
565 SetMockMallocIndex(i);
566 HcfAsyKeyGenerator *tmpGenerator = nullptr;
567 HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &tmpGenerator);
568 if (res != HCF_SUCCESS) {
569 continue;
570 }
571 HcfKeyPair *tmpKeyPair = nullptr;
572 res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
573 if (res != HCF_SUCCESS) {
574 HcfObjDestroy(tmpGenerator);
575 continue;
576 }
577 HcfBlob tmpPubKeyBlob = {
578 .data = nullptr,
579 .len = 0
580 };
581 res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
582 if (res != HCF_SUCCESS) {
583 HcfObjDestroy(tmpKeyPair);
584 HcfObjDestroy(tmpGenerator);
585 continue;
586 }
587 HcfBlob tmpPriKeyBlob = {
588 .data = nullptr,
589 .len = 0
590 };
591 res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
592 if (res != HCF_SUCCESS) {
593 HcfFree(tmpPubKeyBlob.data);
594 HcfObjDestroy(tmpKeyPair);
595 HcfObjDestroy(tmpGenerator);
596 continue;
597 }
598 HcfKeyPair *tmpOutKeyPair = nullptr;
599 res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
600 HcfFree(tmpPubKeyBlob.data);
601 HcfFree(tmpPriKeyBlob.data);
602 HcfObjDestroy(tmpKeyPair);
603 HcfObjDestroy(tmpGenerator);
604 if (res == HCF_SUCCESS) {
605 HcfObjDestroy(tmpOutKeyPair);
606 }
607 }
608 }
609
610 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest025, TestSize.Level0)
611 {
612 StartRecordMallocNum();
613 HcfAsyKeyGenerator *generator = nullptr;
614 HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
615
616 HcfKeyPair *keyPair = nullptr;
617 res = generator->generateKeyPair(generator, nullptr, &keyPair);
618
619 ASSERT_EQ(res, HCF_SUCCESS);
620 ASSERT_NE(keyPair, nullptr);
621
622 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
623 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
624
625 ASSERT_EQ(res, HCF_SUCCESS);
626 ASSERT_NE(pubKeyBlob.data, nullptr);
627 ASSERT_NE(pubKeyBlob.len, 0);
628
629 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
630 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
631
632 ASSERT_EQ(res, HCF_SUCCESS);
633 ASSERT_NE(priKeyBlob.data, nullptr);
634 ASSERT_NE(priKeyBlob.len, 0);
635
636 HcfKeyPair *outKeyPair = nullptr;
637 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
638
639 HcfFree(pubKeyBlob.data);
640 HcfFree(priKeyBlob.data);
641 HcfObjDestroy(outKeyPair);
642 HcfObjDestroy(keyPair);
643 HcfObjDestroy(generator);
644
645 uint32_t mallocCount = GetMallocNum();
646 MemoryMallocTestFunc(mallocCount);
647
648 EndRecordMallocNum();
649 }
650
OpensslMockTestFunc(uint32_t mallocCount)651 static void OpensslMockTestFunc(uint32_t mallocCount)
652 {
653 for (uint32_t i = 0; i < mallocCount; i++) {
654 ResetOpensslCallNum();
655 SetOpensslCallMockIndex(i);
656 HcfAsyKeyGenerator *tmpGenerator = nullptr;
657 HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &tmpGenerator);
658 if (res != HCF_SUCCESS) {
659 continue;
660 }
661 HcfKeyPair *tmpKeyPair = nullptr;
662 res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
663 if (res != HCF_SUCCESS) {
664 HcfObjDestroy(tmpGenerator);
665 continue;
666 }
667 HcfBlob tmpPubKeyBlob = {
668 .data = nullptr,
669 .len = 0
670 };
671 res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
672 if (res != HCF_SUCCESS) {
673 HcfObjDestroy(tmpKeyPair);
674 HcfObjDestroy(tmpGenerator);
675 continue;
676 }
677 HcfBlob tmpPriKeyBlob = {
678 .data = nullptr,
679 .len = 0
680 };
681 res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
682 if (res != HCF_SUCCESS) {
683 HcfFree(tmpPubKeyBlob.data);
684 HcfObjDestroy(tmpKeyPair);
685 HcfObjDestroy(tmpGenerator);
686 continue;
687 }
688 HcfKeyPair *tmpOutKeyPair = nullptr;
689 res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
690 HcfFree(tmpPubKeyBlob.data);
691 HcfFree(tmpPriKeyBlob.data);
692 HcfObjDestroy(tmpKeyPair);
693 HcfObjDestroy(tmpGenerator);
694 if (res == HCF_SUCCESS) {
695 HcfObjDestroy(tmpOutKeyPair);
696 }
697 }
698 }
699
700 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest026, TestSize.Level0)
701 {
702 StartRecordOpensslCallNum();
703 HcfAsyKeyGenerator *generator = nullptr;
704 HcfKeyPair *keyPair = nullptr;
705 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
706 ASSERT_EQ(res, HCF_SUCCESS);
707
708 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
709 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
710
711 ASSERT_EQ(res, HCF_SUCCESS);
712 ASSERT_NE(pubKeyBlob.data, nullptr);
713 ASSERT_NE(pubKeyBlob.len, 0);
714
715 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
716 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
717
718 ASSERT_EQ(res, HCF_SUCCESS);
719 ASSERT_NE(priKeyBlob.data, nullptr);
720 ASSERT_NE(priKeyBlob.len, 0);
721
722 HcfKeyPair *outKeyPair = nullptr;
723 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
724
725 HcfFree(pubKeyBlob.data);
726 HcfFree(priKeyBlob.data);
727 HcfObjDestroy(outKeyPair);
728 HcfObjDestroy(keyPair);
729 HcfObjDestroy(generator);
730
731 uint32_t mallocCount = GetOpensslCallNum();
732 OpensslMockTestFunc(mallocCount);
733
734 EndRecordOpensslCallNum();
735 }
736
737 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest0027, TestSize.Level0)
738 {
739 HcfAsyKeyGenerator *generator = nullptr;
740
741 HcfResult res = HcfAsyKeyGeneratorCreate("ED25519", &generator);
742
743 ASSERT_EQ(res, HCF_INVALID_PARAMS);
744 ASSERT_EQ(generator, nullptr);
745
746 res = HcfAsyKeyGeneratorCreate(nullptr, &generator);
747
748 ASSERT_EQ(res, HCF_INVALID_PARAMS);
749 ASSERT_EQ(generator, nullptr);
750
751 HcfObjDestroy(generator);
752 }
753
754 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest028, TestSize.Level0)
755 {
756 HcfAsyKeyGenerator *generator = nullptr;
757 HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
758
759 ASSERT_EQ(res, HCF_SUCCESS);
760 ASSERT_NE(generator, nullptr);
761
762 const char *algoName = generator->getAlgoName(nullptr);
763 ASSERT_EQ(algoName, nullptr);
764
765 const char *algoName1 = generator->getAlgoName((HcfAsyKeyGenerator *)&g_obj);
766 ASSERT_EQ(algoName1, nullptr);
767
768 HcfObjDestroy(generator);
769 }
770
771 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest029, TestSize.Level0)
772 {
773 HcfAsyKeyGenerator *generator = nullptr;
774 HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
775
776 ASSERT_EQ(res, HCF_SUCCESS);
777 ASSERT_NE(generator, nullptr);
778
779 generator->base.destroy(nullptr);
780
781 HcfObjDestroy(generator);
782 }
783
784 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest030, TestSize.Level0)
785 {
786 HcfAsyKeyGenerator *generator = nullptr;
787 HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
788 ASSERT_EQ(res, HCF_SUCCESS);
789 ASSERT_NE(generator, nullptr);
790
791 generator->base.destroy(&g_obj);
792
793 HcfObjDestroy(generator);
794 }
795
796 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest031, TestSize.Level0)
797 {
798 HcfAsyKeyGenerator *generator = nullptr;
799 HcfKeyPair *keyPair = nullptr;
800 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
801 ASSERT_EQ(res, HCF_SUCCESS);
802
803 HcfKeyPair *failKeyPair = nullptr;
804 res = generator->generateKeyPair((HcfAsyKeyGenerator *)&g_obj, nullptr, &failKeyPair);
805 ASSERT_EQ(res, HCF_INVALID_PARAMS);
806 ASSERT_EQ(failKeyPair, nullptr);
807
808 res = generator->generateKeyPair(generator, nullptr, nullptr);
809 ASSERT_EQ(res, HCF_INVALID_PARAMS);
810
811 HcfObjDestroy(keyPair);
812 HcfObjDestroy(failKeyPair);
813 HcfObjDestroy(generator);
814 }
815
816 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest032, TestSize.Level0)
817 {
818 HcfAsyKeyGenerator *generator = nullptr;
819 HcfKeyPair *keyPair = nullptr;
820 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
821 ASSERT_EQ(res, HCF_SUCCESS);
822
823 const char *algorithmName = keyPair->pubKey->base.getAlgorithm(nullptr);
824 ASSERT_EQ(algorithmName, nullptr);
825
826 const char *algorithmName1 = keyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj);
827 ASSERT_EQ(algorithmName1, nullptr);
828
829 HcfObjDestroy(keyPair);
830 HcfObjDestroy(generator);
831 }
832
833 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest033, TestSize.Level0)
834 {
835 HcfAsyKeyGenerator *generator = nullptr;
836 HcfKeyPair *keyPair = nullptr;
837 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
838 ASSERT_EQ(res, HCF_SUCCESS);
839
840 HcfBlob blob = { .data = nullptr, .len = 0 };
841 res = keyPair->pubKey->base.getEncoded(nullptr, &blob);
842 ASSERT_EQ(res, HCF_INVALID_PARAMS);
843 ASSERT_EQ(blob.data, nullptr);
844 ASSERT_EQ(blob.len, 0);
845
846 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), nullptr);
847 ASSERT_EQ(res, HCF_INVALID_PARAMS);
848
849 res = keyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob);
850 ASSERT_EQ(res, HCF_INVALID_PARAMS);
851 ASSERT_EQ(blob.data, nullptr);
852 ASSERT_EQ(blob.len, 0);
853
854 HcfFree(blob.data);
855 HcfObjDestroy(keyPair);
856 HcfObjDestroy(generator);
857 }
858
859 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest034, TestSize.Level0)
860 {
861 HcfAsyKeyGenerator *generator = nullptr;
862 HcfKeyPair *keyPair = nullptr;
863 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
864 &g_mockEd25519PriKeyBlob, &keyPair);
865 ASSERT_EQ(res, HCF_SUCCESS);
866
867 const char *formatName = keyPair->pubKey->base.getFormat(nullptr);
868 ASSERT_EQ(formatName, nullptr);
869
870 const char *formatName1 = keyPair->pubKey->base.getFormat((HcfKey *)&g_obj);
871 ASSERT_EQ(formatName1, nullptr);
872
873 HcfObjDestroy(keyPair);
874 HcfObjDestroy(generator);
875 }
876
877 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest035, TestSize.Level0)
878 {
879 HcfAsyKeyGenerator *generator = nullptr;
880 HcfKeyPair *keyPair = nullptr;
881 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
882 ASSERT_EQ(res, HCF_SUCCESS);
883
884 HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
885 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ED25519_SK_BN, nullptr);
886 ASSERT_EQ(res, HCF_INVALID_PARAMS);
887 ASSERT_EQ(returnBigInteger.data, nullptr);
888 ASSERT_EQ(returnBigInteger.len, 0);
889
890 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, DSA_P_BN, &returnBigInteger);
891 ASSERT_EQ(res, HCF_INVALID_PARAMS);
892 ASSERT_EQ(returnBigInteger.data, nullptr);
893 ASSERT_EQ(returnBigInteger.len, 0);
894
895 res = keyPair->pubKey->getAsyKeySpecInt(keyPair->pubKey, ED25519_PK_BN, nullptr);
896 ASSERT_EQ(res, HCF_NOT_SUPPORT);
897
898 res = keyPair->pubKey->getAsyKeySpecString(keyPair->pubKey, ED25519_PK_BN, nullptr);
899 ASSERT_EQ(res, HCF_NOT_SUPPORT);
900
901 HcfFree(returnBigInteger.data);
902 HcfObjDestroy(keyPair);
903 HcfObjDestroy(generator);
904 }
905
906 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest036, TestSize.Level0)
907 {
908 HcfAsyKeyGenerator *generator = nullptr;
909 HcfKeyPair *keyPair = nullptr;
910 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
911 ASSERT_EQ(res, HCF_SUCCESS);
912
913 const char *algorithmName = keyPair->priKey->base.getAlgorithm(nullptr);
914 ASSERT_EQ(algorithmName, nullptr);
915
916 const char *algorithmName1 = keyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj);
917 ASSERT_EQ(algorithmName1, nullptr);
918
919 HcfObjDestroy(keyPair);
920 HcfObjDestroy(generator);
921 }
922
923 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest037, TestSize.Level0)
924 {
925 HcfAsyKeyGenerator *generator = nullptr;
926 HcfKeyPair *keyPair = nullptr;
927
928 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
929 ASSERT_EQ(res, HCF_SUCCESS);
930
931 HcfBlob blob = { .data = nullptr, .len = 0 };
932 res = keyPair->priKey->base.getEncoded(nullptr, &blob);
933 ASSERT_EQ(res, HCF_INVALID_PARAMS);
934 ASSERT_EQ(blob.data, nullptr);
935 ASSERT_EQ(blob.len, 0);
936
937 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), nullptr);
938 ASSERT_EQ(res, HCF_INVALID_PARAMS);
939
940 res = keyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob);
941 ASSERT_EQ(res, HCF_INVALID_PARAMS);
942 ASSERT_EQ(blob.data, nullptr);
943 ASSERT_EQ(blob.len, 0);
944
945 HcfFree(blob.data);
946 HcfObjDestroy(keyPair);
947 HcfObjDestroy(generator);
948 }
949
950 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest038, TestSize.Level0)
951 {
952 HcfAsyKeyGenerator *generator = nullptr;
953 HcfKeyPair *keyPair = nullptr;
954
955 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
956 &g_mockEd25519PriKeyBlob, &keyPair);
957 ASSERT_EQ(res, HCF_SUCCESS);
958
959 const char *formatName = formatName = keyPair->priKey->base.getFormat(nullptr);
960 ASSERT_EQ(formatName, nullptr);
961
962 const char *formatName1 = keyPair->priKey->base.getFormat((HcfKey *)&g_obj);
963 ASSERT_EQ(formatName1, nullptr);
964
965 HcfObjDestroy(keyPair);
966 HcfObjDestroy(generator);
967 }
968
969 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest039, TestSize.Level0)
970 {
971 HcfAsyKeyGenerator *generator = nullptr;
972 HcfKeyPair *keyPair = nullptr;
973
974 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
975 ASSERT_EQ(res, HCF_SUCCESS);
976
977 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ED25519_PK_BN, nullptr);
978 ASSERT_EQ(res, HCF_INVALID_PARAMS);
979 HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
980 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, DSA_P_BN, &returnBigInteger);
981 ASSERT_EQ(res, HCF_INVALID_PARAMS);
982 ASSERT_EQ(returnBigInteger.data, nullptr);
983 ASSERT_EQ(returnBigInteger.len, 0);
984 HcfFree(returnBigInteger.data);
985 res = keyPair->priKey->getAsyKeySpecInt(keyPair->priKey, ED25519_SK_BN, nullptr);
986 ASSERT_EQ(res, HCF_NOT_SUPPORT);
987
988 res = keyPair->priKey->getAsyKeySpecString(keyPair->priKey, ED25519_SK_BN, nullptr);
989 ASSERT_EQ(res, HCF_NOT_SUPPORT);
990
991 HcfObjDestroy(keyPair);
992 HcfObjDestroy(generator);
993 }
994
995 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest040, TestSize.Level0)
996 {
997 HcfAsyKeyGenerator *generator = nullptr;
998 HcfKeyPair *keyPair = nullptr;
999 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1000 &g_mockEd25519PriKeyBlob, &keyPair);
1001 ASSERT_EQ(res, HCF_SUCCESS);
1002
1003 res = generator->convertKey(generator, nullptr, &g_mockEd25519PubKeyBlob, &g_mockEd25519PriKeyBlob, nullptr);
1004 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1005
1006 HcfKeyPair *failKeyPair = nullptr;
1007 res = generator->convertKey((HcfAsyKeyGenerator *)&g_obj, nullptr, &g_mockEd25519PubKeyBlob,
1008 &g_mockEd25519PriKeyBlob, &failKeyPair);
1009 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1010 ASSERT_EQ(failKeyPair, nullptr);
1011
1012 res = generator->convertKey(generator, nullptr, nullptr, nullptr, &failKeyPair);
1013 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1014 ASSERT_EQ(failKeyPair, nullptr);
1015
1016 res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob,
1017 &g_mockECC_BrainPool160r1PriKeyBlob, &failKeyPair);
1018 ASSERT_EQ(res, HCF_ERR_CRYPTO_OPERATION);
1019 ASSERT_EQ(failKeyPair, nullptr);
1020
1021 HcfObjDestroy(keyPair);
1022 HcfObjDestroy(failKeyPair);
1023 HcfObjDestroy(generator);
1024 }
1025
1026 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest041, TestSize.Level0)
1027 {
1028 HcfAsyKeyGenerator *generator = nullptr;
1029 HcfKeyPair *keyPair = nullptr;
1030
1031 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1032 &g_mockEd25519PriKeyBlob, &keyPair);
1033 ASSERT_EQ(res, HCF_SUCCESS);
1034
1035 const char *algorithmName = keyPair->pubKey->base.getAlgorithm(nullptr);
1036 ASSERT_EQ(algorithmName, nullptr);
1037
1038 const char *algorithmName1 = keyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj);
1039 ASSERT_EQ(algorithmName1, nullptr);
1040
1041 HcfObjDestroy(keyPair);
1042 HcfObjDestroy(generator);
1043 }
1044
1045
1046 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest042, TestSize.Level0)
1047 {
1048 HcfAsyKeyGenerator *generator = nullptr;
1049 HcfKeyPair *keyPair = nullptr;
1050 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1051 &g_mockEd25519PriKeyBlob, &keyPair);
1052 ASSERT_EQ(res, HCF_SUCCESS);
1053
1054 HcfBlob blob = { .data = nullptr, .len = 0 };
1055 res = keyPair->pubKey->base.getEncoded(nullptr, &blob);
1056 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1057 ASSERT_EQ(blob.data, nullptr);
1058 ASSERT_EQ(blob.len, 0);
1059
1060 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), nullptr);
1061 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1062
1063 res = keyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob);
1064 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1065 ASSERT_EQ(blob.data, nullptr);
1066 ASSERT_EQ(blob.len, 0);
1067 HcfFree(blob.data);
1068 HcfObjDestroy(keyPair);
1069 HcfObjDestroy(generator);
1070 }
1071
1072 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest043, TestSize.Level0)
1073 {
1074 HcfAsyKeyGenerator *generator = nullptr;
1075 HcfKeyPair *keyPair = nullptr;
1076
1077 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1078 &g_mockEd25519PriKeyBlob, &keyPair);
1079 ASSERT_EQ(res, HCF_SUCCESS);
1080
1081 const char *formatName = formatName = keyPair->pubKey->base.getFormat(nullptr);
1082 ASSERT_EQ(formatName, nullptr);
1083
1084 const char *formatName1 = keyPair->pubKey->base.getFormat((HcfKey *)&g_obj);
1085 ASSERT_EQ(formatName1, nullptr);
1086
1087 HcfObjDestroy(keyPair);
1088 HcfObjDestroy(generator);
1089 }
1090
1091 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest044, TestSize.Level0)
1092 {
1093 HcfAsyKeyGenerator *generator = nullptr;
1094 HcfKeyPair *keyPair = nullptr;
1095 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1096 &g_mockEd25519PriKeyBlob, &keyPair);
1097 ASSERT_EQ(res, HCF_SUCCESS);
1098
1099 const char *algorithmName = keyPair->priKey->base.getAlgorithm(nullptr);
1100 ASSERT_EQ(algorithmName, nullptr);
1101
1102 const char *algorithmName1 = keyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj);
1103 ASSERT_EQ(algorithmName1, nullptr);
1104
1105 HcfObjDestroy(keyPair);
1106 HcfObjDestroy(generator);
1107 }
1108
1109 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest045, TestSize.Level0)
1110 {
1111 HcfAsyKeyGenerator *generator = nullptr;
1112 HcfKeyPair *keyPair = nullptr;
1113
1114 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1115 &g_mockEd25519PriKeyBlob, &keyPair);
1116 ASSERT_EQ(res, HCF_SUCCESS);
1117
1118 HcfBlob blob = { .data = nullptr, .len = 0 };
1119 res = keyPair->priKey->base.getEncoded(nullptr, &blob);
1120 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1121 ASSERT_EQ(blob.data, nullptr);
1122 ASSERT_EQ(blob.len, 0);
1123
1124 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), nullptr);
1125 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1126
1127 res = keyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob);
1128 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1129 ASSERT_EQ(blob.data, nullptr);
1130 ASSERT_EQ(blob.len, 0);
1131
1132 HcfFree(blob.data);
1133 HcfObjDestroy(keyPair);
1134 HcfObjDestroy(generator);
1135 }
1136
1137 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest046, TestSize.Level0)
1138 {
1139 HcfAsyKeyGenerator *generator = nullptr;
1140 HcfKeyPair *keyPair = nullptr;
1141 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1142 &g_mockEd25519PriKeyBlob, &keyPair);
1143 ASSERT_EQ(res, HCF_SUCCESS);
1144
1145 const char *formatName = formatName = keyPair->priKey->base.getFormat(nullptr);
1146 ASSERT_EQ(formatName, nullptr);
1147
1148 const char *formatName1 = keyPair->priKey->base.getFormat((HcfKey *)&g_obj);
1149 ASSERT_EQ(formatName1, nullptr);
1150
1151 HcfObjDestroy(keyPair);
1152 HcfObjDestroy(generator);
1153 }
1154
1155 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest047, TestSize.Level0)
1156 {
1157 HcfAsyKeyGenerator *generator = nullptr;
1158 HcfKeyPair *keyPair = nullptr;
1159
1160 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1161 &g_mockEd25519PriKeyBlob, &keyPair);
1162 ASSERT_EQ(res, HCF_SUCCESS);
1163
1164 keyPair->priKey->clearMem(nullptr);
1165 HcfBlob blob = { .data = nullptr, .len = 0 };
1166 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
1167 ASSERT_EQ(res, HCF_SUCCESS);
1168 ASSERT_NE(blob.data, nullptr);
1169 ASSERT_NE(blob.len, 0);
1170 HcfFree(blob.data);
1171 HcfObjDestroy(keyPair);
1172 HcfObjDestroy(generator);
1173 }
1174
1175 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest048, TestSize.Level0)
1176 {
1177 HcfAsyKeyGenerator *generator = nullptr;
1178 HcfKeyPair *keyPair = nullptr;
1179 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1180 &g_mockEd25519PriKeyBlob, &keyPair);
1181 ASSERT_EQ(res, HCF_SUCCESS);
1182
1183 keyPair->priKey->clearMem((HcfPriKey *)&g_obj);
1184 HcfBlob blob = { .data = nullptr, .len = 0 };
1185 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
1186 ASSERT_EQ(res, HCF_SUCCESS);
1187 ASSERT_NE(blob.data, nullptr);
1188 ASSERT_NE(blob.len, 0);
1189 HcfFree(blob.data);
1190 HcfObjDestroy(keyPair);
1191 HcfObjDestroy(generator);
1192 }
1193
1194 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest049, TestSize.Level0)
1195 {
1196 HcfAsyKeyGenerator *generator = nullptr;
1197 HcfKeyPair *keyPair = nullptr;
1198
1199 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
1200 ASSERT_EQ(res, HCF_SUCCESS);
1201
1202 keyPair->pubKey->base.base.destroy(nullptr);
1203 HcfObjDestroy(keyPair);
1204 HcfObjDestroy(generator);
1205 }
1206
1207 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest050, TestSize.Level0)
1208 {
1209 HcfAsyKeyGenerator *generator = nullptr;
1210 HcfKeyPair *keyPair = nullptr;
1211 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
1212 ASSERT_EQ(res, HCF_SUCCESS);
1213
1214 keyPair->pubKey->base.base.destroy(&g_obj);
1215 HcfObjDestroy(keyPair);
1216 HcfObjDestroy(generator);
1217 }
1218
1219 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest051, TestSize.Level0)
1220 {
1221 HcfAsyKeyGenerator *generator = nullptr;
1222 HcfKeyPair *keyPair = nullptr;
1223
1224 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
1225 ASSERT_EQ(res, HCF_SUCCESS);
1226
1227 keyPair->priKey->base.base.destroy(nullptr);
1228 HcfObjDestroy(keyPair);
1229 HcfObjDestroy(generator);
1230 }
1231
1232 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest052, TestSize.Level0)
1233 {
1234 HcfAsyKeyGenerator *generator = nullptr;
1235 HcfKeyPair *keyPair = nullptr;
1236 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
1237 ASSERT_EQ(res, HCF_SUCCESS);
1238
1239 keyPair->priKey->base.base.destroy(&g_obj);
1240 HcfObjDestroy(keyPair);
1241 HcfObjDestroy(generator);
1242 }
1243
1244 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest053, TestSize.Level0)
1245 {
1246 HcfAsyKeyGenerator *generator = nullptr;
1247 HcfKeyPair *keyPair = nullptr;
1248
1249 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
1250 ASSERT_EQ(res, HCF_SUCCESS);
1251
1252 HcfSign *sign = nullptr;
1253 res = HcfSignCreate("Ed25519", &sign);
1254 ASSERT_EQ(res, HCF_SUCCESS);
1255 res = sign->init(sign, nullptr, keyPair->priKey);
1256 ASSERT_EQ(res, HCF_SUCCESS);
1257 HcfBlob out = { .data = nullptr, .len = 0 };
1258 res = sign->sign(sign, &g_mockInput, &out);
1259 ASSERT_EQ(res, HCF_SUCCESS);
1260 ASSERT_NE(out.data, nullptr);
1261 ASSERT_NE(out.len, 0);
1262
1263 HcfVerify *verify = nullptr;
1264 res = HcfVerifyCreate("Ed25519", &verify);
1265 ASSERT_EQ(res, HCF_SUCCESS);
1266 res = verify->init(verify, nullptr, keyPair->pubKey);
1267 ASSERT_EQ(res, HCF_SUCCESS);
1268
1269 bool flag = verify->verify(verify, &g_mockInput, &out);
1270 ASSERT_EQ(flag, true);
1271 ASSERT_NE(out.data, nullptr);
1272 ASSERT_NE(out.len, 0);
1273 HcfFree(out.data);
1274 HcfObjDestroy(keyPair);
1275 HcfObjDestroy(generator);
1276 HcfObjDestroy(sign);
1277 HcfObjDestroy(verify);
1278 }
1279 }