Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2026 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : #include "spdm_unit_test.h"
8 : #include "internal/libspdm_responder_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 : spdm_end_session_request_t m_libspdm_end_session_request1 = {
14 : { SPDM_MESSAGE_VERSION_11, SPDM_END_SESSION, 0, 0 }
15 : };
16 : size_t m_libspdm_end_session_request1_size = sizeof(m_libspdm_end_session_request1);
17 :
18 : spdm_end_session_request_t m_libspdm_end_session_request2 = {
19 : { SPDM_MESSAGE_VERSION_11, SPDM_END_SESSION, 0, 0 }
20 : };
21 : size_t m_libspdm_end_session_request2_size = LIBSPDM_MAX_SPDM_MSG_SIZE;
22 :
23 : spdm_end_session_request_t m_libspdm_end_session_request3 = {
24 : { SPDM_MESSAGE_VERSION_11, SPDM_END_SESSION,
25 : SPDM_END_SESSION_REQUEST_ATTRIBUTES_PRESERVE_NEGOTIATED_STATE_CLEAR, 0 }
26 : };
27 : size_t m_libspdm_end_session_request3_size = sizeof(m_libspdm_end_session_request1);
28 :
29 1 : static void rsp_end_session_ack_case1(void **state)
30 : {
31 : libspdm_return_t status;
32 : libspdm_test_context_t *spdm_test_context;
33 : libspdm_context_t *spdm_context;
34 : size_t response_size;
35 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
36 : spdm_end_session_response_t *spdm_response;
37 : void *data1;
38 : size_t data_size1;
39 : libspdm_session_info_t *session_info;
40 : uint32_t session_id;
41 :
42 1 : spdm_test_context = *state;
43 1 : spdm_context = spdm_test_context->spdm_context;
44 1 : spdm_test_context->case_id = 0x1;
45 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
46 : SPDM_VERSION_NUMBER_SHIFT_BIT;
47 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
48 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
49 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
50 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
51 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
52 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
53 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
54 : m_libspdm_use_measurement_hash_algo;
55 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
56 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
57 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
58 : m_libspdm_use_asym_algo, &data1,
59 : &data_size1, NULL, NULL)) {
60 0 : return;
61 : }
62 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
63 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
64 :
65 1 : libspdm_reset_message_a(spdm_context);
66 :
67 1 : session_id = 0xFFFFFFFF;
68 1 : spdm_context->latest_session_id = session_id;
69 1 : spdm_context->last_spdm_request_session_id_valid = true;
70 1 : spdm_context->last_spdm_request_session_id = session_id;
71 1 : session_info = &spdm_context->session_info[0];
72 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
73 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
74 1 : libspdm_secured_message_set_session_state(
75 : session_info->secured_message_context,
76 : LIBSPDM_SESSION_STATE_ESTABLISHED);
77 :
78 1 : response_size = sizeof(response);
79 1 : status = libspdm_get_response_end_session(spdm_context,
80 : m_libspdm_end_session_request1_size,
81 : &m_libspdm_end_session_request1,
82 : &response_size, response);
83 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
84 1 : assert_int_equal(response_size, sizeof(spdm_end_session_response_t));
85 1 : spdm_response = (void *)response;
86 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_END_SESSION_ACK);
87 1 : free(data1);
88 : }
89 :
90 1 : static void rsp_end_session_ack_case2(void **state)
91 : {
92 : libspdm_return_t status;
93 : libspdm_test_context_t *spdm_test_context;
94 : libspdm_context_t *spdm_context;
95 : size_t response_size;
96 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
97 : spdm_end_session_response_t *spdm_response;
98 : void *data1;
99 : size_t data_size1;
100 : libspdm_session_info_t *session_info;
101 : uint32_t session_id;
102 :
103 1 : spdm_test_context = *state;
104 1 : spdm_context = spdm_test_context->spdm_context;
105 1 : spdm_test_context->case_id = 0x2;
106 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
107 : SPDM_VERSION_NUMBER_SHIFT_BIT;
108 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
109 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
110 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
111 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
112 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
113 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
114 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
115 : m_libspdm_use_measurement_hash_algo;
116 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
117 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
118 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
119 : m_libspdm_use_asym_algo, &data1,
120 : &data_size1, NULL, NULL)) {
121 0 : return;
122 : }
123 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
124 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
125 :
126 1 : libspdm_reset_message_a(spdm_context);
127 :
128 1 : session_id = 0xFFFFFFFF;
129 1 : spdm_context->latest_session_id = session_id;
130 1 : spdm_context->last_spdm_request_session_id_valid = true;
131 1 : spdm_context->last_spdm_request_session_id = session_id;
132 1 : session_info = &spdm_context->session_info[0];
133 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
134 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
135 1 : libspdm_secured_message_set_session_state(
136 : session_info->secured_message_context,
137 : LIBSPDM_SESSION_STATE_ESTABLISHED);
138 :
139 1 : response_size = sizeof(response);
140 1 : status = libspdm_get_response_end_session(spdm_context,
141 : m_libspdm_end_session_request2_size,
142 : &m_libspdm_end_session_request2,
143 : &response_size, response);
144 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
145 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
146 1 : spdm_response = (void *)response;
147 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
148 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
149 1 : assert_int_equal(spdm_response->header.param2, 0);
150 1 : free(data1);
151 : }
152 :
153 1 : static void rsp_end_session_ack_case3(void **state)
154 : {
155 : libspdm_return_t status;
156 : libspdm_test_context_t *spdm_test_context;
157 : libspdm_context_t *spdm_context;
158 : size_t response_size;
159 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
160 : spdm_end_session_response_t *spdm_response;
161 : void *data1;
162 : size_t data_size1;
163 : libspdm_session_info_t *session_info;
164 : uint32_t session_id;
165 :
166 1 : spdm_test_context = *state;
167 1 : spdm_context = spdm_test_context->spdm_context;
168 1 : spdm_test_context->case_id = 0x3;
169 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
170 : SPDM_VERSION_NUMBER_SHIFT_BIT;
171 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_BUSY;
172 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
173 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
174 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
175 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
176 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
177 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
178 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
179 : m_libspdm_use_measurement_hash_algo;
180 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
181 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
182 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
183 : m_libspdm_use_asym_algo, &data1,
184 : &data_size1, NULL, NULL)) {
185 0 : return;
186 : }
187 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
188 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
189 :
190 1 : libspdm_reset_message_a(spdm_context);
191 :
192 1 : session_id = 0xFFFFFFFF;
193 1 : spdm_context->latest_session_id = session_id;
194 1 : spdm_context->last_spdm_request_session_id_valid = true;
195 1 : spdm_context->last_spdm_request_session_id = session_id;
196 1 : session_info = &spdm_context->session_info[0];
197 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
198 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
199 1 : libspdm_secured_message_set_session_state(
200 : session_info->secured_message_context,
201 : LIBSPDM_SESSION_STATE_ESTABLISHED);
202 :
203 1 : response_size = sizeof(response);
204 1 : status = libspdm_get_response_end_session(spdm_context,
205 : m_libspdm_end_session_request1_size,
206 : &m_libspdm_end_session_request1,
207 : &response_size, response);
208 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
209 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
210 1 : spdm_response = (void *)response;
211 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
212 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_BUSY);
213 1 : assert_int_equal(spdm_response->header.param2, 0);
214 1 : assert_int_equal(spdm_context->response_state, LIBSPDM_RESPONSE_STATE_BUSY);
215 1 : free(data1);
216 : }
217 :
218 1 : static void rsp_end_session_ack_case4(void **state)
219 : {
220 : libspdm_return_t status;
221 : libspdm_test_context_t *spdm_test_context;
222 : libspdm_context_t *spdm_context;
223 : size_t response_size;
224 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
225 : spdm_end_session_response_t *spdm_response;
226 : void *data1;
227 : size_t data_size1;
228 : libspdm_session_info_t *session_info;
229 : uint32_t session_id;
230 :
231 1 : spdm_test_context = *state;
232 1 : spdm_context = spdm_test_context->spdm_context;
233 1 : spdm_test_context->case_id = 0x4;
234 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
235 : SPDM_VERSION_NUMBER_SHIFT_BIT;
236 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NEED_RESYNC;
237 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
238 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
239 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
240 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
241 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
242 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
243 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
244 : m_libspdm_use_measurement_hash_algo;
245 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
246 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
247 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
248 : m_libspdm_use_asym_algo, &data1,
249 : &data_size1, NULL, NULL)) {
250 0 : return;
251 : }
252 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
253 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
254 :
255 1 : libspdm_reset_message_a(spdm_context);
256 :
257 1 : session_id = 0xFFFFFFFF;
258 1 : spdm_context->latest_session_id = session_id;
259 1 : spdm_context->last_spdm_request_session_id_valid = true;
260 1 : spdm_context->last_spdm_request_session_id = session_id;
261 1 : session_info = &spdm_context->session_info[0];
262 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
263 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
264 1 : libspdm_secured_message_set_session_state(
265 : session_info->secured_message_context,
266 : LIBSPDM_SESSION_STATE_ESTABLISHED);
267 :
268 1 : response_size = sizeof(response);
269 1 : status = libspdm_get_response_end_session(spdm_context,
270 : m_libspdm_end_session_request1_size,
271 : &m_libspdm_end_session_request1,
272 : &response_size, response);
273 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
274 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
275 1 : spdm_response = (void *)response;
276 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
277 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_REQUEST_RESYNCH);
278 1 : assert_int_equal(spdm_response->header.param2, 0);
279 1 : assert_int_equal(spdm_context->response_state, LIBSPDM_RESPONSE_STATE_NEED_RESYNC);
280 1 : free(data1);
281 : }
282 :
283 : #if LIBSPDM_RESPOND_IF_READY_SUPPORT
284 1 : static void rsp_end_session_ack_case5(void **state)
285 : {
286 : libspdm_return_t status;
287 : libspdm_test_context_t *spdm_test_context;
288 : libspdm_context_t *spdm_context;
289 : size_t response_size;
290 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
291 : spdm_end_session_response_t *spdm_response;
292 : void *data1;
293 : size_t data_size1;
294 : libspdm_session_info_t *session_info;
295 : uint32_t session_id;
296 : spdm_error_data_response_not_ready_t *error_data;
297 :
298 1 : spdm_test_context = *state;
299 1 : spdm_context = spdm_test_context->spdm_context;
300 1 : spdm_test_context->case_id = 0x5;
301 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
302 : SPDM_VERSION_NUMBER_SHIFT_BIT;
303 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NOT_READY;
304 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
305 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
306 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
307 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
308 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
309 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
310 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
311 : m_libspdm_use_measurement_hash_algo;
312 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
313 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
314 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
315 : m_libspdm_use_asym_algo, &data1,
316 : &data_size1, NULL, NULL)) {
317 0 : return;
318 : }
319 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
320 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
321 :
322 1 : libspdm_reset_message_a(spdm_context);
323 :
324 1 : session_id = 0xFFFFFFFF;
325 1 : spdm_context->latest_session_id = session_id;
326 1 : spdm_context->last_spdm_request_session_id_valid = true;
327 1 : spdm_context->last_spdm_request_session_id = session_id;
328 1 : session_info = &spdm_context->session_info[0];
329 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
330 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
331 1 : libspdm_secured_message_set_session_state(
332 : session_info->secured_message_context,
333 : LIBSPDM_SESSION_STATE_ESTABLISHED);
334 :
335 1 : response_size = sizeof(response);
336 1 : status = libspdm_get_response_end_session(spdm_context,
337 : m_libspdm_end_session_request1_size,
338 : &m_libspdm_end_session_request1,
339 : &response_size, response);
340 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
341 1 : assert_int_equal(response_size,
342 : sizeof(spdm_error_response_t) +
343 : sizeof(spdm_error_data_response_not_ready_t));
344 1 : spdm_response = (void *)response;
345 1 : error_data = (spdm_error_data_response_not_ready_t *)(spdm_response + 1);
346 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
347 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_RESPONSE_NOT_READY);
348 1 : assert_int_equal(spdm_response->header.param2, 0);
349 1 : assert_int_equal(spdm_context->response_state, LIBSPDM_RESPONSE_STATE_NOT_READY);
350 1 : assert_int_equal(error_data->request_code, SPDM_END_SESSION);
351 1 : free(data1);
352 : }
353 : #endif /* LIBSPDM_RESPOND_IF_READY_SUPPORT */
354 :
355 1 : static void rsp_end_session_ack_case6(void **state)
356 : {
357 : libspdm_return_t status;
358 : libspdm_test_context_t *spdm_test_context;
359 : libspdm_context_t *spdm_context;
360 : size_t response_size;
361 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
362 : spdm_end_session_response_t *spdm_response;
363 : void *data1;
364 : size_t data_size1;
365 : libspdm_session_info_t *session_info;
366 : uint32_t session_id;
367 :
368 1 : spdm_test_context = *state;
369 1 : spdm_context = spdm_test_context->spdm_context;
370 1 : spdm_test_context->case_id = 0x6;
371 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
372 : SPDM_VERSION_NUMBER_SHIFT_BIT;
373 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
374 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NOT_STARTED;
375 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
376 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
377 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
378 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
379 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
380 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
381 : m_libspdm_use_measurement_hash_algo;
382 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
383 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
384 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
385 : m_libspdm_use_asym_algo, &data1,
386 : &data_size1, NULL, NULL)) {
387 0 : return;
388 : }
389 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
390 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
391 :
392 1 : libspdm_reset_message_a(spdm_context);
393 :
394 1 : session_id = 0xFFFFFFFF;
395 1 : spdm_context->latest_session_id = session_id;
396 1 : spdm_context->last_spdm_request_session_id_valid = true;
397 1 : spdm_context->last_spdm_request_session_id = session_id;
398 1 : session_info = &spdm_context->session_info[0];
399 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
400 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
401 1 : libspdm_secured_message_set_session_state(
402 : session_info->secured_message_context,
403 : LIBSPDM_SESSION_STATE_ESTABLISHED);
404 :
405 1 : response_size = sizeof(response);
406 1 : status = libspdm_get_response_end_session(spdm_context,
407 : m_libspdm_end_session_request1_size,
408 : &m_libspdm_end_session_request1,
409 : &response_size, response);
410 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
411 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
412 1 : spdm_response = (void *)response;
413 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
414 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
415 1 : assert_int_equal(spdm_response->header.param2, 0);
416 1 : free(data1);
417 : }
418 :
419 1 : static void rsp_end_session_ack_case7(void **state)
420 : {
421 : libspdm_return_t status;
422 : libspdm_test_context_t *spdm_test_context;
423 : libspdm_context_t *spdm_context;
424 : size_t response_size;
425 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
426 : spdm_end_session_response_t *spdm_response;
427 : void *data1;
428 : size_t data_size1;
429 : libspdm_session_info_t *session_info;
430 : uint32_t session_id;
431 :
432 1 : spdm_test_context = *state;
433 1 : spdm_context = spdm_test_context->spdm_context;
434 1 : spdm_test_context->case_id = 0x7;
435 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
436 : SPDM_VERSION_NUMBER_SHIFT_BIT;
437 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
438 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
439 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
440 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
441 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
442 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
443 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
444 : m_libspdm_use_measurement_hash_algo;
445 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
446 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
447 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
448 : m_libspdm_use_asym_algo, &data1,
449 : &data_size1, NULL, NULL)) {
450 0 : return;
451 : }
452 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
453 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
454 :
455 1 : libspdm_reset_message_a(spdm_context);
456 :
457 1 : session_id = 0xFFFFFFFF;
458 1 : spdm_context->latest_session_id = session_id;
459 1 : spdm_context->last_spdm_request_session_id_valid = true;
460 1 : spdm_context->last_spdm_request_session_id = session_id;
461 1 : session_info = &spdm_context->session_info[0];
462 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
463 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
464 1 : libspdm_secured_message_set_session_state(
465 : session_info->secured_message_context,
466 : LIBSPDM_SESSION_STATE_ESTABLISHED);
467 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
468 : session_info->session_transcript.message_m.buffer_size =
469 : session_info->session_transcript.message_m.max_buffer_size;
470 : spdm_context->transcript.message_b.buffer_size =
471 : spdm_context->transcript.message_b.max_buffer_size;
472 : spdm_context->transcript.message_c.buffer_size =
473 : spdm_context->transcript.message_c.max_buffer_size;
474 : spdm_context->transcript.message_mut_b.buffer_size =
475 : spdm_context->transcript.message_mut_b.max_buffer_size;
476 : spdm_context->transcript.message_mut_c.buffer_size =
477 : spdm_context->transcript.message_mut_c.max_buffer_size;
478 : #endif
479 :
480 1 : response_size = sizeof(response);
481 1 : status = libspdm_get_response_end_session(spdm_context,
482 : m_libspdm_end_session_request1_size,
483 : &m_libspdm_end_session_request1,
484 : &response_size, response);
485 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
486 1 : assert_int_equal(response_size, sizeof(spdm_end_session_response_t));
487 1 : spdm_response = (void *)response;
488 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_END_SESSION_ACK);
489 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
490 : assert_int_equal(session_info->session_transcript.message_m.buffer_size, 0);
491 : assert_int_equal(spdm_context->transcript.message_b.buffer_size, 0);
492 : assert_int_equal(spdm_context->transcript.message_c.buffer_size, 0);
493 : assert_int_equal(spdm_context->transcript.message_mut_b.buffer_size, 0);
494 : assert_int_equal(spdm_context->transcript.message_mut_c.buffer_size, 0);
495 : #endif
496 :
497 1 : free(data1);
498 : }
499 :
500 1 : static void rsp_end_session_ack_case8(void **state)
501 : {
502 : libspdm_return_t status;
503 : libspdm_test_context_t *spdm_test_context;
504 : libspdm_context_t *spdm_context;
505 : size_t response_size;
506 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
507 : spdm_end_session_response_t *spdm_response;
508 : void *data1;
509 : size_t data_size1;
510 : libspdm_session_info_t *session_info;
511 : uint32_t session_id;
512 :
513 1 : spdm_test_context = *state;
514 1 : spdm_context = spdm_test_context->spdm_context;
515 1 : spdm_test_context->case_id = 0x1;
516 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
517 : SPDM_VERSION_NUMBER_SHIFT_BIT;
518 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
519 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
520 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
521 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
522 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
523 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
524 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
525 : m_libspdm_use_measurement_hash_algo;
526 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
527 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
528 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
529 : m_libspdm_use_asym_algo, &data1,
530 : &data_size1, NULL, NULL)) {
531 0 : return;
532 : }
533 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
534 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
535 :
536 1 : libspdm_reset_message_a(spdm_context);
537 :
538 1 : session_id = 0xFFFFFFFF;
539 1 : spdm_context->latest_session_id = session_id;
540 1 : spdm_context->last_spdm_request_session_id_valid = true;
541 1 : spdm_context->last_spdm_request_session_id = session_id;
542 1 : session_info = &spdm_context->session_info[0];
543 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
544 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
545 1 : libspdm_secured_message_set_session_state(
546 : session_info->secured_message_context,
547 : LIBSPDM_SESSION_STATE_ESTABLISHED);
548 :
549 1 : response_size = sizeof(response);
550 1 : status = libspdm_get_response_end_session(spdm_context,
551 : m_libspdm_end_session_request3_size,
552 : &m_libspdm_end_session_request3,
553 : &response_size, response);
554 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
555 1 : assert_int_equal(response_size, sizeof(spdm_end_session_response_t));
556 1 : spdm_response = (void *)response;
557 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_END_SESSION_ACK);
558 1 : assert_int_not_equal(spdm_context->connection_info.end_session_attributes &
559 : SPDM_END_SESSION_REQUEST_ATTRIBUTES_PRESERVE_NEGOTIATED_STATE_CLEAR, 0);
560 1 : free(data1);
561 : }
562 :
563 1 : int libspdm_rsp_end_session_ack_test(void)
564 : {
565 1 : const struct CMUnitTest test_cases[] = {
566 : /* Success Case*/
567 : cmocka_unit_test(rsp_end_session_ack_case1),
568 : /* Bad request size*/
569 : cmocka_unit_test(rsp_end_session_ack_case2),
570 : /* response_state: SPDM_RESPONSE_STATE_BUSY*/
571 : cmocka_unit_test(rsp_end_session_ack_case3),
572 : /* response_state: LIBSPDM_RESPONSE_STATE_NEED_RESYNC*/
573 : cmocka_unit_test(rsp_end_session_ack_case4),
574 : #if LIBSPDM_RESPOND_IF_READY_SUPPORT
575 : /* response_state: LIBSPDM_RESPONSE_STATE_NOT_READY*/
576 : cmocka_unit_test(rsp_end_session_ack_case5),
577 : #endif /* LIBSPDM_RESPOND_IF_READY_SUPPORT */
578 : /* connection_state Check*/
579 : cmocka_unit_test(rsp_end_session_ack_case6),
580 : /* Buffer reset*/
581 : cmocka_unit_test(rsp_end_session_ack_case7),
582 : /* Success Case with end_session_attribute set */
583 : cmocka_unit_test(rsp_end_session_ack_case8),
584 : };
585 :
586 1 : libspdm_test_context_t test_context = {
587 : LIBSPDM_TEST_CONTEXT_VERSION,
588 : false,
589 : };
590 :
591 1 : libspdm_setup_test_context(&test_context);
592 :
593 1 : return cmocka_run_group_tests(test_cases,
594 : libspdm_unit_test_group_setup,
595 : libspdm_unit_test_group_teardown);
596 : }
597 :
598 : #endif /* (LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP) || (LIBSPDM_ENABLE_CAPABILITY_PSK_CAP) */
|
