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