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 HcfKdfParamsSpec params = {
444 .algName = "HKDF",
445 };
446 ret = generator->generateSecret(generator, ¶ms);
447 EXPECT_NE(ret, HCF_SUCCESS);
448 HcfObjDestroy(generator);
449 }
450
451 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestError6, TestSize.Level1)
452 {
453 // use nullptr params
454 HcfKdf *generator = nullptr;
455 HcfResult ret = HcfKdfCreate("HKDF|SHA256", &generator);
456 EXPECT_EQ(ret, HCF_SUCCESS);
457 ret = generator->generateSecret(generator, nullptr);
458 EXPECT_NE(ret, HCF_SUCCESS);
459 HcfObjDestroy(generator);
460 }
461
462 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestError7, TestSize.Level1)
463 {
464 HcfKdf *generator = nullptr;
465 HcfResult ret = HcfKdfCreate("HKDF|abcd", &generator);
466 EXPECT_NE(ret, HCF_SUCCESS);
467 HcfObjDestroy(generator);
468 }
469
470 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestError8, TestSize.Level1)
471 {
472 HcfKdf *generator = nullptr;
473 HcfResult ret = HcfKdfCreate("ABCD|SM3", &generator);
474 EXPECT_NE(ret, HCF_SUCCESS);
475 HcfObjDestroy(generator);
476 }
477
478 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestError9, TestSize.Level1)
479 {
480 HcfKdf *generator = nullptr;
481 HcfResult ret = HcfKdfCreate(nullptr, &generator);
482 EXPECT_NE(ret, HCF_SUCCESS);
483 HcfObjDestroy(generator);
484 }
485
486 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestError10, TestSize.Level1)
487 {
488 HcfResult ret = HcfKdfCreate(nullptr, nullptr);
489 EXPECT_NE(ret, HCF_SUCCESS);
490 }
491
492 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestVectors1, TestSize.Level1)
493 {
494 uint8_t keyData[] = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
495 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b };
496 uint8_t infoData[] = { 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 };
497 uint8_t saltData[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
498 0x0c };
499 uint8_t expectSecret[] = { 0x3c, 0xb2, 0x5f, 0x25, 0xfa, 0xac, 0xd5, 0x7a, 0x90, 0x43, 0x4f,
500 0x64, 0xd0, 0x36, 0x2f, 0x2a, 0x2d, 0x2d, 0x0a, 0x90, 0xcf, 0x1a, 0x5a, 0x4c, 0x5d, 0xb0,
501 0x2d, 0x56, 0xec, 0xc4, 0xc5, 0xbf, 0x34, 0x00, 0x72, 0x08, 0xd5, 0xb8, 0x87, 0x18, 0x58,
502 0x65 };
503
504 HcfKdf *generator = nullptr;
505 HcfResult ret = HcfKdfCreate("HKDF|SHA256", &generator);
506 EXPECT_EQ(ret, HCF_SUCCESS);
507 uint8_t out[42] = {0};
508 HcfBlob output = {.data = out, .len = 42};
509 HcfBlob salt = {.data = saltData, .len = sizeof(saltData)};
510 HcfBlob key = {.data = keyData, .len = sizeof(keyData)};
511 HcfBlob info = {.data = infoData, .len = sizeof(infoData)};
512 HcfHkdfParamsSpec params = {
513 .base = { .algName = "HKDF", },
514 .key = key,
515 .salt = salt,
516 .info = info,
517 .output = output,
518 };
519 ret = generator->generateSecret(generator, &(params.base));
520 EXPECT_EQ(ret, HCF_SUCCESS);
521 EXPECT_EQ(memcmp(params.output.data, expectSecret, sizeof(expectSecret)), 0);
522 HcfObjDestroy(generator);
523 }
524
525 HWTEST_F(CryptoHkdfTest, CryptoHkdfTestVectors2, TestSize.Level1)
526 {
527 uint8_t keyData[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c,
528 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c,
529 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c,
530 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c,
531 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c,
532 0x4d, 0x4e, 0x4f };
533 uint8_t infoData[] = { 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc,
534 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc,
535 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc,
536 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec,
537 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc,
538 0xfd, 0xfe, 0xff };
539 uint8_t saltData[] = { 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c,
540 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c,
541 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c,
542 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c,
543 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac,
544 0xad, 0xae, 0xaf };
545 uint8_t expectSecret[] = { 0xb1, 0x1e, 0x39, 0x8d, 0xc8, 0x03, 0x27, 0xa1, 0xc8, 0xe7, 0xf7, 0x8c,
546 0x59, 0x6a, 0x49, 0x34, 0x4f, 0x01, 0x2e, 0xda, 0x2d, 0x4e, 0xfa, 0xd8, 0xa0, 0x50, 0xcc, 0x4c,
547 0x19, 0xaf, 0xa9, 0x7c, 0x59, 0x04, 0x5a, 0x99, 0xca, 0xc7, 0x82, 0x72, 0x71, 0xcb, 0x41, 0xc6,
548 0x5e, 0x59, 0x0e, 0x09, 0xda, 0x32, 0x75, 0x60, 0x0c, 0x2f, 0x09, 0xb8, 0x36, 0x77, 0x93, 0xa9,
549 0xac, 0xa3, 0xdb, 0x71, 0xcc, 0x30, 0xc5, 0x81, 0x79, 0xec, 0x3e, 0x87, 0xc1, 0x4c, 0x01, 0xd5,
550 0xc1, 0xf3, 0x43, 0x4f, 0x1d, 0x87 };
551
552 HcfKdf *generator = nullptr;
553 HcfResult ret = HcfKdfCreate("HKDF|SHA256|EXTRACT_AND_EXPAND", &generator);
554 EXPECT_EQ(ret, HCF_SUCCESS);
555 uint8_t out[82] = {0};
556 HcfBlob output = {.data = out, .len = 82};
557 HcfBlob salt = {.data = saltData, .len = sizeof(saltData)};
558 HcfBlob key = {.data = keyData, .len = sizeof(keyData)};
559 HcfBlob info = {.data = infoData, .len = sizeof(infoData)};
560 HcfHkdfParamsSpec params = {
561 .base = { .algName = "HKDF", },
562 .key = key,
563 .salt = salt,
564 .info = info,
565 .output = output,
566 };
567 ret = generator->generateSecret(generator, &(params.base));
568 EXPECT_EQ(ret, HCF_SUCCESS);
569 EXPECT_EQ(memcmp(params.output.data, expectSecret, sizeof(expectSecret)), 0);
570 HcfObjDestroy(generator);
571 }
572
573 HWTEST_F(CryptoHkdfTest, CryptoHkdfErr11, TestSize.Level0)
574 {
575 HcfKdf *generator = nullptr;
576 HcfResult ret = HcfKdfCreate("HKDF|SHA256", &generator);
577 EXPECT_EQ(ret, HCF_SUCCESS);
578 uint8_t out[OUT_PUT_MAX_LENGTH] = {0};
579 HcfBlob output = {.data = out, .len = OUT_PUT_NORMAL_LENGTH};
580 HcfBlob salt = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_saltData)),
581 .len = strlen(g_saltData)};
582 HcfBlob key = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_keyData)),
583 .len = strlen(g_keyData)};
584 HcfBlob info = {.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_infoData)),
585 .len = strlen(g_infoData)};
586 HcfHkdfParamsSpec params = {
587 .base = { .algName = "HKDF", },
588 .key = key,
589 .salt = salt,
590 .info = info,
591 .output = output,
592 };
593 ret = generator->generateSecret(generator, &(params.base));
594 EXPECT_EQ(ret, HCF_SUCCESS);
595 const char *algName = generator->getAlgorithm(nullptr);
596 ASSERT_EQ(algName, nullptr);
597 HcfObjDestroy(generator);
598 }
599
600 HWTEST_F(CryptoHkdfTest, CryptoHkdfErr12, TestSize.Level0)
601 {
602 HcfResult ret = HcfKdfHkdfSpiCreate(nullptr, nullptr);
603 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
604
605 HcfKdfDeriveParams params = {};
606 params.algo = HCF_ALG_HKDF;
607 params.md = HCF_OPENSSL_DIGEST_SHA256;
608 params.mode = HCF_ALG_MODE_EXTRACT_AND_EXPAND;
609
610 HcfKdfSpi *spiObj = nullptr;
611 ret = HcfKdfHkdfSpiCreate(¶ms, &spiObj);
612 EXPECT_EQ(ret, HCF_SUCCESS);
613
614 (void)spiObj->base.destroy(nullptr);
615 ret = spiObj->generateSecret(nullptr, nullptr);
616 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
617 HcfObjDestroy(spiObj);
618 }
619 }
620