Skip to content

Commit 6f83128

Browse files
jyao1jyao1
committed
1.4 Add unit test for FINISH/PSK_FINISH responder
Signed-off-by: Jiewen Yao <[email protected]>
1 parent 45daa58 commit 6f83128

File tree

2 files changed

+259
-1
lines changed

2 files changed

+259
-1
lines changed

‎unit_test/test_spdm_responder/finish.c‎

Lines changed: 141 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,14 @@ typedef struct {
1616
uint8_t verify_data[LIBSPDM_MAX_HASH_SIZE];
1717
} libspdm_finish_request_mine_t;
1818

19+
typedef struct {
20+
spdm_message_header_t header;
21+
uint16_t opaque_data_size;
22+
uint8_t opaque_data[8];
23+
uint8_t signature[LIBSPDM_MAX_ASYM_KEY_SIZE];
24+
uint8_t verify_data[LIBSPDM_MAX_HASH_SIZE];
25+
} libspdm_finish_request_mine_14_t;
26+
1927
#pragma pack()
2028

2129
libspdm_finish_request_mine_t m_libspdm_finish_request1 = {
@@ -48,6 +56,11 @@ libspdm_finish_request_mine_t m_libspdm_finish_request7 = {
4856
};
4957
size_t m_libspdm_finish_request7_size = sizeof(m_libspdm_finish_request7);
5058

59+
libspdm_finish_request_mine_14_t m_libspdm_finish_request8 = {
60+
{ SPDM_MESSAGE_VERSION_14, SPDM_FINISH, 0, 0 },
61+
};
62+
size_t m_libspdm_finish_request8_size = sizeof(m_libspdm_finish_request8);
63+
5164
uint8_t m_dummy_buffer[LIBSPDM_MAX_HASH_SIZE];
5265

5366
#if LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP
@@ -3834,6 +3847,132 @@ void libspdm_test_responder_finish_case29(void **state)
38343847
free(data1);
38353848
}
38363849

