Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2025-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_responder_lib.h"
9 : #include "internal/libspdm_secured_message_lib.h"
10 :
11 : #if LIBSPDM_EVENT_RECIPIENT_SUPPORT
12 :
13 : static uint8_t m_spdm_request_buffer[0x1000];
14 : static uint8_t m_spdm_response_buffer[0x1000];
15 :
16 : static const uint32_t m_session_id = 0xffffffff;
17 :
18 : typedef struct {
19 : uint32_t event_instance_id;
20 : uint8_t svh_id;
21 : uint8_t svh_vendor_id_len;
22 : uint8_t svh_vendor_id[4];
23 : uint16_t event_type_id;
24 : uint16_t event_detail_len;
25 : uint8_t event_detail[100];
26 : } expected_event_t;
27 :
28 : static expected_event_t m_expected_event[4];
29 : static uint32_t m_event_counter;
30 : static bool m_process_event_error = false;
31 :
32 1 : static libspdm_return_t process_event(void *spdm_context,
33 : uint32_t session_id,
34 : uint32_t event_instance_id,
35 : uint8_t svh_id,
36 : uint8_t svh_vendor_id_len,
37 : const void *svh_vendor_id,
38 : uint16_t event_type_id,
39 : uint16_t event_detail_len,
40 : const void *event_detail)
41 : {
42 1 : if (m_process_event_error) {
43 1 : return LIBSPDM_STATUS_INVALID_MSG_FIELD;
44 : }
45 :
46 0 : printf("Event Received\n");
47 0 : printf("Event Instance ID = [0x%x]\n", event_instance_id);
48 0 : printf("SVH ID = [0x%x], SVH VendorIDLen = [0x%x]\n", svh_id, svh_vendor_id_len);
49 0 : if (svh_vendor_id_len != 0) {
50 0 : printf("SVH VendorID\n");
51 0 : libspdm_dump_hex(svh_vendor_id, svh_vendor_id_len);
52 0 : printf("\n");
53 : }
54 0 : printf("EventTypeID = [0x%x], EventDetailLen = [0x%x]\n", event_type_id, event_detail_len);
55 0 : printf("Event Detail\n");
56 0 : libspdm_dump_hex(event_detail, event_detail_len);
57 :
58 0 : assert_int_equal(session_id, m_session_id);
59 0 : assert_int_equal(event_instance_id, m_expected_event[m_event_counter].event_instance_id);
60 0 : assert_int_equal(event_type_id, m_expected_event[m_event_counter].event_type_id);
61 0 : assert_int_equal(svh_id, m_expected_event[m_event_counter].svh_id);
62 0 : assert_int_equal(svh_vendor_id_len, m_expected_event[m_event_counter].svh_vendor_id_len);
63 0 : if (svh_vendor_id_len == 0) {
64 0 : assert_ptr_equal(svh_vendor_id, NULL);
65 : }
66 0 : assert_int_equal(event_detail_len, m_expected_event[m_event_counter].event_detail_len);
67 0 : assert_memory_equal(m_expected_event[m_event_counter].event_detail, event_detail,
68 : event_detail_len);
69 0 : m_event_counter++;
70 :
71 0 : return LIBSPDM_STATUS_SUCCESS;
72 : }
73 :
74 8 : static void set_standard_state(libspdm_context_t *spdm_context)
75 : {
76 : libspdm_session_info_t *session_info;
77 :
78 8 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
79 : SPDM_VERSION_NUMBER_SHIFT_BIT;
80 8 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
81 :
82 8 : spdm_context->connection_info.capability.flags |=
83 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_EVENT_CAP;
84 8 : spdm_context->connection_info.capability.flags |=
85 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
86 8 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
87 8 : spdm_context->connection_info.capability.flags |=
88 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
89 8 : spdm_context->connection_info.capability.flags |=
90 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
91 :
92 8 : spdm_context->local_context.capability.flags |=
93 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
94 8 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
95 8 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
96 8 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
97 :
98 8 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
99 8 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
100 8 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
101 8 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
102 :
103 8 : spdm_context->latest_session_id = m_session_id;
104 8 : spdm_context->last_spdm_request_session_id_valid = true;
105 8 : spdm_context->last_spdm_request_session_id = m_session_id;
106 8 : session_info = &spdm_context->session_info[0];
107 8 : libspdm_session_info_init(spdm_context, session_info, m_session_id,
108 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
109 8 : libspdm_secured_message_set_session_state(
110 : session_info->secured_message_context,
111 : LIBSPDM_SESSION_STATE_ESTABLISHED);
112 :
113 8 : libspdm_register_event_callback(spdm_context, process_event);
114 8 : }
115 :
116 : /**
117 : * Test 1: Illegal EventCount is set to 0.
118 : * Expected behavior: InvalidRequest error response.
119 : **/
120 1 : static void rsp_event_ack_err_case1(void **state)
121 : {
122 : libspdm_return_t status;
123 : libspdm_test_context_t *spdm_test_context;
124 : libspdm_context_t *spdm_context;
125 : spdm_send_event_request_t *send_event;
126 : size_t request_size;
127 : spdm_error_response_t *spdm_response;
128 1 : size_t response_size = sizeof(m_spdm_response_buffer);
129 : uint8_t event_data_size;
130 : spdm_dmtf_event_type_event_lost_t event_lost;
131 :
132 1 : spdm_test_context = *state;
133 1 : spdm_context = spdm_test_context->spdm_context;
134 1 : spdm_test_context->case_id = 0x01;
135 :
136 1 : set_standard_state(spdm_context);
137 :
138 1 : send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
139 :
140 1 : send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
141 1 : send_event->header.request_response_code = SPDM_SEND_EVENT;
142 1 : send_event->header.param1 = 0;
143 1 : send_event->header.param2 = 0;
144 : /* Illegal value for EventCount. */
145 1 : send_event->event_count = 0;
146 :
147 1 : event_lost.last_acked_event_inst_id = 0xffeeddcc;
148 1 : event_lost.last_lost_event_inst_id = 0x55667788;
149 :
150 1 : generate_dmtf_event_data(send_event + 1, &event_data_size, 0x11223344,
151 : SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
152 :
153 1 : m_event_counter = 0;
154 :
155 1 : request_size = sizeof(spdm_send_event_request_t) + event_data_size;
156 :
157 1 : status = libspdm_get_response_send_event(
158 : spdm_context, request_size, m_spdm_request_buffer,
159 : &response_size, m_spdm_response_buffer);
160 :
161 1 : spdm_response = (spdm_error_response_t *)m_spdm_response_buffer;
162 :
163 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
164 :
165 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
166 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_13);
167 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
168 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
169 1 : assert_int_equal(spdm_response->header.param2, 0);
170 :
171 1 : assert_int_equal(m_event_counter, 0);
172 1 : }
173 :
174 : /**
175 : * Test 2: Send two events with gap in event instance IDs.
176 : * Expected behavior: InvalidRequest error response.
177 : **/
178 1 : static void rsp_event_ack_err_case2(void **state)
179 : {
180 : libspdm_return_t status;
181 : libspdm_test_context_t *spdm_test_context;
182 : libspdm_context_t *spdm_context;
183 : spdm_send_event_request_t *send_event;
184 : size_t request_size;
185 : spdm_error_response_t *spdm_response;
186 1 : size_t response_size = sizeof(m_spdm_response_buffer);
187 : uint8_t event_data_size[2];
188 : spdm_dmtf_event_type_event_lost_t event_lost;
189 : spdm_dmtf_event_type_certificate_changed_t certificate_changed;
190 : uint8_t *ptr;
191 :
192 1 : spdm_test_context = *state;
193 1 : spdm_context = spdm_test_context->spdm_context;
194 1 : spdm_test_context->case_id = 0x02;
195 :
196 1 : set_standard_state(spdm_context);
197 :
198 1 : send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
199 :
200 1 : send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
201 1 : send_event->header.request_response_code = SPDM_SEND_EVENT;
202 1 : send_event->header.param1 = 0;
203 1 : send_event->header.param2 = 0;
204 1 : send_event->event_count = 2;
205 :
206 1 : certificate_changed.certificate_changed = 5;
207 :
208 1 : event_lost.last_acked_event_inst_id = 0xffeeddcc;
209 1 : event_lost.last_lost_event_inst_id = 0x55667788;
210 :
211 1 : ptr = (uint8_t *)(send_event + 1);
212 :
213 1 : generate_dmtf_event_data(ptr, &event_data_size[0], 0x11223343,
214 : SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED, &certificate_changed);
215 1 : ptr += event_data_size[0];
216 :
217 1 : generate_dmtf_event_data(ptr, &event_data_size[1], 0x11223345,
218 : SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
219 1 : ptr += event_data_size[1];
220 :
221 1 : m_event_counter = 0;
222 :
223 1 : m_expected_event[0].event_instance_id = 0x11223343;
224 1 : m_expected_event[0].svh_id = SPDM_REGISTRY_ID_DMTF;
225 1 : m_expected_event[0].svh_vendor_id_len = 0;
226 1 : m_expected_event[0].event_type_id = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED;
227 :
228 1 : m_expected_event[1].event_instance_id = 0x11223344;
229 1 : m_expected_event[1].svh_id = SPDM_REGISTRY_ID_DMTF;
230 1 : m_expected_event[1].svh_vendor_id_len = 0;
231 1 : m_expected_event[1].event_type_id = SPDM_DMTF_EVENT_TYPE_EVENT_LOST;
232 :
233 1 : request_size = sizeof(spdm_send_event_request_t) + event_data_size[0] + event_data_size[1];
234 :
235 1 : status = libspdm_get_response_send_event(
236 : spdm_context, request_size, m_spdm_request_buffer,
237 : &response_size, m_spdm_response_buffer);
238 :
239 1 : spdm_response = (spdm_error_response_t *)m_spdm_response_buffer;
240 :
241 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
242 :
243 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
244 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_13);
245 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
246 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
247 1 : assert_int_equal(spdm_response->header.param2, 0);
248 :
249 1 : assert_int_equal(m_event_counter, 0);
250 1 : }
251 :
252 : /**
253 : * Test 3: Send one event but the value of EventCount is two.
254 : * Expected behavior: InvalidRequest error response.
255 : **/
256 1 : static void rsp_event_ack_err_case3(void **state)
257 : {
258 : libspdm_return_t status;
259 : libspdm_test_context_t *spdm_test_context;
260 : libspdm_context_t *spdm_context;
261 : spdm_send_event_request_t *send_event;
262 : size_t request_size;
263 : spdm_error_response_t *spdm_response;
264 1 : size_t response_size = sizeof(m_spdm_response_buffer);
265 : uint8_t event_data_size;
266 : spdm_dmtf_event_type_event_lost_t event_lost;
267 :
268 1 : spdm_test_context = *state;
269 1 : spdm_context = spdm_test_context->spdm_context;
270 1 : spdm_test_context->case_id = 0x03;
271 :
272 1 : set_standard_state(spdm_context);
273 :
274 1 : send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
275 :
276 1 : send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
277 1 : send_event->header.request_response_code = SPDM_SEND_EVENT;
278 1 : send_event->header.param1 = 0;
279 1 : send_event->header.param2 = 0;
280 : /* Only one event but event_count is two. */
281 1 : send_event->event_count = 2;
282 :
283 1 : event_lost.last_acked_event_inst_id = 0xffeeddcc;
284 1 : event_lost.last_lost_event_inst_id = 0x55667788;
285 :
286 1 : generate_dmtf_event_data(send_event + 1, &event_data_size, 0x11223344,
287 : SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
288 :
289 1 : m_event_counter = 0;
290 :
291 1 : request_size = sizeof(spdm_send_event_request_t) + event_data_size;
292 :
293 1 : status = libspdm_get_response_send_event(
294 : spdm_context, request_size, m_spdm_request_buffer,
295 : &response_size, m_spdm_response_buffer);
296 :
297 1 : spdm_response = (spdm_error_response_t *)m_spdm_response_buffer;
298 :
299 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
300 :
301 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
302 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_13);
303 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
304 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
305 1 : assert_int_equal(spdm_response->header.param2, 0);
306 :
307 1 : assert_int_equal(m_event_counter, 0);
308 1 : }
309 :
310 : /**
311 : * Test 4: Send one event but request_size is not exact.
312 : * Expected behavior: InvalidRequest error response.
313 : **/
314 1 : static void rsp_event_ack_err_case4(void **state)
315 : {
316 : libspdm_return_t status;
317 : libspdm_test_context_t *spdm_test_context;
318 : libspdm_context_t *spdm_context;
319 : spdm_send_event_request_t *send_event;
320 : size_t request_size;
321 : spdm_error_response_t *spdm_response;
322 1 : size_t response_size = sizeof(m_spdm_response_buffer);
323 : uint8_t event_data_size;
324 : spdm_dmtf_event_type_event_lost_t event_lost;
325 :
326 1 : spdm_test_context = *state;
327 1 : spdm_context = spdm_test_context->spdm_context;
328 1 : spdm_test_context->case_id = 0x04;
329 :
330 1 : set_standard_state(spdm_context);
331 :
332 1 : send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
333 :
334 1 : send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
335 1 : send_event->header.request_response_code = SPDM_SEND_EVENT;
336 1 : send_event->header.param1 = 0;
337 1 : send_event->header.param2 = 0;
338 1 : send_event->event_count = 1;
339 :
340 1 : event_lost.last_acked_event_inst_id = 0xffeeddcc;
341 1 : event_lost.last_lost_event_inst_id = 0x55667788;
342 :
343 1 : generate_dmtf_event_data(send_event + 1, &event_data_size, 0x11223344,
344 : SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
345 :
346 1 : m_event_counter = 0;
347 :
348 : /* request_size is not exact (+ 1). */
349 1 : request_size = sizeof(spdm_send_event_request_t) + event_data_size + 1;
350 :
351 1 : status = libspdm_get_response_send_event(
352 : spdm_context, request_size, m_spdm_request_buffer,
353 : &response_size, m_spdm_response_buffer);
354 :
355 1 : spdm_response = (spdm_error_response_t *)m_spdm_response_buffer;
356 :
357 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
358 :
359 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
360 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_13);
361 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
362 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
363 1 : assert_int_equal(spdm_response->header.param2, 0);
364 :
365 1 : assert_int_equal(m_event_counter, 0);
366 1 : }
367 :
368 : /**
369 : * Test 5: Negotiated SPDM version does not support SEND_EVENT request message.
370 : * Expected Behavior: Responder returns SPDM_ERROR_CODE_UNSUPPORTED_REQUEST.
371 : **/
372 1 : static void rsp_event_ack_err_case5(void **state)
373 : {
374 : libspdm_return_t status;
375 : libspdm_test_context_t *spdm_test_context;
376 : libspdm_context_t *spdm_context;
377 : spdm_send_event_request_t *send_event;
378 : size_t request_size;
379 : spdm_error_response_t *spdm_response;
380 1 : size_t response_size = sizeof(m_spdm_response_buffer);
381 :
382 1 : spdm_test_context = *state;
383 1 : spdm_context = spdm_test_context->spdm_context;
384 1 : spdm_test_context->case_id = 0x05;
385 :
386 1 : set_standard_state(spdm_context);
387 :
388 : /* SPDM 1.2 does not support SEND_EVENT request message. */
389 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
390 : SPDM_VERSION_NUMBER_SHIFT_BIT;
391 :
392 1 : send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
393 :
394 1 : send_event->header.spdm_version = SPDM_MESSAGE_VERSION_12;
395 1 : send_event->header.request_response_code = SPDM_SEND_EVENT;
396 1 : send_event->header.param1 = 0;
397 1 : send_event->header.param2 = 0;
398 :
399 1 : m_event_counter = 0;
400 :
401 1 : request_size = sizeof(spdm_send_event_request_t);
402 :
403 1 : status = libspdm_get_response_send_event(
404 : spdm_context, request_size, m_spdm_request_buffer,
405 : &response_size, m_spdm_response_buffer);
406 :
407 1 : spdm_response = (spdm_error_response_t *)m_spdm_response_buffer;
408 :
409 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
410 :
411 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
412 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
413 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
414 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_UNSUPPORTED_REQUEST);
415 1 : assert_int_equal(spdm_response->header.param2, SPDM_SEND_EVENT);
416 :
417 1 : assert_int_equal(m_event_counter, 0);
418 1 : }
419 :
420 : /**
421 : * Test 6: SPDM version field in SEND_EVENT request message does not match the
422 : * connection's negotiated version.
423 : * Expected Behavior: Responder returns SPDM_ERROR_CODE_VERSION_MISMATCH.
424 : **/
425 1 : static void rsp_event_ack_err_case6(void **state)
426 : {
427 : libspdm_return_t status;
428 : libspdm_test_context_t *spdm_test_context;
429 : libspdm_context_t *spdm_context;
430 : spdm_send_event_request_t *send_event;
431 : size_t request_size;
432 : spdm_error_response_t *spdm_response;
433 1 : size_t response_size = sizeof(m_spdm_response_buffer);
434 :
435 1 : spdm_test_context = *state;
436 1 : spdm_context = spdm_test_context->spdm_context;
437 1 : spdm_test_context->case_id = 0x06;
438 :
439 1 : set_standard_state(spdm_context);
440 :
441 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_14 <<
442 : SPDM_VERSION_NUMBER_SHIFT_BIT;
443 :
444 1 : send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
445 :
446 : /* Value is not equal to the negotiated SPDM version (1.4). */
447 1 : send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
448 1 : send_event->header.request_response_code = SPDM_SEND_EVENT;
449 1 : send_event->header.param1 = 0;
450 1 : send_event->header.param2 = 0;
451 :
452 1 : m_event_counter = 0;
453 :
454 1 : request_size = sizeof(spdm_send_event_request_t);
455 :
456 1 : status = libspdm_get_response_send_event(
457 : spdm_context, request_size, m_spdm_request_buffer,
458 : &response_size, m_spdm_response_buffer);
459 :
460 1 : spdm_response = (spdm_error_response_t *)m_spdm_response_buffer;
461 :
462 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
463 :
464 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
465 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_14);
466 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
467 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_VERSION_MISMATCH);
468 1 : assert_int_equal(spdm_response->header.param2, 0);
469 :
470 1 : assert_int_equal(m_event_counter, 0);
471 1 : }
472 :
473 : /**
474 : * Test 7: Requester does not support EVENT_CAP.
475 : * Expected Behavior: Responder returns SPDM_ERROR_CODE_UNSUPPORTED_REQUEST.
476 : **/
477 1 : static void rsp_event_ack_err_case7(void **state)
478 : {
479 : libspdm_return_t status;
480 : libspdm_test_context_t *spdm_test_context;
481 : libspdm_context_t *spdm_context;
482 : spdm_send_event_request_t *send_event;
483 : size_t request_size;
484 : spdm_error_response_t *spdm_response;
485 1 : size_t response_size = sizeof(m_spdm_response_buffer);
486 :
487 1 : spdm_test_context = *state;
488 1 : spdm_context = spdm_test_context->spdm_context;
489 1 : spdm_test_context->case_id = 0x07;
490 :
491 1 : set_standard_state(spdm_context);
492 :
493 1 : send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
494 :
495 1 : send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
496 1 : send_event->header.request_response_code = SPDM_SEND_EVENT;
497 1 : send_event->header.param1 = 0;
498 1 : send_event->header.param2 = 0;
499 :
500 : /* Requester sends SEND_EVENT but does not support EVENT_CAP. */
501 1 : spdm_context->connection_info.capability.flags &=
502 : ~SPDM_GET_CAPABILITIES_REQUEST_FLAGS_EVENT_CAP;
503 :
504 1 : m_event_counter = 0;
505 :
506 1 : request_size = sizeof(spdm_send_event_request_t);
507 :
508 1 : status = libspdm_get_response_send_event(
509 : spdm_context, request_size, m_spdm_request_buffer,
510 : &response_size, m_spdm_response_buffer);
511 :
512 1 : spdm_response = (spdm_error_response_t *)m_spdm_response_buffer;
513 :
514 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
515 :
516 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
517 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_13);
518 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
519 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_UNSUPPORTED_REQUEST);
520 1 : assert_int_equal(spdm_response->header.param2, SPDM_SEND_EVENT);
521 :
522 1 : assert_int_equal(m_event_counter, 0);
523 1 : }
524 :
525 : /**
526 : * Test 8: Call to process_event returns an error.
527 : * Expected Behavior: Responder returns SPDM_ERROR_CODE_INVALID_REQUEST.
528 : **/
529 1 : static void rsp_event_ack_err_case8(void **state)
530 : {
531 : libspdm_return_t status;
532 : libspdm_test_context_t *spdm_test_context;
533 : libspdm_context_t *spdm_context;
534 : spdm_send_event_request_t *send_event;
535 : size_t request_size;
536 : spdm_error_response_t *spdm_response;
537 1 : size_t response_size = sizeof(m_spdm_response_buffer);
538 : uint8_t event_data_size;
539 : spdm_dmtf_event_type_event_lost_t event_lost;
540 :
541 1 : spdm_test_context = *state;
542 1 : spdm_context = spdm_test_context->spdm_context;
543 1 : spdm_test_context->case_id = 0x8;
544 :
545 1 : set_standard_state(spdm_context);
546 :
547 1 : send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
548 :
549 1 : send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
550 1 : send_event->header.request_response_code = SPDM_SEND_EVENT;
551 1 : send_event->header.param1 = 0;
552 1 : send_event->header.param2 = 0;
553 1 : send_event->event_count = 1;
554 :
555 1 : event_lost.last_acked_event_inst_id = 0xffeeddcc;
556 1 : event_lost.last_lost_event_inst_id = 0x55667788;
557 :
558 1 : generate_dmtf_event_data(send_event + 1, &event_data_size, 0x11223344,
559 : SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
560 :
561 1 : m_event_counter = 0;
562 :
563 1 : request_size = sizeof(spdm_send_event_request_t) + event_data_size;
564 :
565 : /* Induce error in process_request. */
566 1 : m_process_event_error = true;
567 :
568 1 : status = libspdm_get_response_send_event(
569 : spdm_context, request_size, m_spdm_request_buffer,
570 : &response_size, m_spdm_response_buffer);
571 :
572 1 : m_process_event_error = false;
573 :
574 1 : spdm_response = (spdm_error_response_t *)m_spdm_response_buffer;
575 :
576 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
577 :
578 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
579 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_13);
580 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
581 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
582 1 : assert_int_equal(spdm_response->header.param2, 0);
583 :
584 1 : assert_int_equal(m_event_counter, 0);
585 1 : }
586 :
587 1 : int libspdm_rsp_event_ack_error_test(void)
588 : {
589 1 : const struct CMUnitTest test_cases[] = {
590 : cmocka_unit_test(rsp_event_ack_err_case1),
591 : cmocka_unit_test(rsp_event_ack_err_case2),
592 : cmocka_unit_test(rsp_event_ack_err_case3),
593 : cmocka_unit_test(rsp_event_ack_err_case4),
594 : cmocka_unit_test(rsp_event_ack_err_case5),
595 : cmocka_unit_test(rsp_event_ack_err_case6),
596 : cmocka_unit_test(rsp_event_ack_err_case7),
597 : cmocka_unit_test(rsp_event_ack_err_case8),
598 : };
599 :
600 1 : libspdm_test_context_t test_context = {
601 : LIBSPDM_TEST_CONTEXT_VERSION,
602 : false,
603 : };
604 :
605 1 : libspdm_setup_test_context(&test_context);
606 :
607 1 : return cmocka_run_group_tests(test_cases,
608 : libspdm_unit_test_group_setup,
609 : libspdm_unit_test_group_teardown);
610 : }
611 :
612 : #endif /* LIBSPDM_EVENT_RECIPIENT_SUPPORT */
|
