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