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