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