1 /*
2 * Copyright (c) 2022 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 "hks_ecc_sign_verify_part3_test.h"
17 #include "hks_ecc_sign_verify_test_common.h"
18
19 #include <gtest/gtest.h>
20
21 using namespace testing::ext;
22 namespace Unittest::EccSifnVerify {
23 class HksEccSignVerifyPart3Test : public testing::Test {
24 public:
25 static void SetUpTestCase(void);
26
27 static void TearDownTestCase(void);
28
29 void SetUp();
30
31 void TearDown();
32 };
33
SetUpTestCase(void)34 void HksEccSignVerifyPart3Test::SetUpTestCase(void)
35 {
36 }
37
TearDownTestCase(void)38 void HksEccSignVerifyPart3Test::TearDownTestCase(void)
39 {
40 }
41
SetUp()42 void HksEccSignVerifyPart3Test::SetUp()
43 {
44 }
45
TearDown()46 void HksEccSignVerifyPart3Test::TearDown()
47 {
48 }
49
50 static struct HksParam g_genParamsTest017[] = {
51 {
52 .tag = HKS_TAG_ALGORITHM,
53 .uint32Param = HKS_ALG_ECC
54 }, {
55 .tag = HKS_TAG_PURPOSE,
56 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
57 }, {
58 .tag = HKS_TAG_KEY_SIZE,
59 .uint32Param = HKS_ECC_KEY_SIZE_384
60 }, {
61 .tag = HKS_TAG_DIGEST,
62 .uint32Param = HKS_DIGEST_SHA384
63 }
64 };
65 static struct HksParam g_signParamsTest017[] = {
66 {
67 .tag = HKS_TAG_ALGORITHM,
68 .uint32Param = HKS_ALG_ECC
69 }, {
70 .tag = HKS_TAG_PURPOSE,
71 .uint32Param = HKS_KEY_PURPOSE_SIGN
72 }, {
73 .tag = HKS_TAG_KEY_SIZE,
74 .uint32Param = HKS_ECC_KEY_SIZE_384
75 }, {
76 .tag = HKS_TAG_DIGEST,
77 .uint32Param = HKS_DIGEST_SHA384
78 }
79 };
80 static struct HksParam g_verifyParamsTest017[] = {
81 {
82 .tag = HKS_TAG_ALGORITHM,
83 .uint32Param = HKS_ALG_ECC
84 }, {
85 .tag = HKS_TAG_PURPOSE,
86 .uint32Param = HKS_KEY_PURPOSE_VERIFY
87 }, {
88 .tag = HKS_TAG_KEY_SIZE,
89 .uint32Param = HKS_ECC_KEY_SIZE_384
90 }, {
91 .tag = HKS_TAG_DIGEST,
92 .uint32Param = HKS_DIGEST_SHA384
93 }
94 };
95
96 static struct HksParam g_genParamsTest018[] = {
97 {
98 .tag = HKS_TAG_ALGORITHM,
99 .uint32Param = HKS_ALG_ECC
100 }, {
101 .tag = HKS_TAG_PURPOSE,
102 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
103 }, {
104 .tag = HKS_TAG_KEY_SIZE,
105 .uint32Param = HKS_ECC_KEY_SIZE_384
106 }, {
107 .tag = HKS_TAG_DIGEST,
108 .uint32Param = HKS_DIGEST_SHA512
109 }
110 };
111 static struct HksParam g_signParamsTest018[] = {
112 {
113 .tag = HKS_TAG_ALGORITHM,
114 .uint32Param = HKS_ALG_ECC
115 }, {
116 .tag = HKS_TAG_PURPOSE,
117 .uint32Param = HKS_KEY_PURPOSE_SIGN
118 }, {
119 .tag = HKS_TAG_KEY_SIZE,
120 .uint32Param = HKS_ECC_KEY_SIZE_384
121 }, {
122 .tag = HKS_TAG_DIGEST,
123 .uint32Param = HKS_DIGEST_SHA512
124 }
125 };
126 static struct HksParam g_verifyParamsTest018[] = {
127 {
128 .tag = HKS_TAG_ALGORITHM,
129 .uint32Param = HKS_ALG_ECC
130 }, {
131 .tag = HKS_TAG_PURPOSE,
132 .uint32Param = HKS_KEY_PURPOSE_VERIFY
133 }, {
134 .tag = HKS_TAG_KEY_SIZE,
135 .uint32Param = HKS_ECC_KEY_SIZE_384
136 }, {
137 .tag = HKS_TAG_DIGEST,
138 .uint32Param = HKS_DIGEST_SHA512
139 }
140 };
141
142 static struct HksParam g_genParamsTest019[] = {
143 {
144 .tag = HKS_TAG_ALGORITHM,
145 .uint32Param = HKS_ALG_ECC
146 }, {
147 .tag = HKS_TAG_PURPOSE,
148 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
149 }, {
150 .tag = HKS_TAG_KEY_SIZE,
151 .uint32Param = HKS_ECC_KEY_SIZE_521
152 }, {
153 .tag = HKS_TAG_DIGEST,
154 .uint32Param = HKS_DIGEST_NONE
155 }
156 };
157 static struct HksParam g_signParamsTest019[] = {
158 {
159 .tag = HKS_TAG_ALGORITHM,
160 .uint32Param = HKS_ALG_ECC
161 }, {
162 .tag = HKS_TAG_PURPOSE,
163 .uint32Param = HKS_KEY_PURPOSE_SIGN
164 }, {
165 .tag = HKS_TAG_KEY_SIZE,
166 .uint32Param = HKS_ECC_KEY_SIZE_521
167 }, {
168 .tag = HKS_TAG_DIGEST,
169 .uint32Param = HKS_DIGEST_NONE
170 }
171 };
172 static struct HksParam g_verifyParamsTest019[] = {
173 {
174 .tag = HKS_TAG_ALGORITHM,
175 .uint32Param = HKS_ALG_ECC
176 }, {
177 .tag = HKS_TAG_PURPOSE,
178 .uint32Param = HKS_KEY_PURPOSE_VERIFY
179 }, {
180 .tag = HKS_TAG_KEY_SIZE,
181 .uint32Param = HKS_ECC_KEY_SIZE_521
182 }, {
183 .tag = HKS_TAG_DIGEST,
184 .uint32Param = HKS_DIGEST_NONE
185 }
186 };
187
188 static struct HksParam g_genParamsTest020[] = {
189 {
190 .tag = HKS_TAG_ALGORITHM,
191 .uint32Param = HKS_ALG_ECC
192 }, {
193 .tag = HKS_TAG_PURPOSE,
194 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
195 }, {
196 .tag = HKS_TAG_KEY_SIZE,
197 .uint32Param = HKS_ECC_KEY_SIZE_521
198 }, {
199 .tag = HKS_TAG_DIGEST,
200 .uint32Param = HKS_DIGEST_SHA1
201 }
202 };
203 static struct HksParam g_signParamsTest020[] = {
204 {
205 .tag = HKS_TAG_ALGORITHM,
206 .uint32Param = HKS_ALG_ECC
207 }, {
208 .tag = HKS_TAG_PURPOSE,
209 .uint32Param = HKS_KEY_PURPOSE_SIGN
210 }, {
211 .tag = HKS_TAG_KEY_SIZE,
212 .uint32Param = HKS_ECC_KEY_SIZE_521
213 }, {
214 .tag = HKS_TAG_DIGEST,
215 .uint32Param = HKS_DIGEST_SHA1
216 }
217 };
218 static struct HksParam g_verifyParamsTest020[] = {
219 {
220 .tag = HKS_TAG_ALGORITHM,
221 .uint32Param = HKS_ALG_ECC
222 }, {
223 .tag = HKS_TAG_PURPOSE,
224 .uint32Param = HKS_KEY_PURPOSE_VERIFY
225 }, {
226 .tag = HKS_TAG_KEY_SIZE,
227 .uint32Param = HKS_ECC_KEY_SIZE_521
228 }, {
229 .tag = HKS_TAG_DIGEST,
230 .uint32Param = HKS_DIGEST_SHA1
231 }
232 };
233
234 static struct HksParam g_genParamsTest021[] = {
235 {
236 .tag = HKS_TAG_ALGORITHM,
237 .uint32Param = HKS_ALG_ECC
238 }, {
239 .tag = HKS_TAG_PURPOSE,
240 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
241 }, {
242 .tag = HKS_TAG_KEY_SIZE,
243 .uint32Param = HKS_ECC_KEY_SIZE_521
244 }, {
245 .tag = HKS_TAG_DIGEST,
246 .uint32Param = HKS_DIGEST_SHA224
247 }
248 };
249 static struct HksParam g_signParamsTest021[] = {
250 {
251 .tag = HKS_TAG_ALGORITHM,
252 .uint32Param = HKS_ALG_ECC
253 }, {
254 .tag = HKS_TAG_PURPOSE,
255 .uint32Param = HKS_KEY_PURPOSE_SIGN
256 }, {
257 .tag = HKS_TAG_KEY_SIZE,
258 .uint32Param = HKS_ECC_KEY_SIZE_521
259 }, {
260 .tag = HKS_TAG_DIGEST,
261 .uint32Param = HKS_DIGEST_SHA224
262 }
263 };
264 static struct HksParam g_verifyParamsTest021[] = {
265 {
266 .tag = HKS_TAG_ALGORITHM,
267 .uint32Param = HKS_ALG_ECC
268 }, {
269 .tag = HKS_TAG_PURPOSE,
270 .uint32Param = HKS_KEY_PURPOSE_VERIFY
271 }, {
272 .tag = HKS_TAG_KEY_SIZE,
273 .uint32Param = HKS_ECC_KEY_SIZE_521
274 }, {
275 .tag = HKS_TAG_DIGEST,
276 .uint32Param = HKS_DIGEST_SHA224
277 }
278 };
279
280 static struct HksParam g_genParamsTest022[] = {
281 {
282 .tag = HKS_TAG_ALGORITHM,
283 .uint32Param = HKS_ALG_ECC
284 }, {
285 .tag = HKS_TAG_PURPOSE,
286 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
287 }, {
288 .tag = HKS_TAG_KEY_SIZE,
289 .uint32Param = HKS_ECC_KEY_SIZE_521
290 }, {
291 .tag = HKS_TAG_DIGEST,
292 .uint32Param = HKS_DIGEST_SHA256
293 }
294 };
295 static struct HksParam g_signParamsTest022[] = {
296 {
297 .tag = HKS_TAG_ALGORITHM,
298 .uint32Param = HKS_ALG_ECC
299 }, {
300 .tag = HKS_TAG_PURPOSE,
301 .uint32Param = HKS_KEY_PURPOSE_SIGN
302 }, {
303 .tag = HKS_TAG_KEY_SIZE,
304 .uint32Param = HKS_ECC_KEY_SIZE_521
305 }, {
306 .tag = HKS_TAG_DIGEST,
307 .uint32Param = HKS_DIGEST_SHA256
308 }
309 };
310 static struct HksParam g_verifyParamsTest022[] = {
311 {
312 .tag = HKS_TAG_ALGORITHM,
313 .uint32Param = HKS_ALG_ECC
314 }, {
315 .tag = HKS_TAG_PURPOSE,
316 .uint32Param = HKS_KEY_PURPOSE_VERIFY
317 }, {
318 .tag = HKS_TAG_KEY_SIZE,
319 .uint32Param = HKS_ECC_KEY_SIZE_521
320 }, {
321 .tag = HKS_TAG_DIGEST,
322 .uint32Param = HKS_DIGEST_SHA256
323 }
324 };
325
326 static struct HksParam g_genParamsTest023[] = {
327 {
328 .tag = HKS_TAG_ALGORITHM,
329 .uint32Param = HKS_ALG_ECC
330 }, {
331 .tag = HKS_TAG_PURPOSE,
332 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
333 }, {
334 .tag = HKS_TAG_KEY_SIZE,
335 .uint32Param = HKS_ECC_KEY_SIZE_521
336 }, {
337 .tag = HKS_TAG_DIGEST,
338 .uint32Param = HKS_DIGEST_SHA384
339 }
340 };
341 static struct HksParam g_signParamsTest023[] = {
342 {
343 .tag = HKS_TAG_ALGORITHM,
344 .uint32Param = HKS_ALG_ECC
345 }, {
346 .tag = HKS_TAG_PURPOSE,
347 .uint32Param = HKS_KEY_PURPOSE_SIGN
348 }, {
349 .tag = HKS_TAG_KEY_SIZE,
350 .uint32Param = HKS_ECC_KEY_SIZE_521
351 }, {
352 .tag = HKS_TAG_DIGEST,
353 .uint32Param = HKS_DIGEST_SHA384
354 }
355 };
356 static struct HksParam g_verifyParamsTest023[] = {
357 {
358 .tag = HKS_TAG_ALGORITHM,
359 .uint32Param = HKS_ALG_ECC
360 }, {
361 .tag = HKS_TAG_PURPOSE,
362 .uint32Param = HKS_KEY_PURPOSE_VERIFY
363 }, {
364 .tag = HKS_TAG_KEY_SIZE,
365 .uint32Param = HKS_ECC_KEY_SIZE_521
366 }, {
367 .tag = HKS_TAG_DIGEST,
368 .uint32Param = HKS_DIGEST_SHA384
369 }
370 };
371
372 static struct HksParam g_genParamsTest024[] = {
373 {
374 .tag = HKS_TAG_ALGORITHM,
375 .uint32Param = HKS_ALG_ECC
376 }, {
377 .tag = HKS_TAG_PURPOSE,
378 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
379 }, {
380 .tag = HKS_TAG_KEY_SIZE,
381 .uint32Param = HKS_ECC_KEY_SIZE_521
382 }, {
383 .tag = HKS_TAG_DIGEST,
384 .uint32Param = HKS_DIGEST_SHA512
385 }
386 };
387 static struct HksParam g_signParamsTest024[] = {
388 {
389 .tag = HKS_TAG_ALGORITHM,
390 .uint32Param = HKS_ALG_ECC
391 }, {
392 .tag = HKS_TAG_PURPOSE,
393 .uint32Param = HKS_KEY_PURPOSE_SIGN
394 }, {
395 .tag = HKS_TAG_KEY_SIZE,
396 .uint32Param = HKS_ECC_KEY_SIZE_521
397 }, {
398 .tag = HKS_TAG_DIGEST,
399 .uint32Param = HKS_DIGEST_SHA512
400 }
401 };
402 static struct HksParam g_verifyParamsTest024[] = {
403 {
404 .tag = HKS_TAG_ALGORITHM,
405 .uint32Param = HKS_ALG_ECC
406 }, {
407 .tag = HKS_TAG_PURPOSE,
408 .uint32Param = HKS_KEY_PURPOSE_VERIFY
409 }, {
410 .tag = HKS_TAG_KEY_SIZE,
411 .uint32Param = HKS_ECC_KEY_SIZE_521
412 }, {
413 .tag = HKS_TAG_DIGEST,
414 .uint32Param = HKS_DIGEST_SHA512
415 }
416 };
417
418 static struct HksParam g_genParamsTest025[] = {
419 {
420 .tag = HKS_TAG_ALGORITHM,
421 .uint32Param = HKS_ALG_ECC
422 }, {
423 .tag = HKS_TAG_PURPOSE,
424 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
425 }, {
426 .tag = HKS_TAG_KEY_SIZE,
427 .uint32Param = HKS_ECC_KEY_SIZE_521
428 }, {
429 .tag = HKS_TAG_DIGEST,
430 .uint32Param = HKS_DIGEST_SHA512
431 }
432 };
433 static struct HksParam g_signParamsTest025[] = {
434 {
435 .tag = HKS_TAG_ALGORITHM,
436 .uint32Param = HKS_ALG_ECC
437 }, {
438 .tag = HKS_TAG_PURPOSE,
439 .uint32Param = HKS_KEY_PURPOSE_SIGN
440 }, {
441 .tag = HKS_TAG_KEY_SIZE,
442 .uint32Param = HKS_ECC_KEY_SIZE_521
443 }, {
444 .tag = HKS_TAG_DIGEST,
445 .uint32Param = HKS_DIGEST_SHA512
446 }
447 };
448 static struct HksParam g_verifyParamsTest025[] = {
449 {
450 .tag = HKS_TAG_ALGORITHM,
451 .uint32Param = HKS_ALG_ECC
452 }, {
453 .tag = HKS_TAG_PURPOSE,
454 .uint32Param = HKS_KEY_PURPOSE_VERIFY
455 }, {
456 .tag = HKS_TAG_KEY_SIZE,
457 .uint32Param = HKS_ECC_KEY_SIZE_521
458 }, {
459 .tag = HKS_TAG_DIGEST,
460 .uint32Param = HKS_DIGEST_SHA512
461 }
462 };
463
464 static struct HksParam g_genParamsTest026[] = {
465 {
466 .tag = HKS_TAG_ALGORITHM,
467 .uint32Param = HKS_ALG_ECC
468 }, {
469 .tag = HKS_TAG_PURPOSE,
470 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
471 }, {
472 .tag = HKS_TAG_KEY_SIZE,
473 .uint32Param = HKS_ECC_KEY_SIZE_521
474 }, {
475 .tag = HKS_TAG_DIGEST,
476 .uint32Param = HKS_DIGEST_SHA512
477 }
478 };
479 static struct HksParam g_signParamsTest026[] = {
480 {
481 .tag = HKS_TAG_ALGORITHM,
482 .uint32Param = HKS_ALG_ECC
483 }, {
484 .tag = HKS_TAG_PURPOSE,
485 .uint32Param = HKS_KEY_PURPOSE_SIGN
486 }, {
487 .tag = HKS_TAG_KEY_SIZE,
488 .uint32Param = HKS_ECC_KEY_SIZE_521
489 }, {
490 .tag = HKS_TAG_DIGEST,
491 .uint32Param = HKS_DIGEST_SHA512
492 }
493 };
494
495 static struct HksParam g_genParamsTest027[] = {
496 {
497 .tag = HKS_TAG_ALGORITHM,
498 .uint32Param = HKS_ALG_ECC
499 }, {
500 .tag = HKS_TAG_PURPOSE,
501 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
502 }, {
503 .tag = HKS_TAG_KEY_SIZE,
504 .uint32Param = HKS_ECC_KEY_SIZE_521
505 }, {
506 .tag = HKS_TAG_DIGEST,
507 .uint32Param = HKS_DIGEST_SHA512
508 }
509 };
510 static struct HksParam g_signParamsTest027[] = {
511 {
512 .tag = HKS_TAG_ALGORITHM,
513 .uint32Param = HKS_ALG_ECC
514 }, {
515 .tag = HKS_TAG_PURPOSE,
516 .uint32Param = HKS_KEY_PURPOSE_SIGN
517 }, {
518 .tag = HKS_TAG_KEY_SIZE,
519 .uint32Param = HKS_ECC_KEY_SIZE_521
520 }, {
521 .tag = HKS_TAG_DIGEST,
522 .uint32Param = HKS_DIGEST_SHA512
523 }
524 };
525
526 /**
527 * @tc.name: HksEccSignVerifyPart3Test.HksEccSignVerifyTest0017
528 * @tc.desc: alg-ECC pur-Sign.
529 * @tc.type: FUNC
530 */
531 HWTEST_F(HksEccSignVerifyPart3Test, HksEccSignVerifyTest017, TestSize.Level0)
532 {
533 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest017";
534 struct HksParamSet *genParamSet = nullptr;
535 struct HksParamSet *signParamSet = nullptr;
536 struct HksParamSet *verifyParamSet = nullptr;
537 int32_t ret = HKS_FAILURE;
538 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
539
540 ret = InitParamSet(&genParamSet, g_genParamsTest017, sizeof(g_genParamsTest017)/sizeof(HksParam));
541 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
542 ret = InitParamSet(&signParamSet, g_signParamsTest017, sizeof(g_signParamsTest017)/sizeof(HksParam));
543 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
544 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest017, sizeof(g_verifyParamsTest017)/sizeof(HksParam));
545
546 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
547 ret = HksEccSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
548 }
549
550 /* Delete Key */
551 ret = HksDeleteKey(&keyAlias, genParamSet);
552 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
553
554 HksFreeParamSet(&genParamSet);
555 HksFreeParamSet(&signParamSet);
556 HksFreeParamSet(&verifyParamSet);
557 }
558
559 /**
560 * @tc.name: HksEccSignVerifyPart3Test.HksEccSignVerifyTest0018
561 * @tc.desc: alg-ECC pur-Sign.
562 * @tc.type: FUNC
563 */
564 HWTEST_F(HksEccSignVerifyPart3Test, HksEccSignVerifyTest018, TestSize.Level0)
565 {
566 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest018";
567 struct HksParamSet *genParamSet = nullptr;
568 struct HksParamSet *signParamSet = nullptr;
569 struct HksParamSet *verifyParamSet = nullptr;
570 int32_t ret = HKS_FAILURE;
571 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
572
573 ret = InitParamSet(&genParamSet, g_genParamsTest018, sizeof(g_genParamsTest018)/sizeof(HksParam));
574 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
575 ret = InitParamSet(&signParamSet, g_signParamsTest018, sizeof(g_signParamsTest018)/sizeof(HksParam));
576 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
577 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest018, sizeof(g_verifyParamsTest018)/sizeof(HksParam));
578
579 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
580 ret = HksEccSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
581 }
582
583 /* Delete Key */
584 ret = HksDeleteKey(&keyAlias, genParamSet);
585 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
586
587 HksFreeParamSet(&genParamSet);
588 HksFreeParamSet(&signParamSet);
589 HksFreeParamSet(&verifyParamSet);
590 }
591
592 /**
593 * @tc.name: HksEccSignVerifyPart3Test.HksEccSignVerifyTest0019
594 * @tc.desc: alg-ECC pur-Sign.
595 * @tc.type: FUNC
596 */
597 HWTEST_F(HksEccSignVerifyPart3Test, HksEccSignVerifyTest019, TestSize.Level0)
598 {
599 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest0019";
600 struct HksParamSet *genParamSet = nullptr;
601 struct HksParamSet *signParamSet = nullptr;
602 struct HksParamSet *verifyParamSet = nullptr;
603 int32_t ret = HKS_FAILURE;
604 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
605
606 ret = InitParamSet(&genParamSet, g_genParamsTest019, sizeof(g_genParamsTest019)/sizeof(HksParam));
607 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
608 ret = InitParamSet(&signParamSet, g_signParamsTest019, sizeof(g_signParamsTest019)/sizeof(HksParam));
609 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
610 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest019, sizeof(g_verifyParamsTest019)/sizeof(HksParam));
611
612 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
613 ret = HksEccSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
614 }
615
616 /* Delete Key */
617 ret = HksDeleteKey(&keyAlias, genParamSet);
618 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
619
620 HksFreeParamSet(&genParamSet);
621 HksFreeParamSet(&signParamSet);
622 HksFreeParamSet(&verifyParamSet);
623 }
624
625 /**
626 * @tc.name: HksEccSignVerifyPart3Test.HksEccSignVerifyTest0020
627 * @tc.desc: alg-ECC pur-Sign.
628 * @tc.type: FUNC
629 */
630 HWTEST_F(HksEccSignVerifyPart3Test, HksEccSignVerifyTest020, TestSize.Level0)
631 {
632 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest020";
633 struct HksParamSet *genParamSet = nullptr;
634 struct HksParamSet *signParamSet = nullptr;
635 struct HksParamSet *verifyParamSet = nullptr;
636 int32_t ret = HKS_FAILURE;
637 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
638
639 ret = InitParamSet(&genParamSet, g_genParamsTest020, sizeof(g_genParamsTest020)/sizeof(HksParam));
640 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
641 ret = InitParamSet(&signParamSet, g_signParamsTest020, sizeof(g_signParamsTest020)/sizeof(HksParam));
642 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
643 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest020, sizeof(g_verifyParamsTest020)/sizeof(HksParam));
644
645 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
646 ret = HksEccSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
647 }
648
649 /* Delete Key */
650 ret = HksDeleteKey(&keyAlias, genParamSet);
651 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
652
653 HksFreeParamSet(&genParamSet);
654 HksFreeParamSet(&signParamSet);
655 HksFreeParamSet(&verifyParamSet);
656 }
657
658 /**
659 * @tc.name: HksEccSignVerifyPart3Test.HksEccSignVerifyTest0021
660 * @tc.desc: alg-ECC pur-Sign.
661 * @tc.type: FUNC
662 */
663 HWTEST_F(HksEccSignVerifyPart3Test, HksEccSignVerifyTest021, TestSize.Level0)
664 {
665 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest021";
666 struct HksParamSet *genParamSet = nullptr;
667 struct HksParamSet *signParamSet = nullptr;
668 struct HksParamSet *verifyParamSet = nullptr;
669 int32_t ret = HKS_FAILURE;
670 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
671
672 ret = InitParamSet(&genParamSet, g_genParamsTest021, sizeof(g_genParamsTest021)/sizeof(HksParam));
673 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
674 ret = InitParamSet(&signParamSet, g_signParamsTest021, sizeof(g_signParamsTest021)/sizeof(HksParam));
675 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
676 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest021, sizeof(g_verifyParamsTest021)/sizeof(HksParam));
677
678 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
679 ret = HksEccSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
680 }
681
682 /* Delete Key */
683 ret = HksDeleteKey(&keyAlias, genParamSet);
684 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
685
686 HksFreeParamSet(&genParamSet);
687 HksFreeParamSet(&signParamSet);
688 HksFreeParamSet(&verifyParamSet);
689 }
690
691 /**
692 * @tc.name: HksEccSignVerifyPart3Test.HksEccSignVerifyTest0022
693 * @tc.desc: alg-ECC pur-Sign.
694 * @tc.type: FUNC
695 */
696 HWTEST_F(HksEccSignVerifyPart3Test, HksEccSignVerifyTest022, TestSize.Level0)
697 {
698 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest022";
699 struct HksParamSet *genParamSet = nullptr;
700 struct HksParamSet *signParamSet = nullptr;
701 struct HksParamSet *verifyParamSet = nullptr;
702 int32_t ret = HKS_FAILURE;
703 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
704
705 ret = InitParamSet(&genParamSet, g_genParamsTest022, sizeof(g_genParamsTest022)/sizeof(HksParam));
706 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
707 ret = InitParamSet(&signParamSet, g_signParamsTest022, sizeof(g_signParamsTest022)/sizeof(HksParam));
708 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
709 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest022, sizeof(g_verifyParamsTest022)/sizeof(HksParam));
710
711 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
712 ret = HksEccSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
713 }
714
715 /* Delete Key */
716 ret = HksDeleteKey(&keyAlias, genParamSet);
717 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
718
719 HksFreeParamSet(&genParamSet);
720 HksFreeParamSet(&signParamSet);
721 HksFreeParamSet(&verifyParamSet);
722 }
723
724 /**
725 * @tc.name: HksEccSignVerifyPart3Test.HksEccSignVerifyTest0023
726 * @tc.desc: alg-ECC pur-Sign.
727 * @tc.type: FUNC
728 */
729 HWTEST_F(HksEccSignVerifyPart3Test, HksEccSignVerifyTest023, TestSize.Level0)
730 {
731 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest023";
732 struct HksParamSet *genParamSet = nullptr;
733 struct HksParamSet *signParamSet = nullptr;
734 struct HksParamSet *verifyParamSet = nullptr;
735 int32_t ret = HKS_FAILURE;
736 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
737
738 ret = InitParamSet(&genParamSet, g_genParamsTest023, sizeof(g_genParamsTest023)/sizeof(HksParam));
739 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
740 ret = InitParamSet(&signParamSet, g_signParamsTest023, sizeof(g_signParamsTest023)/sizeof(HksParam));
741 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
742 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest023, sizeof(g_verifyParamsTest023)/sizeof(HksParam));
743
744 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
745 ret = HksEccSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
746 }
747
748 /* Delete Key */
749 ret = HksDeleteKey(&keyAlias, genParamSet);
750 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
751
752 HksFreeParamSet(&genParamSet);
753 HksFreeParamSet(&signParamSet);
754 HksFreeParamSet(&verifyParamSet);
755 }
756
757 /**
758 * @tc.name: HksEccSignVerifyPart3Test.HksEccSignVerifyTest0024
759 * @tc.desc: alg-ECC pur-Sign.
760 * @tc.type: FUNC
761 */
762 HWTEST_F(HksEccSignVerifyPart3Test, HksEccSignVerifyTest024, TestSize.Level0)
763 {
764 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest024";
765 struct HksParamSet *genParamSet = nullptr;
766 struct HksParamSet *signParamSet = nullptr;
767 struct HksParamSet *verifyParamSet = nullptr;
768 int32_t ret = HKS_FAILURE;
769 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
770
771 ret = InitParamSet(&genParamSet, g_genParamsTest024, sizeof(g_genParamsTest024)/sizeof(HksParam));
772 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
773 ret = InitParamSet(&signParamSet, g_signParamsTest024, sizeof(g_signParamsTest024)/sizeof(HksParam));
774 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
775 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest024, sizeof(g_verifyParamsTest024)/sizeof(HksParam));
776
777 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
778 ret = HksEccSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
779 }
780
781 /* Delete Key */
782 ret = HksDeleteKey(&keyAlias, genParamSet);
783 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
784
785 HksFreeParamSet(&genParamSet);
786 HksFreeParamSet(&signParamSet);
787 HksFreeParamSet(&verifyParamSet);
788 }
789
790 /**
791 * @tc.name: HksEccSignVerifyPart3Test.HksEccSignVerifyTest0025
792 * @tc.desc: alg-ECC pur-Sign. Verify-Abort
793 * @tc.type: FUNC
794 */
795 HWTEST_F(HksEccSignVerifyPart3Test, HksEccSignVerifyTest025, TestSize.Level0)
796 {
797 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest025";
798 struct HksParamSet *genParamSet = nullptr;
799 struct HksParamSet *signParamSet = nullptr;
800 struct HksParamSet *verifyParamSet = nullptr;
801 int32_t ret = HKS_FAILURE;
802 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
803
804 ret = InitParamSet(&genParamSet, g_genParamsTest025, sizeof(g_genParamsTest025)/sizeof(HksParam));
805 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
806 ret = InitParamSet(&signParamSet, g_signParamsTest025, sizeof(g_signParamsTest025)/sizeof(HksParam));
807 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
808 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest025, sizeof(g_verifyParamsTest025)/sizeof(HksParam));
809
810 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
811 ret = HksEccSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
812 }
813
814 /* Delete Key */
815 ret = HksDeleteKey(&keyAlias, genParamSet);
816 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
817
818 HksFreeParamSet(&genParamSet);
819 HksFreeParamSet(&signParamSet);
820 HksFreeParamSet(&verifyParamSet);
821 }
822
823 /**
824 * @tc.name: HksEccSignVerifyPart3Test.HksEccSignVerifyTest0026
825 * @tc.desc: alg-ECC pur-Sign. Sign-Abort
826 * @tc.type: FUNC
827 */
828 HWTEST_F(HksEccSignVerifyPart3Test, HksEccSignVerifyTest026, TestSize.Level0)
829 {
830 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest026";
831 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
832 struct HksBlob inData = { Unittest::EccSifnVerify::g_inData.length(),
833 (uint8_t *)Unittest::EccSifnVerify::g_inData.c_str() };
834 int32_t ret = HKS_FAILURE;
835
836 /* 1. Generate Key */
837 struct HksParamSet *genParamSet = nullptr;
838 ret = InitParamSet(&genParamSet, g_genParamsTest026, sizeof(g_genParamsTest026)/sizeof(HksParam));
839 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
840 // Generate Key
841 ret = HksGenerateKey(&keyAlias, genParamSet, nullptr);
842 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey failed.";
843
844 /* 2. Sign Three Stage (Abort) */
845 struct HksParamSet *signParamSet = nullptr;
846 ret = InitParamSet(&signParamSet, g_signParamsTest026, sizeof(g_signParamsTest026)/sizeof(HksParam));
847 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
848 // Init
849 uint8_t handleS[sizeof(uint64_t)] = {0};
850 struct HksBlob handleSign = { sizeof(uint64_t), handleS };
851 ret = HksInit(&keyAlias, signParamSet, &handleSign);
852 EXPECT_EQ(ret, HKS_SUCCESS) << "Init failed.";
853 // Update loop
854 ret = HksTestUpdate(&handleSign, signParamSet, &inData);
855 EXPECT_EQ(ret, HKS_SUCCESS) << "Update failed.";
856 // Abort
857 ret = HksAbort(&handleSign, signParamSet);
858 EXPECT_EQ(ret, HKS_SUCCESS) << "Abort failed.";
859
860 /* 3. Delete Key */
861 ret = HksDeleteKey(&keyAlias, genParamSet);
862 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
863
864 HksFreeParamSet(&genParamSet);
865 HksFreeParamSet(&signParamSet);
866 }
867
868 /**
869 * @tc.name: HksEccSignVerifyPart3Test.HksEccSignVerifyTest0027
870 * @tc.desc: alg-ECC pur-Sign. abnormal
871 * @tc.type: FUNC
872 */
873 HWTEST_F(HksEccSignVerifyPart3Test, HksEccSignVerifyTest027, TestSize.Level0)
874 {
875 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest027";
876 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
877 int32_t ret = HKS_FAILURE;
878
879 /* 1. Generate Key */
880 struct HksParamSet *genParamSet = nullptr;
881 ret = InitParamSet(&genParamSet, g_genParamsTest027, sizeof(g_genParamsTest027)/sizeof(HksParam));
882 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
883 // Generate Key
884 ret = HksGenerateKey(&keyAlias, genParamSet, nullptr);
885 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey failed.";
886
887 /* 2. Sign Three Stage */
888 struct HksParamSet *signParamSet = nullptr;
889 ret = InitParamSet(&signParamSet, g_signParamsTest027, sizeof(g_signParamsTest027)/sizeof(HksParam));
890 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
891 // Init
892 uint8_t handleS[sizeof(uint64_t)] = {0};
893 struct HksBlob handleSign = { sizeof(uint64_t), handleS };
894 ret = HksInit(NULL, signParamSet, &handleSign);
895 EXPECT_NE(ret, HKS_SUCCESS) << "Init failed.";
896
897 /* 3. Delete Key */
898 ret = HksDeleteKey(&keyAlias, genParamSet);
899 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
900
901 HksFreeParamSet(&genParamSet);
902 HksFreeParamSet(&signParamSet);
903 }
904 }