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