Skip to content

Commit ca2fde8

Browse files
Xiaohanjllljyao1
Xiaohanjlll
authored and
jyao1
committed
add uinit test for measurements 1.3
Signed-off-by: Xiaohanjlll <[email protected]>
1 parent a9c0332 commit ca2fde8

File tree

2 files changed

+389
-0
lines changed

2 files changed

+389
-0
lines changed

‎unit_test/test_spdm_requester/get_measurements.c

+315
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,8 @@ static uint8_t m_libspdm_msg_log_buffer[LIBSPDM_MAX_MESSAGE_L1L2_BUFFER_SIZE * 2
2020
static size_t m_libspdm_opaque_data_size;
2121
static uint8_t m_libspdm_opaque_data[SPDM_MAX_OPAQUE_DATA_SIZE];
2222

23+
static uint8_t m_requester_context[SPDM_REQ_CONTEXT_SIZE];
24+
2325
static size_t libspdm_test_get_measurement_request_size(const void *spdm_context,
2426
const void *buffer,
2527
size_t buffer_size)
@@ -450,6 +452,16 @@ static libspdm_return_t libspdm_requester_get_measurements_test_send_message(
450452
(const uint8_t *)request + header_size, message_size);
451453
m_libspdm_local_buffer_size += message_size;
452454
return LIBSPDM_STATUS_SUCCESS;
455+
case 0x28:
456+
case 0x29:
457+
m_libspdm_local_buffer_size = 0;
458+
message_size = libspdm_test_get_measurement_request_size(
459+
spdm_context, (const uint8_t *)request + header_size,
460+
request_size - header_size);
461+
libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
462+
(const uint8_t *)request + header_size, message_size);
463+
m_libspdm_local_buffer_size += message_size;
464+
return LIBSPDM_STATUS_SUCCESS;
453465
default:
454466
return LIBSPDM_STATUS_SEND_FAIL;
455467
}
@@ -3115,6 +3127,143 @@ static libspdm_return_t libspdm_requester_get_measurements_test_receive_message(
31153127
ptr, &sig_size);
31163128
ptr += sig_size;
31173129

