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