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