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