Branch data 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 : 6245 : uint32_t libspdm_get_hash_size(uint32_t base_hash_algo)
10 : : {
11 [ + + + + : 6245 : switch (base_hash_algo) {
+ + + + ]
12 : 5808 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
13 : : #if LIBSPDM_SHA256_SUPPORT
14 : 5808 : return 32;
15 : : #else
16 : : return 0;
17 : : #endif
18 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
19 : : #if LIBSPDM_SHA3_256_SUPPORT
20 : 1 : return 32;
21 : : #else
22 : : return 0;
23 : : #endif
24 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
25 : : #if LIBSPDM_SHA384_SUPPORT
26 : 1 : return 48;
27 : : #else
28 : : return 0;
29 : : #endif
30 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
31 : : #if LIBSPDM_SHA3_384_SUPPORT
32 : 1 : return 48;
33 : : #else
34 : : return 0;
35 : : #endif
36 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
37 : : #if LIBSPDM_SHA512_SUPPORT
38 : 2 : return 64;
39 : : #else
40 : : return 0;
41 : : #endif
42 : 3 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
43 : : #if LIBSPDM_SHA3_512_SUPPORT
44 : 3 : return 64;
45 : : #else
46 : : return 0;
47 : : #endif
48 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
49 : : #if LIBSPDM_SM3_256_SUPPORT
50 : : return 32;
51 : : #else
52 : 1 : return 0;
53 : : #endif
54 : 428 : default:
55 : 428 : return 0;
56 : : }
57 : : }
58 : :
59 : 329 : size_t libspdm_get_hash_nid(uint32_t base_hash_algo)
60 : : {
61 [ + + + + : 329 : switch (base_hash_algo) {
+ + + + ]
62 : 322 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
63 : 322 : return LIBSPDM_CRYPTO_NID_SHA256;
64 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
65 : 1 : return LIBSPDM_CRYPTO_NID_SHA384;
66 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
67 : 1 : return LIBSPDM_CRYPTO_NID_SHA512;
68 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
69 : 1 : return LIBSPDM_CRYPTO_NID_SHA3_256;
70 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
71 : 1 : return LIBSPDM_CRYPTO_NID_SHA3_384;
72 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
73 : 1 : return LIBSPDM_CRYPTO_NID_SHA3_512;
74 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
75 : 1 : return LIBSPDM_CRYPTO_NID_SM3_256;
76 : 1 : default:
77 : 1 : return LIBSPDM_CRYPTO_NID_NULL;
78 : : }
79 : : }
80 : :
81 : 1105 : void *libspdm_hash_new(uint32_t base_hash_algo)
82 : : {
83 [ + + + + : 1105 : switch (base_hash_algo) {
+ + - - ]
84 : 1095 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
85 : : #if LIBSPDM_SHA256_SUPPORT
86 : 1095 : return libspdm_sha256_new();
87 : : #else
88 : : LIBSPDM_ASSERT(false);
89 : : return NULL;
90 : : #endif
91 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
92 : : #if LIBSPDM_SHA384_SUPPORT
93 : 2 : return libspdm_sha384_new();
94 : : #else
95 : : LIBSPDM_ASSERT(false);
96 : : return NULL;
97 : : #endif
98 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
99 : : #if LIBSPDM_SHA512_SUPPORT
100 : 2 : return libspdm_sha512_new();
101 : : #else
102 : : LIBSPDM_ASSERT(false);
103 : : return NULL;
104 : : #endif
105 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
106 : : #if LIBSPDM_SHA3_256_SUPPORT
107 : 2 : return libspdm_sha3_256_new();
108 : : #else
109 : : LIBSPDM_ASSERT(false);
110 : : return NULL;
111 : : #endif
112 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
113 : : #if LIBSPDM_SHA3_384_SUPPORT
114 : 2 : return libspdm_sha3_384_new();
115 : : #else
116 : : LIBSPDM_ASSERT(false);
117 : : return NULL;
118 : : #endif
119 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
120 : : #if LIBSPDM_SHA3_512_SUPPORT
121 : 2 : 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 : 1105 : void libspdm_hash_free(uint32_t base_hash_algo, void *hash_context)
140 : : {
141 [ - + ]: 1105 : if (hash_context == NULL) {
142 : 0 : return;
143 : : }
144 [ + + + + : 1105 : switch (base_hash_algo) {
+ + - - ]
145 : 1095 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
146 : : #if LIBSPDM_SHA256_SUPPORT
147 : 1095 : libspdm_sha256_free(hash_context);
148 : : #else
149 : : LIBSPDM_ASSERT(false);
150 : : #endif
151 : 1095 : break;
152 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
153 : : #if LIBSPDM_SHA384_SUPPORT
154 : 2 : libspdm_sha384_free(hash_context);
155 : : #else
156 : : LIBSPDM_ASSERT(false);
157 : : #endif
158 : 2 : break;
159 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
160 : : #if LIBSPDM_SHA512_SUPPORT
161 : 2 : libspdm_sha512_free(hash_context);
162 : : #else
163 : : LIBSPDM_ASSERT(false);
164 : : #endif
165 : 2 : break;
166 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
167 : : #if LIBSPDM_SHA3_256_SUPPORT
168 : 2 : libspdm_sha3_256_free(hash_context);
169 : : #else
170 : : LIBSPDM_ASSERT(false);
171 : : #endif
172 : 2 : break;
173 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
174 : : #if LIBSPDM_SHA3_384_SUPPORT
175 : 2 : libspdm_sha3_384_free(hash_context);
176 : : #else
177 : : LIBSPDM_ASSERT(false);
178 : : #endif
179 : 2 : break;
180 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
181 : : #if LIBSPDM_SHA3_512_SUPPORT
182 : 2 : libspdm_sha3_512_free(hash_context);
183 : : #else
184 : : LIBSPDM_ASSERT(false);
185 : : #endif
186 : 2 : 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 : 581 : bool libspdm_hash_init(uint32_t base_hash_algo, void *hash_context)
201 : : {
202 [ + + + + : 581 : switch (base_hash_algo) {
+ + - - ]
203 : 576 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
204 : : #if LIBSPDM_SHA256_SUPPORT
205 : 576 : return libspdm_sha256_init(hash_context);
206 : : #else
207 : : LIBSPDM_ASSERT(false);
208 : : return false;
209 : : #endif
210 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
211 : : #if LIBSPDM_SHA384_SUPPORT
212 : 1 : return libspdm_sha384_init(hash_context);
213 : : #else
214 : : LIBSPDM_ASSERT(false);
215 : : return false;
216 : : #endif
217 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
218 : : #if LIBSPDM_SHA512_SUPPORT
219 : 1 : return libspdm_sha512_init(hash_context);
220 : : #else
221 : : LIBSPDM_ASSERT(false);
222 : : return false;
223 : : #endif
224 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
225 : : #if LIBSPDM_SHA3_256_SUPPORT
226 : 1 : return libspdm_sha3_256_init(hash_context);
227 : : #else
228 : : LIBSPDM_ASSERT(false);
229 : : return false;
230 : : #endif
231 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
232 : : #if LIBSPDM_SHA3_384_SUPPORT
233 : 1 : return libspdm_sha3_384_init(hash_context);
234 : : #else
235 : : LIBSPDM_ASSERT(false);
236 : : return false;
237 : : #endif
238 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
239 : : #if LIBSPDM_SHA3_512_SUPPORT
240 : 1 : 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 : 523 : bool libspdm_hash_duplicate(uint32_t base_hash_algo, const void *hash_ctx, void *new_hash_ctx)
259 : : {
260 [ + + + + : 523 : switch (base_hash_algo) {
+ + - - ]
261 : 518 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
262 : : #if LIBSPDM_SHA256_SUPPORT
263 : 518 : return libspdm_sha256_duplicate(hash_ctx, new_hash_ctx);
264 : : #else
265 : : LIBSPDM_ASSERT(false);
266 : : return false;
267 : : #endif
268 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
269 : : #if LIBSPDM_SHA384_SUPPORT
270 : 1 : return libspdm_sha384_duplicate(hash_ctx, new_hash_ctx);
271 : : #else
272 : : LIBSPDM_ASSERT(false);
273 : : return false;
274 : : #endif
275 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
276 : : #if LIBSPDM_SHA512_SUPPORT
277 : 1 : return libspdm_sha512_duplicate(hash_ctx, new_hash_ctx);
278 : : #else
279 : : LIBSPDM_ASSERT(false);
280 : : return false;
281 : : #endif
282 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
283 : : #if LIBSPDM_SHA3_256_SUPPORT
284 : 1 : return libspdm_sha3_256_duplicate(hash_ctx, new_hash_ctx);
285 : : #else
286 : : LIBSPDM_ASSERT(false);
287 : : return false;
288 : : #endif
289 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
290 : : #if LIBSPDM_SHA3_384_SUPPORT
291 : 1 : return libspdm_sha3_384_duplicate(hash_ctx, new_hash_ctx);
292 : : #else
293 : : LIBSPDM_ASSERT(false);
294 : : return false;
295 : : #endif
296 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
297 : : #if LIBSPDM_SHA3_512_SUPPORT
298 : 1 : 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 : 11444 : bool libspdm_hash_update(uint32_t base_hash_algo, void *hash_context,
317 : : const void *data, size_t data_size)
318 : : {
319 [ + + + + : 11444 : switch (base_hash_algo) {
+ + - - ]
320 : 11429 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
321 : : #if LIBSPDM_SHA256_SUPPORT
322 : 11429 : return libspdm_sha256_update(hash_context, data, data_size);
323 : : #else
324 : : LIBSPDM_ASSERT(false);
325 : : return false;
326 : : #endif
327 : 3 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
328 : : #if LIBSPDM_SHA384_SUPPORT
329 : 3 : return libspdm_sha384_update(hash_context, data, data_size);
330 : : #else
331 : : LIBSPDM_ASSERT(false);
332 : : return false;
333 : : #endif
334 : 3 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
335 : : #if LIBSPDM_SHA512_SUPPORT
336 : 3 : return libspdm_sha512_update(hash_context, data, data_size);
337 : : #else
338 : : LIBSPDM_ASSERT(false);
339 : : return false;
340 : : #endif
341 : 3 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
342 : : #if LIBSPDM_SHA3_256_SUPPORT
343 : 3 : return libspdm_sha3_256_update(hash_context, data, data_size);
344 : : #else
345 : : LIBSPDM_ASSERT(false);
346 : : return false;
347 : : #endif
348 : 3 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
349 : : #if LIBSPDM_SHA3_384_SUPPORT
350 : 3 : return libspdm_sha3_384_update(hash_context, data, data_size);
351 : : #else
352 : : LIBSPDM_ASSERT(false);
353 : : return false;
354 : : #endif
355 : 3 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
356 : : #if LIBSPDM_SHA3_512_SUPPORT
357 : 3 : 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 : 526 : bool libspdm_hash_final(uint32_t base_hash_algo, void *hash_context, uint8_t *hash_value)
376 : : {
377 [ + + + + : 526 : switch (base_hash_algo) {
+ + - - ]
378 : 516 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
379 : : #if LIBSPDM_SHA256_SUPPORT
380 : 516 : return libspdm_sha256_final(hash_context, hash_value);
381 : : #else
382 : : LIBSPDM_ASSERT(false);
383 : : return false;
384 : : #endif
385 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
386 : : #if LIBSPDM_SHA384_SUPPORT
387 : 2 : return libspdm_sha384_final(hash_context, hash_value);
388 : : #else
389 : : LIBSPDM_ASSERT(false);
390 : : return false;
391 : : #endif
392 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
393 : : #if LIBSPDM_SHA512_SUPPORT
394 : 2 : return libspdm_sha512_final(hash_context, hash_value);
395 : : #else
396 : : LIBSPDM_ASSERT(false);
397 : : return false;
398 : : #endif
399 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
400 : : #if LIBSPDM_SHA3_256_SUPPORT
401 : 2 : return libspdm_sha3_256_final(hash_context, hash_value);
402 : : #else
403 : : LIBSPDM_ASSERT(false);
404 : : return false;
405 : : #endif
406 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
407 : : #if LIBSPDM_SHA3_384_SUPPORT
408 : 2 : return libspdm_sha3_384_final(hash_context, hash_value);
409 : : #else
410 : : LIBSPDM_ASSERT(false);
411 : : return false;
412 : : #endif
413 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
414 : : #if LIBSPDM_SHA3_512_SUPPORT
415 : 2 : 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 : 2118 : bool libspdm_hash_all(uint32_t base_hash_algo, const void *data,
434 : : size_t data_size, uint8_t *hash_value)
435 : : {
436 [ + + + + : 2118 : switch (base_hash_algo) {
+ + - - ]
437 : 2113 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
438 : : #if LIBSPDM_SHA256_SUPPORT
439 : 2113 : return libspdm_sha256_hash_all(data, data_size, hash_value);
440 : : #else
441 : : LIBSPDM_ASSERT(false);
442 : : return false;
443 : : #endif
444 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
445 : : #if LIBSPDM_SHA384_SUPPORT
446 : 1 : return libspdm_sha384_hash_all(data, data_size, hash_value);
447 : : #else
448 : : LIBSPDM_ASSERT(false);
449 : : return false;
450 : : #endif
451 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
452 : : #if LIBSPDM_SHA512_SUPPORT
453 : 1 : return libspdm_sha512_hash_all(data, data_size, hash_value);
454 : : #else
455 : : LIBSPDM_ASSERT(false);
456 : : return false;
457 : : #endif
458 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
459 : : #if LIBSPDM_SHA3_256_SUPPORT
460 : 1 : return libspdm_sha3_256_hash_all(data, data_size, hash_value);
461 : : #else
462 : : LIBSPDM_ASSERT(false);
463 : : return false;
464 : : #endif
465 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
466 : : #if LIBSPDM_SHA3_384_SUPPORT
467 : 1 : return libspdm_sha3_384_hash_all(data, data_size, hash_value);
468 : : #else
469 : : LIBSPDM_ASSERT(false);
470 : : return false;
471 : : #endif
472 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
473 : : #if LIBSPDM_SHA3_512_SUPPORT
474 : 1 : 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 : 1735 : uint32_t libspdm_get_measurement_hash_size(uint32_t measurement_hash_algo)
493 : : {
494 [ + + + + : 1735 : switch (measurement_hash_algo) {
+ + ]
495 : 23 : case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA_256:
496 : : case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA3_256:
497 : 23 : return 32;
498 : 1703 : case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA_384:
499 : : case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA3_384:
500 : 1703 : return 48;
501 : 3 : case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA_512:
502 : : case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA3_512:
503 : 3 : return 64;
504 : 1 : case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SM3_256:
505 : 1 : return 32;
506 : 1 : case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_RAW_BIT_STREAM_ONLY:
507 : 1 : return 0xFFFFFFFF;
508 : 4 : default:
509 : 4 : return 0;
510 : : }
511 : : }
|
