1 /*
2 * Copyright (C) 2024 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 "hkdf_openssl.h"
17
18 #include <gtest/gtest.h>
19 #include "securec.h"
20
21 #include "detailed_hkdf_params.h"
22 #include "kdf.h"
23 #include "log.h"
24 #include "memory.h"
25
26 using namespace std;
27 using namespace testing::ext;
28
29 namespace {
30 class CryptoHkdfTest : public testing::Test {
31 public:
32 static void SetUpTestCase();
33 static void TearDownTestCase();
34 void SetUp();
35 void TearDown();
36 };
37
SetUpTestCase()38 void CryptoHkdfTest::SetUpTestCase() {}
TearDownTestCase()39 void CryptoHkdfTest::TearDownTestCase() {}
40
SetUp()41 void CryptoHkdfTest::SetUp() // add init here, this will be called before test.
42 {
43 }
44
TearDown()45 void CryptoHkdfTest::TearDown() // add destroy here, this will be called when test case done.
46 {
47 }
48
49 static const char *g_keyData = "012345678901234567890123456789";
50 static const char *g_infoData = "infostring";
51 static const char *g_saltData = "saltstring";
52
53
54 constexpr uint32_t OUT_PUT_MAX_LENGTH = 128;
55 constexpr uint32_t OUT_PUT_NORMAL_LENGTH = 32;
56
57 HWTEST_F(CryptoHkdfTest, CryptoHkdfTest1, TestSize.Level0)
58 {
59 HcfKdf *generator = nullptr;
60 HcfResult ret = HcfKdfCreate("HKDF|SHA256", &generator);
61 EXPECT_EQ(ret, HCF_SUCCESS);
62 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
63 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
64 HcfBlob salt = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_saltData)),
65 .len = strlen(g_saltData)};
66 HcfBlob key = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_keyData)),
67 .len = strlen(g_keyData)};
68 HcfBlob info = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_infoData)),
69 .len = strlen(g_infoData)};
70 HcfHkdfParamsSpec params = {
71 .base = { .algName = "HKDF", },
72 .key = key,
73 .salt = salt,
74 .info = info,
75 .output = output,
76 };
77 ret = generator->generateSecret(generator, &(params.base));
78 EXPECT_EQ(ret, HCF_SUCCESS);
79 HcfObjDestroy(generator);
80 }
81
82 HWTEST_F(CryptoHkdfTest, CryptoHkdfErrTest1, TestSize.Level0)
83 {
84 HcfKdf *generator = nullptr;
85 HcfResult ret = HcfKdfCreate("HKDF|SHA256", &generator);
86 EXPECT_EQ(ret, HCF_SUCCESS);
87 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
88 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
89 HcfBlob salt = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_saltData)),
90 .len = strlen(g_saltData)};
91 HcfBlob key = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_keyData)),
92 .len = strlen(g_keyData)};
93 HcfBlob info = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_infoData)),
94 .len = strlen(g_infoData)};
95 HcfHkdfParamsSpec params = {
96 .base = { .algName = "HKDF", },
97 .key = key,
98 .salt = salt,
99 .info = info,
100 .output = output,
101 };
102 generator->base.destroy(nullptr);
103 ret = generator->generateSecret(nullptr, &(params.base));
104 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
105 HcfObjDestroy(generator);
106 }
107
108 HWTEST_F(CryptoHkdfTest, CryptoHkdfTest2, TestSize.Level0)
109 {
110 // mode is default, info data is nullptr
111 HcfKdf *generator = nullptr;
112 HcfResult ret = HcfKdfCreate("HKDF|SHA256", &generator);
113 EXPECT_EQ(ret, HCF_SUCCESS);
114 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
115 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
116 HcfBlob salt = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_saltData)),
117 .len = strlen(g_saltData)};
118 HcfBlob key = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_keyData)),
119 .len = strlen(g_keyData)};
120 HcfBlob info = {.data = nullptr, .len = strlen(g_infoData)};
121 HcfHkdfParamsSpec params = {
122 .base = { .algName = "HKDF", },
123 .key = key,
124 .salt = salt,
125 .info = info,
126 .output = output,
127 };
128 ret = generator->generateSecret(generator, &(params.base));
129 EXPECT_EQ(ret, HCF_SUCCESS);
130 HcfObjDestroy(generator);
131 }
132
133 HWTEST_F(CryptoHkdfTest, CryptoHkdfTest3, TestSize.Level0)
134 {
135 // default mode is EXTRACT_AND_EXPAND
136 HcfKdf *generator = nullptr;
137 HcfKdf *generator1 = nullptr;
138 HcfResult ret = HcfKdfCreate("HKDF|SHA256", &generator);
139 EXPECT_EQ(ret, HCF_SUCCESS);
140 HcfResult ret1 = HcfKdfCreate("HKDF|SHA256|EXTRACT_AND_EXPAND", &generator1);
141 EXPECT_EQ(ret1, HCF_SUCCESS);
142
143 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
144 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
145 HcfBlob salt = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_saltData)),
146 .len = strlen(g_saltData)};
147 HcfBlob key = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_keyData)),
148 .len = strlen(g_keyData)};
149 HcfBlob info = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_infoData)),
150 .len = strlen(g_infoData)};
151 HcfHkdfParamsSpec params = {
152 .base = { .algName = "HKDF", },
153 .key = key,
154 .salt = salt,
155 .info = info,
156 .output = output,
157 };
158 ret = generator->generateSecret(generator, &(params.base));
159 EXPECT_EQ(ret, HCF_SUCCESS);
160
161 HcfHkdfParamsSpec params1 = {
162 .base = { .algName = "HKDF", },
163 .key = key,
164 .salt = salt,
165 .info = info,
166 .output = output,
167 };
168 ret1 = generator->generateSecret(generator, &(params1.base));
169 EXPECT_EQ(ret1, HCF_SUCCESS);
170 EXPECT_EQ(params.output.data, params1.output.data);
171
172 HcfObjDestroy(generator);
173 HcfObjDestroy(generator1);
174 }
175
176 HWTEST_F(CryptoHkdfTest, CryptoHkdfTest4, TestSize.Level0)
177 {
178 // mode is EXTRACT_ONLY
179 HcfKdf *generator = nullptr;
180 HcfResult ret = HcfKdfCreate("HKDF|SHA256|EXTRACT_ONLY", &generator);
181 EXPECT_EQ(ret, HCF_SUCCESS);
182 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
183 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
184 HcfBlob salt = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_saltData)),
185 .len = strlen(g_saltData)};
186 HcfBlob key = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_keyData)),
187 .len = strlen(g_keyData)};
188 HcfHkdfParamsSpec params = {
189 .base = { .algName = "HKDF", },
190 .key = key,
191 .salt = salt,
192 .output = output,
193 };
194 ret = generator->generateSecret(generator, &(params.base));
195 EXPECT_EQ(ret, HCF_SUCCESS);
196 HcfObjDestroy(generator);
197 }
198
199 HWTEST_F(CryptoHkdfTest, CryptoHkdfTest5, TestSize.Level0)
200 {
201 // mode is EXPAND_ONLY
202 HcfKdf *generator = nullptr;
203 HcfResult ret = HcfKdfCreate("HKDF|SHA256|EXPAND_ONLY", &generator);
204 EXPECT_EQ(ret, HCF_SUCCESS);
205 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
206 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
207 HcfBlob key = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_keyData)),
208 .len = strlen(g_keyData)};
209 HcfBlob info = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_infoData)),
210 .len = strlen(g_infoData)};
211 HcfHkdfParamsSpec params = {
212 .base = { .algName = "HKDF", },
213 .key = key,
214 .info = info,
215 .output = output,
216 };
217 ret = generator->generateSecret(generator, &(params.base));
218 EXPECT_EQ(ret, HCF_SUCCESS);
219 HcfObjDestroy(generator);
220 }
221
222 HWTEST_F(CryptoHkdfTest, CryptoHkdfTest6, TestSize.Level0)
223 {
224 HcfKdf *generator = nullptr;
225 HcfResult ret = HcfKdfCreate("HKDF|SHA1", &generator);
226 EXPECT_EQ(ret, HCF_SUCCESS);
227 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
228 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
229 HcfBlob salt = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_saltData)),
230 .len = strlen(g_saltData)};
231 HcfBlob key = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_keyData)),
232 .len = strlen(g_keyData)};
233 HcfBlob info = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_infoData)),
234 .len = strlen(g_infoData)};
235 HcfHkdfParamsSpec params = {
236 .base = { .algName = "HKDF", },
237 .key = key,
238 .salt = salt,
239 .info = info,
240 .output = output,
241 };
242 ret = generator->generateSecret(generator, &(params.base));
243 EXPECT_EQ(ret, HCF_SUCCESS);
244 HcfObjDestroy(generator);
245 }
246
247 HWTEST_F(CryptoHkdfTest, CryptoHkdfTest7, TestSize.Level0)
248 {
249 HcfKdf *generator = nullptr;
250 HcfResult ret = HcfKdfCreate("HKDF|SHA384", &generator);
251 EXPECT_EQ(ret, HCF_SUCCESS);
252 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
253 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
254 HcfBlob salt = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_saltData)),
255 .len = strlen(g_saltData)};
256 HcfBlob key = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_keyData)),
257 .len = strlen(g_keyData)};
258 HcfBlob info = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_infoData)),
259 .len = strlen(g_infoData)};
260 HcfHkdfParamsSpec params = {
261 .base = { .algName = "HKDF", },
262 .key = key,
263 .salt = salt,
264 .info = info,
265 .output = output,
266 };
267 ret = generator->generateSecret(generator, &(params.base));
268 EXPECT_EQ(ret, HCF_SUCCESS);
269 HcfObjDestroy(generator);
270 }
271
272 HWTEST_F(CryptoHkdfTest, CryptoHkdfTest8, TestSize.Level0)
273 {
274 HcfKdf *generator = nullptr;
275 HcfResult ret = HcfKdfCreate("HKDF|SHA512", &generator);
276 EXPECT_EQ(ret, HCF_SUCCESS);
277 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
278 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
279 HcfBlob salt = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_saltData)),
280 .len = strlen(g_saltData)};
281 HcfBlob key = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_keyData)),
282 .len = strlen(g_keyData)};
283 HcfBlob info = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_infoData)),
284 .len = strlen(g_infoData)};
285 HcfHkdfParamsSpec params = {
286 .base = { .algName = "HKDF", },
287 .key = key,
288 .salt = salt,
289 .info = info,
290 .output = output,
291 };
292 ret = generator->generateSecret(generator, &(params.base));
293 EXPECT_EQ(ret, HCF_SUCCESS);
294 HcfObjDestroy(generator);
295 }
296
297 HWTEST_F(CryptoHkdfTest, CryptoHkdfTest9, TestSize.Level0)
298 {
299 HcfKdf *generator = nullptr;
300 HcfResult ret = HcfKdfCreate("HKDF|SM3", &generator);
301 EXPECT_EQ(ret, HCF_SUCCESS);
302 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
303 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
304 HcfBlob salt = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_saltData)),
305 .len = strlen(g_saltData)};
306 HcfBlob key = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_keyData)),
307 .len = strlen(g_keyData)};
308 HcfBlob info = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_infoData)),
309 .len = strlen(g_infoData)};
310 HcfHkdfParamsSpec params = {
311 .base = { .algName = "HKDF", },
312 .key = key,
313 .salt = salt,
314 .info = info,
315 .output = output,
316 };
317 ret = generator->generateSecret(generator, &(params.base));
318 EXPECT_EQ(ret, HCF_SUCCESS);
319 HcfObjDestroy(generator);
320 }
321
322 HWTEST_F(CryptoHkdfTest, CryptoHkdfTest10, TestSize.Level0)
323 {
324 HcfKdf *generator = nullptr;
325 HcfResult ret = HcfKdfCreate("HKDF|SHA224", &generator);
326 EXPECT_EQ(ret, HCF_SUCCESS);
327 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
328 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
329 HcfBlob salt = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_saltData)),
330 .len = strlen(g_saltData)};
331 HcfBlob key = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_keyData)),
332 .len = strlen(g_keyData)};
333 HcfBlob info = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_infoData)),
334 .len = strlen(g_infoData)};
335 HcfHkdfParamsSpec params = {
336 .base = { .algName = "HKDF", },
337 .key = key,
338 .salt = salt,
339 .info = info,
340 .output = output,
341 };
342 ret = generator->generateSecret(generator, &(params.base));
343 EXPECT_EQ(ret, HCF_SUCCESS);
344 HcfObjDestroy(generator);
345 }
346
347 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestError1, TestSize.Level1)
348 {
349 // mode is EXPAND_ONLY, salt data is nullptr
350 HcfKdf *generator = nullptr;
351 HcfResult ret = HcfKdfCreate("HKDF|SHA256|EXPAND_ONLY", &generator);
352 EXPECT_EQ(ret, HCF_SUCCESS);
353 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
354 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
355 HcfBlob info = {.data = nullptr, .len = 0};
356 HcfBlob key = {.data = nullptr, .len = 0};
357 HcfHkdfParamsSpec params = {
358 .base = { .algName = "HKDF", },
359 .key = key,
360 .info = info,
361 .output = output,
362 };
363 ret = generator->generateSecret(generator, &(params.base));
364 EXPECT_NE(ret, HCF_SUCCESS);
365 HcfObjDestroy(generator);
366 }
367
368 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestError2, TestSize.Level1)
369 {
370 // mode is EXTRACT_ONLY, salt data is nullptr
371 HcfKdf *generator = nullptr;
372 HcfResult ret = HcfKdfCreate("HKDF|SHA256|EXTRACT_ONLY", &generator);
373 EXPECT_EQ(ret, HCF_SUCCESS);
374 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
375 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
376 HcfBlob salt = {.data = nullptr, .len = 0};
377 HcfBlob key = {.data = nullptr, .len = 0};
378 HcfHkdfParamsSpec params = {
379 .base = { .algName = "HKDF", },
380 .key = key,
381 .salt = salt,
382 .output = output,
383 };
384 ret = generator->generateSecret(generator, &(params.base));
385 EXPECT_NE(ret, HCF_SUCCESS);
386 HcfObjDestroy(generator);
387 }
388
389 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestError3, TestSize.Level1)
390 {
391 // mode is default, data is nullptr
392 HcfKdf *generator = nullptr;
393 HcfResult ret = HcfKdfCreate("HKDF|SHA256", &generator);
394 EXPECT_EQ(ret, HCF_SUCCESS);
395 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
396 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
397 HcfBlob salt = {.data = nullptr, .len = 0};
398 HcfBlob key = {.data = nullptr, .len = 0};
399 HcfBlob info = {.data = nullptr, .len = 0};
400 HcfHkdfParamsSpec params = {
401 .base = { .algName = "HKDF", },
402 .key = key,
403 .salt = salt,
404 .info = info,
405 .output = output,
406 };
407 ret = generator->generateSecret(generator, &(params.base));
408 EXPECT_NE(ret, HCF_SUCCESS);
409 HcfObjDestroy(generator);
410 }
411
412 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestError4, TestSize.Level1)
413 {
414 // mode is default, key data is nullptr
415 HcfKdf *generator = nullptr;
416 HcfResult ret = HcfKdfCreate("HKDF|SHA256", &generator);
417 EXPECT_EQ(ret, HCF_SUCCESS);
418 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
419 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
420 HcfBlob salt = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_saltData)),
421 .len = strlen(g_saltData)};
422 HcfBlob key = {.data = nullptr, .len = 0};
423 HcfBlob info = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_infoData)),
424 .len = strlen(g_infoData)};
425 HcfHkdfParamsSpec params = {
426 .base = { .algName = "HKDF", },
427 .key = key,
428 .salt = salt,
429 .info = info,
430 .output = output,
431 };
432 ret = generator->generateSecret(generator, &(params.base));
433 EXPECT_NE(ret, HCF_SUCCESS);
434 HcfObjDestroy(generator);
435 }
436
437 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestError5, TestSize.Level1)
438 {
439 // use basic params
440 HcfKdf *generator = nullptr;
441 HcfResult ret = HcfKdfCreate("HKDF|SHA256", &generator);
442 EXPECT_EQ(ret, HCF_SUCCESS);
443 HcfBlob key = {.data = nullptr, .len = 0};
444 HcfBlob salt = {.data = nullptr, .len = 0};
445 HcfBlob info = {.data = nullptr, .len = 0};
446 HcfBlob output = {.data = nullptr, .len = 0};
447 HcfHkdfParamsSpec params = {
448 .base = { .algName = "HKDF", },
449 .key = key,
450 .salt = salt,
451 .info = info,
452 .output = output,
453 };
454 ret = generator->generateSecret(generator, (HcfKdfParamsSpec *)¶ms);
455 EXPECT_NE(ret, HCF_SUCCESS);
456 HcfObjDestroy(generator);
457 }
458
459 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestError6, TestSize.Level1)
460 {
461 // use nullptr params
462 HcfKdf *generator = nullptr;
463 HcfResult ret = HcfKdfCreate("HKDF|SHA256", &generator);
464 EXPECT_EQ(ret, HCF_SUCCESS);
465 ret = generator->generateSecret(generator, nullptr);
466 EXPECT_NE(ret, HCF_SUCCESS);
467 HcfObjDestroy(generator);
468 }
469
470 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestError7, TestSize.Level1)
471 {
472 HcfKdf *generator = nullptr;
473 HcfResult ret = HcfKdfCreate("HKDF|abcd", &generator);
474 EXPECT_NE(ret, HCF_SUCCESS);
475 HcfObjDestroy(generator);
476 }
477
478 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestError8, TestSize.Level1)
479 {
480 HcfKdf *generator = nullptr;
481 HcfResult ret = HcfKdfCreate("ABCD|SM3", &generator);
482 EXPECT_NE(ret, HCF_SUCCESS);
483 HcfObjDestroy(generator);
484 }
485
486 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestError9, TestSize.Level1)
487 {
488 HcfKdf *generator = nullptr;
489 HcfResult ret = HcfKdfCreate(nullptr, &generator);
490 EXPECT_NE(ret, HCF_SUCCESS);
491 HcfObjDestroy(generator);
492 }
493
494 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestError10, TestSize.Level1)
495 {
496 HcfResult ret = HcfKdfCreate(nullptr, nullptr);
497 EXPECT_NE(ret, HCF_SUCCESS);
498 }
499
500 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestVectors1, TestSize.Level1)
501 {
502 uint8_t keyData[] = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
503 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b };
504 uint8_t infoData[] = { 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 };
505 uint8_t saltData[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
506 0x0c };
507 uint8_t expectSecret[] = { 0x3c, 0xb2, 0x5f, 0x25, 0xfa, 0xac, 0xd5, 0x7a, 0x90, 0x43, 0x4f,
508 0x64, 0xd0, 0x36, 0x2f, 0x2a, 0x2d, 0x2d, 0x0a, 0x90, 0xcf, 0x1a, 0x5a, 0x4c, 0x5d, 0xb0,
509 0x2d, 0x56, 0xec, 0xc4, 0xc5, 0xbf, 0x34, 0x00, 0x72, 0x08, 0xd5, 0xb8, 0x87, 0x18, 0x58,
510 0x65 };
511
512 HcfKdf *generator = nullptr;
513 HcfResult ret = HcfKdfCreate("HKDF|SHA256", &generator);
514 EXPECT_EQ(ret, HCF_SUCCESS);
515 uint8_t out[42] = {0};
516 HcfBlob output = {.data = out, .len = 42};
517 HcfBlob salt = {.data = saltData, .len = sizeof(saltData)};
518 HcfBlob key = {.data = keyData, .len = sizeof(keyData)};
519 HcfBlob info = {.data = infoData, .len = sizeof(infoData)};
520 HcfHkdfParamsSpec params = {
521 .base = { .algName = "HKDF", },
522 .key = key,
523 .salt = salt,
524 .info = info,
525 .output = output,
526 };
527 ret = generator->generateSecret(generator, &(params.base));
528 EXPECT_EQ(ret, HCF_SUCCESS);
529 EXPECT_EQ(memcmp(params.output.data, expectSecret, sizeof(expectSecret)), 0);
530 HcfObjDestroy(generator);
531 }
532
533 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestVectors2, TestSize.Level1)
534 {
535 uint8_t keyData[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c,
536 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c,
537 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c,
538 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c,
539 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c,
540 0x4d, 0x4e, 0x4f };
541 uint8_t infoData[] = { 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc,
542 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc,
543 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc,
544 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec,
545 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc,
546 0xfd, 0xfe, 0xff };
547 uint8_t saltData[] = { 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c,
548 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c,
549 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c,
550 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c,
551 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac,
552 0xad, 0xae, 0xaf };
553 uint8_t expectSecret[] = { 0xb1, 0x1e, 0x39, 0x8d, 0xc8, 0x03, 0x27, 0xa1, 0xc8, 0xe7, 0xf7, 0x8c,
554 0x59, 0x6a, 0x49, 0x34, 0x4f, 0x01, 0x2e, 0xda, 0x2d, 0x4e, 0xfa, 0xd8, 0xa0, 0x50, 0xcc, 0x4c,
555 0x19, 0xaf, 0xa9, 0x7c, 0x59, 0x04, 0x5a, 0x99, 0xca, 0xc7, 0x82, 0x72, 0x71, 0xcb, 0x41, 0xc6,
556 0x5e, 0x59, 0x0e, 0x09, 0xda, 0x32, 0x75, 0x60, 0x0c, 0x2f, 0x09, 0xb8, 0x36, 0x77, 0x93, 0xa9,
557 0xac, 0xa3, 0xdb, 0x71, 0xcc, 0x30, 0xc5, 0x81, 0x79, 0xec, 0x3e, 0x87, 0xc1, 0x4c, 0x01, 0xd5,
558 0xc1, 0xf3, 0x43, 0x4f, 0x1d, 0x87 };
559
560 HcfKdf *generator = nullptr;
561 HcfResult ret = HcfKdfCreate("HKDF|SHA256|EXTRACT_AND_EXPAND", &generator);
562 EXPECT_EQ(ret, HCF_SUCCESS);
563 uint8_t out[82] = {0};
564 HcfBlob output = {.data = out, .len = 82};
565 HcfBlob salt = {.data = saltData, .len = sizeof(saltData)};
566 HcfBlob key = {.data = keyData, .len = sizeof(keyData)};
567 HcfBlob info = {.data = infoData, .len = sizeof(infoData)};
568 HcfHkdfParamsSpec params = {
569 .base = { .algName = "HKDF", },
570 .key = key,
571 .salt = salt,
572 .info = info,
573 .output = output,
574 };
575 ret = generator->generateSecret(generator, &(params.base));
576 EXPECT_EQ(ret, HCF_SUCCESS);
577 EXPECT_EQ(memcmp(params.output.data, expectSecret, sizeof(expectSecret)), 0);
578 HcfObjDestroy(generator);
579 }
580
581 HWTEST_F(CryptoHkdfTest, CryptoHkdfErr11, TestSize.Level0)
582 {
583 HcfKdf *generator = nullptr;
584 HcfResult ret = HcfKdfCreate("HKDF|SHA256", &generator);
585 EXPECT_EQ(ret, HCF_SUCCESS);
586 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
587 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
588 HcfBlob salt = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_saltData)),
589 .len = strlen(g_saltData)};
590 HcfBlob key = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_keyData)),
591 .len = strlen(g_keyData)};
592 HcfBlob info = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_infoData)),
593 .len = strlen(g_infoData)};
594 HcfHkdfParamsSpec params = {
595 .base = { .algName = "HKDF", },
596 .key = key,
597 .salt = salt,
598 .info = info,
599 .output = output,
600 };
601 ret = generator->generateSecret(generator, &(params.base));
602 EXPECT_EQ(ret, HCF_SUCCESS);
603 const char *algName = generator->getAlgorithm(nullptr);
604 ASSERT_EQ(algName, nullptr);
605 HcfObjDestroy(generator);
606 }
607
608 HWTEST_F(CryptoHkdfTest, CryptoHkdfErr12, TestSize.Level0)
609 {
610 HcfResult ret = HcfKdfHkdfSpiCreate(nullptr, nullptr);
611 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
612
613 HcfKdfDeriveParams params = {};
614 params.algo = HCF_ALG_HKDF;
615 params.md = HCF_OPENSSL_DIGEST_SHA256;
616 params.mode = HCF_ALG_MODE_EXTRACT_AND_EXPAND;
617
618 HcfKdfSpi *spiObj = nullptr;
619 ret = HcfKdfHkdfSpiCreate(¶ms, &spiObj);
620 EXPECT_EQ(ret, HCF_SUCCESS);
621
622 (void)spiObj->base.destroy(nullptr);
623 ret = spiObj->generateSecret(nullptr, nullptr);
624 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
625 HcfObjDestroy(spiObj);
626 }
627 }
628