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 "ecc_asy_key_generator_openssl.h"
21 #include "blob.h"
22 #include "params_parser.h"
23 #include "key_utils.h"
24 #include "key_pair.h"
25 #include "object_base.h"
26 #include "memory.h"
27 #include "memory_mock.h"
28 #include "openssl_adapter_mock.h"
29
30 using namespace std;
31 using namespace testing::ext;
32
33 namespace {
34 class CryptoX25519AsyKeyGeneratorTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp();
39 void TearDown();
40 };
41
TearDownTestCase()42 void CryptoX25519AsyKeyGeneratorTest::TearDownTestCase() {}
SetUp()43 void CryptoX25519AsyKeyGeneratorTest::SetUp() {}
TearDown()44 void CryptoX25519AsyKeyGeneratorTest::TearDown() {}
45
46 static string g_x25519AlgoName = "X25519";
47 static string g_pubkeyformatName = "X.509";
48 static string g_prikeyformatName = "PKCS#8";
49
50 HcfBlob g_mockX25519PriKeyBlob = {
51 .data = nullptr,
52 .len = 0
53 };
54
55 HcfBlob g_mockX25519PubKeyBlob = {
56 .data = nullptr,
57 .len = 0
58 };
59
X25519KeyBlob(HcfBlob * priblob,HcfBlob * pubblob)60 static HcfResult X25519KeyBlob(HcfBlob * priblob, HcfBlob *pubblob)
61 {
62 HcfAsyKeyGenerator *generator = nullptr;
63 HcfResult res = HcfAsyKeyGeneratorCreate("X25519", &generator);
64 if (res != HCF_SUCCESS) {
65 return res;
66 }
67
68 HcfKeyPair *keyPair = nullptr;
69 res = generator->generateKeyPair(generator, nullptr, &keyPair);
70 if (res != HCF_SUCCESS) {
71 HcfObjDestroy(generator);
72 return res;
73 }
74 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &g_mockX25519PriKeyBlob);
75 if (res != HCF_SUCCESS) {
76 HcfObjDestroy(generator);
77 HcfObjDestroy(keyPair);
78 return res;
79 }
80 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &g_mockX25519PubKeyBlob);
81 if (res != HCF_SUCCESS) {
82 HcfObjDestroy(generator);
83 HcfObjDestroy(keyPair);
84 return res;
85 }
86 HcfObjDestroy(generator);
87 HcfObjDestroy(keyPair);
88 return HCF_SUCCESS;
89 }
90
SetUpTestCase()91 void CryptoX25519AsyKeyGeneratorTest::SetUpTestCase()
92 {
93 HcfResult res = X25519KeyBlob(&g_mockX25519PriKeyBlob, &g_mockX25519PubKeyBlob);
94 ASSERT_EQ(res, HCF_SUCCESS);
95 }
96
97 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest001, TestSize.Level0)
98 {
99 HcfAsyKeyGenerator *generator = nullptr;
100 HcfResult res = TestHcfAsyKeyGeneratorCreate(g_x25519AlgoName.c_str(), &generator);
101 ASSERT_EQ(res, HCF_SUCCESS);
102
103 HcfObjDestroy(generator);
104 }
105
106 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest002, TestSize.Level0)
107 {
108 HcfAsyKeyGenerator *generator = nullptr;
109 HcfResult res = HcfAsyKeyGeneratorCreate("X25519", &generator);
110
111 const char *className = generator->base.getClass();
112
113 ASSERT_EQ(res, HCF_SUCCESS);
114 ASSERT_NE(className, nullptr);
115
116 HcfObjDestroy(generator);
117 }
118
119 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest003, TestSize.Level0)
120 {
121 HcfAsyKeyGenerator *generator = nullptr;
122 HcfResult res = TestHcfAsyKeyGeneratorCreate(g_x25519AlgoName.c_str(), &generator);
123 ASSERT_EQ(res, HCF_SUCCESS);
124
125 generator->base.destroy((HcfObjectBase *)generator);
126 }
127
128 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest004, TestSize.Level0)
129 {
130 HcfAsyKeyGenerator *generator = nullptr;
131 HcfResult res = TestHcfAsyKeyGeneratorCreate(g_x25519AlgoName.c_str(), &generator);
132 ASSERT_EQ(res, HCF_SUCCESS);
133
134 const char *algoName = generator->getAlgoName(generator);
135
136 ASSERT_EQ(res, HCF_SUCCESS);
137 ASSERT_EQ(algoName, g_x25519AlgoName);
138
139 HcfObjDestroy(generator);
140 }
141
142 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest005, TestSize.Level0)
143 {
144 HcfAsyKeyGenerator *generator = nullptr;
145 HcfKeyPair *keyPair = nullptr;
146 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_x25519AlgoName.c_str(), &generator, &keyPair);
147 ASSERT_EQ(res, HCF_SUCCESS);
148
149 HcfObjDestroy(keyPair);
150 HcfObjDestroy(generator);
151 }
152
153 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest006, TestSize.Level0)
154 {
155 HcfAsyKeyGenerator *generator = nullptr;
156 HcfKeyPair *keyPair = nullptr;
157 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_x25519AlgoName.c_str(), &generator, &keyPair);
158 ASSERT_EQ(res, HCF_SUCCESS);
159
160 const char *className = keyPair->base.getClass();
161 ASSERT_NE(className, nullptr);
162
163 HcfObjDestroy(keyPair);
164 HcfObjDestroy(generator);
165 }
166
167 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest007, TestSize.Level0)
168 {
169 HcfAsyKeyGenerator *generator = nullptr;
170 HcfKeyPair *keyPair = nullptr;
171 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_x25519AlgoName.c_str(), &generator, &keyPair);
172 ASSERT_EQ(res, HCF_SUCCESS);
173
174 keyPair->base.destroy(&(keyPair->base));
175 HcfObjDestroy(generator);
176 }
177
178 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest008, TestSize.Level0)
179 {
180 HcfAsyKeyGenerator *generator = nullptr;
181 HcfKeyPair *keyPair = nullptr;
182 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_x25519AlgoName.c_str(), &generator, &keyPair);
183 ASSERT_EQ(res, HCF_SUCCESS);
184
185 const char *className = keyPair->pubKey->base.base.getClass();
186 ASSERT_NE(className, nullptr);
187
188 HcfObjDestroy(keyPair);
189 HcfObjDestroy(generator);
190 }
191
192 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest009, TestSize.Level0)
193 {
194 HcfAsyKeyGenerator *generator = nullptr;
195 HcfKeyPair *keyPair = nullptr;
196 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_x25519AlgoName.c_str(), &generator, &keyPair);
197 ASSERT_EQ(res, HCF_SUCCESS);
198
199 keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
200 keyPair->pubKey = nullptr;
201
202 HcfObjDestroy(keyPair);
203 HcfObjDestroy(generator);
204 }
205
206 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest010, TestSize.Level0)
207 {
208 HcfAsyKeyGenerator *generator = nullptr;
209 HcfKeyPair *keyPair = nullptr;
210 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_x25519AlgoName.c_str(), &generator, &keyPair);
211 ASSERT_EQ(res, HCF_SUCCESS);
212
213 const char *algorithmName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
214 ASSERT_EQ(algorithmName, g_x25519AlgoName);
215
216 HcfBlob blob = { .data = nullptr, .len = 0 };
217 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
218 ASSERT_EQ(res, HCF_SUCCESS);
219 ASSERT_NE(blob.data, nullptr);
220 ASSERT_NE(blob.len, 0);
221 HcfFree(blob.data);
222 const char *formatName = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
223 ASSERT_EQ(formatName, g_pubkeyformatName);
224
225 HcfObjDestroy(keyPair);
226 HcfObjDestroy(generator);
227 }
228
229 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest011, TestSize.Level0)
230 {
231 HcfAsyKeyGenerator *generator = nullptr;
232 HcfKeyPair *keyPair = nullptr;
233 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_x25519AlgoName.c_str(), &generator, &keyPair);
234 ASSERT_EQ(res, HCF_SUCCESS);
235
236 const char *className = keyPair->priKey->base.base.getClass();
237 ASSERT_NE(className, nullptr);
238
239 HcfObjDestroy(keyPair);
240 HcfObjDestroy(generator);
241 }
242
243 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest012, TestSize.Level0)
244 {
245 HcfAsyKeyGenerator *generator = nullptr;
246 HcfKeyPair *keyPair = nullptr;
247 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_x25519AlgoName.c_str(), &generator, &keyPair);
248 ASSERT_EQ(res, HCF_SUCCESS);
249
250 keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
251 keyPair->priKey = nullptr;
252
253 HcfObjDestroy(keyPair);
254 HcfObjDestroy(generator);
255 }
256
257 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest013, TestSize.Level0)
258 {
259 HcfAsyKeyGenerator *generator = nullptr;
260 HcfKeyPair *keyPair = nullptr;
261 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_x25519AlgoName.c_str(), &generator, &keyPair);
262 ASSERT_EQ(res, HCF_SUCCESS);
263
264 const char *algorithmName = keyPair->priKey->base.getAlgorithm(&(keyPair->priKey->base));
265 ASSERT_EQ(algorithmName, g_x25519AlgoName);
266
267 HcfBlob blob = { .data = nullptr, .len = 0 };
268 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
269 ASSERT_EQ(res, HCF_SUCCESS);
270 ASSERT_NE(blob.data, nullptr);
271 ASSERT_NE(blob.len, 0);
272 HcfFree(blob.data);
273 const char *formatName = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
274 ASSERT_EQ(formatName, g_prikeyformatName);
275
276 HcfObjDestroy(keyPair);
277 HcfObjDestroy(generator);
278 }
279
280 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest014, TestSize.Level0)
281 {
282 HcfAsyKeyGenerator *generator = nullptr;
283 HcfKeyPair *keyPair = nullptr;
284 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_x25519AlgoName.c_str(), &generator, &keyPair);
285 ASSERT_EQ(res, HCF_SUCCESS);
286
287 keyPair->priKey->clearMem(keyPair->priKey);
288 HcfBlob blob = { .data = nullptr, .len = 0 };
289 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
290 ASSERT_EQ(res, HCF_INVALID_PARAMS);
291 ASSERT_EQ(blob.data, nullptr);
292 ASSERT_EQ(blob.len, 0);
293 HcfFree(blob.data);
294 HcfObjDestroy(keyPair);
295 HcfObjDestroy(generator);
296 }
297
298 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest015, TestSize.Level0)
299 {
300 HcfAsyKeyGenerator *generator = nullptr;
301 HcfKeyPair *keyPair = nullptr;
302 HcfResult res = TestGenerateKeyPairAndConvertKey(g_x25519AlgoName.c_str(), &generator, &g_mockX25519PubKeyBlob,
303 &g_mockX25519PriKeyBlob, &keyPair);
304 ASSERT_EQ(res, HCF_SUCCESS);
305
306 res = TestGenerateConvertKey(generator, nullptr, &g_mockX25519PriKeyBlob, &keyPair);
307 ASSERT_EQ(res, HCF_SUCCESS);
308
309 res = TestGenerateConvertKey(generator, &g_mockX25519PubKeyBlob, nullptr, &keyPair);
310 ASSERT_EQ(res, HCF_SUCCESS);
311
312 HcfObjDestroy(keyPair);
313 HcfObjDestroy(generator);
314 }
315
316 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest016, TestSize.Level0)
317 {
318 HcfAsyKeyGenerator *generator = nullptr;
319 HcfKeyPair *keyPair = nullptr;
320 HcfResult res = TestGenerateKeyPairAndConvertKey(g_x25519AlgoName.c_str(), &generator, &g_mockX25519PubKeyBlob,
321 &g_mockX25519PriKeyBlob, &keyPair);
322 ASSERT_EQ(res, HCF_SUCCESS);
323
324 const char *className = keyPair->base.getClass();
325 ASSERT_NE(className, nullptr);
326
327 HcfObjDestroy(keyPair);
328 HcfObjDestroy(generator);
329 }
330
331 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest017, TestSize.Level0)
332 {
333 HcfAsyKeyGenerator *generator = nullptr;
334 HcfKeyPair *keyPair = nullptr;
335 HcfResult res = TestGenerateKeyPairAndConvertKey(g_x25519AlgoName.c_str(), &generator, &g_mockX25519PubKeyBlob,
336 &g_mockX25519PriKeyBlob, &keyPair);
337 ASSERT_EQ(res, HCF_SUCCESS);
338
339 keyPair->base.destroy(&(keyPair->base));
340
341 HcfObjDestroy(generator);
342 }
343
344 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest018, TestSize.Level0)
345 {
346 HcfAsyKeyGenerator *generator = nullptr;
347 HcfKeyPair *keyPair = nullptr;
348 HcfResult res = TestGenerateKeyPairAndConvertKey(g_x25519AlgoName.c_str(), &generator, &g_mockX25519PubKeyBlob,
349 &g_mockX25519PriKeyBlob, &keyPair);
350 ASSERT_EQ(res, HCF_SUCCESS);
351
352 const char *className = keyPair->pubKey->base.base.getClass();
353 ASSERT_NE(className, nullptr);
354
355 HcfObjDestroy(keyPair);
356 HcfObjDestroy(generator);
357 }
358
359 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest019, TestSize.Level0)
360 {
361 HcfAsyKeyGenerator *generator = nullptr;
362 HcfKeyPair *keyPair = nullptr;
363 HcfResult res = TestGenerateKeyPairAndConvertKey(g_x25519AlgoName.c_str(), &generator, &g_mockX25519PubKeyBlob,
364 &g_mockX25519PriKeyBlob, &keyPair);
365 ASSERT_EQ(res, HCF_SUCCESS);
366
367 keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
368 keyPair->pubKey = nullptr;
369
370 HcfObjDestroy(keyPair);
371 HcfObjDestroy(generator);
372 }
373
374 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest020, TestSize.Level0)
375 {
376 HcfAsyKeyGenerator *generator = nullptr;
377 HcfKeyPair *keyPair = nullptr;
378 HcfResult res = TestGenerateKeyPairAndConvertKey(g_x25519AlgoName.c_str(), &generator, &g_mockX25519PubKeyBlob,
379 &g_mockX25519PriKeyBlob, &keyPair);
380 ASSERT_EQ(res, HCF_SUCCESS);
381
382 const char *algorithmName = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
383 ASSERT_NE(algorithmName, nullptr);
384
385 HcfBlob blob = { .data = nullptr, .len = 0 };
386 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
387 ASSERT_EQ(res, HCF_SUCCESS);
388 ASSERT_NE(blob.data, nullptr);
389 ASSERT_NE(blob.len, 0);
390 HcfFree(blob.data);
391
392 const char *formatName = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
393 ASSERT_NE(formatName, nullptr);
394
395 HcfObjDestroy(keyPair);
396 HcfObjDestroy(generator);
397 }
398
399 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest021, TestSize.Level0)
400 {
401 HcfAsyKeyGenerator *generator = nullptr;
402 HcfKeyPair *keyPair = nullptr;
403 HcfResult res = TestGenerateKeyPairAndConvertKey(g_x25519AlgoName.c_str(), &generator, &g_mockX25519PubKeyBlob,
404 &g_mockX25519PriKeyBlob, &keyPair);
405 ASSERT_EQ(res, HCF_SUCCESS);
406
407 const char *className = keyPair->priKey->base.base.getClass();
408 ASSERT_NE(className, nullptr);
409
410 HcfObjDestroy(keyPair);
411 HcfObjDestroy(generator);
412 }
413
414 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest022, TestSize.Level0)
415 {
416 HcfAsyKeyGenerator *generator = nullptr;
417 HcfKeyPair *keyPair = nullptr;
418 HcfResult res = TestGenerateKeyPairAndConvertKey(g_x25519AlgoName.c_str(), &generator, &g_mockX25519PubKeyBlob,
419 &g_mockX25519PriKeyBlob, &keyPair);
420 ASSERT_EQ(res, HCF_SUCCESS);
421
422 keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
423 keyPair->priKey = nullptr;
424
425 HcfObjDestroy(keyPair);
426 HcfObjDestroy(generator);
427 }
428
429 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest023, TestSize.Level0)
430 {
431 HcfAsyKeyGenerator *generator = nullptr;
432 HcfKeyPair *keyPair = nullptr;
433 HcfResult res = TestGenerateKeyPairAndConvertKey(g_x25519AlgoName.c_str(), &generator, &g_mockX25519PubKeyBlob,
434 &g_mockX25519PriKeyBlob, &keyPair);
435 ASSERT_EQ(res, HCF_SUCCESS);
436
437 const char *algorithmName = keyPair->priKey->base.getAlgorithm(&(keyPair->priKey->base));
438 ASSERT_NE(algorithmName, nullptr);
439
440 HcfBlob blob = { .data = nullptr, .len = 0 };
441 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
442 ASSERT_EQ(res, HCF_SUCCESS);
443 ASSERT_NE(blob.data, nullptr);
444 ASSERT_NE(blob.len, 0);
445 HcfFree(blob.data);
446
447 const char *formatName = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
448 ASSERT_NE(formatName, nullptr);
449
450 HcfObjDestroy(keyPair);
451 HcfObjDestroy(generator);
452 }
453
454 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest024, TestSize.Level0)
455 {
456 HcfAsyKeyGenerator *generator = nullptr;
457 HcfKeyPair *keyPair = nullptr;
458 HcfResult res = TestGenerateKeyPairAndConvertKey(g_x25519AlgoName.c_str(), &generator, &g_mockX25519PubKeyBlob,
459 &g_mockX25519PriKeyBlob, &keyPair);
460 ASSERT_EQ(res, HCF_SUCCESS);
461
462 keyPair->priKey->clearMem(keyPair->priKey);
463 HcfBlob blob = { .data = nullptr, .len = 0 };
464 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
465 ASSERT_EQ(res, HCF_INVALID_PARAMS);
466 ASSERT_EQ(blob.data, nullptr);
467 ASSERT_EQ(blob.len, 0);
468 HcfFree(blob.data);
469
470 HcfObjDestroy(keyPair);
471 HcfObjDestroy(generator);
472 }
473
MemoryMallocTestFunc(uint32_t mallocCount)474 static void MemoryMallocTestFunc(uint32_t mallocCount)
475 {
476 for (uint32_t i = 0; i < mallocCount; i++) {
477 ResetRecordMallocNum();
478 SetMockMallocIndex(i);
479 HcfAsyKeyGenerator *tmpGenerator = nullptr;
480 HcfResult res = HcfAsyKeyGeneratorCreate("X25519", &tmpGenerator);
481 if (res != HCF_SUCCESS) {
482 continue;
483 }
484 HcfKeyPair *tmpKeyPair = nullptr;
485 res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
486 if (res != HCF_SUCCESS) {
487 HcfObjDestroy(tmpGenerator);
488 continue;
489 }
490 HcfBlob tmpPubKeyBlob = {
491 .data = nullptr,
492 .len = 0
493 };
494 res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
495 if (res != HCF_SUCCESS) {
496 HcfObjDestroy(tmpKeyPair);
497 HcfObjDestroy(tmpGenerator);
498 continue;
499 }
500 HcfBlob tmpPriKeyBlob = {
501 .data = nullptr,
502 .len = 0
503 };
504 res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
505 if (res != HCF_SUCCESS) {
506 HcfFree(tmpPubKeyBlob.data);
507 HcfObjDestroy(tmpKeyPair);
508 HcfObjDestroy(tmpGenerator);
509 continue;
510 }
511 HcfKeyPair *tmpOutKeyPair = nullptr;
512 res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
513 HcfFree(tmpPubKeyBlob.data);
514 HcfFree(tmpPriKeyBlob.data);
515 HcfObjDestroy(tmpKeyPair);
516 HcfObjDestroy(tmpGenerator);
517 if (res == HCF_SUCCESS) {
518 HcfObjDestroy(tmpOutKeyPair);
519 }
520 }
521 }
522
523 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest025, TestSize.Level0)
524 {
525 StartRecordMallocNum();
526 HcfAsyKeyGenerator *generator = nullptr;
527 HcfKeyPair *keyPair = nullptr;
528 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_x25519AlgoName.c_str(), &generator, &keyPair);
529 ASSERT_EQ(res, HCF_SUCCESS);
530
531 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
532 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
533
534 ASSERT_EQ(res, HCF_SUCCESS);
535 ASSERT_NE(pubKeyBlob.data, nullptr);
536 ASSERT_NE(pubKeyBlob.len, 0);
537
538 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
539 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
540
541 ASSERT_EQ(res, HCF_SUCCESS);
542 ASSERT_NE(priKeyBlob.data, nullptr);
543 ASSERT_NE(priKeyBlob.len, 0);
544
545 HcfKeyPair *outKeyPair = nullptr;
546 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
547
548 HcfFree(pubKeyBlob.data);
549 HcfFree(priKeyBlob.data);
550 HcfObjDestroy(outKeyPair);
551 HcfObjDestroy(keyPair);
552 HcfObjDestroy(generator);
553
554 uint32_t mallocCount = GetMallocNum();
555 MemoryMallocTestFunc(mallocCount);
556
557 EndRecordMallocNum();
558 }
559
OpensslMockTestFunc(uint32_t mallocCount)560 static void OpensslMockTestFunc(uint32_t mallocCount)
561 {
562 for (uint32_t i = 0; i < mallocCount; i++) {
563 ResetOpensslCallNum();
564 SetOpensslCallMockIndex(i);
565 HcfAsyKeyGenerator *tmpGenerator = nullptr;
566 HcfResult res = HcfAsyKeyGeneratorCreate("X25519", &tmpGenerator);
567 if (res != HCF_SUCCESS) {
568 continue;
569 }
570 HcfKeyPair *tmpKeyPair = nullptr;
571 res = tmpGenerator->generateKeyPair(tmpGenerator, nullptr, &tmpKeyPair);
572 if (res != HCF_SUCCESS) {
573 HcfObjDestroy(tmpGenerator);
574 continue;
575 }
576 HcfBlob tmpPubKeyBlob = {
577 .data = nullptr,
578 .len = 0
579 };
580 res = tmpKeyPair->pubKey->base.getEncoded(&(tmpKeyPair->pubKey->base), &tmpPubKeyBlob);
581 if (res != HCF_SUCCESS) {
582 HcfObjDestroy(tmpKeyPair);
583 HcfObjDestroy(tmpGenerator);
584 continue;
585 }
586 HcfBlob tmpPriKeyBlob = {
587 .data = nullptr,
588 .len = 0
589 };
590 res = tmpKeyPair->priKey->base.getEncoded(&(tmpKeyPair->priKey->base), &tmpPriKeyBlob);
591 if (res != HCF_SUCCESS) {
592 HcfFree(tmpPubKeyBlob.data);
593 HcfObjDestroy(tmpKeyPair);
594 HcfObjDestroy(tmpGenerator);
595 continue;
596 }
597 HcfKeyPair *tmpOutKeyPair = nullptr;
598 res = tmpGenerator->convertKey(tmpGenerator, nullptr, &tmpPubKeyBlob, &tmpPriKeyBlob, &tmpOutKeyPair);
599 HcfFree(tmpPubKeyBlob.data);
600 HcfFree(tmpPriKeyBlob.data);
601 HcfObjDestroy(tmpKeyPair);
602 HcfObjDestroy(tmpGenerator);
603 if (res == HCF_SUCCESS) {
604 HcfObjDestroy(tmpOutKeyPair);
605 }
606 }
607 }
608
609 HWTEST_F(CryptoX25519AsyKeyGeneratorTest, CryptoX25519AsyKeyGeneratorTest026, TestSize.Level0)
610 {
611 StartRecordOpensslCallNum();
612 HcfAsyKeyGenerator *generator = nullptr;
613 HcfKeyPair *keyPair = nullptr;
614 HcfResult res = TestKeyGeneratorAndGenerateKeyPair(g_x25519AlgoName.c_str(), &generator, &keyPair);
615 ASSERT_EQ(res, HCF_SUCCESS);
616
617 HcfBlob pubKeyBlob = { .data = nullptr, .len = 0 };
618 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
619
620 ASSERT_EQ(res, HCF_SUCCESS);
621 ASSERT_NE(pubKeyBlob.data, nullptr);
622 ASSERT_NE(pubKeyBlob.len, 0);
623
624 HcfBlob priKeyBlob = { .data = nullptr, .len = 0 };
625 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
626
627 ASSERT_EQ(res, HCF_SUCCESS);
628 ASSERT_NE(priKeyBlob.data, nullptr);
629 ASSERT_NE(priKeyBlob.len, 0);
630
631 HcfKeyPair *outKeyPair = nullptr;
632 res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &outKeyPair);
633
634 HcfFree(pubKeyBlob.data);
635 HcfFree(priKeyBlob.data);
636 HcfObjDestroy(outKeyPair);
637 HcfObjDestroy(keyPair);
638 HcfObjDestroy(generator);
639
640 uint32_t mallocCount = GetOpensslCallNum();
641 OpensslMockTestFunc(mallocCount);
642
643 EndRecordOpensslCallNum();
644 }
645 }