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 }