Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2025 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 "spdm_unit_test.h"
8 : #include "internal/libspdm_requester_lib.h"
9 : #include "internal/libspdm_secured_message_lib.h"
10 :
11 : #if (LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP) || (LIBSPDM_ENABLE_CAPABILITY_PSK_CAP)
12 :
13 : static uint8_t m_libspdm_last_token;
14 : static uint8_t m_libspdm_last_rsp_enc_key[LIBSPDM_MAX_AEAD_KEY_SIZE];
15 : static uint8_t m_libspdm_last_rsp_salt[LIBSPDM_MAX_AEAD_IV_SIZE];
16 : static uint64_t m_libspdm_last_rsp_sequence_number;
17 :
18 35 : static void libspdm_set_standard_key_update_test_state(
19 : libspdm_context_t *spdm_context, uint32_t *session_id)
20 : {
21 : void *data;
22 : size_t data_size;
23 : void *hash;
24 : size_t hash_size;
25 : libspdm_session_info_t *session_info;
26 :
27 35 : spdm_context->connection_info.connection_state =
28 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
29 35 : spdm_context->connection_info.capability.flags |=
30 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_UPD_CAP;
31 35 : spdm_context->connection_info.capability.flags |=
32 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
33 35 : spdm_context->connection_info.capability.flags |=
34 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
35 35 : spdm_context->local_context.capability.flags |=
36 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP;
37 35 : spdm_context->local_context.capability.flags |=
38 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
39 35 : spdm_context->local_context.capability.flags |=
40 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
41 35 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
42 : m_libspdm_use_asym_algo, &data,
43 : &data_size, &hash, &hash_size)) {
44 0 : assert(false);
45 : }
46 35 : spdm_context->transcript.message_a.buffer_size = 0;
47 35 : spdm_context->connection_info.algorithm.base_hash_algo =
48 : m_libspdm_use_hash_algo;
49 35 : spdm_context->connection_info.algorithm.base_asym_algo =
50 : m_libspdm_use_asym_algo;
51 35 : spdm_context->connection_info.algorithm.dhe_named_group =
52 : m_libspdm_use_dhe_algo;
53 35 : spdm_context->connection_info.algorithm.aead_cipher_suite =
54 : m_libspdm_use_aead_algo;
55 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
56 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
57 : data_size;
58 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
59 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
60 : data, data_size);
61 : #endif
62 :
63 35 : *session_id = 0xFFFFFFFF;
64 35 : session_info = &spdm_context->session_info[0];
65 35 : libspdm_session_info_init(spdm_context, session_info, *session_id,
66 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
67 35 : libspdm_secured_message_set_session_state(
68 : session_info->secured_message_context,
69 : LIBSPDM_SESSION_STATE_ESTABLISHED);
70 :
71 35 : free(data);
72 35 : }
73 :
74 83 : static void libspdm_set_standard_key_update_test_secrets(
75 : libspdm_secured_message_context_t *secured_message_context,
76 : uint8_t *m_rsp_secret_buffer, uint8_t rsp_secret_fill,
77 : uint8_t *m_req_secret_buffer, uint8_t req_secret_fill)
78 : {
79 83 : libspdm_set_mem(m_rsp_secret_buffer, secured_message_context
80 : ->hash_size, rsp_secret_fill);
81 83 : libspdm_set_mem(m_req_secret_buffer, secured_message_context
82 : ->hash_size, req_secret_fill);
83 :
84 83 : libspdm_copy_mem(secured_message_context->application_secret.response_data_secret,
85 : sizeof(secured_message_context->application_secret.response_data_secret),
86 : m_rsp_secret_buffer, secured_message_context->aead_key_size);
87 83 : libspdm_copy_mem(secured_message_context->application_secret.request_data_secret,
88 : sizeof(secured_message_context->application_secret.request_data_secret),
89 : m_req_secret_buffer, secured_message_context->aead_key_size);
90 :
91 83 : libspdm_set_mem(secured_message_context->application_secret
92 83 : .response_data_encryption_key,
93 : secured_message_context->aead_key_size, (uint8_t)(0xFF));
94 83 : libspdm_set_mem(secured_message_context->application_secret
95 83 : .response_data_salt,
96 : secured_message_context->aead_iv_size, (uint8_t)(0xFF));
97 :
98 :
99 83 : libspdm_set_mem(secured_message_context->application_secret
100 83 : .request_data_encryption_key,
101 : secured_message_context->aead_key_size, (uint8_t)(0xEE));
102 83 : libspdm_set_mem(secured_message_context->application_secret
103 83 : .request_data_salt,
104 : secured_message_context->aead_iv_size, (uint8_t)(0xEE));
105 :
106 : secured_message_context->application_secret.
107 83 : response_data_sequence_number = 0;
108 : secured_message_context->application_secret.
109 83 : request_data_sequence_number = 0;
110 83 : }
111 :
112 35 : static void libspdm_compute_secret_update(spdm_version_number_t spdm_version,
113 : size_t hash_size,
114 : const uint8_t *in_secret, uint8_t *out_secret,
115 : size_t out_secret_size)
116 : {
117 : uint8_t bin_str9[128];
118 : size_t bin_str9_size;
119 :
120 35 : bin_str9_size = sizeof(bin_str9);
121 35 : libspdm_bin_concat(spdm_version,
122 : SPDM_BIN_STR_9_LABEL, sizeof(SPDM_BIN_STR_9_LABEL) - 1,
123 35 : NULL, (uint16_t)hash_size, hash_size, bin_str9,
124 : &bin_str9_size);
125 :
126 35 : libspdm_hkdf_expand(m_libspdm_use_hash_algo, in_secret, hash_size, bin_str9,
127 : bin_str9_size, out_secret, out_secret_size);
128 35 : }
129 :
130 128 : static libspdm_return_t send_message(
131 : void *spdm_context, size_t request_size, const void *request, uint64_t timeout)
132 : {
133 : libspdm_test_context_t *spdm_test_context;
134 :
135 128 : spdm_test_context = libspdm_get_test_context();
136 128 : switch (spdm_test_context->case_id) {
137 1 : case 0x1:
138 1 : return LIBSPDM_STATUS_SEND_FAIL;
139 2 : case 0x2: {
140 : libspdm_return_t status;
141 : uint8_t *decoded_message;
142 : size_t decoded_message_size;
143 : uint32_t session_id;
144 : uint32_t *message_session_id;
145 : bool is_app_message;
146 : libspdm_session_info_t *session_info;
147 : uint8_t message_buffer[LIBSPDM_SENDER_BUFFER_SIZE];
148 :
149 2 : message_session_id = NULL;
150 2 : session_id = 0xFFFFFFFF;
151 :
152 2 : session_info = libspdm_get_session_info_via_session_id(
153 : spdm_context, session_id);
154 2 : if (session_info == NULL) {
155 0 : return LIBSPDM_STATUS_SEND_FAIL;
156 : }
157 :
158 2 : memcpy(message_buffer, request, request_size);
159 :
160 : ((libspdm_secured_message_context_t
161 2 : *)(session_info->secured_message_context))
162 2 : ->application_secret.request_data_sequence_number--;
163 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&decoded_message, &decoded_message_size);
164 2 : status = libspdm_transport_test_decode_message(spdm_context,
165 : &message_session_id, &is_app_message, true,
166 : request_size,
167 : message_buffer, &decoded_message_size,
168 : (void **)&decoded_message);
169 2 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
170 0 : return LIBSPDM_STATUS_SEND_FAIL;
171 : }
172 :
173 2 : m_libspdm_last_token = ((spdm_key_update_request_t
174 2 : *) decoded_message)->header.param2;
175 : }
176 2 : return LIBSPDM_STATUS_SUCCESS;
177 0 : case 0x3: {
178 : static size_t sub_index = 0;
179 :
180 0 : if(sub_index > 0) {
181 : libspdm_return_t status;
182 : uint8_t *decoded_message;
183 : size_t decoded_message_size;
184 : uint32_t session_id;
185 : uint32_t *message_session_id;
186 : bool is_app_message;
187 : libspdm_session_info_t *session_info;
188 : uint8_t message_buffer[LIBSPDM_SENDER_BUFFER_SIZE];
189 :
190 0 : message_session_id = NULL;
191 0 : session_id = 0xFFFFFFFF;
192 :
193 0 : session_info = libspdm_get_session_info_via_session_id(
194 : spdm_context, session_id);
195 0 : if (session_info == NULL) {
196 0 : return LIBSPDM_STATUS_SEND_FAIL;
197 : }
198 :
199 0 : memcpy(message_buffer, request, request_size);
200 :
201 : ((libspdm_secured_message_context_t
202 0 : *)(session_info->secured_message_context))
203 0 : ->application_secret.request_data_sequence_number--;
204 0 : libspdm_get_scratch_buffer (spdm_context, (void **)&decoded_message,
205 : &decoded_message_size);
206 0 : status = libspdm_transport_test_decode_message(spdm_context,
207 : &message_session_id, &is_app_message,
208 : true,
209 : request_size,
210 : message_buffer, &decoded_message_size,
211 : (void **)&decoded_message);
212 0 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
213 0 : return LIBSPDM_STATUS_SEND_FAIL;
214 : }
215 :
216 0 : m_libspdm_last_token = ((spdm_key_update_request_t
217 0 : *) decoded_message)->header.param2;
218 : }
219 :
220 0 : sub_index++;
221 : }
222 0 : return LIBSPDM_STATUS_SUCCESS;
223 1 : case 0x4: {
224 : static size_t sub_index = 0;
225 :
226 1 : if(sub_index > 0) {
227 : libspdm_return_t status;
228 : uint8_t *decoded_message;
229 : size_t decoded_message_size;
230 : uint32_t session_id;
231 : uint32_t *message_session_id;
232 : bool is_app_message;
233 : libspdm_session_info_t *session_info;
234 : uint8_t message_buffer[LIBSPDM_SENDER_BUFFER_SIZE];
235 :
236 0 : message_session_id = NULL;
237 0 : session_id = 0xFFFFFFFF;
238 :
239 0 : session_info = libspdm_get_session_info_via_session_id(
240 : spdm_context, session_id);
241 0 : if (session_info == NULL) {
242 0 : return LIBSPDM_STATUS_SEND_FAIL;
243 : }
244 :
245 0 : memcpy(message_buffer, request, request_size);
246 :
247 : ((libspdm_secured_message_context_t
248 0 : *)(session_info->secured_message_context))
249 0 : ->application_secret.request_data_sequence_number--;
250 0 : libspdm_get_scratch_buffer (spdm_context, (void **)&decoded_message,
251 : &decoded_message_size);
252 0 : status = libspdm_transport_test_decode_message(spdm_context,
253 : &message_session_id, &is_app_message,
254 : true,
255 : request_size,
256 : message_buffer, &decoded_message_size,
257 : (void **)&decoded_message);
258 0 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
259 0 : return LIBSPDM_STATUS_SEND_FAIL;
260 : }
261 :
262 0 : m_libspdm_last_token = ((spdm_key_update_request_t
263 0 : *) decoded_message)->header.param2;
264 : }
265 :
266 1 : sub_index++;
267 : }
268 1 : return LIBSPDM_STATUS_SUCCESS;
269 1 : case 0x5: {
270 : static size_t sub_index = 0;
271 :
272 1 : if(sub_index > 0) {
273 : libspdm_return_t status;
274 : uint8_t *decoded_message;
275 : size_t decoded_message_size;
276 : uint32_t session_id;
277 : uint32_t *message_session_id;
278 : bool is_app_message;
279 : libspdm_session_info_t *session_info;
280 : uint8_t message_buffer[LIBSPDM_SENDER_BUFFER_SIZE];
281 :
282 0 : message_session_id = NULL;
283 0 : session_id = 0xFFFFFFFF;
284 :
285 0 : session_info = libspdm_get_session_info_via_session_id(
286 : spdm_context, session_id);
287 0 : if (session_info == NULL) {
288 0 : return LIBSPDM_STATUS_SEND_FAIL;
289 : }
290 :
291 0 : memcpy(message_buffer, request, request_size);
292 :
293 : ((libspdm_secured_message_context_t
294 0 : *)(session_info->secured_message_context))
295 0 : ->application_secret.request_data_sequence_number--;
296 0 : libspdm_get_scratch_buffer (spdm_context, (void **)&decoded_message,
297 : &decoded_message_size);
298 0 : status = libspdm_transport_test_decode_message(spdm_context,
299 : &message_session_id, &is_app_message,
300 : true,
301 : request_size,
302 : message_buffer, &decoded_message_size,
303 : (void **)&decoded_message);
304 0 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
305 0 : return LIBSPDM_STATUS_SEND_FAIL;
306 : }
307 :
308 0 : m_libspdm_last_token = ((spdm_key_update_request_t
309 0 : *) decoded_message)->header.param2;
310 : }
311 :
312 1 : sub_index++;
313 : }
314 1 : return LIBSPDM_STATUS_SUCCESS;
315 3 : case 0x6: {
316 : static size_t sub_index = 0;
317 :
318 3 : if(sub_index > 0) {
319 : libspdm_return_t status;
320 : uint8_t *decoded_message;
321 : size_t decoded_message_size;
322 : uint32_t session_id;
323 : uint32_t *message_session_id;
324 : bool is_app_message;
325 : libspdm_session_info_t *session_info;
326 : uint8_t message_buffer[LIBSPDM_SENDER_BUFFER_SIZE];
327 :
328 2 : message_session_id = NULL;
329 2 : session_id = 0xFFFFFFFF;
330 :
331 2 : session_info = libspdm_get_session_info_via_session_id(
332 : spdm_context, session_id);
333 2 : if (session_info == NULL) {
334 0 : return LIBSPDM_STATUS_SEND_FAIL;
335 : }
336 :
337 2 : memcpy(message_buffer, request, request_size);
338 :
339 : ((libspdm_secured_message_context_t
340 2 : *)(session_info->secured_message_context))
341 2 : ->application_secret.request_data_sequence_number--;
342 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&decoded_message,
343 : &decoded_message_size);
344 2 : status = libspdm_transport_test_decode_message(spdm_context,
345 : &message_session_id, &is_app_message,
346 : true,
347 : request_size,
348 : message_buffer, &decoded_message_size,
349 : (void **)&decoded_message);
350 2 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
351 0 : return LIBSPDM_STATUS_SEND_FAIL;
352 : }
353 :
354 2 : m_libspdm_last_token = ((spdm_key_update_request_t
355 2 : *) decoded_message)->header.param2;
356 : }
357 :
358 3 : sub_index++;
359 : }
360 3 : return LIBSPDM_STATUS_SUCCESS;
361 3 : case 0x7:
362 : case 0x8:
363 3 : return LIBSPDM_STATUS_SUCCESS;
364 3 : case 0x9: {
365 : static size_t sub_index = 0;
366 :
367 3 : if(sub_index != 1) {
368 : libspdm_return_t status;
369 : uint8_t *decoded_message;
370 : size_t decoded_message_size;
371 : uint32_t session_id;
372 : uint32_t *message_session_id;
373 : bool is_app_message;
374 : libspdm_session_info_t *session_info;
375 : uint8_t message_buffer[LIBSPDM_SENDER_BUFFER_SIZE];
376 :
377 2 : message_session_id = NULL;
378 2 : session_id = 0xFFFFFFFF;
379 :
380 2 : session_info = libspdm_get_session_info_via_session_id(
381 : spdm_context, session_id);
382 2 : if (session_info == NULL) {
383 0 : return LIBSPDM_STATUS_SEND_FAIL;
384 : }
385 :
386 2 : memcpy(message_buffer, request, request_size);
387 :
388 : ((libspdm_secured_message_context_t
389 2 : *)(session_info->secured_message_context))
390 2 : ->application_secret.request_data_sequence_number--;
391 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&decoded_message,
392 : &decoded_message_size);
393 2 : status = libspdm_transport_test_decode_message(spdm_context,
394 : &message_session_id, &is_app_message,
395 : true,
396 : request_size,
397 : message_buffer, &decoded_message_size,
398 : (void **)&decoded_message);
399 2 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
400 0 : return LIBSPDM_STATUS_SEND_FAIL;
401 : }
402 :
403 2 : m_libspdm_last_token = ((spdm_key_update_request_t
404 2 : *) decoded_message)->header.param2;
405 : }
406 :
407 3 : sub_index++;
408 : }
409 3 : return LIBSPDM_STATUS_SUCCESS;
410 17 : case 0xA:
411 17 : return LIBSPDM_STATUS_SUCCESS;
412 20 : case 0xB:
413 : case 0xC:
414 : case 0xD:
415 : case 0xE:
416 : case 0xF:
417 : case 0x10:
418 : case 0x11:
419 : case 0x12:
420 : case 0x13:
421 : case 0x14:
422 : case 0x15: {
423 : libspdm_return_t status;
424 : uint8_t *decoded_message;
425 : size_t decoded_message_size;
426 : uint32_t session_id;
427 : uint32_t *message_session_id;
428 : bool is_app_message;
429 : libspdm_session_info_t *session_info;
430 : uint8_t message_buffer[LIBSPDM_SENDER_BUFFER_SIZE];
431 :
432 20 : message_session_id = NULL;
433 20 : session_id = 0xFFFFFFFF;
434 :
435 20 : session_info = libspdm_get_session_info_via_session_id(
436 : spdm_context, session_id);
437 20 : if (session_info == NULL) {
438 0 : return LIBSPDM_STATUS_SEND_FAIL;
439 : }
440 :
441 20 : memcpy(message_buffer, request, request_size);
442 :
443 : ((libspdm_secured_message_context_t
444 20 : *)(session_info->secured_message_context))
445 20 : ->application_secret.request_data_sequence_number--;
446 20 : libspdm_get_scratch_buffer (spdm_context, (void **)&decoded_message, &decoded_message_size);
447 20 : status = libspdm_transport_test_decode_message(spdm_context,
448 : &message_session_id, &is_app_message, true,
449 : request_size,
450 : message_buffer, &decoded_message_size,
451 : (void **)&decoded_message);
452 20 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
453 0 : return LIBSPDM_STATUS_SEND_FAIL;
454 : }
455 :
456 20 : m_libspdm_last_token = ((spdm_key_update_request_t
457 20 : *) decoded_message)->header.param2;
458 : }
459 20 : return LIBSPDM_STATUS_SUCCESS;
460 3 : case 0x16: {
461 : static size_t sub_index = 0;
462 :
463 3 : if(sub_index < 2) {
464 : libspdm_return_t status;
465 : uint8_t *decoded_message;
466 : size_t decoded_message_size;
467 : uint32_t session_id;
468 : uint32_t *message_session_id;
469 : bool is_app_message;
470 : libspdm_session_info_t *session_info;
471 : uint8_t message_buffer[LIBSPDM_SENDER_BUFFER_SIZE];
472 :
473 2 : message_session_id = NULL;
474 2 : session_id = 0xFFFFFFFF;
475 :
476 2 : session_info = libspdm_get_session_info_via_session_id(
477 : spdm_context, session_id);
478 2 : if (session_info == NULL) {
479 0 : return LIBSPDM_STATUS_SEND_FAIL;
480 : }
481 :
482 2 : memcpy(message_buffer, request, request_size);
483 :
484 : ((libspdm_secured_message_context_t
485 2 : *)(session_info->secured_message_context))
486 2 : ->application_secret.request_data_sequence_number--;
487 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&decoded_message,
488 : &decoded_message_size);
489 2 : status = libspdm_transport_test_decode_message(spdm_context,
490 : &message_session_id, &is_app_message,
491 : true,
492 : request_size,
493 : message_buffer, &decoded_message_size,
494 : (void **)&decoded_message);
495 2 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
496 0 : return LIBSPDM_STATUS_SEND_FAIL;
497 : }
498 :
499 2 : m_libspdm_last_token = ((spdm_key_update_request_t
500 2 : *) decoded_message)->header.param2;
501 : }
502 :
503 3 : sub_index++;
504 : }
505 3 : return LIBSPDM_STATUS_SUCCESS;
506 34 : case 0x17: {
507 : static size_t sub_index = 0;
508 :
509 34 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "send message: %zu\n", sub_index));
510 :
511 34 : if(sub_index%2 == 0) {
512 : libspdm_return_t status;
513 : uint8_t *decoded_message;
514 : size_t decoded_message_size;
515 : uint32_t session_id;
516 : uint32_t *message_session_id;
517 : bool is_app_message;
518 : libspdm_session_info_t *session_info;
519 : uint8_t message_buffer[LIBSPDM_SENDER_BUFFER_SIZE];
520 :
521 17 : message_session_id = NULL;
522 17 : session_id = 0xFFFFFFFF;
523 :
524 17 : session_info = libspdm_get_session_info_via_session_id(
525 : spdm_context, session_id);
526 17 : if (session_info == NULL) {
527 0 : return LIBSPDM_STATUS_SEND_FAIL;
528 : }
529 :
530 17 : memcpy(message_buffer, request, request_size);
531 :
532 : ((libspdm_secured_message_context_t
533 17 : *)(session_info->secured_message_context))
534 17 : ->application_secret.request_data_sequence_number--;
535 17 : libspdm_get_scratch_buffer (spdm_context, (void **)&decoded_message,
536 : &decoded_message_size);
537 17 : status = libspdm_transport_test_decode_message(spdm_context,
538 : &message_session_id, &is_app_message,
539 : true,
540 : request_size,
541 : message_buffer, &decoded_message_size,
542 : (void **)&decoded_message);
543 17 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
544 0 : return LIBSPDM_STATUS_SEND_FAIL;
545 : }
546 :
547 17 : m_libspdm_last_token = ((spdm_key_update_request_t
548 17 : *) decoded_message)->header.param2;
549 :
550 17 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "last token: %x\n", m_libspdm_last_token));
551 : }
552 :
553 34 : sub_index++;
554 : }
555 34 : return LIBSPDM_STATUS_SUCCESS;
556 6 : case 0x18:
557 : case 0x19:
558 : case 0x1A: {
559 : libspdm_return_t status;
560 : uint8_t *decoded_message;
561 : size_t decoded_message_size;
562 : uint32_t session_id;
563 : uint32_t *message_session_id;
564 : bool is_app_message;
565 : libspdm_session_info_t *session_info;
566 : uint8_t message_buffer[LIBSPDM_SENDER_BUFFER_SIZE];
567 :
568 6 : message_session_id = NULL;
569 6 : session_id = 0xFFFFFFFF;
570 :
571 6 : session_info = libspdm_get_session_info_via_session_id(
572 : spdm_context, session_id);
573 6 : if (session_info == NULL) {
574 0 : return LIBSPDM_STATUS_SEND_FAIL;
575 : }
576 :
577 6 : memcpy(message_buffer, request, request_size);
578 :
579 : ((libspdm_secured_message_context_t
580 6 : *)(session_info->secured_message_context))
581 6 : ->application_secret.request_data_sequence_number--;
582 6 : libspdm_get_scratch_buffer (spdm_context, (void **)&decoded_message, &decoded_message_size);
583 6 : status = libspdm_transport_test_decode_message(spdm_context,
584 : &message_session_id, &is_app_message, true,
585 : request_size,
586 : message_buffer, &decoded_message_size,
587 : (void **)&decoded_message);
588 6 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
589 0 : return LIBSPDM_STATUS_SEND_FAIL;
590 : }
591 :
592 6 : m_libspdm_last_token = ((spdm_key_update_request_t
593 6 : *) decoded_message)->header.param2;
594 : }
595 6 : return LIBSPDM_STATUS_SUCCESS;
596 2 : case 0x1B: {
597 : libspdm_return_t status;
598 : uint8_t *decoded_message;
599 : size_t decoded_message_size;
600 : uint32_t session_id;
601 : uint32_t *message_session_id;
602 : bool is_app_message;
603 : libspdm_session_info_t *session_info;
604 : uint8_t message_buffer[LIBSPDM_SENDER_BUFFER_SIZE];
605 :
606 2 : message_session_id = NULL;
607 2 : session_id = 0xFFFFFFFF;
608 :
609 2 : session_info = libspdm_get_session_info_via_session_id(
610 : spdm_context, session_id);
611 2 : if (session_info == NULL) {
612 0 : return LIBSPDM_STATUS_SEND_FAIL;
613 : }
614 :
615 2 : memcpy(message_buffer, request, request_size);
616 :
617 : ((libspdm_secured_message_context_t
618 2 : *)(session_info->secured_message_context))
619 2 : ->application_secret.request_data_sequence_number--;
620 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&decoded_message, &decoded_message_size);
621 2 : status = libspdm_transport_test_decode_message(spdm_context,
622 : &message_session_id, &is_app_message, true,
623 : request_size,
624 : message_buffer, &decoded_message_size,
625 : (void **)&decoded_message);
626 2 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
627 0 : return LIBSPDM_STATUS_SEND_FAIL;
628 : }
629 :
630 2 : m_libspdm_last_token = ((spdm_key_update_request_t
631 2 : *) decoded_message)->header.param2;
632 : }
633 2 : return LIBSPDM_STATUS_SUCCESS;
634 1 : case 0x1C: {
635 : static size_t sub_index = 0;
636 :
637 1 : if(sub_index > 0) {
638 : libspdm_return_t status;
639 : uint8_t *decoded_message;
640 : size_t decoded_message_size;
641 : uint32_t session_id;
642 : uint32_t *message_session_id;
643 : bool is_app_message;
644 : libspdm_session_info_t *session_info;
645 : uint8_t message_buffer[LIBSPDM_SENDER_BUFFER_SIZE];
646 :
647 0 : message_session_id = NULL;
648 0 : session_id = 0xFFFFFFFF;
649 :
650 0 : session_info = libspdm_get_session_info_via_session_id(
651 : spdm_context, session_id);
652 0 : if (session_info == NULL) {
653 0 : return LIBSPDM_STATUS_SEND_FAIL;
654 : }
655 :
656 0 : memcpy(message_buffer, request, request_size);
657 :
658 : ((libspdm_secured_message_context_t
659 0 : *)(session_info->secured_message_context))
660 0 : ->application_secret.request_data_sequence_number--;
661 0 : libspdm_get_scratch_buffer (spdm_context, (void **)&decoded_message,
662 : &decoded_message_size);
663 0 : status = libspdm_transport_test_decode_message(spdm_context,
664 : &message_session_id, &is_app_message,
665 : true,
666 : request_size,
667 : message_buffer, &decoded_message_size,
668 : (void **)&decoded_message);
669 0 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
670 0 : return LIBSPDM_STATUS_SEND_FAIL;
671 : }
672 :
673 0 : m_libspdm_last_token = ((spdm_key_update_request_t
674 0 : *) decoded_message)->header.param2;
675 : }
676 :
677 1 : sub_index++;
678 : }
679 1 : return LIBSPDM_STATUS_SUCCESS;
680 4 : case 0x1D: {
681 : static size_t sub_index = 0;
682 :
683 4 : if(sub_index > 0) {
684 : libspdm_return_t status;
685 : uint8_t *decoded_message;
686 : size_t decoded_message_size;
687 : uint32_t session_id;
688 : uint32_t *message_session_id;
689 : bool is_app_message;
690 : libspdm_session_info_t *session_info;
691 : uint8_t message_buffer[LIBSPDM_SENDER_BUFFER_SIZE];
692 :
693 3 : message_session_id = NULL;
694 3 : session_id = 0xFFFFFFFF;
695 :
696 3 : session_info = libspdm_get_session_info_via_session_id(
697 : spdm_context, session_id);
698 3 : if (session_info == NULL) {
699 0 : return LIBSPDM_STATUS_SEND_FAIL;
700 : }
701 :
702 3 : memcpy(message_buffer, request, request_size);
703 :
704 : ((libspdm_secured_message_context_t
705 3 : *)(session_info->secured_message_context))
706 3 : ->application_secret.request_data_sequence_number--;
707 3 : libspdm_get_scratch_buffer (spdm_context, (void **)&decoded_message,
708 : &decoded_message_size);
709 3 : status = libspdm_transport_test_decode_message(spdm_context,
710 : &message_session_id, &is_app_message,
711 : true,
712 : request_size,
713 : message_buffer, &decoded_message_size,
714 : (void **)&decoded_message);
715 3 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
716 0 : return LIBSPDM_STATUS_SEND_FAIL;
717 : }
718 :
719 3 : m_libspdm_last_token = ((spdm_key_update_request_t
720 3 : *) decoded_message)->header.param2;
721 : }
722 :
723 4 : sub_index++;
724 : }
725 4 : return LIBSPDM_STATUS_SUCCESS;
726 3 : case 0x1E: {
727 : static size_t sub_index = 0;
728 :
729 3 : if(sub_index > 0) {
730 : libspdm_return_t status;
731 : uint8_t *decoded_message;
732 : size_t decoded_message_size;
733 : uint32_t session_id;
734 : uint32_t *message_session_id;
735 : bool is_app_message;
736 : libspdm_session_info_t *session_info;
737 : uint8_t message_buffer[LIBSPDM_SENDER_BUFFER_SIZE];
738 :
739 2 : message_session_id = NULL;
740 2 : session_id = 0xFFFFFFFF;
741 :
742 2 : session_info = libspdm_get_session_info_via_session_id(
743 : spdm_context, session_id);
744 2 : if (session_info == NULL) {
745 0 : return LIBSPDM_STATUS_SEND_FAIL;
746 : }
747 :
748 2 : memcpy(message_buffer, request, request_size);
749 :
750 : ((libspdm_secured_message_context_t
751 2 : *)(session_info->secured_message_context))
752 2 : ->application_secret.request_data_sequence_number--;
753 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&decoded_message,
754 : &decoded_message_size);
755 2 : status = libspdm_transport_test_decode_message(spdm_context,
756 : &message_session_id, &is_app_message,
757 : true,
758 : request_size,
759 : message_buffer, &decoded_message_size,
760 : (void **)&decoded_message);
761 2 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
762 0 : return LIBSPDM_STATUS_SEND_FAIL;
763 : }
764 :
765 2 : m_libspdm_last_token = ((spdm_key_update_request_t
766 2 : *) decoded_message)->header.param2;
767 : }
768 :
769 3 : sub_index++;
770 : }
771 3 : return LIBSPDM_STATUS_SUCCESS;
772 3 : case 0x1F:
773 : case 0x20:
774 3 : return LIBSPDM_STATUS_SUCCESS;
775 3 : case 0x21: {
776 : static size_t sub_index = 0;
777 :
778 3 : if(sub_index != 1) {
779 : libspdm_return_t status;
780 : uint8_t *decoded_message;
781 : size_t decoded_message_size;
782 : uint32_t session_id;
783 : uint32_t *message_session_id;
784 : bool is_app_message;
785 : libspdm_session_info_t *session_info;
786 : uint8_t message_buffer[LIBSPDM_SENDER_BUFFER_SIZE];
787 :
788 2 : message_session_id = NULL;
789 2 : session_id = 0xFFFFFFFF;
790 :
791 2 : session_info = libspdm_get_session_info_via_session_id(
792 : spdm_context, session_id);
793 2 : if (session_info == NULL) {
794 0 : return LIBSPDM_STATUS_SEND_FAIL;
795 : }
796 :
797 2 : memcpy(message_buffer, request, request_size);
798 :
799 : ((libspdm_secured_message_context_t
800 2 : *)(session_info->secured_message_context))
801 2 : ->application_secret.request_data_sequence_number--;
802 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&decoded_message,
803 : &decoded_message_size);
804 2 : status = libspdm_transport_test_decode_message(spdm_context,
805 : &message_session_id, &is_app_message,
806 : true,
807 : request_size,
808 : message_buffer, &decoded_message_size,
809 : (void **)&decoded_message);
810 2 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
811 0 : return LIBSPDM_STATUS_SEND_FAIL;
812 : }
813 :
814 2 : m_libspdm_last_token = ((spdm_key_update_request_t
815 2 : *) decoded_message)->header.param2;
816 : }
817 :
818 3 : sub_index++;
819 : }
820 3 : return LIBSPDM_STATUS_SUCCESS;
821 17 : case 0x22:
822 17 : return LIBSPDM_STATUS_SUCCESS;
823 1 : case 0x23:
824 1 : return LIBSPDM_STATUS_SUCCESS;
825 0 : default:
826 0 : return LIBSPDM_STATUS_SEND_FAIL;
827 : }
828 : }
829 :
830 127 : static libspdm_return_t receive_message(
831 : void *spdm_context, size_t *response_size, void **response, uint64_t timeout)
832 : {
833 : libspdm_test_context_t *spdm_test_context;
834 :
835 127 : spdm_test_context = libspdm_get_test_context();
836 127 : switch (spdm_test_context->case_id) {
837 0 : case 0x1:
838 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
839 :
840 2 : case 0x2: {
841 : static size_t sub_index = 0;
842 :
843 : spdm_key_update_response_t *spdm_response;
844 : size_t spdm_response_size;
845 : size_t transport_header_size;
846 : uint32_t session_id;
847 : libspdm_session_info_t *session_info;
848 : uint8_t *scratch_buffer;
849 : size_t scratch_buffer_size;
850 :
851 2 : spdm_response_size = sizeof(spdm_key_update_response_t);
852 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
853 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
854 :
855 2 : session_id = 0xFFFFFFFF;
856 :
857 2 : session_info = libspdm_get_session_info_via_session_id(
858 : spdm_context, session_id);
859 2 : if (session_info == NULL) {
860 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
861 : }
862 :
863 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
864 2 : spdm_response->header.request_response_code =
865 : SPDM_KEY_UPDATE_ACK;
866 2 : if (sub_index == 0) {
867 1 : spdm_response->header.param1 =
868 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
869 1 : spdm_response->header.param2 = m_libspdm_last_token;
870 1 : } else if (sub_index == 1) {
871 1 : spdm_response->header.param1 =
872 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_VERIFY_NEW_KEY;
873 1 : spdm_response->header.param2 = m_libspdm_last_token;
874 : }
875 :
876 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
877 : * transport_message is always in sender buffer. */
878 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
879 2 : libspdm_copy_mem (scratch_buffer + transport_header_size,
880 : scratch_buffer_size - transport_header_size,
881 : spdm_response, spdm_response_size);
882 2 : spdm_response = (void *)(scratch_buffer + transport_header_size);
883 2 : libspdm_transport_test_encode_message(spdm_context, &session_id,
884 : false, false, spdm_response_size,
885 : spdm_response, response_size, response);
886 : /* WALKAROUND: If just use single context to encode
887 : * message and then decode message */
888 : ((libspdm_secured_message_context_t
889 2 : *)(session_info->secured_message_context))
890 2 : ->application_secret.response_data_sequence_number--;
891 :
892 2 : sub_index++;
893 : }
894 2 : return LIBSPDM_STATUS_SUCCESS;
895 :
896 0 : case 0x3: {
897 : static size_t sub_index = 0;
898 :
899 : spdm_key_update_response_t *spdm_response;
900 : size_t spdm_response_size;
901 : size_t transport_header_size;
902 : uint32_t session_id;
903 : libspdm_session_info_t *session_info;
904 : uint8_t *scratch_buffer;
905 : size_t scratch_buffer_size;
906 :
907 0 : spdm_response_size = sizeof(spdm_key_update_response_t);
908 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
909 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
910 :
911 0 : session_id = 0xFFFFFFFF;
912 :
913 0 : session_info = libspdm_get_session_info_via_session_id(
914 : spdm_context, session_id);
915 0 : if (session_info == NULL) {
916 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
917 : }
918 :
919 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
920 0 : spdm_response->header.request_response_code =
921 : SPDM_KEY_UPDATE_ACK;
922 0 : if (sub_index == 0) {
923 0 : spdm_response->header.param1 =
924 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
925 0 : spdm_response->header.param2 = m_libspdm_last_token;
926 0 : } else if (sub_index == 1) {
927 0 : spdm_response->header.param1 =
928 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_VERIFY_NEW_KEY;
929 0 : spdm_response->header.param2 = m_libspdm_last_token;
930 : }
931 :
932 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
933 : * transport_message is always in sender buffer. */
934 0 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
935 0 : libspdm_copy_mem (scratch_buffer + transport_header_size,
936 : scratch_buffer_size - transport_header_size,
937 : spdm_response, spdm_response_size);
938 0 : spdm_response = (void *)(scratch_buffer + transport_header_size);
939 0 : libspdm_transport_test_encode_message(spdm_context, &session_id,
940 : false, false, spdm_response_size,
941 : spdm_response, response_size, response);
942 : /* WALKAROUND: If just use single context to encode
943 : * message and then decode message */
944 : ((libspdm_secured_message_context_t
945 0 : *)(session_info->secured_message_context))
946 0 : ->application_secret.response_data_sequence_number--;
947 :
948 0 : sub_index++;
949 : }
950 0 : return LIBSPDM_STATUS_SUCCESS;
951 :
952 1 : case 0x4: {
953 : spdm_error_response_t *spdm_response;
954 : size_t spdm_response_size;
955 : size_t transport_header_size;
956 : uint32_t session_id;
957 : libspdm_session_info_t *session_info;
958 : uint8_t *scratch_buffer;
959 : size_t scratch_buffer_size;
960 :
961 1 : spdm_response_size = sizeof(spdm_error_response_t);
962 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
963 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
964 :
965 1 : session_id = 0xFFFFFFFF;
966 1 : session_info = libspdm_get_session_info_via_session_id(
967 : spdm_context, session_id);
968 1 : if (session_info == NULL) {
969 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
970 : }
971 :
972 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
973 1 : spdm_response->header.request_response_code = SPDM_ERROR;
974 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_INVALID_REQUEST;
975 1 : spdm_response->header.param2 = 0;
976 :
977 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
978 : * transport_message is always in sender buffer. */
979 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
980 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
981 : scratch_buffer_size - transport_header_size,
982 : spdm_response, spdm_response_size);
983 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
984 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
985 : false, false, spdm_response_size,
986 : spdm_response, response_size, response);
987 : /* WALKAROUND: If just use single context to encode
988 : * message and then decode message */
989 : ((libspdm_secured_message_context_t
990 1 : *)(session_info->secured_message_context))
991 1 : ->application_secret.response_data_sequence_number--;
992 : }
993 1 : return LIBSPDM_STATUS_SUCCESS;
994 :
995 1 : case 0x5: {
996 : spdm_error_response_t *spdm_response;
997 : size_t spdm_response_size;
998 : size_t transport_header_size;
999 : uint32_t session_id;
1000 : libspdm_session_info_t *session_info;
1001 : uint8_t *scratch_buffer;
1002 : size_t scratch_buffer_size;
1003 :
1004 1 : spdm_response_size = sizeof(spdm_error_response_t);
1005 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1006 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1007 :
1008 1 : session_id = 0xFFFFFFFF;
1009 1 : session_info = libspdm_get_session_info_via_session_id(
1010 : spdm_context, session_id);
1011 1 : if (session_info == NULL) {
1012 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
1013 : }
1014 :
1015 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1016 1 : spdm_response->header.request_response_code = SPDM_ERROR;
1017 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
1018 1 : spdm_response->header.param2 = 0;
1019 :
1020 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1021 : * transport_message is always in sender buffer. */
1022 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
1023 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1024 : scratch_buffer_size - transport_header_size,
1025 : spdm_response, spdm_response_size);
1026 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1027 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
1028 : false, false, spdm_response_size,
1029 : spdm_response, response_size, response);
1030 : /* WALKAROUND: If just use single context to encode
1031 : * message and then decode message */
1032 : ((libspdm_secured_message_context_t
1033 1 : *)(session_info->secured_message_context))
1034 1 : ->application_secret.response_data_sequence_number--;
1035 : }
1036 1 : return LIBSPDM_STATUS_SUCCESS;
1037 :
1038 3 : case 0x6: {
1039 : static size_t sub_index = 0;
1040 :
1041 : uint32_t session_id;
1042 : libspdm_session_info_t *session_info;
1043 :
1044 3 : session_id = 0xFFFFFFFF;
1045 3 : session_info = libspdm_get_session_info_via_session_id(
1046 : spdm_context, session_id);
1047 3 : if (session_info == NULL) {
1048 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
1049 : }
1050 :
1051 3 : if (sub_index == 0) {
1052 : spdm_error_response_t *spdm_response;
1053 : size_t spdm_response_size;
1054 : size_t transport_header_size;
1055 : uint8_t *scratch_buffer;
1056 : size_t scratch_buffer_size;
1057 :
1058 1 : spdm_response_size = sizeof(spdm_error_response_t);
1059 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1060 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1061 :
1062 1 : spdm_response->header.spdm_version =
1063 : SPDM_MESSAGE_VERSION_11;
1064 1 : spdm_response->header.request_response_code = SPDM_ERROR;
1065 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
1066 1 : spdm_response->header.param2 = 0;
1067 :
1068 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1069 : * transport_message is always in sender buffer. */
1070 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
1071 : &scratch_buffer_size);
1072 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1073 : scratch_buffer_size - transport_header_size,
1074 : spdm_response, spdm_response_size);
1075 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1076 1 : libspdm_transport_test_encode_message(spdm_context,
1077 : &session_id, false, false,
1078 : spdm_response_size, spdm_response,
1079 : response_size, response);
1080 : /* WALKAROUND: If just use single context to encode
1081 : * message and then decode message */
1082 : ((libspdm_secured_message_context_t
1083 1 : *)(session_info->secured_message_context))
1084 1 : ->application_secret.response_data_sequence_number--;
1085 2 : } else if (sub_index == 1) {
1086 : spdm_key_update_response_t *spdm_response;
1087 : size_t spdm_response_size;
1088 : size_t transport_header_size;
1089 : uint8_t *scratch_buffer;
1090 : size_t scratch_buffer_size;
1091 :
1092 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
1093 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1094 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1095 :
1096 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1097 1 : spdm_response->header.request_response_code =
1098 : SPDM_KEY_UPDATE_ACK;
1099 1 : spdm_response->header.param1 =
1100 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
1101 1 : spdm_response->header.param2 = m_libspdm_last_token;
1102 :
1103 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1104 : * transport_message is always in sender buffer. */
1105 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
1106 : &scratch_buffer_size);
1107 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1108 : scratch_buffer_size - transport_header_size,
1109 : spdm_response, spdm_response_size);
1110 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1111 1 : libspdm_transport_test_encode_message(spdm_context,
1112 : &session_id, false, false,
1113 : spdm_response_size, spdm_response,
1114 : response_size, response);
1115 : /* WALKAROUND: If just use single context to encode
1116 : * message and then decode message */
1117 : ((libspdm_secured_message_context_t
1118 1 : *)(session_info->secured_message_context))
1119 1 : ->application_secret.response_data_sequence_number--;
1120 1 : } else if (sub_index == 2) {
1121 : spdm_key_update_response_t *spdm_response;
1122 : size_t spdm_response_size;
1123 : size_t transport_header_size;
1124 : uint8_t *scratch_buffer;
1125 : size_t scratch_buffer_size;
1126 :
1127 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
1128 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1129 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1130 :
1131 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1132 1 : spdm_response->header.request_response_code =
1133 : SPDM_KEY_UPDATE_ACK;
1134 1 : spdm_response->header.param1 =
1135 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_VERIFY_NEW_KEY;
1136 1 : spdm_response->header.param2 = m_libspdm_last_token;
1137 :
1138 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1139 : * transport_message is always in sender buffer. */
1140 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
1141 : &scratch_buffer_size);
1142 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1143 : scratch_buffer_size - transport_header_size,
1144 : spdm_response, spdm_response_size);
1145 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1146 1 : libspdm_transport_test_encode_message(spdm_context,
1147 : &session_id, false, false,
1148 : spdm_response_size, spdm_response,
1149 : response_size, response);
1150 : /* WALKAROUND: If just use single context to encode
1151 : * message and then decode message */
1152 : ((libspdm_secured_message_context_t
1153 1 : *)(session_info->secured_message_context))
1154 1 : ->application_secret.response_data_sequence_number--;
1155 : }
1156 :
1157 3 : sub_index++;
1158 : }
1159 3 : return LIBSPDM_STATUS_SUCCESS;
1160 :
1161 1 : case 0x7: {
1162 : spdm_error_response_t *spdm_response;
1163 : size_t spdm_response_size;
1164 : size_t transport_header_size;
1165 : uint32_t session_id;
1166 : libspdm_session_info_t *session_info;
1167 : uint8_t *scratch_buffer;
1168 : size_t scratch_buffer_size;
1169 :
1170 1 : spdm_response_size = sizeof(spdm_error_response_t);
1171 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1172 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1173 :
1174 1 : session_id = 0xFFFFFFFF;
1175 1 : session_info = libspdm_get_session_info_via_session_id(
1176 : spdm_context, session_id);
1177 1 : if (session_info == NULL) {
1178 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
1179 : }
1180 :
1181 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
1182 1 : spdm_response->header.request_response_code = SPDM_ERROR;
1183 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_REQUEST_RESYNCH;
1184 1 : spdm_response->header.param2 = 0;
1185 :
1186 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1187 : * transport_message is always in sender buffer. */
1188 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
1189 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1190 : scratch_buffer_size - transport_header_size,
1191 : spdm_response, spdm_response_size);
1192 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1193 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
1194 : false, false, spdm_response_size,
1195 : spdm_response, response_size, response);
1196 : /* WALKAROUND: If just use single context to encode
1197 : * message and then decode message */
1198 : ((libspdm_secured_message_context_t
1199 1 : *)(session_info->secured_message_context))
1200 1 : ->application_secret.response_data_sequence_number--;
1201 : }
1202 1 : return LIBSPDM_STATUS_SUCCESS;
1203 :
1204 2 : case 0x8: {
1205 : spdm_error_response_data_response_not_ready_t *spdm_response;
1206 : size_t spdm_response_size;
1207 : size_t transport_header_size;
1208 : uint32_t session_id;
1209 : libspdm_session_info_t *session_info;
1210 : uint8_t *scratch_buffer;
1211 : size_t scratch_buffer_size;
1212 :
1213 2 : spdm_response_size = sizeof(spdm_error_response_data_response_not_ready_t);
1214 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1215 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1216 :
1217 2 : session_id = 0xFFFFFFFF;
1218 2 : session_info = libspdm_get_session_info_via_session_id(
1219 : spdm_context, session_id);
1220 2 : if (session_info == NULL) {
1221 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
1222 : }
1223 :
1224 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1225 2 : spdm_response->header.request_response_code = SPDM_ERROR;
1226 2 : spdm_response->header.param1 =
1227 : SPDM_ERROR_CODE_RESPONSE_NOT_READY;
1228 2 : spdm_response->header.param2 = 0;
1229 2 : spdm_response->extend_error_data.rd_exponent = 1;
1230 2 : spdm_response->extend_error_data.rd_tm = 2;
1231 2 : spdm_response->extend_error_data.request_code = SPDM_KEY_UPDATE;
1232 2 : spdm_response->extend_error_data.token = 0;
1233 :
1234 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1235 : * transport_message is always in sender buffer. */
1236 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
1237 2 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1238 : scratch_buffer_size - transport_header_size,
1239 : spdm_response, spdm_response_size);
1240 2 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1241 2 : libspdm_transport_test_encode_message(spdm_context, &session_id,
1242 : false, false, spdm_response_size,
1243 : spdm_response, response_size, response);
1244 : /* WALKAROUND: If just use single context to encode
1245 : * message and then decode message */
1246 : ((libspdm_secured_message_context_t
1247 2 : *)(session_info->secured_message_context))
1248 2 : ->application_secret.response_data_sequence_number--;
1249 : }
1250 2 : return LIBSPDM_STATUS_SUCCESS;
1251 :
1252 3 : case 0x9: {
1253 : static size_t sub_index = 0;
1254 :
1255 : uint32_t session_id;
1256 : libspdm_session_info_t *session_info;
1257 :
1258 3 : session_id = 0xFFFFFFFF;
1259 3 : session_info = libspdm_get_session_info_via_session_id(
1260 : spdm_context, session_id);
1261 3 : if (session_info == NULL) {
1262 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
1263 : }
1264 :
1265 3 : if (sub_index == 0) {
1266 : spdm_error_response_data_response_not_ready_t
1267 : *spdm_response;
1268 : size_t spdm_response_size;
1269 : size_t transport_header_size;
1270 : uint8_t *scratch_buffer;
1271 : size_t scratch_buffer_size;
1272 :
1273 1 : spdm_response_size = sizeof(spdm_error_response_data_response_not_ready_t);
1274 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1275 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1276 :
1277 1 : spdm_response->header.spdm_version =
1278 : SPDM_MESSAGE_VERSION_11;
1279 1 : spdm_response->header.request_response_code = SPDM_ERROR;
1280 1 : spdm_response->header.param1 =
1281 : SPDM_ERROR_CODE_RESPONSE_NOT_READY;
1282 1 : spdm_response->header.param2 = 0;
1283 1 : spdm_response->extend_error_data.rd_exponent = 1;
1284 1 : spdm_response->extend_error_data.rd_tm = 2;
1285 1 : spdm_response->extend_error_data.request_code =
1286 : SPDM_KEY_UPDATE;
1287 1 : spdm_response->extend_error_data.token = 1;
1288 :
1289 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1290 : * transport_message is always in sender buffer. */
1291 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
1292 : &scratch_buffer_size);
1293 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1294 : scratch_buffer_size - transport_header_size,
1295 : spdm_response, spdm_response_size);
1296 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1297 1 : libspdm_transport_test_encode_message(spdm_context,
1298 : &session_id, false, false,
1299 : spdm_response_size, spdm_response,
1300 : response_size, response);
1301 : /* WALKAROUND: If just use single context to encode
1302 : * message and then decode message */
1303 : ((libspdm_secured_message_context_t
1304 1 : *)(session_info->secured_message_context))
1305 1 : ->application_secret.response_data_sequence_number--;
1306 2 : } else if (sub_index == 1) {
1307 : spdm_key_update_response_t *spdm_response;
1308 : size_t spdm_response_size;
1309 : size_t transport_header_size;
1310 : uint8_t *scratch_buffer;
1311 : size_t scratch_buffer_size;
1312 :
1313 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
1314 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1315 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1316 :
1317 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1318 1 : spdm_response->header.request_response_code =
1319 : SPDM_KEY_UPDATE_ACK;
1320 1 : spdm_response->header.param1 =
1321 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
1322 1 : spdm_response->header.param2 = m_libspdm_last_token;
1323 :
1324 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1325 : * transport_message is always in sender buffer. */
1326 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
1327 : &scratch_buffer_size);
1328 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1329 : scratch_buffer_size - transport_header_size,
1330 : spdm_response, spdm_response_size);
1331 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1332 1 : libspdm_transport_test_encode_message(spdm_context,
1333 : &session_id, false, false,
1334 : spdm_response_size, spdm_response,
1335 : response_size, response);
1336 : /* WALKAROUND: If just use single context to encode
1337 : * message and then decode message */
1338 : ((libspdm_secured_message_context_t
1339 1 : *)(session_info->secured_message_context))
1340 1 : ->application_secret.response_data_sequence_number--;
1341 1 : } else if (sub_index == 2) {
1342 : spdm_key_update_response_t *spdm_response;
1343 : size_t spdm_response_size;
1344 : size_t transport_header_size;
1345 : uint8_t *scratch_buffer;
1346 : size_t scratch_buffer_size;
1347 :
1348 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
1349 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1350 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1351 :
1352 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1353 1 : spdm_response->header.request_response_code =
1354 : SPDM_KEY_UPDATE_ACK;
1355 1 : spdm_response->header.param1 =
1356 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_VERIFY_NEW_KEY;
1357 1 : spdm_response->header.param2 = m_libspdm_last_token;
1358 :
1359 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1360 : * transport_message is always in sender buffer. */
1361 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
1362 : &scratch_buffer_size);
1363 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1364 : scratch_buffer_size - transport_header_size,
1365 : spdm_response, spdm_response_size);
1366 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1367 1 : libspdm_transport_test_encode_message(spdm_context,
1368 : &session_id, false, false,
1369 : spdm_response_size, spdm_response,
1370 : response_size, response);
1371 : /* WALKAROUND: If just use single context to encode
1372 : * message and then decode message */
1373 : ((libspdm_secured_message_context_t
1374 1 : *)(session_info->secured_message_context))
1375 1 : ->application_secret.response_data_sequence_number--;
1376 : }
1377 :
1378 3 : sub_index++;
1379 : }
1380 3 : return LIBSPDM_STATUS_SUCCESS;
1381 :
1382 17 : case 0xA: {
1383 : static uint16_t error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
1384 :
1385 : uint32_t session_id;
1386 : libspdm_session_info_t *session_info;
1387 :
1388 : spdm_error_response_t *spdm_response;
1389 : size_t spdm_response_size;
1390 : size_t transport_header_size;
1391 : uint8_t *scratch_buffer;
1392 : size_t scratch_buffer_size;
1393 :
1394 17 : spdm_response_size = sizeof(spdm_error_response_t);
1395 17 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1396 17 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1397 :
1398 17 : session_id = 0xFFFFFFFF;
1399 17 : session_info = libspdm_get_session_info_via_session_id(
1400 : spdm_context, session_id);
1401 17 : if (session_info == NULL) {
1402 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
1403 : }
1404 :
1405 17 : if(error_code <= 0xff) {
1406 : /* skip SPDM_ERROR_CODE_DECRYPT_ERROR, because this case will free context*/
1407 17 : if(error_code == SPDM_ERROR_CODE_DECRYPT_ERROR) {
1408 1 : error_code++;
1409 : }
1410 17 : libspdm_zero_mem (spdm_response, spdm_response_size);
1411 17 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1412 17 : spdm_response->header.request_response_code = SPDM_ERROR;
1413 17 : spdm_response->header.param1 = (uint8_t) error_code;
1414 17 : spdm_response->header.param2 = 0;
1415 :
1416 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1417 : * transport_message is always in sender buffer. */
1418 17 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
1419 : &scratch_buffer_size);
1420 17 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1421 : scratch_buffer_size - transport_header_size,
1422 : spdm_response, spdm_response_size);
1423 17 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1424 17 : libspdm_transport_test_encode_message(spdm_context,
1425 : &session_id, false, false,
1426 : spdm_response_size, spdm_response,
1427 : response_size, response);
1428 : /* WALKAROUND: If just use single context to encode
1429 : * message and then decode message */
1430 : ((libspdm_secured_message_context_t
1431 17 : *)(session_info->secured_message_context))
1432 17 : ->application_secret.response_data_sequence_number--;
1433 : }
1434 :
1435 17 : error_code++;
1436 : /*busy is treated in cases 5 and 6*/
1437 17 : if(error_code == SPDM_ERROR_CODE_BUSY) {
1438 1 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
1439 : }
1440 : /*skip some reserved error codes (0d to 3e)*/
1441 17 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) {
1442 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
1443 : }
1444 : /*skip response not ready, request resync, and some reserved codes (44 to fc)*/
1445 17 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) {
1446 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
1447 : }
1448 : }
1449 17 : return LIBSPDM_STATUS_SUCCESS;
1450 :
1451 2 : case 0xB: {
1452 : static size_t sub_index = 0;
1453 :
1454 : spdm_key_update_response_t *spdm_response;
1455 : size_t spdm_response_size;
1456 : size_t transport_header_size;
1457 : uint32_t session_id;
1458 : libspdm_session_info_t *session_info;
1459 : uint8_t *scratch_buffer;
1460 : size_t scratch_buffer_size;
1461 :
1462 2 : spdm_response_size = sizeof(spdm_key_update_response_t);
1463 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1464 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1465 :
1466 2 : session_id = 0xFFFFFFFF;
1467 :
1468 2 : session_info = libspdm_get_session_info_via_session_id(
1469 : spdm_context, session_id);
1470 2 : if (session_info == NULL) {
1471 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
1472 : }
1473 :
1474 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1475 2 : spdm_response->header.request_response_code =
1476 : SPDM_KEY_UPDATE_ACK;
1477 2 : if (sub_index == 0) {
1478 1 : spdm_response->header.param1 =
1479 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
1480 1 : spdm_response->header.param2 = m_libspdm_last_token;
1481 1 : } else if (sub_index == 1) {
1482 1 : spdm_response->header.param1 =
1483 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_VERIFY_NEW_KEY;
1484 1 : spdm_response->header.param2 = m_libspdm_last_token;
1485 : }
1486 :
1487 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1488 : * transport_message is always in sender buffer. */
1489 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
1490 2 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1491 : scratch_buffer_size - transport_header_size,
1492 : spdm_response, spdm_response_size);
1493 2 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1494 2 : libspdm_transport_test_encode_message(spdm_context, &session_id,
1495 : false, false, spdm_response_size,
1496 : spdm_response, response_size, response);
1497 : /* WALKAROUND: If just use single context to encode
1498 : * message and then decode message */
1499 : ((libspdm_secured_message_context_t
1500 2 : *)(session_info->secured_message_context))
1501 2 : ->application_secret.response_data_sequence_number--;
1502 :
1503 2 : sub_index++;
1504 : }
1505 2 : return LIBSPDM_STATUS_SUCCESS;
1506 :
1507 1 : case 0xC: {
1508 : static size_t sub_index = 0;
1509 :
1510 : spdm_key_update_response_t *spdm_response;
1511 : size_t spdm_response_size;
1512 : size_t transport_header_size;
1513 : uint32_t session_id;
1514 : libspdm_session_info_t *session_info;
1515 : uint8_t *scratch_buffer;
1516 : size_t scratch_buffer_size;
1517 :
1518 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
1519 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1520 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1521 :
1522 1 : session_id = 0xFFFFFFFF;
1523 :
1524 1 : session_info = libspdm_get_session_info_via_session_id(
1525 : spdm_context, session_id);
1526 1 : if (session_info == NULL) {
1527 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
1528 : }
1529 :
1530 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1531 : /*wrong response code*/
1532 1 : spdm_response->header.request_response_code =
1533 : SPDM_KEY_UPDATE;
1534 1 : if (sub_index == 0) {
1535 1 : spdm_response->header.param1 =
1536 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
1537 1 : spdm_response->header.param2 = m_libspdm_last_token;
1538 0 : } else if (sub_index == 1) {
1539 0 : spdm_response->header.param1 =
1540 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_VERIFY_NEW_KEY;
1541 0 : spdm_response->header.param2 = m_libspdm_last_token;
1542 : }
1543 :
1544 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1545 : * transport_message is always in sender buffer. */
1546 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
1547 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1548 : scratch_buffer_size - transport_header_size,
1549 : spdm_response, spdm_response_size);
1550 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1551 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
1552 : false, false, spdm_response_size,
1553 : spdm_response, response_size, response);
1554 : /* WALKAROUND: If just use single context to encode
1555 : * message and then decode message */
1556 : ((libspdm_secured_message_context_t
1557 1 : *)(session_info->secured_message_context))
1558 1 : ->application_secret.response_data_sequence_number--;
1559 :
1560 1 : sub_index++;
1561 : }
1562 1 : return LIBSPDM_STATUS_SUCCESS;
1563 :
1564 0 : case 0xD: {
1565 : static size_t sub_index = 0;
1566 :
1567 : spdm_key_update_response_t *spdm_response;
1568 : size_t spdm_response_size;
1569 : size_t transport_header_size;
1570 : uint32_t session_id;
1571 : libspdm_session_info_t *session_info;
1572 : uint8_t *scratch_buffer;
1573 : size_t scratch_buffer_size;
1574 :
1575 0 : spdm_response_size = sizeof(spdm_key_update_response_t);
1576 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1577 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1578 :
1579 0 : session_id = 0xFFFFFFFF;
1580 :
1581 0 : session_info = libspdm_get_session_info_via_session_id(
1582 : spdm_context, session_id);
1583 0 : if (session_info == NULL) {
1584 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
1585 : }
1586 :
1587 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1588 0 : spdm_response->header.request_response_code =
1589 : SPDM_KEY_UPDATE_ACK;
1590 0 : if (sub_index == 0) {
1591 0 : spdm_response->header.param1 =
1592 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
1593 0 : spdm_response->header.param2 = m_libspdm_last_token;
1594 0 : } else if (sub_index == 1) {
1595 0 : spdm_response->header.param1 =
1596 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_VERIFY_NEW_KEY;
1597 0 : spdm_response->header.param2 = m_libspdm_last_token;
1598 : }
1599 :
1600 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1601 : * transport_message is always in sender buffer. */
1602 0 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
1603 0 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1604 : scratch_buffer_size - transport_header_size,
1605 : spdm_response, spdm_response_size);
1606 0 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1607 0 : libspdm_transport_test_encode_message(spdm_context, &session_id,
1608 : false, false, spdm_response_size,
1609 : spdm_response, response_size, response);
1610 : /* WALKAROUND: If just use single context to encode
1611 : * message and then decode message */
1612 : ((libspdm_secured_message_context_t
1613 0 : *)(session_info->secured_message_context))
1614 0 : ->application_secret.response_data_sequence_number--;
1615 :
1616 0 : sub_index++;
1617 : }
1618 0 : return LIBSPDM_STATUS_SUCCESS;
1619 :
1620 0 : case 0xE: {
1621 : static size_t sub_index = 0;
1622 :
1623 : spdm_key_update_response_t *spdm_response;
1624 : size_t spdm_response_size;
1625 : size_t transport_header_size;
1626 : uint32_t session_id;
1627 : libspdm_session_info_t *session_info;
1628 : uint8_t *scratch_buffer;
1629 : size_t scratch_buffer_size;
1630 :
1631 0 : spdm_response_size = sizeof(spdm_key_update_response_t);
1632 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1633 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1634 :
1635 0 : session_id = 0xFFFFFFFF;
1636 :
1637 0 : session_info = libspdm_get_session_info_via_session_id(
1638 : spdm_context, session_id);
1639 0 : if (session_info == NULL) {
1640 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
1641 : }
1642 :
1643 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1644 0 : spdm_response->header.request_response_code =
1645 : SPDM_KEY_UPDATE_ACK;
1646 0 : if (sub_index == 0) {
1647 0 : spdm_response->header.param1 =
1648 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
1649 0 : spdm_response->header.param2 = m_libspdm_last_token;
1650 0 : } else if (sub_index == 1) {
1651 0 : spdm_response->header.param1 =
1652 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_VERIFY_NEW_KEY;
1653 0 : spdm_response->header.param2 = m_libspdm_last_token;
1654 : }
1655 :
1656 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1657 : * transport_message is always in sender buffer. */
1658 0 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
1659 0 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1660 : scratch_buffer_size - transport_header_size,
1661 : spdm_response, spdm_response_size);
1662 0 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1663 0 : libspdm_transport_test_encode_message(spdm_context, &session_id,
1664 : false, false, spdm_response_size,
1665 : spdm_response, response_size, response);
1666 : /* WALKAROUND: If just use single context to encode
1667 : * message and then decode message */
1668 : ((libspdm_secured_message_context_t
1669 0 : *)(session_info->secured_message_context))
1670 0 : ->application_secret.response_data_sequence_number--;
1671 :
1672 0 : sub_index++;
1673 : }
1674 0 : return LIBSPDM_STATUS_SUCCESS;
1675 :
1676 1 : case 0xF: {
1677 : static size_t sub_index = 0;
1678 :
1679 : spdm_key_update_response_t *spdm_response;
1680 : size_t spdm_response_size;
1681 : size_t transport_header_size;
1682 : uint32_t session_id;
1683 : libspdm_session_info_t *session_info;
1684 : uint8_t *scratch_buffer;
1685 : size_t scratch_buffer_size;
1686 :
1687 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
1688 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1689 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1690 :
1691 1 : session_id = 0xFFFFFFFF;
1692 :
1693 1 : session_info = libspdm_get_session_info_via_session_id(
1694 : spdm_context, session_id);
1695 1 : if (session_info == NULL) {
1696 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
1697 : }
1698 :
1699 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1700 1 : spdm_response->header.request_response_code =
1701 : SPDM_KEY_UPDATE_ACK;
1702 1 : if (sub_index == 0) {
1703 1 : spdm_response->header.param1 =
1704 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
1705 : /*wrong token*/
1706 1 : spdm_response->header.param2 = m_libspdm_last_token + 1;
1707 0 : } else if (sub_index == 1) {
1708 0 : spdm_response->header.param1 =
1709 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_VERIFY_NEW_KEY;
1710 0 : spdm_response->header.param2 = m_libspdm_last_token;
1711 : }
1712 :
1713 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1714 : * transport_message is always in sender buffer. */
1715 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
1716 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1717 : scratch_buffer_size - transport_header_size,
1718 : spdm_response, spdm_response_size);
1719 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1720 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
1721 : false, false, spdm_response_size,
1722 : spdm_response, response_size, response);
1723 : /* WALKAROUND: If just use single context to encode
1724 : * message and then decode message */
1725 : ((libspdm_secured_message_context_t
1726 1 : *)(session_info->secured_message_context))
1727 1 : ->application_secret.response_data_sequence_number--;
1728 :
1729 1 : sub_index++;
1730 : }
1731 1 : return LIBSPDM_STATUS_SUCCESS;
1732 :
1733 1 : case 0x10: {
1734 : static size_t sub_index = 0;
1735 :
1736 : spdm_key_update_response_t *spdm_response;
1737 : size_t spdm_response_size;
1738 : size_t transport_header_size;
1739 : uint32_t session_id;
1740 : libspdm_session_info_t *session_info;
1741 : uint8_t *scratch_buffer;
1742 : size_t scratch_buffer_size;
1743 :
1744 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
1745 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1746 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1747 :
1748 1 : session_id = 0xFFFFFFFF;
1749 :
1750 1 : session_info = libspdm_get_session_info_via_session_id(
1751 : spdm_context, session_id);
1752 1 : if (session_info == NULL) {
1753 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
1754 : }
1755 :
1756 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1757 1 : spdm_response->header.request_response_code =
1758 : SPDM_KEY_UPDATE_ACK;
1759 1 : if (sub_index == 0) {
1760 : /*wrong operation code*/
1761 1 : spdm_response->header.param1 =
1762 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_ALL_KEYS;
1763 1 : spdm_response->header.param2 = m_libspdm_last_token;
1764 0 : } else if (sub_index == 1) {
1765 0 : spdm_response->header.param1 =
1766 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_VERIFY_NEW_KEY;
1767 0 : spdm_response->header.param2 = m_libspdm_last_token;
1768 : }
1769 :
1770 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1771 : * transport_message is always in sender buffer. */
1772 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
1773 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1774 : scratch_buffer_size - transport_header_size,
1775 : spdm_response, spdm_response_size);
1776 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1777 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
1778 : false, false, spdm_response_size,
1779 : spdm_response, response_size, response);
1780 : /* WALKAROUND: If just use single context to encode
1781 : * message and then decode message */
1782 : ((libspdm_secured_message_context_t
1783 1 : *)(session_info->secured_message_context))
1784 1 : ->application_secret.response_data_sequence_number--;
1785 :
1786 1 : sub_index++;
1787 : }
1788 1 : return LIBSPDM_STATUS_SUCCESS;
1789 :
1790 2 : case 0x11: {
1791 : static size_t sub_index = 0;
1792 :
1793 : uint32_t session_id;
1794 : libspdm_session_info_t *session_info;
1795 :
1796 2 : session_id = 0xFFFFFFFF;
1797 2 : session_info = libspdm_get_session_info_via_session_id(
1798 : spdm_context, session_id);
1799 2 : if (session_info == NULL) {
1800 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
1801 : }
1802 :
1803 2 : if (sub_index == 0) {
1804 : spdm_key_update_response_t *spdm_response;
1805 : size_t spdm_response_size;
1806 : size_t transport_header_size;
1807 : uint8_t *scratch_buffer;
1808 : size_t scratch_buffer_size;
1809 :
1810 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
1811 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1812 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1813 :
1814 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1815 1 : spdm_response->header.request_response_code =
1816 : SPDM_KEY_UPDATE_ACK;
1817 1 : spdm_response->header.param1 =
1818 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
1819 1 : spdm_response->header.param2 = m_libspdm_last_token;
1820 :
1821 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1822 : * transport_message is always in sender buffer. */
1823 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
1824 : &scratch_buffer_size);
1825 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1826 : scratch_buffer_size - transport_header_size,
1827 : spdm_response, spdm_response_size);
1828 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1829 1 : libspdm_transport_test_encode_message(spdm_context,
1830 : &session_id, false, false,
1831 : spdm_response_size, spdm_response,
1832 : response_size, response);
1833 : /* WALKAROUND: If just use single context to encode
1834 : * message and then decode message */
1835 : ((libspdm_secured_message_context_t
1836 1 : *)(session_info->secured_message_context))
1837 1 : ->application_secret.response_data_sequence_number--;
1838 1 : } else if (sub_index == 1) {
1839 : spdm_error_response_t *spdm_response;
1840 : size_t spdm_response_size;
1841 : size_t transport_header_size;
1842 : uint8_t *scratch_buffer;
1843 : size_t scratch_buffer_size;
1844 :
1845 1 : spdm_response_size = sizeof(spdm_error_response_t);
1846 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1847 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1848 :
1849 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1850 1 : spdm_response->header.request_response_code = SPDM_ERROR;
1851 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_INVALID_REQUEST;
1852 1 : spdm_response->header.param2 = 0;
1853 :
1854 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1855 : * transport_message is always in sender buffer. */
1856 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
1857 : &scratch_buffer_size);
1858 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1859 : scratch_buffer_size - transport_header_size,
1860 : spdm_response, spdm_response_size);
1861 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1862 1 : libspdm_transport_test_encode_message(spdm_context,
1863 : &session_id, false, false,
1864 : spdm_response_size, spdm_response,
1865 : response_size, response);
1866 : /* WALKAROUND: If just use single context to encode
1867 : * message and then decode message */
1868 : ((libspdm_secured_message_context_t
1869 1 : *)(session_info->secured_message_context))
1870 1 : ->application_secret.response_data_sequence_number--;
1871 : }
1872 :
1873 2 : sub_index++;
1874 : }
1875 2 : return LIBSPDM_STATUS_SUCCESS;
1876 :
1877 5 : case 0x12: {
1878 : static size_t sub_index = 0;
1879 :
1880 : uint32_t session_id;
1881 : libspdm_session_info_t *session_info;
1882 :
1883 5 : session_id = 0xFFFFFFFF;
1884 5 : session_info = libspdm_get_session_info_via_session_id(
1885 : spdm_context, session_id);
1886 5 : if (session_info == NULL) {
1887 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
1888 : }
1889 :
1890 5 : if (sub_index == 0) {
1891 : spdm_key_update_response_t *spdm_response;
1892 : size_t spdm_response_size;
1893 : size_t transport_header_size;
1894 : uint8_t *scratch_buffer;
1895 : size_t scratch_buffer_size;
1896 :
1897 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
1898 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1899 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1900 :
1901 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1902 1 : spdm_response->header.request_response_code =
1903 : SPDM_KEY_UPDATE_ACK;
1904 1 : spdm_response->header.param1 =
1905 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
1906 1 : spdm_response->header.param2 = m_libspdm_last_token;
1907 :
1908 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1909 : * transport_message is always in sender buffer. */
1910 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
1911 : &scratch_buffer_size);
1912 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1913 : scratch_buffer_size - transport_header_size,
1914 : spdm_response, spdm_response_size);
1915 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1916 1 : libspdm_transport_test_encode_message(spdm_context,
1917 : &session_id, false, false,
1918 : spdm_response_size, spdm_response,
1919 : response_size, response);
1920 : /* WALKAROUND: If just use single context to encode
1921 : * message and then decode message */
1922 : ((libspdm_secured_message_context_t
1923 1 : *)(session_info->secured_message_context))
1924 1 : ->application_secret.response_data_sequence_number--;
1925 : } else {
1926 : spdm_error_response_t *spdm_response;
1927 : size_t spdm_response_size;
1928 : size_t transport_header_size;
1929 : uint8_t *scratch_buffer;
1930 : size_t scratch_buffer_size;
1931 :
1932 4 : spdm_response_size = sizeof(spdm_error_response_t);
1933 4 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1934 4 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1935 :
1936 4 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1937 4 : spdm_response->header.request_response_code = SPDM_ERROR;
1938 4 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
1939 4 : spdm_response->header.param2 = 0;
1940 :
1941 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1942 : * transport_message is always in sender buffer. */
1943 4 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
1944 : &scratch_buffer_size);
1945 4 : libspdm_copy_mem (scratch_buffer + transport_header_size,
1946 : scratch_buffer_size - transport_header_size,
1947 : spdm_response, spdm_response_size);
1948 4 : spdm_response = (void *)(scratch_buffer + transport_header_size);
1949 4 : libspdm_transport_test_encode_message(spdm_context,
1950 : &session_id, false, false,
1951 : spdm_response_size, spdm_response,
1952 : response_size, response);
1953 : /* WALKAROUND: If just use single context to encode
1954 : * message and then decode message */
1955 : ((libspdm_secured_message_context_t
1956 4 : *)(session_info->secured_message_context))
1957 4 : ->application_secret.response_data_sequence_number--;
1958 : }
1959 :
1960 5 : sub_index++;
1961 : }
1962 5 : return LIBSPDM_STATUS_SUCCESS;
1963 :
1964 3 : case 0x13: {
1965 : static size_t sub_index = 0;
1966 :
1967 : uint32_t session_id;
1968 : libspdm_session_info_t *session_info;
1969 :
1970 3 : session_id = 0xFFFFFFFF;
1971 3 : session_info = libspdm_get_session_info_via_session_id(
1972 : spdm_context, session_id);
1973 3 : if (session_info == NULL) {
1974 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
1975 : }
1976 :
1977 3 : if (sub_index == 0) {
1978 : spdm_key_update_response_t *spdm_response;
1979 : size_t spdm_response_size;
1980 : size_t transport_header_size;
1981 : uint8_t *scratch_buffer;
1982 : size_t scratch_buffer_size;
1983 :
1984 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
1985 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1986 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1987 :
1988 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1989 1 : spdm_response->header.request_response_code =
1990 : SPDM_KEY_UPDATE_ACK;
1991 1 : spdm_response->header.param1 =
1992 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
1993 1 : spdm_response->header.param2 = m_libspdm_last_token;
1994 :
1995 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
1996 : * transport_message is always in sender buffer. */
1997 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
1998 : &scratch_buffer_size);
1999 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2000 : scratch_buffer_size - transport_header_size,
2001 : spdm_response, spdm_response_size);
2002 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2003 1 : libspdm_transport_test_encode_message(spdm_context,
2004 : &session_id, false, false,
2005 : spdm_response_size, spdm_response,
2006 : response_size, response);
2007 : /* WALKAROUND: If just use single context to encode
2008 : * message and then decode message */
2009 : ((libspdm_secured_message_context_t
2010 1 : *)(session_info->secured_message_context))
2011 1 : ->application_secret.response_data_sequence_number--;
2012 2 : } else if (sub_index == 1) {
2013 : spdm_error_response_t *spdm_response;
2014 : size_t spdm_response_size;
2015 : size_t transport_header_size;
2016 : uint8_t *scratch_buffer;
2017 : size_t scratch_buffer_size;
2018 :
2019 1 : spdm_response_size = sizeof(spdm_error_response_t);
2020 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2021 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2022 :
2023 1 : spdm_response->header.spdm_version =
2024 : SPDM_MESSAGE_VERSION_11;
2025 1 : spdm_response->header.request_response_code = SPDM_ERROR;
2026 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
2027 1 : spdm_response->header.param2 = 0;
2028 :
2029 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2030 : * transport_message is always in sender buffer. */
2031 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
2032 : &scratch_buffer_size);
2033 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2034 : scratch_buffer_size - transport_header_size,
2035 : spdm_response, spdm_response_size);
2036 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2037 1 : libspdm_transport_test_encode_message(spdm_context,
2038 : &session_id, false, false,
2039 : spdm_response_size, spdm_response,
2040 : response_size, response);
2041 : /* WALKAROUND: If just use single context to encode
2042 : * message and then decode message */
2043 : ((libspdm_secured_message_context_t
2044 1 : *)(session_info->secured_message_context))
2045 1 : ->application_secret.response_data_sequence_number--;
2046 1 : } else if (sub_index == 2) {
2047 : spdm_key_update_response_t *spdm_response;
2048 : size_t spdm_response_size;
2049 : size_t transport_header_size;
2050 : uint8_t *scratch_buffer;
2051 : size_t scratch_buffer_size;
2052 :
2053 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
2054 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2055 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2056 :
2057 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2058 1 : spdm_response->header.request_response_code =
2059 : SPDM_KEY_UPDATE_ACK;
2060 1 : spdm_response->header.param1 =
2061 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_VERIFY_NEW_KEY;
2062 1 : spdm_response->header.param2 = m_libspdm_last_token;
2063 :
2064 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2065 : * transport_message is always in sender buffer. */
2066 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
2067 : &scratch_buffer_size);
2068 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2069 : scratch_buffer_size - transport_header_size,
2070 : spdm_response, spdm_response_size);
2071 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2072 1 : libspdm_transport_test_encode_message(spdm_context,
2073 : &session_id, false, false,
2074 : spdm_response_size, spdm_response,
2075 : response_size, response);
2076 : /* WALKAROUND: If just use single context to encode
2077 : * message and then decode message */
2078 : ((libspdm_secured_message_context_t
2079 1 : *)(session_info->secured_message_context))
2080 1 : ->application_secret.response_data_sequence_number--;
2081 : }
2082 :
2083 3 : sub_index++;
2084 : }
2085 3 : return LIBSPDM_STATUS_SUCCESS;
2086 :
2087 2 : case 0x14: {
2088 : static size_t sub_index = 0;
2089 :
2090 : uint32_t session_id;
2091 : libspdm_session_info_t *session_info;
2092 :
2093 2 : session_id = 0xFFFFFFFF;
2094 2 : session_info = libspdm_get_session_info_via_session_id(
2095 : spdm_context, session_id);
2096 2 : if (session_info == NULL) {
2097 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
2098 : }
2099 :
2100 2 : if (sub_index == 0) {
2101 : spdm_key_update_response_t *spdm_response;
2102 : size_t spdm_response_size;
2103 : size_t transport_header_size;
2104 : uint8_t *scratch_buffer;
2105 : size_t scratch_buffer_size;
2106 :
2107 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
2108 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2109 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2110 :
2111 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2112 1 : spdm_response->header.request_response_code =
2113 : SPDM_KEY_UPDATE_ACK;
2114 1 : spdm_response->header.param1 =
2115 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
2116 1 : spdm_response->header.param2 = m_libspdm_last_token;
2117 :
2118 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2119 : * transport_message is always in sender buffer. */
2120 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
2121 : &scratch_buffer_size);
2122 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2123 : scratch_buffer_size - transport_header_size,
2124 : spdm_response, spdm_response_size);
2125 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2126 1 : libspdm_transport_test_encode_message(spdm_context,
2127 : &session_id, false, false,
2128 : spdm_response_size, spdm_response,
2129 : response_size, response);
2130 : /* WALKAROUND: If just use single context to encode
2131 : * message and then decode message */
2132 : ((libspdm_secured_message_context_t
2133 1 : *)(session_info->secured_message_context))
2134 1 : ->application_secret.response_data_sequence_number--;
2135 1 : } else if (sub_index == 1) {
2136 : spdm_error_response_t *spdm_response;
2137 : size_t spdm_response_size;
2138 : size_t transport_header_size;
2139 : uint8_t *scratch_buffer;
2140 : size_t scratch_buffer_size;
2141 :
2142 1 : spdm_response_size = sizeof(spdm_error_response_t);
2143 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2144 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2145 :
2146 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
2147 1 : spdm_response->header.request_response_code = SPDM_ERROR;
2148 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_REQUEST_RESYNCH;
2149 1 : spdm_response->header.param2 = 0;
2150 :
2151 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2152 : * transport_message is always in sender buffer. */
2153 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
2154 : &scratch_buffer_size);
2155 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2156 : scratch_buffer_size - transport_header_size,
2157 : spdm_response, spdm_response_size);
2158 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2159 1 : libspdm_transport_test_encode_message(spdm_context,
2160 : &session_id, false, false,
2161 : spdm_response_size, spdm_response,
2162 : response_size, response);
2163 : /* WALKAROUND: If just use single context to encode
2164 : * message and then decode message */
2165 : ((libspdm_secured_message_context_t
2166 1 : *)(session_info->secured_message_context))
2167 1 : ->application_secret.response_data_sequence_number--;
2168 : }
2169 :
2170 2 : sub_index++;
2171 : }
2172 2 : return LIBSPDM_STATUS_SUCCESS;
2173 :
2174 3 : case 0x15: {
2175 : static size_t sub_index = 0;
2176 :
2177 : uint32_t session_id;
2178 : libspdm_session_info_t *session_info;
2179 :
2180 3 : session_id = 0xFFFFFFFF;
2181 3 : session_info = libspdm_get_session_info_via_session_id(
2182 : spdm_context, session_id);
2183 3 : if (session_info == NULL) {
2184 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
2185 : }
2186 :
2187 3 : if (sub_index == 0) {
2188 : spdm_key_update_response_t *spdm_response;
2189 : size_t spdm_response_size;
2190 : size_t transport_header_size;
2191 : uint8_t *scratch_buffer;
2192 : size_t scratch_buffer_size;
2193 :
2194 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
2195 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2196 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2197 :
2198 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2199 1 : spdm_response->header.request_response_code =
2200 : SPDM_KEY_UPDATE_ACK;
2201 1 : spdm_response->header.param1 =
2202 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
2203 1 : spdm_response->header.param2 = m_libspdm_last_token;
2204 :
2205 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2206 : * transport_message is always in sender buffer. */
2207 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
2208 : &scratch_buffer_size);
2209 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2210 : scratch_buffer_size - transport_header_size,
2211 : spdm_response, spdm_response_size);
2212 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2213 1 : libspdm_transport_test_encode_message(spdm_context,
2214 : &session_id, false, false,
2215 : spdm_response_size, spdm_response,
2216 : response_size, response);
2217 : /* WALKAROUND: If just use single context to encode
2218 : * message and then decode message */
2219 : ((libspdm_secured_message_context_t
2220 1 : *)(session_info->secured_message_context))
2221 1 : ->application_secret.response_data_sequence_number--;
2222 : } else {
2223 : spdm_error_response_data_response_not_ready_t *spdm_response;
2224 : size_t spdm_response_size;
2225 : size_t transport_header_size;
2226 : uint8_t *scratch_buffer;
2227 : size_t scratch_buffer_size;
2228 :
2229 2 : spdm_response_size = sizeof(spdm_error_response_data_response_not_ready_t);
2230 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2231 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2232 :
2233 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2234 2 : spdm_response->header.request_response_code = SPDM_ERROR;
2235 2 : spdm_response->header.param1 =
2236 : SPDM_ERROR_CODE_RESPONSE_NOT_READY;
2237 2 : spdm_response->header.param2 = 0;
2238 2 : spdm_response->extend_error_data.rd_exponent = 1;
2239 2 : spdm_response->extend_error_data.rd_tm = 2;
2240 2 : spdm_response->extend_error_data.request_code = SPDM_KEY_UPDATE;
2241 2 : spdm_response->extend_error_data.token = 0;
2242 :
2243 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2244 : * transport_message is always in sender buffer. */
2245 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
2246 : &scratch_buffer_size);
2247 2 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2248 : scratch_buffer_size - transport_header_size,
2249 : spdm_response, spdm_response_size);
2250 2 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2251 2 : libspdm_transport_test_encode_message(spdm_context,
2252 : &session_id, false, false,
2253 : spdm_response_size, spdm_response,
2254 : response_size, response);
2255 : /* WALKAROUND: If just use single context to encode
2256 : * message and then decode message */
2257 : ((libspdm_secured_message_context_t
2258 2 : *)(session_info->secured_message_context))
2259 2 : ->application_secret.response_data_sequence_number--;
2260 : }
2261 :
2262 3 : sub_index++;
2263 : }
2264 3 : return LIBSPDM_STATUS_SUCCESS;
2265 :
2266 3 : case 0x16: {
2267 : static size_t sub_index = 0;
2268 :
2269 : uint32_t session_id;
2270 : libspdm_session_info_t *session_info;
2271 :
2272 3 : session_id = 0xFFFFFFFF;
2273 3 : session_info = libspdm_get_session_info_via_session_id(
2274 : spdm_context, session_id);
2275 3 : if (session_info == NULL) {
2276 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
2277 : }
2278 :
2279 3 : if (sub_index == 0) {
2280 : spdm_key_update_response_t *spdm_response;
2281 : size_t spdm_response_size;
2282 : size_t transport_header_size;
2283 : uint8_t *scratch_buffer;
2284 : size_t scratch_buffer_size;
2285 :
2286 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
2287 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2288 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2289 :
2290 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2291 1 : spdm_response->header.request_response_code =
2292 : SPDM_KEY_UPDATE_ACK;
2293 1 : spdm_response->header.param1 =
2294 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
2295 1 : spdm_response->header.param2 = m_libspdm_last_token;
2296 :
2297 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2298 : * transport_message is always in sender buffer. */
2299 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
2300 : &scratch_buffer_size);
2301 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2302 : scratch_buffer_size - transport_header_size,
2303 : spdm_response, spdm_response_size);
2304 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2305 1 : libspdm_transport_test_encode_message(spdm_context,
2306 : &session_id, false, false,
2307 : spdm_response_size, spdm_response,
2308 : response_size, response);
2309 : /* WALKAROUND: If just use single context to encode
2310 : * message and then decode message */
2311 : ((libspdm_secured_message_context_t
2312 1 : *)(session_info->secured_message_context))
2313 1 : ->application_secret.response_data_sequence_number--;
2314 2 : } else if (sub_index == 1) {
2315 : spdm_error_response_data_response_not_ready_t *spdm_response;
2316 : size_t spdm_response_size;
2317 : size_t transport_header_size;
2318 : uint8_t *scratch_buffer;
2319 : size_t scratch_buffer_size;
2320 :
2321 1 : spdm_response_size = sizeof(spdm_error_response_data_response_not_ready_t);
2322 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2323 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2324 :
2325 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2326 1 : spdm_response->header.request_response_code = SPDM_ERROR;
2327 1 : spdm_response->header.param1 =
2328 : SPDM_ERROR_CODE_RESPONSE_NOT_READY;
2329 1 : spdm_response->header.param2 = 0;
2330 1 : spdm_response->extend_error_data.rd_exponent = 1;
2331 1 : spdm_response->extend_error_data.rd_tm = 2;
2332 1 : spdm_response->extend_error_data.request_code = SPDM_KEY_UPDATE;
2333 1 : spdm_response->extend_error_data.token = 0;
2334 :
2335 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2336 : * transport_message is always in sender buffer. */
2337 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
2338 : &scratch_buffer_size);
2339 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2340 : scratch_buffer_size - transport_header_size,
2341 : spdm_response, spdm_response_size);
2342 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2343 1 : libspdm_transport_test_encode_message(spdm_context,
2344 : &session_id, false, false,
2345 : spdm_response_size, spdm_response,
2346 : response_size, response);
2347 : /* WALKAROUND: If just use single context to encode
2348 : * message and then decode message */
2349 : ((libspdm_secured_message_context_t
2350 1 : *)(session_info->secured_message_context))
2351 1 : ->application_secret.response_data_sequence_number--;
2352 1 : } else if (sub_index == 2) {
2353 : spdm_key_update_response_t *spdm_response;
2354 : size_t spdm_response_size;
2355 : size_t transport_header_size;
2356 : uint8_t *scratch_buffer;
2357 : size_t scratch_buffer_size;
2358 :
2359 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
2360 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2361 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2362 :
2363 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2364 1 : spdm_response->header.request_response_code =
2365 : SPDM_KEY_UPDATE_ACK;
2366 1 : spdm_response->header.param1 =
2367 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_VERIFY_NEW_KEY;
2368 1 : spdm_response->header.param2 = m_libspdm_last_token;
2369 :
2370 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2371 : * transport_message is always in sender buffer. */
2372 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
2373 : &scratch_buffer_size);
2374 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2375 : scratch_buffer_size - transport_header_size,
2376 : spdm_response, spdm_response_size);
2377 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2378 1 : libspdm_transport_test_encode_message(spdm_context,
2379 : &session_id, false, false,
2380 : spdm_response_size, spdm_response,
2381 : response_size, response);
2382 : /* WALKAROUND: If just use single context to encode
2383 : * message and then decode message */
2384 : ((libspdm_secured_message_context_t
2385 1 : *)(session_info->secured_message_context))
2386 1 : ->application_secret.response_data_sequence_number--;
2387 : }
2388 :
2389 3 : sub_index++;
2390 : }
2391 3 : return LIBSPDM_STATUS_SUCCESS;
2392 :
2393 34 : case 0x17: {
2394 : static size_t sub_index = 0;
2395 : static uint16_t error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
2396 :
2397 : uint32_t session_id;
2398 : libspdm_session_info_t *session_info;
2399 :
2400 34 : session_id = 0xFFFFFFFF;
2401 34 : session_info = libspdm_get_session_info_via_session_id(
2402 : spdm_context, session_id);
2403 34 : if (session_info == NULL) {
2404 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
2405 : }
2406 :
2407 34 : if(error_code <= 0xff) {
2408 : /* skip SPDM_ERROR_CODE_DECRYPT_ERROR, because this case will free context*/
2409 34 : if(error_code == SPDM_ERROR_CODE_DECRYPT_ERROR) {
2410 1 : error_code++;
2411 : }
2412 34 : if (sub_index%2 == 0) {
2413 : spdm_key_update_response_t *spdm_response;
2414 : size_t spdm_response_size;
2415 : size_t transport_header_size;
2416 : uint8_t *scratch_buffer;
2417 : size_t scratch_buffer_size;
2418 :
2419 17 : spdm_response_size = sizeof(spdm_key_update_response_t);
2420 17 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2421 17 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2422 :
2423 17 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2424 17 : spdm_response->header.request_response_code =
2425 : SPDM_KEY_UPDATE_ACK;
2426 17 : spdm_response->header.param1 =
2427 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
2428 17 : spdm_response->header.param2 = m_libspdm_last_token;
2429 :
2430 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2431 : * transport_message is always in sender buffer. */
2432 17 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
2433 : &scratch_buffer_size);
2434 17 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2435 : scratch_buffer_size - transport_header_size,
2436 : spdm_response, spdm_response_size);
2437 17 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2438 17 : libspdm_transport_test_encode_message(spdm_context,
2439 : &session_id, false, false,
2440 : spdm_response_size, spdm_response,
2441 : response_size, response);
2442 : /* WALKAROUND: If just use single context to encode
2443 : * message and then decode message */
2444 : ((libspdm_secured_message_context_t
2445 17 : *)(session_info->secured_message_context))
2446 17 : ->application_secret.response_data_sequence_number--;
2447 : } else {
2448 : spdm_error_response_t *spdm_response;
2449 : size_t spdm_response_size;
2450 : size_t transport_header_size;
2451 : uint8_t *scratch_buffer;
2452 : size_t scratch_buffer_size;
2453 :
2454 17 : spdm_response_size = sizeof(spdm_error_response_t);
2455 17 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2456 17 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2457 :
2458 17 : libspdm_zero_mem (spdm_response, spdm_response_size);
2459 17 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2460 17 : spdm_response->header.request_response_code = SPDM_ERROR;
2461 17 : spdm_response->header.param1 = (uint8_t) error_code;
2462 17 : spdm_response->header.param2 = 0;
2463 :
2464 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2465 : * transport_message is always in sender buffer. */
2466 17 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
2467 : &scratch_buffer_size);
2468 17 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2469 : scratch_buffer_size - transport_header_size,
2470 : spdm_response, spdm_response_size);
2471 17 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2472 17 : libspdm_transport_test_encode_message(spdm_context,
2473 : &session_id, false, false,
2474 : spdm_response_size, spdm_response,
2475 : response_size, response);
2476 : /* WALKAROUND: If just use single context to encode
2477 : * message and then decode message */
2478 : ((libspdm_secured_message_context_t
2479 17 : *)(session_info->secured_message_context))
2480 17 : ->application_secret.response_data_sequence_number--;
2481 :
2482 17 : error_code++;
2483 : /*busy is treated in cases 5 and 6*/
2484 17 : if(error_code == SPDM_ERROR_CODE_BUSY) {
2485 1 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
2486 : }
2487 : /*skip some reserved error codes (0d to 3e)*/
2488 17 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) {
2489 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
2490 : }
2491 : /*skip response not ready, request resync, and some reserved codes (44 to fc)*/
2492 17 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) {
2493 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
2494 : }
2495 : }
2496 : }
2497 :
2498 34 : sub_index++;
2499 : }
2500 34 : return LIBSPDM_STATUS_SUCCESS;
2501 :
2502 2 : case 0x18: {
2503 : static size_t sub_index = 0;
2504 :
2505 : spdm_key_update_response_t *spdm_response;
2506 : size_t spdm_response_size;
2507 : size_t transport_header_size;
2508 : uint32_t session_id;
2509 : libspdm_session_info_t *session_info;
2510 : uint8_t *scratch_buffer;
2511 : size_t scratch_buffer_size;
2512 :
2513 2 : spdm_response_size = sizeof(spdm_key_update_response_t);
2514 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2515 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2516 :
2517 2 : session_id = 0xFFFFFFFF;
2518 :
2519 2 : session_info = libspdm_get_session_info_via_session_id(
2520 : spdm_context, session_id);
2521 2 : if (session_info == NULL) {
2522 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
2523 : }
2524 :
2525 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2526 2 : spdm_response->header.request_response_code =
2527 : SPDM_KEY_UPDATE_ACK;
2528 2 : if (sub_index == 0) {
2529 1 : spdm_response->header.request_response_code =
2530 : SPDM_KEY_UPDATE_ACK;
2531 1 : spdm_response->header.param1 =
2532 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
2533 1 : spdm_response->header.param2 = m_libspdm_last_token;
2534 1 : } else if (sub_index == 1) {
2535 : /*wrong response code*/
2536 1 : spdm_response->header.request_response_code =
2537 : SPDM_KEY_UPDATE;
2538 1 : spdm_response->header.param1 =
2539 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_VERIFY_NEW_KEY;
2540 1 : spdm_response->header.param2 = m_libspdm_last_token;
2541 : }
2542 :
2543 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2544 : * transport_message is always in sender buffer. */
2545 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
2546 2 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2547 : scratch_buffer_size - transport_header_size,
2548 : spdm_response, spdm_response_size);
2549 2 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2550 2 : libspdm_transport_test_encode_message(spdm_context, &session_id,
2551 : false, false, spdm_response_size,
2552 : spdm_response, response_size, response);
2553 : /* WALKAROUND: If just use single context to encode
2554 : * message and then decode message */
2555 : ((libspdm_secured_message_context_t
2556 2 : *)(session_info->secured_message_context))
2557 2 : ->application_secret.response_data_sequence_number--;
2558 :
2559 2 : sub_index++;
2560 : }
2561 2 : return LIBSPDM_STATUS_SUCCESS;
2562 :
2563 2 : case 0x19: {
2564 : static size_t sub_index = 0;
2565 :
2566 : spdm_key_update_response_t *spdm_response;
2567 : size_t spdm_response_size;
2568 : size_t transport_header_size;
2569 : uint32_t session_id;
2570 : libspdm_session_info_t *session_info;
2571 : uint8_t *scratch_buffer;
2572 : size_t scratch_buffer_size;
2573 :
2574 2 : spdm_response_size = sizeof(spdm_key_update_response_t);
2575 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2576 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2577 :
2578 2 : session_id = 0xFFFFFFFF;
2579 :
2580 2 : session_info = libspdm_get_session_info_via_session_id(
2581 : spdm_context, session_id);
2582 2 : if (session_info == NULL) {
2583 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
2584 : }
2585 :
2586 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2587 2 : spdm_response->header.request_response_code =
2588 : SPDM_KEY_UPDATE_ACK;
2589 2 : if (sub_index == 0) {
2590 1 : spdm_response->header.param1 =
2591 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
2592 1 : spdm_response->header.param2 = m_libspdm_last_token;
2593 1 : } else if (sub_index == 1) {
2594 1 : spdm_response->header.param1 =
2595 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_VERIFY_NEW_KEY;
2596 : /*wrong token*/
2597 1 : spdm_response->header.param2 = m_libspdm_last_token + 1;
2598 : }
2599 :
2600 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2601 : * transport_message is always in sender buffer. */
2602 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
2603 2 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2604 : scratch_buffer_size - transport_header_size,
2605 : spdm_response, spdm_response_size);
2606 2 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2607 2 : libspdm_transport_test_encode_message(spdm_context, &session_id,
2608 : false, false, spdm_response_size,
2609 : spdm_response, response_size, response);
2610 : /* WALKAROUND: If just use single context to encode
2611 : * message and then decode message */
2612 : ((libspdm_secured_message_context_t
2613 2 : *)(session_info->secured_message_context))
2614 2 : ->application_secret.response_data_sequence_number--;
2615 :
2616 2 : sub_index++;
2617 : }
2618 2 : return LIBSPDM_STATUS_SUCCESS;
2619 :
2620 2 : case 0x1A: {
2621 : static size_t sub_index = 0;
2622 :
2623 : spdm_key_update_response_t *spdm_response;
2624 : size_t spdm_response_size;
2625 : size_t transport_header_size;
2626 : uint32_t session_id;
2627 : libspdm_session_info_t *session_info;
2628 : uint8_t *scratch_buffer;
2629 : size_t scratch_buffer_size;
2630 :
2631 2 : spdm_response_size = sizeof(spdm_key_update_response_t);
2632 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2633 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2634 :
2635 2 : session_id = 0xFFFFFFFF;
2636 :
2637 2 : session_info = libspdm_get_session_info_via_session_id(
2638 : spdm_context, session_id);
2639 2 : if (session_info == NULL) {
2640 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
2641 : }
2642 :
2643 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2644 2 : spdm_response->header.request_response_code =
2645 : SPDM_KEY_UPDATE_ACK;
2646 2 : if (sub_index == 0) {
2647 1 : spdm_response->header.param1 =
2648 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
2649 1 : spdm_response->header.param2 = m_libspdm_last_token;
2650 1 : } else if (sub_index == 1) {
2651 : /*wrong operation code*/
2652 1 : spdm_response->header.param1 =
2653 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
2654 1 : spdm_response->header.param2 = m_libspdm_last_token;
2655 : }
2656 :
2657 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2658 : * transport_message is always in sender buffer. */
2659 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
2660 2 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2661 : scratch_buffer_size - transport_header_size,
2662 : spdm_response, spdm_response_size);
2663 2 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2664 2 : libspdm_transport_test_encode_message(spdm_context, &session_id,
2665 : false, false, spdm_response_size,
2666 : spdm_response, response_size, response);
2667 : /* WALKAROUND: If just use single context to encode
2668 : * message and then decode message */
2669 : ((libspdm_secured_message_context_t
2670 2 : *)(session_info->secured_message_context))
2671 2 : ->application_secret.response_data_sequence_number--;
2672 :
2673 2 : sub_index++;
2674 : }
2675 2 : return LIBSPDM_STATUS_SUCCESS;
2676 :
2677 2 : case 0x1B: {
2678 : static size_t sub_index = 0;
2679 :
2680 : spdm_key_update_response_t *spdm_response;
2681 : size_t spdm_response_size;
2682 : size_t transport_header_size;
2683 : uint32_t session_id;
2684 : libspdm_session_info_t *session_info;
2685 : uint8_t *scratch_buffer;
2686 : size_t scratch_buffer_size;
2687 :
2688 2 : spdm_response_size = sizeof(spdm_key_update_response_t);
2689 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2690 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2691 :
2692 2 : session_id = 0xFFFFFFFF;
2693 :
2694 2 : session_info = libspdm_get_session_info_via_session_id(
2695 : spdm_context, session_id);
2696 2 : if (session_info == NULL) {
2697 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
2698 : }
2699 :
2700 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2701 2 : spdm_response->header.request_response_code = SPDM_KEY_UPDATE_ACK;
2702 2 : if (sub_index == 0) {
2703 1 : spdm_response->header.param1 =
2704 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_ALL_KEYS;
2705 1 : spdm_response->header.param2 = m_libspdm_last_token;
2706 1 : } else if (sub_index == 1) {
2707 1 : spdm_response->header.param1 =
2708 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_VERIFY_NEW_KEY;
2709 1 : spdm_response->header.param2 = m_libspdm_last_token;
2710 :
2711 : /* as it is using single context, the keys were updated
2712 : * in the requester and do not need to be updated before
2713 : * sending the response */
2714 : }
2715 :
2716 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2717 : * transport_message is always in sender buffer. */
2718 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
2719 2 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2720 : scratch_buffer_size - transport_header_size,
2721 : spdm_response, spdm_response_size);
2722 2 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2723 2 : libspdm_transport_test_encode_message(spdm_context, &session_id,
2724 : false, false, spdm_response_size,
2725 : spdm_response, response_size, response);
2726 : /* WALKAROUND: If just use single context to encode
2727 : * message and then decode message */
2728 : ((libspdm_secured_message_context_t
2729 2 : *)(session_info->secured_message_context))
2730 2 : ->application_secret.response_data_sequence_number--;
2731 :
2732 2 : sub_index++;
2733 : }
2734 2 : return LIBSPDM_STATUS_SUCCESS;
2735 :
2736 1 : case 0x1C: {
2737 : spdm_error_response_t *spdm_response;
2738 : size_t spdm_response_size;
2739 : size_t transport_header_size;
2740 : uint32_t session_id;
2741 : libspdm_session_info_t *session_info;
2742 : uint8_t *scratch_buffer;
2743 : size_t scratch_buffer_size;
2744 :
2745 : libspdm_secured_message_context_t *secured_message_context;
2746 : uint8_t curr_rsp_enc_key[LIBSPDM_MAX_AEAD_KEY_SIZE];
2747 : uint8_t curr_rsp_salt[LIBSPDM_MAX_AEAD_IV_SIZE];
2748 : uint64_t curr_rsp_sequence_number;
2749 :
2750 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
2751 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2752 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2753 :
2754 1 : session_id = 0xFFFFFFFF;
2755 1 : session_info = libspdm_get_session_info_via_session_id(
2756 : spdm_context, session_id);
2757 1 : if (session_info == NULL) {
2758 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
2759 : }
2760 1 : secured_message_context = session_info->secured_message_context;
2761 :
2762 : /*use previous key to send*/
2763 1 : libspdm_copy_mem(curr_rsp_enc_key, sizeof(curr_rsp_enc_key),
2764 : secured_message_context
2765 1 : ->application_secret.response_data_encryption_key,
2766 : secured_message_context->aead_key_size);
2767 1 : libspdm_copy_mem(curr_rsp_salt, sizeof(curr_rsp_salt),
2768 : secured_message_context
2769 1 : ->application_secret.response_data_salt,
2770 : secured_message_context->aead_iv_size);
2771 1 : curr_rsp_sequence_number = m_libspdm_last_rsp_sequence_number;
2772 :
2773 1 : libspdm_copy_mem(secured_message_context->application_secret
2774 1 : .response_data_encryption_key,
2775 : sizeof(secured_message_context->application_secret
2776 : .response_data_encryption_key),
2777 : m_libspdm_last_rsp_enc_key,
2778 : secured_message_context->aead_key_size);
2779 1 : libspdm_copy_mem(secured_message_context->application_secret
2780 1 : .response_data_salt,
2781 : sizeof(secured_message_context->application_secret
2782 : .response_data_salt),
2783 : m_libspdm_last_rsp_salt,
2784 : secured_message_context->aead_iv_size);
2785 : secured_message_context->application_secret
2786 1 : .response_data_sequence_number = m_libspdm_last_rsp_sequence_number;
2787 :
2788 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2789 1 : spdm_response->header.request_response_code = SPDM_ERROR;
2790 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_INVALID_REQUEST;
2791 1 : spdm_response->header.param2 = 0;
2792 :
2793 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2794 : * transport_message is always in sender buffer. */
2795 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
2796 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2797 : scratch_buffer_size - transport_header_size,
2798 : spdm_response, spdm_response_size);
2799 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2800 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
2801 : false, false, spdm_response_size,
2802 : spdm_response, response_size, response);
2803 :
2804 : /*restore new key*/
2805 1 : libspdm_copy_mem(secured_message_context->application_secret
2806 1 : .response_data_encryption_key,
2807 : sizeof(secured_message_context->application_secret
2808 : .response_data_encryption_key),
2809 : curr_rsp_enc_key,
2810 : secured_message_context->aead_key_size);
2811 1 : libspdm_copy_mem(secured_message_context->application_secret
2812 1 : .response_data_salt,
2813 : sizeof(secured_message_context->application_secret
2814 : .response_data_salt),
2815 : curr_rsp_salt,
2816 : secured_message_context->aead_iv_size);
2817 : secured_message_context->application_secret
2818 1 : .response_data_sequence_number = curr_rsp_sequence_number;
2819 : }
2820 1 : return LIBSPDM_STATUS_SUCCESS;
2821 :
2822 4 : case 0x1D: {
2823 : spdm_error_response_t *spdm_response;
2824 : size_t spdm_response_size;
2825 : size_t transport_header_size;
2826 : uint32_t session_id;
2827 : libspdm_session_info_t *session_info;
2828 : uint8_t *scratch_buffer;
2829 : size_t scratch_buffer_size;
2830 :
2831 : libspdm_secured_message_context_t *secured_message_context;
2832 : uint8_t curr_rsp_enc_key[LIBSPDM_MAX_AEAD_KEY_SIZE];
2833 : uint8_t curr_rsp_salt[LIBSPDM_MAX_AEAD_IV_SIZE];
2834 : uint64_t curr_rsp_sequence_number;
2835 :
2836 4 : spdm_response_size = sizeof(spdm_key_update_response_t);
2837 4 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2838 4 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2839 :
2840 4 : session_id = 0xFFFFFFFF;
2841 4 : session_info = libspdm_get_session_info_via_session_id(
2842 : spdm_context, session_id);
2843 4 : if (session_info == NULL) {
2844 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
2845 : }
2846 4 : secured_message_context = session_info->secured_message_context;
2847 :
2848 : /*use previous key to send*/
2849 4 : libspdm_copy_mem(curr_rsp_enc_key, sizeof(curr_rsp_enc_key),
2850 : secured_message_context
2851 4 : ->application_secret.response_data_encryption_key,
2852 : secured_message_context->aead_key_size);
2853 4 : libspdm_copy_mem(curr_rsp_salt, sizeof(curr_rsp_salt),
2854 : secured_message_context
2855 4 : ->application_secret.response_data_salt,
2856 : secured_message_context->aead_iv_size);
2857 4 : curr_rsp_sequence_number = m_libspdm_last_rsp_sequence_number;
2858 :
2859 4 : libspdm_copy_mem(secured_message_context->application_secret
2860 4 : .response_data_encryption_key,
2861 : sizeof(secured_message_context->application_secret
2862 : .response_data_encryption_key),
2863 : m_libspdm_last_rsp_enc_key,
2864 : secured_message_context->aead_key_size);
2865 4 : libspdm_copy_mem(secured_message_context->application_secret
2866 4 : .response_data_salt,
2867 : sizeof(secured_message_context->application_secret
2868 : .response_data_salt),
2869 : m_libspdm_last_rsp_salt,
2870 : secured_message_context->aead_iv_size);
2871 : secured_message_context->application_secret
2872 4 : .response_data_sequence_number = m_libspdm_last_rsp_sequence_number;
2873 :
2874 : /* once the sequence number is used, it should be increased for next BUSY message.*/
2875 4 : m_libspdm_last_rsp_sequence_number++;
2876 :
2877 4 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2878 4 : spdm_response->header.request_response_code = SPDM_ERROR;
2879 4 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
2880 4 : spdm_response->header.param2 = 0;
2881 :
2882 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2883 : * transport_message is always in sender buffer. */
2884 4 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
2885 4 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2886 : scratch_buffer_size - transport_header_size,
2887 : spdm_response, spdm_response_size);
2888 4 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2889 4 : libspdm_transport_test_encode_message(spdm_context, &session_id,
2890 : false, false, spdm_response_size,
2891 : spdm_response, response_size, response);
2892 :
2893 : /*restore new key*/
2894 4 : libspdm_copy_mem(secured_message_context->application_secret
2895 4 : .response_data_encryption_key,
2896 : sizeof(secured_message_context->application_secret
2897 : .response_data_encryption_key),
2898 : curr_rsp_enc_key,
2899 : secured_message_context->aead_key_size);
2900 4 : libspdm_copy_mem(secured_message_context->application_secret
2901 4 : .response_data_salt,
2902 : sizeof(secured_message_context->application_secret
2903 : .response_data_salt),
2904 : curr_rsp_salt,
2905 : secured_message_context->aead_iv_size);
2906 : secured_message_context->application_secret
2907 4 : .response_data_sequence_number = curr_rsp_sequence_number;
2908 : }
2909 4 : return LIBSPDM_STATUS_SUCCESS;
2910 :
2911 3 : case 0x1E: {
2912 : static size_t sub_index = 0;
2913 :
2914 : uint32_t session_id;
2915 : libspdm_session_info_t *session_info;
2916 :
2917 : libspdm_secured_message_context_t *secured_message_context;
2918 :
2919 3 : session_id = 0xFFFFFFFF;
2920 3 : session_info = libspdm_get_session_info_via_session_id(
2921 : spdm_context, session_id);
2922 3 : if (session_info == NULL) {
2923 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
2924 : }
2925 3 : secured_message_context = session_info->secured_message_context;
2926 :
2927 3 : if (sub_index == 0) {
2928 : spdm_error_response_t *spdm_response;
2929 : size_t spdm_response_size;
2930 : size_t transport_header_size;
2931 : uint8_t *scratch_buffer;
2932 : size_t scratch_buffer_size;
2933 :
2934 1 : spdm_response_size = sizeof(spdm_error_response_t);
2935 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2936 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2937 :
2938 : uint8_t curr_rsp_enc_key[LIBSPDM_MAX_AEAD_KEY_SIZE];
2939 : uint8_t curr_rsp_salt[LIBSPDM_MAX_AEAD_IV_SIZE];
2940 : uint64_t curr_rsp_sequence_number;
2941 :
2942 : /*use previous key to send*/
2943 1 : libspdm_copy_mem(curr_rsp_enc_key, sizeof(curr_rsp_enc_key),
2944 : secured_message_context
2945 1 : ->application_secret.response_data_encryption_key,
2946 : secured_message_context->aead_key_size);
2947 1 : libspdm_copy_mem(curr_rsp_salt, sizeof(curr_rsp_salt),
2948 : secured_message_context
2949 1 : ->application_secret.response_data_salt,
2950 : secured_message_context->aead_iv_size);
2951 1 : curr_rsp_sequence_number = m_libspdm_last_rsp_sequence_number;
2952 :
2953 1 : libspdm_copy_mem(secured_message_context->application_secret
2954 1 : .response_data_encryption_key,
2955 : sizeof(secured_message_context->application_secret
2956 : .response_data_encryption_key),
2957 : m_libspdm_last_rsp_enc_key,
2958 : secured_message_context->aead_key_size);
2959 1 : libspdm_copy_mem(secured_message_context->application_secret
2960 1 : .response_data_salt,
2961 : sizeof(secured_message_context->application_secret
2962 : .response_data_salt),
2963 : m_libspdm_last_rsp_salt,
2964 : secured_message_context->aead_iv_size);
2965 : secured_message_context->application_secret
2966 1 : .response_data_sequence_number = m_libspdm_last_rsp_sequence_number;
2967 :
2968 1 : spdm_response->header.spdm_version =
2969 : SPDM_MESSAGE_VERSION_11;
2970 1 : spdm_response->header.request_response_code = SPDM_ERROR;
2971 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
2972 1 : spdm_response->header.param2 = 0;
2973 :
2974 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2975 : * transport_message is always in sender buffer. */
2976 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
2977 : &scratch_buffer_size);
2978 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2979 : scratch_buffer_size - transport_header_size,
2980 : spdm_response, spdm_response_size);
2981 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2982 1 : libspdm_transport_test_encode_message(spdm_context,
2983 : &session_id, false, false,
2984 : spdm_response_size, spdm_response,
2985 : response_size, response);
2986 :
2987 : /*restore new key*/
2988 1 : libspdm_copy_mem(secured_message_context->application_secret
2989 1 : .response_data_encryption_key,
2990 : sizeof(secured_message_context->application_secret
2991 : .response_data_encryption_key),
2992 : curr_rsp_enc_key,
2993 : secured_message_context->aead_key_size);
2994 1 : libspdm_copy_mem(secured_message_context->application_secret
2995 1 : .response_data_salt,
2996 : sizeof(secured_message_context->application_secret
2997 : .response_data_salt),
2998 : curr_rsp_salt,
2999 : secured_message_context->aead_iv_size);
3000 : secured_message_context->application_secret
3001 1 : .response_data_sequence_number = curr_rsp_sequence_number;
3002 2 : } else if (sub_index == 1) {
3003 : spdm_key_update_response_t *spdm_response;
3004 : size_t spdm_response_size;
3005 : size_t transport_header_size;
3006 : uint8_t *scratch_buffer;
3007 : size_t scratch_buffer_size;
3008 :
3009 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
3010 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
3011 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
3012 :
3013 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
3014 1 : spdm_response->header.request_response_code =
3015 : SPDM_KEY_UPDATE_ACK;
3016 1 : spdm_response->header.param1 =
3017 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_ALL_KEYS;
3018 1 : spdm_response->header.param2 = m_libspdm_last_token;
3019 :
3020 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
3021 : * transport_message is always in sender buffer. */
3022 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
3023 : &scratch_buffer_size);
3024 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
3025 : scratch_buffer_size - transport_header_size,
3026 : spdm_response, spdm_response_size);
3027 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
3028 1 : libspdm_transport_test_encode_message(spdm_context,
3029 : &session_id, false, false,
3030 : spdm_response_size, spdm_response,
3031 : response_size, response);
3032 : /* WALKAROUND: If just use single context to encode
3033 : * message and then decode message */
3034 : secured_message_context->application_secret
3035 1 : .response_data_sequence_number--;
3036 1 : } else if (sub_index == 2) {
3037 : spdm_key_update_response_t *spdm_response;
3038 : size_t spdm_response_size;
3039 : size_t transport_header_size;
3040 : uint8_t *scratch_buffer;
3041 : size_t scratch_buffer_size;
3042 :
3043 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
3044 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
3045 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
3046 :
3047 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
3048 1 : spdm_response->header.request_response_code =
3049 : SPDM_KEY_UPDATE_ACK;
3050 1 : spdm_response->header.param1 =
3051 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_VERIFY_NEW_KEY;
3052 1 : spdm_response->header.param2 = m_libspdm_last_token;
3053 :
3054 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
3055 : * transport_message is always in sender buffer. */
3056 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
3057 : &scratch_buffer_size);
3058 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
3059 : scratch_buffer_size - transport_header_size,
3060 : spdm_response, spdm_response_size);
3061 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
3062 1 : libspdm_transport_test_encode_message(spdm_context,
3063 : &session_id, false, false,
3064 : spdm_response_size, spdm_response,
3065 : response_size, response);
3066 : /* WALKAROUND: If just use single context to encode
3067 : * message and then decode message */
3068 : secured_message_context->application_secret
3069 1 : .response_data_sequence_number--;
3070 : }
3071 :
3072 3 : sub_index++;
3073 : }
3074 3 : return LIBSPDM_STATUS_SUCCESS;
3075 :
3076 1 : case 0x1F: {
3077 : spdm_error_response_t *spdm_response;
3078 : size_t spdm_response_size;
3079 : size_t transport_header_size;
3080 : uint32_t session_id;
3081 : libspdm_session_info_t *session_info;
3082 : uint8_t *scratch_buffer;
3083 : size_t scratch_buffer_size;
3084 :
3085 : libspdm_secured_message_context_t *secured_message_context;
3086 : uint8_t curr_rsp_enc_key[LIBSPDM_MAX_AEAD_KEY_SIZE];
3087 : uint8_t curr_rsp_salt[LIBSPDM_MAX_AEAD_IV_SIZE];
3088 : uint64_t curr_rsp_sequence_number;
3089 :
3090 1 : spdm_response_size = sizeof(spdm_error_response_t);
3091 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
3092 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
3093 :
3094 1 : session_id = 0xFFFFFFFF;
3095 1 : session_info = libspdm_get_session_info_via_session_id(
3096 : spdm_context, session_id);
3097 1 : if (session_info == NULL) {
3098 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
3099 : }
3100 1 : secured_message_context = session_info->secured_message_context;
3101 :
3102 : /*use previous key to send*/
3103 1 : libspdm_copy_mem(curr_rsp_enc_key, sizeof(curr_rsp_enc_key),
3104 : secured_message_context
3105 1 : ->application_secret.response_data_encryption_key,
3106 : secured_message_context->aead_key_size);
3107 1 : libspdm_copy_mem(curr_rsp_salt, sizeof(curr_rsp_salt),
3108 : secured_message_context
3109 1 : ->application_secret.response_data_salt,
3110 : secured_message_context->aead_iv_size);
3111 1 : curr_rsp_sequence_number = m_libspdm_last_rsp_sequence_number;
3112 :
3113 1 : libspdm_copy_mem(secured_message_context->application_secret
3114 1 : .response_data_encryption_key,
3115 : sizeof(secured_message_context->application_secret
3116 : .response_data_encryption_key),
3117 : m_libspdm_last_rsp_enc_key,
3118 : secured_message_context->aead_key_size);
3119 1 : libspdm_copy_mem(secured_message_context->application_secret
3120 1 : .response_data_salt,
3121 : sizeof(secured_message_context->application_secret
3122 : .response_data_salt),
3123 : m_libspdm_last_rsp_salt,
3124 : secured_message_context->aead_iv_size);
3125 : secured_message_context->application_secret
3126 1 : .response_data_sequence_number = m_libspdm_last_rsp_sequence_number;
3127 :
3128 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
3129 1 : spdm_response->header.request_response_code = SPDM_ERROR;
3130 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_REQUEST_RESYNCH;
3131 1 : spdm_response->header.param2 = 0;
3132 :
3133 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
3134 : * transport_message is always in sender buffer. */
3135 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
3136 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
3137 : scratch_buffer_size - transport_header_size,
3138 : spdm_response, spdm_response_size);
3139 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
3140 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
3141 : false, false, spdm_response_size,
3142 : spdm_response, response_size, response);
3143 :
3144 : /*restore new key*/
3145 1 : libspdm_copy_mem(secured_message_context->application_secret
3146 1 : .response_data_encryption_key,
3147 : sizeof(secured_message_context->application_secret
3148 : .response_data_encryption_key),
3149 : curr_rsp_enc_key,
3150 : secured_message_context->aead_key_size);
3151 1 : libspdm_copy_mem(secured_message_context->application_secret
3152 1 : .response_data_salt,
3153 : sizeof(secured_message_context->application_secret
3154 : .response_data_salt),
3155 : curr_rsp_salt,
3156 : secured_message_context->aead_iv_size);
3157 : secured_message_context->application_secret
3158 1 : .response_data_sequence_number = curr_rsp_sequence_number;
3159 : }
3160 1 : return LIBSPDM_STATUS_SUCCESS;
3161 :
3162 2 : case 0x20: {
3163 : spdm_error_response_data_response_not_ready_t *spdm_response;
3164 : size_t spdm_response_size;
3165 : size_t transport_header_size;
3166 : uint32_t session_id;
3167 : libspdm_session_info_t *session_info;
3168 : uint8_t *scratch_buffer;
3169 : size_t scratch_buffer_size;
3170 :
3171 : libspdm_secured_message_context_t *secured_message_context;
3172 : uint8_t curr_rsp_enc_key[LIBSPDM_MAX_AEAD_KEY_SIZE];
3173 : uint8_t curr_rsp_salt[LIBSPDM_MAX_AEAD_IV_SIZE];
3174 : uint64_t curr_rsp_sequence_number;
3175 :
3176 2 : spdm_response_size = sizeof(spdm_error_response_data_response_not_ready_t);
3177 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
3178 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
3179 :
3180 2 : session_id = 0xFFFFFFFF;
3181 2 : session_info = libspdm_get_session_info_via_session_id(
3182 : spdm_context, session_id);
3183 2 : if (session_info == NULL) {
3184 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
3185 : }
3186 2 : secured_message_context = session_info->secured_message_context;
3187 :
3188 : /*use previous key to send*/
3189 2 : libspdm_copy_mem(curr_rsp_enc_key, sizeof(curr_rsp_enc_key),
3190 : secured_message_context
3191 2 : ->application_secret.response_data_encryption_key,
3192 : secured_message_context->aead_key_size);
3193 2 : libspdm_copy_mem(curr_rsp_salt, sizeof(curr_rsp_salt),
3194 : secured_message_context
3195 2 : ->application_secret.response_data_salt,
3196 : secured_message_context->aead_iv_size);
3197 2 : curr_rsp_sequence_number = m_libspdm_last_rsp_sequence_number;
3198 :
3199 2 : libspdm_copy_mem(secured_message_context->application_secret
3200 2 : .response_data_encryption_key,
3201 : sizeof(secured_message_context->application_secret
3202 : .response_data_encryption_key),
3203 : m_libspdm_last_rsp_enc_key,
3204 : secured_message_context->aead_key_size);
3205 2 : libspdm_copy_mem(secured_message_context->application_secret
3206 2 : .response_data_salt,
3207 : sizeof(secured_message_context->application_secret
3208 : .response_data_salt),
3209 : m_libspdm_last_rsp_salt,
3210 : secured_message_context->aead_iv_size);
3211 : secured_message_context->application_secret
3212 2 : .response_data_sequence_number = m_libspdm_last_rsp_sequence_number;
3213 :
3214 : /* once the sequence number is used, it should be increased for next NOT_READY message.*/
3215 2 : m_libspdm_last_rsp_sequence_number++;
3216 :
3217 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
3218 2 : spdm_response->header.request_response_code = SPDM_ERROR;
3219 2 : spdm_response->header.param1 =
3220 : SPDM_ERROR_CODE_RESPONSE_NOT_READY;
3221 2 : spdm_response->header.param2 = 0;
3222 2 : spdm_response->extend_error_data.rd_exponent = 1;
3223 2 : spdm_response->extend_error_data.rd_tm = 2;
3224 2 : spdm_response->extend_error_data.request_code = SPDM_KEY_UPDATE;
3225 2 : spdm_response->extend_error_data.token = 0;
3226 :
3227 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
3228 : * transport_message is always in sender buffer. */
3229 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
3230 2 : libspdm_copy_mem (scratch_buffer + transport_header_size,
3231 : scratch_buffer_size - transport_header_size,
3232 : spdm_response, spdm_response_size);
3233 2 : spdm_response = (void *)(scratch_buffer + transport_header_size);
3234 2 : libspdm_transport_test_encode_message(spdm_context, &session_id,
3235 : false, false, spdm_response_size,
3236 : spdm_response, response_size, response);
3237 :
3238 : /*restore new key*/
3239 2 : libspdm_copy_mem(secured_message_context->application_secret
3240 2 : .response_data_encryption_key,
3241 : sizeof(secured_message_context->application_secret
3242 : .response_data_encryption_key),
3243 : curr_rsp_enc_key,
3244 : secured_message_context->aead_key_size);
3245 2 : libspdm_copy_mem(secured_message_context->application_secret
3246 2 : .response_data_salt,
3247 : sizeof(secured_message_context->application_secret
3248 : .response_data_salt),
3249 : curr_rsp_salt,
3250 : secured_message_context->aead_iv_size);
3251 : secured_message_context->application_secret
3252 2 : .response_data_sequence_number = curr_rsp_sequence_number;
3253 : }
3254 2 : return LIBSPDM_STATUS_SUCCESS;
3255 :
3256 3 : case 0x21: {
3257 : static size_t sub_index = 0;
3258 :
3259 : uint32_t session_id;
3260 : libspdm_session_info_t *session_info;
3261 :
3262 : libspdm_secured_message_context_t *secured_message_context;
3263 :
3264 3 : session_id = 0xFFFFFFFF;
3265 3 : session_info = libspdm_get_session_info_via_session_id(
3266 : spdm_context, session_id);
3267 3 : if (session_info == NULL) {
3268 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
3269 : }
3270 3 : secured_message_context = session_info->secured_message_context;
3271 :
3272 3 : if (sub_index == 0) {
3273 : spdm_error_response_data_response_not_ready_t
3274 : *spdm_response;
3275 : size_t spdm_response_size;
3276 : size_t transport_header_size;
3277 : uint8_t *scratch_buffer;
3278 : size_t scratch_buffer_size;
3279 :
3280 : uint8_t curr_rsp_enc_key[LIBSPDM_MAX_AEAD_KEY_SIZE];
3281 : uint8_t curr_rsp_salt[LIBSPDM_MAX_AEAD_IV_SIZE];
3282 : uint64_t curr_rsp_sequence_number;
3283 :
3284 1 : spdm_response_size = sizeof(spdm_error_response_data_response_not_ready_t);
3285 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
3286 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
3287 :
3288 : /*use previous key to send*/
3289 1 : libspdm_copy_mem(curr_rsp_enc_key, sizeof(curr_rsp_enc_key),
3290 : secured_message_context
3291 1 : ->application_secret.response_data_encryption_key,
3292 : secured_message_context->aead_key_size);
3293 1 : libspdm_copy_mem(curr_rsp_salt, sizeof(curr_rsp_salt),
3294 : secured_message_context
3295 1 : ->application_secret.response_data_salt,
3296 : secured_message_context->aead_iv_size);
3297 1 : curr_rsp_sequence_number = m_libspdm_last_rsp_sequence_number;
3298 :
3299 1 : libspdm_copy_mem(secured_message_context->application_secret
3300 1 : .response_data_encryption_key,
3301 : sizeof(secured_message_context->application_secret
3302 : .response_data_encryption_key),
3303 : m_libspdm_last_rsp_enc_key,
3304 : secured_message_context->aead_key_size);
3305 1 : libspdm_copy_mem(secured_message_context->application_secret
3306 1 : .response_data_salt,
3307 : sizeof(secured_message_context->application_secret
3308 : .response_data_salt),
3309 : m_libspdm_last_rsp_salt,
3310 : secured_message_context->aead_iv_size);
3311 : secured_message_context->application_secret
3312 1 : .response_data_sequence_number = m_libspdm_last_rsp_sequence_number;
3313 :
3314 1 : spdm_response->header.spdm_version =
3315 : SPDM_MESSAGE_VERSION_11;
3316 1 : spdm_response->header.request_response_code = SPDM_ERROR;
3317 1 : spdm_response->header.param1 =
3318 : SPDM_ERROR_CODE_RESPONSE_NOT_READY;
3319 1 : spdm_response->header.param2 = 0;
3320 1 : spdm_response->extend_error_data.rd_exponent = 1;
3321 1 : spdm_response->extend_error_data.rd_tm = 2;
3322 1 : spdm_response->extend_error_data.request_code =
3323 : SPDM_KEY_UPDATE;
3324 1 : spdm_response->extend_error_data.token = 1;
3325 :
3326 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
3327 : * transport_message is always in sender buffer. */
3328 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
3329 : &scratch_buffer_size);
3330 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
3331 : scratch_buffer_size - transport_header_size,
3332 : spdm_response, spdm_response_size);
3333 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
3334 1 : libspdm_transport_test_encode_message(spdm_context,
3335 : &session_id, false, false,
3336 : spdm_response_size, spdm_response,
3337 : response_size, response);
3338 :
3339 : /*restore new key*/
3340 1 : libspdm_copy_mem(secured_message_context->application_secret
3341 1 : .response_data_encryption_key,
3342 : sizeof(secured_message_context->application_secret
3343 : .response_data_encryption_key),
3344 : curr_rsp_enc_key,
3345 : secured_message_context->aead_key_size);
3346 1 : libspdm_copy_mem(secured_message_context->application_secret
3347 1 : .response_data_salt,
3348 : sizeof(secured_message_context->application_secret
3349 : .response_data_salt),
3350 : curr_rsp_salt,
3351 : secured_message_context->aead_iv_size);
3352 : secured_message_context->application_secret
3353 1 : .response_data_sequence_number = curr_rsp_sequence_number;
3354 2 : } else if (sub_index == 1) {
3355 : spdm_key_update_response_t *spdm_response;
3356 : size_t spdm_response_size;
3357 : size_t transport_header_size;
3358 : uint8_t *scratch_buffer;
3359 : size_t scratch_buffer_size;
3360 :
3361 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
3362 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
3363 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
3364 :
3365 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
3366 1 : spdm_response->header.request_response_code =
3367 : SPDM_KEY_UPDATE_ACK;
3368 1 : spdm_response->header.param1 =
3369 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_ALL_KEYS;
3370 1 : spdm_response->header.param2 = m_libspdm_last_token;
3371 :
3372 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
3373 : * transport_message is always in sender buffer. */
3374 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
3375 : &scratch_buffer_size);
3376 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
3377 : scratch_buffer_size - transport_header_size,
3378 : spdm_response, spdm_response_size);
3379 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
3380 1 : libspdm_transport_test_encode_message(spdm_context,
3381 : &session_id, false, false,
3382 : spdm_response_size, spdm_response,
3383 : response_size, response);
3384 : /* WALKAROUND: If just use single context to encode
3385 : * message and then decode message */
3386 : secured_message_context->application_secret
3387 1 : .response_data_sequence_number--;
3388 1 : } else if (sub_index == 2) {
3389 : spdm_key_update_response_t *spdm_response;
3390 : size_t spdm_response_size;
3391 : size_t transport_header_size;
3392 : uint8_t *scratch_buffer;
3393 : size_t scratch_buffer_size;
3394 :
3395 1 : spdm_response_size = sizeof(spdm_key_update_response_t);
3396 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
3397 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
3398 :
3399 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
3400 1 : spdm_response->header.request_response_code =
3401 : SPDM_KEY_UPDATE_ACK;
3402 1 : spdm_response->header.param1 =
3403 : SPDM_KEY_UPDATE_OPERATIONS_TABLE_VERIFY_NEW_KEY;
3404 1 : spdm_response->header.param2 = m_libspdm_last_token;
3405 :
3406 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
3407 : * transport_message is always in sender buffer. */
3408 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
3409 : &scratch_buffer_size);
3410 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
3411 : scratch_buffer_size - transport_header_size,
3412 : spdm_response, spdm_response_size);
3413 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
3414 1 : libspdm_transport_test_encode_message(spdm_context,
3415 : &session_id, false, false,
3416 : spdm_response_size, spdm_response,
3417 : response_size, response);
3418 : /* WALKAROUND: If just use single context to encode
3419 : * message and then decode message */
3420 : secured_message_context->application_secret
3421 1 : .response_data_sequence_number--;
3422 : }
3423 :
3424 3 : sub_index++;
3425 : }
3426 3 : return LIBSPDM_STATUS_SUCCESS;
3427 :
3428 17 : case 0x22: {
3429 : static uint16_t error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
3430 :
3431 : uint32_t session_id;
3432 : libspdm_session_info_t *session_info;
3433 :
3434 : spdm_error_response_t *spdm_response;
3435 : size_t spdm_response_size;
3436 : size_t transport_header_size;
3437 : uint8_t *scratch_buffer;
3438 : size_t scratch_buffer_size;
3439 :
3440 : libspdm_secured_message_context_t *secured_message_context;
3441 : uint8_t curr_rsp_enc_key[LIBSPDM_MAX_AEAD_KEY_SIZE];
3442 : uint8_t curr_rsp_salt[LIBSPDM_MAX_AEAD_IV_SIZE];
3443 : uint64_t curr_rsp_sequence_number;
3444 :
3445 17 : spdm_response_size = sizeof(spdm_error_response_t);
3446 17 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
3447 17 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
3448 :
3449 17 : session_id = 0xFFFFFFFF;
3450 17 : session_info = libspdm_get_session_info_via_session_id(
3451 : spdm_context, session_id);
3452 17 : if (session_info == NULL) {
3453 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
3454 : }
3455 17 : secured_message_context = session_info->secured_message_context;
3456 :
3457 17 : if(error_code <= 0xff) {
3458 : /* skip SPDM_ERROR_CODE_DECRYPT_ERROR, because this case will free context*/
3459 17 : if(error_code == SPDM_ERROR_CODE_DECRYPT_ERROR) {
3460 1 : error_code++;
3461 : }
3462 : /*use previous key to send*/
3463 17 : libspdm_copy_mem(curr_rsp_enc_key, sizeof(curr_rsp_enc_key),
3464 : secured_message_context
3465 17 : ->application_secret.response_data_encryption_key,
3466 : secured_message_context->aead_key_size);
3467 17 : libspdm_copy_mem(curr_rsp_salt, sizeof(curr_rsp_salt),
3468 : secured_message_context
3469 17 : ->application_secret.response_data_salt,
3470 : secured_message_context->aead_iv_size);
3471 17 : curr_rsp_sequence_number = m_libspdm_last_rsp_sequence_number;
3472 :
3473 17 : libspdm_copy_mem(secured_message_context->application_secret
3474 17 : .response_data_encryption_key,
3475 : sizeof(secured_message_context->application_secret
3476 : .response_data_encryption_key),
3477 : m_libspdm_last_rsp_enc_key,
3478 : secured_message_context->aead_key_size);
3479 17 : libspdm_copy_mem(secured_message_context->application_secret
3480 17 : .response_data_salt,
3481 : sizeof(secured_message_context->application_secret
3482 : .response_data_salt),
3483 : m_libspdm_last_rsp_salt,
3484 : secured_message_context->aead_iv_size);
3485 : secured_message_context->application_secret
3486 17 : .response_data_sequence_number = m_libspdm_last_rsp_sequence_number;
3487 :
3488 17 : libspdm_zero_mem (spdm_response, spdm_response_size);
3489 17 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
3490 17 : spdm_response->header.request_response_code = SPDM_ERROR;
3491 17 : spdm_response->header.param1 = (uint8_t) error_code;
3492 17 : spdm_response->header.param2 = 0;
3493 :
3494 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
3495 : * transport_message is always in sender buffer. */
3496 17 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
3497 : &scratch_buffer_size);
3498 17 : libspdm_copy_mem (scratch_buffer + transport_header_size,
3499 : scratch_buffer_size - transport_header_size,
3500 : spdm_response, spdm_response_size);
3501 17 : spdm_response = (void *)(scratch_buffer + transport_header_size);
3502 17 : libspdm_transport_test_encode_message(spdm_context,
3503 : &session_id, false, false,
3504 : spdm_response_size, spdm_response,
3505 : response_size, response);
3506 :
3507 : /*restore new key*/
3508 17 : libspdm_copy_mem(secured_message_context->application_secret
3509 17 : .response_data_encryption_key,
3510 : sizeof(secured_message_context->application_secret
3511 : .response_data_encryption_key),
3512 : curr_rsp_enc_key,
3513 : secured_message_context->aead_key_size);
3514 17 : libspdm_copy_mem(secured_message_context->application_secret
3515 17 : .response_data_salt,
3516 : sizeof(secured_message_context->application_secret
3517 : .response_data_salt),
3518 : curr_rsp_salt,
3519 : secured_message_context->aead_iv_size);
3520 : secured_message_context->application_secret
3521 17 : .response_data_sequence_number = curr_rsp_sequence_number;
3522 : }
3523 :
3524 17 : error_code++;
3525 : /*busy is treated in cases 5 and 6*/
3526 17 : if(error_code == SPDM_ERROR_CODE_BUSY) {
3527 1 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
3528 : }
3529 : /*skip some reserved error codes (0d to 3e)*/
3530 17 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) {
3531 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
3532 : }
3533 : /*skip response not ready, request resync, and some reserved codes (44 to fc)*/
3534 17 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) {
3535 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
3536 : }
3537 : }
3538 17 : return LIBSPDM_STATUS_SUCCESS;
3539 :
3540 1 : case 0x23: {
3541 : spdm_error_response_t *spdm_response;
3542 : size_t spdm_response_size;
3543 : size_t transport_header_size;
3544 : uint32_t session_id;
3545 : libspdm_session_info_t *session_info;
3546 : uint8_t *scratch_buffer;
3547 : size_t scratch_buffer_size;
3548 :
3549 1 : spdm_response_size = sizeof(spdm_error_response_t);
3550 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
3551 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
3552 :
3553 1 : session_id = 0xFFFFFFFF;
3554 1 : session_info = libspdm_get_session_info_via_session_id(
3555 : spdm_context, session_id);
3556 1 : if (session_info == NULL) {
3557 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
3558 : }
3559 :
3560 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
3561 1 : spdm_response->header.request_response_code = SPDM_ERROR;
3562 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_DECRYPT_ERROR;
3563 1 : spdm_response->header.param2 = 0;
3564 :
3565 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
3566 : * transport_message is always in sender buffer. */
3567 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
3568 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
3569 : scratch_buffer_size - transport_header_size,
3570 : spdm_response, spdm_response_size);
3571 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
3572 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
3573 : false, false, spdm_response_size,
3574 : spdm_response, response_size, response);
3575 : /* WALKAROUND: If just use single context to encode
3576 : * message and then decode message */
3577 : ((libspdm_secured_message_context_t
3578 1 : *)(session_info->secured_message_context))
3579 1 : ->application_secret.response_data_sequence_number--;
3580 : }
3581 1 : return LIBSPDM_STATUS_SUCCESS;
3582 :
3583 0 : default:
3584 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
3585 : }
3586 : }
3587 :
3588 :
3589 : /**
3590 : * Test 1: when no KEY_UPDATE_ACK message is received, and the client
3591 : * returns a device error.
3592 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR.
3593 : **/
3594 1 : static void req_key_update_case1(void **state)
3595 : {
3596 : libspdm_return_t status;
3597 : libspdm_test_context_t *spdm_test_context;
3598 : libspdm_context_t *spdm_context;
3599 : uint32_t session_id;
3600 : libspdm_session_info_t *session_info;
3601 :
3602 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
3603 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
3604 :
3605 1 : spdm_test_context = *state;
3606 1 : spdm_context = spdm_test_context->spdm_context;
3607 1 : spdm_test_context->case_id = 0x1;
3608 :
3609 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3610 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3611 1 : libspdm_set_standard_key_update_test_state(
3612 : spdm_context, &session_id);
3613 :
3614 1 : session_info = &spdm_context->session_info[0];
3615 :
3616 1 : libspdm_set_standard_key_update_test_secrets(
3617 1 : session_info->secured_message_context,
3618 : m_rsp_secret_buffer, (uint8_t)(0xFF),
3619 : m_req_secret_buffer, (uint8_t)(0xEE));
3620 :
3621 1 : status = libspdm_key_update(
3622 : spdm_context, session_id, true);
3623 :
3624 1 : assert_int_equal(status, LIBSPDM_STATUS_SEND_FAIL);
3625 1 : }
3626 :
3627 : /**
3628 : * Test 2: receiving a correct UPDATE_KEY_ACK message for updating
3629 : * only the request data key.
3630 : * Expected behavior: client returns a Status of LIBSPDM_STATUS_SUCCESS, the
3631 : * request data key is updated, but not the response data key.
3632 : **/
3633 1 : static void req_key_update_case2(void **state)
3634 : {
3635 : libspdm_return_t status;
3636 : libspdm_test_context_t *spdm_test_context;
3637 : libspdm_context_t *spdm_context;
3638 : uint32_t session_id;
3639 : libspdm_session_info_t *session_info;
3640 :
3641 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
3642 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
3643 :
3644 1 : spdm_test_context = *state;
3645 1 : spdm_context = spdm_test_context->spdm_context;
3646 1 : spdm_test_context->case_id = 0x2;
3647 :
3648 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3649 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3650 1 : libspdm_set_standard_key_update_test_state(
3651 : spdm_context, &session_id);
3652 :
3653 1 : session_info = &spdm_context->session_info[0];
3654 :
3655 1 : libspdm_set_standard_key_update_test_secrets(
3656 1 : session_info->secured_message_context,
3657 : m_rsp_secret_buffer, (uint8_t)(0xFF),
3658 : m_req_secret_buffer, (uint8_t)(0xEE));
3659 :
3660 : /*request side updated*/
3661 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
3662 : ((libspdm_secured_message_context_t
3663 1 : *)(session_info->secured_message_context))->hash_size,
3664 : m_req_secret_buffer, m_req_secret_buffer,
3665 : sizeof(m_req_secret_buffer));
3666 : /*response side *not* updated*/
3667 :
3668 1 : status = libspdm_key_update(
3669 : spdm_context, session_id, true);
3670 :
3671 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
3672 1 : assert_memory_equal(((libspdm_secured_message_context_t
3673 : *)(session_info->secured_message_context))
3674 : ->application_secret.request_data_secret,
3675 : m_req_secret_buffer, ((libspdm_secured_message_context_t
3676 : *)(session_info->secured_message_context))->hash_size);
3677 1 : assert_memory_equal(((libspdm_secured_message_context_t
3678 : *)(session_info->secured_message_context))
3679 : ->application_secret.response_data_secret,
3680 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
3681 : *)(session_info->secured_message_context))->hash_size);
3682 1 : }
3683 :
3684 : /**
3685 : * Test 3: requester state has not been negotiated, as if GET_VERSION,
3686 : * GET_CAPABILITIES and NEGOTIATE_ALGORITHMS had not been exchanged.
3687 : * Expected behavior: client returns a Status of RETURN_UNSUPPORTED.
3688 : **/
3689 1 : static void req_key_update_case3(void **state)
3690 : {
3691 : libspdm_return_t status;
3692 : libspdm_test_context_t *spdm_test_context;
3693 : libspdm_context_t *spdm_context;
3694 : uint32_t session_id;
3695 : libspdm_session_info_t *session_info;
3696 :
3697 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
3698 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
3699 :
3700 1 : spdm_test_context = *state;
3701 1 : spdm_context = spdm_test_context->spdm_context;
3702 1 : spdm_test_context->case_id = 0x3;
3703 :
3704 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3705 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3706 1 : libspdm_set_standard_key_update_test_state(
3707 : spdm_context, &session_id);
3708 :
3709 : /*state not negotiated*/
3710 1 : spdm_context->connection_info.connection_state =
3711 : LIBSPDM_CONNECTION_STATE_NOT_STARTED;
3712 :
3713 1 : session_info = &spdm_context->session_info[0];
3714 :
3715 1 : libspdm_set_standard_key_update_test_secrets(
3716 1 : session_info->secured_message_context,
3717 : m_rsp_secret_buffer, (uint8_t)(0xFF),
3718 : m_req_secret_buffer, (uint8_t)(0xEE));
3719 :
3720 1 : status = libspdm_key_update(
3721 : spdm_context, session_id, true);
3722 :
3723 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_STATE_LOCAL);
3724 1 : }
3725 :
3726 : /**
3727 : * Test 4: the requester is setup correctly (see Test 2), but receives an ERROR
3728 : * message indicating InvalidParameters when updating key.
3729 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR, and
3730 : * no keys should be updated.
3731 : **/
3732 1 : static void req_key_update_case4(void **state)
3733 : {
3734 : libspdm_return_t status;
3735 : libspdm_test_context_t *spdm_test_context;
3736 : libspdm_context_t *spdm_context;
3737 : uint32_t session_id;
3738 : libspdm_session_info_t *session_info;
3739 :
3740 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
3741 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
3742 :
3743 1 : spdm_test_context = *state;
3744 1 : spdm_context = spdm_test_context->spdm_context;
3745 1 : spdm_test_context->case_id = 0x4;
3746 :
3747 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3748 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3749 1 : libspdm_set_standard_key_update_test_state(
3750 : spdm_context, &session_id);
3751 :
3752 1 : session_info = &spdm_context->session_info[0];
3753 :
3754 1 : libspdm_set_standard_key_update_test_secrets(
3755 1 : session_info->secured_message_context,
3756 : m_rsp_secret_buffer, (uint8_t)(0xFF),
3757 : m_req_secret_buffer, (uint8_t)(0xEE));
3758 :
3759 : /*no keys are updated*/
3760 :
3761 1 : status = libspdm_key_update(
3762 : spdm_context, session_id, true);
3763 :
3764 1 : assert_int_equal(status, LIBSPDM_STATUS_ERROR_PEER);
3765 1 : assert_memory_equal(((libspdm_secured_message_context_t
3766 : *)(session_info->secured_message_context))
3767 : ->application_secret.request_data_secret,
3768 : m_req_secret_buffer, ((libspdm_secured_message_context_t
3769 : *)(session_info->secured_message_context))->hash_size);
3770 1 : assert_memory_equal(((libspdm_secured_message_context_t
3771 : *)(session_info->secured_message_context))
3772 : ->application_secret.response_data_secret,
3773 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
3774 : *)(session_info->secured_message_context))->hash_size);
3775 1 : }
3776 :
3777 : /**
3778 : * Test 5: the requester is setup correctly (see Test 2), but receives an ERROR
3779 : * message indicating the Busy status of the responder, when updating key.
3780 : * Expected behavior: client returns a Status of RETURN_NO_RESPONSE, and
3781 : * no keys should be updated.
3782 : **/
3783 1 : static void req_key_update_case5(void **state)
3784 : {
3785 : libspdm_return_t status;
3786 : libspdm_test_context_t *spdm_test_context;
3787 : libspdm_context_t *spdm_context;
3788 : uint32_t session_id;
3789 : libspdm_session_info_t *session_info;
3790 :
3791 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
3792 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
3793 :
3794 1 : spdm_test_context = *state;
3795 1 : spdm_context = spdm_test_context->spdm_context;
3796 1 : spdm_test_context->case_id = 0x5;
3797 :
3798 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3799 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3800 1 : libspdm_set_standard_key_update_test_state(
3801 : spdm_context, &session_id);
3802 :
3803 1 : session_info = &spdm_context->session_info[0];
3804 :
3805 1 : libspdm_set_standard_key_update_test_secrets(
3806 1 : session_info->secured_message_context,
3807 : m_rsp_secret_buffer, (uint8_t)(0xFF),
3808 : m_req_secret_buffer, (uint8_t)(0xEE));
3809 :
3810 : /*no keys are updated*/
3811 :
3812 1 : status = libspdm_key_update(
3813 : spdm_context, session_id, true);
3814 :
3815 1 : assert_int_equal(status, LIBSPDM_STATUS_BUSY_PEER);
3816 1 : assert_memory_equal(((libspdm_secured_message_context_t
3817 : *)(session_info->secured_message_context))
3818 : ->application_secret.request_data_secret,
3819 : m_req_secret_buffer, ((libspdm_secured_message_context_t
3820 : *)(session_info->secured_message_context))->hash_size);
3821 1 : assert_memory_equal(((libspdm_secured_message_context_t
3822 : *)(session_info->secured_message_context))
3823 : ->application_secret.response_data_secret,
3824 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
3825 : *)(session_info->secured_message_context))->hash_size);
3826 1 : }
3827 :
3828 : /**
3829 : * Test 6: the requester is setup correctly (see Test 2), but, when updating
3830 : * key, on the first try, receiving a Busy ERROR message, and on retry,
3831 : * receiving a correct KEY_UPDATE_ACK message. The VERIFY_KEY behavior is
3832 : * not altered.
3833 : * Expected behavior: client returns a Status of LIBSPDM_STATUS_SUCCESS, the
3834 : * request data key is updated, but not the response data key.
3835 : **/
3836 1 : static void req_key_update_case6(void **state)
3837 : {
3838 : libspdm_return_t status;
3839 : libspdm_test_context_t *spdm_test_context;
3840 : libspdm_context_t *spdm_context;
3841 : uint32_t session_id;
3842 : libspdm_session_info_t *session_info;
3843 :
3844 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
3845 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
3846 :
3847 1 : spdm_test_context = *state;
3848 1 : spdm_context = spdm_test_context->spdm_context;
3849 1 : spdm_test_context->case_id = 0x6;
3850 :
3851 1 : spdm_context->retry_times = 3;
3852 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3853 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3854 1 : libspdm_set_standard_key_update_test_state(
3855 : spdm_context, &session_id);
3856 :
3857 1 : session_info = &spdm_context->session_info[0];
3858 :
3859 1 : libspdm_set_standard_key_update_test_secrets(
3860 1 : session_info->secured_message_context,
3861 : m_rsp_secret_buffer, (uint8_t)(0xFF),
3862 : m_req_secret_buffer, (uint8_t)(0xEE));
3863 :
3864 : /*request side updated*/
3865 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
3866 : ((libspdm_secured_message_context_t
3867 1 : *)(session_info->secured_message_context))->hash_size,
3868 : m_req_secret_buffer, m_req_secret_buffer,
3869 : sizeof(m_req_secret_buffer));
3870 : /*response side *not* updated*/
3871 :
3872 1 : status = libspdm_key_update(
3873 : spdm_context, session_id, true);
3874 :
3875 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
3876 1 : assert_memory_equal(((libspdm_secured_message_context_t
3877 : *)(session_info->secured_message_context))
3878 : ->application_secret.request_data_secret,
3879 : m_req_secret_buffer, ((libspdm_secured_message_context_t
3880 : *)(session_info->secured_message_context))->hash_size);
3881 1 : assert_memory_equal(((libspdm_secured_message_context_t
3882 : *)(session_info->secured_message_context))
3883 : ->application_secret.response_data_secret,
3884 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
3885 : *)(session_info->secured_message_context))->hash_size);
3886 1 : }
3887 :
3888 : /**
3889 : * Test 7: the requester is setup correctly (see Test 2), but receives an ERROR
3890 : * message indicating the RequestResynch status of the responder, when updating
3891 : * key.
3892 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR, and the
3893 : * communication is reset to expect a new GET_VERSION message.
3894 : **/
3895 1 : static void req_key_update_case7(void **state)
3896 : {
3897 : libspdm_return_t status;
3898 : libspdm_test_context_t *spdm_test_context;
3899 : libspdm_context_t *spdm_context;
3900 : uint32_t session_id;
3901 : libspdm_session_info_t *session_info;
3902 :
3903 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
3904 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
3905 :
3906 1 : spdm_test_context = *state;
3907 1 : spdm_context = spdm_test_context->spdm_context;
3908 1 : spdm_test_context->case_id = 0x7;
3909 :
3910 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3911 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3912 1 : libspdm_set_standard_key_update_test_state(
3913 : spdm_context, &session_id);
3914 :
3915 1 : session_info = &spdm_context->session_info[0];
3916 :
3917 1 : libspdm_set_standard_key_update_test_secrets(
3918 1 : session_info->secured_message_context,
3919 : m_rsp_secret_buffer, (uint8_t)(0xFF),
3920 : m_req_secret_buffer, (uint8_t)(0xEE));
3921 :
3922 1 : status = libspdm_key_update(
3923 : spdm_context, session_id, true);
3924 :
3925 1 : assert_int_equal(status, LIBSPDM_STATUS_RESYNCH_PEER);
3926 1 : assert_int_equal(spdm_context->connection_info.connection_state,
3927 : LIBSPDM_CONNECTION_STATE_NOT_STARTED);
3928 1 : }
3929 :
3930 : /**
3931 : * Test 8: the requester is setup correctly (see Test 2), but receives an ERROR
3932 : * message indicating the ResponseNotReady status of the responder, when
3933 : * updating key.
3934 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR, and
3935 : * no keys should be updated.
3936 : **/
3937 1 : static void req_key_update_case8(void **state)
3938 : {
3939 : libspdm_return_t status;
3940 : libspdm_test_context_t *spdm_test_context;
3941 : libspdm_context_t *spdm_context;
3942 : uint32_t session_id;
3943 : libspdm_session_info_t *session_info;
3944 :
3945 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
3946 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
3947 :
3948 1 : spdm_test_context = *state;
3949 1 : spdm_context = spdm_test_context->spdm_context;
3950 1 : spdm_test_context->case_id = 0x8;
3951 :
3952 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3953 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3954 1 : libspdm_set_standard_key_update_test_state(
3955 : spdm_context, &session_id);
3956 :
3957 1 : session_info = &spdm_context->session_info[0];
3958 :
3959 1 : libspdm_set_standard_key_update_test_secrets(
3960 1 : session_info->secured_message_context,
3961 : m_rsp_secret_buffer, (uint8_t)(0xFF),
3962 : m_req_secret_buffer, (uint8_t)(0xEE));
3963 :
3964 : /*no keys are updated*/
3965 :
3966 1 : status = libspdm_key_update(
3967 : spdm_context, session_id, true);
3968 :
3969 1 : assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
3970 1 : assert_memory_equal(((libspdm_secured_message_context_t
3971 : *)(session_info->secured_message_context))
3972 : ->application_secret.request_data_secret,
3973 : m_req_secret_buffer, ((libspdm_secured_message_context_t
3974 : *)(session_info->secured_message_context))->hash_size);
3975 1 : assert_memory_equal(((libspdm_secured_message_context_t
3976 : *)(session_info->secured_message_context))
3977 : ->application_secret.response_data_secret,
3978 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
3979 : *)(session_info->secured_message_context))->hash_size);
3980 1 : }
3981 :
3982 : /**
3983 : * Test 9: the requester is setup correctly (see Test 2), but, when updating
3984 : * key, on the first try, receiving a ResponseNotReady ERROR message, and on
3985 : * retry, receiving a correct KEY_UPDATE_ACK message. The VERIFY_KEY
3986 : * behavior is not altered.
3987 : * Expected behavior: client returns a Status of LIBSPDM_STATUS_SUCCESS, the
3988 : * request data key is updated, but not the response data key.
3989 : **/
3990 1 : static void req_key_update_case9(void **state)
3991 : {
3992 : libspdm_return_t status;
3993 : libspdm_test_context_t *spdm_test_context;
3994 : libspdm_context_t *spdm_context;
3995 : uint32_t session_id;
3996 : libspdm_session_info_t *session_info;
3997 :
3998 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
3999 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4000 :
4001 1 : spdm_test_context = *state;
4002 1 : spdm_context = spdm_test_context->spdm_context;
4003 1 : spdm_test_context->case_id = 0x9;
4004 :
4005 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4006 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4007 1 : libspdm_set_standard_key_update_test_state(spdm_context, &session_id);
4008 :
4009 1 : session_info = &spdm_context->session_info[0];
4010 :
4011 1 : libspdm_set_standard_key_update_test_secrets(
4012 1 : session_info->secured_message_context,
4013 : m_rsp_secret_buffer, (uint8_t)(0xFF),
4014 : m_req_secret_buffer, (uint8_t)(0xEE));
4015 :
4016 : /*request side updated*/
4017 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
4018 : ((libspdm_secured_message_context_t
4019 1 : *)(session_info->secured_message_context))->hash_size,
4020 : m_req_secret_buffer, m_req_secret_buffer,
4021 : sizeof(m_req_secret_buffer));
4022 : /*response side *not* updated*/
4023 :
4024 1 : status = libspdm_key_update(spdm_context, session_id, true);
4025 :
4026 : if (LIBSPDM_RESPOND_IF_READY_SUPPORT) {
4027 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
4028 1 : assert_memory_equal(((libspdm_secured_message_context_t *)
4029 : (session_info->secured_message_context))->application_secret.request_data_secret,
4030 : m_req_secret_buffer, ((libspdm_secured_message_context_t *)
4031 : (session_info->secured_message_context))->hash_size);
4032 :
4033 1 : assert_memory_equal(((libspdm_secured_message_context_t *)
4034 : (session_info->secured_message_context))->application_secret.response_data_secret,
4035 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t *)
4036 : (session_info->secured_message_context))->hash_size);
4037 : } else {
4038 : assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
4039 : }
4040 :
4041 1 : }
4042 :
4043 : /**
4044 : * Test 10: receiving an unexpected ERROR message from the responder,
4045 : * when updating key.
4046 : * There are tests for all named codes, including some reserved ones
4047 : * (namely, 0x00, 0x0b, 0x0c, 0x3f, 0xfd, 0xfe).
4048 : * However, for having specific test cases, it is excluded from this case:
4049 : * Busy (0x03), ResponseNotReady (0x42), and RequestResync (0x43).
4050 : * Expected behavior: client returns a status of RETURN_DEVICE_ERROR, and
4051 : * no keys should be updated.
4052 : **/
4053 1 : static void req_key_update_case10(void **state)
4054 : {
4055 : libspdm_return_t status;
4056 : libspdm_test_context_t *spdm_test_context;
4057 : libspdm_context_t *spdm_context;
4058 : uint32_t session_id;
4059 : libspdm_session_info_t *session_info;
4060 : uint16_t error_code;
4061 :
4062 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4063 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4064 :
4065 1 : spdm_test_context = *state;
4066 1 : spdm_context = spdm_test_context->spdm_context;
4067 1 : spdm_test_context->case_id = 0xA;
4068 :
4069 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4070 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4071 1 : libspdm_set_standard_key_update_test_state(
4072 : spdm_context, &session_id);
4073 :
4074 1 : session_info = &spdm_context->session_info[0];
4075 :
4076 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
4077 18 : while(error_code <= 0xff) {
4078 : /* skip SPDM_ERROR_CODE_DECRYPT_ERROR, because this case will free context*/
4079 17 : if(error_code == SPDM_ERROR_CODE_DECRYPT_ERROR) {
4080 1 : error_code++;
4081 : }
4082 17 : libspdm_set_standard_key_update_test_secrets(
4083 17 : session_info->secured_message_context,
4084 : m_rsp_secret_buffer, (uint8_t)(0xFF),
4085 : m_req_secret_buffer, (uint8_t)(0xEE));
4086 :
4087 : /*no keys are updated*/
4088 :
4089 17 : status = libspdm_key_update(
4090 : spdm_context, session_id, true);
4091 :
4092 17 : LIBSPDM_ASSERT_INT_EQUAL_CASE (status, LIBSPDM_STATUS_ERROR_PEER, error_code);
4093 17 : assert_memory_equal(((libspdm_secured_message_context_t
4094 : *)(session_info->secured_message_context))
4095 : ->application_secret.request_data_secret,
4096 : m_req_secret_buffer, ((libspdm_secured_message_context_t
4097 : *)(session_info->secured_message_context))->hash_size);
4098 17 : assert_memory_equal(((libspdm_secured_message_context_t
4099 : *)(session_info->secured_message_context))
4100 : ->application_secret.response_data_secret,
4101 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
4102 : *)(session_info->secured_message_context))->hash_size);
4103 :
4104 17 : error_code++;
4105 : /*busy is treated in cases 5 and 6*/
4106 17 : if(error_code == SPDM_ERROR_CODE_BUSY) {
4107 1 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
4108 : }
4109 : /*skip some reserved error codes (0d to 3e)*/
4110 17 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) {
4111 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
4112 : }
4113 : /*skip response not ready, request resync, and some reserved codes (44 to fc)*/
4114 17 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) {
4115 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
4116 : }
4117 : }
4118 1 : }
4119 :
4120 1 : static void req_key_update_case11(void **state)
4121 : {
4122 : libspdm_return_t status;
4123 : libspdm_test_context_t *spdm_test_context;
4124 : libspdm_context_t *spdm_context;
4125 : uint32_t session_id;
4126 : libspdm_session_info_t *session_info;
4127 :
4128 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4129 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4130 :
4131 1 : spdm_test_context = *state;
4132 1 : spdm_context = spdm_test_context->spdm_context;
4133 1 : spdm_test_context->case_id = 0xB;
4134 :
4135 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4136 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4137 1 : libspdm_set_standard_key_update_test_state(
4138 : spdm_context, &session_id);
4139 :
4140 1 : session_info = &spdm_context->session_info[0];
4141 :
4142 1 : libspdm_set_standard_key_update_test_secrets(
4143 1 : session_info->secured_message_context,
4144 : m_rsp_secret_buffer, (uint8_t)(0xFF),
4145 : m_req_secret_buffer, (uint8_t)(0xEE));
4146 :
4147 : /*request side updated*/
4148 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
4149 : ((libspdm_secured_message_context_t
4150 1 : *)(session_info->secured_message_context))->hash_size,
4151 : m_req_secret_buffer, m_req_secret_buffer,
4152 : sizeof(m_req_secret_buffer));
4153 : /*response side *not* updated*/
4154 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4155 : session_info->session_transcript.message_m.buffer_size =
4156 : session_info->session_transcript.message_m.max_buffer_size;
4157 : spdm_context->transcript.message_b.buffer_size =
4158 : spdm_context->transcript.message_b.max_buffer_size;
4159 : spdm_context->transcript.message_c.buffer_size =
4160 : spdm_context->transcript.message_c.max_buffer_size;
4161 : spdm_context->transcript.message_mut_b.buffer_size =
4162 : spdm_context->transcript.message_mut_b.max_buffer_size;
4163 : spdm_context->transcript.message_mut_c.buffer_size =
4164 : spdm_context->transcript.message_mut_c.max_buffer_size;
4165 : #endif
4166 :
4167 1 : status = libspdm_key_update(
4168 : spdm_context, session_id, true);
4169 :
4170 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
4171 1 : assert_memory_equal(((libspdm_secured_message_context_t
4172 : *)(session_info->secured_message_context))
4173 : ->application_secret.request_data_secret,
4174 : m_req_secret_buffer, ((libspdm_secured_message_context_t
4175 : *)(session_info->secured_message_context))->hash_size);
4176 1 : assert_memory_equal(((libspdm_secured_message_context_t
4177 : *)(session_info->secured_message_context))
4178 : ->application_secret.response_data_secret,
4179 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
4180 : *)(session_info->secured_message_context))->hash_size);
4181 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4182 : assert_int_equal(session_info->session_transcript.message_m.buffer_size, 0);
4183 : assert_int_equal(spdm_context->transcript.message_b.buffer_size, 0);
4184 : assert_int_equal(spdm_context->transcript.message_c.buffer_size, 0);
4185 : assert_int_equal(spdm_context->transcript.message_mut_b.buffer_size, 0);
4186 : assert_int_equal(spdm_context->transcript.message_mut_c.buffer_size, 0);
4187 : #endif
4188 1 : }
4189 :
4190 : /**
4191 : * Test 12: requester is not setup correctly to support key update
4192 : * (no capabilities). The responder would attempt to return a correct
4193 : * KEY_UPDATE_ACK message.
4194 : * Expected behavior: client returns a Status of RETURN_UNSUPPORTED,
4195 : * and no keys are updated.
4196 : **/
4197 1 : static void req_key_update_case12(void **state)
4198 : {
4199 : libspdm_return_t status;
4200 : libspdm_test_context_t *spdm_test_context;
4201 : libspdm_context_t *spdm_context;
4202 : uint32_t session_id;
4203 : libspdm_session_info_t *session_info;
4204 :
4205 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4206 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4207 :
4208 1 : spdm_test_context = *state;
4209 1 : spdm_context = spdm_test_context->spdm_context;
4210 1 : spdm_test_context->case_id = 0xC;
4211 :
4212 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4213 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4214 1 : libspdm_set_standard_key_update_test_state(
4215 : spdm_context, &session_id);
4216 :
4217 : /*no capabilities*/
4218 1 : spdm_context->connection_info.capability.flags &=
4219 : ~SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_UPD_CAP;
4220 1 : spdm_context->local_context.capability.flags &=
4221 : ~SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP;
4222 :
4223 1 : session_info = &spdm_context->session_info[0];
4224 :
4225 1 : libspdm_set_standard_key_update_test_secrets(
4226 1 : session_info->secured_message_context,
4227 : m_rsp_secret_buffer, (uint8_t)(0xFF),
4228 : m_req_secret_buffer, (uint8_t)(0xEE));
4229 :
4230 : /*no keys are updated*/
4231 :
4232 1 : status = libspdm_key_update(
4233 : spdm_context, session_id, true);
4234 :
4235 1 : assert_int_equal(status, LIBSPDM_STATUS_UNSUPPORTED_CAP);
4236 1 : assert_memory_equal(((libspdm_secured_message_context_t
4237 : *)(session_info->secured_message_context))
4238 : ->application_secret.request_data_secret,
4239 : m_req_secret_buffer, ((libspdm_secured_message_context_t
4240 : *)(session_info->secured_message_context))->hash_size);
4241 1 : assert_memory_equal(((libspdm_secured_message_context_t
4242 : *)(session_info->secured_message_context))
4243 : ->application_secret.response_data_secret,
4244 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
4245 : *)(session_info->secured_message_context))->hash_size);
4246 1 : }
4247 :
4248 : /**
4249 : * Test 13: receiving an incorrect KEY_UPDATE_ACK message, with wrong
4250 : * response code, but all other field correct, when updating key.
4251 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR,
4252 : * no keys are updated.
4253 : **/
4254 1 : static void req_key_update_case13(void **state)
4255 : {
4256 : libspdm_return_t status;
4257 : libspdm_test_context_t *spdm_test_context;
4258 : libspdm_context_t *spdm_context;
4259 : uint32_t session_id;
4260 : libspdm_session_info_t *session_info;
4261 :
4262 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4263 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4264 :
4265 1 : spdm_test_context = *state;
4266 1 : spdm_context = spdm_test_context->spdm_context;
4267 1 : spdm_test_context->case_id = 0xC;
4268 :
4269 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4270 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4271 1 : libspdm_set_standard_key_update_test_state(
4272 : spdm_context, &session_id);
4273 :
4274 1 : session_info = &spdm_context->session_info[0];
4275 :
4276 1 : libspdm_set_standard_key_update_test_secrets(
4277 1 : session_info->secured_message_context,
4278 : m_rsp_secret_buffer, (uint8_t)(0xFF),
4279 : m_req_secret_buffer, (uint8_t)(0xEE));
4280 :
4281 : /*no keys are updated*/
4282 :
4283 1 : status = libspdm_key_update(
4284 : spdm_context, session_id, true);
4285 :
4286 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
4287 1 : assert_memory_equal(((libspdm_secured_message_context_t
4288 : *)(session_info->secured_message_context))
4289 : ->application_secret.request_data_secret,
4290 : m_req_secret_buffer, ((libspdm_secured_message_context_t
4291 : *)(session_info->secured_message_context))->hash_size);
4292 1 : assert_memory_equal(((libspdm_secured_message_context_t
4293 : *)(session_info->secured_message_context))
4294 : ->application_secret.response_data_secret,
4295 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
4296 : *)(session_info->secured_message_context))->hash_size);
4297 1 : }
4298 :
4299 : /**
4300 : * Test 14: requester is not setup correctly by not initializing a
4301 : * session during KEY_EXCHANGE. The responder would attempt to
4302 : * return a correct KEY_UPDATE_ACK message.
4303 : * Expected behavior: client returns a Status of RETURN_UNSUPPORTED,
4304 : * and no keys are updated.
4305 : **/
4306 1 : static void req_key_update_case14(void **state)
4307 : {
4308 : libspdm_return_t status;
4309 : libspdm_test_context_t *spdm_test_context;
4310 : libspdm_context_t *spdm_context;
4311 : uint32_t session_id;
4312 : libspdm_session_info_t *session_info;
4313 :
4314 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4315 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4316 :
4317 1 : spdm_test_context = *state;
4318 1 : spdm_context = spdm_test_context->spdm_context;
4319 1 : spdm_test_context->case_id = 0xD;
4320 :
4321 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4322 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4323 1 : libspdm_set_standard_key_update_test_state(
4324 : spdm_context, &session_id);
4325 :
4326 1 : session_info = &spdm_context->session_info[0];
4327 :
4328 : /*session not initialized*/
4329 1 : libspdm_secured_message_set_session_state(
4330 : session_info->secured_message_context,
4331 : LIBSPDM_SESSION_STATE_NOT_STARTED);
4332 :
4333 1 : libspdm_set_standard_key_update_test_secrets(
4334 1 : session_info->secured_message_context,
4335 : m_rsp_secret_buffer, (uint8_t)(0xFF),
4336 : m_req_secret_buffer, (uint8_t)(0xEE));
4337 :
4338 : /*no keys are updated*/
4339 :
4340 1 : status = libspdm_key_update(
4341 : spdm_context, session_id, true);
4342 :
4343 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_STATE_LOCAL);
4344 1 : assert_memory_equal(((libspdm_secured_message_context_t
4345 : *)(session_info->secured_message_context))
4346 : ->application_secret.request_data_secret,
4347 : m_req_secret_buffer, ((libspdm_secured_message_context_t
4348 : *)(session_info->secured_message_context))->hash_size);
4349 1 : assert_memory_equal(((libspdm_secured_message_context_t
4350 : *)(session_info->secured_message_context))
4351 : ->application_secret.response_data_secret,
4352 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
4353 : *)(session_info->secured_message_context))->hash_size);
4354 1 : }
4355 :
4356 : /**
4357 : * Test 15: the requester is setup correctly (see Test 2), but receives a
4358 : * KEY_UPDATE_ACK response with the wrong token. The VERIFY_KEY behavior
4359 : * is not altered.
4360 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR, and
4361 : * no keys should be updated.
4362 : **/
4363 1 : static void req_key_update_case15(void **state)
4364 : {
4365 : libspdm_return_t status;
4366 : libspdm_test_context_t *spdm_test_context;
4367 : libspdm_context_t *spdm_context;
4368 : uint32_t session_id;
4369 : libspdm_session_info_t *session_info;
4370 :
4371 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4372 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4373 :
4374 1 : spdm_test_context = *state;
4375 1 : spdm_context = spdm_test_context->spdm_context;
4376 1 : spdm_test_context->case_id = 0xF;
4377 :
4378 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4379 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4380 1 : libspdm_set_standard_key_update_test_state(
4381 : spdm_context, &session_id);
4382 :
4383 1 : session_info = &spdm_context->session_info[0];
4384 :
4385 1 : libspdm_set_standard_key_update_test_secrets(
4386 1 : session_info->secured_message_context,
4387 : m_rsp_secret_buffer, (uint8_t)(0xFF),
4388 : m_req_secret_buffer, (uint8_t)(0xEE));
4389 :
4390 : /*no keys are updated*/
4391 :
4392 1 : status = libspdm_key_update(
4393 : spdm_context, session_id, true);
4394 :
4395 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
4396 1 : assert_memory_equal(((libspdm_secured_message_context_t
4397 : *)(session_info->secured_message_context))
4398 : ->application_secret.request_data_secret,
4399 : m_req_secret_buffer, ((libspdm_secured_message_context_t
4400 : *)(session_info->secured_message_context))->hash_size);
4401 1 : assert_memory_equal(((libspdm_secured_message_context_t
4402 : *)(session_info->secured_message_context))
4403 : ->application_secret.response_data_secret,
4404 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
4405 : *)(session_info->secured_message_context))->hash_size);
4406 1 : }
4407 :
4408 : /**
4409 : * Test 16: the requester is setup correctly (see Test 2), but receives a
4410 : * KEY_UPDATE_ACK response with the operation code. The VERIFY_KEY
4411 : * behavior is not altered.
4412 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR, and
4413 : * no keys should be updated.
4414 : **/
4415 1 : static void req_key_update_case16(void **state)
4416 : {
4417 : libspdm_return_t status;
4418 : libspdm_test_context_t *spdm_test_context;
4419 : libspdm_context_t *spdm_context;
4420 : uint32_t session_id;
4421 : libspdm_session_info_t *session_info;
4422 :
4423 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4424 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4425 :
4426 1 : spdm_test_context = *state;
4427 1 : spdm_context = spdm_test_context->spdm_context;
4428 1 : spdm_test_context->case_id = 0x10;
4429 :
4430 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4431 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4432 1 : libspdm_set_standard_key_update_test_state(
4433 : spdm_context, &session_id);
4434 :
4435 1 : session_info = &spdm_context->session_info[0];
4436 :
4437 1 : libspdm_set_standard_key_update_test_secrets(
4438 1 : session_info->secured_message_context,
4439 : m_rsp_secret_buffer, (uint8_t)(0xFF),
4440 : m_req_secret_buffer, (uint8_t)(0xEE));
4441 :
4442 : /*no keys are updated*/
4443 :
4444 1 : status = libspdm_key_update(
4445 : spdm_context, session_id, true);
4446 :
4447 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
4448 1 : assert_memory_equal(((libspdm_secured_message_context_t
4449 : *)(session_info->secured_message_context))
4450 : ->application_secret.request_data_secret,
4451 : m_req_secret_buffer, ((libspdm_secured_message_context_t
4452 : *)(session_info->secured_message_context))->hash_size);
4453 1 : assert_memory_equal(((libspdm_secured_message_context_t
4454 : *)(session_info->secured_message_context))
4455 : ->application_secret.response_data_secret,
4456 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
4457 : *)(session_info->secured_message_context))->hash_size);
4458 1 : }
4459 :
4460 : /**
4461 : * Test 17: the requester is setup correctly (see Test 2), but receives an
4462 : * ERROR message indicating InvalidParameters when verifying key.
4463 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR, the
4464 : * request data key is not rollbacked.
4465 : **/
4466 1 : static void req_key_update_case17(void **state)
4467 : {
4468 : libspdm_return_t status;
4469 : libspdm_test_context_t *spdm_test_context;
4470 : libspdm_context_t *spdm_context;
4471 : uint32_t session_id;
4472 : libspdm_session_info_t *session_info;
4473 :
4474 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4475 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4476 :
4477 1 : spdm_test_context = *state;
4478 1 : spdm_context = spdm_test_context->spdm_context;
4479 1 : spdm_test_context->case_id = 0x11;
4480 :
4481 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4482 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4483 1 : libspdm_set_standard_key_update_test_state(spdm_context, &session_id);
4484 :
4485 1 : session_info = &spdm_context->session_info[0];
4486 :
4487 1 : libspdm_set_standard_key_update_test_secrets(
4488 1 : session_info->secured_message_context,
4489 : m_rsp_secret_buffer, (uint8_t)(0xFF),
4490 : m_req_secret_buffer, (uint8_t)(0xEE));
4491 :
4492 : /*request side updated*/
4493 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
4494 : ((libspdm_secured_message_context_t
4495 1 : *)(session_info->secured_message_context))->hash_size,
4496 : m_req_secret_buffer, m_req_secret_buffer,
4497 : sizeof(m_req_secret_buffer));
4498 : /*response side *not* updated*/
4499 :
4500 1 : status = libspdm_key_update(spdm_context, session_id, true);
4501 :
4502 1 : assert_int_equal(status, LIBSPDM_STATUS_ERROR_PEER);
4503 1 : assert_memory_equal(((libspdm_secured_message_context_t
4504 : *)(session_info->secured_message_context))
4505 : ->application_secret.request_data_secret,
4506 : m_req_secret_buffer, ((libspdm_secured_message_context_t
4507 : *)(session_info->secured_message_context))->hash_size);
4508 1 : assert_memory_equal(((libspdm_secured_message_context_t
4509 : *)(session_info->secured_message_context))
4510 : ->application_secret.response_data_secret,
4511 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
4512 : *)(session_info->secured_message_context))->hash_size);
4513 1 : }
4514 :
4515 : /**
4516 : * Test 18: the requester is setup correctly (see Test 2), but receives an
4517 : * ERROR message indicating the Busy status of the responder, when verifying
4518 : * key.
4519 : * Expected behavior: client returns a Status of RETURN_NO_RESPONSE, the
4520 : * request data key is not rollbacked.
4521 : **/
4522 1 : static void req_key_update_case18(void **state)
4523 : {
4524 : libspdm_return_t status;
4525 : libspdm_test_context_t *spdm_test_context;
4526 : libspdm_context_t *spdm_context;
4527 : uint32_t session_id;
4528 : libspdm_session_info_t *session_info;
4529 :
4530 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4531 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4532 :
4533 1 : spdm_test_context = *state;
4534 1 : spdm_context = spdm_test_context->spdm_context;
4535 1 : spdm_test_context->case_id = 0x12;
4536 :
4537 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4538 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4539 1 : libspdm_set_standard_key_update_test_state(
4540 : spdm_context, &session_id);
4541 :
4542 1 : session_info = &spdm_context->session_info[0];
4543 :
4544 1 : libspdm_set_standard_key_update_test_secrets(
4545 1 : session_info->secured_message_context,
4546 : m_rsp_secret_buffer, (uint8_t)(0xFF),
4547 : m_req_secret_buffer, (uint8_t)(0xEE));
4548 :
4549 : /*request side updated*/
4550 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
4551 : ((libspdm_secured_message_context_t
4552 1 : *)(session_info->secured_message_context))->hash_size,
4553 : m_req_secret_buffer, m_req_secret_buffer,
4554 : sizeof(m_req_secret_buffer));
4555 : /*response side *not* updated*/
4556 :
4557 1 : status = libspdm_key_update(
4558 : spdm_context, session_id, true);
4559 :
4560 1 : assert_int_equal(status, LIBSPDM_STATUS_BUSY_PEER);
4561 1 : assert_memory_equal(((libspdm_secured_message_context_t
4562 : *)(session_info->secured_message_context))
4563 : ->application_secret.request_data_secret,
4564 : m_req_secret_buffer, ((libspdm_secured_message_context_t
4565 : *)(session_info->secured_message_context))->hash_size);
4566 1 : assert_memory_equal(((libspdm_secured_message_context_t
4567 : *)(session_info->secured_message_context))
4568 : ->application_secret.response_data_secret,
4569 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
4570 : *)(session_info->secured_message_context))->hash_size);
4571 1 : }
4572 :
4573 : /**
4574 : * Test 19: the requester is setup correctly (see Test 2), but, when
4575 : * verifying key, on the first try, receiving a Busy ERROR message,
4576 : * and on retry, receiving a correct KEY_UPDATE_ACK message. The
4577 : * VERIFY_KEY behavior is not altered.
4578 : * Expected behavior: client returns a Status of LIBSPDM_STATUS_SUCCESS, the
4579 : * request data key is not rollbacked.
4580 : **/
4581 1 : static void req_key_update_case19(void **state)
4582 : {
4583 : libspdm_return_t status;
4584 : libspdm_test_context_t *spdm_test_context;
4585 : libspdm_context_t *spdm_context;
4586 : uint32_t session_id;
4587 : libspdm_session_info_t *session_info;
4588 :
4589 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4590 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4591 :
4592 1 : spdm_test_context = *state;
4593 1 : spdm_context = spdm_test_context->spdm_context;
4594 1 : spdm_test_context->case_id = 0x13;
4595 :
4596 1 : spdm_context->retry_times = 3;
4597 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4598 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4599 1 : libspdm_set_standard_key_update_test_state(
4600 : spdm_context, &session_id);
4601 :
4602 1 : session_info = &spdm_context->session_info[0];
4603 :
4604 1 : libspdm_set_standard_key_update_test_secrets(
4605 1 : session_info->secured_message_context,
4606 : m_rsp_secret_buffer, (uint8_t)(0xFF),
4607 : m_req_secret_buffer, (uint8_t)(0xEE));
4608 :
4609 : /*request side updated*/
4610 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
4611 : ((libspdm_secured_message_context_t
4612 1 : *)(session_info->secured_message_context))->hash_size,
4613 : m_req_secret_buffer, m_req_secret_buffer,
4614 : sizeof(m_req_secret_buffer));
4615 : /*response side *not* updated*/
4616 :
4617 1 : status = libspdm_key_update(
4618 : spdm_context, session_id, true);
4619 :
4620 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
4621 1 : assert_memory_equal(((libspdm_secured_message_context_t
4622 : *)(session_info->secured_message_context))
4623 : ->application_secret.request_data_secret,
4624 : m_req_secret_buffer, ((libspdm_secured_message_context_t
4625 : *)(session_info->secured_message_context))->hash_size);
4626 1 : assert_memory_equal(((libspdm_secured_message_context_t
4627 : *)(session_info->secured_message_context))
4628 : ->application_secret.response_data_secret,
4629 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
4630 : *)(session_info->secured_message_context))->hash_size);
4631 1 : }
4632 :
4633 : /**
4634 : * Test 20: the requester is setup correctly (see Test 2), but receives an
4635 : * ERROR message indicating the RequestResynch status of the responder, when
4636 : * verifying key.
4637 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR, and the
4638 : * communication is reset to expect a new GET_VERSION message.
4639 : **/
4640 1 : static void req_key_update_case20(void **state)
4641 : {
4642 : libspdm_return_t status;
4643 : libspdm_test_context_t *spdm_test_context;
4644 : libspdm_context_t *spdm_context;
4645 : uint32_t session_id;
4646 : libspdm_session_info_t *session_info;
4647 :
4648 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4649 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4650 :
4651 1 : spdm_test_context = *state;
4652 1 : spdm_context = spdm_test_context->spdm_context;
4653 1 : spdm_test_context->case_id = 0x14;
4654 :
4655 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4656 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4657 1 : libspdm_set_standard_key_update_test_state(
4658 : spdm_context, &session_id);
4659 :
4660 1 : session_info = &spdm_context->session_info[0];
4661 :
4662 1 : libspdm_set_standard_key_update_test_secrets(
4663 1 : session_info->secured_message_context,
4664 : m_rsp_secret_buffer, (uint8_t)(0xFF),
4665 : m_req_secret_buffer, (uint8_t)(0xEE));
4666 :
4667 1 : status = libspdm_key_update(
4668 : spdm_context, session_id, true);
4669 :
4670 1 : assert_int_equal(status, LIBSPDM_STATUS_RESYNCH_PEER);
4671 1 : assert_int_equal(spdm_context->connection_info.connection_state,
4672 : LIBSPDM_CONNECTION_STATE_NOT_STARTED);
4673 1 : }
4674 :
4675 : /**
4676 : * Test 21: the requester is setup correctly (see Test 2), but receives an
4677 : * ERROR message indicating the ResponseNotReady status of the responder, when
4678 : * verifying key.
4679 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR, the
4680 : * request data key is not rollbacked.
4681 : **/
4682 1 : static void req_key_update_case21(void **state)
4683 : {
4684 : libspdm_return_t status;
4685 : libspdm_test_context_t *spdm_test_context;
4686 : libspdm_context_t *spdm_context;
4687 : uint32_t session_id;
4688 : libspdm_session_info_t *session_info;
4689 :
4690 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4691 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4692 :
4693 1 : spdm_test_context = *state;
4694 1 : spdm_context = spdm_test_context->spdm_context;
4695 1 : spdm_test_context->case_id = 0x15;
4696 :
4697 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4698 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4699 1 : libspdm_set_standard_key_update_test_state(
4700 : spdm_context, &session_id);
4701 :
4702 1 : session_info = &spdm_context->session_info[0];
4703 :
4704 1 : libspdm_set_standard_key_update_test_secrets(
4705 1 : session_info->secured_message_context,
4706 : m_rsp_secret_buffer, (uint8_t)(0xFF),
4707 : m_req_secret_buffer, (uint8_t)(0xEE));
4708 :
4709 : /*request side updated*/
4710 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
4711 : ((libspdm_secured_message_context_t
4712 1 : *)(session_info->secured_message_context))->hash_size,
4713 : m_req_secret_buffer, m_req_secret_buffer,
4714 : sizeof(m_req_secret_buffer));
4715 : /*response side *not* updated*/
4716 :
4717 1 : status = libspdm_key_update(
4718 : spdm_context, session_id, true);
4719 :
4720 1 : assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
4721 1 : assert_memory_equal(((libspdm_secured_message_context_t
4722 : *)(session_info->secured_message_context))
4723 : ->application_secret.request_data_secret,
4724 : m_req_secret_buffer, ((libspdm_secured_message_context_t
4725 : *)(session_info->secured_message_context))->hash_size);
4726 1 : assert_memory_equal(((libspdm_secured_message_context_t
4727 : *)(session_info->secured_message_context))
4728 : ->application_secret.response_data_secret,
4729 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
4730 : *)(session_info->secured_message_context))->hash_size);
4731 1 : }
4732 :
4733 : /**
4734 : * Test 22: the requester is setup correctly (see Test 2), but, when verifying
4735 : * key, on the first try, receiving a ResponseNotReady ERROR message, and on
4736 : * retry, receiving a correct KEY_UPDATE_ACK message.
4737 : * Expected behavior: client returns a Status of LIBSPDM_STATUS_SUCCESS, the
4738 : * request data key is not rollbacked.
4739 : **/
4740 1 : static void req_key_update_case22(void **state)
4741 : {
4742 : libspdm_return_t status;
4743 : libspdm_test_context_t *spdm_test_context;
4744 : libspdm_context_t *spdm_context;
4745 : uint32_t session_id;
4746 : libspdm_session_info_t *session_info;
4747 :
4748 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4749 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4750 :
4751 1 : spdm_test_context = *state;
4752 1 : spdm_context = spdm_test_context->spdm_context;
4753 1 : spdm_test_context->case_id = 0x16;
4754 :
4755 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4756 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4757 1 : libspdm_set_standard_key_update_test_state(
4758 : spdm_context, &session_id);
4759 :
4760 1 : session_info = &spdm_context->session_info[0];
4761 :
4762 1 : libspdm_set_standard_key_update_test_secrets(
4763 1 : session_info->secured_message_context,
4764 : m_rsp_secret_buffer, (uint8_t)(0xFF),
4765 : m_req_secret_buffer, (uint8_t)(0xEE));
4766 :
4767 : /*request side updated*/
4768 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
4769 : ((libspdm_secured_message_context_t
4770 1 : *)(session_info->secured_message_context))->hash_size,
4771 : m_req_secret_buffer, m_req_secret_buffer,
4772 : sizeof(m_req_secret_buffer));
4773 : /*response side *not* updated*/
4774 :
4775 1 : status = libspdm_key_update(spdm_context, session_id, true);
4776 :
4777 : if (LIBSPDM_RESPOND_IF_READY_SUPPORT) {
4778 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
4779 1 : assert_memory_equal(((libspdm_secured_message_context_t
4780 : *)(session_info->secured_message_context))
4781 : ->application_secret.request_data_secret,
4782 : m_req_secret_buffer, ((libspdm_secured_message_context_t
4783 : *)(session_info->secured_message_context))->hash_size);
4784 1 : assert_memory_equal(((libspdm_secured_message_context_t
4785 : *)(session_info->secured_message_context))
4786 : ->application_secret.response_data_secret,
4787 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
4788 : *)(session_info->secured_message_context))->hash_size);
4789 : } else {
4790 : assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
4791 : }
4792 1 : }
4793 :
4794 : /**
4795 : * Test 23: receiving an unexpected ERROR message from the responder,
4796 : * when verifying key.
4797 : * There are tests for all named codes, including some reserved ones
4798 : * (namely, 0x00, 0x0b, 0x0c, 0x3f, 0xfd, 0xfe).
4799 : * However, for having specific test cases, it is excluded from this case:
4800 : * Busy (0x03), ResponseNotReady (0x42), and RequestResync (0x43).
4801 : * Expected behavior: client returns a status of RETURN_DEVICE_ERROR, the
4802 : * request data key is not rollbacked.
4803 : **/
4804 1 : static void req_key_update_case23(void **state)
4805 : {
4806 : libspdm_return_t status;
4807 : libspdm_test_context_t *spdm_test_context;
4808 : libspdm_context_t *spdm_context;
4809 : uint32_t session_id;
4810 : libspdm_session_info_t *session_info;
4811 : uint16_t error_code;
4812 :
4813 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4814 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4815 :
4816 1 : spdm_test_context = *state;
4817 1 : spdm_context = spdm_test_context->spdm_context;
4818 1 : spdm_test_context->case_id = 0x17;
4819 :
4820 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4821 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4822 1 : libspdm_set_standard_key_update_test_state(
4823 : spdm_context, &session_id);
4824 :
4825 1 : session_info = &spdm_context->session_info[0];
4826 :
4827 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
4828 18 : while(error_code <= 0xff) {
4829 : /* skip SPDM_ERROR_CODE_DECRYPT_ERROR, because this case will free context*/
4830 17 : if(error_code == SPDM_ERROR_CODE_DECRYPT_ERROR) {
4831 1 : error_code++;
4832 : }
4833 17 : libspdm_set_standard_key_update_test_secrets(
4834 17 : session_info->secured_message_context,
4835 : m_rsp_secret_buffer, (uint8_t)(0xFF),
4836 : m_req_secret_buffer, (uint8_t)(0xEE));
4837 :
4838 : /*request side updated*/
4839 17 : libspdm_compute_secret_update(spdm_context->connection_info.version,
4840 : ((libspdm_secured_message_context_t
4841 17 : *)(session_info->secured_message_context))->hash_size,
4842 : m_req_secret_buffer, m_req_secret_buffer,
4843 : sizeof(m_req_secret_buffer));
4844 : /*response side *not* updated*/
4845 :
4846 17 : status = libspdm_key_update(
4847 : spdm_context, session_id, true);
4848 :
4849 17 : LIBSPDM_ASSERT_INT_EQUAL_CASE (status, LIBSPDM_STATUS_ERROR_PEER, error_code);
4850 17 : assert_memory_equal(((libspdm_secured_message_context_t
4851 : *)(session_info->secured_message_context))
4852 : ->application_secret.request_data_secret,
4853 : m_req_secret_buffer, ((libspdm_secured_message_context_t
4854 : *)(session_info->secured_message_context))->hash_size);
4855 17 : assert_memory_equal(((libspdm_secured_message_context_t
4856 : *)(session_info->secured_message_context))
4857 : ->application_secret.response_data_secret,
4858 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
4859 : *)(session_info->secured_message_context))->hash_size);
4860 :
4861 17 : error_code++;
4862 : /*busy is treated in cases 5 and 6*/
4863 17 : if(error_code == SPDM_ERROR_CODE_BUSY) {
4864 1 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
4865 : }
4866 : /*skip some reserved error codes (0d to 3e)*/
4867 17 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) {
4868 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
4869 : }
4870 : /*skip response not ready, request resync, and some reserved codes (44 to fc)*/
4871 17 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) {
4872 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
4873 : }
4874 : }
4875 1 : }
4876 :
4877 : /**
4878 : * Test 24: receiving an incorrect KEY_UPDATE_ACK message, with wrong
4879 : * response code, but all other field correct, when verifying key.
4880 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR, the
4881 : * request data key is not rollbacked.
4882 : **/
4883 1 : static void req_key_update_case24(void **state)
4884 : {
4885 : libspdm_return_t status;
4886 : libspdm_test_context_t *spdm_test_context;
4887 : libspdm_context_t *spdm_context;
4888 : uint32_t session_id;
4889 : libspdm_session_info_t *session_info;
4890 :
4891 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4892 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4893 :
4894 1 : spdm_test_context = *state;
4895 1 : spdm_context = spdm_test_context->spdm_context;
4896 1 : spdm_test_context->case_id = 0x18;
4897 :
4898 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4899 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4900 1 : libspdm_set_standard_key_update_test_state(
4901 : spdm_context, &session_id);
4902 :
4903 1 : session_info = &spdm_context->session_info[0];
4904 :
4905 1 : libspdm_set_standard_key_update_test_secrets(
4906 1 : session_info->secured_message_context,
4907 : m_rsp_secret_buffer, (uint8_t)(0xFF),
4908 : m_req_secret_buffer, (uint8_t)(0xEE));
4909 :
4910 : /*request side updated*/
4911 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
4912 : ((libspdm_secured_message_context_t
4913 1 : *)(session_info->secured_message_context))->hash_size,
4914 : m_req_secret_buffer, m_req_secret_buffer,
4915 : sizeof(m_req_secret_buffer));
4916 : /*response side *not* updated*/
4917 :
4918 1 : status = libspdm_key_update(
4919 : spdm_context, session_id, true);
4920 :
4921 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
4922 1 : assert_memory_equal(((libspdm_secured_message_context_t
4923 : *)(session_info->secured_message_context))
4924 : ->application_secret.request_data_secret,
4925 : m_req_secret_buffer, ((libspdm_secured_message_context_t
4926 : *)(session_info->secured_message_context))->hash_size);
4927 1 : assert_memory_equal(((libspdm_secured_message_context_t
4928 : *)(session_info->secured_message_context))
4929 : ->application_secret.response_data_secret,
4930 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
4931 : *)(session_info->secured_message_context))->hash_size);
4932 1 : }
4933 :
4934 : /**
4935 : * Test 25: the requester is setup correctly (see Test 2), and receives a
4936 : * correct KEY_UPDATE_ACK to update key. However, it receives a
4937 : * KEY_UPDATE_ACK response with the wrong token to verify the key.
4938 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR, the
4939 : * request data key is not rollbacked.
4940 : **/
4941 1 : static void req_key_update_case25(void **state)
4942 : {
4943 : libspdm_return_t status;
4944 : libspdm_test_context_t *spdm_test_context;
4945 : libspdm_context_t *spdm_context;
4946 : uint32_t session_id;
4947 : libspdm_session_info_t *session_info;
4948 :
4949 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4950 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
4951 :
4952 1 : spdm_test_context = *state;
4953 1 : spdm_context = spdm_test_context->spdm_context;
4954 1 : spdm_test_context->case_id = 0x19;
4955 :
4956 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4957 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4958 1 : libspdm_set_standard_key_update_test_state(
4959 : spdm_context, &session_id);
4960 :
4961 1 : session_info = &spdm_context->session_info[0];
4962 :
4963 1 : libspdm_set_standard_key_update_test_secrets(
4964 1 : session_info->secured_message_context,
4965 : m_rsp_secret_buffer, (uint8_t)(0xFF),
4966 : m_req_secret_buffer, (uint8_t)(0xEE));
4967 :
4968 : /*request side updated*/
4969 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
4970 : ((libspdm_secured_message_context_t
4971 1 : *)(session_info->secured_message_context))->hash_size,
4972 : m_req_secret_buffer, m_req_secret_buffer,
4973 : sizeof(m_req_secret_buffer));
4974 : /*response side *not* updated*/
4975 :
4976 1 : status = libspdm_key_update(
4977 : spdm_context, session_id, true);
4978 :
4979 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
4980 1 : assert_memory_equal(((libspdm_secured_message_context_t
4981 : *)(session_info->secured_message_context))
4982 : ->application_secret.request_data_secret,
4983 : m_req_secret_buffer, ((libspdm_secured_message_context_t
4984 : *)(session_info->secured_message_context))->hash_size);
4985 1 : assert_memory_equal(((libspdm_secured_message_context_t
4986 : *)(session_info->secured_message_context))
4987 : ->application_secret.response_data_secret,
4988 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
4989 : *)(session_info->secured_message_context))->hash_size);
4990 1 : }
4991 :
4992 : /**
4993 : * Test 26: the requester is setup correctly (see Test 2) and receives a
4994 : * correct KEY_UPDATE_ACK to update key. However, it receives a
4995 : * KEY_UPDATE_ACK response with the wrong operation code to verify the key.
4996 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR, the
4997 : * request data key is not rollbacked.
4998 : **/
4999 1 : static void req_key_update_case26(void **state)
5000 : {
5001 : libspdm_return_t status;
5002 : libspdm_test_context_t *spdm_test_context;
5003 : libspdm_context_t *spdm_context;
5004 : uint32_t session_id;
5005 : libspdm_session_info_t *session_info;
5006 :
5007 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5008 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5009 :
5010 1 : spdm_test_context = *state;
5011 1 : spdm_context = spdm_test_context->spdm_context;
5012 1 : spdm_test_context->case_id = 0x1A;
5013 :
5014 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
5015 : SPDM_VERSION_NUMBER_SHIFT_BIT;
5016 1 : libspdm_set_standard_key_update_test_state(
5017 : spdm_context, &session_id);
5018 :
5019 1 : session_info = &spdm_context->session_info[0];
5020 :
5021 1 : libspdm_set_standard_key_update_test_secrets(
5022 1 : session_info->secured_message_context,
5023 : m_rsp_secret_buffer, (uint8_t)(0xFF),
5024 : m_req_secret_buffer, (uint8_t)(0xEE));
5025 :
5026 : /*request side updated*/
5027 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
5028 : ((libspdm_secured_message_context_t
5029 1 : *)(session_info->secured_message_context))->hash_size,
5030 : m_req_secret_buffer, m_req_secret_buffer,
5031 : sizeof(m_req_secret_buffer));
5032 : /*response side *not* updated*/
5033 :
5034 1 : status = libspdm_key_update(
5035 : spdm_context, session_id, true);
5036 :
5037 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
5038 1 : assert_memory_equal(((libspdm_secured_message_context_t
5039 : *)(session_info->secured_message_context))
5040 : ->application_secret.request_data_secret,
5041 : m_req_secret_buffer, ((libspdm_secured_message_context_t
5042 : *)(session_info->secured_message_context))->hash_size);
5043 1 : assert_memory_equal(((libspdm_secured_message_context_t
5044 : *)(session_info->secured_message_context))
5045 : ->application_secret.response_data_secret,
5046 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
5047 : *)(session_info->secured_message_context))->hash_size);
5048 1 : }
5049 :
5050 : /**
5051 : * Test 27: receiving a correct UPDATE_KEY_ACK message for updating
5052 : * both the request data key and the response data key.
5053 : * Expected behavior: client returns a Status of LIBSPDM_STATUS_SUCCESS, and
5054 : * the request data key and response data key are updated.
5055 : **/
5056 1 : static void req_key_update_case27(void **state)
5057 : {
5058 : libspdm_return_t status;
5059 : libspdm_test_context_t *spdm_test_context;
5060 : libspdm_context_t *spdm_context;
5061 : uint32_t session_id;
5062 : libspdm_session_info_t *session_info;
5063 :
5064 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5065 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5066 :
5067 1 : spdm_test_context = *state;
5068 1 : spdm_context = spdm_test_context->spdm_context;
5069 1 : spdm_test_context->case_id = 0x1B;
5070 :
5071 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
5072 : SPDM_VERSION_NUMBER_SHIFT_BIT;
5073 1 : libspdm_set_standard_key_update_test_state(
5074 : spdm_context, &session_id);
5075 :
5076 1 : session_info = &spdm_context->session_info[0];
5077 :
5078 1 : libspdm_set_standard_key_update_test_secrets(
5079 1 : session_info->secured_message_context,
5080 : m_rsp_secret_buffer, (uint8_t)(0xFF),
5081 : m_req_secret_buffer, (uint8_t)(0xEE));
5082 :
5083 : /*request side updated*/
5084 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
5085 : ((libspdm_secured_message_context_t
5086 1 : *)(session_info->secured_message_context))->hash_size,
5087 : m_req_secret_buffer, m_req_secret_buffer,
5088 : sizeof(m_req_secret_buffer));
5089 : /*response side updated*/
5090 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
5091 : ((libspdm_secured_message_context_t
5092 1 : *)(session_info->secured_message_context))->hash_size,
5093 : m_rsp_secret_buffer, m_rsp_secret_buffer,
5094 : sizeof(m_rsp_secret_buffer));
5095 :
5096 1 : status = libspdm_key_update(
5097 : spdm_context, session_id, false);
5098 :
5099 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
5100 1 : assert_memory_equal(((libspdm_secured_message_context_t
5101 : *)(session_info->secured_message_context))
5102 : ->application_secret.request_data_secret,
5103 : m_req_secret_buffer, ((libspdm_secured_message_context_t
5104 : *)(session_info->secured_message_context))->hash_size);
5105 1 : assert_memory_equal(((libspdm_secured_message_context_t
5106 : *)(session_info->secured_message_context))
5107 : ->application_secret.response_data_secret,
5108 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
5109 : *)(session_info->secured_message_context))->hash_size);
5110 1 : }
5111 :
5112 : /**
5113 : * Test 28: the requester is setup correctly (see Test 27), but receives an
5114 : * ERROR message indicating InvalidParameters when updating all keys.
5115 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR, and
5116 : * no keys should be updated.
5117 : **/
5118 1 : static void req_key_update_case28(void **state)
5119 : {
5120 : libspdm_return_t status;
5121 : libspdm_test_context_t *spdm_test_context;
5122 : libspdm_context_t *spdm_context;
5123 : uint32_t session_id;
5124 : libspdm_session_info_t *session_info;
5125 :
5126 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5127 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5128 :
5129 : libspdm_secured_message_context_t *secured_message_context;
5130 :
5131 1 : spdm_test_context = *state;
5132 1 : spdm_context = spdm_test_context->spdm_context;
5133 1 : spdm_test_context->case_id = 0x1C;
5134 :
5135 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
5136 : SPDM_VERSION_NUMBER_SHIFT_BIT;
5137 1 : libspdm_set_standard_key_update_test_state(
5138 : spdm_context, &session_id);
5139 :
5140 1 : session_info = &spdm_context->session_info[0];
5141 1 : secured_message_context = session_info->secured_message_context;
5142 :
5143 1 : libspdm_set_standard_key_update_test_secrets(
5144 1 : session_info->secured_message_context,
5145 : m_rsp_secret_buffer, (uint8_t)(0xFF),
5146 : m_req_secret_buffer, (uint8_t)(0xEE));
5147 :
5148 : /*store previous encryption state*/
5149 1 : libspdm_copy_mem(m_libspdm_last_rsp_enc_key, sizeof(m_libspdm_last_rsp_enc_key),
5150 : secured_message_context
5151 1 : ->application_secret.response_data_encryption_key,
5152 : secured_message_context->aead_key_size);
5153 1 : libspdm_copy_mem(m_libspdm_last_rsp_salt, sizeof(m_libspdm_last_rsp_salt),
5154 : secured_message_context
5155 1 : ->application_secret.response_data_salt,
5156 : secured_message_context->aead_iv_size);
5157 1 : m_libspdm_last_rsp_sequence_number = secured_message_context
5158 1 : ->application_secret.response_data_sequence_number;
5159 :
5160 : /*no keys are updated*/
5161 :
5162 1 : status = libspdm_key_update(
5163 : spdm_context, session_id, false);
5164 :
5165 1 : assert_int_equal(status, LIBSPDM_STATUS_ERROR_PEER);
5166 1 : assert_memory_equal(((libspdm_secured_message_context_t
5167 : *)(session_info->secured_message_context))
5168 : ->application_secret.request_data_secret,
5169 : m_req_secret_buffer, ((libspdm_secured_message_context_t
5170 : *)(session_info->secured_message_context))->hash_size);
5171 1 : assert_memory_equal(((libspdm_secured_message_context_t
5172 : *)(session_info->secured_message_context))
5173 : ->application_secret.response_data_secret,
5174 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
5175 : *)(session_info->secured_message_context))->hash_size);
5176 1 : }
5177 :
5178 : /**
5179 : * Test 29: the requester is setup correctly (see Test 27), but receives an
5180 : * ERROR message indicating the Busy status of the responder, when updating
5181 : * all keys.
5182 : * Expected behavior: client returns a Status of RETURN_NO_RESPONSE, and
5183 : * no keys should be updated.
5184 : **/
5185 1 : static void req_key_update_case29(void **state)
5186 : {
5187 : libspdm_return_t status;
5188 : libspdm_test_context_t *spdm_test_context;
5189 : libspdm_context_t *spdm_context;
5190 : uint32_t session_id;
5191 : libspdm_session_info_t *session_info;
5192 :
5193 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5194 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5195 :
5196 : libspdm_secured_message_context_t *secured_message_context;
5197 :
5198 1 : spdm_test_context = *state;
5199 1 : spdm_context = spdm_test_context->spdm_context;
5200 1 : spdm_test_context->case_id = 0x1D;
5201 :
5202 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
5203 : SPDM_VERSION_NUMBER_SHIFT_BIT;
5204 1 : libspdm_set_standard_key_update_test_state(
5205 : spdm_context, &session_id);
5206 :
5207 1 : session_info = &spdm_context->session_info[0];
5208 1 : secured_message_context = session_info->secured_message_context;
5209 :
5210 1 : libspdm_set_standard_key_update_test_secrets(
5211 1 : session_info->secured_message_context,
5212 : m_rsp_secret_buffer, (uint8_t)(0xFF),
5213 : m_req_secret_buffer, (uint8_t)(0xEE));
5214 :
5215 : /*store previous encryption state*/
5216 1 : libspdm_copy_mem(m_libspdm_last_rsp_enc_key, sizeof(m_libspdm_last_rsp_enc_key),
5217 : secured_message_context
5218 1 : ->application_secret.response_data_encryption_key,
5219 : secured_message_context->aead_key_size);
5220 1 : libspdm_copy_mem(m_libspdm_last_rsp_salt, sizeof(m_libspdm_last_rsp_salt),
5221 : secured_message_context
5222 1 : ->application_secret.response_data_salt,
5223 : secured_message_context->aead_iv_size);
5224 1 : m_libspdm_last_rsp_sequence_number = secured_message_context
5225 1 : ->application_secret.response_data_sequence_number;
5226 :
5227 : /*no keys are updated*/
5228 :
5229 1 : status = libspdm_key_update(
5230 : spdm_context, session_id, false);
5231 :
5232 1 : assert_int_equal(status, LIBSPDM_STATUS_BUSY_PEER);
5233 1 : assert_memory_equal(((libspdm_secured_message_context_t
5234 : *)(session_info->secured_message_context))
5235 : ->application_secret.request_data_secret,
5236 : m_req_secret_buffer, ((libspdm_secured_message_context_t
5237 : *)(session_info->secured_message_context))->hash_size);
5238 1 : assert_memory_equal(((libspdm_secured_message_context_t
5239 : *)(session_info->secured_message_context))
5240 : ->application_secret.response_data_secret,
5241 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
5242 : *)(session_info->secured_message_context))->hash_size);
5243 1 : }
5244 :
5245 : /**
5246 : * Test 30: the requester is setup correctly (see Test 27), but, when updating
5247 : * all keys, on the first try, receiving a Busy ERROR message, and on retry,
5248 : * receiving a correct KEY_UPDATE_ACK message. The VERIFY_KEY behavior is
5249 : * not altered.
5250 : * Expected behavior: client returns a Status of LIBSPDM_STATUS_SUCCESS, and
5251 : * the request data key and response data key are updated.
5252 : **/
5253 1 : static void req_key_update_case30(void **state)
5254 : {
5255 : libspdm_return_t status;
5256 : libspdm_test_context_t *spdm_test_context;
5257 : libspdm_context_t *spdm_context;
5258 : uint32_t session_id;
5259 : libspdm_session_info_t *session_info;
5260 :
5261 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5262 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5263 :
5264 : libspdm_secured_message_context_t *secured_message_context;
5265 :
5266 1 : spdm_test_context = *state;
5267 1 : spdm_context = spdm_test_context->spdm_context;
5268 1 : spdm_test_context->case_id = 0x1E;
5269 :
5270 1 : spdm_context->retry_times = 3;
5271 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
5272 : SPDM_VERSION_NUMBER_SHIFT_BIT;
5273 1 : libspdm_set_standard_key_update_test_state(
5274 : spdm_context, &session_id);
5275 :
5276 1 : session_info = &spdm_context->session_info[0];
5277 1 : secured_message_context = session_info->secured_message_context;
5278 :
5279 1 : libspdm_set_standard_key_update_test_secrets(
5280 1 : session_info->secured_message_context,
5281 : m_rsp_secret_buffer, (uint8_t)(0xFF),
5282 : m_req_secret_buffer, (uint8_t)(0xEE));
5283 :
5284 : /*store previous encryption state*/
5285 1 : libspdm_copy_mem(m_libspdm_last_rsp_enc_key, sizeof(m_libspdm_last_rsp_enc_key),
5286 : secured_message_context
5287 1 : ->application_secret.response_data_encryption_key,
5288 : secured_message_context->aead_key_size);
5289 1 : libspdm_copy_mem(m_libspdm_last_rsp_salt, sizeof(m_libspdm_last_rsp_salt),
5290 : secured_message_context
5291 1 : ->application_secret.response_data_salt,
5292 : secured_message_context->aead_iv_size);
5293 1 : m_libspdm_last_rsp_sequence_number = secured_message_context
5294 1 : ->application_secret.response_data_sequence_number;
5295 :
5296 : /*request side updated*/
5297 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
5298 : ((libspdm_secured_message_context_t
5299 1 : *)(session_info->secured_message_context))->hash_size,
5300 : m_req_secret_buffer, m_req_secret_buffer,
5301 : sizeof(m_req_secret_buffer));
5302 : /*response side updated*/
5303 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
5304 : ((libspdm_secured_message_context_t
5305 1 : *)(session_info->secured_message_context))->hash_size,
5306 : m_rsp_secret_buffer, m_rsp_secret_buffer,
5307 : sizeof(m_rsp_secret_buffer));
5308 :
5309 1 : status = libspdm_key_update(
5310 : spdm_context, session_id, false);
5311 :
5312 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
5313 1 : assert_memory_equal(((libspdm_secured_message_context_t
5314 : *)(session_info->secured_message_context))
5315 : ->application_secret.request_data_secret,
5316 : m_req_secret_buffer, ((libspdm_secured_message_context_t
5317 : *)(session_info->secured_message_context))->hash_size);
5318 1 : assert_memory_equal(((libspdm_secured_message_context_t
5319 : *)(session_info->secured_message_context))
5320 : ->application_secret.response_data_secret,
5321 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
5322 : *)(session_info->secured_message_context))->hash_size);
5323 1 : }
5324 :
5325 : /**
5326 : * Test 31: the requester is setup correctly (see Test 27), but receives an
5327 : * ERROR message indicating the RequestResynch status of the responder, when
5328 : * updating all keys.
5329 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR, and the
5330 : * communication is reset to expect a new GET_VERSION message.
5331 : **/
5332 1 : static void req_key_update_case31(void **state)
5333 : {
5334 : libspdm_return_t status;
5335 : libspdm_test_context_t *spdm_test_context;
5336 : libspdm_context_t *spdm_context;
5337 : uint32_t session_id;
5338 : libspdm_session_info_t *session_info;
5339 :
5340 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5341 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5342 :
5343 : libspdm_secured_message_context_t *secured_message_context;
5344 :
5345 1 : spdm_test_context = *state;
5346 1 : spdm_context = spdm_test_context->spdm_context;
5347 1 : spdm_test_context->case_id = 0x1F;
5348 :
5349 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
5350 : SPDM_VERSION_NUMBER_SHIFT_BIT;
5351 1 : libspdm_set_standard_key_update_test_state(
5352 : spdm_context, &session_id);
5353 :
5354 1 : session_info = &spdm_context->session_info[0];
5355 1 : secured_message_context = session_info->secured_message_context;
5356 :
5357 1 : libspdm_set_standard_key_update_test_secrets(
5358 1 : session_info->secured_message_context,
5359 : m_rsp_secret_buffer, (uint8_t)(0xFF),
5360 : m_req_secret_buffer, (uint8_t)(0xEE));
5361 :
5362 : /*store previous encryption state*/
5363 1 : libspdm_copy_mem(m_libspdm_last_rsp_enc_key, sizeof(m_libspdm_last_rsp_enc_key),
5364 : secured_message_context
5365 1 : ->application_secret.response_data_encryption_key,
5366 : secured_message_context->aead_key_size);
5367 1 : libspdm_copy_mem(m_libspdm_last_rsp_salt, sizeof(m_libspdm_last_rsp_salt),
5368 : secured_message_context
5369 1 : ->application_secret.response_data_salt,
5370 : secured_message_context->aead_iv_size);
5371 1 : m_libspdm_last_rsp_sequence_number = secured_message_context
5372 1 : ->application_secret.response_data_sequence_number;
5373 :
5374 1 : status = libspdm_key_update(
5375 : spdm_context, session_id, false);
5376 :
5377 1 : assert_int_equal(status, LIBSPDM_STATUS_RESYNCH_PEER);
5378 1 : assert_int_equal(spdm_context->connection_info.connection_state,
5379 : LIBSPDM_CONNECTION_STATE_NOT_STARTED);
5380 1 : }
5381 :
5382 : /**
5383 : * Test 32: the requester is setup correctly (see Test 27), but receives an
5384 : * ERROR message indicating the ResponseNotReady status of the responder, when
5385 : * updating all keys.
5386 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR, and
5387 : * no keys should be updated.
5388 : **/
5389 1 : static void req_key_update_case32(void **state)
5390 : {
5391 : libspdm_return_t status;
5392 : libspdm_test_context_t *spdm_test_context;
5393 : libspdm_context_t *spdm_context;
5394 : uint32_t session_id;
5395 : libspdm_session_info_t *session_info;
5396 :
5397 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5398 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5399 :
5400 : libspdm_secured_message_context_t *secured_message_context;
5401 :
5402 1 : spdm_test_context = *state;
5403 1 : spdm_context = spdm_test_context->spdm_context;
5404 1 : spdm_test_context->case_id = 0x20;
5405 :
5406 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
5407 : SPDM_VERSION_NUMBER_SHIFT_BIT;
5408 1 : libspdm_set_standard_key_update_test_state(
5409 : spdm_context, &session_id);
5410 :
5411 1 : session_info = &spdm_context->session_info[0];
5412 1 : secured_message_context = session_info->secured_message_context;
5413 :
5414 1 : libspdm_set_standard_key_update_test_secrets(
5415 1 : session_info->secured_message_context,
5416 : m_rsp_secret_buffer, (uint8_t)(0xFF),
5417 : m_req_secret_buffer, (uint8_t)(0xEE));
5418 :
5419 : /*store previous encryption state*/
5420 1 : libspdm_copy_mem(m_libspdm_last_rsp_enc_key, sizeof(m_libspdm_last_rsp_enc_key),
5421 : secured_message_context
5422 1 : ->application_secret.response_data_encryption_key,
5423 : secured_message_context->aead_key_size);
5424 1 : libspdm_copy_mem(m_libspdm_last_rsp_salt, sizeof(m_libspdm_last_rsp_salt),
5425 : secured_message_context
5426 1 : ->application_secret.response_data_salt,
5427 : secured_message_context->aead_iv_size);
5428 1 : m_libspdm_last_rsp_sequence_number = secured_message_context
5429 1 : ->application_secret.response_data_sequence_number;
5430 :
5431 : /*no keys are updated*/
5432 :
5433 1 : status = libspdm_key_update(
5434 : spdm_context, session_id, false);
5435 :
5436 1 : assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
5437 1 : assert_memory_equal(((libspdm_secured_message_context_t
5438 : *)(session_info->secured_message_context))
5439 : ->application_secret.request_data_secret,
5440 : m_req_secret_buffer, ((libspdm_secured_message_context_t
5441 : *)(session_info->secured_message_context))->hash_size);
5442 1 : assert_memory_equal(((libspdm_secured_message_context_t
5443 : *)(session_info->secured_message_context))
5444 : ->application_secret.response_data_secret,
5445 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
5446 : *)(session_info->secured_message_context))->hash_size);
5447 1 : }
5448 :
5449 : /**
5450 : * Test 33: the requester is setup correctly (see Test 27), but, when updating
5451 : * all keys, on the first try, receiving a ResponseNotReady ERROR message, and
5452 : * on retry, receiving a correct KEY_UPDATE_ACK message. The VERIFY_KEY
5453 : * behavior is not altered.
5454 : * Expected behavior: client returns a Status of LIBSPDM_STATUS_SUCCESS, and
5455 : * the request data key and response data key are updated.
5456 : **/
5457 1 : static void req_key_update_case33(void **state)
5458 : {
5459 : libspdm_return_t status;
5460 : libspdm_test_context_t *spdm_test_context;
5461 : libspdm_context_t *spdm_context;
5462 : uint32_t session_id;
5463 : libspdm_session_info_t *session_info;
5464 :
5465 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5466 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5467 :
5468 : libspdm_secured_message_context_t *secured_message_context;
5469 :
5470 1 : spdm_test_context = *state;
5471 1 : spdm_context = spdm_test_context->spdm_context;
5472 1 : spdm_test_context->case_id = 0x21;
5473 :
5474 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
5475 : SPDM_VERSION_NUMBER_SHIFT_BIT;
5476 1 : libspdm_set_standard_key_update_test_state(spdm_context, &session_id);
5477 :
5478 1 : session_info = &spdm_context->session_info[0];
5479 1 : secured_message_context = session_info->secured_message_context;
5480 :
5481 1 : libspdm_set_standard_key_update_test_secrets(
5482 1 : session_info->secured_message_context,
5483 : m_rsp_secret_buffer, (uint8_t)(0xFF),
5484 : m_req_secret_buffer, (uint8_t)(0xEE));
5485 :
5486 : /*store previous encryption state*/
5487 1 : libspdm_copy_mem(m_libspdm_last_rsp_enc_key, sizeof(m_libspdm_last_rsp_enc_key),
5488 : secured_message_context
5489 1 : ->application_secret.response_data_encryption_key,
5490 : secured_message_context->aead_key_size);
5491 1 : libspdm_copy_mem(m_libspdm_last_rsp_salt, sizeof(m_libspdm_last_rsp_salt),
5492 : secured_message_context
5493 1 : ->application_secret.response_data_salt,
5494 : secured_message_context->aead_iv_size);
5495 1 : m_libspdm_last_rsp_sequence_number = secured_message_context
5496 1 : ->application_secret.response_data_sequence_number;
5497 :
5498 : /*request side updated*/
5499 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
5500 : ((libspdm_secured_message_context_t
5501 1 : *)(session_info->secured_message_context))->hash_size,
5502 : m_req_secret_buffer, m_req_secret_buffer,
5503 : sizeof(m_req_secret_buffer));
5504 : /*response side updated*/
5505 1 : libspdm_compute_secret_update(spdm_context->connection_info.version,
5506 : ((libspdm_secured_message_context_t
5507 1 : *)(session_info->secured_message_context))->hash_size,
5508 : m_rsp_secret_buffer, m_rsp_secret_buffer,
5509 : sizeof(m_rsp_secret_buffer));
5510 :
5511 1 : status = libspdm_key_update(spdm_context, session_id, false);
5512 :
5513 : if (LIBSPDM_RESPOND_IF_READY_SUPPORT) {
5514 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
5515 1 : assert_memory_equal(((libspdm_secured_message_context_t
5516 : *)(session_info->secured_message_context))
5517 : ->application_secret.request_data_secret,
5518 : m_req_secret_buffer, ((libspdm_secured_message_context_t
5519 : *)(session_info->secured_message_context))->hash_size);
5520 1 : assert_memory_equal(((libspdm_secured_message_context_t
5521 : *)(session_info->secured_message_context))
5522 : ->application_secret.response_data_secret,
5523 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
5524 : *)(session_info->secured_message_context))->hash_size);
5525 : } else {
5526 : assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
5527 : }
5528 1 : }
5529 :
5530 : /**
5531 : * Test 34: receiving an unexpected ERROR message from the responder,
5532 : * when updating all keys.
5533 : * There are tests for all named codes, including some reserved ones
5534 : * (namely, 0x00, 0x0b, 0x0c, 0x3f, 0xfd, 0xfe).
5535 : * However, for having specific test cases, it is excluded from this case:
5536 : * Busy (0x03), ResponseNotReady (0x42), and RequestResync (0x43).
5537 : * Expected behavior: client returns a status of RETURN_DEVICE_ERROR, and
5538 : * no keys should be updated.
5539 : **/
5540 1 : static void req_key_update_case34(void **state)
5541 : {
5542 : libspdm_return_t status;
5543 : libspdm_test_context_t *spdm_test_context;
5544 : libspdm_context_t *spdm_context;
5545 : uint32_t session_id;
5546 : libspdm_session_info_t *session_info;
5547 : uint16_t error_code;
5548 :
5549 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5550 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5551 :
5552 : libspdm_secured_message_context_t *secured_message_context;
5553 :
5554 1 : spdm_test_context = *state;
5555 1 : spdm_context = spdm_test_context->spdm_context;
5556 1 : spdm_test_context->case_id = 0x22;
5557 :
5558 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
5559 : SPDM_VERSION_NUMBER_SHIFT_BIT;
5560 1 : libspdm_set_standard_key_update_test_state(
5561 : spdm_context, &session_id);
5562 :
5563 1 : session_info = &spdm_context->session_info[0];
5564 1 : secured_message_context = session_info->secured_message_context;
5565 :
5566 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
5567 18 : while(error_code <= 0xff) {
5568 : /* skip SPDM_ERROR_CODE_DECRYPT_ERROR, because this case will free context*/
5569 17 : if(error_code == SPDM_ERROR_CODE_DECRYPT_ERROR) {
5570 1 : error_code++;
5571 : }
5572 17 : libspdm_set_standard_key_update_test_secrets(
5573 17 : session_info->secured_message_context,
5574 : m_rsp_secret_buffer, (uint8_t)(0xFF),
5575 : m_req_secret_buffer, (uint8_t)(0xEE));
5576 :
5577 : /*store previous encryption state*/
5578 17 : libspdm_copy_mem(m_libspdm_last_rsp_enc_key, sizeof(m_libspdm_last_rsp_enc_key),
5579 : secured_message_context
5580 17 : ->application_secret.response_data_encryption_key,
5581 : secured_message_context->aead_key_size);
5582 17 : libspdm_copy_mem(m_libspdm_last_rsp_salt, sizeof(m_libspdm_last_rsp_salt),
5583 : secured_message_context
5584 17 : ->application_secret.response_data_salt,
5585 : secured_message_context->aead_iv_size);
5586 17 : m_libspdm_last_rsp_sequence_number = secured_message_context
5587 17 : ->application_secret.response_data_sequence_number;
5588 :
5589 : /*no keys are updated*/
5590 :
5591 17 : status = libspdm_key_update(
5592 : spdm_context, session_id, false);
5593 :
5594 17 : LIBSPDM_ASSERT_INT_EQUAL_CASE (status, LIBSPDM_STATUS_ERROR_PEER, error_code);
5595 17 : assert_memory_equal(((libspdm_secured_message_context_t
5596 : *)(session_info->secured_message_context))
5597 : ->application_secret.request_data_secret,
5598 : m_req_secret_buffer, ((libspdm_secured_message_context_t
5599 : *)(session_info->secured_message_context))->hash_size);
5600 17 : assert_memory_equal(((libspdm_secured_message_context_t
5601 : *)(session_info->secured_message_context))
5602 : ->application_secret.response_data_secret,
5603 : m_rsp_secret_buffer, ((libspdm_secured_message_context_t
5604 : *)(session_info->secured_message_context))->hash_size);
5605 :
5606 17 : error_code++;
5607 : /*busy is treated in cases 5 and 6*/
5608 17 : if(error_code == SPDM_ERROR_CODE_BUSY) {
5609 1 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
5610 : }
5611 : /*skip some reserved error codes (0d to 3e)*/
5612 17 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) {
5613 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
5614 : }
5615 : /*skip response not ready, request resync, and some reserved codes (44 to fc)*/
5616 17 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) {
5617 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
5618 : }
5619 : }
5620 1 : }
5621 :
5622 : /**
5623 : * Test 35: the requester is setup correctly, but receives an ERROR with SPDM_ERROR_CODE_DECRYPT_ERROR.
5624 : * Expected behavior: client returns a Status of INVALID_SESSION_ID and free the session ID.
5625 : **/
5626 1 : static void req_key_update_case35(void **state)
5627 : {
5628 : libspdm_return_t status;
5629 : libspdm_test_context_t *spdm_test_context;
5630 : libspdm_context_t *spdm_context;
5631 : uint32_t session_id;
5632 : libspdm_session_info_t *session_info;
5633 :
5634 : uint8_t m_req_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5635 : uint8_t m_rsp_secret_buffer[LIBSPDM_MAX_HASH_SIZE];
5636 :
5637 1 : spdm_test_context = *state;
5638 1 : spdm_context = spdm_test_context->spdm_context;
5639 1 : spdm_test_context->case_id = 0x23;
5640 :
5641 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
5642 : SPDM_VERSION_NUMBER_SHIFT_BIT;
5643 1 : libspdm_set_standard_key_update_test_state(spdm_context, &session_id);
5644 :
5645 1 : session_info = &spdm_context->session_info[0];
5646 :
5647 1 : libspdm_set_standard_key_update_test_secrets(
5648 1 : session_info->secured_message_context,
5649 : m_rsp_secret_buffer, (uint8_t)(0xFF),
5650 : m_req_secret_buffer, (uint8_t)(0xEE));
5651 :
5652 : /*no keys are updated*/
5653 :
5654 1 : status = libspdm_key_update(spdm_context, session_id, true);
5655 :
5656 1 : assert_int_equal(status, LIBSPDM_STATUS_SESSION_MSG_ERROR);
5657 1 : assert_int_equal(spdm_context->session_info->session_id, INVALID_SESSION_ID);
5658 1 : }
5659 :
5660 1 : int libspdm_req_key_update_test(void)
5661 : {
5662 1 : const struct CMUnitTest test_cases[] = {
5663 : /* SendRequest failed*/
5664 : cmocka_unit_test(req_key_update_case1),
5665 : /* update single key
5666 : * Successful response*/
5667 : cmocka_unit_test(req_key_update_case2),
5668 : /* connection_state check failed*/
5669 : cmocka_unit_test(req_key_update_case3),
5670 : /* Error response: SPDM_ERROR_CODE_INVALID_REQUEST*/
5671 : cmocka_unit_test(req_key_update_case4),
5672 : /* Always SPDM_ERROR_CODE_BUSY*/
5673 : cmocka_unit_test(req_key_update_case5),
5674 : /* SPDM_ERROR_CODE_BUSY + Successful response*/
5675 : cmocka_unit_test(req_key_update_case6),
5676 : /* Error response: SPDM_ERROR_CODE_REQUEST_RESYNCH*/
5677 : cmocka_unit_test(req_key_update_case7),
5678 : /* Always SPDM_ERROR_CODE_RESPONSE_NOT_READY*/
5679 : cmocka_unit_test(req_key_update_case8),
5680 : /* SPDM_ERROR_CODE_RESPONSE_NOT_READY + Successful response*/
5681 : cmocka_unit_test(req_key_update_case9),
5682 : /* Unexpected errors*/
5683 : cmocka_unit_test(req_key_update_case10),
5684 : /* Buffer reset*/
5685 : cmocka_unit_test(req_key_update_case11),
5686 : /* No correct setup*/
5687 : cmocka_unit_test(req_key_update_case12),
5688 : cmocka_unit_test(req_key_update_case13),
5689 : cmocka_unit_test(req_key_update_case14),
5690 : /* Wrong parameters*/
5691 : cmocka_unit_test(req_key_update_case15),
5692 : cmocka_unit_test(req_key_update_case16),
5693 : /* verify key
5694 : * Error response: SPDM_ERROR_CODE_INVALID_REQUEST*/
5695 : cmocka_unit_test(req_key_update_case17),
5696 : /* Always SPDM_ERROR_CODE_BUSY*/
5697 : cmocka_unit_test(req_key_update_case18),
5698 : /* SPDM_ERROR_CODE_BUSY + Successful response*/
5699 : cmocka_unit_test(req_key_update_case19),
5700 : /* Error response: SPDM_ERROR_CODE_REQUEST_RESYNCH*/
5701 : cmocka_unit_test(req_key_update_case20),
5702 : /* Always SPDM_ERROR_CODE_RESPONSE_NOT_READY*/
5703 : cmocka_unit_test(req_key_update_case21),
5704 : /* SPDM_ERROR_CODE_RESPONSE_NOT_READY + Successful response*/
5705 : cmocka_unit_test(req_key_update_case22),
5706 : /* Unexpected errors*/
5707 : cmocka_unit_test(req_key_update_case23),
5708 : /* No correct setup*/
5709 : cmocka_unit_test(req_key_update_case24),
5710 : /* Wrong parameters*/
5711 : cmocka_unit_test(req_key_update_case25),
5712 : cmocka_unit_test(req_key_update_case26),
5713 : /* update all keys
5714 : * Successful response*/
5715 : cmocka_unit_test(req_key_update_case27),
5716 : /* Error response: SPDM_ERROR_CODE_INVALID_REQUEST*/
5717 : cmocka_unit_test(req_key_update_case28),
5718 : /* Always SPDM_ERROR_CODE_BUSY*/
5719 : cmocka_unit_test(req_key_update_case29),
5720 : /* SPDM_ERROR_CODE_BUSY + Successful response*/
5721 : cmocka_unit_test(req_key_update_case30),
5722 : /* Error response: SPDM_ERROR_CODE_REQUEST_RESYNCH*/
5723 : cmocka_unit_test(req_key_update_case31),
5724 : /* Always SPDM_ERROR_CODE_RESPONSE_NOT_READY*/
5725 : cmocka_unit_test(req_key_update_case32),
5726 : /* SPDM_ERROR_CODE_RESPONSE_NOT_READY + Successful response*/
5727 : cmocka_unit_test(req_key_update_case33),
5728 : /* Unexpected errors*/
5729 : cmocka_unit_test(req_key_update_case34),
5730 : /* Error response: SPDM_ERROR_CODE_DECRYPT_ERROR*/
5731 : cmocka_unit_test(req_key_update_case35),
5732 : };
5733 :
5734 1 : libspdm_test_context_t test_context = {
5735 : LIBSPDM_TEST_CONTEXT_VERSION,
5736 : true,
5737 : send_message,
5738 : receive_message,
5739 : };
5740 :
5741 1 : libspdm_setup_test_context(&test_context);
5742 :
5743 1 : return cmocka_run_group_tests(test_cases,
5744 : libspdm_unit_test_group_setup,
5745 : libspdm_unit_test_group_teardown);
5746 : }
5747 :
5748 : #endif /* (LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP) || (LIBSPDM_ENABLE_CAPABILITY_PSK_CAP) */
|
