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 : NULL,
1564 : 0,
1565 : 0,
1566 : NULL,
1567 : &content_changed,
1568 : &measurements_count,
1569 : expect_measurement_record_data,
1570 : &expect_measurement_record_data_length);
1571 :
1572 1 : libspdm_measurement_opaque_data(
1573 : spdm_context,
1574 : NULL,
1575 1 : spdm_context->connection_info.version,
1576 1 : spdm_context->connection_info.algorithm.measurement_spec,
1577 : spdm_context->connection_info.algorithm.measurement_hash_algo,
1578 1 : m_libspdm_get_measurements_request15.header.param2,
1579 1 : m_libspdm_get_measurements_request15.header.param1,
1580 : 0,
1581 : NULL,
1582 : expect_opaque_data,
1583 : &expect_opaque_data_size);
1584 :
1585 1 : measurement_record_data = (uint8_t *)response + sizeof(spdm_measurements_response_t);
1586 1 : opaque_data_size =
1587 : (uint16_t *)(measurement_record_data + sizeof(spdm_measurement_block_dmtf_t) +
1588 1 : libspdm_get_measurement_hash_size(
1589 1 : m_libspdm_use_measurement_hash_algo) +
1590 : SPDM_NONCE_SIZE);
1591 1 : opaque_data = (uint8_t *)opaque_data_size + sizeof(uint16_t);
1592 :
1593 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
1594 :
1595 1 : assert_int_equal(measurement_record_data_length, expect_measurement_record_data_length );
1596 1 : assert_memory_equal(measurement_record_data, expect_measurement_record_data,
1597 : expect_measurement_record_data_length);
1598 1 : assert_int_equal(*opaque_data_size, libspdm_secret_lib_meas_opaque_data_size);
1599 1 : assert_memory_equal(opaque_data, expect_opaque_data, libspdm_secret_lib_meas_opaque_data_size);
1600 :
1601 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1602 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1603 : #endif
1604 1 : assert_int_equal(spdm_response->header.param2, m_libspdm_get_measurements_request15.slot_id_param|
1605 : (SPDM_MEASUREMENTS_RESPONSE_CONTENT_NO_CHANGE_DETECTED &
1606 : SPDM_MEASUREMENTS_RESPONSE_CONTENT_CHANGE_MASK));
1607 :
1608 1 : free(data);
1609 1 : }
1610 :
1611 : /**
1612 : * Test 28: Successful response to get all measurements with signature using slot_id 0xFF
1613 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m, and correct response message size and fields
1614 : **/
1615 1 : static void rsp_measurements_case28(void **state)
1616 : {
1617 : libspdm_return_t status;
1618 : libspdm_test_context_t *spdm_test_context;
1619 : libspdm_context_t *spdm_context;
1620 : size_t response_size;
1621 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1622 : spdm_measurements_response_t *spdm_response;
1623 : void *data;
1624 : size_t data_size;
1625 : size_t measurment_sig_size;
1626 :
1627 1 : spdm_test_context = *state;
1628 1 : spdm_context = spdm_test_context->spdm_context;
1629 1 : spdm_test_context->case_id = 0x1C;
1630 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1631 1 : spdm_context->local_context.capability.flags |=
1632 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1633 1 : spdm_context->local_context.capability.flags |=
1634 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PUB_KEY_ID_CAP;
1635 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1636 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1637 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1638 : m_libspdm_use_measurement_hash_algo;
1639 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1640 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1641 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1642 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1643 1 : libspdm_reset_message_m(spdm_context, NULL);
1644 :
1645 : /*opaque data*/
1646 1 : libspdm_secret_lib_meas_opaque_data_size = 0x20;
1647 :
1648 1 : libspdm_read_responder_public_key(m_libspdm_use_asym_algo, &data, &data_size);
1649 1 : spdm_context->local_context.local_public_key_provision = data;
1650 1 : spdm_context->local_context.local_public_key_provision_size = data_size;
1651 :
1652 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) +
1653 1 : libspdm_secret_lib_meas_opaque_data_size +
1654 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1655 1 : response_size = sizeof(response);
1656 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request16.nonce);
1657 1 : m_libspdm_get_measurements_request16.slot_id_param = 0xF;
1658 1 : status = libspdm_get_response_measurements(
1659 : spdm_context, m_libspdm_get_measurements_request16_size,
1660 : &m_libspdm_get_measurements_request16, &response_size, response);
1661 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1662 1 : assert_int_equal(response_size,
1663 : sizeof(spdm_measurements_response_t) + sizeof(spdm_measurement_block_dmtf_t) +
1664 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo) +
1665 : measurment_sig_size);
1666 1 : spdm_response = (void *)response;
1667 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1668 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1669 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1670 : #endif
1671 1 : assert_int_equal(spdm_response->header.param2,
1672 : m_libspdm_get_measurements_request16.slot_id_param |
1673 : (SPDM_MEASUREMENTS_RESPONSE_CONTENT_NO_CHANGE_DETECTED &
1674 : SPDM_MEASUREMENTS_RESPONSE_CONTENT_CHANGE_MASK));
1675 :
1676 1 : free(data);
1677 1 : }
1678 :
1679 : /**
1680 : * Test 29: Based of Test Case 7 Successful response to get a number of measurements
1681 : * with signature.
1682 : * Signature test with signing in big endian but verification in little endian.
1683 : *
1684 : * Expected Behavior: Failing signature verification
1685 : **/
1686 1 : static void rsp_measurements_case29(void** state)
1687 : {
1688 : libspdm_return_t status;
1689 : libspdm_test_context_t* spdm_test_context;
1690 : libspdm_context_t* spdm_context;
1691 : size_t response_size;
1692 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1693 : spdm_measurements_response_t* spdm_response;
1694 : size_t measurment_sig_size;
1695 :
1696 : bool result;
1697 : uint32_t measurement_record_data_length;
1698 : uint8_t* measurement_record_data;
1699 : uint8_t* ptr;
1700 : uint16_t opaque_length;
1701 : void* signature;
1702 : size_t signature_size;
1703 : libspdm_session_info_t* session_info;
1704 : void* data;
1705 : size_t data_size;
1706 : void* hash;
1707 : size_t hash_size;
1708 :
1709 1 : spdm_test_context = *state;
1710 1 : spdm_context = spdm_test_context->spdm_context;
1711 1 : spdm_test_context->case_id = 29;
1712 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1713 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1714 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1715 1 : spdm_context->local_context.capability.flags |=
1716 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1717 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1718 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1719 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1720 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1721 : m_libspdm_use_measurement_hash_algo;
1722 1 : spdm_context->spdm_10_11_verify_signature_endian =
1723 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_LITTLE_ONLY;
1724 :
1725 1 : libspdm_reset_message_m(spdm_context, NULL);
1726 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1727 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1728 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1729 :
1730 1 : response_size = sizeof(response);
1731 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
1732 1 : status = libspdm_get_response_measurements(
1733 : spdm_context, m_libspdm_get_measurements_request5_size,
1734 : &m_libspdm_get_measurements_request5, &response_size, response);
1735 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1736 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
1737 1 : spdm_response = (void*)response;
1738 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1739 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
1740 :
1741 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1742 : m_libspdm_use_asym_algo, &data,
1743 : &data_size,
1744 : &hash, &hash_size)) {
1745 0 : assert(false);
1746 : }
1747 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1748 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1749 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1750 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1751 : data, data_size);
1752 : #else
1753 1 : libspdm_hash_all(
1754 : spdm_context->connection_info.algorithm.base_hash_algo,
1755 : data, data_size,
1756 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
1757 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
1758 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
1759 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
1760 : spdm_context->connection_info.algorithm.base_hash_algo,
1761 : spdm_context->connection_info.algorithm.base_asym_algo,
1762 : data, data_size,
1763 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
1764 : #endif
1765 :
1766 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
1767 1 : measurement_record_data = (void*)(spdm_response + 1);
1768 1 : ptr = measurement_record_data + measurement_record_data_length;
1769 1 : ptr += SPDM_NONCE_SIZE;
1770 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
1771 1 : ptr += sizeof(uint16_t);
1772 1 : ptr += opaque_length;
1773 1 : signature = ptr;
1774 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1775 1 : session_info = NULL;
1776 :
1777 1 : status = libspdm_append_message_m(spdm_context, session_info,
1778 : &m_libspdm_get_measurements_request5,
1779 : m_libspdm_get_measurements_request5_size);
1780 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1781 :
1782 1 : status = libspdm_append_message_m(spdm_context, session_info, spdm_response,
1783 : response_size - signature_size);
1784 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1785 :
1786 1 : result = libspdm_verify_measurement_signature(
1787 : spdm_context, session_info, 0, signature, signature_size);
1788 1 : assert_false(result);
1789 :
1790 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1791 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1792 : #endif
1793 1 : }
1794 :
1795 : /**
1796 : * Test 30: Based of Test Case 7 Successful response to get a number of measurements
1797 : * with signature.
1798 : * Signature test with signing in big endian but verification in little endian.
1799 : *
1800 : * Expected Behavior: Failing signature verification
1801 : **/
1802 1 : static void rsp_measurements_case30(void** state)
1803 : {
1804 : libspdm_return_t status;
1805 : libspdm_test_context_t* spdm_test_context;
1806 : libspdm_context_t* spdm_context;
1807 : size_t response_size;
1808 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1809 : spdm_measurements_response_t* spdm_response;
1810 : size_t measurment_sig_size;
1811 :
1812 : bool result;
1813 : uint32_t measurement_record_data_length;
1814 : uint8_t* measurement_record_data;
1815 : uint8_t* ptr;
1816 : uint16_t opaque_length;
1817 : void* signature;
1818 : size_t signature_size;
1819 : libspdm_session_info_t* session_info;
1820 : void* data;
1821 : size_t data_size;
1822 : void* hash;
1823 : size_t hash_size;
1824 :
1825 1 : spdm_test_context = *state;
1826 1 : spdm_context = spdm_test_context->spdm_context;
1827 1 : spdm_test_context->case_id = 30;
1828 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1829 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1830 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1831 1 : spdm_context->local_context.capability.flags |=
1832 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1833 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1834 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1835 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1836 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1837 : m_libspdm_use_measurement_hash_algo;
1838 1 : spdm_context->spdm_10_11_verify_signature_endian =
1839 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_BIG_ONLY;
1840 :
1841 1 : libspdm_reset_message_m(spdm_context, NULL);
1842 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1843 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1844 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1845 :
1846 1 : response_size = sizeof(response);
1847 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
1848 1 : status = libspdm_get_response_measurements(
1849 : spdm_context, m_libspdm_get_measurements_request5_size,
1850 : &m_libspdm_get_measurements_request5, &response_size, response);
1851 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1852 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
1853 1 : spdm_response = (void*)response;
1854 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1855 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
1856 :
1857 1 : libspdm_read_responder_public_certificate_chain(
1858 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
1859 : &data, &data_size,
1860 : &hash, &hash_size);
1861 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1862 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1863 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1864 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1865 : data, data_size);
1866 : #else
1867 1 : libspdm_hash_all(
1868 : spdm_context->connection_info.algorithm.base_hash_algo,
1869 : data, data_size,
1870 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
1871 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
1872 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
1873 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
1874 : spdm_context->connection_info.algorithm.base_hash_algo,
1875 : spdm_context->connection_info.algorithm.base_asym_algo,
1876 : data, data_size,
1877 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
1878 : #endif
1879 :
1880 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
1881 1 : measurement_record_data = (void*)(spdm_response + 1);
1882 1 : ptr = measurement_record_data + measurement_record_data_length;
1883 1 : ptr += SPDM_NONCE_SIZE;
1884 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
1885 1 : ptr += sizeof(uint16_t);
1886 1 : ptr += opaque_length;
1887 1 : signature = ptr;
1888 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1889 1 : session_info = NULL;
1890 :
1891 1 : status = libspdm_append_message_m(
1892 : spdm_context, session_info,
1893 : &m_libspdm_get_measurements_request5,
1894 : m_libspdm_get_measurements_request5_size);
1895 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1896 :
1897 1 : status = libspdm_append_message_m(
1898 : spdm_context, session_info, spdm_response,
1899 : response_size - signature_size);
1900 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1901 :
1902 1 : result = libspdm_verify_measurement_signature(
1903 : spdm_context, session_info, 0, signature, signature_size);
1904 1 : assert_true(result);
1905 :
1906 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1907 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1908 : #endif
1909 1 : }
1910 :
1911 : /**
1912 : * Test 31: Based of Test Case 7 Successful response to get a number of measurements
1913 : * with signature.
1914 : * Signature test with signing in big endian but verification in big or little endian.
1915 : *
1916 : * Expected Behavior: Passing signature verification
1917 : **/
1918 1 : static void rsp_measurements_case31(void** state)
1919 : {
1920 : libspdm_return_t status;
1921 : libspdm_test_context_t* spdm_test_context;
1922 : libspdm_context_t* spdm_context;
1923 : size_t response_size;
1924 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1925 : spdm_measurements_response_t* spdm_response;
1926 : size_t measurment_sig_size;
1927 :
1928 : bool result;
1929 : uint32_t measurement_record_data_length;
1930 : uint8_t* measurement_record_data;
1931 : uint8_t* ptr;
1932 : uint16_t opaque_length;
1933 : void* signature;
1934 : size_t signature_size;
1935 : libspdm_session_info_t* session_info;
1936 : void* data;
1937 : size_t data_size;
1938 : void* hash;
1939 : size_t hash_size;
1940 :
1941 1 : spdm_test_context = *state;
1942 1 : spdm_context = spdm_test_context->spdm_context;
1943 1 : spdm_test_context->case_id = 31;
1944 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1945 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1946 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1947 1 : spdm_context->local_context.capability.flags |=
1948 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1949 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1950 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1951 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1952 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1953 : m_libspdm_use_measurement_hash_algo;
1954 1 : spdm_context->spdm_10_11_verify_signature_endian =
1955 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_BIG_OR_LITTLE;
1956 :
1957 1 : libspdm_reset_message_m(spdm_context, NULL);
1958 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1959 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1960 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1961 :
1962 1 : response_size = sizeof(response);
1963 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
1964 1 : status = libspdm_get_response_measurements(
1965 : spdm_context, m_libspdm_get_measurements_request5_size,
1966 : &m_libspdm_get_measurements_request5, &response_size, response);
1967 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1968 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
1969 1 : spdm_response = (void*)response;
1970 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1971 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
1972 :
1973 1 : libspdm_read_responder_public_certificate_chain(
1974 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
1975 : &data, &data_size,
1976 : &hash, &hash_size);
1977 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1978 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1979 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1980 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1981 : data, data_size);
1982 : #else
1983 1 : libspdm_hash_all(
1984 : spdm_context->connection_info.algorithm.base_hash_algo,
1985 : data, data_size,
1986 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
1987 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
1988 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
1989 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
1990 : spdm_context->connection_info.algorithm.base_hash_algo,
1991 : spdm_context->connection_info.algorithm.base_asym_algo,
1992 : data, data_size,
1993 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
1994 : #endif
1995 :
1996 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
1997 1 : measurement_record_data = (void*)(spdm_response + 1);
1998 1 : ptr = measurement_record_data + measurement_record_data_length;
1999 1 : ptr += SPDM_NONCE_SIZE;
2000 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
2001 1 : ptr += sizeof(uint16_t);
2002 1 : ptr += opaque_length;
2003 1 : signature = ptr;
2004 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2005 1 : session_info = NULL;
2006 :
2007 1 : status = libspdm_append_message_m(
2008 : spdm_context, session_info,
2009 : &m_libspdm_get_measurements_request5,
2010 : m_libspdm_get_measurements_request5_size);
2011 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2012 :
2013 1 : status = libspdm_append_message_m(
2014 : spdm_context, session_info, spdm_response,
2015 : response_size - signature_size);
2016 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2017 :
2018 1 : result = libspdm_verify_measurement_signature(
2019 : spdm_context, session_info, 0, signature, signature_size);
2020 1 : assert_true(result);
2021 :
2022 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2023 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2024 : #endif
2025 1 : }
2026 :
2027 : /**
2028 : * Test 32: Based of Test Case 7 Successful response to get a number of measurements
2029 : * with signature.
2030 : * Signature test with signing in little endian but verification in little endian.
2031 : *
2032 : * Expected Behavior: Failing signature verification
2033 : **/
2034 1 : static void rsp_measurements_case32(void** state)
2035 : {
2036 : libspdm_return_t status;
2037 : libspdm_test_context_t* spdm_test_context;
2038 : libspdm_context_t* spdm_context;
2039 : size_t response_size;
2040 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2041 : spdm_measurements_response_t* spdm_response;
2042 : size_t measurment_sig_size;
2043 :
2044 : bool result;
2045 : uint32_t measurement_record_data_length;
2046 : uint8_t* measurement_record_data;
2047 : uint8_t* ptr;
2048 : uint16_t opaque_length;
2049 : void* signature;
2050 : size_t signature_size;
2051 : libspdm_session_info_t* session_info;
2052 : void* data;
2053 : size_t data_size;
2054 : void* hash;
2055 : size_t hash_size;
2056 :
2057 1 : spdm_test_context = *state;
2058 1 : spdm_context = spdm_test_context->spdm_context;
2059 1 : spdm_test_context->case_id = 32;
2060 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
2061 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2062 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2063 1 : spdm_context->local_context.capability.flags |=
2064 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2065 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2066 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2067 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2068 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2069 : m_libspdm_use_measurement_hash_algo;
2070 1 : spdm_context->spdm_10_11_verify_signature_endian =
2071 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_LITTLE_ONLY;
2072 :
2073 1 : libspdm_reset_message_m(spdm_context, NULL);
2074 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2075 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
2076 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2077 :
2078 1 : response_size = sizeof(response);
2079 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
2080 1 : status = libspdm_get_response_measurements(
2081 : spdm_context, m_libspdm_get_measurements_request5_size,
2082 : &m_libspdm_get_measurements_request5, &response_size, response);
2083 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2084 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
2085 1 : spdm_response = (void*)response;
2086 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
2087 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
2088 :
2089 1 : libspdm_read_responder_public_certificate_chain(
2090 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
2091 : &data, &data_size,
2092 : &hash, &hash_size);
2093 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2094 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
2095 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2096 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2097 : data, data_size);
2098 : #else
2099 1 : libspdm_hash_all(
2100 : spdm_context->connection_info.algorithm.base_hash_algo,
2101 : data, data_size,
2102 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
2103 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2104 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2105 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2106 : spdm_context->connection_info.algorithm.base_hash_algo,
2107 : spdm_context->connection_info.algorithm.base_asym_algo,
2108 : data, data_size,
2109 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2110 : #endif
2111 :
2112 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
2113 1 : measurement_record_data = (void*)(spdm_response + 1);
2114 1 : ptr = measurement_record_data + measurement_record_data_length;
2115 1 : ptr += SPDM_NONCE_SIZE;
2116 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
2117 1 : ptr += sizeof(uint16_t);
2118 1 : ptr += opaque_length;
2119 1 : signature = ptr;
2120 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2121 :
2122 1 : libspdm_copy_signature_swap_endian(
2123 : m_libspdm_use_asym_algo,
2124 : signature, signature_size, signature, signature_size);
2125 :
2126 1 : session_info = NULL;
2127 :
2128 1 : status = libspdm_append_message_m(
2129 : spdm_context, session_info,
2130 : &m_libspdm_get_measurements_request5,
2131 : m_libspdm_get_measurements_request5_size);
2132 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2133 :
2134 1 : status = libspdm_append_message_m(
2135 : spdm_context, session_info, spdm_response,
2136 : response_size - signature_size);
2137 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2138 :
2139 1 : result = libspdm_verify_measurement_signature(
2140 : spdm_context, session_info, 0, signature, signature_size);
2141 1 : assert_true(result);
2142 :
2143 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2144 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2145 : #endif
2146 1 : }
2147 :
2148 : /**
2149 : * Test 33: Based of Test Case 7 Successful response to get a number of measurements
2150 : * with signature.
2151 : * Signature test with signing in little endian but verification in big endian.
2152 : *
2153 : * Expected Behavior: Failing signature verification
2154 : **/
2155 1 : static void rsp_measurements_case33(void** state)
2156 : {
2157 : libspdm_return_t status;
2158 : libspdm_test_context_t* spdm_test_context;
2159 : libspdm_context_t* spdm_context;
2160 : size_t response_size;
2161 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2162 : spdm_measurements_response_t* spdm_response;
2163 : size_t measurment_sig_size;
2164 :
2165 : bool result;
2166 : uint32_t measurement_record_data_length;
2167 : uint8_t* measurement_record_data;
2168 : uint8_t* ptr;
2169 : uint16_t opaque_length;
2170 : void* signature;
2171 : size_t signature_size;
2172 : libspdm_session_info_t* session_info;
2173 : void* data;
2174 : size_t data_size;
2175 : void* hash;
2176 : size_t hash_size;
2177 :
2178 1 : spdm_test_context = *state;
2179 1 : spdm_context = spdm_test_context->spdm_context;
2180 1 : spdm_test_context->case_id = 33;
2181 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
2182 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2183 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2184 1 : spdm_context->local_context.capability.flags |=
2185 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2186 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2187 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2188 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2189 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2190 : m_libspdm_use_measurement_hash_algo;
2191 1 : spdm_context->spdm_10_11_verify_signature_endian =
2192 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_BIG_ONLY;
2193 :
2194 1 : libspdm_reset_message_m(spdm_context, NULL);
2195 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2196 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
2197 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2198 :
2199 1 : response_size = sizeof(response);
2200 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
2201 1 : status = libspdm_get_response_measurements(
2202 : spdm_context, m_libspdm_get_measurements_request5_size,
2203 : &m_libspdm_get_measurements_request5, &response_size, response);
2204 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2205 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
2206 1 : spdm_response = (void*)response;
2207 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
2208 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
2209 :
2210 1 : libspdm_read_responder_public_certificate_chain(
2211 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
2212 : &data, &data_size,
2213 : &hash, &hash_size);
2214 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2215 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
2216 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2217 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2218 : data, data_size);
2219 : #else
2220 1 : libspdm_hash_all(
2221 : spdm_context->connection_info.algorithm.base_hash_algo,
2222 : data, data_size,
2223 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
2224 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2225 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2226 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2227 : spdm_context->connection_info.algorithm.base_hash_algo,
2228 : spdm_context->connection_info.algorithm.base_asym_algo,
2229 : data, data_size,
2230 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2231 : #endif
2232 :
2233 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
2234 1 : measurement_record_data = (void*)(spdm_response + 1);
2235 1 : ptr = measurement_record_data + measurement_record_data_length;
2236 1 : ptr += SPDM_NONCE_SIZE;
2237 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
2238 1 : ptr += sizeof(uint16_t);
2239 1 : ptr += opaque_length;
2240 1 : signature = ptr;
2241 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2242 :
2243 1 : libspdm_copy_signature_swap_endian(
2244 : m_libspdm_use_asym_algo,
2245 : signature, signature_size, signature, signature_size);
2246 :
2247 1 : session_info = NULL;
2248 :
2249 1 : status = libspdm_append_message_m(
2250 : spdm_context, session_info,
2251 : &m_libspdm_get_measurements_request5,
2252 : m_libspdm_get_measurements_request5_size);
2253 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2254 :
2255 1 : status = libspdm_append_message_m(
2256 : spdm_context, session_info, spdm_response,
2257 : response_size - signature_size);
2258 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2259 :
2260 1 : result = libspdm_verify_measurement_signature(
2261 : spdm_context, session_info, 0, signature, signature_size);
2262 1 : assert_false(result);
2263 :
2264 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2265 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2266 : #endif
2267 1 : }
2268 :
2269 :
2270 : /**
2271 : * Test 34: Based of Test Case 7 Successful response to get a number of measurements
2272 : * with signature.
2273 : * Signature test with signing in little endian but verification in big or little endian.
2274 : *
2275 : * Expected Behavior: Passing signature verification
2276 : **/
2277 1 : static void rsp_measurements_case34(void** state)
2278 : {
2279 : libspdm_return_t status;
2280 : libspdm_test_context_t* spdm_test_context;
2281 : libspdm_context_t* spdm_context;
2282 : size_t response_size;
2283 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2284 : spdm_measurements_response_t* spdm_response;
2285 : size_t measurment_sig_size;
2286 :
2287 : bool result;
2288 : uint32_t measurement_record_data_length;
2289 : uint8_t* measurement_record_data;
2290 : uint8_t* ptr;
2291 : uint16_t opaque_length;
2292 : void* signature;
2293 : size_t signature_size;
2294 : libspdm_session_info_t* session_info;
2295 : void* data;
2296 : size_t data_size;
2297 : void* hash;
2298 : size_t hash_size;
2299 :
2300 1 : spdm_test_context = *state;
2301 1 : spdm_context = spdm_test_context->spdm_context;
2302 1 : spdm_test_context->case_id = 34;
2303 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
2304 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2305 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2306 1 : spdm_context->local_context.capability.flags |=
2307 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2308 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2309 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2310 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2311 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2312 : m_libspdm_use_measurement_hash_algo;
2313 1 : spdm_context->spdm_10_11_verify_signature_endian =
2314 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_BIG_OR_LITTLE;
2315 :
2316 1 : libspdm_reset_message_m(spdm_context, NULL);
2317 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2318 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
2319 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2320 :
2321 1 : response_size = sizeof(response);
2322 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
2323 1 : status = libspdm_get_response_measurements(
2324 : spdm_context, m_libspdm_get_measurements_request5_size,
2325 : &m_libspdm_get_measurements_request5, &response_size, response);
2326 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2327 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
2328 1 : spdm_response = (void*)response;
2329 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
2330 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
2331 :
2332 1 : libspdm_read_responder_public_certificate_chain(
2333 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
2334 : &data, &data_size,
2335 : &hash, &hash_size);
2336 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2337 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
2338 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2339 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2340 : data, data_size);
2341 : #else
2342 1 : libspdm_hash_all(
2343 : spdm_context->connection_info.algorithm.base_hash_algo,
2344 : data, data_size,
2345 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
2346 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2347 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2348 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2349 : spdm_context->connection_info.algorithm.base_hash_algo,
2350 : spdm_context->connection_info.algorithm.base_asym_algo,
2351 : data, data_size,
2352 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2353 : #endif
2354 :
2355 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
2356 1 : measurement_record_data = (void*)(spdm_response + 1);
2357 1 : ptr = measurement_record_data + measurement_record_data_length;
2358 1 : ptr += SPDM_NONCE_SIZE;
2359 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
2360 1 : ptr += sizeof(uint16_t);
2361 1 : ptr += opaque_length;
2362 1 : signature = ptr;
2363 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2364 1 : libspdm_copy_signature_swap_endian(
2365 : m_libspdm_use_asym_algo,
2366 : signature, signature_size, signature, signature_size);
2367 :
2368 1 : session_info = NULL;
2369 :
2370 1 : status = libspdm_append_message_m(
2371 : spdm_context, session_info,
2372 : &m_libspdm_get_measurements_request5,
2373 : m_libspdm_get_measurements_request5_size);
2374 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2375 :
2376 1 : status = libspdm_append_message_m(
2377 : spdm_context, session_info, spdm_response,
2378 : response_size - signature_size);
2379 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2380 :
2381 1 : result = libspdm_verify_measurement_signature(
2382 : spdm_context, session_info, 0, signature, signature_size);
2383 1 : assert_true(result);
2384 :
2385 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2386 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2387 : #endif
2388 1 : }
2389 :
2390 : /**
2391 : * Test 35: Successful response V1.3 to get a number of measurements without signature
2392 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, correct context field
2393 : **/
2394 1 : static void rsp_measurements_case35(void **state)
2395 : {
2396 : libspdm_return_t status;
2397 : libspdm_test_context_t *spdm_test_context;
2398 : libspdm_context_t *spdm_context;
2399 : size_t response_size;
2400 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2401 : spdm_measurements_response_t *spdm_response;
2402 : uint8_t *requester_context;
2403 : uint8_t *responder_context;
2404 :
2405 1 : spdm_test_context = *state;
2406 1 : spdm_context = spdm_test_context->spdm_context;
2407 1 : spdm_test_context->case_id = 35;
2408 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
2409 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2410 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2411 1 : spdm_context->local_context.capability.flags |=
2412 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2413 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2414 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2415 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2416 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2417 : m_libspdm_use_measurement_hash_algo;
2418 1 : libspdm_reset_message_m(spdm_context, NULL);
2419 :
2420 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2421 :
2422 1 : response_size = sizeof(response);
2423 :
2424 1 : requester_context = ((uint8_t *)&m_libspdm_get_measurements_request17) +
2425 : m_libspdm_get_measurements_request17_size;
2426 1 : libspdm_set_mem(requester_context, SPDM_REQ_CONTEXT_SIZE, 0xAA);
2427 1 : m_libspdm_get_measurements_request17_size += SPDM_REQ_CONTEXT_SIZE;
2428 :
2429 1 : status = libspdm_get_response_measurements(
2430 : spdm_context, m_libspdm_get_measurements_request17_size,
2431 : &m_libspdm_get_measurements_request17, &response_size, response);
2432 :
2433 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2434 1 : assert_int_equal(response_size,
2435 : sizeof(spdm_measurements_response_t) + SPDM_NONCE_SIZE + sizeof(uint16_t) +
2436 : SPDM_REQ_CONTEXT_SIZE);
2437 1 : spdm_response = (void *)response;
2438 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
2439 1 : responder_context = (void *)response;
2440 1 : responder_context += sizeof(spdm_measurements_response_t) + SPDM_NONCE_SIZE + sizeof(uint16_t);
2441 1 : assert_memory_equal((void *)requester_context, responder_context, SPDM_REQ_CONTEXT_SIZE);
2442 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2443 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
2444 : m_libspdm_get_measurements_request17_size +
2445 : sizeof(spdm_measurements_response_t) +
2446 : SPDM_NONCE_SIZE +
2447 : sizeof(uint16_t) +
2448 : SPDM_REQ_CONTEXT_SIZE);
2449 : #endif
2450 1 : }
2451 :
2452 : /**
2453 : * Test 36: The key usage bit mask is not set, the SlotID fields in GET_MEASUREMENTS and MEASUREMENTS shall not specify this certificate slot
2454 : * Expected Behavior: get a SPDM_ERROR_CODE_INVALID_REQUEST return code
2455 : **/
2456 1 : static void rsp_measurements_case36(void **state)
2457 : {
2458 : libspdm_return_t status;
2459 : libspdm_test_context_t *spdm_test_context;
2460 : libspdm_context_t *spdm_context;
2461 : size_t response_size;
2462 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
2463 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2464 : spdm_get_measurements_request_t *spdm_request;
2465 : spdm_measurements_response_t *spdm_response;
2466 : uint8_t *requester_context;
2467 : uint8_t slot_id;
2468 : void *data;
2469 : size_t data_size;
2470 : size_t request_size;
2471 :
2472 1 : spdm_test_context = *state;
2473 1 : spdm_context = spdm_test_context->spdm_context;
2474 1 : spdm_test_context->case_id = 36;
2475 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
2476 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2477 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2478 1 : spdm_context->local_context.capability.flags |=
2479 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2480 1 : spdm_context->local_context.capability.flags |=
2481 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PUB_KEY_ID_CAP;
2482 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2483 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2484 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2485 : m_libspdm_use_measurement_hash_algo;
2486 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2487 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2488 1 : spdm_context->connection_info.multi_key_conn_rsp = true;
2489 1 : libspdm_reset_message_m(spdm_context, NULL);
2490 :
2491 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2492 : m_libspdm_use_asym_algo, &data,
2493 : &data_size, NULL, NULL);
2494 9 : for (int i = 0; i < SPDM_MAX_SLOT_COUNT; i++) {
2495 8 : spdm_context->local_context.local_cert_chain_provision_size[i] = data_size;
2496 8 : spdm_context->local_context.local_cert_chain_provision[i] = data;
2497 : }
2498 :
2499 1 : spdm_request = (void *)request;
2500 1 : spdm_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
2501 1 : spdm_request->header.request_response_code = SPDM_GET_MEASUREMENTS;
2502 1 : spdm_request->header.param1 = SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
2503 1 : spdm_request->header.param2 = 1;
2504 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, spdm_request->nonce);
2505 : /* If set, the SlotID fields in GET_MEASUREMENTS and MEASUREMENTS can specify this certificate slot. If not set,
2506 : * the SlotID fields in GET_MEASUREMENTS and MEASUREMENTS shall not specify this certificate slot. */
2507 1 : slot_id = 0;
2508 1 : spdm_request->slot_id_param = slot_id;
2509 1 : spdm_context->local_context.local_key_usage_bit_mask[slot_id] =
2510 : SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE |
2511 : SPDM_KEY_USAGE_BIT_MASK_CHALLENGE_USE;
2512 1 : requester_context = ((uint8_t *)spdm_request) + sizeof(spdm_get_measurements_request_t);
2513 1 : libspdm_set_mem(requester_context, SPDM_REQ_CONTEXT_SIZE, 0xAA);
2514 1 : request_size = sizeof(spdm_get_measurements_request_t) + SPDM_REQ_CONTEXT_SIZE;
2515 :
2516 1 : response_size = sizeof(response);
2517 1 : status = libspdm_get_response_measurements(
2518 : spdm_context, request_size,
2519 : (void *)spdm_request, &response_size, response);
2520 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2521 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
2522 1 : spdm_response = (void *)response;
2523 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
2524 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
2525 1 : assert_int_equal(spdm_response->header.param2, 0);
2526 1 : }
2527 :
2528 1 : int libspdm_rsp_measurements_test(void)
2529 : {
2530 1 : m_libspdm_get_measurements_request11.slot_id_param = SPDM_MAX_SLOT_COUNT - 1;
2531 1 : m_libspdm_get_measurements_request12.slot_id_param = SPDM_MAX_SLOT_COUNT + 1;
2532 :
2533 1 : const struct CMUnitTest test_cases[] = {
2534 : /* Success Case to get measurement number without signature*/
2535 : cmocka_unit_test(rsp_measurements_case1),
2536 : /* Can be populated with new test.*/
2537 : cmocka_unit_test(rsp_measurements_case2),
2538 : /* response_state: SPDM_RESPONSE_STATE_BUSY*/
2539 : cmocka_unit_test(rsp_measurements_case3),
2540 : /* response_state: SPDM_RESPONSE_STATE_NEED_RESYNC*/
2541 : cmocka_unit_test(rsp_measurements_case4),
2542 : #if LIBSPDM_RESPOND_IF_READY_SUPPORT
2543 : /* response_state: SPDM_RESPONSE_STATE_NOT_READY*/
2544 : cmocka_unit_test(rsp_measurements_case5),
2545 : #endif /* LIBSPDM_RESPOND_IF_READY_SUPPORT */
2546 : /* connection_state Check*/
2547 : cmocka_unit_test(rsp_measurements_case6),
2548 : /* Success Case to get measurement number with signature*/
2549 : cmocka_unit_test(rsp_measurements_case7),
2550 : /* Success Case to get one measurement with signature*/
2551 : cmocka_unit_test(rsp_measurements_case8),
2552 : /* Bad request size to get one measurement with signature*/
2553 : cmocka_unit_test(rsp_measurements_case9),
2554 : /* Success Case to get one measurement without signature*/
2555 : cmocka_unit_test(rsp_measurements_case10),
2556 : /* Success Case to get all measurements with signature*/
2557 : cmocka_unit_test(rsp_measurements_case11),
2558 : /* Success Case to get all measurements without signature*/
2559 : cmocka_unit_test(rsp_measurements_case12),
2560 : /* Can be populated with new test.*/
2561 : cmocka_unit_test(rsp_measurements_case13),
2562 : /* Error Case: sig required, but no nonce and/or SlotID*/
2563 : cmocka_unit_test(rsp_measurements_case14),
2564 : /* Error Case: sig required, but meas_cap = 01b (including nonce and SlotId on request)*/
2565 : cmocka_unit_test(rsp_measurements_case15),
2566 : /* Error Case: sig required, but meas_cap = 01b (not including nonce and SlotId on request)*/
2567 : cmocka_unit_test(rsp_measurements_case16),
2568 : /* Error Case: meas_cap = 00b*/
2569 : cmocka_unit_test(rsp_measurements_case17),
2570 : /* Success Case: SlotId different from default*/
2571 : cmocka_unit_test(rsp_measurements_case18),
2572 : /* Bad SlotId parameter (>= SPDM_MAX_SLOT_COUNT)*/
2573 : cmocka_unit_test(rsp_measurements_case19),
2574 : /* Error Case: request a measurement out of bounds*/
2575 : cmocka_unit_test(rsp_measurements_case21),
2576 : /* Large number of requests before requiring a signature*/
2577 : cmocka_unit_test(rsp_measurements_case22),
2578 : /* Successful response to get a session based measurement with signature*/
2579 : cmocka_unit_test(rsp_measurements_case23),
2580 : /* Buffer verification */
2581 : cmocka_unit_test(rsp_measurements_case24),
2582 : /* Success Case V1.2 to get one measurement without signature*/
2583 : cmocka_unit_test(rsp_measurements_case25),
2584 : /* Successful response V1.2 to get one measurement with signature and without opqaue data*/
2585 : cmocka_unit_test(rsp_measurements_case26),
2586 : /* Successful response V1.2 to get one measurement with signature and with opqaue data*/
2587 : cmocka_unit_test(rsp_measurements_case27),
2588 : /* Success Case to get measurement with signature using slot_id 0xFF */
2589 : cmocka_unit_test(rsp_measurements_case28),
2590 : /* Error Case: Big Endian Signature. Little Endian Verify */
2591 : cmocka_unit_test(rsp_measurements_case29),
2592 : /* Success Case: Big Endian Signature. Big Endian Verify */
2593 : cmocka_unit_test(rsp_measurements_case30),
2594 : /* Success Case: Big Endian Signature. Big or Little Endian Verify */
2595 : cmocka_unit_test(rsp_measurements_case31),
2596 : /* Success Case: Little Endian Signature. Little Endian Verify */
2597 : cmocka_unit_test(rsp_measurements_case32),
2598 : /* Error Case: Little Endian Signature. Big Endian Verify */
2599 : cmocka_unit_test(rsp_measurements_case33),
2600 : /* Success Case: Little Endian Signature. Big or Little Endian Verify */
2601 : cmocka_unit_test(rsp_measurements_case34),
2602 : /* Success Case: V1.3 get a correct context field */
2603 : cmocka_unit_test(rsp_measurements_case35),
2604 : /* The key usage bit mask is not set, failed Case*/
2605 : cmocka_unit_test(rsp_measurements_case36),
2606 : };
2607 :
2608 1 : libspdm_test_context_t test_context = {
2609 : LIBSPDM_TEST_CONTEXT_VERSION,
2610 : false,
2611 : };
2612 :
2613 1 : libspdm_setup_test_context(&test_context);
2614 :
2615 1 : return cmocka_run_group_tests(test_cases,
2616 : libspdm_unit_test_group_setup,
2617 : libspdm_unit_test_group_teardown);
2618 : }
2619 :
2620 : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP*/
|
