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(¶mSpec);
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(¶mSpec);
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(¶mSpec);
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(¶mSpec);
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