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