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 CryptoEccNoLengthVerifySubTest : 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 *CryptoEccNoLengthVerifySubTest::ecc224KeyPair_ = nullptr;
55 HcfKeyPair *CryptoEccNoLengthVerifySubTest::ecc256KeyPair_ = nullptr;
56 HcfKeyPair *CryptoEccNoLengthVerifySubTest::ecc384KeyPair_ = nullptr;
57 HcfKeyPair *CryptoEccNoLengthVerifySubTest::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 CryptoEccNoLengthVerifySubTest::SetUp() {}
TearDown()66 void CryptoEccNoLengthVerifySubTest::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 CryptoEccNoLengthVerifySubTest::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 CryptoEccNoLengthVerifySubTest::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 CryptoEccNoLengthVerifySubTest::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 CryptoEccNoLengthVerifySubTest::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 CryptoEccNoLengthVerifySubTest::SetUpTestCase()
302 {
303     CryptoEccNoLengthSignTestSubEcc224();
304     CryptoEccNoLengthSignTestSubEcc256();
305     CryptoEccNoLengthSignTestSubEcc384();
306     CryptoEccNoLengthSignTestSubEcc521();
307 }
308 
TearDownTestCase()309 void CryptoEccNoLengthVerifySubTest::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(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest411, TestSize.Level0)
328 {
329     HcfSign *sign = nullptr;
330     int32_t res = HcfSignCreate("ECC|SHA1", &sign);
331 
332     ASSERT_EQ(res, HCF_SUCCESS);
333     ASSERT_NE(sign, nullptr);
334 
335     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
336 
337     ASSERT_EQ(res, HCF_SUCCESS);
338 
339     res = sign->update(sign, &g_mockInput);
340 
341     ASSERT_EQ(res, HCF_SUCCESS);
342 
343     HcfBlob out = { .data = nullptr, .len = 0 };
344     res = sign->sign(sign, nullptr, &out);
345 
346     ASSERT_EQ(res, HCF_SUCCESS);
347     ASSERT_NE(out.data, nullptr);
348     ASSERT_NE(out.len, (const unsigned int)0);
349 
350     HcfVerify *verify = nullptr;
351     res = HcfVerifyCreate("ECC|SHA1", &verify);
352 
353     ASSERT_EQ(res, HCF_SUCCESS);
354     ASSERT_NE(verify, nullptr);
355 
356     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
357 
358     ASSERT_EQ(res, HCF_SUCCESS);
359 
360     res = verify->update(verify, &g_mockInput);
361 
362     ASSERT_EQ(res, HCF_SUCCESS);
363 
364     bool flag = verify->verify(verify, nullptr, &out);
365 
366     ASSERT_EQ(flag, true);
367 
368     HcfFree(out.data);
369     HcfObjDestroy(sign);
370     HcfObjDestroy(verify);
371 }
372 
373 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest412, TestSize.Level0)
374 {
375     HcfSign *sign = nullptr;
376     int32_t res = HcfSignCreate("ECC|SHA224", &sign);
377 
378     ASSERT_EQ(res, HCF_SUCCESS);
379     ASSERT_NE(sign, nullptr);
380 
381     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
382 
383     ASSERT_EQ(res, HCF_SUCCESS);
384 
385     res = sign->update(sign, &g_mockInput);
386 
387     ASSERT_EQ(res, HCF_SUCCESS);
388 
389     HcfBlob out = { .data = nullptr, .len = 0 };
390     res = sign->sign(sign, nullptr, &out);
391 
392     ASSERT_EQ(res, HCF_SUCCESS);
393     ASSERT_NE(out.data, nullptr);
394     ASSERT_NE(out.len, (const unsigned int)0);
395 
396     HcfVerify *verify = nullptr;
397     res = HcfVerifyCreate("ECC|SHA224", &verify);
398 
399     ASSERT_EQ(res, HCF_SUCCESS);
400     ASSERT_NE(verify, nullptr);
401 
402     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
403 
404     ASSERT_EQ(res, HCF_SUCCESS);
405 
406     res = verify->update(verify, &g_mockInput);
407 
408     ASSERT_EQ(res, HCF_SUCCESS);
409 
410     bool flag = verify->verify(verify, nullptr, &out);
411 
412     ASSERT_EQ(flag, true);
413 
414     HcfFree(out.data);
415     HcfObjDestroy(sign);
416     HcfObjDestroy(verify);
417 }
418 
419 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest413, TestSize.Level0)
420 {
421     HcfSign *sign = nullptr;
422     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
423 
424     ASSERT_EQ(res, HCF_SUCCESS);
425     ASSERT_NE(sign, nullptr);
426 
427     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
428 
429     ASSERT_EQ(res, HCF_SUCCESS);
430 
431     res = sign->update(sign, &g_mockInput);
432 
433     ASSERT_EQ(res, HCF_SUCCESS);
434 
435     HcfBlob out = { .data = nullptr, .len = 0 };
436     res = sign->sign(sign, nullptr, &out);
437 
438     ASSERT_EQ(res, HCF_SUCCESS);
439     ASSERT_NE(out.data, nullptr);
440     ASSERT_NE(out.len, (const unsigned int)0);
441 
442     HcfVerify *verify = nullptr;
443     res = HcfVerifyCreate("ECC|SHA256", &verify);
444 
445     ASSERT_EQ(res, HCF_SUCCESS);
446     ASSERT_NE(verify, nullptr);
447 
448     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
449 
450     ASSERT_EQ(res, HCF_SUCCESS);
451 
452     res = verify->update(verify, &g_mockInput);
453 
454     ASSERT_EQ(res, HCF_SUCCESS);
455 
456     bool flag = verify->verify(verify, nullptr, &out);
457 
458     ASSERT_EQ(flag, true);
459 
460     HcfFree(out.data);
461     HcfObjDestroy(sign);
462     HcfObjDestroy(verify);
463 }
464 
465 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest414, TestSize.Level0)
466 {
467     HcfSign *sign = nullptr;
468     int32_t res = HcfSignCreate("ECC|SHA384", &sign);
469 
470     ASSERT_EQ(res, HCF_SUCCESS);
471     ASSERT_NE(sign, nullptr);
472 
473     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
474 
475     ASSERT_EQ(res, HCF_SUCCESS);
476 
477     res = sign->update(sign, &g_mockInput);
478 
479     ASSERT_EQ(res, HCF_SUCCESS);
480 
481     HcfBlob out = { .data = nullptr, .len = 0 };
482     res = sign->sign(sign, nullptr, &out);
483 
484     ASSERT_EQ(res, HCF_SUCCESS);
485     ASSERT_NE(out.data, nullptr);
486     ASSERT_NE(out.len, (const unsigned int)0);
487 
488     HcfVerify *verify = nullptr;
489     res = HcfVerifyCreate("ECC|SHA384", &verify);
490 
491     ASSERT_EQ(res, HCF_SUCCESS);
492     ASSERT_NE(verify, nullptr);
493 
494     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
495 
496     ASSERT_EQ(res, HCF_SUCCESS);
497 
498     res = verify->update(verify, &g_mockInput);
499 
500     ASSERT_EQ(res, HCF_SUCCESS);
501 
502     bool flag = verify->verify(verify, nullptr, &out);
503 
504     ASSERT_EQ(flag, true);
505 
506     HcfFree(out.data);
507     HcfObjDestroy(sign);
508     HcfObjDestroy(verify);
509 }
510 
511 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest415, TestSize.Level0)
512 {
513     HcfSign *sign = nullptr;
514     int32_t res = HcfSignCreate("ECC|SHA512", &sign);
515 
516     ASSERT_EQ(res, HCF_SUCCESS);
517     ASSERT_NE(sign, nullptr);
518 
519     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
520 
521     ASSERT_EQ(res, HCF_SUCCESS);
522 
523     res = sign->update(sign, &g_mockInput);
524 
525     ASSERT_EQ(res, HCF_SUCCESS);
526 
527     HcfBlob out = { .data = nullptr, .len = 0 };
528     res = sign->sign(sign, nullptr, &out);
529 
530     ASSERT_EQ(res, HCF_SUCCESS);
531     ASSERT_NE(out.data, nullptr);
532     ASSERT_NE(out.len, (const unsigned int)0);
533 
534     HcfVerify *verify = nullptr;
535     res = HcfVerifyCreate("ECC|SHA512", &verify);
536 
537     ASSERT_EQ(res, HCF_SUCCESS);
538     ASSERT_NE(verify, nullptr);
539 
540     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
541 
542     ASSERT_EQ(res, HCF_SUCCESS);
543 
544     res = verify->update(verify, &g_mockInput);
545 
546     ASSERT_EQ(res, HCF_SUCCESS);
547 
548     bool flag = verify->verify(verify, nullptr, &out);
549 
550     ASSERT_EQ(flag, true);
551 
552     HcfFree(out.data);
553     HcfObjDestroy(sign);
554     HcfObjDestroy(verify);
555 }
556 
557 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest416, TestSize.Level0)
558 {
559     HcfSign *sign = nullptr;
560     int32_t res = HcfSignCreate("ECC|SHA1", &sign);
561 
562     ASSERT_EQ(res, HCF_SUCCESS);
563     ASSERT_NE(sign, nullptr);
564 
565     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
566 
567     ASSERT_EQ(res, HCF_SUCCESS);
568 
569     res = sign->update(sign, &g_mockInput);
570 
571     ASSERT_EQ(res, HCF_SUCCESS);
572 
573     HcfBlob out = { .data = nullptr, .len = 0 };
574     res = sign->sign(sign, nullptr, &out);
575 
576     ASSERT_EQ(res, HCF_SUCCESS);
577     ASSERT_NE(out.data, nullptr);
578     ASSERT_NE(out.len, (const unsigned int)0);
579 
580     HcfVerify *verify = nullptr;
581     res = HcfVerifyCreate("ECC|SHA1", &verify);
582 
583     ASSERT_EQ(res, HCF_SUCCESS);
584     ASSERT_NE(verify, nullptr);
585 
586     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
587 
588     ASSERT_EQ(res, HCF_SUCCESS);
589 
590     res = verify->update(verify, &g_mockInput);
591 
592     ASSERT_EQ(res, HCF_SUCCESS);
593 
594     bool flag = verify->verify(verify, nullptr, &out);
595 
596     ASSERT_EQ(flag, true);
597 
598     HcfFree(out.data);
599     HcfObjDestroy(sign);
600     HcfObjDestroy(verify);
601 }
602 
603 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest417, TestSize.Level0)
604 {
605     HcfSign *sign = nullptr;
606     int32_t res = HcfSignCreate("ECC|SHA224", &sign);
607 
608     ASSERT_EQ(res, HCF_SUCCESS);
609     ASSERT_NE(sign, nullptr);
610 
611     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
612 
613     ASSERT_EQ(res, HCF_SUCCESS);
614 
615     res = sign->update(sign, &g_mockInput);
616 
617     ASSERT_EQ(res, HCF_SUCCESS);
618 
619     HcfBlob out = { .data = nullptr, .len = 0 };
620     res = sign->sign(sign, nullptr, &out);
621 
622     ASSERT_EQ(res, HCF_SUCCESS);
623     ASSERT_NE(out.data, nullptr);
624     ASSERT_NE(out.len, (const unsigned int)0);
625 
626     HcfVerify *verify = nullptr;
627     res = HcfVerifyCreate("ECC|SHA224", &verify);
628 
629     ASSERT_EQ(res, HCF_SUCCESS);
630     ASSERT_NE(verify, nullptr);
631 
632     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
633 
634     ASSERT_EQ(res, HCF_SUCCESS);
635 
636     res = verify->update(verify, &g_mockInput);
637 
638     ASSERT_EQ(res, HCF_SUCCESS);
639 
640     bool flag = verify->verify(verify, nullptr, &out);
641 
642     ASSERT_EQ(flag, true);
643 
644     HcfFree(out.data);
645     HcfObjDestroy(sign);
646     HcfObjDestroy(verify);
647 }
648 
649 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest418, TestSize.Level0)
650 {
651     HcfSign *sign = nullptr;
652     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
653 
654     ASSERT_EQ(res, HCF_SUCCESS);
655     ASSERT_NE(sign, nullptr);
656 
657     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
658 
659     ASSERT_EQ(res, HCF_SUCCESS);
660 
661     res = sign->update(sign, &g_mockInput);
662 
663     ASSERT_EQ(res, HCF_SUCCESS);
664 
665     HcfBlob out = { .data = nullptr, .len = 0 };
666     res = sign->sign(sign, nullptr, &out);
667 
668     ASSERT_EQ(res, HCF_SUCCESS);
669     ASSERT_NE(out.data, nullptr);
670     ASSERT_NE(out.len, (const unsigned int)0);
671 
672     HcfVerify *verify = nullptr;
673     res = HcfVerifyCreate("ECC|SHA256", &verify);
674 
675     ASSERT_EQ(res, HCF_SUCCESS);
676     ASSERT_NE(verify, nullptr);
677 
678     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
679 
680     ASSERT_EQ(res, HCF_SUCCESS);
681 
682     res = verify->update(verify, &g_mockInput);
683 
684     ASSERT_EQ(res, HCF_SUCCESS);
685 
686     bool flag = verify->verify(verify, nullptr, &out);
687 
688     ASSERT_EQ(flag, true);
689 
690     HcfFree(out.data);
691     HcfObjDestroy(sign);
692     HcfObjDestroy(verify);
693 }
694 
695 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest419, TestSize.Level0)
696 {
697     HcfSign *sign = nullptr;
698     int32_t res = HcfSignCreate("ECC|SHA384", &sign);
699 
700     ASSERT_EQ(res, HCF_SUCCESS);
701     ASSERT_NE(sign, nullptr);
702 
703     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
704 
705     ASSERT_EQ(res, HCF_SUCCESS);
706 
707     res = sign->update(sign, &g_mockInput);
708 
709     ASSERT_EQ(res, HCF_SUCCESS);
710 
711     HcfBlob out = { .data = nullptr, .len = 0 };
712     res = sign->sign(sign, nullptr, &out);
713 
714     ASSERT_EQ(res, HCF_SUCCESS);
715     ASSERT_NE(out.data, nullptr);
716     ASSERT_NE(out.len, (const unsigned int)0);
717 
718     HcfVerify *verify = nullptr;
719     res = HcfVerifyCreate("ECC|SHA384", &verify);
720 
721     ASSERT_EQ(res, HCF_SUCCESS);
722     ASSERT_NE(verify, nullptr);
723 
724     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
725 
726     ASSERT_EQ(res, HCF_SUCCESS);
727 
728     res = verify->update(verify, &g_mockInput);
729 
730     ASSERT_EQ(res, HCF_SUCCESS);
731 
732     bool flag = verify->verify(verify, nullptr, &out);
733 
734     ASSERT_EQ(flag, true);
735 
736     HcfFree(out.data);
737     HcfObjDestroy(sign);
738     HcfObjDestroy(verify);
739 }
740 
741 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest420, TestSize.Level0)
742 {
743     HcfSign *sign = nullptr;
744     int32_t res = HcfSignCreate("ECC|SHA512", &sign);
745 
746     ASSERT_EQ(res, HCF_SUCCESS);
747     ASSERT_NE(sign, nullptr);
748 
749     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
750 
751     ASSERT_EQ(res, HCF_SUCCESS);
752 
753     res = sign->update(sign, &g_mockInput);
754 
755     ASSERT_EQ(res, HCF_SUCCESS);
756 
757     HcfBlob out = { .data = nullptr, .len = 0 };
758     res = sign->sign(sign, nullptr, &out);
759 
760     ASSERT_EQ(res, HCF_SUCCESS);
761     ASSERT_NE(out.data, nullptr);
762     ASSERT_NE(out.len, (const unsigned int)0);
763 
764     HcfVerify *verify = nullptr;
765     res = HcfVerifyCreate("ECC|SHA512", &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     res = verify->update(verify, &g_mockInput);
775 
776     ASSERT_EQ(res, HCF_SUCCESS);
777 
778     bool flag = verify->verify(verify, nullptr, &out);
779 
780     ASSERT_EQ(flag, true);
781 
782     HcfFree(out.data);
783     HcfObjDestroy(sign);
784     HcfObjDestroy(verify);
785 }
786 
787 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest421, TestSize.Level0)
788 {
789     HcfSign *sign = nullptr;
790     int32_t res = HcfSignCreate("ECC|SHA1", &sign);
791 
792     ASSERT_EQ(res, HCF_SUCCESS);
793     ASSERT_NE(sign, nullptr);
794 
795     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
796 
797     ASSERT_EQ(res, HCF_SUCCESS);
798 
799     HcfBlob out = { .data = nullptr, .len = 0 };
800     res = sign->sign(sign, &g_mockInput, &out);
801 
802     ASSERT_EQ(res, HCF_SUCCESS);
803     ASSERT_NE(out.data, nullptr);
804     ASSERT_NE(out.len, (const unsigned int)0);
805 
806     HcfVerify *verify = nullptr;
807     res = HcfVerifyCreate("ECC|SHA1", &verify);
808 
809     ASSERT_EQ(res, HCF_SUCCESS);
810     ASSERT_NE(verify, nullptr);
811 
812     res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
813 
814     ASSERT_EQ(res, HCF_SUCCESS);
815 
816     bool flag = verify->verify(verify, &g_mockInput, &out);
817 
818     ASSERT_EQ(flag, true);
819 
820     HcfFree(out.data);
821     HcfObjDestroy(sign);
822     HcfObjDestroy(verify);
823 }
824 
825 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest422, TestSize.Level0)
826 {
827     HcfSign *sign = nullptr;
828     int32_t res = HcfSignCreate("ECC|SHA224", &sign);
829 
830     ASSERT_EQ(res, HCF_SUCCESS);
831     ASSERT_NE(sign, nullptr);
832 
833     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
834 
835     ASSERT_EQ(res, HCF_SUCCESS);
836 
837     HcfBlob out = { .data = nullptr, .len = 0 };
838     res = sign->sign(sign, &g_mockInput, &out);
839 
840     ASSERT_EQ(res, HCF_SUCCESS);
841     ASSERT_NE(out.data, nullptr);
842     ASSERT_NE(out.len, (const unsigned int)0);
843 
844     HcfVerify *verify = nullptr;
845     res = HcfVerifyCreate("ECC|SHA224", &verify);
846 
847     ASSERT_EQ(res, HCF_SUCCESS);
848     ASSERT_NE(verify, nullptr);
849 
850     res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
851 
852     ASSERT_EQ(res, HCF_SUCCESS);
853 
854     bool flag = verify->verify(verify, &g_mockInput, &out);
855 
856     ASSERT_EQ(flag, true);
857 
858     HcfFree(out.data);
859     HcfObjDestroy(sign);
860     HcfObjDestroy(verify);
861 }
862 
863 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest423, TestSize.Level0)
864 {
865     HcfSign *sign = nullptr;
866     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
867 
868     ASSERT_EQ(res, HCF_SUCCESS);
869     ASSERT_NE(sign, nullptr);
870 
871     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
872 
873     ASSERT_EQ(res, HCF_SUCCESS);
874 
875     HcfBlob out = { .data = nullptr, .len = 0 };
876     res = sign->sign(sign, &g_mockInput, &out);
877 
878     ASSERT_EQ(res, HCF_SUCCESS);
879     ASSERT_NE(out.data, nullptr);
880     ASSERT_NE(out.len, (const unsigned int)0);
881 
882     HcfVerify *verify = nullptr;
883     res = HcfVerifyCreate("ECC|SHA256", &verify);
884 
885     ASSERT_EQ(res, HCF_SUCCESS);
886     ASSERT_NE(verify, nullptr);
887 
888     res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
889 
890     ASSERT_EQ(res, HCF_SUCCESS);
891 
892     bool flag = verify->verify(verify, &g_mockInput, &out);
893 
894     ASSERT_EQ(flag, true);
895 
896     HcfFree(out.data);
897     HcfObjDestroy(sign);
898     HcfObjDestroy(verify);
899 }
900 
901 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest424, TestSize.Level0)
902 {
903     HcfSign *sign = nullptr;
904     int32_t res = HcfSignCreate("ECC|SHA384", &sign);
905 
906     ASSERT_EQ(res, HCF_SUCCESS);
907     ASSERT_NE(sign, nullptr);
908 
909     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
910 
911     ASSERT_EQ(res, HCF_SUCCESS);
912 
913     HcfBlob out = { .data = nullptr, .len = 0 };
914     res = sign->sign(sign, &g_mockInput, &out);
915 
916     ASSERT_EQ(res, HCF_SUCCESS);
917     ASSERT_NE(out.data, nullptr);
918     ASSERT_NE(out.len, (const unsigned int)0);
919 
920     HcfVerify *verify = nullptr;
921     res = HcfVerifyCreate("ECC|SHA384", &verify);
922 
923     ASSERT_EQ(res, HCF_SUCCESS);
924     ASSERT_NE(verify, nullptr);
925 
926     res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
927 
928     ASSERT_EQ(res, HCF_SUCCESS);
929 
930     bool flag = verify->verify(verify, &g_mockInput, &out);
931 
932     ASSERT_EQ(flag, true);
933 
934     HcfFree(out.data);
935     HcfObjDestroy(sign);
936     HcfObjDestroy(verify);
937 }
938 
939 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest425, TestSize.Level0)
940 {
941     HcfSign *sign = nullptr;
942     int32_t res = HcfSignCreate("ECC|SHA512", &sign);
943 
944     ASSERT_EQ(res, HCF_SUCCESS);
945     ASSERT_NE(sign, nullptr);
946 
947     res = sign->init(sign, nullptr, ecc224KeyPair_->priKey);
948 
949     ASSERT_EQ(res, HCF_SUCCESS);
950 
951     HcfBlob out = { .data = nullptr, .len = 0 };
952     res = sign->sign(sign, &g_mockInput, &out);
953 
954     ASSERT_EQ(res, HCF_SUCCESS);
955     ASSERT_NE(out.data, nullptr);
956     ASSERT_NE(out.len, (const unsigned int)0);
957 
958     HcfVerify *verify = nullptr;
959     res = HcfVerifyCreate("ECC|SHA512", &verify);
960 
961     ASSERT_EQ(res, HCF_SUCCESS);
962     ASSERT_NE(verify, nullptr);
963 
964     res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
965 
966     ASSERT_EQ(res, HCF_SUCCESS);
967 
968     bool flag = verify->verify(verify, &g_mockInput, &out);
969 
970     ASSERT_EQ(flag, true);
971 
972     HcfFree(out.data);
973     HcfObjDestroy(sign);
974     HcfObjDestroy(verify);
975 }
976 
977 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest426, TestSize.Level0)
978 {
979     HcfSign *sign = nullptr;
980     int32_t res = HcfSignCreate("ECC|SHA1", &sign);
981 
982     ASSERT_EQ(res, HCF_SUCCESS);
983     ASSERT_NE(sign, nullptr);
984 
985     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
986 
987     ASSERT_EQ(res, HCF_SUCCESS);
988 
989     HcfBlob out = { .data = nullptr, .len = 0 };
990     res = sign->sign(sign, &g_mockInput, &out);
991 
992     ASSERT_EQ(res, HCF_SUCCESS);
993     ASSERT_NE(out.data, nullptr);
994     ASSERT_NE(out.len, (const unsigned int)0);
995 
996     HcfVerify *verify = nullptr;
997     res = HcfVerifyCreate("ECC|SHA1", &verify);
998 
999     ASSERT_EQ(res, HCF_SUCCESS);
1000     ASSERT_NE(verify, nullptr);
1001 
1002     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1003 
1004     ASSERT_EQ(res, HCF_SUCCESS);
1005 
1006     bool flag = verify->verify(verify, &g_mockInput, &out);
1007 
1008     ASSERT_EQ(flag, true);
1009 
1010     HcfFree(out.data);
1011     HcfObjDestroy(sign);
1012     HcfObjDestroy(verify);
1013 }
1014 
1015 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest427, TestSize.Level0)
1016 {
1017     HcfSign *sign = nullptr;
1018     int32_t res = HcfSignCreate("ECC|SHA224", &sign);
1019 
1020     ASSERT_EQ(res, HCF_SUCCESS);
1021     ASSERT_NE(sign, nullptr);
1022 
1023     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1024 
1025     ASSERT_EQ(res, HCF_SUCCESS);
1026 
1027     HcfBlob out = { .data = nullptr, .len = 0 };
1028     res = sign->sign(sign, &g_mockInput, &out);
1029 
1030     ASSERT_EQ(res, HCF_SUCCESS);
1031     ASSERT_NE(out.data, nullptr);
1032     ASSERT_NE(out.len, (const unsigned int)0);
1033 
1034     HcfVerify *verify = nullptr;
1035     res = HcfVerifyCreate("ECC|SHA224", &verify);
1036 
1037     ASSERT_EQ(res, HCF_SUCCESS);
1038     ASSERT_NE(verify, nullptr);
1039 
1040     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1041 
1042     ASSERT_EQ(res, HCF_SUCCESS);
1043 
1044     bool flag = verify->verify(verify, &g_mockInput, &out);
1045 
1046     ASSERT_EQ(flag, true);
1047 
1048     HcfFree(out.data);
1049     HcfObjDestroy(sign);
1050     HcfObjDestroy(verify);
1051 }
1052 
1053 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest428, TestSize.Level0)
1054 {
1055     HcfSign *sign = nullptr;
1056     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1057 
1058     ASSERT_EQ(res, HCF_SUCCESS);
1059     ASSERT_NE(sign, nullptr);
1060 
1061     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1062 
1063     ASSERT_EQ(res, HCF_SUCCESS);
1064 
1065     HcfBlob out = { .data = nullptr, .len = 0 };
1066     res = sign->sign(sign, &g_mockInput, &out);
1067 
1068     ASSERT_EQ(res, HCF_SUCCESS);
1069     ASSERT_NE(out.data, nullptr);
1070     ASSERT_NE(out.len, (const unsigned int)0);
1071 
1072     HcfVerify *verify = nullptr;
1073     res = HcfVerifyCreate("ECC|SHA256", &verify);
1074 
1075     ASSERT_EQ(res, HCF_SUCCESS);
1076     ASSERT_NE(verify, nullptr);
1077 
1078     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1079 
1080     ASSERT_EQ(res, HCF_SUCCESS);
1081 
1082     bool flag = verify->verify(verify, &g_mockInput, &out);
1083 
1084     ASSERT_EQ(flag, true);
1085 
1086     HcfFree(out.data);
1087     HcfObjDestroy(sign);
1088     HcfObjDestroy(verify);
1089 }
1090 
1091 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest429, TestSize.Level0)
1092 {
1093     HcfSign *sign = nullptr;
1094     int32_t res = HcfSignCreate("ECC|SHA384", &sign);
1095 
1096     ASSERT_EQ(res, HCF_SUCCESS);
1097     ASSERT_NE(sign, nullptr);
1098 
1099     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1100 
1101     ASSERT_EQ(res, HCF_SUCCESS);
1102 
1103     HcfBlob out = { .data = nullptr, .len = 0 };
1104     res = sign->sign(sign, &g_mockInput, &out);
1105 
1106     ASSERT_EQ(res, HCF_SUCCESS);
1107     ASSERT_NE(out.data, nullptr);
1108     ASSERT_NE(out.len, (const unsigned int)0);
1109 
1110     HcfVerify *verify = nullptr;
1111     res = HcfVerifyCreate("ECC|SHA384", &verify);
1112 
1113     ASSERT_EQ(res, HCF_SUCCESS);
1114     ASSERT_NE(verify, nullptr);
1115 
1116     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1117 
1118     ASSERT_EQ(res, HCF_SUCCESS);
1119 
1120     bool flag = verify->verify(verify, &g_mockInput, &out);
1121 
1122     ASSERT_EQ(flag, true);
1123 
1124     HcfFree(out.data);
1125     HcfObjDestroy(sign);
1126     HcfObjDestroy(verify);
1127 }
1128 
1129 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest430, TestSize.Level0)
1130 {
1131     HcfSign *sign = nullptr;
1132     int32_t res = HcfSignCreate("ECC|SHA512", &sign);
1133 
1134     ASSERT_EQ(res, HCF_SUCCESS);
1135     ASSERT_NE(sign, nullptr);
1136 
1137     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1138 
1139     ASSERT_EQ(res, HCF_SUCCESS);
1140 
1141     HcfBlob out = { .data = nullptr, .len = 0 };
1142     res = sign->sign(sign, &g_mockInput, &out);
1143 
1144     ASSERT_EQ(res, HCF_SUCCESS);
1145     ASSERT_NE(out.data, nullptr);
1146     ASSERT_NE(out.len, (const unsigned int)0);
1147 
1148     HcfVerify *verify = nullptr;
1149     res = HcfVerifyCreate("ECC|SHA512", &verify);
1150 
1151     ASSERT_EQ(res, HCF_SUCCESS);
1152     ASSERT_NE(verify, nullptr);
1153 
1154     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1155 
1156     ASSERT_EQ(res, HCF_SUCCESS);
1157 
1158     bool flag = verify->verify(verify, &g_mockInput, &out);
1159 
1160     ASSERT_EQ(flag, true);
1161 
1162     HcfFree(out.data);
1163     HcfObjDestroy(sign);
1164     HcfObjDestroy(verify);
1165 }
1166 
1167 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest431, TestSize.Level0)
1168 {
1169     HcfSign *sign = nullptr;
1170     int32_t res = HcfSignCreate("ECC|SHA1", &sign);
1171 
1172     ASSERT_EQ(res, HCF_SUCCESS);
1173     ASSERT_NE(sign, nullptr);
1174 
1175     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1176 
1177     ASSERT_EQ(res, HCF_SUCCESS);
1178 
1179     HcfBlob out = { .data = nullptr, .len = 0 };
1180     res = sign->sign(sign, &g_mockInput, &out);
1181 
1182     ASSERT_EQ(res, HCF_SUCCESS);
1183     ASSERT_NE(out.data, nullptr);
1184     ASSERT_NE(out.len, (const unsigned int)0);
1185 
1186     HcfVerify *verify = nullptr;
1187     res = HcfVerifyCreate("ECC|SHA1", &verify);
1188 
1189     ASSERT_EQ(res, HCF_SUCCESS);
1190     ASSERT_NE(verify, nullptr);
1191 
1192     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
1193 
1194     ASSERT_EQ(res, HCF_SUCCESS);
1195 
1196     bool flag = verify->verify(verify, &g_mockInput, &out);
1197 
1198     ASSERT_EQ(flag, true);
1199 
1200     HcfFree(out.data);
1201     HcfObjDestroy(sign);
1202     HcfObjDestroy(verify);
1203 }
1204 
1205 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest432, TestSize.Level0)
1206 {
1207     HcfSign *sign = nullptr;
1208     int32_t res = HcfSignCreate("ECC|SHA224", &sign);
1209 
1210     ASSERT_EQ(res, HCF_SUCCESS);
1211     ASSERT_NE(sign, nullptr);
1212 
1213     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1214 
1215     ASSERT_EQ(res, HCF_SUCCESS);
1216 
1217     HcfBlob out = { .data = nullptr, .len = 0 };
1218     res = sign->sign(sign, &g_mockInput, &out);
1219 
1220     ASSERT_EQ(res, HCF_SUCCESS);
1221     ASSERT_NE(out.data, nullptr);
1222     ASSERT_NE(out.len, (const unsigned int)0);
1223 
1224     HcfVerify *verify = nullptr;
1225     res = HcfVerifyCreate("ECC|SHA224", &verify);
1226 
1227     ASSERT_EQ(res, HCF_SUCCESS);
1228     ASSERT_NE(verify, nullptr);
1229 
1230     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
1231 
1232     ASSERT_EQ(res, HCF_SUCCESS);
1233 
1234     bool flag = verify->verify(verify, &g_mockInput, &out);
1235 
1236     ASSERT_EQ(flag, true);
1237 
1238     HcfFree(out.data);
1239     HcfObjDestroy(sign);
1240     HcfObjDestroy(verify);
1241 }
1242 
1243 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest433, TestSize.Level0)
1244 {
1245     HcfSign *sign = nullptr;
1246     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1247 
1248     ASSERT_EQ(res, HCF_SUCCESS);
1249     ASSERT_NE(sign, nullptr);
1250 
1251     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1252 
1253     ASSERT_EQ(res, HCF_SUCCESS);
1254 
1255     HcfBlob out = { .data = nullptr, .len = 0 };
1256     res = sign->sign(sign, &g_mockInput, &out);
1257 
1258     ASSERT_EQ(res, HCF_SUCCESS);
1259     ASSERT_NE(out.data, nullptr);
1260     ASSERT_NE(out.len, (const unsigned int)0);
1261 
1262     HcfVerify *verify = nullptr;
1263     res = HcfVerifyCreate("ECC|SHA256", &verify);
1264 
1265     ASSERT_EQ(res, HCF_SUCCESS);
1266     ASSERT_NE(verify, nullptr);
1267 
1268     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
1269 
1270     ASSERT_EQ(res, HCF_SUCCESS);
1271 
1272     bool flag = verify->verify(verify, &g_mockInput, &out);
1273 
1274     ASSERT_EQ(flag, true);
1275 
1276     HcfFree(out.data);
1277     HcfObjDestroy(sign);
1278     HcfObjDestroy(verify);
1279 }
1280 
1281 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest434, TestSize.Level0)
1282 {
1283     HcfSign *sign = nullptr;
1284     int32_t res = HcfSignCreate("ECC|SHA384", &sign);
1285 
1286     ASSERT_EQ(res, HCF_SUCCESS);
1287     ASSERT_NE(sign, nullptr);
1288 
1289     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1290 
1291     ASSERT_EQ(res, HCF_SUCCESS);
1292 
1293     HcfBlob out = { .data = nullptr, .len = 0 };
1294     res = sign->sign(sign, &g_mockInput, &out);
1295 
1296     ASSERT_EQ(res, HCF_SUCCESS);
1297     ASSERT_NE(out.data, nullptr);
1298     ASSERT_NE(out.len, (const unsigned int)0);
1299 
1300     HcfVerify *verify = nullptr;
1301     res = HcfVerifyCreate("ECC|SHA384", &verify);
1302 
1303     ASSERT_EQ(res, HCF_SUCCESS);
1304     ASSERT_NE(verify, nullptr);
1305 
1306     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
1307 
1308     ASSERT_EQ(res, HCF_SUCCESS);
1309 
1310     bool flag = verify->verify(verify, &g_mockInput, &out);
1311 
1312     ASSERT_EQ(flag, true);
1313 
1314     HcfFree(out.data);
1315     HcfObjDestroy(sign);
1316     HcfObjDestroy(verify);
1317 }
1318 
1319 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest435, TestSize.Level0)
1320 {
1321     HcfSign *sign = nullptr;
1322     int32_t res = HcfSignCreate("ECC|SHA512", &sign);
1323 
1324     ASSERT_EQ(res, HCF_SUCCESS);
1325     ASSERT_NE(sign, nullptr);
1326 
1327     res = sign->init(sign, nullptr, ecc384KeyPair_->priKey);
1328 
1329     ASSERT_EQ(res, HCF_SUCCESS);
1330 
1331     HcfBlob out = { .data = nullptr, .len = 0 };
1332     res = sign->sign(sign, &g_mockInput, &out);
1333 
1334     ASSERT_EQ(res, HCF_SUCCESS);
1335     ASSERT_NE(out.data, nullptr);
1336     ASSERT_NE(out.len, (const unsigned int)0);
1337 
1338     HcfVerify *verify = nullptr;
1339     res = HcfVerifyCreate("ECC|SHA512", &verify);
1340 
1341     ASSERT_EQ(res, HCF_SUCCESS);
1342     ASSERT_NE(verify, nullptr);
1343 
1344     res = verify->init(verify, nullptr, ecc384KeyPair_->pubKey);
1345 
1346     ASSERT_EQ(res, HCF_SUCCESS);
1347 
1348     bool flag = verify->verify(verify, &g_mockInput, &out);
1349 
1350     ASSERT_EQ(flag, true);
1351 
1352     HcfFree(out.data);
1353     HcfObjDestroy(sign);
1354     HcfObjDestroy(verify);
1355 }
1356 
1357 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest436, TestSize.Level0)
1358 {
1359     HcfSign *sign = nullptr;
1360     int32_t res = HcfSignCreate("ECC|SHA1", &sign);
1361 
1362     ASSERT_EQ(res, HCF_SUCCESS);
1363     ASSERT_NE(sign, nullptr);
1364 
1365     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1366 
1367     ASSERT_EQ(res, HCF_SUCCESS);
1368 
1369     HcfBlob out = { .data = nullptr, .len = 0 };
1370     res = sign->sign(sign, &g_mockInput, &out);
1371 
1372     ASSERT_EQ(res, HCF_SUCCESS);
1373     ASSERT_NE(out.data, nullptr);
1374     ASSERT_NE(out.len, (const unsigned int)0);
1375 
1376     HcfVerify *verify = nullptr;
1377     res = HcfVerifyCreate("ECC|SHA1", &verify);
1378 
1379     ASSERT_EQ(res, HCF_SUCCESS);
1380     ASSERT_NE(verify, nullptr);
1381 
1382     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
1383 
1384     ASSERT_EQ(res, HCF_SUCCESS);
1385 
1386     bool flag = verify->verify(verify, &g_mockInput, &out);
1387 
1388     ASSERT_EQ(flag, true);
1389 
1390     HcfFree(out.data);
1391     HcfObjDestroy(sign);
1392     HcfObjDestroy(verify);
1393 }
1394 
1395 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest437, TestSize.Level0)
1396 {
1397     HcfSign *sign = nullptr;
1398     int32_t res = HcfSignCreate("ECC|SHA224", &sign);
1399 
1400     ASSERT_EQ(res, HCF_SUCCESS);
1401     ASSERT_NE(sign, nullptr);
1402 
1403     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1404 
1405     ASSERT_EQ(res, HCF_SUCCESS);
1406 
1407     HcfBlob out = { .data = nullptr, .len = 0 };
1408     res = sign->sign(sign, &g_mockInput, &out);
1409 
1410     ASSERT_EQ(res, HCF_SUCCESS);
1411     ASSERT_NE(out.data, nullptr);
1412     ASSERT_NE(out.len, (const unsigned int)0);
1413 
1414     HcfVerify *verify = nullptr;
1415     res = HcfVerifyCreate("ECC|SHA224", &verify);
1416 
1417     ASSERT_EQ(res, HCF_SUCCESS);
1418     ASSERT_NE(verify, nullptr);
1419 
1420     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
1421 
1422     ASSERT_EQ(res, HCF_SUCCESS);
1423 
1424     bool flag = verify->verify(verify, &g_mockInput, &out);
1425 
1426     ASSERT_EQ(flag, true);
1427 
1428     HcfFree(out.data);
1429     HcfObjDestroy(sign);
1430     HcfObjDestroy(verify);
1431 }
1432 
1433 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest438, TestSize.Level0)
1434 {
1435     HcfSign *sign = nullptr;
1436     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1437 
1438     ASSERT_EQ(res, HCF_SUCCESS);
1439     ASSERT_NE(sign, nullptr);
1440 
1441     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1442 
1443     ASSERT_EQ(res, HCF_SUCCESS);
1444 
1445     HcfBlob out = { .data = nullptr, .len = 0 };
1446     res = sign->sign(sign, &g_mockInput, &out);
1447 
1448     ASSERT_EQ(res, HCF_SUCCESS);
1449     ASSERT_NE(out.data, nullptr);
1450     ASSERT_NE(out.len, (const unsigned int)0);
1451 
1452     HcfVerify *verify = nullptr;
1453     res = HcfVerifyCreate("ECC|SHA256", &verify);
1454 
1455     ASSERT_EQ(res, HCF_SUCCESS);
1456     ASSERT_NE(verify, nullptr);
1457 
1458     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
1459 
1460     ASSERT_EQ(res, HCF_SUCCESS);
1461 
1462     bool flag = verify->verify(verify, &g_mockInput, &out);
1463 
1464     ASSERT_EQ(flag, true);
1465 
1466     HcfFree(out.data);
1467     HcfObjDestroy(sign);
1468     HcfObjDestroy(verify);
1469 }
1470 
1471 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest439, TestSize.Level0)
1472 {
1473     HcfSign *sign = nullptr;
1474     int32_t res = HcfSignCreate("ECC|SHA384", &sign);
1475 
1476     ASSERT_EQ(res, HCF_SUCCESS);
1477     ASSERT_NE(sign, nullptr);
1478 
1479     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1480 
1481     ASSERT_EQ(res, HCF_SUCCESS);
1482 
1483     HcfBlob out = { .data = nullptr, .len = 0 };
1484     res = sign->sign(sign, &g_mockInput, &out);
1485 
1486     ASSERT_EQ(res, HCF_SUCCESS);
1487     ASSERT_NE(out.data, nullptr);
1488     ASSERT_NE(out.len, (const unsigned int)0);
1489 
1490     HcfVerify *verify = nullptr;
1491     res = HcfVerifyCreate("ECC|SHA384", &verify);
1492 
1493     ASSERT_EQ(res, HCF_SUCCESS);
1494     ASSERT_NE(verify, nullptr);
1495 
1496     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
1497 
1498     ASSERT_EQ(res, HCF_SUCCESS);
1499 
1500     bool flag = verify->verify(verify, &g_mockInput, &out);
1501 
1502     ASSERT_EQ(flag, true);
1503 
1504     HcfFree(out.data);
1505     HcfObjDestroy(sign);
1506     HcfObjDestroy(verify);
1507 }
1508 
1509 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest440, TestSize.Level0)
1510 {
1511     HcfSign *sign = nullptr;
1512     int32_t res = HcfSignCreate("ECC|SHA512", &sign);
1513 
1514     ASSERT_EQ(res, HCF_SUCCESS);
1515     ASSERT_NE(sign, nullptr);
1516 
1517     res = sign->init(sign, nullptr, ecc521KeyPair_->priKey);
1518 
1519     ASSERT_EQ(res, HCF_SUCCESS);
1520 
1521     HcfBlob out = { .data = nullptr, .len = 0 };
1522     res = sign->sign(sign, &g_mockInput, &out);
1523 
1524     ASSERT_EQ(res, HCF_SUCCESS);
1525     ASSERT_NE(out.data, nullptr);
1526     ASSERT_NE(out.len, (const unsigned int)0);
1527 
1528     HcfVerify *verify = nullptr;
1529     res = HcfVerifyCreate("ECC|SHA512", &verify);
1530 
1531     ASSERT_EQ(res, HCF_SUCCESS);
1532     ASSERT_NE(verify, nullptr);
1533 
1534     res = verify->init(verify, nullptr, ecc521KeyPair_->pubKey);
1535 
1536     ASSERT_EQ(res, HCF_SUCCESS);
1537 
1538     bool flag = verify->verify(verify, &g_mockInput, &out);
1539 
1540     ASSERT_EQ(flag, true);
1541 
1542     HcfFree(out.data);
1543     HcfObjDestroy(sign);
1544     HcfObjDestroy(verify);
1545 }
1546 
1547 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest441, TestSize.Level0)
1548 {
1549     HcfSign *sign = nullptr;
1550     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1551 
1552     ASSERT_EQ(res, HCF_SUCCESS);
1553     ASSERT_NE(sign, nullptr);
1554 
1555     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1556 
1557     ASSERT_EQ(res, HCF_SUCCESS);
1558 
1559     res = sign->update(sign, &g_mockInput);
1560 
1561     ASSERT_EQ(res, HCF_SUCCESS);
1562 
1563     HcfBlob out = { .data = nullptr, .len = 0 };
1564     res = sign->sign(sign, nullptr, &out);
1565 
1566     ASSERT_EQ(res, HCF_SUCCESS);
1567     ASSERT_NE(out.data, nullptr);
1568     ASSERT_NE(out.len, (const unsigned int)0);
1569 
1570     HcfVerify *verify = nullptr;
1571     res = HcfVerifyCreate("ECC|SHA256", &verify);
1572 
1573     ASSERT_EQ(res, HCF_SUCCESS);
1574     ASSERT_NE(verify, nullptr);
1575 
1576     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1577 
1578     ASSERT_EQ(res, HCF_SUCCESS);
1579 
1580     res = verify->update(verify, &g_mockInput);
1581 
1582     ASSERT_EQ(res, HCF_SUCCESS);
1583 
1584     bool flag = verify->verify(nullptr, nullptr, &out);
1585 
1586     ASSERT_EQ(flag, false);
1587 
1588     HcfFree(out.data);
1589     HcfObjDestroy(sign);
1590     HcfObjDestroy(verify);
1591 }
1592 
1593 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest442, TestSize.Level0)
1594 {
1595     HcfSign *sign = nullptr;
1596     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1597 
1598     ASSERT_EQ(res, HCF_SUCCESS);
1599     ASSERT_NE(sign, nullptr);
1600 
1601     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1602 
1603     ASSERT_EQ(res, HCF_SUCCESS);
1604 
1605     res = sign->update(sign, &g_mockInput);
1606 
1607     ASSERT_EQ(res, HCF_SUCCESS);
1608 
1609     HcfBlob out = { .data = nullptr, .len = 0 };
1610     res = sign->sign(sign, nullptr, &out);
1611 
1612     ASSERT_EQ(res, HCF_SUCCESS);
1613     ASSERT_NE(out.data, nullptr);
1614     ASSERT_NE(out.len, (const unsigned int)0);
1615 
1616     HcfVerify *verify = nullptr;
1617     res = HcfVerifyCreate("ECC|SHA256", &verify);
1618 
1619     ASSERT_EQ(res, HCF_SUCCESS);
1620     ASSERT_NE(verify, nullptr);
1621 
1622     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1623 
1624     ASSERT_EQ(res, HCF_SUCCESS);
1625 
1626     res = verify->update(verify, &g_mockInput);
1627 
1628     ASSERT_EQ(res, HCF_SUCCESS);
1629 
1630     bool flag = verify->verify((HcfVerify *)(&obj), nullptr, &out);
1631 
1632     ASSERT_EQ(flag, false);
1633 
1634     HcfFree(out.data);
1635     HcfObjDestroy(sign);
1636     HcfObjDestroy(verify);
1637 }
1638 
1639 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest443, TestSize.Level0)
1640 {
1641     HcfSign *sign = nullptr;
1642     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1643 
1644     ASSERT_EQ(res, HCF_SUCCESS);
1645     ASSERT_NE(sign, nullptr);
1646 
1647     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1648 
1649     ASSERT_EQ(res, HCF_SUCCESS);
1650 
1651     res = sign->update(sign, &g_mockInput);
1652 
1653     ASSERT_EQ(res, HCF_SUCCESS);
1654 
1655     HcfBlob out = { .data = nullptr, .len = 0 };
1656     res = sign->sign(sign, nullptr, &out);
1657 
1658     ASSERT_EQ(res, HCF_SUCCESS);
1659     ASSERT_NE(out.data, nullptr);
1660     ASSERT_NE(out.len, (const unsigned int)0);
1661 
1662     HcfVerify *verify = nullptr;
1663     res = HcfVerifyCreate("ECC|SHA256", &verify);
1664 
1665     ASSERT_EQ(res, HCF_SUCCESS);
1666     ASSERT_NE(verify, nullptr);
1667 
1668     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1669 
1670     ASSERT_EQ(res, HCF_SUCCESS);
1671 
1672     bool flag = verify->verify(verify, nullptr, &out);
1673 
1674     ASSERT_EQ(flag, false);
1675 
1676     HcfFree(out.data);
1677     HcfObjDestroy(sign);
1678     HcfObjDestroy(verify);
1679 }
1680 
1681 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest444, TestSize.Level0)
1682 {
1683     HcfSign *sign = nullptr;
1684     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1685 
1686     ASSERT_EQ(res, HCF_SUCCESS);
1687     ASSERT_NE(sign, nullptr);
1688 
1689     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1690 
1691     ASSERT_EQ(res, HCF_SUCCESS);
1692 
1693     res = sign->update(sign, &g_mockInput);
1694 
1695     ASSERT_EQ(res, HCF_SUCCESS);
1696 
1697     HcfBlob out = { .data = nullptr, .len = 0 };
1698     res = sign->sign(sign, nullptr, &out);
1699 
1700     ASSERT_EQ(res, HCF_SUCCESS);
1701     ASSERT_NE(out.data, nullptr);
1702     ASSERT_NE(out.len, (const unsigned int)0);
1703 
1704     HcfVerify *verify = nullptr;
1705     res = HcfVerifyCreate("ECC|SHA256", &verify);
1706 
1707     ASSERT_EQ(res, HCF_SUCCESS);
1708     ASSERT_NE(verify, nullptr);
1709 
1710     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1711 
1712     ASSERT_EQ(res, HCF_SUCCESS);
1713 
1714     HcfBlob input = {
1715         .data = nullptr,
1716         .len = 1
1717     };
1718     bool flag = verify->verify(verify, &input, &out);
1719 
1720     ASSERT_EQ(flag, false);
1721 
1722     HcfFree(out.data);
1723     HcfObjDestroy(sign);
1724     HcfObjDestroy(verify);
1725 }
1726 
1727 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest445, TestSize.Level0)
1728 {
1729     HcfSign *sign = nullptr;
1730     int32_t res = HcfSignCreate("ECC|SHA256", &sign);
1731 
1732     ASSERT_EQ(res, HCF_SUCCESS);
1733     ASSERT_NE(sign, nullptr);
1734 
1735     res = sign->init(sign, nullptr, ecc256KeyPair_->priKey);
1736 
1737     ASSERT_EQ(res, HCF_SUCCESS);
1738 
1739     res = sign->update(sign, &g_mockInput);
1740 
1741     ASSERT_EQ(res, HCF_SUCCESS);
1742 
1743     HcfBlob out = { .data = nullptr, .len = 0 };
1744     res = sign->sign(sign, nullptr, &out);
1745 
1746     ASSERT_EQ(res, HCF_SUCCESS);
1747     ASSERT_NE(out.data, nullptr);
1748     ASSERT_NE(out.len, (const unsigned int)0);
1749 
1750     HcfVerify *verify = nullptr;
1751     res = HcfVerifyCreate("ECC|SHA256", &verify);
1752 
1753     ASSERT_EQ(res, HCF_SUCCESS);
1754     ASSERT_NE(verify, nullptr);
1755 
1756     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1757 
1758     ASSERT_EQ(res, HCF_SUCCESS);
1759 
1760     HcfBlob input = {
1761         .data = (uint8_t *)g_mockMessage,
1762         .len = 0
1763     };
1764     bool flag = verify->verify(verify, &input, &out);
1765 
1766     ASSERT_EQ(flag, false);
1767 
1768     HcfFree(out.data);
1769     HcfObjDestroy(sign);
1770     HcfObjDestroy(verify);
1771 }
1772 
1773 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest446, TestSize.Level0)
1774 {
1775     HcfVerify *verify = nullptr;
1776     int32_t res = HcfVerifyCreate("ECC|SHA256", &verify);
1777 
1778     ASSERT_EQ(res, HCF_SUCCESS);
1779     ASSERT_NE(verify, nullptr);
1780 
1781     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1782 
1783     ASSERT_EQ(res, HCF_SUCCESS);
1784 
1785     res = verify->update(verify, &g_mockInput);
1786 
1787     ASSERT_EQ(res, HCF_SUCCESS);
1788 
1789     bool flag = verify->verify(verify, nullptr, nullptr);
1790 
1791     ASSERT_EQ(flag, false);
1792 
1793     HcfObjDestroy(verify);
1794 }
1795 
1796 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest447, TestSize.Level0)
1797 {
1798     HcfVerify *verify = nullptr;
1799     int32_t res = HcfVerifyCreate("ECC|SHA256", &verify);
1800 
1801     ASSERT_EQ(res, HCF_SUCCESS);
1802     ASSERT_NE(verify, nullptr);
1803 
1804     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1805 
1806     ASSERT_EQ(res, HCF_SUCCESS);
1807 
1808     res = verify->update(verify, &g_mockInput);
1809 
1810     ASSERT_EQ(res, HCF_SUCCESS);
1811 
1812     HcfBlob mockOut = {
1813         .data = nullptr,
1814         .len = 1
1815     };
1816     bool flag = verify->verify(verify, nullptr, &mockOut);
1817 
1818     ASSERT_EQ(flag, false);
1819 
1820     HcfObjDestroy(verify);
1821 }
1822 
1823 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest448, TestSize.Level0)
1824 {
1825     HcfVerify *verify = nullptr;
1826     int32_t res = HcfVerifyCreate("ECC|SHA256", &verify);
1827 
1828     ASSERT_EQ(res, HCF_SUCCESS);
1829     ASSERT_NE(verify, nullptr);
1830 
1831     res = verify->init(verify, nullptr, ecc256KeyPair_->pubKey);
1832 
1833     ASSERT_EQ(res, HCF_SUCCESS);
1834 
1835     res = verify->update(verify, &g_mockInput);
1836 
1837     ASSERT_EQ(res, HCF_SUCCESS);
1838 
1839     HcfBlob mockOut = {
1840         .data = (uint8_t *)g_mockMessage,
1841         .len = 0
1842     };
1843     bool flag = verify->verify(verify, nullptr, &mockOut);
1844 
1845     ASSERT_EQ(flag, false);
1846 
1847     HcfObjDestroy(verify);
1848 }
1849 
1850 HcfSignatureParams g_params = {
1851     .algo = HCF_ALG_ECC,
1852     .padding = HCF_ALG_NOPADDING,
1853     .md = HCF_OPENSSL_DIGEST_SHA256,
1854     .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
1855 };
1856 
1857 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest501, TestSize.Level0)
1858 {
1859     int32_t res = HcfVerifySpiEcdsaCreate(&g_params, nullptr);
1860 
1861     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1862 }
1863 
1864 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest503, TestSize.Level0)
1865 {
1866     HcfVerifySpi *spiObj = nullptr;
1867     int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
1868 
1869     ASSERT_EQ(res, HCF_SUCCESS);
1870     ASSERT_NE(spiObj, nullptr);
1871 
1872     res = spiObj->engineInit((HcfVerifySpi *)&obj, nullptr, ecc256KeyPair_->pubKey);
1873     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1874 
1875     HcfObjDestroy(spiObj);
1876 }
1877 
1878 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest504, TestSize.Level0)
1879 {
1880     HcfVerifySpi *spiObj = nullptr;
1881     int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
1882 
1883     ASSERT_EQ(res, HCF_SUCCESS);
1884     ASSERT_NE(spiObj, nullptr);
1885 
1886     res = spiObj->engineInit(spiObj, nullptr, (HcfPubKey *)&obj);
1887     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1888 
1889     HcfObjDestroy(spiObj);
1890 }
1891 
1892 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest505, TestSize.Level0)
1893 {
1894     HcfVerifySpi *spiObj = nullptr;
1895     int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
1896 
1897     ASSERT_EQ(res, HCF_SUCCESS);
1898     ASSERT_NE(spiObj, nullptr);
1899 
1900     const char *message = "hello world";
1901     HcfBlob input = {
1902         .data = (uint8_t *)message,
1903         .len = 12
1904     };
1905     res = spiObj->engineUpdate(nullptr, &input);
1906     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1907 
1908     HcfObjDestroy(spiObj);
1909 }
1910 
1911 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest506, TestSize.Level0)
1912 {
1913     HcfVerifySpi *spiObj = nullptr;
1914     int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
1915 
1916     ASSERT_EQ(res, HCF_SUCCESS);
1917     ASSERT_NE(spiObj, nullptr);
1918 
1919     const char *message = "hello world";
1920     HcfBlob input = {
1921         .data = (uint8_t *)message,
1922         .len = 12
1923     };
1924     res = spiObj->engineUpdate((HcfVerifySpi *)&obj, &input);
1925     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1926 
1927     HcfObjDestroy(spiObj);
1928 }
1929 
1930 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest507, TestSize.Level0)
1931 {
1932     HcfVerifySpi *spiObj = nullptr;
1933     int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
1934 
1935     ASSERT_EQ(res, HCF_SUCCESS);
1936     ASSERT_NE(spiObj, nullptr);
1937 
1938     res = spiObj->engineUpdate(spiObj, nullptr);
1939     ASSERT_EQ(res, HCF_INVALID_PARAMS);
1940 
1941     HcfObjDestroy(spiObj);
1942 }
1943 
1944 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest508, TestSize.Level0)
1945 {
1946     HcfVerifySpi *spiObj = nullptr;
1947     int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
1948 
1949     ASSERT_EQ(res, HCF_SUCCESS);
1950     ASSERT_NE(spiObj, nullptr);
1951 
1952     const char *message = "hello world";
1953     HcfBlob input = {
1954         .data = (uint8_t *)message,
1955         .len = 12
1956     };
1957     HcfBlob out = { .data = nullptr, .len = 0 };
1958     bool isOk = spiObj->engineVerify(nullptr, &input, &out);
1959     ASSERT_EQ(isOk, false);
1960 
1961     HcfObjDestroy(spiObj);
1962 }
1963 
1964 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest509, TestSize.Level0)
1965 {
1966     HcfVerifySpi *spiObj = nullptr;
1967     int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
1968 
1969     ASSERT_EQ(res, HCF_SUCCESS);
1970     ASSERT_NE(spiObj, nullptr);
1971 
1972     const char *message = "hello world";
1973     HcfBlob input = {
1974         .data = (uint8_t *)message,
1975         .len = 12
1976     };
1977     bool isOk = spiObj->engineVerify((HcfVerifySpi *)&obj, &input, &input);
1978     ASSERT_EQ(isOk, false);
1979 
1980     HcfObjDestroy(spiObj);
1981 }
1982 
1983 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest510, TestSize.Level0)
1984 {
1985     HcfVerifySpi *spiObj = nullptr;
1986     int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
1987 
1988     ASSERT_EQ(res, HCF_SUCCESS);
1989     ASSERT_NE(spiObj, nullptr);
1990 
1991     spiObj->base.destroy(nullptr);
1992 
1993     HcfObjDestroy(spiObj);
1994 }
1995 
1996 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest511, TestSize.Level0)
1997 {
1998     HcfVerifySpi *spiObj = nullptr;
1999     int32_t res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
2000 
2001     ASSERT_EQ(res, HCF_SUCCESS);
2002     ASSERT_NE(spiObj, nullptr);
2003 
2004     spiObj->base.destroy(&obj);
2005 
2006     HcfObjDestroy(spiObj);
2007 }
2008 
GetSignTestData(HcfBlob * out)2009 static bool GetSignTestData(HcfBlob *out)
2010 {
2011     HcfSign *sign = nullptr;
2012     int32_t res = HcfSignCreate("ECC|SHA224", &sign);
2013     if (res != HCF_SUCCESS) {
2014         return false;
2015     }
2016     res = sign->init(sign, nullptr, CryptoEccNoLengthVerifySubTest::ecc224KeyPair_->priKey);
2017     if (res != HCF_SUCCESS) {
2018         HcfObjDestroy(sign);
2019         return false;
2020     }
2021     res = sign->update(sign, &g_mockInput);
2022     if (res != HCF_SUCCESS) {
2023         HcfObjDestroy(sign);
2024         return false;
2025     }
2026     res = sign->sign(sign, &g_mockInput, out);
2027     HcfObjDestroy(sign);
2028     return res == HCF_SUCCESS;
2029 }
2030 
MemoryMockTestFunc(uint32_t mallocCount,HcfBlob * out)2031 static void MemoryMockTestFunc(uint32_t mallocCount, HcfBlob *out)
2032 {
2033     for (int i = 0; i < mallocCount; i++) {
2034         ResetRecordMallocNum();
2035         SetMockMallocIndex(i);
2036         HcfVerify *verify = nullptr;
2037         int32_t res = HcfVerifyCreate("ECC|SHA224", &verify);
2038         if (res != HCF_SUCCESS) {
2039             continue;
2040         }
2041         res = verify->init(verify, nullptr, CryptoEccNoLengthVerifySubTest::ecc224KeyPair_->pubKey);
2042         if (res != HCF_SUCCESS) {
2043             HcfObjDestroy(verify);
2044             continue;
2045         }
2046         res = verify->update(verify, &g_mockInput);
2047         if (res != HCF_SUCCESS) {
2048             HcfObjDestroy(verify);
2049             continue;
2050         }
2051         (void)verify->verify(verify, nullptr, out);
2052         HcfObjDestroy(verify);
2053     }
2054 }
2055 
2056 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest601, TestSize.Level0)
2057 {
2058     HcfBlob out = { .data = nullptr, .len = 0 };
2059     GetSignTestData(&out);
2060     StartRecordMallocNum();
2061 
2062     HcfVerify *verify = nullptr;
2063     int32_t res = HcfVerifyCreate("ECC|SHA224", &verify);
2064 
2065     ASSERT_EQ(res, HCF_SUCCESS);
2066     ASSERT_NE(verify, nullptr);
2067 
2068     res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
2069 
2070     ASSERT_EQ(res, HCF_SUCCESS);
2071 
2072     res = verify->update(verify, &g_mockInput);
2073 
2074     ASSERT_EQ(res, HCF_SUCCESS);
2075 
2076     bool flag = verify->verify(verify, &g_mockInput, &out);
2077 
2078     ASSERT_EQ(flag, true);
2079     HcfObjDestroy(verify);
2080 
2081     uint32_t mallocCount = GetMallocNum();
2082     MemoryMockTestFunc(mallocCount, &out);
2083     EndRecordMallocNum();
2084 }
2085 
OpensslMockTestFunc(uint32_t mallocCount,HcfBlob * out)2086 static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *out)
2087 {
2088     for (int i = 0; i < mallocCount; i++) {
2089         ResetOpensslCallNum();
2090         SetOpensslCallMockIndex(i);
2091         HcfVerify *verify = nullptr;
2092         int32_t res = HcfVerifyCreate("ECC|SHA224", &verify);
2093         if (res != HCF_SUCCESS) {
2094             continue;
2095         }
2096         res = verify->init(verify, nullptr, CryptoEccNoLengthVerifySubTest::ecc224KeyPair_->pubKey);
2097         if (res != HCF_SUCCESS) {
2098             HcfObjDestroy(verify);
2099             continue;
2100         }
2101         res = verify->update(verify, &g_mockInput);
2102         if (res != HCF_SUCCESS) {
2103             HcfObjDestroy(verify);
2104             continue;
2105         }
2106         (void)verify->verify(verify, &g_mockInput, out);
2107         HcfObjDestroy(verify);
2108     }
2109 }
2110 
2111 HWTEST_F(CryptoEccNoLengthVerifySubTest, CryptoEccNoLengthVerifySubTest602, TestSize.Level0)
2112 {
2113     HcfBlob out = { .data = nullptr, .len = 0 };
2114     ASSERT_EQ(GetSignTestData(&out), true);
2115     StartRecordOpensslCallNum();
2116 
2117     HcfVerify *verify = nullptr;
2118     int32_t res = HcfVerifyCreate("ECC|SHA224", &verify);
2119 
2120     ASSERT_EQ(res, HCF_SUCCESS);
2121     ASSERT_NE(verify, nullptr);
2122 
2123     res = verify->init(verify, nullptr, ecc224KeyPair_->pubKey);
2124 
2125     ASSERT_EQ(res, HCF_SUCCESS);
2126 
2127     res = verify->update(verify, &g_mockInput);
2128 
2129     ASSERT_EQ(res, HCF_SUCCESS);
2130 
2131     bool flag = verify->verify(verify, &g_mockInput, &out);
2132 
2133     ASSERT_EQ(flag, true);
2134     HcfObjDestroy(verify);
2135 
2136     uint32_t mallocCount = GetOpensslCallNum();
2137     OpensslMockTestFunc(mallocCount, &out);
2138     EndRecordOpensslCallNum();
2139 }
2140 }
2141