Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2026 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : #include "spdm_unit_test.h"
8 : #include "internal/libspdm_requester_lib.h"
9 : #include "internal/libspdm_secured_message_lib.h"
10 :
11 : #if (LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP) || (LIBSPDM_ENABLE_CAPABILITY_PSK_CAP)
12 :
13 : static uint8_t m_dummy_key_buffer[LIBSPDM_MAX_AEAD_KEY_SIZE];
14 : static uint8_t m_dummy_salt_buffer[LIBSPDM_MAX_AEAD_IV_SIZE];
15 :
16 28 : static void libspdm_secured_message_set_response_data_encryption_key(
17 : void *spdm_secured_message_context, const void *key, size_t key_size)
18 : {
19 : libspdm_secured_message_context_t *secured_message_context;
20 :
21 28 : secured_message_context = spdm_secured_message_context;
22 28 : LIBSPDM_ASSERT(key_size == secured_message_context->aead_key_size);
23 28 : libspdm_copy_mem(secured_message_context->application_secret.response_data_encryption_key,
24 : sizeof(secured_message_context->application_secret.response_data_encryption_key),
25 : key, secured_message_context->aead_key_size);
26 28 : }
27 :
28 28 : static void libspdm_secured_message_set_response_data_salt(
29 : void *spdm_secured_message_context, const void *salt,
30 : size_t salt_size)
31 : {
32 : libspdm_secured_message_context_t *secured_message_context;
33 :
34 28 : secured_message_context = spdm_secured_message_context;
35 28 : LIBSPDM_ASSERT(salt_size == secured_message_context->aead_iv_size);
36 28 : libspdm_copy_mem(secured_message_context->application_secret.response_data_salt,
37 : sizeof(secured_message_context->application_secret.response_data_salt),
38 : salt, secured_message_context->aead_iv_size);
39 28 : }
40 :
41 31 : static libspdm_return_t send_message(
42 : void *spdm_context, size_t request_size, const void *request, uint64_t timeout)
43 : {
44 : libspdm_test_context_t *spdm_test_context;
45 :
46 31 : spdm_test_context = libspdm_get_test_context();
47 31 : switch (spdm_test_context->case_id) {
48 1 : case 0x1:
49 1 : return LIBSPDM_STATUS_SEND_FAIL;
50 1 : case 0x2:
51 1 : return LIBSPDM_STATUS_SUCCESS;
52 0 : case 0x3:
53 0 : return LIBSPDM_STATUS_SUCCESS;
54 1 : case 0x4:
55 1 : return LIBSPDM_STATUS_SUCCESS;
56 1 : case 0x5:
57 1 : return LIBSPDM_STATUS_SUCCESS;
58 2 : case 0x6:
59 2 : return LIBSPDM_STATUS_SUCCESS;
60 1 : case 0x7:
61 1 : return LIBSPDM_STATUS_SUCCESS;
62 2 : case 0x8:
63 2 : return LIBSPDM_STATUS_SUCCESS;
64 2 : case 0x9:
65 2 : return LIBSPDM_STATUS_SUCCESS;
66 18 : case 0xA:
67 18 : return LIBSPDM_STATUS_SUCCESS;
68 1 : case 0xB:
69 1 : return LIBSPDM_STATUS_SUCCESS;
70 1 : case 0xC:
71 1 : return LIBSPDM_STATUS_SUCCESS;
72 0 : default:
73 0 : return LIBSPDM_STATUS_SEND_FAIL;
74 : }
75 : }
76 :
77 30 : static libspdm_return_t receive_message(
78 : void *spdm_context, size_t *response_size, void **response, uint64_t timeout)
79 : {
80 : libspdm_test_context_t *spdm_test_context;
81 :
82 30 : spdm_test_context = libspdm_get_test_context();
83 30 : switch (spdm_test_context->case_id) {
84 0 : case 0x1:
85 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
86 :
87 1 : case 0x2: {
88 : spdm_end_session_response_t *spdm_response;
89 : size_t spdm_response_size;
90 : size_t transport_header_size;
91 : uint32_t session_id;
92 : libspdm_session_info_t *session_info;
93 : uint8_t *scratch_buffer;
94 : size_t scratch_buffer_size;
95 :
96 1 : session_id = 0xFFFFFFFF;
97 1 : spdm_response_size = sizeof(spdm_end_session_response_t);
98 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
99 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
100 :
101 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
102 1 : spdm_response->header.request_response_code = SPDM_END_SESSION_ACK;
103 1 : spdm_response->header.param1 = 0;
104 1 : spdm_response->header.param2 = 0;
105 :
106 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
107 : * transport_message is always in sender buffer. */
108 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
109 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
110 : scratch_buffer_size - transport_header_size,
111 : spdm_response, spdm_response_size);
112 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
113 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
114 : false, false, spdm_response_size,
115 : spdm_response, response_size,
116 : response);
117 1 : session_info = libspdm_get_session_info_via_session_id( spdm_context, session_id);
118 1 : if (session_info == NULL) {
119 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
120 : }
121 : /* WALKAROUND: If just use single context to encode message and then decode message */
122 : ((libspdm_secured_message_context_t
123 1 : *)(session_info->secured_message_context))
124 1 : ->application_secret.response_data_sequence_number--;
125 : }
126 1 : return LIBSPDM_STATUS_SUCCESS;
127 :
128 0 : case 0x3: {
129 : spdm_end_session_response_t *spdm_response;
130 : size_t spdm_response_size;
131 : size_t transport_header_size;
132 : uint32_t session_id;
133 : libspdm_session_info_t *session_info;
134 : uint8_t *scratch_buffer;
135 : size_t scratch_buffer_size;
136 :
137 0 : session_id = 0xFFFFFFFF;
138 0 : spdm_response_size = sizeof(spdm_end_session_response_t);
139 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
140 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
141 :
142 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
143 0 : spdm_response->header.request_response_code = SPDM_END_SESSION_ACK;
144 0 : spdm_response->header.param1 = 0;
145 0 : spdm_response->header.param2 = 0;
146 :
147 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
148 : * transport_message is always in sender buffer. */
149 0 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
150 0 : libspdm_copy_mem (scratch_buffer + transport_header_size,
151 : scratch_buffer_size - transport_header_size,
152 : spdm_response, spdm_response_size);
153 0 : spdm_response = (void *)(scratch_buffer + transport_header_size);
154 0 : libspdm_transport_test_encode_message(spdm_context, &session_id,
155 : false, false, spdm_response_size,
156 : spdm_response, response_size,
157 : response);
158 0 : session_info = libspdm_get_session_info_via_session_id( spdm_context, session_id);
159 0 : if (session_info == NULL) {
160 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
161 : }
162 : ((libspdm_secured_message_context_t
163 0 : *)(session_info->secured_message_context))
164 0 : ->application_secret.response_data_sequence_number--;
165 : }
166 0 : return LIBSPDM_STATUS_SUCCESS;
167 :
168 1 : case 0x4: {
169 : spdm_error_response_t *spdm_response;
170 : size_t spdm_response_size;
171 : size_t transport_header_size;
172 : uint32_t session_id;
173 : libspdm_session_info_t *session_info;
174 : uint8_t *scratch_buffer;
175 : size_t scratch_buffer_size;
176 :
177 1 : spdm_response_size = sizeof(spdm_error_response_t);
178 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
179 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
180 :
181 1 : session_id = 0xFFFFFFFF;
182 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
183 1 : spdm_response->header.request_response_code = SPDM_ERROR;
184 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_INVALID_REQUEST;
185 1 : spdm_response->header.param2 = 0;
186 :
187 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
188 : * transport_message is always in sender buffer. */
189 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
190 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
191 : scratch_buffer_size - transport_header_size,
192 : spdm_response, spdm_response_size);
193 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
194 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
195 : false, false,
196 : spdm_response_size,
197 : spdm_response,
198 : response_size, response);
199 1 : session_info = libspdm_get_session_info_via_session_id( spdm_context, session_id);
200 1 : if (session_info == NULL) {
201 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
202 : }
203 : ((libspdm_secured_message_context_t
204 1 : *)(session_info->secured_message_context))
205 1 : ->application_secret.response_data_sequence_number--;
206 : }
207 1 : return LIBSPDM_STATUS_SUCCESS;
208 :
209 1 : case 0x5: {
210 : spdm_error_response_t *spdm_response;
211 : size_t spdm_response_size;
212 : size_t transport_header_size;
213 : uint32_t session_id;
214 : libspdm_session_info_t *session_info;
215 : uint8_t *scratch_buffer;
216 : size_t scratch_buffer_size;
217 :
218 1 : spdm_response_size = sizeof(spdm_error_response_t);
219 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
220 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
221 :
222 1 : session_id = 0xFFFFFFFF;
223 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
224 1 : spdm_response->header.request_response_code = SPDM_ERROR;
225 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
226 1 : spdm_response->header.param2 = 0;
227 :
228 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
229 : * transport_message is always in sender buffer. */
230 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
231 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
232 : scratch_buffer_size - transport_header_size,
233 : spdm_response, spdm_response_size);
234 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
235 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
236 : false, false,
237 : spdm_response_size,
238 : spdm_response,
239 : response_size, response);
240 1 : session_info = libspdm_get_session_info_via_session_id( spdm_context, session_id);
241 1 : if (session_info == NULL) {
242 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
243 : }
244 : ((libspdm_secured_message_context_t
245 1 : *)(session_info->secured_message_context))
246 1 : ->application_secret.response_data_sequence_number--;
247 : }
248 1 : return LIBSPDM_STATUS_SUCCESS;
249 :
250 2 : case 0x6: {
251 : static size_t sub_index1 = 0;
252 2 : if (sub_index1 == 0) {
253 : spdm_error_response_t *spdm_response;
254 : size_t spdm_response_size;
255 : size_t transport_header_size;
256 : uint32_t session_id;
257 : libspdm_session_info_t *session_info;
258 : uint8_t *scratch_buffer;
259 : size_t scratch_buffer_size;
260 :
261 1 : spdm_response_size = sizeof(spdm_error_response_t);
262 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
263 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
264 :
265 1 : session_id = 0xFFFFFFFF;
266 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
267 1 : spdm_response->header.request_response_code = SPDM_ERROR;
268 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
269 1 : spdm_response->header.param2 = 0;
270 :
271 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
272 : * transport_message is always in sender buffer. */
273 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
274 : &scratch_buffer_size);
275 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
276 : scratch_buffer_size - transport_header_size,
277 : spdm_response, spdm_response_size);
278 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
279 1 : libspdm_transport_test_encode_message(
280 : spdm_context, &session_id, false, false,
281 : spdm_response_size, spdm_response,
282 : response_size, response);
283 1 : sub_index1++;
284 1 : session_info = libspdm_get_session_info_via_session_id( spdm_context, session_id);
285 1 : if (session_info == NULL) {
286 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
287 : }
288 : ((libspdm_secured_message_context_t
289 1 : *)(session_info->secured_message_context))
290 : ->application_secret
291 1 : .response_data_sequence_number--;
292 1 : } else if (sub_index1 == 1) {
293 : spdm_end_session_response_t *spdm_response;
294 : size_t spdm_response_size;
295 : size_t transport_header_size;
296 : uint32_t session_id;
297 : libspdm_session_info_t *session_info;
298 : uint8_t *scratch_buffer;
299 : size_t scratch_buffer_size;
300 :
301 1 : session_id = 0xFFFFFFFF;
302 1 : spdm_response_size = sizeof(spdm_end_session_response_t);
303 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
304 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
305 :
306 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
307 1 : spdm_response->header.request_response_code = SPDM_END_SESSION_ACK;
308 1 : spdm_response->header.param1 = 0;
309 1 : spdm_response->header.param2 = 0;
310 :
311 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
312 : * transport_message is always in sender buffer. */
313 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
314 : &scratch_buffer_size);
315 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
316 : scratch_buffer_size - transport_header_size,
317 : spdm_response, spdm_response_size);
318 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
319 1 : libspdm_transport_test_encode_message(
320 : spdm_context, &session_id, false, false,
321 : spdm_response_size, spdm_response, response_size,
322 : response);
323 1 : session_info = libspdm_get_session_info_via_session_id( spdm_context, session_id);
324 1 : if (session_info == NULL) {
325 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
326 : }
327 : ((libspdm_secured_message_context_t
328 1 : *)(session_info->secured_message_context))
329 : ->application_secret
330 1 : .response_data_sequence_number--;
331 : }
332 : }
333 2 : return LIBSPDM_STATUS_SUCCESS;
334 :
335 1 : case 0x7: {
336 : spdm_error_response_t *spdm_response;
337 : size_t spdm_response_size;
338 : size_t transport_header_size;
339 : uint32_t session_id;
340 : libspdm_session_info_t *session_info;
341 : uint8_t *scratch_buffer;
342 : size_t scratch_buffer_size;
343 :
344 1 : spdm_response_size = sizeof(spdm_error_response_t);
345 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
346 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
347 :
348 1 : session_id = 0xFFFFFFFF;
349 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
350 1 : spdm_response->header.request_response_code = SPDM_ERROR;
351 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_REQUEST_RESYNCH;
352 1 : spdm_response->header.param2 = 0;
353 :
354 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
355 : * transport_message is always in sender buffer. */
356 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
357 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
358 : scratch_buffer_size - transport_header_size,
359 : spdm_response, spdm_response_size);
360 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
361 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
362 : false, false,
363 : spdm_response_size,
364 : spdm_response,
365 : response_size, response);
366 1 : session_info = libspdm_get_session_info_via_session_id( spdm_context, session_id);
367 1 : if (session_info == NULL) {
368 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
369 : }
370 : ((libspdm_secured_message_context_t
371 1 : *)(session_info->secured_message_context))
372 1 : ->application_secret.response_data_sequence_number--;
373 : }
374 1 : return LIBSPDM_STATUS_SUCCESS;
375 :
376 2 : case 0x8: {
377 : spdm_error_response_data_response_not_ready_t *spdm_response;
378 : size_t spdm_response_size;
379 : size_t transport_header_size;
380 : uint32_t session_id;
381 : libspdm_session_info_t *session_info;
382 : uint8_t *scratch_buffer;
383 : size_t scratch_buffer_size;
384 :
385 2 : spdm_response_size = sizeof(spdm_error_response_data_response_not_ready_t);
386 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
387 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
388 :
389 2 : session_id = 0xFFFFFFFF;
390 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
391 2 : spdm_response->header.request_response_code = SPDM_ERROR;
392 2 : spdm_response->header.param1 = SPDM_ERROR_CODE_RESPONSE_NOT_READY;
393 2 : spdm_response->header.param2 = 0;
394 2 : spdm_response->extend_error_data.rd_exponent = 1;
395 2 : spdm_response->extend_error_data.rd_tm = 2;
396 2 : spdm_response->extend_error_data.request_code = SPDM_END_SESSION;
397 2 : spdm_response->extend_error_data.token = 0;
398 :
399 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
400 : * transport_message is always in sender buffer. */
401 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
402 2 : libspdm_copy_mem (scratch_buffer + transport_header_size,
403 : scratch_buffer_size - transport_header_size,
404 : spdm_response, spdm_response_size);
405 2 : spdm_response = (void *)(scratch_buffer + transport_header_size);
406 2 : libspdm_transport_test_encode_message(spdm_context, &session_id,
407 : false, false,
408 : spdm_response_size,
409 : spdm_response,
410 : response_size, response);
411 2 : session_info = libspdm_get_session_info_via_session_id( spdm_context, session_id);
412 2 : if (session_info == NULL) {
413 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
414 : }
415 : ((libspdm_secured_message_context_t
416 2 : *)(session_info->secured_message_context))
417 2 : ->application_secret.response_data_sequence_number--;
418 : }
419 2 : return LIBSPDM_STATUS_SUCCESS;
420 :
421 2 : case 0x9: {
422 : static size_t sub_index2 = 0;
423 2 : if (sub_index2 == 0) {
424 : spdm_error_response_data_response_not_ready_t
425 : *spdm_response;
426 : size_t spdm_response_size;
427 : size_t transport_header_size;
428 : uint32_t session_id;
429 : libspdm_session_info_t *session_info;
430 : uint8_t *scratch_buffer;
431 : size_t scratch_buffer_size;
432 :
433 1 : spdm_response_size = sizeof(spdm_error_response_data_response_not_ready_t);
434 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
435 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
436 :
437 1 : session_id = 0xFFFFFFFF;
438 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
439 1 : spdm_response->header.request_response_code = SPDM_ERROR;
440 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_RESPONSE_NOT_READY;
441 1 : spdm_response->header.param2 = 0;
442 1 : spdm_response->extend_error_data.rd_exponent = 1;
443 1 : spdm_response->extend_error_data.rd_tm = 2;
444 1 : spdm_response->extend_error_data.request_code = SPDM_END_SESSION;
445 1 : spdm_response->extend_error_data.token = 1;
446 :
447 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
448 : * transport_message is always in sender buffer. */
449 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
450 : &scratch_buffer_size);
451 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
452 : scratch_buffer_size - transport_header_size,
453 : spdm_response, spdm_response_size);
454 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
455 1 : libspdm_transport_test_encode_message(
456 : spdm_context, &session_id, false, false,
457 : spdm_response_size, spdm_response,
458 : response_size, response);
459 1 : sub_index2++;
460 1 : session_info = libspdm_get_session_info_via_session_id( spdm_context, session_id);
461 1 : if (session_info == NULL) {
462 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
463 : }
464 : ((libspdm_secured_message_context_t
465 1 : *)(session_info->secured_message_context))
466 : ->application_secret
467 1 : .response_data_sequence_number--;
468 1 : } else if (sub_index2 == 1) {
469 : spdm_end_session_response_t *spdm_response;
470 : size_t spdm_response_size;
471 : size_t transport_header_size;
472 : uint32_t session_id;
473 : libspdm_session_info_t *session_info;
474 : uint8_t *scratch_buffer;
475 : size_t scratch_buffer_size;
476 :
477 1 : session_id = 0xFFFFFFFF;
478 1 : spdm_response_size = sizeof(spdm_end_session_response_t);
479 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
480 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
481 :
482 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
483 1 : spdm_response->header.request_response_code = SPDM_END_SESSION_ACK;
484 1 : spdm_response->header.param1 = 0;
485 1 : spdm_response->header.param2 = 0;
486 :
487 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
488 : * transport_message is always in sender buffer. */
489 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
490 : &scratch_buffer_size);
491 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
492 : scratch_buffer_size - transport_header_size,
493 : spdm_response, spdm_response_size);
494 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
495 1 : libspdm_transport_test_encode_message(
496 : spdm_context, &session_id, false, false,
497 : spdm_response_size, spdm_response, response_size,
498 : response);
499 1 : session_info = libspdm_get_session_info_via_session_id( spdm_context, session_id);
500 1 : if (session_info == NULL) {
501 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
502 : }
503 : ((libspdm_secured_message_context_t
504 1 : *)(session_info->secured_message_context))
505 : ->application_secret
506 1 : .response_data_sequence_number--;
507 : }
508 : }
509 2 : return LIBSPDM_STATUS_SUCCESS;
510 :
511 18 : case 0xA:
512 : {
513 : static uint16_t error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
514 :
515 : spdm_error_response_t *spdm_response;
516 : size_t spdm_response_size;
517 : size_t transport_header_size;
518 : uint32_t session_id;
519 : libspdm_session_info_t *session_info;
520 : uint8_t *scratch_buffer;
521 : size_t scratch_buffer_size;
522 :
523 18 : spdm_response_size = sizeof(spdm_error_response_t);
524 18 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
525 18 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
526 :
527 18 : session_id = 0xFFFFFFFF;
528 :
529 18 : if(error_code <= 0xff) {
530 18 : libspdm_zero_mem (spdm_response, spdm_response_size);
531 18 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
532 18 : spdm_response->header.request_response_code = SPDM_ERROR;
533 18 : spdm_response->header.param1 = (uint8_t) error_code;
534 18 : spdm_response->header.param2 = 0;
535 :
536 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
537 : * transport_message is always in sender buffer. */
538 18 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
539 : &scratch_buffer_size);
540 18 : libspdm_copy_mem (scratch_buffer + transport_header_size,
541 : scratch_buffer_size - transport_header_size,
542 : spdm_response, spdm_response_size);
543 18 : spdm_response = (void *)(scratch_buffer + transport_header_size);
544 18 : libspdm_transport_test_encode_message (spdm_context, &session_id, false, false,
545 : spdm_response_size, spdm_response,
546 : response_size, response);
547 18 : session_info = libspdm_get_session_info_via_session_id (spdm_context, session_id);
548 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->
549 18 : application_secret.response_data_sequence_number--;
550 : }
551 :
552 18 : error_code++;
553 18 : if(error_code == SPDM_ERROR_CODE_BUSY) { /*busy is treated in cases 5 and 6*/
554 1 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
555 : }
556 : /* skip some reserved error codes (0d to 3e) */
557 18 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) {
558 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
559 : }
560 : /* skip response not ready, request resync, and some reserved codes (44 to fc) */
561 18 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) {
562 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
563 : }
564 : }
565 18 : return LIBSPDM_STATUS_SUCCESS;
566 1 : case 0xB: {
567 : spdm_end_session_response_t *spdm_response;
568 : size_t spdm_response_size;
569 : size_t transport_header_size;
570 : uint32_t session_id;
571 : libspdm_session_info_t *session_info;
572 : uint8_t *scratch_buffer;
573 : size_t scratch_buffer_size;
574 :
575 1 : session_id = 0xFFFFFFFF;
576 1 : spdm_response_size = sizeof(spdm_end_session_response_t);
577 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
578 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
579 :
580 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
581 1 : spdm_response->header.request_response_code = SPDM_END_SESSION_ACK;
582 1 : spdm_response->header.param1 = 0;
583 1 : spdm_response->header.param2 = 0;
584 :
585 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
586 : * transport_message is always in sender buffer. */
587 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
588 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
589 : scratch_buffer_size - transport_header_size,
590 : spdm_response, spdm_response_size);
591 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
592 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
593 : false, false, spdm_response_size,
594 : spdm_response, response_size,
595 : response);
596 1 : session_info = libspdm_get_session_info_via_session_id( spdm_context, session_id);
597 1 : if (session_info == NULL) {
598 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
599 : }
600 : /* WALKAROUND: If just use single context to encode message and then decode message */
601 : ((libspdm_secured_message_context_t
602 1 : *)(session_info->secured_message_context))
603 1 : ->application_secret.response_data_sequence_number--;
604 : }
605 1 : return LIBSPDM_STATUS_SUCCESS;
606 1 : case 0xC: {
607 : spdm_error_response_t *spdm_response;
608 : size_t spdm_response_size;
609 : size_t transport_header_size;
610 : uint32_t session_id;
611 : libspdm_session_info_t *session_info;
612 : uint8_t *scratch_buffer;
613 : size_t scratch_buffer_size;
614 :
615 1 : spdm_response_size = sizeof(spdm_error_response_t);
616 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
617 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
618 :
619 1 : session_id = 0xFFFFFFFF;
620 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
621 1 : spdm_response->header.request_response_code = SPDM_ERROR;
622 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_DECRYPT_ERROR;
623 1 : spdm_response->header.param2 = 0;
624 :
625 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
626 : * transport_message is always in sender buffer. */
627 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
628 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
629 : scratch_buffer_size - transport_header_size,
630 : spdm_response, spdm_response_size);
631 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
632 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
633 : false, false,
634 : spdm_response_size,
635 : spdm_response,
636 : response_size, response);
637 1 : session_info = libspdm_get_session_info_via_session_id( spdm_context, session_id);
638 1 : if (session_info == NULL) {
639 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
640 : }
641 : ((libspdm_secured_message_context_t
642 1 : *)(session_info->secured_message_context))
643 1 : ->application_secret.response_data_sequence_number--;
644 : }
645 1 : return LIBSPDM_STATUS_SUCCESS;
646 :
647 0 : default:
648 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
649 : }
650 : }
651 :
652 1 : static void req_end_session_case1(void **state)
653 : {
654 : libspdm_return_t status;
655 : libspdm_test_context_t *spdm_test_context;
656 : libspdm_context_t *spdm_context;
657 : uint32_t session_id;
658 : void *data;
659 : size_t data_size;
660 : void *hash;
661 : size_t hash_size;
662 : libspdm_session_info_t *session_info;
663 :
664 1 : spdm_test_context = *state;
665 1 : spdm_context = spdm_test_context->spdm_context;
666 1 : spdm_test_context->case_id = 0x1;
667 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
668 : SPDM_VERSION_NUMBER_SHIFT_BIT;
669 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
670 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
671 1 : spdm_context->connection_info.capability.flags |=
672 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
673 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
674 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
675 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
676 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
677 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
678 : m_libspdm_use_asym_algo, &data,
679 : &data_size, &hash, &hash_size)) {
680 0 : assert(false);
681 : }
682 1 : libspdm_reset_message_a(spdm_context);
683 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
684 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
685 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
686 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
687 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
688 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
689 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
690 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
691 : data, data_size);
692 : #endif
693 :
694 1 : session_id = 0xFFFFFFFF;
695 1 : session_info = &spdm_context->session_info[0];
696 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
697 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
698 1 : libspdm_secured_message_set_session_state(
699 : session_info->secured_message_context,
700 : LIBSPDM_SESSION_STATE_ESTABLISHED);
701 :
702 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
703 1 : assert_int_equal(status, LIBSPDM_STATUS_SEND_FAIL);
704 1 : free(data);
705 1 : }
706 :
707 1 : static void req_end_session_case2(void **state)
708 : {
709 : libspdm_return_t status;
710 : libspdm_test_context_t *spdm_test_context;
711 : libspdm_context_t *spdm_context;
712 : uint32_t session_id;
713 : void *data;
714 : size_t data_size;
715 : void *hash;
716 : size_t hash_size;
717 : libspdm_session_info_t *session_info;
718 :
719 1 : spdm_test_context = *state;
720 1 : spdm_context = spdm_test_context->spdm_context;
721 1 : spdm_test_context->case_id = 0x2;
722 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
723 : SPDM_VERSION_NUMBER_SHIFT_BIT;
724 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
725 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
726 1 : spdm_context->connection_info.capability.flags |=
727 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
728 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
729 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
730 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
731 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
732 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
733 : m_libspdm_use_asym_algo, &data,
734 : &data_size, &hash, &hash_size)) {
735 0 : assert(false);
736 : }
737 1 : libspdm_reset_message_a(spdm_context);
738 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
739 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
740 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
741 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
742 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
743 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
744 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
745 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
746 : data, data_size);
747 : #endif
748 :
749 1 : session_id = 0xFFFFFFFF;
750 1 : session_info = &spdm_context->session_info[0];
751 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
752 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
753 1 : libspdm_secured_message_set_session_state(
754 : session_info->secured_message_context,
755 : LIBSPDM_SESSION_STATE_ESTABLISHED);
756 1 : libspdm_set_mem(m_dummy_key_buffer,
757 : ((libspdm_secured_message_context_t
758 1 : *)(session_info->secured_message_context))
759 : ->aead_key_size,
760 : (uint8_t)(0xFF));
761 1 : libspdm_secured_message_set_response_data_encryption_key(
762 : session_info->secured_message_context, m_dummy_key_buffer,
763 : ((libspdm_secured_message_context_t
764 1 : *)(session_info->secured_message_context))
765 : ->aead_key_size);
766 1 : libspdm_set_mem(m_dummy_salt_buffer,
767 : ((libspdm_secured_message_context_t
768 1 : *)(session_info->secured_message_context))
769 : ->aead_iv_size,
770 : (uint8_t)(0xFF));
771 1 : libspdm_secured_message_set_response_data_salt(
772 : session_info->secured_message_context, m_dummy_salt_buffer,
773 : ((libspdm_secured_message_context_t
774 1 : *)(session_info->secured_message_context))
775 : ->aead_iv_size);
776 : ((libspdm_secured_message_context_t *)(session_info
777 1 : ->secured_message_context))
778 1 : ->application_secret.response_data_sequence_number = 0;
779 :
780 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
781 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
782 1 : assert_int_equal(
783 : libspdm_secured_message_get_session_state(
784 : spdm_context->session_info[0].secured_message_context),
785 : LIBSPDM_SESSION_STATE_NOT_STARTED);
786 1 : free(data);
787 1 : }
788 :
789 1 : static void req_end_session_case3(void **state)
790 : {
791 : libspdm_return_t status;
792 : libspdm_test_context_t *spdm_test_context;
793 : libspdm_context_t *spdm_context;
794 : uint32_t session_id;
795 : void *data;
796 : size_t data_size;
797 : void *hash;
798 : size_t hash_size;
799 : libspdm_session_info_t *session_info;
800 :
801 1 : spdm_test_context = *state;
802 1 : spdm_context = spdm_test_context->spdm_context;
803 1 : spdm_test_context->case_id = 0x3;
804 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
805 : SPDM_VERSION_NUMBER_SHIFT_BIT;
806 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NOT_STARTED;
807 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
808 1 : spdm_context->connection_info.capability.flags |=
809 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
810 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
811 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
812 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
813 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
814 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
815 : m_libspdm_use_asym_algo, &data,
816 : &data_size, &hash, &hash_size)) {
817 0 : assert(false);
818 : }
819 1 : libspdm_reset_message_a(spdm_context);
820 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
821 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
822 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
823 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
824 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
825 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
826 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
827 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
828 : data, data_size);
829 : #endif
830 :
831 1 : session_id = 0xFFFFFFFF;
832 1 : session_info = &spdm_context->session_info[0];
833 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
834 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
835 1 : libspdm_secured_message_set_session_state(
836 : session_info->secured_message_context,
837 : LIBSPDM_SESSION_STATE_ESTABLISHED);
838 1 : libspdm_set_mem(m_dummy_key_buffer,
839 : ((libspdm_secured_message_context_t
840 1 : *)(session_info->secured_message_context))
841 : ->aead_key_size,
842 : (uint8_t)(0xFF));
843 1 : libspdm_secured_message_set_response_data_encryption_key(
844 : session_info->secured_message_context, m_dummy_key_buffer,
845 : ((libspdm_secured_message_context_t
846 1 : *)(session_info->secured_message_context))
847 : ->aead_key_size);
848 1 : libspdm_set_mem(m_dummy_salt_buffer,
849 : ((libspdm_secured_message_context_t
850 1 : *)(session_info->secured_message_context))
851 : ->aead_iv_size,
852 : (uint8_t)(0xFF));
853 1 : libspdm_secured_message_set_response_data_salt(
854 : session_info->secured_message_context, m_dummy_salt_buffer,
855 : ((libspdm_secured_message_context_t
856 1 : *)(session_info->secured_message_context))
857 : ->aead_iv_size);
858 : ((libspdm_secured_message_context_t *)(session_info
859 1 : ->secured_message_context))
860 1 : ->application_secret.response_data_sequence_number = 0;
861 :
862 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
863 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_STATE_LOCAL);
864 1 : free(data);
865 1 : }
866 :
867 1 : static void req_end_session_case4(void **state)
868 : {
869 : libspdm_return_t status;
870 : libspdm_test_context_t *spdm_test_context;
871 : libspdm_context_t *spdm_context;
872 : uint32_t session_id;
873 : void *data;
874 : size_t data_size;
875 : void *hash;
876 : size_t hash_size;
877 : libspdm_session_info_t *session_info;
878 :
879 1 : spdm_test_context = *state;
880 1 : spdm_context = spdm_test_context->spdm_context;
881 1 : spdm_test_context->case_id = 0x4;
882 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
883 : SPDM_VERSION_NUMBER_SHIFT_BIT;
884 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
885 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
886 1 : spdm_context->connection_info.capability.flags |=
887 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
888 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
889 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
890 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
891 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
892 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
893 : m_libspdm_use_asym_algo, &data,
894 : &data_size, &hash, &hash_size)) {
895 0 : assert(false);
896 : }
897 1 : libspdm_reset_message_a(spdm_context);
898 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
899 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
900 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
901 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
902 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
903 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
904 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
905 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
906 : data, data_size);
907 : #endif
908 :
909 1 : session_id = 0xFFFFFFFF;
910 1 : session_info = &spdm_context->session_info[0];
911 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
912 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
913 1 : libspdm_secured_message_set_session_state(
914 : session_info->secured_message_context,
915 : LIBSPDM_SESSION_STATE_ESTABLISHED);
916 1 : libspdm_set_mem(m_dummy_key_buffer,
917 : ((libspdm_secured_message_context_t
918 1 : *)(session_info->secured_message_context))
919 : ->aead_key_size,
920 : (uint8_t)(0xFF));
921 1 : libspdm_secured_message_set_response_data_encryption_key(
922 : session_info->secured_message_context, m_dummy_key_buffer,
923 : ((libspdm_secured_message_context_t
924 1 : *)(session_info->secured_message_context))
925 : ->aead_key_size);
926 1 : libspdm_set_mem(m_dummy_salt_buffer,
927 : ((libspdm_secured_message_context_t
928 1 : *)(session_info->secured_message_context))
929 : ->aead_iv_size,
930 : (uint8_t)(0xFF));
931 1 : libspdm_secured_message_set_response_data_salt(
932 : session_info->secured_message_context, m_dummy_salt_buffer,
933 : ((libspdm_secured_message_context_t
934 1 : *)(session_info->secured_message_context))
935 : ->aead_iv_size);
936 : ((libspdm_secured_message_context_t *)(session_info
937 1 : ->secured_message_context))
938 1 : ->application_secret.response_data_sequence_number = 0;
939 :
940 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
941 1 : assert_int_equal(status, LIBSPDM_STATUS_ERROR_PEER);
942 1 : free(data);
943 1 : }
944 :
945 1 : static void req_end_session_case5(void **state)
946 : {
947 : libspdm_return_t status;
948 : libspdm_test_context_t *spdm_test_context;
949 : libspdm_context_t *spdm_context;
950 : uint32_t session_id;
951 : void *data;
952 : size_t data_size;
953 : void *hash;
954 : size_t hash_size;
955 : libspdm_session_info_t *session_info;
956 :
957 1 : spdm_test_context = *state;
958 1 : spdm_context = spdm_test_context->spdm_context;
959 1 : spdm_test_context->case_id = 0x5;
960 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
961 : SPDM_VERSION_NUMBER_SHIFT_BIT;
962 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
963 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
964 1 : spdm_context->connection_info.capability.flags |=
965 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
966 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
967 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
968 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
969 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
970 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
971 : m_libspdm_use_asym_algo, &data,
972 : &data_size, &hash, &hash_size)) {
973 0 : assert(false);
974 : }
975 1 : libspdm_reset_message_a(spdm_context);
976 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
977 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
978 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
979 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
980 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
981 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
982 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
983 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
984 : data, data_size);
985 : #endif
986 :
987 1 : session_id = 0xFFFFFFFF;
988 1 : session_info = &spdm_context->session_info[0];
989 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
990 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
991 1 : libspdm_secured_message_set_session_state(
992 : session_info->secured_message_context,
993 : LIBSPDM_SESSION_STATE_ESTABLISHED);
994 1 : libspdm_set_mem(m_dummy_key_buffer,
995 : ((libspdm_secured_message_context_t
996 1 : *)(session_info->secured_message_context))
997 : ->aead_key_size,
998 : (uint8_t)(0xFF));
999 1 : libspdm_secured_message_set_response_data_encryption_key(
1000 : session_info->secured_message_context, m_dummy_key_buffer,
1001 : ((libspdm_secured_message_context_t
1002 1 : *)(session_info->secured_message_context))
1003 : ->aead_key_size);
1004 1 : libspdm_set_mem(m_dummy_salt_buffer,
1005 : ((libspdm_secured_message_context_t
1006 1 : *)(session_info->secured_message_context))
1007 : ->aead_iv_size,
1008 : (uint8_t)(0xFF));
1009 1 : libspdm_secured_message_set_response_data_salt(
1010 : session_info->secured_message_context, m_dummy_salt_buffer,
1011 : ((libspdm_secured_message_context_t
1012 1 : *)(session_info->secured_message_context))
1013 : ->aead_iv_size);
1014 : ((libspdm_secured_message_context_t *)(session_info
1015 1 : ->secured_message_context))
1016 1 : ->application_secret.response_data_sequence_number = 0;
1017 :
1018 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
1019 1 : assert_int_equal(status, LIBSPDM_STATUS_BUSY_PEER);
1020 1 : free(data);
1021 1 : }
1022 :
1023 1 : static void req_end_session_case6(void **state)
1024 : {
1025 : libspdm_return_t status;
1026 : libspdm_test_context_t *spdm_test_context;
1027 : libspdm_context_t *spdm_context;
1028 : uint32_t session_id;
1029 : void *data;
1030 : size_t data_size;
1031 : void *hash;
1032 : size_t hash_size;
1033 : libspdm_session_info_t *session_info;
1034 :
1035 1 : spdm_test_context = *state;
1036 1 : spdm_context = spdm_test_context->spdm_context;
1037 1 : spdm_test_context->case_id = 0x6;
1038 1 : spdm_context->retry_times = 3;
1039 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1040 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1041 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1042 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1043 1 : spdm_context->connection_info.capability.flags |=
1044 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1045 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1046 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1047 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1048 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1049 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1050 : m_libspdm_use_asym_algo, &data,
1051 : &data_size, &hash, &hash_size)) {
1052 0 : assert(false);
1053 : }
1054 1 : libspdm_reset_message_a(spdm_context);
1055 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1056 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1057 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1058 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1059 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1060 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1061 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1062 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1063 : data, data_size);
1064 : #endif
1065 :
1066 1 : session_id = 0xFFFFFFFF;
1067 1 : session_info = &spdm_context->session_info[0];
1068 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
1069 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
1070 1 : libspdm_secured_message_set_session_state(
1071 : session_info->secured_message_context,
1072 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1073 1 : libspdm_set_mem(m_dummy_key_buffer,
1074 : ((libspdm_secured_message_context_t
1075 1 : *)(session_info->secured_message_context))
1076 : ->aead_key_size,
1077 : (uint8_t)(0xFF));
1078 1 : libspdm_secured_message_set_response_data_encryption_key(
1079 : session_info->secured_message_context, m_dummy_key_buffer,
1080 : ((libspdm_secured_message_context_t
1081 1 : *)(session_info->secured_message_context))
1082 : ->aead_key_size);
1083 1 : libspdm_set_mem(m_dummy_salt_buffer,
1084 : ((libspdm_secured_message_context_t
1085 1 : *)(session_info->secured_message_context))
1086 : ->aead_iv_size,
1087 : (uint8_t)(0xFF));
1088 1 : libspdm_secured_message_set_response_data_salt(
1089 : session_info->secured_message_context, m_dummy_salt_buffer,
1090 : ((libspdm_secured_message_context_t
1091 1 : *)(session_info->secured_message_context))
1092 : ->aead_iv_size);
1093 : ((libspdm_secured_message_context_t *)(session_info
1094 1 : ->secured_message_context))
1095 1 : ->application_secret.response_data_sequence_number = 0;
1096 :
1097 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
1098 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1099 1 : assert_int_equal(
1100 : libspdm_secured_message_get_session_state(
1101 : spdm_context->session_info[0].secured_message_context),
1102 : LIBSPDM_SESSION_STATE_NOT_STARTED);
1103 1 : free(data);
1104 1 : }
1105 :
1106 1 : static void req_end_session_case7(void **state)
1107 : {
1108 : libspdm_return_t status;
1109 : libspdm_test_context_t *spdm_test_context;
1110 : libspdm_context_t *spdm_context;
1111 : uint32_t session_id;
1112 : void *data;
1113 : size_t data_size;
1114 : void *hash;
1115 : size_t hash_size;
1116 : libspdm_session_info_t *session_info;
1117 :
1118 1 : spdm_test_context = *state;
1119 1 : spdm_context = spdm_test_context->spdm_context;
1120 1 : spdm_test_context->case_id = 0x7;
1121 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1122 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1123 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1124 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1125 1 : spdm_context->connection_info.capability.flags |=
1126 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1127 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1128 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1129 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1130 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1131 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1132 : m_libspdm_use_asym_algo, &data,
1133 : &data_size, &hash, &hash_size)) {
1134 0 : assert(false);
1135 : }
1136 1 : libspdm_reset_message_a(spdm_context);
1137 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1138 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1139 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1140 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1141 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1142 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1143 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1144 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1145 : data, data_size);
1146 : #endif
1147 :
1148 1 : session_id = 0xFFFFFFFF;
1149 1 : session_info = &spdm_context->session_info[0];
1150 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
1151 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
1152 1 : libspdm_secured_message_set_session_state(
1153 : session_info->secured_message_context,
1154 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1155 1 : libspdm_set_mem(m_dummy_key_buffer,
1156 : ((libspdm_secured_message_context_t
1157 1 : *)(session_info->secured_message_context))
1158 : ->aead_key_size,
1159 : (uint8_t)(0xFF));
1160 1 : libspdm_secured_message_set_response_data_encryption_key(
1161 : session_info->secured_message_context, m_dummy_key_buffer,
1162 : ((libspdm_secured_message_context_t
1163 1 : *)(session_info->secured_message_context))
1164 : ->aead_key_size);
1165 1 : libspdm_set_mem(m_dummy_salt_buffer,
1166 : ((libspdm_secured_message_context_t
1167 1 : *)(session_info->secured_message_context))
1168 : ->aead_iv_size,
1169 : (uint8_t)(0xFF));
1170 1 : libspdm_secured_message_set_response_data_salt(
1171 : session_info->secured_message_context, m_dummy_salt_buffer,
1172 : ((libspdm_secured_message_context_t
1173 1 : *)(session_info->secured_message_context))
1174 : ->aead_iv_size);
1175 : ((libspdm_secured_message_context_t *)(session_info
1176 1 : ->secured_message_context))
1177 1 : ->application_secret.response_data_sequence_number = 0;
1178 :
1179 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
1180 1 : assert_int_equal(status, LIBSPDM_STATUS_RESYNCH_PEER);
1181 1 : assert_int_equal(spdm_context->connection_info.connection_state,
1182 : LIBSPDM_CONNECTION_STATE_NOT_STARTED);
1183 1 : free(data);
1184 1 : }
1185 :
1186 1 : static void req_end_session_case8(void **state)
1187 : {
1188 : libspdm_return_t status;
1189 : libspdm_test_context_t *spdm_test_context;
1190 : libspdm_context_t *spdm_context;
1191 : uint32_t session_id;
1192 : void *data;
1193 : size_t data_size;
1194 : void *hash;
1195 : size_t hash_size;
1196 : libspdm_session_info_t *session_info;
1197 :
1198 1 : spdm_test_context = *state;
1199 1 : spdm_context = spdm_test_context->spdm_context;
1200 1 : spdm_test_context->case_id = 0x8;
1201 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1202 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1203 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1204 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1205 1 : spdm_context->connection_info.capability.flags |=
1206 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1207 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1208 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1209 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1210 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1211 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1212 : m_libspdm_use_asym_algo, &data,
1213 : &data_size, &hash, &hash_size)) {
1214 0 : assert(false);
1215 : }
1216 1 : libspdm_reset_message_a(spdm_context);
1217 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1218 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1219 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1220 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1221 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1222 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1223 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1224 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1225 : data, data_size);
1226 : #endif
1227 :
1228 1 : session_id = 0xFFFFFFFF;
1229 1 : session_info = &spdm_context->session_info[0];
1230 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
1231 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
1232 1 : libspdm_secured_message_set_session_state(
1233 : session_info->secured_message_context,
1234 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1235 1 : libspdm_set_mem(m_dummy_key_buffer,
1236 : ((libspdm_secured_message_context_t
1237 1 : *)(session_info->secured_message_context))
1238 : ->aead_key_size,
1239 : (uint8_t)(0xFF));
1240 1 : libspdm_secured_message_set_response_data_encryption_key(
1241 : session_info->secured_message_context, m_dummy_key_buffer,
1242 : ((libspdm_secured_message_context_t
1243 1 : *)(session_info->secured_message_context))
1244 : ->aead_key_size);
1245 1 : libspdm_set_mem(m_dummy_salt_buffer,
1246 : ((libspdm_secured_message_context_t
1247 1 : *)(session_info->secured_message_context))
1248 : ->aead_iv_size,
1249 : (uint8_t)(0xFF));
1250 1 : libspdm_secured_message_set_response_data_salt(
1251 : session_info->secured_message_context, m_dummy_salt_buffer,
1252 : ((libspdm_secured_message_context_t
1253 1 : *)(session_info->secured_message_context))
1254 : ->aead_iv_size);
1255 : ((libspdm_secured_message_context_t *)(session_info
1256 1 : ->secured_message_context))
1257 1 : ->application_secret.response_data_sequence_number = 0;
1258 :
1259 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
1260 1 : assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
1261 1 : free(data);
1262 1 : }
1263 :
1264 1 : static void req_end_session_case9(void **state)
1265 : {
1266 : libspdm_return_t status;
1267 : libspdm_test_context_t *spdm_test_context;
1268 : libspdm_context_t *spdm_context;
1269 : uint32_t session_id;
1270 : void *data;
1271 : size_t data_size;
1272 : void *hash;
1273 : size_t hash_size;
1274 : libspdm_session_info_t *session_info;
1275 :
1276 1 : spdm_test_context = *state;
1277 1 : spdm_context = spdm_test_context->spdm_context;
1278 1 : spdm_test_context->case_id = 0x9;
1279 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1280 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1281 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1282 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1283 1 : spdm_context->connection_info.capability.flags |=
1284 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1285 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1286 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1287 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1288 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1289 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1290 : m_libspdm_use_asym_algo, &data,
1291 : &data_size, &hash, &hash_size)) {
1292 0 : assert(false);
1293 : }
1294 1 : libspdm_reset_message_a(spdm_context);
1295 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1296 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1297 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1298 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1299 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1300 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1301 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1302 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1303 : data, data_size);
1304 : #endif
1305 :
1306 1 : session_id = 0xFFFFFFFF;
1307 1 : session_info = &spdm_context->session_info[0];
1308 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
1309 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
1310 1 : libspdm_secured_message_set_session_state(
1311 : session_info->secured_message_context,
1312 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1313 1 : libspdm_set_mem(m_dummy_key_buffer,
1314 : ((libspdm_secured_message_context_t
1315 1 : *)(session_info->secured_message_context))
1316 : ->aead_key_size,
1317 : (uint8_t)(0xFF));
1318 1 : libspdm_secured_message_set_response_data_encryption_key(
1319 : session_info->secured_message_context, m_dummy_key_buffer,
1320 : ((libspdm_secured_message_context_t
1321 1 : *)(session_info->secured_message_context))
1322 : ->aead_key_size);
1323 1 : libspdm_set_mem(m_dummy_salt_buffer,
1324 : ((libspdm_secured_message_context_t
1325 1 : *)(session_info->secured_message_context))
1326 : ->aead_iv_size,
1327 : (uint8_t)(0xFF));
1328 1 : libspdm_secured_message_set_response_data_salt(
1329 : session_info->secured_message_context, m_dummy_salt_buffer,
1330 : ((libspdm_secured_message_context_t
1331 1 : *)(session_info->secured_message_context))->aead_iv_size);
1332 1 : ((libspdm_secured_message_context_t *)(session_info->secured_message_context))
1333 1 : ->application_secret.response_data_sequence_number = 0;
1334 :
1335 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
1336 : if (LIBSPDM_RESPOND_IF_READY_SUPPORT) {
1337 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1338 1 : assert_int_equal(
1339 : libspdm_secured_message_get_session_state(
1340 : spdm_context->session_info[0].secured_message_context),
1341 : LIBSPDM_SESSION_STATE_NOT_STARTED);
1342 : } else {
1343 : assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
1344 : }
1345 1 : free(data);
1346 1 : }
1347 :
1348 1 : static void req_end_session_case10(void **state) {
1349 : libspdm_return_t status;
1350 : libspdm_test_context_t *spdm_test_context;
1351 : libspdm_context_t *spdm_context;
1352 : uint32_t session_id;
1353 : void *data;
1354 : size_t data_size;
1355 : void *hash;
1356 : size_t hash_size;
1357 : libspdm_session_info_t *session_info;
1358 : uint16_t error_code;
1359 :
1360 1 : spdm_test_context = *state;
1361 1 : spdm_context = spdm_test_context->spdm_context;
1362 1 : spdm_test_context->case_id = 0xA;
1363 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1364 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1365 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1366 1 : spdm_context->connection_info.capability.flags |=
1367 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1368 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1369 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1370 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1371 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1372 1 : libspdm_read_responder_public_certificate_chain (m_libspdm_use_hash_algo,
1373 : m_libspdm_use_asym_algo,
1374 : &data, &data_size,
1375 : &hash, &hash_size);
1376 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1377 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1378 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1379 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1380 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1381 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1382 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1383 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1384 : data, data_size);
1385 : #endif
1386 :
1387 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
1388 19 : while(error_code <= 0xff) {
1389 18 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1390 18 : libspdm_reset_message_a(spdm_context);
1391 :
1392 18 : session_id = 0xFFFFFFFF;
1393 18 : session_info = &spdm_context->session_info[0];
1394 18 : libspdm_session_info_init (spdm_context, session_info, session_id,
1395 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
1396 18 : libspdm_secured_message_set_session_state (session_info->secured_message_context,
1397 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1398 18 : libspdm_set_mem (m_dummy_key_buffer,
1399 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->aead_key_size,
1400 : (uint8_t)(0xFF));
1401 18 : libspdm_secured_message_set_response_data_encryption_key (
1402 : session_info->secured_message_context, m_dummy_key_buffer,
1403 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->aead_key_size);
1404 18 : libspdm_set_mem (m_dummy_salt_buffer,
1405 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->aead_iv_size,
1406 : (uint8_t)(0xFF));
1407 18 : libspdm_secured_message_set_response_data_salt (session_info->secured_message_context,
1408 : m_dummy_salt_buffer,
1409 : ((libspdm_secured_message_context_t*)(
1410 : session_info
1411 18 : ->
1412 : secured_message_context))->aead_iv_size);
1413 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->
1414 18 : application_secret.response_data_sequence_number = 0;
1415 :
1416 18 : status = libspdm_send_receive_end_session (spdm_context, session_id, 0);
1417 18 : if(error_code != SPDM_ERROR_CODE_DECRYPT_ERROR) {
1418 17 : LIBSPDM_ASSERT_INT_EQUAL_CASE (status, LIBSPDM_STATUS_ERROR_PEER, error_code);
1419 : } else {
1420 1 : LIBSPDM_ASSERT_INT_EQUAL_CASE (status, LIBSPDM_STATUS_SESSION_MSG_ERROR, error_code);
1421 : }
1422 :
1423 18 : error_code++;
1424 18 : if(error_code == SPDM_ERROR_CODE_BUSY) { /*busy is treated in cases 5 and 6*/
1425 1 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
1426 : }
1427 : /* skip some reserved error codes (0d to 3e) */
1428 18 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) {
1429 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
1430 : }
1431 : /* skip response not ready, request resync, and some reserved codes (44 to fc) */
1432 18 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) {
1433 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
1434 : }
1435 : }
1436 :
1437 1 : free(data);
1438 1 : }
1439 :
1440 1 : static void req_end_session_case11(void **state)
1441 : {
1442 : libspdm_return_t status;
1443 : libspdm_test_context_t *spdm_test_context;
1444 : libspdm_context_t *spdm_context;
1445 : uint32_t session_id;
1446 : void *data;
1447 : size_t data_size;
1448 : void *hash;
1449 : size_t hash_size;
1450 : libspdm_session_info_t *session_info;
1451 :
1452 1 : spdm_test_context = *state;
1453 1 : spdm_context = spdm_test_context->spdm_context;
1454 1 : spdm_test_context->case_id = 0xB;
1455 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1456 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1457 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1458 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1459 1 : spdm_context->connection_info.capability.flags |=
1460 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1461 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1462 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1463 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1464 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1465 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1466 : m_libspdm_use_asym_algo, &data,
1467 : &data_size, &hash, &hash_size)) {
1468 0 : assert(false);
1469 : }
1470 1 : libspdm_reset_message_a(spdm_context);
1471 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1472 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1473 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1474 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1475 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1476 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1477 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1478 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1479 : data, data_size);
1480 : #endif
1481 :
1482 1 : session_id = 0xFFFFFFFF;
1483 1 : session_info = &spdm_context->session_info[0];
1484 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
1485 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
1486 1 : libspdm_secured_message_set_session_state(
1487 : session_info->secured_message_context,
1488 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1489 1 : libspdm_set_mem(m_dummy_key_buffer,
1490 : ((libspdm_secured_message_context_t
1491 1 : *)(session_info->secured_message_context))
1492 : ->aead_key_size,
1493 : (uint8_t)(0xFF));
1494 1 : libspdm_secured_message_set_response_data_encryption_key(
1495 : session_info->secured_message_context, m_dummy_key_buffer,
1496 : ((libspdm_secured_message_context_t
1497 1 : *)(session_info->secured_message_context))
1498 : ->aead_key_size);
1499 1 : libspdm_set_mem(m_dummy_salt_buffer,
1500 : ((libspdm_secured_message_context_t
1501 1 : *)(session_info->secured_message_context))
1502 : ->aead_iv_size,
1503 : (uint8_t)(0xFF));
1504 1 : libspdm_secured_message_set_response_data_salt(
1505 : session_info->secured_message_context, m_dummy_salt_buffer,
1506 : ((libspdm_secured_message_context_t
1507 1 : *)(session_info->secured_message_context))
1508 : ->aead_iv_size);
1509 : ((libspdm_secured_message_context_t *)(session_info
1510 1 : ->secured_message_context))
1511 1 : ->application_secret.response_data_sequence_number = 0;
1512 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1513 : session_info->session_transcript.message_m.buffer_size =
1514 : spdm_context->transcript.message_m.max_buffer_size;
1515 : spdm_context->transcript.message_b.buffer_size =
1516 : spdm_context->transcript.message_b.max_buffer_size;
1517 : spdm_context->transcript.message_c.buffer_size =
1518 : spdm_context->transcript.message_c.max_buffer_size;
1519 : spdm_context->transcript.message_mut_b.buffer_size =
1520 : spdm_context->transcript.message_mut_b.max_buffer_size;
1521 : spdm_context->transcript.message_mut_c.buffer_size =
1522 : spdm_context->transcript.message_mut_c.max_buffer_size;
1523 : #endif
1524 :
1525 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
1526 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1527 1 : assert_int_equal(
1528 : libspdm_secured_message_get_session_state(
1529 : spdm_context->session_info[0].secured_message_context),
1530 : LIBSPDM_SESSION_STATE_NOT_STARTED);
1531 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1532 : assert_int_equal(session_info->session_transcript.message_m.buffer_size, 0);
1533 : assert_int_equal(spdm_context->transcript.message_b.buffer_size, 0);
1534 : assert_int_equal(spdm_context->transcript.message_c.buffer_size, 0);
1535 : assert_int_equal(spdm_context->transcript.message_mut_b.buffer_size, 0);
1536 : assert_int_equal(spdm_context->transcript.message_mut_c.buffer_size, 0);
1537 : #endif
1538 1 : free(data);
1539 1 : }
1540 :
1541 : /**
1542 : * Test 12: the requester is setup correctly, but receives an ERROR with SPDM_ERROR_CODE_DECRYPT_ERROR.
1543 : * Expected behavior: client returns a Status of INVALID_SESSION_ID and free the session ID.
1544 : **/
1545 1 : static void req_end_session_case12(void **state)
1546 : {
1547 : libspdm_return_t status;
1548 : libspdm_test_context_t *spdm_test_context;
1549 : libspdm_context_t *spdm_context;
1550 : uint32_t session_id;
1551 : void *data;
1552 : size_t data_size;
1553 : void *hash;
1554 : size_t hash_size;
1555 : libspdm_session_info_t *session_info;
1556 :
1557 1 : spdm_test_context = *state;
1558 1 : spdm_context = spdm_test_context->spdm_context;
1559 1 : spdm_test_context->case_id = 0xC;
1560 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1561 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1562 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1563 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1564 1 : spdm_context->connection_info.capability.flags |=
1565 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1566 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1567 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1568 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1569 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1570 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1571 : m_libspdm_use_asym_algo, &data,
1572 : &data_size, &hash, &hash_size)) {
1573 0 : assert(false);
1574 : }
1575 1 : libspdm_reset_message_a(spdm_context);
1576 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1577 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1578 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1579 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1580 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1581 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1582 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1583 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1584 : data, data_size);
1585 : #endif
1586 :
1587 1 : session_id = 0xFFFFFFFF;
1588 1 : session_info = &spdm_context->session_info[0];
1589 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
1590 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
1591 1 : libspdm_secured_message_set_session_state(
1592 : session_info->secured_message_context,
1593 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1594 1 : libspdm_set_mem(m_dummy_key_buffer,
1595 : ((libspdm_secured_message_context_t
1596 1 : *)(session_info->secured_message_context))
1597 : ->aead_key_size,
1598 : (uint8_t)(0xFF));
1599 1 : libspdm_secured_message_set_response_data_encryption_key(
1600 : session_info->secured_message_context, m_dummy_key_buffer,
1601 : ((libspdm_secured_message_context_t
1602 1 : *)(session_info->secured_message_context))
1603 : ->aead_key_size);
1604 1 : libspdm_set_mem(m_dummy_salt_buffer,
1605 : ((libspdm_secured_message_context_t
1606 1 : *)(session_info->secured_message_context))
1607 : ->aead_iv_size,
1608 : (uint8_t)(0xFF));
1609 1 : libspdm_secured_message_set_response_data_salt(
1610 : session_info->secured_message_context, m_dummy_salt_buffer,
1611 : ((libspdm_secured_message_context_t
1612 1 : *)(session_info->secured_message_context))
1613 : ->aead_iv_size);
1614 : ((libspdm_secured_message_context_t *)(session_info
1615 1 : ->secured_message_context))
1616 1 : ->application_secret.response_data_sequence_number = 0;
1617 :
1618 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
1619 1 : assert_int_equal(status, LIBSPDM_STATUS_SESSION_MSG_ERROR);
1620 1 : assert_int_equal(spdm_context->session_info->session_id, INVALID_SESSION_ID);
1621 :
1622 1 : free(data);
1623 1 : }
1624 :
1625 1 : int libspdm_req_end_session_test(void)
1626 : {
1627 1 : const struct CMUnitTest test_cases[] = {
1628 : /* SendRequest failed*/
1629 : cmocka_unit_test(req_end_session_case1),
1630 : /* Successful response*/
1631 : cmocka_unit_test(req_end_session_case2),
1632 : /* connection_state check failed*/
1633 : cmocka_unit_test(req_end_session_case3),
1634 : /* Error response: SPDM_ERROR_CODE_INVALID_REQUEST*/
1635 : cmocka_unit_test(req_end_session_case4),
1636 : /* Always SPDM_ERROR_CODE_BUSY*/
1637 : cmocka_unit_test(req_end_session_case5),
1638 : /* SPDM_ERROR_CODE_BUSY + Successful response*/
1639 : cmocka_unit_test(req_end_session_case6),
1640 : /* Error response: SPDM_ERROR_CODE_REQUEST_RESYNCH*/
1641 : cmocka_unit_test(req_end_session_case7),
1642 : /* Always SPDM_ERROR_CODE_RESPONSE_NOT_READY*/
1643 : cmocka_unit_test(req_end_session_case8),
1644 : /* SPDM_ERROR_CODE_RESPONSE_NOT_READY + Successful response*/
1645 : cmocka_unit_test(req_end_session_case9),
1646 : /* Unexpected errors*/
1647 : cmocka_unit_test(req_end_session_case10),
1648 : /* Buffer reset*/
1649 : cmocka_unit_test(req_end_session_case11),
1650 : /* Error response: SPDM_ERROR_CODE_DECRYPT_ERROR*/
1651 : cmocka_unit_test(req_end_session_case12),
1652 : };
1653 :
1654 1 : libspdm_test_context_t test_context = {
1655 : LIBSPDM_TEST_CONTEXT_VERSION,
1656 : true,
1657 : send_message,
1658 : receive_message,
1659 : };
1660 :
1661 1 : libspdm_setup_test_context(&test_context);
1662 :
1663 1 : return cmocka_run_group_tests(test_cases,
1664 : libspdm_unit_test_group_setup,
1665 : libspdm_unit_test_group_teardown);
1666 : }
1667 :
1668 : #endif /* (LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP) || (LIBSPDM_ENABLE_CAPABILITY_PSK_CAP) */
|
