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 CryptoEccNoLengthSignSubTest : 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 *CryptoEccNoLengthSignSubTest::ecc224KeyPair_ = nullptr;
55 HcfKeyPair *CryptoEccNoLengthSignSubTest::ecc256KeyPair_ = nullptr;
56 HcfKeyPair *CryptoEccNoLengthSignSubTest::ecc384KeyPair_ = nullptr;
57 HcfKeyPair *CryptoEccNoLengthSignSubTest::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 CryptoEccNoLengthSignSubTest::CryptoEccNoLengthSignTestSubEcc224(void)
217 {
218     HcfAsyKeyParamsSpec *paramSpec = nullptr;
219     int32_t res = ConstructEcc224KeyPairParamsSpec(&paramSpec);
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 CryptoEccNoLengthSignSubTest::CryptoEccNoLengthSignTestSubEcc256(void)
238 {
239     HcfAsyKeyParamsSpec *paramSpec = nullptr;
240     int32_t res = ConstructEcc256KeyPairParamsSpec(&paramSpec);
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 CryptoEccNoLengthSignSubTest::CryptoEccNoLengthSignTestSubEcc384(void)
259 {
260     HcfAsyKeyParamsSpec *paramSpec = nullptr;
261     int32_t res = ConstructEcc384KeyPairParamsSpec(&paramSpec);
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 CryptoEccNoLengthSignSubTest::CryptoEccNoLengthSignTestSubEcc521(void)
279 {
280     HcfAsyKeyParamsSpec *paramSpec = nullptr;
281     int32_t res = ConstructEcc521KeyPairParamsSpec(&paramSpec);
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 CryptoEccNoLengthSignSubTest::SetUpTestCase()
299 {
300     CryptoEccNoLengthSignTestSubEcc224();
301     CryptoEccNoLengthSignTestSubEcc256();
302     CryptoEccNoLengthSignTestSubEcc384();
303     CryptoEccNoLengthSignTestSubEcc521();
304 }
305 
TearDownTestCase()306 void CryptoEccNoLengthSignSubTest::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(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest416, 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     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
333 
334     ASSERT_EQ(res, HCF_SUCCESS);
335 
336     res = sign->update(sign, &g_mockInput);
337 
338     ASSERT_EQ(res, HCF_SUCCESS);
339 
340     HcfBlob out = { .data = nullptr, .len = 0 };
341     res = sign->sign(sign, nullptr, &out);
342 
343     ASSERT_EQ(res, HCF_SUCCESS);
344     ASSERT_NE(out.data, nullptr);
345     ASSERT_NE(out.len, (const unsigned int)0);
346 
347     HcfFree(out.data);
348     HcfObjDestroy(sign);
349 }
350 
351 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest417, TestSize.Level0)
352 {
353     HcfSign *sign = nullptr;
354     int32_t res = HcfSignCreate("ECC|SHA224", &sign);
355 
356     ASSERT_EQ(res, HCF_SUCCESS);
357     ASSERT_NE(sign, nullptr);
358 
359     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
360 
361     ASSERT_EQ(res, HCF_SUCCESS);
362 
363     res = sign->update(sign, &g_mockInput);
364 
365     ASSERT_EQ(res, HCF_SUCCESS);
366 
367     HcfBlob out = { .data = nullptr, .len = 0 };
368     res = sign->sign(sign, nullptr, &out);
369 
370     ASSERT_EQ(res, HCF_SUCCESS);
371     ASSERT_NE(out.data, nullptr);
372     ASSERT_NE(out.len, (const unsigned int)0);
373 
374     HcfFree(out.data);
375     HcfObjDestroy(sign);
376 }
377 
378 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest418, TestSize.Level0)
379 {
380     HcfSign *sign = nullptr;
381     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
382 
383     ASSERT_EQ(res, HCF_SUCCESS);
384     ASSERT_NE(sign, nullptr);
385 
386     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
387 
388     ASSERT_EQ(res, HCF_SUCCESS);
389 
390     res = sign->update(sign, &g_mockInput);
391 
392     ASSERT_EQ(res, HCF_SUCCESS);
393 
394     HcfBlob out = { .data = nullptr, .len = 0 };
395     res = sign->sign(sign, nullptr, &out);
396 
397     ASSERT_EQ(res, HCF_SUCCESS);
398     ASSERT_NE(out.data, nullptr);
399     ASSERT_NE(out.len, (const unsigned int)0);
400 
401     HcfFree(out.data);
402     HcfObjDestroy(sign);
403 }
404 
405 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest419, TestSize.Level0)
406 {
407     HcfSign *sign = nullptr;
408     int32_t res = HcfSignCreate("ECC|SHA384", &sign);
409 
410     ASSERT_EQ(res, HCF_SUCCESS);
411     ASSERT_NE(sign, nullptr);
412 
413     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
414 
415     ASSERT_EQ(res, HCF_SUCCESS);
416 
417     res = sign->update(sign, &g_mockInput);
418 
419     ASSERT_EQ(res, HCF_SUCCESS);
420 
421     HcfBlob out = { .data = nullptr, .len = 0 };
422     res = sign->sign(sign, nullptr, &out);
423 
424     ASSERT_EQ(res, HCF_SUCCESS);
425     ASSERT_NE(out.data, nullptr);
426     ASSERT_NE(out.len, (const unsigned int)0);
427 
428     HcfFree(out.data);
429     HcfObjDestroy(sign);
430 }
431 
432 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest420, TestSize.Level0)
433 {
434     HcfSign *sign = nullptr;
435     int32_t res = HcfSignCreate("ECC|SHA512", &sign);
436 
437     ASSERT_EQ(res, HCF_SUCCESS);
438     ASSERT_NE(sign, nullptr);
439 
440     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
441 
442     ASSERT_EQ(res, HCF_SUCCESS);
443 
444     res = sign->update(sign, &g_mockInput);
445 
446     ASSERT_EQ(res, HCF_SUCCESS);
447 
448     HcfBlob out = { .data = nullptr, .len = 0 };
449     res = sign->sign(sign, nullptr, &out);
450 
451     ASSERT_EQ(res, HCF_SUCCESS);
452     ASSERT_NE(out.data, nullptr);
453     ASSERT_NE(out.len, (const unsigned int)0);
454 
455     HcfFree(out.data);
456     HcfObjDestroy(sign);
457 }
458 
459 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest421, TestSize.Level0)
460 {
461     HcfSign *sign = nullptr;
462     int32_t res = HcfSignCreate("ECC|SHA1", &sign);
463 
464     ASSERT_EQ(res, HCF_SUCCESS);
465     ASSERT_NE(sign, nullptr);
466 
467     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
468 
469     ASSERT_EQ(res, HCF_SUCCESS);
470 
471     HcfBlob out = { .data = nullptr, .len = 0 };
472     res = sign->sign(sign, &g_mockInput, &out);
473 
474     ASSERT_EQ(res, HCF_SUCCESS);
475     ASSERT_NE(out.data, nullptr);
476     ASSERT_NE(out.len, (const unsigned int)0);
477 
478     HcfFree(out.data);
479     HcfObjDestroy(sign);
480 }
481 
482 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest422, TestSize.Level0)
483 {
484     HcfSign *sign = nullptr;
485     int32_t res = HcfSignCreate("ECC|SHA224", &sign);
486 
487     ASSERT_EQ(res, HCF_SUCCESS);
488     ASSERT_NE(sign, nullptr);
489 
490     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
491 
492     ASSERT_EQ(res, HCF_SUCCESS);
493 
494     HcfBlob out = { .data = nullptr, .len = 0 };
495     res = sign->sign(sign, &g_mockInput, &out);
496 
497     ASSERT_EQ(res, HCF_SUCCESS);
498     ASSERT_NE(out.data, nullptr);
499     ASSERT_NE(out.len, (const unsigned int)0);
500 
501     HcfFree(out.data);
502     HcfObjDestroy(sign);
503 }
504 
505 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest423, TestSize.Level0)
506 {
507     HcfSign *sign = nullptr;
508     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
509 
510     ASSERT_EQ(res, HCF_SUCCESS);
511     ASSERT_NE(sign, nullptr);
512 
513     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
514 
515     ASSERT_EQ(res, HCF_SUCCESS);
516 
517     HcfBlob out = { .data = nullptr, .len = 0 };
518     res = sign->sign(sign, &g_mockInput, &out);
519 
520     ASSERT_EQ(res, HCF_SUCCESS);
521     ASSERT_NE(out.data, nullptr);
522     ASSERT_NE(out.len, (const unsigned int)0);
523 
524     HcfFree(out.data);
525     HcfObjDestroy(sign);
526 }
527 
528 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest424, TestSize.Level0)
529 {
530     HcfSign *sign = nullptr;
531     int32_t res = HcfSignCreate("ECC|SHA384", &sign);
532 
533     ASSERT_EQ(res, HCF_SUCCESS);
534     ASSERT_NE(sign, nullptr);
535 
536     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
537 
538     ASSERT_EQ(res, HCF_SUCCESS);
539 
540     HcfBlob out = { .data = nullptr, .len = 0 };
541     res = sign->sign(sign, &g_mockInput, &out);
542 
543     ASSERT_EQ(res, HCF_SUCCESS);
544     ASSERT_NE(out.data, nullptr);
545     ASSERT_NE(out.len, (const unsigned int)0);
546 
547     HcfFree(out.data);
548     HcfObjDestroy(sign);
549 }
550 
551 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest425, TestSize.Level0)
552 {
553     HcfSign *sign = nullptr;
554     int32_t res = HcfSignCreate("ECC|SHA512", &sign);
555 
556     ASSERT_EQ(res, HCF_SUCCESS);
557     ASSERT_NE(sign, nullptr);
558 
559     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
560 
561     ASSERT_EQ(res, HCF_SUCCESS);
562 
563     HcfBlob out = { .data = nullptr, .len = 0 };
564     res = sign->sign(sign, &g_mockInput, &out);
565 
566     ASSERT_EQ(res, HCF_SUCCESS);
567     ASSERT_NE(out.data, nullptr);
568     ASSERT_NE(out.len, (const unsigned int)0);
569 
570     HcfFree(out.data);
571     HcfObjDestroy(sign);
572 }
573 
574 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest426, TestSize.Level0)
575 {
576     HcfSign *sign = nullptr;
577     int32_t res = HcfSignCreate("ECC|SHA1", &sign);
578 
579     ASSERT_EQ(res, HCF_SUCCESS);
580     ASSERT_NE(sign, nullptr);
581 
582     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
583 
584     ASSERT_EQ(res, HCF_SUCCESS);
585 
586     HcfBlob out = { .data = nullptr, .len = 0 };
587     res = sign->sign(sign, &g_mockInput, &out);
588 
589     ASSERT_EQ(res, HCF_SUCCESS);
590     ASSERT_NE(out.data, nullptr);
591     ASSERT_NE(out.len, (const unsigned int)0);
592 
593     HcfFree(out.data);
594     HcfObjDestroy(sign);
595 }
596 
597 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest427, TestSize.Level0)
598 {
599     HcfSign *sign = nullptr;
600     int32_t res = HcfSignCreate("ECC|SHA224", &sign);
601 
602     ASSERT_EQ(res, HCF_SUCCESS);
603     ASSERT_NE(sign, nullptr);
604 
605     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
606 
607     ASSERT_EQ(res, HCF_SUCCESS);
608 
609     HcfBlob out = { .data = nullptr, .len = 0 };
610     res = sign->sign(sign, &g_mockInput, &out);
611 
612     ASSERT_EQ(res, HCF_SUCCESS);
613     ASSERT_NE(out.data, nullptr);
614     ASSERT_NE(out.len, (const unsigned int)0);
615 
616     HcfFree(out.data);
617     HcfObjDestroy(sign);
618 }
619 
620 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest428, TestSize.Level0)
621 {
622     HcfSign *sign = nullptr;
623     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
624 
625     ASSERT_EQ(res, HCF_SUCCESS);
626     ASSERT_NE(sign, nullptr);
627 
628     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
629 
630     ASSERT_EQ(res, HCF_SUCCESS);
631 
632     HcfBlob out = { .data = nullptr, .len = 0 };
633     res = sign->sign(sign, &g_mockInput, &out);
634 
635     ASSERT_EQ(res, HCF_SUCCESS);
636     ASSERT_NE(out.data, nullptr);
637     ASSERT_NE(out.len, (const unsigned int)0);
638 
639     HcfFree(out.data);
640     HcfObjDestroy(sign);
641 }
642 
643 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest429, TestSize.Level0)
644 {
645     HcfSign *sign = nullptr;
646     int32_t res = HcfSignCreate("ECC|SHA384", &sign);
647 
648     ASSERT_EQ(res, HCF_SUCCESS);
649     ASSERT_NE(sign, nullptr);
650 
651     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
652 
653     ASSERT_EQ(res, HCF_SUCCESS);
654 
655     HcfBlob out = { .data = nullptr, .len = 0 };
656     res = sign->sign(sign, &g_mockInput, &out);
657 
658     ASSERT_EQ(res, HCF_SUCCESS);
659     ASSERT_NE(out.data, nullptr);
660     ASSERT_NE(out.len, (const unsigned int)0);
661 
662     HcfFree(out.data);
663     HcfObjDestroy(sign);
664 }
665 
666 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest430, TestSize.Level0)
667 {
668     HcfSign *sign = nullptr;
669     int32_t res = HcfSignCreate("ECC|SHA512", &sign);
670 
671     ASSERT_EQ(res, HCF_SUCCESS);
672     ASSERT_NE(sign, nullptr);
673 
674     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
675 
676     ASSERT_EQ(res, HCF_SUCCESS);
677 
678     HcfBlob out = { .data = nullptr, .len = 0 };
679     res = sign->sign(sign, &g_mockInput, &out);
680 
681     ASSERT_EQ(res, HCF_SUCCESS);
682     ASSERT_NE(out.data, nullptr);
683     ASSERT_NE(out.len, (const unsigned int)0);
684 
685     HcfFree(out.data);
686     HcfObjDestroy(sign);
687 }
688 
689 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest431, TestSize.Level0)
690 {
691     HcfSign *sign = nullptr;
692     int32_t res = HcfSignCreate("ECC|SHA1", &sign);
693 
694     ASSERT_EQ(res, HCF_SUCCESS);
695     ASSERT_NE(sign, nullptr);
696 
697     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
698 
699     ASSERT_EQ(res, HCF_SUCCESS);
700 
701     HcfBlob out = { .data = nullptr, .len = 0 };
702     res = sign->sign(sign, &g_mockInput, &out);
703 
704     ASSERT_EQ(res, HCF_SUCCESS);
705     ASSERT_NE(out.data, nullptr);
706     ASSERT_NE(out.len, (const unsigned int)0);
707 
708     HcfFree(out.data);
709     HcfObjDestroy(sign);
710 }
711 
712 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest432, TestSize.Level0)
713 {
714     HcfSign *sign = nullptr;
715     int32_t res = HcfSignCreate("ECC|SHA224", &sign);
716 
717     ASSERT_EQ(res, HCF_SUCCESS);
718     ASSERT_NE(sign, nullptr);
719 
720     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
721 
722     ASSERT_EQ(res, HCF_SUCCESS);
723 
724     HcfBlob out = { .data = nullptr, .len = 0 };
725     res = sign->sign(sign, &g_mockInput, &out);
726 
727     ASSERT_EQ(res, HCF_SUCCESS);
728     ASSERT_NE(out.data, nullptr);
729     ASSERT_NE(out.len, (const unsigned int)0);
730 
731     HcfFree(out.data);
732     HcfObjDestroy(sign);
733 }
734 
735 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest433, TestSize.Level0)
736 {
737     HcfSign *sign = nullptr;
738     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
739 
740     ASSERT_EQ(res, HCF_SUCCESS);
741     ASSERT_NE(sign, nullptr);
742 
743     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
744 
745     ASSERT_EQ(res, HCF_SUCCESS);
746 
747     HcfBlob out = { .data = nullptr, .len = 0 };
748     res = sign->sign(sign, &g_mockInput, &out);
749 
750     ASSERT_EQ(res, HCF_SUCCESS);
751     ASSERT_NE(out.data, nullptr);
752     ASSERT_NE(out.len, (const unsigned int)0);
753 
754     HcfFree(out.data);
755     HcfObjDestroy(sign);
756 }
757 
758 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest434, TestSize.Level0)
759 {
760     HcfSign *sign = nullptr;
761     int32_t res = HcfSignCreate("ECC|SHA384", &sign);
762 
763     ASSERT_EQ(res, HCF_SUCCESS);
764     ASSERT_NE(sign, nullptr);
765 
766     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
767 
768     ASSERT_EQ(res, HCF_SUCCESS);
769 
770     HcfBlob out = { .data = nullptr, .len = 0 };
771     res = sign->sign(sign, &g_mockInput, &out);
772 
773     ASSERT_EQ(res, HCF_SUCCESS);
774     ASSERT_NE(out.data, nullptr);
775     ASSERT_NE(out.len, (const unsigned int)0);
776 
777     HcfFree(out.data);
778     HcfObjDestroy(sign);
779 }
780 
781 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest435, TestSize.Level0)
782 {
783     HcfSign *sign = nullptr;
784     int32_t res = HcfSignCreate("ECC|SHA512", &sign);
785 
786     ASSERT_EQ(res, HCF_SUCCESS);
787     ASSERT_NE(sign, nullptr);
788 
789     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
790 
791     ASSERT_EQ(res, HCF_SUCCESS);
792 
793     HcfBlob out = { .data = nullptr, .len = 0 };
794     res = sign->sign(sign, &g_mockInput, &out);
795 
796     ASSERT_EQ(res, HCF_SUCCESS);
797     ASSERT_NE(out.data, nullptr);
798     ASSERT_NE(out.len, (const unsigned int)0);
799 
800     HcfFree(out.data);
801     HcfObjDestroy(sign);
802 }
803 
804 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest436, TestSize.Level0)
805 {
806     HcfSign *sign = nullptr;
807     int32_t res = HcfSignCreate("ECC|SHA1", &sign);
808 
809     ASSERT_EQ(res, HCF_SUCCESS);
810     ASSERT_NE(sign, nullptr);
811 
812     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
813 
814     ASSERT_EQ(res, HCF_SUCCESS);
815 
816     HcfBlob out = { .data = nullptr, .len = 0 };
817     res = sign->sign(sign, &g_mockInput, &out);
818 
819     ASSERT_EQ(res, HCF_SUCCESS);
820     ASSERT_NE(out.data, nullptr);
821     ASSERT_NE(out.len, (const unsigned int)0);
822 
823     HcfFree(out.data);
824     HcfObjDestroy(sign);
825 }
826 
827 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest437, TestSize.Level0)
828 {
829     HcfSign *sign = nullptr;
830     int32_t res = HcfSignCreate("ECC|SHA224", &sign);
831 
832     ASSERT_EQ(res, HCF_SUCCESS);
833     ASSERT_NE(sign, nullptr);
834 
835     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
836 
837     ASSERT_EQ(res, HCF_SUCCESS);
838 
839     HcfBlob out = { .data = nullptr, .len = 0 };
840     res = sign->sign(sign, &g_mockInput, &out);
841 
842     ASSERT_EQ(res, HCF_SUCCESS);
843     ASSERT_NE(out.data, nullptr);
844     ASSERT_NE(out.len, (const unsigned int)0);
845 
846     HcfFree(out.data);
847     HcfObjDestroy(sign);
848 }
849 
850 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest438, TestSize.Level0)
851 {
852     HcfSign *sign = nullptr;
853     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
854 
855     ASSERT_EQ(res, HCF_SUCCESS);
856     ASSERT_NE(sign, nullptr);
857 
858     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
859 
860     ASSERT_EQ(res, HCF_SUCCESS);
861 
862     HcfBlob out = { .data = nullptr, .len = 0 };
863     res = sign->sign(sign, &g_mockInput, &out);
864 
865     ASSERT_EQ(res, HCF_SUCCESS);
866     ASSERT_NE(out.data, nullptr);
867     ASSERT_NE(out.len, (const unsigned int)0);
868 
869     HcfFree(out.data);
870     HcfObjDestroy(sign);
871 }
872 
873 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest439, TestSize.Level0)
874 {
875     HcfSign *sign = nullptr;
876     int32_t res = HcfSignCreate("ECC|SHA384", &sign);
877 
878     ASSERT_EQ(res, HCF_SUCCESS);
879     ASSERT_NE(sign, nullptr);
880 
881     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
882 
883     ASSERT_EQ(res, HCF_SUCCESS);
884 
885     HcfBlob out = { .data = nullptr, .len = 0 };
886     res = sign->sign(sign, &g_mockInput, &out);
887 
888     ASSERT_EQ(res, HCF_SUCCESS);
889     ASSERT_NE(out.data, nullptr);
890     ASSERT_NE(out.len, (const unsigned int)0);
891 
892     HcfFree(out.data);
893     HcfObjDestroy(sign);
894 }
895 
896 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest440, TestSize.Level0)
897 {
898     HcfSign *sign = nullptr;
899     int32_t res = HcfSignCreate("ECC|SHA512", &sign);
900 
901     ASSERT_EQ(res, HCF_SUCCESS);
902     ASSERT_NE(sign, nullptr);
903 
904     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
905 
906     ASSERT_EQ(res, HCF_SUCCESS);
907 
908     HcfBlob out = { .data = nullptr, .len = 0 };
909     res = sign->sign(sign, &g_mockInput, &out);
910 
911     ASSERT_EQ(res, HCF_SUCCESS);
912     ASSERT_NE(out.data, nullptr);
913     ASSERT_NE(out.len, (const unsigned int)0);
914 
915     HcfFree(out.data);
916     HcfObjDestroy(sign);
917 }
918 
919 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest441, TestSize.Level0)
920 {
921     HcfSign *sign = nullptr;
922     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
923 
924     ASSERT_EQ(res, HCF_SUCCESS);
925     ASSERT_NE(sign, nullptr);
926 
927     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
928 
929     ASSERT_EQ(res, HCF_SUCCESS);
930 
931     res = sign->update(sign, &g_mockInput);
932 
933     ASSERT_EQ(res, HCF_SUCCESS);
934 
935     HcfBlob out = { .data = nullptr, .len = 0 };
936     res = sign->sign(nullptr, nullptr, &out);
937 
938     ASSERT_EQ(res, HCF_INVALID_PARAMS);
939 
940     HcfObjDestroy(sign);
941 }
942 
943 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest442, TestSize.Level0)
944 {
945     HcfSign *sign = nullptr;
946     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
947 
948     ASSERT_EQ(res, HCF_SUCCESS);
949     ASSERT_NE(sign, nullptr);
950 
951     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
952 
953     ASSERT_EQ(res, HCF_SUCCESS);
954 
955     res = sign->update(sign, &g_mockInput);
956 
957     ASSERT_EQ(res, HCF_SUCCESS);
958 
959     HcfBlob out = { .data = nullptr, .len = 0 };
960     res = sign->sign((HcfSign *)(&obj), nullptr, &out);
961 
962     ASSERT_EQ(res, HCF_INVALID_PARAMS);
963 
964     HcfObjDestroy(sign);
965 }
966 
967 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest443, TestSize.Level0)
968 {
969     HcfSign *sign = nullptr;
970     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
971 
972     ASSERT_EQ(res, HCF_SUCCESS);
973     ASSERT_NE(sign, nullptr);
974 
975     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
976 
977     ASSERT_EQ(res, HCF_SUCCESS);
978 
979     HcfBlob out = { .data = nullptr, .len = 0 };
980     res = sign->sign(sign, nullptr, &out);
981 
982     ASSERT_EQ(res, HCF_INVALID_PARAMS);
983 
984     HcfObjDestroy(sign);
985 }
986 
987 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest444, TestSize.Level0)
988 {
989     HcfSign *sign = nullptr;
990     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
991 
992     ASSERT_EQ(res, HCF_SUCCESS);
993     ASSERT_NE(sign, nullptr);
994 
995     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
996 
997     ASSERT_EQ(res, HCF_SUCCESS);
998 
999     HcfBlob input = {
1000         .data = nullptr,
1001         .len = 1
1002     };
1003     HcfBlob out = { .data = nullptr, .len = 0 };
1004     res = sign->sign(sign, &input, &out);
1005 
1006     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1007 
1008     HcfObjDestroy(sign);
1009 }
1010 
1011 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest445, TestSize.Level0)
1012 {
1013     HcfSign *sign = nullptr;
1014     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1015 
1016     ASSERT_EQ(res, HCF_SUCCESS);
1017     ASSERT_NE(sign, nullptr);
1018 
1019     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1020 
1021     ASSERT_EQ(res, HCF_SUCCESS);
1022 
1023     HcfBlob input = {
1024         .data = (uint8_t *)g_mockMessage,
1025         .len = 0
1026     };
1027     HcfBlob out = { .data = nullptr, .len = 0 };
1028     res = sign->sign(sign, &input, &out);
1029 
1030     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1031 
1032     HcfObjDestroy(sign);
1033 }
1034 
1035 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest446, TestSize.Level0)
1036 {
1037     HcfSign *sign = nullptr;
1038     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1039 
1040     ASSERT_EQ(res, HCF_SUCCESS);
1041     ASSERT_NE(sign, nullptr);
1042 
1043     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1044 
1045     ASSERT_EQ(res, HCF_SUCCESS);
1046 
1047     res = sign->update(sign, &g_mockInput);
1048 
1049     ASSERT_EQ(res, HCF_SUCCESS);
1050 
1051     res = sign->sign(sign, nullptr, nullptr);
1052 
1053     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1054 
1055     HcfObjDestroy(sign);
1056 }
1057 
1058 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest447, TestSize.Level0)
1059 {
1060     HcfSign *sign = nullptr;
1061     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1062 
1063     ASSERT_EQ(res, HCF_SUCCESS);
1064     ASSERT_NE(sign, nullptr);
1065 
1066     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1067 
1068     ASSERT_EQ(res, HCF_SUCCESS);
1069 
1070     const char *message = "hello world";
1071     HcfBlob input = {
1072         .data = (uint8_t *)message,
1073         .len = 12
1074     };
1075     res = sign->update(sign, &input);
1076 
1077     ASSERT_EQ(res, HCF_SUCCESS);
1078 
1079     HcfBlob out = { .data = nullptr, .len = 0 };
1080     res = sign->sign(sign, nullptr, &out);
1081 
1082     ASSERT_EQ(res, HCF_SUCCESS);
1083     ASSERT_NE(out.data, nullptr);
1084     ASSERT_NE(out.len, (const unsigned int)0);
1085 
1086     res = sign->update(sign, &input);
1087 
1088     ASSERT_EQ(res, HCF_SUCCESS);
1089 
1090     HcfBlob out2 = { .data = nullptr, .len = 0 };
1091     res = sign->sign(sign, nullptr, &out2);
1092 
1093     HcfVerify *verify = nullptr;
1094     res = HcfVerifyCreate("ECC|SHA256", &verify);
1095     ASSERT_EQ(res, HCF_SUCCESS);
1096     ASSERT_NE(verify, nullptr);
1097 
1098     verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1099     ASSERT_EQ(res, HCF_SUCCESS);
1100 
1101     verify->update(verify, &input);
1102     ASSERT_EQ(res, HCF_SUCCESS);
1103 
1104     bool flag = verify->verify(verify, nullptr, &out);
1105     ASSERT_EQ(flag, true);
1106 
1107     verify->update(verify, &input);
1108     ASSERT_EQ(res, HCF_SUCCESS);
1109 
1110     flag = verify->verify(verify, nullptr, &out2);
1111     ASSERT_EQ(flag, true);
1112 
1113     HcfFree(out.data);
1114     HcfFree(out2.data);
1115     HcfObjDestroy(sign);
1116     HcfObjDestroy(verify);
1117 }
1118 
1119 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest448, TestSize.Level0)
1120 {
1121     HcfSign *sign = nullptr;
1122     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1123 
1124     ASSERT_EQ(res, HCF_SUCCESS);
1125     ASSERT_NE(sign, nullptr);
1126 
1127     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1128 
1129     ASSERT_EQ(res, HCF_SUCCESS);
1130 
1131     const char *message = "hello world";
1132     HcfBlob input = {
1133         .data = (uint8_t *)message,
1134         .len = 12
1135     };
1136     res = sign->update(sign, &input);
1137 
1138     ASSERT_EQ(res, HCF_SUCCESS);
1139 
1140     res = sign->update(sign, &input);
1141 
1142     ASSERT_EQ(res, HCF_SUCCESS);
1143 
1144     HcfBlob out2 = { .data = nullptr, .len = 0 };
1145     res = sign->sign(sign, nullptr, &out2);
1146 
1147     HcfFree(out2.data);
1148     HcfObjDestroy(sign);
1149 }
1150 
1151 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest927, TestSize.Level0)
1152 {
1153     HcfAsyKeyGenerator *generator = nullptr;
1154     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1155     ASSERT_EQ(res, HCF_SUCCESS);
1156     ASSERT_NE(generator, nullptr);
1157 
1158     HcfKeyPair *keyPair = nullptr;
1159     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1160     ASSERT_EQ(res, HCF_SUCCESS);
1161     ASSERT_NE(keyPair, nullptr);
1162 
1163     HcfObjDestroy(generator);
1164 
1165     HcfSign *sign = nullptr;
1166     res = HcfSignCreate("ECC|SHA256", &sign);
1167     ASSERT_EQ(res, HCF_SUCCESS);
1168     ASSERT_NE(sign, nullptr);
1169 
1170     HcfParamsSpec params;
1171     res = sign->init(sign, &params, keyPair->priKey);
1172     ASSERT_EQ(res, HCF_SUCCESS);
1173 
1174     const char *message = "hello world";
1175     HcfBlob input = {
1176         .data = (uint8_t *)message,
1177         .len = 12
1178     };
1179 
1180     HcfBlob out = { .data = nullptr, .len = 0 };
1181     res = sign->sign(sign, &input, &out);
1182     ASSERT_EQ(res, HCF_SUCCESS);
1183     ASSERT_NE(out.data, nullptr);
1184     ASSERT_NE(out.len, (const unsigned int)0);
1185 
1186     HcfFree(out.data);
1187     HcfObjDestroy(sign);
1188 }
1189 
1190 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest928, TestSize.Level0)
1191 {
1192     HcfAsyKeyGenerator *generator = nullptr;
1193     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1194     ASSERT_EQ(res, HCF_SUCCESS);
1195     ASSERT_NE(generator, nullptr);
1196 
1197     HcfKeyPair *keyPair = nullptr;
1198     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1199     ASSERT_EQ(res, HCF_SUCCESS);
1200     ASSERT_NE(keyPair, nullptr);
1201 
1202     HcfObjDestroy(generator);
1203 
1204     HcfSign *sign = nullptr;
1205     res = HcfSignCreate("ECC|SHA256", &sign);
1206     ASSERT_EQ(res, HCF_SUCCESS);
1207     ASSERT_NE(sign, nullptr);
1208 
1209     HcfParamsSpec params;
1210     res = sign->init(sign, &params, keyPair->priKey);
1211     ASSERT_EQ(res, HCF_SUCCESS);
1212 
1213     const char *message = "hello world";
1214     HcfBlob input = {
1215         .data = (uint8_t *)message,
1216         .len = 12
1217     };
1218     res = sign->update(sign, &input);
1219     ASSERT_EQ(res, HCF_SUCCESS);
1220 
1221     HcfBlob out = { .data = nullptr, .len = 0 };
1222     res = sign->sign(sign, nullptr, &out);
1223     ASSERT_EQ(res, HCF_SUCCESS);
1224     ASSERT_NE(out.data, nullptr);
1225     ASSERT_NE(out.len, (const unsigned int)0);
1226 
1227     HcfFree(out.data);
1228     HcfObjDestroy(sign);
1229 }
1230 
1231 HcfSignatureParams g_params = {
1232     .algo = HCF_ALG_ECC,
1233     .padding = HCF_ALG_NOPADDING,
1234     .md = HCF_OPENSSL_DIGEST_SHA256,
1235     .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1236 };
1237 
1238 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest1001, TestSize.Level0)
1239 {
1240     int32_t res = HcfSignSpiEcdsaCreate(&g_params, nullptr);
1241 
1242     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1243 }
1244 
1245 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest1003, TestSize.Level0)
1246 {
1247     HcfSignSpi *spiObj = nullptr;
1248     int32_t res = HcfSignSpiEcdsaCreate(&g_params, &spiObj);
1249 
1250     ASSERT_EQ(res, HCF_SUCCESS);
1251     ASSERT_NE(spiObj, nullptr);
1252 
1253     res = spiObj->engineInit((HcfSignSpi *)&obj, nullptr, ecc256KeyPair_->priKey);
1254     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1255 
1256     HcfObjDestroy(spiObj);
1257 }
1258 
1259 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest1004, TestSize.Level0)
1260 {
1261     HcfSignSpi *spiObj = nullptr;
1262     int32_t res = HcfSignSpiEcdsaCreate(&g_params, &spiObj);
1263 
1264     ASSERT_EQ(res, HCF_SUCCESS);
1265     ASSERT_NE(spiObj, nullptr);
1266 
1267     res = spiObj->engineInit(spiObj, nullptr, (HcfPriKey *)&obj);
1268     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1269 
1270     HcfObjDestroy(spiObj);
1271 }
1272 
1273 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest1005, TestSize.Level0)
1274 {
1275     HcfSignSpi *spiObj = nullptr;
1276     int32_t res = HcfSignSpiEcdsaCreate(&g_params, &spiObj);
1277 
1278     ASSERT_EQ(res, HCF_SUCCESS);
1279     ASSERT_NE(spiObj, nullptr);
1280 
1281     const char *message = "hello world";
1282     HcfBlob input = {
1283         .data = (uint8_t *)message,
1284         .len = 12
1285     };
1286     res = spiObj->engineUpdate(nullptr, &input);
1287     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1288 
1289     HcfObjDestroy(spiObj);
1290 }
1291 
1292 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest1006, TestSize.Level0)
1293 {
1294     HcfSignSpi *spiObj = nullptr;
1295     int32_t res = HcfSignSpiEcdsaCreate(&g_params, &spiObj);
1296 
1297     ASSERT_EQ(res, HCF_SUCCESS);
1298     ASSERT_NE(spiObj, nullptr);
1299 
1300     const char *message = "hello world";
1301     HcfBlob input = {
1302         .data = (uint8_t *)message,
1303         .len = 12
1304     };
1305     res = spiObj->engineUpdate((HcfSignSpi *)&obj, &input);
1306     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1307 
1308     HcfObjDestroy(spiObj);
1309 }
1310 
1311 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest1007, TestSize.Level0)
1312 {
1313     HcfSignSpi *spiObj = nullptr;
1314     int32_t res = HcfSignSpiEcdsaCreate(&g_params, &spiObj);
1315 
1316     ASSERT_EQ(res, HCF_SUCCESS);
1317     ASSERT_NE(spiObj, nullptr);
1318 
1319     res = spiObj->engineUpdate(spiObj, nullptr);
1320     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1321 
1322     HcfObjDestroy(spiObj);
1323 }
1324 
1325 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest1008, TestSize.Level0)
1326 {
1327     HcfSignSpi *spiObj = nullptr;
1328     int32_t res = HcfSignSpiEcdsaCreate(&g_params, &spiObj);
1329 
1330     ASSERT_EQ(res, HCF_SUCCESS);
1331     ASSERT_NE(spiObj, nullptr);
1332 
1333     const char *message = "hello world";
1334     HcfBlob input = {
1335         .data = (uint8_t *)message,
1336         .len = 12
1337     };
1338     HcfBlob out = { .data = nullptr, .len = 0 };
1339     res = spiObj->engineSign((HcfSignSpi *)&obj, &input, &out);
1340     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1341 
1342     HcfObjDestroy(spiObj);
1343 }
1344 
1345 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest1009, TestSize.Level0)
1346 {
1347     HcfSignSpi *spiObj = nullptr;
1348     int32_t res = HcfSignSpiEcdsaCreate(&g_params, &spiObj);
1349 
1350     ASSERT_EQ(res, HCF_SUCCESS);
1351     ASSERT_NE(spiObj, nullptr);
1352 
1353     spiObj->base.destroy(nullptr);
1354 
1355     HcfObjDestroy(spiObj);
1356 }
1357 
1358 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest1010, TestSize.Level0)
1359 {
1360     HcfSignSpi *spiObj = nullptr;
1361     int32_t res = HcfSignSpiEcdsaCreate(&g_params, &spiObj);
1362 
1363     ASSERT_EQ(res, HCF_SUCCESS);
1364     ASSERT_NE(spiObj, nullptr);
1365 
1366     spiObj->base.destroy(&obj);
1367 
1368     HcfObjDestroy(spiObj);
1369 }
1370 
MemoryMallocTestFunc(uint32_t mallocCount,HcfBlob * input)1371 static void MemoryMallocTestFunc(uint32_t mallocCount, HcfBlob *input)
1372 {
1373     for (uint32_t i = 0; i < mallocCount; i++) {
1374         ResetRecordMallocNum();
1375         SetMockMallocIndex(i);
1376         HcfAsyKeyGenerator *generator = nullptr;
1377         int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1378         if (res != HCF_SUCCESS) {
1379             continue;
1380         }
1381         HcfKeyPair *keyPair = nullptr;
1382         res = generator->generateKeyPair(generator, nullptr, &keyPair);
1383         HcfObjDestroy(generator);
1384         if (res != HCF_SUCCESS) {
1385             continue;
1386         }
1387         HcfSign *sign = nullptr;
1388         res = HcfSignCreate("ECC|SHA256", &sign);
1389         if (res != HCF_SUCCESS) {
1390             HcfObjDestroy(keyPair);
1391             continue;
1392         }
1393         res = sign->init(sign, nullptr, keyPair->priKey);
1394         if (res != HCF_SUCCESS) {
1395             HcfObjDestroy(sign);
1396             HcfObjDestroy(keyPair);
1397             continue;
1398         }
1399         res = sign->update(sign, input);
1400         if (res != HCF_SUCCESS) {
1401             HcfObjDestroy(sign);
1402             HcfObjDestroy(keyPair);
1403             continue;
1404         }
1405         HcfBlob out = {
1406             .data = nullptr,
1407             .len = 0
1408         };
1409         res = sign->sign(sign, nullptr, &out);
1410         HcfObjDestroy(sign);
1411         HcfObjDestroy(keyPair);
1412         if (res == HCF_SUCCESS) {
1413             HcfFree(out.data);
1414         }
1415     }
1416 }
1417 
1418 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest1101, TestSize.Level0)
1419 {
1420     StartRecordMallocNum();
1421     HcfAsyKeyGenerator *generator = nullptr;
1422     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1423     ASSERT_EQ(res, HCF_SUCCESS);
1424     ASSERT_NE(generator, nullptr);
1425 
1426     HcfKeyPair *keyPair = nullptr;
1427     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1428     ASSERT_EQ(res, HCF_SUCCESS);
1429     ASSERT_NE(keyPair, nullptr);
1430 
1431     HcfObjDestroy(generator);
1432 
1433     HcfSign *sign = nullptr;
1434     res = HcfSignCreate("ECC|SHA256", &sign);
1435     ASSERT_EQ(res, HCF_SUCCESS);
1436     ASSERT_NE(sign, nullptr);
1437 
1438     HcfParamsSpec params;
1439     res = sign->init(sign, &params, keyPair->priKey);
1440     ASSERT_EQ(res, HCF_SUCCESS);
1441 
1442     const char *message = "hello world";
1443     HcfBlob input = {
1444         .data = (uint8_t *)message,
1445         .len = 12
1446     };
1447     res = sign->update(sign, &input);
1448     ASSERT_EQ(res, HCF_SUCCESS);
1449 
1450     HcfBlob out = { .data = nullptr, .len = 0 };
1451     res = sign->sign(sign, nullptr, &out);
1452     ASSERT_EQ(res, HCF_SUCCESS);
1453     ASSERT_NE(out.data, nullptr);
1454     ASSERT_NE(out.len, (const unsigned int)0);
1455 
1456     HcfFree(out.data);
1457     HcfObjDestroy(sign);
1458 
1459     uint32_t mallocCount = GetMallocNum();
1460     MemoryMallocTestFunc(mallocCount, &input);
1461 
1462     EndRecordMallocNum();
1463 }
1464 
OpensslMockTestFunc(uint32_t mallocCount,HcfBlob * input)1465 static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *input)
1466 {
1467     for (uint32_t i = 0; i < mallocCount; i++) {
1468         ResetOpensslCallNum();
1469         SetOpensslCallMockIndex(i);
1470         HcfAsyKeyGenerator *generator = nullptr;
1471         int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1472         if (res != HCF_SUCCESS) {
1473             continue;
1474         }
1475         HcfKeyPair *keyPair = nullptr;
1476         res = generator->generateKeyPair(generator, nullptr, &keyPair);
1477         HcfObjDestroy(generator);
1478         if (res != HCF_SUCCESS) {
1479             continue;
1480         }
1481         HcfSign *sign = nullptr;
1482         res = HcfSignCreate("ECC|SHA256", &sign);
1483         if (res != HCF_SUCCESS) {
1484             HcfObjDestroy(keyPair);
1485             continue;
1486         }
1487         res = sign->init(sign, nullptr, keyPair->priKey);
1488         if (res != HCF_SUCCESS) {
1489             HcfObjDestroy(sign);
1490             HcfObjDestroy(keyPair);
1491             continue;
1492         }
1493         res = sign->update(sign, input);
1494         if (res != HCF_SUCCESS) {
1495             HcfObjDestroy(sign);
1496             HcfObjDestroy(keyPair);
1497             continue;
1498         }
1499         HcfBlob out = {
1500             .data = nullptr,
1501             .len = 0
1502         };
1503         res = sign->sign(sign, input, &out);
1504         HcfObjDestroy(sign);
1505         HcfObjDestroy(keyPair);
1506         if (res == HCF_SUCCESS) {
1507             HcfFree(out.data);
1508         }
1509     }
1510 }
1511 
1512 HWTEST_F(CryptoEccNoLengthSignSubTest, CryptoEccNoLengthSignSubTest1102, TestSize.Level0)
1513 {
1514     StartRecordOpensslCallNum();
1515     HcfAsyKeyGenerator *generator = nullptr;
1516     int32_t res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1517     ASSERT_EQ(res, HCF_SUCCESS);
1518     ASSERT_NE(generator, nullptr);
1519 
1520     HcfKeyPair *keyPair = nullptr;
1521     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1522     ASSERT_EQ(res, HCF_SUCCESS);
1523     ASSERT_NE(keyPair, nullptr);
1524 
1525     HcfObjDestroy(generator);
1526 
1527     HcfSign *sign = nullptr;
1528     res = HcfSignCreate("ECC|SHA256", &sign);
1529     ASSERT_EQ(res, HCF_SUCCESS);
1530     ASSERT_NE(sign, nullptr);
1531 
1532     HcfParamsSpec params;
1533     res = sign->init(sign, &params, keyPair->priKey);
1534     ASSERT_EQ(res, HCF_SUCCESS);
1535 
1536     const char *message = "hello world";
1537     HcfBlob input = {
1538         .data = (uint8_t *)message,
1539         .len = 12
1540     };
1541     res = sign->update(sign, &input);
1542     ASSERT_EQ(res, HCF_SUCCESS);
1543 
1544     HcfBlob out = { .data = nullptr, .len = 0 };
1545     res = sign->sign(sign, &input, &out);
1546     ASSERT_EQ(res, HCF_SUCCESS);
1547     ASSERT_NE(out.data, nullptr);
1548     ASSERT_NE(out.len, (const unsigned int)0);
1549 
1550     HcfFree(out.data);
1551     HcfObjDestroy(sign);
1552 
1553     uint32_t mallocCount = GetOpensslCallNum();
1554     OpensslMockTestFunc(mallocCount, &input);
1555 
1556     EndRecordOpensslCallNum();
1557 }
1558 }
1559