Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2022 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : /** @file
8 : * HMAC-SHA256/384/512 KDF Wrapper Implementation.
9 : *
10 : * RFC 5869: HMAC-based Extract-and-Expand key Derivation Function (HKDF)
11 : **/
12 :
13 : #include "internal_crypt_lib.h"
14 : #include <mbedtls/hkdf.h>
15 :
16 : /**
17 : * Derive HMAC-based Extract-and-Expand key Derivation Function (HKDF).
18 : *
19 : * @param[in] md_type message digest Type.
20 : * @param[in] key Pointer to the user-supplied key.
21 : * @param[in] key_size key size in bytes.
22 : * @param[in] salt Pointer to the salt(non-secret) value.
23 : * @param[in] salt_size salt size in bytes.
24 : * @param[in] info Pointer to the application specific info.
25 : * @param[in] info_size info size in bytes.
26 : * @param[out] out Pointer to buffer to receive hkdf value.
27 : * @param[in] out_size size of hkdf bytes to generate.
28 : *
29 : * @retval true Hkdf generated successfully.
30 : * @retval false Hkdf generation failed.
31 : *
32 : **/
33 0 : bool hkdf_md_extract_and_expand(const mbedtls_md_type_t md_type,
34 : const uint8_t *key, size_t key_size,
35 : const uint8_t *salt, size_t salt_size,
36 : const uint8_t *info, size_t info_size,
37 : uint8_t *out, size_t out_size)
38 : {
39 : const mbedtls_md_info_t *md;
40 : int ret;
41 :
42 0 : if (key == NULL || salt == NULL || info == NULL || out == NULL ||
43 0 : key_size > INT_MAX || salt_size > INT_MAX || info_size > INT_MAX ||
44 : out_size > INT_MAX) {
45 0 : return false;
46 : }
47 :
48 0 : md = mbedtls_md_info_from_type(md_type);
49 0 : LIBSPDM_ASSERT(md != NULL);
50 :
51 0 : ret = mbedtls_hkdf(md, salt, (uint32_t)salt_size, key, (uint32_t)key_size,
52 0 : info, (uint32_t)info_size, out, (uint32_t)out_size);
53 0 : if (ret != 0) {
54 0 : return false;
55 : }
56 :
57 0 : return true;
58 : }
59 :
60 : /**
61 : * Derive HMAC-based Extract key Derivation Function (HKDF).
62 : *
63 : * @param[in] md_type message digest Type.
64 : * @param[in] key Pointer to the user-supplied key.
65 : * @param[in] key_size key size in bytes.
66 : * @param[in] salt Pointer to the salt(non-secret) value.
67 : * @param[in] salt_size salt size in bytes.
68 : * @param[out] prk_out Pointer to buffer to receive hkdf value.
69 : * @param[in] prk_out_size size of hkdf bytes to generate.
70 : *
71 : * @retval true Hkdf generated successfully.
72 : * @retval false Hkdf generation failed.
73 : *
74 : **/
75 190 : bool hkdf_md_extract(const mbedtls_md_type_t md_type, const uint8_t *key,
76 : size_t key_size, const uint8_t *salt,
77 : size_t salt_size, uint8_t *prk_out,
78 : size_t prk_out_size)
79 : {
80 : const mbedtls_md_info_t *md;
81 : int ret;
82 : size_t md_size;
83 :
84 190 : if (key == NULL || salt == NULL || prk_out == NULL ||
85 190 : key_size > INT_MAX || salt_size > INT_MAX ||
86 : prk_out_size > INT_MAX) {
87 0 : return false;
88 : }
89 :
90 190 : md_size = 0;
91 190 : switch (md_type) {
92 190 : case MBEDTLS_MD_SHA256:
93 190 : md_size = LIBSPDM_SHA256_DIGEST_SIZE;
94 190 : break;
95 0 : case MBEDTLS_MD_SHA384:
96 0 : md_size = LIBSPDM_SHA384_DIGEST_SIZE;
97 0 : break;
98 0 : case MBEDTLS_MD_SHA512:
99 0 : md_size = LIBSPDM_SHA512_DIGEST_SIZE;
100 0 : break;
101 0 : default:
102 0 : return false;
103 : }
104 190 : if (prk_out_size != md_size) {
105 0 : return false;
106 : }
107 :
108 190 : md = mbedtls_md_info_from_type(md_type);
109 190 : LIBSPDM_ASSERT(md != NULL);
110 :
111 190 : ret = mbedtls_hkdf_extract(md, salt, (uint32_t)salt_size, key,
112 190 : (uint32_t)key_size, prk_out);
113 190 : if (ret != 0) {
114 0 : return false;
115 : }
116 :
117 190 : return true;
118 : }
119 :
120 : /**
121 : * Derive HMAC-based Expand key Derivation Function (HKDF).
122 : *
123 : * @param[in] md_type message digest Type.
124 : * @param[in] prk Pointer to the user-supplied key.
125 : * @param[in] prk_size key size in bytes.
126 : * @param[in] info Pointer to the application specific info.
127 : * @param[in] info_size info size in bytes.
128 : * @param[out] out Pointer to buffer to receive hkdf value.
129 : * @param[in] out_size size of hkdf bytes to generate.
130 : *
131 : * @retval true Hkdf generated successfully.
132 : * @retval false Hkdf generation failed.
133 : *
134 : **/
135 1235 : bool hkdf_md_expand(const mbedtls_md_type_t md_type, const uint8_t *prk,
136 : size_t prk_size, const uint8_t *info,
137 : size_t info_size, uint8_t *out, size_t out_size)
138 : {
139 : const mbedtls_md_info_t *md;
140 : int ret;
141 : size_t md_size;
142 :
143 1235 : if (prk == NULL || info == NULL || out == NULL || prk_size > INT_MAX ||
144 1235 : info_size > INT_MAX || out_size > INT_MAX) {
145 0 : return false;
146 : }
147 :
148 1235 : switch (md_type) {
149 1235 : case MBEDTLS_MD_SHA256:
150 1235 : md_size = LIBSPDM_SHA256_DIGEST_SIZE;
151 1235 : break;
152 0 : case MBEDTLS_MD_SHA384:
153 0 : md_size = LIBSPDM_SHA384_DIGEST_SIZE;
154 0 : break;
155 0 : case MBEDTLS_MD_SHA512:
156 0 : md_size = LIBSPDM_SHA512_DIGEST_SIZE;
157 0 : break;
158 0 : default:
159 0 : LIBSPDM_ASSERT(false);
160 0 : return false;
161 : }
162 1235 : if (prk_size != md_size) {
163 0 : return false;
164 : }
165 :
166 1235 : md = mbedtls_md_info_from_type(md_type);
167 1235 : LIBSPDM_ASSERT(md != NULL);
168 :
169 1235 : ret = mbedtls_hkdf_expand(md, prk, (uint32_t)prk_size, info,
170 1235 : (uint32_t)info_size, out, (uint32_t)out_size);
171 1235 : if (ret != 0) {
172 0 : return false;
173 : }
174 :
175 1235 : return true;
176 : }
177 :
178 : /**
179 : * Derive SHA256 HMAC-based Extract-and-Expand key Derivation Function (HKDF).
180 : *
181 : * @param[in] key Pointer to the user-supplied key.
182 : * @param[in] key_size key size in bytes.
183 : * @param[in] salt Pointer to the salt(non-secret) value.
184 : * @param[in] salt_size salt size in bytes.
185 : * @param[in] info Pointer to the application specific info.
186 : * @param[in] info_size info size in bytes.
187 : * @param[out] out Pointer to buffer to receive hkdf value.
188 : * @param[in] out_size size of hkdf bytes to generate.
189 : *
190 : * @retval true Hkdf generated successfully.
191 : * @retval false Hkdf generation failed.
192 : *
193 : **/
194 0 : bool libspdm_hkdf_sha256_extract_and_expand(const uint8_t *key, size_t key_size,
195 : const uint8_t *salt, size_t salt_size,
196 : const uint8_t *info, size_t info_size,
197 : uint8_t *out, size_t out_size)
198 : {
199 0 : return hkdf_md_extract_and_expand(MBEDTLS_MD_SHA256, key, key_size,
200 : salt, salt_size, info, info_size, out,
201 : out_size);
202 : }
203 :
204 : /**
205 : * Derive SHA256 HMAC-based Extract key Derivation Function (HKDF).
206 : *
207 : * @param[in] key Pointer to the user-supplied key.
208 : * @param[in] key_size key size in bytes.
209 : * @param[in] salt Pointer to the salt(non-secret) value.
210 : * @param[in] salt_size salt size in bytes.
211 : * @param[out] prk_out Pointer to buffer to receive hkdf value.
212 : * @param[in] prk_out_size size of hkdf bytes to generate.
213 : *
214 : * @retval true Hkdf generated successfully.
215 : * @retval false Hkdf generation failed.
216 : *
217 : **/
218 190 : bool libspdm_hkdf_sha256_extract(const uint8_t *key, size_t key_size,
219 : const uint8_t *salt, size_t salt_size,
220 : uint8_t *prk_out, size_t prk_out_size)
221 : {
222 190 : return hkdf_md_extract(MBEDTLS_MD_SHA256, key, key_size, salt,
223 : salt_size, prk_out, prk_out_size);
224 : }
225 :
226 : /**
227 : * Derive SHA256 HMAC-based Expand key Derivation Function (HKDF).
228 : *
229 : * @param[in] prk Pointer to the user-supplied key.
230 : * @param[in] prk_size key size in bytes.
231 : * @param[in] info Pointer to the application specific info.
232 : * @param[in] info_size info size in bytes.
233 : * @param[out] out Pointer to buffer to receive hkdf value.
234 : * @param[in] out_size size of hkdf bytes to generate.
235 : *
236 : * @retval true Hkdf generated successfully.
237 : * @retval false Hkdf generation failed.
238 : *
239 : **/
240 1235 : bool libspdm_hkdf_sha256_expand(const uint8_t *prk, size_t prk_size,
241 : const uint8_t *info, size_t info_size,
242 : uint8_t *out, size_t out_size)
243 : {
244 1235 : return hkdf_md_expand(MBEDTLS_MD_SHA256, prk, prk_size, info, info_size,
245 : out, out_size);
246 : }
247 :
248 : /**
249 : * Derive SHA384 HMAC-based Extract-and-Expand key Derivation Function (HKDF).
250 : *
251 : * @param[in] key Pointer to the user-supplied key.
252 : * @param[in] key_size key size in bytes.
253 : * @param[in] salt Pointer to the salt(non-secret) value.
254 : * @param[in] salt_size salt size in bytes.
255 : * @param[in] info Pointer to the application specific info.
256 : * @param[in] info_size info size in bytes.
257 : * @param[out] out Pointer to buffer to receive hkdf value.
258 : * @param[in] out_size size of hkdf bytes to generate.
259 : *
260 : * @retval true Hkdf generated successfully.
261 : * @retval false Hkdf generation failed.
262 : *
263 : **/
264 0 : bool libspdm_hkdf_sha384_extract_and_expand(const uint8_t *key, size_t key_size,
265 : const uint8_t *salt, size_t salt_size,
266 : const uint8_t *info, size_t info_size,
267 : uint8_t *out, size_t out_size)
268 : {
269 0 : return hkdf_md_extract_and_expand(MBEDTLS_MD_SHA384, key, key_size,
270 : salt, salt_size, info, info_size, out,
271 : out_size);
272 : }
273 :
274 : /**
275 : * Derive SHA384 HMAC-based Extract key Derivation Function (HKDF).
276 : *
277 : * @param[in] key Pointer to the user-supplied key.
278 : * @param[in] key_size key size in bytes.
279 : * @param[in] salt Pointer to the salt(non-secret) value.
280 : * @param[in] salt_size salt size in bytes.
281 : * @param[out] prk_out Pointer to buffer to receive hkdf value.
282 : * @param[in] prk_out_size size of hkdf bytes to generate.
283 : *
284 : * @retval true Hkdf generated successfully.
285 : * @retval false Hkdf generation failed.
286 : *
287 : **/
288 0 : bool libspdm_hkdf_sha384_extract(const uint8_t *key, size_t key_size,
289 : const uint8_t *salt, size_t salt_size,
290 : uint8_t *prk_out, size_t prk_out_size)
291 : {
292 0 : return hkdf_md_extract(MBEDTLS_MD_SHA384, key, key_size, salt,
293 : salt_size, prk_out, prk_out_size);
294 : }
295 :
296 : /**
297 : * Derive SHA384 HMAC-based Expand key Derivation Function (HKDF).
298 : *
299 : * @param[in] prk Pointer to the user-supplied key.
300 : * @param[in] prk_size key size in bytes.
301 : * @param[in] info Pointer to the application specific info.
302 : * @param[in] info_size info size in bytes.
303 : * @param[out] out Pointer to buffer to receive hkdf value.
304 : * @param[in] out_size size of hkdf bytes to generate.
305 : *
306 : * @retval true Hkdf generated successfully.
307 : * @retval false Hkdf generation failed.
308 : *
309 : **/
310 0 : bool libspdm_hkdf_sha384_expand(const uint8_t *prk, size_t prk_size,
311 : const uint8_t *info, size_t info_size,
312 : uint8_t *out, size_t out_size)
313 : {
314 0 : return hkdf_md_expand(MBEDTLS_MD_SHA384, prk, prk_size, info, info_size,
315 : out, out_size);
316 : }
317 :
318 : /**
319 : * Derive SHA512 HMAC-based Extract-and-Expand key Derivation Function (HKDF).
320 : *
321 : * @param[in] key Pointer to the user-supplied key.
322 : * @param[in] key_size key size in bytes.
323 : * @param[in] salt Pointer to the salt(non-secret) value.
324 : * @param[in] salt_size salt size in bytes.
325 : * @param[in] info Pointer to the application specific info.
326 : * @param[in] info_size info size in bytes.
327 : * @param[out] out Pointer to buffer to receive hkdf value.
328 : * @param[in] out_size size of hkdf bytes to generate.
329 : *
330 : * @retval true Hkdf generated successfully.
331 : * @retval false Hkdf generation failed.
332 : *
333 : **/
334 0 : bool libspdm_hkdf_sha512_extract_and_expand(const uint8_t *key, size_t key_size,
335 : const uint8_t *salt, size_t salt_size,
336 : const uint8_t *info, size_t info_size,
337 : uint8_t *out, size_t out_size)
338 : {
339 0 : return hkdf_md_extract_and_expand(MBEDTLS_MD_SHA512, key, key_size,
340 : salt, salt_size, info, info_size, out,
341 : out_size);
342 : }
343 :
344 : /**
345 : * Derive SHA512 HMAC-based Extract key Derivation Function (HKDF).
346 : *
347 : * @param[in] key Pointer to the user-supplied key.
348 : * @param[in] key_size key size in bytes.
349 : * @param[in] salt Pointer to the salt(non-secret) value.
350 : * @param[in] salt_size salt size in bytes.
351 : * @param[out] prk_out Pointer to buffer to receive hkdf value.
352 : * @param[in] prk_out_size size of hkdf bytes to generate.
353 : *
354 : * @retval true Hkdf generated successfully.
355 : * @retval false Hkdf generation failed.
356 : *
357 : **/
358 0 : bool libspdm_hkdf_sha512_extract(const uint8_t *key, size_t key_size,
359 : const uint8_t *salt, size_t salt_size,
360 : uint8_t *prk_out, size_t prk_out_size)
361 : {
362 0 : return hkdf_md_extract(MBEDTLS_MD_SHA512, key, key_size, salt,
363 : salt_size, prk_out, prk_out_size);
364 : }
365 :
366 : /**
367 : * Derive SHA512 HMAC-based Expand key Derivation Function (HKDF).
368 : *
369 : * @param[in] prk Pointer to the user-supplied key.
370 : * @param[in] prk_size key size in bytes.
371 : * @param[in] info Pointer to the application specific info.
372 : * @param[in] info_size info size in bytes.
373 : * @param[out] out Pointer to buffer to receive hkdf value.
374 : * @param[in] out_size size of hkdf bytes to generate.
375 : *
376 : * @retval true Hkdf generated successfully.
377 : * @retval false Hkdf generation failed.
378 : *
379 : **/
380 0 : bool libspdm_hkdf_sha512_expand(const uint8_t *prk, size_t prk_size,
381 : const uint8_t *info, size_t info_size,
382 : uint8_t *out, size_t out_size)
383 : {
384 0 : return hkdf_md_expand(MBEDTLS_MD_SHA512, prk, prk_size, info, info_size,
385 : out, out_size);
386 : }
|
