LCOV - code coverage report
Current view: top level - library/spdm_responder_lib - libspdm_rsp_measurements.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 84.6 % 195 165
Test Date: 2025-08-24 08:11:14 Functions: 100.0 % 2 2

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

Generated by: LCOV version 2.0-1