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 "ecc_common_param_spec.h"
21 #include "ecc_key_util.h"
22 #include "key_utils.h"
23 #include "blob.h"
24 #include "ecc_openssl_common.h"
25 #include "ecc_openssl_common_param_spec.h"
26 #include "ecc_common.h"
27 #include "ecdsa_openssl.h"
28 #include "memory.h"
29 #include "securec.h"
30 #include "signature.h"
31 #include "memory_mock.h"
32 #include "openssl_adapter_mock.h"
33 #include "openssl_common.h"
34 #include "pub_key.h"
35 
36 using namespace std;
37 using namespace testing::ext;
38 namespace {
39 class CryptoBrainPoolNoLengthVerifyTest : public testing::Test {
40 public:
SetUpTestCase()41     static void SetUpTestCase() {};
TearDownTestCase()42     static void TearDownTestCase() {};
43     void SetUp();
44     void TearDown();
45 };
46 
47 static string g_brainpool160r1AlgName = "ECC_BrainPoolP160r1";
48 static string g_brainpool160r1CurveName = "NID_brainpoolP160r1";
49 
SetUp()50 void CryptoBrainPoolNoLengthVerifyTest::SetUp() {}
TearDown()51 void CryptoBrainPoolNoLengthVerifyTest::TearDown() {}
52 
53 static const char *g_mockMessage = "hello world";
54 static HcfBlob g_mockInput = {
55     .data = (uint8_t *)g_mockMessage,
56     .len = 12
57 };
58 
GetMockClass(void)59 static const char *GetMockClass(void)
60 {
61     return "HcfSymKeyGenerator";
62 }
63 
64 HcfObjectBase obj = {
65     .getClass = GetMockClass,
66     .destroy = nullptr
67 };
68 
HcfVerifyCreateTest(const char * algName)69 static HcfResult HcfVerifyCreateTest(const char *algName)
70 {
71     HcfVerify *verify = nullptr;
72     HcfResult res = HcfVerifyCreate(algName, &verify);
73     if (res == HCF_SUCCESS) {
74         HcfObjDestroy(verify);
75     }
76     return res;
77 }
78 
79 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest001_1, TestSize.Level0)
80 {
81     HcfResult res = HcfVerifyCreateTest("ECC_BrainPoolP160r1|SHA1");
82     ASSERT_EQ(res, HCF_SUCCESS);
83 }
84 
85 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest001_2, TestSize.Level0)
86 {
87     HcfResult res = HcfVerifyCreateTest("ECC_BrainPoolP160r1|SHA224");
88     ASSERT_EQ(res, HCF_SUCCESS);
89 }
90 
91 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest001_3, TestSize.Level0)
92 {
93     HcfResult res = HcfVerifyCreateTest("ECC_BrainPoolP160r1|SHA256");
94     ASSERT_EQ(res, HCF_SUCCESS);
95 }
96 
97 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest001_4, TestSize.Level0)
98 {
99     HcfResult res = HcfVerifyCreateTest("ECC_BrainPoolP160r1|SHA384");
100     ASSERT_EQ(res, HCF_SUCCESS);
101 }
102 
103 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest001_5, TestSize.Level0)
104 {
105     HcfResult res = HcfVerifyCreateTest("ECC_BrainPoolP160r1|SHA512");
106     ASSERT_EQ(res, HCF_SUCCESS);
107 }
108 
109 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest001_6, TestSize.Level0)
110 {
111     HcfResult res = HcfVerifyCreateTest("ECC_BrainPoolP160r1|MD5");
112     ASSERT_EQ(res, HCF_SUCCESS);
113 }
114 
115 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest002, TestSize.Level0)
116 {
117     HcfVerify *verify = nullptr;
118     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
119 
120     ASSERT_EQ(res, HCF_SUCCESS);
121     ASSERT_NE(verify, nullptr);
122 
123     const char *className = verify->base.getClass();
124     ASSERT_NE(className, nullptr);
125     HcfObjDestroy(verify);
126 }
127 
128 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest003, TestSize.Level0)
129 {
130     HcfVerify *verify = nullptr;
131     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
132 
133     ASSERT_EQ(res, HCF_SUCCESS);
134     ASSERT_NE(verify, nullptr);
135     verify->base.destroy((HcfObjectBase *)verify);
136 }
137 
138 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest004, TestSize.Level0)
139 {
140     HcfVerify *verify = nullptr;
141     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
142 
143     ASSERT_EQ(res, HCF_SUCCESS);
144     ASSERT_NE(verify, nullptr);
145     verify->base.destroy(nullptr);
146     HcfObjDestroy(verify);
147 }
148 
149 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest005, TestSize.Level0)
150 {
151     HcfVerify *verify = nullptr;
152     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
153 
154     ASSERT_EQ(res, HCF_SUCCESS);
155     ASSERT_NE(verify, nullptr);
156     verify->base.destroy(&obj);
157     HcfObjDestroy(verify);
158 }
159 
160 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest006, TestSize.Level0)
161 {
162     HcfVerify *verify = nullptr;
163     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
164 
165     ASSERT_EQ(res, HCF_SUCCESS);
166     ASSERT_NE(verify, nullptr);
167 
168     const char *algName = verify->getAlgoName(verify);
169     ASSERT_NE(algName, nullptr);
170     HcfObjDestroy(verify);
171 }
172 
173 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest007, TestSize.Level0)
174 {
175     HcfVerify *verify = nullptr;
176     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
177 
178     ASSERT_EQ(res, HCF_SUCCESS);
179     ASSERT_NE(verify, nullptr);
180 
181     const char *algName = verify->getAlgoName(nullptr);
182     ASSERT_EQ(algName, nullptr);
183     HcfObjDestroy(verify);
184 }
185 
186 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest008, TestSize.Level0)
187 {
188     HcfVerify *verify = nullptr;
189     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
190 
191     ASSERT_EQ(res, HCF_SUCCESS);
192     ASSERT_NE(verify, nullptr);
193 
194     const char *algName = verify->getAlgoName((HcfVerify *)(&obj));
195     ASSERT_EQ(algName, nullptr);
196     HcfObjDestroy(verify);
197 }
198 
199 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest009, TestSize.Level0)
200 {
201     HcfVerify *verify = nullptr;
202     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
203 
204     ASSERT_EQ(res, HCF_SUCCESS);
205     ASSERT_NE(verify, nullptr);
206 
207     HcfKeyPair *keyPair = nullptr;
208     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
209     ASSERT_EQ(res, HCF_SUCCESS);
210     ASSERT_NE(keyPair, nullptr);
211 
212     res = verify->init(verify, nullptr, keyPair->pubKey);
213     ASSERT_EQ(res, HCF_SUCCESS);
214     HcfObjDestroy(keyPair);
215     HcfObjDestroy(verify);
216 }
217 
218 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest010, TestSize.Level0)
219 {
220     HcfVerify *verify = nullptr;
221     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
222 
223     ASSERT_EQ(res, HCF_SUCCESS);
224     ASSERT_NE(verify, nullptr);
225 
226     HcfKeyPair *keyPair = nullptr;
227     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
228     ASSERT_EQ(res, HCF_SUCCESS);
229     ASSERT_NE(keyPair, nullptr);
230 
231     res = verify->init(nullptr, nullptr, keyPair->pubKey);
232     ASSERT_NE(res, HCF_SUCCESS);
233     HcfObjDestroy(verify);
234     HcfObjDestroy(keyPair);
235 }
236 
237 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest011, TestSize.Level0)
238 {
239     HcfVerify *verify = nullptr;
240     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
241 
242     ASSERT_EQ(res, HCF_SUCCESS);
243     ASSERT_NE(verify, nullptr);
244 
245     HcfKeyPair *keyPair = nullptr;
246     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
247     ASSERT_EQ(res, HCF_SUCCESS);
248     ASSERT_NE(keyPair, nullptr);
249 
250     res = verify->init((HcfVerify *)(&obj), nullptr, keyPair->pubKey);
251     ASSERT_NE(res, HCF_SUCCESS);
252     HcfObjDestroy(verify);
253     HcfObjDestroy(keyPair);
254 }
255 
256 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest012, TestSize.Level0)
257 {
258     HcfVerify *verify = nullptr;
259     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
260 
261     ASSERT_EQ(res, HCF_SUCCESS);
262     ASSERT_NE(verify, nullptr);
263 
264     HcfKeyPair *keyPair = nullptr;
265     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
266     ASSERT_EQ(res, HCF_SUCCESS);
267     ASSERT_NE(keyPair, nullptr);
268 
269     res = verify->init(verify, nullptr, keyPair->pubKey);
270     ASSERT_EQ(res, HCF_SUCCESS);
271 
272     res = verify->init(verify, nullptr, keyPair->pubKey);
273     ASSERT_EQ(res, HCF_INVALID_PARAMS);
274 
275     HcfObjDestroy(verify);
276     HcfObjDestroy(keyPair);
277 }
278 
279 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest013, TestSize.Level0)
280 {
281     HcfVerify *verify = nullptr;
282     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
283 
284     ASSERT_EQ(res, HCF_SUCCESS);
285     ASSERT_NE(verify, nullptr);
286 
287     HcfKeyPair *keyPair = nullptr;
288     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
289     ASSERT_EQ(res, HCF_SUCCESS);
290     ASSERT_NE(keyPair, nullptr);
291 
292     res = verify->init(verify, nullptr, nullptr);
293     ASSERT_EQ(res, HCF_INVALID_PARAMS);
294 
295     HcfObjDestroy(verify);
296     HcfObjDestroy(keyPair);
297 }
298 
299 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest014, TestSize.Level0)
300 {
301     HcfVerify *verify = nullptr;
302     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
303 
304     ASSERT_EQ(res, HCF_SUCCESS);
305     ASSERT_NE(verify, nullptr);
306 
307     HcfKeyPair *keyPair = nullptr;
308     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
309     ASSERT_EQ(res, HCF_SUCCESS);
310     ASSERT_NE(keyPair, nullptr);
311 
312     res = verify->init(verify, nullptr, (HcfPubKey *)&obj);
313     ASSERT_EQ(res, HCF_INVALID_PARAMS);
314 
315     HcfObjDestroy(verify);
316     HcfObjDestroy(keyPair);
317 }
318 
319 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest015, TestSize.Level0)
320 {
321     HcfVerify *verify = nullptr;
322     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
323 
324     ASSERT_EQ(res, HCF_SUCCESS);
325     ASSERT_NE(verify, nullptr);
326 
327     HcfKeyPair *keyPair = nullptr;
328     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
329     ASSERT_EQ(res, HCF_SUCCESS);
330     ASSERT_NE(keyPair, nullptr);
331 
332     res = verify->init(verify, nullptr, keyPair->pubKey);
333     ASSERT_NE(res, HCF_INVALID_PARAMS);
334 
335     res = verify->update(verify, &g_mockInput);
336     ASSERT_EQ(res, HCF_SUCCESS);
337 
338     HcfObjDestroy(verify);
339     HcfObjDestroy(keyPair);
340 }
341 
342 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest016, TestSize.Level0)
343 {
344     HcfVerify *verify = nullptr;
345     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
346 
347     ASSERT_EQ(res, HCF_SUCCESS);
348     ASSERT_NE(verify, nullptr);
349 
350     HcfKeyPair *keyPair = nullptr;
351     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
352     ASSERT_EQ(res, HCF_SUCCESS);
353     ASSERT_NE(keyPair, nullptr);
354 
355     res = verify->init(verify, nullptr, keyPair->pubKey);
356     ASSERT_NE(res, HCF_INVALID_PARAMS);
357 
358     res = verify->update(nullptr, &g_mockInput);
359     ASSERT_NE(res, HCF_SUCCESS);
360 
361     HcfObjDestroy(verify);
362     HcfObjDestroy(keyPair);
363 }
364 
365 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest017, TestSize.Level0)
366 {
367     HcfVerify *verify = nullptr;
368     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
369 
370     ASSERT_EQ(res, HCF_SUCCESS);
371     ASSERT_NE(verify, nullptr);
372 
373     HcfKeyPair *keyPair = nullptr;
374     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
375     ASSERT_EQ(res, HCF_SUCCESS);
376     ASSERT_NE(keyPair, nullptr);
377 
378     res = verify->init(verify, nullptr, keyPair->pubKey);
379     ASSERT_NE(res, HCF_INVALID_PARAMS);
380 
381     res = verify->update((HcfVerify *)(&obj), &g_mockInput);
382     ASSERT_NE(res, HCF_SUCCESS);
383 
384     HcfObjDestroy(verify);
385     HcfObjDestroy(keyPair);
386 }
387 
388 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest018, TestSize.Level0)
389 {
390     HcfVerify *verify = nullptr;
391     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
392 
393     ASSERT_EQ(res, HCF_SUCCESS);
394     ASSERT_NE(verify, nullptr);
395 
396     HcfKeyPair *keyPair = nullptr;
397     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
398     ASSERT_EQ(res, HCF_SUCCESS);
399     ASSERT_NE(keyPair, nullptr);
400 
401     res = verify->init(verify, nullptr, keyPair->pubKey);
402     ASSERT_NE(res, HCF_INVALID_PARAMS);
403 
404     res = verify->update(verify, nullptr);
405     ASSERT_NE(res, HCF_SUCCESS);
406 
407     HcfObjDestroy(verify);
408     HcfObjDestroy(keyPair);
409 }
410 
411 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest019, TestSize.Level0)
412 {
413     HcfVerify *verify = nullptr;
414     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
415 
416     ASSERT_EQ(res, HCF_SUCCESS);
417     ASSERT_NE(verify, nullptr);
418 
419     HcfKeyPair *keyPair = nullptr;
420     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
421     ASSERT_EQ(res, HCF_SUCCESS);
422     ASSERT_NE(keyPair, nullptr);
423 
424     res = verify->init(verify, nullptr, keyPair->pubKey);
425     ASSERT_NE(res, HCF_INVALID_PARAMS);
426     HcfBlob input = {
427         .data = nullptr,
428         .len = 1
429     };
430     res = verify->update(verify, &input);
431     ASSERT_NE(res, HCF_SUCCESS);
432 
433     HcfObjDestroy(verify);
434     HcfObjDestroy(keyPair);
435 }
436 
437 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest020, TestSize.Level0)
438 {
439     HcfVerify *verify = nullptr;
440     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
441 
442     ASSERT_EQ(res, HCF_SUCCESS);
443     ASSERT_NE(verify, nullptr);
444 
445     HcfKeyPair *keyPair = nullptr;
446     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
447     ASSERT_EQ(res, HCF_SUCCESS);
448     ASSERT_NE(keyPair, nullptr);
449 
450     res = verify->init(verify, nullptr, keyPair->pubKey);
451     ASSERT_NE(res, HCF_INVALID_PARAMS);
452 
453     HcfBlob input = {
454         .data = (uint8_t *)g_mockMessage,
455         .len = 0
456     };
457     res = verify->update(verify, &input);
458     ASSERT_NE(res, HCF_SUCCESS);
459 
460     HcfObjDestroy(verify);
461     HcfObjDestroy(keyPair);
462 }
463 
464 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest021, TestSize.Level0)
465 {
466     HcfSign *sign = nullptr;
467     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA224", &sign);
468 
469     ASSERT_EQ(res, HCF_SUCCESS);
470     ASSERT_NE(sign, nullptr);
471 
472     HcfKeyPair *keyPair = nullptr;
473     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
474     ASSERT_EQ(res, HCF_SUCCESS);
475     ASSERT_NE(keyPair, nullptr);
476 
477     res = sign->init(sign, nullptr, keyPair->priKey);
478     ASSERT_EQ(res, HCF_SUCCESS);
479 
480     res = sign->update(sign, &g_mockInput);
481     ASSERT_EQ(res, HCF_SUCCESS);
482 
483     HcfBlob out = { .data = nullptr, .len = 0 };
484     res = sign->sign(sign, nullptr, &out);
485 
486     ASSERT_EQ(res, HCF_SUCCESS);
487     ASSERT_NE(out.data, nullptr);
488     ASSERT_NE(out.len, (const unsigned int)0);
489 
490     HcfVerify *verify = nullptr;
491     res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
492 
493     ASSERT_EQ(res, HCF_SUCCESS);
494     ASSERT_NE(verify, nullptr);
495 
496     res = verify->init(verify, nullptr, keyPair->pubKey);
497     ASSERT_EQ(res, HCF_SUCCESS);
498 
499     res = verify->update(verify, &g_mockInput);
500     ASSERT_EQ(res, HCF_SUCCESS);
501 
502     bool flag = verify->verify(verify, nullptr, &out);
503     ASSERT_EQ(flag, true);
504 
505     HcfFree(out.data);
506     HcfObjDestroy(keyPair);
507     HcfObjDestroy(sign);
508     HcfObjDestroy(verify);
509 }
510 
511 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest022, TestSize.Level0)
512 {
513     HcfSign *sign = nullptr;
514     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA224", &sign);
515 
516     ASSERT_EQ(res, HCF_SUCCESS);
517     ASSERT_NE(sign, nullptr);
518 
519     HcfKeyPair *keyPair = nullptr;
520     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
521     ASSERT_EQ(res, HCF_SUCCESS);
522     ASSERT_NE(keyPair, nullptr);
523 
524     res = sign->init(sign, nullptr, keyPair->priKey);
525     ASSERT_EQ(res, HCF_SUCCESS);
526 
527     HcfBlob out = { .data = nullptr, .len = 0 };
528     res = sign->sign(sign, &g_mockInput, &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_BrainPoolP160r1|SHA224", &verify);
536     ASSERT_EQ(res, HCF_SUCCESS);
537     ASSERT_NE(verify, nullptr);
538 
539     res = verify->init(verify, nullptr, keyPair->pubKey);
540     ASSERT_EQ(res, HCF_SUCCESS);
541     bool flag = verify->verify(verify, &g_mockInput, &out);
542     ASSERT_EQ(flag, true);
543 
544     HcfFree(out.data);
545     HcfObjDestroy(keyPair);
546     HcfObjDestroy(sign);
547     HcfObjDestroy(verify);
548 }
549 
550 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest023, TestSize.Level0)
551 {
552     HcfSign *sign = nullptr;
553     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA224", &sign);
554 
555     ASSERT_EQ(res, HCF_SUCCESS);
556     ASSERT_NE(sign, nullptr);
557 
558     HcfKeyPair *keyPair = nullptr;
559     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
560     ASSERT_EQ(res, HCF_SUCCESS);
561     ASSERT_NE(keyPair, nullptr);
562 
563     res = sign->init(sign, nullptr, keyPair->priKey);
564     ASSERT_EQ(res, HCF_SUCCESS);
565 
566     res = sign->update(sign, &g_mockInput);
567     ASSERT_EQ(res, HCF_SUCCESS);
568 
569     HcfBlob out = { .data = nullptr, .len = 0 };
570     res = sign->sign(sign, nullptr, &out);
571 
572     ASSERT_EQ(res, HCF_SUCCESS);
573     ASSERT_NE(out.data, nullptr);
574     ASSERT_NE(out.len, (const unsigned int)0);
575 
576     HcfVerify *verify = nullptr;
577     res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
578 
579     ASSERT_EQ(res, HCF_SUCCESS);
580     ASSERT_NE(verify, nullptr);
581 
582     res = verify->init(verify, nullptr, keyPair->pubKey);
583     ASSERT_EQ(res, HCF_SUCCESS);
584 
585     res = verify->update(verify, &g_mockInput);
586     ASSERT_EQ(res, HCF_SUCCESS);
587 
588     bool flag = verify->verify(nullptr, nullptr, &out);
589     ASSERT_NE(flag, true);
590 
591     HcfFree(out.data);
592     HcfObjDestroy(keyPair);
593     HcfObjDestroy(sign);
594     HcfObjDestroy(verify);
595 }
596 
597 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest024, TestSize.Level0)
598 {
599     HcfSign *sign = nullptr;
600     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA224", &sign);
601 
602     ASSERT_EQ(res, HCF_SUCCESS);
603     ASSERT_NE(sign, nullptr);
604 
605     HcfKeyPair *keyPair = nullptr;
606     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
607     ASSERT_EQ(res, HCF_SUCCESS);
608     ASSERT_NE(keyPair, nullptr);
609 
610     res = sign->init(sign, nullptr, keyPair->priKey);
611     ASSERT_EQ(res, HCF_SUCCESS);
612 
613     res = sign->update(sign, &g_mockInput);
614     ASSERT_EQ(res, HCF_SUCCESS);
615 
616     HcfBlob out = { .data = nullptr, .len = 0 };
617     res = sign->sign(sign, nullptr, &out);
618 
619     ASSERT_EQ(res, HCF_SUCCESS);
620     ASSERT_NE(out.data, nullptr);
621     ASSERT_NE(out.len, (const unsigned int)0);
622 
623     HcfVerify *verify = nullptr;
624     res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
625 
626     ASSERT_EQ(res, HCF_SUCCESS);
627     ASSERT_NE(verify, nullptr);
628 
629     res = verify->init(verify, nullptr, keyPair->pubKey);
630     ASSERT_EQ(res, HCF_SUCCESS);
631 
632     res = verify->update(verify, &g_mockInput);
633     ASSERT_EQ(res, HCF_SUCCESS);
634 
635     bool flag = verify->verify((HcfVerify *)&obj, nullptr, &out);
636     ASSERT_NE(flag, true);
637 
638     HcfFree(out.data);
639     HcfObjDestroy(keyPair);
640     HcfObjDestroy(sign);
641     HcfObjDestroy(verify);
642 }
643 
644 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest025, TestSize.Level0)
645 {
646     HcfSign *sign = nullptr;
647     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA224", &sign);
648 
649     ASSERT_EQ(res, HCF_SUCCESS);
650     ASSERT_NE(sign, nullptr);
651 
652     HcfKeyPair *keyPair = nullptr;
653     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
654     ASSERT_EQ(res, HCF_SUCCESS);
655     ASSERT_NE(keyPair, nullptr);
656 
657     res = sign->init(sign, nullptr, keyPair->priKey);
658     ASSERT_EQ(res, HCF_SUCCESS);
659 
660     res = sign->update(sign, &g_mockInput);
661     ASSERT_EQ(res, HCF_SUCCESS);
662 
663     HcfBlob out = { .data = nullptr, .len = 0 };
664     res = sign->sign(sign, nullptr, &out);
665 
666     ASSERT_EQ(res, HCF_SUCCESS);
667     ASSERT_NE(out.data, nullptr);
668     ASSERT_NE(out.len, (const unsigned int)0);
669 
670     HcfVerify *verify = nullptr;
671     res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
672 
673     ASSERT_EQ(res, HCF_SUCCESS);
674     ASSERT_NE(verify, nullptr);
675 
676     res = verify->init(verify, nullptr, keyPair->pubKey);
677     ASSERT_EQ(res, HCF_SUCCESS);
678 
679     bool flag = verify->verify((HcfVerify *)(&obj), nullptr, &out);
680     ASSERT_NE(flag, true);
681 
682     HcfFree(out.data);
683     HcfObjDestroy(keyPair);
684     HcfObjDestroy(sign);
685     HcfObjDestroy(verify);
686 }
687 
688 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest026, TestSize.Level0)
689 {
690     HcfSign *sign = nullptr;
691     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA224", &sign);
692 
693     ASSERT_EQ(res, HCF_SUCCESS);
694     ASSERT_NE(sign, nullptr);
695 
696     HcfKeyPair *keyPair = nullptr;
697     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
698     ASSERT_EQ(res, HCF_SUCCESS);
699     ASSERT_NE(keyPair, nullptr);
700 
701     res = sign->init(sign, nullptr, keyPair->priKey);
702     ASSERT_EQ(res, HCF_SUCCESS);
703 
704     res = sign->update(sign, &g_mockInput);
705     ASSERT_EQ(res, HCF_SUCCESS);
706 
707     HcfBlob out = { .data = nullptr, .len = 0 };
708     res = sign->sign(sign, nullptr, &out);
709 
710     ASSERT_EQ(res, HCF_SUCCESS);
711     ASSERT_NE(out.data, nullptr);
712     ASSERT_NE(out.len, (const unsigned int)0);
713 
714     HcfVerify *verify = nullptr;
715     res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
716 
717     ASSERT_EQ(res, HCF_SUCCESS);
718     ASSERT_NE(verify, nullptr);
719 
720     res = verify->init(verify, nullptr, keyPair->pubKey);
721     ASSERT_EQ(res, HCF_SUCCESS);
722 
723     HcfBlob input = {
724         .data = nullptr,
725         .len = 1
726     };
727 
728     bool flag = verify->verify((HcfVerify *)(&obj), &input, &out);
729     ASSERT_NE(flag, true);
730 
731     HcfFree(out.data);
732     HcfObjDestroy(keyPair);
733     HcfObjDestroy(sign);
734     HcfObjDestroy(verify);
735 }
736 
737 HcfSignatureParams g_params = {
738     .algo = HCF_ALG_ECC,
739     .padding = HCF_ALG_NOPADDING,
740     .md = HCF_OPENSSL_DIGEST_SHA256,
741     .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
742 };
743 
744 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest027, TestSize.Level0)
745 {
746     HcfResult res = HcfVerifySpiEcdsaCreate(&g_params, nullptr);
747     ASSERT_EQ(res, HCF_INVALID_PARAMS);
748 }
749 
750 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest028, TestSize.Level0)
751 {
752     HcfVerifySpi *spiObj = nullptr;
753     HcfResult res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
754     ASSERT_EQ(res, HCF_SUCCESS);
755     ASSERT_NE(spiObj, nullptr);
756 
757     HcfKeyPair *keyPair = nullptr;
758     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
759     ASSERT_EQ(res, HCF_SUCCESS);
760     ASSERT_NE(keyPair, nullptr);
761 
762     res = spiObj->engineInit((HcfVerifySpi *)&obj, nullptr, keyPair->pubKey);
763     ASSERT_EQ(res, HCF_INVALID_PARAMS);
764 
765     HcfObjDestroy(spiObj);
766     HcfObjDestroy(keyPair);
767 }
768 
769 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest029, TestSize.Level0)
770 {
771     HcfVerifySpi *spiObj = nullptr;
772     HcfResult res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
773     ASSERT_EQ(res, HCF_SUCCESS);
774     ASSERT_NE(spiObj, nullptr);
775 
776     HcfKeyPair *keyPair = nullptr;
777     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
778     ASSERT_EQ(res, HCF_SUCCESS);
779     ASSERT_NE(keyPair, nullptr);
780 
781     res = spiObj->engineInit((HcfVerifySpi *)&obj, nullptr, (HcfPubKey *)&obj);
782     ASSERT_EQ(res, HCF_INVALID_PARAMS);
783 
784     HcfObjDestroy(spiObj);
785     HcfObjDestroy(keyPair);
786 }
787 
788 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest030, TestSize.Level0)
789 {
790     HcfVerifySpi *spiObj = nullptr;
791     HcfResult res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
792 
793     ASSERT_EQ(res, HCF_SUCCESS);
794     ASSERT_NE(spiObj, nullptr);
795 
796     const char *message = "hello world";
797     HcfBlob input = {
798         .data = (uint8_t *)message,
799         .len = 12
800     };
801     res = spiObj->engineUpdate(nullptr, &input);
802     ASSERT_EQ(res, HCF_INVALID_PARAMS);
803     HcfObjDestroy(spiObj);
804 }
805 
806 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest031, TestSize.Level0)
807 {
808     HcfVerifySpi *spiObj = nullptr;
809     HcfResult res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
810 
811     ASSERT_EQ(res, HCF_SUCCESS);
812     ASSERT_NE(spiObj, nullptr);
813 
814     const char *message = "hello world";
815     HcfBlob input = {
816         .data = (uint8_t *)message,
817         .len = 12
818     };
819     res = spiObj->engineUpdate((HcfVerifySpi *)&obj, &input);
820     ASSERT_EQ(res, HCF_INVALID_PARAMS);
821     HcfObjDestroy(spiObj);
822 }
823 
824 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest032, TestSize.Level0)
825 {
826     HcfVerifySpi *spiObj = nullptr;
827     HcfResult res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
828 
829     ASSERT_EQ(res, HCF_SUCCESS);
830     ASSERT_NE(spiObj, nullptr);
831 
832     res = spiObj->engineUpdate(spiObj, nullptr);
833     ASSERT_EQ(res, HCF_INVALID_PARAMS);
834     HcfObjDestroy(spiObj);
835 }
836 
837 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest033, TestSize.Level0)
838 {
839     HcfVerifySpi *spiObj = nullptr;
840     HcfResult res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
841 
842     ASSERT_EQ(res, HCF_SUCCESS);
843     ASSERT_NE(spiObj, nullptr);
844 
845     const char *message = "hello world";
846     HcfBlob input = {
847         .data = (uint8_t *)message,
848         .len = 12
849     };
850     HcfBlob out = { .data = nullptr, .len = 0 };
851     bool isOk = spiObj->engineVerify(nullptr, &input, &out);
852     ASSERT_EQ(isOk, false);
853     HcfObjDestroy(spiObj);
854 }
855 
856 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest034, TestSize.Level0)
857 {
858     HcfVerifySpi *spiObj = nullptr;
859     HcfResult res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
860 
861     ASSERT_EQ(res, HCF_SUCCESS);
862     ASSERT_NE(spiObj, nullptr);
863 
864     const char *message = "hello world";
865     HcfBlob input = {
866         .data = (uint8_t *)message,
867         .len = 12
868     };
869     bool isOk = spiObj->engineVerify((HcfVerifySpi *)&obj, &input, &input);
870     ASSERT_EQ(isOk, false);
871     HcfObjDestroy(spiObj);
872 }
873 
874 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest035, TestSize.Level0)
875 {
876     HcfVerifySpi *spiObj = nullptr;
877     HcfResult res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
878 
879     ASSERT_EQ(res, HCF_SUCCESS);
880     ASSERT_NE(spiObj, nullptr);
881 
882     spiObj->base.destroy(nullptr);
883     HcfObjDestroy(spiObj);
884 }
885 
886 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest036, TestSize.Level0)
887 {
888     HcfVerifySpi *spiObj = nullptr;
889     HcfResult res = HcfVerifySpiEcdsaCreate(&g_params, &spiObj);
890 
891     ASSERT_EQ(res, HCF_SUCCESS);
892     ASSERT_NE(spiObj, nullptr);
893 
894     spiObj->base.destroy(&obj);
895     HcfObjDestroy(spiObj);
896 }
897 
GetSignTestData(HcfBlob * out,HcfPriKey * priKey)898 static bool GetSignTestData(HcfBlob *out, HcfPriKey *priKey)
899 {
900     HcfSign *sign = nullptr;
901 
902     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA224", &sign);
903     if (res != HCF_SUCCESS) {
904         return false;
905     }
906     res = sign->init(sign, nullptr, priKey);
907     if (res != HCF_SUCCESS) {
908         HcfObjDestroy(sign);
909         return false;
910     }
911     res = sign->update(sign, &g_mockInput);
912     if (res != HCF_SUCCESS) {
913         HcfObjDestroy(sign);
914         return false;
915     }
916     res = sign->sign(sign, &g_mockInput, out);
917     HcfObjDestroy(sign);
918     return res == HCF_SUCCESS;
919 }
920 
MemoryMockTestFunc(uint32_t mallocCount,HcfBlob * out,HcfPubKey * pubKey)921 static void MemoryMockTestFunc(uint32_t mallocCount, HcfBlob *out, HcfPubKey *pubKey)
922 {
923     for (uint32_t i = 0; i < mallocCount; i++) {
924         ResetRecordMallocNum();
925         SetMockMallocIndex(i);
926         HcfVerify *verify = nullptr;
927         HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
928         if (res != HCF_SUCCESS) {
929             continue;
930         }
931         res = verify->init(verify, nullptr, pubKey);
932         if (res != HCF_SUCCESS) {
933             HcfObjDestroy(verify);
934             continue;
935         }
936         res = verify->update(verify, &g_mockInput);
937         if (res != HCF_SUCCESS) {
938             HcfObjDestroy(verify);
939             continue;
940         }
941         (void)verify->verify(verify, nullptr, out);
942         HcfObjDestroy(verify);
943     }
944 }
945 
946 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest037, TestSize.Level0)
947 {
948     StartRecordMallocNum();
949 
950     HcfVerify *verify = nullptr;
951     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
952 
953     ASSERT_EQ(res, HCF_SUCCESS);
954     ASSERT_NE(verify, nullptr);
955 
956     HcfKeyPair *keyPair = nullptr;
957     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
958     ASSERT_EQ(res, HCF_SUCCESS);
959     ASSERT_NE(keyPair, nullptr);
960 
961     res = verify->init(verify, nullptr, keyPair->pubKey);
962     ASSERT_EQ(res, HCF_SUCCESS);
963 
964     res = verify->update(verify, &g_mockInput);
965     ASSERT_EQ(res, HCF_SUCCESS);
966     HcfBlob out = { .data = nullptr, .len = 0 };
967     GetSignTestData(&out, keyPair->priKey);
968     bool flag = verify->verify(verify, &g_mockInput, &out);
969 
970     ASSERT_EQ(flag, true);
971     HcfObjDestroy(verify);
972 
973     uint32_t mallocCount = GetMallocNum();
974     MemoryMockTestFunc(mallocCount, &out, keyPair->pubKey);
975     EndRecordMallocNum();
976     HcfFree(out.data);
977     HcfObjDestroy(keyPair);
978 }
979 
OpensslMockTestFunc(uint32_t mallocCount,HcfBlob * out,HcfPubKey * pubKey)980 static void OpensslMockTestFunc(uint32_t mallocCount, HcfBlob *out, HcfPubKey *pubKey)
981 {
982     for (uint32_t i = 0; i < mallocCount; i++) {
983         ResetOpensslCallNum();
984         SetOpensslCallMockIndex(i);
985         HcfVerify *verify = nullptr;
986         HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
987         if (res != HCF_SUCCESS) {
988             continue;
989         }
990         res = verify->init(verify, nullptr, pubKey);
991         if (res != HCF_SUCCESS) {
992             HcfObjDestroy(verify);
993             continue;
994         }
995         res = verify->update(verify, &g_mockInput);
996         if (res != HCF_SUCCESS) {
997             HcfObjDestroy(verify);
998             continue;
999         }
1000         (void)verify->verify(verify, &g_mockInput, out);
1001         HcfObjDestroy(verify);
1002     }
1003 }
1004 
1005 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest038, TestSize.Level0)
1006 {
1007     StartRecordOpensslCallNum();
1008     HcfVerify *verify = nullptr;
1009     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
1010 
1011     ASSERT_EQ(res, HCF_SUCCESS);
1012     ASSERT_NE(verify, nullptr);
1013 
1014     HcfKeyPair *keyPair = nullptr;
1015     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
1016     ASSERT_EQ(res, HCF_SUCCESS);
1017     ASSERT_NE(keyPair, nullptr);
1018 
1019     res = verify->init(verify, nullptr, keyPair->pubKey);
1020     ASSERT_EQ(res, HCF_SUCCESS);
1021 
1022     res = verify->update(verify, &g_mockInput);
1023     ASSERT_EQ(res, HCF_SUCCESS);
1024 
1025     HcfBlob out = { .data = nullptr, .len = 0 };
1026     ASSERT_EQ(GetSignTestData(&out, keyPair->priKey), true);
1027     bool flag = verify->verify(verify, &g_mockInput, &out);
1028 
1029     ASSERT_EQ(flag, true);
1030     HcfObjDestroy(verify);
1031 
1032     uint32_t mallocCount = GetOpensslCallNum();
1033     OpensslMockTestFunc(mallocCount, &out, keyPair->pubKey);
1034     EndRecordOpensslCallNum();
1035     HcfFree(out.data);
1036     HcfObjDestroy(keyPair);
1037 }
1038 
1039 HWTEST_F(CryptoBrainPoolNoLengthVerifyTest, CryptoBrainPoolNoLengthVerifyTest039, TestSize.Level0)
1040 {
1041     HcfVerify *verify = nullptr;
1042     HcfResult res = HcfVerifyCreate("ECC_BrainPoolP160r1|SHA224", &verify);
1043 
1044     ASSERT_EQ(res, HCF_SUCCESS);
1045     ASSERT_NE(verify, nullptr);
1046 
1047     int32_t returnInt = 0;
1048     res = verify->setVerifySpecInt(verify, SM2_USER_ID_UINT8ARR, returnInt);
1049     ASSERT_EQ(res, HCF_NOT_SUPPORT);
1050     res = verify->getVerifySpecInt(verify, SM2_USER_ID_UINT8ARR, &returnInt);
1051     ASSERT_EQ(res, HCF_NOT_SUPPORT);
1052     HcfBlob returnBlob = { .data = nullptr, .len = 0};
1053     res = verify->setVerifySpecUint8Array(verify, SM2_USER_ID_UINT8ARR, returnBlob);
1054     ASSERT_EQ(res, HCF_NOT_SUPPORT);
1055     char *itemName = nullptr;
1056     res = verify->getVerifySpecString(verify, SM2_USER_ID_UINT8ARR, &itemName);
1057     ASSERT_EQ(res, HCF_NOT_SUPPORT);
1058 
1059     HcfObjDestroy(verify);
1060 }
1061 }