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 "asy_key_generator.h"
20 #include "detailed_ecc_key_params.h"
21 #include "ecc_openssl_common.h"
22 #include "ecc_openssl_common_param_spec.h"
23 #include "ecc_common.h"
24 #include "ecdh_openssl.h"
25 #include "key_agreement.h"
26 #include "memory.h"
27 #include "memory_mock.h"
28 #include "openssl_adapter_mock.h"
29 #include "openssl_common.h"
30 #include "params_parser.h"
31
32 using namespace std;
33 using namespace testing::ext;
34
35 namespace {
36 class CryptoEccKeyAgreementBySpecTest : public testing::Test {
37 public:
38 static void CryptoEccNoLengthSignTestSubEcc224(void);
39 static void CryptoEccNoLengthSignTestSubEcc256(void);
40 static void CryptoEccNoLengthSignTestSubEcc384(void);
41 static void CryptoEccNoLengthSignTestSubEcc521(void);
42
43 static void SetUpTestCase();
44 static void TearDownTestCase();
45 void SetUp();
46 void TearDown();
47
48 static HcfKeyPair *ecc224KeyPair_;
49 static HcfKeyPair *ecc256KeyPair_;
50 static HcfKeyPair *ecc384KeyPair_;
51 static HcfKeyPair *ecc521KeyPair_;
52 };
53
54 HcfKeyPair *CryptoEccKeyAgreementBySpecTest::ecc224KeyPair_ = nullptr;
55 HcfKeyPair *CryptoEccKeyAgreementBySpecTest::ecc256KeyPair_ = nullptr;
56 HcfKeyPair *CryptoEccKeyAgreementBySpecTest::ecc384KeyPair_ = nullptr;
57 HcfKeyPair *CryptoEccKeyAgreementBySpecTest::ecc521KeyPair_ = nullptr;
58
SetUp()59 void CryptoEccKeyAgreementBySpecTest::SetUp() {}
TearDown()60 void CryptoEccKeyAgreementBySpecTest::TearDown() {}
61
62 static const bool IS_BIG_ENDIAN = IsBigEndian();
63
64 static string g_eccAlgName = "ECC";
65 static string g_eccFieldType = "Fp";
66 static int32_t g_ecc224CorrectH = 1;
67 static int32_t g_ecc256CorrectH = 1;
68 static int32_t g_ecc384CorrectH = 1;
69 static int32_t g_ecc521CorrectH = 1;
70
71 HcfEccKeyPairParamsSpec g_ecc224KeyPairSpec;
72 HcfEccKeyPairParamsSpec g_ecc256KeyPairSpec;
73 HcfEccKeyPairParamsSpec g_ecc384KeyPairSpec;
74 HcfEccKeyPairParamsSpec g_ecc521KeyPairSpec;
75 HcfECFieldFp g_fieldFp;
76
ConstructEcc224KeyPairParamsSpec(HcfAsyKeyParamsSpec ** spec)77 static HcfResult ConstructEcc224KeyPairParamsSpec(HcfAsyKeyParamsSpec **spec)
78 {
79 HcfEccKeyPairParamsSpec *eccKeyPairSpec = &g_ecc224KeyPairSpec;
80 HcfECField *tmpField = (HcfECField *)(&g_fieldFp);
81
82 eccKeyPairSpec->base.base.algName = const_cast<char *>(g_eccAlgName.c_str());
83 eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
84 eccKeyPairSpec->base.field = tmpField;
85 eccKeyPairSpec->base.field->fieldType = const_cast<char *>(g_eccFieldType.c_str());
86 ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data =
87 (IS_BIG_ENDIAN ? g_ecc224CorrectBigP : g_ecc224CorrectLittleP);
88 ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = NID_secp224r1_len;
89 eccKeyPairSpec->base.a.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigA : g_ecc224CorrectLittleA);
90 eccKeyPairSpec->base.a.len = NID_secp224r1_len;
91 eccKeyPairSpec->base.b.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigB : g_ecc224CorrectLittleB);
92 eccKeyPairSpec->base.b.len = NID_secp224r1_len;
93 eccKeyPairSpec->base.g.x.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGX : g_ecc224CorrectLittleGX);
94 eccKeyPairSpec->base.g.x.len = NID_secp224r1_len;
95 eccKeyPairSpec->base.g.y.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGY : g_ecc224CorrectLittleGY);
96 eccKeyPairSpec->base.g.y.len = NID_secp224r1_len;
97 eccKeyPairSpec->base.n.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigN : g_ecc224CorrectLittleN);
98 eccKeyPairSpec->base.n.len = NID_secp224r1_len;
99 eccKeyPairSpec->base.h = g_ecc224CorrectH;
100 eccKeyPairSpec->pk.x.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigPkX : g_ecc224CorrectLittlePkX);
101 eccKeyPairSpec->pk.x.len = NID_secp224r1_len;
102 eccKeyPairSpec->pk.y.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigPkY : g_ecc224CorrectLittlePkY);
103 eccKeyPairSpec->pk.y.len = NID_secp224r1_len;
104 eccKeyPairSpec->sk.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigSk : g_ecc224CorrectLittleSk);
105 eccKeyPairSpec->sk.len = NID_secp224r1_len;
106
107 *spec = (HcfAsyKeyParamsSpec *)eccKeyPairSpec;
108 return HCF_SUCCESS;
109 }
110
ConstructEcc256KeyPairParamsSpec(HcfAsyKeyParamsSpec ** spec)111 static HcfResult ConstructEcc256KeyPairParamsSpec(HcfAsyKeyParamsSpec **spec)
112 {
113 HcfEccKeyPairParamsSpec *eccKeyPairSpec = &g_ecc256KeyPairSpec;
114 HcfECField *tmpField = (HcfECField *)(&g_fieldFp);
115
116 eccKeyPairSpec->base.base.algName = const_cast<char *>(g_eccAlgName.c_str());
117 eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
118 eccKeyPairSpec->base.field = tmpField;
119 eccKeyPairSpec->base.field->fieldType = const_cast<char *>(g_eccFieldType.c_str());
120 ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data =
121 (IS_BIG_ENDIAN ? g_ecc256CorrectBigP : g_ecc256CorrectLittleP);
122 ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = NID_X9_62_prime256v1_len;
123 eccKeyPairSpec->base.a.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigA : g_ecc256CorrectLittleA);
124 eccKeyPairSpec->base.a.len = NID_X9_62_prime256v1_len;
125 eccKeyPairSpec->base.b.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigB : g_ecc256CorrectLittleB);
126 eccKeyPairSpec->base.b.len = NID_X9_62_prime256v1_len;
127 eccKeyPairSpec->base.g.x.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigGX : g_ecc256CorrectLittleGX);
128 eccKeyPairSpec->base.g.x.len = NID_X9_62_prime256v1_len;
129 eccKeyPairSpec->base.g.y.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigGY : g_ecc256CorrectLittleGY);
130 eccKeyPairSpec->base.g.y.len = NID_X9_62_prime256v1_len;
131 eccKeyPairSpec->base.n.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigN : g_ecc256CorrectLittleN);
132 eccKeyPairSpec->base.n.len = NID_X9_62_prime256v1_len;
133 eccKeyPairSpec->base.h = g_ecc256CorrectH;
134 eccKeyPairSpec->pk.x.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigPkX : g_ecc256CorrectLittlePkX);
135 eccKeyPairSpec->pk.x.len = NID_X9_62_prime256v1_len;
136 eccKeyPairSpec->pk.y.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigPkY : g_ecc256CorrectLittlePkY);
137 eccKeyPairSpec->pk.y.len = NID_X9_62_prime256v1_len;
138 eccKeyPairSpec->sk.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigSk : g_ecc256CorrectLittleSk);
139 eccKeyPairSpec->sk.len = NID_X9_62_prime256v1_len;
140
141 *spec = (HcfAsyKeyParamsSpec *)eccKeyPairSpec;
142 return HCF_SUCCESS;
143 }
144
ConstructEcc384KeyPairParamsSpec(HcfAsyKeyParamsSpec ** spec)145 static HcfResult ConstructEcc384KeyPairParamsSpec(HcfAsyKeyParamsSpec **spec)
146 {
147 HcfEccKeyPairParamsSpec *eccKeyPairSpec = &g_ecc384KeyPairSpec;
148 HcfECField *tmpField = (HcfECField *)(&g_fieldFp);
149
150 eccKeyPairSpec->base.base.algName = const_cast<char *>(g_eccAlgName.c_str());
151 eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
152 eccKeyPairSpec->base.field = tmpField;
153 eccKeyPairSpec->base.field->fieldType = const_cast<char *>(g_eccFieldType.c_str());
154 ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data =
155 (IS_BIG_ENDIAN ? g_ecc384CorrectBigP : g_ecc384CorrectLittleP);
156 ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = NID_secp384r1_len;
157 eccKeyPairSpec->base.a.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigA : g_ecc384CorrectLittleA);
158 eccKeyPairSpec->base.a.len = NID_secp384r1_len;
159 eccKeyPairSpec->base.b.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigB : g_ecc384CorrectLittleB);
160 eccKeyPairSpec->base.b.len = NID_secp384r1_len;
161 eccKeyPairSpec->base.g.x.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigGX : g_ecc384CorrectLittleGX);
162 eccKeyPairSpec->base.g.x.len = NID_secp384r1_len;
163 eccKeyPairSpec->base.g.y.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigGY : g_ecc384CorrectLittleGY);
164 eccKeyPairSpec->base.g.y.len = NID_secp384r1_len;
165 eccKeyPairSpec->base.n.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigN : g_ecc384CorrectLittleN);
166 eccKeyPairSpec->base.n.len = NID_secp384r1_len;
167 eccKeyPairSpec->base.h = g_ecc384CorrectH;
168 eccKeyPairSpec->pk.x.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigPkX : g_ecc384CorrectLittlePkX);
169 eccKeyPairSpec->pk.x.len = NID_secp384r1_len;
170 eccKeyPairSpec->pk.y.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigPkY : g_ecc384CorrectLittlePkY);
171 eccKeyPairSpec->pk.y.len = NID_secp384r1_len;
172 eccKeyPairSpec->sk.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigSk : g_ecc384CorrectLittleSk);
173 eccKeyPairSpec->sk.len = NID_secp384r1_len;
174
175 *spec = (HcfAsyKeyParamsSpec *)eccKeyPairSpec;
176 return HCF_SUCCESS;
177 }
178
ConstructEcc521KeyPairParamsSpec(HcfAsyKeyParamsSpec ** spec)179 static HcfResult ConstructEcc521KeyPairParamsSpec(HcfAsyKeyParamsSpec **spec)
180 {
181 HcfEccKeyPairParamsSpec *eccKeyPairSpec = &g_ecc521KeyPairSpec;
182 HcfECField *tmpField = (HcfECField *)(&g_fieldFp);
183
184 eccKeyPairSpec->base.base.algName = const_cast<char *>(g_eccAlgName.c_str());
185 eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
186 eccKeyPairSpec->base.field = tmpField;
187 eccKeyPairSpec->base.field->fieldType = const_cast<char *>(g_eccFieldType.c_str());
188 ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data =
189 (IS_BIG_ENDIAN ? g_ecc521CorrectBigP : g_ecc521CorrectLittleP);
190 ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = NID_secp521r1_len;
191 eccKeyPairSpec->base.a.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigA : g_ecc521CorrectLittleA);
192 eccKeyPairSpec->base.a.len = NID_secp521r1_len;
193 eccKeyPairSpec->base.b.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigB : g_ecc521CorrectLittleB);
194 eccKeyPairSpec->base.b.len = NID_secp521r1_len;
195 eccKeyPairSpec->base.g.x.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigGX : g_ecc521CorrectLittleGX);
196 eccKeyPairSpec->base.g.x.len = NID_secp521r1_len;
197 eccKeyPairSpec->base.g.y.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigGY : g_ecc521CorrectLittleGY);
198 eccKeyPairSpec->base.g.y.len = NID_secp521r1_len;
199 eccKeyPairSpec->base.n.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigN : g_ecc521CorrectLittleN);
200 eccKeyPairSpec->base.n.len = NID_secp521r1_len;
201 eccKeyPairSpec->base.h = g_ecc521CorrectH;
202 eccKeyPairSpec->pk.x.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigPkX : g_ecc521CorrectLittlePkX);
203 eccKeyPairSpec->pk.x.len = NID_secp521r1_len;
204 eccKeyPairSpec->pk.y.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigPkY : g_ecc521CorrectLittlePkY);
205 eccKeyPairSpec->pk.y.len = NID_secp521r1_len;
206 eccKeyPairSpec->sk.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigSk : g_ecc521CorrectLittleSk);
207 eccKeyPairSpec->sk.len = NID_secp521r1_len;
208
209 *spec = (HcfAsyKeyParamsSpec *)eccKeyPairSpec;
210 return HCF_SUCCESS;
211 }
212
CryptoEccNoLengthSignTestSubEcc224(void)213 void CryptoEccKeyAgreementBySpecTest::CryptoEccNoLengthSignTestSubEcc224(void)
214 {
215 HcfAsyKeyParamsSpec *paramSpec = nullptr;
216 int32_t res = ConstructEcc224KeyPairParamsSpec(¶mSpec);
217 ASSERT_EQ(res, HCF_SUCCESS);
218
219 HcfAsyKeyGeneratorBySpec *generator = nullptr;
220 res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
221 ASSERT_EQ(res, HCF_SUCCESS);
222 ASSERT_NE(generator, nullptr);
223
224 HcfKeyPair *keyPair = nullptr;
225 res = generator->generateKeyPair(generator, &keyPair);
226 ASSERT_EQ(res, HCF_SUCCESS);
227 ASSERT_NE(keyPair, nullptr);
228
229 ecc224KeyPair_ = keyPair;
230
231 HcfObjDestroy(generator);
232 }
233
CryptoEccNoLengthSignTestSubEcc256(void)234 void CryptoEccKeyAgreementBySpecTest::CryptoEccNoLengthSignTestSubEcc256(void)
235 {
236 HcfAsyKeyParamsSpec *paramSpec = nullptr;
237 int32_t res = ConstructEcc256KeyPairParamsSpec(¶mSpec);
238 ASSERT_EQ(res, HCF_SUCCESS);
239
240 HcfAsyKeyGeneratorBySpec *generator = nullptr;
241 res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
242 ASSERT_EQ(res, HCF_SUCCESS);
243 ASSERT_NE(generator, nullptr);
244
245 HcfKeyPair *keyPair = nullptr;
246 res = generator->generateKeyPair(generator, &keyPair);
247 ASSERT_EQ(res, HCF_SUCCESS);
248 ASSERT_NE(keyPair, nullptr);
249
250 ecc256KeyPair_ = keyPair;
251
252 HcfObjDestroy(generator);
253 }
254
CryptoEccNoLengthSignTestSubEcc384(void)255 void CryptoEccKeyAgreementBySpecTest::CryptoEccNoLengthSignTestSubEcc384(void)
256 {
257 HcfAsyKeyParamsSpec *paramSpec = nullptr;
258 int32_t res = ConstructEcc384KeyPairParamsSpec(¶mSpec);
259 ASSERT_EQ(res, HCF_SUCCESS);
260
261 HcfAsyKeyGeneratorBySpec *generator = nullptr;
262 res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
263 ASSERT_EQ(res, HCF_SUCCESS);
264 ASSERT_NE(generator, nullptr);
265
266 HcfKeyPair *keyPair = nullptr;
267 res = generator->generateKeyPair(generator, &keyPair);
268 ASSERT_EQ(res, HCF_SUCCESS);
269 ASSERT_NE(keyPair, nullptr);
270
271 ecc384KeyPair_ = keyPair;
272 HcfObjDestroy(generator);
273 }
274
CryptoEccNoLengthSignTestSubEcc521(void)275 void CryptoEccKeyAgreementBySpecTest::CryptoEccNoLengthSignTestSubEcc521(void)
276 {
277 HcfAsyKeyParamsSpec *paramSpec = nullptr;
278 int32_t res = ConstructEcc521KeyPairParamsSpec(¶mSpec);
279 ASSERT_EQ(res, HCF_SUCCESS);
280
281 HcfAsyKeyGeneratorBySpec *generator = nullptr;
282 res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
283 ASSERT_EQ(res, HCF_SUCCESS);
284 ASSERT_NE(generator, nullptr);
285
286 HcfKeyPair *keyPair = nullptr;
287 res = generator->generateKeyPair(generator, &keyPair);
288 ASSERT_EQ(res, HCF_SUCCESS);
289 ASSERT_NE(keyPair, nullptr);
290
291 ecc521KeyPair_ = keyPair;
292 HcfObjDestroy(generator);
293 }
294
SetUpTestCase()295 void CryptoEccKeyAgreementBySpecTest::SetUpTestCase()
296 {
297 CryptoEccNoLengthSignTestSubEcc224();
298 CryptoEccNoLengthSignTestSubEcc256();
299 CryptoEccNoLengthSignTestSubEcc384();
300 CryptoEccNoLengthSignTestSubEcc521();
301 }
302
TearDownTestCase()303 void CryptoEccKeyAgreementBySpecTest::TearDownTestCase()
304 {
305 HcfObjDestroy(ecc224KeyPair_);
306 HcfObjDestroy(ecc256KeyPair_);
307 HcfObjDestroy(ecc384KeyPair_);
308 HcfObjDestroy(ecc521KeyPair_);
309 }
310
GetMockClass(void)311 static const char *GetMockClass(void)
312 {
313 return "HcfSymKeyGenerator";
314 }
315
316 static HcfObjectBase obj = {
317 .getClass = GetMockClass,
318 .destroy = nullptr
319 };
320
321 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest501, TestSize.Level0)
322 {
323 HcfKeyAgreement *keyAgreement = nullptr;
324 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
325
326 ASSERT_EQ(res, HCF_SUCCESS);
327 ASSERT_NE(keyAgreement, nullptr);
328
329 HcfObjDestroy(keyAgreement);
330 }
331
332 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest502, TestSize.Level0)
333 {
334 HcfKeyAgreement *keyAgreement = nullptr;
335 int32_t res = HcfKeyAgreementCreate("ecc", &keyAgreement);
336
337 ASSERT_EQ(res, HCF_INVALID_PARAMS);
338 ASSERT_EQ(keyAgreement, nullptr);
339 }
340
341 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementTes503, TestSize.Level0)
342 {
343 int32_t res = HcfKeyAgreementCreate("ECC", nullptr);
344
345 ASSERT_EQ(res, HCF_INVALID_PARAMS);
346 }
347
348 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest601, TestSize.Level0)
349 {
350 HcfKeyAgreement *keyAgreement = nullptr;
351 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
352
353 ASSERT_EQ(res, HCF_SUCCESS);
354 ASSERT_NE(keyAgreement, nullptr);
355
356 const char *className = keyAgreement->base.getClass();
357
358 ASSERT_NE(className, nullptr);
359
360 HcfObjDestroy(keyAgreement);
361 }
362
363 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest602, TestSize.Level0)
364 {
365 HcfKeyAgreement *keyAgreement = nullptr;
366 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
367
368 ASSERT_EQ(res, HCF_SUCCESS);
369 ASSERT_NE(keyAgreement, nullptr);
370
371 keyAgreement->base.destroy((HcfObjectBase *)keyAgreement);
372 }
373
374 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest603, TestSize.Level0)
375 {
376 HcfKeyAgreement *keyAgreement = nullptr;
377 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
378
379 ASSERT_EQ(res, HCF_SUCCESS);
380 ASSERT_NE(keyAgreement, nullptr);
381
382 keyAgreement->base.destroy(nullptr);
383
384 HcfObjDestroy(keyAgreement);
385 }
386
387 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest604, TestSize.Level0)
388 {
389 HcfKeyAgreement *keyAgreement = nullptr;
390 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
391
392 ASSERT_EQ(res, HCF_SUCCESS);
393 ASSERT_NE(keyAgreement, nullptr);
394
395 keyAgreement->base.destroy(&obj);
396
397 HcfObjDestroy(keyAgreement);
398 }
399
400 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest605, TestSize.Level0)
401 {
402 HcfKeyAgreement *keyAgreement = nullptr;
403 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
404
405 ASSERT_EQ(res, HCF_SUCCESS);
406 ASSERT_NE(keyAgreement, nullptr);
407
408 const char *algName = keyAgreement->getAlgoName(keyAgreement);
409
410 ASSERT_NE(algName, nullptr);
411
412 HcfObjDestroy(keyAgreement);
413 }
414
415 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest606, TestSize.Level0)
416 {
417 HcfKeyAgreement *keyAgreement = nullptr;
418 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
419
420 ASSERT_EQ(res, HCF_SUCCESS);
421 ASSERT_NE(keyAgreement, nullptr);
422
423 const char *algName = keyAgreement->getAlgoName(nullptr);
424
425 ASSERT_EQ(algName, nullptr);
426
427 HcfObjDestroy(keyAgreement);
428 }
429
430 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest607, TestSize.Level0)
431 {
432 HcfKeyAgreement *keyAgreement = nullptr;
433 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
434
435 ASSERT_EQ(res, HCF_SUCCESS);
436 ASSERT_NE(keyAgreement, nullptr);
437
438 const char *algName = keyAgreement->getAlgoName((HcfKeyAgreement *)(&obj));
439
440 ASSERT_EQ(algName, nullptr);
441
442 HcfObjDestroy(keyAgreement);
443 }
444
445 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest701, TestSize.Level0)
446 {
447 HcfKeyAgreement *keyAgreement = nullptr;
448 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
449
450 ASSERT_EQ(res, HCF_SUCCESS);
451 ASSERT_NE(keyAgreement, nullptr);
452
453 HcfBlob out = { .data = nullptr, .len = 0 };
454 res = keyAgreement->generateSecret(keyAgreement, ecc224KeyPair_->priKey, ecc224KeyPair_->pubKey, &out);
455
456 ASSERT_EQ(res, HCF_SUCCESS);
457 ASSERT_NE(out.data, nullptr);
458 ASSERT_NE(out.len, (const unsigned int)0);
459
460 HcfFree(out.data);
461 HcfObjDestroy(keyAgreement);
462 }
463
464 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest702, TestSize.Level0)
465 {
466 HcfKeyAgreement *keyAgreement = nullptr;
467 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
468
469 ASSERT_EQ(res, HCF_SUCCESS);
470 ASSERT_NE(keyAgreement, nullptr);
471
472 HcfBlob out = { .data = nullptr, .len = 0 };
473 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
474
475 ASSERT_EQ(res, HCF_SUCCESS);
476 ASSERT_NE(out.data, nullptr);
477 ASSERT_NE(out.len, (const unsigned int)0);
478
479 HcfFree(out.data);
480 HcfObjDestroy(keyAgreement);
481 }
482
483 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest703, TestSize.Level0)
484 {
485 HcfKeyAgreement *keyAgreement = nullptr;
486 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
487
488 ASSERT_EQ(res, HCF_SUCCESS);
489 ASSERT_NE(keyAgreement, nullptr);
490
491 HcfBlob out = { .data = nullptr, .len = 0 };
492 res = keyAgreement->generateSecret(keyAgreement, ecc384KeyPair_->priKey, ecc384KeyPair_->pubKey, &out);
493
494 ASSERT_EQ(res, HCF_SUCCESS);
495 ASSERT_NE(out.data, nullptr);
496 ASSERT_NE(out.len, (const unsigned int)0);
497
498 HcfFree(out.data);
499 HcfObjDestroy(keyAgreement);
500 }
501
502 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest704, TestSize.Level0)
503 {
504 HcfKeyAgreement *keyAgreement = nullptr;
505 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
506
507 ASSERT_EQ(res, HCF_SUCCESS);
508 ASSERT_NE(keyAgreement, nullptr);
509
510 HcfBlob out = { .data = nullptr, .len = 0 };
511 res = keyAgreement->generateSecret(keyAgreement, ecc521KeyPair_->priKey, ecc521KeyPair_->pubKey, &out);
512
513 ASSERT_EQ(res, HCF_SUCCESS);
514 ASSERT_NE(out.data, nullptr);
515 ASSERT_NE(out.len, (const unsigned int)0);
516
517 HcfFree(out.data);
518 HcfObjDestroy(keyAgreement);
519 }
520
521 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest705, TestSize.Level0)
522 {
523 HcfKeyAgreement *keyAgreement = nullptr;
524 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
525
526 ASSERT_EQ(res, HCF_SUCCESS);
527 ASSERT_NE(keyAgreement, nullptr);
528
529 HcfBlob out = { .data = nullptr, .len = 0 };
530 res = keyAgreement->generateSecret(nullptr, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
531
532 ASSERT_EQ(res, HCF_INVALID_PARAMS);
533 ASSERT_EQ(out.data, nullptr);
534 ASSERT_EQ(out.len, 0);
535
536 HcfObjDestroy(keyAgreement);
537 }
538
539 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest706, TestSize.Level0)
540 {
541 HcfKeyAgreement *keyAgreement = nullptr;
542 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
543
544 ASSERT_EQ(res, HCF_SUCCESS);
545 ASSERT_NE(keyAgreement, nullptr);
546
547 HcfBlob out = { .data = nullptr, .len = 0 };
548 res = keyAgreement->generateSecret((HcfKeyAgreement *)(&obj), ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
549
550 ASSERT_EQ(res, HCF_INVALID_PARAMS);
551 ASSERT_EQ(out.data, nullptr);
552 ASSERT_EQ(out.len, 0);
553
554 HcfObjDestroy(keyAgreement);
555 }
556
557 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest707, TestSize.Level0)
558 {
559 HcfKeyAgreement *keyAgreement = nullptr;
560 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
561
562 ASSERT_EQ(res, HCF_SUCCESS);
563 ASSERT_NE(keyAgreement, nullptr);
564
565 HcfBlob out = { .data = nullptr, .len = 0 };
566 res = keyAgreement->generateSecret(keyAgreement, (HcfPriKey *)(&obj), ecc256KeyPair_->pubKey, &out);
567
568 ASSERT_EQ(res, HCF_INVALID_PARAMS);
569 ASSERT_EQ(out.data, nullptr);
570 ASSERT_EQ(out.len, 0);
571
572 HcfObjDestroy(keyAgreement);
573 }
574
575 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest708, TestSize.Level0)
576 {
577 HcfKeyAgreement *keyAgreement = nullptr;
578 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
579
580 ASSERT_EQ(res, HCF_SUCCESS);
581 ASSERT_NE(keyAgreement, nullptr);
582
583 HcfBlob out = { .data = nullptr, .len = 0 };
584 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, (HcfPubKey *)(&obj), &out);
585
586 ASSERT_EQ(res, HCF_INVALID_PARAMS);
587 ASSERT_EQ(out.data, nullptr);
588 ASSERT_EQ(out.len, 0);
589
590 HcfObjDestroy(keyAgreement);
591 }
592
593 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest709, TestSize.Level0)
594 {
595 HcfKeyAgreement *keyAgreement = nullptr;
596 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
597
598 ASSERT_EQ(res, HCF_SUCCESS);
599 ASSERT_NE(keyAgreement, nullptr);
600
601 HcfBlob out = { .data = nullptr, .len = 0 };
602 res = keyAgreement->generateSecret(keyAgreement, nullptr, nullptr, &out);
603
604 ASSERT_EQ(res, HCF_INVALID_PARAMS);
605 ASSERT_EQ(out.data, nullptr);
606 ASSERT_EQ(out.len, 0);
607
608 HcfObjDestroy(keyAgreement);
609 }
610
611 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest710, TestSize.Level0)
612 {
613 HcfKeyAgreement *keyAgreement = nullptr;
614 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
615
616 ASSERT_EQ(res, HCF_SUCCESS);
617 ASSERT_NE(keyAgreement, nullptr);
618
619 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, nullptr);
620
621 ASSERT_EQ(res, HCF_INVALID_PARAMS);
622
623 HcfObjDestroy(keyAgreement);
624 }
625
626 HcfKeyAgreementParams g_params = {
627 .algo = HCF_ALG_ECC
628 };
629
630
631 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest801, TestSize.Level0)
632 {
633 HcfKeyAgreementSpi *spiObj = nullptr;
634 int32_t res = HcfKeyAgreementSpiEcdhCreate(&g_params, &spiObj);
635
636 ASSERT_EQ(res, HCF_SUCCESS);
637 ASSERT_NE(spiObj, nullptr);
638 }
639
640 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest802, TestSize.Level0)
641 {
642 HcfKeyAgreementSpi *spiObj = nullptr;
643 int32_t res = HcfKeyAgreementSpiEcdhCreate(&g_params, &spiObj);
644
645 ASSERT_EQ(res, HCF_SUCCESS);
646 ASSERT_NE(spiObj, nullptr);
647
648 HcfBlob out = { .data = nullptr, .len = 0 };
649 res = spiObj->engineGenerateSecret((HcfKeyAgreementSpi *)&obj,
650 ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
651 ASSERT_EQ(res, HCF_INVALID_PARAMS);
652
653 HcfObjDestroy(spiObj);
654 }
655
656 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest803, TestSize.Level0)
657 {
658 HcfKeyAgreementSpi *spiObj = nullptr;
659 int32_t res = HcfKeyAgreementSpiEcdhCreate(&g_params, &spiObj);
660
661 ASSERT_EQ(res, HCF_SUCCESS);
662 ASSERT_NE(spiObj, nullptr);
663
664 HcfBlob out = { .data = nullptr, .len = 0 };
665 res = spiObj->engineGenerateSecret(spiObj, (HcfPriKey *)&obj, ecc256KeyPair_->pubKey, &out);
666 ASSERT_EQ(res, HCF_INVALID_PARAMS);
667
668 HcfObjDestroy(spiObj);
669 }
670
671 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest804, TestSize.Level0)
672 {
673 HcfKeyAgreementSpi *spiObj = nullptr;
674 int32_t res = HcfKeyAgreementSpiEcdhCreate(&g_params, &spiObj);
675
676 ASSERT_EQ(res, HCF_SUCCESS);
677 ASSERT_NE(spiObj, nullptr);
678
679 HcfBlob out = { .data = nullptr, .len = 0 };
680 res = spiObj->engineGenerateSecret(spiObj, ecc256KeyPair_->priKey, (HcfPubKey *)&obj, &out);
681 ASSERT_EQ(res, HCF_INVALID_PARAMS);
682
683 HcfObjDestroy(spiObj);
684 }
685
686 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest805, TestSize.Level0)
687 {
688 HcfKeyAgreementSpi *spiObj = nullptr;
689 int32_t res = HcfKeyAgreementSpiEcdhCreate(&g_params, &spiObj);
690
691 ASSERT_EQ(res, HCF_SUCCESS);
692 ASSERT_NE(spiObj, nullptr);
693
694 spiObj->base.destroy(nullptr);
695
696 HcfObjDestroy(spiObj);
697 }
698
699 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest806, TestSize.Level0)
700 {
701 HcfKeyAgreementSpi *spiObj = nullptr;
702 int32_t res = HcfKeyAgreementSpiEcdhCreate(&g_params, &spiObj);
703
704 ASSERT_EQ(res, HCF_SUCCESS);
705 ASSERT_NE(spiObj, nullptr);
706
707 spiObj->base.destroy(&obj);
708
709 HcfObjDestroy(spiObj);
710 }
711
712 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest901, TestSize.Level0)
713 {
714 StartRecordMallocNum();
715 HcfKeyAgreement *keyAgreement = nullptr;
716 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
717
718 ASSERT_EQ(res, HCF_SUCCESS);
719 ASSERT_NE(keyAgreement, nullptr);
720
721 HcfBlob out = { .data = nullptr, .len = 0 };
722 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
723
724 ASSERT_EQ(res, HCF_SUCCESS);
725
726 HcfObjDestroy(keyAgreement);
727
728 uint32_t mallocCount = GetMallocNum();
729
730 for (uint32_t i = 0; i < mallocCount; i++) {
731 ResetRecordMallocNum();
732 SetMockMallocIndex(i);
733 keyAgreement = nullptr;
734 res = HcfKeyAgreementCreate("ECC", &keyAgreement);
735
736 if (res != HCF_SUCCESS) {
737 continue;
738 }
739
740 out = {
741 .data = nullptr,
742 .len = 0
743 };
744 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
745
746 if (res != HCF_SUCCESS) {
747 HcfObjDestroy(keyAgreement);
748 continue;
749 }
750
751 HcfObjDestroy(keyAgreement);
752 HcfFree(out.data);
753 }
754 EndRecordMallocNum();
755 }
756
757 HWTEST_F(CryptoEccKeyAgreementBySpecTest, CryptoEccKeyAgreementBySpecTest902, TestSize.Level0)
758 {
759 StartRecordOpensslCallNum();
760 HcfKeyAgreement *keyAgreement = nullptr;
761 int32_t res = HcfKeyAgreementCreate("ECC", &keyAgreement);
762
763 ASSERT_EQ(res, HCF_SUCCESS);
764 ASSERT_NE(keyAgreement, nullptr);
765
766 HcfBlob out = { .data = nullptr, .len = 0 };
767 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
768
769 ASSERT_EQ(res, HCF_SUCCESS);
770
771 HcfObjDestroy(keyAgreement);
772
773 uint32_t mallocCount = GetOpensslCallNum();
774
775 for (uint32_t i = 0; i < mallocCount; i++) {
776 ResetOpensslCallNum();
777 SetOpensslCallMockIndex(i);
778 keyAgreement = nullptr;
779 res = HcfKeyAgreementCreate("ECC", &keyAgreement);
780
781 if (res != HCF_SUCCESS) {
782 continue;
783 }
784
785 out = {
786 .data = nullptr,
787 .len = 0
788 };
789 res = keyAgreement->generateSecret(keyAgreement, ecc256KeyPair_->priKey, ecc256KeyPair_->pubKey, &out);
790
791 if (res != HCF_SUCCESS) {
792 HcfObjDestroy(keyAgreement);
793 continue;
794 }
795
796 HcfObjDestroy(keyAgreement);
797 HcfFree(out.data);
798 }
799 EndRecordOpensslCallNum();
800 }
801 }
802