Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2025 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 : #include "internal/libspdm_crypt_lib.h"
8 :
9 0 : void *libspdm_hmac_new(uint32_t base_hash_algo)
10 : {
11 0 : switch (base_hash_algo) {
12 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
13 : #if LIBSPDM_SHA256_SUPPORT
14 0 : return libspdm_hmac_sha256_new();
15 : #else
16 : LIBSPDM_ASSERT(false);
17 : return NULL;
18 : #endif
19 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
20 : #if LIBSPDM_SHA384_SUPPORT
21 0 : return libspdm_hmac_sha384_new();
22 : #else
23 : LIBSPDM_ASSERT(false);
24 : return NULL;
25 : #endif
26 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
27 : #if LIBSPDM_SHA512_SUPPORT
28 0 : return libspdm_hmac_sha512_new();
29 : #else
30 : LIBSPDM_ASSERT(false);
31 : return NULL;
32 : #endif
33 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
34 : #if LIBSPDM_SHA3_256_SUPPORT
35 0 : return libspdm_hmac_sha3_256_new();
36 : #else
37 : LIBSPDM_ASSERT(false);
38 : return NULL;
39 : #endif
40 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
41 : #if LIBSPDM_SHA3_384_SUPPORT
42 0 : return libspdm_hmac_sha3_384_new();
43 : #else
44 : LIBSPDM_ASSERT(false);
45 : return NULL;
46 : #endif
47 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
48 : #if LIBSPDM_SHA3_512_SUPPORT
49 0 : return libspdm_hmac_sha3_512_new();
50 : #else
51 : LIBSPDM_ASSERT(false);
52 : return NULL;
53 : #endif
54 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
55 : #if LIBSPDM_SM3_256_SUPPORT
56 : return libspdm_hmac_sm3_256_new();
57 : #else
58 0 : LIBSPDM_ASSERT(false);
59 0 : return NULL;
60 : #endif
61 0 : default:
62 0 : LIBSPDM_ASSERT(false);
63 0 : return NULL;
64 : }
65 : }
66 :
67 0 : void libspdm_hmac_free(uint32_t base_hash_algo, void *hmac_ctx)
68 : {
69 0 : if (hmac_ctx == NULL) {
70 0 : return;
71 : }
72 0 : switch (base_hash_algo) {
73 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
74 : #if LIBSPDM_SHA256_SUPPORT
75 0 : libspdm_hmac_sha256_free(hmac_ctx);
76 : #else
77 : LIBSPDM_ASSERT(false);
78 : #endif
79 0 : break;
80 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
81 : #if LIBSPDM_SHA384_SUPPORT
82 0 : libspdm_hmac_sha384_free(hmac_ctx);
83 : #else
84 : LIBSPDM_ASSERT(false);
85 : #endif
86 0 : break;
87 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
88 : #if LIBSPDM_SHA512_SUPPORT
89 0 : libspdm_hmac_sha512_free(hmac_ctx);
90 : #else
91 : LIBSPDM_ASSERT(false);
92 : #endif
93 0 : break;
94 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
95 : #if LIBSPDM_SHA3_256_SUPPORT
96 0 : libspdm_hmac_sha3_256_free(hmac_ctx);
97 : #else
98 : LIBSPDM_ASSERT(false);
99 : #endif
100 0 : break;
101 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
102 : #if LIBSPDM_SHA3_384_SUPPORT
103 0 : libspdm_hmac_sha3_384_free(hmac_ctx);
104 : #else
105 : LIBSPDM_ASSERT(false);
106 : #endif
107 0 : break;
108 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
109 : #if LIBSPDM_SHA3_512_SUPPORT
110 0 : libspdm_hmac_sha3_512_free(hmac_ctx);
111 : #else
112 : LIBSPDM_ASSERT(false);
113 : #endif
114 0 : break;
115 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
116 : #if LIBSPDM_SM3_256_SUPPORT
117 : libspdm_hmac_sm3_256_free(hmac_ctx);
118 : #else
119 0 : LIBSPDM_ASSERT(false);
120 : #endif
121 0 : break;
122 0 : default:
123 0 : LIBSPDM_ASSERT(false);
124 0 : break;
125 : }
126 : }
127 :
128 0 : bool libspdm_hmac_init(uint32_t base_hash_algo,
129 : void *hmac_ctx, const uint8_t *key,
130 : size_t key_size)
131 : {
132 0 : switch (base_hash_algo) {
133 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
134 : #if LIBSPDM_SHA256_SUPPORT
135 0 : return libspdm_hmac_sha256_set_key(hmac_ctx, key, key_size);
136 : #else
137 : LIBSPDM_ASSERT(false);
138 : return false;
139 : #endif
140 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
141 : #if LIBSPDM_SHA384_SUPPORT
142 0 : return libspdm_hmac_sha384_set_key(hmac_ctx, key, key_size);
143 : #else
144 : LIBSPDM_ASSERT(false);
145 : return false;
146 : #endif
147 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
148 : #if LIBSPDM_SHA512_SUPPORT
149 0 : return libspdm_hmac_sha512_set_key(hmac_ctx, key, key_size);
150 : #else
151 : LIBSPDM_ASSERT(false);
152 : return false;
153 : #endif
154 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
155 : #if LIBSPDM_SHA3_256_SUPPORT
156 0 : return libspdm_hmac_sha3_256_set_key(hmac_ctx, key, key_size);
157 : #else
158 : LIBSPDM_ASSERT(false);
159 : return false;
160 : #endif
161 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
162 : #if LIBSPDM_SHA3_384_SUPPORT
163 0 : return libspdm_hmac_sha3_384_set_key(hmac_ctx, key, key_size);
164 : #else
165 : LIBSPDM_ASSERT(false);
166 : return false;
167 : #endif
168 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
169 : #if LIBSPDM_SHA3_512_SUPPORT
170 0 : return libspdm_hmac_sha3_512_set_key(hmac_ctx, key, key_size);
171 : #else
172 : LIBSPDM_ASSERT(false);
173 : return false;
174 : #endif
175 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
176 : #if LIBSPDM_SM3_256_SUPPORT
177 : return libspdm_hmac_sm3_256_set_key(hmac_ctx, key, key_size);
178 : #else
179 0 : LIBSPDM_ASSERT(false);
180 0 : return false;
181 : #endif
182 0 : default:
183 0 : LIBSPDM_ASSERT(false);
184 0 : return false;
185 : }
186 : }
187 :
188 0 : bool libspdm_hmac_duplicate(uint32_t base_hash_algo, const void *hmac_ctx, void *new_hmac_ctx)
189 : {
190 0 : switch (base_hash_algo) {
191 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
192 : #if LIBSPDM_SHA256_SUPPORT
193 0 : return libspdm_hmac_sha256_duplicate(hmac_ctx, new_hmac_ctx);
194 : #else
195 : LIBSPDM_ASSERT(false);
196 : return false;
197 : #endif
198 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
199 : #if LIBSPDM_SHA384_SUPPORT
200 0 : return libspdm_hmac_sha384_duplicate(hmac_ctx, new_hmac_ctx);
201 : #else
202 : LIBSPDM_ASSERT(false);
203 : return false;
204 : #endif
205 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
206 : #if LIBSPDM_SHA512_SUPPORT
207 0 : return libspdm_hmac_sha512_duplicate(hmac_ctx, new_hmac_ctx);
208 : #else
209 : LIBSPDM_ASSERT(false);
210 : return false;
211 : #endif
212 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
213 : #if LIBSPDM_SHA3_256_SUPPORT
214 0 : return libspdm_hmac_sha3_256_duplicate(hmac_ctx, new_hmac_ctx);
215 : #else
216 : LIBSPDM_ASSERT(false);
217 : return false;
218 : #endif
219 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
220 : #if LIBSPDM_SHA3_384_SUPPORT
221 0 : return libspdm_hmac_sha3_384_duplicate(hmac_ctx, new_hmac_ctx);
222 : #else
223 : LIBSPDM_ASSERT(false);
224 : return false;
225 : #endif
226 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
227 : #if LIBSPDM_SHA3_512_SUPPORT
228 0 : return libspdm_hmac_sha3_512_duplicate(hmac_ctx, new_hmac_ctx);
229 : #else
230 : LIBSPDM_ASSERT(false);
231 : return false;
232 : #endif
233 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
234 : #if LIBSPDM_SM3_256_SUPPORT
235 : return libspdm_hmac_sm3_256_duplicate(hmac_ctx, new_hmac_ctx);
236 : #else
237 0 : LIBSPDM_ASSERT(false);
238 0 : return false;
239 : #endif
240 0 : default:
241 0 : LIBSPDM_ASSERT(false);
242 0 : return false;
243 : }
244 : }
245 :
246 0 : bool libspdm_hmac_update(uint32_t base_hash_algo,
247 : void *hmac_ctx, const void *data,
248 : size_t data_size)
249 : {
250 0 : switch (base_hash_algo) {
251 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
252 : #if LIBSPDM_SHA256_SUPPORT
253 0 : return libspdm_hmac_sha256_update(hmac_ctx, data, data_size);
254 : #else
255 : LIBSPDM_ASSERT(false);
256 : return false;
257 : #endif
258 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
259 : #if LIBSPDM_SHA384_SUPPORT
260 0 : return libspdm_hmac_sha384_update(hmac_ctx, data, data_size);
261 : #else
262 : LIBSPDM_ASSERT(false);
263 : return false;
264 : #endif
265 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
266 : #if LIBSPDM_SHA512_SUPPORT
267 0 : return libspdm_hmac_sha512_update(hmac_ctx, data, data_size);
268 : #else
269 : LIBSPDM_ASSERT(false);
270 : return false;
271 : #endif
272 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
273 : #if LIBSPDM_SHA3_256_SUPPORT
274 0 : return libspdm_hmac_sha3_256_update(hmac_ctx, data, data_size);
275 : #else
276 : LIBSPDM_ASSERT(false);
277 : return false;
278 : #endif
279 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
280 : #if LIBSPDM_SHA3_384_SUPPORT
281 0 : return libspdm_hmac_sha3_384_update(hmac_ctx, data, data_size);
282 : #else
283 : LIBSPDM_ASSERT(false);
284 : return false;
285 : #endif
286 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
287 : #if LIBSPDM_SHA3_512_SUPPORT
288 0 : return libspdm_hmac_sha3_512_update(hmac_ctx, data, data_size);
289 : #else
290 : LIBSPDM_ASSERT(false);
291 : return false;
292 : #endif
293 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
294 : #if LIBSPDM_SM3_256_SUPPORT
295 : return libspdm_hmac_sm3_256_update(hmac_ctx, data, data_size);
296 : #else
297 0 : LIBSPDM_ASSERT(false);
298 0 : return false;
299 : #endif
300 0 : default:
301 0 : LIBSPDM_ASSERT(false);
302 0 : return false;
303 : }
304 : }
305 :
306 0 : bool libspdm_hmac_final(uint32_t base_hash_algo, void *hmac_ctx, uint8_t *hmac_value)
307 : {
308 0 : switch (base_hash_algo) {
309 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
310 : #if LIBSPDM_SHA256_SUPPORT
311 0 : return libspdm_hmac_sha256_final(hmac_ctx, hmac_value);
312 : #else
313 : LIBSPDM_ASSERT(false);
314 : return false;
315 : #endif
316 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
317 : #if LIBSPDM_SHA384_SUPPORT
318 0 : return libspdm_hmac_sha384_final(hmac_ctx, hmac_value);
319 : #else
320 : LIBSPDM_ASSERT(false);
321 : return false;
322 : #endif
323 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
324 : #if LIBSPDM_SHA512_SUPPORT
325 0 : return libspdm_hmac_sha512_final(hmac_ctx, hmac_value);
326 : #else
327 : LIBSPDM_ASSERT(false);
328 : return false;
329 : #endif
330 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
331 : #if LIBSPDM_SHA3_256_SUPPORT
332 0 : return libspdm_hmac_sha3_256_final(hmac_ctx, hmac_value);
333 : #else
334 : LIBSPDM_ASSERT(false);
335 : return false;
336 : #endif
337 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
338 : #if LIBSPDM_SHA3_384_SUPPORT
339 0 : return libspdm_hmac_sha3_384_final(hmac_ctx, hmac_value);
340 : #else
341 : LIBSPDM_ASSERT(false);
342 : return false;
343 : #endif
344 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
345 : #if LIBSPDM_SHA3_512_SUPPORT
346 0 : return libspdm_hmac_sha3_512_final(hmac_ctx, hmac_value);
347 : #else
348 : LIBSPDM_ASSERT(false);
349 : return false;
350 : #endif
351 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
352 : #if LIBSPDM_SM3_256_SUPPORT
353 : return libspdm_hmac_sm3_256_final(hmac_ctx, hmac_value);
354 : #else
355 0 : LIBSPDM_ASSERT(false);
356 0 : return false;
357 : #endif
358 0 : default:
359 0 : LIBSPDM_ASSERT(false);
360 0 : return false;
361 : }
362 : }
363 :
364 317 : bool libspdm_hmac_all(uint32_t base_hash_algo, const void *data,
365 : size_t data_size, const uint8_t *key,
366 : size_t key_size, uint8_t *hmac_value)
367 : {
368 317 : switch (base_hash_algo) {
369 317 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
370 : #if LIBSPDM_SHA256_SUPPORT
371 317 : return libspdm_hmac_sha256_all(data, data_size, key, key_size, hmac_value);
372 : #else
373 : LIBSPDM_ASSERT(false);
374 : return false;
375 : #endif
376 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
377 : #if LIBSPDM_SHA384_SUPPORT
378 0 : return libspdm_hmac_sha384_all(data, data_size, key, key_size, hmac_value);
379 : #else
380 : LIBSPDM_ASSERT(false);
381 : return false;
382 : #endif
383 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
384 : #if LIBSPDM_SHA512_SUPPORT
385 0 : return libspdm_hmac_sha512_all(data, data_size, key, key_size, hmac_value);
386 : #else
387 : LIBSPDM_ASSERT(false);
388 : return false;
389 : #endif
390 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
391 : #if LIBSPDM_SHA3_256_SUPPORT
392 0 : return libspdm_hmac_sha3_256_all(data, data_size, key, key_size, hmac_value);
393 : #else
394 : LIBSPDM_ASSERT(false);
395 : return false;
396 : #endif
397 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
398 : #if LIBSPDM_SHA3_384_SUPPORT
399 0 : return libspdm_hmac_sha3_384_all(data, data_size, key, key_size, hmac_value);
400 : #else
401 : LIBSPDM_ASSERT(false);
402 : return false;
403 : #endif
404 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
405 : #if LIBSPDM_SHA3_512_SUPPORT
406 0 : return libspdm_hmac_sha3_512_all(data, data_size, key, key_size, hmac_value);
407 : #else
408 : LIBSPDM_ASSERT(false);
409 : return false;
410 : #endif
411 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
412 : #if LIBSPDM_SM3_256_SUPPORT
413 : return libspdm_hmac_sm3_256_all(data, data_size, key, key_size, hmac_value);
414 : #else
415 0 : LIBSPDM_ASSERT(false);
416 0 : return false;
417 : #endif
418 0 : default:
419 0 : LIBSPDM_ASSERT(false);
420 0 : return false;
421 : }
422 : }
|
