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