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_secured_message_lib.h"
8 : :
9 : 375 : static bool libspdm_generate_aead_key_and_iv(
10 : : libspdm_secured_message_context_t *secured_message_context,
11 : : const uint8_t *major_secret, uint8_t *key, uint8_t *iv)
12 : : {
13 : : bool status;
14 : : size_t hash_size;
15 : : size_t key_length;
16 : : size_t iv_length;
17 : : uint8_t bin_str5[128];
18 : : size_t bin_str5_size;
19 : : uint8_t bin_str6[128];
20 : : size_t bin_str6_size;
21 : :
22 : 375 : hash_size = secured_message_context->hash_size;
23 : 375 : key_length = secured_message_context->aead_key_size;
24 : 375 : iv_length = secured_message_context->aead_iv_size;
25 : :
26 : 375 : bin_str5_size = sizeof(bin_str5);
27 : 375 : libspdm_bin_concat(secured_message_context->version,
28 : : SPDM_BIN_STR_5_LABEL, sizeof(SPDM_BIN_STR_5_LABEL) - 1,
29 : 375 : NULL, (uint16_t)key_length, hash_size, bin_str5,
30 : : &bin_str5_size);
31 : :
32 : 375 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "bin_str5 (0x%zx):\n", bin_str5_size));
33 : 375 : LIBSPDM_INTERNAL_DUMP_HEX(bin_str5, bin_str5_size);
34 : 375 : status = libspdm_hkdf_expand(secured_message_context->base_hash_algo,
35 : : major_secret, hash_size, bin_str5,
36 : : bin_str5_size, key, key_length);
37 [ - + ]: 375 : if (!status) {
38 : 0 : return false;
39 : : }
40 : 375 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "key (0x%zx) - ", key_length));
41 : 375 : LIBSPDM_INTERNAL_DUMP_DATA(key, key_length);
42 : 375 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
43 : :
44 : 375 : bin_str6_size = sizeof(bin_str6);
45 : 375 : libspdm_bin_concat(secured_message_context->version,
46 : : SPDM_BIN_STR_6_LABEL, sizeof(SPDM_BIN_STR_6_LABEL) - 1,
47 : 375 : NULL, (uint16_t)iv_length, hash_size, bin_str6,
48 : : &bin_str6_size);
49 : :
50 : 375 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "bin_str6 (0x%zx):\n", bin_str6_size));
51 : 375 : LIBSPDM_INTERNAL_DUMP_HEX(bin_str6, bin_str6_size);
52 : 375 : status = libspdm_hkdf_expand(secured_message_context->base_hash_algo,
53 : : major_secret, hash_size, bin_str6,
54 : : bin_str6_size, iv, iv_length);
55 [ - + ]: 375 : if (!status) {
56 : 0 : return false;
57 : : }
58 : 375 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "iv (0x%zx) - ", iv_length));
59 : 375 : LIBSPDM_INTERNAL_DUMP_DATA(iv, iv_length);
60 : 375 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
61 : :
62 : 375 : return true;
63 : : }
64 : :
65 : 164 : static bool libspdm_generate_finished_key(
66 : : libspdm_secured_message_context_t *secured_message_context,
67 : : const uint8_t *handshake_secret, uint8_t *finished_key)
68 : : {
69 : : bool status;
70 : : size_t hash_size;
71 : : uint8_t bin_str7[128];
72 : : size_t bin_str7_size;
73 : :
74 : 164 : hash_size = secured_message_context->hash_size;
75 : :
76 : 164 : bin_str7_size = sizeof(bin_str7);
77 : 164 : libspdm_bin_concat(secured_message_context->version,
78 : : SPDM_BIN_STR_7_LABEL, sizeof(SPDM_BIN_STR_7_LABEL) - 1,
79 : 164 : NULL, (uint16_t)hash_size, hash_size, bin_str7,
80 : : &bin_str7_size);
81 : :
82 : 164 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "bin_str7 (0x%zx):\n", bin_str7_size));
83 : 164 : LIBSPDM_INTERNAL_DUMP_HEX(bin_str7, bin_str7_size);
84 : 164 : status = libspdm_hkdf_expand(secured_message_context->base_hash_algo,
85 : : handshake_secret, hash_size, bin_str7,
86 : : bin_str7_size, finished_key, hash_size);
87 [ - + ]: 164 : if (!status) {
88 : 0 : return false;
89 : : }
90 : 164 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "finished_key (0x%zx) - ", hash_size));
91 : 164 : LIBSPDM_INTERNAL_DUMP_DATA(finished_key, hash_size);
92 : 164 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
93 : :
94 : 164 : return true;
95 : : }
96 : :
97 : 82 : bool libspdm_generate_session_handshake_key(void *spdm_secured_message_context,
98 : : const uint8_t *th1_hash_data)
99 : : {
100 : : bool status;
101 : : size_t hash_size;
102 : : libspdm_secured_message_context_t *secured_message_context;
103 : : size_t handshake_secret_size;
104 : : size_t request_handshake_secret_size;
105 : : size_t response_handshake_secret_size;
106 : :
107 : 82 : secured_message_context = spdm_secured_message_context;
108 : :
109 : 82 : hash_size = secured_message_context->hash_size;
110 : 82 : handshake_secret_size = hash_size;
111 : 82 : request_handshake_secret_size = hash_size;
112 : 82 : response_handshake_secret_size = hash_size;
113 : :
114 : : #if LIBSPDM_ENABLE_CAPABILITY_PSK_CAP
115 [ + + ]: 82 : if (secured_message_context->use_psk) {
116 : 35 : status = libspdm_generate_handshake_key (
117 : 35 : secured_message_context->version,
118 : : NULL,
119 : : 0,
120 : : false,
121 : 35 : secured_message_context->psk_hint,
122 : : secured_message_context->psk_hint_size,
123 : 35 : secured_message_context->use_psk,
124 : : secured_message_context->base_hash_algo,
125 : : th1_hash_data,
126 : 35 : secured_message_context->master_secret.handshake_secret,
127 : : &handshake_secret_size,
128 : 35 : secured_message_context->handshake_secret.request_handshake_secret,
129 : : &request_handshake_secret_size,
130 : 35 : secured_message_context->handshake_secret.response_handshake_secret,
131 : : &response_handshake_secret_size);
132 : :
133 [ - + ]: 35 : if (!status) {
134 : 0 : return status;
135 : : }
136 : : }
137 : : #endif /* LIBSPDM_ENABLE_CAPABILITY_PSK_CAP */
138 [ + + ]: 82 : if (!(secured_message_context->use_psk)) {
139 [ - + ]: 47 : if (secured_message_context->kem_alg != 0) {
140 : 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "[KEM Secret]: "));
141 : : } else {
142 : 47 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "[DHE Secret]: "));
143 : : }
144 : 47 : LIBSPDM_INTERNAL_DUMP_HEX_STR(
145 : : secured_message_context->master_secret.shared_secret,
146 : : secured_message_context->shared_key_size);
147 : 47 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
148 : :
149 : 47 : status = libspdm_generate_handshake_key (
150 : 47 : secured_message_context->version,
151 : 47 : secured_message_context->master_secret.shared_secret,
152 : : secured_message_context->shared_key_size,
153 : : false,
154 : : NULL,
155 : : 0,
156 : 47 : secured_message_context->use_psk,
157 : : secured_message_context->base_hash_algo,
158 : : th1_hash_data,
159 : 47 : secured_message_context->master_secret.handshake_secret,
160 : : &handshake_secret_size,
161 : 47 : secured_message_context->handshake_secret.request_handshake_secret,
162 : : &request_handshake_secret_size,
163 : 47 : secured_message_context->handshake_secret.response_handshake_secret,
164 : : &response_handshake_secret_size);
165 : :
166 [ - + ]: 47 : if (!status) {
167 : 0 : return status;
168 : : }
169 : :
170 : 47 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "handshake_secret (0x%zx) - ", hash_size));
171 : 47 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->master_secret.handshake_secret, hash_size);
172 : 47 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
173 : :
174 : 47 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "request_handshake_secret (0x%zx) - ", hash_size));
175 : 47 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->handshake_secret.request_handshake_secret, hash_size);
176 : 47 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
177 : :
178 : 47 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "response_handshake_secret (0x%zx) - ", hash_size));
179 : 47 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->handshake_secret.response_handshake_secret, hash_size);
180 : 47 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
181 : : }
182 : :
183 : 82 : status = libspdm_generate_finished_key(
184 : : secured_message_context,
185 : : secured_message_context->handshake_secret
186 : 82 : .request_handshake_secret,
187 : 82 : secured_message_context->handshake_secret.request_finished_key);
188 [ - + ]: 82 : if (!status) {
189 : 0 : return status;
190 : : }
191 : :
192 : 82 : status = libspdm_generate_finished_key(
193 : : secured_message_context,
194 : 82 : secured_message_context->handshake_secret.response_handshake_secret,
195 : 82 : secured_message_context->handshake_secret.response_finished_key);
196 [ - + ]: 82 : if (!status) {
197 : 0 : return status;
198 : : }
199 : :
200 : 82 : status = libspdm_generate_aead_key_and_iv(secured_message_context,
201 : : secured_message_context->handshake_secret
202 : 82 : .request_handshake_secret,
203 : : secured_message_context->handshake_secret
204 : 82 : .request_handshake_encryption_key,
205 : : secured_message_context->handshake_secret
206 : 82 : .request_handshake_salt);
207 [ - + ]: 82 : if (!status) {
208 : 0 : return status;
209 : : }
210 : 82 : secured_message_context->handshake_secret.request_handshake_sequence_number = 0;
211 : :
212 : 82 : status = libspdm_generate_aead_key_and_iv(
213 : : secured_message_context,
214 : 82 : secured_message_context->handshake_secret.response_handshake_secret,
215 : 82 : secured_message_context->handshake_secret.response_handshake_encryption_key,
216 : 82 : secured_message_context->handshake_secret.response_handshake_salt);
217 [ - + ]: 82 : if (!status) {
218 : 0 : return status;
219 : : }
220 : :
221 : 82 : secured_message_context->handshake_secret.response_handshake_sequence_number = 0;
222 : 82 : libspdm_zero_mem(secured_message_context->master_secret.shared_secret, LIBSPDM_MAX_SHARED_KEY_SIZE);
223 : :
224 : 82 : return true;
225 : : }
226 : :
227 : 52 : bool libspdm_generate_session_data_key(void *spdm_secured_message_context,
228 : : const uint8_t *th2_hash_data)
229 : : {
230 : : bool status;
231 : : size_t hash_size;
232 : : size_t master_secret_size;
233 : : size_t request_data_secret_size;
234 : : size_t response_data_secret_size;
235 : : size_t export_master_secret_size;
236 : :
237 : : libspdm_secured_message_context_t *secured_message_context;
238 : :
239 : 52 : secured_message_context = spdm_secured_message_context;
240 : :
241 : 52 : hash_size = secured_message_context->hash_size;
242 : 52 : master_secret_size = hash_size;
243 : 52 : request_data_secret_size = hash_size;
244 : 52 : response_data_secret_size = hash_size;
245 : 52 : export_master_secret_size = hash_size;
246 : :
247 : : #if LIBSPDM_ENABLE_CAPABILITY_PSK_CAP
248 [ + + ]: 52 : if (secured_message_context->use_psk) {
249 : 24 : status = libspdm_generate_data_key(
250 : 24 : secured_message_context->version,
251 : : NULL,
252 : : 0,
253 : 24 : secured_message_context->psk_hint,
254 : : secured_message_context->psk_hint_size,
255 : 24 : secured_message_context->use_psk,
256 : : secured_message_context->base_hash_algo,
257 : : th2_hash_data,
258 : 24 : secured_message_context->master_secret.master_secret,
259 : : &master_secret_size,
260 : 24 : secured_message_context->application_secret.request_data_secret,
261 : : &request_data_secret_size,
262 : 24 : secured_message_context->application_secret.response_data_secret,
263 : : &response_data_secret_size,
264 : 24 : secured_message_context->export_master_secret,
265 : : &export_master_secret_size);
266 : :
267 [ - + ]: 24 : if (!status) {
268 : 0 : return status;
269 : : }
270 : : }
271 : : #endif /* LIBSPDM_ENABLE_CAPABILITY_PSK_CAP */
272 [ + + ]: 52 : if (!(secured_message_context->use_psk)) {
273 : 28 : status = libspdm_generate_data_key(
274 : 28 : secured_message_context->version,
275 : 28 : secured_message_context->master_secret.handshake_secret,
276 : : hash_size,
277 : : NULL,
278 : : 0,
279 : 28 : secured_message_context->use_psk,
280 : : secured_message_context->base_hash_algo,
281 : : th2_hash_data,
282 : 28 : secured_message_context->master_secret.master_secret,
283 : : &master_secret_size,
284 : 28 : secured_message_context->application_secret.request_data_secret,
285 : : &request_data_secret_size,
286 : 28 : secured_message_context->application_secret.response_data_secret,
287 : : &response_data_secret_size,
288 : 28 : secured_message_context->export_master_secret,
289 : : &export_master_secret_size);
290 : :
291 [ - + ]: 28 : if (!status) {
292 : 0 : return status;
293 : : }
294 : :
295 : 28 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "master_secret (0x%zx) - ", hash_size));
296 : 28 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->master_secret.master_secret, hash_size);
297 : 28 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
298 : :
299 : 28 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "request_data_secret (0x%zx) - ", hash_size));
300 : 28 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->application_secret.request_data_secret, hash_size);
301 : 28 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
302 : :
303 : 28 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "response_data_secret (0x%zx) - ", hash_size));
304 : 28 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->application_secret.response_data_secret, hash_size);
305 : 28 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
306 : :
307 : 28 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "export_master_secret (0x%zx) - ", hash_size));
308 : 28 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->export_master_secret, hash_size);
309 : 28 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
310 : : }
311 : :
312 : 52 : status = libspdm_generate_aead_key_and_iv(
313 : : secured_message_context,
314 : 52 : secured_message_context->application_secret.request_data_secret,
315 : 52 : secured_message_context->application_secret.request_data_encryption_key,
316 : 52 : secured_message_context->application_secret.request_data_salt);
317 [ - + ]: 52 : if (!status) {
318 : 0 : return status;
319 : : }
320 : 52 : secured_message_context->application_secret.request_data_sequence_number = 0;
321 : :
322 : 52 : status = libspdm_generate_aead_key_and_iv(
323 : : secured_message_context,
324 : 52 : secured_message_context->application_secret.response_data_secret,
325 : 52 : secured_message_context->application_secret.response_data_encryption_key,
326 : 52 : secured_message_context->application_secret.response_data_salt);
327 [ - + ]: 52 : if (!status) {
328 : 0 : return status;
329 : : }
330 : 52 : secured_message_context->application_secret.response_data_sequence_number = 0;
331 : :
332 : 52 : return true;
333 : : }
334 : :
335 : 107 : bool libspdm_create_update_session_data_key(void *spdm_secured_message_context,
336 : : libspdm_key_update_action_t action)
337 : : {
338 : : bool status;
339 : : size_t hash_size;
340 : : uint8_t bin_str9[128];
341 : : size_t bin_str9_size;
342 : : libspdm_secured_message_context_t *secured_message_context;
343 : :
344 : 107 : secured_message_context = spdm_secured_message_context;
345 : :
346 : 107 : hash_size = secured_message_context->hash_size;
347 : :
348 : 107 : bin_str9_size = sizeof(bin_str9);
349 : 107 : libspdm_bin_concat(secured_message_context->version,
350 : : SPDM_BIN_STR_9_LABEL, sizeof(SPDM_BIN_STR_9_LABEL) - 1,
351 : 107 : NULL, (uint16_t)hash_size, hash_size, bin_str9,
352 : : &bin_str9_size);
353 : :
354 : 107 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "bin_str9 (0x%zx):\n", bin_str9_size));
355 : 107 : LIBSPDM_INTERNAL_DUMP_HEX(bin_str9, bin_str9_size);
356 : :
357 [ + + ]: 107 : if (action == LIBSPDM_KEY_UPDATE_ACTION_REQUESTER) {
358 : 41 : libspdm_copy_mem(&secured_message_context->application_secret_backup
359 : : .request_data_secret,
360 : : sizeof(secured_message_context->application_secret_backup
361 : : .request_data_secret),
362 : 41 : &secured_message_context->application_secret
363 : : .request_data_secret,
364 : : LIBSPDM_MAX_HASH_SIZE);
365 : 41 : libspdm_copy_mem(&secured_message_context->application_secret_backup
366 : : .request_data_encryption_key,
367 : : sizeof(secured_message_context->application_secret_backup
368 : : .request_data_encryption_key),
369 : 41 : &secured_message_context->application_secret
370 : : .request_data_encryption_key,
371 : : LIBSPDM_MAX_AEAD_KEY_SIZE);
372 : 41 : libspdm_copy_mem(&secured_message_context->application_secret_backup
373 : : .request_data_salt,
374 : : sizeof(secured_message_context->application_secret_backup
375 : : .request_data_salt),
376 : 41 : &secured_message_context->application_secret
377 : : .request_data_salt,
378 : : LIBSPDM_MAX_AEAD_IV_SIZE);
379 : : secured_message_context->application_secret_backup
380 : 41 : .request_data_sequence_number =
381 : 41 : secured_message_context->application_secret.request_data_sequence_number;
382 : :
383 : 41 : status = libspdm_hkdf_expand(
384 : : secured_message_context->base_hash_algo,
385 : 41 : secured_message_context->application_secret.request_data_secret,
386 : : hash_size, bin_str9, bin_str9_size,
387 : 41 : secured_message_context->application_secret.request_data_secret,
388 : : hash_size);
389 [ - + ]: 41 : if (!status) {
390 : 0 : return false;
391 : : }
392 : 41 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "RequestDataSecretUpdate (0x%zx) - ", hash_size));
393 : 41 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->application_secret.request_data_secret,
394 : : hash_size);
395 : 41 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
396 : :
397 : 41 : status = libspdm_generate_aead_key_and_iv(
398 : : secured_message_context,
399 : 41 : secured_message_context->application_secret.request_data_secret,
400 : 41 : secured_message_context->application_secret.request_data_encryption_key,
401 : 41 : secured_message_context->application_secret.request_data_salt);
402 [ - + ]: 41 : if (!status) {
403 : 0 : return status;
404 : : }
405 : 41 : secured_message_context->application_secret.request_data_sequence_number = 0;
406 : :
407 : 41 : secured_message_context->requester_backup_valid = true;
408 [ + - ]: 66 : } else if (action == LIBSPDM_KEY_UPDATE_ACTION_RESPONDER) {
409 : 66 : libspdm_copy_mem(&secured_message_context->application_secret_backup
410 : : .response_data_secret,
411 : : sizeof(secured_message_context->application_secret_backup
412 : : .response_data_secret),
413 : 66 : &secured_message_context->application_secret
414 : : .response_data_secret,
415 : : LIBSPDM_MAX_HASH_SIZE);
416 : 66 : libspdm_copy_mem(&secured_message_context->application_secret_backup
417 : : .response_data_encryption_key,
418 : : sizeof(secured_message_context->application_secret_backup
419 : : .response_data_encryption_key),
420 : 66 : &secured_message_context->application_secret
421 : : .response_data_encryption_key,
422 : : LIBSPDM_MAX_AEAD_KEY_SIZE);
423 : 66 : libspdm_copy_mem(&secured_message_context->application_secret_backup
424 : : .response_data_salt,
425 : : sizeof(secured_message_context->application_secret_backup
426 : : .response_data_salt),
427 : 66 : &secured_message_context->application_secret
428 : : .response_data_salt,
429 : : LIBSPDM_MAX_AEAD_IV_SIZE);
430 : : secured_message_context->application_secret_backup
431 : 66 : .response_data_sequence_number =
432 : 66 : secured_message_context->application_secret.response_data_sequence_number;
433 : :
434 : 66 : status = libspdm_hkdf_expand(
435 : : secured_message_context->base_hash_algo,
436 : 66 : secured_message_context->application_secret.response_data_secret,
437 : : hash_size, bin_str9, bin_str9_size,
438 : 66 : secured_message_context->application_secret.response_data_secret,
439 : : hash_size);
440 [ - + ]: 66 : if (!status) {
441 : 0 : return false;
442 : : }
443 : 66 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "ResponseDataSecretUpdate (0x%zx) - ",
444 : : hash_size));
445 : 66 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->application_secret.response_data_secret,
446 : : hash_size);
447 : 66 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
448 : :
449 : 66 : status = libspdm_generate_aead_key_and_iv(
450 : : secured_message_context,
451 : 66 : secured_message_context->application_secret.response_data_secret,
452 : 66 : secured_message_context->application_secret.response_data_encryption_key,
453 : 66 : secured_message_context->application_secret.response_data_salt);
454 [ - + ]: 66 : if (!status) {
455 : 0 : return status;
456 : : }
457 : 66 : secured_message_context->application_secret.response_data_sequence_number = 0;
458 : :
459 : 66 : secured_message_context->responder_backup_valid = true;
460 : : } else {
461 : 0 : return false;
462 : : }
463 : :
464 : 107 : return true;
465 : : }
466 : :
467 : 369 : void libspdm_clear_handshake_secret(void *spdm_secured_message_context)
468 : : {
469 : : libspdm_secured_message_context_t *secured_message_context;
470 : :
471 : 369 : secured_message_context = spdm_secured_message_context;
472 : :
473 : 369 : libspdm_zero_mem(secured_message_context->master_secret.handshake_secret,
474 : : LIBSPDM_MAX_HASH_SIZE);
475 : 369 : libspdm_zero_mem(&(secured_message_context->handshake_secret),
476 : : sizeof(libspdm_session_info_struct_handshake_secret_t));
477 : :
478 : 369 : secured_message_context->requester_backup_valid = false;
479 : 369 : secured_message_context->responder_backup_valid = false;
480 : 369 : }
481 : :
482 : 369 : void libspdm_clear_master_secret(void *spdm_secured_message_context)
483 : : {
484 : : libspdm_secured_message_context_t *secured_message_context;
485 : :
486 : 369 : secured_message_context = spdm_secured_message_context;
487 : :
488 : 369 : libspdm_zero_mem(secured_message_context->master_secret.master_secret, LIBSPDM_MAX_HASH_SIZE);
489 : 369 : }
490 : :
491 : 97 : bool libspdm_activate_update_session_data_key(void *spdm_secured_message_context,
492 : : libspdm_key_update_action_t action,
493 : : bool use_new_key)
494 : : {
495 : : libspdm_secured_message_context_t *secured_message_context;
496 : :
497 : 97 : secured_message_context = spdm_secured_message_context;
498 : :
499 [ + + ]: 97 : if (!use_new_key) {
500 [ - + ]: 53 : if ((action == LIBSPDM_KEY_UPDATE_ACTION_REQUESTER) &&
501 [ # # ]: 0 : secured_message_context->requester_backup_valid) {
502 : 0 : libspdm_copy_mem(&secured_message_context->application_secret
503 : : .request_data_secret,
504 : : sizeof(secured_message_context->application_secret
505 : : .request_data_secret),
506 : 0 : &secured_message_context
507 : : ->application_secret_backup
508 : : .request_data_secret,
509 : : LIBSPDM_MAX_HASH_SIZE);
510 : 0 : libspdm_copy_mem(&secured_message_context->application_secret
511 : : .request_data_encryption_key,
512 : : sizeof(secured_message_context->application_secret
513 : : .request_data_encryption_key),
514 : 0 : &secured_message_context
515 : : ->application_secret_backup
516 : : .request_data_encryption_key,
517 : : LIBSPDM_MAX_AEAD_KEY_SIZE);
518 : 0 : libspdm_copy_mem(&secured_message_context->application_secret
519 : : .request_data_salt,
520 : : sizeof(secured_message_context->application_secret
521 : : .request_data_salt),
522 : 0 : &secured_message_context
523 : : ->application_secret_backup
524 : : .request_data_salt,
525 : : LIBSPDM_MAX_AEAD_IV_SIZE);
526 : : secured_message_context->application_secret
527 : 0 : .request_data_sequence_number =
528 : 0 : secured_message_context->application_secret_backup.request_data_sequence_number;
529 [ + - ]: 53 : } else if ((action == LIBSPDM_KEY_UPDATE_ACTION_RESPONDER) &&
530 [ + - ]: 53 : secured_message_context->responder_backup_valid) {
531 : 53 : libspdm_copy_mem(&secured_message_context->application_secret
532 : : .response_data_secret,
533 : : sizeof(secured_message_context->application_secret
534 : : .response_data_secret),
535 : 53 : &secured_message_context
536 : : ->application_secret_backup
537 : : .response_data_secret,
538 : : LIBSPDM_MAX_HASH_SIZE);
539 : 53 : libspdm_copy_mem(&secured_message_context->application_secret
540 : : .response_data_encryption_key,
541 : : sizeof(secured_message_context->application_secret
542 : : .response_data_encryption_key),
543 : 53 : &secured_message_context
544 : : ->application_secret_backup
545 : : .response_data_encryption_key,
546 : : LIBSPDM_MAX_AEAD_KEY_SIZE);
547 : 53 : libspdm_copy_mem(&secured_message_context->application_secret
548 : : .response_data_salt,
549 : : sizeof(secured_message_context->application_secret
550 : : .response_data_salt),
551 : 53 : &secured_message_context
552 : : ->application_secret_backup
553 : : .response_data_salt,
554 : : LIBSPDM_MAX_AEAD_IV_SIZE);
555 : 53 : secured_message_context->application_secret.response_data_sequence_number =
556 : 53 : secured_message_context->application_secret_backup.response_data_sequence_number;
557 : : }
558 : : }
559 : :
560 [ + + ]: 97 : if (action == LIBSPDM_KEY_UPDATE_ACTION_REQUESTER) {
561 : 36 : libspdm_zero_mem(&secured_message_context->application_secret_backup.request_data_secret,
562 : : LIBSPDM_MAX_HASH_SIZE);
563 : 36 : libspdm_zero_mem(&secured_message_context->application_secret_backup
564 : : .request_data_encryption_key,
565 : : LIBSPDM_MAX_AEAD_KEY_SIZE);
566 : 36 : libspdm_zero_mem(&secured_message_context->application_secret_backup.request_data_salt,
567 : : LIBSPDM_MAX_AEAD_IV_SIZE);
568 : 36 : secured_message_context->application_secret_backup.request_data_sequence_number = 0;
569 : 36 : secured_message_context->requester_backup_valid = false;
570 [ + - ]: 61 : } else if (action == LIBSPDM_KEY_UPDATE_ACTION_RESPONDER) {
571 : 61 : libspdm_zero_mem(&secured_message_context->application_secret_backup.response_data_secret,
572 : : LIBSPDM_MAX_HASH_SIZE);
573 : 61 : libspdm_zero_mem(&secured_message_context->application_secret_backup
574 : : .response_data_encryption_key,
575 : : LIBSPDM_MAX_AEAD_KEY_SIZE);
576 : 61 : libspdm_zero_mem(&secured_message_context->application_secret_backup.response_data_salt,
577 : : LIBSPDM_MAX_AEAD_IV_SIZE);
578 : 61 : secured_message_context->application_secret_backup.response_data_sequence_number = 0;
579 : 61 : secured_message_context->responder_backup_valid = false;
580 : : }
581 : :
582 : 97 : return true;
583 : : }
584 : :
585 : 0 : void *libspdm_hmac_new_with_request_finished_key(void *spdm_secured_message_context)
586 : : {
587 : : libspdm_secured_message_context_t *secured_message_context;
588 : :
589 : 0 : secured_message_context = spdm_secured_message_context;
590 : 0 : return libspdm_hmac_new(secured_message_context->base_hash_algo);
591 : : }
592 : :
593 : 0 : void libspdm_hmac_free_with_request_finished_key(
594 : : void *spdm_secured_message_context, void *hmac_ctx)
595 : : {
596 : : libspdm_secured_message_context_t *secured_message_context;
597 : :
598 : 0 : secured_message_context = spdm_secured_message_context;
599 : 0 : libspdm_hmac_free(secured_message_context->base_hash_algo, hmac_ctx);
600 : 0 : }
601 : :
602 : 0 : bool libspdm_hmac_init_with_request_finished_key(
603 : : void *spdm_secured_message_context, void *hmac_ctx)
604 : : {
605 : : libspdm_secured_message_context_t *secured_message_context;
606 : :
607 : 0 : secured_message_context = spdm_secured_message_context;
608 : 0 : return libspdm_hmac_init(
609 : : secured_message_context->base_hash_algo, hmac_ctx,
610 : 0 : secured_message_context->handshake_secret.request_finished_key,
611 : : secured_message_context->hash_size);
612 : : }
613 : :
614 : 0 : bool libspdm_hmac_update_with_request_finished_key(
615 : : void *spdm_secured_message_context,
616 : : void *hmac_ctx, const void *data,
617 : : size_t data_size)
618 : : {
619 : : libspdm_secured_message_context_t *secured_message_context;
620 : :
621 : 0 : secured_message_context = spdm_secured_message_context;
622 : 0 : return libspdm_hmac_update(secured_message_context->base_hash_algo, hmac_ctx, data, data_size);
623 : : }
624 : :
625 : 0 : bool libspdm_hmac_final_with_request_finished_key(
626 : : void *spdm_secured_message_context,
627 : : void *hmac_ctx, uint8_t *hmac_value)
628 : : {
629 : : libspdm_secured_message_context_t *secured_message_context;
630 : :
631 : 0 : secured_message_context = spdm_secured_message_context;
632 : 0 : return libspdm_hmac_final(secured_message_context->base_hash_algo, hmac_ctx, hmac_value);
633 : : }
634 : :
635 : 113 : bool libspdm_hmac_all_with_request_finished_key(void *spdm_secured_message_context,
636 : : const void *data, size_t data_size,
637 : : uint8_t *hmac_value)
638 : : {
639 : : libspdm_secured_message_context_t *secured_message_context;
640 : :
641 : 113 : secured_message_context = spdm_secured_message_context;
642 : 226 : return libspdm_hmac_all(
643 : : secured_message_context->base_hash_algo, data, data_size,
644 : 113 : secured_message_context->handshake_secret.request_finished_key,
645 : : secured_message_context->hash_size, hmac_value);
646 : : }
647 : :
648 : 0 : void *libspdm_hmac_new_with_response_finished_key(void *spdm_secured_message_context)
649 : : {
650 : : libspdm_secured_message_context_t *secured_message_context;
651 : :
652 : 0 : secured_message_context = spdm_secured_message_context;
653 : 0 : return libspdm_hmac_new(secured_message_context->base_hash_algo);
654 : : }
655 : :
656 : 0 : void libspdm_hmac_free_with_response_finished_key(
657 : : void *spdm_secured_message_context, void *hmac_ctx)
658 : : {
659 : : libspdm_secured_message_context_t *secured_message_context;
660 : :
661 : 0 : secured_message_context = spdm_secured_message_context;
662 : 0 : libspdm_hmac_free(secured_message_context->base_hash_algo, hmac_ctx);
663 : 0 : }
664 : :
665 : 0 : bool libspdm_hmac_init_with_response_finished_key(
666 : : void *spdm_secured_message_context, void *hmac_ctx)
667 : : {
668 : : libspdm_secured_message_context_t *secured_message_context;
669 : :
670 : 0 : secured_message_context = spdm_secured_message_context;
671 : 0 : return libspdm_hmac_init(
672 : : secured_message_context->base_hash_algo, hmac_ctx,
673 : 0 : secured_message_context->handshake_secret.response_finished_key,
674 : : secured_message_context->hash_size);
675 : : }
676 : :
677 : 0 : bool libspdm_hmac_update_with_response_finished_key(
678 : : void *spdm_secured_message_context,
679 : : void *hmac_ctx, const void *data,
680 : : size_t data_size)
681 : : {
682 : : libspdm_secured_message_context_t *secured_message_context;
683 : :
684 : 0 : secured_message_context = spdm_secured_message_context;
685 : 0 : return libspdm_hmac_update(secured_message_context->base_hash_algo, hmac_ctx, data, data_size);
686 : : }
687 : :
688 : 0 : bool libspdm_hmac_final_with_response_finished_key(
689 : : void *spdm_secured_message_context,
690 : : void *hmac_ctx, uint8_t *hmac_value)
691 : : {
692 : : libspdm_secured_message_context_t *secured_message_context;
693 : :
694 : 0 : secured_message_context = spdm_secured_message_context;
695 : 0 : return libspdm_hmac_final(secured_message_context->base_hash_algo, hmac_ctx, hmac_value);
696 : : }
697 : :
698 : 97 : bool libspdm_hmac_all_with_response_finished_key(
699 : : void *spdm_secured_message_context, const void *data,
700 : : size_t data_size, uint8_t *hmac_value)
701 : : {
702 : : libspdm_secured_message_context_t *secured_message_context;
703 : :
704 : 97 : secured_message_context = spdm_secured_message_context;
705 : 194 : return libspdm_hmac_all(
706 : : secured_message_context->base_hash_algo, data, data_size,
707 : 97 : secured_message_context->handshake_secret.response_finished_key,
708 : : secured_message_context->hash_size, hmac_value);
709 : : }
|
