1 /*
2 * Copyright (C) 2022-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 "asy_key_generator.h"
20 #include "ecdh_openssl.h"
21 #include "key_agreement.h"
22 #include "memory.h"
23 #include "memory_mock.h"
24 #include "openssl_adapter_mock.h"
25 #include "params_parser.h"
26 #include "ecc_openssl_common.h"
27
28 using namespace std;
29 using namespace testing::ext;
30
31 static string g_testEccSecp256k1PriKey = "-----BEGIN PRIVATE KEY-----\n"
32 "MIGEAgEAMBAGByqGSM49AgEGBSuBBAAKBG0wawIBAQQgHCRzy0IcEx6CeA6ogNNK\n"
33 "SOfuTlHy4fE/LNxkANUS4k+hRANCAASDBmwKklX4OcbZSJJX9mxm1Wr7TPTLpbyp\n"
34 "xKcKRm0XKNxVlrZU8WQCl66GtX2DDyX+0+XiC3hbaRWcYtg7P6WO\n"
35 "-----END PRIVATE KEY-----\n";
36
37 static string g_testEccSecp256k1PubKey = "-----BEGIN PUBLIC KEY-----\n"
38 "MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEBUKCHJHsvlcod0MCVlFHylzW241nveMm\n"
39 "RAFhryNgX6rVqooGReVUm+WiF7Uz0ZsIjdHKd9HHe+2BOWfnuWyR1A==\n"
40 "-----END PUBLIC KEY-----\n";
41
42 static uint8_t SharedSecret[] = {0xaf, 0x43, 0xb5, 0x27, 0x90, 0x08, 0x2f, 0xd8,
43 0x7a, 0xfb, 0x1d, 0x14, 0xb8, 0x83, 0xc1, 0x2d,
44 0x12, 0xbb, 0x9e, 0x55, 0x40, 0x80, 0xd1, 0xf8,
45 0xe5, 0x27, 0x92, 0x06, 0x76, 0xe3, 0x1f, 0x3e};
46
47 namespace {
48 class CryptoEccKeyAgreementTest : public testing::Test {
49 public:
50 static void SetUpTestCase();
51 static void TearDownTestCase();
52 void SetUp();
53 void TearDown();
54
55 static HcfKeyPair *ecc224KeyPair_;
56 static HcfKeyPair *ecc256KeyPair_;
57 static HcfKeyPair *ecc384KeyPair_;
58 static HcfKeyPair *ecc521KeyPair_;
59 };
60
61 HcfKeyPair *CryptoEccKeyAgreementTest::ecc224KeyPair_ = nullptr;
62 HcfKeyPair *CryptoEccKeyAgreementTest::ecc256KeyPair_ = nullptr;
63 HcfKeyPair *CryptoEccKeyAgreementTest::ecc384KeyPair_ = nullptr;
64 HcfKeyPair *CryptoEccKeyAgreementTest::ecc521KeyPair_ = nullptr;
65
SetUp()66 void CryptoEccKeyAgreementTest::SetUp() {}
TearDown()67 void CryptoEccKeyAgreementTest::TearDown() {}
68
SetUpTestCase()69 void CryptoEccKeyAgreementTest::SetUpTestCase()
70 {
71 HcfAsyKeyGenerator *generator = nullptr;
72 int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
73 ASSERT_EQ(res, HCF_SUCCESS);
74 ASSERT_NE(generator, nullptr);
75
76 HcfKeyPair *keyPair = nullptr;
77 res = generator->generateKeyPair(generator, nullptr, &keyPair);
78 ASSERT_EQ(res, HCF_SUCCESS);
79 ASSERT_NE(keyPair, nullptr);
80
81 ecc224KeyPair_ = keyPair;
82
83 HcfObjDestroy(generator);
84
85 HcfAsyKeyGenerator *generator2 = nullptr;
86 res = HcfAsyKeyGeneratorCreate("ECC256", &generator2);
87 ASSERT_EQ(res, HCF_SUCCESS);
88 ASSERT_NE(generator2, nullptr);
89
90 HcfKeyPair *keyPair2 = nullptr;
91 res = generator2->generateKeyPair(generator2, nullptr, &keyPair2);
92 ASSERT_EQ(res, HCF_SUCCESS);
93 ASSERT_NE(keyPair2, nullptr);
94
95 ecc256KeyPair_ = keyPair2;
96
97 HcfObjDestroy(generator2);
98
99 HcfAsyKeyGenerator *generator3 = nullptr;
100 res = HcfAsyKeyGeneratorCreate("ECC384", &generator3);
101 ASSERT_EQ(res, HCF_SUCCESS);
102 ASSERT_NE(generator3, nullptr);
103
104 HcfKeyPair *keyPair3 = nullptr;
105 res = generator3->generateKeyPair(generator3, nullptr, &keyPair3);
106 ASSERT_EQ(res, HCF_SUCCESS);
107 ASSERT_NE(keyPair3, nullptr);
108
109 ecc384KeyPair_ = keyPair3;
110
111 HcfObjDestroy(generator3);
112
113 HcfAsyKeyGenerator *generator4 = nullptr;
114 res = HcfAsyKeyGeneratorCreate("ECC521", &generator4);
115 ASSERT_EQ(res, HCF_SUCCESS);
116 ASSERT_NE(generator4, nullptr);
117
118 HcfKeyPair *keyPair4 = nullptr;
119 res = generator4->generateKeyPair(generator4, nullptr, &keyPair4);
120 ASSERT_EQ(res, HCF_SUCCESS);
121 ASSERT_NE(keyPair4, nullptr);
122
123 ecc521KeyPair_ = keyPair4;
124
125 HcfObjDestroy(generator4);
126 }
127
TearDownTestCase()128 void CryptoEccKeyAgreementTest::TearDownTestCase()
129 {
130 HcfObjDestroy(ecc224KeyPair_);
131 HcfObjDestroy(ecc256KeyPair_);
132 HcfObjDestroy(ecc384KeyPair_);
133 HcfObjDestroy(ecc521KeyPair_);
134 }
135
GetMockClass(void)136 static const char *GetMockClass(void)
137 {
138 return "HcfSymKeyGenerator";
139 }
140
141 static HcfObjectBase obj = {
142 .getClass = GetMockClass,
143 .destroy = nullptr
144 };
145
146 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest001, TestSize.Level0)
147 {
148 HcfKeyAgreement *keyAgreement = nullptr;
149 int32_t res = HcfKeyAgreementCreate("ECC224", &keyAgreement);
150
151 ASSERT_EQ(res, HCF_SUCCESS);
152 ASSERT_NE(keyAgreement, nullptr);
153
154 HcfObjDestroy(keyAgreement);
155 }
156
157 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest002, TestSize.Level0)
158 {
159 HcfKeyAgreement *keyAgreement = nullptr;
160 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
161
162 ASSERT_EQ(res, HCF_SUCCESS);
163 ASSERT_NE(keyAgreement, nullptr);
164
165 HcfObjDestroy(keyAgreement);
166 }
167
168 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest003, TestSize.Level0)
169 {
170 HcfKeyAgreement *keyAgreement = nullptr;
171 int32_t res = HcfKeyAgreementCreate("ECC384", &keyAgreement);
172
173 ASSERT_EQ(res, HCF_SUCCESS);
174 ASSERT_NE(keyAgreement, nullptr);
175
176 HcfObjDestroy(keyAgreement);
177 }
178
179 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest004, TestSize.Level0)
180 {
181 HcfKeyAgreement *keyAgreement = nullptr;
182 int32_t res = HcfKeyAgreementCreate("ECC521", &keyAgreement);
183
184 ASSERT_EQ(res, HCF_SUCCESS);
185 ASSERT_NE(keyAgreement, nullptr);
186
187 HcfObjDestroy(keyAgreement);
188 }
189
190 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest005, TestSize.Level0)
191 {
192 HcfKeyAgreement *keyAgreement = nullptr;
193 int32_t res = HcfKeyAgreementCreate(nullptr, &keyAgreement);
194
195 ASSERT_EQ(res, HCF_INVALID_PARAMS);
196 ASSERT_EQ(keyAgreement, nullptr);
197 }
198
199 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest006, TestSize.Level0)
200 {
201 HcfKeyAgreement *keyAgreement = nullptr;
202 int32_t res = HcfKeyAgreementCreate("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD"
203 "ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", &keyAgreement);
204
205 ASSERT_EQ(res, HCF_INVALID_PARAMS);
206 ASSERT_EQ(keyAgreement, nullptr);
207 }
208
209 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest007, TestSize.Level0)
210 {
211 HcfKeyAgreement *keyAgreement = nullptr;
212 int32_t res = HcfKeyAgreementCreate("ECC257", &keyAgreement);
213
214 ASSERT_EQ(res, HCF_INVALID_PARAMS);
215 ASSERT_EQ(keyAgreement, nullptr);
216 }
217
218 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest008, TestSize.Level0)
219 {
220 int32_t res = HcfKeyAgreementCreate("ECC256", nullptr);
221
222 ASSERT_EQ(res, HCF_INVALID_PARAMS);
223 }
224
225 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest101, TestSize.Level0)
226 {
227 HcfKeyAgreement *keyAgreement = nullptr;
228 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
229
230 ASSERT_EQ(res, HCF_SUCCESS);
231 ASSERT_NE(keyAgreement, nullptr);
232
233 const char *className = keyAgreement->base.getClass();
234
235 ASSERT_NE(className, nullptr);
236
237 HcfObjDestroy(keyAgreement);
238 }
239
240 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest102, TestSize.Level0)
241 {
242 HcfKeyAgreement *keyAgreement = nullptr;
243 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
244
245 ASSERT_EQ(res, HCF_SUCCESS);
246 ASSERT_NE(keyAgreement, nullptr);
247
248 keyAgreement->base.destroy((HcfObjectBase *)keyAgreement);
249 }
250
251 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest103, TestSize.Level0)
252 {
253 HcfKeyAgreement *keyAgreement = nullptr;
254 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
255
256 ASSERT_EQ(res, HCF_SUCCESS);
257 ASSERT_NE(keyAgreement, nullptr);
258
259 keyAgreement->base.destroy(nullptr);
260
261 HcfObjDestroy(keyAgreement);
262 }
263
264 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest104, TestSize.Level0)
265 {
266 HcfKeyAgreement *keyAgreement = nullptr;
267 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
268
269 ASSERT_EQ(res, HCF_SUCCESS);
270 ASSERT_NE(keyAgreement, nullptr);
271
272 keyAgreement->base.destroy(&obj);
273
274 HcfObjDestroy(keyAgreement);
275 }
276
277 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest105, TestSize.Level0)
278 {
279 HcfKeyAgreement *keyAgreement = nullptr;
280 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
281
282 ASSERT_EQ(res, HCF_SUCCESS);
283 ASSERT_NE(keyAgreement, nullptr);
284
285 const char *algName = keyAgreement->getAlgoName(keyAgreement);
286
287 ASSERT_NE(algName, nullptr);
288
289 HcfObjDestroy(keyAgreement);
290 }
291
292 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest106, TestSize.Level0)
293 {
294 HcfKeyAgreement *keyAgreement = nullptr;
295 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
296
297 ASSERT_EQ(res, HCF_SUCCESS);
298 ASSERT_NE(keyAgreement, nullptr);
299
300 const char *algName = keyAgreement->getAlgoName(nullptr);
301
302 ASSERT_EQ(algName, nullptr);
303
304 HcfObjDestroy(keyAgreement);
305 }
306
307 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest107, TestSize.Level0)
308 {
309 HcfKeyAgreement *keyAgreement = nullptr;
310 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
311
312 ASSERT_EQ(res, HCF_SUCCESS);
313 ASSERT_NE(keyAgreement, nullptr);
314
315 const char *algName = keyAgreement->getAlgoName((HcfKeyAgreement *)(&obj));
316
317 ASSERT_EQ(algName, nullptr);
318
319 HcfObjDestroy(keyAgreement);
320 }
321
322 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest201, TestSize.Level0)
323 {
324 HcfKeyAgreement *keyAgreement = nullptr;
325 int32_t res = HcfKeyAgreementCreate("ECC224", &keyAgreement);
326
327 ASSERT_EQ(res, HCF_SUCCESS);
328 ASSERT_NE(keyAgreement, nullptr);
329
330 HcfBlob out = { .data = nullptr, .len = 0 };
331 res = keyAgreement->generateSecret(keyAgreement, ecc224KeyPair_->priKey, ecc224KeyPair_->pubKey, &out);
332
333 ASSERT_EQ(res, HCF_SUCCESS);
334 ASSERT_NE(out.data, nullptr);
335 ASSERT_NE(out.len, (const unsigned int)0);
336
337 HcfFree(out.data);
338 HcfObjDestroy(keyAgreement);
339 }
340
341 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest202, TestSize.Level0)
342 {
343 HcfKeyAgreement *keyAgreement = nullptr;
344 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
345
346 ASSERT_EQ(res, HCF_SUCCESS);
347 ASSERT_NE(keyAgreement, nullptr);
348
349 HcfBlob out = { .data = nullptr, .len = 0 };
350 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
351
352 ASSERT_EQ(res, HCF_SUCCESS);
353 ASSERT_NE(out.data, nullptr);
354 ASSERT_NE(out.len, (const unsigned int)0);
355
356 HcfFree(out.data);
357 HcfObjDestroy(keyAgreement);
358 }
359
360 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest203, TestSize.Level0)
361 {
362 HcfKeyAgreement *keyAgreement = nullptr;
363 int32_t res = HcfKeyAgreementCreate("ECC384", &keyAgreement);
364
365 ASSERT_EQ(res, HCF_SUCCESS);
366 ASSERT_NE(keyAgreement, nullptr);
367
368 HcfBlob out = { .data = nullptr, .len = 0 };
369 res = keyAgreement->generateSecret(keyAgreement, ecc384KeyPair_->priKey, ecc384KeyPair_->pubKey, &out);
370
371 ASSERT_EQ(res, HCF_SUCCESS);
372 ASSERT_NE(out.data, nullptr);
373 ASSERT_NE(out.len, (const unsigned int)0);
374
375 HcfFree(out.data);
376 HcfObjDestroy(keyAgreement);
377 }
378
379 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest204, TestSize.Level0)
380 {
381 HcfKeyAgreement *keyAgreement = nullptr;
382 int32_t res = HcfKeyAgreementCreate("ECC521", &keyAgreement);
383
384 ASSERT_EQ(res, HCF_SUCCESS);
385 ASSERT_NE(keyAgreement, nullptr);
386
387 HcfBlob out = { .data = nullptr, .len = 0 };
388 res = keyAgreement->generateSecret(keyAgreement, ecc521KeyPair_->priKey, ecc521KeyPair_->pubKey, &out);
389
390 ASSERT_EQ(res, HCF_SUCCESS);
391 ASSERT_NE(out.data, nullptr);
392 ASSERT_NE(out.len, (const unsigned int)0);
393
394 HcfFree(out.data);
395 HcfObjDestroy(keyAgreement);
396 }
397
398 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest205, TestSize.Level0)
399 {
400 HcfKeyAgreement *keyAgreement = nullptr;
401 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
402
403 ASSERT_EQ(res, HCF_SUCCESS);
404 ASSERT_NE(keyAgreement, nullptr);
405
406 HcfBlob out = { .data = nullptr, .len = 0 };
407 res = keyAgreement->generateSecret(nullptr, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
408
409 ASSERT_EQ(res, HCF_INVALID_PARAMS);
410 ASSERT_EQ(out.data, nullptr);
411 ASSERT_EQ(out.len, 0);
412
413 HcfObjDestroy(keyAgreement);
414 }
415
416 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest206, TestSize.Level0)
417 {
418 HcfKeyAgreement *keyAgreement = nullptr;
419 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
420
421 ASSERT_EQ(res, HCF_SUCCESS);
422 ASSERT_NE(keyAgreement, nullptr);
423
424 HcfBlob out = { .data = nullptr, .len = 0 };
425 res = keyAgreement->generateSecret((HcfKeyAgreement *)(&obj), ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
426
427 ASSERT_EQ(res, HCF_INVALID_PARAMS);
428 ASSERT_EQ(out.data, nullptr);
429 ASSERT_EQ(out.len, 0);
430
431 HcfObjDestroy(keyAgreement);
432 }
433
434 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest207, TestSize.Level0)
435 {
436 HcfKeyAgreement *keyAgreement = nullptr;
437 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
438
439 ASSERT_EQ(res, HCF_SUCCESS);
440 ASSERT_NE(keyAgreement, nullptr);
441
442 HcfBlob out = { .data = nullptr, .len = 0 };
443 res = keyAgreement->generateSecret(keyAgreement, (HcfPriKey *)(&obj), ecc256KeyPair_->pubKey, &out);
444
445 ASSERT_EQ(res, HCF_INVALID_PARAMS);
446 ASSERT_EQ(out.data, nullptr);
447 ASSERT_EQ(out.len, 0);
448
449 HcfObjDestroy(keyAgreement);
450 }
451
452 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest208, TestSize.Level0)
453 {
454 HcfKeyAgreement *keyAgreement = nullptr;
455 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
456
457 ASSERT_EQ(res, HCF_SUCCESS);
458 ASSERT_NE(keyAgreement, nullptr);
459
460 HcfBlob out = { .data = nullptr, .len = 0 };
461 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, (HcfPubKey *)(&obj), &out);
462
463 ASSERT_EQ(res, HCF_INVALID_PARAMS);
464 ASSERT_EQ(out.data, nullptr);
465 ASSERT_EQ(out.len, 0);
466
467 HcfObjDestroy(keyAgreement);
468 }
469
470 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest209, TestSize.Level0)
471 {
472 HcfKeyAgreement *keyAgreement = nullptr;
473 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
474
475 ASSERT_EQ(res, HCF_SUCCESS);
476 ASSERT_NE(keyAgreement, nullptr);
477
478 HcfBlob out = { .data = nullptr, .len = 0 };
479 res = keyAgreement->generateSecret(keyAgreement, nullptr, nullptr, &out);
480
481 ASSERT_EQ(res, HCF_INVALID_PARAMS);
482 ASSERT_EQ(out.data, nullptr);
483 ASSERT_EQ(out.len, 0);
484
485 HcfObjDestroy(keyAgreement);
486 }
487
488 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest210, TestSize.Level0)
489 {
490 HcfKeyAgreement *keyAgreement = nullptr;
491 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
492
493 ASSERT_EQ(res, HCF_SUCCESS);
494 ASSERT_NE(keyAgreement, nullptr);
495
496 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, nullptr);
497
498 ASSERT_EQ(res, HCF_INVALID_PARAMS);
499
500 HcfObjDestroy(keyAgreement);
501 }
502
503 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest301, TestSize.Level0)
504 {
505 HcfKeyAgreementSpi *spiObj = nullptr;
506 int32_t res = HcfKeyAgreementSpiEcdhCreate(nullptr, &spiObj);
507
508 ASSERT_EQ(res, HCF_INVALID_PARAMS);
509 ASSERT_EQ(spiObj, nullptr);
510 }
511
512 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest302, TestSize.Level0)
513 {
514 HcfKeyAgreementParams params = {
515 .algo = HCF_ALG_ECC,
516 };
517
518 int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, nullptr);
519
520 ASSERT_EQ(res, HCF_INVALID_PARAMS);
521 }
522
523 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest304, TestSize.Level0)
524 {
525 HcfKeyAgreementParams params = {
526 .algo = HCF_ALG_ECC,
527 };
528
529 HcfKeyAgreementSpi *spiObj = nullptr;
530 int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj);
531
532 ASSERT_EQ(res, HCF_SUCCESS);
533 ASSERT_NE(spiObj, nullptr);
534
535 HcfBlob out = { .data = nullptr, .len = 0 };
536 res = spiObj->engineGenerateSecret((HcfKeyAgreementSpi *)&obj,
537 ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
538 ASSERT_EQ(res, HCF_INVALID_PARAMS);
539
540 HcfObjDestroy(spiObj);
541 }
542
543 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest305, TestSize.Level0)
544 {
545 HcfKeyAgreementParams params = {
546 .algo = HCF_ALG_ECC,
547 };
548
549 HcfKeyAgreementSpi *spiObj = nullptr;
550 int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj);
551
552 ASSERT_EQ(res, HCF_SUCCESS);
553 ASSERT_NE(spiObj, nullptr);
554
555 HcfBlob out = { .data = nullptr, .len = 0 };
556 res = spiObj->engineGenerateSecret(spiObj, (HcfPriKey *)&obj, ecc256KeyPair_->pubKey, &out);
557 ASSERT_EQ(res, HCF_INVALID_PARAMS);
558
559 HcfObjDestroy(spiObj);
560 }
561
562 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest306, TestSize.Level0)
563 {
564 HcfKeyAgreementParams params = {
565 .algo = HCF_ALG_ECC,
566 };
567
568 HcfKeyAgreementSpi *spiObj = nullptr;
569 int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj);
570
571 ASSERT_EQ(res, HCF_SUCCESS);
572 ASSERT_NE(spiObj, nullptr);
573
574 HcfBlob out = { .data = nullptr, .len = 0 };
575 res = spiObj->engineGenerateSecret(spiObj, ecc256KeyPair_->priKey, (HcfPubKey *)&obj, &out);
576 ASSERT_EQ(res, HCF_INVALID_PARAMS);
577
578 HcfObjDestroy(spiObj);
579 }
580
581 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest307, TestSize.Level0)
582 {
583 HcfKeyAgreementParams params = {
584 .algo = HCF_ALG_ECC,
585 };
586
587 HcfKeyAgreementSpi *spiObj = nullptr;
588 int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj);
589
590 ASSERT_EQ(res, HCF_SUCCESS);
591 ASSERT_NE(spiObj, nullptr);
592
593 spiObj->base.destroy(nullptr);
594
595 HcfObjDestroy(spiObj);
596 }
597
598 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest308, TestSize.Level0)
599 {
600 HcfKeyAgreementParams params = {
601 .algo = HCF_ALG_ECC,
602 };
603
604 HcfKeyAgreementSpi *spiObj = nullptr;
605 int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj);
606
607 ASSERT_EQ(res, HCF_SUCCESS);
608 ASSERT_NE(spiObj, nullptr);
609
610 spiObj->base.destroy(&obj);
611
612 HcfObjDestroy(spiObj);
613 }
614
615 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest309, TestSize.Level0)
616 {
617 HcfKeyAgreementParams params = {
618 .algo = HCF_ALG_ECC,
619 };
620
621 HcfKeyAgreementSpi *spiObj = nullptr;
622 int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj);
623
624 ASSERT_EQ(res, HCF_SUCCESS);
625 ASSERT_NE(spiObj, nullptr);
626
627 HcfBlob out = { .data = nullptr, .len = 0 };
628 res = spiObj->engineGenerateSecret(spiObj, ecc256KeyPair_->priKey, nullptr, &out);
629 ASSERT_EQ(res, HCF_INVALID_PARAMS);
630
631 HcfObjDestroy(spiObj);
632 }
633
634 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest310, TestSize.Level0)
635 {
636 HcfKeyAgreementParams params = {
637 .algo = HCF_ALG_ECC,
638 };
639
640 HcfKeyAgreementSpi *spiObj = nullptr;
641 int32_t res = HcfKeyAgreementSpiEcdhCreate(¶ms, &spiObj);
642
643 ASSERT_EQ(res, HCF_SUCCESS);
644 ASSERT_NE(spiObj, nullptr);
645
646 HcfBlob out = { .data = nullptr, .len = 0 };
647 res = spiObj->engineGenerateSecret(nullptr, ecc256KeyPair_->priKey, nullptr, &out);
648 ASSERT_EQ(res, HCF_INVALID_PARAMS);
649
650 HcfObjDestroy(spiObj);
651 }
652
653 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest401, TestSize.Level0)
654 {
655 StartRecordMallocNum();
656 HcfKeyAgreement *keyAgreement = nullptr;
657 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
658
659 ASSERT_EQ(res, HCF_SUCCESS);
660 ASSERT_NE(keyAgreement, nullptr);
661
662 HcfBlob out = { .data = nullptr, .len = 0 };
663 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
664
665 ASSERT_EQ(res, HCF_SUCCESS);
666 HcfFree(out.data);
667
668 HcfObjDestroy(keyAgreement);
669
670 uint32_t mallocCount = GetMallocNum();
671
672 for (uint32_t i = 0; i < mallocCount; i++) {
673 ResetRecordMallocNum();
674 SetMockMallocIndex(i);
675 keyAgreement = nullptr;
676 res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
677
678 if (res != HCF_SUCCESS) {
679 continue;
680 }
681
682 out = {
683 .data = nullptr,
684 .len = 0
685 };
686 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
687
688 if (res != HCF_SUCCESS) {
689 HcfObjDestroy(keyAgreement);
690 continue;
691 }
692
693 HcfObjDestroy(keyAgreement);
694 HcfFree(out.data);
695 }
696 EndRecordMallocNum();
697 }
698
699 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest402, TestSize.Level0)
700 {
701 StartRecordOpensslCallNum();
702 HcfKeyAgreement *keyAgreement = nullptr;
703 int32_t res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
704
705 ASSERT_EQ(res, HCF_SUCCESS);
706 ASSERT_NE(keyAgreement, nullptr);
707
708 HcfBlob out = { .data = nullptr, .len = 0 };
709 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
710
711 ASSERT_EQ(res, HCF_SUCCESS);
712 HcfFree(out.data);
713
714 HcfObjDestroy(keyAgreement);
715
716 uint32_t mallocCount = GetOpensslCallNum();
717
718 for (uint32_t i = 0; i < mallocCount; i++) {
719 ResetOpensslCallNum();
720 SetOpensslCallMockIndex(i);
721 keyAgreement = nullptr;
722 res = HcfKeyAgreementCreate("ECC256", &keyAgreement);
723
724 if (res != HCF_SUCCESS) {
725 continue;
726 }
727
728 out = {
729 .data = nullptr,
730 .len = 0
731 };
732 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
733
734 if (res != HCF_SUCCESS) {
735 HcfObjDestroy(keyAgreement);
736 continue;
737 }
738
739 HcfObjDestroy(keyAgreement);
740 HcfFree(out.data);
741 }
742 EndRecordOpensslCallNum();
743 }
744
745 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccCommonTest01, TestSize.Level0)
746 {
747 HcfResult ret = GenerateEcGroupWithParamsSpec(nullptr, nullptr);
748 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
749 }
750
751 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest403, TestSize.Level0)
752 {
753 HcfKeyAgreement *keyAgreement = nullptr;
754 int32_t res = HcfKeyAgreementCreate("ECC_Secp256k1", &keyAgreement);
755
756 ASSERT_EQ(res, HCF_SUCCESS);
757 ASSERT_NE(keyAgreement, nullptr);
758 HcfBlob out = { .data = nullptr, .len = 0 };
759 HcfKeyPair *eccSecp256k1KeyPair = nullptr;
760 HcfAsyKeyGenerator *generator = nullptr;
761 res = HcfAsyKeyGeneratorCreate("ECC_Secp256k1", &generator);
762 ASSERT_EQ(res, HCF_SUCCESS);
763 ASSERT_NE(generator, nullptr);
764
765 res = generator->convertPemKey(generator, nullptr, g_testEccSecp256k1PubKey.c_str(),
766 g_testEccSecp256k1PriKey.c_str(), &eccSecp256k1KeyPair);
767 ASSERT_EQ(res, HCF_SUCCESS);
768 ASSERT_NE(eccSecp256k1KeyPair, nullptr);
769
770 res = keyAgreement->generateSecret(keyAgreement, eccSecp256k1KeyPair->priKey, eccSecp256k1KeyPair->pubKey, &out);
771 ASSERT_EQ(res, HCF_SUCCESS);
772 ASSERT_EQ(out.len, sizeof(SharedSecret));
773 for (int i = 0; i < out.len; i++) {
774 ASSERT_EQ(out.data[i], SharedSecret[i]);
775 }
776 HcfObjDestroy(keyAgreement);
777 HcfObjDestroy(eccSecp256k1KeyPair);
778 HcfFree(out.data);
779 HcfObjDestroy(generator);
780 }
781
782 HWTEST_F(CryptoEccKeyAgreementTest, CryptoEccKeyAgreementTest404, TestSize.Level0)
783 {
784 HcfAsyKeyGenerator *generator = nullptr;
785 int32_t res = HcfAsyKeyGeneratorCreate("ECC_Secp256k1", &generator);
786
787 HcfKeyPair *keyPair1 = nullptr;
788 res = generator->generateKeyPair(generator, nullptr, &keyPair1);
789 ASSERT_EQ(res, HCF_SUCCESS);
790 ASSERT_NE(keyPair1, nullptr);
791
792 HcfKeyPair *keyPair2 = nullptr;
793 res = generator->generateKeyPair(generator, nullptr, &keyPair2);
794 ASSERT_EQ(res, HCF_SUCCESS);
795 ASSERT_NE(keyPair2, nullptr);
796
797 HcfKeyAgreement *keyAgreement = nullptr;
798 res = HcfKeyAgreementCreate("ECC_Secp256k1", &keyAgreement);
799 ASSERT_EQ(res, HCF_SUCCESS);
800 ASSERT_NE(keyAgreement, nullptr);
801
802 HcfBlob out1 = { .data = nullptr, .len = 0 };
803 HcfBlob out2 = { .data = nullptr, .len = 0 };
804 res = keyAgreement->generateSecret(keyAgreement, keyPair1->priKey, keyPair2->pubKey, &out1);
805 ASSERT_EQ(res, HCF_SUCCESS);
806 res = keyAgreement->generateSecret(keyAgreement, keyPair2->priKey, keyPair1->pubKey, &out2);
807 ASSERT_EQ(res, HCF_SUCCESS);
808 ASSERT_EQ(out1.len, out2.len);
809 for (int i = 0; i < out1.len; i++) {
810 ASSERT_EQ(out1.data[i], out2.data[i]);
811 }
812 HcfObjDestroy(keyAgreement);
813 HcfFree(out1.data);
814 HcfFree(out2.data);
815 HcfObjDestroy(keyPair1);
816 HcfObjDestroy(keyPair2);
817 HcfObjDestroy(generator);
818 }
819 }
820