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