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