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