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 290 : 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 290 : hash_size = secured_message_context->hash_size;
23 290 : key_length = secured_message_context->aead_key_size;
24 290 : iv_length = secured_message_context->aead_iv_size;
25 :
26 290 : bin_str5_size = sizeof(bin_str5);
27 290 : libspdm_bin_concat(secured_message_context->version,
28 : SPDM_BIN_STR_5_LABEL, sizeof(SPDM_BIN_STR_5_LABEL) - 1,
29 290 : NULL, (uint16_t)key_length, hash_size, bin_str5,
30 : &bin_str5_size);
31 :
32 290 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "bin_str5 (0x%zx):\n", bin_str5_size));
33 290 : LIBSPDM_INTERNAL_DUMP_HEX(bin_str5, bin_str5_size);
34 290 : 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 290 : if (!status) {
38 0 : return false;
39 : }
40 290 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "key (0x%zx) - ", key_length));
41 290 : LIBSPDM_INTERNAL_DUMP_DATA(key, key_length);
42 290 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
43 :
44 290 : bin_str6_size = sizeof(bin_str6);
45 290 : libspdm_bin_concat(secured_message_context->version,
46 : SPDM_BIN_STR_6_LABEL, sizeof(SPDM_BIN_STR_6_LABEL) - 1,
47 290 : NULL, (uint16_t)iv_length, hash_size, bin_str6,
48 : &bin_str6_size);
49 :
50 290 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "bin_str6 (0x%zx):\n", bin_str6_size));
51 290 : LIBSPDM_INTERNAL_DUMP_HEX(bin_str6, bin_str6_size);
52 290 : 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 290 : if (!status) {
56 0 : return false;
57 : }
58 290 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "iv (0x%zx) - ", iv_length));
59 290 : LIBSPDM_INTERNAL_DUMP_DATA(iv, iv_length);
60 290 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
61 :
62 290 : return true;
63 : }
64 :
65 116 : 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 116 : hash_size = secured_message_context->hash_size;
75 :
76 116 : bin_str7_size = sizeof(bin_str7);
77 116 : libspdm_bin_concat(secured_message_context->version,
78 : SPDM_BIN_STR_7_LABEL, sizeof(SPDM_BIN_STR_7_LABEL) - 1,
79 116 : NULL, (uint16_t)hash_size, hash_size, bin_str7,
80 : &bin_str7_size);
81 :
82 116 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "bin_str7 (0x%zx):\n", bin_str7_size));
83 116 : LIBSPDM_INTERNAL_DUMP_HEX(bin_str7, bin_str7_size);
84 116 : 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 116 : if (!status) {
88 0 : return false;
89 : }
90 116 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "finished_key (0x%zx) - ", hash_size));
91 116 : LIBSPDM_INTERNAL_DUMP_DATA(finished_key, hash_size);
92 116 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
93 :
94 116 : return true;
95 : }
96 :
97 58 : 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 58 : secured_message_context = spdm_secured_message_context;
108 :
109 58 : hash_size = secured_message_context->hash_size;
110 58 : handshake_secret_size = hash_size;
111 58 : request_handshake_secret_size = hash_size;
112 58 : response_handshake_secret_size = hash_size;
113 :
114 : #if LIBSPDM_ENABLE_CAPABILITY_PSK_CAP
115 58 : if (secured_message_context->use_psk) {
116 27 : status = libspdm_generate_handshake_key (
117 27 : secured_message_context->version,
118 : NULL,
119 : 0,
120 : false,
121 27 : secured_message_context->psk_hint,
122 : secured_message_context->psk_hint_size,
123 27 : secured_message_context->use_psk,
124 : secured_message_context->base_hash_algo,
125 : th1_hash_data,
126 27 : secured_message_context->master_secret.handshake_secret,
127 : &handshake_secret_size,
128 27 : secured_message_context->handshake_secret.request_handshake_secret,
129 : &request_handshake_secret_size,
130 27 : secured_message_context->handshake_secret.response_handshake_secret,
131 : &response_handshake_secret_size);
132 :
133 27 : if (!status) {
134 0 : return status;
135 : }
136 : }
137 : #endif /* LIBSPDM_ENABLE_CAPABILITY_PSK_CAP */
138 58 : if (!(secured_message_context->use_psk)) {
139 31 : if (secured_message_context->kem_alg != 0) {
140 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "[KEM Secret]: "));
141 : } else {
142 31 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "[DHE Secret]: "));
143 : }
144 31 : LIBSPDM_INTERNAL_DUMP_HEX_STR(
145 : secured_message_context->master_secret.shared_secret,
146 : secured_message_context->shared_key_size);
147 31 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
148 :
149 31 : status = libspdm_generate_handshake_key (
150 31 : secured_message_context->version,
151 31 : secured_message_context->master_secret.shared_secret,
152 : secured_message_context->shared_key_size,
153 : false,
154 : NULL,
155 : 0,
156 31 : secured_message_context->use_psk,
157 : secured_message_context->base_hash_algo,
158 : th1_hash_data,
159 31 : secured_message_context->master_secret.handshake_secret,
160 : &handshake_secret_size,
161 31 : secured_message_context->handshake_secret.request_handshake_secret,
162 : &request_handshake_secret_size,
163 31 : secured_message_context->handshake_secret.response_handshake_secret,
164 : &response_handshake_secret_size);
165 :
166 31 : if (!status) {
167 0 : return status;
168 : }
169 :
170 31 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "handshake_secret (0x%zx) - ", hash_size));
171 31 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->master_secret.handshake_secret, hash_size);
172 31 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
173 :
174 31 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "request_handshake_secret (0x%zx) - ", hash_size));
175 31 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->handshake_secret.request_handshake_secret, hash_size);
176 31 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
177 :
178 31 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "response_handshake_secret (0x%zx) - ", hash_size));
179 31 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->handshake_secret.response_handshake_secret, hash_size);
180 31 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
181 : }
182 :
183 58 : status = libspdm_generate_finished_key(
184 : secured_message_context,
185 : secured_message_context->handshake_secret
186 58 : .request_handshake_secret,
187 58 : secured_message_context->handshake_secret.request_finished_key);
188 58 : if (!status) {
189 0 : return status;
190 : }
191 :
192 58 : status = libspdm_generate_finished_key(
193 : secured_message_context,
194 58 : secured_message_context->handshake_secret.response_handshake_secret,
195 58 : secured_message_context->handshake_secret.response_finished_key);
196 58 : if (!status) {
197 0 : return status;
198 : }
199 :
200 58 : status = libspdm_generate_aead_key_and_iv(secured_message_context,
201 : secured_message_context->handshake_secret
202 58 : .request_handshake_secret,
203 : secured_message_context->handshake_secret
204 58 : .request_handshake_encryption_key,
205 : secured_message_context->handshake_secret
206 58 : .request_handshake_salt);
207 58 : if (!status) {
208 0 : return status;
209 : }
210 58 : secured_message_context->handshake_secret.request_handshake_sequence_number = 0;
211 :
212 58 : status = libspdm_generate_aead_key_and_iv(
213 : secured_message_context,
214 58 : secured_message_context->handshake_secret.response_handshake_secret,
215 58 : secured_message_context->handshake_secret.response_handshake_encryption_key,
216 58 : secured_message_context->handshake_secret.response_handshake_salt);
217 58 : if (!status) {
218 0 : return status;
219 : }
220 :
221 58 : secured_message_context->handshake_secret.response_handshake_sequence_number = 0;
222 58 : libspdm_zero_mem(secured_message_context->master_secret.shared_secret, LIBSPDM_MAX_SHARED_KEY_SIZE);
223 :
224 58 : return true;
225 : }
226 :
227 36 : 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 36 : secured_message_context = spdm_secured_message_context;
240 :
241 36 : hash_size = secured_message_context->hash_size;
242 36 : master_secret_size = hash_size;
243 36 : request_data_secret_size = hash_size;
244 36 : response_data_secret_size = hash_size;
245 36 : export_master_secret_size = hash_size;
246 :
247 : #if LIBSPDM_ENABLE_CAPABILITY_PSK_CAP
248 36 : if (secured_message_context->use_psk) {
249 13 : status = libspdm_generate_data_key(
250 13 : secured_message_context->version,
251 : NULL,
252 : 0,
253 13 : secured_message_context->psk_hint,
254 : secured_message_context->psk_hint_size,
255 13 : secured_message_context->use_psk,
256 : secured_message_context->base_hash_algo,
257 : th2_hash_data,
258 13 : secured_message_context->master_secret.master_secret,
259 : &master_secret_size,
260 13 : secured_message_context->application_secret.request_data_secret,
261 : &request_data_secret_size,
262 13 : secured_message_context->application_secret.response_data_secret,
263 : &response_data_secret_size,
264 13 : secured_message_context->export_master_secret,
265 : &export_master_secret_size);
266 :
267 13 : if (!status) {
268 0 : return status;
269 : }
270 : }
271 : #endif /* LIBSPDM_ENABLE_CAPABILITY_PSK_CAP */
272 36 : if (!(secured_message_context->use_psk)) {
273 23 : status = libspdm_generate_data_key(
274 23 : secured_message_context->version,
275 23 : secured_message_context->master_secret.handshake_secret,
276 : hash_size,
277 : NULL,
278 : 0,
279 23 : secured_message_context->use_psk,
280 : secured_message_context->base_hash_algo,
281 : th2_hash_data,
282 23 : secured_message_context->master_secret.master_secret,
283 : &master_secret_size,
284 23 : secured_message_context->application_secret.request_data_secret,
285 : &request_data_secret_size,
286 23 : secured_message_context->application_secret.response_data_secret,
287 : &response_data_secret_size,
288 23 : secured_message_context->export_master_secret,
289 : &export_master_secret_size);
290 :
291 23 : if (!status) {
292 0 : return status;
293 : }
294 :
295 23 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "master_secret (0x%zx) - ", hash_size));
296 23 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->master_secret.master_secret, hash_size);
297 23 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
298 :
299 23 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "request_data_secret (0x%zx) - ", hash_size));
300 23 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->application_secret.request_data_secret, hash_size);
301 23 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
302 :
303 23 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "response_data_secret (0x%zx) - ", hash_size));
304 23 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->application_secret.response_data_secret, hash_size);
305 23 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
306 :
307 23 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "export_master_secret (0x%zx) - ", hash_size));
308 23 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->export_master_secret, hash_size);
309 23 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
310 : }
311 :
312 36 : status = libspdm_generate_aead_key_and_iv(
313 : secured_message_context,
314 36 : secured_message_context->application_secret.request_data_secret,
315 36 : secured_message_context->application_secret.request_data_encryption_key,
316 36 : secured_message_context->application_secret.request_data_salt);
317 36 : if (!status) {
318 0 : return status;
319 : }
320 36 : secured_message_context->application_secret.request_data_sequence_number = 0;
321 :
322 36 : status = libspdm_generate_aead_key_and_iv(
323 : secured_message_context,
324 36 : secured_message_context->application_secret.response_data_secret,
325 36 : secured_message_context->application_secret.response_data_encryption_key,
326 36 : secured_message_context->application_secret.response_data_salt);
327 36 : if (!status) {
328 0 : return status;
329 : }
330 36 : secured_message_context->application_secret.response_data_sequence_number = 0;
331 :
332 36 : return true;
333 : }
334 :
335 102 : 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 102 : secured_message_context = spdm_secured_message_context;
345 :
346 102 : hash_size = secured_message_context->hash_size;
347 :
348 102 : bin_str9_size = sizeof(bin_str9);
349 102 : libspdm_bin_concat(secured_message_context->version,
350 : SPDM_BIN_STR_9_LABEL, sizeof(SPDM_BIN_STR_9_LABEL) - 1,
351 102 : NULL, (uint16_t)hash_size, hash_size, bin_str9,
352 : &bin_str9_size);
353 :
354 102 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "bin_str9 (0x%zx):\n", bin_str9_size));
355 102 : LIBSPDM_INTERNAL_DUMP_HEX(bin_str9, bin_str9_size);
356 :
357 102 : if (action == LIBSPDM_KEY_UPDATE_ACTION_REQUESTER) {
358 40 : 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 40 : &secured_message_context->application_secret
363 : .request_data_secret,
364 : LIBSPDM_MAX_HASH_SIZE);
365 40 : 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 40 : &secured_message_context->application_secret
370 : .request_data_encryption_key,
371 : LIBSPDM_MAX_AEAD_KEY_SIZE);
372 40 : 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 40 : &secured_message_context->application_secret
377 : .request_data_salt,
378 : LIBSPDM_MAX_AEAD_IV_SIZE);
379 : secured_message_context->application_secret_backup
380 40 : .request_data_sequence_number =
381 40 : secured_message_context->application_secret.request_data_sequence_number;
382 :
383 40 : status = libspdm_hkdf_expand(
384 : secured_message_context->base_hash_algo,
385 40 : secured_message_context->application_secret.request_data_secret,
386 : hash_size, bin_str9, bin_str9_size,
387 40 : secured_message_context->application_secret.request_data_secret,
388 : hash_size);
389 40 : if (!status) {
390 0 : return false;
391 : }
392 40 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "RequestDataSecretUpdate (0x%zx) - ", hash_size));
393 40 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->application_secret.request_data_secret,
394 : hash_size);
395 40 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
396 :
397 40 : status = libspdm_generate_aead_key_and_iv(
398 : secured_message_context,
399 40 : secured_message_context->application_secret.request_data_secret,
400 40 : secured_message_context->application_secret.request_data_encryption_key,
401 40 : secured_message_context->application_secret.request_data_salt);
402 40 : if (!status) {
403 0 : return status;
404 : }
405 40 : secured_message_context->application_secret.request_data_sequence_number = 0;
406 :
407 40 : secured_message_context->requester_backup_valid = true;
408 62 : } else if (action == LIBSPDM_KEY_UPDATE_ACTION_RESPONDER) {
409 62 : 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 62 : &secured_message_context->application_secret
414 : .response_data_secret,
415 : LIBSPDM_MAX_HASH_SIZE);
416 62 : 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 62 : &secured_message_context->application_secret
421 : .response_data_encryption_key,
422 : LIBSPDM_MAX_AEAD_KEY_SIZE);
423 62 : 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 62 : &secured_message_context->application_secret
428 : .response_data_salt,
429 : LIBSPDM_MAX_AEAD_IV_SIZE);
430 : secured_message_context->application_secret_backup
431 62 : .response_data_sequence_number =
432 62 : secured_message_context->application_secret.response_data_sequence_number;
433 :
434 62 : status = libspdm_hkdf_expand(
435 : secured_message_context->base_hash_algo,
436 62 : secured_message_context->application_secret.response_data_secret,
437 : hash_size, bin_str9, bin_str9_size,
438 62 : secured_message_context->application_secret.response_data_secret,
439 : hash_size);
440 62 : if (!status) {
441 0 : return false;
442 : }
443 62 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "ResponseDataSecretUpdate (0x%zx) - ",
444 : hash_size));
445 62 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->application_secret.response_data_secret,
446 : hash_size);
447 62 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
448 :
449 62 : status = libspdm_generate_aead_key_and_iv(
450 : secured_message_context,
451 62 : secured_message_context->application_secret.response_data_secret,
452 62 : secured_message_context->application_secret.response_data_encryption_key,
453 62 : secured_message_context->application_secret.response_data_salt);
454 62 : if (!status) {
455 0 : return status;
456 : }
457 62 : secured_message_context->application_secret.response_data_sequence_number = 0;
458 :
459 62 : secured_message_context->responder_backup_valid = true;
460 : } else {
461 0 : return false;
462 : }
463 :
464 102 : return true;
465 : }
466 :
467 264 : void libspdm_clear_handshake_secret(void *spdm_secured_message_context)
468 : {
469 : libspdm_secured_message_context_t *secured_message_context;
470 :
471 264 : secured_message_context = spdm_secured_message_context;
472 :
473 264 : libspdm_zero_mem(secured_message_context->master_secret.handshake_secret,
474 : LIBSPDM_MAX_HASH_SIZE);
475 264 : libspdm_zero_mem(&(secured_message_context->handshake_secret),
476 : sizeof(libspdm_session_info_struct_handshake_secret_t));
477 :
478 264 : secured_message_context->requester_backup_valid = false;
479 264 : secured_message_context->responder_backup_valid = false;
480 264 : }
481 :
482 264 : void libspdm_clear_master_secret(void *spdm_secured_message_context)
483 : {
484 : libspdm_secured_message_context_t *secured_message_context;
485 :
486 264 : secured_message_context = spdm_secured_message_context;
487 :
488 264 : libspdm_zero_mem(secured_message_context->master_secret.master_secret, LIBSPDM_MAX_HASH_SIZE);
489 264 : }
490 :
491 93 : 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 93 : secured_message_context = spdm_secured_message_context;
498 :
499 93 : if (!use_new_key) {
500 52 : 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 52 : } else if ((action == LIBSPDM_KEY_UPDATE_ACTION_RESPONDER) &&
530 52 : secured_message_context->responder_backup_valid) {
531 52 : libspdm_copy_mem(&secured_message_context->application_secret
532 : .response_data_secret,
533 : sizeof(secured_message_context->application_secret
534 : .response_data_secret),
535 52 : &secured_message_context
536 : ->application_secret_backup
537 : .response_data_secret,
538 : LIBSPDM_MAX_HASH_SIZE);
539 52 : 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 52 : &secured_message_context
544 : ->application_secret_backup
545 : .response_data_encryption_key,
546 : LIBSPDM_MAX_AEAD_KEY_SIZE);
547 52 : libspdm_copy_mem(&secured_message_context->application_secret
548 : .response_data_salt,
549 : sizeof(secured_message_context->application_secret
550 : .response_data_salt),
551 52 : &secured_message_context
552 : ->application_secret_backup
553 : .response_data_salt,
554 : LIBSPDM_MAX_AEAD_IV_SIZE);
555 52 : secured_message_context->application_secret.response_data_sequence_number =
556 52 : secured_message_context->application_secret_backup.response_data_sequence_number;
557 : }
558 : }
559 :
560 93 : if (action == LIBSPDM_KEY_UPDATE_ACTION_REQUESTER) {
561 35 : libspdm_zero_mem(&secured_message_context->application_secret_backup.request_data_secret,
562 : LIBSPDM_MAX_HASH_SIZE);
563 35 : libspdm_zero_mem(&secured_message_context->application_secret_backup
564 : .request_data_encryption_key,
565 : LIBSPDM_MAX_AEAD_KEY_SIZE);
566 35 : libspdm_zero_mem(&secured_message_context->application_secret_backup.request_data_salt,
567 : LIBSPDM_MAX_AEAD_IV_SIZE);
568 35 : secured_message_context->application_secret_backup.request_data_sequence_number = 0;
569 35 : secured_message_context->requester_backup_valid = false;
570 58 : } else if (action == LIBSPDM_KEY_UPDATE_ACTION_RESPONDER) {
571 58 : libspdm_zero_mem(&secured_message_context->application_secret_backup.response_data_secret,
572 : LIBSPDM_MAX_HASH_SIZE);
573 58 : libspdm_zero_mem(&secured_message_context->application_secret_backup
574 : .response_data_encryption_key,
575 : LIBSPDM_MAX_AEAD_KEY_SIZE);
576 58 : libspdm_zero_mem(&secured_message_context->application_secret_backup.response_data_salt,
577 : LIBSPDM_MAX_AEAD_IV_SIZE);
578 58 : secured_message_context->application_secret_backup.response_data_sequence_number = 0;
579 58 : secured_message_context->responder_backup_valid = false;
580 : }
581 :
582 93 : 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_duplicate_with_request_finished_key(
615 : void *spdm_secured_message_context,
616 : const void *hmac_ctx, void *new_hmac_ctx)
617 : {
618 : libspdm_secured_message_context_t *secured_message_context;
619 :
620 0 : secured_message_context = spdm_secured_message_context;
621 0 : return libspdm_hmac_duplicate(secured_message_context->base_hash_algo, hmac_ctx, new_hmac_ctx);
622 : }
623 :
624 0 : bool libspdm_hmac_update_with_request_finished_key(
625 : void *spdm_secured_message_context,
626 : void *hmac_ctx, const void *data,
627 : size_t data_size)
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_update(secured_message_context->base_hash_algo, hmac_ctx, data, data_size);
633 : }
634 :
635 0 : bool libspdm_hmac_final_with_request_finished_key(
636 : void *spdm_secured_message_context,
637 : void *hmac_ctx, uint8_t *hmac_value)
638 : {
639 : libspdm_secured_message_context_t *secured_message_context;
640 :
641 0 : secured_message_context = spdm_secured_message_context;
642 0 : return libspdm_hmac_final(secured_message_context->base_hash_algo, hmac_ctx, hmac_value);
643 : }
644 :
645 93 : bool libspdm_hmac_all_with_request_finished_key(void *spdm_secured_message_context,
646 : const void *data, size_t data_size,
647 : uint8_t *hmac_value)
648 : {
649 : libspdm_secured_message_context_t *secured_message_context;
650 :
651 93 : secured_message_context = spdm_secured_message_context;
652 186 : return libspdm_hmac_all(
653 : secured_message_context->base_hash_algo, data, data_size,
654 93 : secured_message_context->handshake_secret.request_finished_key,
655 : secured_message_context->hash_size, hmac_value);
656 : }
657 :
658 0 : void *libspdm_hmac_new_with_response_finished_key(void *spdm_secured_message_context)
659 : {
660 : libspdm_secured_message_context_t *secured_message_context;
661 :
662 0 : secured_message_context = spdm_secured_message_context;
663 0 : return libspdm_hmac_new(secured_message_context->base_hash_algo);
664 : }
665 :
666 0 : void libspdm_hmac_free_with_response_finished_key(
667 : void *spdm_secured_message_context, void *hmac_ctx)
668 : {
669 : libspdm_secured_message_context_t *secured_message_context;
670 :
671 0 : secured_message_context = spdm_secured_message_context;
672 0 : libspdm_hmac_free(secured_message_context->base_hash_algo, hmac_ctx);
673 0 : }
674 :
675 0 : bool libspdm_hmac_init_with_response_finished_key(
676 : void *spdm_secured_message_context, void *hmac_ctx)
677 : {
678 : libspdm_secured_message_context_t *secured_message_context;
679 :
680 0 : secured_message_context = spdm_secured_message_context;
681 0 : return libspdm_hmac_init(
682 : secured_message_context->base_hash_algo, hmac_ctx,
683 0 : secured_message_context->handshake_secret.response_finished_key,
684 : secured_message_context->hash_size);
685 : }
686 :
687 0 : bool libspdm_hmac_duplicate_with_response_finished_key(
688 : void *spdm_secured_message_context,
689 : const void *hmac_ctx, void *new_hmac_ctx)
690 : {
691 : libspdm_secured_message_context_t *secured_message_context;
692 :
693 0 : secured_message_context = spdm_secured_message_context;
694 0 : return libspdm_hmac_duplicate(secured_message_context->base_hash_algo, hmac_ctx, new_hmac_ctx);
695 : }
696 :
697 0 : bool libspdm_hmac_update_with_response_finished_key(
698 : void *spdm_secured_message_context,
699 : void *hmac_ctx, const void *data,
700 : size_t data_size)
701 : {
702 : libspdm_secured_message_context_t *secured_message_context;
703 :
704 0 : secured_message_context = spdm_secured_message_context;
705 0 : return libspdm_hmac_update(secured_message_context->base_hash_algo, hmac_ctx, data, data_size);
706 : }
707 :
708 0 : bool libspdm_hmac_final_with_response_finished_key(
709 : void *spdm_secured_message_context,
710 : void *hmac_ctx, uint8_t *hmac_value)
711 : {
712 : libspdm_secured_message_context_t *secured_message_context;
713 :
714 0 : secured_message_context = spdm_secured_message_context;
715 0 : return libspdm_hmac_final(secured_message_context->base_hash_algo, hmac_ctx, hmac_value);
716 : }
717 :
718 75 : bool libspdm_hmac_all_with_response_finished_key(
719 : void *spdm_secured_message_context, const void *data,
720 : size_t data_size, uint8_t *hmac_value)
721 : {
722 : libspdm_secured_message_context_t *secured_message_context;
723 :
724 75 : secured_message_context = spdm_secured_message_context;
725 150 : return libspdm_hmac_all(
726 : secured_message_context->base_hash_algo, data, data_size,
727 75 : secured_message_context->handshake_secret.response_finished_key,
728 : secured_message_context->hash_size, hmac_value);
729 : }
|
