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 : #include "internal/libspdm_crypt_lib.h"
8 :
9 4577 : uint32_t libspdm_get_hash_size(uint32_t base_hash_algo)
10 : {
11 4577 : switch (base_hash_algo) {
12 4404 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
13 : #if LIBSPDM_SHA256_SUPPORT
14 4404 : return 32;
15 : #else
16 : return 0;
17 : #endif
18 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
19 : #if LIBSPDM_SHA3_256_SUPPORT
20 0 : return 32;
21 : #else
22 : return 0;
23 : #endif
24 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
25 : #if LIBSPDM_SHA384_SUPPORT
26 0 : return 48;
27 : #else
28 : return 0;
29 : #endif
30 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
31 : #if LIBSPDM_SHA3_384_SUPPORT
32 0 : return 48;
33 : #else
34 : return 0;
35 : #endif
36 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
37 : #if LIBSPDM_SHA512_SUPPORT
38 1 : return 64;
39 : #else
40 : return 0;
41 : #endif
42 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
43 : #if LIBSPDM_SHA3_512_SUPPORT
44 1 : return 64;
45 : #else
46 : return 0;
47 : #endif
48 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
49 : #if LIBSPDM_SM3_256_SUPPORT
50 : return 32;
51 : #else
52 0 : return 0;
53 : #endif
54 171 : default:
55 171 : return 0;
56 : }
57 : }
58 :
59 291 : size_t libspdm_get_hash_nid(uint32_t base_hash_algo)
60 : {
61 291 : switch (base_hash_algo) {
62 291 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
63 291 : return LIBSPDM_CRYPTO_NID_SHA256;
64 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
65 0 : return LIBSPDM_CRYPTO_NID_SHA384;
66 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
67 0 : return LIBSPDM_CRYPTO_NID_SHA512;
68 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
69 0 : return LIBSPDM_CRYPTO_NID_SHA3_256;
70 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
71 0 : return LIBSPDM_CRYPTO_NID_SHA3_384;
72 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
73 0 : return LIBSPDM_CRYPTO_NID_SHA3_512;
74 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
75 0 : return LIBSPDM_CRYPTO_NID_SM3_256;
76 0 : default:
77 0 : return LIBSPDM_CRYPTO_NID_NULL;
78 : }
79 : }
80 :
81 848 : void *libspdm_hash_new(uint32_t base_hash_algo)
82 : {
83 848 : switch (base_hash_algo) {
84 848 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
85 : #if LIBSPDM_SHA256_SUPPORT
86 848 : return libspdm_sha256_new();
87 : #else
88 : LIBSPDM_ASSERT(false);
89 : return NULL;
90 : #endif
91 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
92 : #if LIBSPDM_SHA384_SUPPORT
93 0 : return libspdm_sha384_new();
94 : #else
95 : LIBSPDM_ASSERT(false);
96 : return NULL;
97 : #endif
98 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
99 : #if LIBSPDM_SHA512_SUPPORT
100 0 : return libspdm_sha512_new();
101 : #else
102 : LIBSPDM_ASSERT(false);
103 : return NULL;
104 : #endif
105 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
106 : #if LIBSPDM_SHA3_256_SUPPORT
107 0 : return libspdm_sha3_256_new();
108 : #else
109 : LIBSPDM_ASSERT(false);
110 : return NULL;
111 : #endif
112 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
113 : #if LIBSPDM_SHA3_384_SUPPORT
114 0 : return libspdm_sha3_384_new();
115 : #else
116 : LIBSPDM_ASSERT(false);
117 : return NULL;
118 : #endif
119 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
120 : #if LIBSPDM_SHA3_512_SUPPORT
121 0 : return libspdm_sha3_512_new();
122 : #else
123 : LIBSPDM_ASSERT(false);
124 : return NULL;
125 : #endif
126 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
127 : #if LIBSPDM_SM3_256_SUPPORT
128 : return libspdm_sm3_256_new();
129 : #else
130 0 : LIBSPDM_ASSERT(false);
131 0 : return NULL;
132 : #endif
133 0 : default:
134 0 : LIBSPDM_ASSERT(false);
135 0 : return NULL;
136 : }
137 : }
138 :
139 804 : void libspdm_hash_free(uint32_t base_hash_algo, void *hash_context)
140 : {
141 804 : if (hash_context == NULL) {
142 0 : return;
143 : }
144 804 : switch (base_hash_algo) {
145 804 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
146 : #if LIBSPDM_SHA256_SUPPORT
147 804 : libspdm_sha256_free(hash_context);
148 : #else
149 : LIBSPDM_ASSERT(false);
150 : #endif
151 804 : break;
152 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
153 : #if LIBSPDM_SHA384_SUPPORT
154 0 : libspdm_sha384_free(hash_context);
155 : #else
156 : LIBSPDM_ASSERT(false);
157 : #endif
158 0 : break;
159 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
160 : #if LIBSPDM_SHA512_SUPPORT
161 0 : libspdm_sha512_free(hash_context);
162 : #else
163 : LIBSPDM_ASSERT(false);
164 : #endif
165 0 : break;
166 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
167 : #if LIBSPDM_SHA3_256_SUPPORT
168 0 : libspdm_sha3_256_free(hash_context);
169 : #else
170 : LIBSPDM_ASSERT(false);
171 : #endif
172 0 : break;
173 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
174 : #if LIBSPDM_SHA3_384_SUPPORT
175 0 : libspdm_sha3_384_free(hash_context);
176 : #else
177 : LIBSPDM_ASSERT(false);
178 : #endif
179 0 : break;
180 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
181 : #if LIBSPDM_SHA3_512_SUPPORT
182 0 : libspdm_sha3_512_free(hash_context);
183 : #else
184 : LIBSPDM_ASSERT(false);
185 : #endif
186 0 : break;
187 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
188 : #if LIBSPDM_SM3_256_SUPPORT
189 : libspdm_sm3_256_free(hash_context);
190 : #else
191 0 : LIBSPDM_ASSERT(false);
192 : #endif
193 0 : break;
194 0 : default:
195 0 : LIBSPDM_ASSERT(false);
196 0 : break;
197 : }
198 : }
199 :
200 455 : bool libspdm_hash_init(uint32_t base_hash_algo, void *hash_context)
201 : {
202 455 : switch (base_hash_algo) {
203 455 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
204 : #if LIBSPDM_SHA256_SUPPORT
205 455 : return libspdm_sha256_init(hash_context);
206 : #else
207 : LIBSPDM_ASSERT(false);
208 : return false;
209 : #endif
210 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
211 : #if LIBSPDM_SHA384_SUPPORT
212 0 : return libspdm_sha384_init(hash_context);
213 : #else
214 : LIBSPDM_ASSERT(false);
215 : return false;
216 : #endif
217 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
218 : #if LIBSPDM_SHA512_SUPPORT
219 0 : return libspdm_sha512_init(hash_context);
220 : #else
221 : LIBSPDM_ASSERT(false);
222 : return false;
223 : #endif
224 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
225 : #if LIBSPDM_SHA3_256_SUPPORT
226 0 : return libspdm_sha3_256_init(hash_context);
227 : #else
228 : LIBSPDM_ASSERT(false);
229 : return false;
230 : #endif
231 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
232 : #if LIBSPDM_SHA3_384_SUPPORT
233 0 : return libspdm_sha3_384_init(hash_context);
234 : #else
235 : LIBSPDM_ASSERT(false);
236 : return false;
237 : #endif
238 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
239 : #if LIBSPDM_SHA3_512_SUPPORT
240 0 : return libspdm_sha3_512_init(hash_context);
241 : #else
242 : LIBSPDM_ASSERT(false);
243 : return false;
244 : #endif
245 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
246 : #if LIBSPDM_SM3_256_SUPPORT
247 : return libspdm_sm3_256_init(hash_context);
248 : #else
249 0 : LIBSPDM_ASSERT(false);
250 0 : return false;
251 : #endif
252 0 : default:
253 0 : LIBSPDM_ASSERT(false);
254 0 : return false;
255 : }
256 : }
257 :
258 393 : bool libspdm_hash_duplicate(uint32_t base_hash_algo, const void *hash_ctx, void *new_hash_ctx)
259 : {
260 393 : switch (base_hash_algo) {
261 393 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
262 : #if LIBSPDM_SHA256_SUPPORT
263 393 : return libspdm_sha256_duplicate(hash_ctx, new_hash_ctx);
264 : #else
265 : LIBSPDM_ASSERT(false);
266 : return false;
267 : #endif
268 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
269 : #if LIBSPDM_SHA384_SUPPORT
270 0 : return libspdm_sha384_duplicate(hash_ctx, new_hash_ctx);
271 : #else
272 : LIBSPDM_ASSERT(false);
273 : return false;
274 : #endif
275 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
276 : #if LIBSPDM_SHA512_SUPPORT
277 0 : return libspdm_sha512_duplicate(hash_ctx, new_hash_ctx);
278 : #else
279 : LIBSPDM_ASSERT(false);
280 : return false;
281 : #endif
282 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
283 : #if LIBSPDM_SHA3_256_SUPPORT
284 0 : return libspdm_sha3_256_duplicate(hash_ctx, new_hash_ctx);
285 : #else
286 : LIBSPDM_ASSERT(false);
287 : return false;
288 : #endif
289 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
290 : #if LIBSPDM_SHA3_384_SUPPORT
291 0 : return libspdm_sha3_384_duplicate(hash_ctx, new_hash_ctx);
292 : #else
293 : LIBSPDM_ASSERT(false);
294 : return false;
295 : #endif
296 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
297 : #if LIBSPDM_SHA3_512_SUPPORT
298 0 : return libspdm_sha3_512_duplicate(hash_ctx, new_hash_ctx);
299 : #else
300 : LIBSPDM_ASSERT(false);
301 : return false;
302 : #endif
303 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
304 : #if LIBSPDM_SM3_256_SUPPORT
305 : return libspdm_sm3_256_duplicate(hash_ctx, new_hash_ctx);
306 : #else
307 0 : LIBSPDM_ASSERT(false);
308 0 : return false;
309 : #endif
310 0 : default:
311 0 : LIBSPDM_ASSERT(false);
312 0 : return false;
313 : }
314 : }
315 :
316 10628 : bool libspdm_hash_update(uint32_t base_hash_algo, void *hash_context,
317 : const void *data, size_t data_size)
318 : {
319 10628 : switch (base_hash_algo) {
320 10628 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
321 : #if LIBSPDM_SHA256_SUPPORT
322 10628 : return libspdm_sha256_update(hash_context, data, data_size);
323 : #else
324 : LIBSPDM_ASSERT(false);
325 : return false;
326 : #endif
327 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
328 : #if LIBSPDM_SHA384_SUPPORT
329 0 : return libspdm_sha384_update(hash_context, data, data_size);
330 : #else
331 : LIBSPDM_ASSERT(false);
332 : return false;
333 : #endif
334 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
335 : #if LIBSPDM_SHA512_SUPPORT
336 0 : return libspdm_sha512_update(hash_context, data, data_size);
337 : #else
338 : LIBSPDM_ASSERT(false);
339 : return false;
340 : #endif
341 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
342 : #if LIBSPDM_SHA3_256_SUPPORT
343 0 : return libspdm_sha3_256_update(hash_context, data, data_size);
344 : #else
345 : LIBSPDM_ASSERT(false);
346 : return false;
347 : #endif
348 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
349 : #if LIBSPDM_SHA3_384_SUPPORT
350 0 : return libspdm_sha3_384_update(hash_context, data, data_size);
351 : #else
352 : LIBSPDM_ASSERT(false);
353 : return false;
354 : #endif
355 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
356 : #if LIBSPDM_SHA3_512_SUPPORT
357 0 : return libspdm_sha3_512_update(hash_context, data, data_size);
358 : #else
359 : LIBSPDM_ASSERT(false);
360 : return false;
361 : #endif
362 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
363 : #if LIBSPDM_SM3_256_SUPPORT
364 : return libspdm_sm3_256_update(hash_context, data, data_size);
365 : #else
366 0 : LIBSPDM_ASSERT(false);
367 0 : return false;
368 : #endif
369 0 : default:
370 0 : LIBSPDM_ASSERT(false);
371 0 : return false;
372 : }
373 : }
374 :
375 402 : bool libspdm_hash_final(uint32_t base_hash_algo, void *hash_context, uint8_t *hash_value)
376 : {
377 402 : switch (base_hash_algo) {
378 402 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
379 : #if LIBSPDM_SHA256_SUPPORT
380 402 : return libspdm_sha256_final(hash_context, hash_value);
381 : #else
382 : LIBSPDM_ASSERT(false);
383 : return false;
384 : #endif
385 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
386 : #if LIBSPDM_SHA384_SUPPORT
387 0 : return libspdm_sha384_final(hash_context, hash_value);
388 : #else
389 : LIBSPDM_ASSERT(false);
390 : return false;
391 : #endif
392 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
393 : #if LIBSPDM_SHA512_SUPPORT
394 0 : return libspdm_sha512_final(hash_context, hash_value);
395 : #else
396 : LIBSPDM_ASSERT(false);
397 : return false;
398 : #endif
399 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
400 : #if LIBSPDM_SHA3_256_SUPPORT
401 0 : return libspdm_sha3_256_final(hash_context, hash_value);
402 : #else
403 : LIBSPDM_ASSERT(false);
404 : return false;
405 : #endif
406 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
407 : #if LIBSPDM_SHA3_384_SUPPORT
408 0 : return libspdm_sha3_384_final(hash_context, hash_value);
409 : #else
410 : LIBSPDM_ASSERT(false);
411 : return false;
412 : #endif
413 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
414 : #if LIBSPDM_SHA3_512_SUPPORT
415 0 : return libspdm_sha3_512_final(hash_context, hash_value);
416 : #else
417 : LIBSPDM_ASSERT(false);
418 : return false;
419 : #endif
420 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
421 : #if LIBSPDM_SM3_256_SUPPORT
422 : return libspdm_sm3_256_final(hash_context, hash_value);
423 : #else
424 0 : LIBSPDM_ASSERT(false);
425 0 : return false;
426 : #endif
427 0 : default:
428 0 : LIBSPDM_ASSERT(false);
429 0 : return false;
430 : }
431 : }
432 :
433 1808 : bool libspdm_hash_all(uint32_t base_hash_algo, const void *data,
434 : size_t data_size, uint8_t *hash_value)
435 : {
436 1808 : switch (base_hash_algo) {
437 1808 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
438 : #if LIBSPDM_SHA256_SUPPORT
439 1808 : return libspdm_sha256_hash_all(data, data_size, hash_value);
440 : #else
441 : LIBSPDM_ASSERT(false);
442 : return false;
443 : #endif
444 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
445 : #if LIBSPDM_SHA384_SUPPORT
446 0 : return libspdm_sha384_hash_all(data, data_size, hash_value);
447 : #else
448 : LIBSPDM_ASSERT(false);
449 : return false;
450 : #endif
451 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
452 : #if LIBSPDM_SHA512_SUPPORT
453 0 : return libspdm_sha512_hash_all(data, data_size, hash_value);
454 : #else
455 : LIBSPDM_ASSERT(false);
456 : return false;
457 : #endif
458 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
459 : #if LIBSPDM_SHA3_256_SUPPORT
460 0 : return libspdm_sha3_256_hash_all(data, data_size, hash_value);
461 : #else
462 : LIBSPDM_ASSERT(false);
463 : return false;
464 : #endif
465 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
466 : #if LIBSPDM_SHA3_384_SUPPORT
467 0 : return libspdm_sha3_384_hash_all(data, data_size, hash_value);
468 : #else
469 : LIBSPDM_ASSERT(false);
470 : return false;
471 : #endif
472 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
473 : #if LIBSPDM_SHA3_512_SUPPORT
474 0 : return libspdm_sha3_512_hash_all(data, data_size, hash_value);
475 : #else
476 : LIBSPDM_ASSERT(false);
477 : return false;
478 : #endif
479 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
480 : #if LIBSPDM_SM3_256_SUPPORT
481 : return libspdm_sm3_256_hash_all(data, data_size, hash_value);
482 : #else
483 0 : LIBSPDM_ASSERT(false);
484 0 : return false;
485 : #endif
486 0 : default:
487 0 : LIBSPDM_ASSERT(false);
488 0 : return false;
489 : }
490 : }
491 :
492 1686 : uint32_t libspdm_get_measurement_hash_size(uint32_t measurement_hash_algo)
493 : {
494 1686 : switch (measurement_hash_algo) {
495 0 : case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA_256:
496 : case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA3_256:
497 0 : return 32;
498 1685 : case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA_384:
499 : case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA3_384:
500 1685 : return 48;
501 0 : case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA_512:
502 : case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA3_512:
503 0 : return 64;
504 0 : case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SM3_256:
505 0 : return 32;
506 0 : case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_RAW_BIT_STREAM_ONLY:
507 0 : return 0xFFFFFFFF;
508 1 : default:
509 1 : return 0;
510 : }
511 : }
|
