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
405 res = priKey->getAsyKeySpecBigInteger(priKey, ED25519_SK_BN, &returnBigInteger);
406 ASSERT_EQ(res, HCF_SUCCESS);
407 ASSERT_NE(returnBigInteger.data, nullptr);
408 ASSERT_NE(returnBigInteger.len, 0);
409 HcfFree(returnBigInteger.data);
410 HcfObjDestroy(pubKey);
411 HcfObjDestroy(priKey);
412 HcfObjDestroy(returnpubObj);
413 HcfObjDestroy(returnpriObj);
414 DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(pubparamSpec));
415 DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(priparamSpec));
416 }
417
418 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest016, TestSize.Level0)
419 {
420 HcfAsyKeyParamsSpec *paramSpec = nullptr;
421 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
422 HcfResult res = TestCreateKeyPairParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
423 ¶mSpec, &returnObj);
424 ASSERT_EQ(res, HCF_SUCCESS);
425
426 HcfKeyPair *keyPair = nullptr;
427 res = returnObj->generateKeyPair(returnObj, &keyPair);
428 ASSERT_EQ(res, HCF_SUCCESS);
429 ASSERT_NE(keyPair, nullptr);
430
431 HcfSign *sign = nullptr;
432 res = HcfSignCreate("Ed25519", &sign);
433 ASSERT_EQ(res, HCF_SUCCESS);
434 res = sign->init(sign, nullptr, keyPair->priKey);
435 ASSERT_EQ(res, HCF_SUCCESS);
436 HcfBlob out = { .data = nullptr, .len = 0 };
437 res = sign->sign(sign, &g_mockInput, &out);
438 ASSERT_EQ(res, HCF_SUCCESS);
439 ASSERT_NE(out.data, nullptr);
440 ASSERT_NE(out.len, 0);
441
442 HcfVerify *verify = nullptr;
443 res = HcfVerifyCreate("Ed25519", &verify);
444 ASSERT_EQ(res, HCF_SUCCESS);
445 res = verify->init(verify, nullptr, keyPair->pubKey);
446 ASSERT_EQ(res, HCF_SUCCESS);
447
448 bool flag = verify->verify(verify, &g_mockInput, &out);
449 ASSERT_EQ(flag, true);
450 ASSERT_NE(out.data, nullptr);
451 ASSERT_NE(out.len, 0);
452
453 HcfFree(out.data);
454 HcfObjDestroy(sign);
455 HcfObjDestroy(verify);
456 HcfObjDestroy(keyPair);
457 HcfObjDestroy(returnObj);
458 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
459 }
460
461 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest017, TestSize.Level0)
462 {
463 HcfAsyKeyGenParams params = {
464 .algo = HCF_ALG_ED25519,
465 .bits = HCF_ALG_ED25519_256,
466 .primes = HCF_OPENSSL_PRIMES_2,
467 };
468
469 HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
470 HcfResult res = HcfAsyKeyGeneratorSpiEd25519Create(¶ms, &returnSpi);
471
472 ASSERT_EQ(res, HCF_SUCCESS);
473 ASSERT_NE(returnSpi, nullptr);
474 HcfObjDestroy(returnSpi);
475 }
476
477 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest018, TestSize.Level0)
478 {
479 HcfAsyKeyGenParams params = {
480 .algo = HCF_ALG_ED25519,
481 .bits = HCF_ALG_ED25519_256,
482 .primes = HCF_OPENSSL_PRIMES_2,
483 };
484
485 HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
486 HcfResult res = HcfAsyKeyGeneratorSpiEd25519Create(¶ms, &returnSpi);
487
488 ASSERT_EQ(res, HCF_SUCCESS);
489 ASSERT_NE(returnSpi, nullptr);
490
491 HcfAsyKeyParamsSpec *paramsSpec = nullptr;
492 res = ConstructAlg25519KeyPairParamsSpec(g_ed25519AlgoName.c_str(), true, ¶msSpec);
493 ASSERT_EQ(res, HCF_SUCCESS);
494 ASSERT_NE(returnSpi, nullptr);
495
496 HcfKeyPair *keyPair = nullptr;
497 res = returnSpi->engineGenerateKeyPairBySpec(returnSpi, paramsSpec, &keyPair);
498 ASSERT_EQ(res, HCF_SUCCESS);
499 ASSERT_NE(keyPair, nullptr);
500
501 HcfObjDestroy(returnSpi);
502 HcfObjDestroy(keyPair);
503 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramsSpec));
504 }
505
506 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest019, TestSize.Level0)
507 {
508 HcfAsyKeyGenParams params = {
509 .algo = HCF_ALG_ED25519,
510 .bits = HCF_ALG_ED25519_256,
511 .primes = HCF_OPENSSL_PRIMES_2,
512 };
513
514 HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
515 HcfResult res = HcfAsyKeyGeneratorSpiEd25519Create(¶ms, &returnSpi);
516
517 ASSERT_EQ(res, HCF_SUCCESS);
518 ASSERT_NE(returnSpi, nullptr);
519
520 HcfAsyKeyParamsSpec *paramsSpec = nullptr;
521 res = ConstructAlg25519PubKeyParamsSpec(g_ed25519AlgoName.c_str(), true, ¶msSpec);
522 ASSERT_EQ(res, HCF_SUCCESS);
523 ASSERT_NE(returnSpi, nullptr);
524
525 HcfPubKey *pubKey = nullptr;
526 res = returnSpi->engineGeneratePubKeyBySpec(returnSpi, paramsSpec, &pubKey);
527 ASSERT_EQ(res, HCF_SUCCESS);
528 ASSERT_NE(pubKey, nullptr);
529
530 HcfObjDestroy(returnSpi);
531 HcfObjDestroy(pubKey);
532 DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramsSpec));
533 }
534
535 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest020, TestSize.Level0)
536 {
537 HcfAsyKeyGenParams params = {
538 .algo = HCF_ALG_ED25519,
539 .bits = HCF_ALG_ED25519_256,
540 .primes = HCF_OPENSSL_PRIMES_2,
541 };
542
543 HcfAsyKeyGeneratorSpi *returnSpi = nullptr;
544 HcfResult res = HcfAsyKeyGeneratorSpiEd25519Create(¶ms, &returnSpi);
545
546 ASSERT_EQ(res, HCF_SUCCESS);
547 ASSERT_NE(returnSpi, nullptr);
548
549 HcfAsyKeyParamsSpec *paramsSpec = nullptr;
550 res = ConstructAlg25519PriKeyParamsSpec(g_ed25519AlgoName.c_str(), true, ¶msSpec);
551 ASSERT_EQ(res, HCF_SUCCESS);
552 ASSERT_NE(returnSpi, nullptr);
553
554 HcfPriKey *priKey = nullptr;
555 res = returnSpi->engineGeneratePriKeyBySpec(returnSpi, paramsSpec, &priKey);
556 ASSERT_EQ(res, HCF_SUCCESS);
557 ASSERT_NE(priKey, nullptr);
558
559 HcfObjDestroy(returnSpi);
560 HcfObjDestroy(priKey);
561 DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramsSpec));
562 }
563
564 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest021, TestSize.Level0)
565 {
566 HcfAsyKeyParamsSpec *paramSpec = nullptr;
567 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
568 HcfResult res = TestCreatePubKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
569 ¶mSpec, &returnObj);
570 ASSERT_EQ(res, HCF_SUCCESS);
571
572 HcfPriKey *priKey = nullptr;
573 res = returnObj->generatePriKey(returnObj, &priKey);
574 ASSERT_EQ(res, HCF_INVALID_PARAMS);
575 ASSERT_EQ(priKey, nullptr);
576
577 HcfKeyPair *keyPair = nullptr;
578 res = returnObj->generateKeyPair(returnObj, &keyPair);
579 ASSERT_EQ(res, HCF_INVALID_PARAMS);
580 ASSERT_EQ(keyPair, nullptr);
581
582 HcfObjDestroy(returnObj);
583 HcfObjDestroy(priKey);
584 HcfObjDestroy(keyPair);
585 DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramSpec));
586 }
587
588 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest022, TestSize.Level0)
589 {
590 HcfAsyKeyParamsSpec *paramSpec = nullptr;
591 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
592
593 HcfResult res = TestCreatePriKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
594 ¶mSpec, &returnObj);
595 ASSERT_EQ(res, HCF_SUCCESS);
596
597 HcfKeyPair *keyPair = nullptr;
598 res = returnObj->generateKeyPair(returnObj, &keyPair);
599 ASSERT_EQ(res, HCF_INVALID_PARAMS);
600 ASSERT_EQ(keyPair, nullptr);
601
602 HcfPubKey *pubKey = nullptr;
603 res = returnObj->generatePubKey(returnObj, &pubKey);
604 ASSERT_EQ(res, HCF_INVALID_PARAMS);
605 ASSERT_EQ(pubKey, nullptr);
606
607 HcfObjDestroy(returnObj);
608 HcfObjDestroy(keyPair);
609 HcfObjDestroy(pubKey);
610 DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramSpec));
611 }
612
613 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest023, TestSize.Level0)
614 {
615 HcfAsyKeyGenerator *generator;
616 HcfResult res = HcfAsyKeyGeneratorCreate(g_ed25519AlgoName.c_str(), &generator);
617 ASSERT_EQ(res, HCF_SUCCESS);
618
619 HcfKeyPair *keyPair = nullptr;
620 res = generator->generateKeyPair(generator, nullptr, &keyPair);
621
622 ASSERT_EQ(res, HCF_SUCCESS);
623 ASSERT_NE(keyPair, nullptr);
624
625 HcfBlob blob1 = { .data = nullptr, .len = 0 };
626 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob1);
627 ASSERT_EQ(res, HCF_SUCCESS);
628 ASSERT_NE(blob1.data, nullptr);
629 ASSERT_NE(blob1.len, 0);
630
631 HcfAsyKeyParamsSpec *paramSpec = nullptr;
632 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
633 res = TestCreatePubKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
634 ¶mSpec, &returnObj);
635 ASSERT_EQ(res, HCF_SUCCESS);
636
637 HcfPubKey *pubKey = nullptr;
638 res = returnObj->generatePubKey(returnObj, &pubKey);
639 ASSERT_EQ(res, HCF_SUCCESS);
640 ASSERT_NE(pubKey, nullptr);
641
642 HcfBlob blob2 = { .data = nullptr, .len = 0 };
643 res = pubKey->base.getEncoded(&(pubKey->base), &blob2);
644 ASSERT_EQ(res, HCF_SUCCESS);
645 ASSERT_NE(blob2.data, nullptr);
646 ASSERT_NE(blob2.len, 0);
647
648 ASSERT_EQ(*(blob1.data), *(blob2.data));
649 ASSERT_EQ(blob1.len, blob2.len);
650
651 HcfFree(blob1.data);
652 HcfFree(blob2.data);
653 HcfObjDestroy(returnObj);
654 HcfObjDestroy(pubKey);
655 HcfObjDestroy(keyPair);
656 DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramSpec));
657 }
658
659 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest024, TestSize.Level0)
660 {
661 HcfAsyKeyGenerator *generator;
662 HcfResult res = HcfAsyKeyGeneratorCreate(g_ed25519AlgoName.c_str(), &generator);
663 ASSERT_EQ(res, HCF_SUCCESS);
664
665 HcfKeyPair *keyPair = nullptr;
666 res = generator->generateKeyPair(generator, nullptr, &keyPair);
667
668 ASSERT_EQ(res, HCF_SUCCESS);
669 ASSERT_NE(keyPair, nullptr);
670
671 HcfBlob blob1 = { .data = nullptr, .len = 0 };
672 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob1);
673 ASSERT_EQ(res, HCF_SUCCESS);
674 ASSERT_NE(blob1.data, nullptr);
675 ASSERT_NE(blob1.len, 0);
676
677 HcfAsyKeyParamsSpec *paramSpec = nullptr;
678 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
679
680 res = TestCreatePriKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
681 ¶mSpec, &returnObj);
682 ASSERT_EQ(res, HCF_SUCCESS);
683
684 HcfPriKey *priKey = nullptr;
685 res = returnObj->generatePriKey(returnObj, &priKey);
686 ASSERT_EQ(res, HCF_SUCCESS);
687 ASSERT_NE(priKey, nullptr);
688
689 HcfBlob blob2 = { .data = nullptr, .len = 0 };
690 res = priKey->base.getEncoded(&(priKey->base), &blob2);
691 ASSERT_EQ(res, HCF_SUCCESS);
692 ASSERT_NE(blob2.data, nullptr);
693 ASSERT_NE(blob2.len, 0);
694
695 ASSERT_EQ(*(blob1.data), *(blob2.data));
696 ASSERT_EQ(blob1.len, blob2.len);
697
698 HcfFree(blob1.data);
699 HcfFree(blob2.data);
700 HcfObjDestroy(returnObj);
701 HcfObjDestroy(priKey);
702 HcfObjDestroy(keyPair);
703 DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramSpec));
704 }
705
706 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest025, TestSize.Level0)
707 {
708 HcfAsyKeyParamsSpec *paramSpec = nullptr;
709 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
710 HcfResult res = TestCreatePriKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
711 ¶mSpec, &returnObj);
712 ASSERT_EQ(res, HCF_SUCCESS);
713
714 HcfPriKey *priKey = nullptr;
715 res = returnObj->generatePriKey(returnObj, &priKey);
716 ASSERT_EQ(res, HCF_SUCCESS);
717 ASSERT_NE(priKey, nullptr);
718
719 HcfBlob blob = { .data = nullptr, .len = 0 };
720 res = priKey->base.getEncoded(&(priKey->base), &blob);
721 ASSERT_EQ(res, HCF_SUCCESS);
722 ASSERT_NE(blob.data, nullptr);
723 ASSERT_NE(blob.len, 0);
724
725 HcfAsyKeyGenerator *generator;
726 res = HcfAsyKeyGeneratorCreate(g_ed25519AlgoName.c_str(), &generator);
727 ASSERT_EQ(res, HCF_SUCCESS);
728
729 HcfKeyPair *keyPair = nullptr;
730 res = generator->convertKey(generator, nullptr, nullptr, &blob, &keyPair);
731
732 HcfFree(blob.data);
733 HcfObjDestroy(returnObj);
734 HcfObjDestroy(priKey);
735 HcfObjDestroy(keyPair);
736 DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramSpec));
737 }
738
739 HWTEST_F(CryptoEd25519AsyKeyGeneratorBySpecTest, CryptoEd25519AsyKeyGeneratorBySpecTest026, TestSize.Level0)
740 {
741 HcfAsyKeyParamsSpec *paramSpec = nullptr;
742 HcfAsyKeyGeneratorBySpec *returnObj = nullptr;
743
744 HcfResult res = TestCreatePubKeyParamsSpecAndGeneratorBySpec(g_ed25519AlgoName.c_str(), true,
745 ¶mSpec, &returnObj);
746 ASSERT_EQ(res, HCF_SUCCESS);
747
748 HcfPubKey *pubKey = nullptr;
749 res = returnObj->generatePubKey(returnObj, &pubKey);
750 ASSERT_EQ(res, HCF_SUCCESS);
751 ASSERT_NE(pubKey, nullptr);
752
753 HcfBlob blob = { .data = nullptr, .len = 0 };
754 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
755 ASSERT_EQ(res, HCF_SUCCESS);
756 ASSERT_NE(blob.data, nullptr);
757 ASSERT_NE(blob.len, 0);
758
759 HcfAsyKeyGenerator *generator;
760 res = HcfAsyKeyGeneratorCreate(g_ed25519AlgoName.c_str(), &generator);
761 ASSERT_EQ(res, HCF_SUCCESS);
762
763 HcfKeyPair *keyPair = nullptr;
764 res = generator->convertKey(generator, nullptr, &blob, nullptr, &keyPair);
765 HcfFree(blob.data);
766 HcfObjDestroy(returnObj);
767 HcfObjDestroy(pubKey);
768 HcfObjDestroy(keyPair);
769 DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramSpec));
770 }
771 }