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(&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 CryptoEccNoLengthSignTest::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 CryptoEccNoLengthSignTest::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 CryptoEccNoLengthSignTest::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 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