3130+
libspdm_transport_test_encode_message(spdm_context, NULL, false,
3131+
false, spdm_response_size,
3132+
spdm_response, response_size,
3133+
response);
3134+
}
3135+
return LIBSPDM_STATUS_SUCCESS;
3136+
case 0x28: {
3137+
spdm_measurements_response_t *spdm_response;
3138+
spdm_measurement_block_dmtf_t *measurment_block;
3139+
size_t spdm_response_size;
3140+
size_t transport_header_size;
3141+
uint8_t *ptr;
3142+
((libspdm_context_t *)spdm_context)
3143+
->connection_info.algorithm.measurement_hash_algo =
3144+
m_libspdm_use_measurement_hash_algo;
3145+
spdm_response_size = sizeof(spdm_measurements_response_t) +
3146+
sizeof(spdm_measurement_block_dmtf_t) +
3147+
libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo)
3148+
+ SPDM_NONCE_SIZE + sizeof(uint16_t) + SPDM_REQ_CONTEXT_SIZE;
3149+
3150+
transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
3151+
spdm_response = (void *)((uint8_t *)*response + transport_header_size);
3152+
3153+
spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
3154+
spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
3155+
spdm_response->header.param1 = 0;
3156+
spdm_response->header.param2 = 0;
3157+
spdm_response->number_of_blocks = 1;
3158+
libspdm_write_uint24(
3159+
spdm_response->measurement_record_length,
3160+
(uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
3161+
libspdm_get_measurement_hash_size( m_libspdm_use_measurement_hash_algo)));
3162+
3163+
measurment_block = (void *)(spdm_response + 1);
3164+
libspdm_set_mem(measurment_block,
3165+
sizeof(spdm_measurement_block_dmtf_t) +
3166+
libspdm_get_measurement_hash_size(
3167+
m_libspdm_use_measurement_hash_algo),
3168+
1);
3169+
3170+
measurment_block->measurement_block_common_header
3171+
.measurement_specification =
3172+
SPDM_MEASUREMENT_SPECIFICATION_DMTF;
3173+
measurment_block->measurement_block_common_header
3174+
.measurement_size =
3175+
(uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
3176+
libspdm_get_measurement_hash_size(
3177+
m_libspdm_use_measurement_hash_algo));
3178+
3179+
ptr = (uint8_t *)spdm_response +
3180+
sizeof(spdm_measurements_response_t) +
3181+
sizeof(spdm_measurement_block_dmtf_t) +
3182+
libspdm_get_measurement_hash_size(
3183+
m_libspdm_use_measurement_hash_algo);
3184+
libspdm_get_random_number(SPDM_NONCE_SIZE,ptr);
3185+
3186+
ptr += SPDM_NONCE_SIZE;
3187+
*(uint16_t *)ptr = 0;
3188+
3189+
ptr += sizeof(uint16_t);
3190+
libspdm_copy_mem(ptr, SPDM_REQ_CONTEXT_SIZE, m_requester_context, SPDM_REQ_CONTEXT_SIZE);
3191+
3192+
libspdm_copy_mem(m_libspdm_local_buffer + m_libspdm_local_buffer_size,
3193+
sizeof(m_libspdm_local_buffer) - m_libspdm_local_buffer_size,
3194+
spdm_response, spdm_response_size);
3195+
3196+
m_libspdm_local_buffer_size += spdm_response_size;
3197+
3198+
libspdm_transport_test_encode_message(spdm_context, NULL, false,
3199+
false, spdm_response_size,
3200+
spdm_response, response_size,
3201+
response);
3202+
}
3203+
return LIBSPDM_STATUS_SUCCESS;
3204+
case 0x29: {
3205+
spdm_measurements_response_t *spdm_response;
3206+
spdm_measurement_block_dmtf_t *measurment_block;
3207+
size_t spdm_response_size;
3208+
size_t transport_header_size;
3209+
uint8_t *ptr;
3210+
((libspdm_context_t *)spdm_context)
3211+
->connection_info.algorithm.measurement_hash_algo =
3212+
m_libspdm_use_measurement_hash_algo;
3213+
spdm_response_size = sizeof(spdm_measurements_response_t) +
3214+
sizeof(spdm_measurement_block_dmtf_t) +
3215+
libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo)
3216+
+
3217+
SPDM_NONCE_SIZE + sizeof(uint16_t) + SPDM_REQ_CONTEXT_SIZE;
3218+
3219+
transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
3220+
spdm_response = (void *)((uint8_t *)*response + transport_header_size);
3221+
3222+
spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
3223+
spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
3224+
spdm_response->header.param1 = 0;
3225+
spdm_response->header.param2 = 0;
3226+
spdm_response->number_of_blocks = 1;
3227+
libspdm_write_uint24(
3228+
spdm_response->measurement_record_length,
3229+
(uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
3230+
libspdm_get_measurement_hash_size( m_libspdm_use_measurement_hash_algo)));
3231+
3232+
measurment_block = (void *)(spdm_response + 1);
3233+
libspdm_set_mem(measurment_block,
3234+
sizeof(spdm_measurement_block_dmtf_t) +
3235+
libspdm_get_measurement_hash_size(
3236+
m_libspdm_use_measurement_hash_algo),
3237+
1);
3238+
3239+
measurment_block->measurement_block_common_header
3240+
.measurement_specification =
3241+
SPDM_MEASUREMENT_SPECIFICATION_DMTF;
3242+
measurment_block->measurement_block_common_header
3243+
.measurement_size =
3244+
(uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
3245+
libspdm_get_measurement_hash_size(
3246+
m_libspdm_use_measurement_hash_algo));
3247+
3248+
ptr = (uint8_t *)spdm_response +
3249+
sizeof(spdm_measurements_response_t) +
3250+
sizeof(spdm_measurement_block_dmtf_t) +
3251+
libspdm_get_measurement_hash_size(
3252+
m_libspdm_use_measurement_hash_algo);
3253+
libspdm_get_random_number(SPDM_NONCE_SIZE,ptr);
3254+
3255+
ptr += SPDM_NONCE_SIZE;
3256+
*(uint16_t *)ptr = 0;
3257+
3258+
ptr += sizeof(uint16_t);
3259+
libspdm_get_random_number(SPDM_REQ_CONTEXT_SIZE,ptr);
3260+
3261+
libspdm_copy_mem(m_libspdm_local_buffer + m_libspdm_local_buffer_size,
3262+
sizeof(m_libspdm_local_buffer) - m_libspdm_local_buffer_size,
3263+
spdm_response, spdm_response_size);
3264+
3265+
m_libspdm_local_buffer_size += spdm_response_size;
3266+
31183267
libspdm_transport_test_encode_message(spdm_context, NULL, false,
31193268
false, spdm_response_size,
31203269
spdm_response, response_size,
@@ -6033,6 +6182,170 @@ static void libspdm_test_requester_get_measurements_case39(void **state)
60336182
free(data);
60346183
}
60356184

