Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2025 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : #include "internal/libspdm_responder_lib.h"
8 :
9 : #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
10 16 : bool libspdm_generate_measurement_signature(libspdm_context_t *spdm_context,
11 : libspdm_session_info_t *session_info,
12 : uint8_t slot_id,
13 : uint8_t *signature)
14 : {
15 : size_t signature_size;
16 : bool result;
17 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
18 : libspdm_l1l2_managed_buffer_t l1l2;
19 : uint8_t *l1l2_buffer;
20 : size_t l1l2_buffer_size;
21 : #else
22 : uint8_t l1l2_hash[LIBSPDM_MAX_HASH_SIZE];
23 : size_t l1l2_hash_size;
24 : #endif
25 :
26 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
27 : result = libspdm_calculate_l1l2(spdm_context, session_info, &l1l2);
28 : #else
29 16 : l1l2_hash_size = sizeof(l1l2_hash);
30 16 : result = libspdm_calculate_l1l2_hash(spdm_context, session_info, &l1l2_hash_size, l1l2_hash);
31 : #endif
32 16 : libspdm_reset_message_m(spdm_context, session_info);
33 16 : if (!result) {
34 0 : return false;
35 : }
36 :
37 16 : if (spdm_context->connection_info.algorithm.pqc_asym_algo != 0) {
38 0 : signature_size = libspdm_get_pqc_asym_signature_size(
39 : spdm_context->connection_info.algorithm.pqc_asym_algo);
40 : } else {
41 16 : signature_size = libspdm_get_asym_signature_size(
42 : spdm_context->connection_info.algorithm.base_asym_algo);
43 : }
44 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
45 : l1l2_buffer = libspdm_get_managed_buffer(&l1l2);
46 : l1l2_buffer_size = libspdm_get_managed_buffer_size(&l1l2);
47 :
48 : result = libspdm_responder_data_sign(
49 : spdm_context,
50 : spdm_context->connection_info.version,
51 : libspdm_slot_id_to_key_pair_id(spdm_context, slot_id, false),
52 : SPDM_MEASUREMENTS,
53 : spdm_context->connection_info.algorithm.base_asym_algo,
54 : spdm_context->connection_info.algorithm.pqc_asym_algo,
55 : spdm_context->connection_info.algorithm.base_hash_algo,
56 : false, l1l2_buffer, l1l2_buffer_size, signature, &signature_size);
57 : #else
58 32 : result = libspdm_responder_data_sign(
59 : spdm_context,
60 16 : spdm_context->connection_info.version,
61 16 : libspdm_slot_id_to_key_pair_id(spdm_context, slot_id, false),
62 : SPDM_MEASUREMENTS,
63 : spdm_context->connection_info.algorithm.base_asym_algo,
64 : spdm_context->connection_info.algorithm.pqc_asym_algo,
65 : spdm_context->connection_info.algorithm.base_hash_algo,
66 : true, l1l2_hash, l1l2_hash_size, signature, &signature_size);
67 : #endif
68 16 : return result;
69 : }
70 137 : libspdm_return_t libspdm_get_response_measurements(libspdm_context_t *spdm_context,
71 : size_t request_size,
72 : const void *request,
73 : size_t *response_size,
74 : void *response)
75 : {
76 : const spdm_get_measurements_request_t *spdm_request;
77 : size_t spdm_request_size;
78 : spdm_measurements_response_t *spdm_response;
79 : size_t spdm_response_size;
80 : libspdm_return_t status;
81 : size_t signature_size;
82 : uint8_t slot_id_param;
83 : uint8_t measurements_index;
84 : uint8_t measurements_count;
85 : uint8_t *measurements;
86 : size_t measurements_size;
87 : uint8_t *opaque_data;
88 : size_t opaque_data_size;
89 : size_t meas_opaque_buffer_size;
90 : bool ret;
91 : libspdm_session_info_t *session_info;
92 : libspdm_session_state_t session_state;
93 : uint8_t content_changed;
94 : uint8_t *fill_response_ptr;
95 : size_t request_context_size;
96 : const void *request_context;
97 :
98 137 : spdm_request = request;
99 :
100 : /* -=[Check Parameters Phase]=- */
101 137 : LIBSPDM_ASSERT(spdm_request->header.request_response_code == SPDM_GET_MEASUREMENTS);
102 :
103 137 : if (!spdm_context->last_spdm_request_session_id_valid) {
104 136 : session_info = NULL;
105 : } else {
106 1 : session_info = libspdm_get_session_info_via_session_id(
107 : spdm_context,
108 : spdm_context->last_spdm_request_session_id);
109 1 : if (session_info == NULL) {
110 : /* do not reset message_m because it is unclear which context it should be used. */
111 0 : return libspdm_generate_error_response(
112 : spdm_context,
113 : SPDM_ERROR_CODE_UNEXPECTED_REQUEST, 0,
114 : response_size, response);
115 : }
116 1 : session_state = libspdm_secured_message_get_session_state(
117 : session_info->secured_message_context);
118 1 : if (session_state != LIBSPDM_SESSION_STATE_ESTABLISHED) {
119 0 : libspdm_reset_message_m(spdm_context, session_info);
120 0 : return libspdm_generate_error_response(
121 : spdm_context,
122 : SPDM_ERROR_CODE_UNEXPECTED_REQUEST, 0,
123 : response_size, response);
124 : }
125 : }
126 :
127 137 : if (spdm_request->header.spdm_version != libspdm_get_connection_version(spdm_context)) {
128 0 : libspdm_reset_message_m(spdm_context, session_info);
129 0 : return libspdm_generate_error_response(spdm_context,
130 : SPDM_ERROR_CODE_VERSION_MISMATCH, 0,
131 : response_size, response);
132 : }
133 137 : if (spdm_context->response_state != LIBSPDM_RESPONSE_STATE_NORMAL) {
134 : #if LIBSPDM_RESPOND_IF_READY_SUPPORT
135 3 : if (spdm_context->response_state != LIBSPDM_RESPONSE_STATE_NOT_READY) {
136 : #endif
137 2 : libspdm_reset_message_m(spdm_context, session_info);
138 : #if LIBSPDM_RESPOND_IF_READY_SUPPORT
139 : }
140 : #endif
141 3 : return libspdm_responder_handle_response_state(
142 : spdm_context,
143 3 : spdm_request->header.request_response_code,
144 : response_size, response);
145 : }
146 : /* check local context here, because meas_cap is reserved for requester.*/
147 134 : if (!libspdm_is_capabilities_flag_supported(
148 : spdm_context, false, 0,
149 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP)) {
150 1 : libspdm_reset_message_m(spdm_context, session_info);
151 1 : return libspdm_generate_error_response(
152 : spdm_context, SPDM_ERROR_CODE_UNSUPPORTED_REQUEST,
153 : SPDM_GET_MEASUREMENTS, response_size, response);
154 : }
155 133 : if ((spdm_context->connection_info.algorithm.measurement_spec == 0) ||
156 133 : (spdm_context->connection_info.algorithm.measurement_hash_algo == 0) ) {
157 0 : libspdm_reset_message_m(spdm_context, session_info);
158 0 : return libspdm_generate_error_response(
159 : spdm_context, SPDM_ERROR_CODE_UNEXPECTED_REQUEST,
160 : 0, response_size, response);
161 : }
162 133 : if (spdm_context->connection_info.connection_state <
163 : LIBSPDM_CONNECTION_STATE_NEGOTIATED) {
164 1 : libspdm_reset_message_m(spdm_context, session_info);
165 1 : return libspdm_generate_error_response(
166 : spdm_context,
167 : SPDM_ERROR_CODE_UNEXPECTED_REQUEST, 0,
168 : response_size, response);
169 : }
170 :
171 132 : if ((spdm_request->header.param1 &
172 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE) != 0) {
173 24 : if (spdm_request->header.spdm_version >= SPDM_MESSAGE_VERSION_11) {
174 13 : if (request_size < sizeof(spdm_get_measurements_request_t)) {
175 4 : libspdm_reset_message_m(spdm_context, session_info);
176 4 : return libspdm_generate_error_response(
177 : spdm_context,
178 : SPDM_ERROR_CODE_INVALID_REQUEST, 0,
179 : response_size, response);
180 : }
181 9 : spdm_request_size = sizeof(spdm_get_measurements_request_t);
182 : } else {
183 11 : if (request_size <
184 : sizeof(spdm_get_measurements_request_t) -
185 : sizeof(spdm_request->slot_id_param)) {
186 1 : libspdm_reset_message_m(spdm_context, session_info);
187 1 : return libspdm_generate_error_response(
188 : spdm_context,
189 : SPDM_ERROR_CODE_INVALID_REQUEST, 0,
190 : response_size, response);
191 : }
192 10 : spdm_request_size = sizeof(spdm_get_measurements_request_t) -
193 : sizeof(spdm_request->slot_id_param);
194 : }
195 : } else {
196 108 : if (request_size < sizeof(spdm_message_header_t)) {
197 0 : libspdm_reset_message_m(spdm_context, session_info);
198 0 : return libspdm_generate_error_response(
199 : spdm_context, SPDM_ERROR_CODE_INVALID_REQUEST,
200 : 0, response_size, response);
201 : }
202 108 : spdm_request_size = sizeof(spdm_message_header_t);
203 : }
204 127 : if (spdm_request->header.spdm_version >= SPDM_MESSAGE_VERSION_13) {
205 2 : if (request_size < spdm_request_size + SPDM_REQ_CONTEXT_SIZE) {
206 0 : libspdm_reset_message_m(spdm_context, session_info);
207 0 : return libspdm_generate_error_response(
208 : spdm_context, SPDM_ERROR_CODE_INVALID_REQUEST,
209 : 0, response_size, response);
210 : }
211 2 : spdm_request_size += SPDM_REQ_CONTEXT_SIZE;
212 : }
213 :
214 127 : if ((spdm_request->header.param1 &
215 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE) != 0) {
216 19 : if (!libspdm_is_capabilities_flag_supported(
217 : spdm_context, false, 0,
218 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG)) {
219 1 : libspdm_reset_message_m(spdm_context, session_info);
220 1 : return libspdm_generate_error_response(
221 : spdm_context, SPDM_ERROR_CODE_INVALID_REQUEST,
222 : 0, response_size, response);
223 : }
224 : }
225 :
226 126 : if ((spdm_request->header.param1 &
227 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE) == 0) {
228 108 : signature_size = 0;
229 : } else {
230 18 : if (spdm_context->connection_info.algorithm.pqc_asym_algo != 0) {
231 0 : signature_size = libspdm_get_pqc_asym_signature_size(
232 : spdm_context->connection_info.algorithm.pqc_asym_algo);
233 : } else {
234 18 : signature_size = libspdm_get_asym_signature_size(
235 : spdm_context->connection_info.algorithm.base_asym_algo);
236 : }
237 : }
238 :
239 126 : if (spdm_request->header.spdm_version >= SPDM_MESSAGE_VERSION_13) {
240 2 : request_context_size = SPDM_REQ_CONTEXT_SIZE;
241 :
242 2 : if ((spdm_request->header.param1 &
243 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE) == 0) {
244 1 : request_context = (const uint8_t *)spdm_request + sizeof(spdm_message_header_t);
245 : } else {
246 1 : request_context = spdm_request + 1;
247 : }
248 : } else {
249 124 : request_context_size = 0;
250 124 : request_context = NULL;
251 : }
252 :
253 : /* response_size should be large enough to hold a MEASUREMENTS response without
254 : * measurements or opaque data. */
255 126 : LIBSPDM_ASSERT(*response_size >= (sizeof(spdm_measurements_response_t) +
256 : SPDM_NONCE_SIZE + sizeof(uint16_t) + signature_size));
257 :
258 126 : meas_opaque_buffer_size = *response_size - (sizeof(spdm_measurements_response_t) +
259 : SPDM_NONCE_SIZE + sizeof(uint16_t) +
260 : signature_size);
261 :
262 126 : libspdm_zero_mem(response, *response_size);
263 :
264 126 : measurements_index = spdm_request->header.param2;
265 126 : measurements_count = 0;
266 126 : measurements = (uint8_t*)response + sizeof(spdm_measurements_response_t);
267 126 : measurements_size = meas_opaque_buffer_size;
268 :
269 126 : status = libspdm_measurement_collection(
270 : spdm_context,
271 126 : spdm_context->connection_info.version,
272 126 : spdm_context->connection_info.algorithm.measurement_spec,
273 : spdm_context->connection_info.algorithm.measurement_hash_algo,
274 : measurements_index,
275 126 : spdm_request->header.param1,
276 : request_context_size,
277 : request_context,
278 : &content_changed,
279 : &measurements_count,
280 : measurements,
281 : &measurements_size);
282 :
283 126 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
284 1 : if (status == LIBSPDM_STATUS_MEAS_INVALID_INDEX) {
285 1 : libspdm_reset_message_m(spdm_context, session_info);
286 1 : return libspdm_generate_error_response(
287 : spdm_context, SPDM_ERROR_CODE_INVALID_REQUEST,
288 : 0, response_size, response);
289 : } else {
290 0 : libspdm_reset_message_m(spdm_context, session_info);
291 0 : return libspdm_generate_error_response(
292 : spdm_context, SPDM_ERROR_CODE_UNSPECIFIED,
293 : 0, response_size, response);
294 : }
295 : }
296 :
297 125 : LIBSPDM_ASSERT(measurements_count != 0);
298 125 : LIBSPDM_ASSERT((measurements_index == 0) || (measurements_size > 0));
299 125 : LIBSPDM_ASSERT(measurements_size <= SPDM_MAX_MEASUREMENT_RECORD_LENGTH);
300 125 : LIBSPDM_ASSERT(measurements_size <= meas_opaque_buffer_size);
301 :
302 125 : if (measurements_index == 0) {
303 11 : measurements_size = 0;
304 : }
305 :
306 125 : opaque_data =
307 : (uint8_t*)response + sizeof(spdm_measurements_response_t) + measurements_size +
308 125 : SPDM_NONCE_SIZE + sizeof(uint16_t);
309 :
310 125 : if ((libspdm_get_connection_version(spdm_context) >= SPDM_MESSAGE_VERSION_12) &&
311 8 : ((spdm_context->connection_info.algorithm.other_params_support &
312 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_MASK) == SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_NONE)) {
313 4 : opaque_data_size = 0;
314 : } else {
315 121 : opaque_data_size = meas_opaque_buffer_size - measurements_size;
316 :
317 121 : ret = libspdm_measurement_opaque_data(
318 : spdm_context,
319 121 : spdm_context->connection_info.version,
320 121 : spdm_context->connection_info.algorithm.measurement_spec,
321 : spdm_context->connection_info.algorithm.measurement_hash_algo,
322 : measurements_index,
323 121 : spdm_request->header.param1,
324 : request_context_size,
325 : request_context,
326 : opaque_data,
327 : &opaque_data_size);
328 :
329 121 : if (!ret) {
330 0 : libspdm_reset_message_m(spdm_context, session_info);
331 0 : return libspdm_generate_error_response(
332 : spdm_context, SPDM_ERROR_CODE_UNSPECIFIED,
333 : 0, response_size, response);
334 : }
335 : }
336 :
337 125 : LIBSPDM_ASSERT(opaque_data_size <= (meas_opaque_buffer_size - measurements_size));
338 :
339 125 : spdm_response_size =
340 : sizeof(spdm_measurements_response_t) + measurements_size + SPDM_NONCE_SIZE +
341 125 : sizeof(uint16_t) + opaque_data_size + signature_size;
342 125 : if (spdm_request->header.spdm_version >= SPDM_MESSAGE_VERSION_13) {
343 2 : spdm_response_size += SPDM_REQ_CONTEXT_SIZE;
344 : }
345 :
346 125 : LIBSPDM_ASSERT(*response_size >= spdm_response_size);
347 :
348 125 : *response_size = spdm_response_size;
349 125 : spdm_response = response;
350 :
351 125 : switch (spdm_request->header.param2) {
352 11 : case SPDM_GET_MEASUREMENTS_REQUEST_MEASUREMENT_OPERATION_TOTAL_NUMBER_OF_MEASUREMENTS:
353 11 : spdm_response->header.spdm_version = spdm_request->header.spdm_version;
354 11 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
355 11 : spdm_response->header.param1 = measurements_count;
356 11 : spdm_response->header.param2 = 0;
357 11 : spdm_response->number_of_blocks = 0;
358 11 : libspdm_write_uint24(spdm_response->measurement_record_length, 0);
359 11 : break;
360 5 : case SPDM_GET_MEASUREMENTS_REQUEST_MEASUREMENT_OPERATION_ALL_MEASUREMENTS:
361 45 : LIBSPDM_DEBUG_CODE(
362 : uint8_t index;
363 : size_t debug_measurements_record_size;
364 : size_t debug_measurements_block_size;
365 : spdm_measurement_block_dmtf_t *debug_measurement_block;
366 :
367 : debug_measurements_record_size = 0;
368 : debug_measurement_block = (void *)measurements;
369 : for (index = 0; index < measurements_count; index++) {
370 : debug_measurements_block_size =
371 : sizeof(spdm_measurement_block_dmtf_t) +
372 : debug_measurement_block->measurement_block_dmtf_header
373 : .dmtf_spec_measurement_value_size;
374 : debug_measurements_record_size += debug_measurements_block_size;
375 : debug_measurement_block =
376 : (void *)((size_t)debug_measurement_block + debug_measurements_block_size);
377 : }
378 : LIBSPDM_ASSERT(debug_measurements_record_size == measurements_size);
379 : );
380 :
381 5 : spdm_response->header.spdm_version = spdm_request->header.spdm_version;
382 5 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
383 5 : spdm_response->header.param1 = 0;
384 5 : spdm_response->header.param2 = 0;
385 5 : spdm_response->number_of_blocks = measurements_count;
386 5 : libspdm_write_uint24(spdm_response->measurement_record_length, (uint32_t)measurements_size);
387 5 : break;
388 109 : default:
389 109 : LIBSPDM_ASSERT(measurements_count == 1);
390 :
391 109 : spdm_response->header.spdm_version = spdm_request->header.spdm_version;
392 109 : spdm_response->header.request_response_code = SPDM_MEASUREMENTS;
393 109 : spdm_response->header.param1 = 0;
394 109 : spdm_response->header.param2 = 0;
395 109 : spdm_response->number_of_blocks = 1;
396 109 : libspdm_write_uint24(spdm_response->measurement_record_length, (uint32_t)measurements_size);
397 109 : break;
398 : }
399 :
400 125 : if ((spdm_request->header.param1 &
401 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE) != 0) {
402 18 : if (spdm_response->header.spdm_version >= SPDM_MESSAGE_VERSION_11) {
403 8 : slot_id_param = spdm_request->slot_id_param &
404 : SPDM_GET_MEASUREMENTS_REQUEST_SLOT_ID_MASK;
405 8 : if ((slot_id_param != 0xF) && (slot_id_param >= SPDM_MAX_SLOT_COUNT)) {
406 1 : libspdm_reset_message_m(spdm_context, session_info);
407 1 : return libspdm_generate_error_response(
408 : spdm_context,
409 : SPDM_ERROR_CODE_INVALID_REQUEST, 0,
410 : response_size, response);
411 : }
412 7 : if (slot_id_param != 0xF) {
413 6 : if (spdm_context->local_context
414 6 : .local_cert_chain_provision[slot_id_param] == NULL) {
415 0 : libspdm_reset_message_m(spdm_context, session_info);
416 0 : return libspdm_generate_error_response(
417 : spdm_context, SPDM_ERROR_CODE_INVALID_REQUEST,
418 : 0, response_size, response);
419 : }
420 : } else {
421 1 : if (spdm_context->local_context
422 1 : .local_public_key_provision == NULL) {
423 0 : libspdm_reset_message_m(spdm_context, session_info);
424 0 : return libspdm_generate_error_response(
425 : spdm_context, SPDM_ERROR_CODE_INVALID_REQUEST,
426 : 0, response_size, response);
427 : }
428 : }
429 :
430 7 : if ((spdm_request->header.spdm_version >= SPDM_MESSAGE_VERSION_13) &&
431 1 : spdm_context->connection_info.multi_key_conn_rsp &&
432 : (slot_id_param != 0xF)) {
433 1 : if ((spdm_context->local_context.local_key_usage_bit_mask[slot_id_param] &
434 : SPDM_KEY_USAGE_BIT_MASK_MEASUREMENT_USE) == 0) {
435 1 : return libspdm_generate_error_response(
436 : spdm_context, SPDM_ERROR_CODE_INVALID_REQUEST,
437 : 0, response_size, response);
438 : }
439 : }
440 :
441 6 : spdm_response->header.param2 = slot_id_param;
442 6 : if (spdm_response->header.spdm_version >= SPDM_MESSAGE_VERSION_12) {
443 5 : spdm_response->header.param2 = slot_id_param |
444 5 : (content_changed &
445 : SPDM_MEASUREMENTS_RESPONSE_CONTENT_CHANGE_MASK);
446 : }
447 : }
448 : }
449 :
450 123 : fill_response_ptr =
451 123 : (uint8_t*)response + sizeof(spdm_measurements_response_t) + measurements_size;
452 :
453 123 : if (!libspdm_get_random_number(SPDM_NONCE_SIZE, fill_response_ptr)) {
454 0 : libspdm_reset_message_m(spdm_context, session_info);
455 0 : return libspdm_generate_error_response(spdm_context,
456 : SPDM_ERROR_CODE_UNSPECIFIED, 0,
457 : response_size, response);
458 : }
459 123 : fill_response_ptr += SPDM_NONCE_SIZE;
460 :
461 123 : libspdm_write_uint16(fill_response_ptr, (uint16_t)opaque_data_size);
462 123 : fill_response_ptr += sizeof(uint16_t);
463 :
464 123 : fill_response_ptr += opaque_data_size;
465 :
466 123 : if (spdm_request->header.spdm_version >= SPDM_MESSAGE_VERSION_13) {
467 1 : libspdm_copy_mem(fill_response_ptr, SPDM_REQ_CONTEXT_SIZE,
468 1 : (const uint8_t *)spdm_request + spdm_request_size - SPDM_REQ_CONTEXT_SIZE,
469 : SPDM_REQ_CONTEXT_SIZE);
470 1 : fill_response_ptr += SPDM_REQ_CONTEXT_SIZE;
471 : }
472 :
473 123 : libspdm_reset_message_buffer_via_request_code(spdm_context, session_info,
474 123 : spdm_request->header.request_response_code);
475 :
476 123 : status = libspdm_append_message_m(spdm_context, session_info, spdm_request, spdm_request_size);
477 123 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
478 0 : libspdm_reset_message_m(spdm_context, session_info);
479 0 : return libspdm_generate_error_response(spdm_context,
480 : SPDM_ERROR_CODE_UNSPECIFIED, 0,
481 : response_size, response);
482 : }
483 :
484 123 : status = libspdm_append_message_m(spdm_context, session_info,
485 123 : spdm_response, *response_size - signature_size);
486 123 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
487 0 : libspdm_reset_message_m(spdm_context, session_info);
488 0 : return libspdm_generate_error_response(spdm_context,
489 : SPDM_ERROR_CODE_UNSPECIFIED, 0,
490 : response_size, response);
491 : }
492 :
493 123 : if ((spdm_request->header.param1 &
494 : SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE) != 0) {
495 :
496 16 : ret = libspdm_generate_measurement_signature(
497 : spdm_context, session_info, slot_id_param, fill_response_ptr);
498 :
499 16 : if (!ret) {
500 0 : libspdm_reset_message_m(spdm_context, session_info);
501 0 : return libspdm_generate_error_response(
502 : spdm_context,
503 : SPDM_ERROR_CODE_UNSPECIFIED,
504 : 0,
505 : response_size, response);
506 : }
507 : /*reset*/
508 16 : libspdm_reset_message_m(spdm_context, session_info);
509 : }
510 :
511 123 : return LIBSPDM_STATUS_SUCCESS;
512 : }
513 :
514 : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP*/
|
