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