Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-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_requester_lib.h"
10 :
11 : #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
12 :
13 79 : void spdm_meas_log_reset_callback ( void *spdm_context, const uint32_t *session_id) {
14 79 : libspdm_context_t *context = spdm_context;
15 79 : if (session_id == NULL) {
16 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
17 : assert_int_equal(context->transcript.message_m.buffer_size, 0);
18 : #else
19 77 : assert_null(context->transcript.digest_context_l1l2);
20 : #endif
21 : } else {
22 2 : libspdm_session_info_t* session_info = &context->session_info[0];
23 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
24 : assert_int_equal(session_info->session_transcript.message_m.buffer_size, 0);
25 : #else
26 2 : assert_null(session_info->session_transcript.digest_context_l1l2);
27 : #endif
28 : }
29 79 : }
30 :
31 : spdm_get_measurements_request_t m_libspdm_get_measurements_request1 = {
32 : { SPDM_MESSAGE_VERSION_10, SPDM_GET_MEASUREMENTS, 0,
33 : SPDM_GET_MEASUREMENTS_REQUEST_MEASUREMENT_OPERATION_TOTAL_NUMBER_OF_MEASUREMENTS },
34 : };
35 : size_t m_libspdm_get_measurements_request1_size = sizeof(spdm_message_header_t);
36 :
37 : spdm_get_measurements_request_t m_libspdm_get_measurements_request3 = {
38 : { SPDM_MESSAGE_VERSION_10, SPDM_GET_MEASUREMENTS,
39 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE, 1 },
40 : };
41 : size_t m_libspdm_get_measurements_request3_size =
42 : sizeof(m_libspdm_get_measurements_request3) - sizeof(uint8_t);
43 :
44 : spdm_get_measurements_request_t m_libspdm_get_measurements_request4 = {
45 : { SPDM_MESSAGE_VERSION_10, SPDM_GET_MEASUREMENTS,
46 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE, 1 },
47 : };
48 : size_t m_libspdm_get_measurements_request4_size = sizeof(spdm_message_header_t);
49 :
50 : spdm_get_measurements_request_t m_libspdm_get_measurements_request5 = {
51 : { SPDM_MESSAGE_VERSION_10, SPDM_GET_MEASUREMENTS,
52 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE,
53 : SPDM_GET_MEASUREMENTS_REQUEST_MEASUREMENT_OPERATION_TOTAL_NUMBER_OF_MEASUREMENTS },
54 : };
55 : size_t m_libspdm_get_measurements_request5_size =
56 : sizeof(m_libspdm_get_measurements_request5) - sizeof(uint8_t);
57 :
58 : spdm_get_measurements_request_t m_libspdm_get_measurements_request6 = {
59 : { SPDM_MESSAGE_VERSION_10, SPDM_GET_MEASUREMENTS, 0, 1 },
60 : };
61 : size_t m_libspdm_get_measurements_request6_size = sizeof(spdm_message_header_t);
62 :
63 : spdm_get_measurements_request_t m_libspdm_get_measurements_request7 = {
64 : { SPDM_MESSAGE_VERSION_10, SPDM_GET_MEASUREMENTS, 0,
65 : SPDM_GET_MEASUREMENTS_REQUEST_MEASUREMENT_OPERATION_ALL_MEASUREMENTS },
66 : };
67 : size_t m_libspdm_get_measurements_request7_size = sizeof(spdm_message_header_t);
68 :
69 : spdm_get_measurements_request_t m_libspdm_get_measurements_request8 = {
70 : { SPDM_MESSAGE_VERSION_10, SPDM_GET_MEASUREMENTS,
71 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE,
72 : SPDM_GET_MEASUREMENTS_REQUEST_MEASUREMENT_OPERATION_ALL_MEASUREMENTS },
73 : };
74 : size_t m_libspdm_get_measurements_request8_size =
75 : sizeof(m_libspdm_get_measurements_request8) - sizeof(uint8_t);
76 :
77 : spdm_get_measurements_request_t m_libspdm_get_measurements_request9 = {
78 : { SPDM_MESSAGE_VERSION_11, SPDM_GET_MEASUREMENTS, 0, 1 },
79 : };
80 : size_t m_libspdm_get_measurements_request9_size = sizeof(spdm_message_header_t);
81 :
82 : spdm_get_measurements_request_t m_libspdm_get_measurements_request10 = {
83 : { SPDM_MESSAGE_VERSION_11, SPDM_GET_MEASUREMENTS,
84 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE, 1 },
85 : };
86 : size_t m_libspdm_get_measurements_request10_size = sizeof(m_libspdm_get_measurements_request10);
87 :
88 : spdm_get_measurements_request_t m_libspdm_get_measurements_request11 = {
89 : { SPDM_MESSAGE_VERSION_11, SPDM_GET_MEASUREMENTS,
90 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE, 1 },
91 : /* nonce
92 : * SlotId != 0*/
93 : };
94 : size_t m_libspdm_get_measurements_request11_size = sizeof(m_libspdm_get_measurements_request11);
95 :
96 : spdm_get_measurements_request_t m_libspdm_get_measurements_request12 = {
97 : { SPDM_MESSAGE_VERSION_11, SPDM_GET_MEASUREMENTS,
98 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE, 1 },
99 : /* nonce
100 : * SlotId >= SPDM_MAX_SLOT_COUNT*/
101 : };
102 : size_t m_libspdm_get_measurements_request12_size = sizeof(m_libspdm_get_measurements_request12);
103 :
104 : spdm_get_measurements_request_t m_libspdm_get_measurements_request13 = {
105 : { SPDM_MESSAGE_VERSION_11, SPDM_GET_MEASUREMENTS, 0, 0xF0 },
106 : };
107 : size_t m_libspdm_get_measurements_request13_size = sizeof(spdm_message_header_t);
108 :
109 : spdm_get_measurements_request_t m_libspdm_get_measurements_request14 = {
110 : { SPDM_MESSAGE_VERSION_12, SPDM_GET_MEASUREMENTS,
111 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_RAW_BIT_STREAM_REQUESTED, 1},
112 : };
113 : size_t m_libspdm_get_measurements_request14_size = sizeof(spdm_message_header_t);
114 :
115 : spdm_get_measurements_request_t m_libspdm_get_measurements_request15 = {
116 : { SPDM_MESSAGE_VERSION_12, SPDM_GET_MEASUREMENTS,
117 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE, 1},
118 : };
119 : size_t m_libspdm_get_measurements_request15_size = sizeof(m_libspdm_get_measurements_request14);
120 :
121 : spdm_get_measurements_request_t m_libspdm_get_measurements_request16 = {
122 : { SPDM_MESSAGE_VERSION_12, SPDM_GET_MEASUREMENTS,
123 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE, 1 },
124 : };
125 : size_t m_libspdm_get_measurements_request16_size = sizeof(m_libspdm_get_measurements_request16);
126 :
127 : spdm_get_measurements_request_t m_libspdm_get_measurements_request17 = {
128 : { SPDM_MESSAGE_VERSION_13, SPDM_GET_MEASUREMENTS, 0,
129 : SPDM_GET_MEASUREMENTS_REQUEST_MEASUREMENT_OPERATION_TOTAL_NUMBER_OF_MEASUREMENTS },
130 : };
131 : size_t m_libspdm_get_measurements_request17_size = sizeof(spdm_message_header_t);
132 :
133 : extern size_t libspdm_secret_lib_meas_opaque_data_size;
134 :
135 : /**
136 : * Test 1: Successful response to get a number of measurements without signature
137 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, correct transcript.message_m size, and correct response message size and fields
138 : **/
139 1 : static void rsp_measurements_case1(void **state)
140 : {
141 : libspdm_return_t status;
142 : libspdm_test_context_t *spdm_test_context;
143 : libspdm_context_t *spdm_context;
144 : size_t response_size;
145 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
146 : spdm_measurements_response_t *spdm_response;
147 :
148 1 : spdm_test_context = *state;
149 1 : spdm_context = spdm_test_context->spdm_context;
150 1 : spdm_test_context->case_id = 0x1;
151 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
152 : SPDM_VERSION_NUMBER_SHIFT_BIT;
153 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
154 1 : spdm_context->local_context.capability.flags |=
155 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
156 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
157 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
158 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
159 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
160 : m_libspdm_use_measurement_hash_algo;
161 1 : spdm_context->spdm_meas_log_reset_callback = spdm_meas_log_reset_callback;
162 1 : libspdm_reset_message_m(spdm_context, NULL);
163 :
164 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
165 :
166 1 : response_size = sizeof(response);
167 :
168 1 : status = libspdm_get_response_measurements(
169 : spdm_context, m_libspdm_get_measurements_request1_size,
170 : &m_libspdm_get_measurements_request1, &response_size, response);
171 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
172 1 : assert_int_equal(response_size,
173 : sizeof(spdm_measurements_response_t) + SPDM_NONCE_SIZE + sizeof(uint16_t));
174 1 : spdm_response = (void *)response;
175 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
176 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
177 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
178 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
179 : m_libspdm_get_measurements_request1_size +
180 : sizeof(spdm_measurements_response_t) +
181 : SPDM_NONCE_SIZE +
182 : sizeof(uint16_t));
183 : #endif
184 1 : }
185 :
186 : /**
187 : * Test 2:
188 : * Expected Behavior:
189 : **/
190 1 : static void rsp_measurements_case2(void **state)
191 : {
192 1 : }
193 :
194 : /**
195 : * Test 3: Force response_state = SPDM_RESPONSE_STATE_BUSY when asked GET_MEASUREMENTS
196 : * Expected Behavior: generate an ERROR_RESPONSE with code SPDM_ERROR_CODE_BUSY
197 : **/
198 1 : static void rsp_measurements_case3(void **state)
199 : {
200 : libspdm_return_t status;
201 : libspdm_test_context_t *spdm_test_context;
202 : libspdm_context_t *spdm_context;
203 : size_t response_size;
204 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
205 : spdm_measurements_response_t *spdm_response;
206 :
207 1 : spdm_test_context = *state;
208 1 : spdm_context = spdm_test_context->spdm_context;
209 1 : spdm_test_context->case_id = 0x3;
210 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
211 : SPDM_VERSION_NUMBER_SHIFT_BIT;
212 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_BUSY;
213 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
214 1 : spdm_context->local_context.capability.flags |=
215 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
216 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
217 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
218 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
219 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
220 : m_libspdm_use_measurement_hash_algo;
221 1 : libspdm_reset_message_m(spdm_context, NULL);
222 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
223 :
224 1 : response_size = sizeof(response);
225 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request1.nonce);
226 1 : status = libspdm_get_response_measurements(
227 : spdm_context, m_libspdm_get_measurements_request1_size,
228 : &m_libspdm_get_measurements_request1, &response_size, response);
229 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
230 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
231 1 : spdm_response = (void *)response;
232 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
233 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_BUSY);
234 1 : assert_int_equal(spdm_response->header.param2, 0);
235 1 : assert_int_equal(spdm_context->response_state, LIBSPDM_RESPONSE_STATE_BUSY);
236 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
237 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
238 : #endif
239 1 : }
240 :
241 : /**
242 : * Test 4: Force response_state = SPDM_RESPONSE_STATE_NEED_RESYNC when asked GET_MEASUREMENTS
243 : * Expected Behavior: generate an ERROR_RESPONSE with code SPDM_ERROR_CODE_REQUEST_RESYNCH
244 : **/
245 1 : static void rsp_measurements_case4(void **state)
246 : {
247 : libspdm_return_t status;
248 : libspdm_test_context_t *spdm_test_context;
249 : libspdm_context_t *spdm_context;
250 : size_t response_size;
251 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
252 : spdm_measurements_response_t *spdm_response;
253 :
254 1 : spdm_test_context = *state;
255 1 : spdm_context = spdm_test_context->spdm_context;
256 1 : spdm_test_context->case_id = 0x4;
257 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
258 : SPDM_VERSION_NUMBER_SHIFT_BIT;
259 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NEED_RESYNC;
260 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
261 1 : spdm_context->local_context.capability.flags |=
262 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
263 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
264 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
265 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
266 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
267 : m_libspdm_use_measurement_hash_algo;
268 1 : libspdm_reset_message_m(spdm_context, NULL);
269 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
270 :
271 1 : response_size = sizeof(response);
272 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request1.nonce);
273 1 : status = libspdm_get_response_measurements(
274 : spdm_context, m_libspdm_get_measurements_request1_size,
275 : &m_libspdm_get_measurements_request1, &response_size, response);
276 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
277 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
278 1 : spdm_response = (void *)response;
279 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
280 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_REQUEST_RESYNCH);
281 1 : assert_int_equal(spdm_response->header.param2, 0);
282 1 : assert_int_equal(spdm_context->response_state, LIBSPDM_RESPONSE_STATE_NEED_RESYNC);
283 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
284 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
285 : #endif
286 1 : }
287 :
288 : #if LIBSPDM_RESPOND_IF_READY_SUPPORT
289 : /**
290 : * Test 5: Force response_state = SPDM_RESPONSE_STATE_NOT_READY when asked GET_MEASUREMENTS
291 : * Expected Behavior: generate an ERROR_RESPONSE with code SPDM_ERROR_CODE_RESPONSE_NOT_READY
292 : **/
293 1 : static void rsp_measurements_case5(void **state)
294 : {
295 : libspdm_return_t status;
296 : libspdm_test_context_t *spdm_test_context;
297 : libspdm_context_t *spdm_context;
298 : size_t response_size;
299 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
300 : spdm_measurements_response_t *spdm_response;
301 : spdm_error_data_response_not_ready_t *error_data;
302 :
303 1 : spdm_test_context = *state;
304 1 : spdm_context = spdm_test_context->spdm_context;
305 1 : spdm_test_context->case_id = 0x5;
306 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
307 : SPDM_VERSION_NUMBER_SHIFT_BIT;
308 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NOT_READY;
309 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
310 1 : spdm_context->local_context.capability.flags |=
311 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
312 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
313 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
314 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
315 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
316 : m_libspdm_use_measurement_hash_algo;
317 1 : libspdm_reset_message_m(spdm_context, NULL);
318 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
319 :
320 1 : response_size = sizeof(response);
321 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request1.nonce);
322 1 : status = libspdm_get_response_measurements(
323 : spdm_context, m_libspdm_get_measurements_request1_size,
324 : &m_libspdm_get_measurements_request1, &response_size, response);
325 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
326 1 : assert_int_equal(response_size,
327 : sizeof(spdm_error_response_t) +
328 : sizeof(spdm_error_data_response_not_ready_t));
329 1 : spdm_response = (void *)response;
330 1 : error_data = (spdm_error_data_response_not_ready_t
331 : *)(&spdm_response->number_of_blocks);
332 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
333 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_RESPONSE_NOT_READY);
334 1 : assert_int_equal(spdm_response->header.param2, 0);
335 1 : assert_int_equal(spdm_context->response_state, LIBSPDM_RESPONSE_STATE_NOT_READY);
336 1 : assert_int_equal(error_data->request_code, SPDM_GET_MEASUREMENTS);
337 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
338 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
339 : #endif
340 1 : }
341 : #endif /* LIBSPDM_RESPOND_IF_READY_SUPPORT */
342 :
343 : /**
344 : * Test 6: simulate wrong connection_state when asked GET_MEASUREMENTS
345 : * (missing SPDM_GET_DIGESTS_RECEIVE_FLAG, SPDM_GET_CAPABILITIES_RECEIVE_FLAG and SPDM_NEGOTIATE_ALGORITHMS_RECEIVE_FLAG)
346 : * Expected Behavior: generate an ERROR_RESPONSE with code SPDM_ERROR_CODE_UNEXPECTED_REQUEST
347 : **/
348 1 : static void rsp_measurements_case6(void **state)
349 : {
350 : libspdm_return_t status;
351 : libspdm_test_context_t *spdm_test_context;
352 : libspdm_context_t *spdm_context;
353 : size_t response_size;
354 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
355 : spdm_measurements_response_t *spdm_response;
356 :
357 1 : spdm_test_context = *state;
358 1 : spdm_context = spdm_test_context->spdm_context;
359 1 : spdm_test_context->case_id = 0x6;
360 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
361 : SPDM_VERSION_NUMBER_SHIFT_BIT;
362 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
363 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NOT_STARTED;
364 1 : spdm_context->local_context.capability.flags |=
365 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
366 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
367 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
368 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
369 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
370 : m_libspdm_use_measurement_hash_algo;
371 1 : libspdm_reset_message_m(spdm_context, NULL);
372 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
373 :
374 1 : response_size = sizeof(response);
375 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request1.nonce);
376 1 : status = libspdm_get_response_measurements(
377 : spdm_context, m_libspdm_get_measurements_request1_size,
378 : &m_libspdm_get_measurements_request1, &response_size, response);
379 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
380 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
381 1 : spdm_response = (void *)response;
382 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
383 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
384 1 : assert_int_equal(spdm_response->header.param2, 0);
385 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
386 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
387 : #endif
388 1 : }
389 :
390 : /**
391 : * Test 7: Successful response to get a number of measurements with signature
392 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m, and correct response message size and fields
393 : **/
394 1 : static void rsp_measurements_case7(void **state)
395 : {
396 : libspdm_return_t status;
397 : libspdm_test_context_t *spdm_test_context;
398 : libspdm_context_t *spdm_context;
399 : size_t response_size;
400 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
401 : spdm_measurements_response_t *spdm_response;
402 : size_t measurment_sig_size;
403 :
404 : bool result;
405 : uint32_t measurement_record_data_length;
406 : uint8_t *measurement_record_data;
407 : uint8_t *ptr;
408 : uint16_t opaque_length;
409 : void *signature;
410 : size_t signature_size;
411 : libspdm_session_info_t *session_info;
412 : void *data;
413 : size_t data_size;
414 : void *hash;
415 : size_t hash_size;
416 :
417 1 : spdm_test_context = *state;
418 1 : spdm_context = spdm_test_context->spdm_context;
419 1 : spdm_test_context->case_id = 0x7;
420 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
421 : SPDM_VERSION_NUMBER_SHIFT_BIT;
422 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
423 1 : spdm_context->local_context.capability.flags |=
424 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
425 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
426 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
427 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
428 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
429 : m_libspdm_use_measurement_hash_algo;
430 1 : libspdm_reset_message_m(spdm_context, NULL);
431 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
432 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
433 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
434 :
435 1 : response_size = sizeof(response);
436 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
437 1 : status = libspdm_get_response_measurements(
438 : spdm_context, m_libspdm_get_measurements_request5_size,
439 : &m_libspdm_get_measurements_request5, &response_size, response);
440 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
441 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
442 1 : spdm_response = (void *)response;
443 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
444 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
445 :
446 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
447 : m_libspdm_use_asym_algo, &data,
448 : &data_size,
449 : &hash, &hash_size)) {
450 0 : assert(false);
451 : }
452 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
453 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
454 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
455 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
456 : data, data_size);
457 : #else
458 1 : libspdm_hash_all(
459 : spdm_context->connection_info.algorithm.base_hash_algo,
460 : data, data_size,
461 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
462 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
463 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
464 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
465 : spdm_context->connection_info.algorithm.base_hash_algo,
466 : spdm_context->connection_info.algorithm.base_asym_algo,
467 : data, data_size,
468 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
469 : #endif
470 :
471 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
472 1 : measurement_record_data = (void *)(spdm_response + 1);
473 1 : ptr = measurement_record_data + measurement_record_data_length;
474 1 : ptr += SPDM_NONCE_SIZE;
475 1 : opaque_length = libspdm_read_uint16((const uint8_t *)ptr);
476 1 : ptr += sizeof(uint16_t);
477 1 : ptr += opaque_length;
478 1 : signature = ptr;
479 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
480 1 : session_info = NULL;
481 :
482 1 : status = libspdm_append_message_m(spdm_context, session_info,
483 : &m_libspdm_get_measurements_request5,
484 : m_libspdm_get_measurements_request5_size);
485 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
486 :
487 1 : status = libspdm_append_message_m(spdm_context, session_info, spdm_response,
488 : response_size - signature_size);
489 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
490 :
491 1 : result = libspdm_verify_measurement_signature(
492 : spdm_context, session_info, 0, signature, signature_size);
493 1 : assert_true(result);
494 :
495 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
496 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
497 : #endif
498 1 : }
499 :
500 : /**
501 : * Test 8: Successful response to get one measurement with signature
502 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m, and correct response message size and fields
503 : **/
504 1 : static void rsp_measurements_case8(void **state)
505 : {
506 : libspdm_return_t status;
507 : libspdm_test_context_t *spdm_test_context;
508 : libspdm_context_t *spdm_context;
509 : size_t response_size;
510 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
511 : spdm_measurements_response_t *spdm_response;
512 : size_t measurment_sig_size;
513 :
514 1 : spdm_test_context = *state;
515 1 : spdm_context = spdm_test_context->spdm_context;
516 1 : spdm_test_context->case_id = 0x8;
517 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
518 : SPDM_VERSION_NUMBER_SHIFT_BIT;
519 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
520 1 : spdm_context->local_context.capability.flags |=
521 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
522 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
523 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
524 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
525 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
526 : m_libspdm_use_measurement_hash_algo;
527 1 : libspdm_reset_message_m(spdm_context, NULL);
528 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
529 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
530 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
531 1 : response_size = sizeof(response);
532 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request3.nonce);
533 1 : status = libspdm_get_response_measurements(
534 : spdm_context, m_libspdm_get_measurements_request3_size,
535 : &m_libspdm_get_measurements_request3, &response_size, response);
536 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
537 1 : assert_int_equal(response_size,
538 : sizeof(spdm_measurements_response_t) +
539 : sizeof(spdm_measurement_block_dmtf_t) +
540 : libspdm_get_measurement_hash_size(
541 : m_libspdm_use_measurement_hash_algo) +
542 : measurment_sig_size);
543 1 : spdm_response = (void *)response;
544 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
545 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
546 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
547 : #endif
548 1 : }
549 :
550 : /**
551 : * Test 9: Error case, Bad request size (sizeof(spdm_message_header_t)x) to get measurement number with signature
552 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m size, and Error message as response
553 : **/
554 1 : static void rsp_measurements_case9(void **state)
555 : {
556 : libspdm_return_t status;
557 : libspdm_test_context_t *spdm_test_context;
558 : libspdm_context_t *spdm_context;
559 : size_t response_size;
560 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
561 : spdm_measurements_response_t *spdm_response;
562 :
563 1 : spdm_test_context = *state;
564 1 : spdm_context = spdm_test_context->spdm_context;
565 1 : spdm_test_context->case_id = 0x9;
566 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
567 : SPDM_VERSION_NUMBER_SHIFT_BIT;
568 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
569 1 : spdm_context->local_context.capability.flags |=
570 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
571 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
572 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
573 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
574 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
575 : m_libspdm_use_measurement_hash_algo;
576 1 : libspdm_reset_message_m(spdm_context, NULL);
577 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
578 :
579 1 : response_size = sizeof(response);
580 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request4.nonce);
581 1 : status = libspdm_get_response_measurements(
582 : spdm_context, m_libspdm_get_measurements_request4_size,
583 : &m_libspdm_get_measurements_request4, &response_size, response);
584 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
585 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
586 1 : spdm_response = (void *)response;
587 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
588 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
589 1 : assert_int_equal(spdm_response->header.param2, 0);
590 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
591 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
592 : #endif
593 1 : }
594 :
595 : /**
596 : * Test 10: Successful response to get one measurement without signature
597 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, correct transcript.message_m size, and correct response message size and fields
598 : **/
599 1 : static void rsp_measurements_case10(void **state)
600 : {
601 : libspdm_return_t status;
602 : libspdm_test_context_t *spdm_test_context;
603 : libspdm_context_t *spdm_context;
604 : size_t response_size;
605 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
606 : spdm_measurements_response_t *spdm_response;
607 :
608 1 : spdm_test_context = *state;
609 1 : spdm_context = spdm_test_context->spdm_context;
610 1 : spdm_test_context->case_id = 0xA;
611 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
612 : SPDM_VERSION_NUMBER_SHIFT_BIT;
613 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
614 1 : spdm_context->local_context.capability.flags |=
615 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
616 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
617 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
618 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
619 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
620 : m_libspdm_use_measurement_hash_algo;
621 1 : libspdm_reset_message_m(spdm_context, NULL);
622 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
623 :
624 1 : response_size = sizeof(response);
625 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request6.nonce);
626 1 : status = libspdm_get_response_measurements(
627 : spdm_context, m_libspdm_get_measurements_request6_size,
628 : &m_libspdm_get_measurements_request6, &response_size, response);
629 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
630 1 : assert_int_equal(response_size,
631 : sizeof(spdm_measurements_response_t) +
632 : sizeof(spdm_measurement_block_dmtf_t) +
633 : libspdm_get_measurement_hash_size(
634 : m_libspdm_use_measurement_hash_algo) + SPDM_NONCE_SIZE +
635 : sizeof(uint16_t));
636 1 : spdm_response = (void *)response;
637 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
638 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
639 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
640 : m_libspdm_get_measurements_request6_size +
641 : sizeof(spdm_measurements_response_t) +
642 : sizeof(spdm_measurement_block_dmtf_t) +
643 : libspdm_get_measurement_hash_size(
644 : m_libspdm_use_measurement_hash_algo) + SPDM_NONCE_SIZE +
645 : sizeof(uint16_t));
646 : #endif
647 1 : }
648 :
649 : /**
650 : * Test 11: Successful response to get all measurements with signature
651 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m, and correct response message size and fields
652 : **/
653 1 : static void rsp_measurements_case11(void **state)
654 : {
655 : libspdm_return_t status;
656 : libspdm_test_context_t *spdm_test_context;
657 : libspdm_context_t *spdm_context;
658 : size_t response_size;
659 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
660 : spdm_measurements_response_t *spdm_response;
661 : size_t measurment_sig_size;
662 :
663 1 : spdm_test_context = *state;
664 1 : spdm_context = spdm_test_context->spdm_context;
665 1 : spdm_test_context->case_id = 0xB;
666 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
667 : SPDM_VERSION_NUMBER_SHIFT_BIT;
668 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
669 1 : spdm_context->local_context.capability.flags |=
670 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
671 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
672 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
673 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
674 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
675 : m_libspdm_use_measurement_hash_algo;
676 1 : libspdm_reset_message_m(spdm_context, NULL);
677 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
678 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
679 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
680 :
681 1 : response_size = sizeof(response);
682 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request8.nonce);
683 1 : status = libspdm_get_response_measurements(
684 : spdm_context, m_libspdm_get_measurements_request8_size,
685 : &m_libspdm_get_measurements_request8, &response_size, response);
686 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
687 1 : assert_int_equal(response_size,
688 : sizeof(spdm_measurements_response_t) +
689 : LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER *
690 : (sizeof(spdm_measurement_block_dmtf_t) +
691 : libspdm_get_measurement_hash_size(
692 : m_libspdm_use_measurement_hash_algo)) +
693 : (sizeof(spdm_measurement_block_dmtf_t) +
694 : sizeof(spdm_measurements_secure_version_number_t)) +
695 : (sizeof(spdm_measurement_block_dmtf_t) +
696 : libspdm_get_measurement_hash_size(
697 : m_libspdm_use_measurement_hash_algo)) +
698 : (sizeof(spdm_measurement_block_dmtf_t) +
699 : LIBSPDM_MEASUREMENT_MANIFEST_SIZE) +
700 : (sizeof(spdm_measurement_block_dmtf_t) +
701 : sizeof(spdm_measurements_device_mode_t)) +
702 : measurment_sig_size);
703 1 : spdm_response = (void *)response;
704 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
705 1 : assert_int_equal(spdm_response->number_of_blocks, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
706 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
707 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
708 : #endif
709 1 : }
710 :
711 : /**
712 : * Test 12: Successful response to get all measurements without signature
713 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, correct transcript.message_m size, and correct response message size and fields
714 : **/
715 1 : static void rsp_measurements_case12(void **state)
716 : {
717 : libspdm_return_t status;
718 : libspdm_test_context_t *spdm_test_context;
719 : libspdm_context_t *spdm_context;
720 : size_t response_size;
721 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
722 : spdm_measurements_response_t *spdm_response;
723 :
724 1 : spdm_test_context = *state;
725 1 : spdm_context = spdm_test_context->spdm_context;
726 1 : spdm_test_context->case_id = 0xC;
727 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
728 : SPDM_VERSION_NUMBER_SHIFT_BIT;
729 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
730 1 : spdm_context->local_context.capability.flags |=
731 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
732 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
733 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
734 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
735 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
736 : m_libspdm_use_measurement_hash_algo;
737 1 : libspdm_reset_message_m(spdm_context, NULL);
738 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
739 :
740 1 : response_size = sizeof(response);
741 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request7.nonce);
742 1 : status = libspdm_get_response_measurements(
743 : spdm_context, m_libspdm_get_measurements_request7_size,
744 : &m_libspdm_get_measurements_request7, &response_size, response);
745 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
746 1 : assert_int_equal(response_size,
747 : sizeof(spdm_measurements_response_t) +
748 : LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER *
749 : (sizeof(spdm_measurement_block_dmtf_t) +
750 : libspdm_get_measurement_hash_size(
751 : m_libspdm_use_measurement_hash_algo)) +
752 : (sizeof(spdm_measurement_block_dmtf_t) +
753 : sizeof(spdm_measurements_secure_version_number_t)) +
754 : (sizeof(spdm_measurement_block_dmtf_t) +
755 : libspdm_get_measurement_hash_size(
756 : m_libspdm_use_measurement_hash_algo)) +
757 : (sizeof(spdm_measurement_block_dmtf_t) +
758 : LIBSPDM_MEASUREMENT_MANIFEST_SIZE) +
759 : (sizeof(spdm_measurement_block_dmtf_t) +
760 : sizeof(spdm_measurements_device_mode_t)) +
761 : SPDM_NONCE_SIZE + sizeof(uint16_t));
762 1 : spdm_response = (void *)response;
763 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
764 1 : assert_int_equal(spdm_response->number_of_blocks, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
765 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
766 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
767 : m_libspdm_get_measurements_request7_size +
768 : sizeof(spdm_measurements_response_t) +
769 : LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER *
770 : (sizeof(spdm_measurement_block_dmtf_t) +
771 : libspdm_get_measurement_hash_size(
772 : m_libspdm_use_measurement_hash_algo)) +
773 : (sizeof(spdm_measurement_block_dmtf_t) +
774 : sizeof(spdm_measurements_secure_version_number_t)) +
775 : (sizeof(spdm_measurement_block_dmtf_t) +
776 : libspdm_get_measurement_hash_size(
777 : m_libspdm_use_measurement_hash_algo)) +
778 : (sizeof(spdm_measurement_block_dmtf_t) +
779 : LIBSPDM_MEASUREMENT_MANIFEST_SIZE) +
780 : (sizeof(spdm_measurement_block_dmtf_t) +
781 : sizeof(spdm_measurements_device_mode_t)) +
782 : SPDM_NONCE_SIZE + sizeof(uint16_t));
783 : #endif
784 1 : }
785 :
786 : /**
787 : * Test 13:
788 : * Expected Behavior:
789 : **/
790 1 : static void rsp_measurements_case13(void **state)
791 : {
792 1 : }
793 :
794 : /**
795 : * Test 14: Error case, signature was required, but there is no nonce and/or slotID
796 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m size, and Error message as response
797 : **/
798 1 : static void rsp_measurements_case14(void **state)
799 : {
800 : libspdm_return_t status;
801 : libspdm_test_context_t *spdm_test_context;
802 : libspdm_context_t *spdm_context;
803 : size_t response_size;
804 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
805 : spdm_measurements_response_t *spdm_response;
806 : uint16_t TestMsgSizes[3];
807 :
808 1 : TestMsgSizes[0] =
809 1 : (uint16_t)(m_libspdm_get_measurements_request10_size -
810 : sizeof(m_libspdm_get_measurements_request10.slot_id_param) -
811 : sizeof(m_libspdm_get_measurements_request10.nonce));
812 1 : TestMsgSizes[1] =
813 1 : (uint16_t)(m_libspdm_get_measurements_request10_size -
814 : sizeof(m_libspdm_get_measurements_request10.slot_id_param));
815 1 : TestMsgSizes[2] =
816 1 : (uint16_t)(m_libspdm_get_measurements_request10_size -
817 : sizeof(m_libspdm_get_measurements_request10.nonce));
818 :
819 1 : spdm_test_context = *state;
820 1 : spdm_context = spdm_test_context->spdm_context;
821 1 : spdm_test_context->case_id = 0xE;
822 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
823 1 : spdm_context->local_context.capability.flags = 0;
824 1 : spdm_context->local_context.capability.flags |=
825 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
826 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
827 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
828 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
829 : m_libspdm_use_measurement_hash_algo;
830 :
831 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
832 : SPDM_VERSION_NUMBER_SHIFT_BIT;
833 1 : libspdm_reset_message_m(spdm_context, NULL);
834 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
835 :
836 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request10.nonce);
837 4 : for (int i = 0; i < sizeof(TestMsgSizes) / sizeof(TestMsgSizes[0]); i++) {
838 3 : response_size = sizeof(response);
839 3 : status = libspdm_get_response_measurements(
840 3 : spdm_context, TestMsgSizes[i],
841 : &m_libspdm_get_measurements_request10, &response_size,
842 : response);
843 3 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
844 3 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
845 3 : spdm_response = (void *)response;
846 3 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
847 3 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
848 3 : assert_int_equal(spdm_response->header.param2, 0);
849 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
850 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
851 : #endif
852 : }
853 1 : }
854 :
855 : /**
856 : * Test 15: Error case, meas_cap = 01b, but signature was requested (request message includes nonce and slotID)
857 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m size, and Error message as response
858 : **/
859 1 : static void rsp_measurements_case15(void **state)
860 : {
861 : libspdm_return_t status;
862 : libspdm_test_context_t *spdm_test_context;
863 : libspdm_context_t *spdm_context;
864 : size_t response_size;
865 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
866 : spdm_measurements_response_t *spdm_response;
867 : /* size_t measurment_sig_size;*/
868 :
869 1 : spdm_test_context = *state;
870 1 : spdm_context = spdm_test_context->spdm_context;
871 1 : spdm_test_context->case_id = 0xF;
872 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
873 1 : spdm_context->local_context.capability.flags = 0;
874 1 : spdm_context->local_context.capability.flags |=
875 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_NO_SIG;
876 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
877 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
878 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
879 : m_libspdm_use_measurement_hash_algo;
880 :
881 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
882 : SPDM_VERSION_NUMBER_SHIFT_BIT;
883 1 : libspdm_reset_message_m(spdm_context, NULL);
884 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
885 : /* measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 + libspdm_get_asym_signature_size (m_libspdm_use_asym_algo);*/
886 :
887 1 : response_size = sizeof(response);
888 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request10.nonce);
889 1 : status = libspdm_get_response_measurements(
890 : spdm_context, m_libspdm_get_measurements_request10_size,
891 : &m_libspdm_get_measurements_request10, &response_size, response);
892 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
893 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
894 1 : spdm_response = (void *)response;
895 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
896 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
897 1 : assert_int_equal(spdm_response->header.param2, 0);
898 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
899 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
900 : #endif
901 1 : }
902 :
903 : /**
904 : * Test 16: Error case, meas_cap = 01b, but signature was requested (request message does not include nonce and slotID)
905 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m size, and Error message as response
906 : **/
907 1 : static void rsp_measurements_case16(void **state)
908 : {
909 : libspdm_return_t status;
910 : libspdm_test_context_t *spdm_test_context;
911 : libspdm_context_t *spdm_context;
912 : size_t response_size;
913 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
914 : spdm_measurements_response_t *spdm_response;
915 : /* size_t measurment_sig_size;*/
916 :
917 1 : spdm_test_context = *state;
918 1 : spdm_context = spdm_test_context->spdm_context;
919 1 : spdm_test_context->case_id = 0x10;
920 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
921 1 : spdm_context->local_context.capability.flags = 0;
922 1 : spdm_context->local_context.capability.flags |=
923 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_NO_SIG;
924 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
925 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
926 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
927 : m_libspdm_use_measurement_hash_algo;
928 :
929 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
930 : SPDM_VERSION_NUMBER_SHIFT_BIT;
931 1 : libspdm_reset_message_m(spdm_context, NULL);
932 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
933 : /* measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 + libspdm_get_asym_signature_size (m_libspdm_use_asym_algo);*/
934 :
935 1 : response_size = sizeof(response);
936 1 : status = libspdm_get_response_measurements(
937 : spdm_context, m_libspdm_get_measurements_request9_size,
938 : &m_libspdm_get_measurements_request10, &response_size, response);
939 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
940 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
941 1 : spdm_response = (void *)response;
942 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
943 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
944 1 : assert_int_equal(spdm_response->header.param2, 0);
945 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
946 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
947 : #endif
948 1 : }
949 :
950 : /**
951 : * Test 17: Error case, meas_cap = 00
952 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m size, and Error message as response
953 : **/
954 1 : static void rsp_measurements_case17(void **state)
955 : {
956 : libspdm_return_t status;
957 : libspdm_test_context_t *spdm_test_context;
958 : libspdm_context_t *spdm_context;
959 : size_t response_size;
960 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
961 : spdm_measurements_response_t *spdm_response;
962 : /* size_t measurment_sig_size;*/
963 :
964 1 : spdm_test_context = *state;
965 1 : spdm_context = spdm_test_context->spdm_context;
966 1 : spdm_test_context->case_id = 0x11;
967 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
968 1 : spdm_context->local_context.capability.flags = 0;
969 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
970 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
971 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
972 : m_libspdm_use_measurement_hash_algo;
973 :
974 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
975 : SPDM_VERSION_NUMBER_SHIFT_BIT;
976 1 : libspdm_reset_message_m(spdm_context, NULL);
977 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
978 : /* measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 + libspdm_get_asym_signature_size (m_libspdm_use_asym_algo);*/
979 :
980 1 : response_size = sizeof(response);
981 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request9.nonce);
982 1 : status = libspdm_get_response_measurements(
983 : spdm_context, m_libspdm_get_measurements_request9_size,
984 : &m_libspdm_get_measurements_request9, &response_size, response);
985 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
986 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
987 1 : spdm_response = (void *)response;
988 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
989 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_UNSUPPORTED_REQUEST);
990 1 : assert_int_equal(
991 : spdm_response->header.param2,
992 : m_libspdm_get_measurements_request10.header.request_response_code);
993 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
994 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
995 : #endif
996 1 : }
997 :
998 : /**
999 : * Test 18: Successful response to get one measurement with signature, SlotId different from default
1000 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m, and correct response message size and fields
1001 : **/
1002 1 : static void rsp_measurements_case18(void **state)
1003 : {
1004 : libspdm_return_t status;
1005 : libspdm_test_context_t *spdm_test_context;
1006 : libspdm_context_t *spdm_context;
1007 : size_t response_size;
1008 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1009 : spdm_measurements_response_t *spdm_response;
1010 : void *data;
1011 : size_t data_size;
1012 : size_t measurment_sig_size;
1013 :
1014 1 : spdm_test_context = *state;
1015 1 : spdm_context = spdm_test_context->spdm_context;
1016 1 : spdm_test_context->case_id = 0x12;
1017 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1018 1 : spdm_context->local_context.capability.flags |=
1019 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1020 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1021 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1022 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1023 : m_libspdm_use_measurement_hash_algo;
1024 :
1025 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1026 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1027 1 : libspdm_reset_message_m(spdm_context, NULL);
1028 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1029 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1030 : m_libspdm_use_asym_algo, &data,
1031 : &data_size, NULL, NULL);
1032 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1033 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1034 9 : for (int i = 0; i < SPDM_MAX_SLOT_COUNT; i++) {
1035 8 : spdm_context->local_context.local_cert_chain_provision_size[i] = data_size;
1036 8 : spdm_context->local_context.local_cert_chain_provision[i] = data;
1037 : }
1038 :
1039 1 : response_size = sizeof(response);
1040 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request11.nonce);
1041 1 : status = libspdm_get_response_measurements(
1042 : spdm_context, m_libspdm_get_measurements_request11_size,
1043 : &m_libspdm_get_measurements_request11, &response_size, response);
1044 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1045 1 : assert_int_equal(response_size,
1046 : sizeof(spdm_measurements_response_t) +
1047 : sizeof(spdm_measurement_block_dmtf_t) +
1048 : libspdm_get_measurement_hash_size(
1049 : m_libspdm_use_measurement_hash_algo) +
1050 : measurment_sig_size);
1051 1 : spdm_response = (void *)response;
1052 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1053 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1054 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1055 : #endif
1056 1 : assert_int_equal(m_libspdm_get_measurements_request11.slot_id_param,
1057 : spdm_response->header.param2);
1058 :
1059 1 : free(data);
1060 1 : }
1061 :
1062 : /**
1063 : * Test 19: Error case, invalid SlotId parameter (SlotId >= SPDM_MAX_SLOT_COUNT)
1064 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m size, and Error message as response
1065 : **/
1066 1 : static void rsp_measurements_case19(void **state)
1067 : {
1068 : libspdm_return_t status;
1069 : libspdm_test_context_t *spdm_test_context;
1070 : libspdm_context_t *spdm_context;
1071 : size_t response_size;
1072 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1073 : spdm_measurements_response_t *spdm_response;
1074 : /* size_t measurment_sig_size;*/
1075 :
1076 1 : spdm_test_context = *state;
1077 1 : spdm_context = spdm_test_context->spdm_context;
1078 1 : spdm_test_context->case_id = 0x13;
1079 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1080 1 : spdm_context->local_context.capability.flags |=
1081 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1082 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1083 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1084 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1085 : m_libspdm_use_measurement_hash_algo;
1086 :
1087 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1088 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1089 1 : libspdm_reset_message_m(spdm_context, NULL);
1090 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1091 : /* measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 + libspdm_get_asym_signature_size (m_libspdm_use_asym_algo);*/
1092 :
1093 1 : response_size = sizeof(response);
1094 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request12.nonce);
1095 1 : status = libspdm_get_response_measurements(
1096 : spdm_context, m_libspdm_get_measurements_request12_size,
1097 : &m_libspdm_get_measurements_request12, &response_size, response);
1098 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1099 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1100 1 : spdm_response = (void *)response;
1101 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1102 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1103 1 : assert_int_equal(spdm_response->header.param2, 0);
1104 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1105 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1106 : #endif
1107 1 : }
1108 :
1109 : /**
1110 : * Test 21: Error case, request a measurement index not found
1111 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m size, and Error message as response
1112 : **/
1113 1 : static void rsp_measurements_case21(void **state)
1114 : {
1115 : libspdm_return_t status;
1116 : libspdm_test_context_t *spdm_test_context;
1117 : libspdm_context_t *spdm_context;
1118 : size_t response_size;
1119 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1120 : spdm_measurements_response_t *spdm_response;
1121 :
1122 1 : spdm_test_context = *state;
1123 1 : spdm_context = spdm_test_context->spdm_context;
1124 1 : spdm_test_context->case_id = 0x15;
1125 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1126 1 : spdm_context->local_context.capability.flags |=
1127 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1128 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1129 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1130 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1131 : m_libspdm_use_measurement_hash_algo;
1132 :
1133 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1134 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1135 1 : libspdm_reset_message_m(spdm_context, NULL);
1136 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1137 :
1138 1 : response_size = sizeof(response);
1139 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request13.nonce);
1140 1 : status = libspdm_get_response_measurements(
1141 : spdm_context, m_libspdm_get_measurements_request13_size,
1142 : &m_libspdm_get_measurements_request13, &response_size, response);
1143 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1144 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1145 1 : spdm_response = (void *)response;
1146 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1147 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1148 1 : assert_int_equal(spdm_response->header.param2, 0);
1149 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1150 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1151 : #endif
1152 1 : }
1153 :
1154 : /**
1155 : * Test 22: request a large number of measurements before requesting a signed response
1156 : * Expected Behavior: while transcript.message_m is not full, get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m, and correct response message size and fields
1157 : * if transcript.message_m has no more room, an error response is expected
1158 : **/
1159 1 : static void rsp_measurements_case22(void **state)
1160 : {
1161 : libspdm_return_t status;
1162 : libspdm_test_context_t *spdm_test_context;
1163 : libspdm_context_t *spdm_context;
1164 : size_t response_size;
1165 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1166 : spdm_measurements_response_t *spdm_response;
1167 : size_t NumberOfMessages;
1168 : #define TOTAL_MESSAGES 100
1169 :
1170 1 : spdm_test_context = *state;
1171 1 : spdm_context = spdm_test_context->spdm_context;
1172 1 : spdm_test_context->case_id = 0x16;
1173 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1174 1 : spdm_context->local_context.capability.flags |=
1175 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1176 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1177 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1178 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1179 : m_libspdm_use_measurement_hash_algo;
1180 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1181 :
1182 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1183 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1184 1 : libspdm_reset_message_m(spdm_context, NULL);
1185 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1186 :
1187 101 : for (NumberOfMessages = 1; NumberOfMessages <= TOTAL_MESSAGES; NumberOfMessages++) {
1188 100 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request9.nonce);
1189 100 : response_size = sizeof(response);
1190 100 : status = libspdm_get_response_measurements(
1191 : spdm_context, m_libspdm_get_measurements_request9_size,
1192 : &m_libspdm_get_measurements_request9, &response_size,
1193 : response);
1194 100 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1195 100 : spdm_response = (void *)response;
1196 100 : if (spdm_response->header.request_response_code == SPDM_MEASUREMENTS) {
1197 100 : assert_int_equal( spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1198 100 : assert_int_equal(
1199 : response_size,
1200 : sizeof(spdm_measurements_response_t) +
1201 : sizeof(spdm_measurement_block_dmtf_t) +
1202 : libspdm_get_measurement_hash_size(
1203 : m_libspdm_use_measurement_hash_algo) + SPDM_NONCE_SIZE +
1204 : sizeof(uint16_t));
1205 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1206 : assert_int_equal(
1207 : spdm_context->transcript.message_m.buffer_size,
1208 : NumberOfMessages *
1209 : (m_libspdm_get_measurements_request9_size +
1210 : sizeof(spdm_measurements_response_t) +
1211 : sizeof(spdm_measurement_block_dmtf_t) +
1212 : libspdm_get_measurement_hash_size(
1213 : m_libspdm_use_measurement_hash_algo) + SPDM_NONCE_SIZE +
1214 : sizeof(uint16_t)));
1215 : #endif
1216 : } else {
1217 0 : assert_int_equal( spdm_response->header.request_response_code, SPDM_ERROR);
1218 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1219 : assert_int_equal( spdm_context->transcript.message_m.buffer_size, 0);
1220 : #endif
1221 0 : break;
1222 : }
1223 : }
1224 1 : }
1225 :
1226 : /**
1227 : * Test 23: Successful response to get a session based measurement with signature
1228 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, with an empty session_transcript.message_m
1229 : **/
1230 1 : static void rsp_measurements_case23(void **state)
1231 : {
1232 : libspdm_return_t status;
1233 : libspdm_test_context_t *spdm_test_context;
1234 : libspdm_context_t *spdm_context;
1235 : size_t response_size;
1236 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1237 : spdm_measurements_response_t *spdm_response;
1238 : size_t measurment_sig_size;
1239 : libspdm_session_info_t *session_info;
1240 : uint32_t session_id;
1241 :
1242 1 : spdm_test_context = *state;
1243 1 : spdm_context = spdm_test_context->spdm_context;
1244 1 : spdm_test_context->case_id = 0x17;
1245 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1246 1 : spdm_context->local_context.capability.flags |=
1247 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1248 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1249 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1250 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1251 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1252 : m_libspdm_use_measurement_hash_algo;
1253 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1254 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1255 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1256 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1257 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1258 :
1259 1 : response_size = sizeof(response);
1260 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
1261 :
1262 :
1263 1 : session_id = 0xFFFFFFFF;
1264 1 : spdm_context->latest_session_id = session_id;
1265 1 : spdm_context->last_spdm_request_session_id_valid = true;
1266 1 : spdm_context->last_spdm_request_session_id = session_id;
1267 1 : session_info = &spdm_context->session_info[0];
1268 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
1269 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
1270 1 : libspdm_secured_message_set_session_state(
1271 : session_info->secured_message_context,
1272 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1273 1 : status = libspdm_get_response_measurements(
1274 : spdm_context, m_libspdm_get_measurements_request5_size,
1275 : &m_libspdm_get_measurements_request5, &response_size, response);
1276 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1277 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
1278 1 : spdm_response = (void *)response;
1279 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1280 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
1281 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1282 : assert_int_equal(session_info->session_transcript.message_m.buffer_size, 0);
1283 : #endif
1284 1 : }
1285 :
1286 : /**
1287 : * Test 24: receiving a correct GET_MEASUREMENTS from the requester that does not request a
1288 : * signature. Buffer M already has arbitrary data.
1289 : * Expected behavior: the responder accepts the request and produces a valid
1290 : * MEASUREMENTS response message, and buffer M appends the exchanged GET_MEASUREMENTS and MEASUREMENTS
1291 : * messages.
1292 : **/
1293 1 : static void rsp_measurements_case24(void **state)
1294 : {
1295 : libspdm_return_t status;
1296 : libspdm_test_context_t *spdm_test_context;
1297 : libspdm_context_t *spdm_context;
1298 : size_t response_size;
1299 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1300 : spdm_measurements_response_t *spdm_response;
1301 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1302 : size_t arbitrary_size;
1303 : #endif
1304 :
1305 1 : spdm_test_context = *state;
1306 1 : spdm_context = spdm_test_context->spdm_context;
1307 1 : spdm_test_context->case_id = 0x18;
1308 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1309 1 : spdm_context->local_context.capability.flags |=
1310 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1311 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1312 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1313 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1314 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1315 : m_libspdm_use_measurement_hash_algo;
1316 1 : libspdm_reset_message_m(spdm_context, NULL);
1317 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1318 1 : spdm_context->last_spdm_request_session_id_valid = 0;
1319 :
1320 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1321 : /*filling M buffer with arbitrary data*/
1322 : arbitrary_size = 18;
1323 : libspdm_set_mem(spdm_context->transcript.message_m.buffer, arbitrary_size, (uint8_t) 0xFF);
1324 : spdm_context->transcript.message_m.buffer_size = arbitrary_size;
1325 : #endif
1326 :
1327 1 : response_size = sizeof(response);
1328 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request7.nonce);
1329 1 : status = libspdm_get_response_measurements(
1330 : spdm_context, m_libspdm_get_measurements_request7_size,
1331 : &m_libspdm_get_measurements_request7, &response_size, response);
1332 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1333 1 : assert_int_equal(response_size,
1334 : sizeof(spdm_measurements_response_t) + LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER*
1335 : (sizeof(spdm_measurement_block_dmtf_t) +
1336 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo)) +
1337 : (sizeof(spdm_measurement_block_dmtf_t) +
1338 : sizeof(spdm_measurements_secure_version_number_t)) +
1339 : (sizeof(spdm_measurement_block_dmtf_t) +
1340 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo)) +
1341 : (sizeof(spdm_measurement_block_dmtf_t) + LIBSPDM_MEASUREMENT_MANIFEST_SIZE) +
1342 : (sizeof(spdm_measurement_block_dmtf_t) +
1343 : sizeof(spdm_measurements_device_mode_t)) +
1344 : SPDM_NONCE_SIZE + sizeof(uint16_t));
1345 1 : spdm_response = (void *)response;
1346 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1347 1 : assert_int_equal(spdm_response->number_of_blocks, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
1348 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1349 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
1350 : arbitrary_size + m_libspdm_get_measurements_request7_size +
1351 : sizeof(spdm_measurements_response_t) + LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER*
1352 : (sizeof(spdm_measurement_block_dmtf_t) +
1353 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo)) +
1354 : (sizeof(spdm_measurement_block_dmtf_t) +
1355 : sizeof(spdm_measurements_secure_version_number_t)) +
1356 : (sizeof(spdm_measurement_block_dmtf_t) +
1357 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo)) +
1358 : (sizeof(spdm_measurement_block_dmtf_t) + LIBSPDM_MEASUREMENT_MANIFEST_SIZE) +
1359 : (sizeof(spdm_measurement_block_dmtf_t) +
1360 : sizeof(spdm_measurements_device_mode_t)) +
1361 : SPDM_NONCE_SIZE + sizeof(uint16_t));
1362 :
1363 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
1364 : arbitrary_size + m_libspdm_get_measurements_request7_size + response_size);
1365 : assert_memory_equal(spdm_context->transcript.message_m.buffer + arbitrary_size,
1366 : &m_libspdm_get_measurements_request7,
1367 : m_libspdm_get_measurements_request7_size);
1368 : assert_memory_equal(spdm_context->transcript.message_m.buffer + arbitrary_size
1369 : + m_libspdm_get_measurements_request7_size,
1370 : response, response_size);
1371 : #endif
1372 1 : }
1373 :
1374 1 : static void rsp_measurements_case25(void **state)
1375 : {
1376 : libspdm_return_t status;
1377 : libspdm_test_context_t *spdm_test_context;
1378 : libspdm_context_t *spdm_context;
1379 : size_t response_size;
1380 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1381 : spdm_measurements_response_t *spdm_response;
1382 :
1383 1 : spdm_test_context = *state;
1384 1 : spdm_context = spdm_test_context->spdm_context;
1385 1 : spdm_test_context->case_id = 0x19;
1386 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1387 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1388 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1389 1 : spdm_context->local_context.capability.flags |=
1390 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1391 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1392 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1393 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1394 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1395 : m_libspdm_use_measurement_hash_algo;
1396 1 : libspdm_reset_message_m(spdm_context, NULL);
1397 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1398 :
1399 1 : response_size = sizeof(response);
1400 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request14.nonce);
1401 1 : status = libspdm_get_response_measurements(
1402 : spdm_context, m_libspdm_get_measurements_request14_size,
1403 : &m_libspdm_get_measurements_request14, &response_size, response);
1404 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1405 1 : assert_int_equal(response_size,
1406 : sizeof(spdm_measurements_response_t) +
1407 : sizeof(spdm_measurement_block_dmtf_t) +
1408 : LIBSPDM_MEASUREMENT_RAW_DATA_SIZE + SPDM_NONCE_SIZE +
1409 : sizeof(uint16_t));
1410 1 : spdm_response = (void *)response;
1411 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1412 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1413 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
1414 : m_libspdm_get_measurements_request14_size +
1415 : sizeof(spdm_measurements_response_t) +
1416 : sizeof(spdm_measurement_block_dmtf_t) +
1417 : LIBSPDM_MEASUREMENT_RAW_DATA_SIZE + SPDM_NONCE_SIZE +
1418 : sizeof(uint16_t));
1419 : #endif
1420 1 : }
1421 :
1422 1 : static void rsp_measurements_case26(void **state)
1423 : {
1424 : libspdm_return_t status;
1425 : libspdm_test_context_t *spdm_test_context;
1426 : libspdm_context_t *spdm_context;
1427 : size_t response_size;
1428 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1429 : spdm_measurements_response_t *spdm_response;
1430 : void *data;
1431 : size_t data_size;
1432 : size_t measurment_sig_size;
1433 :
1434 1 : spdm_test_context = *state;
1435 1 : spdm_context = spdm_test_context->spdm_context;
1436 1 : spdm_test_context->case_id = 0x1A;
1437 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1438 1 : spdm_context->local_context.capability.flags |=
1439 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1440 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1441 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1442 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1443 : m_libspdm_use_measurement_hash_algo;
1444 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1445 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1446 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1447 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1448 1 : libspdm_reset_message_m(spdm_context, NULL);
1449 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1450 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1451 : m_libspdm_use_asym_algo, &data,
1452 : &data_size, NULL, NULL);
1453 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1454 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1455 9 : for (int i = 0; i < SPDM_MAX_SLOT_COUNT; i++) {
1456 8 : spdm_context->local_context.local_cert_chain_provision_size[i] = data_size;
1457 8 : spdm_context->local_context.local_cert_chain_provision[i] = data;
1458 : }
1459 :
1460 1 : response_size = sizeof(response);
1461 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request15.nonce);
1462 1 : status = libspdm_get_response_measurements(
1463 : spdm_context, m_libspdm_get_measurements_request15_size,
1464 : &m_libspdm_get_measurements_request15, &response_size, response);
1465 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1466 1 : assert_int_equal(response_size,
1467 : sizeof(spdm_measurements_response_t) +
1468 : sizeof(spdm_measurement_block_dmtf_t) +
1469 : libspdm_get_measurement_hash_size(
1470 : m_libspdm_use_measurement_hash_algo) +
1471 : measurment_sig_size);
1472 1 : spdm_response = (void *)response;
1473 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1474 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1475 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1476 : #endif
1477 1 : assert_int_equal(spdm_response->header.param2, m_libspdm_get_measurements_request15.slot_id_param|
1478 : (SPDM_MEASUREMENTS_RESPONSE_CONTENT_NO_CHANGE_DETECTED &
1479 : SPDM_MEASUREMENTS_RESPONSE_CONTENT_CHANGE_MASK));
1480 :
1481 1 : free(data);
1482 1 : }
1483 :
1484 1 : static void rsp_measurements_case27(void **state)
1485 : {
1486 : libspdm_return_t status;
1487 : libspdm_test_context_t *spdm_test_context;
1488 : libspdm_context_t *spdm_context;
1489 : size_t response_size;
1490 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1491 : spdm_measurements_response_t *spdm_response;
1492 : void *data;
1493 : size_t data_size;
1494 : size_t measurment_sig_size;
1495 : uint8_t content_changed;
1496 : uint8_t measurements_count;
1497 : uint8_t *measurement_record_data;
1498 : size_t measurement_record_data_length;
1499 : uint8_t expect_measurement_record_data[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
1500 : size_t expect_measurement_record_data_length;
1501 : uint8_t *opaque_data;
1502 : uint16_t *opaque_data_size;
1503 : uint8_t expect_opaque_data[SPDM_MAX_OPAQUE_DATA_SIZE];
1504 : size_t expect_opaque_data_size;
1505 :
1506 1 : spdm_test_context = *state;
1507 1 : spdm_context = spdm_test_context->spdm_context;
1508 1 : spdm_test_context->case_id = 0x1B;
1509 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1510 1 : spdm_context->local_context.capability.flags |=
1511 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1512 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1513 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1514 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1515 : m_libspdm_use_measurement_hash_algo;
1516 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1517 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1518 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1519 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1520 1 : spdm_context->connection_info.algorithm.other_params_support =
1521 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
1522 1 : libspdm_reset_message_m(spdm_context, NULL);
1523 :
1524 : /*opaque data*/
1525 1 : libspdm_secret_lib_meas_opaque_data_size = 0x20;
1526 :
1527 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1528 : m_libspdm_use_asym_algo, &data,
1529 : &data_size, NULL, NULL);
1530 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) +
1531 1 : libspdm_secret_lib_meas_opaque_data_size +
1532 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1533 9 : for (int i = 0; i < SPDM_MAX_SLOT_COUNT; i++) {
1534 8 : spdm_context->local_context.local_cert_chain_provision_size[i] = data_size;
1535 8 : spdm_context->local_context.local_cert_chain_provision[i] = data;
1536 : }
1537 :
1538 1 : response_size = sizeof(response);
1539 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request15.nonce);
1540 1 : status = libspdm_get_response_measurements(
1541 : spdm_context, m_libspdm_get_measurements_request15_size,
1542 : &m_libspdm_get_measurements_request15, &response_size, response);
1543 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1544 1 : assert_int_equal(response_size,
1545 : sizeof(spdm_measurements_response_t) +
1546 : sizeof(spdm_measurement_block_dmtf_t) +
1547 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo) +
1548 : measurment_sig_size);
1549 1 : spdm_response = (void *)response;
1550 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1551 :
1552 1 : expect_measurement_record_data_length = sizeof(expect_measurement_record_data);
1553 1 : expect_opaque_data_size = sizeof(expect_opaque_data);
1554 :
1555 1 : libspdm_measurement_collection(
1556 : spdm_context,
1557 : NULL,
1558 1 : spdm_context->connection_info.version,
1559 1 : spdm_context->connection_info.algorithm.measurement_spec,
1560 : spdm_context->connection_info.algorithm.measurement_hash_algo,
1561 1 : m_libspdm_get_measurements_request15.header.param2,
1562 1 : m_libspdm_get_measurements_request15.header.param1,
1563 : 0,
1564 : NULL,
1565 : &content_changed,
1566 : &measurements_count,
1567 : expect_measurement_record_data,
1568 : &expect_measurement_record_data_length);
1569 :
1570 1 : libspdm_measurement_opaque_data(
1571 : spdm_context,
1572 : NULL,
1573 1 : spdm_context->connection_info.version,
1574 1 : spdm_context->connection_info.algorithm.measurement_spec,
1575 : spdm_context->connection_info.algorithm.measurement_hash_algo,
1576 1 : m_libspdm_get_measurements_request15.header.param2,
1577 1 : m_libspdm_get_measurements_request15.header.param1,
1578 : 0,
1579 : NULL,
1580 : expect_opaque_data,
1581 : &expect_opaque_data_size);
1582 :
1583 1 : measurement_record_data = (uint8_t *)response + sizeof(spdm_measurements_response_t);
1584 1 : opaque_data_size =
1585 : (uint16_t *)(measurement_record_data + sizeof(spdm_measurement_block_dmtf_t) +
1586 1 : libspdm_get_measurement_hash_size(
1587 1 : m_libspdm_use_measurement_hash_algo) +
1588 : SPDM_NONCE_SIZE);
1589 1 : opaque_data = (uint8_t *)opaque_data_size + sizeof(uint16_t);
1590 :
1591 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
1592 :
1593 1 : assert_int_equal(measurement_record_data_length, expect_measurement_record_data_length );
1594 1 : assert_memory_equal(measurement_record_data, expect_measurement_record_data,
1595 : expect_measurement_record_data_length);
1596 1 : assert_int_equal(*opaque_data_size, libspdm_secret_lib_meas_opaque_data_size);
1597 1 : assert_memory_equal(opaque_data, expect_opaque_data, libspdm_secret_lib_meas_opaque_data_size);
1598 :
1599 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1600 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1601 : #endif
1602 1 : assert_int_equal(spdm_response->header.param2, m_libspdm_get_measurements_request15.slot_id_param|
1603 : (SPDM_MEASUREMENTS_RESPONSE_CONTENT_NO_CHANGE_DETECTED &
1604 : SPDM_MEASUREMENTS_RESPONSE_CONTENT_CHANGE_MASK));
1605 :
1606 1 : free(data);
1607 1 : }
1608 :
1609 : /**
1610 : * Test 28: Successful response to get all measurements with signature using slot_id 0xFF
1611 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m, and correct response message size and fields
1612 : **/
1613 1 : static void rsp_measurements_case28(void **state)
1614 : {
1615 : libspdm_return_t status;
1616 : libspdm_test_context_t *spdm_test_context;
1617 : libspdm_context_t *spdm_context;
1618 : size_t response_size;
1619 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1620 : spdm_measurements_response_t *spdm_response;
1621 : void *data;
1622 : size_t data_size;
1623 : size_t measurment_sig_size;
1624 :
1625 1 : spdm_test_context = *state;
1626 1 : spdm_context = spdm_test_context->spdm_context;
1627 1 : spdm_test_context->case_id = 0x1C;
1628 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1629 1 : spdm_context->local_context.capability.flags |=
1630 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1631 1 : spdm_context->local_context.capability.flags |=
1632 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PUB_KEY_ID_CAP;
1633 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1634 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1635 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1636 : m_libspdm_use_measurement_hash_algo;
1637 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1638 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1639 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1640 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1641 1 : libspdm_reset_message_m(spdm_context, NULL);
1642 :
1643 : /*opaque data*/
1644 1 : libspdm_secret_lib_meas_opaque_data_size = 0x20;
1645 :
1646 1 : libspdm_read_responder_public_key(m_libspdm_use_asym_algo, &data, &data_size);
1647 1 : spdm_context->local_context.local_public_key_provision = data;
1648 1 : spdm_context->local_context.local_public_key_provision_size = data_size;
1649 :
1650 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) +
1651 1 : libspdm_secret_lib_meas_opaque_data_size +
1652 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1653 1 : response_size = sizeof(response);
1654 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request16.nonce);
1655 1 : m_libspdm_get_measurements_request16.slot_id_param = 0xF;
1656 1 : status = libspdm_get_response_measurements(
1657 : spdm_context, m_libspdm_get_measurements_request16_size,
1658 : &m_libspdm_get_measurements_request16, &response_size, response);
1659 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1660 1 : assert_int_equal(response_size,
1661 : sizeof(spdm_measurements_response_t) + sizeof(spdm_measurement_block_dmtf_t) +
1662 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo) +
1663 : measurment_sig_size);
1664 1 : spdm_response = (void *)response;
1665 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1666 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1667 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1668 : #endif
1669 1 : assert_int_equal(spdm_response->header.param2,
1670 : m_libspdm_get_measurements_request16.slot_id_param |
1671 : (SPDM_MEASUREMENTS_RESPONSE_CONTENT_NO_CHANGE_DETECTED &
1672 : SPDM_MEASUREMENTS_RESPONSE_CONTENT_CHANGE_MASK));
1673 :
1674 1 : free(data);
1675 1 : }
1676 :
1677 : /**
1678 : * Test 29: Based of Test Case 7 Successful response to get a number of measurements
1679 : * with signature.
1680 : * Signature test with signing in big endian but verification in little endian.
1681 : *
1682 : * Expected Behavior: Failing signature verification
1683 : **/
1684 1 : static void rsp_measurements_case29(void** state)
1685 : {
1686 : libspdm_return_t status;
1687 : libspdm_test_context_t* spdm_test_context;
1688 : libspdm_context_t* spdm_context;
1689 : size_t response_size;
1690 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1691 : spdm_measurements_response_t* spdm_response;
1692 : size_t measurment_sig_size;
1693 :
1694 : bool result;
1695 : uint32_t measurement_record_data_length;
1696 : uint8_t* measurement_record_data;
1697 : uint8_t* ptr;
1698 : uint16_t opaque_length;
1699 : void* signature;
1700 : size_t signature_size;
1701 : libspdm_session_info_t* session_info;
1702 : void* data;
1703 : size_t data_size;
1704 : void* hash;
1705 : size_t hash_size;
1706 :
1707 1 : spdm_test_context = *state;
1708 1 : spdm_context = spdm_test_context->spdm_context;
1709 1 : spdm_test_context->case_id = 29;
1710 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1711 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1712 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1713 1 : spdm_context->local_context.capability.flags |=
1714 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1715 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1716 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1717 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1718 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1719 : m_libspdm_use_measurement_hash_algo;
1720 1 : spdm_context->spdm_10_11_verify_signature_endian =
1721 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_LITTLE_ONLY;
1722 :
1723 1 : libspdm_reset_message_m(spdm_context, NULL);
1724 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1725 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1726 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1727 :
1728 1 : response_size = sizeof(response);
1729 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
1730 1 : status = libspdm_get_response_measurements(
1731 : spdm_context, m_libspdm_get_measurements_request5_size,
1732 : &m_libspdm_get_measurements_request5, &response_size, response);
1733 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1734 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
1735 1 : spdm_response = (void*)response;
1736 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1737 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
1738 :
1739 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1740 : m_libspdm_use_asym_algo, &data,
1741 : &data_size,
1742 : &hash, &hash_size)) {
1743 0 : assert(false);
1744 : }
1745 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1746 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1747 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1748 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1749 : data, data_size);
1750 : #else
1751 1 : libspdm_hash_all(
1752 : spdm_context->connection_info.algorithm.base_hash_algo,
1753 : data, data_size,
1754 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
1755 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
1756 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
1757 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
1758 : spdm_context->connection_info.algorithm.base_hash_algo,
1759 : spdm_context->connection_info.algorithm.base_asym_algo,
1760 : data, data_size,
1761 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
1762 : #endif
1763 :
1764 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
1765 1 : measurement_record_data = (void*)(spdm_response + 1);
1766 1 : ptr = measurement_record_data + measurement_record_data_length;
1767 1 : ptr += SPDM_NONCE_SIZE;
1768 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
1769 1 : ptr += sizeof(uint16_t);
1770 1 : ptr += opaque_length;
1771 1 : signature = ptr;
1772 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1773 1 : session_info = NULL;
1774 :
1775 1 : status = libspdm_append_message_m(spdm_context, session_info,
1776 : &m_libspdm_get_measurements_request5,
1777 : m_libspdm_get_measurements_request5_size);
1778 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1779 :
1780 1 : status = libspdm_append_message_m(spdm_context, session_info, spdm_response,
1781 : response_size - signature_size);
1782 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1783 :
1784 1 : result = libspdm_verify_measurement_signature(
1785 : spdm_context, session_info, 0, signature, signature_size);
1786 1 : assert_false(result);
1787 :
1788 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1789 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1790 : #endif
1791 1 : }
1792 :
1793 : /**
1794 : * Test 30: Based of Test Case 7 Successful response to get a number of measurements
1795 : * with signature.
1796 : * Signature test with signing in big endian but verification in little endian.
1797 : *
1798 : * Expected Behavior: Failing signature verification
1799 : **/
1800 1 : static void rsp_measurements_case30(void** state)
1801 : {
1802 : libspdm_return_t status;
1803 : libspdm_test_context_t* spdm_test_context;
1804 : libspdm_context_t* spdm_context;
1805 : size_t response_size;
1806 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1807 : spdm_measurements_response_t* spdm_response;
1808 : size_t measurment_sig_size;
1809 :
1810 : bool result;
1811 : uint32_t measurement_record_data_length;
1812 : uint8_t* measurement_record_data;
1813 : uint8_t* ptr;
1814 : uint16_t opaque_length;
1815 : void* signature;
1816 : size_t signature_size;
1817 : libspdm_session_info_t* session_info;
1818 : void* data;
1819 : size_t data_size;
1820 : void* hash;
1821 : size_t hash_size;
1822 :
1823 1 : spdm_test_context = *state;
1824 1 : spdm_context = spdm_test_context->spdm_context;
1825 1 : spdm_test_context->case_id = 30;
1826 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1827 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1828 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1829 1 : spdm_context->local_context.capability.flags |=
1830 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1831 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1832 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1833 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1834 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1835 : m_libspdm_use_measurement_hash_algo;
1836 1 : spdm_context->spdm_10_11_verify_signature_endian =
1837 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_BIG_ONLY;
1838 :
1839 1 : libspdm_reset_message_m(spdm_context, NULL);
1840 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1841 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1842 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1843 :
1844 1 : response_size = sizeof(response);
1845 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
1846 1 : status = libspdm_get_response_measurements(
1847 : spdm_context, m_libspdm_get_measurements_request5_size,
1848 : &m_libspdm_get_measurements_request5, &response_size, response);
1849 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1850 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
1851 1 : spdm_response = (void*)response;
1852 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1853 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
1854 :
1855 1 : libspdm_read_responder_public_certificate_chain(
1856 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
1857 : &data, &data_size,
1858 : &hash, &hash_size);
1859 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1860 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1861 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1862 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1863 : data, data_size);
1864 : #else
1865 1 : libspdm_hash_all(
1866 : spdm_context->connection_info.algorithm.base_hash_algo,
1867 : data, data_size,
1868 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
1869 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
1870 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
1871 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
1872 : spdm_context->connection_info.algorithm.base_hash_algo,
1873 : spdm_context->connection_info.algorithm.base_asym_algo,
1874 : data, data_size,
1875 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
1876 : #endif
1877 :
1878 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
1879 1 : measurement_record_data = (void*)(spdm_response + 1);
1880 1 : ptr = measurement_record_data + measurement_record_data_length;
1881 1 : ptr += SPDM_NONCE_SIZE;
1882 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
1883 1 : ptr += sizeof(uint16_t);
1884 1 : ptr += opaque_length;
1885 1 : signature = ptr;
1886 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1887 1 : session_info = NULL;
1888 :
1889 1 : status = libspdm_append_message_m(
1890 : spdm_context, session_info,
1891 : &m_libspdm_get_measurements_request5,
1892 : m_libspdm_get_measurements_request5_size);
1893 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1894 :
1895 1 : status = libspdm_append_message_m(
1896 : spdm_context, session_info, spdm_response,
1897 : response_size - signature_size);
1898 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1899 :
1900 1 : result = libspdm_verify_measurement_signature(
1901 : spdm_context, session_info, 0, signature, signature_size);
1902 1 : assert_true(result);
1903 :
1904 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1905 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1906 : #endif
1907 1 : }
1908 :
1909 : /**
1910 : * Test 31: Based of Test Case 7 Successful response to get a number of measurements
1911 : * with signature.
1912 : * Signature test with signing in big endian but verification in big or little endian.
1913 : *
1914 : * Expected Behavior: Passing signature verification
1915 : **/
1916 1 : static void rsp_measurements_case31(void** state)
1917 : {
1918 : libspdm_return_t status;
1919 : libspdm_test_context_t* spdm_test_context;
1920 : libspdm_context_t* spdm_context;
1921 : size_t response_size;
1922 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1923 : spdm_measurements_response_t* spdm_response;
1924 : size_t measurment_sig_size;
1925 :
1926 : bool result;
1927 : uint32_t measurement_record_data_length;
1928 : uint8_t* measurement_record_data;
1929 : uint8_t* ptr;
1930 : uint16_t opaque_length;
1931 : void* signature;
1932 : size_t signature_size;
1933 : libspdm_session_info_t* session_info;
1934 : void* data;
1935 : size_t data_size;
1936 : void* hash;
1937 : size_t hash_size;
1938 :
1939 1 : spdm_test_context = *state;
1940 1 : spdm_context = spdm_test_context->spdm_context;
1941 1 : spdm_test_context->case_id = 31;
1942 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1943 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1944 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1945 1 : spdm_context->local_context.capability.flags |=
1946 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1947 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1948 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1949 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1950 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1951 : m_libspdm_use_measurement_hash_algo;
1952 1 : spdm_context->spdm_10_11_verify_signature_endian =
1953 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_BIG_OR_LITTLE;
1954 :
1955 1 : libspdm_reset_message_m(spdm_context, NULL);
1956 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1957 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1958 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1959 :
1960 1 : response_size = sizeof(response);
1961 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
1962 1 : status = libspdm_get_response_measurements(
1963 : spdm_context, m_libspdm_get_measurements_request5_size,
1964 : &m_libspdm_get_measurements_request5, &response_size, response);
1965 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1966 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
1967 1 : spdm_response = (void*)response;
1968 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1969 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
1970 :
1971 1 : libspdm_read_responder_public_certificate_chain(
1972 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
1973 : &data, &data_size,
1974 : &hash, &hash_size);
1975 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1976 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1977 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1978 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1979 : data, data_size);
1980 : #else
1981 1 : libspdm_hash_all(
1982 : spdm_context->connection_info.algorithm.base_hash_algo,
1983 : data, data_size,
1984 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
1985 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
1986 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
1987 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
1988 : spdm_context->connection_info.algorithm.base_hash_algo,
1989 : spdm_context->connection_info.algorithm.base_asym_algo,
1990 : data, data_size,
1991 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
1992 : #endif
1993 :
1994 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
1995 1 : measurement_record_data = (void*)(spdm_response + 1);
1996 1 : ptr = measurement_record_data + measurement_record_data_length;
1997 1 : ptr += SPDM_NONCE_SIZE;
1998 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
1999 1 : ptr += sizeof(uint16_t);
2000 1 : ptr += opaque_length;
2001 1 : signature = ptr;
2002 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2003 1 : session_info = NULL;
2004 :
2005 1 : status = libspdm_append_message_m(
2006 : spdm_context, session_info,
2007 : &m_libspdm_get_measurements_request5,
2008 : m_libspdm_get_measurements_request5_size);
2009 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2010 :
2011 1 : status = libspdm_append_message_m(
2012 : spdm_context, session_info, spdm_response,
2013 : response_size - signature_size);
2014 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2015 :
2016 1 : result = libspdm_verify_measurement_signature(
2017 : spdm_context, session_info, 0, signature, signature_size);
2018 1 : assert_true(result);
2019 :
2020 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2021 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2022 : #endif
2023 1 : }
2024 :
2025 : /**
2026 : * Test 32: Based of Test Case 7 Successful response to get a number of measurements
2027 : * with signature.
2028 : * Signature test with signing in little endian but verification in little endian.
2029 : *
2030 : * Expected Behavior: Failing signature verification
2031 : **/
2032 1 : static void rsp_measurements_case32(void** state)
2033 : {
2034 : libspdm_return_t status;
2035 : libspdm_test_context_t* spdm_test_context;
2036 : libspdm_context_t* spdm_context;
2037 : size_t response_size;
2038 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2039 : spdm_measurements_response_t* spdm_response;
2040 : size_t measurment_sig_size;
2041 :
2042 : bool result;
2043 : uint32_t measurement_record_data_length;
2044 : uint8_t* measurement_record_data;
2045 : uint8_t* ptr;
2046 : uint16_t opaque_length;
2047 : void* signature;
2048 : size_t signature_size;
2049 : libspdm_session_info_t* session_info;
2050 : void* data;
2051 : size_t data_size;
2052 : void* hash;
2053 : size_t hash_size;
2054 :
2055 1 : spdm_test_context = *state;
2056 1 : spdm_context = spdm_test_context->spdm_context;
2057 1 : spdm_test_context->case_id = 32;
2058 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
2059 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2060 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2061 1 : spdm_context->local_context.capability.flags |=
2062 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2063 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2064 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2065 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2066 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2067 : m_libspdm_use_measurement_hash_algo;
2068 1 : spdm_context->spdm_10_11_verify_signature_endian =
2069 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_LITTLE_ONLY;
2070 :
2071 1 : libspdm_reset_message_m(spdm_context, NULL);
2072 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2073 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
2074 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2075 :
2076 1 : response_size = sizeof(response);
2077 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
2078 1 : status = libspdm_get_response_measurements(
2079 : spdm_context, m_libspdm_get_measurements_request5_size,
2080 : &m_libspdm_get_measurements_request5, &response_size, response);
2081 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2082 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
2083 1 : spdm_response = (void*)response;
2084 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
2085 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
2086 :
2087 1 : libspdm_read_responder_public_certificate_chain(
2088 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
2089 : &data, &data_size,
2090 : &hash, &hash_size);
2091 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2092 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
2093 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2094 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2095 : data, data_size);
2096 : #else
2097 1 : libspdm_hash_all(
2098 : spdm_context->connection_info.algorithm.base_hash_algo,
2099 : data, data_size,
2100 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
2101 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2102 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2103 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2104 : spdm_context->connection_info.algorithm.base_hash_algo,
2105 : spdm_context->connection_info.algorithm.base_asym_algo,
2106 : data, data_size,
2107 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2108 : #endif
2109 :
2110 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
2111 1 : measurement_record_data = (void*)(spdm_response + 1);
2112 1 : ptr = measurement_record_data + measurement_record_data_length;
2113 1 : ptr += SPDM_NONCE_SIZE;
2114 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
2115 1 : ptr += sizeof(uint16_t);
2116 1 : ptr += opaque_length;
2117 1 : signature = ptr;
2118 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2119 :
2120 1 : libspdm_copy_signature_swap_endian(
2121 : m_libspdm_use_asym_algo,
2122 : signature, signature_size, signature, signature_size);
2123 :
2124 1 : session_info = NULL;
2125 :
2126 1 : status = libspdm_append_message_m(
2127 : spdm_context, session_info,
2128 : &m_libspdm_get_measurements_request5,
2129 : m_libspdm_get_measurements_request5_size);
2130 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2131 :
2132 1 : status = libspdm_append_message_m(
2133 : spdm_context, session_info, spdm_response,
2134 : response_size - signature_size);
2135 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2136 :
2137 1 : result = libspdm_verify_measurement_signature(
2138 : spdm_context, session_info, 0, signature, signature_size);
2139 1 : assert_true(result);
2140 :
2141 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2142 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2143 : #endif
2144 1 : }
2145 :
2146 : /**
2147 : * Test 33: Based of Test Case 7 Successful response to get a number of measurements
2148 : * with signature.
2149 : * Signature test with signing in little endian but verification in big endian.
2150 : *
2151 : * Expected Behavior: Failing signature verification
2152 : **/
2153 1 : static void rsp_measurements_case33(void** state)
2154 : {
2155 : libspdm_return_t status;
2156 : libspdm_test_context_t* spdm_test_context;
2157 : libspdm_context_t* spdm_context;
2158 : size_t response_size;
2159 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2160 : spdm_measurements_response_t* spdm_response;
2161 : size_t measurment_sig_size;
2162 :
2163 : bool result;
2164 : uint32_t measurement_record_data_length;
2165 : uint8_t* measurement_record_data;
2166 : uint8_t* ptr;
2167 : uint16_t opaque_length;
2168 : void* signature;
2169 : size_t signature_size;
2170 : libspdm_session_info_t* session_info;
2171 : void* data;
2172 : size_t data_size;
2173 : void* hash;
2174 : size_t hash_size;
2175 :
2176 1 : spdm_test_context = *state;
2177 1 : spdm_context = spdm_test_context->spdm_context;
2178 1 : spdm_test_context->case_id = 33;
2179 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
2180 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2181 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2182 1 : spdm_context->local_context.capability.flags |=
2183 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2184 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2185 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2186 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2187 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2188 : m_libspdm_use_measurement_hash_algo;
2189 1 : spdm_context->spdm_10_11_verify_signature_endian =
2190 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_BIG_ONLY;
2191 :
2192 1 : libspdm_reset_message_m(spdm_context, NULL);
2193 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2194 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
2195 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2196 :
2197 1 : response_size = sizeof(response);
2198 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
2199 1 : status = libspdm_get_response_measurements(
2200 : spdm_context, m_libspdm_get_measurements_request5_size,
2201 : &m_libspdm_get_measurements_request5, &response_size, response);
2202 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2203 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
2204 1 : spdm_response = (void*)response;
2205 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
2206 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
2207 :
2208 1 : libspdm_read_responder_public_certificate_chain(
2209 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
2210 : &data, &data_size,
2211 : &hash, &hash_size);
2212 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2213 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
2214 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2215 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2216 : data, data_size);
2217 : #else
2218 1 : libspdm_hash_all(
2219 : spdm_context->connection_info.algorithm.base_hash_algo,
2220 : data, data_size,
2221 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
2222 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2223 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2224 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2225 : spdm_context->connection_info.algorithm.base_hash_algo,
2226 : spdm_context->connection_info.algorithm.base_asym_algo,
2227 : data, data_size,
2228 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2229 : #endif
2230 :
2231 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
2232 1 : measurement_record_data = (void*)(spdm_response + 1);
2233 1 : ptr = measurement_record_data + measurement_record_data_length;
2234 1 : ptr += SPDM_NONCE_SIZE;
2235 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
2236 1 : ptr += sizeof(uint16_t);
2237 1 : ptr += opaque_length;
2238 1 : signature = ptr;
2239 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2240 :
2241 1 : libspdm_copy_signature_swap_endian(
2242 : m_libspdm_use_asym_algo,
2243 : signature, signature_size, signature, signature_size);
2244 :
2245 1 : session_info = NULL;
2246 :
2247 1 : status = libspdm_append_message_m(
2248 : spdm_context, session_info,
2249 : &m_libspdm_get_measurements_request5,
2250 : m_libspdm_get_measurements_request5_size);
2251 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2252 :
2253 1 : status = libspdm_append_message_m(
2254 : spdm_context, session_info, spdm_response,
2255 : response_size - signature_size);
2256 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2257 :
2258 1 : result = libspdm_verify_measurement_signature(
2259 : spdm_context, session_info, 0, signature, signature_size);
2260 1 : assert_false(result);
2261 :
2262 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2263 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2264 : #endif
2265 1 : }
2266 :
2267 :
2268 : /**
2269 : * Test 34: Based of Test Case 7 Successful response to get a number of measurements
2270 : * with signature.
2271 : * Signature test with signing in little endian but verification in big or little endian.
2272 : *
2273 : * Expected Behavior: Passing signature verification
2274 : **/
2275 1 : static void rsp_measurements_case34(void** state)
2276 : {
2277 : libspdm_return_t status;
2278 : libspdm_test_context_t* spdm_test_context;
2279 : libspdm_context_t* spdm_context;
2280 : size_t response_size;
2281 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2282 : spdm_measurements_response_t* spdm_response;
2283 : size_t measurment_sig_size;
2284 :
2285 : bool result;
2286 : uint32_t measurement_record_data_length;
2287 : uint8_t* measurement_record_data;
2288 : uint8_t* ptr;
2289 : uint16_t opaque_length;
2290 : void* signature;
2291 : size_t signature_size;
2292 : libspdm_session_info_t* session_info;
2293 : void* data;
2294 : size_t data_size;
2295 : void* hash;
2296 : size_t hash_size;
2297 :
2298 1 : spdm_test_context = *state;
2299 1 : spdm_context = spdm_test_context->spdm_context;
2300 1 : spdm_test_context->case_id = 34;
2301 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
2302 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2303 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2304 1 : spdm_context->local_context.capability.flags |=
2305 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2306 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2307 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2308 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2309 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2310 : m_libspdm_use_measurement_hash_algo;
2311 1 : spdm_context->spdm_10_11_verify_signature_endian =
2312 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_BIG_OR_LITTLE;
2313 :
2314 1 : libspdm_reset_message_m(spdm_context, NULL);
2315 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2316 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
2317 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2318 :
2319 1 : response_size = sizeof(response);
2320 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
2321 1 : status = libspdm_get_response_measurements(
2322 : spdm_context, m_libspdm_get_measurements_request5_size,
2323 : &m_libspdm_get_measurements_request5, &response_size, response);
2324 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2325 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
2326 1 : spdm_response = (void*)response;
2327 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
2328 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
2329 :
2330 1 : libspdm_read_responder_public_certificate_chain(
2331 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
2332 : &data, &data_size,
2333 : &hash, &hash_size);
2334 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2335 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
2336 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2337 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2338 : data, data_size);
2339 : #else
2340 1 : libspdm_hash_all(
2341 : spdm_context->connection_info.algorithm.base_hash_algo,
2342 : data, data_size,
2343 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
2344 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2345 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2346 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2347 : spdm_context->connection_info.algorithm.base_hash_algo,
2348 : spdm_context->connection_info.algorithm.base_asym_algo,
2349 : data, data_size,
2350 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2351 : #endif
2352 :
2353 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
2354 1 : measurement_record_data = (void*)(spdm_response + 1);
2355 1 : ptr = measurement_record_data + measurement_record_data_length;
2356 1 : ptr += SPDM_NONCE_SIZE;
2357 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
2358 1 : ptr += sizeof(uint16_t);
2359 1 : ptr += opaque_length;
2360 1 : signature = ptr;
2361 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2362 1 : libspdm_copy_signature_swap_endian(
2363 : m_libspdm_use_asym_algo,
2364 : signature, signature_size, signature, signature_size);
2365 :
2366 1 : session_info = NULL;
2367 :
2368 1 : status = libspdm_append_message_m(
2369 : spdm_context, session_info,
2370 : &m_libspdm_get_measurements_request5,
2371 : m_libspdm_get_measurements_request5_size);
2372 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2373 :
2374 1 : status = libspdm_append_message_m(
2375 : spdm_context, session_info, spdm_response,
2376 : response_size - signature_size);
2377 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2378 :
2379 1 : result = libspdm_verify_measurement_signature(
2380 : spdm_context, session_info, 0, signature, signature_size);
2381 1 : assert_true(result);
2382 :
2383 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2384 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2385 : #endif
2386 1 : }
2387 :
2388 : /**
2389 : * Test 35: Successful response V1.3 to get a number of measurements without signature
2390 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, correct context field
2391 : **/
2392 1 : static void rsp_measurements_case35(void **state)
2393 : {
2394 : libspdm_return_t status;
2395 : libspdm_test_context_t *spdm_test_context;
2396 : libspdm_context_t *spdm_context;
2397 : size_t response_size;
2398 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2399 : spdm_measurements_response_t *spdm_response;
2400 : uint8_t *requester_context;
2401 : uint8_t *responder_context;
2402 :
2403 1 : spdm_test_context = *state;
2404 1 : spdm_context = spdm_test_context->spdm_context;
2405 1 : spdm_test_context->case_id = 35;
2406 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
2407 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2408 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2409 1 : spdm_context->local_context.capability.flags |=
2410 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2411 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2412 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2413 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2414 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2415 : m_libspdm_use_measurement_hash_algo;
2416 1 : libspdm_reset_message_m(spdm_context, NULL);
2417 :
2418 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2419 :
2420 1 : response_size = sizeof(response);
2421 :
2422 1 : requester_context = ((uint8_t *)&m_libspdm_get_measurements_request17) +
2423 : m_libspdm_get_measurements_request17_size;
2424 1 : libspdm_set_mem(requester_context, SPDM_REQ_CONTEXT_SIZE, 0xAA);
2425 1 : m_libspdm_get_measurements_request17_size += SPDM_REQ_CONTEXT_SIZE;
2426 :
2427 1 : status = libspdm_get_response_measurements(
2428 : spdm_context, m_libspdm_get_measurements_request17_size,
2429 : &m_libspdm_get_measurements_request17, &response_size, response);
2430 :
2431 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2432 1 : assert_int_equal(response_size,
2433 : sizeof(spdm_measurements_response_t) + SPDM_NONCE_SIZE + sizeof(uint16_t) +
2434 : SPDM_REQ_CONTEXT_SIZE);
2435 1 : spdm_response = (void *)response;
2436 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
2437 1 : responder_context = (void *)response;
2438 1 : responder_context += sizeof(spdm_measurements_response_t) + SPDM_NONCE_SIZE + sizeof(uint16_t);
2439 1 : assert_memory_equal((void *)requester_context, responder_context, SPDM_REQ_CONTEXT_SIZE);
2440 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2441 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
2442 : m_libspdm_get_measurements_request17_size +
2443 : sizeof(spdm_measurements_response_t) +
2444 : SPDM_NONCE_SIZE +
2445 : sizeof(uint16_t) +
2446 : SPDM_REQ_CONTEXT_SIZE);
2447 : #endif
2448 1 : }
2449 :
2450 : /**
2451 : * Test 36: The key usage bit mask is not set, the SlotID fields in GET_MEASUREMENTS and MEASUREMENTS shall not specify this certificate slot
2452 : * Expected Behavior: get a SPDM_ERROR_CODE_INVALID_REQUEST return code
2453 : **/
2454 1 : static void rsp_measurements_case36(void **state)
2455 : {
2456 : libspdm_return_t status;
2457 : libspdm_test_context_t *spdm_test_context;
2458 : libspdm_context_t *spdm_context;
2459 : size_t response_size;
2460 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
2461 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2462 : spdm_get_measurements_request_t *spdm_request;
2463 : spdm_measurements_response_t *spdm_response;
2464 : uint8_t *requester_context;
2465 : uint8_t slot_id;
2466 : void *data;
2467 : size_t data_size;
2468 : size_t request_size;
2469 :
2470 1 : spdm_test_context = *state;
2471 1 : spdm_context = spdm_test_context->spdm_context;
2472 1 : spdm_test_context->case_id = 36;
2473 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
2474 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2475 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2476 1 : spdm_context->local_context.capability.flags |=
2477 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2478 1 : spdm_context->local_context.capability.flags |=
2479 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PUB_KEY_ID_CAP;
2480 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2481 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2482 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2483 : m_libspdm_use_measurement_hash_algo;
2484 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2485 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2486 1 : spdm_context->connection_info.multi_key_conn_rsp = true;
2487 1 : libspdm_reset_message_m(spdm_context, NULL);
2488 :
2489 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2490 : m_libspdm_use_asym_algo, &data,
2491 : &data_size, NULL, NULL);
2492 9 : for (int i = 0; i < SPDM_MAX_SLOT_COUNT; i++) {
2493 8 : spdm_context->local_context.local_cert_chain_provision_size[i] = data_size;
2494 8 : spdm_context->local_context.local_cert_chain_provision[i] = data;
2495 : }
2496 :
2497 1 : spdm_request = (void *)request;
2498 1 : spdm_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
2499 1 : spdm_request->header.request_response_code = SPDM_GET_MEASUREMENTS;
2500 1 : spdm_request->header.param1 = SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
2501 1 : spdm_request->header.param2 = 1;
2502 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, spdm_request->nonce);
2503 : /* If set, the SlotID fields in GET_MEASUREMENTS and MEASUREMENTS can specify this certificate slot. If not set,
2504 : * the SlotID fields in GET_MEASUREMENTS and MEASUREMENTS shall not specify this certificate slot. */
2505 1 : slot_id = 0;
2506 1 : spdm_request->slot_id_param = slot_id;
2507 1 : spdm_context->local_context.local_key_usage_bit_mask[slot_id] =
2508 : SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE |
2509 : SPDM_KEY_USAGE_BIT_MASK_CHALLENGE_USE;
2510 1 : requester_context = ((uint8_t *)spdm_request) + sizeof(spdm_get_measurements_request_t);
2511 1 : libspdm_set_mem(requester_context, SPDM_REQ_CONTEXT_SIZE, 0xAA);
2512 1 : request_size = sizeof(spdm_get_measurements_request_t) + SPDM_REQ_CONTEXT_SIZE;
2513 :
2514 1 : response_size = sizeof(response);
2515 1 : status = libspdm_get_response_measurements(
2516 : spdm_context, request_size,
2517 : (void *)spdm_request, &response_size, response);
2518 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2519 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
2520 1 : spdm_response = (void *)response;
2521 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
2522 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
2523 1 : assert_int_equal(spdm_response->header.param2, 0);
2524 1 : }
2525 :
2526 1 : int libspdm_rsp_measurements_test(void)
2527 : {
2528 1 : m_libspdm_get_measurements_request11.slot_id_param = SPDM_MAX_SLOT_COUNT - 1;
2529 1 : m_libspdm_get_measurements_request12.slot_id_param = SPDM_MAX_SLOT_COUNT + 1;
2530 :
2531 1 : const struct CMUnitTest test_cases[] = {
2532 : /* Success Case to get measurement number without signature*/
2533 : cmocka_unit_test(rsp_measurements_case1),
2534 : /* Can be populated with new test.*/
2535 : cmocka_unit_test(rsp_measurements_case2),
2536 : /* response_state: SPDM_RESPONSE_STATE_BUSY*/
2537 : cmocka_unit_test(rsp_measurements_case3),
2538 : /* response_state: SPDM_RESPONSE_STATE_NEED_RESYNC*/
2539 : cmocka_unit_test(rsp_measurements_case4),
2540 : #if LIBSPDM_RESPOND_IF_READY_SUPPORT
2541 : /* response_state: SPDM_RESPONSE_STATE_NOT_READY*/
2542 : cmocka_unit_test(rsp_measurements_case5),
2543 : #endif /* LIBSPDM_RESPOND_IF_READY_SUPPORT */
2544 : /* connection_state Check*/
2545 : cmocka_unit_test(rsp_measurements_case6),
2546 : /* Success Case to get measurement number with signature*/
2547 : cmocka_unit_test(rsp_measurements_case7),
2548 : /* Success Case to get one measurement with signature*/
2549 : cmocka_unit_test(rsp_measurements_case8),
2550 : /* Bad request size to get one measurement with signature*/
2551 : cmocka_unit_test(rsp_measurements_case9),
2552 : /* Success Case to get one measurement without signature*/
2553 : cmocka_unit_test(rsp_measurements_case10),
2554 : /* Success Case to get all measurements with signature*/
2555 : cmocka_unit_test(rsp_measurements_case11),
2556 : /* Success Case to get all measurements without signature*/
2557 : cmocka_unit_test(rsp_measurements_case12),
2558 : /* Can be populated with new test.*/
2559 : cmocka_unit_test(rsp_measurements_case13),
2560 : /* Error Case: sig required, but no nonce and/or SlotID*/
2561 : cmocka_unit_test(rsp_measurements_case14),
2562 : /* Error Case: sig required, but meas_cap = 01b (including nonce and SlotId on request)*/
2563 : cmocka_unit_test(rsp_measurements_case15),
2564 : /* Error Case: sig required, but meas_cap = 01b (not including nonce and SlotId on request)*/
2565 : cmocka_unit_test(rsp_measurements_case16),
2566 : /* Error Case: meas_cap = 00b*/
2567 : cmocka_unit_test(rsp_measurements_case17),
2568 : /* Success Case: SlotId different from default*/
2569 : cmocka_unit_test(rsp_measurements_case18),
2570 : /* Bad SlotId parameter (>= SPDM_MAX_SLOT_COUNT)*/
2571 : cmocka_unit_test(rsp_measurements_case19),
2572 : /* Error Case: request a measurement out of bounds*/
2573 : cmocka_unit_test(rsp_measurements_case21),
2574 : /* Large number of requests before requiring a signature*/
2575 : cmocka_unit_test(rsp_measurements_case22),
2576 : /* Successful response to get a session based measurement with signature*/
2577 : cmocka_unit_test(rsp_measurements_case23),
2578 : /* Buffer verification */
2579 : cmocka_unit_test(rsp_measurements_case24),
2580 : /* Success Case V1.2 to get one measurement without signature*/
2581 : cmocka_unit_test(rsp_measurements_case25),
2582 : /* Successful response V1.2 to get one measurement with signature and without opqaue data*/
2583 : cmocka_unit_test(rsp_measurements_case26),
2584 : /* Successful response V1.2 to get one measurement with signature and with opqaue data*/
2585 : cmocka_unit_test(rsp_measurements_case27),
2586 : /* Success Case to get measurement with signature using slot_id 0xFF */
2587 : cmocka_unit_test(rsp_measurements_case28),
2588 : /* Error Case: Big Endian Signature. Little Endian Verify */
2589 : cmocka_unit_test(rsp_measurements_case29),
2590 : /* Success Case: Big Endian Signature. Big Endian Verify */
2591 : cmocka_unit_test(rsp_measurements_case30),
2592 : /* Success Case: Big Endian Signature. Big or Little Endian Verify */
2593 : cmocka_unit_test(rsp_measurements_case31),
2594 : /* Success Case: Little Endian Signature. Little Endian Verify */
2595 : cmocka_unit_test(rsp_measurements_case32),
2596 : /* Error Case: Little Endian Signature. Big Endian Verify */
2597 : cmocka_unit_test(rsp_measurements_case33),
2598 : /* Success Case: Little Endian Signature. Big or Little Endian Verify */
2599 : cmocka_unit_test(rsp_measurements_case34),
2600 : /* Success Case: V1.3 get a correct context field */
2601 : cmocka_unit_test(rsp_measurements_case35),
2602 : /* The key usage bit mask is not set, failed Case*/
2603 : cmocka_unit_test(rsp_measurements_case36),
2604 : };
2605 :
2606 1 : libspdm_test_context_t test_context = {
2607 : LIBSPDM_TEST_CONTEXT_VERSION,
2608 : false,
2609 : };
2610 :
2611 1 : libspdm_setup_test_context(&test_context);
2612 :
2613 1 : return cmocka_run_group_tests(test_cases,
2614 : libspdm_unit_test_group_setup,
2615 : libspdm_unit_test_group_teardown);
2616 : }
2617 :
2618 : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP*/
|
