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_requester_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 : static uint8_t m_libspdm_dummy_key_buffer[LIBSPDM_MAX_AEAD_KEY_SIZE];
14 : static uint8_t m_libspdm_dummy_salt_buffer[LIBSPDM_MAX_AEAD_IV_SIZE];
15 :
16 29 : void libspdm_secured_message_set_response_data_encryption_key(
17 : void *spdm_secured_message_context, const void *key, size_t key_size)
18 : {
19 : libspdm_secured_message_context_t *secured_message_context;
20 :
21 29 : secured_message_context = spdm_secured_message_context;
22 29 : LIBSPDM_ASSERT(key_size == secured_message_context->aead_key_size);
23 29 : libspdm_copy_mem(secured_message_context->application_secret.response_data_encryption_key,
24 : sizeof(secured_message_context->application_secret.response_data_encryption_key),
25 : key, secured_message_context->aead_key_size);
26 29 : }
27 :
28 29 : void libspdm_secured_message_set_response_data_salt(
29 : void *spdm_secured_message_context, const void *salt,
30 : size_t salt_size)
31 : {
32 : libspdm_secured_message_context_t *secured_message_context;
33 :
34 29 : secured_message_context = spdm_secured_message_context;
35 29 : LIBSPDM_ASSERT(salt_size == secured_message_context->aead_iv_size);
36 29 : libspdm_copy_mem(secured_message_context->application_secret.response_data_salt,
37 : sizeof(secured_message_context->application_secret.response_data_salt),
38 : salt, secured_message_context->aead_iv_size);
39 29 : }
40 :
41 31 : libspdm_return_t libspdm_requester_heartbeat_test_send_message(void *spdm_context,
42 : size_t request_size,
43 : const void *request,
44 : uint64_t timeout)
45 : {
46 : libspdm_test_context_t *spdm_test_context;
47 :
48 31 : spdm_test_context = libspdm_get_test_context();
49 31 : switch (spdm_test_context->case_id) {
50 1 : case 0x1:
51 1 : return LIBSPDM_STATUS_SEND_FAIL;
52 1 : case 0x2:
53 1 : return LIBSPDM_STATUS_SUCCESS;
54 0 : case 0x3:
55 0 : return LIBSPDM_STATUS_SUCCESS;
56 1 : case 0x4:
57 1 : return LIBSPDM_STATUS_SUCCESS;
58 1 : case 0x5:
59 1 : return LIBSPDM_STATUS_SUCCESS;
60 2 : case 0x6:
61 2 : return LIBSPDM_STATUS_SUCCESS;
62 1 : case 0x7:
63 1 : return LIBSPDM_STATUS_SUCCESS;
64 2 : case 0x8:
65 2 : return LIBSPDM_STATUS_SUCCESS;
66 2 : case 0x9:
67 2 : return LIBSPDM_STATUS_SUCCESS;
68 18 : case 0xA:
69 18 : return LIBSPDM_STATUS_SUCCESS;
70 1 : case 0xB:
71 1 : return LIBSPDM_STATUS_SUCCESS;
72 1 : case 0xC:
73 1 : return LIBSPDM_STATUS_SUCCESS;
74 0 : default:
75 0 : return LIBSPDM_STATUS_SEND_FAIL;
76 : }
77 : }
78 :
79 30 : libspdm_return_t libspdm_requester_heartbeat_test_receive_message(
80 : void *spdm_context, size_t *response_size,
81 : void **response, uint64_t timeout)
82 : {
83 : libspdm_test_context_t *spdm_test_context;
84 :
85 30 : spdm_test_context = libspdm_get_test_context();
86 30 : switch (spdm_test_context->case_id) {
87 0 : case 0x1:
88 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
89 :
90 1 : case 0x2: {
91 : spdm_heartbeat_response_t *spdm_response;
92 : size_t spdm_response_size;
93 : size_t transport_header_size;
94 : uint32_t session_id;
95 : libspdm_session_info_t *session_info;
96 : uint8_t *scratch_buffer;
97 : size_t scratch_buffer_size;
98 :
99 1 : session_id = 0xFFFFFFFF;
100 1 : spdm_response_size = sizeof(spdm_heartbeat_response_t);
101 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
102 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
103 :
104 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
105 1 : spdm_response->header.request_response_code =
106 : SPDM_HEARTBEAT_ACK;
107 1 : spdm_response->header.param1 = 0;
108 1 : spdm_response->header.param2 = 0;
109 :
110 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
111 : * transport_message is always in sender buffer. */
112 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
113 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
114 : scratch_buffer_size - transport_header_size,
115 : spdm_response, spdm_response_size);
116 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
117 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
118 : false, false, spdm_response_size,
119 : spdm_response, response_size,
120 : response);
121 1 : session_info = libspdm_get_session_info_via_session_id(
122 : spdm_context, session_id);
123 1 : if (session_info == NULL) {
124 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
125 : }
126 : /* WALKAROUND: If just use single context to encode message and then decode message */
127 : ((libspdm_secured_message_context_t
128 1 : *)(session_info->secured_message_context))
129 1 : ->application_secret.response_data_sequence_number--;
130 : }
131 1 : return LIBSPDM_STATUS_SUCCESS;
132 :
133 0 : case 0x3: {
134 : spdm_heartbeat_response_t *spdm_response;
135 : size_t spdm_response_size;
136 : size_t transport_header_size;
137 : uint32_t session_id;
138 : libspdm_session_info_t *session_info;
139 : uint8_t *scratch_buffer;
140 : size_t scratch_buffer_size;
141 :
142 0 : session_id = 0xFFFFFFFF;
143 0 : spdm_response_size = sizeof(spdm_heartbeat_response_t);
144 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
145 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
146 :
147 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
148 0 : spdm_response->header.request_response_code =
149 : SPDM_HEARTBEAT_ACK;
150 0 : spdm_response->header.param1 = 0;
151 0 : spdm_response->header.param2 = 0;
152 :
153 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
154 : * transport_message is always in sender buffer. */
155 0 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
156 0 : libspdm_copy_mem (scratch_buffer + transport_header_size,
157 : scratch_buffer_size - transport_header_size,
158 : spdm_response, spdm_response_size);
159 0 : spdm_response = (void *)(scratch_buffer + transport_header_size);
160 0 : libspdm_transport_test_encode_message(spdm_context, &session_id,
161 : false, false, spdm_response_size,
162 : spdm_response, response_size,
163 : response);
164 0 : session_info = libspdm_get_session_info_via_session_id(
165 : spdm_context, session_id);
166 0 : if (session_info == NULL) {
167 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
168 : }
169 : ((libspdm_secured_message_context_t
170 0 : *)(session_info->secured_message_context))
171 0 : ->application_secret.response_data_sequence_number--;
172 : }
173 0 : return LIBSPDM_STATUS_SUCCESS;
174 :
175 1 : case 0x4: {
176 : spdm_error_response_t *spdm_response;
177 : size_t spdm_response_size;
178 : size_t transport_header_size;
179 : uint32_t session_id;
180 : libspdm_session_info_t *session_info;
181 : uint8_t *scratch_buffer;
182 : size_t scratch_buffer_size;
183 :
184 1 : spdm_response_size = sizeof(spdm_error_response_t);
185 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
186 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
187 :
188 1 : session_id = 0xFFFFFFFF;
189 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
190 1 : spdm_response->header.request_response_code = SPDM_ERROR;
191 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_INVALID_REQUEST;
192 1 : spdm_response->header.param2 = 0;
193 :
194 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
195 : * transport_message is always in sender buffer. */
196 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
197 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
198 : scratch_buffer_size - transport_header_size,
199 : spdm_response, spdm_response_size);
200 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
201 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
202 : false, false,
203 : spdm_response_size,
204 : spdm_response,
205 : response_size, response);
206 1 : session_info = libspdm_get_session_info_via_session_id(
207 : spdm_context, session_id);
208 1 : if (session_info == NULL) {
209 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
210 : }
211 : ((libspdm_secured_message_context_t
212 1 : *)(session_info->secured_message_context))
213 1 : ->application_secret.response_data_sequence_number--;
214 : }
215 1 : return LIBSPDM_STATUS_SUCCESS;
216 :
217 1 : case 0x5: {
218 : spdm_error_response_t *spdm_response;
219 : size_t spdm_response_size;
220 : size_t transport_header_size;
221 : uint32_t session_id;
222 : libspdm_session_info_t *session_info;
223 : uint8_t *scratch_buffer;
224 : size_t scratch_buffer_size;
225 :
226 1 : spdm_response_size = sizeof(spdm_error_response_t);
227 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
228 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
229 :
230 1 : session_id = 0xFFFFFFFF;
231 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
232 1 : spdm_response->header.request_response_code = SPDM_ERROR;
233 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
234 1 : spdm_response->header.param2 = 0;
235 :
236 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
237 : * transport_message is always in sender buffer. */
238 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
239 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
240 : scratch_buffer_size - transport_header_size,
241 : spdm_response, spdm_response_size);
242 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
243 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
244 : false, false,
245 : spdm_response_size,
246 : spdm_response,
247 : response_size, response);
248 1 : session_info = libspdm_get_session_info_via_session_id(
249 : spdm_context, session_id);
250 1 : if (session_info == NULL) {
251 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
252 : }
253 : ((libspdm_secured_message_context_t
254 1 : *)(session_info->secured_message_context))
255 1 : ->application_secret.response_data_sequence_number--;
256 : }
257 1 : return LIBSPDM_STATUS_SUCCESS;
258 :
259 2 : case 0x6: {
260 : static size_t sub_index1 = 0;
261 2 : if (sub_index1 == 0) {
262 : spdm_error_response_t *spdm_response;
263 : size_t spdm_response_size;
264 : size_t transport_header_size;
265 : uint32_t session_id;
266 : libspdm_session_info_t *session_info;
267 : uint8_t *scratch_buffer;
268 : size_t scratch_buffer_size;
269 :
270 1 : spdm_response_size = sizeof(spdm_error_response_t);
271 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
272 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
273 :
274 1 : session_id = 0xFFFFFFFF;
275 1 : spdm_response->header.spdm_version =
276 : SPDM_MESSAGE_VERSION_11;
277 1 : spdm_response->header.request_response_code = SPDM_ERROR;
278 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
279 1 : spdm_response->header.param2 = 0;
280 :
281 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
282 : * transport_message is always in sender buffer. */
283 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
284 : &scratch_buffer_size);
285 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
286 : scratch_buffer_size - transport_header_size,
287 : spdm_response, spdm_response_size);
288 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
289 1 : libspdm_transport_test_encode_message(
290 : spdm_context, &session_id, false, false,
291 : spdm_response_size, spdm_response,
292 : response_size, response);
293 1 : sub_index1++;
294 1 : session_info = libspdm_get_session_info_via_session_id(
295 : spdm_context, session_id);
296 1 : if (session_info == NULL) {
297 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
298 : }
299 : ((libspdm_secured_message_context_t
300 1 : *)(session_info->secured_message_context))
301 : ->application_secret
302 1 : .response_data_sequence_number--;
303 1 : } else if (sub_index1 == 1) {
304 : spdm_heartbeat_response_t *spdm_response;
305 : size_t spdm_response_size;
306 : size_t transport_header_size;
307 : uint32_t session_id;
308 : libspdm_session_info_t *session_info;
309 : uint8_t *scratch_buffer;
310 : size_t scratch_buffer_size;
311 :
312 1 : session_id = 0xFFFFFFFF;
313 1 : spdm_response_size = sizeof(spdm_heartbeat_response_t);
314 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
315 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
316 :
317 1 : spdm_response->header.spdm_version =
318 : SPDM_MESSAGE_VERSION_11;
319 1 : spdm_response->header.request_response_code =
320 : SPDM_HEARTBEAT_ACK;
321 1 : spdm_response->header.param1 = 0;
322 1 : spdm_response->header.param2 = 0;
323 :
324 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
325 : * transport_message is always in sender buffer. */
326 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
327 : &scratch_buffer_size);
328 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
329 : scratch_buffer_size - transport_header_size,
330 : spdm_response, spdm_response_size);
331 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
332 1 : libspdm_transport_test_encode_message(
333 : spdm_context, &session_id, false, false,
334 : spdm_response_size, spdm_response, response_size,
335 : response);
336 1 : session_info = libspdm_get_session_info_via_session_id(
337 : spdm_context, session_id);
338 1 : if (session_info == NULL) {
339 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
340 : }
341 : ((libspdm_secured_message_context_t
342 1 : *)(session_info->secured_message_context))
343 : ->application_secret
344 1 : .response_data_sequence_number--;
345 : }
346 : }
347 2 : return LIBSPDM_STATUS_SUCCESS;
348 :
349 1 : case 0x7: {
350 : spdm_error_response_t *spdm_response;
351 : size_t spdm_response_size;
352 : size_t transport_header_size;
353 : uint32_t session_id;
354 : libspdm_session_info_t *session_info;
355 : uint8_t *scratch_buffer;
356 : size_t scratch_buffer_size;
357 :
358 1 : spdm_response_size = sizeof(spdm_error_response_t);
359 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
360 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
361 :
362 1 : session_id = 0xFFFFFFFF;
363 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
364 1 : spdm_response->header.request_response_code = SPDM_ERROR;
365 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_REQUEST_RESYNCH;
366 1 : spdm_response->header.param2 = 0;
367 :
368 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
369 : * transport_message is always in sender buffer. */
370 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
371 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
372 : scratch_buffer_size - transport_header_size,
373 : spdm_response, spdm_response_size);
374 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
375 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
376 : false, false,
377 : spdm_response_size,
378 : spdm_response,
379 : response_size, response);
380 1 : session_info = libspdm_get_session_info_via_session_id(
381 : spdm_context, session_id);
382 1 : if (session_info == NULL) {
383 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
384 : }
385 : ((libspdm_secured_message_context_t
386 1 : *)(session_info->secured_message_context))
387 1 : ->application_secret.response_data_sequence_number--;
388 : }
389 1 : return LIBSPDM_STATUS_SUCCESS;
390 :
391 2 : case 0x8: {
392 : spdm_error_response_data_response_not_ready_t *spdm_response;
393 : size_t spdm_response_size;
394 : size_t transport_header_size;
395 : uint32_t session_id;
396 : libspdm_session_info_t *session_info;
397 : uint8_t *scratch_buffer;
398 : size_t scratch_buffer_size;
399 :
400 2 : spdm_response_size = sizeof(spdm_error_response_data_response_not_ready_t);
401 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
402 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
403 :
404 2 : session_id = 0xFFFFFFFF;
405 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
406 2 : spdm_response->header.request_response_code = SPDM_ERROR;
407 2 : spdm_response->header.param1 =
408 : SPDM_ERROR_CODE_RESPONSE_NOT_READY;
409 2 : spdm_response->header.param2 = 0;
410 2 : spdm_response->extend_error_data.rd_exponent = 1;
411 2 : spdm_response->extend_error_data.rd_tm = 2;
412 2 : spdm_response->extend_error_data.request_code = SPDM_HEARTBEAT;
413 2 : spdm_response->extend_error_data.token = 0;
414 :
415 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
416 : * transport_message is always in sender buffer. */
417 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
418 2 : libspdm_copy_mem (scratch_buffer + transport_header_size,
419 : scratch_buffer_size - transport_header_size,
420 : spdm_response, spdm_response_size);
421 2 : spdm_response = (void *)(scratch_buffer + transport_header_size);
422 2 : libspdm_transport_test_encode_message(spdm_context, &session_id,
423 : false, false,
424 : spdm_response_size,
425 : spdm_response,
426 : response_size, response);
427 2 : session_info = libspdm_get_session_info_via_session_id(
428 : spdm_context, session_id);
429 2 : if (session_info == NULL) {
430 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
431 : }
432 : ((libspdm_secured_message_context_t
433 2 : *)(session_info->secured_message_context))
434 2 : ->application_secret.response_data_sequence_number--;
435 : }
436 2 : return LIBSPDM_STATUS_SUCCESS;
437 :
438 2 : case 0x9: {
439 : static size_t sub_index2 = 0;
440 2 : if (sub_index2 == 0) {
441 : spdm_error_response_data_response_not_ready_t
442 : *spdm_response;
443 : size_t spdm_response_size;
444 : size_t transport_header_size;
445 : uint32_t session_id;
446 : libspdm_session_info_t *session_info;
447 : uint8_t *scratch_buffer;
448 : size_t scratch_buffer_size;
449 :
450 1 : spdm_response_size = sizeof(spdm_error_response_data_response_not_ready_t);
451 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
452 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
453 :
454 1 : session_id = 0xFFFFFFFF;
455 1 : spdm_response->header.spdm_version =
456 : SPDM_MESSAGE_VERSION_11;
457 1 : spdm_response->header.request_response_code = SPDM_ERROR;
458 1 : spdm_response->header.param1 =
459 : SPDM_ERROR_CODE_RESPONSE_NOT_READY;
460 1 : spdm_response->header.param2 = 0;
461 1 : spdm_response->extend_error_data.rd_exponent = 1;
462 1 : spdm_response->extend_error_data.rd_tm = 2;
463 1 : spdm_response->extend_error_data.request_code =
464 : SPDM_HEARTBEAT;
465 1 : spdm_response->extend_error_data.token = 1;
466 :
467 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
468 : * transport_message is always in sender buffer. */
469 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
470 : &scratch_buffer_size);
471 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
472 : scratch_buffer_size - transport_header_size,
473 : spdm_response, spdm_response_size);
474 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
475 1 : libspdm_transport_test_encode_message(
476 : spdm_context, &session_id, false, false,
477 : spdm_response_size, spdm_response,
478 : response_size, response);
479 1 : sub_index2++;
480 1 : session_info = libspdm_get_session_info_via_session_id(
481 : spdm_context, session_id);
482 1 : if (session_info == NULL) {
483 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
484 : }
485 : ((libspdm_secured_message_context_t
486 1 : *)(session_info->secured_message_context))
487 : ->application_secret
488 1 : .response_data_sequence_number--;
489 1 : } else if (sub_index2 == 1) {
490 : spdm_heartbeat_response_t *spdm_response;
491 : size_t spdm_response_size;
492 : size_t transport_header_size;
493 : uint32_t session_id;
494 : libspdm_session_info_t *session_info;
495 : uint8_t *scratch_buffer;
496 : size_t scratch_buffer_size;
497 :
498 1 : session_id = 0xFFFFFFFF;
499 1 : spdm_response_size = sizeof(spdm_heartbeat_response_t);
500 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
501 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
502 :
503 1 : spdm_response->header.spdm_version =
504 : SPDM_MESSAGE_VERSION_11;
505 1 : spdm_response->header.request_response_code =
506 : SPDM_HEARTBEAT_ACK;
507 1 : spdm_response->header.param1 = 0;
508 1 : spdm_response->header.param2 = 0;
509 :
510 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
511 : * transport_message is always in sender buffer. */
512 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
513 : &scratch_buffer_size);
514 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
515 : scratch_buffer_size - transport_header_size,
516 : spdm_response, spdm_response_size);
517 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
518 1 : libspdm_transport_test_encode_message(
519 : spdm_context, &session_id, false, false,
520 : spdm_response_size, spdm_response, response_size,
521 : response);
522 1 : session_info = libspdm_get_session_info_via_session_id(
523 : spdm_context, session_id);
524 1 : if (session_info == NULL) {
525 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
526 : }
527 : ((libspdm_secured_message_context_t
528 1 : *)(session_info->secured_message_context))
529 : ->application_secret
530 1 : .response_data_sequence_number--;
531 : }
532 : }
533 2 : return LIBSPDM_STATUS_SUCCESS;
534 :
535 18 : case 0xA:
536 : {
537 : static uint16_t error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
538 :
539 : spdm_error_response_t *spdm_response;
540 : size_t spdm_response_size;
541 : size_t transport_header_size;
542 : uint32_t session_id;
543 : libspdm_session_info_t *session_info;
544 : uint8_t *scratch_buffer;
545 : size_t scratch_buffer_size;
546 :
547 18 : session_id = 0xFFFFFFFF;
548 :
549 18 : spdm_response_size = sizeof(spdm_error_response_t);
550 18 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
551 18 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
552 :
553 18 : if(error_code <= 0xff) {
554 18 : libspdm_zero_mem (spdm_response, spdm_response_size);
555 18 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
556 18 : spdm_response->header.request_response_code = SPDM_ERROR;
557 18 : spdm_response->header.param1 = (uint8_t) error_code;
558 18 : spdm_response->header.param2 = 0;
559 :
560 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
561 : * transport_message is always in sender buffer. */
562 18 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
563 : &scratch_buffer_size);
564 18 : libspdm_copy_mem (scratch_buffer + transport_header_size,
565 : scratch_buffer_size - transport_header_size,
566 : spdm_response, spdm_response_size);
567 18 : spdm_response = (void *)(scratch_buffer + transport_header_size);
568 18 : libspdm_transport_test_encode_message (spdm_context, &session_id, false, false,
569 : spdm_response_size, spdm_response,
570 : response_size, response);
571 18 : session_info = libspdm_get_session_info_via_session_id (spdm_context, session_id);
572 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->
573 18 : application_secret.response_data_sequence_number--;
574 : }
575 :
576 18 : error_code++;
577 18 : if(error_code == SPDM_ERROR_CODE_BUSY) { /*busy is treated in cases 5 and 6*/
578 1 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
579 : }
580 18 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) { /*skip some reserved error codes (0d to 3e)*/
581 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
582 : }
583 18 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) { /*skip response not ready, request resync, and some reserved codes (44 to fc)*/
584 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
585 : }
586 : }
587 18 : return LIBSPDM_STATUS_SUCCESS;
588 1 : case 0xB: {
589 : spdm_heartbeat_response_t *spdm_response;
590 : size_t spdm_response_size;
591 : size_t transport_header_size;
592 : uint32_t session_id;
593 : libspdm_session_info_t *session_info;
594 : uint8_t *scratch_buffer;
595 : size_t scratch_buffer_size;
596 :
597 1 : session_id = 0xFFFFFFFF;
598 1 : spdm_response_size = sizeof(spdm_heartbeat_response_t);
599 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
600 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
601 :
602 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
603 1 : spdm_response->header.request_response_code =
604 : SPDM_HEARTBEAT_ACK;
605 1 : spdm_response->header.param1 = 0;
606 1 : spdm_response->header.param2 = 0;
607 :
608 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
609 : * transport_message is always in sender buffer. */
610 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
611 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
612 : scratch_buffer_size - transport_header_size,
613 : spdm_response, spdm_response_size);
614 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
615 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
616 : false, false, spdm_response_size,
617 : spdm_response, response_size,
618 : response);
619 1 : session_info = libspdm_get_session_info_via_session_id(
620 : spdm_context, session_id);
621 1 : if (session_info == NULL) {
622 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
623 : }
624 : /* WALKAROUND: If just use single context to encode message and then decode message */
625 : ((libspdm_secured_message_context_t
626 1 : *)(session_info->secured_message_context))
627 1 : ->application_secret.response_data_sequence_number--;
628 : }
629 1 : return LIBSPDM_STATUS_SUCCESS;
630 :
631 1 : case 0xC: {
632 : spdm_error_response_t *spdm_response;
633 : size_t spdm_response_size;
634 : size_t transport_header_size;
635 : uint32_t session_id;
636 : libspdm_session_info_t *session_info;
637 : uint8_t *scratch_buffer;
638 : size_t scratch_buffer_size;
639 :
640 1 : spdm_response_size = sizeof(spdm_error_response_t);
641 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
642 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
643 :
644 1 : session_id = 0xFFFFFFFF;
645 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
646 1 : spdm_response->header.request_response_code = SPDM_ERROR;
647 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_DECRYPT_ERROR;
648 1 : spdm_response->header.param2 = 0;
649 :
650 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
651 : * transport_message is always in sender buffer. */
652 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
653 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
654 : scratch_buffer_size - transport_header_size,
655 : spdm_response, spdm_response_size);
656 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
657 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
658 : false, false,
659 : spdm_response_size,
660 : spdm_response,
661 : response_size, response);
662 1 : session_info = libspdm_get_session_info_via_session_id(
663 : spdm_context, session_id);
664 1 : if (session_info == NULL) {
665 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
666 : }
667 : ((libspdm_secured_message_context_t
668 1 : *)(session_info->secured_message_context))
669 1 : ->application_secret.response_data_sequence_number--;
670 : }
671 1 : return LIBSPDM_STATUS_SUCCESS;
672 :
673 0 : default:
674 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
675 : }
676 : }
677 :
678 1 : void libspdm_test_requester_heartbeat_case1(void **state)
679 : {
680 : libspdm_return_t status;
681 : libspdm_test_context_t *spdm_test_context;
682 : libspdm_context_t *spdm_context;
683 : uint32_t session_id;
684 : void *data;
685 : size_t data_size;
686 : void *hash;
687 : size_t hash_size;
688 : libspdm_session_info_t *session_info;
689 :
690 1 : spdm_test_context = *state;
691 1 : spdm_context = spdm_test_context->spdm_context;
692 1 : spdm_test_context->case_id = 0x1;
693 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
694 : SPDM_VERSION_NUMBER_SHIFT_BIT;
695 1 : spdm_context->connection_info.connection_state =
696 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
697 1 : spdm_context->connection_info.capability.flags |=
698 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_HBEAT_CAP;
699 1 : spdm_context->connection_info.capability.flags |=
700 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
701 1 : spdm_context->connection_info.capability.flags |=
702 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
703 1 : spdm_context->local_context.capability.flags |=
704 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP;
705 1 : spdm_context->local_context.capability.flags |=
706 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
707 1 : spdm_context->local_context.capability.flags |=
708 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
709 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
710 : m_libspdm_use_asym_algo, &data,
711 : &data_size, &hash, &hash_size)) {
712 0 : assert(false);
713 : }
714 1 : libspdm_reset_message_a(spdm_context);
715 1 : spdm_context->connection_info.algorithm.base_hash_algo =
716 : m_libspdm_use_hash_algo;
717 1 : spdm_context->connection_info.algorithm.base_asym_algo =
718 : m_libspdm_use_asym_algo;
719 1 : spdm_context->connection_info.algorithm.dhe_named_group =
720 : m_libspdm_use_dhe_algo;
721 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
722 : m_libspdm_use_aead_algo;
723 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
724 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
725 : data_size;
726 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
727 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
728 : data, data_size);
729 : #endif
730 :
731 1 : session_id = 0xFFFFFFFF;
732 1 : session_info = &spdm_context->session_info[0];
733 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
734 1 : libspdm_secured_message_set_session_state(
735 : session_info->secured_message_context,
736 : LIBSPDM_SESSION_STATE_ESTABLISHED);
737 1 : session_info->heartbeat_period = 1;
738 :
739 1 : status = libspdm_heartbeat(spdm_context, session_id);
740 1 : assert_int_equal(status, LIBSPDM_STATUS_SEND_FAIL);
741 1 : free(data);
742 1 : }
743 :
744 1 : void libspdm_test_requester_heartbeat_case2(void **state)
745 : {
746 : libspdm_return_t status;
747 : libspdm_test_context_t *spdm_test_context;
748 : libspdm_context_t *spdm_context;
749 : uint32_t session_id;
750 : void *data;
751 : size_t data_size;
752 : void *hash;
753 : size_t hash_size;
754 : libspdm_session_info_t *session_info;
755 :
756 1 : spdm_test_context = *state;
757 1 : spdm_context = spdm_test_context->spdm_context;
758 1 : spdm_test_context->case_id = 0x2;
759 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
760 : SPDM_VERSION_NUMBER_SHIFT_BIT;
761 1 : spdm_context->connection_info.connection_state =
762 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
763 1 : spdm_context->connection_info.capability.flags |=
764 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_HBEAT_CAP;
765 1 : spdm_context->connection_info.capability.flags |=
766 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
767 1 : spdm_context->connection_info.capability.flags |=
768 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
769 1 : spdm_context->local_context.capability.flags |=
770 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP;
771 1 : spdm_context->local_context.capability.flags |=
772 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
773 1 : spdm_context->local_context.capability.flags |=
774 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
775 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
776 : m_libspdm_use_asym_algo, &data,
777 : &data_size, &hash, &hash_size)) {
778 0 : assert(false);
779 : }
780 1 : libspdm_reset_message_a(spdm_context);
781 1 : spdm_context->connection_info.algorithm.base_hash_algo =
782 : m_libspdm_use_hash_algo;
783 1 : spdm_context->connection_info.algorithm.base_asym_algo =
784 : m_libspdm_use_asym_algo;
785 1 : spdm_context->connection_info.algorithm.dhe_named_group =
786 : m_libspdm_use_dhe_algo;
787 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
788 : m_libspdm_use_aead_algo;
789 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
790 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
791 : data_size;
792 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
793 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
794 : data, data_size);
795 : #endif
796 :
797 1 : session_id = 0xFFFFFFFF;
798 1 : session_info = &spdm_context->session_info[0];
799 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
800 1 : libspdm_secured_message_set_session_state(
801 : session_info->secured_message_context,
802 : LIBSPDM_SESSION_STATE_ESTABLISHED);
803 1 : session_info->heartbeat_period = 1;
804 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
805 : ((libspdm_secured_message_context_t
806 1 : *)(session_info->secured_message_context))
807 : ->aead_key_size,
808 : (uint8_t)(0xFF));
809 1 : libspdm_secured_message_set_response_data_encryption_key(
810 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
811 : ((libspdm_secured_message_context_t
812 1 : *)(session_info->secured_message_context))
813 : ->aead_key_size);
814 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
815 : ((libspdm_secured_message_context_t
816 1 : *)(session_info->secured_message_context))
817 : ->aead_iv_size,
818 : (uint8_t)(0xFF));
819 1 : libspdm_secured_message_set_response_data_salt(
820 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
821 : ((libspdm_secured_message_context_t
822 1 : *)(session_info->secured_message_context))
823 : ->aead_iv_size);
824 : ((libspdm_secured_message_context_t *)(session_info
825 1 : ->secured_message_context))
826 1 : ->application_secret.response_data_sequence_number = 0;
827 :
828 1 : status = libspdm_heartbeat(spdm_context, session_id);
829 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
830 1 : free(data);
831 1 : }
832 :
833 1 : void libspdm_test_requester_heartbeat_case3(void **state)
834 : {
835 : libspdm_return_t status;
836 : libspdm_test_context_t *spdm_test_context;
837 : libspdm_context_t *spdm_context;
838 : uint32_t session_id;
839 : void *data;
840 : size_t data_size;
841 : void *hash;
842 : size_t hash_size;
843 : libspdm_session_info_t *session_info;
844 :
845 1 : spdm_test_context = *state;
846 1 : spdm_context = spdm_test_context->spdm_context;
847 1 : spdm_test_context->case_id = 0x3;
848 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
849 : SPDM_VERSION_NUMBER_SHIFT_BIT;
850 1 : spdm_context->connection_info.connection_state =
851 : LIBSPDM_CONNECTION_STATE_NOT_STARTED;
852 1 : spdm_context->connection_info.capability.flags |=
853 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_HBEAT_CAP;
854 1 : spdm_context->connection_info.capability.flags |=
855 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
856 1 : spdm_context->connection_info.capability.flags |=
857 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
858 1 : spdm_context->local_context.capability.flags |=
859 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP;
860 1 : spdm_context->local_context.capability.flags |=
861 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
862 1 : spdm_context->local_context.capability.flags |=
863 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
864 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
865 : m_libspdm_use_asym_algo, &data,
866 : &data_size, &hash, &hash_size)) {
867 0 : assert(false);
868 : }
869 1 : libspdm_reset_message_a(spdm_context);
870 1 : spdm_context->connection_info.algorithm.base_hash_algo =
871 : m_libspdm_use_hash_algo;
872 1 : spdm_context->connection_info.algorithm.base_asym_algo =
873 : m_libspdm_use_asym_algo;
874 1 : spdm_context->connection_info.algorithm.dhe_named_group =
875 : m_libspdm_use_dhe_algo;
876 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
877 : m_libspdm_use_aead_algo;
878 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
879 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
880 : data_size;
881 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
882 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
883 : data, data_size);
884 : #endif
885 :
886 1 : session_id = 0xFFFFFFFF;
887 1 : session_info = &spdm_context->session_info[0];
888 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
889 1 : libspdm_secured_message_set_session_state(
890 : session_info->secured_message_context,
891 : LIBSPDM_SESSION_STATE_ESTABLISHED);
892 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
893 : ((libspdm_secured_message_context_t
894 1 : *)(session_info->secured_message_context))
895 : ->aead_key_size,
896 : (uint8_t)(0xFF));
897 1 : libspdm_secured_message_set_response_data_encryption_key(
898 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
899 : ((libspdm_secured_message_context_t
900 1 : *)(session_info->secured_message_context))
901 : ->aead_key_size);
902 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
903 : ((libspdm_secured_message_context_t
904 1 : *)(session_info->secured_message_context))
905 : ->aead_iv_size,
906 : (uint8_t)(0xFF));
907 1 : libspdm_secured_message_set_response_data_salt(
908 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
909 : ((libspdm_secured_message_context_t
910 1 : *)(session_info->secured_message_context))
911 : ->aead_iv_size);
912 : ((libspdm_secured_message_context_t *)(session_info
913 1 : ->secured_message_context))
914 1 : ->application_secret.response_data_sequence_number = 0;
915 :
916 1 : status = libspdm_heartbeat(spdm_context, session_id);
917 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_STATE_LOCAL);
918 1 : free(data);
919 1 : }
920 :
921 1 : void libspdm_test_requester_heartbeat_case4(void **state)
922 : {
923 : libspdm_return_t status;
924 : libspdm_test_context_t *spdm_test_context;
925 : libspdm_context_t *spdm_context;
926 : uint32_t session_id;
927 : void *data;
928 : size_t data_size;
929 : void *hash;
930 : size_t hash_size;
931 : libspdm_session_info_t *session_info;
932 :
933 1 : spdm_test_context = *state;
934 1 : spdm_context = spdm_test_context->spdm_context;
935 1 : spdm_test_context->case_id = 0x4;
936 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
937 : SPDM_VERSION_NUMBER_SHIFT_BIT;
938 1 : spdm_context->connection_info.connection_state =
939 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
940 1 : spdm_context->connection_info.capability.flags |=
941 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_HBEAT_CAP;
942 1 : spdm_context->connection_info.capability.flags |=
943 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
944 1 : spdm_context->connection_info.capability.flags |=
945 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
946 1 : spdm_context->local_context.capability.flags |=
947 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP;
948 1 : spdm_context->local_context.capability.flags |=
949 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
950 1 : spdm_context->local_context.capability.flags |=
951 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
952 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
953 : m_libspdm_use_asym_algo, &data,
954 : &data_size, &hash, &hash_size)) {
955 0 : assert(false);
956 : }
957 1 : libspdm_reset_message_a(spdm_context);
958 1 : spdm_context->connection_info.algorithm.base_hash_algo =
959 : m_libspdm_use_hash_algo;
960 1 : spdm_context->connection_info.algorithm.base_asym_algo =
961 : m_libspdm_use_asym_algo;
962 1 : spdm_context->connection_info.algorithm.dhe_named_group =
963 : m_libspdm_use_dhe_algo;
964 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
965 : m_libspdm_use_aead_algo;
966 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
967 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
968 : data_size;
969 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
970 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
971 : data, data_size);
972 : #endif
973 :
974 1 : session_id = 0xFFFFFFFF;
975 1 : session_info = &spdm_context->session_info[0];
976 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
977 1 : libspdm_secured_message_set_session_state(
978 : session_info->secured_message_context,
979 : LIBSPDM_SESSION_STATE_ESTABLISHED);
980 1 : session_info->heartbeat_period = 1;
981 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
982 : ((libspdm_secured_message_context_t
983 1 : *)(session_info->secured_message_context))
984 : ->aead_key_size,
985 : (uint8_t)(0xFF));
986 1 : libspdm_secured_message_set_response_data_encryption_key(
987 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
988 : ((libspdm_secured_message_context_t
989 1 : *)(session_info->secured_message_context))
990 : ->aead_key_size);
991 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
992 : ((libspdm_secured_message_context_t
993 1 : *)(session_info->secured_message_context))
994 : ->aead_iv_size,
995 : (uint8_t)(0xFF));
996 1 : libspdm_secured_message_set_response_data_salt(
997 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
998 : ((libspdm_secured_message_context_t
999 1 : *)(session_info->secured_message_context))
1000 : ->aead_iv_size);
1001 : ((libspdm_secured_message_context_t *)(session_info
1002 1 : ->secured_message_context))
1003 1 : ->application_secret.response_data_sequence_number = 0;
1004 :
1005 1 : status = libspdm_heartbeat(spdm_context, session_id);
1006 1 : assert_int_equal(status, LIBSPDM_STATUS_ERROR_PEER);
1007 1 : free(data);
1008 1 : }
1009 :
1010 1 : void libspdm_test_requester_heartbeat_case5(void **state)
1011 : {
1012 : libspdm_return_t status;
1013 : libspdm_test_context_t *spdm_test_context;
1014 : libspdm_context_t *spdm_context;
1015 : uint32_t session_id;
1016 : void *data;
1017 : size_t data_size;
1018 : void *hash;
1019 : size_t hash_size;
1020 : libspdm_session_info_t *session_info;
1021 :
1022 1 : spdm_test_context = *state;
1023 1 : spdm_context = spdm_test_context->spdm_context;
1024 1 : spdm_test_context->case_id = 0x5;
1025 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1026 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1027 1 : spdm_context->connection_info.connection_state =
1028 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1029 1 : spdm_context->connection_info.capability.flags |=
1030 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_HBEAT_CAP;
1031 1 : spdm_context->connection_info.capability.flags |=
1032 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1033 1 : spdm_context->connection_info.capability.flags |=
1034 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1035 1 : spdm_context->local_context.capability.flags |=
1036 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP;
1037 1 : spdm_context->local_context.capability.flags |=
1038 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1039 1 : spdm_context->local_context.capability.flags |=
1040 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1041 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1042 : m_libspdm_use_asym_algo, &data,
1043 : &data_size, &hash, &hash_size)) {
1044 0 : assert(false);
1045 : }
1046 1 : libspdm_reset_message_a(spdm_context);
1047 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1048 : m_libspdm_use_hash_algo;
1049 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1050 : m_libspdm_use_asym_algo;
1051 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1052 : m_libspdm_use_dhe_algo;
1053 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1054 : m_libspdm_use_aead_algo;
1055 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1056 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1057 : data_size;
1058 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1059 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1060 : data, data_size);
1061 : #endif
1062 :
1063 1 : session_id = 0xFFFFFFFF;
1064 1 : session_info = &spdm_context->session_info[0];
1065 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1066 1 : libspdm_secured_message_set_session_state(
1067 : session_info->secured_message_context,
1068 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1069 1 : session_info->heartbeat_period = 1;
1070 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1071 : ((libspdm_secured_message_context_t
1072 1 : *)(session_info->secured_message_context))
1073 : ->aead_key_size,
1074 : (uint8_t)(0xFF));
1075 1 : libspdm_secured_message_set_response_data_encryption_key(
1076 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1077 : ((libspdm_secured_message_context_t
1078 1 : *)(session_info->secured_message_context))
1079 : ->aead_key_size);
1080 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1081 : ((libspdm_secured_message_context_t
1082 1 : *)(session_info->secured_message_context))
1083 : ->aead_iv_size,
1084 : (uint8_t)(0xFF));
1085 1 : libspdm_secured_message_set_response_data_salt(
1086 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1087 : ((libspdm_secured_message_context_t
1088 1 : *)(session_info->secured_message_context))
1089 : ->aead_iv_size);
1090 : ((libspdm_secured_message_context_t *)(session_info
1091 1 : ->secured_message_context))
1092 1 : ->application_secret.response_data_sequence_number = 0;
1093 :
1094 1 : status = libspdm_heartbeat(spdm_context, session_id);
1095 1 : assert_int_equal(status, LIBSPDM_STATUS_BUSY_PEER);
1096 1 : free(data);
1097 1 : }
1098 :
1099 1 : void libspdm_test_requester_heartbeat_case6(void **state)
1100 : {
1101 : libspdm_return_t status;
1102 : libspdm_test_context_t *spdm_test_context;
1103 : libspdm_context_t *spdm_context;
1104 : uint32_t session_id;
1105 : void *data;
1106 : size_t data_size;
1107 : void *hash;
1108 : size_t hash_size;
1109 : libspdm_session_info_t *session_info;
1110 :
1111 1 : spdm_test_context = *state;
1112 1 : spdm_context = spdm_test_context->spdm_context;
1113 1 : spdm_test_context->case_id = 0x6;
1114 1 : spdm_context->retry_times = 3;
1115 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1116 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1117 1 : spdm_context->connection_info.connection_state =
1118 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1119 1 : spdm_context->connection_info.capability.flags |=
1120 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_HBEAT_CAP;
1121 1 : spdm_context->connection_info.capability.flags |=
1122 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1123 1 : spdm_context->connection_info.capability.flags |=
1124 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1125 1 : spdm_context->local_context.capability.flags |=
1126 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP;
1127 1 : spdm_context->local_context.capability.flags |=
1128 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1129 1 : spdm_context->local_context.capability.flags |=
1130 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1131 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1132 : m_libspdm_use_asym_algo, &data,
1133 : &data_size, &hash, &hash_size)) {
1134 0 : assert(false);
1135 : }
1136 1 : libspdm_reset_message_a(spdm_context);
1137 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1138 : m_libspdm_use_hash_algo;
1139 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1140 : m_libspdm_use_asym_algo;
1141 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1142 : m_libspdm_use_dhe_algo;
1143 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1144 : m_libspdm_use_aead_algo;
1145 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1146 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1147 : data_size;
1148 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1149 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1150 : data, data_size);
1151 : #endif
1152 :
1153 1 : session_id = 0xFFFFFFFF;
1154 1 : session_info = &spdm_context->session_info[0];
1155 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1156 1 : libspdm_secured_message_set_session_state(
1157 : session_info->secured_message_context,
1158 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1159 1 : session_info->heartbeat_period = 1;
1160 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1161 : ((libspdm_secured_message_context_t
1162 1 : *)(session_info->secured_message_context))
1163 : ->aead_key_size,
1164 : (uint8_t)(0xFF));
1165 1 : libspdm_secured_message_set_response_data_encryption_key(
1166 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1167 : ((libspdm_secured_message_context_t
1168 1 : *)(session_info->secured_message_context))
1169 : ->aead_key_size);
1170 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1171 : ((libspdm_secured_message_context_t
1172 1 : *)(session_info->secured_message_context))
1173 : ->aead_iv_size,
1174 : (uint8_t)(0xFF));
1175 1 : libspdm_secured_message_set_response_data_salt(
1176 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1177 : ((libspdm_secured_message_context_t
1178 1 : *)(session_info->secured_message_context))
1179 : ->aead_iv_size);
1180 : ((libspdm_secured_message_context_t *)(session_info
1181 1 : ->secured_message_context))
1182 1 : ->application_secret.response_data_sequence_number = 0;
1183 :
1184 1 : status = libspdm_heartbeat(spdm_context, session_id);
1185 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1186 1 : free(data);
1187 1 : }
1188 :
1189 1 : void libspdm_test_requester_heartbeat_case7(void **state)
1190 : {
1191 : libspdm_return_t status;
1192 : libspdm_test_context_t *spdm_test_context;
1193 : libspdm_context_t *spdm_context;
1194 : uint32_t session_id;
1195 : void *data;
1196 : size_t data_size;
1197 : void *hash;
1198 : size_t hash_size;
1199 : libspdm_session_info_t *session_info;
1200 :
1201 1 : spdm_test_context = *state;
1202 1 : spdm_context = spdm_test_context->spdm_context;
1203 1 : spdm_test_context->case_id = 0x7;
1204 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1205 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1206 1 : spdm_context->connection_info.connection_state =
1207 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1208 1 : spdm_context->connection_info.capability.flags |=
1209 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_HBEAT_CAP;
1210 1 : spdm_context->connection_info.capability.flags |=
1211 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1212 1 : spdm_context->connection_info.capability.flags |=
1213 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1214 1 : spdm_context->local_context.capability.flags |=
1215 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP;
1216 1 : spdm_context->local_context.capability.flags |=
1217 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1218 1 : spdm_context->local_context.capability.flags |=
1219 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1220 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1221 : m_libspdm_use_asym_algo, &data,
1222 : &data_size, &hash, &hash_size)) {
1223 0 : assert(false);
1224 : }
1225 1 : libspdm_reset_message_a(spdm_context);
1226 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1227 : m_libspdm_use_hash_algo;
1228 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1229 : m_libspdm_use_asym_algo;
1230 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1231 : m_libspdm_use_dhe_algo;
1232 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1233 : m_libspdm_use_aead_algo;
1234 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1235 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1236 : data_size;
1237 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1238 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1239 : data, data_size);
1240 : #endif
1241 :
1242 1 : session_id = 0xFFFFFFFF;
1243 1 : session_info = &spdm_context->session_info[0];
1244 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1245 1 : libspdm_secured_message_set_session_state(
1246 : session_info->secured_message_context,
1247 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1248 1 : session_info->heartbeat_period = 1;
1249 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1250 : ((libspdm_secured_message_context_t
1251 1 : *)(session_info->secured_message_context))
1252 : ->aead_key_size,
1253 : (uint8_t)(0xFF));
1254 1 : libspdm_secured_message_set_response_data_encryption_key(
1255 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1256 : ((libspdm_secured_message_context_t
1257 1 : *)(session_info->secured_message_context))
1258 : ->aead_key_size);
1259 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1260 : ((libspdm_secured_message_context_t
1261 1 : *)(session_info->secured_message_context))
1262 : ->aead_iv_size,
1263 : (uint8_t)(0xFF));
1264 1 : libspdm_secured_message_set_response_data_salt(
1265 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1266 : ((libspdm_secured_message_context_t
1267 1 : *)(session_info->secured_message_context))
1268 : ->aead_iv_size);
1269 : ((libspdm_secured_message_context_t *)(session_info
1270 1 : ->secured_message_context))
1271 1 : ->application_secret.response_data_sequence_number = 0;
1272 :
1273 1 : status = libspdm_heartbeat(spdm_context, session_id);
1274 1 : assert_int_equal(status, LIBSPDM_STATUS_RESYNCH_PEER);
1275 1 : assert_int_equal(spdm_context->connection_info.connection_state,
1276 : LIBSPDM_CONNECTION_STATE_NOT_STARTED);
1277 1 : free(data);
1278 1 : }
1279 :
1280 1 : void libspdm_test_requester_heartbeat_case8(void **state)
1281 : {
1282 : libspdm_return_t status;
1283 : libspdm_test_context_t *spdm_test_context;
1284 : libspdm_context_t *spdm_context;
1285 : uint32_t session_id;
1286 : void *data;
1287 : size_t data_size;
1288 : void *hash;
1289 : size_t hash_size;
1290 : libspdm_session_info_t *session_info;
1291 :
1292 1 : spdm_test_context = *state;
1293 1 : spdm_context = spdm_test_context->spdm_context;
1294 1 : spdm_test_context->case_id = 0x8;
1295 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1296 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1297 1 : spdm_context->connection_info.connection_state =
1298 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1299 1 : spdm_context->connection_info.capability.flags |=
1300 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_HBEAT_CAP;
1301 1 : spdm_context->connection_info.capability.flags |=
1302 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1303 1 : spdm_context->connection_info.capability.flags |=
1304 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1305 1 : spdm_context->local_context.capability.flags |=
1306 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP;
1307 1 : spdm_context->local_context.capability.flags |=
1308 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1309 1 : spdm_context->local_context.capability.flags |=
1310 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1311 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1312 : m_libspdm_use_asym_algo, &data,
1313 : &data_size, &hash, &hash_size)) {
1314 0 : assert(false);
1315 : }
1316 1 : libspdm_reset_message_a(spdm_context);
1317 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1318 : m_libspdm_use_hash_algo;
1319 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1320 : m_libspdm_use_asym_algo;
1321 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1322 : m_libspdm_use_dhe_algo;
1323 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1324 : m_libspdm_use_aead_algo;
1325 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1326 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1327 : data_size;
1328 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1329 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1330 : data, data_size);
1331 : #endif
1332 :
1333 1 : session_id = 0xFFFFFFFF;
1334 1 : session_info = &spdm_context->session_info[0];
1335 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1336 1 : libspdm_secured_message_set_session_state(
1337 : session_info->secured_message_context,
1338 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1339 1 : session_info->heartbeat_period = 1;
1340 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1341 : ((libspdm_secured_message_context_t
1342 1 : *)(session_info->secured_message_context))
1343 : ->aead_key_size,
1344 : (uint8_t)(0xFF));
1345 1 : libspdm_secured_message_set_response_data_encryption_key(
1346 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1347 : ((libspdm_secured_message_context_t
1348 1 : *)(session_info->secured_message_context))
1349 : ->aead_key_size);
1350 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1351 : ((libspdm_secured_message_context_t
1352 1 : *)(session_info->secured_message_context))
1353 : ->aead_iv_size,
1354 : (uint8_t)(0xFF));
1355 1 : libspdm_secured_message_set_response_data_salt(
1356 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1357 : ((libspdm_secured_message_context_t
1358 1 : *)(session_info->secured_message_context))
1359 : ->aead_iv_size);
1360 : ((libspdm_secured_message_context_t *)(session_info
1361 1 : ->secured_message_context))
1362 1 : ->application_secret.response_data_sequence_number = 0;
1363 :
1364 1 : status = libspdm_heartbeat(spdm_context, session_id);
1365 1 : assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
1366 1 : free(data);
1367 1 : }
1368 :
1369 1 : void libspdm_test_requester_heartbeat_case9(void **state)
1370 : {
1371 : libspdm_return_t status;
1372 : libspdm_test_context_t *spdm_test_context;
1373 : libspdm_context_t *spdm_context;
1374 : uint32_t session_id;
1375 : void *data;
1376 : size_t data_size;
1377 : void *hash;
1378 : size_t hash_size;
1379 : libspdm_session_info_t *session_info;
1380 :
1381 1 : spdm_test_context = *state;
1382 1 : spdm_context = spdm_test_context->spdm_context;
1383 1 : spdm_test_context->case_id = 0x9;
1384 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1385 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1386 1 : spdm_context->connection_info.connection_state =
1387 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1388 1 : spdm_context->connection_info.capability.flags |=
1389 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_HBEAT_CAP;
1390 1 : spdm_context->connection_info.capability.flags |=
1391 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1392 1 : spdm_context->connection_info.capability.flags |=
1393 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1394 1 : spdm_context->local_context.capability.flags |=
1395 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP;
1396 1 : spdm_context->local_context.capability.flags |=
1397 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1398 1 : spdm_context->local_context.capability.flags |=
1399 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1400 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1401 : m_libspdm_use_asym_algo, &data,
1402 : &data_size, &hash, &hash_size)) {
1403 0 : assert(false);
1404 : }
1405 1 : libspdm_reset_message_a(spdm_context);
1406 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1407 : m_libspdm_use_hash_algo;
1408 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1409 : m_libspdm_use_asym_algo;
1410 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1411 : m_libspdm_use_dhe_algo;
1412 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1413 : m_libspdm_use_aead_algo;
1414 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1415 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1416 : data_size;
1417 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1418 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1419 : data, data_size);
1420 : #endif
1421 :
1422 1 : session_id = 0xFFFFFFFF;
1423 1 : session_info = &spdm_context->session_info[0];
1424 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1425 1 : libspdm_secured_message_set_session_state(
1426 : session_info->secured_message_context,
1427 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1428 1 : session_info->heartbeat_period = 1;
1429 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1430 : ((libspdm_secured_message_context_t
1431 1 : *)(session_info->secured_message_context))
1432 : ->aead_key_size,
1433 : (uint8_t)(0xFF));
1434 1 : libspdm_secured_message_set_response_data_encryption_key(
1435 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1436 : ((libspdm_secured_message_context_t
1437 1 : *)(session_info->secured_message_context))
1438 : ->aead_key_size);
1439 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1440 : ((libspdm_secured_message_context_t
1441 1 : *)(session_info->secured_message_context))
1442 : ->aead_iv_size,
1443 : (uint8_t)(0xFF));
1444 1 : libspdm_secured_message_set_response_data_salt(
1445 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1446 : ((libspdm_secured_message_context_t
1447 1 : *)(session_info->secured_message_context))
1448 : ->aead_iv_size);
1449 : ((libspdm_secured_message_context_t *)(session_info
1450 1 : ->secured_message_context))
1451 1 : ->application_secret.response_data_sequence_number = 0;
1452 :
1453 1 : status = libspdm_heartbeat(spdm_context, session_id);
1454 : if (LIBSPDM_RESPOND_IF_READY_SUPPORT) {
1455 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1456 : } else {
1457 : assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
1458 : }
1459 1 : free(data);
1460 1 : }
1461 :
1462 1 : void libspdm_test_requester_heartbeat_case10(void **state) {
1463 : libspdm_return_t status;
1464 : libspdm_test_context_t *spdm_test_context;
1465 : libspdm_context_t *spdm_context;
1466 : uint32_t session_id;
1467 : void *data;
1468 : size_t data_size;
1469 : void *hash;
1470 : size_t hash_size;
1471 : libspdm_session_info_t *session_info;
1472 : uint16_t error_code;
1473 :
1474 1 : spdm_test_context = *state;
1475 1 : spdm_context = spdm_test_context->spdm_context;
1476 1 : spdm_test_context->case_id = 0xA;
1477 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1478 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1479 1 : spdm_context->connection_info.capability.flags |=
1480 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_HBEAT_CAP;
1481 1 : spdm_context->connection_info.capability.flags |=
1482 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1483 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1484 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP;
1485 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1486 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1487 1 : libspdm_read_responder_public_certificate_chain (m_libspdm_use_hash_algo,
1488 : m_libspdm_use_asym_algo,
1489 : &data, &data_size,
1490 : &hash, &hash_size);
1491 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1492 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1493 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1494 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1495 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1496 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1497 : data_size;
1498 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1499 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1500 : data, data_size);
1501 : #endif
1502 :
1503 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
1504 19 : while(error_code <= 0xff) {
1505 18 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1506 18 : libspdm_reset_message_a(spdm_context);
1507 :
1508 18 : session_id = 0xFFFFFFFF;
1509 18 : session_info = &spdm_context->session_info[0];
1510 18 : libspdm_session_info_init (spdm_context, session_info, session_id, true);
1511 18 : libspdm_secured_message_set_session_state (session_info->secured_message_context,
1512 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1513 18 : session_info->heartbeat_period = 1;
1514 18 : libspdm_set_mem (m_libspdm_dummy_key_buffer,
1515 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->aead_key_size,
1516 : (uint8_t)(0xFF));
1517 18 : libspdm_secured_message_set_response_data_encryption_key (
1518 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1519 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->aead_key_size);
1520 18 : libspdm_set_mem (m_libspdm_dummy_salt_buffer,
1521 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->aead_iv_size,
1522 : (uint8_t)(0xFF));
1523 18 : libspdm_secured_message_set_response_data_salt (session_info->secured_message_context,
1524 : m_libspdm_dummy_salt_buffer,
1525 : ((libspdm_secured_message_context_t*)(
1526 : session_info
1527 18 : ->
1528 : secured_message_context))->aead_iv_size);
1529 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->
1530 18 : application_secret.response_data_sequence_number = 0;
1531 :
1532 18 : status = libspdm_heartbeat (spdm_context, session_id);
1533 18 : if(error_code != SPDM_ERROR_CODE_DECRYPT_ERROR) {
1534 17 : LIBSPDM_ASSERT_INT_EQUAL_CASE (status, LIBSPDM_STATUS_ERROR_PEER, error_code);
1535 : } else {
1536 1 : LIBSPDM_ASSERT_INT_EQUAL_CASE (status, LIBSPDM_STATUS_SESSION_MSG_ERROR, error_code);
1537 : }
1538 :
1539 18 : error_code++;
1540 18 : if(error_code == SPDM_ERROR_CODE_BUSY) { /*busy is treated in cases 5 and 6*/
1541 1 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
1542 : }
1543 18 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) { /*skip some reserved error codes (0d to 3e)*/
1544 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
1545 : }
1546 18 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) { /*skip response not ready, request resync, and some reserved codes (44 to fc)*/
1547 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
1548 : }
1549 : }
1550 :
1551 1 : free(data);
1552 1 : }
1553 :
1554 1 : void libspdm_test_requester_heartbeat_case11(void **state)
1555 : {
1556 : libspdm_return_t status;
1557 : libspdm_test_context_t *spdm_test_context;
1558 : libspdm_context_t *spdm_context;
1559 : uint32_t session_id;
1560 : void *data;
1561 : size_t data_size;
1562 : void *hash;
1563 : size_t hash_size;
1564 : libspdm_session_info_t *session_info;
1565 :
1566 1 : spdm_test_context = *state;
1567 1 : spdm_context = spdm_test_context->spdm_context;
1568 1 : spdm_test_context->case_id = 0xB;
1569 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1570 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1571 1 : spdm_context->connection_info.connection_state =
1572 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1573 1 : spdm_context->connection_info.capability.flags |=
1574 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_HBEAT_CAP;
1575 1 : spdm_context->connection_info.capability.flags |=
1576 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1577 1 : spdm_context->connection_info.capability.flags |=
1578 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1579 1 : spdm_context->local_context.capability.flags |=
1580 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP;
1581 1 : spdm_context->local_context.capability.flags |=
1582 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1583 1 : spdm_context->local_context.capability.flags |=
1584 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1585 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1586 : m_libspdm_use_asym_algo, &data,
1587 : &data_size, &hash, &hash_size)) {
1588 0 : assert(false);
1589 : }
1590 1 : libspdm_reset_message_a(spdm_context);
1591 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1592 : m_libspdm_use_hash_algo;
1593 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1594 : m_libspdm_use_asym_algo;
1595 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1596 : m_libspdm_use_dhe_algo;
1597 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1598 : m_libspdm_use_aead_algo;
1599 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1600 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1601 : data_size;
1602 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1603 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1604 : data, data_size);
1605 : #endif
1606 :
1607 1 : session_id = 0xFFFFFFFF;
1608 1 : session_info = &spdm_context->session_info[0];
1609 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1610 1 : libspdm_secured_message_set_session_state(
1611 : session_info->secured_message_context,
1612 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1613 1 : session_info->heartbeat_period = 1;
1614 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1615 : ((libspdm_secured_message_context_t
1616 1 : *)(session_info->secured_message_context))
1617 : ->aead_key_size,
1618 : (uint8_t)(0xFF));
1619 1 : libspdm_secured_message_set_response_data_encryption_key(
1620 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1621 : ((libspdm_secured_message_context_t
1622 1 : *)(session_info->secured_message_context))
1623 : ->aead_key_size);
1624 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1625 : ((libspdm_secured_message_context_t
1626 1 : *)(session_info->secured_message_context))
1627 : ->aead_iv_size,
1628 : (uint8_t)(0xFF));
1629 1 : libspdm_secured_message_set_response_data_salt(
1630 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1631 : ((libspdm_secured_message_context_t
1632 1 : *)(session_info->secured_message_context))
1633 : ->aead_iv_size);
1634 : ((libspdm_secured_message_context_t *)(session_info
1635 1 : ->secured_message_context))
1636 1 : ->application_secret.response_data_sequence_number = 0;
1637 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1638 : session_info->session_transcript.message_m.buffer_size =
1639 : session_info->session_transcript.message_m.max_buffer_size;
1640 : spdm_context->transcript.message_b.buffer_size =
1641 : spdm_context->transcript.message_b.max_buffer_size;
1642 : spdm_context->transcript.message_c.buffer_size =
1643 : spdm_context->transcript.message_c.max_buffer_size;
1644 : spdm_context->transcript.message_mut_b.buffer_size =
1645 : spdm_context->transcript.message_mut_b.max_buffer_size;
1646 : spdm_context->transcript.message_mut_c.buffer_size =
1647 : spdm_context->transcript.message_mut_c.max_buffer_size;
1648 : #endif
1649 :
1650 1 : status = libspdm_heartbeat(spdm_context, session_id);
1651 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1652 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1653 : assert_int_equal(session_info->session_transcript.message_m.buffer_size, 0);
1654 : assert_int_equal(spdm_context->transcript.message_b.buffer_size, 0);
1655 : assert_int_equal(spdm_context->transcript.message_c.buffer_size, 0);
1656 : assert_int_equal(spdm_context->transcript.message_mut_b.buffer_size, 0);
1657 : assert_int_equal(spdm_context->transcript.message_mut_c.buffer_size, 0);
1658 : #endif
1659 1 : free(data);
1660 1 : }
1661 :
1662 : /**
1663 : * Test 12: the requester is setup correctly, but receives an ERROR with SPDM_ERROR_CODE_DECRYPT_ERROR.
1664 : * Expected behavior: client returns a Status of INVALID_SESSION_ID and free the session ID.
1665 : **/
1666 1 : void libspdm_test_requester_heartbeat_case12(void **state)
1667 : {
1668 : libspdm_return_t status;
1669 : libspdm_test_context_t *spdm_test_context;
1670 : libspdm_context_t *spdm_context;
1671 : uint32_t session_id;
1672 : void *data;
1673 : size_t data_size;
1674 : void *hash;
1675 : size_t hash_size;
1676 : libspdm_session_info_t *session_info;
1677 :
1678 1 : spdm_test_context = *state;
1679 1 : spdm_context = spdm_test_context->spdm_context;
1680 1 : spdm_test_context->case_id = 0xC;
1681 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1682 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1683 1 : spdm_context->connection_info.connection_state =
1684 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1685 1 : spdm_context->connection_info.capability.flags |=
1686 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_HBEAT_CAP;
1687 1 : spdm_context->connection_info.capability.flags |=
1688 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1689 1 : spdm_context->connection_info.capability.flags |=
1690 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1691 1 : spdm_context->local_context.capability.flags |=
1692 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP;
1693 1 : spdm_context->local_context.capability.flags |=
1694 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1695 1 : spdm_context->local_context.capability.flags |=
1696 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1697 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1698 : m_libspdm_use_asym_algo, &data,
1699 : &data_size, &hash, &hash_size)) {
1700 0 : assert(false);
1701 : }
1702 1 : libspdm_reset_message_a(spdm_context);
1703 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1704 : m_libspdm_use_hash_algo;
1705 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1706 : m_libspdm_use_asym_algo;
1707 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1708 : m_libspdm_use_dhe_algo;
1709 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1710 : m_libspdm_use_aead_algo;
1711 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1712 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1713 : data_size;
1714 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1715 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1716 : data, data_size);
1717 : #endif
1718 :
1719 1 : session_id = 0xFFFFFFFF;
1720 1 : session_info = &spdm_context->session_info[0];
1721 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1722 1 : libspdm_secured_message_set_session_state(
1723 : session_info->secured_message_context,
1724 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1725 1 : session_info->heartbeat_period = 1;
1726 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1727 : ((libspdm_secured_message_context_t
1728 1 : *)(session_info->secured_message_context))
1729 : ->aead_key_size,
1730 : (uint8_t)(0xFF));
1731 1 : libspdm_secured_message_set_response_data_encryption_key(
1732 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1733 : ((libspdm_secured_message_context_t
1734 1 : *)(session_info->secured_message_context))
1735 : ->aead_key_size);
1736 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1737 : ((libspdm_secured_message_context_t
1738 1 : *)(session_info->secured_message_context))
1739 : ->aead_iv_size,
1740 : (uint8_t)(0xFF));
1741 1 : libspdm_secured_message_set_response_data_salt(
1742 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1743 : ((libspdm_secured_message_context_t
1744 1 : *)(session_info->secured_message_context))
1745 : ->aead_iv_size);
1746 : ((libspdm_secured_message_context_t *)(session_info
1747 1 : ->secured_message_context))
1748 1 : ->application_secret.response_data_sequence_number = 0;
1749 :
1750 1 : status = libspdm_heartbeat(spdm_context, session_id);
1751 1 : assert_int_equal(status, LIBSPDM_STATUS_SESSION_MSG_ERROR);
1752 1 : assert_int_equal(spdm_context->session_info->session_id, INVALID_SESSION_ID);
1753 :
1754 1 : free(data);
1755 1 : }
1756 :
1757 1 : void libspdm_test_requester_heartbeat_case13(void **state)
1758 : {
1759 : libspdm_return_t status;
1760 : libspdm_test_context_t *spdm_test_context;
1761 : libspdm_context_t *spdm_context;
1762 : uint32_t session_id;
1763 : void *data;
1764 : size_t data_size;
1765 : void *hash;
1766 : size_t hash_size;
1767 : libspdm_session_info_t *session_info;
1768 :
1769 1 : spdm_test_context = *state;
1770 1 : spdm_context = spdm_test_context->spdm_context;
1771 1 : spdm_test_context->case_id = 0x3;
1772 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1773 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1774 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1775 1 : spdm_context->connection_info.capability.flags |=
1776 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_HBEAT_CAP;
1777 1 : spdm_context->connection_info.capability.flags |=
1778 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1779 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1780 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP;
1781 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1782 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1783 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1784 : m_libspdm_use_asym_algo, &data,
1785 : &data_size, &hash, &hash_size)) {
1786 0 : assert(false);
1787 : }
1788 1 : libspdm_reset_message_a(spdm_context);
1789 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1790 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1791 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1792 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1793 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1794 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1795 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1796 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1797 : data, data_size);
1798 : #endif
1799 :
1800 1 : session_id = 0xFFFFFFFF;
1801 1 : session_info = &spdm_context->session_info[0];
1802 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1803 1 : libspdm_secured_message_set_session_state(
1804 : session_info->secured_message_context,
1805 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1806 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1807 : ((libspdm_secured_message_context_t
1808 1 : *)(session_info->secured_message_context))
1809 : ->aead_key_size, (uint8_t)(0xFF));
1810 1 : libspdm_secured_message_set_response_data_encryption_key(
1811 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1812 : ((libspdm_secured_message_context_t
1813 1 : *)(session_info->secured_message_context))->aead_key_size);
1814 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1815 : ((libspdm_secured_message_context_t
1816 1 : *)(session_info->secured_message_context))
1817 : ->aead_iv_size, (uint8_t)(0xFF));
1818 1 : libspdm_secured_message_set_response_data_salt(
1819 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1820 : ((libspdm_secured_message_context_t
1821 1 : *)(session_info->secured_message_context))->aead_iv_size);
1822 : ((libspdm_secured_message_context_t *)(session_info
1823 1 : ->secured_message_context))
1824 1 : ->application_secret.response_data_sequence_number = 0;
1825 :
1826 1 : session_info->heartbeat_period = 0;
1827 :
1828 1 : status = libspdm_heartbeat(spdm_context, session_id);
1829 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_STATE_LOCAL);
1830 1 : free(data);
1831 1 : }
1832 :
1833 1 : int libspdm_requester_heartbeat_test_main(void)
1834 : {
1835 1 : const struct CMUnitTest spdm_requester_heartbeat_tests[] = {
1836 : /* SendRequest failed*/
1837 : cmocka_unit_test(libspdm_test_requester_heartbeat_case1),
1838 : /* Successful response*/
1839 : cmocka_unit_test(libspdm_test_requester_heartbeat_case2),
1840 : /* connection_state check failed*/
1841 : cmocka_unit_test(libspdm_test_requester_heartbeat_case3),
1842 : /* Error response: SPDM_ERROR_CODE_INVALID_REQUEST*/
1843 : cmocka_unit_test(libspdm_test_requester_heartbeat_case4),
1844 : /* Always SPDM_ERROR_CODE_BUSY*/
1845 : cmocka_unit_test(libspdm_test_requester_heartbeat_case5),
1846 : /* SPDM_ERROR_CODE_BUSY + Successful response*/
1847 : cmocka_unit_test(libspdm_test_requester_heartbeat_case6),
1848 : /* Error response: SPDM_ERROR_CODE_REQUEST_RESYNCH*/
1849 : cmocka_unit_test(libspdm_test_requester_heartbeat_case7),
1850 : /* Always SPDM_ERROR_CODE_RESPONSE_NOT_READY*/
1851 : cmocka_unit_test(libspdm_test_requester_heartbeat_case8),
1852 : /* SPDM_ERROR_CODE_RESPONSE_NOT_READY + Successful response*/
1853 : cmocka_unit_test(libspdm_test_requester_heartbeat_case9),
1854 : /* Unexpected errors*/
1855 : cmocka_unit_test(libspdm_test_requester_heartbeat_case10),
1856 : /* Buffer reset*/
1857 : cmocka_unit_test(libspdm_test_requester_heartbeat_case11),
1858 : /* Error response: SPDM_ERROR_CODE_DECRYPT_ERROR*/
1859 : cmocka_unit_test(libspdm_test_requester_heartbeat_case12),
1860 : cmocka_unit_test(libspdm_test_requester_heartbeat_case13),
1861 : };
1862 :
1863 1 : libspdm_test_context_t test_context = {
1864 : LIBSPDM_TEST_CONTEXT_VERSION,
1865 : true,
1866 : libspdm_requester_heartbeat_test_send_message,
1867 : libspdm_requester_heartbeat_test_receive_message,
1868 : };
1869 :
1870 1 : libspdm_setup_test_context(&test_context);
1871 :
1872 1 : return cmocka_run_group_tests(spdm_requester_heartbeat_tests,
1873 : libspdm_unit_test_group_setup,
1874 : libspdm_unit_test_group_teardown);
1875 : }
1876 :
1877 : #endif /* (LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP) || (LIBSPDM_ENABLE_CAPABILITY_PSK_CAP) */
|
