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