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 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1030 : m_libspdm_use_asym_algo, &data,
1031 : &data_size, NULL, NULL)) {
1032 0 : return;
1033 : }
1034 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1035 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1036 9 : for (int i = 0; i < SPDM_MAX_SLOT_COUNT; i++) {
1037 8 : spdm_context->local_context.local_cert_chain_provision_size[i] = data_size;
1038 8 : spdm_context->local_context.local_cert_chain_provision[i] = data;
1039 : }
1040 :
1041 1 : response_size = sizeof(response);
1042 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request11.nonce);
1043 1 : status = libspdm_get_response_measurements(
1044 : spdm_context, m_libspdm_get_measurements_request11_size,
1045 : &m_libspdm_get_measurements_request11, &response_size, response);
1046 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1047 1 : assert_int_equal(response_size,
1048 : sizeof(spdm_measurements_response_t) +
1049 : sizeof(spdm_measurement_block_dmtf_t) +
1050 : libspdm_get_measurement_hash_size(
1051 : m_libspdm_use_measurement_hash_algo) +
1052 : measurment_sig_size);
1053 1 : spdm_response = (void *)response;
1054 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1055 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1056 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1057 : #endif
1058 1 : assert_int_equal(m_libspdm_get_measurements_request11.slot_id_param,
1059 : spdm_response->header.param2);
1060 :
1061 1 : free(data);
1062 : }
1063 :
1064 : /**
1065 : * Test 19: Error case, invalid SlotId parameter (SlotId >= SPDM_MAX_SLOT_COUNT)
1066 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m size, and Error message as response
1067 : **/
1068 1 : static void rsp_measurements_case19(void **state)
1069 : {
1070 : libspdm_return_t status;
1071 : libspdm_test_context_t *spdm_test_context;
1072 : libspdm_context_t *spdm_context;
1073 : size_t response_size;
1074 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1075 : spdm_measurements_response_t *spdm_response;
1076 : /* size_t measurment_sig_size;*/
1077 :
1078 1 : spdm_test_context = *state;
1079 1 : spdm_context = spdm_test_context->spdm_context;
1080 1 : spdm_test_context->case_id = 0x13;
1081 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1082 1 : spdm_context->local_context.capability.flags |=
1083 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1084 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1085 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1086 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1087 : m_libspdm_use_measurement_hash_algo;
1088 :
1089 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1090 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1091 1 : libspdm_reset_message_m(spdm_context, NULL);
1092 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1093 : /* measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 + libspdm_get_asym_signature_size (m_libspdm_use_asym_algo);*/
1094 :
1095 1 : response_size = sizeof(response);
1096 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request12.nonce);
1097 1 : status = libspdm_get_response_measurements(
1098 : spdm_context, m_libspdm_get_measurements_request12_size,
1099 : &m_libspdm_get_measurements_request12, &response_size, response);
1100 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1101 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1102 1 : spdm_response = (void *)response;
1103 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1104 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1105 1 : assert_int_equal(spdm_response->header.param2, 0);
1106 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1107 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1108 : #endif
1109 1 : }
1110 :
1111 : /**
1112 : * Test 21: Error case, request a measurement index not found
1113 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m size, and Error message as response
1114 : **/
1115 1 : static void rsp_measurements_case21(void **state)
1116 : {
1117 : libspdm_return_t status;
1118 : libspdm_test_context_t *spdm_test_context;
1119 : libspdm_context_t *spdm_context;
1120 : size_t response_size;
1121 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1122 : spdm_measurements_response_t *spdm_response;
1123 :
1124 1 : spdm_test_context = *state;
1125 1 : spdm_context = spdm_test_context->spdm_context;
1126 1 : spdm_test_context->case_id = 0x15;
1127 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1128 1 : spdm_context->local_context.capability.flags |=
1129 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1130 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1131 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1132 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1133 : m_libspdm_use_measurement_hash_algo;
1134 :
1135 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1136 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1137 1 : libspdm_reset_message_m(spdm_context, NULL);
1138 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1139 :
1140 1 : response_size = sizeof(response);
1141 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request13.nonce);
1142 1 : status = libspdm_get_response_measurements(
1143 : spdm_context, m_libspdm_get_measurements_request13_size,
1144 : &m_libspdm_get_measurements_request13, &response_size, response);
1145 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1146 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1147 1 : spdm_response = (void *)response;
1148 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1149 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1150 1 : assert_int_equal(spdm_response->header.param2, 0);
1151 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1152 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1153 : #endif
1154 1 : }
1155 :
1156 : /**
1157 : * Test 22: request a large number of measurements before requesting a signed response
1158 : * 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
1159 : * if transcript.message_m has no more room, an error response is expected
1160 : **/
1161 1 : static void rsp_measurements_case22(void **state)
1162 : {
1163 : libspdm_return_t status;
1164 : libspdm_test_context_t *spdm_test_context;
1165 : libspdm_context_t *spdm_context;
1166 : size_t response_size;
1167 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1168 : spdm_measurements_response_t *spdm_response;
1169 : size_t NumberOfMessages;
1170 : #define TOTAL_MESSAGES 100
1171 :
1172 1 : spdm_test_context = *state;
1173 1 : spdm_context = spdm_test_context->spdm_context;
1174 1 : spdm_test_context->case_id = 0x16;
1175 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1176 1 : spdm_context->local_context.capability.flags |=
1177 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1178 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1179 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1180 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1181 : m_libspdm_use_measurement_hash_algo;
1182 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1183 :
1184 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1185 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1186 1 : libspdm_reset_message_m(spdm_context, NULL);
1187 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1188 :
1189 101 : for (NumberOfMessages = 1; NumberOfMessages <= TOTAL_MESSAGES; NumberOfMessages++) {
1190 100 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request9.nonce);
1191 100 : response_size = sizeof(response);
1192 100 : status = libspdm_get_response_measurements(
1193 : spdm_context, m_libspdm_get_measurements_request9_size,
1194 : &m_libspdm_get_measurements_request9, &response_size,
1195 : response);
1196 100 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1197 100 : spdm_response = (void *)response;
1198 100 : if (spdm_response->header.request_response_code == SPDM_MEASUREMENTS) {
1199 100 : assert_int_equal( spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1200 100 : assert_int_equal(
1201 : response_size,
1202 : sizeof(spdm_measurements_response_t) +
1203 : sizeof(spdm_measurement_block_dmtf_t) +
1204 : libspdm_get_measurement_hash_size(
1205 : m_libspdm_use_measurement_hash_algo) + SPDM_NONCE_SIZE +
1206 : sizeof(uint16_t));
1207 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1208 : assert_int_equal(
1209 : spdm_context->transcript.message_m.buffer_size,
1210 : NumberOfMessages *
1211 : (m_libspdm_get_measurements_request9_size +
1212 : sizeof(spdm_measurements_response_t) +
1213 : sizeof(spdm_measurement_block_dmtf_t) +
1214 : libspdm_get_measurement_hash_size(
1215 : m_libspdm_use_measurement_hash_algo) + SPDM_NONCE_SIZE +
1216 : sizeof(uint16_t)));
1217 : #endif
1218 : } else {
1219 0 : assert_int_equal( spdm_response->header.request_response_code, SPDM_ERROR);
1220 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1221 : assert_int_equal( spdm_context->transcript.message_m.buffer_size, 0);
1222 : #endif
1223 0 : break;
1224 : }
1225 : }
1226 1 : }
1227 :
1228 : /**
1229 : * Test 23: Successful response to get a session based measurement with signature
1230 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, with an empty session_transcript.message_m
1231 : **/
1232 1 : static void rsp_measurements_case23(void **state)
1233 : {
1234 : libspdm_return_t status;
1235 : libspdm_test_context_t *spdm_test_context;
1236 : libspdm_context_t *spdm_context;
1237 : size_t response_size;
1238 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1239 : spdm_measurements_response_t *spdm_response;
1240 : size_t measurment_sig_size;
1241 : libspdm_session_info_t *session_info;
1242 : uint32_t session_id;
1243 :
1244 1 : spdm_test_context = *state;
1245 1 : spdm_context = spdm_test_context->spdm_context;
1246 1 : spdm_test_context->case_id = 0x17;
1247 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1248 1 : spdm_context->local_context.capability.flags |=
1249 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1250 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1251 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1252 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1253 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1254 : m_libspdm_use_measurement_hash_algo;
1255 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1256 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1257 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1258 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1259 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1260 :
1261 1 : response_size = sizeof(response);
1262 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
1263 :
1264 :
1265 1 : session_id = 0xFFFFFFFF;
1266 1 : spdm_context->latest_session_id = session_id;
1267 1 : spdm_context->last_spdm_request_session_id_valid = true;
1268 1 : spdm_context->last_spdm_request_session_id = session_id;
1269 1 : session_info = &spdm_context->session_info[0];
1270 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
1271 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
1272 1 : libspdm_secured_message_set_session_state(
1273 : session_info->secured_message_context,
1274 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1275 1 : status = libspdm_get_response_measurements(
1276 : spdm_context, m_libspdm_get_measurements_request5_size,
1277 : &m_libspdm_get_measurements_request5, &response_size, response);
1278 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1279 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
1280 1 : spdm_response = (void *)response;
1281 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1282 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
1283 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1284 : assert_int_equal(session_info->session_transcript.message_m.buffer_size, 0);
1285 : #endif
1286 1 : }
1287 :
1288 : /**
1289 : * Test 24: receiving a correct GET_MEASUREMENTS from the requester that does not request a
1290 : * signature. Buffer M already has arbitrary data.
1291 : * Expected behavior: the responder accepts the request and produces a valid
1292 : * MEASUREMENTS response message, and buffer M appends the exchanged GET_MEASUREMENTS and MEASUREMENTS
1293 : * messages.
1294 : **/
1295 1 : static void rsp_measurements_case24(void **state)
1296 : {
1297 : libspdm_return_t status;
1298 : libspdm_test_context_t *spdm_test_context;
1299 : libspdm_context_t *spdm_context;
1300 : size_t response_size;
1301 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1302 : spdm_measurements_response_t *spdm_response;
1303 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1304 : size_t arbitrary_size;
1305 : #endif
1306 :
1307 1 : spdm_test_context = *state;
1308 1 : spdm_context = spdm_test_context->spdm_context;
1309 1 : spdm_test_context->case_id = 0x18;
1310 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1311 1 : spdm_context->local_context.capability.flags |=
1312 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1313 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1314 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1315 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1316 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1317 : m_libspdm_use_measurement_hash_algo;
1318 1 : libspdm_reset_message_m(spdm_context, NULL);
1319 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1320 1 : spdm_context->last_spdm_request_session_id_valid = 0;
1321 :
1322 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1323 : /*filling M buffer with arbitrary data*/
1324 : arbitrary_size = 18;
1325 : libspdm_set_mem(spdm_context->transcript.message_m.buffer, arbitrary_size, (uint8_t) 0xFF);
1326 : spdm_context->transcript.message_m.buffer_size = arbitrary_size;
1327 : #endif
1328 :
1329 1 : response_size = sizeof(response);
1330 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request7.nonce);
1331 1 : status = libspdm_get_response_measurements(
1332 : spdm_context, m_libspdm_get_measurements_request7_size,
1333 : &m_libspdm_get_measurements_request7, &response_size, response);
1334 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1335 1 : assert_int_equal(response_size,
1336 : sizeof(spdm_measurements_response_t) + LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER*
1337 : (sizeof(spdm_measurement_block_dmtf_t) +
1338 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo)) +
1339 : (sizeof(spdm_measurement_block_dmtf_t) +
1340 : sizeof(spdm_measurements_secure_version_number_t)) +
1341 : (sizeof(spdm_measurement_block_dmtf_t) +
1342 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo)) +
1343 : (sizeof(spdm_measurement_block_dmtf_t) + LIBSPDM_MEASUREMENT_MANIFEST_SIZE) +
1344 : (sizeof(spdm_measurement_block_dmtf_t) +
1345 : sizeof(spdm_measurements_device_mode_t)) +
1346 : SPDM_NONCE_SIZE + sizeof(uint16_t));
1347 1 : spdm_response = (void *)response;
1348 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1349 1 : assert_int_equal(spdm_response->number_of_blocks, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
1350 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1351 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
1352 : arbitrary_size + m_libspdm_get_measurements_request7_size +
1353 : sizeof(spdm_measurements_response_t) + LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER*
1354 : (sizeof(spdm_measurement_block_dmtf_t) +
1355 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo)) +
1356 : (sizeof(spdm_measurement_block_dmtf_t) +
1357 : sizeof(spdm_measurements_secure_version_number_t)) +
1358 : (sizeof(spdm_measurement_block_dmtf_t) +
1359 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo)) +
1360 : (sizeof(spdm_measurement_block_dmtf_t) + LIBSPDM_MEASUREMENT_MANIFEST_SIZE) +
1361 : (sizeof(spdm_measurement_block_dmtf_t) +
1362 : sizeof(spdm_measurements_device_mode_t)) +
1363 : SPDM_NONCE_SIZE + sizeof(uint16_t));
1364 :
1365 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
1366 : arbitrary_size + m_libspdm_get_measurements_request7_size + response_size);
1367 : assert_memory_equal(spdm_context->transcript.message_m.buffer + arbitrary_size,
1368 : &m_libspdm_get_measurements_request7,
1369 : m_libspdm_get_measurements_request7_size);
1370 : assert_memory_equal(spdm_context->transcript.message_m.buffer + arbitrary_size
1371 : + m_libspdm_get_measurements_request7_size,
1372 : response, response_size);
1373 : #endif
1374 1 : }
1375 :
1376 1 : static void rsp_measurements_case25(void **state)
1377 : {
1378 : libspdm_return_t status;
1379 : libspdm_test_context_t *spdm_test_context;
1380 : libspdm_context_t *spdm_context;
1381 : size_t response_size;
1382 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1383 : spdm_measurements_response_t *spdm_response;
1384 :
1385 1 : spdm_test_context = *state;
1386 1 : spdm_context = spdm_test_context->spdm_context;
1387 1 : spdm_test_context->case_id = 0x19;
1388 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1389 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1390 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1391 1 : spdm_context->local_context.capability.flags |=
1392 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1393 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1394 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1395 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1396 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1397 : m_libspdm_use_measurement_hash_algo;
1398 1 : libspdm_reset_message_m(spdm_context, NULL);
1399 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1400 :
1401 1 : response_size = sizeof(response);
1402 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request14.nonce);
1403 1 : status = libspdm_get_response_measurements(
1404 : spdm_context, m_libspdm_get_measurements_request14_size,
1405 : &m_libspdm_get_measurements_request14, &response_size, response);
1406 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1407 1 : assert_int_equal(response_size,
1408 : sizeof(spdm_measurements_response_t) +
1409 : sizeof(spdm_measurement_block_dmtf_t) +
1410 : LIBSPDM_MEASUREMENT_RAW_DATA_SIZE + SPDM_NONCE_SIZE +
1411 : sizeof(uint16_t));
1412 1 : spdm_response = (void *)response;
1413 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1414 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1415 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
1416 : m_libspdm_get_measurements_request14_size +
1417 : sizeof(spdm_measurements_response_t) +
1418 : sizeof(spdm_measurement_block_dmtf_t) +
1419 : LIBSPDM_MEASUREMENT_RAW_DATA_SIZE + SPDM_NONCE_SIZE +
1420 : sizeof(uint16_t));
1421 : #endif
1422 1 : }
1423 :
1424 1 : static void rsp_measurements_case26(void **state)
1425 : {
1426 : libspdm_return_t status;
1427 : libspdm_test_context_t *spdm_test_context;
1428 : libspdm_context_t *spdm_context;
1429 : size_t response_size;
1430 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1431 : spdm_measurements_response_t *spdm_response;
1432 : void *data;
1433 : size_t data_size;
1434 : size_t measurment_sig_size;
1435 :
1436 1 : spdm_test_context = *state;
1437 1 : spdm_context = spdm_test_context->spdm_context;
1438 1 : spdm_test_context->case_id = 0x1A;
1439 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1440 1 : spdm_context->local_context.capability.flags |=
1441 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1442 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1443 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1444 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1445 : m_libspdm_use_measurement_hash_algo;
1446 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1447 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1448 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1449 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1450 1 : libspdm_reset_message_m(spdm_context, NULL);
1451 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1452 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1453 : m_libspdm_use_asym_algo, &data,
1454 : &data_size, NULL, NULL)) {
1455 0 : return;
1456 : }
1457 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1458 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1459 9 : for (int i = 0; i < SPDM_MAX_SLOT_COUNT; i++) {
1460 8 : spdm_context->local_context.local_cert_chain_provision_size[i] = data_size;
1461 8 : spdm_context->local_context.local_cert_chain_provision[i] = data;
1462 : }
1463 :
1464 1 : response_size = sizeof(response);
1465 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request15.nonce);
1466 1 : status = libspdm_get_response_measurements(
1467 : spdm_context, m_libspdm_get_measurements_request15_size,
1468 : &m_libspdm_get_measurements_request15, &response_size, response);
1469 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1470 1 : assert_int_equal(response_size,
1471 : sizeof(spdm_measurements_response_t) +
1472 : sizeof(spdm_measurement_block_dmtf_t) +
1473 : libspdm_get_measurement_hash_size(
1474 : m_libspdm_use_measurement_hash_algo) +
1475 : measurment_sig_size);
1476 1 : spdm_response = (void *)response;
1477 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1478 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1479 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1480 : #endif
1481 1 : assert_int_equal(spdm_response->header.param2, m_libspdm_get_measurements_request15.slot_id_param|
1482 : (SPDM_MEASUREMENTS_RESPONSE_CONTENT_NO_CHANGE_DETECTED &
1483 : SPDM_MEASUREMENTS_RESPONSE_CONTENT_CHANGE_MASK));
1484 :
1485 1 : free(data);
1486 : }
1487 :
1488 1 : static void rsp_measurements_case27(void **state)
1489 : {
1490 : libspdm_return_t status;
1491 : libspdm_test_context_t *spdm_test_context;
1492 : libspdm_context_t *spdm_context;
1493 : size_t response_size;
1494 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1495 : spdm_measurements_response_t *spdm_response;
1496 : void *data;
1497 : size_t data_size;
1498 : size_t measurment_sig_size;
1499 : uint8_t content_changed;
1500 : uint8_t measurements_count;
1501 : uint8_t *measurement_record_data;
1502 : size_t measurement_record_data_length;
1503 : uint8_t expect_measurement_record_data[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
1504 : size_t expect_measurement_record_data_length;
1505 : uint8_t *opaque_data;
1506 : uint16_t *opaque_data_size;
1507 : uint8_t expect_opaque_data[SPDM_MAX_OPAQUE_DATA_SIZE];
1508 : size_t expect_opaque_data_size;
1509 :
1510 1 : spdm_test_context = *state;
1511 1 : spdm_context = spdm_test_context->spdm_context;
1512 1 : spdm_test_context->case_id = 0x1B;
1513 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1514 1 : spdm_context->local_context.capability.flags |=
1515 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1516 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1517 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1518 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1519 : m_libspdm_use_measurement_hash_algo;
1520 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1521 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1522 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1523 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1524 1 : spdm_context->connection_info.algorithm.other_params_support =
1525 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
1526 1 : libspdm_reset_message_m(spdm_context, NULL);
1527 :
1528 : /*opaque data*/
1529 1 : libspdm_secret_lib_meas_opaque_data_size = 0x20;
1530 :
1531 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1532 : m_libspdm_use_asym_algo, &data,
1533 : &data_size, NULL, NULL)) {
1534 0 : return;
1535 : }
1536 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) +
1537 1 : libspdm_secret_lib_meas_opaque_data_size +
1538 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1539 9 : for (int i = 0; i < SPDM_MAX_SLOT_COUNT; i++) {
1540 8 : spdm_context->local_context.local_cert_chain_provision_size[i] = data_size;
1541 8 : spdm_context->local_context.local_cert_chain_provision[i] = data;
1542 : }
1543 :
1544 1 : response_size = sizeof(response);
1545 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request15.nonce);
1546 1 : status = libspdm_get_response_measurements(
1547 : spdm_context, m_libspdm_get_measurements_request15_size,
1548 : &m_libspdm_get_measurements_request15, &response_size, response);
1549 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1550 1 : assert_int_equal(response_size,
1551 : sizeof(spdm_measurements_response_t) +
1552 : sizeof(spdm_measurement_block_dmtf_t) +
1553 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo) +
1554 : measurment_sig_size);
1555 1 : spdm_response = (void *)response;
1556 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1557 :
1558 1 : expect_measurement_record_data_length = sizeof(expect_measurement_record_data);
1559 1 : expect_opaque_data_size = sizeof(expect_opaque_data);
1560 :
1561 1 : libspdm_measurement_collection(
1562 : spdm_context,
1563 : NULL,
1564 1 : spdm_context->connection_info.version,
1565 1 : spdm_context->connection_info.algorithm.measurement_spec,
1566 : spdm_context->connection_info.algorithm.measurement_hash_algo,
1567 1 : m_libspdm_get_measurements_request15.header.param2,
1568 1 : m_libspdm_get_measurements_request15.header.param1,
1569 : NULL,
1570 : 0,
1571 : 0,
1572 : NULL,
1573 : &content_changed,
1574 : &measurements_count,
1575 : expect_measurement_record_data,
1576 : &expect_measurement_record_data_length);
1577 :
1578 1 : libspdm_measurement_opaque_data(
1579 : spdm_context,
1580 : NULL,
1581 1 : spdm_context->connection_info.version,
1582 1 : spdm_context->connection_info.algorithm.measurement_spec,
1583 : spdm_context->connection_info.algorithm.measurement_hash_algo,
1584 1 : m_libspdm_get_measurements_request15.header.param2,
1585 1 : m_libspdm_get_measurements_request15.header.param1,
1586 : 0,
1587 : NULL,
1588 : expect_opaque_data,
1589 : &expect_opaque_data_size);
1590 :
1591 1 : measurement_record_data = (uint8_t *)response + sizeof(spdm_measurements_response_t);
1592 1 : opaque_data_size =
1593 : (uint16_t *)(measurement_record_data + sizeof(spdm_measurement_block_dmtf_t) +
1594 1 : libspdm_get_measurement_hash_size(
1595 1 : m_libspdm_use_measurement_hash_algo) +
1596 : SPDM_NONCE_SIZE);
1597 1 : opaque_data = (uint8_t *)opaque_data_size + sizeof(uint16_t);
1598 :
1599 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
1600 :
1601 1 : assert_int_equal(measurement_record_data_length, expect_measurement_record_data_length );
1602 1 : assert_memory_equal(measurement_record_data, expect_measurement_record_data,
1603 : expect_measurement_record_data_length);
1604 1 : assert_int_equal(*opaque_data_size, libspdm_secret_lib_meas_opaque_data_size);
1605 1 : assert_memory_equal(opaque_data, expect_opaque_data, libspdm_secret_lib_meas_opaque_data_size);
1606 :
1607 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1608 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1609 : #endif
1610 1 : assert_int_equal(spdm_response->header.param2, m_libspdm_get_measurements_request15.slot_id_param|
1611 : (SPDM_MEASUREMENTS_RESPONSE_CONTENT_NO_CHANGE_DETECTED &
1612 : SPDM_MEASUREMENTS_RESPONSE_CONTENT_CHANGE_MASK));
1613 :
1614 1 : free(data);
1615 : }
1616 :
1617 : /**
1618 : * Test 28: Successful response to get all measurements with signature using slot_id 0xFF
1619 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m, and correct response message size and fields
1620 : **/
1621 1 : static void rsp_measurements_case28(void **state)
1622 : {
1623 : libspdm_return_t status;
1624 : libspdm_test_context_t *spdm_test_context;
1625 : libspdm_context_t *spdm_context;
1626 : size_t response_size;
1627 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1628 : spdm_measurements_response_t *spdm_response;
1629 : void *data;
1630 : size_t data_size;
1631 : size_t measurment_sig_size;
1632 :
1633 1 : spdm_test_context = *state;
1634 1 : spdm_context = spdm_test_context->spdm_context;
1635 1 : spdm_test_context->case_id = 0x1C;
1636 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1637 1 : spdm_context->local_context.capability.flags |=
1638 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1639 1 : spdm_context->local_context.capability.flags |=
1640 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PUB_KEY_ID_CAP;
1641 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1642 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1643 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1644 : m_libspdm_use_measurement_hash_algo;
1645 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1646 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1647 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1648 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1649 1 : libspdm_reset_message_m(spdm_context, NULL);
1650 :
1651 : /*opaque data*/
1652 1 : libspdm_secret_lib_meas_opaque_data_size = 0x20;
1653 :
1654 1 : if (!libspdm_read_responder_public_key(m_libspdm_use_asym_algo, &data, &data_size)) {
1655 0 : return;
1656 : }
1657 1 : spdm_context->local_context.local_public_key_provision = data;
1658 1 : spdm_context->local_context.local_public_key_provision_size = data_size;
1659 :
1660 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) +
1661 1 : libspdm_secret_lib_meas_opaque_data_size +
1662 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1663 1 : response_size = sizeof(response);
1664 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request16.nonce);
1665 1 : m_libspdm_get_measurements_request16.slot_id_param = 0xF;
1666 1 : status = libspdm_get_response_measurements(
1667 : spdm_context, m_libspdm_get_measurements_request16_size,
1668 : &m_libspdm_get_measurements_request16, &response_size, response);
1669 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1670 1 : assert_int_equal(response_size,
1671 : sizeof(spdm_measurements_response_t) + sizeof(spdm_measurement_block_dmtf_t) +
1672 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo) +
1673 : measurment_sig_size);
1674 1 : spdm_response = (void *)response;
1675 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1676 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1677 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1678 : #endif
1679 1 : assert_int_equal(spdm_response->header.param2,
1680 : m_libspdm_get_measurements_request16.slot_id_param |
1681 : (SPDM_MEASUREMENTS_RESPONSE_CONTENT_NO_CHANGE_DETECTED &
1682 : SPDM_MEASUREMENTS_RESPONSE_CONTENT_CHANGE_MASK));
1683 :
1684 1 : free(data);
1685 : }
1686 :
1687 : /**
1688 : * Test 29: Based of Test Case 7 Successful response to get a number of measurements
1689 : * with signature.
1690 : * Signature test with signing in big endian but verification in little endian.
1691 : *
1692 : * Expected Behavior: Failing signature verification
1693 : **/
1694 1 : static void rsp_measurements_case29(void** state)
1695 : {
1696 : libspdm_return_t status;
1697 : libspdm_test_context_t* spdm_test_context;
1698 : libspdm_context_t* spdm_context;
1699 : size_t response_size;
1700 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1701 : spdm_measurements_response_t* spdm_response;
1702 : size_t measurment_sig_size;
1703 :
1704 : bool result;
1705 : uint32_t measurement_record_data_length;
1706 : uint8_t* measurement_record_data;
1707 : uint8_t* ptr;
1708 : uint16_t opaque_length;
1709 : void* signature;
1710 : size_t signature_size;
1711 : libspdm_session_info_t* session_info;
1712 : void* data;
1713 : size_t data_size;
1714 : void* hash;
1715 : size_t hash_size;
1716 :
1717 1 : spdm_test_context = *state;
1718 1 : spdm_context = spdm_test_context->spdm_context;
1719 1 : spdm_test_context->case_id = 29;
1720 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1721 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1722 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1723 1 : spdm_context->local_context.capability.flags |=
1724 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1725 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1726 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1727 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1728 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1729 : m_libspdm_use_measurement_hash_algo;
1730 1 : spdm_context->spdm_10_11_verify_signature_endian =
1731 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_LITTLE_ONLY;
1732 :
1733 1 : libspdm_reset_message_m(spdm_context, NULL);
1734 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1735 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1736 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1737 :
1738 1 : response_size = sizeof(response);
1739 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
1740 1 : status = libspdm_get_response_measurements(
1741 : spdm_context, m_libspdm_get_measurements_request5_size,
1742 : &m_libspdm_get_measurements_request5, &response_size, response);
1743 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1744 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
1745 1 : spdm_response = (void*)response;
1746 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1747 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
1748 :
1749 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1750 : m_libspdm_use_asym_algo, &data,
1751 : &data_size,
1752 : &hash, &hash_size)) {
1753 0 : assert(false);
1754 : }
1755 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1756 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1757 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1758 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1759 : data, data_size);
1760 : #else
1761 1 : libspdm_hash_all(
1762 : spdm_context->connection_info.algorithm.base_hash_algo,
1763 : data, data_size,
1764 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
1765 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
1766 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
1767 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
1768 : spdm_context->connection_info.algorithm.base_hash_algo,
1769 : spdm_context->connection_info.algorithm.base_asym_algo,
1770 : data, data_size,
1771 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
1772 : #endif
1773 :
1774 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
1775 1 : measurement_record_data = (void*)(spdm_response + 1);
1776 1 : ptr = measurement_record_data + measurement_record_data_length;
1777 1 : ptr += SPDM_NONCE_SIZE;
1778 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
1779 1 : ptr += sizeof(uint16_t);
1780 1 : ptr += opaque_length;
1781 1 : signature = ptr;
1782 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1783 1 : session_info = NULL;
1784 :
1785 1 : status = libspdm_append_message_m(spdm_context, session_info,
1786 : &m_libspdm_get_measurements_request5,
1787 : m_libspdm_get_measurements_request5_size);
1788 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1789 :
1790 1 : status = libspdm_append_message_m(spdm_context, session_info, spdm_response,
1791 : response_size - signature_size);
1792 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1793 :
1794 1 : result = libspdm_verify_measurement_signature(
1795 : spdm_context, session_info, 0, signature, signature_size);
1796 1 : assert_false(result);
1797 :
1798 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1799 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1800 : #endif
1801 1 : }
1802 :
1803 : /**
1804 : * Test 30: Based of Test Case 7 Successful response to get a number of measurements
1805 : * with signature.
1806 : * Signature test with signing in big endian but verification in little endian.
1807 : *
1808 : * Expected Behavior: Failing signature verification
1809 : **/
1810 1 : static void rsp_measurements_case30(void** state)
1811 : {
1812 : libspdm_return_t status;
1813 : libspdm_test_context_t* spdm_test_context;
1814 : libspdm_context_t* spdm_context;
1815 : size_t response_size;
1816 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1817 : spdm_measurements_response_t* spdm_response;
1818 : size_t measurment_sig_size;
1819 :
1820 : bool result;
1821 : uint32_t measurement_record_data_length;
1822 : uint8_t* measurement_record_data;
1823 : uint8_t* ptr;
1824 : uint16_t opaque_length;
1825 : void* signature;
1826 : size_t signature_size;
1827 : libspdm_session_info_t* session_info;
1828 : void* data;
1829 : size_t data_size;
1830 : void* hash;
1831 : size_t hash_size;
1832 :
1833 1 : spdm_test_context = *state;
1834 1 : spdm_context = spdm_test_context->spdm_context;
1835 1 : spdm_test_context->case_id = 30;
1836 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1837 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1838 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1839 1 : spdm_context->local_context.capability.flags |=
1840 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1841 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1842 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1843 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1844 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1845 : m_libspdm_use_measurement_hash_algo;
1846 1 : spdm_context->spdm_10_11_verify_signature_endian =
1847 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_BIG_ONLY;
1848 :
1849 1 : libspdm_reset_message_m(spdm_context, NULL);
1850 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1851 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1852 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1853 :
1854 1 : response_size = sizeof(response);
1855 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
1856 1 : status = libspdm_get_response_measurements(
1857 : spdm_context, m_libspdm_get_measurements_request5_size,
1858 : &m_libspdm_get_measurements_request5, &response_size, response);
1859 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1860 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
1861 1 : spdm_response = (void*)response;
1862 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1863 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
1864 :
1865 1 : if (!libspdm_read_responder_public_certificate_chain(
1866 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
1867 : &data, &data_size,
1868 : &hash, &hash_size)) {
1869 0 : return;
1870 : }
1871 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1872 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1873 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1874 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1875 : data, data_size);
1876 : #else
1877 1 : libspdm_hash_all(
1878 : spdm_context->connection_info.algorithm.base_hash_algo,
1879 : data, data_size,
1880 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
1881 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
1882 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
1883 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
1884 : spdm_context->connection_info.algorithm.base_hash_algo,
1885 : spdm_context->connection_info.algorithm.base_asym_algo,
1886 : data, data_size,
1887 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
1888 : #endif
1889 :
1890 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
1891 1 : measurement_record_data = (void*)(spdm_response + 1);
1892 1 : ptr = measurement_record_data + measurement_record_data_length;
1893 1 : ptr += SPDM_NONCE_SIZE;
1894 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
1895 1 : ptr += sizeof(uint16_t);
1896 1 : ptr += opaque_length;
1897 1 : signature = ptr;
1898 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1899 1 : session_info = NULL;
1900 :
1901 1 : status = libspdm_append_message_m(
1902 : spdm_context, session_info,
1903 : &m_libspdm_get_measurements_request5,
1904 : m_libspdm_get_measurements_request5_size);
1905 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1906 :
1907 1 : status = libspdm_append_message_m(
1908 : spdm_context, session_info, spdm_response,
1909 : response_size - signature_size);
1910 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1911 :
1912 1 : result = libspdm_verify_measurement_signature(
1913 : spdm_context, session_info, 0, signature, signature_size);
1914 1 : assert_true(result);
1915 :
1916 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1917 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1918 : #endif
1919 : }
1920 :
1921 : /**
1922 : * Test 31: Based of Test Case 7 Successful response to get a number of measurements
1923 : * with signature.
1924 : * Signature test with signing in big endian but verification in big or little endian.
1925 : *
1926 : * Expected Behavior: Passing signature verification
1927 : **/
1928 1 : static void rsp_measurements_case31(void** state)
1929 : {
1930 : libspdm_return_t status;
1931 : libspdm_test_context_t* spdm_test_context;
1932 : libspdm_context_t* spdm_context;
1933 : size_t response_size;
1934 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1935 : spdm_measurements_response_t* spdm_response;
1936 : size_t measurment_sig_size;
1937 :
1938 : bool result;
1939 : uint32_t measurement_record_data_length;
1940 : uint8_t* measurement_record_data;
1941 : uint8_t* ptr;
1942 : uint16_t opaque_length;
1943 : void* signature;
1944 : size_t signature_size;
1945 : libspdm_session_info_t* session_info;
1946 : void* data;
1947 : size_t data_size;
1948 : void* hash;
1949 : size_t hash_size;
1950 :
1951 1 : spdm_test_context = *state;
1952 1 : spdm_context = spdm_test_context->spdm_context;
1953 1 : spdm_test_context->case_id = 31;
1954 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1955 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1956 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1957 1 : spdm_context->local_context.capability.flags |=
1958 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1959 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1960 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1961 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1962 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1963 : m_libspdm_use_measurement_hash_algo;
1964 1 : spdm_context->spdm_10_11_verify_signature_endian =
1965 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_BIG_OR_LITTLE;
1966 :
1967 1 : libspdm_reset_message_m(spdm_context, NULL);
1968 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1969 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1970 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1971 :
1972 1 : response_size = sizeof(response);
1973 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
1974 1 : status = libspdm_get_response_measurements(
1975 : spdm_context, m_libspdm_get_measurements_request5_size,
1976 : &m_libspdm_get_measurements_request5, &response_size, response);
1977 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1978 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
1979 1 : spdm_response = (void*)response;
1980 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
1981 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
1982 :
1983 1 : if (!libspdm_read_responder_public_certificate_chain(
1984 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
1985 : &data, &data_size,
1986 : &hash, &hash_size)) {
1987 0 : return;
1988 : }
1989 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1990 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
1991 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1992 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1993 : data, data_size);
1994 : #else
1995 1 : libspdm_hash_all(
1996 : spdm_context->connection_info.algorithm.base_hash_algo,
1997 : data, data_size,
1998 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
1999 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2000 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2001 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2002 : spdm_context->connection_info.algorithm.base_hash_algo,
2003 : spdm_context->connection_info.algorithm.base_asym_algo,
2004 : data, data_size,
2005 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2006 : #endif
2007 :
2008 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
2009 1 : measurement_record_data = (void*)(spdm_response + 1);
2010 1 : ptr = measurement_record_data + measurement_record_data_length;
2011 1 : ptr += SPDM_NONCE_SIZE;
2012 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
2013 1 : ptr += sizeof(uint16_t);
2014 1 : ptr += opaque_length;
2015 1 : signature = ptr;
2016 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2017 1 : session_info = NULL;
2018 :
2019 1 : status = libspdm_append_message_m(
2020 : spdm_context, session_info,
2021 : &m_libspdm_get_measurements_request5,
2022 : m_libspdm_get_measurements_request5_size);
2023 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2024 :
2025 1 : status = libspdm_append_message_m(
2026 : spdm_context, session_info, spdm_response,
2027 : response_size - signature_size);
2028 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2029 :
2030 1 : result = libspdm_verify_measurement_signature(
2031 : spdm_context, session_info, 0, signature, signature_size);
2032 1 : assert_true(result);
2033 :
2034 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2035 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2036 : #endif
2037 : }
2038 :
2039 : /**
2040 : * Test 32: Based of Test Case 7 Successful response to get a number of measurements
2041 : * with signature.
2042 : * Signature test with signing in little endian but verification in little endian.
2043 : *
2044 : * Expected Behavior: Failing signature verification
2045 : **/
2046 1 : static void rsp_measurements_case32(void** state)
2047 : {
2048 : libspdm_return_t status;
2049 : libspdm_test_context_t* spdm_test_context;
2050 : libspdm_context_t* spdm_context;
2051 : size_t response_size;
2052 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2053 : spdm_measurements_response_t* spdm_response;
2054 : size_t measurment_sig_size;
2055 :
2056 : bool result;
2057 : uint32_t measurement_record_data_length;
2058 : uint8_t* measurement_record_data;
2059 : uint8_t* ptr;
2060 : uint16_t opaque_length;
2061 : void* signature;
2062 : size_t signature_size;
2063 : libspdm_session_info_t* session_info;
2064 : void* data;
2065 : size_t data_size;
2066 : void* hash;
2067 : size_t hash_size;
2068 :
2069 1 : spdm_test_context = *state;
2070 1 : spdm_context = spdm_test_context->spdm_context;
2071 1 : spdm_test_context->case_id = 32;
2072 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
2073 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2074 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2075 1 : spdm_context->local_context.capability.flags |=
2076 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2077 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2078 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2079 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2080 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2081 : m_libspdm_use_measurement_hash_algo;
2082 1 : spdm_context->spdm_10_11_verify_signature_endian =
2083 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_LITTLE_ONLY;
2084 :
2085 1 : libspdm_reset_message_m(spdm_context, NULL);
2086 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2087 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
2088 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2089 :
2090 1 : response_size = sizeof(response);
2091 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
2092 1 : status = libspdm_get_response_measurements(
2093 : spdm_context, m_libspdm_get_measurements_request5_size,
2094 : &m_libspdm_get_measurements_request5, &response_size, response);
2095 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2096 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
2097 1 : spdm_response = (void*)response;
2098 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
2099 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
2100 :
2101 1 : if (!libspdm_read_responder_public_certificate_chain(
2102 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
2103 : &data, &data_size,
2104 : &hash, &hash_size)) {
2105 0 : return;
2106 : }
2107 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2108 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
2109 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2110 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2111 : data, data_size);
2112 : #else
2113 1 : libspdm_hash_all(
2114 : spdm_context->connection_info.algorithm.base_hash_algo,
2115 : data, data_size,
2116 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
2117 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2118 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2119 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2120 : spdm_context->connection_info.algorithm.base_hash_algo,
2121 : spdm_context->connection_info.algorithm.base_asym_algo,
2122 : data, data_size,
2123 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2124 : #endif
2125 :
2126 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
2127 1 : measurement_record_data = (void*)(spdm_response + 1);
2128 1 : ptr = measurement_record_data + measurement_record_data_length;
2129 1 : ptr += SPDM_NONCE_SIZE;
2130 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
2131 1 : ptr += sizeof(uint16_t);
2132 1 : ptr += opaque_length;
2133 1 : signature = ptr;
2134 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2135 :
2136 1 : libspdm_copy_signature_swap_endian(
2137 : m_libspdm_use_asym_algo,
2138 : signature, signature_size, signature, signature_size);
2139 :
2140 1 : session_info = NULL;
2141 :
2142 1 : status = libspdm_append_message_m(
2143 : spdm_context, session_info,
2144 : &m_libspdm_get_measurements_request5,
2145 : m_libspdm_get_measurements_request5_size);
2146 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2147 :
2148 1 : status = libspdm_append_message_m(
2149 : spdm_context, session_info, spdm_response,
2150 : response_size - signature_size);
2151 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2152 :
2153 1 : result = libspdm_verify_measurement_signature(
2154 : spdm_context, session_info, 0, signature, signature_size);
2155 1 : assert_true(result);
2156 :
2157 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2158 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2159 : #endif
2160 : }
2161 :
2162 : /**
2163 : * Test 33: Based of Test Case 7 Successful response to get a number of measurements
2164 : * with signature.
2165 : * Signature test with signing in little endian but verification in big endian.
2166 : *
2167 : * Expected Behavior: Failing signature verification
2168 : **/
2169 1 : static void rsp_measurements_case33(void** state)
2170 : {
2171 : libspdm_return_t status;
2172 : libspdm_test_context_t* spdm_test_context;
2173 : libspdm_context_t* spdm_context;
2174 : size_t response_size;
2175 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2176 : spdm_measurements_response_t* spdm_response;
2177 : size_t measurment_sig_size;
2178 :
2179 : bool result;
2180 : uint32_t measurement_record_data_length;
2181 : uint8_t* measurement_record_data;
2182 : uint8_t* ptr;
2183 : uint16_t opaque_length;
2184 : void* signature;
2185 : size_t signature_size;
2186 : libspdm_session_info_t* session_info;
2187 : void* data;
2188 : size_t data_size;
2189 : void* hash;
2190 : size_t hash_size;
2191 :
2192 1 : spdm_test_context = *state;
2193 1 : spdm_context = spdm_test_context->spdm_context;
2194 1 : spdm_test_context->case_id = 33;
2195 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
2196 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2197 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2198 1 : spdm_context->local_context.capability.flags |=
2199 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2200 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2201 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2202 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2203 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2204 : m_libspdm_use_measurement_hash_algo;
2205 1 : spdm_context->spdm_10_11_verify_signature_endian =
2206 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_BIG_ONLY;
2207 :
2208 1 : libspdm_reset_message_m(spdm_context, NULL);
2209 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2210 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
2211 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2212 :
2213 1 : response_size = sizeof(response);
2214 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
2215 1 : status = libspdm_get_response_measurements(
2216 : spdm_context, m_libspdm_get_measurements_request5_size,
2217 : &m_libspdm_get_measurements_request5, &response_size, response);
2218 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2219 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
2220 1 : spdm_response = (void*)response;
2221 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
2222 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
2223 :
2224 1 : if (!libspdm_read_responder_public_certificate_chain(
2225 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
2226 : &data, &data_size,
2227 : &hash, &hash_size)) {
2228 0 : return;
2229 : }
2230 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2231 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
2232 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2233 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2234 : data, data_size);
2235 : #else
2236 1 : libspdm_hash_all(
2237 : spdm_context->connection_info.algorithm.base_hash_algo,
2238 : data, data_size,
2239 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
2240 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2241 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2242 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2243 : spdm_context->connection_info.algorithm.base_hash_algo,
2244 : spdm_context->connection_info.algorithm.base_asym_algo,
2245 : data, data_size,
2246 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2247 : #endif
2248 :
2249 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
2250 1 : measurement_record_data = (void*)(spdm_response + 1);
2251 1 : ptr = measurement_record_data + measurement_record_data_length;
2252 1 : ptr += SPDM_NONCE_SIZE;
2253 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
2254 1 : ptr += sizeof(uint16_t);
2255 1 : ptr += opaque_length;
2256 1 : signature = ptr;
2257 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2258 :
2259 1 : libspdm_copy_signature_swap_endian(
2260 : m_libspdm_use_asym_algo,
2261 : signature, signature_size, signature, signature_size);
2262 :
2263 1 : session_info = NULL;
2264 :
2265 1 : status = libspdm_append_message_m(
2266 : spdm_context, session_info,
2267 : &m_libspdm_get_measurements_request5,
2268 : m_libspdm_get_measurements_request5_size);
2269 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2270 :
2271 1 : status = libspdm_append_message_m(
2272 : spdm_context, session_info, spdm_response,
2273 : response_size - signature_size);
2274 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2275 :
2276 1 : result = libspdm_verify_measurement_signature(
2277 : spdm_context, session_info, 0, signature, signature_size);
2278 1 : assert_false(result);
2279 :
2280 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2281 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2282 : #endif
2283 : }
2284 :
2285 :
2286 : /**
2287 : * Test 34: Based of Test Case 7 Successful response to get a number of measurements
2288 : * with signature.
2289 : * Signature test with signing in little endian but verification in big or little endian.
2290 : *
2291 : * Expected Behavior: Passing signature verification
2292 : **/
2293 1 : static void rsp_measurements_case34(void** state)
2294 : {
2295 : libspdm_return_t status;
2296 : libspdm_test_context_t* spdm_test_context;
2297 : libspdm_context_t* spdm_context;
2298 : size_t response_size;
2299 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2300 : spdm_measurements_response_t* spdm_response;
2301 : size_t measurment_sig_size;
2302 :
2303 : bool result;
2304 : uint32_t measurement_record_data_length;
2305 : uint8_t* measurement_record_data;
2306 : uint8_t* ptr;
2307 : uint16_t opaque_length;
2308 : void* signature;
2309 : size_t signature_size;
2310 : libspdm_session_info_t* session_info;
2311 : void* data;
2312 : size_t data_size;
2313 : void* hash;
2314 : size_t hash_size;
2315 :
2316 1 : spdm_test_context = *state;
2317 1 : spdm_context = spdm_test_context->spdm_context;
2318 1 : spdm_test_context->case_id = 34;
2319 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
2320 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2321 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2322 1 : spdm_context->local_context.capability.flags |=
2323 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2324 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2325 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2326 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2327 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2328 : m_libspdm_use_measurement_hash_algo;
2329 1 : spdm_context->spdm_10_11_verify_signature_endian =
2330 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_BIG_OR_LITTLE;
2331 :
2332 1 : libspdm_reset_message_m(spdm_context, NULL);
2333 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2334 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
2335 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2336 :
2337 1 : response_size = sizeof(response);
2338 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_get_measurements_request5.nonce);
2339 1 : status = libspdm_get_response_measurements(
2340 : spdm_context, m_libspdm_get_measurements_request5_size,
2341 : &m_libspdm_get_measurements_request5, &response_size, response);
2342 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2343 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) + measurment_sig_size);
2344 1 : spdm_response = (void*)response;
2345 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
2346 1 : assert_int_equal(spdm_response->header.param1, LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
2347 :
2348 1 : if (!libspdm_read_responder_public_certificate_chain(
2349 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
2350 : &data, &data_size,
2351 : &hash, &hash_size)) {
2352 0 : return;
2353 : }
2354 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2355 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
2356 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2357 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2358 : data, data_size);
2359 : #else
2360 1 : libspdm_hash_all(
2361 : spdm_context->connection_info.algorithm.base_hash_algo,
2362 : data, data_size,
2363 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
2364 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2365 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2366 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2367 : spdm_context->connection_info.algorithm.base_hash_algo,
2368 : spdm_context->connection_info.algorithm.base_asym_algo,
2369 : data, data_size,
2370 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2371 : #endif
2372 :
2373 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
2374 1 : measurement_record_data = (void*)(spdm_response + 1);
2375 1 : ptr = measurement_record_data + measurement_record_data_length;
2376 1 : ptr += SPDM_NONCE_SIZE;
2377 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
2378 1 : ptr += sizeof(uint16_t);
2379 1 : ptr += opaque_length;
2380 1 : signature = ptr;
2381 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2382 1 : libspdm_copy_signature_swap_endian(
2383 : m_libspdm_use_asym_algo,
2384 : signature, signature_size, signature, signature_size);
2385 :
2386 1 : session_info = NULL;
2387 :
2388 1 : status = libspdm_append_message_m(
2389 : spdm_context, session_info,
2390 : &m_libspdm_get_measurements_request5,
2391 : m_libspdm_get_measurements_request5_size);
2392 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2393 :
2394 1 : status = libspdm_append_message_m(
2395 : spdm_context, session_info, spdm_response,
2396 : response_size - signature_size);
2397 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2398 :
2399 1 : result = libspdm_verify_measurement_signature(
2400 : spdm_context, session_info, 0, signature, signature_size);
2401 1 : assert_true(result);
2402 :
2403 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2404 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2405 : #endif
2406 : }
2407 :
2408 : /**
2409 : * Test 35: Successful response V1.3 to get a number of measurements without signature
2410 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, correct context field
2411 : **/
2412 1 : static void rsp_measurements_case35(void **state)
2413 : {
2414 : libspdm_return_t status;
2415 : libspdm_test_context_t *spdm_test_context;
2416 : libspdm_context_t *spdm_context;
2417 : size_t response_size;
2418 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2419 : spdm_measurements_response_t *spdm_response;
2420 : uint8_t *requester_context;
2421 : uint8_t *responder_context;
2422 :
2423 1 : spdm_test_context = *state;
2424 1 : spdm_context = spdm_test_context->spdm_context;
2425 1 : spdm_test_context->case_id = 35;
2426 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
2427 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2428 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2429 1 : spdm_context->local_context.capability.flags |=
2430 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2431 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2432 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2433 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2434 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2435 : m_libspdm_use_measurement_hash_algo;
2436 1 : libspdm_reset_message_m(spdm_context, NULL);
2437 :
2438 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2439 :
2440 1 : response_size = sizeof(response);
2441 :
2442 1 : requester_context = ((uint8_t *)&m_libspdm_get_measurements_request17) +
2443 : m_libspdm_get_measurements_request17_size;
2444 1 : libspdm_set_mem(requester_context, SPDM_REQ_CONTEXT_SIZE, 0xAA);
2445 1 : m_libspdm_get_measurements_request17_size += SPDM_REQ_CONTEXT_SIZE;
2446 :
2447 1 : status = libspdm_get_response_measurements(
2448 : spdm_context, m_libspdm_get_measurements_request17_size,
2449 : &m_libspdm_get_measurements_request17, &response_size, response);
2450 :
2451 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2452 1 : assert_int_equal(response_size,
2453 : sizeof(spdm_measurements_response_t) + SPDM_NONCE_SIZE + sizeof(uint16_t) +
2454 : SPDM_REQ_CONTEXT_SIZE);
2455 1 : spdm_response = (void *)response;
2456 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENTS);
2457 1 : responder_context = (void *)response;
2458 1 : responder_context += sizeof(spdm_measurements_response_t) + SPDM_NONCE_SIZE + sizeof(uint16_t);
2459 1 : assert_memory_equal((void *)requester_context, responder_context, SPDM_REQ_CONTEXT_SIZE);
2460 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2461 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
2462 : m_libspdm_get_measurements_request17_size +
2463 : sizeof(spdm_measurements_response_t) +
2464 : SPDM_NONCE_SIZE +
2465 : sizeof(uint16_t) +
2466 : SPDM_REQ_CONTEXT_SIZE);
2467 : #endif
2468 1 : }
2469 :
2470 : /**
2471 : * Test 36: The key usage bit mask is not set, the SlotID fields in GET_MEASUREMENTS and MEASUREMENTS shall not specify this certificate slot
2472 : * Expected Behavior: get a SPDM_ERROR_CODE_INVALID_REQUEST return code
2473 : **/
2474 1 : static void rsp_measurements_case36(void **state)
2475 : {
2476 : libspdm_return_t status;
2477 : libspdm_test_context_t *spdm_test_context;
2478 : libspdm_context_t *spdm_context;
2479 : size_t response_size;
2480 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
2481 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2482 : spdm_get_measurements_request_t *spdm_request;
2483 : spdm_measurements_response_t *spdm_response;
2484 : uint8_t *requester_context;
2485 : uint8_t slot_id;
2486 : void *data;
2487 : size_t data_size;
2488 : size_t request_size;
2489 :
2490 1 : spdm_test_context = *state;
2491 1 : spdm_context = spdm_test_context->spdm_context;
2492 1 : spdm_test_context->case_id = 36;
2493 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
2494 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2495 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2496 1 : spdm_context->local_context.capability.flags |=
2497 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2498 1 : spdm_context->local_context.capability.flags |=
2499 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PUB_KEY_ID_CAP;
2500 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2501 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2502 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2503 : m_libspdm_use_measurement_hash_algo;
2504 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2505 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2506 1 : spdm_context->connection_info.multi_key_conn_rsp = true;
2507 1 : libspdm_reset_message_m(spdm_context, NULL);
2508 :
2509 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2510 : m_libspdm_use_asym_algo, &data,
2511 : &data_size, NULL, NULL)) {
2512 0 : return;
2513 : }
2514 9 : for (int i = 0; i < SPDM_MAX_SLOT_COUNT; i++) {
2515 8 : spdm_context->local_context.local_cert_chain_provision_size[i] = data_size;
2516 8 : spdm_context->local_context.local_cert_chain_provision[i] = data;
2517 : }
2518 :
2519 1 : spdm_request = (void *)request;
2520 1 : spdm_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
2521 1 : spdm_request->header.request_response_code = SPDM_GET_MEASUREMENTS;
2522 1 : spdm_request->header.param1 = SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
2523 1 : spdm_request->header.param2 = 1;
2524 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, spdm_request->nonce);
2525 : /* If set, the SlotID fields in GET_MEASUREMENTS and MEASUREMENTS can specify this certificate slot. If not set,
2526 : * the SlotID fields in GET_MEASUREMENTS and MEASUREMENTS shall not specify this certificate slot. */
2527 1 : slot_id = 0;
2528 1 : spdm_request->slot_id_param = slot_id;
2529 1 : spdm_context->local_context.local_key_usage_bit_mask[slot_id] =
2530 : SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE |
2531 : SPDM_KEY_USAGE_BIT_MASK_CHALLENGE_USE;
2532 1 : requester_context = ((uint8_t *)spdm_request) + sizeof(spdm_get_measurements_request_t);
2533 1 : libspdm_set_mem(requester_context, SPDM_REQ_CONTEXT_SIZE, 0xAA);
2534 1 : request_size = sizeof(spdm_get_measurements_request_t) + SPDM_REQ_CONTEXT_SIZE;
2535 :
2536 1 : response_size = sizeof(response);
2537 1 : status = libspdm_get_response_measurements(
2538 : spdm_context, request_size,
2539 : (void *)spdm_request, &response_size, response);
2540 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2541 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
2542 1 : spdm_response = (void *)response;
2543 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
2544 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
2545 1 : assert_int_equal(spdm_response->header.param2, 0);
2546 : }
2547 :
2548 1 : int libspdm_rsp_measurements_test(void)
2549 : {
2550 1 : m_libspdm_get_measurements_request11.slot_id_param = SPDM_MAX_SLOT_COUNT - 1;
2551 1 : m_libspdm_get_measurements_request12.slot_id_param = SPDM_MAX_SLOT_COUNT + 1;
2552 :
2553 1 : const struct CMUnitTest test_cases[] = {
2554 : /* Success Case to get measurement number without signature*/
2555 : cmocka_unit_test(rsp_measurements_case1),
2556 : /* Can be populated with new test.*/
2557 : cmocka_unit_test(rsp_measurements_case2),
2558 : /* response_state: SPDM_RESPONSE_STATE_BUSY*/
2559 : cmocka_unit_test(rsp_measurements_case3),
2560 : /* response_state: SPDM_RESPONSE_STATE_NEED_RESYNC*/
2561 : cmocka_unit_test(rsp_measurements_case4),
2562 : #if LIBSPDM_RESPOND_IF_READY_SUPPORT
2563 : /* response_state: SPDM_RESPONSE_STATE_NOT_READY*/
2564 : cmocka_unit_test(rsp_measurements_case5),
2565 : #endif /* LIBSPDM_RESPOND_IF_READY_SUPPORT */
2566 : /* connection_state Check*/
2567 : cmocka_unit_test(rsp_measurements_case6),
2568 : /* Success Case to get measurement number with signature*/
2569 : cmocka_unit_test(rsp_measurements_case7),
2570 : /* Success Case to get one measurement with signature*/
2571 : cmocka_unit_test(rsp_measurements_case8),
2572 : /* Bad request size to get one measurement with signature*/
2573 : cmocka_unit_test(rsp_measurements_case9),
2574 : /* Success Case to get one measurement without signature*/
2575 : cmocka_unit_test(rsp_measurements_case10),
2576 : /* Success Case to get all measurements with signature*/
2577 : cmocka_unit_test(rsp_measurements_case11),
2578 : /* Success Case to get all measurements without signature*/
2579 : cmocka_unit_test(rsp_measurements_case12),
2580 : /* Can be populated with new test.*/
2581 : cmocka_unit_test(rsp_measurements_case13),
2582 : /* Error Case: sig required, but no nonce and/or SlotID*/
2583 : cmocka_unit_test(rsp_measurements_case14),
2584 : /* Error Case: sig required, but meas_cap = 01b (including nonce and SlotId on request)*/
2585 : cmocka_unit_test(rsp_measurements_case15),
2586 : /* Error Case: sig required, but meas_cap = 01b (not including nonce and SlotId on request)*/
2587 : cmocka_unit_test(rsp_measurements_case16),
2588 : /* Error Case: meas_cap = 00b*/
2589 : cmocka_unit_test(rsp_measurements_case17),
2590 : /* Success Case: SlotId different from default*/
2591 : cmocka_unit_test(rsp_measurements_case18),
2592 : /* Bad SlotId parameter (>= SPDM_MAX_SLOT_COUNT)*/
2593 : cmocka_unit_test(rsp_measurements_case19),
2594 : /* Error Case: request a measurement out of bounds*/
2595 : cmocka_unit_test(rsp_measurements_case21),
2596 : /* Large number of requests before requiring a signature*/
2597 : cmocka_unit_test(rsp_measurements_case22),
2598 : /* Successful response to get a session based measurement with signature*/
2599 : cmocka_unit_test(rsp_measurements_case23),
2600 : /* Buffer verification */
2601 : cmocka_unit_test(rsp_measurements_case24),
2602 : /* Success Case V1.2 to get one measurement without signature*/
2603 : cmocka_unit_test(rsp_measurements_case25),
2604 : /* Successful response V1.2 to get one measurement with signature and without opqaue data*/
2605 : cmocka_unit_test(rsp_measurements_case26),
2606 : /* Successful response V1.2 to get one measurement with signature and with opqaue data*/
2607 : cmocka_unit_test(rsp_measurements_case27),
2608 : /* Success Case to get measurement with signature using slot_id 0xFF */
2609 : cmocka_unit_test(rsp_measurements_case28),
2610 : /* Error Case: Big Endian Signature. Little Endian Verify */
2611 : cmocka_unit_test(rsp_measurements_case29),
2612 : /* Success Case: Big Endian Signature. Big Endian Verify */
2613 : cmocka_unit_test(rsp_measurements_case30),
2614 : /* Success Case: Big Endian Signature. Big or Little Endian Verify */
2615 : cmocka_unit_test(rsp_measurements_case31),
2616 : /* Success Case: Little Endian Signature. Little Endian Verify */
2617 : cmocka_unit_test(rsp_measurements_case32),
2618 : /* Error Case: Little Endian Signature. Big Endian Verify */
2619 : cmocka_unit_test(rsp_measurements_case33),
2620 : /* Success Case: Little Endian Signature. Big or Little Endian Verify */
2621 : cmocka_unit_test(rsp_measurements_case34),
2622 : /* Success Case: V1.3 get a correct context field */
2623 : cmocka_unit_test(rsp_measurements_case35),
2624 : /* The key usage bit mask is not set, failed Case*/
2625 : cmocka_unit_test(rsp_measurements_case36),
2626 : };
2627 :
2628 1 : libspdm_test_context_t test_context = {
2629 : LIBSPDM_TEST_CONTEXT_VERSION,
2630 : false,
2631 : };
2632 :
2633 1 : libspdm_setup_test_context(&test_context);
2634 :
2635 1 : return cmocka_run_group_tests(test_cases,
2636 : libspdm_unit_test_group_setup,
2637 : libspdm_unit_test_group_teardown);
2638 : }
2639 :
2640 : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP*/
|
