Line data    Source code

       1              : /**
       2              :  *  Copyright Notice:
       3              :  *  Copyright 2025-2026 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 "hal/base.h"
       8              : #include "internal/libspdm_common_lib.h"
       9              : 
      10              : uint8_t g_key_exchange_start_mut_auth = 0;
      11              : bool g_mandatory_mut_auth = false;
      12              : 
      13              : #if LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP
      14              : bool g_generate_key_exchange_opaque_data = false;
      15              : size_t libspdm_secret_lib_finish_opaque_data_size;
      16              : bool g_generate_finish_opaque_data = false;
      17              : 
      18           16 : bool libspdm_key_exchange_rsp_opaque_data(
      19              :     void *spdm_context,
      20              :     spdm_version_number_t spdm_version,
      21              :     uint8_t measurement_hash_type,
      22              :     uint8_t slot_id,
      23              :     uint8_t session_policy,
      24              :     const void *req_opaque_data,
      25              :     size_t req_opaque_data_size,
      26              :     void *opaque_data,
      27              :     size_t *opaque_data_size)
      28              : {
      29           16 :     if (g_generate_key_exchange_opaque_data) {
      30              :         size_t version_selection_data_size;
      31            3 :         version_selection_data_size = sizeof(spdm_general_opaque_data_table_header_t) +
      32              :                                       sizeof(secured_message_opaque_element_table_header_t) +
      33              :                                       sizeof(secured_message_opaque_element_version_selection_t);
      34              : 
      35            3 :         LIBSPDM_ASSERT(*opaque_data_size >= version_selection_data_size);
      36            3 :         *opaque_data_size = version_selection_data_size;
      37              : 
      38            3 :         if (opaque_data != NULL) {
      39              :             spdm_general_opaque_data_table_header_t *spdm_general_opaque_data_table_header;
      40              :             secured_message_opaque_element_table_header_t *opaque_element_table_header;
      41              :             secured_message_opaque_element_version_selection_t *opaque_element_version_section;
      42              : 
      43            2 :             spdm_general_opaque_data_table_header = opaque_data;
      44            2 :             spdm_general_opaque_data_table_header->total_elements = 1;
      45            2 :             libspdm_write_uint24(spdm_general_opaque_data_table_header->reserved, 0);
      46              : 
      47            2 :             opaque_element_table_header = (void *)(spdm_general_opaque_data_table_header + 1);
      48            2 :             opaque_element_table_header->id = SPDM_REGISTRY_ID_DMTF;
      49            2 :             opaque_element_table_header->vendor_len = 0;
      50            2 :             opaque_element_table_header->opaque_element_data_len =
      51              :                 sizeof(secured_message_opaque_element_version_selection_t);
      52            2 :             opaque_element_version_section = (void *)(opaque_element_table_header + 1);
      53            2 :             opaque_element_version_section->sm_data_version =
      54              :                 SECURED_MESSAGE_OPAQUE_ELEMENT_SMDATA_DATA_VERSION;
      55            2 :             opaque_element_version_section->sm_data_id =
      56              :                 SECURED_MESSAGE_OPAQUE_ELEMENT_SMDATA_ID_VERSION_SELECTION;
      57            2 :             opaque_element_version_section->selected_version =
      58              :                 SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT;
      59              :         }
      60              : 
      61            3 :         return true;
      62              :     }
      63           13 :     return false;
      64              : }
      65              : 
      66            1 : bool libspdm_finish_rsp_opaque_data(
      67              :     void *spdm_context,
      68              :     uint32_t session_id,
      69              :     spdm_version_number_t spdm_version,
      70              :     uint8_t req_slot_id,
      71              :     const void *req_opaque_data,
      72              :     size_t req_opaque_data_size,
      73              :     void *opaque_data,
      74              :     size_t *opaque_data_size)
      75              : {
      76            1 :     if (g_generate_finish_opaque_data) {
      77            1 :         LIBSPDM_ASSERT(libspdm_secret_lib_finish_opaque_data_size <= *opaque_data_size);
      78              : 
      79            1 :         *opaque_data_size = libspdm_secret_lib_finish_opaque_data_size;
      80              : 
      81            1 :         if (opaque_data != NULL) {
      82            9 :             for (size_t index = 0; index < *opaque_data_size; index++)
      83              :             {
      84            8 :                 ((uint8_t *)opaque_data)[index] = (uint8_t)(index + 1);
      85              :             }
      86              :         }
      87              :     } else {
      88            0 :         *opaque_data_size = 0;
      89              :     }
      90              : 
      91            1 :     return true;
      92              : }
      93              : 
      94              : #if LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP
      95            3 : extern uint8_t libspdm_key_exchange_start_mut_auth(
      96              :     void *spdm_context,
      97              :     uint32_t session_id,
      98              :     spdm_version_number_t spdm_version,
      99              :     uint8_t slot_id,
     100              :     uint8_t *req_slot_id,
     101              :     uint8_t session_policy,
     102              :     size_t opaque_data_length,
     103              :     const void *opaque_data,
     104              :     bool *mandatory_mut_auth)
     105              : {
     106            3 :     *req_slot_id = 0;
     107            3 :     *mandatory_mut_auth = g_mandatory_mut_auth;
     108              : 
     109            3 :     return g_key_exchange_start_mut_auth;
     110              : }
     111              : #endif /* LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP */
     112              : #endif /* LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP */