1 /*
2 * Copyright (C) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <cstring>
18
19 #include "alg_25519_common_param_spec.h"
20 #include "blob.h"
21 #include "ecdsa_openssl.h"
22 #include "memory.h"
23 #include "securec.h"
24 #include "openssl_common.h"
25 #include "asy_key_params.h"
26 #include "params_parser.h"
27 #include "alg_25519_asy_key_generator_openssl.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 CryptoEd25519AsyKeyGeneratorBySpecTest : public testing::Test {
36 public:
SetUpTestCase()37 static void SetUpTestCase() {};
TearDownTestCase()38 static void TearDownTestCase() {};
39 void SetUp();
40 void TearDown();
41 };
42
43 static string g_ed25519AlgoName = "Ed25519";
44 static string g_pubkeyformatName = "X.509";
45 static string g_prikeyformatName = "PKCS#8";
46
SetUp()47 void CryptoEd25519AsyKeyGeneratorBySpecTest::SetUp() {}
TearDown()48 void CryptoEd25519AsyKeyGeneratorBySpecTest::TearDown() {}
49
50 static const char *g_mockMessage = "hello world";
51 static HcfBlob g_mockInput = {
52 .data = (uint8_t *)g_mockMessage,
53 .len = 12
54 };
55
GetMockClass(void)56 static const char *GetMockClass(void)
57 {
58 return "ed25519generator";
59 }
60 HcfObjectBase g_obj = {
61 .getClass = GetMockClass,
62 .destroy = nullptr
63 };
64
65 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest001_1, TestSize.Level0)
66 {
67 HcfAsyKeyParamsSpec *paramSpec = nullptr;
68 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
69 HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
70 ¶mSpec, &returnObj);
71 ASSERT_EQ(res, HCF_SUCCESS);
72 HcfObjDestroy(returnObj);
73 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
74 }
75
76 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest001_2, TestSize.Level0)
77 {
78 HcfAsyKeyParamsSpec *paramSpec = nullptr;
79 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
80 HcfResult res = TestCreatePubKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
81 ¶mSpec, &returnObj);
82 ASSERT_EQ(res, HCF_SUCCESS);
83 HcfObjDestroy(returnObj);
84 DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramSpec));
85 }
86
87 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest001_3, TestSize.Level0)
88 {
89 HcfAsyKeyParamsSpec *paramSpec = nullptr;
90 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
91 HcfResult res = TestCreatePriKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
92 ¶mSpec, &returnObj);
93 ASSERT_EQ(res, HCF_SUCCESS);
94 HcfObjDestroy(returnObj);
95 DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramSpec));
96 }
97
98 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest002, TestSize.Level0)
99 {
100 HcfAsyKeyParamsSpec *paramSpec = nullptr;
101 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
102 HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
103 ¶mSpec, &returnObj);
104 ASSERT_EQ(res, HCF_SUCCESS);
105
106 const char *className = returnObj->base.getClass();
107 ASSERT_NE(className, nullptr);
108 ASSERT_NE(returnObj, nullptr);
109 HcfObjDestroy(returnObj);
110 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
111 }
112
113 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest003, TestSize.Level0)
114 {
115 HcfAsyKeyParamsSpec *paramSpec = nullptr;
116 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
117
118 HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
119 ¶mSpec, &returnObj);
120 ASSERT_EQ(res, HCF_SUCCESS);
121
122 returnObj->base.destroy(&g_obj);
123 HcfObjDestroy(returnObj);
124 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
125 }
126
127 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest004, TestSize.Level0)
128 {
129 HcfAsyKeyParamsSpec *paramSpec = nullptr;
130 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
131 HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
132 ¶mSpec, &returnObj);
133 ASSERT_EQ(res, HCF_SUCCESS);
134
135 const char *algoName = returnObj->getAlgName(returnObj);
136 ASSERT_EQ(res, HCF_SUCCESS);
137 ASSERT_EQ(algoName, g_ed25519AlgoName);
138
139 HcfObjDestroy(returnObj);
140 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
141 }
142
143 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest005, TestSize.Level0)
144 {
145 HcfAsyKeyParamsSpec *paramSpec = nullptr;
146 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
147
148 HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
149 ¶mSpec, &returnObj);
150 ASSERT_EQ(res, HCF_SUCCESS);
151
152 HcfKeyPair *keyPair = nullptr;
153 res = returnObj->generateKeyPair(returnObj, &keyPair);
154
155 ASSERT_EQ(res, HCF_SUCCESS);
156 ASSERT_NE(keyPair, nullptr);
157
158 HcfObjDestroy(keyPair);
159 HcfObjDestroy(returnObj);
160 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
161 }
162
163 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest006, TestSize.Level0)
164 {
165 HcfAsyKeyParamsSpec *paramSpec = nullptr;
166 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
167 HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
168 ¶mSpec, &returnObj);
169 ASSERT_EQ(res, HCF_SUCCESS);
170
171 HcfKeyPair *keyPair = nullptr;
172 res = returnObj->generateKeyPair(returnObj, &keyPair);
173
174 ASSERT_EQ(res, HCF_SUCCESS);
175 ASSERT_NE(keyPair, nullptr);
176
177 const char *className = keyPair->base.getClass();
178 ASSERT_NE(className, nullptr);
179
180 HcfObjDestroy(keyPair);
181 HcfObjDestroy(returnObj);
182 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
183 }
184
185 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest007, TestSize.Level0)
186 {
187 HcfAsyKeyParamsSpec *paramSpec = nullptr;
188 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
189
190 HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
191 ¶mSpec, &returnObj);
192 ASSERT_EQ(res, HCF_SUCCESS);
193
194 HcfKeyPair *keyPair = nullptr;
195 res = returnObj->generateKeyPair(returnObj, &keyPair);
196
197 ASSERT_EQ(res, HCF_SUCCESS);
198 ASSERT_NE(keyPair, nullptr);
199
200 keyPair->base.destroy(&(keyPair->base));
201 HcfObjDestroy(returnObj);
202 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
203 }
204
205 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest008, TestSize.Level0)
206 {
207 HcfAsyKeyParamsSpec *paramSpec = nullptr;
208 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
209 HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
210 ¶mSpec, &returnObj);
211 ASSERT_EQ(res, HCF_SUCCESS);
212
213 HcfKeyPair *keyPair = nullptr;
214 res = returnObj->generateKeyPair(returnObj, &keyPair);
215 ASSERT_EQ(res, HCF_SUCCESS);
216 ASSERT_NE(keyPair, nullptr);
217
218 const char *className = keyPair->pubKey->base.base.getClass();
219 ASSERT_NE(className, nullptr);
220
221 HcfObjDestroy(keyPair);
222 HcfObjDestroy(returnObj);
223 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
224 }
225
226 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest009, TestSize.Level0)
227 {
228 HcfAsyKeyParamsSpec *paramSpec = nullptr;
229 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
230
231 HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
232 ¶mSpec, &returnObj);
233 ASSERT_EQ(res, HCF_SUCCESS);
234
235 HcfKeyPair *keyPair = nullptr;
236 res = returnObj->generateKeyPair(returnObj, &keyPair);
237 ASSERT_EQ(res, HCF_SUCCESS);
238 ASSERT_NE(keyPair, nullptr);
239
240 keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
241 keyPair->pubKey = nullptr;
242 HcfObjDestroy(keyPair);
243 HcfObjDestroy(returnObj);
244 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
245 }
246
247 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest010, TestSize.Level0)
248 {
249 HcfAsyKeyParamsSpec *paramSpec = nullptr;
250 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
251 HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
252 ¶mSpec, &returnObj);
253 ASSERT_EQ(res, HCF_SUCCESS);
254
255 HcfKeyPair *keyPair = nullptr;
256 res = returnObj->generateKeyPair(returnObj, &keyPair);
257 ASSERT_EQ(res, HCF_SUCCESS);
258 ASSERT_NE(keyPair, nullptr);
259
260 const char *algorithmName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
261 ASSERT_EQ(algorithmName, g_ed25519AlgoName);
262
263 HcfBlob blob = { .data = nullptr, .len = 0 };
264 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
265 ASSERT_EQ(res, HCF_SUCCESS);
266 ASSERT_NE(blob.data, nullptr);
267 ASSERT_NE(blob.len, 0);
268 HcfFree(blob.data);
269 const char *formatName = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
270 ASSERT_EQ(formatName, g_pubkeyformatName);
271
272 HcfObjDestroy(keyPair);
273 HcfObjDestroy(returnObj);
274 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
275 }
276
277 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest011, TestSize.Level0)
278 {
279 HcfAsyKeyParamsSpec *paramSpec = nullptr;
280 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
281
282 HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
283 ¶mSpec, &returnObj);
284 ASSERT_EQ(res, HCF_SUCCESS);
285
286 HcfKeyPair *keyPair = nullptr;
287 res = returnObj->generateKeyPair(returnObj, &keyPair);
288 ASSERT_EQ(res, HCF_SUCCESS);
289 ASSERT_NE(keyPair, nullptr);
290
291 const char *className = keyPair->priKey->base.base.getClass();
292 ASSERT_NE(className, nullptr);
293
294 HcfObjDestroy(keyPair);
295 HcfObjDestroy(returnObj);
296 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
297 }
298
299 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest012, TestSize.Level0)
300 {
301 HcfAsyKeyParamsSpec *paramSpec = nullptr;
302 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
303 HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
304 ¶mSpec, &returnObj);
305 ASSERT_EQ(res, HCF_SUCCESS);
306
307 HcfKeyPair *keyPair = nullptr;
308 res = returnObj->generateKeyPair(returnObj, &keyPair);
309 ASSERT_EQ(res, HCF_SUCCESS);
310 ASSERT_NE(keyPair, nullptr);
311
312 keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
313 keyPair->priKey = nullptr;
314 HcfObjDestroy(keyPair);
315 HcfObjDestroy(returnObj);
316 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
317 }
318
319 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest013, TestSize.Level0)
320 {
321 HcfAsyKeyParamsSpec *paramSpec = nullptr;
322 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
323
324 HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
325 ¶mSpec, &returnObj);
326 ASSERT_EQ(res, HCF_SUCCESS);
327
328 HcfKeyPair *keyPair = nullptr;
329 res = returnObj->generateKeyPair(returnObj, &keyPair);
330 ASSERT_EQ(res, HCF_SUCCESS);
331 ASSERT_NE(keyPair, nullptr);
332
333 const char *algorithmName = keyPair->priKey->base.getAlgorithm(&(keyPair->priKey->base));
334 ASSERT_EQ(algorithmName, g_ed25519AlgoName);
335
336 HcfBlob blob = { .data = nullptr, .len = 0 };
337 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
338 ASSERT_EQ(res, HCF_SUCCESS);
339 ASSERT_NE(blob.data, nullptr);
340 ASSERT_NE(blob.len, 0);
341 HcfFree(blob.data);
342 const char *formatName = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
343 ASSERT_EQ(formatName, g_prikeyformatName);
344
345 HcfObjDestroy(keyPair);
346 HcfObjDestroy(returnObj);
347 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
348 }
349
350 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest014, TestSize.Level0)
351 {
352 HcfAsyKeyParamsSpec *paramSpec = nullptr;
353 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
354 HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
355 ¶mSpec, &returnObj);
356 ASSERT_EQ(res, HCF_SUCCESS);
357
358 HcfKeyPair *keyPair = nullptr;
359 res = returnObj->generateKeyPair(returnObj, &keyPair);
360 ASSERT_EQ(res, HCF_SUCCESS);
361 ASSERT_NE(keyPair, nullptr);
362
363 keyPair->priKey->clearMem(keyPair->priKey);
364 HcfBlob blob = { .data = nullptr, .len = 0 };
365 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
366 ASSERT_EQ(res, HCF_INVALID_PARAMS);
367 ASSERT_EQ(blob.data, nullptr);
368 ASSERT_EQ(blob.len, 0);
369 HcfFree(blob.data);
370 HcfObjDestroy(keyPair);
371 HcfObjDestroy(returnObj);
372 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
373 }
374
375 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest015, TestSize.Level0)
376 {
377 HcfAsyKeyParamsSpec *pubparamSpec = nullptr;
378 HcfAsyKeyGeneratorBySpec *returnpubObj = nullptr;
379 HcfResult res = TestCreatePubKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
380 &pubparamSpec, &returnpubObj);
381 ASSERT_EQ(res, HCF_SUCCESS);
382
383 HcfAsyKeyParamsSpec *priparamSpec = nullptr;
384 HcfAsyKeyGeneratorBySpec *returnpriObj = nullptr;
385 res = TestCreatePriKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
386 &priparamSpec, &returnpriObj);
387 ASSERT_EQ(res, HCF_SUCCESS);
388
389 HcfPubKey *pubKey = nullptr;
390 res = returnpubObj->generatePubKey(returnpubObj, &pubKey);
391 ASSERT_EQ(res, HCF_SUCCESS);
392 ASSERT_NE(pubKey, nullptr);
393
394 HcfPriKey *priKey = nullptr;
395 res = returnpriObj->generatePriKey(returnpriObj, &priKey);
396 ASSERT_EQ(res, HCF_SUCCESS);
397 ASSERT_NE(priKey, nullptr);
398
399 HcfBigInteger returnBigInteger = { .data = nullptr, .len = 0 };
400 res = pubKey->getAsyKeySpecBigInteger(pubKey, ED25519_PK_BN, &returnBigInteger);
401 ASSERT_EQ(res, HCF_SUCCESS);
402 ASSERT_NE(returnBigInteger.data, nullptr);
403 ASSERT_NE(returnBigInteger.len, 0);
404 HcfFree(returnBigInteger.data);
405
406 res = priKey->getAsyKeySpecBigInteger(priKey, ED25519_SK_BN, &returnBigInteger);
407 ASSERT_EQ(res, HCF_SUCCESS);
408 ASSERT_NE(returnBigInteger.data, nullptr);
409 ASSERT_NE(returnBigInteger.len, 0);
410 HcfFree(returnBigInteger.data);
411 HcfObjDestroy(pubKey);
412 HcfObjDestroy(priKey);
413 HcfObjDestroy(returnpubObj);
414 HcfObjDestroy(returnpriObj);
415 DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(pubparamSpec));
416 DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(priparamSpec));
417 }
418
419 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest016, TestSize.Level0)
420 {
421 HcfAsyKeyParamsSpec *paramSpec = nullptr;
422 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
423 HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
424 ¶mSpec, &returnObj);
425 ASSERT_EQ(res, HCF_SUCCESS);
426
427 HcfKeyPair *keyPair = nullptr;
428 res = returnObj->generateKeyPair(returnObj, &keyPair);
429 ASSERT_EQ(res, HCF_SUCCESS);
430 ASSERT_NE(keyPair, nullptr);
431
432 HcfSign *sign = nullptr;
433 res = HcfSignCreate("Ed25519", &sign);
434 ASSERT_EQ(res, HCF_SUCCESS);
435 res = sign->init(sign, nullptr, keyPair->priKey);
436 ASSERT_EQ(res, HCF_SUCCESS);
437 HcfBlob out = { .data = nullptr, .len = 0 };
438 res = sign->sign(sign, &g_mockInput, &out);
439 ASSERT_EQ(res, HCF_SUCCESS);
440 ASSERT_NE(out.data, nullptr);
441 ASSERT_NE(out.len, 0);
442
443 HcfVerify *verify = nullptr;
444 res = HcfVerifyCreate("Ed25519", &verify);
445 ASSERT_EQ(res, HCF_SUCCESS);
446 res = verify->init(verify, nullptr, keyPair->pubKey);
447 ASSERT_EQ(res, HCF_SUCCESS);
448
449 bool flag = verify->verify(verify, &g_mockInput, &out);
450 ASSERT_EQ(flag, true);
451 ASSERT_NE(out.data, nullptr);
452 ASSERT_NE(out.len, 0);
453
454 HcfFree(out.data);
455 HcfObjDestroy(sign);
456 HcfObjDestroy(verify);
457 HcfObjDestroy(keyPair);
458 HcfObjDestroy(returnObj);
459 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
460 }
461
462 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest017, TestSize.Level0)
463 {
464 HcfAsyKeyGenParams params = {
465 .algo = HCF_ALG_ED25519,
466 .bits = HCF_ALG_ED25519_256,
467 .primes = HCF_OPENSSL_PRIMES_2,
468 };
469
470 HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
471 HcfResult res = HcfAsyKeyGeneratorSpiEd25519Create(¶ms, &returnSpi);
472
473 ASSERT_EQ(res, HCF_SUCCESS);
474 ASSERT_NE(returnSpi, nullptr);
475 HcfObjDestroy(returnSpi);
476 }
477
478 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest018, TestSize.Level0)
479 {
480 HcfAsyKeyGenParams params = {
481 .algo = HCF_ALG_ED25519,
482 .bits = HCF_ALG_ED25519_256,
483 .primes = HCF_OPENSSL_PRIMES_2,
484 };
485
486 HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
487 HcfResult res = HcfAsyKeyGeneratorSpiEd25519Create(¶ms, &returnSpi);
488
489 ASSERT_EQ(res, HCF_SUCCESS);
490 ASSERT_NE(returnSpi, nullptr);
491
492 HcfAsyKeyParamsSpec *paramsSpec = nullptr;
493 res = ConstructAlg25519KeyPairParamsSpec(g_ed25519AlgoName.c_str(), true, ¶msSpec);
494 ASSERT_EQ(res, HCF_SUCCESS);
495 ASSERT_NE(returnSpi, nullptr);
496
497 HcfKeyPair *keyPair = nullptr;
498 res = returnSpi->engineGenerateKeyPairBySpec(returnSpi, paramsSpec, &keyPair);
499 ASSERT_EQ(res, HCF_SUCCESS);
500 ASSERT_NE(keyPair, nullptr);
501
502 HcfObjDestroy(returnSpi);
503 HcfObjDestroy(keyPair);
504 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramsSpec));
505 }
506
507 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest019, TestSize.Level0)
508 {
509 HcfAsyKeyGenParams params = {
510 .algo = HCF_ALG_ED25519,
511 .bits = HCF_ALG_ED25519_256,
512 .primes = HCF_OPENSSL_PRIMES_2,
513 };
514
515 HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
516 HcfResult res = HcfAsyKeyGeneratorSpiEd25519Create(¶ms, &returnSpi);
517
518 ASSERT_EQ(res, HCF_SUCCESS);
519 ASSERT_NE(returnSpi, nullptr);
520
521 HcfAsyKeyParamsSpec *paramsSpec = nullptr;
522 res = ConstructAlg25519PubKeyParamsSpec(g_ed25519AlgoName.c_str(), true, ¶msSpec);
523 ASSERT_EQ(res, HCF_SUCCESS);
524 ASSERT_NE(returnSpi, nullptr);
525
526 HcfPubKey *pubKey = nullptr;
527 res = returnSpi->engineGeneratePubKeyBySpec(returnSpi, paramsSpec, &pubKey);
528 ASSERT_EQ(res, HCF_SUCCESS);
529 ASSERT_NE(pubKey, nullptr);
530
531 HcfObjDestroy(returnSpi);
532 HcfObjDestroy(pubKey);
533 DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramsSpec));
534 }
535
536 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest020, TestSize.Level0)
537 {
538 HcfAsyKeyGenParams params = {
539 .algo = HCF_ALG_ED25519,
540 .bits = HCF_ALG_ED25519_256,
541 .primes = HCF_OPENSSL_PRIMES_2,
542 };
543
544 HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
545 HcfResult res = HcfAsyKeyGeneratorSpiEd25519Create(¶ms, &returnSpi);
546
547 ASSERT_EQ(res, HCF_SUCCESS);
548 ASSERT_NE(returnSpi, nullptr);
549
550 HcfAsyKeyParamsSpec *paramsSpec = nullptr;
551 res = ConstructAlg25519PriKeyParamsSpec(g_ed25519AlgoName.c_str(), true, ¶msSpec);
552 ASSERT_EQ(res, HCF_SUCCESS);
553 ASSERT_NE(returnSpi, nullptr);
554
555 HcfPriKey *priKey = nullptr;
556 res = returnSpi->engineGeneratePriKeyBySpec(returnSpi, paramsSpec, &priKey);
557 ASSERT_EQ(res, HCF_SUCCESS);
558 ASSERT_NE(priKey, nullptr);
559
560 HcfObjDestroy(returnSpi);
561 HcfObjDestroy(priKey);
562 DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramsSpec));
563 }
564
565 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest021, TestSize.Level0)
566 {
567 HcfAsyKeyParamsSpec *paramSpec = nullptr;
568 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
569 HcfResult res = TestCreatePubKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
570 ¶mSpec, &returnObj);
571 ASSERT_EQ(res, HCF_SUCCESS);
572
573 HcfPriKey *priKey = nullptr;
574 res = returnObj->generatePriKey(returnObj, &priKey);
575 ASSERT_EQ(res, HCF_INVALID_PARAMS);
576 ASSERT_EQ(priKey, nullptr);
577
578 HcfKeyPair *keyPair = nullptr;
579 res = returnObj->generateKeyPair(returnObj, &keyPair);
580 ASSERT_EQ(res, HCF_INVALID_PARAMS);
581 ASSERT_EQ(keyPair, nullptr);
582
583 HcfObjDestroy(returnObj);
584 HcfObjDestroy(priKey);
585 HcfObjDestroy(keyPair);
586 DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramSpec));
587 }
588
589 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest022, TestSize.Level0)
590 {
591 HcfAsyKeyParamsSpec *paramSpec = nullptr;
592 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
593
594 HcfResult res = TestCreatePriKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
595 ¶mSpec, &returnObj);
596 ASSERT_EQ(res, HCF_SUCCESS);
597
598 HcfKeyPair *keyPair = nullptr;
599 res = returnObj->generateKeyPair(returnObj, &keyPair);
600 ASSERT_EQ(res, HCF_INVALID_PARAMS);
601 ASSERT_EQ(keyPair, nullptr);
602
603 HcfPubKey *pubKey = nullptr;
604 res = returnObj->generatePubKey(returnObj, &pubKey);
605 ASSERT_EQ(res, HCF_INVALID_PARAMS);
606 ASSERT_EQ(pubKey, nullptr);
607
608 HcfObjDestroy(returnObj);
609 HcfObjDestroy(keyPair);
610 HcfObjDestroy(pubKey);
611 DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramSpec));
612 }
613
614 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest023, TestSize.Level0)
615 {
616 HcfAsyKeyGenerator *generator;
617 HcfResult res = HcfAsyKeyGeneratorCreate(g_ed25519AlgoName.c_str(), &generator);
618 ASSERT_EQ(res, HCF_SUCCESS);
619
620 HcfKeyPair *keyPair = nullptr;
621 res = generator->generateKeyPair(generator, nullptr, &keyPair);
622
623 ASSERT_EQ(res, HCF_SUCCESS);
624 ASSERT_NE(keyPair, nullptr);
625
626 HcfBlob blob1 = { .data = nullptr, .len = 0 };
627 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob1);
628 ASSERT_EQ(res, HCF_SUCCESS);
629 ASSERT_NE(blob1.data, nullptr);
630 ASSERT_NE(blob1.len, 0);
631
632 HcfAsyKeyParamsSpec *paramSpec = nullptr;
633 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
634 res = TestCreatePubKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
635 ¶mSpec, &returnObj);
636 ASSERT_EQ(res, HCF_SUCCESS);
637
638 HcfPubKey *pubKey = nullptr;
639 res = returnObj->generatePubKey(returnObj, &pubKey);
640 ASSERT_EQ(res, HCF_SUCCESS);
641 ASSERT_NE(pubKey, nullptr);
642
643 HcfBlob blob2 = { .data = nullptr, .len = 0 };
644 res = pubKey->base.getEncoded(&(pubKey->base), &blob2);
645 ASSERT_EQ(res, HCF_SUCCESS);
646 ASSERT_NE(blob2.data, nullptr);
647 ASSERT_NE(blob2.len, 0);
648
649 ASSERT_EQ(*(blob1.data), *(blob2.data));
650 ASSERT_EQ(blob1.len, blob2.len);
651
652 HcfFree(blob1.data);
653 HcfFree(blob2.data);
654 HcfObjDestroy(returnObj);
655 HcfObjDestroy(pubKey);
656 HcfObjDestroy(keyPair);
657 DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramSpec));
658 HcfObjDestroy(generator);
659 }
660
661 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest024, TestSize.Level0)
662 {
663 HcfAsyKeyGenerator *generator;
664 HcfResult res = HcfAsyKeyGeneratorCreate(g_ed25519AlgoName.c_str(), &generator);
665 ASSERT_EQ(res, HCF_SUCCESS);
666
667 HcfKeyPair *keyPair = nullptr;
668 res = generator->generateKeyPair(generator, nullptr, &keyPair);
669
670 ASSERT_EQ(res, HCF_SUCCESS);
671 ASSERT_NE(keyPair, nullptr);
672
673 HcfBlob blob1 = { .data = nullptr, .len = 0 };
674 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob1);
675 ASSERT_EQ(res, HCF_SUCCESS);
676 ASSERT_NE(blob1.data, nullptr);
677 ASSERT_NE(blob1.len, 0);
678
679 HcfAsyKeyParamsSpec *paramSpec = nullptr;
680 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
681
682 res = TestCreatePriKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
683 ¶mSpec, &returnObj);
684 ASSERT_EQ(res, HCF_SUCCESS);
685
686 HcfPriKey *priKey = nullptr;
687 res = returnObj->generatePriKey(returnObj, &priKey);
688 ASSERT_EQ(res, HCF_SUCCESS);
689 ASSERT_NE(priKey, nullptr);
690
691 HcfBlob blob2 = { .data = nullptr, .len = 0 };
692 res = priKey->base.getEncoded(&(priKey->base), &blob2);
693 ASSERT_EQ(res, HCF_SUCCESS);
694 ASSERT_NE(blob2.data, nullptr);
695 ASSERT_NE(blob2.len, 0);
696
697 ASSERT_EQ(*(blob1.data), *(blob2.data));
698 ASSERT_EQ(blob1.len, blob2.len);
699
700 HcfFree(blob1.data);
701 HcfFree(blob2.data);
702 HcfObjDestroy(returnObj);
703 HcfObjDestroy(priKey);
704 HcfObjDestroy(keyPair);
705 DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramSpec));
706 HcfObjDestroy(generator);
707 }
708
709 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest025, TestSize.Level0)
710 {
711 HcfAsyKeyParamsSpec *paramSpec = nullptr;
712 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
713 HcfResult res = TestCreatePriKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
714 ¶mSpec, &returnObj);
715 ASSERT_EQ(res, HCF_SUCCESS);
716
717 HcfPriKey *priKey = nullptr;
718 res = returnObj->generatePriKey(returnObj, &priKey);
719 ASSERT_EQ(res, HCF_SUCCESS);
720 ASSERT_NE(priKey, nullptr);
721
722 HcfBlob blob = { .data = nullptr, .len = 0 };
723 res = priKey->base.getEncoded(&(priKey->base), &blob);
724 ASSERT_EQ(res, HCF_SUCCESS);
725 ASSERT_NE(blob.data, nullptr);
726 ASSERT_NE(blob.len, 0);
727
728 HcfAsyKeyGenerator *generator;
729 res = HcfAsyKeyGeneratorCreate(g_ed25519AlgoName.c_str(), &generator);
730 ASSERT_EQ(res, HCF_SUCCESS);
731
732 HcfKeyPair *keyPair = nullptr;
733 res = generator->convertKey(generator, nullptr, nullptr, &blob, &keyPair);
734
735 HcfFree(blob.data);
736 HcfObjDestroy(returnObj);
737 HcfObjDestroy(priKey);
738 HcfObjDestroy(keyPair);
739 DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramSpec));
740 HcfObjDestroy(generator);
741 }
742
743 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest026, TestSize.Level0)
744 {
745 HcfAsyKeyParamsSpec *paramSpec = nullptr;
746 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
747
748 HcfResult res = TestCreatePubKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
749 ¶mSpec, &returnObj);
750 ASSERT_EQ(res, HCF_SUCCESS);
751
752 HcfPubKey *pubKey = nullptr;
753 res = returnObj->generatePubKey(returnObj, &pubKey);
754 ASSERT_EQ(res, HCF_SUCCESS);
755 ASSERT_NE(pubKey, nullptr);
756
757 HcfBlob blob = { .data = nullptr, .len = 0 };
758 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
759 ASSERT_EQ(res, HCF_SUCCESS);
760 ASSERT_NE(blob.data, nullptr);
761 ASSERT_NE(blob.len, 0);
762
763 HcfAsyKeyGenerator *generator;
764 res = HcfAsyKeyGeneratorCreate(g_ed25519AlgoName.c_str(), &generator);
765 ASSERT_EQ(res, HCF_SUCCESS);
766
767 HcfKeyPair *keyPair = nullptr;
768 res = generator->convertKey(generator, nullptr, &blob, nullptr, &keyPair);
769 HcfFree(blob.data);
770 HcfObjDestroy(returnObj);
771 HcfObjDestroy(pubKey);
772 HcfObjDestroy(keyPair);
773 DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramSpec));
774 HcfObjDestroy(generator);
775 }
776 }