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 }