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_part1_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 HksEccSignVerifyPart1Test : 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 HksEccSignVerifyPart1Test::SetUpTestCase(void)
35 {
36 }
37
TearDownTestCase(void)38 void HksEccSignVerifyPart1Test::TearDownTestCase(void)
39 {
40 }
41
SetUp()42 void HksEccSignVerifyPart1Test::SetUp()
43 {
44 }
45
TearDown()46 void HksEccSignVerifyPart1Test::TearDown()
47 {
48 }
49
50 static struct HksParam g_genParamsTest001[] = {
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_224
60 }, {
61 .tag = HKS_TAG_DIGEST,
62 .uint32Param = HKS_DIGEST_NONE
63 }
64 };
65 static struct HksParam g_signParamsTest001[] = {
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_224
75 }, {
76 .tag = HKS_TAG_DIGEST,
77 .uint32Param = HKS_DIGEST_NONE
78 }
79 };
80 static struct HksParam g_verifyParamsTest001[] = {
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_224
90 }, {
91 .tag = HKS_TAG_DIGEST,
92 .uint32Param = HKS_DIGEST_NONE
93 }
94 };
95
96 static struct HksParam g_genParamsTest002[] = {
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_224
106 }, {
107 .tag = HKS_TAG_DIGEST,
108 .uint32Param = HKS_DIGEST_SHA1
109 }
110 };
111 static struct HksParam g_signParamsTest002[] = {
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_224
121 }, {
122 .tag = HKS_TAG_DIGEST,
123 .uint32Param = HKS_DIGEST_SHA1
124 }
125 };
126 static struct HksParam g_verifyParamsTest002[] = {
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_224
136 }, {
137 .tag = HKS_TAG_DIGEST,
138 .uint32Param = HKS_DIGEST_SHA1
139 }
140 };
141
142 static struct HksParam g_genParamsTest003[] = {
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_224
152 }, {
153 .tag = HKS_TAG_DIGEST,
154 .uint32Param = HKS_DIGEST_SHA224
155 }
156 };
157 static struct HksParam g_signParamsTest003[] = {
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_224
167 }, {
168 .tag = HKS_TAG_DIGEST,
169 .uint32Param = HKS_DIGEST_SHA224
170 }
171 };
172 static struct HksParam g_verifyParamsTest003[] = {
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_224
182 }, {
183 .tag = HKS_TAG_DIGEST,
184 .uint32Param = HKS_DIGEST_SHA224
185 }
186 };
187
188 static struct HksParam g_genParamsTest004[] = {
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_224
198 }, {
199 .tag = HKS_TAG_DIGEST,
200 .uint32Param = HKS_DIGEST_SHA256
201 }
202 };
203 static struct HksParam g_signParamsTest004[] = {
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_224
213 }, {
214 .tag = HKS_TAG_DIGEST,
215 .uint32Param = HKS_DIGEST_SHA256
216 }
217 };
218 static struct HksParam g_verifyParamsTest004[] = {
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_224
228 }, {
229 .tag = HKS_TAG_DIGEST,
230 .uint32Param = HKS_DIGEST_SHA256
231 }
232 };
233
234 static struct HksParam g_genParamsTest005[] = {
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_224
244 }, {
245 .tag = HKS_TAG_DIGEST,
246 .uint32Param = HKS_DIGEST_SHA384
247 }
248 };
249 static struct HksParam g_signParamsTest005[] = {
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_224
259 }, {
260 .tag = HKS_TAG_DIGEST,
261 .uint32Param = HKS_DIGEST_SHA384
262 }
263 };
264 static struct HksParam g_verifyParamsTest005[] = {
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_224
274 }, {
275 .tag = HKS_TAG_DIGEST,
276 .uint32Param = HKS_DIGEST_SHA384
277 }
278 };
279
280 static struct HksParam g_genParamsTest006[] = {
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_224
290 }, {
291 .tag = HKS_TAG_DIGEST,
292 .uint32Param = HKS_DIGEST_SHA512
293 }
294 };
295 static struct HksParam g_signParamsTest006[] = {
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_224
305 }, {
306 .tag = HKS_TAG_DIGEST,
307 .uint32Param = HKS_DIGEST_SHA512
308 }
309 };
310 static struct HksParam g_verifyParamsTest006[] = {
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_224
320 }, {
321 .tag = HKS_TAG_DIGEST,
322 .uint32Param = HKS_DIGEST_SHA512
323 }
324 };
325
326 static struct HksParam g_genParamsTest007[] = {
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_256
336 }, {
337 .tag = HKS_TAG_DIGEST,
338 .uint32Param = HKS_DIGEST_NONE
339 }
340 };
341 static struct HksParam g_signParamsTest007[] = {
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_256
351 }, {
352 .tag = HKS_TAG_DIGEST,
353 .uint32Param = HKS_DIGEST_NONE
354 }
355 };
356 static struct HksParam g_verifyParamsTest007[] = {
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_256
366 }, {
367 .tag = HKS_TAG_DIGEST,
368 .uint32Param = HKS_DIGEST_NONE
369 }
370 };
371
372 static struct HksParam g_genParamsTest008[] = {
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_256
382 }, {
383 .tag = HKS_TAG_DIGEST,
384 .uint32Param = HKS_DIGEST_SHA1
385 }
386 };
387 static struct HksParam g_signParamsTest008[] = {
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_256
397 }, {
398 .tag = HKS_TAG_DIGEST,
399 .uint32Param = HKS_DIGEST_SHA1
400 }
401 };
402 static struct HksParam g_verifyParamsTest008[] = {
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_256
412 }, {
413 .tag = HKS_TAG_DIGEST,
414 .uint32Param = HKS_DIGEST_SHA1
415 }
416 };
417
418 /**
419 * @tc.name: HksEccSignVerifyPart1Test.HksEccSignVerifyTest001
420 * @tc.desc: alg-ECC pur-Sign.
421 * @tc.type: FUNC
422 */
423 HWTEST_F(HksEccSignVerifyPart1Test, HksEccSignVerifyTest001, TestSize.Level0)
424 {
425 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest001";
426 struct HksParamSet *genParamSet = nullptr;
427 struct HksParamSet *signParamSet = nullptr;
428 struct HksParamSet *verifyParamSet = nullptr;
429 int32_t ret = HKS_FAILURE;
430 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
431
432 ret = InitParamSet(&genParamSet, g_genParamsTest001, sizeof(g_genParamsTest001)/sizeof(HksParam));
433 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
434 ret = InitParamSet(&signParamSet, g_signParamsTest001, sizeof(g_signParamsTest001)/sizeof(HksParam));
435 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
436 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest001, sizeof(g_verifyParamsTest001)/sizeof(HksParam));
437 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
438 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
439 ret = HksEccSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
440 }
441
442 /* Delete Key */
443 ret = HksDeleteKey(&keyAlias, genParamSet);
444 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
445
446 HksFreeParamSet(&genParamSet);
447 HksFreeParamSet(&signParamSet);
448 HksFreeParamSet(&verifyParamSet);
449 }
450
451 /**
452 * @tc.name: HksEccSignVerifyPart1Test.HksEccSignVerifyTest002
453 * @tc.desc: alg-ECC pur-Sign.
454 * @tc.type: FUNC
455 */
456 HWTEST_F(HksEccSignVerifyPart1Test, HksEccSignVerifyTest002, TestSize.Level0)
457 {
458 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest002";
459 struct HksParamSet *genParamSet = nullptr;
460 struct HksParamSet *signParamSet = nullptr;
461 struct HksParamSet *verifyParamSet = nullptr;
462 int32_t ret = HKS_FAILURE;
463 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
464
465 ret = InitParamSet(&genParamSet, g_genParamsTest002, sizeof(g_genParamsTest002)/sizeof(HksParam));
466 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
467 ret = InitParamSet(&signParamSet, g_signParamsTest002, sizeof(g_signParamsTest002)/sizeof(HksParam));
468 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
469 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest002, sizeof(g_verifyParamsTest002)/sizeof(HksParam));
470
471 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
472 ret = HksEccSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
473 }
474
475 /* Delete Key */
476 ret = HksDeleteKey(&keyAlias, genParamSet);
477 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
478
479 HksFreeParamSet(&genParamSet);
480 HksFreeParamSet(&signParamSet);
481 HksFreeParamSet(&verifyParamSet);
482 }
483
484 /**
485 * @tc.name: HksEccSignVerifyPart1Test.HksEccSignVerifyTest003
486 * @tc.desc: alg-ECC pur-Sign.
487 * @tc.type: FUNC
488 */
489 HWTEST_F(HksEccSignVerifyPart1Test, HksEccSignVerifyTest003, TestSize.Level0)
490 {
491 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest003";
492 struct HksParamSet *genParamSet = nullptr;
493 struct HksParamSet *signParamSet = nullptr;
494 struct HksParamSet *verifyParamSet = nullptr;
495 int32_t ret = HKS_FAILURE;
496 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
497
498 ret = InitParamSet(&genParamSet, g_genParamsTest003, sizeof(g_genParamsTest003)/sizeof(HksParam));
499 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
500 ret = InitParamSet(&signParamSet, g_signParamsTest003, sizeof(g_signParamsTest003)/sizeof(HksParam));
501 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
502 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest003, sizeof(g_verifyParamsTest003)/sizeof(HksParam));
503
504 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
505 ret = HksEccSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
506 }
507
508 /* Delete Key */
509 ret = HksDeleteKey(&keyAlias, genParamSet);
510 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
511
512 HksFreeParamSet(&genParamSet);
513 HksFreeParamSet(&signParamSet);
514 HksFreeParamSet(&verifyParamSet);
515 }
516
517 /**
518 * @tc.name: HksEccSignVerifyPart1Test.HksEccSignVerifyTest004
519 * @tc.desc: alg-ECC pur-Sign.
520 * @tc.type: FUNC
521 */
522 HWTEST_F(HksEccSignVerifyPart1Test, HksEccSignVerifyTest004, TestSize.Level0)
523 {
524 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest004";
525 struct HksParamSet *genParamSet = nullptr;
526 struct HksParamSet *signParamSet = nullptr;
527 struct HksParamSet *verifyParamSet = nullptr;
528 int32_t ret = HKS_FAILURE;
529 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
530
531 ret = InitParamSet(&genParamSet, g_genParamsTest004, sizeof(g_genParamsTest004)/sizeof(HksParam));
532 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
533 ret = InitParamSet(&signParamSet, g_signParamsTest004, sizeof(g_signParamsTest004)/sizeof(HksParam));
534 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
535 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest004, sizeof(g_verifyParamsTest004)/sizeof(HksParam));
536
537 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
538 ret = HksEccSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
539 }
540
541 /* Delete Key */
542 ret = HksDeleteKey(&keyAlias, genParamSet);
543 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
544
545 HksFreeParamSet(&genParamSet);
546 HksFreeParamSet(&signParamSet);
547 HksFreeParamSet(&verifyParamSet);
548 }
549
550 /**
551 * @tc.name: HksEccSignVerifyPart1Test.HksEccSignVerifyTest005
552 * @tc.desc: alg-ECC pur-Sign.
553 * @tc.type: FUNC
554 */
555 HWTEST_F(HksEccSignVerifyPart1Test, HksEccSignVerifyTest005, TestSize.Level0)
556 {
557 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest005";
558 struct HksParamSet *genParamSet = nullptr;
559 struct HksParamSet *signParamSet = nullptr;
560 struct HksParamSet *verifyParamSet = nullptr;
561 int32_t ret = HKS_FAILURE;
562 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
563
564 ret = InitParamSet(&genParamSet, g_genParamsTest005, sizeof(g_genParamsTest005)/sizeof(HksParam));
565 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
566 ret = InitParamSet(&signParamSet, g_signParamsTest005, sizeof(g_signParamsTest005)/sizeof(HksParam));
567 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
568 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest005, sizeof(g_verifyParamsTest005)/sizeof(HksParam));
569
570 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
571 ret = HksEccSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
572 }
573
574 /* Delete Key */
575 ret = HksDeleteKey(&keyAlias, genParamSet);
576 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
577
578 HksFreeParamSet(&genParamSet);
579 HksFreeParamSet(&signParamSet);
580 HksFreeParamSet(&verifyParamSet);
581 }
582
583 /**
584 * @tc.name: HksEccSignVerifyPart1Test.HksEccSignVerifyTest006
585 * @tc.desc: alg-ECC pur-Sign.
586 * @tc.type: FUNC
587 */
588 HWTEST_F(HksEccSignVerifyPart1Test, HksEccSignVerifyTest006, TestSize.Level0)
589 {
590 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest006";
591 struct HksParamSet *genParamSet = nullptr;
592 struct HksParamSet *signParamSet = nullptr;
593 struct HksParamSet *verifyParamSet = nullptr;
594 int32_t ret = HKS_FAILURE;
595 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
596
597 ret = InitParamSet(&genParamSet, g_genParamsTest006, sizeof(g_genParamsTest006)/sizeof(HksParam));
598 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
599 ret = InitParamSet(&signParamSet, g_signParamsTest006, sizeof(g_signParamsTest006)/sizeof(HksParam));
600 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
601 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest006, sizeof(g_verifyParamsTest006)/sizeof(HksParam));
602
603 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
604 ret = HksEccSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
605 }
606
607 /* Delete Key */
608 ret = HksDeleteKey(&keyAlias, genParamSet);
609 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
610
611 HksFreeParamSet(&genParamSet);
612 HksFreeParamSet(&signParamSet);
613 HksFreeParamSet(&verifyParamSet);
614 }
615
616 /**
617 * @tc.name: HksEccSignVerifyPart1Test.HksEccSignVerifyTest007
618 * @tc.desc: alg-ECC pur-Sign.
619 * @tc.type: FUNC
620 */
621 HWTEST_F(HksEccSignVerifyPart1Test, HksEccSignVerifyTest007, TestSize.Level0)
622 {
623 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest007";
624 struct HksParamSet *genParamSet = nullptr;
625 struct HksParamSet *signParamSet = nullptr;
626 struct HksParamSet *verifyParamSet = nullptr;
627 int32_t ret = HKS_FAILURE;
628 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
629
630 ret = InitParamSet(&genParamSet, g_genParamsTest007, sizeof(g_genParamsTest007)/sizeof(HksParam));
631 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
632 ret = InitParamSet(&signParamSet, g_signParamsTest007, sizeof(g_signParamsTest007)/sizeof(HksParam));
633 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
634 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest007, sizeof(g_verifyParamsTest007)/sizeof(HksParam));
635
636 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
637 ret = HksEccSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
638 }
639
640 /* Delete Key */
641 ret = HksDeleteKey(&keyAlias, genParamSet);
642 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
643
644 HksFreeParamSet(&genParamSet);
645 HksFreeParamSet(&signParamSet);
646 HksFreeParamSet(&verifyParamSet);
647 }
648
649 /**
650 * @tc.name: HksEccSignVerifyPart1Test.HksEccSignVerifyTest008
651 * @tc.desc: alg-ECC pur-Sign.
652 * @tc.type: FUNC
653 */
654 HWTEST_F(HksEccSignVerifyPart1Test, HksEccSignVerifyTest008, TestSize.Level0)
655 {
656 const char *keyAliasString = "HksECCSignVerifyKeyAliasTest008";
657 struct HksParamSet *genParamSet = nullptr;
658 struct HksParamSet *signParamSet = nullptr;
659 struct HksParamSet *verifyParamSet = nullptr;
660 int32_t ret = HKS_FAILURE;
661 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
662
663 ret = InitParamSet(&genParamSet, g_genParamsTest008, sizeof(g_genParamsTest008)/sizeof(HksParam));
664 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
665 ret = InitParamSet(&signParamSet, g_signParamsTest008, sizeof(g_signParamsTest008)/sizeof(HksParam));
666 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
667 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest008, sizeof(g_verifyParamsTest008)/sizeof(HksParam));
668
669 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
670 ret = HksEccSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
671 }
672
673 /* Delete Key */
674 ret = HksDeleteKey(&keyAlias, genParamSet);
675 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
676
677 HksFreeParamSet(&genParamSet);
678 HksFreeParamSet(&signParamSet);
679 HksFreeParamSet(&verifyParamSet);
680 }
681 }