1 /*
2 * Copyright (c) 2021-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 <gtest/gtest.h>
17 #include <iostream>
18
19 #include "hks_ability.h"
20 #include "hks_config.h"
21 #include "hks_crypto_hal.h"
22 #include "hks_crypto_hal_common.h"
23 #include "hks_mem.h"
24 #include "hks_log.h"
25
26 using namespace testing::ext;
27 namespace OHOS {
28 namespace Security {
29 namespace Huks {
30 namespace UnitTest {
31 namespace {
32 struct TestCaseParams {
33 HksKeySpec spec = {0};
34 HksUsageSpec usageSpec = {0};
35 HksStageType runStage = HksStageType::HKS_STAGE_THREE;
36
37 HksErrorCode generateKeyResult = HksErrorCode::HKS_SUCCESS;
38 HksErrorCode signResult = HksErrorCode::HKS_SUCCESS;
39 HksErrorCode verifyResult = HksErrorCode::HKS_SUCCESS;
40 };
41
42 const uint32_t SIGNATURE_SIZE = 521;
43 const uint32_t MAX_PUB_KEY_SIZE = 218;
44 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_001_PARAMS = {
45 .spec = {
46 .algType = HKS_ALG_ECC,
47 .keyLen = HKS_ECC_KEY_SIZE_224,
48 .algParam = nullptr,
49 },
50 .usageSpec = {
51 .algType = HKS_ALG_ECC,
52 .mode = HKS_MODE_ECB,
53 .padding = HKS_PADDING_NONE,
54 .digest = HKS_DIGEST_NONE,
55 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
56 },
57
58 .generateKeyResult = HKS_SUCCESS,
59 .signResult = HKS_SUCCESS,
60 .verifyResult = HKS_SUCCESS,
61 };
62
63 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_002_PARAMS = {
64 .spec = {
65 .algType = HKS_ALG_ECC,
66 .keyLen = HKS_ECC_KEY_SIZE_256,
67 .algParam = nullptr,
68 },
69 .usageSpec = {
70 .algType = HKS_ALG_ECC,
71 .mode = HKS_MODE_ECB,
72 .padding = HKS_PADDING_NONE,
73 .digest = HKS_DIGEST_NONE,
74 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
75 },
76
77 .generateKeyResult = HKS_SUCCESS,
78 .signResult = HKS_SUCCESS,
79 .verifyResult = HKS_SUCCESS,
80 };
81
82 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_003_PARAMS = {
83 .spec = {
84 .algType = HKS_ALG_ECC,
85 .keyLen = HKS_ECC_KEY_SIZE_384,
86 .algParam = nullptr,
87 },
88 .usageSpec = {
89 .algType = HKS_ALG_ECC,
90 .mode = HKS_MODE_ECB,
91 .padding = HKS_PADDING_NONE,
92 .digest = HKS_DIGEST_NONE,
93 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
94 },
95
96 .generateKeyResult = HKS_SUCCESS,
97 .signResult = HKS_SUCCESS,
98 .verifyResult = HKS_SUCCESS,
99 };
100
101 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_004_PARAMS = {
102 .spec = {
103 .algType = HKS_ALG_ECC,
104 .keyLen = HKS_ECC_KEY_SIZE_521,
105 .algParam = nullptr,
106 },
107 .usageSpec = {
108 .algType = HKS_ALG_ECC,
109 .mode = HKS_MODE_ECB,
110 .padding = HKS_PADDING_NONE,
111 .digest = HKS_DIGEST_NONE,
112 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
113 },
114
115 .generateKeyResult = HKS_SUCCESS,
116 .signResult = HKS_SUCCESS,
117 .verifyResult = HKS_SUCCESS,
118 };
119
120 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_005_PARAMS = {
121 .spec = {
122 .algType = HKS_ALG_ECC,
123 .keyLen = HKS_ECC_KEY_SIZE_224,
124 .algParam = nullptr,
125 },
126 .usageSpec = {
127 .algType = HKS_ALG_ECC,
128 .mode = HKS_MODE_ECB,
129 .padding = HKS_PADDING_NONE,
130 .digest = HKS_DIGEST_SHA1,
131 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
132 },
133
134 .generateKeyResult = HKS_SUCCESS,
135 .signResult = HKS_SUCCESS,
136 .verifyResult = HKS_SUCCESS,
137 };
138
139 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_006_PARAMS = {
140 .spec = {
141 .algType = HKS_ALG_ECC,
142 .keyLen = HKS_ECC_KEY_SIZE_256,
143 .algParam = nullptr,
144 },
145 .usageSpec = {
146 .algType = HKS_ALG_ECC,
147 .mode = HKS_MODE_ECB,
148 .padding = HKS_PADDING_NONE,
149 .digest = HKS_DIGEST_SHA1,
150 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
151 },
152
153 .generateKeyResult = HKS_SUCCESS,
154 .signResult = HKS_SUCCESS,
155 .verifyResult = HKS_SUCCESS,
156 };
157
158 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_007_PARAMS = {
159 .spec = {
160 .algType = HKS_ALG_ECC,
161 .keyLen = HKS_ECC_KEY_SIZE_384,
162 .algParam = nullptr,
163 },
164 .usageSpec = {
165 .algType = HKS_ALG_ECC,
166 .mode = HKS_MODE_ECB,
167 .padding = HKS_PADDING_NONE,
168 .digest = HKS_DIGEST_SHA1,
169 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
170 },
171
172 .generateKeyResult = HKS_SUCCESS,
173 .signResult = HKS_SUCCESS,
174 .verifyResult = HKS_SUCCESS,
175 };
176
177 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_008_PARAMS = {
178 .spec = {
179 .algType = HKS_ALG_ECC,
180 .keyLen = HKS_ECC_KEY_SIZE_521,
181 .algParam = nullptr,
182 },
183 .usageSpec = {
184 .algType = HKS_ALG_ECC,
185 .mode = HKS_MODE_ECB,
186 .padding = HKS_PADDING_NONE,
187 .digest = HKS_DIGEST_SHA1,
188 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
189 },
190
191 .generateKeyResult = HKS_SUCCESS,
192 .signResult = HKS_SUCCESS,
193 .verifyResult = HKS_SUCCESS,
194 };
195
196 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_009_PARAMS = {
197 .spec = {
198 .algType = HKS_ALG_ECC,
199 .keyLen = HKS_ECC_KEY_SIZE_224,
200 .algParam = nullptr,
201 },
202 .usageSpec = {
203 .algType = HKS_ALG_ECC,
204 .mode = HKS_MODE_ECB,
205 .padding = HKS_PADDING_NONE,
206 .digest = HKS_DIGEST_SHA224,
207 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
208 },
209
210 .generateKeyResult = HKS_SUCCESS,
211 .signResult = HKS_SUCCESS,
212 .verifyResult = HKS_SUCCESS,
213 };
214
215 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_010_PARAMS = {
216 .spec = {
217 .algType = HKS_ALG_ECC,
218 .keyLen = HKS_ECC_KEY_SIZE_256,
219 .algParam = nullptr,
220 },
221 .usageSpec = {
222 .algType = HKS_ALG_ECC,
223 .mode = HKS_MODE_ECB,
224 .padding = HKS_PADDING_NONE,
225 .digest = HKS_DIGEST_SHA224,
226 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
227 },
228
229 .generateKeyResult = HKS_SUCCESS,
230 .signResult = HKS_SUCCESS,
231 .verifyResult = HKS_SUCCESS,
232 };
233
234 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_011_PARAMS = {
235 .spec = {
236 .algType = HKS_ALG_ECC,
237 .keyLen = HKS_ECC_KEY_SIZE_384,
238 .algParam = nullptr,
239 },
240 .usageSpec = {
241 .algType = HKS_ALG_ECC,
242 .mode = HKS_MODE_ECB,
243 .padding = HKS_PADDING_NONE,
244 .digest = HKS_DIGEST_SHA224,
245 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
246 },
247
248 .generateKeyResult = HKS_SUCCESS,
249 .signResult = HKS_SUCCESS,
250 .verifyResult = HKS_SUCCESS,
251 };
252
253 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_012_PARAMS = {
254 .spec = {
255 .algType = HKS_ALG_ECC,
256 .keyLen = HKS_ECC_KEY_SIZE_521,
257 .algParam = nullptr,
258 },
259 .usageSpec = {
260 .algType = HKS_ALG_ECC,
261 .mode = HKS_MODE_ECB,
262 .padding = HKS_PADDING_NONE,
263 .digest = HKS_DIGEST_SHA224,
264 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
265 },
266
267 .generateKeyResult = HKS_SUCCESS,
268 .signResult = HKS_SUCCESS,
269 .verifyResult = HKS_SUCCESS,
270 };
271
272 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_013_PARAMS = {
273 .spec = {
274 .algType = HKS_ALG_ECC,
275 .keyLen = HKS_ECC_KEY_SIZE_224,
276 .algParam = nullptr,
277 },
278 .usageSpec = {
279 .algType = HKS_ALG_ECC,
280 .mode = HKS_MODE_ECB,
281 .padding = HKS_PADDING_NONE,
282 .digest = HKS_DIGEST_SHA256,
283 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
284 },
285
286 .generateKeyResult = HKS_SUCCESS,
287 .signResult = HKS_SUCCESS,
288 .verifyResult = HKS_SUCCESS,
289 };
290
291 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_014_PARAMS = {
292 .spec = {
293 .algType = HKS_ALG_ECC,
294 .keyLen = HKS_ECC_KEY_SIZE_256,
295 .algParam = nullptr,
296 },
297 .usageSpec = {
298 .algType = HKS_ALG_ECC,
299 .mode = HKS_MODE_ECB,
300 .padding = HKS_PADDING_NONE,
301 .digest = HKS_DIGEST_SHA256,
302 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
303 },
304
305 .generateKeyResult = HKS_SUCCESS,
306 .signResult = HKS_SUCCESS,
307 .verifyResult = HKS_SUCCESS,
308 };
309
310 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_015_PARAMS = {
311 .spec = {
312 .algType = HKS_ALG_ECC,
313 .keyLen = HKS_ECC_KEY_SIZE_384,
314 .algParam = nullptr,
315 },
316 .usageSpec = {
317 .algType = HKS_ALG_ECC,
318 .mode = HKS_MODE_ECB,
319 .padding = HKS_PADDING_NONE,
320 .digest = HKS_DIGEST_SHA256,
321 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
322 },
323
324 .generateKeyResult = HKS_SUCCESS,
325 .signResult = HKS_SUCCESS,
326 .verifyResult = HKS_SUCCESS,
327 };
328
329 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_016_PARAMS = {
330 .spec = {
331 .algType = HKS_ALG_ECC,
332 .keyLen = HKS_ECC_KEY_SIZE_521,
333 .algParam = nullptr,
334 },
335 .usageSpec = {
336 .algType = HKS_ALG_ECC,
337 .mode = HKS_MODE_ECB,
338 .padding = HKS_PADDING_NONE,
339 .digest = HKS_DIGEST_SHA256,
340 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
341 },
342
343 .generateKeyResult = HKS_SUCCESS,
344 .signResult = HKS_SUCCESS,
345 .verifyResult = HKS_SUCCESS,
346 };
347
348 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_017_PARAMS = {
349 .spec = {
350 .algType = HKS_ALG_ECC,
351 .keyLen = HKS_ECC_KEY_SIZE_224,
352 .algParam = nullptr,
353 },
354 .usageSpec = {
355 .algType = HKS_ALG_ECC,
356 .mode = HKS_MODE_ECB,
357 .padding = HKS_PADDING_NONE,
358 .digest = HKS_DIGEST_SHA384,
359 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
360 },
361
362 .generateKeyResult = HKS_SUCCESS,
363 .signResult = HKS_SUCCESS,
364 .verifyResult = HKS_SUCCESS,
365 };
366
367 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_018_PARAMS = {
368 .spec = {
369 .algType = HKS_ALG_ECC,
370 .keyLen = HKS_ECC_KEY_SIZE_256,
371 .algParam = nullptr,
372 },
373 .usageSpec = {
374 .algType = HKS_ALG_ECC,
375 .mode = HKS_MODE_ECB,
376 .padding = HKS_PADDING_NONE,
377 .digest = HKS_DIGEST_SHA384,
378 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
379 },
380
381 .generateKeyResult = HKS_SUCCESS,
382 .signResult = HKS_SUCCESS,
383 .verifyResult = HKS_SUCCESS,
384 };
385
386 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_019_PARAMS = {
387 .spec = {
388 .algType = HKS_ALG_ECC,
389 .keyLen = HKS_ECC_KEY_SIZE_384,
390 .algParam = nullptr,
391 },
392 .usageSpec = {
393 .algType = HKS_ALG_ECC,
394 .mode = HKS_MODE_ECB,
395 .padding = HKS_PADDING_NONE,
396 .digest = HKS_DIGEST_SHA384,
397 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
398 },
399
400 .generateKeyResult = HKS_SUCCESS,
401 .signResult = HKS_SUCCESS,
402 .verifyResult = HKS_SUCCESS,
403 };
404
405 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_020_PARAMS = {
406 .spec = {
407 .algType = HKS_ALG_ECC,
408 .keyLen = HKS_ECC_KEY_SIZE_521,
409 .algParam = nullptr,
410 },
411 .usageSpec = {
412 .algType = HKS_ALG_ECC,
413 .mode = HKS_MODE_ECB,
414 .padding = HKS_PADDING_NONE,
415 .digest = HKS_DIGEST_SHA384,
416 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
417 },
418
419 .generateKeyResult = HKS_SUCCESS,
420 .signResult = HKS_SUCCESS,
421 .verifyResult = HKS_SUCCESS,
422 };
423
424 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_021_PARAMS = {
425 .spec = {
426 .algType = HKS_ALG_ECC,
427 .keyLen = HKS_ECC_KEY_SIZE_224,
428 .algParam = nullptr,
429 },
430 .usageSpec = {
431 .algType = HKS_ALG_ECC,
432 .mode = HKS_MODE_ECB,
433 .padding = HKS_PADDING_NONE,
434 .digest = HKS_DIGEST_SHA512,
435 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
436 },
437
438 .generateKeyResult = HKS_SUCCESS,
439 .signResult = HKS_SUCCESS,
440 .verifyResult = HKS_SUCCESS,
441 };
442
443 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_022_PARAMS = {
444 .spec = {
445 .algType = HKS_ALG_ECC,
446 .keyLen = HKS_ECC_KEY_SIZE_256,
447 .algParam = nullptr,
448 },
449 .usageSpec = {
450 .algType = HKS_ALG_ECC,
451 .mode = HKS_MODE_ECB,
452 .padding = HKS_PADDING_NONE,
453 .digest = HKS_DIGEST_SHA512,
454 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
455 },
456
457 .generateKeyResult = HKS_SUCCESS,
458 .signResult = HKS_SUCCESS,
459 .verifyResult = HKS_SUCCESS,
460 };
461
462 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_023_PARAMS = {
463 .spec = {
464 .algType = HKS_ALG_ECC,
465 .keyLen = HKS_ECC_KEY_SIZE_384,
466 .algParam = nullptr,
467 },
468 .usageSpec = {
469 .algType = HKS_ALG_ECC,
470 .mode = HKS_MODE_ECB,
471 .padding = HKS_PADDING_NONE,
472 .digest = HKS_DIGEST_SHA512,
473 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
474 },
475
476 .generateKeyResult = HKS_SUCCESS,
477 .signResult = HKS_SUCCESS,
478 .verifyResult = HKS_SUCCESS,
479 };
480
481 const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_024_PARAMS = {
482 .spec = {
483 .algType = HKS_ALG_ECC,
484 .keyLen = HKS_ECC_KEY_SIZE_521,
485 .algParam = nullptr,
486 },
487 .usageSpec = {
488 .algType = HKS_ALG_ECC,
489 .mode = HKS_MODE_ECB,
490 .padding = HKS_PADDING_NONE,
491 .digest = HKS_DIGEST_SHA512,
492 .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY,
493 },
494
495 .generateKeyResult = HKS_SUCCESS,
496 .signResult = HKS_SUCCESS,
497 .verifyResult = HKS_SUCCESS,
498 };
499 } // namespace
500
501 class HksCryptoHalEcdsaSign : public HksCryptoHalCommon, public testing::Test {
502 public:
503 static void SetUpTestCase(void);
504 static void TearDownTestCase(void);
505 void SetUp();
506 void TearDown();
507 protected:
RunTestCase(const TestCaseParams & testCaseParams) const508 void RunTestCase(const TestCaseParams &testCaseParams) const
509 {
510 HksBlob key = { .size = 0, .data = nullptr };
511
512 EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult);
513
514 const char *hexData = "00112233445566778899aabbccddeeff";
515 uint32_t dataLen = strlen(hexData) / HKS_COUNT_OF_HALF;
516
517 HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) };
518 ASSERT_NE(message.data, nullptr);
519 for (uint32_t ii = 0; ii < dataLen; ii++) {
520 message.data[ii] = ReadHex((const uint8_t *)&hexData[HKS_COUNT_OF_HALF * ii]);
521 }
522
523 struct HksBlob* pBlob = nullptr;
524 uint8_t hashData[HKS_HMAC_DIGEST_SHA512_LEN] = {0};
525 struct HksBlob hash = { HKS_HMAC_DIGEST_SHA512_LEN, hashData };
526 struct HksUsageSpec usageSpecTmp = testCaseParams.usageSpec;
527 if (testCaseParams.runStage == HksStageType::HKS_STAGE_THREE) {
528 /* NONEwithECDSA default sha256: ec_pkey_ctrl default md nid */
529 uint32_t inputDigest = usageSpecTmp.digest;
530 usageSpecTmp.digest = (inputDigest == HKS_DIGEST_NONE) ? HKS_DIGEST_SHA256 : inputDigest;
531 EXPECT_EQ(HksCryptoHalHash(usageSpecTmp.digest, &message, &hash), HKS_SUCCESS);
532 pBlob = &hash;
533 } else {
534 pBlob = &message;
535 }
536
537 struct HksBlob signature = { .size = SIGNATURE_SIZE, .data = (uint8_t *)HksMalloc(SIGNATURE_SIZE) };
538 ASSERT_NE(signature.data, nullptr);
539
540 EXPECT_EQ(HksCryptoHalSign(&key, &usageSpecTmp, pBlob, &signature), testCaseParams.signResult);
541
542 struct HksBlob pubKey = { .size = MAX_PUB_KEY_SIZE, .data = (uint8_t *)HksMalloc(MAX_PUB_KEY_SIZE) };
543 ASSERT_NE(pubKey.data, nullptr);
544
545 EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS);
546
547 EXPECT_EQ(
548 HksCryptoHalVerify(&pubKey, &usageSpecTmp, pBlob, &signature), testCaseParams.verifyResult);
549
550 HksFree(message.data);
551 HksFree(signature.data);
552 HksFree(pubKey.data);
553 HksFree(key.data);
554 }
555 };
556
SetUpTestCase(void)557 void HksCryptoHalEcdsaSign::SetUpTestCase(void)
558 {
559 }
560
TearDownTestCase(void)561 void HksCryptoHalEcdsaSign::TearDownTestCase(void)
562 {
563 }
564
SetUp()565 void HksCryptoHalEcdsaSign::SetUp()
566 {
567 EXPECT_EQ(HksCryptoAbilityInit(), 0);
568 }
569
TearDown()570 void HksCryptoHalEcdsaSign::TearDown()
571 {
572 }
573
574 /**
575 * @tc.number : HksCryptoHalEcdsaSign_001
576 * @tc.name : HksCryptoHalEcdsaSign_001
577 * @tc.desc : Using HksCryptoHalSign Sign ECC-224-NONE key.
578 */
579 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_001, Function | SmallTest | Level0)
580 {
581 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_001_PARAMS);
582 }
583
584 /**
585 * @tc.number : HksCryptoHalEcdsaSign_002
586 * @tc.name : HksCryptoHalEcdsaSign_002
587 * @tc.desc : Using HksCryptoHalSign Sign ECC-256-NONE key.
588 */
589 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_002, Function | SmallTest | Level0)
590 {
591 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_002_PARAMS);
592 }
593
594 /**
595 * @tc.number : HksCryptoHalEcdsaSign_003
596 * @tc.name : HksCryptoHalEcdsaSign_003
597 * @tc.desc : Using HksCryptoHalSign Sign ECC-384-NONE key.
598 */
599 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_003, Function | SmallTest | Level0)
600 {
601 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_003_PARAMS);
602 }
603
604 /**
605 * @tc.number : HksCryptoHalEcdsaSign_004
606 * @tc.name : HksCryptoHalEcdsaSign_004
607 * @tc.desc : Using HksCryptoHalSign Sign ECC-521-NONE key.
608 */
609 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_004, Function | SmallTest | Level0)
610 {
611 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_004_PARAMS);
612 }
613
614 /**
615 * @tc.number : HksCryptoHalEcdsaSign_005
616 * @tc.name : HksCryptoHalEcdsaSign_005
617 * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA1 key.
618 */
619 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_005, Function | SmallTest | Level0)
620 {
621 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_005_PARAMS);
622 }
623
624 /**
625 * @tc.number : HksCryptoHalEcdsaSign_006
626 * @tc.name : HksCryptoHalEcdsaSign_006
627 * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA1 key.
628 */
629 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_006, Function | SmallTest | Level0)
630 {
631 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_006_PARAMS);
632 }
633
634 /**
635 * @tc.number : HksCryptoHalEcdsaSign_007
636 * @tc.name : HksCryptoHalEcdsaSign_007
637 * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA1 key.
638 */
639 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_007, Function | SmallTest | Level0)
640 {
641 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_007_PARAMS);
642 }
643
644 /**
645 * @tc.number : HksCryptoHalEcdsaSign_008
646 * @tc.name : HksCryptoHalEcdsaSign_008
647 * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA1 key.
648 */
649 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_008, Function | SmallTest | Level0)
650 {
651 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_008_PARAMS);
652 }
653
654 /**
655 * @tc.number : HksCryptoHalEcdsaSign_009
656 * @tc.name : HksCryptoHalEcdsaSign_009
657 * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA224 key.
658 */
659 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_009, Function | SmallTest | Level0)
660 {
661 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_009_PARAMS);
662 }
663
664 /**
665 * @tc.number : HksCryptoHalEcdsaSign_010
666 * @tc.name : HksCryptoHalEcdsaSign_010
667 * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA224 key.
668 */
669 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_010, Function | SmallTest | Level0)
670 {
671 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_010_PARAMS);
672 }
673
674 /**
675 * @tc.number : HksCryptoHalEcdsaSign_011
676 * @tc.name : HksCryptoHalEcdsaSign_011
677 * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA224 key.
678 */
679 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_011, Function | SmallTest | Level0)
680 {
681 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_011_PARAMS);
682 }
683
684 /**
685 * @tc.number : HksCryptoHalEcdsaSign_012
686 * @tc.name : HksCryptoHalEcdsaSign_012
687 * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA224 key.
688 */
689 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_012, Function | SmallTest | Level0)
690 {
691 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_012_PARAMS);
692 }
693
694 /**
695 * @tc.number : HksCryptoHalEcdsaSign_013
696 * @tc.name : HksCryptoHalEcdsaSign_013
697 * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA256 key.
698 */
699 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_013, Function | SmallTest | Level0)
700 {
701 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_013_PARAMS);
702 }
703
704 /**
705 * @tc.number : HksCryptoHalEcdsaSign_014
706 * @tc.name : HksCryptoHalEcdsaSign_014
707 * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA256 key.
708 */
709 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_014, Function | SmallTest | Level0)
710 {
711 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_014_PARAMS);
712 }
713
714 /**
715 * @tc.number : HksCryptoHalEcdsaSign_015
716 * @tc.name : HksCryptoHalEcdsaSign_015
717 * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA256 key.
718 */
719 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_015, Function | SmallTest | Level0)
720 {
721 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_015_PARAMS);
722 }
723
724 /**
725 * @tc.number : HksCryptoHalEcdsaSign_016
726 * @tc.name : HksCryptoHalEcdsaSign_016
727 * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA256 key.
728 */
729 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_016, Function | SmallTest | Level0)
730 {
731 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_016_PARAMS);
732 }
733
734 /**
735 * @tc.number : HksCryptoHalEcdsaSign_017
736 * @tc.name : HksCryptoHalEcdsaSign_017
737 * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA384 key.
738 */
739 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_017, Function | SmallTest | Level0)
740 {
741 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_017_PARAMS);
742 }
743
744 /**
745 * @tc.number : HksCryptoHalEcdsaSign_018
746 * @tc.name : HksCryptoHalEcdsaSign_018
747 * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA384 key.
748 */
749 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_018, Function | SmallTest | Level0)
750 {
751 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_018_PARAMS);
752 }
753
754 /**
755 * @tc.number : HksCryptoHalEcdsaSign_019
756 * @tc.name : HksCryptoHalEcdsaSign_019
757 * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA384 key.
758 */
759 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_019, Function | SmallTest | Level0)
760 {
761 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_019_PARAMS);
762 }
763
764 /**
765 * @tc.number : HksCryptoHalEcdsaSign_020
766 * @tc.name : HksCryptoHalEcdsaSign_020
767 * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA384 key.
768 */
769 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_020, Function | SmallTest | Level0)
770 {
771 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_020_PARAMS);
772 }
773
774 /**
775 * @tc.number : HksCryptoHalEcdsaSign_021
776 * @tc.name : HksCryptoHalEcdsaSign_021
777 * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA512 key.
778 */
779 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_021, Function | SmallTest | Level0)
780 {
781 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_021_PARAMS);
782 }
783
784 /**
785 * @tc.number : HksCryptoHalEcdsaSign_022
786 * @tc.name : HksCryptoHalEcdsaSign_022
787 * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA512 key.
788 */
789 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_022, Function | SmallTest | Level0)
790 {
791 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_022_PARAMS);
792 }
793
794 /**
795 * @tc.number : HksCryptoHalEcdsaSign_023
796 * @tc.name : HksCryptoHalEcdsaSign_023
797 * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA512 key.
798 */
799 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_023, Function | SmallTest | Level0)
800 {
801 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_023_PARAMS);
802 }
803
804 /**
805 * @tc.number : HksCryptoHalEcdsaSign_024
806 * @tc.name : HksCryptoHalEcdsaSign_024
807 * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA512 key.
808 */
809 HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_024, Function | SmallTest | Level0)
810 {
811 RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_024_PARAMS);
812 }
813 } // namespace UnitTest
814 } // namespace Huks
815 } // namespace Security
816 } // namespace OHOS