Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2022 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : #include "spdm_unit_test.h"
8 : #include "internal/libspdm_requester_lib.h"
9 : #include "internal/libspdm_secured_message_lib.h"
10 :
11 : #if (LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP) || (LIBSPDM_ENABLE_CAPABILITY_PSK_CAP)
12 :
13 : static uint8_t m_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_11;
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 : 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 1 : libspdm_reset_message_a(spdm_context);
711 1 : spdm_context->connection_info.algorithm.base_hash_algo =
712 : m_libspdm_use_hash_algo;
713 1 : spdm_context->connection_info.algorithm.base_asym_algo =
714 : m_libspdm_use_asym_algo;
715 1 : spdm_context->connection_info.algorithm.dhe_named_group =
716 : m_libspdm_use_dhe_algo;
717 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
718 : m_libspdm_use_aead_algo;
719 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
720 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
721 : data_size;
722 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
723 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
724 : data, data_size);
725 : #endif
726 :
727 1 : session_id = 0xFFFFFFFF;
728 1 : session_info = &spdm_context->session_info[0];
729 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
730 1 : libspdm_secured_message_set_session_state(
731 : session_info->secured_message_context,
732 : LIBSPDM_SESSION_STATE_ESTABLISHED);
733 :
734 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
735 1 : assert_int_equal(status, LIBSPDM_STATUS_SEND_FAIL);
736 1 : free(data);
737 1 : }
738 :
739 1 : void libspdm_test_requester_end_session_case2(void **state)
740 : {
741 : libspdm_return_t status;
742 : libspdm_test_context_t *spdm_test_context;
743 : libspdm_context_t *spdm_context;
744 : uint32_t session_id;
745 : void *data;
746 : size_t data_size;
747 : void *hash;
748 : size_t hash_size;
749 : libspdm_session_info_t *session_info;
750 :
751 1 : spdm_test_context = *state;
752 1 : spdm_context = spdm_test_context->spdm_context;
753 1 : spdm_test_context->case_id = 0x2;
754 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
755 : SPDM_VERSION_NUMBER_SHIFT_BIT;
756 1 : spdm_context->connection_info.connection_state =
757 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
758 1 : spdm_context->connection_info.capability.flags |=
759 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
760 1 : spdm_context->connection_info.capability.flags |=
761 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
762 1 : spdm_context->connection_info.capability.flags |=
763 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
764 1 : spdm_context->local_context.capability.flags |=
765 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
766 1 : spdm_context->local_context.capability.flags |=
767 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
768 1 : spdm_context->local_context.capability.flags |=
769 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
770 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
771 : m_libspdm_use_asym_algo, &data,
772 : &data_size, &hash, &hash_size);
773 1 : libspdm_reset_message_a(spdm_context);
774 1 : spdm_context->connection_info.algorithm.base_hash_algo =
775 : m_libspdm_use_hash_algo;
776 1 : spdm_context->connection_info.algorithm.base_asym_algo =
777 : m_libspdm_use_asym_algo;
778 1 : spdm_context->connection_info.algorithm.dhe_named_group =
779 : m_libspdm_use_dhe_algo;
780 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
781 : m_libspdm_use_aead_algo;
782 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
783 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
784 : data_size;
785 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
786 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
787 : data, data_size);
788 : #endif
789 :
790 1 : session_id = 0xFFFFFFFF;
791 1 : session_info = &spdm_context->session_info[0];
792 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
793 1 : libspdm_secured_message_set_session_state(
794 : session_info->secured_message_context,
795 : LIBSPDM_SESSION_STATE_ESTABLISHED);
796 1 : libspdm_set_mem(m_dummy_key_buffer,
797 : ((libspdm_secured_message_context_t
798 1 : *)(session_info->secured_message_context))
799 : ->aead_key_size,
800 : (uint8_t)(0xFF));
801 1 : libspdm_secured_message_set_response_data_encryption_key(
802 : session_info->secured_message_context, m_dummy_key_buffer,
803 : ((libspdm_secured_message_context_t
804 1 : *)(session_info->secured_message_context))
805 : ->aead_key_size);
806 1 : libspdm_set_mem(m_dummy_salt_buffer,
807 : ((libspdm_secured_message_context_t
808 1 : *)(session_info->secured_message_context))
809 : ->aead_iv_size,
810 : (uint8_t)(0xFF));
811 1 : libspdm_secured_message_set_response_data_salt(
812 : session_info->secured_message_context, m_dummy_salt_buffer,
813 : ((libspdm_secured_message_context_t
814 1 : *)(session_info->secured_message_context))
815 : ->aead_iv_size);
816 : ((libspdm_secured_message_context_t *)(session_info
817 1 : ->secured_message_context))
818 1 : ->application_secret.response_data_sequence_number = 0;
819 :
820 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
821 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
822 1 : assert_int_equal(
823 : libspdm_secured_message_get_session_state(
824 : spdm_context->session_info[0].secured_message_context),
825 : LIBSPDM_SESSION_STATE_NOT_STARTED);
826 1 : free(data);
827 1 : }
828 :
829 1 : void libspdm_test_requester_end_session_case3(void **state)
830 : {
831 : libspdm_return_t status;
832 : libspdm_test_context_t *spdm_test_context;
833 : libspdm_context_t *spdm_context;
834 : uint32_t session_id;
835 : void *data;
836 : size_t data_size;
837 : void *hash;
838 : size_t hash_size;
839 : libspdm_session_info_t *session_info;
840 :
841 1 : spdm_test_context = *state;
842 1 : spdm_context = spdm_test_context->spdm_context;
843 1 : spdm_test_context->case_id = 0x3;
844 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
845 : SPDM_VERSION_NUMBER_SHIFT_BIT;
846 1 : spdm_context->connection_info.connection_state =
847 : LIBSPDM_CONNECTION_STATE_NOT_STARTED;
848 1 : spdm_context->connection_info.capability.flags |=
849 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
850 1 : spdm_context->connection_info.capability.flags |=
851 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
852 1 : spdm_context->connection_info.capability.flags |=
853 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
854 1 : spdm_context->local_context.capability.flags |=
855 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
856 1 : spdm_context->local_context.capability.flags |=
857 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
858 1 : spdm_context->local_context.capability.flags |=
859 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
860 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
861 : m_libspdm_use_asym_algo, &data,
862 : &data_size, &hash, &hash_size);
863 1 : libspdm_reset_message_a(spdm_context);
864 1 : spdm_context->connection_info.algorithm.base_hash_algo =
865 : m_libspdm_use_hash_algo;
866 1 : spdm_context->connection_info.algorithm.base_asym_algo =
867 : m_libspdm_use_asym_algo;
868 1 : spdm_context->connection_info.algorithm.dhe_named_group =
869 : m_libspdm_use_dhe_algo;
870 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
871 : m_libspdm_use_aead_algo;
872 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
873 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
874 : data_size;
875 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
876 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
877 : data, data_size);
878 : #endif
879 :
880 1 : session_id = 0xFFFFFFFF;
881 1 : session_info = &spdm_context->session_info[0];
882 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
883 1 : libspdm_secured_message_set_session_state(
884 : session_info->secured_message_context,
885 : LIBSPDM_SESSION_STATE_ESTABLISHED);
886 1 : libspdm_set_mem(m_dummy_key_buffer,
887 : ((libspdm_secured_message_context_t
888 1 : *)(session_info->secured_message_context))
889 : ->aead_key_size,
890 : (uint8_t)(0xFF));
891 1 : libspdm_secured_message_set_response_data_encryption_key(
892 : session_info->secured_message_context, m_dummy_key_buffer,
893 : ((libspdm_secured_message_context_t
894 1 : *)(session_info->secured_message_context))
895 : ->aead_key_size);
896 1 : libspdm_set_mem(m_dummy_salt_buffer,
897 : ((libspdm_secured_message_context_t
898 1 : *)(session_info->secured_message_context))
899 : ->aead_iv_size,
900 : (uint8_t)(0xFF));
901 1 : libspdm_secured_message_set_response_data_salt(
902 : session_info->secured_message_context, m_dummy_salt_buffer,
903 : ((libspdm_secured_message_context_t
904 1 : *)(session_info->secured_message_context))
905 : ->aead_iv_size);
906 : ((libspdm_secured_message_context_t *)(session_info
907 1 : ->secured_message_context))
908 1 : ->application_secret.response_data_sequence_number = 0;
909 :
910 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
911 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_STATE_LOCAL);
912 1 : free(data);
913 1 : }
914 :
915 1 : void libspdm_test_requester_end_session_case4(void **state)
916 : {
917 : libspdm_return_t status;
918 : libspdm_test_context_t *spdm_test_context;
919 : libspdm_context_t *spdm_context;
920 : uint32_t session_id;
921 : void *data;
922 : size_t data_size;
923 : void *hash;
924 : size_t hash_size;
925 : libspdm_session_info_t *session_info;
926 :
927 1 : spdm_test_context = *state;
928 1 : spdm_context = spdm_test_context->spdm_context;
929 1 : spdm_test_context->case_id = 0x4;
930 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
931 : SPDM_VERSION_NUMBER_SHIFT_BIT;
932 1 : spdm_context->connection_info.connection_state =
933 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
934 1 : spdm_context->connection_info.capability.flags |=
935 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
936 1 : spdm_context->connection_info.capability.flags |=
937 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
938 1 : spdm_context->connection_info.capability.flags |=
939 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
940 1 : spdm_context->local_context.capability.flags |=
941 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
942 1 : spdm_context->local_context.capability.flags |=
943 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
944 1 : spdm_context->local_context.capability.flags |=
945 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
946 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
947 : m_libspdm_use_asym_algo, &data,
948 : &data_size, &hash, &hash_size);
949 1 : libspdm_reset_message_a(spdm_context);
950 1 : spdm_context->connection_info.algorithm.base_hash_algo =
951 : m_libspdm_use_hash_algo;
952 1 : spdm_context->connection_info.algorithm.base_asym_algo =
953 : m_libspdm_use_asym_algo;
954 1 : spdm_context->connection_info.algorithm.dhe_named_group =
955 : m_libspdm_use_dhe_algo;
956 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
957 : m_libspdm_use_aead_algo;
958 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
959 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
960 : data_size;
961 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
962 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
963 : data, data_size);
964 : #endif
965 :
966 1 : session_id = 0xFFFFFFFF;
967 1 : session_info = &spdm_context->session_info[0];
968 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
969 1 : libspdm_secured_message_set_session_state(
970 : session_info->secured_message_context,
971 : LIBSPDM_SESSION_STATE_ESTABLISHED);
972 1 : libspdm_set_mem(m_dummy_key_buffer,
973 : ((libspdm_secured_message_context_t
974 1 : *)(session_info->secured_message_context))
975 : ->aead_key_size,
976 : (uint8_t)(0xFF));
977 1 : libspdm_secured_message_set_response_data_encryption_key(
978 : session_info->secured_message_context, m_dummy_key_buffer,
979 : ((libspdm_secured_message_context_t
980 1 : *)(session_info->secured_message_context))
981 : ->aead_key_size);
982 1 : libspdm_set_mem(m_dummy_salt_buffer,
983 : ((libspdm_secured_message_context_t
984 1 : *)(session_info->secured_message_context))
985 : ->aead_iv_size,
986 : (uint8_t)(0xFF));
987 1 : libspdm_secured_message_set_response_data_salt(
988 : session_info->secured_message_context, m_dummy_salt_buffer,
989 : ((libspdm_secured_message_context_t
990 1 : *)(session_info->secured_message_context))
991 : ->aead_iv_size);
992 : ((libspdm_secured_message_context_t *)(session_info
993 1 : ->secured_message_context))
994 1 : ->application_secret.response_data_sequence_number = 0;
995 :
996 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
997 1 : assert_int_equal(status, LIBSPDM_STATUS_ERROR_PEER);
998 1 : free(data);
999 1 : }
1000 :
1001 1 : void libspdm_test_requester_end_session_case5(void **state)
1002 : {
1003 : libspdm_return_t status;
1004 : libspdm_test_context_t *spdm_test_context;
1005 : libspdm_context_t *spdm_context;
1006 : uint32_t session_id;
1007 : void *data;
1008 : size_t data_size;
1009 : void *hash;
1010 : size_t hash_size;
1011 : libspdm_session_info_t *session_info;
1012 :
1013 1 : spdm_test_context = *state;
1014 1 : spdm_context = spdm_test_context->spdm_context;
1015 1 : spdm_test_context->case_id = 0x5;
1016 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1017 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1018 1 : spdm_context->connection_info.connection_state =
1019 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1020 1 : spdm_context->connection_info.capability.flags |=
1021 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1022 1 : spdm_context->connection_info.capability.flags |=
1023 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1024 1 : spdm_context->connection_info.capability.flags |=
1025 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1026 1 : spdm_context->local_context.capability.flags |=
1027 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1028 1 : spdm_context->local_context.capability.flags |=
1029 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1030 1 : spdm_context->local_context.capability.flags |=
1031 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1032 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1033 : m_libspdm_use_asym_algo, &data,
1034 : &data_size, &hash, &hash_size);
1035 1 : libspdm_reset_message_a(spdm_context);
1036 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1037 : m_libspdm_use_hash_algo;
1038 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1039 : m_libspdm_use_asym_algo;
1040 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1041 : m_libspdm_use_dhe_algo;
1042 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1043 : m_libspdm_use_aead_algo;
1044 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1045 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1046 : data_size;
1047 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1048 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1049 : data, data_size);
1050 : #endif
1051 :
1052 1 : session_id = 0xFFFFFFFF;
1053 1 : session_info = &spdm_context->session_info[0];
1054 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1055 1 : libspdm_secured_message_set_session_state(
1056 : session_info->secured_message_context,
1057 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1058 1 : libspdm_set_mem(m_dummy_key_buffer,
1059 : ((libspdm_secured_message_context_t
1060 1 : *)(session_info->secured_message_context))
1061 : ->aead_key_size,
1062 : (uint8_t)(0xFF));
1063 1 : libspdm_secured_message_set_response_data_encryption_key(
1064 : session_info->secured_message_context, m_dummy_key_buffer,
1065 : ((libspdm_secured_message_context_t
1066 1 : *)(session_info->secured_message_context))
1067 : ->aead_key_size);
1068 1 : libspdm_set_mem(m_dummy_salt_buffer,
1069 : ((libspdm_secured_message_context_t
1070 1 : *)(session_info->secured_message_context))
1071 : ->aead_iv_size,
1072 : (uint8_t)(0xFF));
1073 1 : libspdm_secured_message_set_response_data_salt(
1074 : session_info->secured_message_context, m_dummy_salt_buffer,
1075 : ((libspdm_secured_message_context_t
1076 1 : *)(session_info->secured_message_context))
1077 : ->aead_iv_size);
1078 : ((libspdm_secured_message_context_t *)(session_info
1079 1 : ->secured_message_context))
1080 1 : ->application_secret.response_data_sequence_number = 0;
1081 :
1082 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
1083 1 : assert_int_equal(status, LIBSPDM_STATUS_BUSY_PEER);
1084 1 : free(data);
1085 1 : }
1086 :
1087 1 : void libspdm_test_requester_end_session_case6(void **state)
1088 : {
1089 : libspdm_return_t status;
1090 : libspdm_test_context_t *spdm_test_context;
1091 : libspdm_context_t *spdm_context;
1092 : uint32_t session_id;
1093 : void *data;
1094 : size_t data_size;
1095 : void *hash;
1096 : size_t hash_size;
1097 : libspdm_session_info_t *session_info;
1098 :
1099 1 : spdm_test_context = *state;
1100 1 : spdm_context = spdm_test_context->spdm_context;
1101 1 : spdm_test_context->case_id = 0x6;
1102 1 : spdm_context->retry_times = 3;
1103 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1104 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1105 1 : spdm_context->connection_info.connection_state =
1106 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1107 1 : spdm_context->connection_info.capability.flags |=
1108 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1109 1 : spdm_context->connection_info.capability.flags |=
1110 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1111 1 : spdm_context->connection_info.capability.flags |=
1112 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1113 1 : spdm_context->local_context.capability.flags |=
1114 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1115 1 : spdm_context->local_context.capability.flags |=
1116 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1117 1 : spdm_context->local_context.capability.flags |=
1118 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1119 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1120 : m_libspdm_use_asym_algo, &data,
1121 : &data_size, &hash, &hash_size);
1122 1 : libspdm_reset_message_a(spdm_context);
1123 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1124 : m_libspdm_use_hash_algo;
1125 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1126 : m_libspdm_use_asym_algo;
1127 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1128 : m_libspdm_use_dhe_algo;
1129 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1130 : m_libspdm_use_aead_algo;
1131 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1132 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1133 : data_size;
1134 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1135 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1136 : data, data_size);
1137 : #endif
1138 :
1139 1 : session_id = 0xFFFFFFFF;
1140 1 : session_info = &spdm_context->session_info[0];
1141 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1142 1 : libspdm_secured_message_set_session_state(
1143 : session_info->secured_message_context,
1144 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1145 1 : libspdm_set_mem(m_dummy_key_buffer,
1146 : ((libspdm_secured_message_context_t
1147 1 : *)(session_info->secured_message_context))
1148 : ->aead_key_size,
1149 : (uint8_t)(0xFF));
1150 1 : libspdm_secured_message_set_response_data_encryption_key(
1151 : session_info->secured_message_context, m_dummy_key_buffer,
1152 : ((libspdm_secured_message_context_t
1153 1 : *)(session_info->secured_message_context))
1154 : ->aead_key_size);
1155 1 : libspdm_set_mem(m_dummy_salt_buffer,
1156 : ((libspdm_secured_message_context_t
1157 1 : *)(session_info->secured_message_context))
1158 : ->aead_iv_size,
1159 : (uint8_t)(0xFF));
1160 1 : libspdm_secured_message_set_response_data_salt(
1161 : session_info->secured_message_context, m_dummy_salt_buffer,
1162 : ((libspdm_secured_message_context_t
1163 1 : *)(session_info->secured_message_context))
1164 : ->aead_iv_size);
1165 : ((libspdm_secured_message_context_t *)(session_info
1166 1 : ->secured_message_context))
1167 1 : ->application_secret.response_data_sequence_number = 0;
1168 :
1169 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
1170 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1171 1 : assert_int_equal(
1172 : libspdm_secured_message_get_session_state(
1173 : spdm_context->session_info[0].secured_message_context),
1174 : LIBSPDM_SESSION_STATE_NOT_STARTED);
1175 1 : free(data);
1176 1 : }
1177 :
1178 1 : void libspdm_test_requester_end_session_case7(void **state)
1179 : {
1180 : libspdm_return_t status;
1181 : libspdm_test_context_t *spdm_test_context;
1182 : libspdm_context_t *spdm_context;
1183 : uint32_t session_id;
1184 : void *data;
1185 : size_t data_size;
1186 : void *hash;
1187 : size_t hash_size;
1188 : libspdm_session_info_t *session_info;
1189 :
1190 1 : spdm_test_context = *state;
1191 1 : spdm_context = spdm_test_context->spdm_context;
1192 1 : spdm_test_context->case_id = 0x7;
1193 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1194 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1195 1 : spdm_context->connection_info.connection_state =
1196 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1197 1 : spdm_context->connection_info.capability.flags |=
1198 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1199 1 : spdm_context->connection_info.capability.flags |=
1200 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1201 1 : spdm_context->connection_info.capability.flags |=
1202 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1203 1 : spdm_context->local_context.capability.flags |=
1204 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1205 1 : spdm_context->local_context.capability.flags |=
1206 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1207 1 : spdm_context->local_context.capability.flags |=
1208 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1209 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1210 : m_libspdm_use_asym_algo, &data,
1211 : &data_size, &hash, &hash_size);
1212 1 : libspdm_reset_message_a(spdm_context);
1213 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1214 : m_libspdm_use_hash_algo;
1215 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1216 : m_libspdm_use_asym_algo;
1217 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1218 : m_libspdm_use_dhe_algo;
1219 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1220 : m_libspdm_use_aead_algo;
1221 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1222 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1223 : data_size;
1224 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1225 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1226 : data, data_size);
1227 : #endif
1228 :
1229 1 : session_id = 0xFFFFFFFF;
1230 1 : session_info = &spdm_context->session_info[0];
1231 1 : libspdm_session_info_init(spdm_context, session_info, session_id, 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_RESYNCH_PEER);
1261 1 : assert_int_equal(spdm_context->connection_info.connection_state,
1262 : LIBSPDM_CONNECTION_STATE_NOT_STARTED);
1263 1 : free(data);
1264 1 : }
1265 :
1266 1 : void libspdm_test_requester_end_session_case8(void **state)
1267 : {
1268 : libspdm_return_t status;
1269 : libspdm_test_context_t *spdm_test_context;
1270 : libspdm_context_t *spdm_context;
1271 : uint32_t session_id;
1272 : void *data;
1273 : size_t data_size;
1274 : void *hash;
1275 : size_t hash_size;
1276 : libspdm_session_info_t *session_info;
1277 :
1278 1 : spdm_test_context = *state;
1279 1 : spdm_context = spdm_test_context->spdm_context;
1280 1 : spdm_test_context->case_id = 0x8;
1281 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1282 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1283 1 : spdm_context->connection_info.connection_state =
1284 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1285 1 : spdm_context->connection_info.capability.flags |=
1286 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1287 1 : spdm_context->connection_info.capability.flags |=
1288 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1289 1 : spdm_context->connection_info.capability.flags |=
1290 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1291 1 : spdm_context->local_context.capability.flags |=
1292 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1293 1 : spdm_context->local_context.capability.flags |=
1294 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1295 1 : spdm_context->local_context.capability.flags |=
1296 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1297 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1298 : m_libspdm_use_asym_algo, &data,
1299 : &data_size, &hash, &hash_size);
1300 1 : libspdm_reset_message_a(spdm_context);
1301 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1302 : m_libspdm_use_hash_algo;
1303 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1304 : m_libspdm_use_asym_algo;
1305 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1306 : m_libspdm_use_dhe_algo;
1307 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1308 : m_libspdm_use_aead_algo;
1309 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1310 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1311 : data_size;
1312 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1313 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1314 : data, data_size);
1315 : #endif
1316 :
1317 1 : session_id = 0xFFFFFFFF;
1318 1 : session_info = &spdm_context->session_info[0];
1319 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1320 1 : libspdm_secured_message_set_session_state(
1321 : session_info->secured_message_context,
1322 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1323 1 : libspdm_set_mem(m_dummy_key_buffer,
1324 : ((libspdm_secured_message_context_t
1325 1 : *)(session_info->secured_message_context))
1326 : ->aead_key_size,
1327 : (uint8_t)(0xFF));
1328 1 : libspdm_secured_message_set_response_data_encryption_key(
1329 : session_info->secured_message_context, m_dummy_key_buffer,
1330 : ((libspdm_secured_message_context_t
1331 1 : *)(session_info->secured_message_context))
1332 : ->aead_key_size);
1333 1 : libspdm_set_mem(m_dummy_salt_buffer,
1334 : ((libspdm_secured_message_context_t
1335 1 : *)(session_info->secured_message_context))
1336 : ->aead_iv_size,
1337 : (uint8_t)(0xFF));
1338 1 : libspdm_secured_message_set_response_data_salt(
1339 : session_info->secured_message_context, m_dummy_salt_buffer,
1340 : ((libspdm_secured_message_context_t
1341 1 : *)(session_info->secured_message_context))
1342 : ->aead_iv_size);
1343 : ((libspdm_secured_message_context_t *)(session_info
1344 1 : ->secured_message_context))
1345 1 : ->application_secret.response_data_sequence_number = 0;
1346 :
1347 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
1348 1 : assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
1349 1 : free(data);
1350 1 : }
1351 :
1352 1 : void libspdm_test_requester_end_session_case9(void **state)
1353 : {
1354 : libspdm_return_t status;
1355 : libspdm_test_context_t *spdm_test_context;
1356 : libspdm_context_t *spdm_context;
1357 : uint32_t session_id;
1358 : void *data;
1359 : size_t data_size;
1360 : void *hash;
1361 : size_t hash_size;
1362 : libspdm_session_info_t *session_info;
1363 :
1364 1 : spdm_test_context = *state;
1365 1 : spdm_context = spdm_test_context->spdm_context;
1366 1 : spdm_test_context->case_id = 0x9;
1367 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1368 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1369 1 : spdm_context->connection_info.connection_state =
1370 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1371 1 : spdm_context->connection_info.capability.flags |=
1372 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1373 1 : spdm_context->connection_info.capability.flags |=
1374 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1375 1 : spdm_context->connection_info.capability.flags |=
1376 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1377 1 : spdm_context->local_context.capability.flags |=
1378 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1379 1 : spdm_context->local_context.capability.flags |=
1380 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1381 1 : spdm_context->local_context.capability.flags |=
1382 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1383 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1384 : m_libspdm_use_asym_algo, &data,
1385 : &data_size, &hash, &hash_size);
1386 1 : libspdm_reset_message_a(spdm_context);
1387 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1388 : m_libspdm_use_hash_algo;
1389 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1390 : m_libspdm_use_asym_algo;
1391 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1392 : m_libspdm_use_dhe_algo;
1393 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1394 : m_libspdm_use_aead_algo;
1395 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1396 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1397 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1398 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1399 : data, data_size);
1400 : #endif
1401 :
1402 1 : session_id = 0xFFFFFFFF;
1403 1 : session_info = &spdm_context->session_info[0];
1404 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1405 1 : libspdm_secured_message_set_session_state(
1406 : session_info->secured_message_context,
1407 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1408 1 : libspdm_set_mem(m_dummy_key_buffer,
1409 : ((libspdm_secured_message_context_t
1410 1 : *)(session_info->secured_message_context))
1411 : ->aead_key_size,
1412 : (uint8_t)(0xFF));
1413 1 : libspdm_secured_message_set_response_data_encryption_key(
1414 : session_info->secured_message_context, m_dummy_key_buffer,
1415 : ((libspdm_secured_message_context_t
1416 1 : *)(session_info->secured_message_context))
1417 : ->aead_key_size);
1418 1 : libspdm_set_mem(m_dummy_salt_buffer,
1419 : ((libspdm_secured_message_context_t
1420 1 : *)(session_info->secured_message_context))
1421 : ->aead_iv_size,
1422 : (uint8_t)(0xFF));
1423 1 : libspdm_secured_message_set_response_data_salt(
1424 : session_info->secured_message_context, m_dummy_salt_buffer,
1425 : ((libspdm_secured_message_context_t
1426 1 : *)(session_info->secured_message_context))->aead_iv_size);
1427 1 : ((libspdm_secured_message_context_t *)(session_info->secured_message_context))
1428 1 : ->application_secret.response_data_sequence_number = 0;
1429 :
1430 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
1431 : if (LIBSPDM_RESPOND_IF_READY_SUPPORT) {
1432 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1433 1 : assert_int_equal(
1434 : libspdm_secured_message_get_session_state(
1435 : spdm_context->session_info[0].secured_message_context),
1436 : LIBSPDM_SESSION_STATE_NOT_STARTED);
1437 : } else {
1438 : assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
1439 : }
1440 1 : free(data);
1441 1 : }
1442 :
1443 1 : void libspdm_test_requester_end_session_case10(void **state) {
1444 : libspdm_return_t status;
1445 : libspdm_test_context_t *spdm_test_context;
1446 : libspdm_context_t *spdm_context;
1447 : uint32_t session_id;
1448 : void *data;
1449 : size_t data_size;
1450 : void *hash;
1451 : size_t hash_size;
1452 : libspdm_session_info_t *session_info;
1453 : uint16_t error_code;
1454 :
1455 1 : spdm_test_context = *state;
1456 1 : spdm_context = spdm_test_context->spdm_context;
1457 1 : spdm_test_context->case_id = 0xA;
1458 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1459 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1460 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1461 1 : spdm_context->connection_info.capability.flags |=
1462 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1463 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1464 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1465 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1466 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1467 1 : libspdm_read_responder_public_certificate_chain (m_libspdm_use_hash_algo,
1468 : m_libspdm_use_asym_algo,
1469 : &data, &data_size,
1470 : &hash, &hash_size);
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 =
1477 : data_size;
1478 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1479 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1480 : data, data_size);
1481 : #endif
1482 :
1483 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
1484 19 : while(error_code <= 0xff) {
1485 18 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1486 18 : libspdm_reset_message_a(spdm_context);
1487 :
1488 18 : session_id = 0xFFFFFFFF;
1489 18 : session_info = &spdm_context->session_info[0];
1490 18 : libspdm_session_info_init (spdm_context, session_info, session_id, true);
1491 18 : libspdm_secured_message_set_session_state (session_info->secured_message_context,
1492 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1493 18 : libspdm_set_mem (m_dummy_key_buffer,
1494 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->aead_key_size,
1495 : (uint8_t)(0xFF));
1496 18 : libspdm_secured_message_set_response_data_encryption_key (
1497 : session_info->secured_message_context, m_dummy_key_buffer,
1498 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->aead_key_size);
1499 18 : libspdm_set_mem (m_dummy_salt_buffer,
1500 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->aead_iv_size,
1501 : (uint8_t)(0xFF));
1502 18 : libspdm_secured_message_set_response_data_salt (session_info->secured_message_context,
1503 : m_dummy_salt_buffer,
1504 : ((libspdm_secured_message_context_t*)(
1505 : session_info
1506 18 : ->
1507 : secured_message_context))->aead_iv_size);
1508 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->
1509 18 : application_secret.response_data_sequence_number = 0;
1510 :
1511 18 : status = libspdm_send_receive_end_session (spdm_context, session_id, 0);
1512 18 : if(error_code != SPDM_ERROR_CODE_DECRYPT_ERROR) {
1513 17 : LIBSPDM_ASSERT_INT_EQUAL_CASE (status, LIBSPDM_STATUS_ERROR_PEER, error_code);
1514 : } else {
1515 1 : LIBSPDM_ASSERT_INT_EQUAL_CASE (status, LIBSPDM_STATUS_SESSION_MSG_ERROR, error_code);
1516 : }
1517 :
1518 18 : error_code++;
1519 18 : if(error_code == SPDM_ERROR_CODE_BUSY) { /*busy is treated in cases 5 and 6*/
1520 1 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
1521 : }
1522 18 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) { /*skip some reserved error codes (0d to 3e)*/
1523 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
1524 : }
1525 18 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) { /*skip response not ready, request resync, and some reserved codes (44 to fc)*/
1526 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
1527 : }
1528 : }
1529 :
1530 1 : free(data);
1531 1 : }
1532 :
1533 1 : void libspdm_test_requester_end_session_case11(void **state)
1534 : {
1535 : libspdm_return_t status;
1536 : libspdm_test_context_t *spdm_test_context;
1537 : libspdm_context_t *spdm_context;
1538 : uint32_t session_id;
1539 : void *data;
1540 : size_t data_size;
1541 : void *hash;
1542 : size_t hash_size;
1543 : libspdm_session_info_t *session_info;
1544 :
1545 1 : spdm_test_context = *state;
1546 1 : spdm_context = spdm_test_context->spdm_context;
1547 1 : spdm_test_context->case_id = 0xB;
1548 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1549 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1550 1 : spdm_context->connection_info.connection_state =
1551 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1552 1 : spdm_context->connection_info.capability.flags |=
1553 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1554 1 : spdm_context->connection_info.capability.flags |=
1555 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1556 1 : spdm_context->connection_info.capability.flags |=
1557 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1558 1 : spdm_context->local_context.capability.flags |=
1559 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1560 1 : spdm_context->local_context.capability.flags |=
1561 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1562 1 : spdm_context->local_context.capability.flags |=
1563 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1564 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1565 : m_libspdm_use_asym_algo, &data,
1566 : &data_size, &hash, &hash_size);
1567 1 : libspdm_reset_message_a(spdm_context);
1568 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1569 : m_libspdm_use_hash_algo;
1570 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1571 : m_libspdm_use_asym_algo;
1572 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1573 : m_libspdm_use_dhe_algo;
1574 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1575 : m_libspdm_use_aead_algo;
1576 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1577 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1578 : data_size;
1579 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1580 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1581 : data, data_size);
1582 : #endif
1583 :
1584 1 : session_id = 0xFFFFFFFF;
1585 1 : session_info = &spdm_context->session_info[0];
1586 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1587 1 : libspdm_secured_message_set_session_state(
1588 : session_info->secured_message_context,
1589 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1590 1 : libspdm_set_mem(m_dummy_key_buffer,
1591 : ((libspdm_secured_message_context_t
1592 1 : *)(session_info->secured_message_context))
1593 : ->aead_key_size,
1594 : (uint8_t)(0xFF));
1595 1 : libspdm_secured_message_set_response_data_encryption_key(
1596 : session_info->secured_message_context, m_dummy_key_buffer,
1597 : ((libspdm_secured_message_context_t
1598 1 : *)(session_info->secured_message_context))
1599 : ->aead_key_size);
1600 1 : libspdm_set_mem(m_dummy_salt_buffer,
1601 : ((libspdm_secured_message_context_t
1602 1 : *)(session_info->secured_message_context))
1603 : ->aead_iv_size,
1604 : (uint8_t)(0xFF));
1605 1 : libspdm_secured_message_set_response_data_salt(
1606 : session_info->secured_message_context, m_dummy_salt_buffer,
1607 : ((libspdm_secured_message_context_t
1608 1 : *)(session_info->secured_message_context))
1609 : ->aead_iv_size);
1610 : ((libspdm_secured_message_context_t *)(session_info
1611 1 : ->secured_message_context))
1612 1 : ->application_secret.response_data_sequence_number = 0;
1613 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1614 : session_info->session_transcript.message_m.buffer_size =
1615 : spdm_context->transcript.message_m.max_buffer_size;
1616 : spdm_context->transcript.message_b.buffer_size =
1617 : spdm_context->transcript.message_b.max_buffer_size;
1618 : spdm_context->transcript.message_c.buffer_size =
1619 : spdm_context->transcript.message_c.max_buffer_size;
1620 : spdm_context->transcript.message_mut_b.buffer_size =
1621 : spdm_context->transcript.message_mut_b.max_buffer_size;
1622 : spdm_context->transcript.message_mut_c.buffer_size =
1623 : spdm_context->transcript.message_mut_c.max_buffer_size;
1624 : #endif
1625 :
1626 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
1627 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1628 1 : assert_int_equal(
1629 : libspdm_secured_message_get_session_state(
1630 : spdm_context->session_info[0].secured_message_context),
1631 : LIBSPDM_SESSION_STATE_NOT_STARTED);
1632 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1633 : assert_int_equal(session_info->session_transcript.message_m.buffer_size, 0);
1634 : assert_int_equal(spdm_context->transcript.message_b.buffer_size, 0);
1635 : assert_int_equal(spdm_context->transcript.message_c.buffer_size, 0);
1636 : assert_int_equal(spdm_context->transcript.message_mut_b.buffer_size, 0);
1637 : assert_int_equal(spdm_context->transcript.message_mut_c.buffer_size, 0);
1638 : #endif
1639 1 : free(data);
1640 1 : }
1641 :
1642 : /**
1643 : * Test 12: the requester is setup correctly, but receives an ERROR with SPDM_ERROR_CODE_DECRYPT_ERROR.
1644 : * Expected behavior: client returns a Status of INVALID_SESSION_ID and free the session ID.
1645 : **/
1646 1 : void libspdm_test_requester_end_session_case12(void **state)
1647 : {
1648 : libspdm_return_t status;
1649 : libspdm_test_context_t *spdm_test_context;
1650 : libspdm_context_t *spdm_context;
1651 : uint32_t session_id;
1652 : void *data;
1653 : size_t data_size;
1654 : void *hash;
1655 : size_t hash_size;
1656 : libspdm_session_info_t *session_info;
1657 :
1658 1 : spdm_test_context = *state;
1659 1 : spdm_context = spdm_test_context->spdm_context;
1660 1 : spdm_test_context->case_id = 0xC;
1661 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1662 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1663 1 : spdm_context->connection_info.connection_state =
1664 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1665 1 : spdm_context->connection_info.capability.flags |=
1666 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1667 1 : spdm_context->connection_info.capability.flags |=
1668 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1669 1 : spdm_context->connection_info.capability.flags |=
1670 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1671 1 : spdm_context->local_context.capability.flags |=
1672 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1673 1 : spdm_context->local_context.capability.flags |=
1674 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1675 1 : spdm_context->local_context.capability.flags |=
1676 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1677 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1678 : m_libspdm_use_asym_algo, &data,
1679 : &data_size, &hash, &hash_size);
1680 1 : libspdm_reset_message_a(spdm_context);
1681 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1682 : m_libspdm_use_hash_algo;
1683 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1684 : m_libspdm_use_asym_algo;
1685 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1686 : m_libspdm_use_dhe_algo;
1687 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1688 : m_libspdm_use_aead_algo;
1689 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1690 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1691 : data_size;
1692 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1693 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1694 : data, data_size);
1695 : #endif
1696 :
1697 1 : session_id = 0xFFFFFFFF;
1698 1 : session_info = &spdm_context->session_info[0];
1699 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1700 1 : libspdm_secured_message_set_session_state(
1701 : session_info->secured_message_context,
1702 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1703 1 : libspdm_set_mem(m_dummy_key_buffer,
1704 : ((libspdm_secured_message_context_t
1705 1 : *)(session_info->secured_message_context))
1706 : ->aead_key_size,
1707 : (uint8_t)(0xFF));
1708 1 : libspdm_secured_message_set_response_data_encryption_key(
1709 : session_info->secured_message_context, m_dummy_key_buffer,
1710 : ((libspdm_secured_message_context_t
1711 1 : *)(session_info->secured_message_context))
1712 : ->aead_key_size);
1713 1 : libspdm_set_mem(m_dummy_salt_buffer,
1714 : ((libspdm_secured_message_context_t
1715 1 : *)(session_info->secured_message_context))
1716 : ->aead_iv_size,
1717 : (uint8_t)(0xFF));
1718 1 : libspdm_secured_message_set_response_data_salt(
1719 : session_info->secured_message_context, m_dummy_salt_buffer,
1720 : ((libspdm_secured_message_context_t
1721 1 : *)(session_info->secured_message_context))
1722 : ->aead_iv_size);
1723 : ((libspdm_secured_message_context_t *)(session_info
1724 1 : ->secured_message_context))
1725 1 : ->application_secret.response_data_sequence_number = 0;
1726 :
1727 1 : status = libspdm_send_receive_end_session(spdm_context, session_id, 0);
1728 1 : assert_int_equal(status, LIBSPDM_STATUS_SESSION_MSG_ERROR);
1729 1 : assert_int_equal(spdm_context->session_info->session_id, INVALID_SESSION_ID);
1730 :
1731 1 : free(data);
1732 1 : }
1733 :
1734 1 : int libspdm_requester_end_session_test_main(void)
1735 : {
1736 1 : const struct CMUnitTest spdm_requester_end_session_tests[] = {
1737 : /* SendRequest failed*/
1738 : cmocka_unit_test(libspdm_test_requester_end_session_case1),
1739 : /* Successful response*/
1740 : cmocka_unit_test(libspdm_test_requester_end_session_case2),
1741 : /* connection_state check failed*/
1742 : cmocka_unit_test(libspdm_test_requester_end_session_case3),
1743 : /* Error response: SPDM_ERROR_CODE_INVALID_REQUEST*/
1744 : cmocka_unit_test(libspdm_test_requester_end_session_case4),
1745 : /* Always SPDM_ERROR_CODE_BUSY*/
1746 : cmocka_unit_test(libspdm_test_requester_end_session_case5),
1747 : /* SPDM_ERROR_CODE_BUSY + Successful response*/
1748 : cmocka_unit_test(libspdm_test_requester_end_session_case6),
1749 : /* Error response: SPDM_ERROR_CODE_REQUEST_RESYNCH*/
1750 : cmocka_unit_test(libspdm_test_requester_end_session_case7),
1751 : /* Always SPDM_ERROR_CODE_RESPONSE_NOT_READY*/
1752 : cmocka_unit_test(libspdm_test_requester_end_session_case8),
1753 : /* SPDM_ERROR_CODE_RESPONSE_NOT_READY + Successful response*/
1754 : cmocka_unit_test(libspdm_test_requester_end_session_case9),
1755 : /* Unexpected errors*/
1756 : cmocka_unit_test(libspdm_test_requester_end_session_case10),
1757 : /* Buffer reset*/
1758 : cmocka_unit_test(libspdm_test_requester_end_session_case11),
1759 : /* Error response: SPDM_ERROR_CODE_DECRYPT_ERROR*/
1760 : cmocka_unit_test(libspdm_test_requester_end_session_case12),
1761 : };
1762 :
1763 1 : libspdm_test_context_t test_context = {
1764 : LIBSPDM_TEST_CONTEXT_VERSION,
1765 : true,
1766 : libspdm_requester_end_session_test_send_message,
1767 : libspdm_requester_end_session_test_receive_message,
1768 : };
1769 :
1770 1 : libspdm_setup_test_context(&test_context);
1771 :
1772 1 : return cmocka_run_group_tests(spdm_requester_end_session_tests,
1773 : libspdm_unit_test_group_setup,
1774 : libspdm_unit_test_group_teardown);
1775 : }
1776 :
1777 : #endif /* (LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP) || (LIBSPDM_ENABLE_CAPABILITY_PSK_CAP) */
|
