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