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