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