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