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 "asy_key_generator.h"
20 #include "blob.h"
21 #include "detailed_ecc_key_params.h"
22 #include "ecc_openssl_common.h"
23 #include "ecc_openssl_common_param_spec.h"
24 #include "ecc_common.h"
25 #include "ecdsa_openssl.h"
26 #include "memory.h"
27 #include "securec.h"
28 #include "signature.h"
29 #include "memory_mock.h"
30 #include "openssl_adapter_mock.h"
31 #include "openssl_common.h"
32
33 using namespace std;
34 using namespace testing::ext;
35
36 namespace {
37 class CryptoEccNoLengthSignTest : public testing::Test {
38 public:
39 static void CryptoEccNoLengthSignTestSubEcc224(void);
40 static void CryptoEccNoLengthSignTestSubEcc256(void);
41 static void CryptoEccNoLengthSignTestSubEcc384(void);
42 static void CryptoEccNoLengthSignTestSubEcc521(void);
43 static void SetUpTestCase();
44 static void TearDownTestCase();
SetUp()45 void SetUp() {};
TearDown()46 void TearDown() {};
47
48 static HcfKeyPair *ecc224KeyPair_;
49 static HcfKeyPair *ecc256KeyPair_;
50 static HcfKeyPair *ecc384KeyPair_;
51 static HcfKeyPair *ecc521KeyPair_;
52 };
53
54 HcfKeyPair *CryptoEccNoLengthSignTest::ecc224KeyPair_ = nullptr;
55 HcfKeyPair *CryptoEccNoLengthSignTest::ecc256KeyPair_ = nullptr;
56 HcfKeyPair *CryptoEccNoLengthSignTest::ecc384KeyPair_ = nullptr;
57 HcfKeyPair *CryptoEccNoLengthSignTest::ecc521KeyPair_ = nullptr;
58
59 static const char *g_mockMessage = "hello world";
60 static HcfBlob g_mockInput = {
61 .data = (uint8_t *)g_mockMessage,
62 .len = 12
63 };
64
65 static const bool IS_BIG_ENDIAN = IsBigEndian();
66
67 static string g_eccAlgName = "ECC";
68 static string g_eccFieldType = "Fp";
69 static int32_t g_ecc224CorrectH = 1;
70 static int32_t g_ecc256CorrectH = 1;
71 static int32_t g_ecc384CorrectH = 1;
72 static int32_t g_ecc521CorrectH = 1;
73
74 HcfEccKeyPairParamsSpec g_ecc224KeyPairSpec;
75 HcfEccKeyPairParamsSpec g_ecc256KeyPairSpec;
76 HcfEccKeyPairParamsSpec g_ecc384KeyPairSpec;
77 HcfEccKeyPairParamsSpec g_ecc521KeyPairSpec;
78 HcfECFieldFp g_fieldFp;
79
ConstructEcc224KeyPairParamsSpec(HcfAsyKeyParamsSpec ** spec)80 static HcfResult ConstructEcc224KeyPairParamsSpec(HcfAsyKeyParamsSpec **spec)
81 {
82 HcfEccKeyPairParamsSpec *eccKeyPairSpec = &g_ecc224KeyPairSpec;
83 HcfECField *tmpField = (HcfECField *)(&g_fieldFp);
84
85 eccKeyPairSpec->base.base.algName = const_cast<char *>(g_eccAlgName.c_str());
86 eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
87 eccKeyPairSpec->base.field = tmpField;
88 eccKeyPairSpec->base.field->fieldType = const_cast<char *>(g_eccFieldType.c_str());
89 ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data =
90 (IS_BIG_ENDIAN ? g_ecc224CorrectBigP : g_ecc224CorrectLittleP);
91 ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = NID_secp224r1_len;
92 eccKeyPairSpec->base.a.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigA : g_ecc224CorrectLittleA);
93 eccKeyPairSpec->base.a.len = NID_secp224r1_len;
94 eccKeyPairSpec->base.b.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigB : g_ecc224CorrectLittleB);
95 eccKeyPairSpec->base.b.len = NID_secp224r1_len;
96 eccKeyPairSpec->base.g.x.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGX : g_ecc224CorrectLittleGX);
97 eccKeyPairSpec->base.g.x.len = NID_secp224r1_len;
98 eccKeyPairSpec->base.g.y.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigGY : g_ecc224CorrectLittleGY);
99 eccKeyPairSpec->base.g.y.len = NID_secp224r1_len;
100 eccKeyPairSpec->base.n.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigN : g_ecc224CorrectLittleN);
101 eccKeyPairSpec->base.n.len = NID_secp224r1_len;
102 eccKeyPairSpec->base.h = g_ecc224CorrectH;
103 eccKeyPairSpec->pk.x.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigPkX : g_ecc224CorrectLittlePkX);
104 eccKeyPairSpec->pk.x.len = NID_secp224r1_len;
105 eccKeyPairSpec->pk.y.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigPkY : g_ecc224CorrectLittlePkY);
106 eccKeyPairSpec->pk.y.len = NID_secp224r1_len;
107 eccKeyPairSpec->sk.data = (IS_BIG_ENDIAN ? g_ecc224CorrectBigSk : g_ecc224CorrectLittleSk);
108 eccKeyPairSpec->sk.len = NID_secp224r1_len;
109
110 *spec = (HcfAsyKeyParamsSpec *)eccKeyPairSpec;
111 return HCF_SUCCESS;
112 }
113
ConstructEcc256KeyPairParamsSpec(HcfAsyKeyParamsSpec ** spec)114 static HcfResult ConstructEcc256KeyPairParamsSpec(HcfAsyKeyParamsSpec **spec)
115 {
116 HcfEccKeyPairParamsSpec *eccKeyPairSpec = &g_ecc256KeyPairSpec;
117 HcfECField *tmpField = (HcfECField *)(&g_fieldFp);
118
119 eccKeyPairSpec->base.base.algName = const_cast<char *>(g_eccAlgName.c_str());
120 eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
121 eccKeyPairSpec->base.field = tmpField;
122 eccKeyPairSpec->base.field->fieldType = const_cast<char *>(g_eccFieldType.c_str());
123 ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data =
124 (IS_BIG_ENDIAN ? g_ecc256CorrectBigP : g_ecc256CorrectLittleP);
125 ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = NID_X9_62_prime256v1_len;
126 eccKeyPairSpec->base.a.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigA : g_ecc256CorrectLittleA);
127 eccKeyPairSpec->base.a.len = NID_X9_62_prime256v1_len;
128 eccKeyPairSpec->base.b.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigB : g_ecc256CorrectLittleB);
129 eccKeyPairSpec->base.b.len = NID_X9_62_prime256v1_len;
130 eccKeyPairSpec->base.g.x.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigGX : g_ecc256CorrectLittleGX);
131 eccKeyPairSpec->base.g.x.len = NID_X9_62_prime256v1_len;
132 eccKeyPairSpec->base.g.y.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigGY : g_ecc256CorrectLittleGY);
133 eccKeyPairSpec->base.g.y.len = NID_X9_62_prime256v1_len;
134 eccKeyPairSpec->base.n.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigN : g_ecc256CorrectLittleN);
135 eccKeyPairSpec->base.n.len = NID_X9_62_prime256v1_len;
136 eccKeyPairSpec->base.h = g_ecc256CorrectH;
137 eccKeyPairSpec->pk.x.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigPkX : g_ecc256CorrectLittlePkX);
138 eccKeyPairSpec->pk.x.len = NID_X9_62_prime256v1_len;
139 eccKeyPairSpec->pk.y.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigPkY : g_ecc256CorrectLittlePkY);
140 eccKeyPairSpec->pk.y.len = NID_X9_62_prime256v1_len;
141 eccKeyPairSpec->sk.data = (IS_BIG_ENDIAN ? g_ecc256CorrectBigSk : g_ecc256CorrectLittleSk);
142 eccKeyPairSpec->sk.len = NID_X9_62_prime256v1_len;
143
144 *spec = (HcfAsyKeyParamsSpec *)eccKeyPairSpec;
145 return HCF_SUCCESS;
146 }
147
ConstructEcc384KeyPairParamsSpec(HcfAsyKeyParamsSpec ** spec)148 static HcfResult ConstructEcc384KeyPairParamsSpec(HcfAsyKeyParamsSpec **spec)
149 {
150 HcfEccKeyPairParamsSpec *eccKeyPairSpec = &g_ecc384KeyPairSpec;
151 HcfECField *tmpField = (HcfECField *)(&g_fieldFp);
152
153 eccKeyPairSpec->base.base.algName = const_cast<char *>(g_eccAlgName.c_str());
154 eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
155 eccKeyPairSpec->base.field = tmpField;
156 eccKeyPairSpec->base.field->fieldType = const_cast<char *>(g_eccFieldType.c_str());
157 ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data =
158 (IS_BIG_ENDIAN ? g_ecc384CorrectBigP : g_ecc384CorrectLittleP);
159 ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = NID_secp384r1_len;
160 eccKeyPairSpec->base.a.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigA : g_ecc384CorrectLittleA);
161 eccKeyPairSpec->base.a.len = NID_secp384r1_len;
162 eccKeyPairSpec->base.b.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigB : g_ecc384CorrectLittleB);
163 eccKeyPairSpec->base.b.len = NID_secp384r1_len;
164 eccKeyPairSpec->base.g.x.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigGX : g_ecc384CorrectLittleGX);
165 eccKeyPairSpec->base.g.x.len = NID_secp384r1_len;
166 eccKeyPairSpec->base.g.y.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigGY : g_ecc384CorrectLittleGY);
167 eccKeyPairSpec->base.g.y.len = NID_secp384r1_len;
168 eccKeyPairSpec->base.n.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigN : g_ecc384CorrectLittleN);
169 eccKeyPairSpec->base.n.len = NID_secp384r1_len;
170 eccKeyPairSpec->base.h = g_ecc384CorrectH;
171 eccKeyPairSpec->pk.x.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigPkX : g_ecc384CorrectLittlePkX);
172 eccKeyPairSpec->pk.x.len = NID_secp384r1_len;
173 eccKeyPairSpec->pk.y.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigPkY : g_ecc384CorrectLittlePkY);
174 eccKeyPairSpec->pk.y.len = NID_secp384r1_len;
175 eccKeyPairSpec->sk.data = (IS_BIG_ENDIAN ? g_ecc384CorrectBigSk : g_ecc384CorrectLittleSk);
176 eccKeyPairSpec->sk.len = NID_secp384r1_len;
177
178 *spec = (HcfAsyKeyParamsSpec *)eccKeyPairSpec;
179 return HCF_SUCCESS;
180 }
181
ConstructEcc521KeyPairParamsSpec(HcfAsyKeyParamsSpec ** spec)182 static HcfResult ConstructEcc521KeyPairParamsSpec(HcfAsyKeyParamsSpec **spec)
183 {
184 HcfEccKeyPairParamsSpec *eccKeyPairSpec = &g_ecc521KeyPairSpec;
185 HcfECField *tmpField = (HcfECField *)(&g_fieldFp);
186
187 eccKeyPairSpec->base.base.algName = const_cast<char *>(g_eccAlgName.c_str());
188 eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
189 eccKeyPairSpec->base.field = tmpField;
190 eccKeyPairSpec->base.field->fieldType = const_cast<char *>(g_eccFieldType.c_str());
191 ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.data =
192 (IS_BIG_ENDIAN ? g_ecc521CorrectBigP : g_ecc521CorrectLittleP);
193 ((HcfECFieldFp *)(eccKeyPairSpec->base.field))->p.len = NID_secp521r1_len;
194 eccKeyPairSpec->base.a.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigA : g_ecc521CorrectLittleA);
195 eccKeyPairSpec->base.a.len = NID_secp521r1_len;
196 eccKeyPairSpec->base.b.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigB : g_ecc521CorrectLittleB);
197 eccKeyPairSpec->base.b.len = NID_secp521r1_len;
198 eccKeyPairSpec->base.g.x.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigGX : g_ecc521CorrectLittleGX);
199 eccKeyPairSpec->base.g.x.len = NID_secp521r1_len;
200 eccKeyPairSpec->base.g.y.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigGY : g_ecc521CorrectLittleGY);
201 eccKeyPairSpec->base.g.y.len = NID_secp521r1_len;
202 eccKeyPairSpec->base.n.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigN : g_ecc521CorrectLittleN);
203 eccKeyPairSpec->base.n.len = NID_secp521r1_len;
204 eccKeyPairSpec->base.h = g_ecc521CorrectH;
205 eccKeyPairSpec->pk.x.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigPkX : g_ecc521CorrectLittlePkX);
206 eccKeyPairSpec->pk.x.len = NID_secp521r1_len;
207 eccKeyPairSpec->pk.y.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigPkY : g_ecc521CorrectLittlePkY);
208 eccKeyPairSpec->pk.y.len = NID_secp521r1_len;
209 eccKeyPairSpec->sk.data = (IS_BIG_ENDIAN ? g_ecc521CorrectBigSk : g_ecc521CorrectLittleSk);
210 eccKeyPairSpec->sk.len = NID_secp521r1_len;
211
212 *spec = (HcfAsyKeyParamsSpec *)eccKeyPairSpec;
213 return HCF_SUCCESS;
214 }
215
CryptoEccNoLengthSignTestSubEcc224(void)216 void CryptoEccNoLengthSignTest::CryptoEccNoLengthSignTestSubEcc224(void)
217 {
218 HcfAsyKeyParamsSpec *paramSpec = nullptr;
219 int32_t res = ConstructEcc224KeyPairParamsSpec(¶mSpec);
220 ASSERT_EQ(res, HCF_SUCCESS);
221
222 HcfAsyKeyGeneratorBySpec *generator = nullptr;
223 res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
224 ASSERT_EQ(res, HCF_SUCCESS);
225 ASSERT_NE(generator, nullptr);
226
227 HcfKeyPair *keyPair = nullptr;
228 res = generator->generateKeyPair(generator, &keyPair);
229 ASSERT_EQ(res, HCF_SUCCESS);
230 ASSERT_NE(keyPair, nullptr);
231
232 ecc224KeyPair_ = keyPair;
233
234 HcfObjDestroy(generator);
235 }
236
CryptoEccNoLengthSignTestSubEcc256(void)237 void CryptoEccNoLengthSignTest::CryptoEccNoLengthSignTestSubEcc256(void)
238 {
239 HcfAsyKeyParamsSpec *paramSpec = nullptr;
240 int32_t res = ConstructEcc256KeyPairParamsSpec(¶mSpec);
241 ASSERT_EQ(res, HCF_SUCCESS);
242
243 HcfAsyKeyGeneratorBySpec *generator = nullptr;
244 res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
245 ASSERT_EQ(res, HCF_SUCCESS);
246 ASSERT_NE(generator, nullptr);
247
248 HcfKeyPair *keyPair = nullptr;
249 res = generator->generateKeyPair(generator, &keyPair);
250 ASSERT_EQ(res, HCF_SUCCESS);
251 ASSERT_NE(keyPair, nullptr);
252
253 ecc256KeyPair_ = keyPair;
254
255 HcfObjDestroy(generator);
256 }
257
CryptoEccNoLengthSignTestSubEcc384(void)258 void CryptoEccNoLengthSignTest::CryptoEccNoLengthSignTestSubEcc384(void)
259 {
260 HcfAsyKeyParamsSpec *paramSpec = nullptr;
261 int32_t res = ConstructEcc384KeyPairParamsSpec(¶mSpec);
262 ASSERT_EQ(res, HCF_SUCCESS);
263
264 HcfAsyKeyGeneratorBySpec *generator = nullptr;
265 res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
266 ASSERT_EQ(res, HCF_SUCCESS);
267 ASSERT_NE(generator, nullptr);
268
269 HcfKeyPair *keyPair = nullptr;
270 res = generator->generateKeyPair(generator, &keyPair);
271 ASSERT_EQ(res, HCF_SUCCESS);
272 ASSERT_NE(keyPair, nullptr);
273
274 ecc384KeyPair_ = keyPair;
275 HcfObjDestroy(generator);
276 }
277
CryptoEccNoLengthSignTestSubEcc521(void)278 void CryptoEccNoLengthSignTest::CryptoEccNoLengthSignTestSubEcc521(void)
279 {
280 HcfAsyKeyParamsSpec *paramSpec = nullptr;
281 int32_t res = ConstructEcc521KeyPairParamsSpec(¶mSpec);
282 ASSERT_EQ(res, HCF_SUCCESS);
283
284 HcfAsyKeyGeneratorBySpec *generator = nullptr;
285 res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
286 ASSERT_EQ(res, HCF_SUCCESS);
287 ASSERT_NE(generator, nullptr);
288
289 HcfKeyPair *keyPair = nullptr;
290 res = generator->generateKeyPair(generator, &keyPair);
291 ASSERT_EQ(res, HCF_SUCCESS);
292 ASSERT_NE(keyPair, nullptr);
293
294 ecc521KeyPair_ = keyPair;
295 HcfObjDestroy(generator);
296 }
297
SetUpTestCase()298 void CryptoEccNoLengthSignTest::SetUpTestCase()
299 {
300 CryptoEccNoLengthSignTestSubEcc224();
301 CryptoEccNoLengthSignTestSubEcc256();
302 CryptoEccNoLengthSignTestSubEcc384();
303 CryptoEccNoLengthSignTestSubEcc521();
304 }
305
TearDownTestCase()306 void CryptoEccNoLengthSignTest::TearDownTestCase()
307 {
308 HcfObjDestroy(ecc224KeyPair_);
309 HcfObjDestroy(ecc256KeyPair_);
310 HcfObjDestroy(ecc384KeyPair_);
311 HcfObjDestroy(ecc521KeyPair_);
312 }
313
GetMockClass(void)314 static const char *GetMockClass(void)
315 {
316 return "HcfMock";
317 }
318
319 static HcfObjectBase obj = {
320 .getClass = GetMockClass,
321 .destroy = nullptr
322 };
323
324 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest001, TestSize.Level0)
325 {
326 HcfSign *sign = nullptr;
327 int32_t res = HcfSignCreate("ECC|SHA1", &sign);
328
329 ASSERT_EQ(res, HCF_SUCCESS);
330 ASSERT_NE(sign, nullptr);
331
332 HcfObjDestroy(sign);
333 }
334
335 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest002, TestSize.Level0)
336 {
337 HcfSign *sign = nullptr;
338 int32_t res = HcfSignCreate("ECC|SHA224", &sign);
339
340 ASSERT_EQ(res, HCF_SUCCESS);
341 ASSERT_NE(sign, nullptr);
342
343 HcfObjDestroy(sign);
344 }
345
346 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest003, TestSize.Level0)
347 {
348 HcfSign *sign = nullptr;
349 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
350
351 ASSERT_EQ(res, HCF_SUCCESS);
352 ASSERT_NE(sign, nullptr);
353
354 HcfObjDestroy(sign);
355 }
356
357 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest004, TestSize.Level0)
358 {
359 HcfSign *sign = nullptr;
360 int32_t res = HcfSignCreate("ECC|SHA384", &sign);
361
362 ASSERT_EQ(res, HCF_SUCCESS);
363 ASSERT_NE(sign, nullptr);
364
365 HcfObjDestroy(sign);
366 }
367
368 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest005, TestSize.Level0)
369 {
370 HcfSign *sign = nullptr;
371 int32_t res = HcfSignCreate("ECC|SHA512", &sign);
372
373 ASSERT_EQ(res, HCF_SUCCESS);
374 ASSERT_NE(sign, nullptr);
375
376 HcfObjDestroy(sign);
377 }
378
379 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest006, TestSize.Level0)
380 {
381 HcfSign *sign = nullptr;
382 int32_t res = HcfSignCreate("ecc|SHA512", &sign);
383
384 ASSERT_NE(res, HCF_SUCCESS);
385 ASSERT_EQ(sign, nullptr);
386 }
387
388 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest007, TestSize.Level0)
389 {
390 HcfSign *sign = nullptr;
391 int32_t res = HcfSignCreate("ECC|MD5", &sign);
392
393 ASSERT_NE(res, HCF_SUCCESS);
394 ASSERT_EQ(sign, nullptr);
395 }
396
397 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest008, TestSize.Level0)
398 {
399 HcfSign *sign = nullptr;
400 int32_t res = HcfSignCreate("ECCSHA256", &sign);
401
402 ASSERT_NE(res, HCF_SUCCESS);
403 ASSERT_EQ(sign, nullptr);
404 }
405
406 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest009, TestSize.Level0)
407 {
408 int32_t res = HcfSignCreate("ECC|SHA256", nullptr);
409
410 ASSERT_EQ(res, HCF_INVALID_PARAMS);
411 }
412
413 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest101, TestSize.Level0)
414 {
415 HcfSign *sign = nullptr;
416 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
417
418 ASSERT_EQ(res, HCF_SUCCESS);
419 ASSERT_NE(sign, nullptr);
420
421 const char *className = sign->base.getClass();
422
423 ASSERT_NE(className, nullptr);
424
425 HcfObjDestroy(sign);
426 }
427
428 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest102, TestSize.Level0)
429 {
430 HcfSign *sign = nullptr;
431 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
432
433 ASSERT_EQ(res, HCF_SUCCESS);
434 ASSERT_NE(sign, nullptr);
435
436 sign->base.destroy((HcfObjectBase *)sign);
437 }
438
439 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest103, TestSize.Level0)
440 {
441 HcfSign *sign = nullptr;
442 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
443
444 ASSERT_EQ(res, HCF_SUCCESS);
445 ASSERT_NE(sign, nullptr);
446
447 sign->base.destroy(nullptr);
448
449 HcfObjDestroy(sign);
450 }
451
452 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest104, TestSize.Level0)
453 {
454 HcfSign *sign = nullptr;
455 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
456
457 ASSERT_EQ(res, HCF_SUCCESS);
458 ASSERT_NE(sign, nullptr);
459
460 sign->base.destroy(&obj);
461
462 HcfObjDestroy(sign);
463 }
464
465 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest105, TestSize.Level0)
466 {
467 HcfSign *sign = nullptr;
468 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
469
470 ASSERT_EQ(res, HCF_SUCCESS);
471 ASSERT_NE(sign, nullptr);
472
473 const char *algName = sign->getAlgoName(sign);
474
475 ASSERT_NE(algName, nullptr);
476
477 HcfObjDestroy(sign);
478 }
479
480 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest106, TestSize.Level0)
481 {
482 HcfSign *sign = nullptr;
483 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
484
485 ASSERT_EQ(res, HCF_SUCCESS);
486 ASSERT_NE(sign, nullptr);
487
488 const char *algName = sign->getAlgoName(nullptr);
489
490 ASSERT_EQ(algName, nullptr);
491
492 HcfObjDestroy(sign);
493 }
494
495 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest107, TestSize.Level0)
496 {
497 HcfSign *sign = nullptr;
498 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
499
500 ASSERT_EQ(res, HCF_SUCCESS);
501 ASSERT_NE(sign, nullptr);
502
503 const char *algName = sign->getAlgoName((HcfSign *)(&obj));
504
505 ASSERT_EQ(algName, nullptr);
506
507 HcfObjDestroy(sign);
508 }
509
510 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest201, TestSize.Level0)
511 {
512 HcfSign *sign = nullptr;
513 int32_t res = HcfSignCreate("ECC|SHA1", &sign);
514
515 ASSERT_EQ(res, HCF_SUCCESS);
516 ASSERT_NE(sign, nullptr);
517
518 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
519
520 ASSERT_EQ(res, HCF_SUCCESS);
521
522 HcfObjDestroy(sign);
523 }
524
525 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest202, TestSize.Level0)
526 {
527 HcfSign *sign = nullptr;
528 int32_t res = HcfSignCreate("ECC|SHA224", &sign);
529
530 ASSERT_EQ(res, HCF_SUCCESS);
531 ASSERT_NE(sign, nullptr);
532
533 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
534
535 ASSERT_EQ(res, HCF_SUCCESS);
536
537 HcfObjDestroy(sign);
538 }
539
540 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest203, TestSize.Level0)
541 {
542 HcfSign *sign = nullptr;
543 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
544
545 ASSERT_EQ(res, HCF_SUCCESS);
546 ASSERT_NE(sign, nullptr);
547
548 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
549
550 ASSERT_EQ(res, HCF_SUCCESS);
551
552 HcfObjDestroy(sign);
553 }
554
555 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest204, TestSize.Level0)
556 {
557 HcfSign *sign = nullptr;
558 int32_t res = HcfSignCreate("ECC|SHA384", &sign);
559
560 ASSERT_EQ(res, HCF_SUCCESS);
561 ASSERT_NE(sign, nullptr);
562
563 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
564
565 ASSERT_EQ(res, HCF_SUCCESS);
566
567 HcfObjDestroy(sign);
568 }
569
570 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest205, TestSize.Level0)
571 {
572 HcfSign *sign = nullptr;
573 int32_t res = HcfSignCreate("ECC|SHA512", &sign);
574
575 ASSERT_EQ(res, HCF_SUCCESS);
576 ASSERT_NE(sign, nullptr);
577
578 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
579
580 ASSERT_EQ(res, HCF_SUCCESS);
581
582 HcfObjDestroy(sign);
583 }
584
585 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest206, TestSize.Level0)
586 {
587 HcfSign *sign = nullptr;
588 int32_t res = HcfSignCreate("ECC|SHA1", &sign);
589
590 ASSERT_EQ(res, HCF_SUCCESS);
591 ASSERT_NE(sign, nullptr);
592
593 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
594
595 ASSERT_EQ(res, HCF_SUCCESS);
596
597 HcfObjDestroy(sign);
598 }
599
600 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest207, TestSize.Level0)
601 {
602 HcfSign *sign = nullptr;
603 int32_t res = HcfSignCreate("ECC|SHA224", &sign);
604
605 ASSERT_EQ(res, HCF_SUCCESS);
606 ASSERT_NE(sign, nullptr);
607
608 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
609
610 ASSERT_EQ(res, HCF_SUCCESS);
611
612 HcfObjDestroy(sign);
613 }
614
615 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest208, TestSize.Level0)
616 {
617 HcfSign *sign = nullptr;
618 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
619
620 ASSERT_EQ(res, HCF_SUCCESS);
621 ASSERT_NE(sign, nullptr);
622
623 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
624
625 ASSERT_EQ(res, HCF_SUCCESS);
626
627 HcfObjDestroy(sign);
628 }
629
630 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest209, TestSize.Level0)
631 {
632 HcfSign *sign = nullptr;
633 int32_t res = HcfSignCreate("ECC|SHA384", &sign);
634
635 ASSERT_EQ(res, HCF_SUCCESS);
636 ASSERT_NE(sign, nullptr);
637
638 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
639
640 ASSERT_EQ(res, HCF_SUCCESS);
641
642 HcfObjDestroy(sign);
643 }
644
645 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest210, TestSize.Level0)
646 {
647 HcfSign *sign = nullptr;
648 int32_t res = HcfSignCreate("ECC|SHA512", &sign);
649
650 ASSERT_EQ(res, HCF_SUCCESS);
651 ASSERT_NE(sign, nullptr);
652
653 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
654
655 ASSERT_EQ(res, HCF_SUCCESS);
656
657 HcfObjDestroy(sign);
658 }
659
660 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest211, TestSize.Level0)
661 {
662 HcfSign *sign = nullptr;
663 int32_t res = HcfSignCreate("ECC|SHA1", &sign);
664
665 ASSERT_EQ(res, HCF_SUCCESS);
666 ASSERT_NE(sign, nullptr);
667
668 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
669
670 ASSERT_EQ(res, HCF_SUCCESS);
671
672 HcfObjDestroy(sign);
673 }
674
675 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest212, TestSize.Level0)
676 {
677 HcfSign *sign = nullptr;
678 int32_t res = HcfSignCreate("ECC|SHA224", &sign);
679
680 ASSERT_EQ(res, HCF_SUCCESS);
681 ASSERT_NE(sign, nullptr);
682
683 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
684
685 ASSERT_EQ(res, HCF_SUCCESS);
686
687 HcfObjDestroy(sign);
688 }
689
690 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest213, TestSize.Level0)
691 {
692 HcfSign *sign = nullptr;
693 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
694
695 ASSERT_EQ(res, HCF_SUCCESS);
696 ASSERT_NE(sign, nullptr);
697
698 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
699
700 ASSERT_EQ(res, HCF_SUCCESS);
701
702 HcfObjDestroy(sign);
703 }
704
705 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest214, TestSize.Level0)
706 {
707 HcfSign *sign = nullptr;
708 int32_t res = HcfSignCreate("ECC|SHA384", &sign);
709
710 ASSERT_EQ(res, HCF_SUCCESS);
711 ASSERT_NE(sign, nullptr);
712
713 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
714
715 ASSERT_EQ(res, HCF_SUCCESS);
716
717 HcfObjDestroy(sign);
718 }
719
720 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest215, TestSize.Level0)
721 {
722 HcfSign *sign = nullptr;
723 int32_t res = HcfSignCreate("ECC|SHA512", &sign);
724
725 ASSERT_EQ(res, HCF_SUCCESS);
726 ASSERT_NE(sign, nullptr);
727
728 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
729
730 ASSERT_EQ(res, HCF_SUCCESS);
731
732 HcfObjDestroy(sign);
733 }
734
735 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest216, TestSize.Level0)
736 {
737 HcfSign *sign = nullptr;
738 int32_t res = HcfSignCreate("ECC|SHA1", &sign);
739
740 ASSERT_EQ(res, HCF_SUCCESS);
741 ASSERT_NE(sign, nullptr);
742
743 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
744
745 ASSERT_EQ(res, HCF_SUCCESS);
746
747 HcfObjDestroy(sign);
748 }
749
750 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest217, TestSize.Level0)
751 {
752 HcfSign *sign = nullptr;
753 int32_t res = HcfSignCreate("ECC|SHA224", &sign);
754
755 ASSERT_EQ(res, HCF_SUCCESS);
756 ASSERT_NE(sign, nullptr);
757
758 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
759
760 ASSERT_EQ(res, HCF_SUCCESS);
761
762 HcfObjDestroy(sign);
763 }
764
765 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest218, TestSize.Level0)
766 {
767 HcfSign *sign = nullptr;
768 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
769
770 ASSERT_EQ(res, HCF_SUCCESS);
771 ASSERT_NE(sign, nullptr);
772
773 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
774
775 ASSERT_EQ(res, HCF_SUCCESS);
776
777 HcfObjDestroy(sign);
778 }
779
780 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest219, TestSize.Level0)
781 {
782 HcfSign *sign = nullptr;
783 int32_t res = HcfSignCreate("ECC|SHA384", &sign);
784
785 ASSERT_EQ(res, HCF_SUCCESS);
786 ASSERT_NE(sign, nullptr);
787
788 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
789
790 ASSERT_EQ(res, HCF_SUCCESS);
791
792 HcfObjDestroy(sign);
793 }
794
795 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest220, TestSize.Level0)
796 {
797 HcfSign *sign = nullptr;
798 int32_t res = HcfSignCreate("ECC|SHA512", &sign);
799
800 ASSERT_EQ(res, HCF_SUCCESS);
801 ASSERT_NE(sign, nullptr);
802
803 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
804
805 ASSERT_EQ(res, HCF_SUCCESS);
806
807 HcfObjDestroy(sign);
808 }
809
810 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest221, TestSize.Level0)
811 {
812 HcfSign *sign = nullptr;
813 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
814
815 ASSERT_EQ(res, HCF_SUCCESS);
816 ASSERT_NE(sign, nullptr);
817
818 res = sign->init(nullptr, nullptr, ecc256KeyPair_->priKey);
819
820 ASSERT_EQ(res, HCF_INVALID_PARAMS);
821
822 HcfObjDestroy(sign);
823 }
824
825 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest222, TestSize.Level0)
826 {
827 HcfSign *sign = nullptr;
828 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
829
830 ASSERT_EQ(res, HCF_SUCCESS);
831 ASSERT_NE(sign, nullptr);
832
833 res = sign->init((HcfSign *)(&obj), nullptr, ecc256KeyPair_->priKey);
834
835 ASSERT_EQ(res, HCF_INVALID_PARAMS);
836
837 HcfObjDestroy(sign);
838 }
839
840 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest223, TestSize.Level0)
841 {
842 HcfSign *sign = nullptr;
843 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
844
845 ASSERT_EQ(res, HCF_SUCCESS);
846 ASSERT_NE(sign, nullptr);
847
848 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
849
850 ASSERT_EQ(res, HCF_SUCCESS);
851
852 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
853
854 ASSERT_EQ(res, HCF_INVALID_PARAMS);
855
856 HcfObjDestroy(sign);
857 }
858
859 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest224, TestSize.Level0)
860 {
861 HcfSign *sign = nullptr;
862 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
863
864 ASSERT_EQ(res, HCF_SUCCESS);
865 ASSERT_NE(sign, nullptr);
866
867 res = sign->init(sign, nullptr, nullptr);
868
869 ASSERT_EQ(res, HCF_INVALID_PARAMS);
870
871 HcfObjDestroy(sign);
872 }
873
874 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest225, TestSize.Level0)
875 {
876 HcfSign *sign = nullptr;
877 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
878
879 ASSERT_EQ(res, HCF_SUCCESS);
880 ASSERT_NE(sign, nullptr);
881
882 res = sign->init(sign, nullptr, (HcfPriKey *)(&obj));
883
884 ASSERT_EQ(res, HCF_INVALID_PARAMS);
885
886 HcfObjDestroy(sign);
887 }
888
889 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest301, TestSize.Level0)
890 {
891 HcfSign *sign = nullptr;
892 int32_t res = HcfSignCreate("ECC|SHA1", &sign);
893
894 ASSERT_EQ(res, HCF_SUCCESS);
895 ASSERT_NE(sign, nullptr);
896
897 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
898
899 ASSERT_EQ(res, HCF_SUCCESS);
900
901 res = sign->update(sign, &g_mockInput);
902
903 ASSERT_EQ(res, HCF_SUCCESS);
904
905 HcfObjDestroy(sign);
906 }
907
908 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest302, TestSize.Level0)
909 {
910 HcfSign *sign = nullptr;
911 int32_t res = HcfSignCreate("ECC|SHA224", &sign);
912
913 ASSERT_EQ(res, HCF_SUCCESS);
914 ASSERT_NE(sign, nullptr);
915
916 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
917
918 ASSERT_EQ(res, HCF_SUCCESS);
919
920 res = sign->update(sign, &g_mockInput);
921
922 ASSERT_EQ(res, HCF_SUCCESS);
923
924 HcfObjDestroy(sign);
925 }
926
927 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest303, TestSize.Level0)
928 {
929 HcfSign *sign = nullptr;
930 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
931
932 ASSERT_EQ(res, HCF_SUCCESS);
933 ASSERT_NE(sign, nullptr);
934
935 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
936
937 ASSERT_EQ(res, HCF_SUCCESS);
938
939 res = sign->update(sign, &g_mockInput);
940
941 ASSERT_EQ(res, HCF_SUCCESS);
942
943 HcfObjDestroy(sign);
944 }
945
946 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest304, TestSize.Level0)
947 {
948 HcfSign *sign = nullptr;
949 int32_t res = HcfSignCreate("ECC|SHA384", &sign);
950
951 ASSERT_EQ(res, HCF_SUCCESS);
952 ASSERT_NE(sign, nullptr);
953
954 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
955
956 ASSERT_EQ(res, HCF_SUCCESS);
957
958 res = sign->update(sign, &g_mockInput);
959
960 ASSERT_EQ(res, HCF_SUCCESS);
961
962 HcfObjDestroy(sign);
963 }
964
965 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest305, TestSize.Level0)
966 {
967 HcfSign *sign = nullptr;
968 int32_t res = HcfSignCreate("ECC|SHA512", &sign);
969
970 ASSERT_EQ(res, HCF_SUCCESS);
971 ASSERT_NE(sign, nullptr);
972
973 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
974
975 ASSERT_EQ(res, HCF_SUCCESS);
976
977 res = sign->update(sign, &g_mockInput);
978
979 ASSERT_EQ(res, HCF_SUCCESS);
980
981 HcfObjDestroy(sign);
982 }
983
984 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest306, TestSize.Level0)
985 {
986 HcfSign *sign = nullptr;
987 int32_t res = HcfSignCreate("ECC|SHA1", &sign);
988
989 ASSERT_EQ(res, HCF_SUCCESS);
990 ASSERT_NE(sign, nullptr);
991
992 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
993
994 ASSERT_EQ(res, HCF_SUCCESS);
995
996 res = sign->update(sign, &g_mockInput);
997
998 ASSERT_EQ(res, HCF_SUCCESS);
999
1000 HcfObjDestroy(sign);
1001 }
1002
1003 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest307, TestSize.Level0)
1004 {
1005 HcfSign *sign = nullptr;
1006 int32_t res = HcfSignCreate("ECC|SHA224", &sign);
1007
1008 ASSERT_EQ(res, HCF_SUCCESS);
1009 ASSERT_NE(sign, nullptr);
1010
1011 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1012
1013 ASSERT_EQ(res, HCF_SUCCESS);
1014
1015 res = sign->update(sign, &g_mockInput);
1016
1017 ASSERT_EQ(res, HCF_SUCCESS);
1018
1019 HcfObjDestroy(sign);
1020 }
1021
1022 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest308, TestSize.Level0)
1023 {
1024 HcfSign *sign = nullptr;
1025 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1026
1027 ASSERT_EQ(res, HCF_SUCCESS);
1028 ASSERT_NE(sign, nullptr);
1029
1030 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1031
1032 ASSERT_EQ(res, HCF_SUCCESS);
1033
1034 res = sign->update(sign, &g_mockInput);
1035
1036 ASSERT_EQ(res, HCF_SUCCESS);
1037
1038 HcfObjDestroy(sign);
1039 }
1040
1041 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest309, TestSize.Level0)
1042 {
1043 HcfSign *sign = nullptr;
1044 int32_t res = HcfSignCreate("ECC|SHA384", &sign);
1045
1046 ASSERT_EQ(res, HCF_SUCCESS);
1047 ASSERT_NE(sign, nullptr);
1048
1049 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1050
1051 ASSERT_EQ(res, HCF_SUCCESS);
1052
1053 res = sign->update(sign, &g_mockInput);
1054
1055 ASSERT_EQ(res, HCF_SUCCESS);
1056
1057 HcfObjDestroy(sign);
1058 }
1059
1060 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest310, TestSize.Level0)
1061 {
1062 HcfSign *sign = nullptr;
1063 int32_t res = HcfSignCreate("ECC|SHA512", &sign);
1064
1065 ASSERT_EQ(res, HCF_SUCCESS);
1066 ASSERT_NE(sign, nullptr);
1067
1068 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1069
1070 ASSERT_EQ(res, HCF_SUCCESS);
1071
1072 res = sign->update(sign, &g_mockInput);
1073
1074 ASSERT_EQ(res, HCF_SUCCESS);
1075
1076 HcfObjDestroy(sign);
1077 }
1078
1079 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest311, TestSize.Level0)
1080 {
1081 HcfSign *sign = nullptr;
1082 int32_t res = HcfSignCreate("ECC|SHA1", &sign);
1083
1084 ASSERT_EQ(res, HCF_SUCCESS);
1085 ASSERT_NE(sign, nullptr);
1086
1087 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1088
1089 ASSERT_EQ(res, HCF_SUCCESS);
1090
1091 res = sign->update(sign, &g_mockInput);
1092
1093 ASSERT_EQ(res, HCF_SUCCESS);
1094
1095 HcfObjDestroy(sign);
1096 }
1097
1098 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest312, TestSize.Level0)
1099 {
1100 HcfSign *sign = nullptr;
1101 int32_t res = HcfSignCreate("ECC|SHA224", &sign);
1102
1103 ASSERT_EQ(res, HCF_SUCCESS);
1104 ASSERT_NE(sign, nullptr);
1105
1106 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1107
1108 ASSERT_EQ(res, HCF_SUCCESS);
1109
1110 res = sign->update(sign, &g_mockInput);
1111
1112 ASSERT_EQ(res, HCF_SUCCESS);
1113
1114 HcfObjDestroy(sign);
1115 }
1116
1117 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest313, TestSize.Level0)
1118 {
1119 HcfSign *sign = nullptr;
1120 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1121
1122 ASSERT_EQ(res, HCF_SUCCESS);
1123 ASSERT_NE(sign, nullptr);
1124
1125 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1126
1127 ASSERT_EQ(res, HCF_SUCCESS);
1128
1129 res = sign->update(sign, &g_mockInput);
1130
1131 ASSERT_EQ(res, HCF_SUCCESS);
1132
1133 HcfObjDestroy(sign);
1134 }
1135
1136 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest314, TestSize.Level0)
1137 {
1138 HcfSign *sign = nullptr;
1139 int32_t res = HcfSignCreate("ECC|SHA384", &sign);
1140
1141 ASSERT_EQ(res, HCF_SUCCESS);
1142 ASSERT_NE(sign, nullptr);
1143
1144 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1145
1146 ASSERT_EQ(res, HCF_SUCCESS);
1147
1148 res = sign->update(sign, &g_mockInput);
1149
1150 ASSERT_EQ(res, HCF_SUCCESS);
1151
1152 HcfObjDestroy(sign);
1153 }
1154
1155 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest315, TestSize.Level0)
1156 {
1157 HcfSign *sign = nullptr;
1158 int32_t res = HcfSignCreate("ECC|SHA512", &sign);
1159
1160 ASSERT_EQ(res, HCF_SUCCESS);
1161 ASSERT_NE(sign, nullptr);
1162
1163 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1164
1165 ASSERT_EQ(res, HCF_SUCCESS);
1166
1167 res = sign->update(sign, &g_mockInput);
1168
1169 ASSERT_EQ(res, HCF_SUCCESS);
1170
1171 HcfObjDestroy(sign);
1172 }
1173
1174 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest316, TestSize.Level0)
1175 {
1176 HcfSign *sign = nullptr;
1177 int32_t res = HcfSignCreate("ECC|SHA1", &sign);
1178
1179 ASSERT_EQ(res, HCF_SUCCESS);
1180 ASSERT_NE(sign, nullptr);
1181
1182 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1183
1184 ASSERT_EQ(res, HCF_SUCCESS);
1185
1186 res = sign->update(sign, &g_mockInput);
1187
1188 ASSERT_EQ(res, HCF_SUCCESS);
1189
1190 HcfObjDestroy(sign);
1191 }
1192
1193 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest317, TestSize.Level0)
1194 {
1195 HcfSign *sign = nullptr;
1196 int32_t res = HcfSignCreate("ECC|SHA224", &sign);
1197
1198 ASSERT_EQ(res, HCF_SUCCESS);
1199 ASSERT_NE(sign, nullptr);
1200
1201 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1202
1203 ASSERT_EQ(res, HCF_SUCCESS);
1204
1205 res = sign->update(sign, &g_mockInput);
1206
1207 ASSERT_EQ(res, HCF_SUCCESS);
1208
1209 HcfObjDestroy(sign);
1210 }
1211
1212 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest318, TestSize.Level0)
1213 {
1214 HcfSign *sign = nullptr;
1215 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1216
1217 ASSERT_EQ(res, HCF_SUCCESS);
1218 ASSERT_NE(sign, nullptr);
1219
1220 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1221
1222 ASSERT_EQ(res, HCF_SUCCESS);
1223
1224 res = sign->update(sign, &g_mockInput);
1225
1226 ASSERT_EQ(res, HCF_SUCCESS);
1227
1228 HcfObjDestroy(sign);
1229 }
1230
1231 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest319, TestSize.Level0)
1232 {
1233 HcfSign *sign = nullptr;
1234 int32_t res = HcfSignCreate("ECC|SHA384", &sign);
1235
1236 ASSERT_EQ(res, HCF_SUCCESS);
1237 ASSERT_NE(sign, nullptr);
1238
1239 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1240
1241 ASSERT_EQ(res, HCF_SUCCESS);
1242
1243 res = sign->update(sign, &g_mockInput);
1244
1245 ASSERT_EQ(res, HCF_SUCCESS);
1246
1247 HcfObjDestroy(sign);
1248 }
1249
1250 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest320, TestSize.Level0)
1251 {
1252 HcfSign *sign = nullptr;
1253 int32_t res = HcfSignCreate("ECC|SHA512", &sign);
1254
1255 ASSERT_EQ(res, HCF_SUCCESS);
1256 ASSERT_NE(sign, nullptr);
1257
1258 res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1259
1260 ASSERT_EQ(res, HCF_SUCCESS);
1261
1262 res = sign->update(sign, &g_mockInput);
1263
1264 ASSERT_EQ(res, HCF_SUCCESS);
1265
1266 HcfObjDestroy(sign);
1267 }
1268
1269 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest321, TestSize.Level0)
1270 {
1271 HcfSign *sign = nullptr;
1272 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1273
1274 ASSERT_EQ(res, HCF_SUCCESS);
1275 ASSERT_NE(sign, nullptr);
1276
1277 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1278
1279 ASSERT_EQ(res, HCF_SUCCESS);
1280
1281 res = sign->update(nullptr, &g_mockInput);
1282
1283 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1284
1285 HcfObjDestroy(sign);
1286 }
1287
1288 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest322, TestSize.Level0)
1289 {
1290 HcfSign *sign = nullptr;
1291 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1292
1293 ASSERT_EQ(res, HCF_SUCCESS);
1294 ASSERT_NE(sign, nullptr);
1295
1296 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1297
1298 ASSERT_EQ(res, HCF_SUCCESS);
1299
1300 res = sign->update((HcfSign *)(&obj), &g_mockInput);
1301
1302 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1303
1304 HcfObjDestroy(sign);
1305 }
1306
1307 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest323, TestSize.Level0)
1308 {
1309 HcfSign *sign = nullptr;
1310 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1311
1312 ASSERT_EQ(res, HCF_SUCCESS);
1313 ASSERT_NE(sign, nullptr);
1314
1315 res = sign->update(sign, &g_mockInput);
1316
1317 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1318
1319 HcfObjDestroy(sign);
1320 }
1321
1322 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest324, TestSize.Level0)
1323 {
1324 HcfSign *sign = nullptr;
1325 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1326
1327 ASSERT_EQ(res, HCF_SUCCESS);
1328 ASSERT_NE(sign, nullptr);
1329
1330 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1331
1332 ASSERT_EQ(res, HCF_SUCCESS);
1333
1334 res = sign->update(sign, nullptr);
1335
1336 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1337
1338 HcfObjDestroy(sign);
1339 }
1340
1341 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest325, TestSize.Level0)
1342 {
1343 HcfSign *sign = nullptr;
1344 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1345
1346 ASSERT_EQ(res, HCF_SUCCESS);
1347 ASSERT_NE(sign, nullptr);
1348
1349 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1350
1351 ASSERT_EQ(res, HCF_SUCCESS);
1352
1353 HcfBlob input = {
1354 .data = nullptr,
1355 .len = 1
1356 };
1357 res = sign->update(sign, &input);
1358
1359 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1360
1361 HcfObjDestroy(sign);
1362 }
1363
1364 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest326, TestSize.Level0)
1365 {
1366 HcfSign *sign = nullptr;
1367 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1368
1369 ASSERT_EQ(res, HCF_SUCCESS);
1370 ASSERT_NE(sign, nullptr);
1371
1372 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1373
1374 ASSERT_EQ(res, HCF_SUCCESS);
1375
1376 HcfBlob input = {
1377 .data = (uint8_t *)g_mockMessage,
1378 .len = 0
1379 };
1380 res = sign->update(sign, &input);
1381
1382 ASSERT_EQ(res, HCF_INVALID_PARAMS);
1383
1384 HcfObjDestroy(sign);
1385 }
1386
1387 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest401, TestSize.Level0)
1388 {
1389 HcfSign *sign = nullptr;
1390 int32_t res = HcfSignCreate("ECC|SHA1", &sign);
1391
1392 ASSERT_EQ(res, HCF_SUCCESS);
1393 ASSERT_NE(sign, nullptr);
1394
1395 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1396
1397 ASSERT_EQ(res, HCF_SUCCESS);
1398
1399 res = sign->update(sign, &g_mockInput);
1400
1401 ASSERT_EQ(res, HCF_SUCCESS);
1402
1403 HcfBlob out = { .data = nullptr, .len = 0 };
1404 res = sign->sign(sign, nullptr, &out);
1405
1406 ASSERT_EQ(res, HCF_SUCCESS);
1407 ASSERT_NE(out.data, nullptr);
1408 ASSERT_NE(out.len, (const unsigned int)0);
1409
1410 HcfFree(out.data);
1411 HcfObjDestroy(sign);
1412 }
1413
1414 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest402, TestSize.Level0)
1415 {
1416 HcfSign *sign = nullptr;
1417 int32_t res = HcfSignCreate("ECC|SHA224", &sign);
1418
1419 ASSERT_EQ(res, HCF_SUCCESS);
1420 ASSERT_NE(sign, nullptr);
1421
1422 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1423
1424 ASSERT_EQ(res, HCF_SUCCESS);
1425
1426 res = sign->update(sign, &g_mockInput);
1427
1428 ASSERT_EQ(res, HCF_SUCCESS);
1429
1430 HcfBlob out = { .data = nullptr, .len = 0 };
1431 res = sign->sign(sign, nullptr, &out);
1432
1433 ASSERT_EQ(res, HCF_SUCCESS);
1434 ASSERT_NE(out.data, nullptr);
1435 ASSERT_NE(out.len, (const unsigned int)0);
1436
1437 HcfFree(out.data);
1438 HcfObjDestroy(sign);
1439 }
1440
1441 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest403, TestSize.Level0)
1442 {
1443 HcfSign *sign = nullptr;
1444 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1445
1446 ASSERT_EQ(res, HCF_SUCCESS);
1447 ASSERT_NE(sign, nullptr);
1448
1449 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1450
1451 ASSERT_EQ(res, HCF_SUCCESS);
1452
1453 res = sign->update(sign, &g_mockInput);
1454
1455 ASSERT_EQ(res, HCF_SUCCESS);
1456
1457 HcfBlob out = { .data = nullptr, .len = 0 };
1458 res = sign->sign(sign, nullptr, &out);
1459
1460 ASSERT_EQ(res, HCF_SUCCESS);
1461 ASSERT_NE(out.data, nullptr);
1462 ASSERT_NE(out.len, (const unsigned int)0);
1463
1464 HcfFree(out.data);
1465 HcfObjDestroy(sign);
1466 }
1467
1468 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest404, TestSize.Level0)
1469 {
1470 HcfSign *sign = nullptr;
1471 int32_t res = HcfSignCreate("ECC|SHA384", &sign);
1472
1473 ASSERT_EQ(res, HCF_SUCCESS);
1474 ASSERT_NE(sign, nullptr);
1475
1476 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1477
1478 ASSERT_EQ(res, HCF_SUCCESS);
1479
1480 res = sign->update(sign, &g_mockInput);
1481
1482 ASSERT_EQ(res, HCF_SUCCESS);
1483
1484 HcfBlob out = { .data = nullptr, .len = 0 };
1485 res = sign->sign(sign, nullptr, &out);
1486
1487 ASSERT_EQ(res, HCF_SUCCESS);
1488 ASSERT_NE(out.data, nullptr);
1489 ASSERT_NE(out.len, (const unsigned int)0);
1490
1491 HcfFree(out.data);
1492 HcfObjDestroy(sign);
1493 }
1494
1495 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest405, TestSize.Level0)
1496 {
1497 HcfSign *sign = nullptr;
1498 int32_t res = HcfSignCreate("ECC|SHA512", &sign);
1499
1500 ASSERT_EQ(res, HCF_SUCCESS);
1501 ASSERT_NE(sign, nullptr);
1502
1503 res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
1504
1505 ASSERT_EQ(res, HCF_SUCCESS);
1506
1507 res = sign->update(sign, &g_mockInput);
1508
1509 ASSERT_EQ(res, HCF_SUCCESS);
1510
1511 HcfBlob out = { .data = nullptr, .len = 0 };
1512 res = sign->sign(sign, nullptr, &out);
1513
1514 ASSERT_EQ(res, HCF_SUCCESS);
1515 ASSERT_NE(out.data, nullptr);
1516 ASSERT_NE(out.len, (const unsigned int)0);
1517
1518 HcfFree(out.data);
1519 HcfObjDestroy(sign);
1520 }
1521
1522 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest406, TestSize.Level0)
1523 {
1524 HcfSign *sign = nullptr;
1525 int32_t res = HcfSignCreate("ECC|SHA1", &sign);
1526
1527 ASSERT_EQ(res, HCF_SUCCESS);
1528 ASSERT_NE(sign, nullptr);
1529
1530 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1531
1532 ASSERT_EQ(res, HCF_SUCCESS);
1533
1534 res = sign->update(sign, &g_mockInput);
1535
1536 ASSERT_EQ(res, HCF_SUCCESS);
1537
1538 HcfBlob out = { .data = nullptr, .len = 0 };
1539 res = sign->sign(sign, nullptr, &out);
1540
1541 ASSERT_EQ(res, HCF_SUCCESS);
1542 ASSERT_NE(out.data, nullptr);
1543 ASSERT_NE(out.len, (const unsigned int)0);
1544
1545 HcfFree(out.data);
1546 HcfObjDestroy(sign);
1547 }
1548
1549 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest407, TestSize.Level0)
1550 {
1551 HcfSign *sign = nullptr;
1552 int32_t res = HcfSignCreate("ECC|SHA224", &sign);
1553
1554 ASSERT_EQ(res, HCF_SUCCESS);
1555 ASSERT_NE(sign, nullptr);
1556
1557 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1558
1559 ASSERT_EQ(res, HCF_SUCCESS);
1560
1561 res = sign->update(sign, &g_mockInput);
1562
1563 ASSERT_EQ(res, HCF_SUCCESS);
1564
1565 HcfBlob out = { .data = nullptr, .len = 0 };
1566 res = sign->sign(sign, nullptr, &out);
1567
1568 ASSERT_EQ(res, HCF_SUCCESS);
1569 ASSERT_NE(out.data, nullptr);
1570 ASSERT_NE(out.len, (const unsigned int)0);
1571
1572 HcfFree(out.data);
1573 HcfObjDestroy(sign);
1574 }
1575
1576 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest408, TestSize.Level0)
1577 {
1578 HcfSign *sign = nullptr;
1579 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1580
1581 ASSERT_EQ(res, HCF_SUCCESS);
1582 ASSERT_NE(sign, nullptr);
1583
1584 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1585
1586 ASSERT_EQ(res, HCF_SUCCESS);
1587
1588 res = sign->update(sign, &g_mockInput);
1589
1590 ASSERT_EQ(res, HCF_SUCCESS);
1591
1592 HcfBlob out = { .data = nullptr, .len = 0 };
1593 res = sign->sign(sign, nullptr, &out);
1594
1595 ASSERT_EQ(res, HCF_SUCCESS);
1596 ASSERT_NE(out.data, nullptr);
1597 ASSERT_NE(out.len, (const unsigned int)0);
1598
1599 HcfFree(out.data);
1600 HcfObjDestroy(sign);
1601 }
1602
1603 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest409, TestSize.Level0)
1604 {
1605 HcfSign *sign = nullptr;
1606 int32_t res = HcfSignCreate("ECC|SHA384", &sign);
1607
1608 ASSERT_EQ(res, HCF_SUCCESS);
1609 ASSERT_NE(sign, nullptr);
1610
1611 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1612
1613 ASSERT_EQ(res, HCF_SUCCESS);
1614
1615 res = sign->update(sign, &g_mockInput);
1616
1617 ASSERT_EQ(res, HCF_SUCCESS);
1618
1619 HcfBlob out = { .data = nullptr, .len = 0 };
1620 res = sign->sign(sign, nullptr, &out);
1621
1622 ASSERT_EQ(res, HCF_SUCCESS);
1623 ASSERT_NE(out.data, nullptr);
1624 ASSERT_NE(out.len, (const unsigned int)0);
1625
1626 HcfFree(out.data);
1627 HcfObjDestroy(sign);
1628 }
1629
1630 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest410, TestSize.Level0)
1631 {
1632 HcfSign *sign = nullptr;
1633 int32_t res = HcfSignCreate("ECC|SHA512", &sign);
1634
1635 ASSERT_EQ(res, HCF_SUCCESS);
1636 ASSERT_NE(sign, nullptr);
1637
1638 res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1639
1640 ASSERT_EQ(res, HCF_SUCCESS);
1641
1642 res = sign->update(sign, &g_mockInput);
1643
1644 ASSERT_EQ(res, HCF_SUCCESS);
1645
1646 HcfBlob out = { .data = nullptr, .len = 0 };
1647 res = sign->sign(sign, nullptr, &out);
1648
1649 ASSERT_EQ(res, HCF_SUCCESS);
1650 ASSERT_NE(out.data, nullptr);
1651 ASSERT_NE(out.len, (const unsigned int)0);
1652
1653 HcfFree(out.data);
1654 HcfObjDestroy(sign);
1655 }
1656
1657 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest411, TestSize.Level0)
1658 {
1659 HcfSign *sign = nullptr;
1660 int32_t res = HcfSignCreate("ECC|SHA1", &sign);
1661
1662 ASSERT_EQ(res, HCF_SUCCESS);
1663 ASSERT_NE(sign, nullptr);
1664
1665 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1666
1667 ASSERT_EQ(res, HCF_SUCCESS);
1668
1669 res = sign->update(sign, &g_mockInput);
1670
1671 ASSERT_EQ(res, HCF_SUCCESS);
1672
1673 HcfBlob out = { .data = nullptr, .len = 0 };
1674 res = sign->sign(sign, nullptr, &out);
1675
1676 ASSERT_EQ(res, HCF_SUCCESS);
1677 ASSERT_NE(out.data, nullptr);
1678 ASSERT_NE(out.len, (const unsigned int)0);
1679
1680 HcfFree(out.data);
1681 HcfObjDestroy(sign);
1682 }
1683
1684 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest412, TestSize.Level0)
1685 {
1686 HcfSign *sign = nullptr;
1687 int32_t res = HcfSignCreate("ECC|SHA224", &sign);
1688
1689 ASSERT_EQ(res, HCF_SUCCESS);
1690 ASSERT_NE(sign, nullptr);
1691
1692 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1693
1694 ASSERT_EQ(res, HCF_SUCCESS);
1695
1696 res = sign->update(sign, &g_mockInput);
1697
1698 ASSERT_EQ(res, HCF_SUCCESS);
1699
1700 HcfBlob out = { .data = nullptr, .len = 0 };
1701 res = sign->sign(sign, nullptr, &out);
1702
1703 ASSERT_EQ(res, HCF_SUCCESS);
1704 ASSERT_NE(out.data, nullptr);
1705 ASSERT_NE(out.len, (const unsigned int)0);
1706
1707 HcfFree(out.data);
1708 HcfObjDestroy(sign);
1709 }
1710
1711 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest413, TestSize.Level0)
1712 {
1713 HcfSign *sign = nullptr;
1714 int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1715
1716 ASSERT_EQ(res, HCF_SUCCESS);
1717 ASSERT_NE(sign, nullptr);
1718
1719 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1720
1721 ASSERT_EQ(res, HCF_SUCCESS);
1722
1723 res = sign->update(sign, &g_mockInput);
1724
1725 ASSERT_EQ(res, HCF_SUCCESS);
1726
1727 HcfBlob out = { .data = nullptr, .len = 0 };
1728 res = sign->sign(sign, nullptr, &out);
1729
1730 ASSERT_EQ(res, HCF_SUCCESS);
1731 ASSERT_NE(out.data, nullptr);
1732 ASSERT_NE(out.len, (const unsigned int)0);
1733
1734 HcfFree(out.data);
1735 HcfObjDestroy(sign);
1736 }
1737
1738 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest414, TestSize.Level0)
1739 {
1740 HcfSign *sign = nullptr;
1741 int32_t res = HcfSignCreate("ECC|SHA384", &sign);
1742
1743 ASSERT_EQ(res, HCF_SUCCESS);
1744 ASSERT_NE(sign, nullptr);
1745
1746 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1747
1748 ASSERT_EQ(res, HCF_SUCCESS);
1749
1750 res = sign->update(sign, &g_mockInput);
1751
1752 ASSERT_EQ(res, HCF_SUCCESS);
1753
1754 HcfBlob out = { .data = nullptr, .len = 0 };
1755 res = sign->sign(sign, nullptr, &out);
1756
1757 ASSERT_EQ(res, HCF_SUCCESS);
1758 ASSERT_NE(out.data, nullptr);
1759 ASSERT_NE(out.len, (const unsigned int)0);
1760
1761 HcfFree(out.data);
1762 HcfObjDestroy(sign);
1763 }
1764
1765 HWTEST_F(CryptoEccNoLengthSignTest, CryptoEccNoLengthSignTest415, TestSize.Level0)
1766 {
1767 HcfSign *sign = nullptr;
1768 int32_t res = HcfSignCreate("ECC|SHA512", &sign);
1769
1770 ASSERT_EQ(res, HCF_SUCCESS);
1771 ASSERT_NE(sign, nullptr);
1772
1773 res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1774
1775 ASSERT_EQ(res, HCF_SUCCESS);
1776
1777 res = sign->update(sign, &g_mockInput);
1778
1779 ASSERT_EQ(res, HCF_SUCCESS);
1780
1781 HcfBlob out = { .data = nullptr, .len = 0 };
1782 res = sign->sign(sign, nullptr, &out);
1783
1784 ASSERT_EQ(res, HCF_SUCCESS);
1785 ASSERT_NE(out.data, nullptr);
1786 ASSERT_NE(out.len, (const unsigned int)0);
1787
1788 HcfFree(out.data);
1789 HcfObjDestroy(sign);
1790 }
1791 }
1792