Branch data Line data Source code
1 : : /**
2 : : * Copyright Notice:
3 : : * Copyright 2021-2026 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 : 6 : void *libspdm_hmac_new(uint32_t base_hash_algo)
10 : : {
11 [ + + + + : 6 : switch (base_hash_algo) {
+ + - - ]
12 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
13 : : #if LIBSPDM_SHA256_SUPPORT
14 : 1 : return libspdm_hmac_sha256_new();
15 : : #else
16 : : LIBSPDM_ASSERT(false);
17 : : return NULL;
18 : : #endif
19 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
20 : : #if LIBSPDM_SHA384_SUPPORT
21 : 1 : return libspdm_hmac_sha384_new();
22 : : #else
23 : : LIBSPDM_ASSERT(false);
24 : : return NULL;
25 : : #endif
26 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
27 : : #if LIBSPDM_SHA512_SUPPORT
28 : 1 : return libspdm_hmac_sha512_new();
29 : : #else
30 : : LIBSPDM_ASSERT(false);
31 : : return NULL;
32 : : #endif
33 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
34 : : #if LIBSPDM_SHA3_256_SUPPORT
35 : 1 : return libspdm_hmac_sha3_256_new();
36 : : #else
37 : : LIBSPDM_ASSERT(false);
38 : : return NULL;
39 : : #endif
40 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
41 : : #if LIBSPDM_SHA3_384_SUPPORT
42 : 1 : return libspdm_hmac_sha3_384_new();
43 : : #else
44 : : LIBSPDM_ASSERT(false);
45 : : return NULL;
46 : : #endif
47 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
48 : : #if LIBSPDM_SHA3_512_SUPPORT
49 : 1 : 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 : 6 : void libspdm_hmac_free(uint32_t base_hash_algo, void *hmac_ctx)
68 : : {
69 [ - + ]: 6 : if (hmac_ctx == NULL) {
70 : 0 : return;
71 : : }
72 [ + + + + : 6 : switch (base_hash_algo) {
+ + - - ]
73 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
74 : : #if LIBSPDM_SHA256_SUPPORT
75 : 1 : libspdm_hmac_sha256_free(hmac_ctx);
76 : : #else
77 : : LIBSPDM_ASSERT(false);
78 : : #endif
79 : 1 : break;
80 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
81 : : #if LIBSPDM_SHA384_SUPPORT
82 : 1 : libspdm_hmac_sha384_free(hmac_ctx);
83 : : #else
84 : : LIBSPDM_ASSERT(false);
85 : : #endif
86 : 1 : break;
87 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
88 : : #if LIBSPDM_SHA512_SUPPORT
89 : 1 : libspdm_hmac_sha512_free(hmac_ctx);
90 : : #else
91 : : LIBSPDM_ASSERT(false);
92 : : #endif
93 : 1 : break;
94 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
95 : : #if LIBSPDM_SHA3_256_SUPPORT
96 : 1 : libspdm_hmac_sha3_256_free(hmac_ctx);
97 : : #else
98 : : LIBSPDM_ASSERT(false);
99 : : #endif
100 : 1 : break;
101 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
102 : : #if LIBSPDM_SHA3_384_SUPPORT
103 : 1 : libspdm_hmac_sha3_384_free(hmac_ctx);
104 : : #else
105 : : LIBSPDM_ASSERT(false);
106 : : #endif
107 : 1 : break;
108 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
109 : : #if LIBSPDM_SHA3_512_SUPPORT
110 : 1 : libspdm_hmac_sha3_512_free(hmac_ctx);
111 : : #else
112 : : LIBSPDM_ASSERT(false);
113 : : #endif
114 : 1 : 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 : 6 : bool libspdm_hmac_init(uint32_t base_hash_algo,
129 : : void *hmac_ctx, const uint8_t *key,
130 : : size_t key_size)
131 : : {
132 [ + + + + : 6 : switch (base_hash_algo) {
+ + - - ]
133 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
134 : : #if LIBSPDM_SHA256_SUPPORT
135 : 1 : return libspdm_hmac_sha256_set_key(hmac_ctx, key, key_size);
136 : : #else
137 : : LIBSPDM_ASSERT(false);
138 : : return false;
139 : : #endif
140 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
141 : : #if LIBSPDM_SHA384_SUPPORT
142 : 1 : return libspdm_hmac_sha384_set_key(hmac_ctx, key, key_size);
143 : : #else
144 : : LIBSPDM_ASSERT(false);
145 : : return false;
146 : : #endif
147 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
148 : : #if LIBSPDM_SHA512_SUPPORT
149 : 1 : return libspdm_hmac_sha512_set_key(hmac_ctx, key, key_size);
150 : : #else
151 : : LIBSPDM_ASSERT(false);
152 : : return false;
153 : : #endif
154 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
155 : : #if LIBSPDM_SHA3_256_SUPPORT
156 : 1 : return libspdm_hmac_sha3_256_set_key(hmac_ctx, key, key_size);
157 : : #else
158 : : LIBSPDM_ASSERT(false);
159 : : return false;
160 : : #endif
161 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
162 : : #if LIBSPDM_SHA3_384_SUPPORT
163 : 1 : return libspdm_hmac_sha3_384_set_key(hmac_ctx, key, key_size);
164 : : #else
165 : : LIBSPDM_ASSERT(false);
166 : : return false;
167 : : #endif
168 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
169 : : #if LIBSPDM_SHA3_512_SUPPORT
170 : 1 : 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 : 12 : bool libspdm_hmac_update(uint32_t base_hash_algo,
189 : : void *hmac_ctx, const void *data,
190 : : size_t data_size)
191 : : {
192 [ + + + + : 12 : switch (base_hash_algo) {
+ + - - ]
193 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
194 : : #if LIBSPDM_SHA256_SUPPORT
195 : 2 : return libspdm_hmac_sha256_update(hmac_ctx, data, data_size);
196 : : #else
197 : : LIBSPDM_ASSERT(false);
198 : : return false;
199 : : #endif
200 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
201 : : #if LIBSPDM_SHA384_SUPPORT
202 : 2 : return libspdm_hmac_sha384_update(hmac_ctx, data, data_size);
203 : : #else
204 : : LIBSPDM_ASSERT(false);
205 : : return false;
206 : : #endif
207 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
208 : : #if LIBSPDM_SHA512_SUPPORT
209 : 2 : return libspdm_hmac_sha512_update(hmac_ctx, data, data_size);
210 : : #else
211 : : LIBSPDM_ASSERT(false);
212 : : return false;
213 : : #endif
214 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
215 : : #if LIBSPDM_SHA3_256_SUPPORT
216 : 2 : return libspdm_hmac_sha3_256_update(hmac_ctx, data, data_size);
217 : : #else
218 : : LIBSPDM_ASSERT(false);
219 : : return false;
220 : : #endif
221 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
222 : : #if LIBSPDM_SHA3_384_SUPPORT
223 : 2 : return libspdm_hmac_sha3_384_update(hmac_ctx, data, data_size);
224 : : #else
225 : : LIBSPDM_ASSERT(false);
226 : : return false;
227 : : #endif
228 : 2 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
229 : : #if LIBSPDM_SHA3_512_SUPPORT
230 : 2 : return libspdm_hmac_sha3_512_update(hmac_ctx, data, data_size);
231 : : #else
232 : : LIBSPDM_ASSERT(false);
233 : : return false;
234 : : #endif
235 : 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
236 : : #if LIBSPDM_SM3_256_SUPPORT
237 : : return libspdm_hmac_sm3_256_update(hmac_ctx, data, data_size);
238 : : #else
239 : 0 : LIBSPDM_ASSERT(false);
240 : 0 : return false;
241 : : #endif
242 : 0 : default:
243 : 0 : LIBSPDM_ASSERT(false);
244 : 0 : return false;
245 : : }
246 : : }
247 : :
248 : 6 : bool libspdm_hmac_final(uint32_t base_hash_algo, void *hmac_ctx, uint8_t *hmac_value)
249 : : {
250 [ + + + + : 6 : switch (base_hash_algo) {
+ + - - ]
251 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
252 : : #if LIBSPDM_SHA256_SUPPORT
253 : 1 : return libspdm_hmac_sha256_final(hmac_ctx, hmac_value);
254 : : #else
255 : : LIBSPDM_ASSERT(false);
256 : : return false;
257 : : #endif
258 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
259 : : #if LIBSPDM_SHA384_SUPPORT
260 : 1 : return libspdm_hmac_sha384_final(hmac_ctx, hmac_value);
261 : : #else
262 : : LIBSPDM_ASSERT(false);
263 : : return false;
264 : : #endif
265 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
266 : : #if LIBSPDM_SHA512_SUPPORT
267 : 1 : return libspdm_hmac_sha512_final(hmac_ctx, hmac_value);
268 : : #else
269 : : LIBSPDM_ASSERT(false);
270 : : return false;
271 : : #endif
272 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
273 : : #if LIBSPDM_SHA3_256_SUPPORT
274 : 1 : return libspdm_hmac_sha3_256_final(hmac_ctx, hmac_value);
275 : : #else
276 : : LIBSPDM_ASSERT(false);
277 : : return false;
278 : : #endif
279 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
280 : : #if LIBSPDM_SHA3_384_SUPPORT
281 : 1 : return libspdm_hmac_sha3_384_final(hmac_ctx, hmac_value);
282 : : #else
283 : : LIBSPDM_ASSERT(false);
284 : : return false;
285 : : #endif
286 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
287 : : #if LIBSPDM_SHA3_512_SUPPORT
288 : 1 : return libspdm_hmac_sha3_512_final(hmac_ctx, hmac_value);
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_final(hmac_ctx, hmac_value);
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 : 391 : bool libspdm_hmac_all(uint32_t base_hash_algo, const void *data,
307 : : size_t data_size, const uint8_t *key,
308 : : size_t key_size, uint8_t *hmac_value)
309 : : {
310 [ + + + + : 391 : switch (base_hash_algo) {
+ + - - ]
311 : 386 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
312 : : #if LIBSPDM_SHA256_SUPPORT
313 : 386 : return libspdm_hmac_sha256_all(data, data_size, key, key_size, hmac_value);
314 : : #else
315 : : LIBSPDM_ASSERT(false);
316 : : return false;
317 : : #endif
318 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
319 : : #if LIBSPDM_SHA384_SUPPORT
320 : 1 : return libspdm_hmac_sha384_all(data, data_size, key, key_size, hmac_value);
321 : : #else
322 : : LIBSPDM_ASSERT(false);
323 : : return false;
324 : : #endif
325 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
326 : : #if LIBSPDM_SHA512_SUPPORT
327 : 1 : return libspdm_hmac_sha512_all(data, data_size, key, key_size, hmac_value);
328 : : #else
329 : : LIBSPDM_ASSERT(false);
330 : : return false;
331 : : #endif
332 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
333 : : #if LIBSPDM_SHA3_256_SUPPORT
334 : 1 : return libspdm_hmac_sha3_256_all(data, data_size, key, key_size, hmac_value);
335 : : #else
336 : : LIBSPDM_ASSERT(false);
337 : : return false;
338 : : #endif
339 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
340 : : #if LIBSPDM_SHA3_384_SUPPORT
341 : 1 : return libspdm_hmac_sha3_384_all(data, data_size, key, key_size, hmac_value);
342 : : #else
343 : : LIBSPDM_ASSERT(false);
344 : : return false;
345 : : #endif
346 : 1 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
347 : : #if LIBSPDM_SHA3_512_SUPPORT
348 : 1 : return libspdm_hmac_sha3_512_all(data, data_size, key, key_size, hmac_value);
349 : : #else
350 : : LIBSPDM_ASSERT(false);
351 : : return false;
352 : : #endif
353 : 0 : case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
354 : : #if LIBSPDM_SM3_256_SUPPORT
355 : : return libspdm_hmac_sm3_256_all(data, data_size, key, key_size, hmac_value);
356 : : #else
357 : 0 : LIBSPDM_ASSERT(false);
358 : 0 : return false;
359 : : #endif
360 : 0 : default:
361 : 0 : LIBSPDM_ASSERT(false);
362 : 0 : return false;
363 : : }
364 : : }
|