6185+
/**
6186+
* Test 40: Successful case , correct measuerments context field , without signature
6187+
* Expected Behavior: client returns a status of RETURN_SUCCESS.
6188+
**/
6189+
static void libspdm_test_requester_get_measurements_case40(void **state)
6190+
{
6191+
libspdm_return_t status;
6192+
libspdm_test_context_t *spdm_test_context;
6193+
libspdm_context_t *spdm_context;
6194+
uint8_t number_of_block;
6195+
uint32_t measurement_record_length;
6196+
uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
6197+
uint8_t request_attribute;
6198+
void *data;
6199+
size_t data_size;
6200+
void *hash;
6201+
size_t hash_size;
6202+
6203+
spdm_test_context = *state;
6204+
spdm_context = spdm_test_context->spdm_context;
6205+
spdm_test_context->case_id = 0x28;
6206+
spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
6207+
SPDM_VERSION_NUMBER_SHIFT_BIT;
6208+
spdm_context->connection_info.connection_state =
6209+
LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
6210+
spdm_context->connection_info.capability.flags |=
6211+
SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
6212+
libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
6213+
m_libspdm_use_asym_algo, &data,
6214+
&data_size, &hash, &hash_size);
6215+
libspdm_reset_message_m(spdm_context, NULL);
6216+
spdm_context->connection_info.algorithm.measurement_spec =
6217+
m_libspdm_use_measurement_spec;
6218+
spdm_context->connection_info.algorithm.measurement_hash_algo =
6219+
m_libspdm_use_measurement_hash_algo;
6220+
spdm_context->connection_info.algorithm.base_hash_algo =
6221+
m_libspdm_use_hash_algo;
6222+
spdm_context->connection_info.algorithm.base_asym_algo =
6223+
m_libspdm_use_asym_algo;
6224+
spdm_context->local_context.algorithm.measurement_spec =
6225+
SPDM_MEASUREMENT_SPECIFICATION_DMTF;
6226+
6227+
#if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
6228+
spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
6229+
libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
6230+
sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
6231+
data, data_size);
6232+
#else
6233+
libspdm_hash_all(
6234+
spdm_context->connection_info.algorithm.base_hash_algo,
6235+
data, data_size,
6236+
spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
6237+
spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
6238+
libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
6239+
libspdm_get_leaf_cert_public_key_from_cert_chain(
6240+
spdm_context->connection_info.algorithm.base_hash_algo,
6241+
spdm_context->connection_info.algorithm.base_asym_algo,
6242+
data, data_size,
6243+
&spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
6244+
#endif
6245+
6246+
measurement_record_length = sizeof(measurement_record);
6247+
6248+
libspdm_set_mem(m_requester_context, SPDM_REQ_CONTEXT_SIZE, 0xAA);
6249+
6250+
request_attribute = 0; /* Do not request a signature. */
6251+
6252+
status = libspdm_get_measurement_ex2(spdm_context, NULL, request_attribute, 1,
6253+
0, m_requester_context, NULL, &number_of_block,
6254+
&measurement_record_length,
6255+
measurement_record, NULL, NULL, NULL, NULL, NULL);
6256+
6257+
assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
6258+
6259+
#if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
6260+
assert_int_equal(spdm_context->transcript.message_m.buffer_size,
6261+
sizeof(spdm_message_header_t) + SPDM_REQ_CONTEXT_SIZE +
6262+
sizeof(spdm_measurements_response_t) +
6263+
sizeof(spdm_measurement_block_dmtf_t) +
6264+
libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo) +
6265+
SPDM_NONCE_SIZE + sizeof(uint16_t) + SPDM_REQ_CONTEXT_SIZE);
6266+
#endif
6267+
free(data);
6268+
}
6269+
6270+
/**
6271+
* Test 41: Error case , Measurement context fields are inconsistent , without signature
6272+
* Expected Behavior: get a LIBSPDM_STATUS_INVALID_MSG_FIELD return code
6273+
**/
6274+
static void libspdm_test_requester_get_measurements_case41(void **state)
6275+
{
6276+
libspdm_return_t status;
6277+
libspdm_test_context_t *spdm_test_context;
6278+
libspdm_context_t *spdm_context;
6279+
uint8_t number_of_block;
6280+
uint32_t measurement_record_length;
6281+
uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
6282+
uint8_t request_attribute;
6283+
void *data;
6284+
size_t data_size;
6285+
void *hash;
6286+
size_t hash_size;
6287+
6288+
spdm_test_context = *state;
6289+
spdm_context = spdm_test_context->spdm_context;
6290+
spdm_test_context->case_id = 0x29;
6291+
spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
6292+
SPDM_VERSION_NUMBER_SHIFT_BIT;
6293+
spdm_context->connection_info.connection_state =
6294+
LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
6295+
spdm_context->connection_info.capability.flags |=
6296+
SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
6297+
libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
6298+
m_libspdm_use_asym_algo, &data,
6299+
&data_size, &hash, &hash_size);
6300+
libspdm_reset_message_m(spdm_context, NULL);
6301+
spdm_context->connection_info.algorithm.measurement_spec =
6302+
m_libspdm_use_measurement_spec;
6303+
spdm_context->connection_info.algorithm.measurement_hash_algo =
6304+
m_libspdm_use_measurement_hash_algo;
6305+
spdm_context->connection_info.algorithm.base_hash_algo =
6306+
m_libspdm_use_hash_algo;
6307+
spdm_context->connection_info.algorithm.base_asym_algo =
6308+
m_libspdm_use_asym_algo;
6309+
spdm_context->local_context.algorithm.measurement_spec =
6310+
SPDM_MEASUREMENT_SPECIFICATION_DMTF;
6311+
6312+
#if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
6313+
spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
6314+
libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
6315+
sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
6316+
data, data_size);
6317+
#else
6318+
libspdm_hash_all(
6319+
spdm_context->connection_info.algorithm.base_hash_algo,
6320+
data, data_size,
6321+
spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
6322+
spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
6323+
libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
6324+
libspdm_get_leaf_cert_public_key_from_cert_chain(
6325+
spdm_context->connection_info.algorithm.base_hash_algo,
6326+
spdm_context->connection_info.algorithm.base_asym_algo,
6327+
data, data_size,
6328+
&spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
6329+
#endif
6330+
6331+
measurement_record_length = sizeof(measurement_record);
6332+
6333+
libspdm_set_mem(m_requester_context, SPDM_REQ_CONTEXT_SIZE, 0xAA);
6334+
6335+
request_attribute = 0; /* Do not request a signature. */
6336+
6337+
status = libspdm_get_measurement_ex2(spdm_context, NULL, request_attribute, 1,
6338+
0, m_requester_context, NULL, &number_of_block,
6339+
&measurement_record_length,
6340+
measurement_record, NULL, NULL, NULL, NULL, NULL);
6341+
6342+
assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
6343+
6344+
#if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
6345+
assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
6346+
#endif
6347+
free(data);
6348+
}
60366349
libspdm_test_context_t m_libspdm_requester_get_measurements_test_context = {
60376350
LIBSPDM_TEST_CONTEXT_VERSION,
60386351
true,
@@ -6082,6 +6395,8 @@ int libspdm_requester_get_measurements_test_main(void)
60826395
cmocka_unit_test(libspdm_test_requester_get_measurements_case37),
60836396
cmocka_unit_test(libspdm_test_requester_get_measurements_case38),
60846397
cmocka_unit_test(libspdm_test_requester_get_measurements_case39),
6398+
cmocka_unit_test(libspdm_test_requester_get_measurements_case40),
6399+
cmocka_unit_test(libspdm_test_requester_get_measurements_case41),
60856400
};
60866401

60876402
libspdm_setup_test_context(&m_libspdm_requester_get_measurements_test_context);

0 commit comments

Comments
 (0)