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_dsa_sign_verify_test.h"
17
18 #include <gtest/gtest.h>
19
20 using namespace testing::ext;
21 namespace Unittest::DsaSignVerify {
22 class HksDsaSignVerifyTest : public testing::Test {
23 public:
24 static void SetUpTestCase(void);
25
26 static void TearDownTestCase(void);
27
28 void SetUp();
29
30 void TearDown();
31 };
32
SetUpTestCase(void)33 void HksDsaSignVerifyTest::SetUpTestCase(void)
34 {
35 }
36
TearDownTestCase(void)37 void HksDsaSignVerifyTest::TearDownTestCase(void)
38 {
39 }
40
SetUp()41 void HksDsaSignVerifyTest::SetUp()
42 {
43 }
44
TearDown()45 void HksDsaSignVerifyTest::TearDown()
46 {
47 }
48
49 static struct HksParam g_genParamsTest001[] = {
50 {
51 .tag = HKS_TAG_ALGORITHM,
52 .uint32Param = HKS_ALG_DSA
53 }, {
54 .tag = HKS_TAG_PURPOSE,
55 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
56 }, {
57 .tag = HKS_TAG_KEY_SIZE,
58 .uint32Param = Unittest::DsaSignVerify::DSA_COMMON_SIZE
59 }, {
60 .tag = HKS_TAG_DIGEST,
61 .uint32Param = HKS_DIGEST_SHA1
62 }
63 };
64 static struct HksParam g_signParamsTest001[] = {
65 {
66 .tag = HKS_TAG_ALGORITHM,
67 .uint32Param = HKS_ALG_DSA
68 }, {
69 .tag = HKS_TAG_PURPOSE,
70 .uint32Param = HKS_KEY_PURPOSE_SIGN
71 }, {
72 .tag = HKS_TAG_DIGEST,
73 .uint32Param = HKS_DIGEST_SHA1
74 }
75 };
76 static struct HksParam g_verifyParamsTest001[] = {
77 {
78 .tag = HKS_TAG_ALGORITHM,
79 .uint32Param = HKS_ALG_DSA
80 }, {
81 .tag = HKS_TAG_PURPOSE,
82 .uint32Param = HKS_KEY_PURPOSE_VERIFY
83 }, {
84 .tag = HKS_TAG_KEY_SIZE,
85 .uint32Param = Unittest::DsaSignVerify::DSA_COMMON_SIZE
86 }, {
87 .tag = HKS_TAG_DIGEST,
88 .uint32Param = HKS_DIGEST_SHA1
89 }
90 };
91
92 static struct HksParam g_genParamsTest002[] = {
93 {
94 .tag = HKS_TAG_ALGORITHM,
95 .uint32Param = HKS_ALG_DSA
96 }, {
97 .tag = HKS_TAG_PURPOSE,
98 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
99 }, {
100 .tag = HKS_TAG_KEY_SIZE,
101 .uint32Param = Unittest::DsaSignVerify::DSA_COMMON_SIZE
102 }, {
103 .tag = HKS_TAG_DIGEST,
104 .uint32Param = HKS_DIGEST_SHA224
105 }
106 };
107 static struct HksParam g_signParamsTest002[] = {
108 {
109 .tag = HKS_TAG_ALGORITHM,
110 .uint32Param = HKS_ALG_DSA
111 }, {
112 .tag = HKS_TAG_PURPOSE,
113 .uint32Param = HKS_KEY_PURPOSE_SIGN
114 }, {
115 .tag = HKS_TAG_DIGEST,
116 .uint32Param = HKS_DIGEST_SHA224
117 }
118 };
119 static struct HksParam g_verifyParamsTest002[] = {
120 {
121 .tag = HKS_TAG_ALGORITHM,
122 .uint32Param = HKS_ALG_DSA
123 }, {
124 .tag = HKS_TAG_PURPOSE,
125 .uint32Param = HKS_KEY_PURPOSE_VERIFY
126 }, {
127 .tag = HKS_TAG_KEY_SIZE,
128 .uint32Param = Unittest::DsaSignVerify::DSA_COMMON_SIZE
129 }, {
130 .tag = HKS_TAG_DIGEST,
131 .uint32Param = HKS_DIGEST_SHA224
132 }
133 };
134 static struct HksParam g_genParamsTest003[] = {
135 {
136 .tag = HKS_TAG_ALGORITHM,
137 .uint32Param = HKS_ALG_DSA
138 }, {
139 .tag = HKS_TAG_PURPOSE,
140 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
141 }, {
142 .tag = HKS_TAG_KEY_SIZE,
143 .uint32Param = Unittest::DsaSignVerify::DSA_COMMON_SIZE
144 }, {
145 .tag = HKS_TAG_DIGEST,
146 .uint32Param = HKS_DIGEST_SHA256
147 }
148 };
149 static struct HksParam g_signParamsTest003[] = {
150 {
151 .tag = HKS_TAG_ALGORITHM,
152 .uint32Param = HKS_ALG_DSA
153 }, {
154 .tag = HKS_TAG_PURPOSE,
155 .uint32Param = HKS_KEY_PURPOSE_SIGN
156 }, {
157 .tag = HKS_TAG_DIGEST,
158 .uint32Param = HKS_DIGEST_SHA256
159 }
160 };
161 static struct HksParam g_verifyParamsTest003[] = {
162 {
163 .tag = HKS_TAG_ALGORITHM,
164 .uint32Param = HKS_ALG_DSA
165 }, {
166 .tag = HKS_TAG_PURPOSE,
167 .uint32Param = HKS_KEY_PURPOSE_VERIFY
168 }, {
169 .tag = HKS_TAG_KEY_SIZE,
170 .uint32Param = Unittest::DsaSignVerify::DSA_COMMON_SIZE
171 }, {
172 .tag = HKS_TAG_DIGEST,
173 .uint32Param = HKS_DIGEST_SHA256
174 }
175 };
176
177 static struct HksParam g_genParamsTest004[] = {
178 {
179 .tag = HKS_TAG_ALGORITHM,
180 .uint32Param = HKS_ALG_DSA
181 }, {
182 .tag = HKS_TAG_PURPOSE,
183 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
184 }, {
185 .tag = HKS_TAG_KEY_SIZE,
186 .uint32Param = Unittest::DsaSignVerify::DSA_COMMON_SIZE
187 }, {
188 .tag = HKS_TAG_DIGEST,
189 .uint32Param = HKS_DIGEST_SHA384
190 }
191 };
192 static struct HksParam g_signParamsTest004[] = {
193 {
194 .tag = HKS_TAG_ALGORITHM,
195 .uint32Param = HKS_ALG_DSA
196 }, {
197 .tag = HKS_TAG_PURPOSE,
198 .uint32Param = HKS_KEY_PURPOSE_SIGN
199 }, {
200 .tag = HKS_TAG_DIGEST,
201 .uint32Param = HKS_DIGEST_SHA384
202 }
203 };
204 static struct HksParam g_verifyParamsTest004[] = {
205 {
206 .tag = HKS_TAG_ALGORITHM,
207 .uint32Param = HKS_ALG_DSA
208 }, {
209 .tag = HKS_TAG_PURPOSE,
210 .uint32Param = HKS_KEY_PURPOSE_VERIFY
211 }, {
212 .tag = HKS_TAG_KEY_SIZE,
213 .uint32Param = Unittest::DsaSignVerify::DSA_COMMON_SIZE
214 }, {
215 .tag = HKS_TAG_DIGEST,
216 .uint32Param = HKS_DIGEST_SHA384
217 }
218 };
219 static struct HksParam g_genParamsTest005[] = {
220 {
221 .tag = HKS_TAG_ALGORITHM,
222 .uint32Param = HKS_ALG_DSA
223 }, {
224 .tag = HKS_TAG_PURPOSE,
225 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
226 }, {
227 .tag = HKS_TAG_KEY_SIZE,
228 .uint32Param = Unittest::DsaSignVerify::DSA_COMMON_SIZE
229 }, {
230 .tag = HKS_TAG_DIGEST,
231 .uint32Param = HKS_DIGEST_SHA512
232 }
233 };
234 static struct HksParam g_signParamsTest005[] = {
235 {
236 .tag = HKS_TAG_ALGORITHM,
237 .uint32Param = HKS_ALG_DSA
238 }, {
239 .tag = HKS_TAG_PURPOSE,
240 .uint32Param = HKS_KEY_PURPOSE_SIGN
241 }, {
242 .tag = HKS_TAG_DIGEST,
243 .uint32Param = HKS_DIGEST_SHA512
244 }
245 };
246 static struct HksParam g_verifyParamsTest005[] = {
247 {
248 .tag = HKS_TAG_ALGORITHM,
249 .uint32Param = HKS_ALG_DSA
250 }, {
251 .tag = HKS_TAG_PURPOSE,
252 .uint32Param = HKS_KEY_PURPOSE_VERIFY
253 }, {
254 .tag = HKS_TAG_KEY_SIZE,
255 .uint32Param = Unittest::DsaSignVerify::DSA_COMMON_SIZE
256 }, {
257 .tag = HKS_TAG_DIGEST,
258 .uint32Param = HKS_DIGEST_SHA512
259 }
260 };
261 static struct HksParam g_genParamsTest006[] = {
262 {
263 .tag = HKS_TAG_ALGORITHM,
264 .uint32Param = HKS_ALG_DSA
265 }, {
266 .tag = HKS_TAG_PURPOSE,
267 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
268 }, {
269 .tag = HKS_TAG_KEY_SIZE,
270 .uint32Param = Unittest::DsaSignVerify::DSA_COMMON_SIZE
271 }, {
272 .tag = HKS_TAG_DIGEST,
273 .uint32Param = HKS_DIGEST_SHA1
274 }
275 };
276 static struct HksParam g_signParamsTest006[] = {
277 {
278 .tag = HKS_TAG_ALGORITHM,
279 .uint32Param = HKS_ALG_DSA
280 }, {
281 .tag = HKS_TAG_PURPOSE,
282 .uint32Param = HKS_KEY_PURPOSE_SIGN
283 }, {
284 .tag = HKS_TAG_DIGEST,
285 .uint32Param = HKS_DIGEST_SHA1
286 }
287 };
288 static struct HksParam g_verifyParamsTest006[] = {
289 {
290 .tag = HKS_TAG_ALGORITHM,
291 .uint32Param = HKS_ALG_DSA
292 }, {
293 .tag = HKS_TAG_PURPOSE,
294 .uint32Param = HKS_KEY_PURPOSE_VERIFY
295 }, {
296 .tag = HKS_TAG_KEY_SIZE,
297 .uint32Param = Unittest::DsaSignVerify::DSA_COMMON_SIZE
298 }, {
299 .tag = HKS_TAG_DIGEST,
300 .uint32Param = HKS_DIGEST_SHA1
301 }
302 };
303
304 static struct HksParam g_genParamsTest007[] = {
305 {
306 .tag = HKS_TAG_ALGORITHM,
307 .uint32Param = HKS_ALG_DSA
308 }, {
309 .tag = HKS_TAG_PURPOSE,
310 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
311 }, {
312 .tag = HKS_TAG_KEY_SIZE,
313 .uint32Param = Unittest::DsaSignVerify::DSA_COMMON_SIZE
314 }, {
315 .tag = HKS_TAG_DIGEST,
316 .uint32Param = HKS_DIGEST_SHA1
317 }
318 };
319 static struct HksParam g_signParamsTest007[] = {
320 {
321 .tag = HKS_TAG_ALGORITHM,
322 .uint32Param = HKS_ALG_DSA
323 }, {
324 .tag = HKS_TAG_PURPOSE,
325 .uint32Param = HKS_KEY_PURPOSE_SIGN
326 }, {
327 .tag = HKS_TAG_DIGEST,
328 .uint32Param = HKS_DIGEST_SHA1
329 }
330 };
331 static struct HksParam g_genParamsTest008[] = {
332 {
333 .tag = HKS_TAG_ALGORITHM,
334 .uint32Param = HKS_ALG_DSA
335 }, {
336 .tag = HKS_TAG_PURPOSE,
337 .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY
338 }, {
339 .tag = HKS_TAG_KEY_SIZE,
340 .uint32Param = Unittest::DsaSignVerify::DSA_COMMON_SIZE
341 }, {
342 .tag = HKS_TAG_DIGEST,
343 .uint32Param = HKS_DIGEST_SHA1
344 }
345 };
346 static struct HksParam g_signParamsTest008[] = {
347 {
348 .tag = HKS_TAG_ALGORITHM,
349 .uint32Param = HKS_ALG_DSA
350 }, {
351 .tag = HKS_TAG_PURPOSE,
352 .uint32Param = HKS_KEY_PURPOSE_SIGN
353 }, {
354 .tag = HKS_TAG_DIGEST,
355 .uint32Param = HKS_DIGEST_NONE
356 }
357 };
358
HksTestSignVerify(struct HksBlob * keyAlias,struct HksParamSet * paramSet,const struct HksBlob * inData,struct HksBlob * outData,bool isSign)359 int32_t HksTestSignVerify(struct HksBlob *keyAlias, struct HksParamSet *paramSet, const struct HksBlob *inData,
360 struct HksBlob *outData, bool isSign)
361 {
362 uint8_t tmpHandle[sizeof(uint64_t)] = {0};
363 struct HksBlob handle = { sizeof(uint64_t), tmpHandle };
364 int32_t ret = HksInit(keyAlias, paramSet, &handle);
365 EXPECT_EQ(ret, HKS_SUCCESS) << "Init failed.";
366 if (ret != HKS_SUCCESS) {
367 return HKS_FAILURE;
368 }
369
370 struct HksParam *tmpParam = NULL;
371 ret = HksGetParam(paramSet, HKS_TAG_PURPOSE, &tmpParam);
372 if (ret != HKS_SUCCESS) {
373 HKS_LOG_E("get tag purpose failed.");
374 return HKS_FAILURE;
375 }
376
377 ret = TestUpdateFinish(&handle, paramSet, tmpParam->uint32Param, inData, outData);
378 EXPECT_EQ(ret, HKS_SUCCESS) << "TestUpdateFinish failed.";
379 if (ret != HKS_SUCCESS) {
380 return HKS_FAILURE;
381 }
382
383 if (isSign) {
384 uint8_t tmpOut[Unittest::DsaSignVerify::DSA_COMMON_SIZE] = {0};
385 struct HksBlob outData1 = { Unittest::DsaSignVerify::DSA_COMMON_SIZE, tmpOut };
386 ret = HksSign(keyAlias, paramSet, inData, &outData1);
387 EXPECT_EQ(ret, HKS_SUCCESS) << "HksSign failed.";
388 } else {
389 ret = HksVerify(keyAlias, paramSet, inData, outData);
390 EXPECT_EQ(ret, HKS_SUCCESS) << "HksVerify failed.";
391 }
392
393 return ret;
394 }
395
HksDsaSignVerifyTestNormalCase(struct HksBlob keyAlias,struct HksParamSet * genParamSet,struct HksParamSet * signParamSet,struct HksParamSet * verifyParamSet)396 int32_t HksDsaSignVerifyTestNormalCase(struct HksBlob keyAlias, struct HksParamSet *genParamSet,
397 struct HksParamSet *signParamSet, struct HksParamSet *verifyParamSet)
398 {
399 struct HksBlob inData = {
400 Unittest::DsaSignVerify::g_inData.length(),
401 (uint8_t *)Unittest::DsaSignVerify::g_inData.c_str()
402 };
403 int32_t ret = HKS_FAILURE;
404
405 /* 1. Generate Key */
406 // Generate Key
407 ret = HksGenerateKey(&keyAlias, genParamSet, nullptr);
408 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey failed.";
409
410 /* 2. Sign Three Stage */
411 uint8_t outDataS[Unittest::DsaSignVerify::DSA_COMMON_SIZE] = {0};
412 struct HksBlob outDataSign = { Unittest::DsaSignVerify::DSA_COMMON_SIZE, outDataS };
413 ret = HksTestSignVerify(&keyAlias, signParamSet, &inData, &outDataSign, true);
414 EXPECT_EQ(ret, HKS_SUCCESS) << "Sign failed.";
415
416 /* 3. Export Public Key */
417 uint8_t pubKey[Unittest::DsaSignVerify::DSA_COMMON_SIZE] = {0};
418 struct HksBlob publicKey = { Unittest::DsaSignVerify::DSA_COMMON_SIZE, pubKey };
419 ret = HksExportPublicKey(&keyAlias, genParamSet, &publicKey);
420 EXPECT_EQ(ret, HKS_SUCCESS) << "ExportPublicKey failed.";
421
422 /* 4. Import Key */
423 char newKey[] = "DSA_Sign_Verify_Import_KeyAlias";
424 struct HksBlob newKeyAlias = { .size = strlen(newKey), .data = (uint8_t *)newKey };
425 ret = HksImportKey(&newKeyAlias, verifyParamSet, &publicKey);
426 EXPECT_EQ(ret, HKS_SUCCESS) << "ImportKey failed";
427
428 /* 5. Verify Three Stage */
429 ret = HksTestSignVerify(&newKeyAlias, verifyParamSet, &inData, &outDataSign, false);
430 EXPECT_EQ(ret, HKS_SUCCESS) << "Verify failed.";
431
432 /* 6. Delete New Key */
433 int32_t deleteRet = HksDeleteKey(&newKeyAlias, verifyParamSet);
434 EXPECT_EQ(deleteRet, HKS_SUCCESS) << "Delete ImportKey failed.";
435
436 return ret;
437 }
438
439 /**
440 * @tc.name: HksDsaSignVerifyTest.HksDsaSignVerifyTest001
441 * @tc.desc: alg-DSA pur-Sign-verify dig-SHA1
442 * @tc.type: FUNC
443 */
444 HWTEST_F(HksDsaSignVerifyTest, HksDsaSignVerifyTest001, TestSize.Level0)
445 {
446 int32_t ret = HKS_FAILURE;
447 const char *keyAliasString = "HksDSASignVerifyKeyAliasTest001";
448 struct HksParamSet *genParamSet = nullptr;
449 struct HksParamSet *signParamSet = nullptr;
450 struct HksParamSet *verifyParamSet = nullptr;
451 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
452
453 ret = InitParamSet(&genParamSet, g_genParamsTest001, sizeof(g_genParamsTest001)/sizeof(HksParam));
454 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
455 ret = InitParamSet(&signParamSet, g_signParamsTest001, sizeof(g_signParamsTest001)/sizeof(HksParam));
456 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
457 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest001, sizeof(g_verifyParamsTest001)/sizeof(HksParam));
458 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
459 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
460 ret = HksDsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
461 }
462
463 /* 5. Delete Key */
464 ret = HksDeleteKey(&keyAlias, genParamSet);
465 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
466
467 HksFreeParamSet(&genParamSet);
468 HksFreeParamSet(&signParamSet);
469 HksFreeParamSet(&verifyParamSet);
470 }
471
472 /**
473 * @tc.name: HksDsaSignVerifyTest.HksDsaSignVerifyTest002
474 * @tc.desc: alg-DSA pur-Sign-verify dig-SHA224
475 * @tc.type: FUNC
476 */
477 HWTEST_F(HksDsaSignVerifyTest, HksDsaSignVerifyTest002, TestSize.Level0)
478 {
479 int32_t ret = HKS_FAILURE;
480 const char *keyAliasString = "HksDSASignVerifyKeyAliasTest002";
481 struct HksParamSet *genParamSet = nullptr;
482 struct HksParamSet *signParamSet = nullptr;
483 struct HksParamSet *verifyParamSet = nullptr;
484 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
485
486 ret = InitParamSet(&genParamSet, g_genParamsTest002, sizeof(g_genParamsTest002)/sizeof(HksParam));
487 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
488 ret = InitParamSet(&signParamSet, g_signParamsTest002, sizeof(g_signParamsTest002)/sizeof(HksParam));
489 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
490 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest002, sizeof(g_verifyParamsTest002)/sizeof(HksParam));
491 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
492
493 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
494 ret = HksDsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
495 }
496
497 /* 5. Delete Key */
498 ret = HksDeleteKey(&keyAlias, genParamSet);
499 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
500
501 HksFreeParamSet(&genParamSet);
502 HksFreeParamSet(&signParamSet);
503 HksFreeParamSet(&verifyParamSet);
504 }
505
506 /**
507 * @tc.name: HksDsaSignVerifyTest.HksDsaSignVerifyTest003
508 * @tc.desc: alg-DSA pur-Sign-verify dig-SHA256
509 * @tc.type: FUNC
510 */
511 HWTEST_F(HksDsaSignVerifyTest, HksDsaSignVerifyTest003, TestSize.Level0)
512 {
513 int32_t ret = HKS_FAILURE;
514 const char *keyAliasString = "HksDSASignVerifyKeyAliasTest003";
515 struct HksParamSet *genParamSet = nullptr;
516 struct HksParamSet *signParamSet = nullptr;
517 struct HksParamSet *verifyParamSet = nullptr;
518 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
519
520 ret = InitParamSet(&genParamSet, g_genParamsTest003, sizeof(g_genParamsTest003)/sizeof(HksParam));
521 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
522 ret = InitParamSet(&signParamSet, g_signParamsTest003, sizeof(g_signParamsTest003)/sizeof(HksParam));
523 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
524 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest003, sizeof(g_verifyParamsTest003)/sizeof(HksParam));
525 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
526
527 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
528 ret = HksDsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
529 }
530
531 /* 5. Delete Key */
532 ret = HksDeleteKey(&keyAlias, genParamSet);
533 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
534
535 HksFreeParamSet(&genParamSet);
536 HksFreeParamSet(&signParamSet);
537 HksFreeParamSet(&verifyParamSet);
538 }
539
540 /**
541 * @tc.name: HksDsaSignVerifyTest.HksDsaSignVerifyTest004
542 * @tc.desc: alg-DSA pur-Sign-verify dig-SHA384
543 * @tc.type: FUNC
544 */
545 HWTEST_F(HksDsaSignVerifyTest, HksDsaSignVerifyTest004, TestSize.Level0)
546 {
547 int32_t ret = HKS_FAILURE;
548 const char *keyAliasString = "HksDSASignVerifyKeyAliasTest004";
549 struct HksParamSet *genParamSet = nullptr;
550 struct HksParamSet *signParamSet = nullptr;
551 struct HksParamSet *verifyParamSet = nullptr;
552 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
553
554 ret = InitParamSet(&genParamSet, g_genParamsTest004, sizeof(g_genParamsTest004)/sizeof(HksParam));
555 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
556 ret = InitParamSet(&signParamSet, g_signParamsTest004, sizeof(g_signParamsTest004)/sizeof(HksParam));
557 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
558 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest004, sizeof(g_verifyParamsTest004)/sizeof(HksParam));
559 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
560
561 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
562 ret = HksDsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
563 }
564
565 /* 5. Delete Key */
566 ret = HksDeleteKey(&keyAlias, genParamSet);
567 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
568
569 HksFreeParamSet(&genParamSet);
570 HksFreeParamSet(&signParamSet);
571 HksFreeParamSet(&verifyParamSet);
572 }
573
574 /**
575 * @tc.name: HksDsaSignVerifyTest.HksDsaSignVerifyTest005
576 * @tc.desc: alg-DSA pur-Sign-verify dig-SHA512
577 * @tc.type: FUNC
578 */
579 HWTEST_F(HksDsaSignVerifyTest, HksDsaSignVerifyTest005, TestSize.Level0)
580 {
581 int32_t ret = HKS_FAILURE;
582 const char *keyAliasString = "HksDSASignVerifyKeyAliasTest005";
583 struct HksParamSet *genParamSet = nullptr;
584 struct HksParamSet *signParamSet = nullptr;
585 struct HksParamSet *verifyParamSet = nullptr;
586 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
587
588 ret = InitParamSet(&genParamSet, g_genParamsTest005, sizeof(g_genParamsTest005)/sizeof(HksParam));
589 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
590 ret = InitParamSet(&signParamSet, g_signParamsTest005, sizeof(g_signParamsTest005)/sizeof(HksParam));
591 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
592 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest005, sizeof(g_verifyParamsTest005)/sizeof(HksParam));
593 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
594
595 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
596 ret = HksDsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
597 }
598
599 /* 5. Delete Key */
600 ret = HksDeleteKey(&keyAlias, genParamSet);
601 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
602
603 HksFreeParamSet(&genParamSet);
604 HksFreeParamSet(&signParamSet);
605 HksFreeParamSet(&verifyParamSet);
606 }
607
608 /**
609 * @tc.name: HksDsaSignVerifyTest.HksDsaSignVerifyTest006
610 * @tc.desc: alg-DSA pur-Sign-verify dig-SHA1 Verify-Abort
611 * @tc.type: FUNC
612 */
613 HWTEST_F(HksDsaSignVerifyTest, HksDsaSignVerifyTest006, TestSize.Level0)
614 {
615 int32_t ret = HKS_FAILURE;
616 const char *keyAliasString = "HksDSASignVerifyKeyAliasTest006";
617 struct HksParamSet *genParamSet = nullptr;
618 struct HksParamSet *signParamSet = nullptr;
619 struct HksParamSet *verifyParamSet = nullptr;
620 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
621
622 ret = InitParamSet(&genParamSet, g_genParamsTest006, sizeof(g_genParamsTest006)/sizeof(HksParam));
623 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
624 ret = InitParamSet(&signParamSet, g_signParamsTest006, sizeof(g_signParamsTest006)/sizeof(HksParam));
625 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
626 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest006, sizeof(g_verifyParamsTest006)/sizeof(HksParam));
627 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
628
629 if ((genParamSet != nullptr) || (signParamSet != nullptr) || (verifyParamSet != nullptr)) {
630 ret = HksDsaSignVerifyTestNormalCase(keyAlias, genParamSet, signParamSet, verifyParamSet);
631 }
632
633 /* 5. Delete Key */
634 ret = HksDeleteKey(&keyAlias, genParamSet);
635 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
636
637 HksFreeParamSet(&genParamSet);
638 HksFreeParamSet(&signParamSet);
639 HksFreeParamSet(&verifyParamSet);
640 }
641
642 /**
643 * @tc.name: HksDsaSignVerifyTest.HksDsaSignVerifyTest007
644 * @tc.desc: alg-DSA pur-Sign-verify dig-SHA1 Sign-Abort
645 * @tc.type: FUNC
646 */
647 HWTEST_F(HksDsaSignVerifyTest, HksDsaSignVerifyTest007, TestSize.Level0)
648 {
649 const char *keyAliasString = "HksDSASignVerifyKeyAliasTest007";
650 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
651 struct HksBlob inData = { Unittest::DsaSignVerify::g_inData.length(),
652 (uint8_t *)Unittest::DsaSignVerify::g_inData.c_str() };
653 int32_t ret = HKS_FAILURE;
654
655 /* 1. Generate Key */
656 struct HksParamSet *genParamSet = nullptr;
657 ret = InitParamSet(&genParamSet, g_genParamsTest007, sizeof(g_genParamsTest007)/sizeof(HksParam));
658 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
659 // Generate Key
660 ret = HksGenerateKey(&keyAlias, genParamSet, nullptr);
661 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey failed.";
662
663 /* 2. Sign Three Stage (Abort) */
664 struct HksParamSet *signParamSet = nullptr;
665 ret = InitParamSet(&signParamSet, g_signParamsTest007, sizeof(g_signParamsTest007)/sizeof(HksParam));
666 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
667
668 // Init
669 uint8_t handleS[sizeof(uint64_t)] = {0};
670 struct HksBlob handleSign = { sizeof(uint64_t), handleS };
671
672 ret = HksInit(&keyAlias, signParamSet, &handleSign);
673 EXPECT_EQ(ret, HKS_SUCCESS) << "Init failed.";
674
675 // Update loop
676 ret = HksTestUpdate(&handleSign, signParamSet, &inData);
677 EXPECT_EQ(ret, HKS_SUCCESS) << "Update failed.";
678
679 // Abort
680 ret = HksAbort(&handleSign, signParamSet);
681 EXPECT_EQ(ret, HKS_SUCCESS) << "Abort failed.";
682
683 /* 3. Delete Key */
684 ret = HksDeleteKey(&keyAlias, genParamSet);
685 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
686
687 HksFreeParamSet(&genParamSet);
688 HksFreeParamSet(&signParamSet);
689 }
690
691 /**
692 * @tc.name: HksDsaSignVerifyTest.HksDsaSignVerifyTest008
693 * @tc.desc: alg-DSA pur-Sign-verify dig-NONE abnormal
694 * @tc.type: FUNC
695 */
696 HWTEST_F(HksDsaSignVerifyTest, HksDsaSignVerifyTest008, TestSize.Level0)
697 {
698 const char *keyAliasString = "HksDSASignVerifyKeyAliasTest008";
699 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
700 int32_t ret = HKS_FAILURE;
701
702 /* 1. Generate Key */
703 struct HksParamSet *genParamSet = nullptr;
704 ret = InitParamSet(&genParamSet, g_genParamsTest008, sizeof(g_genParamsTest008)/sizeof(HksParam));
705 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
706 // Generate Key
707 ret = HksGenerateKey(&keyAlias, genParamSet, nullptr);
708 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey failed.";
709
710 /* 2. Sign Three Stage */
711 struct HksParamSet *signParamSet = nullptr;
712 ret = InitParamSet(&signParamSet, g_signParamsTest008, sizeof(g_signParamsTest008)/sizeof(HksParam));
713 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
714
715 // Init
716 uint8_t handleS[sizeof(uint64_t)] = {0};
717 struct HksBlob handleSign = { sizeof(uint64_t), handleS };
718 ret = HksInit(NULL, signParamSet, &handleSign);
719 EXPECT_NE(ret, HKS_SUCCESS) << "Init should failed.";
720
721 /* 3. Delete Key */
722 ret = HksDeleteKey(&keyAlias, genParamSet);
723 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
724
725 HksFreeParamSet(&genParamSet);
726 HksFreeParamSet(&signParamSet);
727 }
728 } // namespace