Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2026 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : #include "spdm_unit_test.h"
8 : #include "internal/libspdm_responder_lib.h"
9 : #include "internal/libspdm_requester_lib.h"
10 :
11 : #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
12 :
13 79 : void spdm_meas_log_reset_callback (
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 : NULL,
1723 1 : spdm_context->connection_info.version,
1724 1 : spdm_context->connection_info.algorithm.measurement_spec,
1725 : spdm_context->connection_info.algorithm.measurement_hash_algo,
1726 1 : m_libspdm_get_measurements_request15.header.param2,
1727 1 : m_libspdm_get_measurements_request15.header.param1,
1728 : 0,
1729 : NULL,
1730 : &content_changed,
1731 : &measurements_count,
1732 : expect_measurement_record_data,
1733 : &expect_measurement_record_data_length);
1734 :
1735 1 : libspdm_measurement_opaque_data(
1736 : spdm_context,
1737 : NULL,
1738 1 : spdm_context->connection_info.version,
1739 1 : spdm_context->connection_info.algorithm.measurement_spec,
1740 : spdm_context->connection_info.algorithm.measurement_hash_algo,
1741 1 : m_libspdm_get_measurements_request15.header.param2,
1742 1 : m_libspdm_get_measurements_request15.header.param1,
1743 : 0,
1744 : NULL,
1745 : expect_opaque_data,
1746 : &expect_opaque_data_size);
1747 :
1748 1 : measurement_record_data = (uint8_t *)response + sizeof(spdm_measurements_response_t);
1749 1 : opaque_data_size =
1750 : (uint16_t *)(measurement_record_data + sizeof(spdm_measurement_block_dmtf_t) +
1751 1 : libspdm_get_measurement_hash_size(
1752 1 : m_libspdm_use_measurement_hash_algo) +
1753 : SPDM_NONCE_SIZE);
1754 1 : opaque_data = (uint8_t *)opaque_data_size + sizeof(uint16_t);
1755 :
1756 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
1757 :
1758 1 : assert_int_equal(measurement_record_data_length, expect_measurement_record_data_length );
1759 1 : assert_memory_equal(measurement_record_data, expect_measurement_record_data,
1760 : expect_measurement_record_data_length);
1761 1 : assert_int_equal(*opaque_data_size, libspdm_secret_lib_meas_opaque_data_size);
1762 1 : assert_memory_equal(opaque_data, expect_opaque_data, libspdm_secret_lib_meas_opaque_data_size);
1763 :
1764 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1765 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1766 : #endif
1767 1 : assert_int_equal(spdm_response->header.param2, m_libspdm_get_measurements_request15.slot_id_param|
1768 : (SPDM_MEASUREMENTS_RESPONSE_CONTENT_NO_CHANGE_DETECTED &
1769 : SPDM_MEASUREMENTS_RESPONSE_CONTENT_CHANGE_MASK));
1770 :
1771 1 : free(data);
1772 1 : }
1773 :
1774 : /**
1775 : * Test 28: Successful response to get all measurements with signature using slot_id 0xFF
1776 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, empty transcript.message_m, and correct response message size and fields
1777 : **/
1778 1 : static void rsp_measurements_case28(void **state)
1779 : {
1780 : libspdm_return_t status;
1781 : libspdm_test_context_t *spdm_test_context;
1782 : libspdm_context_t *spdm_context;
1783 : size_t response_size;
1784 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1785 : spdm_measurements_response_t *spdm_response;
1786 : void *data;
1787 : size_t data_size;
1788 : size_t measurment_sig_size;
1789 :
1790 1 : spdm_test_context = *state;
1791 1 : spdm_context = spdm_test_context->spdm_context;
1792 1 : spdm_test_context->case_id = 0x1C;
1793 1 : spdm_context->connection_info.connection_state =
1794 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1795 1 : spdm_context->local_context.capability.flags |=
1796 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1797 1 : spdm_context->local_context.capability.flags |=
1798 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PUB_KEY_ID_CAP;
1799 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1800 : m_libspdm_use_hash_algo;
1801 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1802 : m_libspdm_use_asym_algo;
1803 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1804 : m_libspdm_use_measurement_hash_algo;
1805 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1806 : m_libspdm_use_hash_algo;
1807 1 : spdm_context->connection_info.algorithm.measurement_spec =
1808 : m_libspdm_use_measurement_spec;
1809 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1810 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1811 1 : libspdm_reset_message_m(spdm_context, NULL);
1812 :
1813 : /*opaque data*/
1814 1 : libspdm_secret_lib_meas_opaque_data_size = 0x20;
1815 :
1816 1 : libspdm_read_responder_public_key(m_libspdm_use_asym_algo, &data, &data_size);
1817 1 : spdm_context->local_context.local_public_key_provision = data;
1818 1 : spdm_context->local_context.local_public_key_provision_size = data_size;
1819 :
1820 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) +
1821 1 : libspdm_secret_lib_meas_opaque_data_size +
1822 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1823 1 : response_size = sizeof(response);
1824 1 : libspdm_get_random_number(SPDM_NONCE_SIZE,
1825 : m_libspdm_get_measurements_request16.nonce);
1826 1 : m_libspdm_get_measurements_request16.slot_id_param = 0xF;
1827 1 : status = libspdm_get_response_measurements(
1828 : spdm_context, m_libspdm_get_measurements_request16_size,
1829 : &m_libspdm_get_measurements_request16, &response_size, response);
1830 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1831 1 : assert_int_equal(response_size,
1832 : sizeof(spdm_measurements_response_t) + sizeof(spdm_measurement_block_dmtf_t) +
1833 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo) +
1834 : measurment_sig_size);
1835 1 : spdm_response = (void *)response;
1836 1 : assert_int_equal(spdm_response->header.request_response_code,
1837 : SPDM_MEASUREMENTS);
1838 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1839 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1840 : #endif
1841 1 : assert_int_equal(spdm_response->header.param2,
1842 : m_libspdm_get_measurements_request16.slot_id_param |
1843 : (SPDM_MEASUREMENTS_RESPONSE_CONTENT_NO_CHANGE_DETECTED &
1844 : SPDM_MEASUREMENTS_RESPONSE_CONTENT_CHANGE_MASK));
1845 :
1846 1 : free(data);
1847 1 : }
1848 :
1849 : /**
1850 : * Test 29: Based of Test Case 7 Successful response to get a number of measurements
1851 : * with signature.
1852 : * Signature test with signing in big endian but verification in little endian.
1853 : *
1854 : * Expected Behavior: Failing signature verification
1855 : **/
1856 1 : static void rsp_measurements_case29(void** state)
1857 : {
1858 : libspdm_return_t status;
1859 : libspdm_test_context_t* spdm_test_context;
1860 : libspdm_context_t* spdm_context;
1861 : size_t response_size;
1862 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1863 : spdm_measurements_response_t* spdm_response;
1864 : size_t measurment_sig_size;
1865 :
1866 : bool result;
1867 : uint32_t measurement_record_data_length;
1868 : uint8_t* measurement_record_data;
1869 : uint8_t* ptr;
1870 : uint16_t opaque_length;
1871 : void* signature;
1872 : size_t signature_size;
1873 : libspdm_session_info_t* session_info;
1874 : void* data;
1875 : size_t data_size;
1876 : void* hash;
1877 : size_t hash_size;
1878 :
1879 1 : spdm_test_context = *state;
1880 1 : spdm_context = spdm_test_context->spdm_context;
1881 1 : spdm_test_context->case_id = 29;
1882 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1883 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1884 1 : spdm_context->connection_info.connection_state =
1885 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1886 1 : spdm_context->local_context.capability.flags |=
1887 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
1888 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1889 : m_libspdm_use_hash_algo;
1890 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1891 : m_libspdm_use_asym_algo;
1892 1 : spdm_context->connection_info.algorithm.measurement_spec =
1893 : m_libspdm_use_measurement_spec;
1894 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1895 : m_libspdm_use_measurement_hash_algo;
1896 1 : spdm_context->spdm_10_11_verify_signature_endian =
1897 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_LITTLE_ONLY;
1898 :
1899 1 : libspdm_reset_message_m(spdm_context, NULL);
1900 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
1901 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1902 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1903 :
1904 1 : response_size = sizeof(response);
1905 1 : libspdm_get_random_number(SPDM_NONCE_SIZE,
1906 : m_libspdm_get_measurements_request5.nonce);
1907 1 : status = libspdm_get_response_measurements(
1908 : spdm_context, m_libspdm_get_measurements_request5_size,
1909 : &m_libspdm_get_measurements_request5, &response_size, response);
1910 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1911 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) +
1912 : measurment_sig_size);
1913 1 : spdm_response = (void*)response;
1914 1 : assert_int_equal(spdm_response->header.request_response_code,
1915 : SPDM_MEASUREMENTS);
1916 1 : assert_int_equal(spdm_response->header.param1,
1917 : LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
1918 :
1919 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1920 : m_libspdm_use_asym_algo, &data,
1921 : &data_size,
1922 : &hash, &hash_size)) {
1923 0 : assert(false);
1924 : }
1925 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1926 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1927 : data_size;
1928 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1929 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1930 : data, data_size);
1931 : #else
1932 1 : libspdm_hash_all(
1933 : spdm_context->connection_info.algorithm.base_hash_algo,
1934 : data, data_size,
1935 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
1936 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
1937 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
1938 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
1939 : spdm_context->connection_info.algorithm.base_hash_algo,
1940 : spdm_context->connection_info.algorithm.base_asym_algo,
1941 : data, data_size,
1942 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
1943 : #endif
1944 :
1945 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
1946 1 : measurement_record_data = (void*)(spdm_response + 1);
1947 1 : ptr = measurement_record_data + measurement_record_data_length;
1948 1 : ptr += SPDM_NONCE_SIZE;
1949 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
1950 1 : ptr += sizeof(uint16_t);
1951 1 : ptr += opaque_length;
1952 1 : signature = ptr;
1953 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1954 1 : session_info = NULL;
1955 :
1956 1 : status = libspdm_append_message_m(spdm_context, session_info,
1957 : &m_libspdm_get_measurements_request5,
1958 : m_libspdm_get_measurements_request5_size);
1959 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1960 :
1961 1 : status = libspdm_append_message_m(spdm_context, session_info, spdm_response,
1962 : response_size - signature_size);
1963 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1964 :
1965 1 : result = libspdm_verify_measurement_signature(
1966 : spdm_context, session_info, 0, signature, signature_size);
1967 1 : assert_false(result);
1968 :
1969 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1970 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1971 : #endif
1972 1 : }
1973 :
1974 : /**
1975 : * Test 30: Based of Test Case 7 Successful response to get a number of measurements
1976 : * with signature.
1977 : * Signature test with signing in big endian but verification in little endian.
1978 : *
1979 : * Expected Behavior: Failing signature verification
1980 : **/
1981 1 : static void rsp_measurements_case30(void** state)
1982 : {
1983 : libspdm_return_t status;
1984 : libspdm_test_context_t* spdm_test_context;
1985 : libspdm_context_t* spdm_context;
1986 : size_t response_size;
1987 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1988 : spdm_measurements_response_t* spdm_response;
1989 : size_t measurment_sig_size;
1990 :
1991 : bool result;
1992 : uint32_t measurement_record_data_length;
1993 : uint8_t* measurement_record_data;
1994 : uint8_t* ptr;
1995 : uint16_t opaque_length;
1996 : void* signature;
1997 : size_t signature_size;
1998 : libspdm_session_info_t* session_info;
1999 : void* data;
2000 : size_t data_size;
2001 : void* hash;
2002 : size_t hash_size;
2003 :
2004 1 : spdm_test_context = *state;
2005 1 : spdm_context = spdm_test_context->spdm_context;
2006 1 : spdm_test_context->case_id = 30;
2007 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
2008 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2009 1 : spdm_context->connection_info.connection_state =
2010 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2011 1 : spdm_context->local_context.capability.flags |=
2012 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2013 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2014 : m_libspdm_use_hash_algo;
2015 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2016 : m_libspdm_use_asym_algo;
2017 1 : spdm_context->connection_info.algorithm.measurement_spec =
2018 : m_libspdm_use_measurement_spec;
2019 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2020 : m_libspdm_use_measurement_hash_algo;
2021 1 : spdm_context->spdm_10_11_verify_signature_endian =
2022 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_BIG_ONLY;
2023 :
2024 1 : libspdm_reset_message_m(spdm_context, NULL);
2025 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2026 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
2027 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2028 :
2029 1 : response_size = sizeof(response);
2030 1 : libspdm_get_random_number(SPDM_NONCE_SIZE,
2031 : m_libspdm_get_measurements_request5.nonce);
2032 1 : status = libspdm_get_response_measurements(
2033 : spdm_context, m_libspdm_get_measurements_request5_size,
2034 : &m_libspdm_get_measurements_request5, &response_size, response);
2035 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2036 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) +
2037 : measurment_sig_size);
2038 1 : spdm_response = (void*)response;
2039 1 : assert_int_equal(spdm_response->header.request_response_code,
2040 : SPDM_MEASUREMENTS);
2041 1 : assert_int_equal(spdm_response->header.param1,
2042 : LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
2043 :
2044 1 : libspdm_read_responder_public_certificate_chain(
2045 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
2046 : &data, &data_size,
2047 : &hash, &hash_size);
2048 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2049 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2050 : data_size;
2051 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2052 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2053 : data, data_size);
2054 : #else
2055 1 : libspdm_hash_all(
2056 : spdm_context->connection_info.algorithm.base_hash_algo,
2057 : data, data_size,
2058 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
2059 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2060 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2061 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2062 : spdm_context->connection_info.algorithm.base_hash_algo,
2063 : spdm_context->connection_info.algorithm.base_asym_algo,
2064 : data, data_size,
2065 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2066 : #endif
2067 :
2068 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
2069 1 : measurement_record_data = (void*)(spdm_response + 1);
2070 1 : ptr = measurement_record_data + measurement_record_data_length;
2071 1 : ptr += SPDM_NONCE_SIZE;
2072 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
2073 1 : ptr += sizeof(uint16_t);
2074 1 : ptr += opaque_length;
2075 1 : signature = ptr;
2076 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2077 1 : session_info = NULL;
2078 :
2079 1 : status = libspdm_append_message_m(
2080 : spdm_context, session_info,
2081 : &m_libspdm_get_measurements_request5,
2082 : m_libspdm_get_measurements_request5_size);
2083 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2084 :
2085 1 : status = libspdm_append_message_m(
2086 : spdm_context, session_info, spdm_response,
2087 : response_size - signature_size);
2088 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2089 :
2090 1 : result = libspdm_verify_measurement_signature(
2091 : spdm_context, session_info, 0, signature, signature_size);
2092 1 : assert_true(result);
2093 :
2094 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2095 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2096 : #endif
2097 1 : }
2098 :
2099 : /**
2100 : * Test 31: Based of Test Case 7 Successful response to get a number of measurements
2101 : * with signature.
2102 : * Signature test with signing in big endian but verification in big or little endian.
2103 : *
2104 : * Expected Behavior: Passing signature verification
2105 : **/
2106 1 : static void rsp_measurements_case31(void** state)
2107 : {
2108 : libspdm_return_t status;
2109 : libspdm_test_context_t* spdm_test_context;
2110 : libspdm_context_t* spdm_context;
2111 : size_t response_size;
2112 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2113 : spdm_measurements_response_t* spdm_response;
2114 : size_t measurment_sig_size;
2115 :
2116 : bool result;
2117 : uint32_t measurement_record_data_length;
2118 : uint8_t* measurement_record_data;
2119 : uint8_t* ptr;
2120 : uint16_t opaque_length;
2121 : void* signature;
2122 : size_t signature_size;
2123 : libspdm_session_info_t* session_info;
2124 : void* data;
2125 : size_t data_size;
2126 : void* hash;
2127 : size_t hash_size;
2128 :
2129 1 : spdm_test_context = *state;
2130 1 : spdm_context = spdm_test_context->spdm_context;
2131 1 : spdm_test_context->case_id = 31;
2132 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
2133 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2134 1 : spdm_context->connection_info.connection_state =
2135 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2136 1 : spdm_context->local_context.capability.flags |=
2137 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2138 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2139 : m_libspdm_use_hash_algo;
2140 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2141 : m_libspdm_use_asym_algo;
2142 1 : spdm_context->connection_info.algorithm.measurement_spec =
2143 : m_libspdm_use_measurement_spec;
2144 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2145 : m_libspdm_use_measurement_hash_algo;
2146 1 : spdm_context->spdm_10_11_verify_signature_endian =
2147 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_BIG_OR_LITTLE;
2148 :
2149 1 : libspdm_reset_message_m(spdm_context, NULL);
2150 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2151 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
2152 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2153 :
2154 1 : response_size = sizeof(response);
2155 1 : libspdm_get_random_number(SPDM_NONCE_SIZE,
2156 : m_libspdm_get_measurements_request5.nonce);
2157 1 : status = libspdm_get_response_measurements(
2158 : spdm_context, m_libspdm_get_measurements_request5_size,
2159 : &m_libspdm_get_measurements_request5, &response_size, response);
2160 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2161 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) +
2162 : measurment_sig_size);
2163 1 : spdm_response = (void*)response;
2164 1 : assert_int_equal(spdm_response->header.request_response_code,
2165 : SPDM_MEASUREMENTS);
2166 1 : assert_int_equal(spdm_response->header.param1,
2167 : LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
2168 :
2169 1 : libspdm_read_responder_public_certificate_chain(
2170 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
2171 : &data, &data_size,
2172 : &hash, &hash_size);
2173 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2174 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2175 : data_size;
2176 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2177 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2178 : data, data_size);
2179 : #else
2180 1 : libspdm_hash_all(
2181 : spdm_context->connection_info.algorithm.base_hash_algo,
2182 : data, data_size,
2183 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
2184 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2185 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2186 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2187 : spdm_context->connection_info.algorithm.base_hash_algo,
2188 : spdm_context->connection_info.algorithm.base_asym_algo,
2189 : data, data_size,
2190 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2191 : #endif
2192 :
2193 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
2194 1 : measurement_record_data = (void*)(spdm_response + 1);
2195 1 : ptr = measurement_record_data + measurement_record_data_length;
2196 1 : ptr += SPDM_NONCE_SIZE;
2197 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
2198 1 : ptr += sizeof(uint16_t);
2199 1 : ptr += opaque_length;
2200 1 : signature = ptr;
2201 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2202 1 : session_info = NULL;
2203 :
2204 1 : status = libspdm_append_message_m(
2205 : spdm_context, session_info,
2206 : &m_libspdm_get_measurements_request5,
2207 : m_libspdm_get_measurements_request5_size);
2208 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2209 :
2210 1 : status = libspdm_append_message_m(
2211 : spdm_context, session_info, spdm_response,
2212 : response_size - signature_size);
2213 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2214 :
2215 1 : result = libspdm_verify_measurement_signature(
2216 : spdm_context, session_info, 0, signature, signature_size);
2217 1 : assert_true(result);
2218 :
2219 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2220 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2221 : #endif
2222 1 : }
2223 :
2224 : /**
2225 : * Test 32: Based of Test Case 7 Successful response to get a number of measurements
2226 : * with signature.
2227 : * Signature test with signing in little endian but verification in little endian.
2228 : *
2229 : * Expected Behavior: Failing signature verification
2230 : **/
2231 1 : static void rsp_measurements_case32(void** state)
2232 : {
2233 : libspdm_return_t status;
2234 : libspdm_test_context_t* spdm_test_context;
2235 : libspdm_context_t* spdm_context;
2236 : size_t response_size;
2237 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2238 : spdm_measurements_response_t* spdm_response;
2239 : size_t measurment_sig_size;
2240 :
2241 : bool result;
2242 : uint32_t measurement_record_data_length;
2243 : uint8_t* measurement_record_data;
2244 : uint8_t* ptr;
2245 : uint16_t opaque_length;
2246 : void* signature;
2247 : size_t signature_size;
2248 : libspdm_session_info_t* session_info;
2249 : void* data;
2250 : size_t data_size;
2251 : void* hash;
2252 : size_t hash_size;
2253 :
2254 1 : spdm_test_context = *state;
2255 1 : spdm_context = spdm_test_context->spdm_context;
2256 1 : spdm_test_context->case_id = 32;
2257 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
2258 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2259 1 : spdm_context->connection_info.connection_state =
2260 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2261 1 : spdm_context->local_context.capability.flags |=
2262 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2263 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2264 : m_libspdm_use_hash_algo;
2265 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2266 : m_libspdm_use_asym_algo;
2267 1 : spdm_context->connection_info.algorithm.measurement_spec =
2268 : m_libspdm_use_measurement_spec;
2269 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2270 : m_libspdm_use_measurement_hash_algo;
2271 1 : spdm_context->spdm_10_11_verify_signature_endian =
2272 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_LITTLE_ONLY;
2273 :
2274 1 : libspdm_reset_message_m(spdm_context, NULL);
2275 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2276 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
2277 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2278 :
2279 1 : response_size = sizeof(response);
2280 1 : libspdm_get_random_number(SPDM_NONCE_SIZE,
2281 : m_libspdm_get_measurements_request5.nonce);
2282 1 : status = libspdm_get_response_measurements(
2283 : spdm_context, m_libspdm_get_measurements_request5_size,
2284 : &m_libspdm_get_measurements_request5, &response_size, response);
2285 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2286 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) +
2287 : measurment_sig_size);
2288 1 : spdm_response = (void*)response;
2289 1 : assert_int_equal(spdm_response->header.request_response_code,
2290 : SPDM_MEASUREMENTS);
2291 1 : assert_int_equal(spdm_response->header.param1,
2292 : LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
2293 :
2294 1 : libspdm_read_responder_public_certificate_chain(
2295 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
2296 : &data, &data_size,
2297 : &hash, &hash_size);
2298 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2299 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2300 : data_size;
2301 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2302 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2303 : data, data_size);
2304 : #else
2305 1 : libspdm_hash_all(
2306 : spdm_context->connection_info.algorithm.base_hash_algo,
2307 : data, data_size,
2308 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
2309 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2310 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2311 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2312 : spdm_context->connection_info.algorithm.base_hash_algo,
2313 : spdm_context->connection_info.algorithm.base_asym_algo,
2314 : data, data_size,
2315 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2316 : #endif
2317 :
2318 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
2319 1 : measurement_record_data = (void*)(spdm_response + 1);
2320 1 : ptr = measurement_record_data + measurement_record_data_length;
2321 1 : ptr += SPDM_NONCE_SIZE;
2322 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
2323 1 : ptr += sizeof(uint16_t);
2324 1 : ptr += opaque_length;
2325 1 : signature = ptr;
2326 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2327 :
2328 1 : libspdm_copy_signature_swap_endian(
2329 : m_libspdm_use_asym_algo,
2330 : signature, signature_size, signature, signature_size);
2331 :
2332 1 : session_info = NULL;
2333 :
2334 1 : status = libspdm_append_message_m(
2335 : spdm_context, session_info,
2336 : &m_libspdm_get_measurements_request5,
2337 : m_libspdm_get_measurements_request5_size);
2338 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2339 :
2340 1 : status = libspdm_append_message_m(
2341 : spdm_context, session_info, spdm_response,
2342 : response_size - signature_size);
2343 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2344 :
2345 1 : result = libspdm_verify_measurement_signature(
2346 : spdm_context, session_info, 0, signature, signature_size);
2347 1 : assert_true(result);
2348 :
2349 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2350 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2351 : #endif
2352 1 : }
2353 :
2354 : /**
2355 : * Test 33: Based of Test Case 7 Successful response to get a number of measurements
2356 : * with signature.
2357 : * Signature test with signing in little endian but verification in big endian.
2358 : *
2359 : * Expected Behavior: Failing signature verification
2360 : **/
2361 1 : static void rsp_measurements_case33(void** state)
2362 : {
2363 : libspdm_return_t status;
2364 : libspdm_test_context_t* spdm_test_context;
2365 : libspdm_context_t* spdm_context;
2366 : size_t response_size;
2367 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2368 : spdm_measurements_response_t* spdm_response;
2369 : size_t measurment_sig_size;
2370 :
2371 : bool result;
2372 : uint32_t measurement_record_data_length;
2373 : uint8_t* measurement_record_data;
2374 : uint8_t* ptr;
2375 : uint16_t opaque_length;
2376 : void* signature;
2377 : size_t signature_size;
2378 : libspdm_session_info_t* session_info;
2379 : void* data;
2380 : size_t data_size;
2381 : void* hash;
2382 : size_t hash_size;
2383 :
2384 1 : spdm_test_context = *state;
2385 1 : spdm_context = spdm_test_context->spdm_context;
2386 1 : spdm_test_context->case_id = 33;
2387 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
2388 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2389 1 : spdm_context->connection_info.connection_state =
2390 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2391 1 : spdm_context->local_context.capability.flags |=
2392 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2393 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2394 : m_libspdm_use_hash_algo;
2395 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2396 : m_libspdm_use_asym_algo;
2397 1 : spdm_context->connection_info.algorithm.measurement_spec =
2398 : m_libspdm_use_measurement_spec;
2399 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2400 : m_libspdm_use_measurement_hash_algo;
2401 1 : spdm_context->spdm_10_11_verify_signature_endian =
2402 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_BIG_ONLY;
2403 :
2404 1 : libspdm_reset_message_m(spdm_context, NULL);
2405 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2406 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
2407 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2408 :
2409 1 : response_size = sizeof(response);
2410 1 : libspdm_get_random_number(SPDM_NONCE_SIZE,
2411 : m_libspdm_get_measurements_request5.nonce);
2412 1 : status = libspdm_get_response_measurements(
2413 : spdm_context, m_libspdm_get_measurements_request5_size,
2414 : &m_libspdm_get_measurements_request5, &response_size, response);
2415 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2416 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) +
2417 : measurment_sig_size);
2418 1 : spdm_response = (void*)response;
2419 1 : assert_int_equal(spdm_response->header.request_response_code,
2420 : SPDM_MEASUREMENTS);
2421 1 : assert_int_equal(spdm_response->header.param1,
2422 : LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
2423 :
2424 1 : libspdm_read_responder_public_certificate_chain(
2425 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
2426 : &data, &data_size,
2427 : &hash, &hash_size);
2428 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2429 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2430 : data_size;
2431 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2432 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2433 : data, data_size);
2434 : #else
2435 1 : libspdm_hash_all(
2436 : spdm_context->connection_info.algorithm.base_hash_algo,
2437 : data, data_size,
2438 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
2439 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2440 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2441 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2442 : spdm_context->connection_info.algorithm.base_hash_algo,
2443 : spdm_context->connection_info.algorithm.base_asym_algo,
2444 : data, data_size,
2445 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2446 : #endif
2447 :
2448 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
2449 1 : measurement_record_data = (void*)(spdm_response + 1);
2450 1 : ptr = measurement_record_data + measurement_record_data_length;
2451 1 : ptr += SPDM_NONCE_SIZE;
2452 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
2453 1 : ptr += sizeof(uint16_t);
2454 1 : ptr += opaque_length;
2455 1 : signature = ptr;
2456 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2457 :
2458 1 : libspdm_copy_signature_swap_endian(
2459 : m_libspdm_use_asym_algo,
2460 : signature, signature_size, signature, signature_size);
2461 :
2462 1 : session_info = NULL;
2463 :
2464 1 : status = libspdm_append_message_m(
2465 : spdm_context, session_info,
2466 : &m_libspdm_get_measurements_request5,
2467 : m_libspdm_get_measurements_request5_size);
2468 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2469 :
2470 1 : status = libspdm_append_message_m(
2471 : spdm_context, session_info, spdm_response,
2472 : response_size - signature_size);
2473 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2474 :
2475 1 : result = libspdm_verify_measurement_signature(
2476 : spdm_context, session_info, 0, signature, signature_size);
2477 1 : assert_false(result);
2478 :
2479 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2480 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2481 : #endif
2482 1 : }
2483 :
2484 :
2485 : /**
2486 : * Test 34: Based of Test Case 7 Successful response to get a number of measurements
2487 : * with signature.
2488 : * Signature test with signing in little endian but verification in big or little endian.
2489 : *
2490 : * Expected Behavior: Passing signature verification
2491 : **/
2492 1 : static void rsp_measurements_case34(void** state)
2493 : {
2494 : libspdm_return_t status;
2495 : libspdm_test_context_t* spdm_test_context;
2496 : libspdm_context_t* spdm_context;
2497 : size_t response_size;
2498 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2499 : spdm_measurements_response_t* spdm_response;
2500 : size_t measurment_sig_size;
2501 :
2502 : bool result;
2503 : uint32_t measurement_record_data_length;
2504 : uint8_t* measurement_record_data;
2505 : uint8_t* ptr;
2506 : uint16_t opaque_length;
2507 : void* signature;
2508 : size_t signature_size;
2509 : libspdm_session_info_t* session_info;
2510 : void* data;
2511 : size_t data_size;
2512 : void* hash;
2513 : size_t hash_size;
2514 :
2515 1 : spdm_test_context = *state;
2516 1 : spdm_context = spdm_test_context->spdm_context;
2517 1 : spdm_test_context->case_id = 34;
2518 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
2519 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2520 1 : spdm_context->connection_info.connection_state =
2521 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2522 1 : spdm_context->local_context.capability.flags |=
2523 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2524 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2525 : m_libspdm_use_hash_algo;
2526 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2527 : m_libspdm_use_asym_algo;
2528 1 : spdm_context->connection_info.algorithm.measurement_spec =
2529 : m_libspdm_use_measurement_spec;
2530 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2531 : m_libspdm_use_measurement_hash_algo;
2532 1 : spdm_context->spdm_10_11_verify_signature_endian =
2533 : LIBSPDM_SPDM_10_11_VERIFY_SIGNATURE_ENDIAN_BIG_OR_LITTLE;
2534 :
2535 1 : libspdm_reset_message_m(spdm_context, NULL);
2536 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2537 1 : measurment_sig_size = SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
2538 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2539 :
2540 1 : response_size = sizeof(response);
2541 1 : libspdm_get_random_number(SPDM_NONCE_SIZE,
2542 : m_libspdm_get_measurements_request5.nonce);
2543 1 : status = libspdm_get_response_measurements(
2544 : spdm_context, m_libspdm_get_measurements_request5_size,
2545 : &m_libspdm_get_measurements_request5, &response_size, response);
2546 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2547 1 : assert_int_equal(response_size, sizeof(spdm_measurements_response_t) +
2548 : measurment_sig_size);
2549 1 : spdm_response = (void*)response;
2550 1 : assert_int_equal(spdm_response->header.request_response_code,
2551 : SPDM_MEASUREMENTS);
2552 1 : assert_int_equal(spdm_response->header.param1,
2553 : LIBSPDM_MEASUREMENT_BLOCK_NUMBER);
2554 :
2555 1 : libspdm_read_responder_public_certificate_chain(
2556 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
2557 : &data, &data_size,
2558 : &hash, &hash_size);
2559 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2560 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2561 : data_size;
2562 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2563 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2564 : data, data_size);
2565 : #else
2566 1 : libspdm_hash_all(
2567 : spdm_context->connection_info.algorithm.base_hash_algo,
2568 : data, data_size,
2569 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
2570 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2571 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2572 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2573 : spdm_context->connection_info.algorithm.base_hash_algo,
2574 : spdm_context->connection_info.algorithm.base_asym_algo,
2575 : data, data_size,
2576 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2577 : #endif
2578 :
2579 1 : measurement_record_data_length = libspdm_read_uint24(spdm_response->measurement_record_length);
2580 1 : measurement_record_data = (void*)(spdm_response + 1);
2581 1 : ptr = measurement_record_data + measurement_record_data_length;
2582 1 : ptr += SPDM_NONCE_SIZE;
2583 1 : opaque_length = libspdm_read_uint16((const uint8_t*)ptr);
2584 1 : ptr += sizeof(uint16_t);
2585 1 : ptr += opaque_length;
2586 1 : signature = ptr;
2587 1 : signature_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2588 1 : libspdm_copy_signature_swap_endian(
2589 : m_libspdm_use_asym_algo,
2590 : signature, signature_size, signature, signature_size);
2591 :
2592 1 : session_info = NULL;
2593 :
2594 1 : status = libspdm_append_message_m(
2595 : spdm_context, session_info,
2596 : &m_libspdm_get_measurements_request5,
2597 : m_libspdm_get_measurements_request5_size);
2598 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2599 :
2600 1 : status = libspdm_append_message_m(
2601 : spdm_context, session_info, spdm_response,
2602 : response_size - signature_size);
2603 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2604 :
2605 1 : result = libspdm_verify_measurement_signature(
2606 : spdm_context, session_info, 0, signature, signature_size);
2607 1 : assert_true(result);
2608 :
2609 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2610 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2611 : #endif
2612 1 : }
2613 :
2614 : /**
2615 : * Test 35: Successful response V1.3 to get a number of measurements without signature
2616 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, correct context field
2617 : **/
2618 1 : static void rsp_measurements_case35(void **state)
2619 : {
2620 : libspdm_return_t status;
2621 : libspdm_test_context_t *spdm_test_context;
2622 : libspdm_context_t *spdm_context;
2623 : size_t response_size;
2624 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2625 : spdm_measurements_response_t *spdm_response;
2626 : uint8_t *requester_context;
2627 : uint8_t *responder_context;
2628 :
2629 1 : spdm_test_context = *state;
2630 1 : spdm_context = spdm_test_context->spdm_context;
2631 1 : spdm_test_context->case_id = 35;
2632 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
2633 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2634 1 : spdm_context->connection_info.connection_state =
2635 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2636 1 : spdm_context->local_context.capability.flags |=
2637 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2638 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2639 : m_libspdm_use_hash_algo;
2640 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2641 : m_libspdm_use_asym_algo;
2642 1 : spdm_context->connection_info.algorithm.measurement_spec =
2643 : m_libspdm_use_measurement_spec;
2644 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2645 : m_libspdm_use_measurement_hash_algo;
2646 1 : libspdm_reset_message_m(spdm_context, NULL);
2647 :
2648 1 : libspdm_secret_lib_meas_opaque_data_size = 0;
2649 :
2650 1 : response_size = sizeof(response);
2651 :
2652 1 : requester_context = ((uint8_t *)&m_libspdm_get_measurements_request17) +
2653 : m_libspdm_get_measurements_request17_size;
2654 1 : libspdm_set_mem(requester_context, SPDM_REQ_CONTEXT_SIZE, 0xAA);
2655 1 : m_libspdm_get_measurements_request17_size += SPDM_REQ_CONTEXT_SIZE;
2656 :
2657 1 : status = libspdm_get_response_measurements(
2658 : spdm_context, m_libspdm_get_measurements_request17_size,
2659 : &m_libspdm_get_measurements_request17, &response_size, response);
2660 :
2661 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2662 1 : assert_int_equal(response_size,
2663 : sizeof(spdm_measurements_response_t) + SPDM_NONCE_SIZE + sizeof(uint16_t) +
2664 : SPDM_REQ_CONTEXT_SIZE);
2665 1 : spdm_response = (void *)response;
2666 1 : assert_int_equal(spdm_response->header.request_response_code,
2667 : SPDM_MEASUREMENTS);
2668 1 : responder_context = (void *)response;
2669 1 : responder_context += sizeof(spdm_measurements_response_t) + SPDM_NONCE_SIZE + sizeof(uint16_t);
2670 1 : assert_memory_equal((void *)requester_context, responder_context, SPDM_REQ_CONTEXT_SIZE);
2671 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2672 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
2673 : m_libspdm_get_measurements_request17_size +
2674 : sizeof(spdm_measurements_response_t) +
2675 : SPDM_NONCE_SIZE +
2676 : sizeof(uint16_t) +
2677 : SPDM_REQ_CONTEXT_SIZE);
2678 : #endif
2679 1 : }
2680 :
2681 : /**
2682 : * Test 36: The key usage bit mask is not set, the SlotID fields in GET_MEASUREMENTS and MEASUREMENTS shall not specify this certificate slot
2683 : * Expected Behavior: get a SPDM_ERROR_CODE_INVALID_REQUEST return code
2684 : **/
2685 1 : static void rsp_measurements_case36(void **state)
2686 : {
2687 : libspdm_return_t status;
2688 : libspdm_test_context_t *spdm_test_context;
2689 : libspdm_context_t *spdm_context;
2690 : size_t response_size;
2691 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
2692 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2693 : spdm_get_measurements_request_t *spdm_request;
2694 : spdm_measurements_response_t *spdm_response;
2695 : uint8_t *requester_context;
2696 : uint8_t slot_id;
2697 : void *data;
2698 : size_t data_size;
2699 : size_t request_size;
2700 :
2701 1 : spdm_test_context = *state;
2702 1 : spdm_context = spdm_test_context->spdm_context;
2703 1 : spdm_test_context->case_id = 36;
2704 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
2705 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2706 1 : spdm_context->connection_info.connection_state =
2707 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2708 1 : spdm_context->local_context.capability.flags |=
2709 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2710 1 : spdm_context->local_context.capability.flags |=
2711 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PUB_KEY_ID_CAP;
2712 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2713 : m_libspdm_use_hash_algo;
2714 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2715 : m_libspdm_use_asym_algo;
2716 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2717 : m_libspdm_use_measurement_hash_algo;
2718 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2719 : m_libspdm_use_hash_algo;
2720 1 : spdm_context->connection_info.algorithm.measurement_spec =
2721 : m_libspdm_use_measurement_spec;
2722 1 : spdm_context->connection_info.multi_key_conn_rsp = true;
2723 1 : libspdm_reset_message_m(spdm_context, NULL);
2724 :
2725 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2726 : m_libspdm_use_asym_algo, &data,
2727 : &data_size, NULL, NULL);
2728 9 : for (int i = 0; i < SPDM_MAX_SLOT_COUNT; i++) {
2729 8 : spdm_context->local_context.local_cert_chain_provision_size[i] = data_size;
2730 8 : spdm_context->local_context.local_cert_chain_provision[i] = data;
2731 : }
2732 :
2733 1 : spdm_request = (void *)request;
2734 1 : spdm_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
2735 1 : spdm_request->header.request_response_code = SPDM_GET_MEASUREMENTS;
2736 1 : spdm_request->header.param1 = SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
2737 1 : spdm_request->header.param2 = 1;
2738 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, spdm_request->nonce);
2739 : /* If set, the SlotID fields in GET_MEASUREMENTS and MEASUREMENTS can specify this certificate slot. If not set,
2740 : * the SlotID fields in GET_MEASUREMENTS and MEASUREMENTS shall not specify this certificate slot. */
2741 1 : slot_id = 0;
2742 1 : spdm_request->slot_id_param = slot_id;
2743 1 : spdm_context->local_context.local_key_usage_bit_mask[slot_id] =
2744 : SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE |
2745 : SPDM_KEY_USAGE_BIT_MASK_CHALLENGE_USE;
2746 1 : requester_context = ((uint8_t *)spdm_request) + sizeof(spdm_get_measurements_request_t);
2747 1 : libspdm_set_mem(requester_context, SPDM_REQ_CONTEXT_SIZE, 0xAA);
2748 1 : request_size = sizeof(spdm_get_measurements_request_t) + SPDM_REQ_CONTEXT_SIZE;
2749 :
2750 1 : response_size = sizeof(response);
2751 1 : status = libspdm_get_response_measurements(
2752 : spdm_context, request_size,
2753 : (void *)spdm_request, &response_size, response);
2754 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2755 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
2756 1 : spdm_response = (void *)response;
2757 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
2758 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
2759 1 : assert_int_equal(spdm_response->header.param2, 0);
2760 1 : }
2761 :
2762 1 : int libspdm_rsp_measurements_test(void)
2763 : {
2764 1 : m_libspdm_get_measurements_request11.slot_id_param = SPDM_MAX_SLOT_COUNT - 1;
2765 1 : m_libspdm_get_measurements_request12.slot_id_param = SPDM_MAX_SLOT_COUNT + 1;
2766 :
2767 1 : const struct CMUnitTest test_cases[] = {
2768 : /* Success Case to get measurement number without signature*/
2769 : cmocka_unit_test(rsp_measurements_case1),
2770 : /* Can be populated with new test.*/
2771 : cmocka_unit_test(rsp_measurements_case2),
2772 : /* response_state: SPDM_RESPONSE_STATE_BUSY*/
2773 : cmocka_unit_test(rsp_measurements_case3),
2774 : /* response_state: SPDM_RESPONSE_STATE_NEED_RESYNC*/
2775 : cmocka_unit_test(rsp_measurements_case4),
2776 : #if LIBSPDM_RESPOND_IF_READY_SUPPORT
2777 : /* response_state: SPDM_RESPONSE_STATE_NOT_READY*/
2778 : cmocka_unit_test(rsp_measurements_case5),
2779 : #endif /* LIBSPDM_RESPOND_IF_READY_SUPPORT */
2780 : /* connection_state Check*/
2781 : cmocka_unit_test(rsp_measurements_case6),
2782 : /* Success Case to get measurement number with signature*/
2783 : cmocka_unit_test(rsp_measurements_case7),
2784 : /* Success Case to get one measurement with signature*/
2785 : cmocka_unit_test(rsp_measurements_case8),
2786 : /* Bad request size to get one measurement with signature*/
2787 : cmocka_unit_test(rsp_measurements_case9),
2788 : /* Success Case to get one measurement without signature*/
2789 : cmocka_unit_test(rsp_measurements_case10),
2790 : /* Success Case to get all measurements with signature*/
2791 : cmocka_unit_test(rsp_measurements_case11),
2792 : /* Success Case to get all measurements without signature*/
2793 : cmocka_unit_test(rsp_measurements_case12),
2794 : /* Can be populated with new test.*/
2795 : cmocka_unit_test(rsp_measurements_case13),
2796 : /* Error Case: sig required, but no nonce and/or SlotID*/
2797 : cmocka_unit_test(rsp_measurements_case14),
2798 : /* Error Case: sig required, but meas_cap = 01b (including nonce and SlotId on request)*/
2799 : cmocka_unit_test(rsp_measurements_case15),
2800 : /* Error Case: sig required, but meas_cap = 01b (not including nonce and SlotId on request)*/
2801 : cmocka_unit_test(rsp_measurements_case16),
2802 : /* Error Case: meas_cap = 00b*/
2803 : cmocka_unit_test(rsp_measurements_case17),
2804 : /* Success Case: SlotId different from default*/
2805 : cmocka_unit_test(rsp_measurements_case18),
2806 : /* Bad SlotId parameter (>= SPDM_MAX_SLOT_COUNT)*/
2807 : cmocka_unit_test(rsp_measurements_case19),
2808 : /* Error Case: request a measurement out of bounds*/
2809 : cmocka_unit_test(rsp_measurements_case21),
2810 : /* Large number of requests before requiring a signature*/
2811 : cmocka_unit_test(rsp_measurements_case22),
2812 : /* Successful response to get a session based measurement with signature*/
2813 : cmocka_unit_test(rsp_measurements_case23),
2814 : /* Buffer verification */
2815 : cmocka_unit_test(rsp_measurements_case24),
2816 : /* Success Case V1.2 to get one measurement without signature*/
2817 : cmocka_unit_test(rsp_measurements_case25),
2818 : /* Successful response V1.2 to get one measurement with signature and without opqaue data*/
2819 : cmocka_unit_test(rsp_measurements_case26),
2820 : /* Successful response V1.2 to get one measurement with signature and with opqaue data*/
2821 : cmocka_unit_test(rsp_measurements_case27),
2822 : /* Success Case to get measurement with signature using slot_id 0xFF */
2823 : cmocka_unit_test(rsp_measurements_case28),
2824 : /* Error Case: Big Endian Signature. Little Endian Verify */
2825 : cmocka_unit_test(rsp_measurements_case29),
2826 : /* Success Case: Big Endian Signature. Big Endian Verify */
2827 : cmocka_unit_test(rsp_measurements_case30),
2828 : /* Success Case: Big Endian Signature. Big or Little Endian Verify */
2829 : cmocka_unit_test(rsp_measurements_case31),
2830 : /* Success Case: Little Endian Signature. Little Endian Verify */
2831 : cmocka_unit_test(rsp_measurements_case32),
2832 : /* Error Case: Little Endian Signature. Big Endian Verify */
2833 : cmocka_unit_test(rsp_measurements_case33),
2834 : /* Success Case: Little Endian Signature. Big or Little Endian Verify */
2835 : cmocka_unit_test(rsp_measurements_case34),
2836 : /* Success Case: V1.3 get a correct context field */
2837 : cmocka_unit_test(rsp_measurements_case35),
2838 : /* The key usage bit mask is not set, failed Case*/
2839 : cmocka_unit_test(rsp_measurements_case36),
2840 : };
2841 :
2842 1 : libspdm_test_context_t test_context = {
2843 : LIBSPDM_TEST_CONTEXT_VERSION,
2844 : false,
2845 : };
2846 :
2847 1 : libspdm_setup_test_context(&test_context);
2848 :
2849 1 : return cmocka_run_group_tests(test_cases,
2850 : libspdm_unit_test_group_setup,
2851 : libspdm_unit_test_group_teardown);
2852 : }
2853 :
2854 : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP*/
|
