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