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 "object_base.h"
35 #include "ecc_common_param_spec_generator_openssl.h"
36 
37 using namespace std;
38 using namespace testing::ext;
39 
40 namespace {
41 class CryptoBrainPoolNoLengthSignTest : public testing::Test {
42 public:
SetUpTestCase()43     static void SetUpTestCase() {};
TearDownTestCase()44     static void TearDownTestCase() {};
45     void SetUp();
46     void TearDown();
47 };
48 
49 static string g_brainpool160r1AlgName = "ECC_BrainPoolP160r1";
50 static string g_brainpool160r1CurveName = "NID_brainpoolP160r1";
51 
SetUp()52 void CryptoBrainPoolNoLengthSignTest::SetUp() {}
TearDown()53 void CryptoBrainPoolNoLengthSignTest::TearDown() {}
54 
55 static const char *g_mockMessage = "hello world";
56 static HcfBlob g_mockInput = {
57     .data = (uint8_t *)g_mockMessage,
58     .len = 12
59 };
60 
GetMockClass(void)61 static const char *GetMockClass(void)
62 {
63     return "HcfSymKeyGenerator";
64 }
65 
66 HcfObjectBase obj = {
67     .getClass = GetMockClass,
68     .destroy = nullptr
69 };
70 
HcfSignCreateTest(const char * algName)71 static HcfResult HcfSignCreateTest(const char *algName)
72 {
73     HcfSign *sign = nullptr;
74     HcfResult res = HcfSignCreate(algName, &sign);
75     if (res == HCF_SUCCESS) {
76         HcfObjDestroy(sign);
77     }
78     return res;
79 }
80 
81 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest001_1, TestSize.Level0)
82 {
83     HcfResult res = HcfSignCreateTest("ECC_BrainPoolP160r1|SHA1");
84     ASSERT_EQ(res, HCF_SUCCESS);
85 }
86 
87 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest001_2, TestSize.Level0)
88 {
89     HcfResult res = HcfSignCreateTest("ECC_BrainPoolP160r1|SHA224");
90     ASSERT_EQ(res, HCF_SUCCESS);
91 }
92 
93 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest001_3, TestSize.Level0)
94 {
95     HcfResult res = HcfSignCreateTest("ECC_BrainPoolP160r1|SHA256");
96     ASSERT_EQ(res, HCF_SUCCESS);
97 }
98 
99 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest001_4, TestSize.Level0)
100 {
101     HcfResult res = HcfSignCreateTest("ECC_BrainPoolP160r1|SHA384");
102     ASSERT_EQ(res, HCF_SUCCESS);
103 }
104 
105 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest001_5, TestSize.Level0)
106 {
107     HcfResult res = HcfSignCreateTest("ECC_BrainPoolP160r1|SHA512");
108     ASSERT_EQ(res, HCF_SUCCESS);
109 }
110 
111 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest001_6, TestSize.Level0)
112 {
113     HcfResult res = HcfSignCreateTest("ECC_BrainPoolP160r1|MD5");
114     ASSERT_EQ(res, HCF_SUCCESS);
115 }
116 
117 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest002, TestSize.Level0)
118 {
119     HcfSign *sign = nullptr;
120     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
121     ASSERT_EQ(res, HCF_SUCCESS);
122     ASSERT_NE(sign, nullptr);
123 
124     const char *className = sign->base.getClass();
125     ASSERT_NE(className, nullptr);
126     HcfObjDestroy(sign);
127 }
128 
129 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest003, TestSize.Level0)
130 {
131     HcfSign *sign = nullptr;
132     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
133     ASSERT_EQ(res, HCF_SUCCESS);
134     ASSERT_NE(sign, nullptr);
135     sign->base.destroy((HcfObjectBase *)sign);
136 }
137 
138 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest004, TestSize.Level0)
139 {
140     HcfSign *sign = nullptr;
141     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
142     ASSERT_EQ(res, HCF_SUCCESS);
143     ASSERT_NE(sign, nullptr);
144     sign->base.destroy(nullptr);
145 }
146 
147 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest005, TestSize.Level0)
148 {
149     HcfSign *sign = nullptr;
150     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
151     ASSERT_EQ(res, HCF_SUCCESS);
152     ASSERT_NE(sign, nullptr);
153 
154     sign->base.destroy(&obj);
155     HcfObjDestroy(sign);
156 }
157 
158 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest006, TestSize.Level0)
159 {
160     HcfSign *sign = nullptr;
161     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
162     ASSERT_EQ(res, HCF_SUCCESS);
163     ASSERT_NE(sign, nullptr);
164 
165     const char *algName = sign->getAlgoName(sign);
166     ASSERT_NE(algName, nullptr);
167     HcfObjDestroy(sign);
168 }
169 
170 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest007, TestSize.Level0)
171 {
172     HcfSign *sign = nullptr;
173     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
174     ASSERT_EQ(res, HCF_SUCCESS);
175     ASSERT_NE(sign, nullptr);
176 
177     const char *algName = sign->getAlgoName(nullptr);
178     ASSERT_EQ(algName, nullptr);
179     HcfObjDestroy(sign);
180 }
181 
182 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest008, TestSize.Level0)
183 {
184     HcfSign *sign = nullptr;
185     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
186     ASSERT_EQ(res, HCF_SUCCESS);
187     ASSERT_NE(sign, nullptr);
188 
189     const char *algName = sign->getAlgoName((HcfSign *)&obj);
190     ASSERT_EQ(algName, nullptr);
191     HcfObjDestroy(sign);
192 }
193 
194 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest009, TestSize.Level0)
195 {
196     HcfSign *sign = nullptr;
197     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
198     ASSERT_EQ(res, HCF_SUCCESS);
199     ASSERT_NE(sign, nullptr);
200 
201     HcfKeyPair *keyPair = nullptr;
202     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
203     ASSERT_EQ(res, HCF_SUCCESS);
204     ASSERT_NE(keyPair, nullptr);
205 
206     res = sign->init(sign, nullptr, keyPair->priKey);
207     ASSERT_EQ(res, HCF_SUCCESS);
208 
209     HcfObjDestroy(sign);
210     HcfObjDestroy(keyPair);
211 }
212 
213 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest010, TestSize.Level0)
214 {
215     HcfSign *sign = nullptr;
216     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
217     ASSERT_EQ(res, HCF_SUCCESS);
218     ASSERT_NE(sign, nullptr);
219 
220     HcfKeyPair *keyPair = nullptr;
221     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
222     ASSERT_EQ(res, HCF_SUCCESS);
223     ASSERT_NE(keyPair, nullptr);
224 
225     res = sign->init(nullptr, nullptr, keyPair->priKey);
226     ASSERT_NE(res, HCF_SUCCESS);
227 
228     HcfObjDestroy(sign);
229     HcfObjDestroy(keyPair);
230 }
231 
232 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest011, TestSize.Level0)
233 {
234     HcfSign *sign = nullptr;
235     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
236     ASSERT_EQ(res, HCF_SUCCESS);
237     ASSERT_NE(sign, nullptr);
238 
239     HcfKeyPair *keyPair = nullptr;
240     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
241     ASSERT_EQ(res, HCF_SUCCESS);
242     ASSERT_NE(keyPair, nullptr);
243 
244     res = sign->init((HcfSign *)(&obj), nullptr, keyPair->priKey);
245     ASSERT_NE(res, HCF_SUCCESS);
246 
247     HcfObjDestroy(sign);
248     HcfObjDestroy(keyPair);
249 }
250 
251 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest012, TestSize.Level0)
252 {
253     HcfSign *sign = nullptr;
254     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
255     ASSERT_EQ(res, HCF_SUCCESS);
256     ASSERT_NE(sign, nullptr);
257 
258     HcfKeyPair *keyPair = nullptr;
259     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
260     ASSERT_EQ(res, HCF_SUCCESS);
261     ASSERT_NE(keyPair, nullptr);
262 
263     res = sign->init(sign, nullptr, keyPair->priKey);
264     ASSERT_EQ(res, HCF_SUCCESS);
265 
266     res = sign->init(sign, nullptr, keyPair->priKey);
267     ASSERT_NE(res, HCF_SUCCESS);
268 
269     HcfObjDestroy(sign);
270     HcfObjDestroy(keyPair);
271 }
272 
273 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest013, TestSize.Level0)
274 {
275     HcfSign *sign = nullptr;
276     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
277     ASSERT_EQ(res, HCF_SUCCESS);
278     ASSERT_NE(sign, nullptr);
279 
280     res = sign->init(sign, nullptr, nullptr);
281     ASSERT_EQ(res, HCF_INVALID_PARAMS);
282     HcfObjDestroy(sign);
283 }
284 
285 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest014, TestSize.Level0)
286 {
287     HcfSign *sign = nullptr;
288     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
289     ASSERT_EQ(res, HCF_SUCCESS);
290     ASSERT_NE(sign, nullptr);
291 
292     res = sign->init(sign, nullptr, (HcfPriKey *)(&obj));
293     ASSERT_EQ(res, HCF_INVALID_PARAMS);
294     HcfObjDestroy(sign);
295 }
296 
297 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest015, TestSize.Level0)
298 {
299     HcfSign *sign = nullptr;
300     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
301     ASSERT_EQ(res, HCF_SUCCESS);
302     ASSERT_NE(sign, nullptr);
303 
304     res = sign->init(sign, nullptr, (HcfPriKey *)(&obj));
305     ASSERT_EQ(res, HCF_INVALID_PARAMS);
306 
307     HcfBlob mockInput = {
308         .data = (uint8_t *)g_mockMessage,
309         .len = 1
310     };
311     res = sign->update(sign, &mockInput);
312     ASSERT_EQ(res, HCF_INVALID_PARAMS);
313     HcfObjDestroy(sign);
314 }
315 
316 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest016, TestSize.Level0)
317 {
318     HcfSign *sign = nullptr;
319     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
320     ASSERT_EQ(res, HCF_SUCCESS);
321     ASSERT_NE(sign, nullptr);
322 
323     res = sign->init(sign, nullptr, (HcfPriKey *)(&obj));
324     ASSERT_EQ(res, HCF_INVALID_PARAMS);
325 
326     HcfBlob mockInput = {
327         .data = (uint8_t *)g_mockMessage,
328         .len = 1
329     };
330     res = sign->update(nullptr, &mockInput);
331     ASSERT_EQ(res, HCF_INVALID_PARAMS);
332     HcfObjDestroy(sign);
333 }
334 
335 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest017, TestSize.Level0)
336 {
337     HcfSign *sign = nullptr;
338     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
339     ASSERT_EQ(res, HCF_SUCCESS);
340     ASSERT_NE(sign, nullptr);
341 
342     res = sign->init(sign, nullptr, (HcfPriKey *)(&obj));
343     ASSERT_EQ(res, HCF_INVALID_PARAMS);
344     HcfBlob mockInput = {
345         .data = (uint8_t *)g_mockMessage,
346         .len = 1
347     };
348 
349     res = sign->update((HcfSign *)(&obj), &mockInput);
350     ASSERT_EQ(res, HCF_INVALID_PARAMS);
351     HcfObjDestroy(sign);
352 }
353 
354 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest018, TestSize.Level0)
355 {
356     HcfSign *sign = nullptr;
357     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
358 
359     ASSERT_EQ(res, HCF_SUCCESS);
360     ASSERT_NE(sign, nullptr);
361 
362     HcfBlob mockInput = {
363         .data = (uint8_t *)g_mockMessage,
364         .len = 1
365     };
366 
367     res = sign->update(sign, &mockInput);
368     ASSERT_EQ(res, HCF_INVALID_PARAMS);
369     HcfObjDestroy(sign);
370 }
371 
372 
373 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest019, TestSize.Level0)
374 {
375     HcfSign *sign = nullptr;
376     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
377     ASSERT_EQ(res, HCF_SUCCESS);
378     ASSERT_NE(sign, nullptr);
379 
380     HcfKeyPair *keyPair = nullptr;
381     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
382     ASSERT_EQ(res, HCF_SUCCESS);
383     ASSERT_NE(keyPair, nullptr);
384 
385     res = sign->init(sign, nullptr, keyPair->priKey);
386     ASSERT_EQ(res, HCF_SUCCESS);
387 
388     res = sign->update(sign, nullptr);
389     ASSERT_EQ(res, HCF_INVALID_PARAMS);
390 
391     HcfObjDestroy(sign);
392     HcfObjDestroy(keyPair);
393 }
394 
395 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest020, TestSize.Level0)
396 {
397     HcfSign *sign = nullptr;
398     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
399     ASSERT_EQ(res, HCF_SUCCESS);
400     ASSERT_NE(sign, nullptr);
401 
402     HcfKeyPair *keyPair = nullptr;
403     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
404     ASSERT_EQ(res, HCF_SUCCESS);
405     ASSERT_NE(keyPair, nullptr);
406 
407     res = sign->init(sign, nullptr, keyPair->priKey);
408     ASSERT_EQ(res, HCF_SUCCESS);
409 
410     HcfBlob input = {
411         .data = nullptr,
412         .len = 1
413     };
414 
415     res = sign->update(sign, &input);
416     ASSERT_EQ(res, HCF_INVALID_PARAMS);
417 
418     HcfObjDestroy(sign);
419     HcfObjDestroy(keyPair);
420     HcfBlobDataFree(&input);
421 }
422 
423 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest021, TestSize.Level0)
424 {
425     HcfSign *sign = nullptr;
426     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
427 
428     ASSERT_EQ(res, HCF_SUCCESS);
429     ASSERT_NE(sign, nullptr);
430 
431     HcfKeyPair *keyPair = nullptr;
432     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
433     ASSERT_EQ(res, HCF_SUCCESS);
434     ASSERT_NE(keyPair, nullptr);
435 
436     res = sign->init(sign, nullptr, keyPair->priKey);
437     ASSERT_EQ(res, HCF_SUCCESS);
438 
439     HcfBlob input = {
440         .data = (uint8_t *)g_mockMessage,
441         .len = 0
442     };
443 
444     res = sign->update(sign, &input);
445     ASSERT_NE(res, HCF_SUCCESS);
446 
447     HcfObjDestroy(sign);
448     HcfObjDestroy(keyPair);
449 }
450 
451 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest022, TestSize.Level0)
452 {
453     HcfSign *sign = nullptr;
454     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
455     ASSERT_EQ(res, HCF_SUCCESS);
456     ASSERT_NE(sign, nullptr);
457 
458     HcfKeyPair *keyPair = nullptr;
459     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
460     ASSERT_EQ(res, HCF_SUCCESS);
461     ASSERT_NE(keyPair, nullptr);
462 
463     res = sign->init(sign, nullptr, keyPair->priKey);
464     ASSERT_EQ(res, HCF_SUCCESS);
465 
466     res = sign->update(sign, &g_mockInput);
467     ASSERT_EQ(res, HCF_SUCCESS);
468 
469     HcfBlob out = { .data = nullptr, .len = 0 };
470     res = sign->sign(sign, nullptr, &out);
471     ASSERT_EQ(res, HCF_SUCCESS);
472     ASSERT_NE(out.data, nullptr);
473     ASSERT_NE(out.len, (const unsigned int)0);
474 
475     HcfFree(out.data);
476     HcfObjDestroy(sign);
477     HcfObjDestroy(keyPair);
478 }
479 
480 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest023, TestSize.Level0)
481 {
482     HcfSign *sign = nullptr;
483     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
484     ASSERT_EQ(res, HCF_SUCCESS);
485     ASSERT_NE(sign, nullptr);
486 
487     HcfKeyPair *keyPair = nullptr;
488     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
489     ASSERT_EQ(res, HCF_SUCCESS);
490     ASSERT_NE(keyPair, nullptr);
491 
492     res = sign->init(sign, nullptr, keyPair->priKey);
493     ASSERT_EQ(res, HCF_SUCCESS);
494 
495     HcfBlob out = { .data = nullptr, .len = 0 };
496     res = sign->sign(sign, &g_mockInput, &out);
497     ASSERT_EQ(res, HCF_SUCCESS);
498     ASSERT_NE(out.data, nullptr);
499     ASSERT_NE(out.len, (const unsigned int)0);
500 
501     HcfFree(out.data);
502     HcfObjDestroy(sign);
503     HcfObjDestroy(keyPair);
504 }
505 
506 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest024, TestSize.Level0)
507 {
508     HcfSign *sign = nullptr;
509     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
510     ASSERT_EQ(res, HCF_SUCCESS);
511     ASSERT_NE(sign, nullptr);
512 
513     HcfKeyPair *keyPair = nullptr;
514     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
515     ASSERT_EQ(res, HCF_SUCCESS);
516     ASSERT_NE(keyPair, nullptr);
517 
518     res = sign->init(sign, nullptr, keyPair->priKey);
519     ASSERT_EQ(res, HCF_SUCCESS);
520 
521     res = sign->update(sign, &g_mockInput);
522     ASSERT_EQ(res, HCF_SUCCESS);
523 
524     HcfBlob out = { .data = nullptr, .len = 0 };
525     res = sign->sign(nullptr, nullptr, &out);
526     ASSERT_EQ(res, HCF_INVALID_PARAMS);
527     ASSERT_EQ(out.data, nullptr);
528     ASSERT_EQ(out.len, (const unsigned int)0);
529 
530     HcfObjDestroy(sign);
531     HcfObjDestroy(keyPair);
532 }
533 
534 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest025, TestSize.Level0)
535 {
536     HcfSign *sign = nullptr;
537     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
538     ASSERT_EQ(res, HCF_SUCCESS);
539     ASSERT_NE(sign, nullptr);
540 
541     HcfKeyPair *keyPair = nullptr;
542     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
543     ASSERT_EQ(res, HCF_SUCCESS);
544     ASSERT_NE(keyPair, nullptr);
545 
546     res = sign->init(sign, nullptr, keyPair->priKey);
547     ASSERT_EQ(res, HCF_SUCCESS);
548 
549     HcfBlob out = { .data = nullptr, .len = 0 };
550     res = sign->sign((HcfSign *)(&obj), nullptr, &out);
551     ASSERT_EQ(res, HCF_INVALID_PARAMS);
552     ASSERT_EQ(out.data, nullptr);
553     ASSERT_EQ(out.len, (const unsigned int)0);
554 
555     HcfObjDestroy(sign);
556     HcfObjDestroy(keyPair);
557 }
558 
559 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest026, TestSize.Level0)
560 {
561     HcfSign *sign = nullptr;
562     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
563     ASSERT_EQ(res, HCF_SUCCESS);
564     ASSERT_NE(sign, nullptr);
565 
566     HcfKeyPair *keyPair = nullptr;
567     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
568     ASSERT_EQ(res, HCF_SUCCESS);
569     ASSERT_NE(keyPair, nullptr);
570 
571     res = sign->init(sign, nullptr, keyPair->priKey);
572     ASSERT_EQ(res, HCF_SUCCESS);
573 
574     HcfBlob out = {
575         .data = nullptr,
576         .len = 0
577     };
578     res = sign->sign(sign, nullptr, &out);
579     ASSERT_EQ(res, HCF_INVALID_PARAMS);
580     ASSERT_EQ(out.data, nullptr);
581     ASSERT_EQ(out.len, (const unsigned int)0);
582 
583     HcfObjDestroy(sign);
584     HcfObjDestroy(keyPair);
585 }
586 
587 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest027, TestSize.Level0)
588 {
589     HcfSign *sign = nullptr;
590     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
591     ASSERT_EQ(res, HCF_SUCCESS);
592     ASSERT_NE(sign, nullptr);
593 
594     HcfKeyPair *keyPair = nullptr;
595     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
596     ASSERT_EQ(res, HCF_SUCCESS);
597     ASSERT_NE(keyPair, nullptr);
598 
599     res = sign->init(sign, nullptr, keyPair->priKey);
600     ASSERT_EQ(res, HCF_SUCCESS);
601 
602     HcfBlob input = {
603         .data = nullptr,
604         .len = 1
605     };
606     HcfBlob out = {
607         .data = nullptr,
608         .len = 0
609     };
610     res = sign->sign(sign, &input, &out);
611     ASSERT_EQ(res, HCF_INVALID_PARAMS);
612     ASSERT_EQ(out.data, nullptr);
613     ASSERT_EQ(out.len, (const unsigned int)0);
614 
615     HcfObjDestroy(sign);
616     HcfObjDestroy(keyPair);
617 }
618 
619 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest028, TestSize.Level0)
620 {
621     HcfSign *sign = nullptr;
622     HcfResult res = HcfSignCreate("ECC_BrainPoolP160r1|SHA256", &sign);
623     ASSERT_EQ(res, HCF_SUCCESS);
624     ASSERT_NE(sign, nullptr);
625 
626     HcfKeyPair *keyPair = nullptr;
627     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
628     ASSERT_EQ(res, HCF_SUCCESS);
629     ASSERT_NE(keyPair, nullptr);
630 
631     res = sign->init(sign, nullptr, keyPair->priKey);
632     ASSERT_EQ(res, HCF_SUCCESS);
633 
634     HcfBlob input = {
635         .data = (uint8_t *)g_mockMessage,
636         .len = 0
637     };
638     HcfBlob out = {
639         .data = nullptr,
640         .len = 0
641     };
642     res = sign->sign(sign, &input, &out);
643     ASSERT_EQ(res, HCF_INVALID_PARAMS);
644     ASSERT_EQ(out.data, nullptr);
645     ASSERT_EQ(out.len, (const unsigned int)0);
646 
647     HcfObjDestroy(sign);
648     HcfObjDestroy(keyPair);
649 }
650 
651 HcfSignatureParams g_params = {
652     .algo = HCF_ALG_ECC,
653     .padding = HCF_ALG_NOPADDING,
654     .md = HCF_OPENSSL_DIGEST_SHA256,
655     .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
656 };
657 
658 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest029, TestSize.Level0)
659 {
660     HcfResult res = HcfSignSpiEcdsaCreate(&g_params, nullptr);
661     ASSERT_EQ(res, HCF_INVALID_PARAMS);
662 }
663 
664 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest030, TestSize.Level0)
665 {
666     HcfSignSpi *spiObj = nullptr;
667     HcfResult res = HcfSignSpiEcdsaCreate(&g_params, &spiObj);
668 
669     ASSERT_EQ(res, HCF_SUCCESS);
670     ASSERT_NE(spiObj, nullptr);
671 
672     HcfKeyPair *keyPair = nullptr;
673     res = GenerateBrainpoolP160r1KeyPair(&keyPair);
674     ASSERT_EQ(res, HCF_SUCCESS);
675     ASSERT_NE(keyPair, nullptr);
676 
677     res = spiObj->engineInit((HcfSignSpi *)&obj, nullptr, keyPair->priKey);
678     ASSERT_EQ(res, HCF_INVALID_PARAMS);
679 
680     HcfObjDestroy(spiObj);
681     HcfObjDestroy(keyPair);
682 }
683 
684 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest031, TestSize.Level0)
685 {
686     HcfSignSpi *spiObj = nullptr;
687     HcfResult res = HcfSignSpiEcdsaCreate(&g_params, &spiObj);
688 
689     ASSERT_EQ(res, HCF_SUCCESS);
690     ASSERT_NE(spiObj, nullptr);
691 
692     res = spiObj->engineInit(spiObj, nullptr, (HcfPriKey *)&obj);
693     ASSERT_EQ(res, HCF_INVALID_PARAMS);
694     HcfObjDestroy(spiObj);
695 }
696 
697 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest032, TestSize.Level0)
698 {
699     HcfSignSpi *spiObj = nullptr;
700     HcfResult res = HcfSignSpiEcdsaCreate(&g_params, &spiObj);
701     ASSERT_EQ(res, HCF_SUCCESS);
702     ASSERT_NE(spiObj, nullptr);
703 
704     const char *message = "hello world";
705     HcfBlob input = {
706         .data = (uint8_t *)message,
707         .len = 12
708     };
709     res = spiObj->engineUpdate(nullptr, &input);
710     ASSERT_EQ(res, HCF_INVALID_PARAMS);
711     HcfObjDestroy(spiObj);
712 }
713 
714 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest033, TestSize.Level0)
715 {
716     HcfSignSpi *spiObj = nullptr;
717     HcfResult res = HcfSignSpiEcdsaCreate(&g_params, &spiObj);
718     ASSERT_EQ(res, HCF_SUCCESS);
719     ASSERT_NE(spiObj, nullptr);
720 
721     const char *message = "hello world";
722     HcfBlob input = {
723         .data = (uint8_t *)message,
724         .len = 12
725     };
726     res = spiObj->engineUpdate((HcfSignSpi *)&obj, &input);
727     ASSERT_EQ(res, HCF_INVALID_PARAMS);
728     HcfObjDestroy(spiObj);
729 }
730 
731 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest034, TestSize.Level0)
732 {
733     HcfSignSpi *spiObj = nullptr;
734     HcfResult res = HcfSignSpiEcdsaCreate(&g_params, &spiObj);
735     ASSERT_EQ(res, HCF_SUCCESS);
736     ASSERT_NE(spiObj, nullptr);
737 
738     res = spiObj->engineUpdate(spiObj, nullptr);
739     ASSERT_EQ(res, HCF_INVALID_PARAMS);
740     HcfObjDestroy(spiObj);
741 }
742 
743 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest035, TestSize.Level0)
744 {
745     HcfSignSpi *spiObj = nullptr;
746     HcfResult res = HcfSignSpiEcdsaCreate(&g_params, &spiObj);
747     ASSERT_EQ(res, HCF_SUCCESS);
748     ASSERT_NE(spiObj, nullptr);
749 
750     const char *message = "hello world";
751     HcfBlob input = {
752         .data = (uint8_t *)message,
753         .len = 12
754     };
755     HcfBlob out = { .data = nullptr, .len = 0 };
756     res = spiObj->engineSign((HcfSignSpi *)&obj, &input, &out);
757     ASSERT_EQ(res, HCF_INVALID_PARAMS);
758     HcfObjDestroy(spiObj);
759 }
760 
761 HWTEST_F(CryptoBrainPoolNoLengthSignTest, CryptoBrainPoolNoLengthSignTest036, TestSize.Level0)
762 {
763     HcfSign *sign = nullptr;
764     HcfResult ret = HcfSignCreate("ECC_BrainPoolP160r1|SHA1", &sign);
765     ASSERT_EQ(ret, HCF_SUCCESS);
766     ASSERT_NE(sign, nullptr);
767 
768     int32_t returnInt = 0;
769     ret = sign->setSignSpecInt(sign, SM2_USER_ID_UINT8ARR, returnInt);
770     ASSERT_EQ(ret, HCF_NOT_SUPPORT);
771     ret = sign->getSignSpecInt(sign, SM2_USER_ID_UINT8ARR, &returnInt);
772     ASSERT_EQ(ret, HCF_NOT_SUPPORT);
773     HcfBlob returnBlob = { .data = nullptr, .len = 0};
774     ret = sign->setSignSpecUint8Array(sign, SM2_USER_ID_UINT8ARR, returnBlob);
775     ASSERT_EQ(ret, HCF_NOT_SUPPORT);
776     char *itemName = nullptr;
777     ret = sign->getSignSpecString(sign, SM2_USER_ID_UINT8ARR, &itemName);
778     ASSERT_EQ(ret, HCF_NOT_SUPPORT);
779 
780     HcfObjDestroy(sign);
781 }
782 }