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 HcfObjDestroy(keyPair);
380
381 res = TestGenerateConvertKey(generator, nullptr, &g_mockEd25519PriKeyBlob, &keyPair);
382 ASSERT_EQ(res, HCF_SUCCESS);
383 HcfObjDestroy(keyPair);
384
385 res = TestGenerateConvertKey(generator, &g_mockEd25519PubKeyBlob, nullptr, &keyPair);
386 ASSERT_EQ(res, HCF_SUCCESS);
387
388 HcfObjDestroy(keyPair);
389 HcfObjDestroy(generator);
390 }
391
392 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest016, TestSize.Level0)
393 {
394 HcfAsyKeyGenerator *generator = nullptr;
395 HcfKeyPair *keyPair = nullptr;
396
397 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
398 &g_mockEd25519PriKeyBlob, &keyPair);
399 ASSERT_EQ(res, HCF_SUCCESS);
400
401 const char *className = keyPair->base.getClass();
402 ASSERT_NE(className, nullptr);
403
404 HcfObjDestroy(keyPair);
405 HcfObjDestroy(generator);
406 }
407
408 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest017, TestSize.Level0)
409 {
410 HcfAsyKeyGenerator *generator = nullptr;
411 HcfKeyPair *keyPair = nullptr;
412 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
413 &g_mockEd25519PriKeyBlob, &keyPair);
414 ASSERT_EQ(res, HCF_SUCCESS);
415
416 keyPair->base.destroy(&(keyPair->base));
417
418 HcfObjDestroy(generator);
419 }
420
421 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest018, TestSize.Level0)
422 {
423 HcfAsyKeyGenerator *generator = nullptr;
424 HcfKeyPair *keyPair = nullptr;
425
426 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
427 &g_mockEd25519PriKeyBlob, &keyPair);
428 ASSERT_EQ(res, HCF_SUCCESS);
429
430 const char *className = keyPair->pubKey->base.base.getClass();
431 ASSERT_NE(className, nullptr);
432
433 HcfObjDestroy(keyPair);
434 HcfObjDestroy(generator);
435 }
436
437 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest019, TestSize.Level0)
438 {
439 HcfAsyKeyGenerator *generator = nullptr;
440 HcfKeyPair *keyPair = nullptr;
441 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
442 &g_mockEd25519PriKeyBlob, &keyPair);
443 ASSERT_EQ(res, HCF_SUCCESS);
444
445 keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
446 keyPair->pubKey = nullptr;
447
448 HcfObjDestroy(keyPair);
449 HcfObjDestroy(generator);
450 }
451
452 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest020, TestSize.Level0)
453 {
454 HcfAsyKeyGenerator *generator = nullptr;
455 HcfKeyPair *keyPair = nullptr;
456
457 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
458 &g_mockEd25519PriKeyBlob, &keyPair);
459 ASSERT_EQ(res, HCF_SUCCESS);
460
461 const char *algorithmName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
462 ASSERT_EQ(algorithmName, g_ed25519AlgoName);
463
464 HcfBlob blob = { .data = nullptr, .len = 0 };
465 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
466 ASSERT_EQ(res, HCF_SUCCESS);
467 ASSERT_NE(blob.data, nullptr);
468 ASSERT_NE(blob.len, 0);
469 HcfFree(blob.data);
470 const char *formatName = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
471 ASSERT_EQ(formatName, g_pubkeyformatName);
472
473 HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
474 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ED25519_PK_BN, &returnBigInteger);
475 ASSERT_EQ(res, HCF_SUCCESS);
476 ASSERT_NE(returnBigInteger.data, nullptr);
477 ASSERT_NE(returnBigInteger.len, 0);
478 HcfFree(returnBigInteger.data);
479 HcfObjDestroy(keyPair);
480 HcfObjDestroy(generator);
481 }
482
483 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest021, TestSize.Level0)
484 {
485 HcfAsyKeyGenerator *generator = nullptr;
486 HcfKeyPair *keyPair = nullptr;
487 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
488 &g_mockEd25519PriKeyBlob, &keyPair);
489 ASSERT_EQ(res, HCF_SUCCESS);
490
491 const char *className = keyPair->priKey->base.base.getClass();
492 ASSERT_NE(className, nullptr);
493
494 HcfObjDestroy(keyPair);
495 HcfObjDestroy(generator);
496 }
497
498 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest022, TestSize.Level0)
499 {
500 HcfAsyKeyGenerator *generator = nullptr;
501 HcfKeyPair *keyPair = nullptr;
502
503 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
504 &g_mockEd25519PriKeyBlob, &keyPair);
505 ASSERT_EQ(res, HCF_SUCCESS);
506
507 keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
508 keyPair->priKey = nullptr;
509 HcfObjDestroy(keyPair);
510 HcfObjDestroy(generator);
511 }
512
513 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest023, TestSize.Level0)
514 {
515 HcfAsyKeyGenerator *generator = nullptr;
516 HcfKeyPair *keyPair = nullptr;
517 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
518 &g_mockEd25519PriKeyBlob, &keyPair);
519 ASSERT_EQ(res, HCF_SUCCESS);
520
521 const char *algorithmName = keyPair->priKey->base.getAlgorithm(&(keyPair->priKey->base));
522 ASSERT_EQ(algorithmName, g_ed25519AlgoName);
523
524 HcfBlob blob = { .data = nullptr, .len = 0 };
525 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
526 ASSERT_EQ(res, HCF_SUCCESS);
527 ASSERT_NE(blob.data, nullptr);
528 ASSERT_NE(blob.len, 0);
529 HcfFree(blob.data);
530 const char *formatName = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
531 ASSERT_EQ(formatName, g_prikeyformatName);
532
533 HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
534 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ED25519_SK_BN, &returnBigInteger);
535 ASSERT_EQ(res, HCF_SUCCESS);
536 ASSERT_NE(returnBigInteger.data, nullptr);
537 ASSERT_NE(returnBigInteger.len, 0);
538 HcfFree(returnBigInteger.data);
539 HcfObjDestroy(keyPair);
540 HcfObjDestroy(generator);
541 }
542
543 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest024, TestSize.Level0)
544 {
545 HcfAsyKeyGenerator *generator = nullptr;
546 HcfKeyPair *keyPair = nullptr;
547
548 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
549 &g_mockEd25519PriKeyBlob, &keyPair);
550 ASSERT_EQ(res, HCF_SUCCESS);
551
552 keyPair->priKey->clearMem(keyPair->priKey);
553 HcfBlob blob = { .data = nullptr, .len = 0 };
554 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
555 ASSERT_EQ(res, HCF_INVALID_PARAMS);
556 ASSERT_EQ(blob.data, nullptr);
557 ASSERT_EQ(blob.len, 0);
558 HcfFree(blob.data);
559 HcfObjDestroy(keyPair);
560 HcfObjDestroy(generator);
561 }
562
MemoryMallocTestFunc(uint32_t mallocCount)563 static void MemoryMallocTestFunc(uint32_t mallocCount)
564 {
565 for (uint32_t i = 0; i < mallocCount; i++) {
566 ResetRecordMallocNum();
567 SetMockMallocIndex(i);
568 HcfAsyKeyGenerator *tmpGenerator = nullptr;
569 HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &tmpGenerator);
570 if (res != HCF_SUCCESS) {
571 continue;
572 }
573 HcfKeyPair *tmpKeyPair = nullptr;
574 res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
575 if (res != HCF_SUCCESS) {
576 HcfObjDestroy(tmpGenerator);
577 continue;
578 }
579 HcfBlob tmpPubKeyBlob = {
580 .data = nullptr,
581 .len = 0
582 };
583 res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
584 if (res != HCF_SUCCESS) {
585 HcfObjDestroy(tmpKeyPair);
586 HcfObjDestroy(tmpGenerator);
587 continue;
588 }
589 HcfBlob tmpPriKeyBlob = {
590 .data = nullptr,
591 .len = 0
592 };
593 res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
594 if (res != HCF_SUCCESS) {
595 HcfFree(tmpPubKeyBlob.data);
596 HcfObjDestroy(tmpKeyPair);
597 HcfObjDestroy(tmpGenerator);
598 continue;
599 }
600 HcfKeyPair *tmpOutKeyPair = nullptr;
601 res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
602 HcfFree(tmpPubKeyBlob.data);
603 HcfFree(tmpPriKeyBlob.data);
604 HcfObjDestroy(tmpKeyPair);
605 HcfObjDestroy(tmpGenerator);
606 if (res == HCF_SUCCESS) {
607 HcfObjDestroy(tmpOutKeyPair);
608 }
609 }
610 }
611
612 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest025, TestSize.Level0)
613 {
614 StartRecordMallocNum();
615 HcfAsyKeyGenerator *generator = nullptr;
616 HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
617
618 HcfKeyPair *keyPair = nullptr;
619 res = generator->generateKeyPair(generator, nullptr, &keyPair);
620
621 ASSERT_EQ(res, HCF_SUCCESS);
622 ASSERT_NE(keyPair, nullptr);
623
624 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
625 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
626
627 ASSERT_EQ(res, HCF_SUCCESS);
628 ASSERT_NE(pubKeyBlob.data, nullptr);
629 ASSERT_NE(pubKeyBlob.len, 0);
630
631 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
632 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
633
634 ASSERT_EQ(res, HCF_SUCCESS);
635 ASSERT_NE(priKeyBlob.data, nullptr);
636 ASSERT_NE(priKeyBlob.len, 0);
637
638 HcfKeyPair *outKeyPair = nullptr;
639 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
640
641 HcfFree(pubKeyBlob.data);
642 HcfFree(priKeyBlob.data);
643 HcfObjDestroy(outKeyPair);
644 HcfObjDestroy(keyPair);
645 HcfObjDestroy(generator);
646
647 uint32_t mallocCount = GetMallocNum();
648 MemoryMallocTestFunc(mallocCount);
649
650 EndRecordMallocNum();
651 }
652
OpensslMockTestFunc(uint32_t mallocCount)653 static void OpensslMockTestFunc(uint32_t mallocCount)
654 {
655 for (uint32_t i = 0; i < mallocCount; i++) {
656 ResetOpensslCallNum();
657 SetOpensslCallMockIndex(i);
658 HcfAsyKeyGenerator *tmpGenerator = nullptr;
659 HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &tmpGenerator);
660 if (res != HCF_SUCCESS) {
661 continue;
662 }
663 HcfKeyPair *tmpKeyPair = nullptr;
664 res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
665 if (res != HCF_SUCCESS) {
666 HcfObjDestroy(tmpGenerator);
667 continue;
668 }
669 HcfBlob tmpPubKeyBlob = {
670 .data = nullptr,
671 .len = 0
672 };
673 res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
674 if (res != HCF_SUCCESS) {
675 HcfObjDestroy(tmpKeyPair);
676 HcfObjDestroy(tmpGenerator);
677 continue;
678 }
679 HcfBlob tmpPriKeyBlob = {
680 .data = nullptr,
681 .len = 0
682 };
683 res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
684 if (res != HCF_SUCCESS) {
685 HcfFree(tmpPubKeyBlob.data);
686 HcfObjDestroy(tmpKeyPair);
687 HcfObjDestroy(tmpGenerator);
688 continue;
689 }
690 HcfKeyPair *tmpOutKeyPair = nullptr;
691 res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
692 HcfFree(tmpPubKeyBlob.data);
693 HcfFree(tmpPriKeyBlob.data);
694 HcfObjDestroy(tmpKeyPair);
695 HcfObjDestroy(tmpGenerator);
696 if (res == HCF_SUCCESS) {
697 HcfObjDestroy(tmpOutKeyPair);
698 }
699 }
700 }
701
702 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest026, TestSize.Level0)
703 {
704 StartRecordOpensslCallNum();
705 HcfAsyKeyGenerator *generator = nullptr;
706 HcfKeyPair *keyPair = nullptr;
707 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
708 ASSERT_EQ(res, HCF_SUCCESS);
709
710 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
711 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
712
713 ASSERT_EQ(res, HCF_SUCCESS);
714 ASSERT_NE(pubKeyBlob.data, nullptr);
715 ASSERT_NE(pubKeyBlob.len, 0);
716
717 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
718 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
719
720 ASSERT_EQ(res, HCF_SUCCESS);
721 ASSERT_NE(priKeyBlob.data, nullptr);
722 ASSERT_NE(priKeyBlob.len, 0);
723
724 HcfKeyPair *outKeyPair = nullptr;
725 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
726
727 HcfFree(pubKeyBlob.data);
728 HcfFree(priKeyBlob.data);
729 HcfObjDestroy(outKeyPair);
730 HcfObjDestroy(keyPair);
731 HcfObjDestroy(generator);
732
733 uint32_t mallocCount = GetOpensslCallNum();
734 OpensslMockTestFunc(mallocCount);
735
736 EndRecordOpensslCallNum();
737 }
738
739 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest0027, TestSize.Level0)
740 {
741 HcfAsyKeyGenerator *generator = nullptr;
742
743 HcfResult res = HcfAsyKeyGeneratorCreate("ED25519", &generator);
744
745 ASSERT_EQ(res, HCF_INVALID_PARAMS);
746 ASSERT_EQ(generator, nullptr);
747
748 res = HcfAsyKeyGeneratorCreate(nullptr, &generator);
749
750 ASSERT_EQ(res, HCF_INVALID_PARAMS);
751 ASSERT_EQ(generator, nullptr);
752
753 HcfObjDestroy(generator);
754 }
755
756 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest028, TestSize.Level0)
757 {
758 HcfAsyKeyGenerator *generator = nullptr;
759 HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
760
761 ASSERT_EQ(res, HCF_SUCCESS);
762 ASSERT_NE(generator, nullptr);
763
764 const char *algoName = generator->getAlgoName(nullptr);
765 ASSERT_EQ(algoName, nullptr);
766
767 const char *algoName1 = generator->getAlgoName((HcfAsyKeyGenerator *)&g_obj);
768 ASSERT_EQ(algoName1, nullptr);
769
770 HcfObjDestroy(generator);
771 }
772
773 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest029, TestSize.Level0)
774 {
775 HcfAsyKeyGenerator *generator = nullptr;
776 HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
777
778 ASSERT_EQ(res, HCF_SUCCESS);
779 ASSERT_NE(generator, nullptr);
780
781 generator->base.destroy(nullptr);
782
783 HcfObjDestroy(generator);
784 }
785
786 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest030, TestSize.Level0)
787 {
788 HcfAsyKeyGenerator *generator = nullptr;
789 HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
790 ASSERT_EQ(res, HCF_SUCCESS);
791 ASSERT_NE(generator, nullptr);
792
793 generator->base.destroy(&g_obj);
794
795 HcfObjDestroy(generator);
796 }
797
798 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest031, TestSize.Level0)
799 {
800 HcfAsyKeyGenerator *generator = nullptr;
801 HcfKeyPair *keyPair = nullptr;
802 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
803 ASSERT_EQ(res, HCF_SUCCESS);
804
805 HcfKeyPair *failKeyPair = nullptr;
806 res = generator->generateKeyPair((HcfAsyKeyGenerator *)&g_obj, nullptr, &failKeyPair);
807 ASSERT_EQ(res, HCF_INVALID_PARAMS);
808 ASSERT_EQ(failKeyPair, nullptr);
809
810 res = generator->generateKeyPair(generator, nullptr, nullptr);
811 ASSERT_EQ(res, HCF_INVALID_PARAMS);
812
813 HcfObjDestroy(keyPair);
814 HcfObjDestroy(failKeyPair);
815 HcfObjDestroy(generator);
816 }
817
818 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest032, TestSize.Level0)
819 {
820 HcfAsyKeyGenerator *generator = nullptr;
821 HcfKeyPair *keyPair = nullptr;
822 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
823 ASSERT_EQ(res, HCF_SUCCESS);
824
825 const char *algorithmName = keyPair->pubKey->base.getAlgorithm(nullptr);
826 ASSERT_EQ(algorithmName, nullptr);
827
828 const char *algorithmName1 = keyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj);
829 ASSERT_EQ(algorithmName1, nullptr);
830
831 HcfObjDestroy(keyPair);
832 HcfObjDestroy(generator);
833 }
834
835 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest033, TestSize.Level0)
836 {
837 HcfAsyKeyGenerator *generator = nullptr;
838 HcfKeyPair *keyPair = nullptr;
839 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
840 ASSERT_EQ(res, HCF_SUCCESS);
841
842 HcfBlob blob = { .data = nullptr, .len = 0 };
843 res = keyPair->pubKey->base.getEncoded(nullptr, &blob);
844 ASSERT_EQ(res, HCF_INVALID_PARAMS);
845 ASSERT_EQ(blob.data, nullptr);
846 ASSERT_EQ(blob.len, 0);
847
848 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), nullptr);
849 ASSERT_EQ(res, HCF_INVALID_PARAMS);
850
851 res = keyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob);
852 ASSERT_EQ(res, HCF_INVALID_PARAMS);
853 ASSERT_EQ(blob.data, nullptr);
854 ASSERT_EQ(blob.len, 0);
855
856 HcfFree(blob.data);
857 HcfObjDestroy(keyPair);
858 HcfObjDestroy(generator);
859 }
860
861 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest034, TestSize.Level0)
862 {
863 HcfAsyKeyGenerator *generator = nullptr;
864 HcfKeyPair *keyPair = nullptr;
865 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
866 &g_mockEd25519PriKeyBlob, &keyPair);
867 ASSERT_EQ(res, HCF_SUCCESS);
868
869 const char *formatName = keyPair->pubKey->base.getFormat(nullptr);
870 ASSERT_EQ(formatName, nullptr);
871
872 const char *formatName1 = keyPair->pubKey->base.getFormat((HcfKey *)&g_obj);
873 ASSERT_EQ(formatName1, nullptr);
874
875 HcfObjDestroy(keyPair);
876 HcfObjDestroy(generator);
877 }
878
879 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest035, TestSize.Level0)
880 {
881 HcfAsyKeyGenerator *generator = nullptr;
882 HcfKeyPair *keyPair = nullptr;
883 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
884 ASSERT_EQ(res, HCF_SUCCESS);
885
886 HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
887 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ED25519_SK_BN, nullptr);
888 ASSERT_EQ(res, HCF_INVALID_PARAMS);
889 ASSERT_EQ(returnBigInteger.data, nullptr);
890 ASSERT_EQ(returnBigInteger.len, 0);
891
892 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, DSA_P_BN, &returnBigInteger);
893 ASSERT_EQ(res, HCF_INVALID_PARAMS);
894 ASSERT_EQ(returnBigInteger.data, nullptr);
895 ASSERT_EQ(returnBigInteger.len, 0);
896
897 res = keyPair->pubKey->getAsyKeySpecInt(keyPair->pubKey, ED25519_PK_BN, nullptr);
898 ASSERT_EQ(res, HCF_NOT_SUPPORT);
899
900 res = keyPair->pubKey->getAsyKeySpecString(keyPair->pubKey, ED25519_PK_BN, nullptr);
901 ASSERT_EQ(res, HCF_NOT_SUPPORT);
902
903 HcfFree(returnBigInteger.data);
904 HcfObjDestroy(keyPair);
905 HcfObjDestroy(generator);
906 }
907
908 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest036, TestSize.Level0)
909 {
910 HcfAsyKeyGenerator *generator = nullptr;
911 HcfKeyPair *keyPair = nullptr;
912 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
913 ASSERT_EQ(res, HCF_SUCCESS);
914
915 const char *algorithmName = keyPair->priKey->base.getAlgorithm(nullptr);
916 ASSERT_EQ(algorithmName, nullptr);
917
918 const char *algorithmName1 = keyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj);
919 ASSERT_EQ(algorithmName1, nullptr);
920
921 HcfObjDestroy(keyPair);
922 HcfObjDestroy(generator);
923 }
924
925 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest037, TestSize.Level0)
926 {
927 HcfAsyKeyGenerator *generator = nullptr;
928 HcfKeyPair *keyPair = nullptr;
929
930 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
931 ASSERT_EQ(res, HCF_SUCCESS);
932
933 HcfBlob blob = { .data = nullptr, .len = 0 };
934 res = keyPair->priKey->base.getEncoded(nullptr, &blob);
935 ASSERT_EQ(res, HCF_INVALID_PARAMS);
936 ASSERT_EQ(blob.data, nullptr);
937 ASSERT_EQ(blob.len, 0);
938
939 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), nullptr);
940 ASSERT_EQ(res, HCF_INVALID_PARAMS);
941
942 res = keyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob);
943 ASSERT_EQ(res, HCF_INVALID_PARAMS);
944 ASSERT_EQ(blob.data, nullptr);
945 ASSERT_EQ(blob.len, 0);
946
947 HcfFree(blob.data);
948 HcfObjDestroy(keyPair);
949 HcfObjDestroy(generator);
950 }
951
952 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest038, TestSize.Level0)
953 {
954 HcfAsyKeyGenerator *generator = nullptr;
955 HcfKeyPair *keyPair = nullptr;
956
957 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
958 &g_mockEd25519PriKeyBlob, &keyPair);
959 ASSERT_EQ(res, HCF_SUCCESS);
960
961 const char *formatName = formatName = keyPair->priKey->base.getFormat(nullptr);
962 ASSERT_EQ(formatName, nullptr);
963
964 const char *formatName1 = keyPair->priKey->base.getFormat((HcfKey *)&g_obj);
965 ASSERT_EQ(formatName1, nullptr);
966
967 HcfObjDestroy(keyPair);
968 HcfObjDestroy(generator);
969 }
970
971 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest039, TestSize.Level0)
972 {
973 HcfAsyKeyGenerator *generator = nullptr;
974 HcfKeyPair *keyPair = nullptr;
975
976 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
977 ASSERT_EQ(res, HCF_SUCCESS);
978
979 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ED25519_PK_BN, nullptr);
980 ASSERT_EQ(res, HCF_INVALID_PARAMS);
981 HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
982 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, DSA_P_BN, &returnBigInteger);
983 ASSERT_EQ(res, HCF_INVALID_PARAMS);
984 ASSERT_EQ(returnBigInteger.data, nullptr);
985 ASSERT_EQ(returnBigInteger.len, 0);
986 HcfFree(returnBigInteger.data);
987 res = keyPair->priKey->getAsyKeySpecInt(keyPair->priKey, ED25519_SK_BN, nullptr);
988 ASSERT_EQ(res, HCF_NOT_SUPPORT);
989
990 res = keyPair->priKey->getAsyKeySpecString(keyPair->priKey, ED25519_SK_BN, nullptr);
991 ASSERT_EQ(res, HCF_NOT_SUPPORT);
992
993 HcfObjDestroy(keyPair);
994 HcfObjDestroy(generator);
995 }
996
997 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest040, TestSize.Level0)
998 {
999 HcfAsyKeyGenerator *generator = nullptr;
1000 HcfKeyPair *keyPair = nullptr;
1001 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1002 &g_mockEd25519PriKeyBlob, &keyPair);
1003 ASSERT_EQ(res, HCF_SUCCESS);
1004
1005 res = generator->convertKey(generator, nullptr, &g_mockEd25519PubKeyBlob, &g_mockEd25519PriKeyBlob, nullptr);
1006 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1007
1008 HcfKeyPair *failKeyPair = nullptr;
1009 res = generator->convertKey((HcfAsyKeyGenerator *)&g_obj, nullptr, &g_mockEd25519PubKeyBlob,
1010 &g_mockEd25519PriKeyBlob, &failKeyPair);
1011 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1012 ASSERT_EQ(failKeyPair, nullptr);
1013
1014 res = generator->convertKey(generator, nullptr, nullptr, nullptr, &failKeyPair);
1015 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1016 ASSERT_EQ(failKeyPair, nullptr);
1017
1018 res = generator->convertKey(generator, nullptr, &g_mockECC_BrainPool160r1PubKeyBlob,
1019 &g_mockECC_BrainPool160r1PriKeyBlob, &failKeyPair);
1020 ASSERT_EQ(res, HCF_ERR_CRYPTO_OPERATION);
1021 ASSERT_EQ(failKeyPair, nullptr);
1022
1023 HcfObjDestroy(keyPair);
1024 HcfObjDestroy(failKeyPair);
1025 HcfObjDestroy(generator);
1026 }
1027
1028 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest041, TestSize.Level0)
1029 {
1030 HcfAsyKeyGenerator *generator = nullptr;
1031 HcfKeyPair *keyPair = nullptr;
1032
1033 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1034 &g_mockEd25519PriKeyBlob, &keyPair);
1035 ASSERT_EQ(res, HCF_SUCCESS);
1036
1037 const char *algorithmName = keyPair->pubKey->base.getAlgorithm(nullptr);
1038 ASSERT_EQ(algorithmName, nullptr);
1039
1040 const char *algorithmName1 = keyPair->pubKey->base.getAlgorithm((HcfKey *)&g_obj);
1041 ASSERT_EQ(algorithmName1, nullptr);
1042
1043 HcfObjDestroy(keyPair);
1044 HcfObjDestroy(generator);
1045 }
1046
1047
1048 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest042, TestSize.Level0)
1049 {
1050 HcfAsyKeyGenerator *generator = nullptr;
1051 HcfKeyPair *keyPair = nullptr;
1052 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1053 &g_mockEd25519PriKeyBlob, &keyPair);
1054 ASSERT_EQ(res, HCF_SUCCESS);
1055
1056 HcfBlob blob = { .data = nullptr, .len = 0 };
1057 res = keyPair->pubKey->base.getEncoded(nullptr, &blob);
1058 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1059 ASSERT_EQ(blob.data, nullptr);
1060 ASSERT_EQ(blob.len, 0);
1061
1062 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), nullptr);
1063 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1064
1065 res = keyPair->pubKey->base.getEncoded((HcfKey *)&g_obj, &blob);
1066 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1067 ASSERT_EQ(blob.data, nullptr);
1068 ASSERT_EQ(blob.len, 0);
1069 HcfFree(blob.data);
1070 HcfObjDestroy(keyPair);
1071 HcfObjDestroy(generator);
1072 }
1073
1074 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest043, TestSize.Level0)
1075 {
1076 HcfAsyKeyGenerator *generator = nullptr;
1077 HcfKeyPair *keyPair = nullptr;
1078
1079 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1080 &g_mockEd25519PriKeyBlob, &keyPair);
1081 ASSERT_EQ(res, HCF_SUCCESS);
1082
1083 const char *formatName = formatName = keyPair->pubKey->base.getFormat(nullptr);
1084 ASSERT_EQ(formatName, nullptr);
1085
1086 const char *formatName1 = keyPair->pubKey->base.getFormat((HcfKey *)&g_obj);
1087 ASSERT_EQ(formatName1, nullptr);
1088
1089 HcfObjDestroy(keyPair);
1090 HcfObjDestroy(generator);
1091 }
1092
1093 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest044, TestSize.Level0)
1094 {
1095 HcfAsyKeyGenerator *generator = nullptr;
1096 HcfKeyPair *keyPair = nullptr;
1097 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1098 &g_mockEd25519PriKeyBlob, &keyPair);
1099 ASSERT_EQ(res, HCF_SUCCESS);
1100
1101 const char *algorithmName = keyPair->priKey->base.getAlgorithm(nullptr);
1102 ASSERT_EQ(algorithmName, nullptr);
1103
1104 const char *algorithmName1 = keyPair->priKey->base.getAlgorithm((HcfKey *)&g_obj);
1105 ASSERT_EQ(algorithmName1, nullptr);
1106
1107 HcfObjDestroy(keyPair);
1108 HcfObjDestroy(generator);
1109 }
1110
1111 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest045, TestSize.Level0)
1112 {
1113 HcfAsyKeyGenerator *generator = nullptr;
1114 HcfKeyPair *keyPair = nullptr;
1115
1116 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1117 &g_mockEd25519PriKeyBlob, &keyPair);
1118 ASSERT_EQ(res, HCF_SUCCESS);
1119
1120 HcfBlob blob = { .data = nullptr, .len = 0 };
1121 res = keyPair->priKey->base.getEncoded(nullptr, &blob);
1122 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1123 ASSERT_EQ(blob.data, nullptr);
1124 ASSERT_EQ(blob.len, 0);
1125
1126 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), nullptr);
1127 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1128
1129 res = keyPair->priKey->base.getEncoded((HcfKey *)&g_obj, &blob);
1130 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1131 ASSERT_EQ(blob.data, nullptr);
1132 ASSERT_EQ(blob.len, 0);
1133
1134 HcfFree(blob.data);
1135 HcfObjDestroy(keyPair);
1136 HcfObjDestroy(generator);
1137 }
1138
1139 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest046, TestSize.Level0)
1140 {
1141 HcfAsyKeyGenerator *generator = nullptr;
1142 HcfKeyPair *keyPair = nullptr;
1143 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1144 &g_mockEd25519PriKeyBlob, &keyPair);
1145 ASSERT_EQ(res, HCF_SUCCESS);
1146
1147 const char *formatName = formatName = keyPair->priKey->base.getFormat(nullptr);
1148 ASSERT_EQ(formatName, nullptr);
1149
1150 const char *formatName1 = keyPair->priKey->base.getFormat((HcfKey *)&g_obj);
1151 ASSERT_EQ(formatName1, nullptr);
1152
1153 HcfObjDestroy(keyPair);
1154 HcfObjDestroy(generator);
1155 }
1156
1157 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest047, TestSize.Level0)
1158 {
1159 HcfAsyKeyGenerator *generator = nullptr;
1160 HcfKeyPair *keyPair = nullptr;
1161
1162 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1163 &g_mockEd25519PriKeyBlob, &keyPair);
1164 ASSERT_EQ(res, HCF_SUCCESS);
1165
1166 keyPair->priKey->clearMem(nullptr);
1167 HcfBlob blob = { .data = nullptr, .len = 0 };
1168 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
1169 ASSERT_EQ(res, HCF_SUCCESS);
1170 ASSERT_NE(blob.data, nullptr);
1171 ASSERT_NE(blob.len, 0);
1172 HcfFree(blob.data);
1173 HcfObjDestroy(keyPair);
1174 HcfObjDestroy(generator);
1175 }
1176
1177 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest048, TestSize.Level0)
1178 {
1179 HcfAsyKeyGenerator *generator = nullptr;
1180 HcfKeyPair *keyPair = nullptr;
1181 HcfResult res = TestGenerateKeyPairAndConvertKey(g_ed25519AlgoName.c_str(), &generator, &g_mockEd25519PubKeyBlob,
1182 &g_mockEd25519PriKeyBlob, &keyPair);
1183 ASSERT_EQ(res, HCF_SUCCESS);
1184
1185 keyPair->priKey->clearMem((HcfPriKey *)&g_obj);
1186 HcfBlob blob = { .data = nullptr, .len = 0 };
1187 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
1188 ASSERT_EQ(res, HCF_SUCCESS);
1189 ASSERT_NE(blob.data, nullptr);
1190 ASSERT_NE(blob.len, 0);
1191 HcfFree(blob.data);
1192 HcfObjDestroy(keyPair);
1193 HcfObjDestroy(generator);
1194 }
1195
1196 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest049, TestSize.Level0)
1197 {
1198 HcfAsyKeyGenerator *generator = nullptr;
1199 HcfKeyPair *keyPair = nullptr;
1200
1201 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
1202 ASSERT_EQ(res, HCF_SUCCESS);
1203
1204 keyPair->pubKey->base.base.destroy(nullptr);
1205 HcfObjDestroy(keyPair);
1206 HcfObjDestroy(generator);
1207 }
1208
1209 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest050, TestSize.Level0)
1210 {
1211 HcfAsyKeyGenerator *generator = nullptr;
1212 HcfKeyPair *keyPair = nullptr;
1213 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
1214 ASSERT_EQ(res, HCF_SUCCESS);
1215
1216 keyPair->pubKey->base.base.destroy(&g_obj);
1217 HcfObjDestroy(keyPair);
1218 HcfObjDestroy(generator);
1219 }
1220
1221 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest051, TestSize.Level0)
1222 {
1223 HcfAsyKeyGenerator *generator = nullptr;
1224 HcfKeyPair *keyPair = nullptr;
1225
1226 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
1227 ASSERT_EQ(res, HCF_SUCCESS);
1228
1229 keyPair->priKey->base.base.destroy(nullptr);
1230 HcfObjDestroy(keyPair);
1231 HcfObjDestroy(generator);
1232 }
1233
1234 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest052, TestSize.Level0)
1235 {
1236 HcfAsyKeyGenerator *generator = nullptr;
1237 HcfKeyPair *keyPair = nullptr;
1238 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
1239 ASSERT_EQ(res, HCF_SUCCESS);
1240
1241 keyPair->priKey->base.base.destroy(&g_obj);
1242 HcfObjDestroy(keyPair);
1243 HcfObjDestroy(generator);
1244 }
1245
1246 HWTEST_F(CryptoEd25519AsyKeyGeneratorTest, CryptoEd25519AsyKeyGeneratorTest053, TestSize.Level0)
1247 {
1248 HcfAsyKeyGenerator *generator = nullptr;
1249 HcfKeyPair *keyPair = nullptr;
1250
1251 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_ed25519AlgoName.c_str(), &generator, &keyPair);
1252 ASSERT_EQ(res, HCF_SUCCESS);
1253
1254 HcfSign *sign = nullptr;
1255 res = HcfSignCreate("Ed25519", &sign);
1256 ASSERT_EQ(res, HCF_SUCCESS);
1257 res = sign->init(sign, nullptr, keyPair->priKey);
1258 ASSERT_EQ(res, HCF_SUCCESS);
1259 HcfBlob out = { .data = nullptr, .len = 0 };
1260 res = sign->sign(sign, &g_mockInput, &out);
1261 ASSERT_EQ(res, HCF_SUCCESS);
1262 ASSERT_NE(out.data, nullptr);
1263 ASSERT_NE(out.len, 0);
1264
1265 HcfVerify *verify = nullptr;
1266 res = HcfVerifyCreate("Ed25519", &verify);
1267 ASSERT_EQ(res, HCF_SUCCESS);
1268 res = verify->init(verify, nullptr, keyPair->pubKey);
1269 ASSERT_EQ(res, HCF_SUCCESS);
1270
1271 bool flag = verify->verify(verify, &g_mockInput, &out);
1272 ASSERT_EQ(flag, true);
1273 ASSERT_NE(out.data, nullptr);
1274 ASSERT_NE(out.len, 0);
1275 HcfFree(out.data);
1276 HcfObjDestroy(keyPair);
1277 HcfObjDestroy(generator);
1278 HcfObjDestroy(sign);
1279 HcfObjDestroy(verify);
1280 }
1281 }