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