Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2025 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : #include "spdm_unit_test.h"
8 : #include "internal/libspdm_requester_lib.h"
9 : #include "internal/libspdm_secured_message_lib.h"
10 :
11 : #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
12 :
13 : #define LIBSPDM_ALTERNATIVE_DEFAULT_SLOT_ID 2
14 : #define LIBSPDM_LARGE_MEASUREMENT_SIZE ((1 << 24) - 1)
15 :
16 : static size_t m_libspdm_local_buffer_size;
17 : static uint8_t m_libspdm_local_buffer[LIBSPDM_MAX_MESSAGE_L1L2_BUFFER_SIZE];
18 :
19 140 : static size_t libspdm_test_get_measurement_request_size(const void *spdm_context,
20 : const void *buffer,
21 : size_t buffer_size)
22 : {
23 : const spdm_get_measurements_request_t *spdm_request;
24 : size_t message_size;
25 :
26 140 : spdm_request = buffer;
27 140 : message_size = sizeof(spdm_message_header_t);
28 140 : if (buffer_size < message_size) {
29 0 : return buffer_size;
30 : }
31 :
32 140 : if (spdm_request->header.request_response_code !=
33 : SPDM_GET_MEASUREMENTS) {
34 1 : return buffer_size;
35 : }
36 :
37 139 : if ((spdm_request->header.param1 &
38 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE) != 0) {
39 30 : if (spdm_request->header.spdm_version >=
40 : SPDM_MESSAGE_VERSION_11) {
41 30 : if (buffer_size <
42 : sizeof(spdm_get_measurements_request_t)) {
43 0 : return buffer_size;
44 : }
45 30 : message_size = sizeof(spdm_get_measurements_request_t);
46 : } else {
47 0 : if (buffer_size <
48 : sizeof(spdm_get_measurements_request_t) -
49 : sizeof(spdm_request->slot_id_param)) {
50 0 : return buffer_size;
51 : }
52 0 : message_size = sizeof(spdm_get_measurements_request_t) -
53 : sizeof(spdm_request->slot_id_param);
54 : }
55 : } else {
56 : /* already checked before if buffer_size < sizeof(spdm_message_header_t)*/
57 109 : message_size = sizeof(spdm_message_header_t);
58 : }
59 :
60 : /* Good message, return actual size*/
61 139 : return message_size;
62 : }
63 :
64 141 : static libspdm_return_t libspdm_requester_get_measurements_test_send_message(
65 : void *spdm_context, size_t request_size, const void *request,
66 : uint64_t timeout)
67 : {
68 : libspdm_test_context_t *spdm_test_context;
69 : size_t header_size;
70 : size_t message_size;
71 : uint32_t *session_id;
72 : libspdm_session_info_t *session_info;
73 : bool is_app_message;
74 : uint8_t *app_message;
75 : size_t app_message_size;
76 : uint8_t message_buffer[LIBSPDM_SENDER_BUFFER_SIZE];
77 :
78 141 : memcpy(message_buffer, request, request_size);
79 :
80 141 : spdm_test_context = libspdm_get_test_context();
81 141 : header_size = sizeof(libspdm_test_message_header_t);
82 141 : switch (spdm_test_context->case_id) {
83 1 : case 0x1:
84 1 : return LIBSPDM_STATUS_SEND_FAIL;
85 0 : case 0x2:
86 0 : m_libspdm_local_buffer_size = 0;
87 0 : message_size = libspdm_test_get_measurement_request_size(
88 : spdm_context, (const uint8_t *)request + header_size,
89 : request_size - header_size);
90 0 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
91 : (const uint8_t *)request + header_size, message_size);
92 0 : m_libspdm_local_buffer_size += message_size;
93 0 : return LIBSPDM_STATUS_SUCCESS;
94 0 : case 0x3:
95 0 : m_libspdm_local_buffer_size = 0;
96 0 : message_size = libspdm_test_get_measurement_request_size(
97 : spdm_context, (const uint8_t *)request + header_size,
98 : request_size - header_size);
99 0 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
100 : (const uint8_t *)request + header_size, message_size);
101 0 : m_libspdm_local_buffer_size += message_size;
102 0 : return LIBSPDM_STATUS_SUCCESS;
103 1 : case 0x4:
104 1 : m_libspdm_local_buffer_size = 0;
105 1 : message_size = libspdm_test_get_measurement_request_size(
106 : spdm_context, (const uint8_t *)request + header_size,
107 : request_size - header_size);
108 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
109 : (const uint8_t *)request + header_size, message_size);
110 1 : m_libspdm_local_buffer_size += message_size;
111 1 : return LIBSPDM_STATUS_SUCCESS;
112 1 : case 0x5:
113 1 : m_libspdm_local_buffer_size = 0;
114 1 : message_size = libspdm_test_get_measurement_request_size(
115 : spdm_context, (const uint8_t *)request + header_size,
116 : request_size - header_size);
117 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
118 : (const uint8_t *)request + header_size, message_size);
119 1 : m_libspdm_local_buffer_size += message_size;
120 1 : return LIBSPDM_STATUS_SUCCESS;
121 0 : case 0x6:
122 0 : m_libspdm_local_buffer_size = 0;
123 0 : message_size = libspdm_test_get_measurement_request_size(
124 : spdm_context, (const uint8_t *)request + header_size,
125 : request_size - header_size);
126 0 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
127 : (const uint8_t *)request + header_size, message_size);
128 0 : m_libspdm_local_buffer_size += message_size;
129 0 : return LIBSPDM_STATUS_SUCCESS;
130 1 : case 0x7:
131 1 : m_libspdm_local_buffer_size = 0;
132 1 : message_size = libspdm_test_get_measurement_request_size(
133 : spdm_context, (const uint8_t *)request + header_size,
134 : request_size - header_size);
135 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
136 : (const uint8_t *)request + header_size, message_size);
137 1 : m_libspdm_local_buffer_size += message_size;
138 1 : return LIBSPDM_STATUS_SUCCESS;
139 2 : case 0x8:
140 2 : m_libspdm_local_buffer_size = 0;
141 2 : message_size = libspdm_test_get_measurement_request_size(
142 : spdm_context, (const uint8_t *)request + header_size,
143 : request_size - header_size);
144 2 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
145 : (const uint8_t *)request + header_size, message_size);
146 2 : m_libspdm_local_buffer_size += message_size;
147 2 : return LIBSPDM_STATUS_SUCCESS;
148 0 : case 0x9:
149 0 : return LIBSPDM_STATUS_SUCCESS;
150 0 : case 0xA:
151 0 : m_libspdm_local_buffer_size = 0;
152 0 : message_size = libspdm_test_get_measurement_request_size(
153 : spdm_context, (const uint8_t *)request + header_size,
154 : request_size - header_size);
155 0 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
156 : (const uint8_t *)request + header_size, message_size);
157 0 : m_libspdm_local_buffer_size += message_size;
158 0 : return LIBSPDM_STATUS_SUCCESS;
159 1 : case 0xB:
160 1 : m_libspdm_local_buffer_size = 0;
161 1 : message_size = libspdm_test_get_measurement_request_size(
162 : spdm_context, (const uint8_t *)request + header_size,
163 : request_size - header_size);
164 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
165 : (const uint8_t *)request + header_size, message_size);
166 1 : m_libspdm_local_buffer_size += message_size;
167 1 : return LIBSPDM_STATUS_SUCCESS;
168 1 : case 0xC:
169 1 : m_libspdm_local_buffer_size = 0;
170 1 : message_size = libspdm_test_get_measurement_request_size(
171 : spdm_context, (const uint8_t *)request + header_size,
172 : request_size - header_size);
173 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
174 : (const uint8_t *)request + header_size, message_size);
175 1 : m_libspdm_local_buffer_size += message_size;
176 1 : return LIBSPDM_STATUS_SUCCESS;
177 1 : case 0xD:
178 1 : m_libspdm_local_buffer_size = 0;
179 1 : message_size = libspdm_test_get_measurement_request_size(
180 : spdm_context, (const uint8_t *)request + header_size,
181 : request_size - header_size);
182 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
183 : (const uint8_t *)request + header_size, message_size);
184 1 : m_libspdm_local_buffer_size += message_size;
185 1 : return LIBSPDM_STATUS_SUCCESS;
186 1 : case 0xE:
187 1 : m_libspdm_local_buffer_size = 0;
188 1 : message_size = libspdm_test_get_measurement_request_size(
189 : spdm_context, (const uint8_t *)request + header_size,
190 : request_size - header_size);
191 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
192 : (const uint8_t *)request + header_size, message_size);
193 1 : m_libspdm_local_buffer_size += message_size;
194 1 : return LIBSPDM_STATUS_SUCCESS;
195 1 : case 0xF:
196 1 : m_libspdm_local_buffer_size = 0;
197 1 : message_size = libspdm_test_get_measurement_request_size(
198 : spdm_context, (const uint8_t *)request + header_size,
199 : request_size - header_size);
200 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
201 : (const uint8_t *)request + header_size, message_size);
202 1 : m_libspdm_local_buffer_size += message_size;
203 1 : return LIBSPDM_STATUS_SUCCESS;
204 1 : case 0x10:
205 1 : m_libspdm_local_buffer_size = 0;
206 1 : message_size = libspdm_test_get_measurement_request_size(
207 : spdm_context, (const uint8_t *)request + header_size,
208 : request_size - header_size);
209 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
210 : (const uint8_t *)request + header_size, message_size);
211 1 : m_libspdm_local_buffer_size += message_size;
212 1 : return LIBSPDM_STATUS_SUCCESS;
213 3 : case 0x11:
214 3 : m_libspdm_local_buffer_size = 0;
215 3 : message_size = libspdm_test_get_measurement_request_size(
216 : spdm_context, (const uint8_t *)request + header_size,
217 : request_size - header_size);
218 3 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
219 : (const uint8_t *)request + header_size, message_size);
220 3 : m_libspdm_local_buffer_size += message_size;
221 3 : return LIBSPDM_STATUS_SUCCESS;
222 0 : case 0x12:
223 0 : m_libspdm_local_buffer_size = 0;
224 0 : message_size = libspdm_test_get_measurement_request_size(
225 : spdm_context, (const uint8_t *)request + header_size,
226 : request_size - header_size);
227 0 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
228 : (const uint8_t *)request + header_size, message_size);
229 0 : m_libspdm_local_buffer_size += message_size;
230 0 : return LIBSPDM_STATUS_SUCCESS;
231 1 : case 0x13:
232 1 : m_libspdm_local_buffer_size = 0;
233 1 : message_size = libspdm_test_get_measurement_request_size(
234 : spdm_context, (const uint8_t *)request + header_size,
235 : request_size - header_size);
236 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
237 : (const uint8_t *)request + header_size, message_size);
238 1 : m_libspdm_local_buffer_size += message_size;
239 1 : return LIBSPDM_STATUS_SUCCESS;
240 1 : case 0x14:
241 1 : m_libspdm_local_buffer_size = 0;
242 1 : message_size = libspdm_test_get_measurement_request_size(
243 : spdm_context, (const uint8_t *)request + header_size,
244 : request_size - header_size);
245 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
246 : (const uint8_t *)request + header_size, message_size);
247 1 : m_libspdm_local_buffer_size += message_size;
248 1 : return LIBSPDM_STATUS_SUCCESS;
249 1 : case 0x15:
250 1 : m_libspdm_local_buffer_size = 0;
251 1 : message_size = libspdm_test_get_measurement_request_size(
252 : spdm_context, (const uint8_t *)request + header_size,
253 : request_size - header_size);
254 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
255 : (const uint8_t *)request + header_size, message_size);
256 1 : m_libspdm_local_buffer_size += message_size;
257 1 : return LIBSPDM_STATUS_SUCCESS;
258 100 : case 0x16:
259 100 : m_libspdm_local_buffer_size = 0;
260 100 : message_size = libspdm_test_get_measurement_request_size(
261 : spdm_context, (const uint8_t *)request + header_size,
262 : request_size - header_size);
263 100 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
264 : (const uint8_t *)request + header_size, message_size);
265 100 : m_libspdm_local_buffer_size += message_size;
266 100 : return LIBSPDM_STATUS_SUCCESS;
267 0 : case 0x17:
268 0 : m_libspdm_local_buffer_size = 0;
269 0 : message_size = libspdm_test_get_measurement_request_size(
270 : spdm_context, (const uint8_t *)request + header_size,
271 : request_size - header_size);
272 0 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
273 : (const uint8_t *)request + header_size, message_size);
274 0 : m_libspdm_local_buffer_size += message_size;
275 0 : return LIBSPDM_STATUS_SUCCESS;
276 1 : case 0x18:
277 1 : m_libspdm_local_buffer_size = 0;
278 1 : message_size = libspdm_test_get_measurement_request_size(
279 : spdm_context, (const uint8_t *)request + header_size,
280 : request_size - header_size);
281 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
282 : (const uint8_t *)request + header_size, message_size);
283 1 : m_libspdm_local_buffer_size += message_size;
284 1 : return LIBSPDM_STATUS_SUCCESS;
285 1 : case 0x19:
286 1 : m_libspdm_local_buffer_size = 0;
287 1 : message_size = libspdm_test_get_measurement_request_size(
288 : spdm_context, (const uint8_t *)request + header_size,
289 : request_size - header_size);
290 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
291 : (const uint8_t *)request + header_size, message_size);
292 1 : m_libspdm_local_buffer_size += message_size;
293 1 : return LIBSPDM_STATUS_SUCCESS;
294 1 : case 0x1A:
295 1 : m_libspdm_local_buffer_size = 0;
296 1 : message_size = libspdm_test_get_measurement_request_size(
297 : spdm_context, (const uint8_t *)request + header_size,
298 : request_size - header_size);
299 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
300 : (const uint8_t *)request + header_size, message_size);
301 1 : m_libspdm_local_buffer_size += message_size;
302 1 : return LIBSPDM_STATUS_SUCCESS;
303 1 : case 0x1B:
304 1 : m_libspdm_local_buffer_size = 0;
305 1 : message_size = libspdm_test_get_measurement_request_size(
306 : spdm_context, (const uint8_t *)request + header_size,
307 : request_size - header_size);
308 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
309 : (const uint8_t *)request + header_size, message_size);
310 1 : m_libspdm_local_buffer_size += message_size;
311 1 : return LIBSPDM_STATUS_SUCCESS;
312 1 : case 0x1C:
313 1 : m_libspdm_local_buffer_size = 0;
314 1 : message_size = libspdm_test_get_measurement_request_size(
315 : spdm_context, (const uint8_t *)request + header_size,
316 : request_size - header_size);
317 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
318 : (const uint8_t *)request + header_size, message_size);
319 1 : m_libspdm_local_buffer_size += message_size;
320 1 : return LIBSPDM_STATUS_SUCCESS;
321 0 : case 0x1D:
322 0 : m_libspdm_local_buffer_size = 0;
323 0 : message_size = libspdm_test_get_measurement_request_size(
324 : spdm_context, (const uint8_t *)request + header_size,
325 : request_size - header_size);
326 0 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
327 : (const uint8_t *)request + header_size, message_size);
328 0 : m_libspdm_local_buffer_size += message_size;
329 0 : return LIBSPDM_STATUS_SUCCESS;
330 0 : case 0x1E:
331 0 : m_libspdm_local_buffer_size = 0;
332 0 : message_size = libspdm_test_get_measurement_request_size(
333 : spdm_context, (const uint8_t *)request + header_size,
334 : request_size - header_size);
335 0 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
336 : (const uint8_t *)request + header_size, message_size);
337 0 : m_libspdm_local_buffer_size += message_size;
338 0 : return LIBSPDM_STATUS_SUCCESS;
339 0 : case 0x1F:
340 0 : m_libspdm_local_buffer_size = 0;
341 0 : message_size = libspdm_test_get_measurement_request_size(
342 : spdm_context, (const uint8_t *)request + header_size,
343 : request_size - header_size);
344 0 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
345 : (const uint8_t *)request + header_size, message_size);
346 0 : m_libspdm_local_buffer_size += message_size;
347 0 : return LIBSPDM_STATUS_SUCCESS;
348 0 : case 0x20:
349 0 : m_libspdm_local_buffer_size = 0;
350 0 : message_size = libspdm_test_get_measurement_request_size(
351 : spdm_context, (const uint8_t *)request + header_size,
352 : request_size - header_size);
353 0 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
354 : (const uint8_t *)request + header_size, message_size);
355 0 : m_libspdm_local_buffer_size += message_size;
356 0 : return LIBSPDM_STATUS_SUCCESS;
357 18 : case 0x21:
358 18 : m_libspdm_local_buffer_size = 0;
359 18 : message_size = libspdm_test_get_measurement_request_size(
360 : spdm_context, (const uint8_t *)request + header_size,
361 : request_size - header_size);
362 18 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
363 : (const uint8_t *)request + header_size, message_size);
364 18 : m_libspdm_local_buffer_size += message_size;
365 18 : return LIBSPDM_STATUS_SUCCESS;
366 0 : case 0x22:
367 0 : m_libspdm_local_buffer_size = 0;
368 0 : session_id = NULL;
369 0 : session_info = libspdm_get_session_info_via_session_id(
370 : spdm_context, 0xFFFFFFFF);
371 0 : message_size = libspdm_test_get_measurement_request_size(
372 : spdm_context, (const uint8_t *)request + header_size,
373 : request_size - header_size);
374 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "Request (0x%zx):\n",
375 : request_size));
376 0 : libspdm_dump_hex(request, request_size);
377 0 : libspdm_get_scratch_buffer (spdm_context, (void **)&app_message, &app_message_size);
378 0 : libspdm_transport_test_decode_message(
379 : spdm_context, &session_id, &is_app_message,
380 : false, request_size, message_buffer,
381 : &app_message_size, (void **)&app_message);
382 : ((libspdm_secured_message_context_t
383 0 : *)(session_info->secured_message_context))
384 0 : ->application_secret.response_data_sequence_number--;
385 0 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
386 : app_message, app_message_size - 3);
387 0 : m_libspdm_local_buffer_size += app_message_size - 3;
388 0 : return LIBSPDM_STATUS_SUCCESS;
389 0 : case 0x23:
390 0 : m_libspdm_local_buffer_size = 0;
391 0 : message_size = libspdm_test_get_measurement_request_size(
392 : spdm_context, (const uint8_t *)request + header_size,
393 : request_size - header_size);
394 0 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
395 : (const uint8_t *)request + header_size, message_size);
396 0 : m_libspdm_local_buffer_size += message_size;
397 0 : return LIBSPDM_STATUS_SUCCESS;
398 0 : case 0x24:
399 0 : m_libspdm_local_buffer_size = 0;
400 0 : message_size = libspdm_test_get_measurement_request_size(
401 : spdm_context, (const uint8_t *)request + header_size,
402 : request_size - header_size);
403 0 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
404 : (const uint8_t *)request + header_size, message_size);
405 0 : m_libspdm_local_buffer_size += message_size;
406 0 : return LIBSPDM_STATUS_SUCCESS;
407 0 : case 0x25:
408 0 : m_libspdm_local_buffer_size = 0;
409 0 : message_size = libspdm_test_get_measurement_request_size(
410 : spdm_context, (const uint8_t *)request + header_size,
411 : request_size - header_size);
412 0 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
413 : (const uint8_t *)request + header_size, message_size);
414 0 : m_libspdm_local_buffer_size += message_size;
415 0 : return LIBSPDM_STATUS_SUCCESS;
416 0 : default:
417 0 : return LIBSPDM_STATUS_SEND_FAIL;
418 : }
419 : }
420 :
421 139 : static libspdm_return_t libspdm_requester_get_measurements_test_receive_message(
422 : void *spdm_context, size_t *response_size,
423 : void **response, uint64_t timeout)
424 : {
425 : libspdm_test_context_t *spdm_test_context;
426 : libspdm_return_t status;
427 :
428 139 : spdm_test_context = libspdm_get_test_context();
429 139 : switch (spdm_test_context->case_id) {
430 0 : case 0x1:
431 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
432 :
433 0 : case 0x2: {
434 : spdm_measurements_response_t *spdm_response;
435 : uint8_t *ptr;
436 : uint8_t hash_data[LIBSPDM_MAX_HASH_SIZE];
437 : size_t sig_size;
438 : size_t measurment_sig_size;
439 : spdm_measurement_block_dmtf_t *measurment_block;
440 : size_t spdm_response_size;
441 : size_t transport_header_size;
442 :
443 : ((libspdm_context_t *)spdm_context)
444 0 : ->connection_info.algorithm.base_asym_algo =
445 : m_libspdm_use_asym_algo;
446 : ((libspdm_context_t *)spdm_context)
447 0 : ->connection_info.algorithm.base_hash_algo =
448 : m_libspdm_use_hash_algo;
449 : ((libspdm_context_t *)spdm_context)
450 0 : ->connection_info.algorithm.measurement_hash_algo =
451 : m_libspdm_use_measurement_hash_algo;
452 0 : measurment_sig_size =
453 : SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
454 0 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
455 0 : spdm_response_size = sizeof(spdm_measurements_response_t) +
456 : sizeof(spdm_measurement_block_dmtf_t) +
457 0 : libspdm_get_measurement_hash_size(
458 0 : m_libspdm_use_measurement_hash_algo) +
459 : measurment_sig_size;
460 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
461 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
462 :
463 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
464 0 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
465 0 : spdm_response->header.param1 = 0;
466 0 : spdm_response->header.param2 = 0;
467 0 : spdm_response->number_of_blocks = 1;
468 0 : libspdm_write_uint24(
469 0 : spdm_response->measurement_record_length,
470 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
471 0 : libspdm_get_measurement_hash_size(
472 : m_libspdm_use_measurement_hash_algo)));
473 0 : measurment_block = (void *)(spdm_response + 1);
474 0 : libspdm_set_mem(measurment_block,
475 : sizeof(spdm_measurement_block_dmtf_t) +
476 0 : libspdm_get_measurement_hash_size(
477 : m_libspdm_use_measurement_hash_algo),
478 : 1);
479 : measurment_block->measurement_block_common_header
480 0 : .measurement_specification =
481 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
482 : measurment_block->measurement_block_common_header
483 0 : .measurement_size =
484 0 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
485 0 : libspdm_get_measurement_hash_size(
486 : m_libspdm_use_measurement_hash_algo));
487 0 : ptr = (void *)((uint8_t *)spdm_response + spdm_response_size -
488 : measurment_sig_size);
489 0 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
490 0 : ptr += SPDM_NONCE_SIZE;
491 0 : *(uint16_t *)ptr = 0;
492 0 : ptr += sizeof(uint16_t);
493 0 : libspdm_copy_mem(&m_libspdm_local_buffer[m_libspdm_local_buffer_size],
494 : sizeof(m_libspdm_local_buffer)
495 0 : - (&m_libspdm_local_buffer[m_libspdm_local_buffer_size] -
496 : m_libspdm_local_buffer),
497 0 : spdm_response, (size_t)ptr - (size_t)spdm_response);
498 0 : m_libspdm_local_buffer_size += ((size_t)ptr - (size_t)spdm_response);
499 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "m_libspdm_local_buffer_size (0x%zx):\n",
500 : m_libspdm_local_buffer_size));
501 0 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
502 0 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_buffer,
503 : m_libspdm_local_buffer_size, hash_data);
504 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "HashDataSize (0x%x):\n",
505 : libspdm_get_hash_size(m_libspdm_use_hash_algo)));
506 0 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
507 0 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
508 0 : libspdm_responder_data_sign(
509 : spdm_context,
510 0 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
511 : SPDM_MEASUREMENTS,
512 : m_libspdm_use_asym_algo, m_libspdm_use_pqc_asym_algo, m_libspdm_use_hash_algo,
513 : false, m_libspdm_local_buffer, m_libspdm_local_buffer_size,
514 : ptr, &sig_size);
515 0 : ptr += sig_size;
516 :
517 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
518 : false, spdm_response_size,
519 : spdm_response, response_size,
520 : response);
521 : }
522 0 : return LIBSPDM_STATUS_SUCCESS;
523 :
524 0 : case 0x3: {
525 : spdm_measurements_response_t *spdm_response;
526 : uint8_t *ptr;
527 : uint8_t hash_data[LIBSPDM_MAX_HASH_SIZE];
528 : size_t sig_size;
529 : size_t measurment_sig_size;
530 : spdm_measurement_block_dmtf_t *measurment_block;
531 : size_t spdm_response_size;
532 : size_t transport_header_size;
533 :
534 : ((libspdm_context_t *)spdm_context)
535 0 : ->connection_info.algorithm.base_asym_algo =
536 : m_libspdm_use_asym_algo;
537 : ((libspdm_context_t *)spdm_context)
538 0 : ->connection_info.algorithm.base_hash_algo =
539 : m_libspdm_use_hash_algo;
540 : ((libspdm_context_t *)spdm_context)
541 0 : ->connection_info.algorithm.measurement_hash_algo =
542 : m_libspdm_use_measurement_hash_algo;
543 0 : measurment_sig_size =
544 : SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
545 0 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
546 0 : spdm_response_size = sizeof(spdm_measurements_response_t) +
547 : sizeof(spdm_measurement_block_dmtf_t) +
548 0 : libspdm_get_measurement_hash_size(
549 0 : m_libspdm_use_measurement_hash_algo) +
550 : measurment_sig_size;
551 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
552 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
553 :
554 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
555 0 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
556 0 : spdm_response->header.param1 = 0;
557 0 : spdm_response->header.param2 = 0;
558 0 : spdm_response->number_of_blocks = 1;
559 0 : libspdm_write_uint24(
560 0 : spdm_response->measurement_record_length,
561 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
562 0 : libspdm_get_measurement_hash_size(
563 : m_libspdm_use_measurement_hash_algo)));
564 0 : measurment_block = (void *)(spdm_response + 1);
565 0 : libspdm_set_mem(measurment_block,
566 : sizeof(spdm_measurement_block_dmtf_t) +
567 0 : libspdm_get_measurement_hash_size(
568 : m_libspdm_use_measurement_hash_algo),
569 : 1);
570 : measurment_block->measurement_block_common_header
571 0 : .measurement_specification =
572 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
573 : measurment_block->measurement_block_common_header
574 0 : .measurement_size =
575 0 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
576 0 : libspdm_get_measurement_hash_size(
577 : m_libspdm_use_measurement_hash_algo));
578 0 : ptr = (void *)((uint8_t *)spdm_response + spdm_response_size -
579 : measurment_sig_size);
580 0 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
581 0 : ptr += SPDM_NONCE_SIZE;
582 0 : *(uint16_t *)ptr = 0;
583 0 : ptr += sizeof(uint16_t);
584 0 : libspdm_copy_mem(&m_libspdm_local_buffer[m_libspdm_local_buffer_size],
585 : sizeof(m_libspdm_local_buffer)
586 0 : - (&m_libspdm_local_buffer[m_libspdm_local_buffer_size] -
587 : m_libspdm_local_buffer),
588 0 : spdm_response, (size_t)ptr - (size_t)spdm_response);
589 0 : m_libspdm_local_buffer_size += ((size_t)ptr - (size_t)spdm_response);
590 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "m_libspdm_local_buffer_size (0x%zx):\n",
591 : m_libspdm_local_buffer_size));
592 0 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
593 0 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_buffer,
594 : m_libspdm_local_buffer_size, hash_data);
595 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "HashDataSize (0x%x):\n",
596 : libspdm_get_hash_size(m_libspdm_use_hash_algo)));
597 0 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
598 0 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
599 0 : libspdm_responder_data_sign(
600 : spdm_context,
601 0 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
602 : SPDM_MEASUREMENTS,
603 : m_libspdm_use_asym_algo, m_libspdm_use_pqc_asym_algo, m_libspdm_use_hash_algo,
604 : false, m_libspdm_local_buffer, m_libspdm_local_buffer_size,
605 : ptr, &sig_size);
606 0 : ptr += sig_size;
607 :
608 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
609 : false, spdm_response_size,
610 : spdm_response, response_size,
611 : response);
612 : }
613 0 : return LIBSPDM_STATUS_SUCCESS;
614 :
615 1 : case 0x4: {
616 : spdm_error_response_t *spdm_response;
617 : size_t spdm_response_size;
618 : size_t transport_header_size;
619 :
620 1 : spdm_response_size = sizeof(spdm_error_response_t);
621 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
622 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
623 :
624 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
625 1 : spdm_response->header.request_response_code = SPDM_ERROR;
626 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_INVALID_REQUEST;
627 1 : spdm_response->header.param2 = 0;
628 :
629 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
630 : false, spdm_response_size,
631 : spdm_response,
632 : response_size, response);
633 : }
634 1 : return LIBSPDM_STATUS_SUCCESS;
635 :
636 1 : case 0x5: {
637 : spdm_error_response_t *spdm_response;
638 : size_t spdm_response_size;
639 : size_t transport_header_size;
640 :
641 1 : spdm_response_size = sizeof(spdm_error_response_t);
642 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
643 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
644 :
645 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
646 1 : spdm_response->header.request_response_code = SPDM_ERROR;
647 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
648 1 : spdm_response->header.param2 = 0;
649 :
650 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
651 : false, spdm_response_size,
652 : spdm_response,
653 : response_size, response);
654 : }
655 1 : return LIBSPDM_STATUS_SUCCESS;
656 :
657 0 : case 0x6: {
658 : static size_t sub_index1 = 0;
659 0 : if (sub_index1 == 0) {
660 : spdm_error_response_t *spdm_response;
661 : size_t spdm_response_size;
662 : size_t transport_header_size;
663 :
664 0 : spdm_response_size = sizeof(spdm_error_response_t);
665 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
666 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
667 :
668 0 : spdm_response->header.spdm_version =
669 : SPDM_MESSAGE_VERSION_11;
670 0 : spdm_response->header.request_response_code = SPDM_ERROR;
671 0 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
672 0 : spdm_response->header.param2 = 0;
673 :
674 0 : libspdm_transport_test_encode_message(
675 : spdm_context, NULL, false, false,
676 : spdm_response_size, spdm_response,
677 : response_size, response);
678 0 : sub_index1++;
679 0 : } else if (sub_index1 == 1) {
680 : spdm_measurements_response_t *spdm_response;
681 : uint8_t *ptr;
682 : uint8_t hash_data[LIBSPDM_MAX_HASH_SIZE];
683 : size_t sig_size;
684 : size_t measurment_sig_size;
685 : spdm_measurement_block_dmtf_t *measurment_block;
686 : size_t spdm_response_size;
687 : size_t transport_header_size;
688 :
689 : ((libspdm_context_t *)spdm_context)
690 0 : ->connection_info.algorithm.base_asym_algo =
691 : m_libspdm_use_asym_algo;
692 : ((libspdm_context_t *)spdm_context)
693 0 : ->connection_info.algorithm.base_hash_algo =
694 : m_libspdm_use_hash_algo;
695 : ((libspdm_context_t *)spdm_context)
696 : ->connection_info.algorithm
697 0 : .measurement_hash_algo =
698 : m_libspdm_use_measurement_hash_algo;
699 0 : measurment_sig_size =
700 : SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
701 0 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
702 0 : spdm_response_size = sizeof(spdm_measurements_response_t) +
703 : sizeof(spdm_measurement_block_dmtf_t) +
704 0 : libspdm_get_measurement_hash_size(
705 0 : m_libspdm_use_measurement_hash_algo) +
706 : measurment_sig_size;
707 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
708 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
709 :
710 0 : spdm_response->header.spdm_version =
711 : SPDM_MESSAGE_VERSION_11;
712 0 : spdm_response->header.request_response_code =
713 : SPDM_MEASUREMENTS;
714 0 : spdm_response->header.param1 = 0;
715 0 : spdm_response->header.param2 = 0;
716 0 : spdm_response->number_of_blocks = 1;
717 0 : libspdm_write_uint24(
718 0 : spdm_response->measurement_record_length,
719 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
720 0 : libspdm_get_measurement_hash_size(
721 : m_libspdm_use_measurement_hash_algo)));
722 0 : measurment_block = (void *)(spdm_response + 1);
723 0 : libspdm_set_mem(measurment_block,
724 : sizeof(spdm_measurement_block_dmtf_t) +
725 0 : libspdm_get_measurement_hash_size(
726 : m_libspdm_use_measurement_hash_algo),
727 : 1);
728 : measurment_block->measurement_block_common_header
729 0 : .measurement_specification =
730 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
731 : measurment_block->measurement_block_common_header
732 0 : .measurement_size = (uint16_t)(
733 : sizeof(spdm_measurement_block_dmtf_header_t) +
734 0 : libspdm_get_measurement_hash_size(
735 : m_libspdm_use_measurement_hash_algo));
736 0 : ptr = (void *)((uint8_t *)spdm_response + spdm_response_size -
737 : measurment_sig_size);
738 0 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
739 0 : ptr += SPDM_NONCE_SIZE;
740 0 : *(uint16_t *)ptr = 0;
741 0 : ptr += sizeof(uint16_t);
742 0 : libspdm_copy_mem(&m_libspdm_local_buffer[m_libspdm_local_buffer_size],
743 : sizeof(m_libspdm_local_buffer)
744 0 : - (&m_libspdm_local_buffer[m_libspdm_local_buffer_size] -
745 : m_libspdm_local_buffer),
746 0 : spdm_response, (size_t)ptr - (size_t)spdm_response);
747 0 : m_libspdm_local_buffer_size +=
748 0 : ((size_t)ptr - (size_t)spdm_response);
749 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "m_libspdm_local_buffer_size (0x%zx):\n",
750 : m_libspdm_local_buffer_size));
751 0 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
752 0 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_buffer,
753 : m_libspdm_local_buffer_size, hash_data);
754 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "HashDataSize (0x%x):\n",
755 : libspdm_get_hash_size(m_libspdm_use_hash_algo)));
756 0 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
757 0 : sig_size =
758 0 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
759 0 : libspdm_responder_data_sign(
760 : spdm_context,
761 0 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
762 : SPDM_MEASUREMENTS,
763 : m_libspdm_use_asym_algo, m_libspdm_use_pqc_asym_algo,
764 : m_libspdm_use_hash_algo,
765 : false, m_libspdm_local_buffer,
766 : m_libspdm_local_buffer_size, ptr,
767 : &sig_size);
768 0 : ptr += sig_size;
769 :
770 0 : libspdm_transport_test_encode_message(
771 : spdm_context, NULL, false, false, spdm_response_size,
772 : spdm_response, response_size, response);
773 : }
774 : }
775 0 : return LIBSPDM_STATUS_SUCCESS;
776 :
777 1 : case 0x7: {
778 : spdm_error_response_t *spdm_response;
779 : size_t spdm_response_size;
780 : size_t transport_header_size;
781 :
782 1 : spdm_response_size = sizeof(spdm_error_response_t);
783 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
784 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
785 :
786 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
787 1 : spdm_response->header.request_response_code = SPDM_ERROR;
788 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_REQUEST_RESYNCH;
789 1 : spdm_response->header.param2 = 0;
790 :
791 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
792 : false, spdm_response_size,
793 : spdm_response,
794 : response_size, response);
795 : }
796 1 : return LIBSPDM_STATUS_SUCCESS;
797 :
798 2 : case 0x8: {
799 : spdm_error_response_data_response_not_ready_t *spdm_response;
800 : size_t spdm_response_size;
801 : size_t transport_header_size;
802 :
803 2 : spdm_response_size = sizeof(spdm_error_response_data_response_not_ready_t);
804 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
805 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
806 :
807 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
808 2 : spdm_response->header.request_response_code = SPDM_ERROR;
809 2 : spdm_response->header.param1 =
810 : SPDM_ERROR_CODE_RESPONSE_NOT_READY;
811 2 : spdm_response->header.param2 = 0;
812 2 : spdm_response->extend_error_data.rd_exponent = 1;
813 2 : spdm_response->extend_error_data.rd_tm = 2;
814 2 : spdm_response->extend_error_data.request_code =
815 : SPDM_GET_MEASUREMENTS;
816 2 : spdm_response->extend_error_data.token = 0;
817 :
818 2 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
819 : false, spdm_response_size,
820 : spdm_response,
821 : response_size, response);
822 : }
823 2 : return LIBSPDM_STATUS_SUCCESS;
824 :
825 0 : case 0x9:
826 0 : return LIBSPDM_STATUS_SUCCESS;
827 :
828 0 : case 0xA: {
829 : spdm_measurements_response_t *spdm_response;
830 : size_t spdm_response_size;
831 : size_t transport_header_size;
832 : uint8_t *ptr;
833 0 : spdm_response_size =
834 : sizeof(spdm_measurements_response_t)
835 : + SPDM_NONCE_SIZE + sizeof(uint16_t);
836 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
837 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
838 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
839 0 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
840 0 : spdm_response->header.param1 = 4;
841 0 : spdm_response->header.param2 = 0;
842 0 : spdm_response->number_of_blocks = 0;
843 0 : libspdm_write_uint24(spdm_response->measurement_record_length, 0);
844 :
845 0 : ptr = (uint8_t *)spdm_response +
846 : sizeof(spdm_measurements_response_t);
847 0 : libspdm_get_random_number(SPDM_NONCE_SIZE,ptr);
848 0 : ptr += SPDM_NONCE_SIZE;
849 0 : *(uint16_t *)ptr = 0;
850 :
851 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
852 : false, spdm_response_size,
853 : spdm_response, response_size,
854 : response);
855 : }
856 0 : return LIBSPDM_STATUS_SUCCESS;
857 :
858 0 : case 0xB: {
859 : spdm_measurements_response_t *spdm_response;
860 : spdm_measurement_block_dmtf_t *measurment_block;
861 : size_t spdm_response_size;
862 : size_t transport_header_size;
863 : uint8_t *ptr;
864 : ((libspdm_context_t *)spdm_context)
865 0 : ->connection_info.algorithm.measurement_hash_algo =
866 : m_libspdm_use_measurement_hash_algo;
867 0 : spdm_response_size = sizeof(spdm_measurements_response_t) +
868 : sizeof(spdm_measurement_block_dmtf_t) +
869 0 : libspdm_get_measurement_hash_size(
870 : m_libspdm_use_measurement_hash_algo) +
871 : SPDM_NONCE_SIZE + sizeof(uint16_t);
872 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
873 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
874 :
875 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
876 0 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
877 0 : spdm_response->header.param1 = 0;
878 0 : spdm_response->header.param2 = 0;
879 0 : spdm_response->number_of_blocks = 1;
880 0 : libspdm_write_uint24(
881 0 : spdm_response->measurement_record_length,
882 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
883 0 : libspdm_get_measurement_hash_size(
884 : m_libspdm_use_measurement_hash_algo)));
885 0 : measurment_block = (void *)(spdm_response + 1);
886 0 : libspdm_set_mem(measurment_block,
887 : sizeof(spdm_measurement_block_dmtf_t) +
888 0 : libspdm_get_measurement_hash_size(
889 : m_libspdm_use_measurement_hash_algo),
890 : 1);
891 : measurment_block->measurement_block_common_header
892 0 : .measurement_specification =
893 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
894 : measurment_block->measurement_block_common_header
895 0 : .measurement_size =
896 0 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
897 0 : libspdm_get_measurement_hash_size(
898 : m_libspdm_use_measurement_hash_algo));
899 :
900 0 : ptr = (uint8_t *)spdm_response +
901 : sizeof(spdm_measurements_response_t) +
902 0 : sizeof(spdm_measurement_block_dmtf_t) +
903 0 : libspdm_get_measurement_hash_size(
904 : m_libspdm_use_measurement_hash_algo);
905 0 : libspdm_get_random_number(SPDM_NONCE_SIZE,ptr);
906 0 : *(uint16_t *)(ptr + SPDM_NONCE_SIZE) = 0;
907 :
908 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
909 : false, spdm_response_size,
910 : spdm_response, response_size,
911 : response);
912 : }
913 0 : return LIBSPDM_STATUS_SUCCESS;
914 :
915 1 : case 0xC: {
916 : spdm_measurements_response_t *spdm_response;
917 : uint8_t *ptr;
918 : size_t sig_size;
919 : size_t measurment_sig_size;
920 : spdm_measurement_block_dmtf_t *measurment_block;
921 : size_t spdm_response_size;
922 : size_t transport_header_size;
923 :
924 : ((libspdm_context_t *)spdm_context)
925 1 : ->connection_info.algorithm.base_asym_algo =
926 : m_libspdm_use_asym_algo;
927 : ((libspdm_context_t *)spdm_context)
928 1 : ->connection_info.algorithm.base_hash_algo =
929 : m_libspdm_use_hash_algo;
930 : ((libspdm_context_t *)spdm_context)
931 1 : ->connection_info.algorithm.measurement_hash_algo =
932 : m_libspdm_use_measurement_hash_algo;
933 :
934 1 : measurment_sig_size =
935 : SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
936 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
937 1 : spdm_response_size = sizeof(spdm_measurements_response_t) +
938 : sizeof(spdm_measurement_block_dmtf_t) +
939 1 : libspdm_get_measurement_hash_size(
940 1 : m_libspdm_use_measurement_hash_algo) +
941 : measurment_sig_size;
942 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
943 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
944 :
945 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
946 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
947 1 : spdm_response->header.param1 = 0;
948 1 : spdm_response->header.param2 = 0;
949 1 : spdm_response->number_of_blocks = 1;
950 1 : libspdm_write_uint24(
951 1 : spdm_response->measurement_record_length,
952 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
953 1 : libspdm_get_measurement_hash_size(
954 : m_libspdm_use_measurement_hash_algo)));
955 1 : measurment_block = (void *)(spdm_response + 1);
956 1 : libspdm_set_mem(measurment_block,
957 : sizeof(spdm_measurement_block_dmtf_t) +
958 1 : libspdm_get_measurement_hash_size(
959 : m_libspdm_use_measurement_hash_algo),
960 : 1);
961 : measurment_block->measurement_block_common_header
962 1 : .measurement_specification =
963 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
964 : measurment_block->measurement_block_common_header
965 1 : .measurement_size =
966 1 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
967 1 : libspdm_get_measurement_hash_size(
968 : m_libspdm_use_measurement_hash_algo));
969 1 : ptr = (void *)((uint8_t *)spdm_response + spdm_response_size -
970 : measurment_sig_size);
971 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
972 1 : ptr += SPDM_NONCE_SIZE;
973 1 : *(uint16_t *)ptr = 0;
974 1 : ptr += sizeof(uint16_t);
975 1 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
976 1 : libspdm_set_mem(ptr, sig_size, 0);
977 1 : ptr += sig_size;
978 :
979 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
980 : false, spdm_response_size,
981 : spdm_response, response_size,
982 : response);
983 : }
984 1 : return LIBSPDM_STATUS_SUCCESS;
985 :
986 1 : case 0xD: {
987 : spdm_measurements_response_t *spdm_response;
988 : uint8_t *ptr;
989 : uint8_t hash_data[LIBSPDM_MAX_HASH_SIZE];
990 : size_t sig_size;
991 : size_t measurment_sig_size;
992 : spdm_measurement_block_dmtf_t *measurment_block;
993 : size_t spdm_response_size;
994 : size_t transport_header_size;
995 :
996 : ((libspdm_context_t *)spdm_context)
997 1 : ->connection_info.algorithm.base_asym_algo =
998 : m_libspdm_use_asym_algo;
999 : ((libspdm_context_t *)spdm_context)
1000 1 : ->connection_info.algorithm.base_hash_algo =
1001 : m_libspdm_use_hash_algo;
1002 : ((libspdm_context_t *)spdm_context)
1003 1 : ->connection_info.algorithm.measurement_hash_algo =
1004 : m_libspdm_use_measurement_hash_algo;
1005 1 : measurment_sig_size =
1006 : SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1007 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1008 1 : spdm_response_size = sizeof(spdm_measurements_response_t) +
1009 : sizeof(spdm_measurement_block_dmtf_t) +
1010 1 : libspdm_get_measurement_hash_size(
1011 1 : m_libspdm_use_measurement_hash_algo) +
1012 : measurment_sig_size;
1013 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1014 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1015 :
1016 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1017 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
1018 1 : spdm_response->header.param1 = 0;
1019 1 : spdm_response->header.param2 = 0;
1020 1 : spdm_response->number_of_blocks = 1;
1021 1 : libspdm_write_uint24(
1022 1 : spdm_response->measurement_record_length,
1023 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
1024 1 : libspdm_get_measurement_hash_size(
1025 : m_libspdm_use_measurement_hash_algo)));
1026 1 : measurment_block = (void *)(spdm_response + 1);
1027 1 : libspdm_set_mem(measurment_block,
1028 : sizeof(spdm_measurement_block_dmtf_t) +
1029 1 : libspdm_get_measurement_hash_size(
1030 : m_libspdm_use_measurement_hash_algo),
1031 : 1);
1032 : measurment_block->measurement_block_common_header
1033 1 : .measurement_specification =
1034 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
1035 : measurment_block->measurement_block_common_header
1036 1 : .measurement_size =
1037 1 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
1038 1 : libspdm_get_measurement_hash_size(
1039 : m_libspdm_use_measurement_hash_algo));
1040 1 : ptr = (void *)((uint8_t *)spdm_response + spdm_response_size -
1041 : measurment_sig_size);
1042 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
1043 1 : ptr += SPDM_NONCE_SIZE;
1044 1 : *(uint16_t *)ptr = 0;
1045 1 : ptr += sizeof(uint16_t);
1046 1 : libspdm_copy_mem(&m_libspdm_local_buffer[m_libspdm_local_buffer_size],
1047 : sizeof(m_libspdm_local_buffer)
1048 1 : - (&m_libspdm_local_buffer[m_libspdm_local_buffer_size] -
1049 : m_libspdm_local_buffer),
1050 1 : spdm_response, (size_t)ptr - (size_t)spdm_response);
1051 1 : m_libspdm_local_buffer_size += ((size_t)ptr - (size_t)spdm_response);
1052 1 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "m_libspdm_local_buffer_size (0x%zx):\n",
1053 : m_libspdm_local_buffer_size));
1054 1 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
1055 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_buffer,
1056 : m_libspdm_local_buffer_size, hash_data);
1057 1 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "HashDataSize (0x%x):\n",
1058 : libspdm_get_hash_size(m_libspdm_use_hash_algo)));
1059 1 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
1060 1 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1061 1 : libspdm_get_random_number(sig_size, ptr);
1062 1 : ptr += sig_size;
1063 :
1064 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
1065 : false, spdm_response_size,
1066 : spdm_response, response_size,
1067 : response);
1068 : }
1069 1 : return LIBSPDM_STATUS_SUCCESS;
1070 :
1071 1 : case 0xE: {
1072 : spdm_measurements_response_t *spdm_response;
1073 : spdm_measurement_block_dmtf_t *measurment_block;
1074 : size_t spdm_response_size;
1075 : size_t transport_header_size;
1076 :
1077 : ((libspdm_context_t *)spdm_context)
1078 1 : ->connection_info.algorithm.base_asym_algo =
1079 : m_libspdm_use_asym_algo;
1080 : ((libspdm_context_t *)spdm_context)
1081 1 : ->connection_info.algorithm.base_hash_algo =
1082 : m_libspdm_use_hash_algo;
1083 : ((libspdm_context_t *)spdm_context)
1084 1 : ->connection_info.algorithm.measurement_hash_algo =
1085 : m_libspdm_use_measurement_hash_algo;
1086 1 : spdm_response_size = sizeof(spdm_measurements_response_t) +
1087 : sizeof(spdm_measurement_block_dmtf_t) +
1088 1 : libspdm_get_measurement_hash_size(
1089 : m_libspdm_use_measurement_hash_algo) +
1090 : SPDM_NONCE_SIZE + sizeof(uint16_t);
1091 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1092 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1093 :
1094 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1095 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
1096 1 : spdm_response->header.param1 = 0;
1097 1 : spdm_response->header.param2 = 0;
1098 1 : spdm_response->number_of_blocks = 1;
1099 1 : libspdm_write_uint24(
1100 1 : spdm_response->measurement_record_length,
1101 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
1102 1 : libspdm_get_measurement_hash_size(
1103 : m_libspdm_use_measurement_hash_algo)));
1104 1 : measurment_block = (void *)(spdm_response + 1);
1105 1 : libspdm_set_mem(measurment_block,
1106 : sizeof(spdm_measurement_block_dmtf_t) +
1107 1 : libspdm_get_measurement_hash_size(
1108 : m_libspdm_use_measurement_hash_algo),
1109 : 1);
1110 : measurment_block->measurement_block_common_header
1111 1 : .measurement_specification =
1112 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
1113 : measurment_block->measurement_block_common_header
1114 1 : .measurement_size =
1115 1 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
1116 1 : libspdm_get_measurement_hash_size(
1117 : m_libspdm_use_measurement_hash_algo));
1118 :
1119 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
1120 : false, spdm_response_size,
1121 : spdm_response, response_size,
1122 : response);
1123 : }
1124 1 : return LIBSPDM_STATUS_SUCCESS;
1125 :
1126 1 : case 0xF: {
1127 : spdm_measurements_response_t *spdm_response;
1128 : uint8_t *ptr;
1129 : uint8_t hash_data[LIBSPDM_MAX_HASH_SIZE];
1130 : size_t sig_size;
1131 : size_t measurment_sig_size;
1132 : spdm_measurement_block_dmtf_t *measurment_block;
1133 : size_t spdm_response_size;
1134 : size_t transport_header_size;
1135 :
1136 : ((libspdm_context_t *)spdm_context)
1137 1 : ->connection_info.algorithm.base_asym_algo =
1138 : m_libspdm_use_asym_algo;
1139 : ((libspdm_context_t *)spdm_context)
1140 1 : ->connection_info.algorithm.base_hash_algo =
1141 : m_libspdm_use_hash_algo;
1142 : ((libspdm_context_t *)spdm_context)
1143 1 : ->connection_info.algorithm.measurement_hash_algo =
1144 : m_libspdm_use_measurement_hash_algo;
1145 1 : measurment_sig_size =
1146 : SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
1147 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1148 1 : spdm_response_size = sizeof(spdm_measurements_response_t) +
1149 : sizeof(spdm_measurement_block_dmtf_t) +
1150 1 : libspdm_get_measurement_hash_size(
1151 1 : m_libspdm_use_measurement_hash_algo) +
1152 : measurment_sig_size;
1153 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1154 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1155 :
1156 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1157 1 : spdm_response->header.request_response_code =
1158 : SPDM_MEASUREMENTS + 1;
1159 1 : spdm_response->header.param1 = 0;
1160 1 : spdm_response->header.param2 = 0;
1161 1 : spdm_response->number_of_blocks = 1;
1162 1 : libspdm_write_uint24(
1163 1 : spdm_response->measurement_record_length,
1164 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
1165 1 : libspdm_get_measurement_hash_size(
1166 : m_libspdm_use_measurement_hash_algo)));
1167 1 : measurment_block = (void *)(spdm_response + 1);
1168 1 : libspdm_set_mem(measurment_block,
1169 : sizeof(spdm_measurement_block_dmtf_t) +
1170 1 : libspdm_get_measurement_hash_size(
1171 : m_libspdm_use_measurement_hash_algo),
1172 : 1);
1173 : measurment_block->measurement_block_common_header
1174 1 : .measurement_specification =
1175 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
1176 : measurment_block->measurement_block_common_header
1177 1 : .measurement_size =
1178 1 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
1179 1 : libspdm_get_measurement_hash_size(
1180 : m_libspdm_use_measurement_hash_algo));
1181 1 : ptr = (void *)((uint8_t *)spdm_response + spdm_response_size -
1182 : measurment_sig_size);
1183 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
1184 1 : ptr += SPDM_NONCE_SIZE;
1185 1 : *(uint16_t *)ptr = 0;
1186 1 : ptr += sizeof(uint16_t);
1187 1 : libspdm_copy_mem(&m_libspdm_local_buffer[m_libspdm_local_buffer_size],
1188 : sizeof(m_libspdm_local_buffer)
1189 1 : - (&m_libspdm_local_buffer[m_libspdm_local_buffer_size] -
1190 : m_libspdm_local_buffer),
1191 1 : spdm_response, (size_t)ptr - (size_t)spdm_response);
1192 1 : m_libspdm_local_buffer_size += ((size_t)ptr - (size_t)spdm_response);
1193 1 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "m_libspdm_local_buffer_size (0x%zx):\n",
1194 : m_libspdm_local_buffer_size));
1195 1 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
1196 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_buffer,
1197 : m_libspdm_local_buffer_size, hash_data);
1198 1 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "HashDataSize (0x%x):\n",
1199 : libspdm_get_hash_size(m_libspdm_use_hash_algo)));
1200 1 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
1201 1 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1202 1 : libspdm_responder_data_sign(
1203 : spdm_context,
1204 1 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
1205 : SPDM_MEASUREMENTS,
1206 : m_libspdm_use_asym_algo, m_libspdm_use_pqc_asym_algo, m_libspdm_use_hash_algo,
1207 : false, m_libspdm_local_buffer, m_libspdm_local_buffer_size,
1208 : ptr, &sig_size);
1209 1 : ptr += sig_size;
1210 :
1211 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
1212 : false, spdm_response_size,
1213 : spdm_response, response_size,
1214 : response);
1215 : }
1216 1 : return LIBSPDM_STATUS_SUCCESS;
1217 :
1218 1 : case 0x10:
1219 1 : return LIBSPDM_STATUS_RECEIVE_FAIL;
1220 :
1221 3 : case 0x11: {
1222 : static size_t sub_index0x11 = 0;
1223 :
1224 : spdm_measurements_response_t *spdm_response;
1225 : spdm_measurement_block_dmtf_t *measurment_block;
1226 : size_t spdm_response_size;
1227 : size_t transport_header_size;
1228 3 : spdm_response_size = sizeof(spdm_measurements_response_t);
1229 :
1230 : ((libspdm_context_t *)spdm_context)
1231 3 : ->connection_info.algorithm.measurement_hash_algo =
1232 : m_libspdm_use_measurement_hash_algo;
1233 3 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1234 3 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1235 :
1236 3 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1237 3 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
1238 3 : spdm_response->header.param1 = 1;
1239 3 : spdm_response->header.param2 = 0;
1240 3 : if (sub_index0x11 == 0) {
1241 1 : spdm_response_size = sizeof(spdm_measurements_response_t) +
1242 : sizeof(spdm_measurement_block_dmtf_t) +
1243 1 : libspdm_get_measurement_hash_size(
1244 : m_libspdm_use_measurement_hash_algo) +
1245 : SPDM_NONCE_SIZE + sizeof(uint16_t);
1246 1 : spdm_response->number_of_blocks = 1;
1247 1 : libspdm_write_uint24(
1248 1 : spdm_response->measurement_record_length,
1249 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
1250 1 : libspdm_get_measurement_hash_size(
1251 : m_libspdm_use_measurement_hash_algo)));
1252 1 : measurment_block = (void *)(spdm_response + 1);
1253 1 : libspdm_set_mem(measurment_block,
1254 : sizeof(spdm_measurement_block_dmtf_t) +
1255 1 : libspdm_get_measurement_hash_size(
1256 : m_libspdm_use_measurement_hash_algo),
1257 : 1);
1258 : measurment_block->measurement_block_common_header
1259 1 : .measurement_specification =
1260 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
1261 : measurment_block->measurement_block_common_header
1262 1 : .measurement_size = (uint16_t)(
1263 : sizeof(spdm_measurement_block_dmtf_header_t) +
1264 1 : libspdm_get_measurement_hash_size(
1265 : m_libspdm_use_measurement_hash_algo));
1266 2 : } else if (sub_index0x11 == 1) {
1267 1 : spdm_response_size = sizeof(spdm_measurements_response_t) +
1268 : SPDM_NONCE_SIZE + sizeof(uint16_t);
1269 1 : spdm_response->number_of_blocks = 1;
1270 1 : libspdm_write_uint24(
1271 1 : spdm_response->measurement_record_length, 0);
1272 1 : } else if (sub_index0x11 == 2) {
1273 1 : spdm_response_size = sizeof(spdm_measurements_response_t) +
1274 : sizeof(spdm_measurement_block_dmtf_t) +
1275 1 : libspdm_get_measurement_hash_size(
1276 : m_libspdm_use_measurement_hash_algo) +
1277 : SPDM_NONCE_SIZE + sizeof(uint16_t);
1278 1 : spdm_response->number_of_blocks = 0;
1279 1 : libspdm_write_uint24(
1280 1 : spdm_response->measurement_record_length,
1281 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
1282 1 : libspdm_get_measurement_hash_size(
1283 : m_libspdm_use_measurement_hash_algo)));
1284 1 : measurment_block = (void *)(spdm_response + 1);
1285 1 : libspdm_set_mem(measurment_block,
1286 : sizeof(spdm_measurement_block_dmtf_t) +
1287 1 : libspdm_get_measurement_hash_size(
1288 : m_libspdm_use_measurement_hash_algo),
1289 : 1);
1290 : measurment_block->measurement_block_common_header
1291 1 : .measurement_specification =
1292 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
1293 : measurment_block->measurement_block_common_header
1294 1 : .measurement_size = (uint16_t)(
1295 : sizeof(spdm_measurement_block_dmtf_header_t) +
1296 1 : libspdm_get_measurement_hash_size(
1297 : m_libspdm_use_measurement_hash_algo));
1298 : }
1299 3 : sub_index0x11++;
1300 :
1301 3 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
1302 : false, spdm_response_size,
1303 : spdm_response, response_size,
1304 : response);
1305 : }
1306 3 : return LIBSPDM_STATUS_SUCCESS;
1307 :
1308 0 : case 0x12: {
1309 : spdm_measurements_response_t *spdm_response;
1310 : spdm_measurement_block_dmtf_t *measurment_block;
1311 : uint8_t *large_spdm_response;
1312 : size_t spdm_response_size;
1313 : size_t transport_header_size;
1314 : size_t count;
1315 :
1316 : large_spdm_response =
1317 0 : (uint8_t *)malloc(sizeof(spdm_measurements_response_t) +
1318 : LIBSPDM_LARGE_MEASUREMENT_SIZE);
1319 :
1320 : ((libspdm_context_t *)spdm_context)
1321 0 : ->connection_info.algorithm.measurement_hash_algo =
1322 : m_libspdm_use_measurement_hash_algo;
1323 0 : spdm_response_size = sizeof(spdm_measurements_response_t);
1324 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1325 0 : spdm_response = (void *)large_spdm_response;
1326 :
1327 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1328 0 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
1329 0 : spdm_response->header.param1 = 0;
1330 0 : spdm_response->header.param2 = 0;
1331 0 : spdm_response->number_of_blocks = 0xFF;
1332 0 : libspdm_write_uint24(spdm_response->measurement_record_length,
1333 : (uint32_t)(LIBSPDM_LARGE_MEASUREMENT_SIZE));
1334 0 : measurment_block = (void *)(spdm_response + 1);
1335 0 : libspdm_set_mem(measurment_block, LIBSPDM_LARGE_MEASUREMENT_SIZE, 1);
1336 0 : for (count = 0; count < spdm_response->number_of_blocks;
1337 0 : count++) {
1338 0 : measurment_block->measurement_block_common_header.index =
1339 0 : (uint8_t)(count + 1);
1340 : measurment_block->measurement_block_common_header
1341 0 : .measurement_specification =
1342 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
1343 : measurment_block->measurement_block_common_header
1344 0 : .measurement_size = 0xFFFF;
1345 0 : spdm_response_size += (size_t)(
1346 : sizeof(spdm_measurement_block_common_header_t) +
1347 : 0xFFFF);
1348 : }
1349 :
1350 0 : spdm_response = (void *)((uint8_t *)(*response) + transport_header_size);
1351 0 : if (spdm_response_size > (size_t)(*response) + *response_size - (size_t)spdm_response) {
1352 0 : spdm_response_size = (size_t)(*response) + *response_size - (size_t)spdm_response;
1353 : }
1354 0 : libspdm_copy_mem (spdm_response, spdm_response_size,
1355 : large_spdm_response, spdm_response_size);
1356 :
1357 0 : status = libspdm_transport_test_encode_message(
1358 : spdm_context, NULL, false, false, spdm_response_size,
1359 : spdm_response, response_size, response);
1360 :
1361 0 : free(large_spdm_response);
1362 : }
1363 0 : return status;
1364 :
1365 1 : case 0x13: {
1366 : spdm_measurements_response_t *spdm_response;
1367 : spdm_measurement_block_dmtf_t *measurment_block;
1368 : size_t spdm_response_size;
1369 : size_t transport_header_size;
1370 :
1371 : ((libspdm_context_t *)spdm_context)
1372 1 : ->connection_info.algorithm.measurement_hash_algo =
1373 : m_libspdm_use_measurement_hash_algo;
1374 1 : spdm_response_size = sizeof(spdm_measurements_response_t) +
1375 : sizeof(spdm_measurement_block_dmtf_t) +
1376 1 : libspdm_get_measurement_hash_size(
1377 : m_libspdm_use_measurement_hash_algo) +
1378 : SPDM_NONCE_SIZE + sizeof(uint16_t);
1379 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1380 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1381 :
1382 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1383 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
1384 1 : spdm_response->header.param1 = 0;
1385 1 : spdm_response->header.param2 = 0;
1386 1 : spdm_response->number_of_blocks = 1;
1387 1 : libspdm_write_uint24(
1388 1 : spdm_response->measurement_record_length,
1389 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
1390 1 : libspdm_get_measurement_hash_size(
1391 : m_libspdm_use_measurement_hash_algo)));
1392 1 : measurment_block = (void *)(spdm_response + 1);
1393 1 : libspdm_set_mem(measurment_block,
1394 : sizeof(spdm_measurement_block_dmtf_t) +
1395 1 : libspdm_get_measurement_hash_size(
1396 : m_libspdm_use_measurement_hash_algo),
1397 : 1);
1398 1 : measurment_block->measurement_block_common_header.index = 1;
1399 : measurment_block->measurement_block_common_header
1400 1 : .measurement_specification = 0x00000001 | 0x00000002;
1401 : measurment_block->measurement_block_common_header
1402 1 : .measurement_size =
1403 1 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
1404 1 : libspdm_get_measurement_hash_size(
1405 : m_libspdm_use_measurement_hash_algo));
1406 :
1407 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
1408 : false, spdm_response_size,
1409 : spdm_response, response_size,
1410 : response);
1411 : }
1412 1 : return LIBSPDM_STATUS_SUCCESS;
1413 :
1414 1 : case 0x14: {
1415 : spdm_measurements_response_t *spdm_response;
1416 : spdm_measurement_block_dmtf_t *measurment_block;
1417 : size_t spdm_response_size;
1418 : size_t transport_header_size;
1419 :
1420 : ((libspdm_context_t *)spdm_context)
1421 1 : ->connection_info.algorithm.measurement_hash_algo =
1422 : m_libspdm_use_measurement_hash_algo;
1423 1 : spdm_response_size = sizeof(spdm_measurements_response_t) +
1424 : sizeof(spdm_measurement_block_dmtf_t) +
1425 1 : libspdm_get_measurement_hash_size(
1426 : m_libspdm_use_measurement_hash_algo) +
1427 : SPDM_NONCE_SIZE + sizeof(uint16_t);
1428 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1429 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1430 :
1431 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1432 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
1433 1 : spdm_response->header.param1 = 0;
1434 1 : spdm_response->header.param2 = 0;
1435 1 : spdm_response->number_of_blocks = 1;
1436 1 : libspdm_write_uint24(
1437 1 : spdm_response->measurement_record_length,
1438 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
1439 1 : libspdm_get_measurement_hash_size(
1440 : m_libspdm_use_measurement_hash_algo)));
1441 1 : measurment_block = (void *)(spdm_response + 1);
1442 1 : libspdm_set_mem(measurment_block,
1443 : sizeof(spdm_measurement_block_dmtf_t) +
1444 1 : libspdm_get_measurement_hash_size(
1445 : m_libspdm_use_measurement_hash_algo),
1446 : 1);
1447 1 : measurment_block->measurement_block_common_header.index = 1;
1448 : measurment_block->measurement_block_common_header
1449 1 : .measurement_specification = 0x00000004 | 0x00000002;
1450 : measurment_block->measurement_block_common_header
1451 1 : .measurement_size =
1452 1 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
1453 1 : libspdm_get_measurement_hash_size(
1454 : m_libspdm_use_measurement_hash_algo));
1455 :
1456 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
1457 : false, spdm_response_size,
1458 : spdm_response, response_size,
1459 : response);
1460 : }
1461 1 : return LIBSPDM_STATUS_SUCCESS;
1462 :
1463 1 : case 0x15: {
1464 : spdm_measurements_response_t *spdm_response;
1465 : spdm_measurement_block_dmtf_t *measurment_block;
1466 : size_t spdm_response_size;
1467 : size_t transport_header_size;
1468 :
1469 : ((libspdm_context_t *)spdm_context)
1470 1 : ->connection_info.algorithm.measurement_hash_algo =
1471 : m_libspdm_use_measurement_hash_algo;
1472 1 : spdm_response_size = sizeof(spdm_measurements_response_t) +
1473 : sizeof(spdm_measurement_block_dmtf_t) +
1474 1 : libspdm_get_measurement_hash_size(
1475 : m_libspdm_use_measurement_hash_algo) +
1476 : SPDM_NONCE_SIZE + sizeof(uint16_t);
1477 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1478 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1479 :
1480 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1481 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
1482 1 : spdm_response->header.param1 = 0;
1483 1 : spdm_response->header.param2 = 0;
1484 1 : spdm_response->number_of_blocks = 1;
1485 1 : libspdm_write_uint24(
1486 1 : spdm_response->measurement_record_length,
1487 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
1488 1 : libspdm_get_measurement_hash_size(
1489 : m_libspdm_use_measurement_hash_algo)));
1490 1 : measurment_block = (void *)(spdm_response + 1);
1491 1 : libspdm_set_mem(measurment_block,
1492 : sizeof(spdm_measurement_block_dmtf_t) +
1493 1 : libspdm_get_measurement_hash_size(
1494 : m_libspdm_use_measurement_hash_algo),
1495 : 1);
1496 1 : measurment_block->measurement_block_common_header.index = 1;
1497 : measurment_block->measurement_block_common_header
1498 1 : .measurement_specification =
1499 1 : (uint8_t)(m_libspdm_use_measurement_spec << 1);
1500 : measurment_block->measurement_block_common_header
1501 1 : .measurement_size =
1502 1 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
1503 1 : libspdm_get_measurement_hash_size(
1504 : m_libspdm_use_measurement_hash_algo));
1505 :
1506 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
1507 : false, spdm_response_size,
1508 : spdm_response, response_size,
1509 : response);
1510 : }
1511 1 : return LIBSPDM_STATUS_SUCCESS;
1512 :
1513 100 : case 0x16: {
1514 : spdm_measurements_response_t *spdm_response;
1515 : spdm_measurement_block_dmtf_t *measurment_block;
1516 : size_t spdm_response_size;
1517 : size_t transport_header_size;
1518 : uint8_t *ptr;
1519 : ((libspdm_context_t *)spdm_context)
1520 100 : ->connection_info.algorithm.measurement_hash_algo =
1521 : m_libspdm_use_measurement_hash_algo;
1522 100 : spdm_response_size = sizeof(spdm_measurements_response_t) +
1523 : sizeof(spdm_measurement_block_dmtf_t) +
1524 100 : libspdm_get_measurement_hash_size(
1525 : m_libspdm_use_measurement_hash_algo) +
1526 : SPDM_NONCE_SIZE + sizeof(uint16_t);
1527 100 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1528 100 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1529 :
1530 100 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1531 100 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
1532 100 : spdm_response->header.param1 = 0;
1533 100 : spdm_response->header.param2 = 0;
1534 100 : spdm_response->number_of_blocks = 1;
1535 100 : libspdm_write_uint24(
1536 100 : spdm_response->measurement_record_length,
1537 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
1538 100 : libspdm_get_measurement_hash_size(
1539 : m_libspdm_use_measurement_hash_algo)));
1540 100 : measurment_block = (void *)(spdm_response + 1);
1541 100 : libspdm_set_mem(measurment_block,
1542 : sizeof(spdm_measurement_block_dmtf_t) +
1543 100 : libspdm_get_measurement_hash_size(
1544 : m_libspdm_use_measurement_hash_algo),
1545 : 1);
1546 : measurment_block->measurement_block_common_header
1547 100 : .measurement_specification =
1548 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
1549 : measurment_block->measurement_block_common_header
1550 100 : .measurement_size =
1551 100 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
1552 100 : libspdm_get_measurement_hash_size(
1553 : m_libspdm_use_measurement_hash_algo));
1554 100 : *(uint16_t *)((uint8_t *)spdm_response +
1555 : sizeof(spdm_measurements_response_t) +
1556 100 : sizeof(spdm_measurement_block_dmtf_t) +
1557 100 : libspdm_get_measurement_hash_size(
1558 100 : m_libspdm_use_measurement_hash_algo)) = 0;
1559 100 : ptr = (uint8_t *)spdm_response + spdm_response_size - SPDM_NONCE_SIZE - sizeof(uint16_t);
1560 100 : libspdm_get_random_number(SPDM_NONCE_SIZE,ptr);
1561 100 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
1562 : false, spdm_response_size,
1563 : spdm_response, response_size,
1564 : response);
1565 : }
1566 100 : return LIBSPDM_STATUS_SUCCESS;
1567 :
1568 0 : case 0x17: {
1569 : spdm_measurements_response_t *spdm_response;
1570 : uint8_t *ptr;
1571 : spdm_measurement_block_dmtf_t *measurment_block;
1572 : size_t spdm_response_size;
1573 : size_t transport_header_size;
1574 :
1575 : ((libspdm_context_t *)spdm_context)
1576 0 : ->connection_info.algorithm.measurement_hash_algo =
1577 : m_libspdm_use_measurement_hash_algo;
1578 0 : spdm_response_size = sizeof(spdm_measurements_response_t) +
1579 : sizeof(spdm_measurement_block_dmtf_t) +
1580 0 : libspdm_get_measurement_hash_size(
1581 : m_libspdm_use_measurement_hash_algo) +
1582 : SPDM_NONCE_SIZE +
1583 : sizeof(uint16_t) + SPDM_MAX_OPAQUE_DATA_SIZE;
1584 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1585 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1586 :
1587 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1588 0 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
1589 0 : spdm_response->header.param1 = 0;
1590 0 : spdm_response->header.param2 = 0;
1591 0 : spdm_response->number_of_blocks = 1;
1592 0 : libspdm_write_uint24(
1593 0 : spdm_response->measurement_record_length,
1594 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
1595 0 : libspdm_get_measurement_hash_size(
1596 : m_libspdm_use_measurement_hash_algo)));
1597 0 : measurment_block = (void *)(spdm_response + 1);
1598 0 : libspdm_set_mem(measurment_block,
1599 : sizeof(spdm_measurement_block_dmtf_t) +
1600 0 : libspdm_get_measurement_hash_size(
1601 : m_libspdm_use_measurement_hash_algo),
1602 : 1);
1603 : measurment_block->measurement_block_common_header
1604 0 : .measurement_specification =
1605 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
1606 : measurment_block->measurement_block_common_header
1607 0 : .measurement_size =
1608 0 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
1609 0 : libspdm_get_measurement_hash_size(
1610 : m_libspdm_use_measurement_hash_algo));
1611 : /* adding extra fields: opaque_length, opaque_data*/
1612 0 : ptr = (void *)((uint8_t *)spdm_response +
1613 : sizeof(spdm_measurements_response_t) +
1614 0 : sizeof(spdm_measurement_block_dmtf_t) +
1615 0 : libspdm_get_measurement_hash_size(
1616 : m_libspdm_use_measurement_hash_algo));
1617 0 : libspdm_get_random_number (SPDM_NONCE_SIZE, ptr);
1618 0 : ptr += SPDM_NONCE_SIZE;
1619 0 : *(uint16_t *)ptr = SPDM_MAX_OPAQUE_DATA_SIZE; /* opaque_length*/
1620 0 : ptr += sizeof(uint16_t);
1621 0 : libspdm_set_mem(ptr, SPDM_MAX_OPAQUE_DATA_SIZE, 255);
1622 0 : ptr += SPDM_MAX_OPAQUE_DATA_SIZE;
1623 :
1624 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
1625 : false, spdm_response_size,
1626 : spdm_response, response_size,
1627 : response);
1628 : }
1629 0 : return LIBSPDM_STATUS_SUCCESS;
1630 :
1631 1 : case 0x18: {
1632 : spdm_measurements_response_t *spdm_response;
1633 : uint8_t *ptr;
1634 : spdm_measurement_block_dmtf_t *measurment_block;
1635 : size_t spdm_response_size;
1636 : size_t transport_header_size;
1637 :
1638 : ((libspdm_context_t *)spdm_context)
1639 1 : ->connection_info.algorithm.measurement_hash_algo =
1640 : m_libspdm_use_measurement_hash_algo;
1641 1 : spdm_response_size = sizeof(spdm_measurements_response_t) +
1642 : sizeof(spdm_measurement_block_dmtf_t) +
1643 1 : libspdm_get_measurement_hash_size(
1644 : m_libspdm_use_measurement_hash_algo) +
1645 : SPDM_NONCE_SIZE +
1646 : sizeof(uint16_t) +
1647 : (SPDM_MAX_OPAQUE_DATA_SIZE + 1);
1648 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1649 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1650 :
1651 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1652 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
1653 1 : spdm_response->header.param1 = 0;
1654 1 : spdm_response->header.param2 = 0;
1655 1 : spdm_response->number_of_blocks = 1;
1656 1 : libspdm_write_uint24(
1657 1 : spdm_response->measurement_record_length,
1658 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
1659 1 : libspdm_get_measurement_hash_size(
1660 : m_libspdm_use_measurement_hash_algo)));
1661 1 : measurment_block = (void *)(spdm_response + 1);
1662 1 : libspdm_set_mem(measurment_block,
1663 : sizeof(spdm_measurement_block_dmtf_t) +
1664 1 : libspdm_get_measurement_hash_size(
1665 : m_libspdm_use_measurement_hash_algo),
1666 : 1);
1667 : measurment_block->measurement_block_common_header
1668 1 : .measurement_specification =
1669 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
1670 : measurment_block->measurement_block_common_header
1671 1 : .measurement_size =
1672 1 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
1673 1 : libspdm_get_measurement_hash_size(
1674 : m_libspdm_use_measurement_hash_algo));
1675 : /* adding extra fields: opaque_length, opaque_data*/
1676 1 : ptr = (void *)((uint8_t *)spdm_response +
1677 : sizeof(spdm_measurements_response_t) +
1678 1 : sizeof(spdm_measurement_block_dmtf_t) +
1679 1 : libspdm_get_measurement_hash_size(
1680 : m_libspdm_use_measurement_hash_algo));
1681 1 : ptr += SPDM_NONCE_SIZE;
1682 1 : *(uint16_t *)ptr =
1683 : (SPDM_MAX_OPAQUE_DATA_SIZE + 1); /* opaque_length*/
1684 1 : ptr += sizeof(uint16_t);
1685 1 : libspdm_set_mem(ptr, (SPDM_MAX_OPAQUE_DATA_SIZE + 1), 255);
1686 1 : ptr += (SPDM_MAX_OPAQUE_DATA_SIZE + 1);
1687 :
1688 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
1689 : false, spdm_response_size,
1690 : spdm_response, response_size,
1691 : response);
1692 : }
1693 1 : return LIBSPDM_STATUS_SUCCESS;
1694 :
1695 1 : case 0x19: {
1696 : spdm_measurements_response_t *spdm_response;
1697 : uint8_t *ptr;
1698 : uint8_t hash_data[LIBSPDM_MAX_HASH_SIZE];
1699 : size_t sig_size;
1700 : size_t measurment_sig_size;
1701 : spdm_measurement_block_dmtf_t *measurment_block;
1702 : size_t spdm_response_size;
1703 : size_t transport_header_size;
1704 1 : uint16_t opaque_size_test = SPDM_MAX_OPAQUE_DATA_SIZE;
1705 :
1706 : ((libspdm_context_t *)spdm_context)
1707 1 : ->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1708 : ((libspdm_context_t *)spdm_context)
1709 1 : ->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1710 : ((libspdm_context_t *)spdm_context)
1711 1 : ->connection_info.algorithm.measurement_hash_algo = m_libspdm_use_measurement_hash_algo;
1712 1 : measurment_sig_size =
1713 2 : SPDM_NONCE_SIZE + sizeof(uint16_t) + opaque_size_test +
1714 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1715 1 : spdm_response_size = sizeof(spdm_measurements_response_t) +
1716 : sizeof(spdm_measurement_block_dmtf_t) +
1717 1 : libspdm_get_measurement_hash_size(
1718 1 : m_libspdm_use_measurement_hash_algo) + measurment_sig_size;
1719 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1720 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1721 :
1722 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1723 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
1724 1 : spdm_response->header.param1 = 0;
1725 1 : spdm_response->header.param2 = SPDM_MEASUREMENTS_RESPONSE_CONTENT_CHANGE_DETECTED;
1726 1 : spdm_response->number_of_blocks = 1;
1727 1 : libspdm_write_uint24(
1728 1 : spdm_response->measurement_record_length,
1729 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
1730 1 : libspdm_get_measurement_hash_size(
1731 : m_libspdm_use_measurement_hash_algo)));
1732 1 : measurment_block = (void *)(spdm_response + 1);
1733 1 : libspdm_set_mem(measurment_block,
1734 : sizeof(spdm_measurement_block_dmtf_t) +
1735 1 : libspdm_get_measurement_hash_size(
1736 : m_libspdm_use_measurement_hash_algo), 1);
1737 : measurment_block->measurement_block_common_header
1738 1 : .measurement_specification = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
1739 : measurment_block->measurement_block_common_header
1740 1 : .measurement_size =
1741 1 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
1742 1 : libspdm_get_measurement_hash_size(
1743 : m_libspdm_use_measurement_hash_algo));
1744 1 : ptr = (void *)((uint8_t *)spdm_response + spdm_response_size - measurment_sig_size);
1745 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
1746 1 : ptr += SPDM_NONCE_SIZE;
1747 :
1748 1 : *(uint16_t *)ptr = opaque_size_test; /* opaque_length*/
1749 1 : ptr += sizeof(uint16_t);
1750 1 : libspdm_set_mem(ptr, opaque_size_test, 255);
1751 1 : ptr += opaque_size_test;
1752 :
1753 1 : libspdm_copy_mem(&m_libspdm_local_buffer[m_libspdm_local_buffer_size],
1754 : sizeof(m_libspdm_local_buffer)
1755 1 : - (&m_libspdm_local_buffer[m_libspdm_local_buffer_size] -
1756 : m_libspdm_local_buffer),
1757 1 : spdm_response, (size_t)ptr - (size_t)spdm_response);
1758 1 : m_libspdm_local_buffer_size += ((size_t)ptr - (size_t)spdm_response);
1759 1 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "m_libspdm_local_buffer_size (0x%zx):\n",
1760 : m_libspdm_local_buffer_size));
1761 1 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
1762 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_buffer,
1763 : m_libspdm_local_buffer_size, hash_data);
1764 1 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "HashDataSize (0x%x):\n",
1765 : libspdm_get_hash_size(m_libspdm_use_hash_algo)));
1766 1 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
1767 1 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1768 1 : libspdm_responder_data_sign(
1769 : spdm_context,
1770 1 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
1771 : SPDM_MEASUREMENTS,
1772 : m_libspdm_use_asym_algo, m_libspdm_use_pqc_asym_algo, m_libspdm_use_hash_algo,
1773 : false, m_libspdm_local_buffer, m_libspdm_local_buffer_size,
1774 : ptr, &sig_size);
1775 1 : ptr += sig_size;
1776 :
1777 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
1778 : false, spdm_response_size,
1779 : spdm_response, response_size,
1780 : response);
1781 : }
1782 1 : return LIBSPDM_STATUS_SUCCESS;
1783 :
1784 1 : case 0x1A: {
1785 : spdm_measurements_response_t *spdm_response;
1786 : uint8_t *ptr;
1787 : uint8_t hash_data[LIBSPDM_MAX_HASH_SIZE];
1788 : size_t sig_size;
1789 : size_t measurment_sig_size;
1790 : spdm_measurement_block_dmtf_t *measurment_block;
1791 : size_t spdm_response_size;
1792 : size_t transport_header_size;
1793 : size_t MissingBytes;
1794 1 : uint16_t opaque_size_test = SPDM_MAX_OPAQUE_DATA_SIZE;
1795 :
1796 1 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1797 1 : MissingBytes = sig_size;
1798 :
1799 : ((libspdm_context_t *)spdm_context)
1800 1 : ->connection_info.algorithm.base_asym_algo =
1801 : m_libspdm_use_asym_algo;
1802 : ((libspdm_context_t *)spdm_context)
1803 1 : ->connection_info.algorithm.base_hash_algo =
1804 : m_libspdm_use_hash_algo;
1805 : ((libspdm_context_t *)spdm_context)
1806 1 : ->connection_info.algorithm.measurement_hash_algo =
1807 : m_libspdm_use_measurement_hash_algo;
1808 1 : measurment_sig_size =
1809 : SPDM_NONCE_SIZE + sizeof(uint16_t) +
1810 2 : (opaque_size_test - MissingBytes) +
1811 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1812 1 : spdm_response_size = sizeof(spdm_measurements_response_t) +
1813 : sizeof(spdm_measurement_block_dmtf_t) +
1814 1 : libspdm_get_measurement_hash_size(
1815 1 : m_libspdm_use_measurement_hash_algo) +
1816 : measurment_sig_size;
1817 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1818 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1819 :
1820 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1821 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
1822 1 : spdm_response->header.param1 = 0;
1823 1 : spdm_response->header.param2 = 0;
1824 1 : spdm_response->number_of_blocks = 1;
1825 1 : libspdm_write_uint24(
1826 1 : spdm_response->measurement_record_length,
1827 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
1828 1 : libspdm_get_measurement_hash_size(
1829 : m_libspdm_use_measurement_hash_algo)));
1830 1 : measurment_block = (void *)(spdm_response + 1);
1831 1 : libspdm_set_mem(measurment_block,
1832 : sizeof(spdm_measurement_block_dmtf_t) +
1833 1 : libspdm_get_measurement_hash_size(
1834 : m_libspdm_use_measurement_hash_algo),
1835 : 1);
1836 : measurment_block->measurement_block_common_header
1837 1 : .measurement_specification =
1838 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
1839 : measurment_block->measurement_block_common_header
1840 1 : .measurement_size =
1841 1 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
1842 1 : libspdm_get_measurement_hash_size(
1843 : m_libspdm_use_measurement_hash_algo));
1844 1 : ptr = (void *)((uint8_t *)spdm_response + spdm_response_size -
1845 : measurment_sig_size);
1846 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
1847 1 : ptr += SPDM_NONCE_SIZE;
1848 :
1849 1 : *(uint16_t *)ptr = opaque_size_test; /* opaque_length*/
1850 1 : ptr += sizeof(uint16_t);
1851 1 : libspdm_set_mem(ptr, opaque_size_test - MissingBytes, 255);
1852 1 : ptr += (opaque_size_test - MissingBytes);
1853 :
1854 1 : libspdm_copy_mem(&m_libspdm_local_buffer[m_libspdm_local_buffer_size],
1855 : sizeof(m_libspdm_local_buffer)
1856 1 : - (&m_libspdm_local_buffer[m_libspdm_local_buffer_size] -
1857 : m_libspdm_local_buffer),
1858 1 : spdm_response, (size_t)ptr - (size_t)spdm_response);
1859 1 : m_libspdm_local_buffer_size += ((size_t)ptr - (size_t)spdm_response);
1860 1 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "m_libspdm_local_buffer_size (0x%zx):\n",
1861 : m_libspdm_local_buffer_size));
1862 1 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
1863 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_buffer,
1864 : m_libspdm_local_buffer_size, hash_data);
1865 1 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "HashDataSize (0x%x):\n",
1866 : libspdm_get_hash_size(m_libspdm_use_hash_algo)));
1867 1 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
1868 1 : libspdm_responder_data_sign(
1869 : spdm_context,
1870 1 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
1871 : SPDM_MEASUREMENTS,
1872 : m_libspdm_use_asym_algo, m_libspdm_use_pqc_asym_algo, m_libspdm_use_hash_algo,
1873 : false, m_libspdm_local_buffer, m_libspdm_local_buffer_size,
1874 : ptr, &sig_size);
1875 1 : ptr += sig_size;
1876 :
1877 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
1878 : false, spdm_response_size,
1879 : spdm_response, response_size,
1880 : response);
1881 : }
1882 1 : return LIBSPDM_STATUS_SUCCESS;
1883 :
1884 1 : case 0x1B: {
1885 : spdm_measurements_response_t *spdm_response;
1886 : uint8_t *ptr;
1887 : uint8_t hash_data[LIBSPDM_MAX_HASH_SIZE];
1888 : size_t sig_size;
1889 : size_t measurment_sig_size;
1890 : spdm_measurement_block_dmtf_t *measurment_block;
1891 : size_t spdm_response_size;
1892 : size_t transport_header_size;
1893 : size_t MissingBytes;
1894 1 : uint16_t opaque_size_test = SPDM_MAX_OPAQUE_DATA_SIZE;
1895 :
1896 1 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1897 1 : MissingBytes = sig_size + 1;
1898 :
1899 : ((libspdm_context_t *)spdm_context)
1900 1 : ->connection_info.algorithm.base_asym_algo =
1901 : m_libspdm_use_asym_algo;
1902 : ((libspdm_context_t *)spdm_context)
1903 1 : ->connection_info.algorithm.base_hash_algo =
1904 : m_libspdm_use_hash_algo;
1905 : ((libspdm_context_t *)spdm_context)
1906 1 : ->connection_info.algorithm.measurement_hash_algo =
1907 : m_libspdm_use_measurement_hash_algo;
1908 1 : measurment_sig_size =
1909 : SPDM_NONCE_SIZE + sizeof(uint16_t) +
1910 2 : (opaque_size_test - MissingBytes) +
1911 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1912 1 : spdm_response_size = sizeof(spdm_measurements_response_t) +
1913 : sizeof(spdm_measurement_block_dmtf_t) +
1914 1 : libspdm_get_measurement_hash_size(
1915 1 : m_libspdm_use_measurement_hash_algo) +
1916 : measurment_sig_size;
1917 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1918 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1919 :
1920 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1921 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
1922 1 : spdm_response->header.param1 = 0;
1923 1 : spdm_response->header.param2 = 0;
1924 1 : spdm_response->number_of_blocks = 1;
1925 1 : libspdm_write_uint24(
1926 1 : spdm_response->measurement_record_length,
1927 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
1928 1 : libspdm_get_measurement_hash_size(
1929 : m_libspdm_use_measurement_hash_algo)));
1930 1 : measurment_block = (void *)(spdm_response + 1);
1931 1 : libspdm_set_mem(measurment_block,
1932 : sizeof(spdm_measurement_block_dmtf_t) +
1933 1 : libspdm_get_measurement_hash_size(
1934 : m_libspdm_use_measurement_hash_algo),
1935 : 1);
1936 : measurment_block->measurement_block_common_header
1937 1 : .measurement_specification =
1938 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
1939 : measurment_block->measurement_block_common_header
1940 1 : .measurement_size =
1941 1 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
1942 1 : libspdm_get_measurement_hash_size(
1943 : m_libspdm_use_measurement_hash_algo));
1944 1 : ptr = (void *)((uint8_t *)spdm_response + spdm_response_size -
1945 : measurment_sig_size);
1946 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
1947 1 : ptr += SPDM_NONCE_SIZE;
1948 :
1949 1 : *(uint16_t *)ptr = opaque_size_test; /* opaque_length*/
1950 1 : ptr += sizeof(uint16_t);
1951 1 : libspdm_set_mem(ptr, opaque_size_test - MissingBytes, 255);
1952 1 : ptr += (opaque_size_test - MissingBytes);
1953 :
1954 1 : libspdm_copy_mem(&m_libspdm_local_buffer[m_libspdm_local_buffer_size],
1955 : sizeof(m_libspdm_local_buffer)
1956 1 : - (&m_libspdm_local_buffer[m_libspdm_local_buffer_size] -
1957 : m_libspdm_local_buffer),
1958 1 : spdm_response, (size_t)ptr - (size_t)spdm_response);
1959 1 : m_libspdm_local_buffer_size += ((size_t)ptr - (size_t)spdm_response);
1960 1 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "m_libspdm_local_buffer_size (0x%zx):\n",
1961 : m_libspdm_local_buffer_size));
1962 1 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
1963 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_buffer,
1964 : m_libspdm_local_buffer_size, hash_data);
1965 1 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "HashDataSize (0x%x):\n",
1966 : libspdm_get_hash_size(m_libspdm_use_hash_algo)));
1967 1 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
1968 1 : libspdm_responder_data_sign(
1969 : spdm_context,
1970 1 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
1971 : SPDM_MEASUREMENTS,
1972 : m_libspdm_use_asym_algo, m_libspdm_use_pqc_asym_algo, m_libspdm_use_hash_algo,
1973 : false, m_libspdm_local_buffer, m_libspdm_local_buffer_size,
1974 : ptr, &sig_size);
1975 1 : ptr += sig_size;
1976 :
1977 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
1978 : false, spdm_response_size,
1979 : spdm_response, response_size,
1980 : response);
1981 : }
1982 1 : return LIBSPDM_STATUS_SUCCESS;
1983 :
1984 1 : case 0x1C: {
1985 : spdm_measurements_response_t *spdm_response;
1986 : uint8_t *ptr;
1987 : uint8_t hash_data[LIBSPDM_MAX_HASH_SIZE];
1988 : size_t sig_size;
1989 : size_t measurment_sig_size;
1990 : spdm_measurement_block_dmtf_t *measurment_block;
1991 : size_t spdm_response_size;
1992 : size_t transport_header_size;
1993 1 : uint16_t opaque_size_test = SPDM_MAX_OPAQUE_DATA_SIZE / 2;
1994 1 : uint16_t opaque_informed_size = opaque_size_test - 1;
1995 :
1996 1 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
1997 :
1998 : ((libspdm_context_t *)spdm_context)
1999 1 : ->connection_info.algorithm.base_asym_algo =
2000 : m_libspdm_use_asym_algo;
2001 : ((libspdm_context_t *)spdm_context)
2002 1 : ->connection_info.algorithm.base_hash_algo =
2003 : m_libspdm_use_hash_algo;
2004 : ((libspdm_context_t *)spdm_context)
2005 1 : ->connection_info.algorithm.measurement_hash_algo =
2006 : m_libspdm_use_measurement_hash_algo;
2007 1 : measurment_sig_size =
2008 2 : SPDM_NONCE_SIZE + sizeof(uint16_t) + opaque_size_test +
2009 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2010 1 : spdm_response_size = sizeof(spdm_measurements_response_t) +
2011 : sizeof(spdm_measurement_block_dmtf_t) +
2012 1 : libspdm_get_measurement_hash_size(
2013 1 : m_libspdm_use_measurement_hash_algo) +
2014 : measurment_sig_size;
2015 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2016 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2017 :
2018 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2019 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
2020 1 : spdm_response->header.param1 = 0;
2021 1 : spdm_response->header.param2 = 0;
2022 1 : spdm_response->number_of_blocks = 1;
2023 1 : libspdm_write_uint24(
2024 1 : spdm_response->measurement_record_length,
2025 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
2026 1 : libspdm_get_measurement_hash_size(
2027 : m_libspdm_use_measurement_hash_algo)));
2028 1 : measurment_block = (void *)(spdm_response + 1);
2029 1 : libspdm_set_mem(measurment_block,
2030 : sizeof(spdm_measurement_block_dmtf_t) +
2031 1 : libspdm_get_measurement_hash_size(
2032 : m_libspdm_use_measurement_hash_algo),
2033 : 1);
2034 : measurment_block->measurement_block_common_header
2035 1 : .measurement_specification =
2036 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
2037 : measurment_block->measurement_block_common_header
2038 1 : .measurement_size =
2039 1 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
2040 1 : libspdm_get_measurement_hash_size(
2041 : m_libspdm_use_measurement_hash_algo));
2042 1 : ptr = (void *)((uint8_t *)spdm_response + spdm_response_size -
2043 : measurment_sig_size);
2044 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
2045 1 : ptr += SPDM_NONCE_SIZE;
2046 :
2047 1 : *(uint16_t *)ptr = opaque_informed_size; /* opaque_length*/
2048 1 : ptr += sizeof(uint16_t);
2049 1 : libspdm_set_mem(ptr, opaque_size_test, 255);
2050 1 : ptr += (opaque_size_test);
2051 :
2052 1 : libspdm_copy_mem(&m_libspdm_local_buffer[m_libspdm_local_buffer_size],
2053 : sizeof(m_libspdm_local_buffer)
2054 1 : - (&m_libspdm_local_buffer[m_libspdm_local_buffer_size] -
2055 : m_libspdm_local_buffer),
2056 1 : spdm_response, (size_t)ptr - (size_t)spdm_response);
2057 1 : m_libspdm_local_buffer_size += ((size_t)ptr - (size_t)spdm_response);
2058 1 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "m_libspdm_local_buffer_size (0x%zx):\n",
2059 : m_libspdm_local_buffer_size));
2060 1 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
2061 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_buffer,
2062 : m_libspdm_local_buffer_size, hash_data);
2063 1 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "HashDataSize (0x%x):\n",
2064 : libspdm_get_hash_size(m_libspdm_use_hash_algo)));
2065 1 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
2066 1 : libspdm_responder_data_sign(
2067 : spdm_context,
2068 1 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
2069 : SPDM_MEASUREMENTS,
2070 : m_libspdm_use_asym_algo, m_libspdm_use_pqc_asym_algo, m_libspdm_use_hash_algo,
2071 : false, m_libspdm_local_buffer, m_libspdm_local_buffer_size,
2072 : ptr, &sig_size);
2073 1 : ptr += sig_size;
2074 :
2075 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
2076 : false, spdm_response_size,
2077 : spdm_response, response_size,
2078 : response);
2079 : }
2080 1 : return LIBSPDM_STATUS_SUCCESS;
2081 :
2082 0 : case 0x1D: {
2083 : spdm_measurements_response_t *spdm_response;
2084 : uint8_t *ptr;
2085 : spdm_measurement_block_dmtf_t *measurment_block;
2086 : size_t spdm_response_size;
2087 : size_t transport_header_size;
2088 0 : uint16_t opaque_size_test = SPDM_MAX_OPAQUE_DATA_SIZE / 2;
2089 0 : uint16_t opaque_informed_size = opaque_size_test - 1;
2090 :
2091 : ((libspdm_context_t *)spdm_context)
2092 0 : ->connection_info.algorithm.measurement_hash_algo =
2093 : m_libspdm_use_measurement_hash_algo;
2094 0 : spdm_response_size = sizeof(spdm_measurements_response_t) +
2095 : sizeof(spdm_measurement_block_dmtf_t) +
2096 0 : libspdm_get_measurement_hash_size(
2097 : m_libspdm_use_measurement_hash_algo) +
2098 : SPDM_NONCE_SIZE +
2099 0 : sizeof(uint16_t) + opaque_size_test;
2100 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2101 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2102 :
2103 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2104 0 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
2105 0 : spdm_response->header.param1 = 0;
2106 0 : spdm_response->header.param2 = 0;
2107 0 : spdm_response->number_of_blocks = 1;
2108 0 : libspdm_write_uint24(
2109 0 : spdm_response->measurement_record_length,
2110 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
2111 0 : libspdm_get_measurement_hash_size(
2112 : m_libspdm_use_measurement_hash_algo)));
2113 0 : measurment_block = (void *)(spdm_response + 1);
2114 0 : libspdm_set_mem(measurment_block,
2115 : sizeof(spdm_measurement_block_dmtf_t) +
2116 0 : libspdm_get_measurement_hash_size(
2117 : m_libspdm_use_measurement_hash_algo),
2118 : 1);
2119 : measurment_block->measurement_block_common_header
2120 0 : .measurement_specification =
2121 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
2122 : measurment_block->measurement_block_common_header
2123 0 : .measurement_size =
2124 0 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
2125 0 : libspdm_get_measurement_hash_size(
2126 : m_libspdm_use_measurement_hash_algo));
2127 : /* adding extra fields: opaque_length, opaque_data*/
2128 0 : ptr = (void *)((uint8_t *)spdm_response +
2129 : sizeof(spdm_measurements_response_t) +
2130 0 : sizeof(spdm_measurement_block_dmtf_t) +
2131 0 : libspdm_get_measurement_hash_size(
2132 : m_libspdm_use_measurement_hash_algo));
2133 0 : libspdm_get_random_number (SPDM_NONCE_SIZE, ptr);
2134 0 : ptr += SPDM_NONCE_SIZE;
2135 0 : *(uint16_t *)ptr = opaque_informed_size; /* opaque_length*/
2136 0 : ptr += sizeof(uint16_t);
2137 0 : libspdm_set_mem(ptr, opaque_size_test, 255);
2138 0 : ptr += opaque_size_test;
2139 :
2140 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
2141 : false, spdm_response_size,
2142 : spdm_response, response_size,
2143 : response);
2144 : }
2145 0 : return LIBSPDM_STATUS_SUCCESS;
2146 :
2147 0 : case 0x1E: {
2148 : spdm_measurements_response_t *spdm_response;
2149 : uint8_t *ptr;
2150 : spdm_measurement_block_dmtf_t *measurment_block;
2151 : size_t spdm_response_size;
2152 : size_t transport_header_size;
2153 0 : uint16_t opaque_size_test = 0xFFFF;
2154 0 : uint16_t opaque_informed_size = SPDM_MAX_OPAQUE_DATA_SIZE / 2;
2155 :
2156 : ((libspdm_context_t *)spdm_context)
2157 0 : ->connection_info.algorithm.measurement_hash_algo =
2158 : m_libspdm_use_measurement_hash_algo;
2159 0 : spdm_response_size = sizeof(spdm_measurements_response_t) +
2160 : sizeof(spdm_measurement_block_dmtf_t) +
2161 0 : libspdm_get_measurement_hash_size(
2162 : m_libspdm_use_measurement_hash_algo) +
2163 : SPDM_NONCE_SIZE +
2164 0 : sizeof(uint16_t) + opaque_size_test;
2165 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2166 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2167 :
2168 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2169 0 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
2170 0 : spdm_response->header.param1 = 0;
2171 0 : spdm_response->header.param2 = 0;
2172 0 : spdm_response->number_of_blocks = 1;
2173 0 : libspdm_write_uint24(
2174 0 : spdm_response->measurement_record_length,
2175 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
2176 0 : libspdm_get_measurement_hash_size(
2177 : m_libspdm_use_measurement_hash_algo)));
2178 0 : measurment_block = (void *)(spdm_response + 1);
2179 0 : libspdm_set_mem(measurment_block,
2180 : sizeof(spdm_measurement_block_dmtf_t) +
2181 0 : libspdm_get_measurement_hash_size(
2182 : m_libspdm_use_measurement_hash_algo),
2183 : 1);
2184 : measurment_block->measurement_block_common_header
2185 0 : .measurement_specification =
2186 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
2187 : measurment_block->measurement_block_common_header
2188 0 : .measurement_size =
2189 0 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
2190 0 : libspdm_get_measurement_hash_size(
2191 : m_libspdm_use_measurement_hash_algo));
2192 : /* adding extra fields: NONCE, opaque_length, opaque_data*/
2193 0 : ptr = (void *)((uint8_t *)spdm_response +
2194 : sizeof(spdm_measurements_response_t) +
2195 0 : sizeof(spdm_measurement_block_dmtf_t) +
2196 0 : libspdm_get_measurement_hash_size(
2197 : m_libspdm_use_measurement_hash_algo));
2198 0 : ptr += SPDM_NONCE_SIZE;
2199 0 : *(uint16_t *)ptr = opaque_informed_size; /* opaque_length*/
2200 0 : ptr += sizeof(uint16_t);
2201 0 : libspdm_set_mem(ptr, opaque_size_test, 255);
2202 0 : ptr += opaque_size_test;
2203 :
2204 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
2205 : false, spdm_response_size,
2206 : spdm_response, response_size,
2207 : response);
2208 : }
2209 0 : return LIBSPDM_STATUS_SUCCESS;
2210 :
2211 0 : case 0x1F: {
2212 : spdm_measurements_response_t *spdm_response;
2213 : uint8_t *ptr;
2214 : spdm_measurement_block_dmtf_t *measurment_block;
2215 : size_t spdm_response_size;
2216 : size_t transport_header_size;
2217 0 : uint16_t opaque_size_test = 0xFFFF;
2218 :
2219 : ((libspdm_context_t *)spdm_context)
2220 0 : ->connection_info.algorithm.measurement_hash_algo =
2221 : m_libspdm_use_measurement_hash_algo;
2222 0 : spdm_response_size = sizeof(spdm_measurements_response_t) +
2223 : sizeof(spdm_measurement_block_dmtf_t) +
2224 0 : libspdm_get_measurement_hash_size(
2225 : m_libspdm_use_measurement_hash_algo) +
2226 0 : SPDM_NONCE_SIZE + sizeof(uint16_t) +
2227 : opaque_size_test;
2228 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2229 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2230 :
2231 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2232 0 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
2233 0 : spdm_response->header.param1 = 0;
2234 0 : spdm_response->header.param2 = 0;
2235 0 : spdm_response->number_of_blocks = 1;
2236 0 : libspdm_write_uint24(
2237 0 : spdm_response->measurement_record_length,
2238 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
2239 0 : libspdm_get_measurement_hash_size(
2240 : m_libspdm_use_measurement_hash_algo)));
2241 0 : measurment_block = (void *)(spdm_response + 1);
2242 0 : libspdm_set_mem(measurment_block,
2243 : sizeof(spdm_measurement_block_dmtf_t) +
2244 0 : libspdm_get_measurement_hash_size(
2245 : m_libspdm_use_measurement_hash_algo),
2246 : 1);
2247 : measurment_block->measurement_block_common_header
2248 0 : .measurement_specification =
2249 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
2250 : measurment_block->measurement_block_common_header
2251 0 : .measurement_size =
2252 0 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
2253 0 : libspdm_get_measurement_hash_size(
2254 : m_libspdm_use_measurement_hash_algo));
2255 : /* adding extra fields: NONCE, opaque_length, opaque_data*/
2256 0 : ptr = (void *)((uint8_t *)spdm_response +
2257 : sizeof(spdm_measurements_response_t) +
2258 0 : sizeof(spdm_measurement_block_dmtf_t) +
2259 0 : libspdm_get_measurement_hash_size(
2260 : m_libspdm_use_measurement_hash_algo));
2261 0 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
2262 0 : ptr += SPDM_NONCE_SIZE;
2263 0 : *(uint16_t *)ptr = (opaque_size_test); /* opaque_length*/
2264 0 : ptr += sizeof(uint16_t);
2265 0 : libspdm_set_mem(ptr, (opaque_size_test), 255);
2266 0 : ptr += (opaque_size_test);
2267 :
2268 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
2269 : false, spdm_response_size,
2270 : spdm_response, response_size,
2271 : response);
2272 : }
2273 0 : return LIBSPDM_STATUS_SUCCESS;
2274 :
2275 0 : case 0x20: {
2276 : spdm_measurements_response_t *spdm_response;
2277 : spdm_measurement_block_dmtf_t *measurment_block;
2278 : size_t spdm_response_size;
2279 : size_t transport_header_size;
2280 : uint8_t *ptr;
2281 : ((libspdm_context_t *)spdm_context)
2282 0 : ->connection_info.algorithm.measurement_hash_algo =
2283 : m_libspdm_use_measurement_hash_algo;
2284 0 : spdm_response_size = sizeof(spdm_measurements_response_t) +
2285 : 2 * (sizeof(spdm_measurement_block_dmtf_t) +
2286 0 : libspdm_get_measurement_hash_size(
2287 0 : m_libspdm_use_measurement_hash_algo)) +
2288 : SPDM_NONCE_SIZE;
2289 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2290 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2291 :
2292 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2293 0 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
2294 0 : spdm_response->header.param1 = 0;
2295 0 : spdm_response->header.param2 = 0;
2296 0 : spdm_response->number_of_blocks = 2;
2297 0 : *(uint32_t *)spdm_response->measurement_record_length =
2298 0 : 2 * ((uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
2299 0 : libspdm_get_measurement_hash_size(
2300 : m_libspdm_use_measurement_hash_algo)));
2301 0 : measurment_block = (void *)(spdm_response + 1);
2302 0 : libspdm_set_mem(measurment_block,
2303 0 : 2 * (sizeof(spdm_measurement_block_dmtf_t) +
2304 0 : libspdm_get_measurement_hash_size(
2305 : m_libspdm_use_measurement_hash_algo)),
2306 : 1);
2307 0 : measurment_block->measurement_block_common_header.index = 1;
2308 : measurment_block->measurement_block_common_header
2309 0 : .measurement_specification =
2310 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
2311 : measurment_block->measurement_block_common_header
2312 0 : .measurement_size =
2313 0 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
2314 0 : libspdm_get_measurement_hash_size(
2315 : m_libspdm_use_measurement_hash_algo));
2316 0 : measurment_block =
2317 : (void *)(((uint8_t *)measurment_block) +
2318 0 : (sizeof(spdm_measurement_block_dmtf_t) +
2319 0 : libspdm_get_measurement_hash_size(
2320 : m_libspdm_use_measurement_hash_algo)));
2321 0 : measurment_block->measurement_block_common_header.index = 2;
2322 : measurment_block->measurement_block_common_header
2323 0 : .measurement_specification =
2324 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
2325 : measurment_block->measurement_block_common_header
2326 0 : .measurement_size =
2327 0 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
2328 0 : libspdm_get_measurement_hash_size(
2329 : m_libspdm_use_measurement_hash_algo));
2330 0 : ptr = (uint8_t *)spdm_response + spdm_response_size - SPDM_NONCE_SIZE;
2331 0 : libspdm_get_random_number(SPDM_NONCE_SIZE,ptr);
2332 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
2333 : false, spdm_response_size,
2334 : spdm_response, response_size,
2335 : response);
2336 : }
2337 0 : return LIBSPDM_STATUS_SUCCESS;
2338 :
2339 18 : case 0x21:
2340 : {
2341 : static uint16_t error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
2342 :
2343 : spdm_error_response_t *spdm_response;
2344 : size_t spdm_response_size;
2345 : size_t transport_header_size;
2346 :
2347 18 : spdm_response_size = sizeof(spdm_error_response_t);
2348 18 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2349 18 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2350 :
2351 18 : if(error_code <= 0xff) {
2352 18 : libspdm_zero_mem (spdm_response, spdm_response_size);
2353 18 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2354 18 : spdm_response->header.request_response_code = SPDM_ERROR;
2355 18 : spdm_response->header.param1 = (uint8_t) error_code;
2356 18 : spdm_response->header.param2 = 0;
2357 :
2358 18 : libspdm_transport_test_encode_message (spdm_context, NULL, false, false,
2359 : spdm_response_size, spdm_response,
2360 : response_size, response);
2361 : }
2362 :
2363 18 : error_code++;
2364 18 : if(error_code == SPDM_ERROR_CODE_BUSY) { /*busy is treated in cases 5 and 6*/
2365 1 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
2366 : }
2367 18 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) { /*skip some reserved error codes (0d to 3e)*/
2368 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
2369 : }
2370 18 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) { /*skip response not ready, request resync, and some reserved codes (44 to fc)*/
2371 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
2372 : }
2373 : }
2374 18 : return LIBSPDM_STATUS_SUCCESS;
2375 0 : case 0x22: {
2376 : spdm_measurements_response_t *spdm_response;
2377 : uint8_t *ptr;
2378 : uint8_t hash_data[LIBSPDM_MAX_HASH_SIZE];
2379 : size_t sig_size;
2380 : size_t measurment_sig_size;
2381 : spdm_measurement_block_dmtf_t *measurment_block;
2382 : size_t spdm_response_size;
2383 : size_t transport_header_size;
2384 : uint32_t session_id;
2385 : libspdm_session_info_t *session_info;
2386 : uint8_t *scratch_buffer;
2387 : size_t scratch_buffer_size;
2388 :
2389 0 : session_id = 0xFFFFFFFF;
2390 : ((libspdm_context_t *)spdm_context)
2391 0 : ->connection_info.algorithm.base_asym_algo =
2392 : m_libspdm_use_asym_algo;
2393 : ((libspdm_context_t *)spdm_context)
2394 0 : ->connection_info.algorithm.base_hash_algo =
2395 : m_libspdm_use_hash_algo;
2396 : ((libspdm_context_t *)spdm_context)
2397 0 : ->connection_info.algorithm.measurement_hash_algo =
2398 : m_libspdm_use_measurement_hash_algo;
2399 0 : measurment_sig_size =
2400 : SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
2401 0 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2402 0 : spdm_response_size = sizeof(spdm_measurements_response_t) +
2403 : sizeof(spdm_measurement_block_dmtf_t) +
2404 0 : libspdm_get_measurement_hash_size(
2405 0 : m_libspdm_use_measurement_hash_algo) +
2406 : measurment_sig_size;
2407 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2408 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2409 :
2410 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2411 0 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
2412 0 : spdm_response->header.param1 = 0;
2413 0 : spdm_response->header.param2 = 0;
2414 0 : spdm_response->number_of_blocks = 1;
2415 0 : libspdm_write_uint24(
2416 0 : spdm_response->measurement_record_length,
2417 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
2418 0 : libspdm_get_measurement_hash_size(
2419 : m_libspdm_use_measurement_hash_algo)));
2420 0 : measurment_block = (void *)(spdm_response + 1);
2421 0 : libspdm_set_mem(measurment_block,
2422 : sizeof(spdm_measurement_block_dmtf_t) +
2423 0 : libspdm_get_measurement_hash_size(
2424 : m_libspdm_use_measurement_hash_algo),
2425 : 1);
2426 : measurment_block->measurement_block_common_header
2427 0 : .measurement_specification =
2428 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
2429 : measurment_block->measurement_block_common_header
2430 0 : .measurement_size =
2431 0 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
2432 0 : libspdm_get_measurement_hash_size(
2433 : m_libspdm_use_measurement_hash_algo));
2434 0 : ptr = (void *)((uint8_t *)spdm_response + spdm_response_size -
2435 : measurment_sig_size);
2436 0 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
2437 0 : ptr += SPDM_NONCE_SIZE;
2438 0 : *(uint16_t *)ptr = 0;
2439 0 : ptr += sizeof(uint16_t);
2440 0 : libspdm_copy_mem(&m_libspdm_local_buffer[m_libspdm_local_buffer_size],
2441 : sizeof(m_libspdm_local_buffer)
2442 0 : - (&m_libspdm_local_buffer[m_libspdm_local_buffer_size] -
2443 : m_libspdm_local_buffer),
2444 0 : spdm_response, (size_t)ptr - (size_t)spdm_response);
2445 0 : m_libspdm_local_buffer_size += ((size_t)ptr - (size_t)spdm_response);
2446 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "m_libspdm_local_buffer_size (0x%zx):\n",
2447 : m_libspdm_local_buffer_size));
2448 0 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
2449 0 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_buffer,
2450 : m_libspdm_local_buffer_size, hash_data);
2451 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "HashDataSize (0x%x):\n",
2452 : libspdm_get_hash_size(m_libspdm_use_hash_algo)));
2453 0 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
2454 0 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2455 0 : libspdm_responder_data_sign(
2456 : spdm_context,
2457 0 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
2458 : SPDM_MEASUREMENTS,
2459 : m_libspdm_use_asym_algo, m_libspdm_use_pqc_asym_algo, m_libspdm_use_hash_algo,
2460 : false, m_libspdm_local_buffer, m_libspdm_local_buffer_size,
2461 : ptr, &sig_size);
2462 0 : ptr += sig_size;
2463 :
2464 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
2465 : * transport_message is always in sender buffer. */
2466 0 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
2467 0 : libspdm_copy_mem (scratch_buffer + transport_header_size,
2468 : scratch_buffer_size - transport_header_size,
2469 : spdm_response, spdm_response_size);
2470 0 : spdm_response = (void *)(scratch_buffer + transport_header_size);
2471 0 : libspdm_transport_test_encode_message(spdm_context, &session_id, false,
2472 : false, spdm_response_size,
2473 : spdm_response, response_size,
2474 : response);
2475 0 : session_info = libspdm_get_session_info_via_session_id(
2476 : spdm_context, session_id);
2477 0 : if (session_info == NULL) {
2478 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
2479 : }
2480 : /* WALKAROUND: If just use single context to encode message and then decode message */
2481 : ((libspdm_secured_message_context_t
2482 0 : *)(session_info->secured_message_context))
2483 0 : ->application_secret.response_data_sequence_number--;
2484 : }
2485 0 : return LIBSPDM_STATUS_SUCCESS;
2486 :
2487 0 : case 0x23: {
2488 : spdm_measurements_response_t *spdm_response;
2489 : spdm_measurement_block_dmtf_t *measurment_block;
2490 : uint8_t temp_buf[LIBSPDM_RECEIVER_BUFFER_SIZE];
2491 : size_t temp_buf_size;
2492 : uint8_t* temp_buf_ptr;
2493 :
2494 : uint8_t *ptr;
2495 0 : ((libspdm_context_t *)spdm_context)->connection_info.algorithm.measurement_hash_algo =
2496 : m_libspdm_use_measurement_hash_algo;
2497 0 : temp_buf_size = sizeof(spdm_measurements_response_t) +
2498 : sizeof(spdm_measurement_block_dmtf_t) +
2499 0 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo) +
2500 : SPDM_NONCE_SIZE + sizeof(uint16_t);
2501 0 : temp_buf_ptr = temp_buf + sizeof(libspdm_test_message_header_t);
2502 0 : spdm_response = (void *)temp_buf_ptr;
2503 :
2504 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
2505 0 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
2506 0 : spdm_response->header.param1 = 0;
2507 0 : spdm_response->header.param2 = 0;
2508 0 : spdm_response->number_of_blocks = 1;
2509 0 : libspdm_write_uint24(spdm_response->measurement_record_length,
2510 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
2511 0 : libspdm_get_measurement_hash_size(
2512 : m_libspdm_use_measurement_hash_algo)));
2513 0 : measurment_block = (void *)(spdm_response + 1);
2514 0 : libspdm_set_mem(measurment_block,
2515 : sizeof(spdm_measurement_block_dmtf_t) +
2516 0 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo),
2517 : 1);
2518 0 : measurment_block->measurement_block_common_header.measurement_specification =
2519 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
2520 0 : measurment_block->measurement_block_common_header.measurement_size =
2521 0 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
2522 0 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo));
2523 :
2524 0 : ptr = (uint8_t *)spdm_response +
2525 : sizeof(spdm_measurements_response_t) +
2526 0 : sizeof(spdm_measurement_block_dmtf_t) +
2527 0 : libspdm_get_measurement_hash_size(m_libspdm_use_measurement_hash_algo);
2528 0 : libspdm_get_random_number(SPDM_NONCE_SIZE,ptr);
2529 0 : *(uint16_t *)(ptr + SPDM_NONCE_SIZE) = 0;
2530 :
2531 0 : libspdm_copy_mem(&m_libspdm_local_buffer[m_libspdm_local_buffer_size],
2532 : sizeof(m_libspdm_local_buffer) - m_libspdm_local_buffer_size,
2533 : temp_buf_ptr, temp_buf_size);
2534 0 : m_libspdm_local_buffer_size += temp_buf_size;
2535 :
2536 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false, false,
2537 : temp_buf_size, temp_buf_ptr,
2538 : response_size, response);
2539 : }
2540 0 : return LIBSPDM_STATUS_SUCCESS;
2541 :
2542 0 : case 0x24: {
2543 : spdm_measurements_response_t *spdm_response;
2544 : uint8_t *ptr;
2545 : uint8_t hash_data[LIBSPDM_MAX_HASH_SIZE];
2546 : size_t sig_size;
2547 : size_t measurment_sig_size;
2548 : spdm_measurement_block_dmtf_t *measurment_block;
2549 : size_t spdm_response_size;
2550 : size_t transport_header_size;
2551 :
2552 : ((libspdm_context_t *)spdm_context)
2553 0 : ->connection_info.algorithm.base_asym_algo =
2554 : m_libspdm_use_asym_algo;
2555 : ((libspdm_context_t *)spdm_context)
2556 0 : ->connection_info.algorithm.base_hash_algo =
2557 : m_libspdm_use_hash_algo;
2558 : ((libspdm_context_t *)spdm_context)
2559 0 : ->connection_info.algorithm.measurement_hash_algo =
2560 : m_libspdm_use_measurement_hash_algo;
2561 0 : measurment_sig_size =
2562 : SPDM_NONCE_SIZE + sizeof(uint16_t) + 0 +
2563 0 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2564 0 : spdm_response_size = sizeof(spdm_measurements_response_t) +
2565 : sizeof(spdm_measurement_block_dmtf_t) +
2566 0 : libspdm_get_measurement_hash_size(
2567 0 : m_libspdm_use_measurement_hash_algo) +
2568 : measurment_sig_size;
2569 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2570 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2571 :
2572 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_12;
2573 0 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
2574 0 : spdm_response->header.param1 = 0;
2575 0 : spdm_response->header.param2 = 0;
2576 0 : spdm_response->number_of_blocks = 1;
2577 0 : libspdm_write_uint24(
2578 0 : spdm_response->measurement_record_length,
2579 : (uint32_t)(sizeof(spdm_measurement_block_dmtf_t) +
2580 0 : libspdm_get_measurement_hash_size(
2581 : m_libspdm_use_measurement_hash_algo)));
2582 0 : measurment_block = (void *)(spdm_response + 1);
2583 0 : libspdm_set_mem(measurment_block,
2584 : sizeof(spdm_measurement_block_dmtf_t) +
2585 0 : libspdm_get_measurement_hash_size(
2586 : m_libspdm_use_measurement_hash_algo),
2587 : 1);
2588 : measurment_block->measurement_block_common_header
2589 0 : .measurement_specification =
2590 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
2591 : measurment_block->measurement_block_common_header
2592 0 : .measurement_size =
2593 0 : (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) +
2594 0 : libspdm_get_measurement_hash_size(
2595 : m_libspdm_use_measurement_hash_algo));
2596 0 : ptr = (void *)((uint8_t *)spdm_response + spdm_response_size -
2597 : measurment_sig_size);
2598 0 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
2599 0 : ptr += SPDM_NONCE_SIZE;
2600 0 : *(uint16_t *)ptr = 0;
2601 0 : ptr += sizeof(uint16_t);
2602 0 : libspdm_copy_mem(&m_libspdm_local_buffer[m_libspdm_local_buffer_size],
2603 : sizeof(m_libspdm_local_buffer)
2604 0 : - (&m_libspdm_local_buffer[m_libspdm_local_buffer_size] -
2605 : m_libspdm_local_buffer),
2606 0 : spdm_response, (size_t)ptr - (size_t)spdm_response);
2607 0 : m_libspdm_local_buffer_size += ((size_t)ptr - (size_t)spdm_response);
2608 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "m_libspdm_local_buffer_size (0x%zx):\n",
2609 : m_libspdm_local_buffer_size));
2610 0 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
2611 0 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_buffer,
2612 : m_libspdm_local_buffer_size, hash_data);
2613 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "HashDataSize (0x%x):\n",
2614 : libspdm_get_hash_size(m_libspdm_use_hash_algo)));
2615 0 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
2616 0 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
2617 0 : libspdm_responder_data_sign(
2618 : spdm_context,
2619 0 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
2620 : SPDM_MEASUREMENTS,
2621 : m_libspdm_use_asym_algo, m_libspdm_use_pqc_asym_algo, m_libspdm_use_hash_algo,
2622 : false, m_libspdm_local_buffer, m_libspdm_local_buffer_size,
2623 : ptr, &sig_size);
2624 0 : ptr += sig_size;
2625 :
2626 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
2627 : false, spdm_response_size,
2628 : spdm_response, response_size,
2629 : response);
2630 : }
2631 0 : return LIBSPDM_STATUS_SUCCESS;
2632 0 : case 0x25: {
2633 : spdm_measurements_response_t *spdm_response;
2634 : size_t spdm_response_size;
2635 : size_t transport_header_size;
2636 : uint8_t *ptr;
2637 0 : spdm_response_size =
2638 : sizeof(spdm_measurements_response_t)
2639 : + SPDM_NONCE_SIZE + sizeof(uint16_t);
2640 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
2641 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
2642 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_12;
2643 0 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
2644 0 : spdm_response->header.param1 = 4;
2645 0 : spdm_response->header.param2 = 0;
2646 0 : spdm_response->number_of_blocks = 0;
2647 0 : libspdm_write_uint24(spdm_response->measurement_record_length, 0);
2648 :
2649 0 : ptr = (uint8_t *)spdm_response +
2650 : sizeof(spdm_measurements_response_t);
2651 0 : libspdm_get_random_number(SPDM_NONCE_SIZE,ptr);
2652 0 : ptr += SPDM_NONCE_SIZE;
2653 0 : *(uint16_t *)ptr = 0;
2654 :
2655 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
2656 : false, spdm_response_size,
2657 : spdm_response, response_size,
2658 : response);
2659 : }
2660 0 : return LIBSPDM_STATUS_SUCCESS;
2661 :
2662 0 : default:
2663 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
2664 : }
2665 : }
2666 :
2667 : /**
2668 : * Test 1: message could not be sent
2669 : * Expected Behavior: get a RETURN_DEVICE_ERROR return code, with an empty transcript.message_m
2670 : **/
2671 1 : static void libspdm_test_requester_get_measurements_err_case1(void **state)
2672 : {
2673 : libspdm_return_t status;
2674 : libspdm_test_context_t *spdm_test_context;
2675 : libspdm_context_t *spdm_context;
2676 : uint8_t number_of_block;
2677 : uint32_t measurement_record_length;
2678 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
2679 : uint8_t request_attribute;
2680 : void *data;
2681 : size_t data_size;
2682 : void *hash;
2683 : size_t hash_size;
2684 :
2685 1 : spdm_test_context = *state;
2686 1 : spdm_context = spdm_test_context->spdm_context;
2687 1 : spdm_test_context->case_id = 0x1;
2688 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
2689 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2690 1 : spdm_context->connection_info.connection_state =
2691 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2692 1 : spdm_context->connection_info.capability.flags |=
2693 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2694 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2695 : m_libspdm_use_asym_algo, &data,
2696 : &data_size, &hash, &hash_size)) {
2697 0 : assert(false);
2698 : }
2699 1 : libspdm_reset_message_m(spdm_context, NULL);
2700 1 : spdm_context->connection_info.algorithm.measurement_spec =
2701 : m_libspdm_use_measurement_spec;
2702 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2703 : m_libspdm_use_measurement_hash_algo;
2704 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2705 : m_libspdm_use_hash_algo;
2706 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2707 : m_libspdm_use_asym_algo;
2708 1 : spdm_context->local_context.algorithm.measurement_spec =
2709 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
2710 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2711 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2712 : data_size;
2713 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2714 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2715 : data, data_size);
2716 : #else
2717 1 : libspdm_hash_all(
2718 : spdm_context->connection_info.algorithm.base_hash_algo,
2719 : data, data_size,
2720 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
2721 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2722 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2723 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2724 : spdm_context->connection_info.algorithm.base_hash_algo,
2725 : spdm_context->connection_info.algorithm.base_asym_algo,
2726 : data, data_size,
2727 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2728 : #endif
2729 :
2730 1 : request_attribute =
2731 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
2732 :
2733 1 : measurement_record_length = sizeof(measurement_record);
2734 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
2735 : 0, NULL, &number_of_block,
2736 : &measurement_record_length,
2737 : measurement_record);
2738 1 : assert_int_equal(status, LIBSPDM_STATUS_SEND_FAIL);
2739 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2740 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2741 : #endif
2742 1 : free(data);
2743 1 : }
2744 :
2745 : /**
2746 : * Test 2: Responder does not support measurements.
2747 : * Expected Behavior: Returns with LIBSPDM_STATUS_UNSUPPORTED_CAP.
2748 : **/
2749 1 : static void libspdm_test_requester_get_measurements_err_case2(void **state)
2750 : {
2751 : libspdm_return_t status;
2752 : libspdm_test_context_t *spdm_test_context;
2753 : libspdm_context_t *spdm_context;
2754 : uint8_t number_of_block;
2755 : uint32_t measurement_record_length;
2756 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
2757 : uint8_t request_attribute;
2758 : void *data;
2759 : size_t data_size;
2760 : void *hash;
2761 : size_t hash_size;
2762 :
2763 1 : spdm_test_context = *state;
2764 1 : spdm_context = spdm_test_context->spdm_context;
2765 1 : spdm_test_context->case_id = 0x2;
2766 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
2767 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2768 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2769 1 : spdm_context->connection_info.capability.flags = 0;
2770 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2771 : m_libspdm_use_asym_algo, &data,
2772 : &data_size, &hash, &hash_size)) {
2773 0 : assert(false);
2774 : }
2775 1 : libspdm_reset_message_m(spdm_context, NULL);
2776 1 : spdm_context->connection_info.algorithm.measurement_spec =
2777 : m_libspdm_use_measurement_spec;
2778 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2779 : m_libspdm_use_measurement_hash_algo;
2780 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2781 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2782 1 : spdm_context->local_context.algorithm.measurement_spec =
2783 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
2784 :
2785 1 : request_attribute = SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
2786 :
2787 1 : measurement_record_length = sizeof(measurement_record);
2788 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
2789 : 0, NULL, &number_of_block,
2790 : &measurement_record_length,
2791 : measurement_record);
2792 :
2793 1 : assert_int_equal(status, LIBSPDM_STATUS_UNSUPPORTED_CAP);
2794 1 : }
2795 :
2796 : /**
2797 : * Test 3: Error case, attempt to get measurements before GET_DIGESTS, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS
2798 : * Expected Behavior: get a RETURN_UNSUPPORTED return code, with an empty transcript.message_m
2799 : **/
2800 1 : static void libspdm_test_requester_get_measurements_err_case3(void **state)
2801 : {
2802 : libspdm_return_t status;
2803 : libspdm_test_context_t *spdm_test_context;
2804 : libspdm_context_t *spdm_context;
2805 : uint8_t number_of_block;
2806 : uint32_t measurement_record_length;
2807 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
2808 : uint8_t request_attribute;
2809 : void *data;
2810 : size_t data_size;
2811 : void *hash;
2812 : size_t hash_size;
2813 :
2814 1 : spdm_test_context = *state;
2815 1 : spdm_context = spdm_test_context->spdm_context;
2816 1 : spdm_test_context->case_id = 0x3;
2817 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
2818 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2819 1 : spdm_context->connection_info.connection_state =
2820 : LIBSPDM_CONNECTION_STATE_NOT_STARTED;
2821 1 : spdm_context->connection_info.capability.flags |=
2822 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2823 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2824 : m_libspdm_use_asym_algo, &data,
2825 : &data_size, &hash, &hash_size)) {
2826 0 : assert(false);
2827 : }
2828 1 : libspdm_reset_message_m(spdm_context, NULL);
2829 1 : spdm_context->connection_info.algorithm.measurement_spec =
2830 : m_libspdm_use_measurement_spec;
2831 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2832 : m_libspdm_use_measurement_hash_algo;
2833 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2834 : m_libspdm_use_hash_algo;
2835 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2836 : m_libspdm_use_asym_algo;
2837 1 : spdm_context->local_context.algorithm.measurement_spec =
2838 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
2839 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2840 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2841 : data_size;
2842 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2843 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2844 : data, data_size);
2845 : #else
2846 1 : libspdm_hash_all(
2847 : spdm_context->connection_info.algorithm.base_hash_algo,
2848 : data, data_size,
2849 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
2850 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2851 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2852 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2853 : spdm_context->connection_info.algorithm.base_hash_algo,
2854 : spdm_context->connection_info.algorithm.base_asym_algo,
2855 : data, data_size,
2856 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2857 : #endif
2858 :
2859 1 : request_attribute = SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
2860 :
2861 1 : measurement_record_length = sizeof(measurement_record);
2862 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
2863 : 0, NULL, &number_of_block,
2864 : &measurement_record_length,
2865 : measurement_record);
2866 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_STATE_LOCAL);
2867 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2868 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2869 : #endif
2870 1 : free(data);
2871 1 : }
2872 :
2873 : /**
2874 : * Test 4: Error case, always get an error response with code SPDM_ERROR_CODE_INVALID_REQUEST
2875 : * Expected Behavior: get a RETURN_DEVICE_ERROR return code, with an empty transcript.message_m
2876 : **/
2877 1 : static void libspdm_test_requester_get_measurements_err_case4(void **state)
2878 : {
2879 : libspdm_return_t status;
2880 : libspdm_test_context_t *spdm_test_context;
2881 : libspdm_context_t *spdm_context;
2882 : uint8_t number_of_block;
2883 : uint32_t measurement_record_length;
2884 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
2885 : uint8_t request_attribute;
2886 : void *data;
2887 : size_t data_size;
2888 : void *hash;
2889 : size_t hash_size;
2890 :
2891 1 : spdm_test_context = *state;
2892 1 : spdm_context = spdm_test_context->spdm_context;
2893 1 : spdm_test_context->case_id = 0x4;
2894 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
2895 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2896 1 : spdm_context->connection_info.connection_state =
2897 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2898 1 : spdm_context->connection_info.capability.flags |=
2899 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2900 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2901 : m_libspdm_use_asym_algo, &data,
2902 : &data_size, &hash, &hash_size)) {
2903 0 : assert(false);
2904 : }
2905 1 : libspdm_reset_message_m(spdm_context, NULL);
2906 1 : spdm_context->connection_info.algorithm.measurement_spec =
2907 : m_libspdm_use_measurement_spec;
2908 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2909 : m_libspdm_use_measurement_hash_algo;
2910 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2911 : m_libspdm_use_hash_algo;
2912 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2913 : m_libspdm_use_asym_algo;
2914 1 : spdm_context->local_context.algorithm.measurement_spec =
2915 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
2916 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2917 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2918 : data_size;
2919 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2920 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2921 : data, data_size);
2922 : #else
2923 1 : libspdm_hash_all(
2924 : spdm_context->connection_info.algorithm.base_hash_algo,
2925 : data, data_size,
2926 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
2927 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
2928 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
2929 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
2930 : spdm_context->connection_info.algorithm.base_hash_algo,
2931 : spdm_context->connection_info.algorithm.base_asym_algo,
2932 : data, data_size,
2933 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
2934 : #endif
2935 :
2936 1 : request_attribute =
2937 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
2938 :
2939 1 : measurement_record_length = sizeof(measurement_record);
2940 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
2941 : 0, NULL, &number_of_block,
2942 : &measurement_record_length,
2943 : measurement_record);
2944 1 : assert_int_equal(status, LIBSPDM_STATUS_ERROR_PEER);
2945 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2946 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
2947 : #endif
2948 1 : free(data);
2949 1 : }
2950 :
2951 : /**
2952 : * Test 5: Error case, always get an error response with code SPDM_ERROR_CODE_BUSY
2953 : * Expected Behavior: get a RETURN_DEVICE_ERROR return code, with an empty transcript.message_m
2954 : **/
2955 1 : static void libspdm_test_requester_get_measurements_err_case5(void **state)
2956 : {
2957 : libspdm_return_t status;
2958 : libspdm_test_context_t *spdm_test_context;
2959 : libspdm_context_t *spdm_context;
2960 : uint8_t number_of_block;
2961 : uint32_t measurement_record_length;
2962 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
2963 : uint8_t request_attribute;
2964 : void *data;
2965 : size_t data_size;
2966 : void *hash;
2967 : size_t hash_size;
2968 :
2969 1 : spdm_test_context = *state;
2970 1 : spdm_context = spdm_test_context->spdm_context;
2971 1 : spdm_test_context->case_id = 0x5;
2972 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
2973 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2974 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
2975 1 : spdm_context->connection_info.capability.flags |=
2976 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2977 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2978 : m_libspdm_use_asym_algo, &data,
2979 : &data_size, &hash, &hash_size)) {
2980 0 : assert(false);
2981 : }
2982 1 : libspdm_reset_message_m(spdm_context, NULL);
2983 1 : spdm_context->connection_info.algorithm.measurement_spec =
2984 : m_libspdm_use_measurement_spec;
2985 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
2986 : m_libspdm_use_measurement_hash_algo;
2987 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2988 : m_libspdm_use_hash_algo;
2989 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2990 : m_libspdm_use_asym_algo;
2991 1 : spdm_context->local_context.algorithm.measurement_spec =
2992 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
2993 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2994 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2995 : data_size;
2996 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2997 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2998 : data, data_size);
2999 : #else
3000 1 : libspdm_hash_all(
3001 : spdm_context->connection_info.algorithm.base_hash_algo,
3002 : data, data_size,
3003 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
3004 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
3005 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
3006 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
3007 : spdm_context->connection_info.algorithm.base_hash_algo,
3008 : spdm_context->connection_info.algorithm.base_asym_algo,
3009 : data, data_size,
3010 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
3011 : #endif
3012 :
3013 1 : request_attribute =
3014 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
3015 :
3016 1 : measurement_record_length = sizeof(measurement_record);
3017 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
3018 : 0, NULL, &number_of_block,
3019 : &measurement_record_length,
3020 : measurement_record);
3021 1 : assert_int_equal(status, LIBSPDM_STATUS_BUSY_PEER);
3022 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
3023 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
3024 : #endif
3025 1 : free(data);
3026 1 : }
3027 :
3028 : /**
3029 : * Test 6: Connection state is less than negotiated.
3030 : * Expected Behavior: Returns with LIBSPDM_STATUS_INVALID_STATE_LOCAL.
3031 : **/
3032 1 : static void libspdm_test_requester_get_measurements_err_case6(void **state)
3033 : {
3034 : libspdm_return_t status;
3035 : libspdm_test_context_t *spdm_test_context;
3036 : libspdm_context_t *spdm_context;
3037 : uint8_t number_of_block;
3038 : uint32_t measurement_record_length;
3039 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
3040 : uint8_t request_attribute;
3041 : void *data;
3042 : size_t data_size;
3043 : void *hash;
3044 : size_t hash_size;
3045 :
3046 1 : spdm_test_context = *state;
3047 1 : spdm_context = spdm_test_context->spdm_context;
3048 1 : spdm_test_context->case_id = 0x2;
3049 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3050 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3051 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
3052 1 : spdm_context->connection_info.capability.flags |=
3053 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
3054 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
3055 : m_libspdm_use_asym_algo, &data,
3056 : &data_size, &hash, &hash_size)) {
3057 0 : assert(false);
3058 : }
3059 1 : libspdm_reset_message_m(spdm_context, NULL);
3060 1 : spdm_context->connection_info.algorithm.measurement_spec =
3061 : m_libspdm_use_measurement_spec;
3062 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
3063 : m_libspdm_use_measurement_hash_algo;
3064 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
3065 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
3066 1 : spdm_context->local_context.algorithm.measurement_spec =
3067 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
3068 1 : request_attribute = SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
3069 :
3070 1 : measurement_record_length = sizeof(measurement_record);
3071 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
3072 : 0, NULL, &number_of_block,
3073 : &measurement_record_length,
3074 : measurement_record);
3075 :
3076 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_STATE_LOCAL);
3077 1 : }
3078 :
3079 : /**
3080 : * Test 7: Error case, get an error response with code SPDM_ERROR_CODE_REQUEST_RESYNCH
3081 : * Expected Behavior: get a RETURN_DEVICE_ERROR return code, with an empty transcript.message_m
3082 : **/
3083 1 : static void libspdm_test_requester_get_measurements_err_case7(void **state)
3084 : {
3085 : libspdm_return_t status;
3086 : libspdm_test_context_t *spdm_test_context;
3087 : libspdm_context_t *spdm_context;
3088 : uint8_t number_of_block;
3089 : uint32_t measurement_record_length;
3090 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
3091 : uint8_t request_attribute;
3092 : void *data;
3093 : size_t data_size;
3094 : void *hash;
3095 : size_t hash_size;
3096 :
3097 1 : spdm_test_context = *state;
3098 1 : spdm_context = spdm_test_context->spdm_context;
3099 1 : spdm_test_context->case_id = 0x7;
3100 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3101 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3102 1 : spdm_context->connection_info.connection_state =
3103 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
3104 1 : spdm_context->connection_info.capability.flags |=
3105 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
3106 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
3107 : m_libspdm_use_asym_algo, &data,
3108 : &data_size, &hash, &hash_size)) {
3109 0 : assert(false);
3110 : }
3111 1 : libspdm_reset_message_m(spdm_context, NULL);
3112 1 : spdm_context->connection_info.algorithm.measurement_spec =
3113 : m_libspdm_use_measurement_spec;
3114 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
3115 : m_libspdm_use_measurement_hash_algo;
3116 1 : spdm_context->connection_info.algorithm.base_hash_algo =
3117 : m_libspdm_use_hash_algo;
3118 1 : spdm_context->connection_info.algorithm.base_asym_algo =
3119 : m_libspdm_use_asym_algo;
3120 1 : spdm_context->local_context.algorithm.measurement_spec =
3121 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
3122 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
3123 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
3124 : data_size;
3125 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
3126 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
3127 : data, data_size);
3128 : #else
3129 1 : libspdm_hash_all(
3130 : spdm_context->connection_info.algorithm.base_hash_algo,
3131 : data, data_size,
3132 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
3133 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
3134 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
3135 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
3136 : spdm_context->connection_info.algorithm.base_hash_algo,
3137 : spdm_context->connection_info.algorithm.base_asym_algo,
3138 : data, data_size,
3139 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
3140 : #endif
3141 :
3142 1 : request_attribute =
3143 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
3144 :
3145 1 : measurement_record_length = sizeof(measurement_record);
3146 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
3147 : 0, NULL, &number_of_block,
3148 : &measurement_record_length,
3149 : measurement_record);
3150 1 : assert_int_equal(status, LIBSPDM_STATUS_RESYNCH_PEER);
3151 1 : assert_int_equal(spdm_context->connection_info.connection_state,
3152 : LIBSPDM_CONNECTION_STATE_NOT_STARTED);
3153 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
3154 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
3155 : #endif
3156 1 : free(data);
3157 1 : }
3158 :
3159 : /**
3160 : * Test 8: Error case, always get an error response with code SPDM_ERROR_CODE_RESPONSE_NOT_READY
3161 : * Expected Behavior: get a RETURN_DEVICE_ERROR return code, with an empty transcript.message_m
3162 : **/
3163 1 : static void libspdm_test_requester_get_measurements_err_case8(void **state)
3164 : {
3165 : libspdm_return_t status;
3166 : libspdm_test_context_t *spdm_test_context;
3167 : libspdm_context_t *spdm_context;
3168 : uint8_t number_of_block;
3169 : uint32_t measurement_record_length;
3170 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
3171 : uint8_t request_attribute;
3172 : void *data;
3173 : size_t data_size;
3174 : void *hash;
3175 : size_t hash_size;
3176 :
3177 1 : spdm_test_context = *state;
3178 1 : spdm_context = spdm_test_context->spdm_context;
3179 1 : spdm_test_context->case_id = 0x8;
3180 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3181 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3182 1 : spdm_context->connection_info.connection_state =
3183 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
3184 1 : spdm_context->connection_info.capability.flags |=
3185 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
3186 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
3187 : m_libspdm_use_asym_algo, &data,
3188 : &data_size, &hash, &hash_size)) {
3189 0 : assert(false);
3190 : }
3191 1 : libspdm_reset_message_m(spdm_context, NULL);
3192 1 : spdm_context->connection_info.algorithm.measurement_spec =
3193 : m_libspdm_use_measurement_spec;
3194 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
3195 : m_libspdm_use_measurement_hash_algo;
3196 1 : spdm_context->connection_info.algorithm.base_hash_algo =
3197 : m_libspdm_use_hash_algo;
3198 1 : spdm_context->connection_info.algorithm.base_asym_algo =
3199 : m_libspdm_use_asym_algo;
3200 1 : spdm_context->local_context.algorithm.measurement_spec =
3201 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
3202 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
3203 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
3204 : data_size;
3205 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
3206 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
3207 : data, data_size);
3208 : #else
3209 1 : libspdm_hash_all(
3210 : spdm_context->connection_info.algorithm.base_hash_algo,
3211 : data, data_size,
3212 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
3213 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
3214 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
3215 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
3216 : spdm_context->connection_info.algorithm.base_hash_algo,
3217 : spdm_context->connection_info.algorithm.base_asym_algo,
3218 : data, data_size,
3219 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
3220 : #endif
3221 :
3222 1 : request_attribute =
3223 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
3224 :
3225 1 : measurement_record_length = sizeof(measurement_record);
3226 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
3227 : 0, NULL, &number_of_block,
3228 : &measurement_record_length,
3229 : measurement_record);
3230 1 : assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
3231 1 : free(data);
3232 1 : }
3233 :
3234 : /**
3235 : * Test 9: Integrator requests signature when Responder does not support signatures.
3236 : * Expected Behavior: Returns LIBSPDM_STATUS_INVALID_PARAMETER.
3237 : **/
3238 1 : static void libspdm_test_requester_get_measurements_err_case9(void **state)
3239 : {
3240 : libspdm_return_t status;
3241 : libspdm_test_context_t *spdm_test_context;
3242 : libspdm_context_t *spdm_context;
3243 : uint8_t number_of_block;
3244 : uint32_t measurement_record_length;
3245 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
3246 : uint8_t request_attribute;
3247 : void *data;
3248 : size_t data_size;
3249 : void *hash;
3250 : size_t hash_size;
3251 :
3252 1 : spdm_test_context = *state;
3253 1 : spdm_context = spdm_test_context->spdm_context;
3254 1 : spdm_test_context->case_id = 0x9;
3255 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3256 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3257 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
3258 1 : spdm_context->connection_info.capability.flags =
3259 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_NO_SIG;
3260 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
3261 : m_libspdm_use_asym_algo, &data,
3262 : &data_size, &hash, &hash_size)) {
3263 0 : assert(false);
3264 : }
3265 1 : spdm_context->connection_info.algorithm.measurement_spec =
3266 : m_libspdm_use_measurement_spec;
3267 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
3268 : m_libspdm_use_measurement_hash_algo;
3269 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
3270 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
3271 1 : spdm_context->local_context.algorithm.measurement_spec =
3272 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
3273 1 : request_attribute = SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
3274 :
3275 1 : measurement_record_length = sizeof(measurement_record);
3276 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
3277 : 0, NULL, &number_of_block,
3278 : &measurement_record_length,
3279 : measurement_record);
3280 :
3281 1 : spdm_context->connection_info.capability.flags = 0;
3282 :
3283 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_PARAMETER);
3284 1 : }
3285 :
3286 : /**
3287 : * Test 10: Unable to acquire the sender buffer.
3288 : * Expected Behavior: Returns with LIBSPDM_STATUS_ACQUIRE_FAIL.
3289 : **/
3290 1 : static void libspdm_test_requester_get_measurements_err_case10(void **state)
3291 : {
3292 : libspdm_return_t status;
3293 : libspdm_test_context_t *spdm_test_context;
3294 : libspdm_context_t *spdm_context;
3295 : uint8_t number_of_block;
3296 : uint32_t measurement_record_length;
3297 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
3298 : uint8_t request_attribute;
3299 : void *data;
3300 : size_t data_size;
3301 : void *hash;
3302 : size_t hash_size;
3303 :
3304 1 : spdm_test_context = *state;
3305 1 : spdm_context = spdm_test_context->spdm_context;
3306 1 : spdm_test_context->case_id = 0xa;
3307 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3308 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3309 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
3310 1 : spdm_context->connection_info.capability.flags =
3311 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_NO_SIG;
3312 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
3313 : m_libspdm_use_asym_algo, &data,
3314 : &data_size, &hash, &hash_size)) {
3315 0 : assert(false);
3316 : }
3317 :
3318 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
3319 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
3320 : m_libspdm_use_measurement_hash_algo;
3321 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
3322 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
3323 1 : spdm_context->local_context.algorithm.measurement_spec =
3324 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
3325 1 : request_attribute = 0;
3326 1 : measurement_record_length = sizeof(measurement_record);
3327 :
3328 1 : libspdm_force_error (LIBSPDM_ERR_ACQUIRE_SENDER_BUFFER);
3329 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
3330 : 0, NULL, &number_of_block,
3331 : &measurement_record_length,
3332 : measurement_record);
3333 1 : libspdm_release_error (LIBSPDM_ERR_ACQUIRE_SENDER_BUFFER);
3334 :
3335 1 : spdm_context->connection_info.capability.flags = 0;
3336 :
3337 1 : assert_int_equal(status, LIBSPDM_STATUS_ACQUIRE_FAIL);
3338 1 : }
3339 :
3340 : /**
3341 : * Test 11: Unable to acquire the receiver buffer.
3342 : * Expected Behavior: Returns with LIBSPDM_STATUS_ACQUIRE_FAIL.
3343 : **/
3344 1 : static void libspdm_test_requester_get_measurements_err_case11(void **state)
3345 : {
3346 : libspdm_return_t status;
3347 : libspdm_test_context_t *spdm_test_context;
3348 : libspdm_context_t *spdm_context;
3349 : uint8_t number_of_block;
3350 : uint32_t measurement_record_length;
3351 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
3352 : uint8_t request_attribute;
3353 : void *data;
3354 : size_t data_size;
3355 : void *hash;
3356 : size_t hash_size;
3357 :
3358 1 : spdm_test_context = *state;
3359 1 : spdm_context = spdm_test_context->spdm_context;
3360 1 : spdm_test_context->case_id = 0xb;
3361 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3362 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3363 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
3364 1 : spdm_context->connection_info.capability.flags =
3365 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_NO_SIG;
3366 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
3367 : m_libspdm_use_asym_algo, &data,
3368 : &data_size, &hash, &hash_size)) {
3369 0 : assert(false);
3370 : }
3371 :
3372 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
3373 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
3374 : m_libspdm_use_measurement_hash_algo;
3375 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
3376 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
3377 1 : spdm_context->local_context.algorithm.measurement_spec =
3378 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
3379 :
3380 1 : request_attribute = 0;
3381 1 : measurement_record_length = sizeof(measurement_record);
3382 :
3383 1 : libspdm_force_error (LIBSPDM_ERR_ACQUIRE_RECEIVER_BUFFER);
3384 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
3385 : 0, NULL, &number_of_block,
3386 : &measurement_record_length,
3387 : measurement_record);
3388 1 : libspdm_release_error (LIBSPDM_ERR_ACQUIRE_RECEIVER_BUFFER);
3389 :
3390 1 : spdm_context->connection_info.capability.flags = 0;
3391 :
3392 1 : assert_int_equal(status, LIBSPDM_STATUS_ACQUIRE_FAIL);
3393 1 : }
3394 :
3395 : /**
3396 : * Test 12: Error case, signature is invalid (all bytes are 0)
3397 : * Expected Behavior: get a RETURN_SECURITY_VIOLATION return code
3398 : **/
3399 1 : static void libspdm_test_requester_get_measurements_err_case12(void **state)
3400 : {
3401 : libspdm_return_t status;
3402 : libspdm_test_context_t *spdm_test_context;
3403 : libspdm_context_t *spdm_context;
3404 : uint8_t number_of_block;
3405 : uint32_t measurement_record_length;
3406 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
3407 : uint8_t request_attribute;
3408 : void *data;
3409 : size_t data_size;
3410 : void *hash;
3411 : size_t hash_size;
3412 :
3413 1 : spdm_test_context = *state;
3414 1 : spdm_context = spdm_test_context->spdm_context;
3415 1 : spdm_test_context->case_id = 0xC;
3416 :
3417 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3418 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3419 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
3420 1 : spdm_context->connection_info.capability.flags |=
3421 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
3422 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
3423 : m_libspdm_use_asym_algo, &data,
3424 : &data_size, &hash, &hash_size)) {
3425 0 : assert(false);
3426 : }
3427 1 : libspdm_reset_message_m(spdm_context, NULL);
3428 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
3429 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
3430 : m_libspdm_use_measurement_hash_algo;
3431 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
3432 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
3433 1 : spdm_context->local_context.algorithm.measurement_spec =
3434 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
3435 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
3436 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
3437 : data_size;
3438 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
3439 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
3440 : data, data_size);
3441 : #else
3442 1 : libspdm_hash_all(
3443 : spdm_context->connection_info.algorithm.base_hash_algo,
3444 : data, data_size,
3445 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
3446 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
3447 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
3448 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
3449 : spdm_context->connection_info.algorithm.base_hash_algo,
3450 : spdm_context->connection_info.algorithm.base_asym_algo,
3451 : data, data_size,
3452 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
3453 : #endif
3454 :
3455 1 : request_attribute = SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
3456 :
3457 1 : measurement_record_length = sizeof(measurement_record);
3458 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
3459 : 0, NULL, &number_of_block,
3460 : &measurement_record_length,
3461 : measurement_record);
3462 1 : assert_int_equal(status, LIBSPDM_STATUS_VERIF_FAIL);
3463 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
3464 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
3465 : #endif
3466 1 : free(data);
3467 1 : }
3468 :
3469 : /**
3470 : * Test 13: Error case, signature is invalid (random)
3471 : * Expected Behavior: get a RETURN_SECURITY_VIOLATION return code
3472 : **/
3473 1 : static void libspdm_test_requester_get_measurements_err_case13(void **state)
3474 : {
3475 : libspdm_return_t status;
3476 : libspdm_test_context_t *spdm_test_context;
3477 : libspdm_context_t *spdm_context;
3478 : uint8_t number_of_block;
3479 : uint32_t measurement_record_length;
3480 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
3481 : uint8_t request_attribute;
3482 : void *data;
3483 : size_t data_size;
3484 : void *hash;
3485 : size_t hash_size;
3486 :
3487 1 : spdm_test_context = *state;
3488 1 : spdm_context = spdm_test_context->spdm_context;
3489 1 : spdm_test_context->case_id = 0xD;
3490 :
3491 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3492 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3493 1 : spdm_context->connection_info.connection_state =
3494 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
3495 1 : spdm_context->connection_info.capability.flags |=
3496 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
3497 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
3498 : m_libspdm_use_asym_algo, &data,
3499 : &data_size, &hash, &hash_size)) {
3500 0 : assert(false);
3501 : }
3502 1 : libspdm_reset_message_m(spdm_context, NULL);
3503 1 : spdm_context->connection_info.algorithm.measurement_spec =
3504 : m_libspdm_use_measurement_spec;
3505 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
3506 : m_libspdm_use_measurement_hash_algo;
3507 1 : spdm_context->connection_info.algorithm.base_hash_algo =
3508 : m_libspdm_use_hash_algo;
3509 1 : spdm_context->connection_info.algorithm.base_asym_algo =
3510 : m_libspdm_use_asym_algo;
3511 1 : spdm_context->local_context.algorithm.measurement_spec =
3512 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
3513 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
3514 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
3515 : data_size;
3516 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
3517 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
3518 : data, data_size);
3519 : #else
3520 1 : libspdm_hash_all(
3521 : spdm_context->connection_info.algorithm.base_hash_algo,
3522 : data, data_size,
3523 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
3524 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
3525 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
3526 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
3527 : spdm_context->connection_info.algorithm.base_hash_algo,
3528 : spdm_context->connection_info.algorithm.base_asym_algo,
3529 : data, data_size,
3530 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
3531 : #endif
3532 :
3533 1 : request_attribute =
3534 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
3535 :
3536 1 : measurement_record_length = sizeof(measurement_record);
3537 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
3538 : 0, NULL, &number_of_block,
3539 : &measurement_record_length,
3540 : measurement_record);
3541 1 : assert_int_equal(status, LIBSPDM_STATUS_VERIF_FAIL);
3542 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
3543 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
3544 : #endif
3545 1 : free(data);
3546 1 : }
3547 :
3548 : /**
3549 : * Test 14: Error case, request a signed response, but response is malformed (signature absent)
3550 : * Expected Behavior: get a RETURN_DEVICE_ERROR return code
3551 : **/
3552 1 : static void libspdm_test_requester_get_measurements_err_case14(void **state)
3553 : {
3554 : libspdm_return_t status;
3555 : libspdm_test_context_t *spdm_test_context;
3556 : libspdm_context_t *spdm_context;
3557 : uint8_t number_of_block;
3558 : uint32_t measurement_record_length;
3559 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
3560 : uint8_t request_attribute;
3561 : void *data;
3562 : size_t data_size;
3563 : void *hash;
3564 : size_t hash_size;
3565 :
3566 1 : spdm_test_context = *state;
3567 1 : spdm_context = spdm_test_context->spdm_context;
3568 1 : spdm_test_context->case_id = 0xE;
3569 :
3570 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3571 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3572 1 : spdm_context->connection_info.connection_state =
3573 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
3574 1 : spdm_context->connection_info.capability.flags |=
3575 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
3576 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
3577 : m_libspdm_use_asym_algo, &data,
3578 : &data_size, &hash, &hash_size)) {
3579 0 : assert(false);
3580 : }
3581 1 : libspdm_reset_message_m(spdm_context, NULL);
3582 1 : spdm_context->connection_info.algorithm.measurement_spec =
3583 : m_libspdm_use_measurement_spec;
3584 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
3585 : m_libspdm_use_measurement_hash_algo;
3586 1 : spdm_context->connection_info.algorithm.base_hash_algo =
3587 : m_libspdm_use_hash_algo;
3588 1 : spdm_context->connection_info.algorithm.base_asym_algo =
3589 : m_libspdm_use_asym_algo;
3590 1 : spdm_context->local_context.algorithm.measurement_spec =
3591 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
3592 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
3593 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
3594 : data_size;
3595 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
3596 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
3597 : data, data_size);
3598 : #else
3599 1 : libspdm_hash_all(
3600 : spdm_context->connection_info.algorithm.base_hash_algo,
3601 : data, data_size,
3602 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
3603 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
3604 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
3605 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
3606 : spdm_context->connection_info.algorithm.base_hash_algo,
3607 : spdm_context->connection_info.algorithm.base_asym_algo,
3608 : data, data_size,
3609 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
3610 : #endif
3611 :
3612 1 : request_attribute =
3613 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
3614 :
3615 1 : measurement_record_length = sizeof(measurement_record);
3616 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
3617 : 0, NULL, &number_of_block,
3618 : &measurement_record_length,
3619 : measurement_record);
3620 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_SIZE);
3621 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
3622 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
3623 : #endif
3624 1 : free(data);
3625 1 : }
3626 :
3627 : /**
3628 : * Test 15: Error case, response with wrong response code
3629 : * Expected Behavior: get a RETURN_DEVICE_ERROR return code
3630 : **/
3631 1 : static void libspdm_test_requester_get_measurements_err_case15(void **state)
3632 : {
3633 : libspdm_return_t status;
3634 : libspdm_test_context_t *spdm_test_context;
3635 : libspdm_context_t *spdm_context;
3636 : uint8_t number_of_block;
3637 : uint32_t measurement_record_length;
3638 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
3639 : uint8_t request_attribute;
3640 : void *data;
3641 : size_t data_size;
3642 : void *hash;
3643 : size_t hash_size;
3644 :
3645 1 : spdm_test_context = *state;
3646 1 : spdm_context = spdm_test_context->spdm_context;
3647 1 : spdm_test_context->case_id = 0xF;
3648 :
3649 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3650 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3651 1 : spdm_context->connection_info.connection_state =
3652 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
3653 1 : spdm_context->connection_info.capability.flags |=
3654 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
3655 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
3656 : m_libspdm_use_asym_algo, &data,
3657 : &data_size, &hash, &hash_size)) {
3658 0 : assert(false);
3659 : }
3660 1 : libspdm_reset_message_m(spdm_context, NULL);
3661 1 : spdm_context->connection_info.algorithm.measurement_spec =
3662 : m_libspdm_use_measurement_spec;
3663 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
3664 : m_libspdm_use_measurement_hash_algo;
3665 1 : spdm_context->connection_info.algorithm.base_hash_algo =
3666 : m_libspdm_use_hash_algo;
3667 1 : spdm_context->connection_info.algorithm.base_asym_algo =
3668 : m_libspdm_use_asym_algo;
3669 1 : spdm_context->local_context.algorithm.measurement_spec =
3670 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
3671 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
3672 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
3673 : data_size;
3674 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
3675 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
3676 : data, data_size);
3677 : #else
3678 1 : libspdm_hash_all(
3679 : spdm_context->connection_info.algorithm.base_hash_algo,
3680 : data, data_size,
3681 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
3682 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
3683 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
3684 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
3685 : spdm_context->connection_info.algorithm.base_hash_algo,
3686 : spdm_context->connection_info.algorithm.base_asym_algo,
3687 : data, data_size,
3688 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
3689 : #endif
3690 :
3691 1 : request_attribute =
3692 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
3693 :
3694 1 : measurement_record_length = sizeof(measurement_record);
3695 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
3696 : 0, NULL, &number_of_block,
3697 : &measurement_record_length,
3698 : measurement_record);
3699 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
3700 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
3701 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
3702 : #endif
3703 1 : free(data);
3704 1 : }
3705 :
3706 : /**
3707 : * Test 16: Unable to receive response.
3708 : * Expected Behavior: Returns with LIBSPDM_STATUS_RECEIVE_FAIL.
3709 : **/
3710 1 : static void libspdm_test_requester_get_measurements_err_case16(void **state)
3711 : {
3712 : libspdm_return_t status;
3713 : libspdm_test_context_t *spdm_test_context;
3714 : libspdm_context_t *spdm_context;
3715 : uint8_t number_of_block;
3716 : uint32_t measurement_record_length;
3717 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
3718 : uint8_t request_attribute;
3719 : void *data;
3720 : size_t data_size;
3721 : void *hash;
3722 : size_t hash_size;
3723 :
3724 1 : spdm_test_context = *state;
3725 1 : spdm_context = spdm_test_context->spdm_context;
3726 1 : spdm_test_context->case_id = 0x10;
3727 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3728 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3729 1 : spdm_context->connection_info.connection_state =
3730 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
3731 1 : spdm_context->connection_info.capability.flags |=
3732 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
3733 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
3734 : m_libspdm_use_asym_algo, &data,
3735 : &data_size, &hash, &hash_size)) {
3736 0 : assert(false);
3737 : }
3738 1 : libspdm_reset_message_m(spdm_context, NULL);
3739 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
3740 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
3741 : m_libspdm_use_measurement_hash_algo;
3742 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
3743 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
3744 1 : spdm_context->local_context.algorithm.measurement_spec =
3745 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
3746 1 : request_attribute = SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
3747 :
3748 1 : measurement_record_length = sizeof(measurement_record);
3749 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
3750 : 0, NULL, &number_of_block,
3751 : &measurement_record_length,
3752 : measurement_record);
3753 :
3754 1 : assert_int_equal(status, LIBSPDM_STATUS_RECEIVE_FAIL);
3755 1 : }
3756 :
3757 : /**
3758 : * Test 17: Error case, response to get total number of measurements, but response number_of_blocks and/or measurement_record_length are non 0
3759 : * Expected Behavior: get a RETURN_DEVICE_ERROR return code
3760 : **/
3761 1 : static void libspdm_test_requester_get_measurements_err_case17(void **state)
3762 : {
3763 : libspdm_return_t status;
3764 : libspdm_test_context_t *spdm_test_context;
3765 : libspdm_context_t *spdm_context;
3766 : uint8_t number_of_blocks;
3767 : uint8_t request_attribute;
3768 : void *data;
3769 : size_t data_size;
3770 : void *hash;
3771 : size_t hash_size;
3772 :
3773 1 : spdm_test_context = *state;
3774 1 : spdm_context = spdm_test_context->spdm_context;
3775 1 : spdm_test_context->case_id = 0x11;
3776 :
3777 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3778 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3779 1 : spdm_context->connection_info.connection_state =
3780 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
3781 1 : spdm_context->connection_info.capability.flags |=
3782 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
3783 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
3784 : m_libspdm_use_asym_algo, &data,
3785 : &data_size, &hash, &hash_size)) {
3786 0 : assert(false);
3787 : }
3788 1 : libspdm_reset_message_m(spdm_context, NULL);
3789 1 : spdm_context->connection_info.algorithm.measurement_spec =
3790 : m_libspdm_use_measurement_spec;
3791 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
3792 : m_libspdm_use_measurement_hash_algo;
3793 1 : spdm_context->connection_info.algorithm.base_hash_algo =
3794 : m_libspdm_use_hash_algo;
3795 1 : spdm_context->connection_info.algorithm.base_asym_algo =
3796 : m_libspdm_use_asym_algo;
3797 1 : spdm_context->local_context.algorithm.measurement_spec =
3798 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
3799 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
3800 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
3801 : data_size;
3802 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
3803 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
3804 : data, data_size);
3805 : #else
3806 1 : libspdm_hash_all(
3807 : spdm_context->connection_info.algorithm.base_hash_algo,
3808 : data, data_size,
3809 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
3810 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
3811 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
3812 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
3813 : spdm_context->connection_info.algorithm.base_hash_algo,
3814 : spdm_context->connection_info.algorithm.base_asym_algo,
3815 : data, data_size,
3816 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
3817 : #endif
3818 :
3819 1 : request_attribute = 0;
3820 :
3821 4 : for (int i = 0; i < 3; i++) {
3822 : /* i=0 => both number_of_blocks and measurement_record_length are non 0
3823 : * i=1 => only number_of_blocks is non 0
3824 : * i=2 => only is measurement_record_length is non 0*/
3825 3 : status = libspdm_get_measurement(
3826 : spdm_context, NULL, request_attribute,
3827 : SPDM_GET_MEASUREMENTS_REQUEST_MEASUREMENT_OPERATION_TOTAL_NUMBER_OF_MEASUREMENTS,
3828 : 0, NULL, &number_of_blocks, NULL, NULL);
3829 3 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
3830 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
3831 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
3832 : 0);
3833 : #endif
3834 : }
3835 1 : free(data);
3836 1 : }
3837 :
3838 : /**
3839 : * Test 18:
3840 : * Expected Behavior:
3841 : **/
3842 1 : static void libspdm_test_requester_get_measurements_err_case18(void **state)
3843 : {
3844 1 : }
3845 :
3846 : /**
3847 : * Test 19: Error case, measurement_specification field in response has 2 bits set (bit 0 is one of them)
3848 : * Expected Behavior: get a RETURN_DEVICE_ERROR return code,
3849 : **/
3850 1 : static void libspdm_test_requester_get_measurements_err_case19(void **state)
3851 : {
3852 : libspdm_return_t status;
3853 : libspdm_test_context_t *spdm_test_context;
3854 : libspdm_context_t *spdm_context;
3855 : uint8_t number_of_block;
3856 : uint32_t measurement_record_length;
3857 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
3858 : uint8_t request_attribute;
3859 : void *data;
3860 : size_t data_size;
3861 : void *hash;
3862 : size_t hash_size;
3863 :
3864 1 : spdm_test_context = *state;
3865 1 : spdm_context = spdm_test_context->spdm_context;
3866 1 : spdm_test_context->case_id = 0x13;
3867 :
3868 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3869 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3870 1 : spdm_context->connection_info.connection_state =
3871 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
3872 1 : spdm_context->connection_info.capability.flags |=
3873 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
3874 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
3875 : m_libspdm_use_asym_algo, &data,
3876 : &data_size, &hash, &hash_size)) {
3877 0 : assert(false);
3878 : }
3879 1 : libspdm_reset_message_m(spdm_context, NULL);
3880 1 : spdm_context->connection_info.algorithm.measurement_spec =
3881 : m_libspdm_use_measurement_spec;
3882 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
3883 : m_libspdm_use_measurement_hash_algo;
3884 1 : spdm_context->connection_info.algorithm.base_hash_algo =
3885 : m_libspdm_use_hash_algo;
3886 1 : spdm_context->connection_info.algorithm.base_asym_algo =
3887 : m_libspdm_use_asym_algo;
3888 1 : spdm_context->local_context.algorithm.measurement_spec =
3889 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
3890 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
3891 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
3892 : data_size;
3893 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
3894 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
3895 : data, data_size);
3896 : #else
3897 1 : libspdm_hash_all(
3898 : spdm_context->connection_info.algorithm.base_hash_algo,
3899 : data, data_size,
3900 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
3901 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
3902 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
3903 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
3904 : spdm_context->connection_info.algorithm.base_hash_algo,
3905 : spdm_context->connection_info.algorithm.base_asym_algo,
3906 : data, data_size,
3907 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
3908 : #endif
3909 :
3910 1 : request_attribute = 0;
3911 :
3912 1 : measurement_record_length = sizeof(measurement_record);
3913 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
3914 : 0, NULL, &number_of_block,
3915 : &measurement_record_length,
3916 : measurement_record);
3917 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
3918 : /* #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT*/
3919 : /* assert_int_equal (spdm_context->transcript.message_m.buffer_size, 0);*/
3920 : /* #endif*/
3921 1 : free(data);
3922 1 : }
3923 :
3924 : /**
3925 : * Test 20: Error case, measurement_specification field in response has 2 bits set (bit 0 is not one of them)
3926 : * Expected Behavior: get a RETURN_DEVICE_ERROR return code,
3927 : **/
3928 1 : static void libspdm_test_requester_get_measurements_err_case20(void **state)
3929 : {
3930 : libspdm_return_t status;
3931 : libspdm_test_context_t *spdm_test_context;
3932 : libspdm_context_t *spdm_context;
3933 : uint8_t number_of_block;
3934 : uint32_t measurement_record_length;
3935 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
3936 : uint8_t request_attribute;
3937 : void *data;
3938 : size_t data_size;
3939 : void *hash;
3940 : size_t hash_size;
3941 :
3942 1 : spdm_test_context = *state;
3943 1 : spdm_context = spdm_test_context->spdm_context;
3944 1 : spdm_test_context->case_id = 0x14;
3945 :
3946 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
3947 : SPDM_VERSION_NUMBER_SHIFT_BIT;
3948 1 : spdm_context->connection_info.connection_state =
3949 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
3950 1 : spdm_context->connection_info.capability.flags |=
3951 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
3952 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
3953 : m_libspdm_use_asym_algo, &data,
3954 : &data_size, &hash, &hash_size)) {
3955 0 : assert(false);
3956 : }
3957 1 : libspdm_reset_message_m(spdm_context, NULL);
3958 1 : spdm_context->connection_info.algorithm.measurement_spec =
3959 : m_libspdm_use_measurement_spec;
3960 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
3961 : m_libspdm_use_measurement_hash_algo;
3962 1 : spdm_context->connection_info.algorithm.base_hash_algo =
3963 : m_libspdm_use_hash_algo;
3964 1 : spdm_context->connection_info.algorithm.base_asym_algo =
3965 : m_libspdm_use_asym_algo;
3966 1 : spdm_context->local_context.algorithm.measurement_spec =
3967 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
3968 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
3969 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
3970 : data_size;
3971 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
3972 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
3973 : data, data_size);
3974 : #else
3975 1 : libspdm_hash_all(
3976 : spdm_context->connection_info.algorithm.base_hash_algo,
3977 : data, data_size,
3978 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
3979 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
3980 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
3981 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
3982 : spdm_context->connection_info.algorithm.base_hash_algo,
3983 : spdm_context->connection_info.algorithm.base_asym_algo,
3984 : data, data_size,
3985 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
3986 : #endif
3987 :
3988 1 : request_attribute = 0;
3989 :
3990 1 : measurement_record_length = sizeof(measurement_record);
3991 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
3992 : 0, NULL, &number_of_block,
3993 : &measurement_record_length,
3994 : measurement_record);
3995 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
3996 : /* #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT*/
3997 : /* assert_int_equal (spdm_context->transcript.message_m.buffer_size, 0);*/
3998 : /* #endif*/
3999 1 : free(data);
4000 1 : }
4001 :
4002 : /**
4003 : * Test 21: Error case, measurement_specification field in response does not "match the selected measurement specification in the ALGORITHMS message"
4004 : * Expected Behavior: get a RETURN_DEVICE_ERROR return code,
4005 : **/
4006 1 : static void libspdm_test_requester_get_measurements_err_case21(void **state)
4007 : {
4008 : libspdm_return_t status;
4009 : libspdm_test_context_t *spdm_test_context;
4010 : libspdm_context_t *spdm_context;
4011 : uint8_t number_of_block;
4012 : uint32_t measurement_record_length;
4013 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
4014 : uint8_t request_attribute;
4015 : void *data;
4016 : size_t data_size;
4017 : void *hash;
4018 : size_t hash_size;
4019 :
4020 1 : spdm_test_context = *state;
4021 1 : spdm_context = spdm_test_context->spdm_context;
4022 1 : spdm_test_context->case_id = 0x15;
4023 :
4024 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4025 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4026 1 : spdm_context->connection_info.connection_state =
4027 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
4028 1 : spdm_context->connection_info.capability.flags |=
4029 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
4030 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
4031 : m_libspdm_use_asym_algo, &data,
4032 : &data_size, &hash, &hash_size)) {
4033 0 : assert(false);
4034 : }
4035 1 : libspdm_reset_message_m(spdm_context, NULL);
4036 1 : spdm_context->connection_info.algorithm.measurement_spec =
4037 : m_libspdm_use_measurement_spec;
4038 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
4039 : m_libspdm_use_measurement_hash_algo;
4040 1 : spdm_context->connection_info.algorithm.base_hash_algo =
4041 : m_libspdm_use_hash_algo;
4042 1 : spdm_context->connection_info.algorithm.base_asym_algo =
4043 : m_libspdm_use_asym_algo;
4044 1 : spdm_context->local_context.algorithm.measurement_spec =
4045 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
4046 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4047 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
4048 : data_size;
4049 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
4050 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
4051 : data, data_size);
4052 : #else
4053 1 : libspdm_hash_all(
4054 : spdm_context->connection_info.algorithm.base_hash_algo,
4055 : data, data_size,
4056 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
4057 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
4058 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
4059 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
4060 : spdm_context->connection_info.algorithm.base_hash_algo,
4061 : spdm_context->connection_info.algorithm.base_asym_algo,
4062 : data, data_size,
4063 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
4064 : #endif
4065 :
4066 1 : request_attribute = 0;
4067 :
4068 1 : measurement_record_length = sizeof(measurement_record);
4069 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
4070 : 0, NULL, &number_of_block,
4071 : &measurement_record_length,
4072 : measurement_record);
4073 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
4074 : /* #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT*/
4075 : /* assert_int_equal (spdm_context->transcript.message_m.buffer_size, 0);*/
4076 : /* #endif*/
4077 1 : free(data);
4078 1 : }
4079 :
4080 : /**
4081 : * Test 22: request a large number of unsigned measurements before requesting a signature
4082 : * Expected Behavior: RETURN_SUCCESS return code and correct transcript.message_m.buffer_size while transcript.message_m has room; RETURN_DEVICE_ERROR otherwise
4083 : **/
4084 1 : static void libspdm_test_requester_get_measurements_err_case22(void **state)
4085 : {
4086 : libspdm_return_t status;
4087 : libspdm_test_context_t *spdm_test_context;
4088 : libspdm_context_t *spdm_context;
4089 : uint8_t number_of_block;
4090 : uint32_t measurement_record_length;
4091 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
4092 : uint8_t request_attribute;
4093 : void *data;
4094 : size_t data_size;
4095 : void *hash;
4096 : size_t hash_size;
4097 : size_t NumberOfMessages;
4098 : #define TOTAL_MESSAGES 100
4099 :
4100 1 : spdm_test_context = *state;
4101 1 : spdm_context = spdm_test_context->spdm_context;
4102 1 : spdm_test_context->case_id = 0x16;
4103 :
4104 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4105 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4106 1 : spdm_context->connection_info.connection_state =
4107 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
4108 1 : spdm_context->connection_info.capability.flags |=
4109 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
4110 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
4111 : m_libspdm_use_asym_algo, &data,
4112 : &data_size, &hash, &hash_size)) {
4113 0 : assert(false);
4114 : }
4115 1 : libspdm_reset_message_m(spdm_context, NULL);
4116 1 : spdm_context->connection_info.algorithm.measurement_spec =
4117 : m_libspdm_use_measurement_spec;
4118 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
4119 : m_libspdm_use_measurement_hash_algo;
4120 1 : spdm_context->connection_info.algorithm.base_hash_algo =
4121 : m_libspdm_use_hash_algo;
4122 1 : spdm_context->connection_info.algorithm.base_asym_algo =
4123 : m_libspdm_use_asym_algo;
4124 1 : spdm_context->local_context.algorithm.measurement_spec =
4125 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
4126 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4127 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
4128 : data_size;
4129 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
4130 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
4131 : data, data_size);
4132 : #else
4133 1 : libspdm_hash_all(
4134 : spdm_context->connection_info.algorithm.base_hash_algo,
4135 : data, data_size,
4136 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
4137 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
4138 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
4139 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
4140 : spdm_context->connection_info.algorithm.base_hash_algo,
4141 : spdm_context->connection_info.algorithm.base_asym_algo,
4142 : data, data_size,
4143 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
4144 : #endif
4145 :
4146 1 : request_attribute = 0;
4147 :
4148 1 : measurement_record_length = sizeof(measurement_record);
4149 101 : for (NumberOfMessages = 1; NumberOfMessages <= TOTAL_MESSAGES;
4150 100 : NumberOfMessages++) {
4151 100 : status = libspdm_get_measurement(spdm_context, NULL,
4152 : request_attribute, 1, 0,
4153 : NULL, &number_of_block,
4154 : &measurement_record_length,
4155 : measurement_record);
4156 : /* It may fail due to transcript.message_m overflow*/
4157 100 : if (status == LIBSPDM_STATUS_SUCCESS) {
4158 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4159 : assert_int_equal(
4160 : spdm_context->transcript.message_m.buffer_size,
4161 : NumberOfMessages *
4162 : (sizeof(spdm_message_header_t) +
4163 : sizeof(spdm_measurements_response_t) +
4164 : sizeof(spdm_measurement_block_dmtf_t) +
4165 : libspdm_get_measurement_hash_size(
4166 : m_libspdm_use_measurement_hash_algo) +
4167 : SPDM_NONCE_SIZE +
4168 : sizeof(uint16_t)));
4169 : #endif
4170 : } else {
4171 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4172 : assert_int_equal(
4173 : spdm_context->transcript.message_m.buffer_size,
4174 : 0);
4175 : #endif
4176 0 : break;
4177 : }
4178 : }
4179 1 : free(data);
4180 1 : }
4181 :
4182 : /**
4183 : * Test 23:
4184 : * Expected Behavior:
4185 : **/
4186 1 : static void libspdm_test_requester_get_measurements_err_case23(void **state)
4187 : {
4188 1 : }
4189 :
4190 : /**
4191 : * Test 24: Error case, response contains opaque data larger than the maximum allowed
4192 : * Expected Behavior: get a RETURN_DEVICE_ERROR return code, correct transcript.message_m.buffer_size
4193 : **/
4194 1 : static void libspdm_test_requester_get_measurements_err_case24(void **state)
4195 : {
4196 : libspdm_return_t status;
4197 : libspdm_test_context_t *spdm_test_context;
4198 : libspdm_context_t *spdm_context;
4199 : uint8_t number_of_block;
4200 : uint32_t measurement_record_length;
4201 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
4202 : uint8_t request_attribute;
4203 : void *data;
4204 : size_t data_size;
4205 : void *hash;
4206 : size_t hash_size;
4207 :
4208 1 : spdm_test_context = *state;
4209 1 : spdm_context = spdm_test_context->spdm_context;
4210 1 : spdm_test_context->case_id = 0x18;
4211 :
4212 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4213 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4214 1 : spdm_context->connection_info.connection_state =
4215 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
4216 1 : spdm_context->connection_info.capability.flags |=
4217 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
4218 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
4219 : m_libspdm_use_asym_algo, &data,
4220 : &data_size, &hash, &hash_size)) {
4221 0 : assert(false);
4222 : }
4223 1 : libspdm_reset_message_m(spdm_context, NULL);
4224 1 : spdm_context->connection_info.algorithm.measurement_spec =
4225 : m_libspdm_use_measurement_spec;
4226 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
4227 : m_libspdm_use_measurement_hash_algo;
4228 1 : spdm_context->connection_info.algorithm.base_hash_algo =
4229 : m_libspdm_use_hash_algo;
4230 1 : spdm_context->connection_info.algorithm.base_asym_algo =
4231 : m_libspdm_use_asym_algo;
4232 1 : spdm_context->local_context.algorithm.measurement_spec =
4233 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
4234 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4235 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
4236 : data_size;
4237 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
4238 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
4239 : data, data_size);
4240 : #else
4241 1 : libspdm_hash_all(
4242 : spdm_context->connection_info.algorithm.base_hash_algo,
4243 : data, data_size,
4244 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
4245 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
4246 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
4247 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
4248 : spdm_context->connection_info.algorithm.base_hash_algo,
4249 : spdm_context->connection_info.algorithm.base_asym_algo,
4250 : data, data_size,
4251 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
4252 : #endif
4253 :
4254 1 : request_attribute = 0;
4255 :
4256 1 : measurement_record_length = sizeof(measurement_record);
4257 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
4258 : 0, NULL, &number_of_block,
4259 : &measurement_record_length,
4260 : measurement_record);
4261 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
4262 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4263 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
4264 : 0);
4265 : #endif
4266 1 : free(data);
4267 1 : }
4268 :
4269 : /**
4270 : * Test 25: Requester does not request a signature and `content_changed` is non-zero in the response.
4271 : * Expected Behavior: returns with LIBSPDM_STATUS_INVALID_MSG_FIELD.
4272 : **/
4273 1 : static void libspdm_test_requester_get_measurements_err_case25(void **state)
4274 : {
4275 : libspdm_return_t status;
4276 : libspdm_test_context_t *spdm_test_context;
4277 : libspdm_context_t *spdm_context;
4278 : uint8_t number_of_block;
4279 : uint32_t measurement_record_length;
4280 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
4281 : uint8_t request_attribute;
4282 : void *data;
4283 : size_t data_size;
4284 : void *hash;
4285 : size_t hash_size;
4286 :
4287 1 : spdm_test_context = *state;
4288 1 : spdm_context = spdm_test_context->spdm_context;
4289 1 : spdm_test_context->case_id = 0x19;
4290 :
4291 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
4292 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4293 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
4294 1 : spdm_context->connection_info.capability.flags |=
4295 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
4296 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
4297 : m_libspdm_use_asym_algo, &data,
4298 : &data_size, &hash, &hash_size)) {
4299 0 : assert(false);
4300 : }
4301 1 : libspdm_reset_message_m(spdm_context, NULL);
4302 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
4303 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
4304 : m_libspdm_use_measurement_hash_algo;
4305 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
4306 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
4307 1 : spdm_context->local_context.algorithm.measurement_spec =
4308 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
4309 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4310 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
4311 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
4312 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
4313 : data, data_size);
4314 : #else
4315 1 : libspdm_hash_all(
4316 : spdm_context->connection_info.algorithm.base_hash_algo,
4317 : data, data_size,
4318 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
4319 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
4320 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
4321 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
4322 : spdm_context->connection_info.algorithm.base_hash_algo,
4323 : spdm_context->connection_info.algorithm.base_asym_algo,
4324 : data, data_size,
4325 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
4326 : #endif
4327 :
4328 1 : request_attribute = 0;
4329 :
4330 1 : measurement_record_length = sizeof(measurement_record);
4331 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
4332 : 0, NULL, &number_of_block,
4333 : &measurement_record_length,
4334 : measurement_record);
4335 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
4336 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4337 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
4338 : #endif
4339 1 : free(data);
4340 1 : }
4341 :
4342 : /**
4343 : * Test 26: Error case, request with signature, but response opaque data is S bytes shorter than informed
4344 : * Expected Behavior: get a RETURN_DEVICE_ERROR return code, correct transcript.message_m.buffer_size
4345 : **/
4346 1 : static void libspdm_test_requester_get_measurements_err_case26(void **state)
4347 : {
4348 : libspdm_return_t status;
4349 : libspdm_test_context_t *spdm_test_context;
4350 : libspdm_context_t *spdm_context;
4351 : uint8_t number_of_block;
4352 : uint32_t measurement_record_length;
4353 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
4354 : uint8_t request_attribute;
4355 : void *data;
4356 : size_t data_size;
4357 : void *hash;
4358 : size_t hash_size;
4359 :
4360 1 : spdm_test_context = *state;
4361 1 : spdm_context = spdm_test_context->spdm_context;
4362 1 : spdm_test_context->case_id = 0x1A;
4363 :
4364 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4365 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4366 1 : spdm_context->connection_info.connection_state =
4367 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
4368 1 : spdm_context->connection_info.capability.flags |=
4369 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
4370 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
4371 : m_libspdm_use_asym_algo, &data,
4372 : &data_size, &hash, &hash_size)) {
4373 0 : assert(false);
4374 : }
4375 1 : libspdm_reset_message_m(spdm_context, NULL);
4376 1 : spdm_context->connection_info.algorithm.measurement_spec =
4377 : m_libspdm_use_measurement_spec;
4378 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
4379 : m_libspdm_use_measurement_hash_algo;
4380 1 : spdm_context->connection_info.algorithm.base_hash_algo =
4381 : m_libspdm_use_hash_algo;
4382 1 : spdm_context->connection_info.algorithm.base_asym_algo =
4383 : m_libspdm_use_asym_algo;
4384 1 : spdm_context->local_context.algorithm.measurement_spec =
4385 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
4386 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4387 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
4388 : data_size;
4389 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
4390 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
4391 : data, data_size);
4392 : #else
4393 1 : libspdm_hash_all(
4394 : spdm_context->connection_info.algorithm.base_hash_algo,
4395 : data, data_size,
4396 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
4397 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
4398 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
4399 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
4400 : spdm_context->connection_info.algorithm.base_hash_algo,
4401 : spdm_context->connection_info.algorithm.base_asym_algo,
4402 : data, data_size,
4403 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
4404 : #endif
4405 :
4406 1 : request_attribute =
4407 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
4408 :
4409 1 : measurement_record_length = sizeof(measurement_record);
4410 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
4411 : 0, NULL, &number_of_block,
4412 : &measurement_record_length,
4413 : measurement_record);
4414 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_SIZE);
4415 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4416 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
4417 : 0);
4418 : #endif
4419 1 : free(data);
4420 1 : }
4421 :
4422 : /**
4423 : * Test 27: Error case, request with signature, but response opaque data is (S+1) bytes shorter than informed
4424 : * Expected Behavior: get a RETURN_DEVICE_ERROR return code, correct transcript.message_m.buffer_size
4425 : **/
4426 1 : static void libspdm_test_requester_get_measurements_err_case27(void **state)
4427 : {
4428 : libspdm_return_t status;
4429 : libspdm_test_context_t *spdm_test_context;
4430 : libspdm_context_t *spdm_context;
4431 : uint8_t number_of_block;
4432 : uint32_t measurement_record_length;
4433 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
4434 : uint8_t request_attribute;
4435 : void *data;
4436 : size_t data_size;
4437 : void *hash;
4438 : size_t hash_size;
4439 :
4440 1 : spdm_test_context = *state;
4441 1 : spdm_context = spdm_test_context->spdm_context;
4442 1 : spdm_test_context->case_id = 0x1B;
4443 :
4444 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4445 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4446 1 : spdm_context->connection_info.connection_state =
4447 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
4448 1 : spdm_context->connection_info.capability.flags |=
4449 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
4450 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
4451 : m_libspdm_use_asym_algo, &data,
4452 : &data_size, &hash, &hash_size)) {
4453 0 : assert(false);
4454 : }
4455 1 : libspdm_reset_message_m(spdm_context, NULL);
4456 1 : spdm_context->connection_info.algorithm.measurement_spec =
4457 : m_libspdm_use_measurement_spec;
4458 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
4459 : m_libspdm_use_measurement_hash_algo;
4460 1 : spdm_context->connection_info.algorithm.base_hash_algo =
4461 : m_libspdm_use_hash_algo;
4462 1 : spdm_context->connection_info.algorithm.base_asym_algo =
4463 : m_libspdm_use_asym_algo;
4464 1 : spdm_context->local_context.algorithm.measurement_spec =
4465 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
4466 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4467 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
4468 : data_size;
4469 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
4470 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
4471 : data, data_size);
4472 : #else
4473 1 : libspdm_hash_all(
4474 : spdm_context->connection_info.algorithm.base_hash_algo,
4475 : data, data_size,
4476 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
4477 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
4478 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
4479 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
4480 : spdm_context->connection_info.algorithm.base_hash_algo,
4481 : spdm_context->connection_info.algorithm.base_asym_algo,
4482 : data, data_size,
4483 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
4484 : #endif
4485 :
4486 1 : request_attribute =
4487 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
4488 :
4489 1 : measurement_record_length = sizeof(measurement_record);
4490 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
4491 : 0, NULL, &number_of_block,
4492 : &measurement_record_length,
4493 : measurement_record);
4494 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_SIZE);
4495 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4496 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
4497 : 0);
4498 : #endif
4499 1 : free(data);
4500 1 : }
4501 :
4502 : /**
4503 : * Test 28: Error case, request with signature, but response opaque data is 1 byte longer than informed
4504 : * Expected Behavior: get a RETURN_DEVICE_ERROR return code, correct transcript.message_m.buffer_size
4505 : **/
4506 1 : static void libspdm_test_requester_get_measurements_err_case28(void **state)
4507 : {
4508 : libspdm_return_t status;
4509 : libspdm_test_context_t *spdm_test_context;
4510 : libspdm_context_t *spdm_context;
4511 : uint8_t number_of_block;
4512 : uint32_t measurement_record_length;
4513 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
4514 : uint8_t request_attribute;
4515 : void *data;
4516 : size_t data_size;
4517 : void *hash;
4518 : size_t hash_size;
4519 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4520 : size_t ExpectedBufferSize;
4521 : #endif
4522 1 : spdm_test_context = *state;
4523 1 : spdm_context = spdm_test_context->spdm_context;
4524 1 : spdm_test_context->case_id = 0x1C;
4525 :
4526 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
4527 : SPDM_VERSION_NUMBER_SHIFT_BIT;
4528 1 : spdm_context->connection_info.connection_state =
4529 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
4530 1 : spdm_context->connection_info.capability.flags |=
4531 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
4532 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
4533 : m_libspdm_use_asym_algo, &data,
4534 : &data_size, &hash, &hash_size)) {
4535 0 : assert(false);
4536 : }
4537 1 : libspdm_reset_message_m(spdm_context, NULL);
4538 1 : spdm_context->connection_info.algorithm.measurement_spec =
4539 : m_libspdm_use_measurement_spec;
4540 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
4541 : m_libspdm_use_measurement_hash_algo;
4542 1 : spdm_context->connection_info.algorithm.base_hash_algo =
4543 : m_libspdm_use_hash_algo;
4544 1 : spdm_context->connection_info.algorithm.base_asym_algo =
4545 : m_libspdm_use_asym_algo;
4546 1 : spdm_context->local_context.algorithm.measurement_spec =
4547 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
4548 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4549 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
4550 : data_size;
4551 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
4552 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
4553 : data, data_size);
4554 : #else
4555 1 : libspdm_hash_all(
4556 : spdm_context->connection_info.algorithm.base_hash_algo,
4557 : data, data_size,
4558 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
4559 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
4560 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
4561 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
4562 : spdm_context->connection_info.algorithm.base_hash_algo,
4563 : spdm_context->connection_info.algorithm.base_asym_algo,
4564 : data, data_size,
4565 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
4566 : #endif
4567 :
4568 1 : request_attribute =
4569 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
4570 :
4571 1 : measurement_record_length = sizeof(measurement_record);
4572 1 : status = libspdm_get_measurement(spdm_context, NULL, request_attribute, 1,
4573 : 0, NULL, &number_of_block,
4574 : &measurement_record_length,
4575 : measurement_record);
4576 1 : assert_int_equal(status, LIBSPDM_STATUS_VERIF_FAIL);
4577 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4578 : ExpectedBufferSize = 0;
4579 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
4580 : ExpectedBufferSize);
4581 : #endif
4582 1 : free(data);
4583 1 : }
4584 :
4585 : /**
4586 : * Test 29:
4587 : * Expected Behavior:
4588 : **/
4589 1 : static void libspdm_test_requester_get_measurements_err_case29(void **state)
4590 : {
4591 1 : }
4592 :
4593 : /**
4594 : * Test 30:
4595 : * Expected Behavior:
4596 : **/
4597 1 : static void libspdm_test_requester_get_measurements_err_case30(void **state)
4598 : {
4599 1 : }
4600 :
4601 : /**
4602 : * Test 31: Error case, response contains opaque data larger than the maximum allowed. MAXUINT16 is used
4603 : * Expected Behavior: get a RETURN_DEVICE_ERROR return code, correct transcript.message_m.buffer_size
4604 : **/
4605 1 : static void libspdm_test_requester_get_measurements_err_case31(void **state)
4606 : {
4607 1 : }
4608 :
4609 : /**
4610 : * Test 32:
4611 : * Expected Behavior:
4612 : **/
4613 1 : static void libspdm_test_requester_get_measurements_err_case32(void **state)
4614 : {
4615 1 : }
4616 :
4617 : /**
4618 : * Test 33: receiving an unexpected ERROR message from the responder.
4619 : * There are tests for all named codes, including some reserved ones
4620 : * (namely, 0x00, 0x0b, 0x0c, 0x3f, 0xfd, 0xfe).
4621 : * However, for having specific test cases, it is excluded from this case:
4622 : * Busy (0x03), ResponseNotReady (0x42), and RequestResync (0x43).
4623 : * Expected behavior: client returns a status of RETURN_DEVICE_ERROR.
4624 : **/
4625 1 : static void libspdm_test_requester_get_measurements_err_case33(void **state) {
4626 : libspdm_return_t status;
4627 : libspdm_test_context_t *spdm_test_context;
4628 : libspdm_context_t *spdm_context;
4629 : uint8_t number_of_block;
4630 : uint32_t measurement_record_length;
4631 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
4632 : uint8_t request_attribute;
4633 : void *data;
4634 : size_t data_size;
4635 : void *hash;
4636 : size_t hash_size;
4637 : uint16_t error_code;
4638 :
4639 1 : spdm_test_context = *state;
4640 1 : spdm_context = spdm_test_context->spdm_context;
4641 1 : spdm_test_context->case_id = 0x21;
4642 1 : spdm_context->connection_info.capability.flags |=
4643 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
4644 1 : libspdm_read_responder_public_certificate_chain (m_libspdm_use_hash_algo,
4645 : m_libspdm_use_asym_algo,
4646 : &data, &data_size,
4647 : &hash, &hash_size);
4648 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
4649 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
4650 : m_libspdm_use_measurement_hash_algo;
4651 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
4652 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
4653 1 : spdm_context->local_context.algorithm.measurement_spec =
4654 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
4655 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4656 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
4657 : data_size;
4658 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
4659 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
4660 : data, data_size);
4661 : #else
4662 1 : libspdm_hash_all(
4663 : spdm_context->connection_info.algorithm.base_hash_algo,
4664 : data, data_size,
4665 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
4666 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
4667 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
4668 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
4669 : spdm_context->connection_info.algorithm.base_hash_algo,
4670 : spdm_context->connection_info.algorithm.base_asym_algo,
4671 : data, data_size,
4672 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
4673 : #endif
4674 :
4675 1 : request_attribute = SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE;
4676 :
4677 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
4678 19 : while(error_code <= 0xff) {
4679 18 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
4680 18 : libspdm_reset_message_m(spdm_context, NULL);
4681 :
4682 18 : measurement_record_length = sizeof(measurement_record);
4683 18 : status = libspdm_get_measurement (spdm_context, NULL, request_attribute, 1, 0, NULL,
4684 : &number_of_block, &measurement_record_length,
4685 : measurement_record);
4686 18 : LIBSPDM_ASSERT_INT_EQUAL_CASE (status, LIBSPDM_STATUS_ERROR_PEER, error_code);
4687 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
4688 : /* assert_int_equal (spdm_context->transcript.message_m.buffer_size, 0);*/
4689 : LIBSPDM_ASSERT_INT_EQUAL_CASE (spdm_context->transcript.message_m.buffer_size, 0,
4690 : error_code);
4691 : #endif
4692 :
4693 18 : error_code++;
4694 18 : if(error_code == SPDM_ERROR_CODE_BUSY) { /*busy is treated in cases 5 and 6*/
4695 1 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
4696 : }
4697 18 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) { /*skip some reserved error codes (0d to 3e)*/
4698 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
4699 : }
4700 18 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) { /*skip response not ready, request resync, and some reserved codes (44 to fc)*/
4701 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
4702 : }
4703 : }
4704 :
4705 1 : free(data);
4706 1 : }
4707 :
4708 : /**
4709 : * Test 34:
4710 : * Expected Behavior:
4711 : **/
4712 1 : static void libspdm_test_requester_get_measurements_err_case34(void **state)
4713 : {
4714 1 : }
4715 :
4716 : /**
4717 : * Test 35:
4718 : * Expected Behavior:
4719 : **/
4720 1 : static void libspdm_test_requester_get_measurements_err_case35(void **state)
4721 : {
4722 1 : }
4723 :
4724 1 : static void libspdm_test_requester_get_measurements_err_case36(void **state)
4725 : {
4726 1 : }
4727 :
4728 1 : static void libspdm_test_requester_get_measurements_err_case37(void **state)
4729 : {
4730 1 : }
4731 :
4732 1 : int libspdm_requester_get_measurements_error_test_main(void)
4733 : {
4734 1 : const struct CMUnitTest spdm_requester_get_measurements_tests[] = {
4735 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case1),
4736 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case2),
4737 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case3),
4738 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case4),
4739 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case5),
4740 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case6),
4741 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case7),
4742 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case8),
4743 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case9),
4744 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case10),
4745 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case11),
4746 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case12),
4747 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case13),
4748 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case14),
4749 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case15),
4750 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case16),
4751 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case17),
4752 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case18),
4753 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case19),
4754 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case20),
4755 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case21),
4756 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case22),
4757 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case23),
4758 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case24),
4759 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case25),
4760 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case26),
4761 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case27),
4762 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case28),
4763 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case29),
4764 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case30),
4765 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case31),
4766 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case32),
4767 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case33),
4768 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case34),
4769 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case35),
4770 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case36),
4771 : cmocka_unit_test(libspdm_test_requester_get_measurements_err_case37),
4772 : };
4773 :
4774 1 : libspdm_test_context_t test_context = {
4775 : LIBSPDM_TEST_CONTEXT_VERSION,
4776 : true,
4777 : libspdm_requester_get_measurements_test_send_message,
4778 : libspdm_requester_get_measurements_test_receive_message,
4779 : };
4780 :
4781 1 : libspdm_setup_test_context(&test_context);
4782 :
4783 1 : return cmocka_run_group_tests(spdm_requester_get_measurements_tests,
4784 : libspdm_unit_test_group_setup,
4785 : libspdm_unit_test_group_teardown);
4786 : }
4787 :
4788 : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP*/
|
