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 : 812 : 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 : 812 : hash_size = secured_message_context->hash_size;
23 : 812 : key_length = secured_message_context->aead_key_size;
24 : 812 : iv_length = secured_message_context->aead_iv_size;
25 : :
26 : 812 : bin_str5_size = sizeof(bin_str5);
27 : 812 : libspdm_bin_concat(secured_message_context->version,
28 : : SPDM_BIN_STR_5_LABEL, sizeof(SPDM_BIN_STR_5_LABEL) - 1,
29 : 812 : NULL, (uint16_t)key_length, hash_size, bin_str5,
30 : : &bin_str5_size);
31 : :
32 : 812 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "bin_str5 (0x%zx):\n", bin_str5_size));
33 : 812 : LIBSPDM_INTERNAL_DUMP_HEX(bin_str5, bin_str5_size);
34 : 812 : 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 [ + + ]: 812 : if (!status) {
38 : 10 : return false;
39 : : }
40 : 802 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "key (0x%zx) - ", key_length));
41 : 802 : LIBSPDM_INTERNAL_DUMP_DATA(key, key_length);
42 : 802 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
43 : :
44 : 802 : bin_str6_size = sizeof(bin_str6);
45 : 802 : libspdm_bin_concat(secured_message_context->version,
46 : : SPDM_BIN_STR_6_LABEL, sizeof(SPDM_BIN_STR_6_LABEL) - 1,
47 : 802 : NULL, (uint16_t)iv_length, hash_size, bin_str6,
48 : : &bin_str6_size);
49 : :
50 : 802 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "bin_str6 (0x%zx):\n", bin_str6_size));
51 : 802 : LIBSPDM_INTERNAL_DUMP_HEX(bin_str6, bin_str6_size);
52 : 802 : 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 [ - + ]: 802 : if (!status) {
56 : 0 : return false;
57 : : }
58 : 802 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "iv (0x%zx) - ", iv_length));
59 : 802 : LIBSPDM_INTERNAL_DUMP_DATA(iv, iv_length);
60 : 802 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
61 : :
62 : 802 : return true;
63 : : }
64 : :
65 : 360 : 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 : 360 : hash_size = secured_message_context->hash_size;
75 : :
76 : 360 : bin_str7_size = sizeof(bin_str7);
77 : 360 : libspdm_bin_concat(secured_message_context->version,
78 : : SPDM_BIN_STR_7_LABEL, sizeof(SPDM_BIN_STR_7_LABEL) - 1,
79 : 360 : NULL, (uint16_t)hash_size, hash_size, bin_str7,
80 : : &bin_str7_size);
81 : :
82 : 360 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "bin_str7 (0x%zx):\n", bin_str7_size));
83 : 360 : LIBSPDM_INTERNAL_DUMP_HEX(bin_str7, bin_str7_size);
84 : 360 : 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 [ - + ]: 360 : if (!status) {
88 : 0 : return false;
89 : : }
90 : 360 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "finished_key (0x%zx) - ", hash_size));
91 : 360 : LIBSPDM_INTERNAL_DUMP_DATA(finished_key, hash_size);
92 : 360 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
93 : :
94 : 360 : return true;
95 : : }
96 : :
97 : 180 : 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 : 180 : secured_message_context = spdm_secured_message_context;
108 : :
109 : 180 : hash_size = secured_message_context->hash_size;
110 : 180 : handshake_secret_size = hash_size;
111 : 180 : request_handshake_secret_size = hash_size;
112 : 180 : response_handshake_secret_size = hash_size;
113 : :
114 : : #if LIBSPDM_ENABLE_CAPABILITY_PSK_CAP
115 [ + + ]: 180 : if (secured_message_context->use_psk) {
116 : 74 : status = libspdm_generate_handshake_key (
117 : 74 : secured_message_context->version,
118 : : NULL,
119 : : 0,
120 : : false,
121 : 74 : secured_message_context->psk_hint,
122 : : secured_message_context->psk_hint_size,
123 : 74 : secured_message_context->use_psk,
124 : : secured_message_context->base_hash_algo,
125 : : th1_hash_data,
126 : 74 : secured_message_context->master_secret.handshake_secret,
127 : : &handshake_secret_size,
128 : 74 : secured_message_context->handshake_secret.request_handshake_secret,
129 : : &request_handshake_secret_size,
130 : 74 : secured_message_context->handshake_secret.response_handshake_secret,
131 : : &response_handshake_secret_size);
132 : :
133 [ - + ]: 74 : if (!status) {
134 : 0 : return status;
135 : : }
136 : : }
137 : : #endif /* LIBSPDM_ENABLE_CAPABILITY_PSK_CAP */
138 [ + + ]: 180 : if (!(secured_message_context->use_psk)) {
139 [ - + ]: 106 : if (secured_message_context->kem_alg != 0) {
140 : 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "[KEM Secret]: "));
141 : : } else {
142 : 106 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "[DHE Secret]: "));
143 : : }
144 : 106 : LIBSPDM_INTERNAL_DUMP_HEX_STR(
145 : : secured_message_context->master_secret.shared_secret,
146 : : secured_message_context->shared_key_size);
147 : 106 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
148 : :
149 : 106 : status = libspdm_generate_handshake_key (
150 : 106 : secured_message_context->version,
151 : 106 : secured_message_context->master_secret.shared_secret,
152 : : secured_message_context->shared_key_size,
153 : : false,
154 : : NULL,
155 : : 0,
156 : 106 : secured_message_context->use_psk,
157 : : secured_message_context->base_hash_algo,
158 : : th1_hash_data,
159 : 106 : secured_message_context->master_secret.handshake_secret,
160 : : &handshake_secret_size,
161 : 106 : secured_message_context->handshake_secret.request_handshake_secret,
162 : : &request_handshake_secret_size,
163 : 106 : secured_message_context->handshake_secret.response_handshake_secret,
164 : : &response_handshake_secret_size);
165 : :
166 [ - + ]: 106 : if (!status) {
167 : 0 : return status;
168 : : }
169 : :
170 : 106 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "handshake_secret (0x%zx) - ", hash_size));
171 : 106 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->master_secret.handshake_secret, hash_size);
172 : 106 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
173 : :
174 : 106 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "request_handshake_secret (0x%zx) - ", hash_size));
175 : 106 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->handshake_secret.request_handshake_secret, hash_size);
176 : 106 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
177 : :
178 : 106 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "response_handshake_secret (0x%zx) - ", hash_size));
179 : 106 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->handshake_secret.response_handshake_secret, hash_size);
180 : 106 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
181 : : }
182 : :
183 : 180 : status = libspdm_generate_finished_key(
184 : : secured_message_context,
185 : : secured_message_context->handshake_secret
186 : 180 : .request_handshake_secret,
187 : 180 : secured_message_context->handshake_secret.request_finished_key);
188 [ - + ]: 180 : if (!status) {
189 : 0 : return status;
190 : : }
191 : :
192 : 180 : status = libspdm_generate_finished_key(
193 : : secured_message_context,
194 : 180 : secured_message_context->handshake_secret.response_handshake_secret,
195 : 180 : secured_message_context->handshake_secret.response_finished_key);
196 [ - + ]: 180 : if (!status) {
197 : 0 : return status;
198 : : }
199 : :
200 : 180 : status = libspdm_generate_aead_key_and_iv(secured_message_context,
201 : : secured_message_context->handshake_secret
202 : 180 : .request_handshake_secret,
203 : : secured_message_context->handshake_secret
204 : 180 : .request_handshake_encryption_key,
205 : : secured_message_context->handshake_secret
206 : 180 : .request_handshake_salt);
207 [ - + ]: 180 : if (!status) {
208 : 0 : return status;
209 : : }
210 : 180 : secured_message_context->handshake_secret.request_handshake_sequence_number = 0;
211 : :
212 : 180 : status = libspdm_generate_aead_key_and_iv(
213 : : secured_message_context,
214 : 180 : secured_message_context->handshake_secret.response_handshake_secret,
215 : 180 : secured_message_context->handshake_secret.response_handshake_encryption_key,
216 : 180 : secured_message_context->handshake_secret.response_handshake_salt);
217 [ - + ]: 180 : if (!status) {
218 : 0 : return status;
219 : : }
220 : :
221 : 180 : secured_message_context->handshake_secret.response_handshake_sequence_number = 0;
222 : 180 : libspdm_zero_mem(secured_message_context->master_secret.shared_secret, LIBSPDM_MAX_SHARED_KEY_SIZE);
223 : :
224 : 180 : return true;
225 : : }
226 : :
227 : 112 : 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 : 112 : secured_message_context = spdm_secured_message_context;
240 : :
241 : 112 : hash_size = secured_message_context->hash_size;
242 : 112 : master_secret_size = hash_size;
243 : 112 : request_data_secret_size = hash_size;
244 : 112 : response_data_secret_size = hash_size;
245 : 112 : export_master_secret_size = hash_size;
246 : :
247 : : #if LIBSPDM_ENABLE_CAPABILITY_PSK_CAP
248 [ + + ]: 112 : if (secured_message_context->use_psk) {
249 : 52 : status = libspdm_generate_data_key(
250 : 52 : secured_message_context->version,
251 : : NULL,
252 : : 0,
253 : 52 : secured_message_context->psk_hint,
254 : : secured_message_context->psk_hint_size,
255 : 52 : secured_message_context->use_psk,
256 : : secured_message_context->base_hash_algo,
257 : : th2_hash_data,
258 : 52 : secured_message_context->master_secret.master_secret,
259 : : &master_secret_size,
260 : 52 : secured_message_context->application_secret.request_data_secret,
261 : : &request_data_secret_size,
262 : 52 : secured_message_context->application_secret.response_data_secret,
263 : : &response_data_secret_size,
264 : 52 : secured_message_context->export_master_secret,
265 : : &export_master_secret_size);
266 : :
267 [ - + ]: 52 : if (!status) {
268 : 0 : return status;
269 : : }
270 : : }
271 : : #endif /* LIBSPDM_ENABLE_CAPABILITY_PSK_CAP */
272 [ + + ]: 112 : if (!(secured_message_context->use_psk)) {
273 : 60 : status = libspdm_generate_data_key(
274 : 60 : secured_message_context->version,
275 : 60 : secured_message_context->master_secret.handshake_secret,
276 : : hash_size,
277 : : NULL,
278 : : 0,
279 : 60 : secured_message_context->use_psk,
280 : : secured_message_context->base_hash_algo,
281 : : th2_hash_data,
282 : 60 : secured_message_context->master_secret.master_secret,
283 : : &master_secret_size,
284 : 60 : secured_message_context->application_secret.request_data_secret,
285 : : &request_data_secret_size,
286 : 60 : secured_message_context->application_secret.response_data_secret,
287 : : &response_data_secret_size,
288 : 60 : secured_message_context->export_master_secret,
289 : : &export_master_secret_size);
290 : :
291 [ - + ]: 60 : if (!status) {
292 : 0 : return status;
293 : : }
294 : :
295 : 60 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "master_secret (0x%zx) - ", hash_size));
296 : 60 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->master_secret.master_secret, hash_size);
297 : 60 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
298 : :
299 : 60 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "request_data_secret (0x%zx) - ", hash_size));
300 : 60 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->application_secret.request_data_secret, hash_size);
301 : 60 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
302 : :
303 : 60 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "response_data_secret (0x%zx) - ", hash_size));
304 : 60 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->application_secret.response_data_secret, hash_size);
305 : 60 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
306 : :
307 : 60 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "export_master_secret (0x%zx) - ", hash_size));
308 : 60 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->export_master_secret, hash_size);
309 : 60 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
310 : : }
311 : :
312 : 112 : status = libspdm_generate_aead_key_and_iv(
313 : : secured_message_context,
314 : 112 : secured_message_context->application_secret.request_data_secret,
315 : 112 : secured_message_context->application_secret.request_data_encryption_key,
316 : 112 : secured_message_context->application_secret.request_data_salt);
317 [ - + ]: 112 : if (!status) {
318 : 0 : return status;
319 : : }
320 : 112 : secured_message_context->application_secret.request_data_sequence_number = 0;
321 : :
322 : 112 : status = libspdm_generate_aead_key_and_iv(
323 : : secured_message_context,
324 : 112 : secured_message_context->application_secret.response_data_secret,
325 : 112 : secured_message_context->application_secret.response_data_encryption_key,
326 : 112 : secured_message_context->application_secret.response_data_salt);
327 [ - + ]: 112 : if (!status) {
328 : 0 : return status;
329 : : }
330 : 112 : secured_message_context->application_secret.response_data_sequence_number = 0;
331 : :
332 : 112 : return true;
333 : : }
334 : :
335 : 228 : 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 : 228 : secured_message_context = spdm_secured_message_context;
345 : :
346 : 228 : hash_size = secured_message_context->hash_size;
347 : :
348 : 228 : bin_str9_size = sizeof(bin_str9);
349 : 228 : libspdm_bin_concat(secured_message_context->version,
350 : : SPDM_BIN_STR_9_LABEL, sizeof(SPDM_BIN_STR_9_LABEL) - 1,
351 : 228 : NULL, (uint16_t)hash_size, hash_size, bin_str9,
352 : : &bin_str9_size);
353 : :
354 : 228 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "bin_str9 (0x%zx):\n", bin_str9_size));
355 : 228 : LIBSPDM_INTERNAL_DUMP_HEX(bin_str9, bin_str9_size);
356 : :
357 [ + + ]: 228 : if (action == LIBSPDM_KEY_UPDATE_ACTION_REQUESTER) {
358 : 92 : 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 : 92 : &secured_message_context->application_secret
363 : : .request_data_secret,
364 : : LIBSPDM_MAX_HASH_SIZE);
365 : 92 : 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 : 92 : &secured_message_context->application_secret
370 : : .request_data_encryption_key,
371 : : LIBSPDM_MAX_AEAD_KEY_SIZE);
372 : 92 : 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 : 92 : &secured_message_context->application_secret
377 : : .request_data_salt,
378 : : LIBSPDM_MAX_AEAD_IV_SIZE);
379 : : secured_message_context->application_secret_backup
380 : 92 : .request_data_sequence_number =
381 : 92 : secured_message_context->application_secret.request_data_sequence_number;
382 : :
383 : : /* The backup now holds a complete snapshot of the old keys, so mark it valid before
384 : : * deriving the new ones. If a derivation below fails the caller can still roll back
385 : : * via libspdm_activate_update_session_data_key(..., use_new_key = false). */
386 : 92 : secured_message_context->requester_backup_valid = true;
387 : :
388 : 92 : status = libspdm_hkdf_expand(
389 : : secured_message_context->base_hash_algo,
390 : 92 : secured_message_context->application_secret.request_data_secret,
391 : : hash_size, bin_str9, bin_str9_size,
392 : 92 : secured_message_context->application_secret.request_data_secret,
393 : : hash_size);
394 [ - + ]: 92 : if (!status) {
395 : 0 : return false;
396 : : }
397 : 92 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "RequestDataSecretUpdate (0x%zx) - ", hash_size));
398 : 92 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->application_secret.request_data_secret,
399 : : hash_size);
400 : 92 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
401 : :
402 : 92 : status = libspdm_generate_aead_key_and_iv(
403 : : secured_message_context,
404 : 92 : secured_message_context->application_secret.request_data_secret,
405 : 92 : secured_message_context->application_secret.request_data_encryption_key,
406 : 92 : secured_message_context->application_secret.request_data_salt);
407 [ + + ]: 92 : if (!status) {
408 : 6 : return status;
409 : : }
410 : 86 : secured_message_context->application_secret.request_data_sequence_number = 0;
411 [ + - ]: 136 : } else if (action == LIBSPDM_KEY_UPDATE_ACTION_RESPONDER) {
412 : 136 : libspdm_copy_mem(&secured_message_context->application_secret_backup
413 : : .response_data_secret,
414 : : sizeof(secured_message_context->application_secret_backup
415 : : .response_data_secret),
416 : 136 : &secured_message_context->application_secret
417 : : .response_data_secret,
418 : : LIBSPDM_MAX_HASH_SIZE);
419 : 136 : libspdm_copy_mem(&secured_message_context->application_secret_backup
420 : : .response_data_encryption_key,
421 : : sizeof(secured_message_context->application_secret_backup
422 : : .response_data_encryption_key),
423 : 136 : &secured_message_context->application_secret
424 : : .response_data_encryption_key,
425 : : LIBSPDM_MAX_AEAD_KEY_SIZE);
426 : 136 : libspdm_copy_mem(&secured_message_context->application_secret_backup
427 : : .response_data_salt,
428 : : sizeof(secured_message_context->application_secret_backup
429 : : .response_data_salt),
430 : 136 : &secured_message_context->application_secret
431 : : .response_data_salt,
432 : : LIBSPDM_MAX_AEAD_IV_SIZE);
433 : : secured_message_context->application_secret_backup
434 : 136 : .response_data_sequence_number =
435 : 136 : secured_message_context->application_secret.response_data_sequence_number;
436 : :
437 : : /* The backup now holds a complete snapshot of the old keys, so mark it valid before
438 : : * deriving the new ones. If a derivation below fails the caller can still roll back
439 : : * via libspdm_activate_update_session_data_key(..., use_new_key = false). */
440 : 136 : secured_message_context->responder_backup_valid = true;
441 : :
442 : 136 : status = libspdm_hkdf_expand(
443 : : secured_message_context->base_hash_algo,
444 : 136 : secured_message_context->application_secret.response_data_secret,
445 : : hash_size, bin_str9, bin_str9_size,
446 : 136 : secured_message_context->application_secret.response_data_secret,
447 : : hash_size);
448 [ - + ]: 136 : if (!status) {
449 : 0 : return false;
450 : : }
451 : 136 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "ResponseDataSecretUpdate (0x%zx) - ",
452 : : hash_size));
453 : 136 : LIBSPDM_INTERNAL_DUMP_DATA(secured_message_context->application_secret.response_data_secret,
454 : : hash_size);
455 : 136 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
456 : :
457 : 136 : status = libspdm_generate_aead_key_and_iv(
458 : : secured_message_context,
459 : 136 : secured_message_context->application_secret.response_data_secret,
460 : 136 : secured_message_context->application_secret.response_data_encryption_key,
461 : 136 : secured_message_context->application_secret.response_data_salt);
462 [ + + ]: 136 : if (!status) {
463 : 4 : return status;
464 : : }
465 : 132 : secured_message_context->application_secret.response_data_sequence_number = 0;
466 : : } else {
467 : 0 : return false;
468 : : }
469 : :
470 : 218 : return true;
471 : : }
472 : :
473 : 824 : void libspdm_clear_handshake_secret(void *spdm_secured_message_context)
474 : : {
475 : : libspdm_secured_message_context_t *secured_message_context;
476 : :
477 : 824 : secured_message_context = spdm_secured_message_context;
478 : :
479 : 824 : libspdm_zero_mem(secured_message_context->master_secret.handshake_secret,
480 : : LIBSPDM_MAX_HASH_SIZE);
481 : 824 : libspdm_zero_mem(&(secured_message_context->handshake_secret),
482 : : sizeof(libspdm_session_info_struct_handshake_secret_t));
483 : :
484 : 824 : secured_message_context->requester_backup_valid = false;
485 : 824 : secured_message_context->responder_backup_valid = false;
486 : 824 : }
487 : :
488 : 824 : void libspdm_clear_master_secret(void *spdm_secured_message_context)
489 : : {
490 : : libspdm_secured_message_context_t *secured_message_context;
491 : :
492 : 824 : secured_message_context = spdm_secured_message_context;
493 : :
494 : 824 : libspdm_zero_mem(secured_message_context->master_secret.master_secret, LIBSPDM_MAX_HASH_SIZE);
495 : 824 : }
496 : :
497 : 208 : bool libspdm_activate_update_session_data_key(void *spdm_secured_message_context,
498 : : libspdm_key_update_action_t action,
499 : : bool use_new_key)
500 : : {
501 : : libspdm_secured_message_context_t *secured_message_context;
502 : :
503 : 208 : secured_message_context = spdm_secured_message_context;
504 : :
505 [ + + ]: 208 : if (!use_new_key) {
506 [ + + ]: 118 : if ((action == LIBSPDM_KEY_UPDATE_ACTION_REQUESTER) &&
507 [ + - ]: 8 : secured_message_context->requester_backup_valid) {
508 : 8 : libspdm_copy_mem(&secured_message_context->application_secret
509 : : .request_data_secret,
510 : : sizeof(secured_message_context->application_secret
511 : : .request_data_secret),
512 : 8 : &secured_message_context
513 : : ->application_secret_backup
514 : : .request_data_secret,
515 : : LIBSPDM_MAX_HASH_SIZE);
516 : 8 : libspdm_copy_mem(&secured_message_context->application_secret
517 : : .request_data_encryption_key,
518 : : sizeof(secured_message_context->application_secret
519 : : .request_data_encryption_key),
520 : 8 : &secured_message_context
521 : : ->application_secret_backup
522 : : .request_data_encryption_key,
523 : : LIBSPDM_MAX_AEAD_KEY_SIZE);
524 : 8 : libspdm_copy_mem(&secured_message_context->application_secret
525 : : .request_data_salt,
526 : : sizeof(secured_message_context->application_secret
527 : : .request_data_salt),
528 : 8 : &secured_message_context
529 : : ->application_secret_backup
530 : : .request_data_salt,
531 : : LIBSPDM_MAX_AEAD_IV_SIZE);
532 : : secured_message_context->application_secret
533 : 8 : .request_data_sequence_number =
534 : 8 : secured_message_context->application_secret_backup.request_data_sequence_number;
535 [ + - ]: 110 : } else if ((action == LIBSPDM_KEY_UPDATE_ACTION_RESPONDER) &&
536 [ + - ]: 110 : secured_message_context->responder_backup_valid) {
537 : 110 : libspdm_copy_mem(&secured_message_context->application_secret
538 : : .response_data_secret,
539 : : sizeof(secured_message_context->application_secret
540 : : .response_data_secret),
541 : 110 : &secured_message_context
542 : : ->application_secret_backup
543 : : .response_data_secret,
544 : : LIBSPDM_MAX_HASH_SIZE);
545 : 110 : libspdm_copy_mem(&secured_message_context->application_secret
546 : : .response_data_encryption_key,
547 : : sizeof(secured_message_context->application_secret
548 : : .response_data_encryption_key),
549 : 110 : &secured_message_context
550 : : ->application_secret_backup
551 : : .response_data_encryption_key,
552 : : LIBSPDM_MAX_AEAD_KEY_SIZE);
553 : 110 : libspdm_copy_mem(&secured_message_context->application_secret
554 : : .response_data_salt,
555 : : sizeof(secured_message_context->application_secret
556 : : .response_data_salt),
557 : 110 : &secured_message_context
558 : : ->application_secret_backup
559 : : .response_data_salt,
560 : : LIBSPDM_MAX_AEAD_IV_SIZE);
561 : 110 : secured_message_context->application_secret.response_data_sequence_number =
562 : 110 : secured_message_context->application_secret_backup.response_data_sequence_number;
563 : : }
564 : : }
565 : :
566 [ + + ]: 208 : if (action == LIBSPDM_KEY_UPDATE_ACTION_REQUESTER) {
567 : 82 : libspdm_zero_mem(&secured_message_context->application_secret_backup.request_data_secret,
568 : : LIBSPDM_MAX_HASH_SIZE);
569 : 82 : libspdm_zero_mem(&secured_message_context->application_secret_backup
570 : : .request_data_encryption_key,
571 : : LIBSPDM_MAX_AEAD_KEY_SIZE);
572 : 82 : libspdm_zero_mem(&secured_message_context->application_secret_backup.request_data_salt,
573 : : LIBSPDM_MAX_AEAD_IV_SIZE);
574 : 82 : secured_message_context->application_secret_backup.request_data_sequence_number = 0;
575 : 82 : secured_message_context->requester_backup_valid = false;
576 [ + - ]: 126 : } else if (action == LIBSPDM_KEY_UPDATE_ACTION_RESPONDER) {
577 : 126 : libspdm_zero_mem(&secured_message_context->application_secret_backup.response_data_secret,
578 : : LIBSPDM_MAX_HASH_SIZE);
579 : 126 : libspdm_zero_mem(&secured_message_context->application_secret_backup
580 : : .response_data_encryption_key,
581 : : LIBSPDM_MAX_AEAD_KEY_SIZE);
582 : 126 : libspdm_zero_mem(&secured_message_context->application_secret_backup.response_data_salt,
583 : : LIBSPDM_MAX_AEAD_IV_SIZE);
584 : 126 : secured_message_context->application_secret_backup.response_data_sequence_number = 0;
585 : 126 : secured_message_context->responder_backup_valid = false;
586 : : }
587 : :
588 : 208 : return true;
589 : : }
590 : :
591 : 236 : bool libspdm_hmac_all_with_request_finished_key(void *spdm_secured_message_context,
592 : : const void *data, size_t data_size,
593 : : uint8_t *hmac_value)
594 : : {
595 : : libspdm_secured_message_context_t *secured_message_context;
596 : :
597 : 236 : secured_message_context = spdm_secured_message_context;
598 : 472 : return libspdm_hmac_all(
599 : : secured_message_context->base_hash_algo, data, data_size,
600 : 236 : secured_message_context->handshake_secret.request_finished_key,
601 : : secured_message_context->hash_size, hmac_value);
602 : : }
603 : :
604 : 210 : bool libspdm_hmac_all_with_response_finished_key(
605 : : void *spdm_secured_message_context, const void *data,
606 : : size_t data_size, uint8_t *hmac_value)
607 : : {
608 : : libspdm_secured_message_context_t *secured_message_context;
609 : :
610 : 210 : secured_message_context = spdm_secured_message_context;
611 : 420 : return libspdm_hmac_all(
612 : : secured_message_context->base_hash_algo, data, data_size,
613 : 210 : secured_message_context->handshake_secret.response_finished_key,
614 : : secured_message_context->hash_size, hmac_value);
615 : : }
|
