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