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