3850+
/**
3851+
* Test 30: SPDM version 1.4, with OpaqueData.
3852+
* Expected behavior: the responder accepts the request and produces a valid
3853+
* FINISH_RSP response message.
3854+
**/
3855+
void libspdm_test_responder_finish_case30(void **state)
3856+
{
3857+
libspdm_return_t status;
3858+
libspdm_test_context_t *spdm_test_context;
3859+
libspdm_context_t *spdm_context;
3860+
size_t response_size;
3861+
uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
3862+
spdm_finish_response_t *spdm_response;
3863+
void *data1;
3864+
size_t data_size1;
3865+
uint8_t *ptr;
3866+
uint8_t *cert_buffer;
3867+
size_t cert_buffer_size;
3868+
uint8_t cert_buffer_hash[LIBSPDM_MAX_HASH_SIZE];
3869+
uint8_t hash_data[LIBSPDM_MAX_HASH_SIZE];
3870+
uint8_t request_finished_key[LIBSPDM_MAX_HASH_SIZE];
3871+
libspdm_session_info_t *session_info;
3872+
uint32_t session_id;
3873+
uint32_t hash_size;
3874+
uint32_t hmac_size;
3875+
3876+
spdm_test_context = *state;
3877+
spdm_context = spdm_test_context->spdm_context;
3878+
spdm_test_context->case_id = 30;
3879+
spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_14 <<
3880+
SPDM_VERSION_NUMBER_SHIFT_BIT;
3881+
spdm_context->connection_info.connection_state =
3882+
LIBSPDM_CONNECTION_STATE_NEGOTIATED;
3883+
spdm_context->connection_info.capability.flags |=
3884+
SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
3885+
spdm_context->local_context.capability.flags |=
3886+
SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
3887+
3888+
spdm_context->connection_info.algorithm.base_hash_algo =
3889+
m_libspdm_use_hash_algo;
3890+
spdm_context->connection_info.algorithm.base_asym_algo =
3891+
m_libspdm_use_asym_algo;
3892+
spdm_context->connection_info.algorithm.measurement_spec =
3893+
m_libspdm_use_measurement_spec;
3894+
spdm_context->connection_info.algorithm.measurement_hash_algo =
3895+
m_libspdm_use_measurement_hash_algo;
3896+
spdm_context->connection_info.algorithm.dhe_named_group =
3897+
m_libspdm_use_dhe_algo;
3898+
spdm_context->connection_info.algorithm.aead_cipher_suite =
3899+
m_libspdm_use_aead_algo;
3900+
libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
3901+
m_libspdm_use_asym_algo, &data1,
3902+
&data_size1, NULL, NULL);
3903+
spdm_context->local_context.local_cert_chain_provision[0] = data1;
3904+
spdm_context->local_context.local_cert_chain_provision_size[0] =
3905+
data_size1;
3906+
spdm_context->connection_info.local_used_cert_chain_buffer = data1;
3907+
spdm_context->connection_info.local_used_cert_chain_buffer_size =
3908+
data_size1;
3909+
3910+
libspdm_reset_message_a(spdm_context);
3911+
spdm_context->local_context.mut_auth_requested = 0;
3912+
3913+
/* The requester and responder have not set HANDSHAKE_IN_THE_CLEAR*/
3914+
spdm_context->connection_info.capability.flags &=
3915+
~SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP;
3916+
spdm_context->local_context.capability.flags &=
3917+
~SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP;
3918+
3919+
session_id = 0xFFFFFFFF;
3920+
spdm_context->latest_session_id = session_id;
3921+
spdm_context->last_spdm_request_session_id_valid = true;
3922+
spdm_context->last_spdm_request_session_id = session_id;
3923+
session_info = &spdm_context->session_info[0];
3924+
libspdm_session_info_init(spdm_context, session_info, session_id, false);
3925+
3926+
hash_size = libspdm_get_hash_size(m_libspdm_use_hash_algo);
3927+
hmac_size = libspdm_get_hash_size(m_libspdm_use_hash_algo);
3928+
3929+
libspdm_set_mem(m_dummy_buffer, hash_size, (uint8_t)(0xFF));
3930+
libspdm_secured_message_set_request_finished_key(
3931+
session_info->secured_message_context, m_dummy_buffer,
3932+
hash_size);
3933+
libspdm_secured_message_set_session_state(
3934+
session_info->secured_message_context,
3935+
LIBSPDM_SESSION_STATE_HANDSHAKING);
3936+
3937+
m_libspdm_finish_request8.opaque_data_size = sizeof(m_libspdm_finish_request8.opaque_data);
3938+
3939+
hash_size = libspdm_get_hash_size(m_libspdm_use_hash_algo);
3940+
ptr = m_libspdm_finish_request8.signature;
3941+
libspdm_init_managed_buffer(&th_curr, sizeof(th_curr.buffer));
3942+
cert_buffer = (uint8_t *)data1;
3943+
cert_buffer_size = data_size1;
3944+
libspdm_hash_all(m_libspdm_use_hash_algo, cert_buffer, cert_buffer_size,
3945+
cert_buffer_hash);
3946+
/* transcript.message_a size is 0*/
3947+
libspdm_append_managed_buffer(&th_curr, cert_buffer_hash, hash_size);
3948+
/* session_transcript.message_k is 0*/
3949+
libspdm_append_managed_buffer(&th_curr, (uint8_t *)&m_libspdm_finish_request8,
3950+
sizeof(spdm_finish_request_t) + sizeof(uint16_t) +
3951+
m_libspdm_finish_request8.opaque_data_size);
3952+
libspdm_set_mem(request_finished_key, LIBSPDM_MAX_HASH_SIZE, (uint8_t)(0xFF));
3953+
libspdm_hash_all(m_libspdm_use_hash_algo, libspdm_get_managed_buffer(&th_curr),
3954+
libspdm_get_managed_buffer_size(&th_curr), hash_data);
3955+
libspdm_hmac_all(m_libspdm_use_hash_algo, hash_data, hash_size,
3956+
request_finished_key, hash_size, ptr);
3957+
m_libspdm_finish_request8_size = sizeof(spdm_finish_request_t) + hmac_size +
3958+
sizeof(uint16_t) + m_libspdm_finish_request8.opaque_data_size;
3959+
response_size = sizeof(response);
3960+
status = libspdm_get_response_finish(spdm_context,
3961+
m_libspdm_finish_request8_size,
3962+
&m_libspdm_finish_request8,
3963+
&response_size, response);
3964+
assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
3965+
/* The ResponderVerifyData field shall be absent.*/
3966+
ptr = (uint8_t *)response + sizeof(spdm_finish_response_t);
3967+
assert_int_equal(response_size,
3968+
sizeof(spdm_finish_response_t) + sizeof(uint16_t) +
3969+
libspdm_read_uint16(ptr));
3970+
spdm_response = (void *)response;
3971+
assert_int_equal(spdm_response->header.request_response_code,
3972+
SPDM_FINISH_RSP);
3973+
free(data1);
3974+
}
3975+
38373976
int libspdm_responder_finish_test_main(void)
38383977
{
38393978
const struct CMUnitTest spdm_responder_finish_tests[] = {
@@ -3893,6 +4032,8 @@ int libspdm_responder_finish_test_main(void)
38934032
cmocka_unit_test_setup(libspdm_test_responder_finish_case28, libspdm_unit_test_group_setup),
38944033
/* The requester and responder have not set HANDSHAKE_IN_THE_CLEAR*/
38954034
cmocka_unit_test(libspdm_test_responder_finish_case29),
4035+
/* SPDM 1.4 with OpaqueData */
4036+
cmocka_unit_test(libspdm_test_responder_finish_case30),
38964037
};
38974038

38984039
libspdm_test_context_t test_context = {

‎unit_test/test_spdm_responder/psk_finish.c‎

Lines changed: 118 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
/**
22
* Copyright Notice:
3-
* Copyright 2021-2022 DMTF. All rights reserved.
3+
* Copyright 2021-2025 DMTF. All rights reserved.
44
* License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
55
**/
66

@@ -14,6 +14,13 @@ typedef struct {
1414
spdm_message_header_t header;
1515
uint8_t verify_data[LIBSPDM_MAX_HASH_SIZE];
1616
} libspdm_psk_finish_request_mine_t;
17+
18+
typedef struct {
19+
spdm_message_header_t header;
20+
uint16_t opaque_data_size;
21+
uint8_t opaque_data[8];
22+
uint8_t verify_data[LIBSPDM_MAX_HASH_SIZE];
23+
} libspdm_psk_finish_request_mine_14_t;
1724
#pragma pack()
1825

1926
static libspdm_th_managed_buffer_t th_curr;
@@ -28,6 +35,11 @@ libspdm_psk_finish_request_mine_t m_libspdm_psk_finish_request2 = {
2835
};
2936
size_t m_libspdm_psk_finish_request2_size = LIBSPDM_MAX_SPDM_MSG_SIZE;
3037

38+
libspdm_psk_finish_request_mine_14_t m_libspdm_psk_finish_request3 = {
39+
{ SPDM_MESSAGE_VERSION_14, SPDM_PSK_FINISH, 0, 0 },
40+
};
41+
size_t m_libspdm_psk_finish_request3_size = sizeof(m_libspdm_psk_finish_request3);
42+
3143
static uint8_t m_libspdm_dummy_buffer[LIBSPDM_MAX_HASH_SIZE];
3244

3345
static void libspdm_secured_message_set_request_finished_key(
@@ -1497,6 +1509,8 @@ void libspdm_test_responder_psk_finish_case14(void **state)
14971509
spdm_test_context = *state;
14981510
spdm_context = spdm_test_context->spdm_context;
14991511
spdm_test_context->case_id = 0xE;
1512+
spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1513+
SPDM_VERSION_NUMBER_SHIFT_BIT;
15001514
spdm_context->connection_info.connection_state =
15011515
LIBSPDM_CONNECTION_STATE_NEGOTIATED;
15021516
spdm_context->connection_info.capability.flags |=
@@ -1572,6 +1586,107 @@ void libspdm_test_responder_psk_finish_case14(void **state)
15721586
free(data1);
15731587
}
15741588

1589+
/**
1590+
* Test 15: SPDM version 1.4, with OpaqueData.
1591+
* Expected behavior: the responder accepts the request and produces a valid PSK_FINISH
1592+
* response message.
1593+
**/
1594+
void libspdm_test_responder_psk_finish_case15(void **state)
1595+
{
1596+
libspdm_return_t status;
1597+
libspdm_test_context_t *spdm_test_context;
1598+
libspdm_context_t *spdm_context;
1599+
size_t response_size;
1600+
uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1601+
spdm_psk_finish_response_t *spdm_response;
1602+
void *data1;
1603+
size_t data_size1;
1604+
uint8_t *ptr;
1605+
uint8_t hash_data[LIBSPDM_MAX_HASH_SIZE];
1606+
uint8_t request_finished_key[LIBSPDM_MAX_HASH_SIZE];
1607+
libspdm_session_info_t *session_info;
1608+
uint32_t session_id;
1609+
uint32_t hash_size;
1610+
uint32_t hmac_size;
1611+
1612+
spdm_test_context = *state;
1613+
spdm_context = spdm_test_context->spdm_context;
1614+
spdm_test_context->case_id = 0xF;
1615+
spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_14 <<
1616+
SPDM_VERSION_NUMBER_SHIFT_BIT;
1617+
spdm_context->connection_info.connection_state =
1618+
LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1619+
spdm_context->connection_info.capability.flags |=
1620+
SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1621+
spdm_context->local_context.capability.flags |=
1622+
SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1623+
spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1624+
spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1625+
spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1626+
spdm_context->connection_info.algorithm.measurement_hash_algo =
1627+
m_libspdm_use_measurement_hash_algo;
1628+
spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1629+
spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1630+
libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1631+
m_libspdm_use_asym_algo, &data1,
1632+
&data_size1, NULL, NULL);
1633+
spdm_context->local_context.local_cert_chain_provision[0] = data1;
1634+
spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
1635+
spdm_context->connection_info.local_used_cert_chain_buffer = data1;
1636+
spdm_context->connection_info.local_used_cert_chain_buffer_size = data_size1;
1637+
1638+
libspdm_reset_message_a(spdm_context);
1639+
spdm_context->local_context.mut_auth_requested = 0;
1640+
1641+
session_id = 0xFFFFFFFF;
1642+
spdm_context->latest_session_id = session_id;
1643+
spdm_context->last_spdm_request_session_id_valid = true;
1644+
spdm_context->last_spdm_request_session_id = session_id;
1645+
session_info = &spdm_context->session_info[0];
1646+
libspdm_session_info_init(spdm_context, session_info, session_id, true);
1647+
libspdm_session_info_set_psk_hint(session_info,
1648+
LIBSPDM_TEST_PSK_HINT_STRING,
1649+
sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1650+
hash_size = libspdm_get_hash_size(m_libspdm_use_hash_algo);
1651+
libspdm_set_mem(m_libspdm_dummy_buffer, hash_size, (uint8_t)(0xFF));
1652+
libspdm_secured_message_set_request_finished_key(
1653+
session_info->secured_message_context, m_libspdm_dummy_buffer, hash_size);
1654+
libspdm_secured_message_set_session_state(
1655+
session_info->secured_message_context, LIBSPDM_SESSION_STATE_HANDSHAKING);
1656+
1657+
m_libspdm_psk_finish_request3.opaque_data_size =
1658+
sizeof(m_libspdm_psk_finish_request3.opaque_data);
1659+
hash_size = libspdm_get_hash_size(m_libspdm_use_hash_algo);
1660+
hmac_size = libspdm_get_hash_size(m_libspdm_use_hash_algo);
1661+
ptr = m_libspdm_psk_finish_request3.verify_data;
1662+
libspdm_init_managed_buffer(&th_curr, sizeof(th_curr.buffer));
1663+
/* transcript.message_a size is 0
1664+
* session_transcript.message_k is 0*/
1665+
libspdm_append_managed_buffer(&th_curr, (uint8_t *)&m_libspdm_psk_finish_request3,
1666+
sizeof(spdm_psk_finish_request_t) + sizeof(uint16_t) +
1667+
m_libspdm_psk_finish_request3.opaque_data_size);
1668+
libspdm_set_mem(request_finished_key, LIBSPDM_MAX_HASH_SIZE, (uint8_t)(0xFF));
1669+
libspdm_hash_all(m_libspdm_use_hash_algo, libspdm_get_managed_buffer(&th_curr),
1670+
libspdm_get_managed_buffer_size(&th_curr), hash_data);
1671+
libspdm_hmac_all(m_libspdm_use_hash_algo, hash_data, hash_size,
1672+
request_finished_key, hash_size, ptr);
1673+
m_libspdm_psk_finish_request3_size = sizeof(spdm_psk_finish_request_t) + hmac_size +
1674+
sizeof(uint16_t) +
1675+
m_libspdm_psk_finish_request3.opaque_data_size;
1676+
response_size = sizeof(response);
1677+
status = libspdm_get_response_psk_finish(
1678+
spdm_context, m_libspdm_psk_finish_request3_size, &m_libspdm_psk_finish_request3,
1679+
&response_size, response);
1680+
assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1681+
ptr = (uint8_t *)response + sizeof(spdm_psk_finish_response_t);
1682+
assert_int_equal(response_size, sizeof(spdm_psk_finish_response_t) +
1683+
sizeof(uint16_t) + libspdm_read_uint16(ptr));
1684+
spdm_response = (void *)response;
1685+
assert_int_equal(spdm_response->header.request_response_code, SPDM_PSK_FINISH_RSP);
1686+
1687+
free(data1);
1688+
}
1689+
15751690
int libspdm_responder_psk_finish_test_main(void)
15761691
{
15771692
const struct CMUnitTest spdm_responder_psk_finish_tests[] = {
@@ -1603,6 +1718,8 @@ int libspdm_responder_psk_finish_test_main(void)
16031718
cmocka_unit_test(libspdm_test_responder_psk_finish_case13),
16041719
/* Buffer verification*/
16051720
cmocka_unit_test(libspdm_test_responder_psk_finish_case14),
1721+
/* SPDM 1.4 with OpaqueData */
1722+
cmocka_unit_test(libspdm_test_responder_psk_finish_case15),
16061723
};
16071724

16081725
libspdm_test_context_t test_context = {

0 commit comments

Comments
 (0)