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