Skip to content

Encapsulated SUPPORTED_EVENT_TYPES support for Requester #3173

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Sep 3, 2025
Merged

Encapsulated SUPPORTED_EVENT_TYPES support for Requester #3173

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
7 changes: 7 additions & 0 deletions include/internal/libspdm_requester_lib.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -498,6 +498,13 @@ libspdm_return_t libspdm_get_encap_response_event_ack(void *spdm_context,
size_t *response_size,
void *response);
#endif /* LIBSPDM_EVENT_RECIPIENT_SUPPORT */
#if LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP
libspdm_return_t libspdm_get_encap_supported_event_types(void *spdm_context,
size_t request_size,
void *request,
size_t *response_size,
void *response);
#endif /* LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP */
#if LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP
libspdm_return_t libspdm_get_encap_response_endpoint_info(void *spdm_context,
size_t request_size,
Expand Down
3 changes: 2 additions & 1 deletion library/spdm_requester_lib/CMakeLists.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,6 +20,7 @@ target_sources(spdm_requester_lib
libspdm_req_encap_event_ack.c
libspdm_req_encap_endpoint_info.c
libspdm_req_encap_request.c
libspdm_req_encap_supported_event_types.c
libspdm_req_end_session.c
libspdm_req_finish.c
libspdm_req_get_capabilities.c
Expand All @@ -44,4 +45,4 @@ target_sources(spdm_requester_lib
libspdm_req_get_measurement_extension_log.c
libspdm_req_get_key_pair_info.c
libspdm_req_set_key_pair_info.c
)
)
6 changes: 5 additions & 1 deletion library/spdm_requester_lib/libspdm_req_encap_request.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -35,7 +35,7 @@ libspdm_get_encap_response_func_via_request_code(uint8_t request_response_code)

size_t index;

libspdm_get_encap_response_struct_t get_encap_response_struct[] = {
const libspdm_get_encap_response_struct_t get_encap_response_struct[] = {
#if LIBSPDM_ENABLE_CAPABILITY_CERT_CAP
{ SPDM_GET_DIGESTS, libspdm_get_encap_response_digest },
{ SPDM_GET_CERTIFICATE, libspdm_get_encap_response_certificate },
Expand All @@ -53,6 +53,10 @@ libspdm_get_encap_response_func_via_request_code(uint8_t request_response_code)
{ SPDM_SEND_EVENT, libspdm_get_encap_response_event_ack },
#endif /* LIBSPDM_EVENT_RECIPIENT_SUPPORT */

#if LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP
{ SPDM_GET_SUPPORTED_EVENT_TYPES, libspdm_get_encap_supported_event_types },
#endif /* LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP */

#if LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP
{ SPDM_GET_ENDPOINT_INFO, libspdm_get_encap_response_endpoint_info },
#endif /* LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP */
Expand Down
107 changes: 107 additions & 0 deletions library/spdm_requester_lib/libspdm_req_encap_supported_event_types.c
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,107 @@
/**
* Copyright Notice:
* Copyright 2025 DMTF. All rights reserved.
* License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
**/

#include "internal/libspdm_requester_lib.h"
#include "internal/libspdm_secured_message_lib.h"

#if (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP)

libspdm_return_t libspdm_get_encap_supported_event_types(void *spdm_context,
size_t request_size,
void *request,
size_t *response_size,
void *response)
{
uint32_t session_id;
spdm_supported_event_types_response_t *spdm_response;
spdm_get_supported_event_types_request_t *spdm_request;
const size_t response_buffer_size = *response_size;
libspdm_context_t *context;
libspdm_session_info_t *session_info;
libspdm_session_state_t session_state;
uint32_t supported_event_groups_list_len;
uint8_t event_group_count;

context = spdm_context;
spdm_request = request;

if (libspdm_get_connection_version(context) < SPDM_MESSAGE_VERSION_13) {
return libspdm_generate_encap_error_response(
context, SPDM_ERROR_CODE_UNSUPPORTED_REQUEST, SPDM_GET_SUPPORTED_EVENT_TYPES,
response_size, response);
}
if (spdm_request->header.spdm_version != libspdm_get_connection_version(context)) {
return libspdm_generate_encap_error_response(
context, SPDM_ERROR_CODE_VERSION_MISMATCH, 0, response_size, response);
}
if (!libspdm_is_capabilities_flag_supported(
context, true, SPDM_GET_CAPABILITIES_REQUEST_FLAGS_EVENT_CAP, 0)) {
return libspdm_generate_encap_error_response(
context, SPDM_ERROR_CODE_UNSUPPORTED_REQUEST, SPDM_GET_SUPPORTED_EVENT_TYPES,
response_size, response);
}
if (!context->last_spdm_request_session_id_valid) {
return libspdm_generate_encap_error_response(
context, SPDM_ERROR_CODE_SESSION_REQUIRED, 0, response_size, response);
}

session_id = context->last_spdm_request_session_id;
session_info = libspdm_get_session_info_via_session_id(context, session_id);
if (session_info == NULL) {
return libspdm_generate_encap_error_response(
context, SPDM_ERROR_CODE_INVALID_REQUEST, 0, response_size, response);
}

session_state = libspdm_secured_message_get_session_state(
session_info->secured_message_context);
if (session_state != LIBSPDM_SESSION_STATE_ESTABLISHED) {
return libspdm_generate_encap_error_response(
context, SPDM_ERROR_CODE_INVALID_REQUEST, 0, response_size, response);
}

libspdm_reset_message_buffer_via_request_code(context, session_info,
spdm_request->header.request_response_code);

/* This message can only be in secured session.
* Thus don't need to consider transport layer padding, just check its exact size. */
if (request_size != sizeof(spdm_get_supported_event_types_request_t)) {
return libspdm_generate_encap_error_response(
context, SPDM_ERROR_CODE_INVALID_REQUEST, 0,
response_size, response);
}

spdm_response = response;

spdm_response->header.spdm_version = libspdm_get_connection_version(context);
spdm_response->header.request_response_code = SPDM_SUPPORTED_EVENT_TYPES;
spdm_response->header.param2 = 0;

supported_event_groups_list_len = (uint32_t)(response_buffer_size -
sizeof(spdm_supported_event_types_response_t));

if (!libspdm_event_get_types(context, context->connection_info.version, session_id,
(void *)(spdm_response + 1), &supported_event_groups_list_len,
&event_group_count)) {
return libspdm_generate_encap_error_response(context,
SPDM_ERROR_CODE_UNSPECIFIED, 0,
response_size, response);
}

LIBSPDM_ASSERT(supported_event_groups_list_len > 0);
LIBSPDM_ASSERT(supported_event_groups_list_len <=
(response_buffer_size - sizeof(spdm_supported_event_types_response_t)));
LIBSPDM_ASSERT(event_group_count > 0);

spdm_response->header.param1 = event_group_count;
spdm_response->supported_event_groups_list_len = supported_event_groups_list_len;

*response_size = sizeof(spdm_supported_event_types_response_t) +
supported_event_groups_list_len;

return LIBSPDM_STATUS_SUCCESS;
}

#endif /* (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP) */
2 changes: 2 additions & 0 deletions unit_test/test_spdm_requester/CMakeLists.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -41,6 +41,7 @@ target_sources(test_spdm_requester
encap_endpoint_info.c
encap_key_update.c
encap_request.c
encap_supported_event_types.c
set_certificate.c
get_csr.c
chunk_get.c
Expand All @@ -63,6 +64,7 @@ target_sources(test_spdm_requester
error_test/encap_event_ack_err.c
error_test/get_endpoint_info_err.c
error_test/encap_endpoint_info_err.c
error_test/encap_supported_event_types_err.c
${LIBSPDM_DIR}/unit_test/spdm_unit_test_common/common.c
${LIBSPDM_DIR}/unit_test/spdm_unit_test_common/algo.c
${LIBSPDM_DIR}/unit_test/spdm_unit_test_common/support.c
Expand Down
131 changes: 131 additions & 0 deletions unit_test/test_spdm_requester/encap_supported_event_types.c
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,131 @@
/**
* Copyright Notice:
* Copyright 2025 DMTF. All rights reserved.
* License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
**/

#include "spdm_unit_test.h"
#include "internal/libspdm_requester_lib.h"

#if (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP)

static uint8_t m_spdm_request_buffer[0x1000];
static uint8_t m_spdm_response_buffer[0x1000];

static const uint32_t m_session_id = 0xffffffff;

extern uint32_t g_supported_event_groups_list_len;
extern uint8_t g_event_group_count;

static void set_standard_state(libspdm_context_t *spdm_context)
{
libspdm_session_info_t *session_info;

spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
SPDM_VERSION_NUMBER_SHIFT_BIT;
spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;

spdm_context->connection_info.capability.flags |=
SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
spdm_context->connection_info.capability.flags |=
SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
spdm_context->connection_info.capability.flags |=
SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
spdm_context->connection_info.capability.flags |=
SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;

spdm_context->local_context.capability.flags |=
SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
spdm_context->local_context.capability.flags |=
SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
spdm_context->local_context.capability.flags |=
SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
spdm_context->local_context.capability.flags |=
SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
spdm_context->local_context.capability.flags |=
SPDM_GET_CAPABILITIES_REQUEST_FLAGS_EVENT_CAP;

spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;

spdm_context->latest_session_id = m_session_id;
spdm_context->last_spdm_request_session_id_valid = true;
spdm_context->last_spdm_request_session_id = m_session_id;
session_info = &spdm_context->session_info[0];
libspdm_session_info_init(spdm_context, session_info, m_session_id, true);
libspdm_secured_message_set_session_state(
session_info->secured_message_context,
LIBSPDM_SESSION_STATE_ESTABLISHED);
}

static void test_supported_event_types_case1(void **state)
{
libspdm_return_t status;
libspdm_test_context_t *spdm_test_context;
libspdm_context_t *spdm_context;
spdm_get_supported_event_types_request_t *get_supported_event_types;
size_t request_size;
spdm_supported_event_types_response_t *supported_event_types;
size_t response_size = sizeof(m_spdm_response_buffer);

spdm_test_context = *state;
spdm_context = spdm_test_context->spdm_context;
spdm_test_context->case_id = 0x01;

set_standard_state(spdm_context);

get_supported_event_types = (spdm_get_supported_event_types_request_t *)m_spdm_request_buffer;

get_supported_event_types->header.spdm_version = SPDM_MESSAGE_VERSION_13;
get_supported_event_types->header.request_response_code = SPDM_GET_SUPPORTED_EVENT_TYPES;
get_supported_event_types->header.param1 = 0;
get_supported_event_types->header.param2 = 0;

request_size = sizeof(spdm_get_supported_event_types_request_t);

status = libspdm_get_encap_supported_event_types(spdm_context,
request_size,
m_spdm_request_buffer,
&response_size,
m_spdm_response_buffer);

supported_event_types = (spdm_supported_event_types_response_t *)m_spdm_response_buffer;

assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
assert_int_equal(supported_event_types->header.spdm_version, SPDM_MESSAGE_VERSION_13);
assert_int_equal(supported_event_types->header.request_response_code, SPDM_SUPPORTED_EVENT_TYPES);
assert_int_equal(supported_event_types->header.param1, g_event_group_count);
assert_int_equal(supported_event_types->header.param2, 0);
assert_int_equal(supported_event_types->supported_event_groups_list_len,
g_supported_event_groups_list_len);

for (uint32_t index = 0; index < supported_event_types->supported_event_groups_list_len; index++)
{
assert_int_equal(((char *)(supported_event_types + 1))[index], (char)index);
}

libspdm_dump_data(m_spdm_response_buffer, response_size);
LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
}

int libspdm_requester_encap_supported_event_types_test_main(void)
{
const struct CMUnitTest spdm_requester_supported_event_types_tests[] = {
cmocka_unit_test(test_supported_event_types_case1),
};

libspdm_test_context_t test_context = {
LIBSPDM_TEST_CONTEXT_VERSION,
false,
};

libspdm_setup_test_context(&test_context);

return cmocka_run_group_tests(spdm_requester_supported_event_types_tests,
libspdm_unit_test_group_setup,
libspdm_unit_test_group_teardown);
}

#endif /* (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP) */
Loading
Loading