LCOV - code coverage report
Current view: top level - unit_test/test_spdm_responder - psk_exchange_rsp.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 99.7 % 787 785
Test Date: 2025-10-12 08:10:56 Functions: 100.0 % 18 18

            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 "spdm_unit_test.h"
       8              : #include "internal/libspdm_responder_lib.h"
       9              : #include "internal/libspdm_requester_lib.h"
      10              : 
      11              : #if LIBSPDM_ENABLE_CAPABILITY_PSK_CAP
      12              : 
      13              : #pragma pack(1)
      14              : 
      15              : typedef struct {
      16              :     spdm_message_header_t header;
      17              :     uint16_t req_session_id;
      18              :     uint16_t psk_hint_length;
      19              :     uint16_t context_length;
      20              :     uint16_t opaque_length;
      21              :     uint8_t psk_hint[LIBSPDM_PSK_MAX_HINT_LENGTH];
      22              :     uint8_t context[LIBSPDM_PSK_CONTEXT_LENGTH];
      23              :     uint8_t opaque_data[SPDM_MAX_OPAQUE_DATA_SIZE];
      24              : } libspdm_psk_exchange_request_mine_t;
      25              : 
      26              : typedef struct {
      27              :     spdm_message_header_t header;
      28              :     uint16_t req_session_id;
      29              :     uint16_t psk_hint_length;
      30              :     uint16_t context_length;
      31              :     uint16_t opaque_length;
      32              :     uint8_t context[LIBSPDM_PSK_CONTEXT_LENGTH];
      33              :     uint8_t opaque_data[SPDM_MAX_OPAQUE_DATA_SIZE];
      34              : } libspdm_psk_exchange_request_mine_t_noPSKHINT;
      35              : 
      36              : typedef struct {
      37              :     spdm_message_header_t header;
      38              :     uint16_t req_session_id;
      39              :     uint16_t psk_hint_length;
      40              :     uint16_t context_length;
      41              :     uint16_t opaque_length;
      42              :     uint8_t psk_hint[LIBSPDM_PSK_MAX_HINT_LENGTH];
      43              :     uint8_t context[LIBSPDM_PSK_CONTEXT_LENGTH];
      44              : } libspdm_psk_exchange_request_mine_t_noOPAQUE;
      45              : 
      46              : typedef struct {
      47              :     spdm_message_header_t header;
      48              :     uint16_t req_session_id;
      49              :     uint16_t psk_hint_length;
      50              :     uint16_t context_length;
      51              :     uint16_t opaque_length;
      52              :     uint8_t context[LIBSPDM_PSK_CONTEXT_LENGTH];
      53              : } libspdm_psk_exchange_request_mine_t_noPSKHINT_noOPAQUE;
      54              : 
      55              : #pragma pack()
      56              : 
      57              : 
      58              : libspdm_psk_exchange_request_mine_t m_libspdm_psk_exchange_request1 = {
      59              :     { SPDM_MESSAGE_VERSION_11, SPDM_PSK_EXCHANGE,
      60              :       SPDM_PSK_EXCHANGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH, 0 },
      61              : };
      62              : size_t m_libspdm_psk_exchange_request1_size = sizeof(m_libspdm_psk_exchange_request1);
      63              : 
      64              : libspdm_psk_exchange_request_mine_t m_libspdm_psk_exchange_request2 = {
      65              :     { SPDM_MESSAGE_VERSION_11, SPDM_PSK_EXCHANGE,
      66              :       SPDM_PSK_EXCHANGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH, 0 },
      67              : };
      68              : size_t m_libspdm_psk_exchange_request2_size = sizeof(spdm_psk_exchange_request_t);
      69              : 
      70              : libspdm_psk_exchange_request_mine_t m_libspdm_psk_exchange_request3 = {
      71              :     { SPDM_MESSAGE_VERSION_12, SPDM_PSK_EXCHANGE,
      72              :       SPDM_PSK_EXCHANGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH, 0 },
      73              : };
      74              : size_t m_libspdm_psk_exchange_request3_size = sizeof(m_libspdm_psk_exchange_request3);
      75              : 
      76              : /* Request TCB measurement hash */
      77              : libspdm_psk_exchange_request_mine_t m_libspdm_psk_exchange_request4 = {
      78              :     { SPDM_MESSAGE_VERSION_11, SPDM_PSK_EXCHANGE,
      79              :       SPDM_PSK_EXCHANGE_REQUEST_TCB_COMPONENT_MEASUREMENT_HASH, 0 },
      80              : };
      81              : size_t m_libspdm_psk_exchange_request4_size = sizeof(m_libspdm_psk_exchange_request4);
      82              : 
      83              : /* Request all measurement hash */
      84              : libspdm_psk_exchange_request_mine_t m_libspdm_psk_exchange_request5 = {
      85              :     { SPDM_MESSAGE_VERSION_11, SPDM_PSK_EXCHANGE,
      86              :       SPDM_PSK_EXCHANGE_REQUEST_ALL_MEASUREMENTS_HASH, 0 },
      87              : };
      88              : size_t m_libspdm_psk_exchange_request5_size = sizeof(m_libspdm_psk_exchange_request5);
      89              : 
      90              : /* Uses a reserved value in measurement hash */
      91              : libspdm_psk_exchange_request_mine_t m_libspdm_psk_exchange_request6 = {
      92              :     { SPDM_MESSAGE_VERSION_11, SPDM_PSK_EXCHANGE,
      93              :       0x50, 0 },
      94              : };
      95              : size_t m_libspdm_psk_exchange_request6_size = sizeof(m_libspdm_psk_exchange_request6);
      96              : 
      97              : libspdm_psk_exchange_request_mine_t_noPSKHINT m_libspdm_psk_exchange_request7 = {
      98              :     { SPDM_MESSAGE_VERSION_11, SPDM_PSK_EXCHANGE,
      99              :       SPDM_PSK_EXCHANGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH, 0 },
     100              : };
     101              : size_t m_libspdm_psk_exchange_request7_size = sizeof(m_libspdm_psk_exchange_request7);
     102              : 
     103              : libspdm_psk_exchange_request_mine_t_noOPAQUE m_libspdm_psk_exchange_request8 = {
     104              :     { SPDM_MESSAGE_VERSION_11, SPDM_PSK_EXCHANGE,
     105              :       SPDM_PSK_EXCHANGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH, 0 },
     106              : };
     107              : size_t m_libspdm_psk_exchange_request8_size = sizeof(m_libspdm_psk_exchange_request8);
     108              : 
     109              : libspdm_psk_exchange_request_mine_t_noPSKHINT_noOPAQUE m_libspdm_psk_exchange_request9 = {
     110              :     { SPDM_MESSAGE_VERSION_11, SPDM_PSK_EXCHANGE,
     111              :       SPDM_PSK_EXCHANGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH, 0 },
     112              : };
     113              : size_t m_libspdm_psk_exchange_request9_size = sizeof(m_libspdm_psk_exchange_request9);
     114              : 
     115            1 : static void rsp_psk_exchange_rsp_case1(void **state)
     116              : {
     117              :     libspdm_return_t status;
     118              :     libspdm_test_context_t *spdm_test_context;
     119              :     libspdm_context_t *spdm_context;
     120              :     size_t response_size;
     121              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     122              :     spdm_psk_exchange_response_t *spdm_response;
     123              :     void *data1;
     124              :     size_t data_size1;
     125              :     uint8_t *ptr;
     126              :     size_t opaque_psk_exchange_req_size;
     127              : 
     128            1 :     spdm_test_context = *state;
     129            1 :     spdm_context = spdm_test_context->spdm_context;
     130            1 :     spdm_test_context->case_id = 0x1;
     131            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     132              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     133            1 :     spdm_context->connection_info.connection_state =
     134              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     135            1 :     spdm_context->connection_info.capability.flags |=
     136              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP |
     137              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
     138            1 :     spdm_context->local_context.capability.flags |=
     139              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP |
     140              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
     141            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
     142              :         m_libspdm_use_hash_algo;
     143            1 :     spdm_context->connection_info.algorithm.measurement_spec =
     144              :         m_libspdm_use_measurement_spec;
     145            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     146              :         m_libspdm_use_measurement_hash_algo;
     147            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
     148              :         m_libspdm_use_dhe_algo;
     149            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
     150              :         m_libspdm_use_aead_algo;
     151            1 :     spdm_context->connection_info.algorithm.key_schedule =
     152              :         m_libspdm_use_key_schedule_algo;
     153            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     154              :                                                     m_libspdm_use_asym_algo, &data1,
     155              :                                                     &data_size1, NULL, NULL);
     156            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
     157            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
     158              :         data_size1;
     159            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
     160            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
     161              :         data_size1;
     162              : 
     163            1 :     libspdm_reset_message_a(spdm_context);
     164              : 
     165            1 :     m_libspdm_psk_exchange_request1.psk_hint_length =
     166              :         (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
     167            1 :     m_libspdm_psk_exchange_request1.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
     168            1 :     opaque_psk_exchange_req_size =
     169            1 :         libspdm_get_opaque_data_supported_version_data_size(spdm_context);
     170            1 :     m_libspdm_psk_exchange_request1.opaque_length =
     171            1 :         (uint16_t)opaque_psk_exchange_req_size;
     172            1 :     m_libspdm_psk_exchange_request1.req_session_id = 0xFFFF;
     173            1 :     ptr = m_libspdm_psk_exchange_request1.psk_hint;
     174            1 :     libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request1.psk_hint),
     175              :                      LIBSPDM_TEST_PSK_HINT_STRING,
     176              :                      sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
     177            1 :     ptr += m_libspdm_psk_exchange_request1.psk_hint_length;
     178            1 :     libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
     179            1 :     ptr += m_libspdm_psk_exchange_request1.context_length;
     180            1 :     libspdm_build_opaque_data_supported_version_data(
     181              :         spdm_context, &opaque_psk_exchange_req_size, ptr);
     182              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     183              :     spdm_context->transcript.message_m.buffer_size =
     184              :         spdm_context->transcript.message_m.max_buffer_size;
     185              : #endif
     186            1 :     ptr += opaque_psk_exchange_req_size;
     187            1 :     response_size = sizeof(response);
     188            1 :     status = libspdm_get_response_psk_exchange(
     189              :         spdm_context, m_libspdm_psk_exchange_request1_size,
     190              :         &m_libspdm_psk_exchange_request1, &response_size, response);
     191            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     192            1 :     assert_int_equal(
     193              :         libspdm_secured_message_get_session_state(
     194              :             spdm_context->session_info[0].secured_message_context),
     195              :         LIBSPDM_SESSION_STATE_HANDSHAKING);
     196            1 :     spdm_response = (void *)response;
     197            1 :     assert_int_equal(spdm_response->header.request_response_code,
     198              :                      SPDM_PSK_EXCHANGE_RSP);
     199            1 :     assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
     200              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     201              :     assert_int_equal(spdm_context->transcript.message_m.buffer_size,
     202              :                      0);
     203              : #endif
     204            1 :     free(data1);
     205            1 : }
     206              : 
     207            1 : static void rsp_psk_exchange_rsp_case2(void **state)
     208              : {
     209              :     libspdm_return_t status;
     210              :     libspdm_test_context_t *spdm_test_context;
     211              :     libspdm_context_t *spdm_context;
     212              :     size_t response_size;
     213              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     214              :     spdm_psk_exchange_response_t *spdm_response;
     215              :     void *data1;
     216              :     size_t data_size1;
     217              :     uint8_t *ptr;
     218              :     size_t opaque_psk_exchange_req_size;
     219              : 
     220            1 :     spdm_test_context = *state;
     221            1 :     spdm_context = spdm_test_context->spdm_context;
     222            1 :     spdm_test_context->case_id = 0x2;
     223            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     224              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     225            1 :     spdm_context->connection_info.connection_state =
     226              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     227            1 :     spdm_context->connection_info.capability.flags |=
     228              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
     229            1 :     spdm_context->local_context.capability.flags |=
     230              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
     231            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
     232              :         m_libspdm_use_hash_algo;
     233            1 :     spdm_context->connection_info.algorithm.measurement_spec =
     234              :         m_libspdm_use_measurement_spec;
     235            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     236              :         m_libspdm_use_measurement_hash_algo;
     237            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
     238              :         m_libspdm_use_dhe_algo;
     239            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
     240              :         m_libspdm_use_aead_algo;
     241            1 :     spdm_context->connection_info.algorithm.key_schedule =
     242              :         m_libspdm_use_key_schedule_algo;
     243            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     244              :                                                     m_libspdm_use_asym_algo, &data1,
     245              :                                                     &data_size1, NULL, NULL);
     246            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
     247            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
     248              :         data_size1;
     249            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
     250            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
     251              :         data_size1;
     252              : 
     253            1 :     libspdm_reset_message_a(spdm_context);
     254              : 
     255            1 :     m_libspdm_psk_exchange_request2.psk_hint_length =
     256              :         (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
     257            1 :     m_libspdm_psk_exchange_request2.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
     258            1 :     opaque_psk_exchange_req_size =
     259            1 :         libspdm_get_opaque_data_supported_version_data_size(spdm_context);
     260            1 :     m_libspdm_psk_exchange_request2.opaque_length =
     261            1 :         (uint16_t)opaque_psk_exchange_req_size;
     262            1 :     m_libspdm_psk_exchange_request2.req_session_id = 0xFFFF;
     263            1 :     ptr = m_libspdm_psk_exchange_request2.psk_hint;
     264            1 :     libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request2.psk_hint),
     265              :                      LIBSPDM_TEST_PSK_HINT_STRING,
     266              :                      sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
     267            1 :     ptr += m_libspdm_psk_exchange_request2.psk_hint_length;
     268            1 :     libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
     269            1 :     ptr += m_libspdm_psk_exchange_request2.context_length;
     270            1 :     libspdm_build_opaque_data_supported_version_data(
     271              :         spdm_context, &opaque_psk_exchange_req_size, ptr);
     272            1 :     ptr += opaque_psk_exchange_req_size;
     273            1 :     response_size = sizeof(response);
     274            1 :     status = libspdm_get_response_psk_exchange(
     275              :         spdm_context, m_libspdm_psk_exchange_request2_size,
     276              :         &m_libspdm_psk_exchange_request2, &response_size, response);
     277            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     278            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     279            1 :     spdm_response = (void *)response;
     280            1 :     assert_int_equal(spdm_response->header.request_response_code,
     281              :                      SPDM_ERROR);
     282            1 :     assert_int_equal(spdm_response->header.param1,
     283              :                      SPDM_ERROR_CODE_INVALID_REQUEST);
     284            1 :     assert_int_equal(spdm_response->header.param2, 0);
     285            1 :     free(data1);
     286            1 : }
     287              : 
     288            1 : static void rsp_psk_exchange_rsp_case3(void **state)
     289              : {
     290              :     libspdm_return_t status;
     291              :     libspdm_test_context_t *spdm_test_context;
     292              :     libspdm_context_t *spdm_context;
     293              :     size_t response_size;
     294              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     295              :     spdm_psk_exchange_response_t *spdm_response;
     296              :     void *data1;
     297              :     size_t data_size1;
     298              :     uint8_t *ptr;
     299              :     size_t opaque_psk_exchange_req_size;
     300              : 
     301            1 :     spdm_test_context = *state;
     302            1 :     spdm_context = spdm_test_context->spdm_context;
     303            1 :     spdm_test_context->case_id = 0x3;
     304            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     305              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     306            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_BUSY;
     307            1 :     spdm_context->connection_info.connection_state =
     308              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     309            1 :     spdm_context->connection_info.capability.flags |=
     310              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
     311            1 :     spdm_context->local_context.capability.flags |=
     312              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
     313            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
     314              :         m_libspdm_use_hash_algo;
     315            1 :     spdm_context->connection_info.algorithm.measurement_spec =
     316              :         m_libspdm_use_measurement_spec;
     317            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     318              :         m_libspdm_use_measurement_hash_algo;
     319            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
     320              :         m_libspdm_use_dhe_algo;
     321            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
     322              :         m_libspdm_use_aead_algo;
     323            1 :     spdm_context->connection_info.algorithm.key_schedule =
     324              :         m_libspdm_use_key_schedule_algo;
     325            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     326              :                                                     m_libspdm_use_asym_algo, &data1,
     327              :                                                     &data_size1, NULL, NULL);
     328            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
     329            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
     330              :         data_size1;
     331            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
     332            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
     333              :         data_size1;
     334              : 
     335            1 :     libspdm_reset_message_a(spdm_context);
     336              : 
     337            1 :     m_libspdm_psk_exchange_request1.psk_hint_length =
     338              :         (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
     339            1 :     m_libspdm_psk_exchange_request1.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
     340            1 :     opaque_psk_exchange_req_size =
     341            1 :         libspdm_get_opaque_data_supported_version_data_size(spdm_context);
     342            1 :     m_libspdm_psk_exchange_request1.opaque_length =
     343            1 :         (uint16_t)opaque_psk_exchange_req_size;
     344            1 :     m_libspdm_psk_exchange_request1.req_session_id = 0xFFFF;
     345            1 :     ptr = m_libspdm_psk_exchange_request1.psk_hint;
     346            1 :     libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request1.psk_hint),
     347              :                      LIBSPDM_TEST_PSK_HINT_STRING,
     348              :                      sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
     349            1 :     ptr += m_libspdm_psk_exchange_request1.psk_hint_length;
     350            1 :     libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
     351            1 :     ptr += m_libspdm_psk_exchange_request1.context_length;
     352            1 :     libspdm_build_opaque_data_supported_version_data(
     353              :         spdm_context, &opaque_psk_exchange_req_size, ptr);
     354            1 :     ptr += opaque_psk_exchange_req_size;
     355            1 :     response_size = sizeof(response);
     356            1 :     status = libspdm_get_response_psk_exchange(
     357              :         spdm_context, m_libspdm_psk_exchange_request1_size,
     358              :         &m_libspdm_psk_exchange_request1, &response_size, response);
     359            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     360            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     361            1 :     spdm_response = (void *)response;
     362            1 :     assert_int_equal(spdm_response->header.request_response_code,
     363              :                      SPDM_ERROR);
     364            1 :     assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_BUSY);
     365            1 :     assert_int_equal(spdm_response->header.param2, 0);
     366            1 :     assert_int_equal(spdm_context->response_state,
     367              :                      LIBSPDM_RESPONSE_STATE_BUSY);
     368            1 :     free(data1);
     369            1 : }
     370              : 
     371            1 : static void rsp_psk_exchange_rsp_case4(void **state)
     372              : {
     373              :     libspdm_return_t status;
     374              :     libspdm_test_context_t *spdm_test_context;
     375              :     libspdm_context_t *spdm_context;
     376              :     size_t response_size;
     377              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     378              :     spdm_psk_exchange_response_t *spdm_response;
     379              :     void *data1;
     380              :     size_t data_size1;
     381              :     uint8_t *ptr;
     382              :     size_t opaque_psk_exchange_req_size;
     383              : 
     384            1 :     spdm_test_context = *state;
     385            1 :     spdm_context = spdm_test_context->spdm_context;
     386            1 :     spdm_test_context->case_id = 0x4;
     387            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     388              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     389            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NEED_RESYNC;
     390            1 :     spdm_context->connection_info.connection_state =
     391              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     392            1 :     spdm_context->connection_info.capability.flags |=
     393              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
     394            1 :     spdm_context->local_context.capability.flags |=
     395              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
     396            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
     397              :         m_libspdm_use_hash_algo;
     398            1 :     spdm_context->connection_info.algorithm.measurement_spec =
     399              :         m_libspdm_use_measurement_spec;
     400            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     401              :         m_libspdm_use_measurement_hash_algo;
     402            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
     403              :         m_libspdm_use_dhe_algo;
     404            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
     405              :         m_libspdm_use_aead_algo;
     406            1 :     spdm_context->connection_info.algorithm.key_schedule =
     407              :         m_libspdm_use_key_schedule_algo;
     408            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     409              :                                                     m_libspdm_use_asym_algo, &data1,
     410              :                                                     &data_size1, NULL, NULL);
     411            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
     412            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
     413              :         data_size1;
     414            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
     415            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
     416              :         data_size1;
     417              : 
     418            1 :     libspdm_reset_message_a(spdm_context);
     419              : 
     420            1 :     m_libspdm_psk_exchange_request1.psk_hint_length =
     421              :         (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
     422            1 :     m_libspdm_psk_exchange_request1.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
     423            1 :     opaque_psk_exchange_req_size =
     424            1 :         libspdm_get_opaque_data_supported_version_data_size(spdm_context);
     425            1 :     m_libspdm_psk_exchange_request1.opaque_length =
     426            1 :         (uint16_t)opaque_psk_exchange_req_size;
     427            1 :     m_libspdm_psk_exchange_request1.req_session_id = 0xFFFF;
     428            1 :     ptr = m_libspdm_psk_exchange_request1.psk_hint;
     429            1 :     libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request1.psk_hint),
     430              :                      LIBSPDM_TEST_PSK_HINT_STRING,
     431              :                      sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
     432            1 :     ptr += m_libspdm_psk_exchange_request1.psk_hint_length;
     433            1 :     libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
     434            1 :     ptr += m_libspdm_psk_exchange_request1.context_length;
     435            1 :     libspdm_build_opaque_data_supported_version_data(
     436              :         spdm_context, &opaque_psk_exchange_req_size, ptr);
     437            1 :     ptr += opaque_psk_exchange_req_size;
     438            1 :     response_size = sizeof(response);
     439            1 :     status = libspdm_get_response_psk_exchange(
     440              :         spdm_context, m_libspdm_psk_exchange_request1_size,
     441              :         &m_libspdm_psk_exchange_request1, &response_size, response);
     442            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     443            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     444            1 :     spdm_response = (void *)response;
     445            1 :     assert_int_equal(spdm_response->header.request_response_code,
     446              :                      SPDM_ERROR);
     447            1 :     assert_int_equal(spdm_response->header.param1,
     448              :                      SPDM_ERROR_CODE_REQUEST_RESYNCH);
     449            1 :     assert_int_equal(spdm_response->header.param2, 0);
     450            1 :     assert_int_equal(spdm_context->response_state,
     451              :                      LIBSPDM_RESPONSE_STATE_NEED_RESYNC);
     452            1 :     free(data1);
     453            1 : }
     454              : 
     455              : #if LIBSPDM_RESPOND_IF_READY_SUPPORT
     456            1 : static void rsp_psk_exchange_rsp_case5(void **state)
     457              : {
     458              :     libspdm_return_t status;
     459              :     libspdm_test_context_t *spdm_test_context;
     460              :     libspdm_context_t *spdm_context;
     461              :     size_t response_size;
     462              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     463              :     spdm_psk_exchange_response_t *spdm_response;
     464              :     void *data1;
     465              :     size_t data_size1;
     466              :     uint8_t *ptr;
     467              :     size_t opaque_psk_exchange_req_size;
     468              :     spdm_error_data_response_not_ready_t *error_data;
     469              : 
     470            1 :     spdm_test_context = *state;
     471            1 :     spdm_context = spdm_test_context->spdm_context;
     472            1 :     spdm_test_context->case_id = 0x5;
     473            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     474              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     475            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NOT_READY;
     476            1 :     spdm_context->connection_info.connection_state =
     477              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     478            1 :     spdm_context->connection_info.capability.flags |=
     479              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
     480            1 :     spdm_context->local_context.capability.flags |=
     481              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
     482            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
     483              :         m_libspdm_use_hash_algo;
     484            1 :     spdm_context->connection_info.algorithm.measurement_spec =
     485              :         m_libspdm_use_measurement_spec;
     486            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     487              :         m_libspdm_use_measurement_hash_algo;
     488            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
     489              :         m_libspdm_use_dhe_algo;
     490            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
     491              :         m_libspdm_use_aead_algo;
     492            1 :     spdm_context->connection_info.algorithm.key_schedule =
     493              :         m_libspdm_use_key_schedule_algo;
     494            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     495              :                                                     m_libspdm_use_asym_algo, &data1,
     496              :                                                     &data_size1, NULL, NULL);
     497            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
     498            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
     499              :         data_size1;
     500            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
     501            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
     502              :         data_size1;
     503              : 
     504            1 :     libspdm_reset_message_a(spdm_context);
     505              : 
     506            1 :     m_libspdm_psk_exchange_request1.psk_hint_length =
     507              :         (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
     508            1 :     m_libspdm_psk_exchange_request1.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
     509            1 :     opaque_psk_exchange_req_size =
     510            1 :         libspdm_get_opaque_data_supported_version_data_size(spdm_context);
     511            1 :     m_libspdm_psk_exchange_request1.opaque_length =
     512            1 :         (uint16_t)opaque_psk_exchange_req_size;
     513            1 :     m_libspdm_psk_exchange_request1.req_session_id = 0xFFFF;
     514            1 :     ptr = m_libspdm_psk_exchange_request1.psk_hint;
     515            1 :     libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request1.psk_hint),
     516              :                      LIBSPDM_TEST_PSK_HINT_STRING,
     517              :                      sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
     518            1 :     ptr += m_libspdm_psk_exchange_request1.psk_hint_length;
     519            1 :     libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
     520            1 :     ptr += m_libspdm_psk_exchange_request1.context_length;
     521            1 :     libspdm_build_opaque_data_supported_version_data(
     522              :         spdm_context, &opaque_psk_exchange_req_size, ptr);
     523            1 :     ptr += opaque_psk_exchange_req_size;
     524            1 :     response_size = sizeof(response);
     525            1 :     status = libspdm_get_response_psk_exchange(
     526              :         spdm_context, m_libspdm_psk_exchange_request1_size,
     527              :         &m_libspdm_psk_exchange_request1, &response_size, response);
     528            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     529            1 :     assert_int_equal(response_size,
     530              :                      sizeof(spdm_error_response_t) +
     531              :                      sizeof(spdm_error_data_response_not_ready_t));
     532            1 :     spdm_response = (void *)response;
     533            1 :     error_data = (spdm_error_data_response_not_ready_t
     534              :                   *)(&spdm_response->rsp_session_id);
     535            1 :     assert_int_equal(spdm_response->header.request_response_code,
     536              :                      SPDM_ERROR);
     537            1 :     assert_int_equal(spdm_response->header.param1,
     538              :                      SPDM_ERROR_CODE_RESPONSE_NOT_READY);
     539            1 :     assert_int_equal(spdm_response->header.param2, 0);
     540            1 :     assert_int_equal(spdm_context->response_state,
     541              :                      LIBSPDM_RESPONSE_STATE_NOT_READY);
     542            1 :     assert_int_equal(error_data->request_code, SPDM_PSK_EXCHANGE);
     543            1 :     free(data1);
     544            1 : }
     545              : #endif /* LIBSPDM_RESPOND_IF_READY_SUPPORT */
     546              : 
     547            1 : static void rsp_psk_exchange_rsp_case6(void **state)
     548              : {
     549              :     libspdm_return_t status;
     550              :     libspdm_test_context_t *spdm_test_context;
     551              :     libspdm_context_t *spdm_context;
     552              :     size_t response_size;
     553              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     554              :     spdm_psk_exchange_response_t *spdm_response;
     555              :     void *data1;
     556              :     size_t data_size1;
     557              :     uint8_t *ptr;
     558              :     size_t opaque_psk_exchange_req_size;
     559              : 
     560            1 :     spdm_test_context = *state;
     561            1 :     spdm_context = spdm_test_context->spdm_context;
     562            1 :     spdm_test_context->case_id = 0x6;
     563            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     564              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     565            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
     566            1 :     spdm_context->connection_info.connection_state =
     567              :         LIBSPDM_CONNECTION_STATE_NOT_STARTED;
     568            1 :     spdm_context->connection_info.capability.flags |=
     569              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
     570            1 :     spdm_context->local_context.capability.flags |=
     571              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
     572            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
     573              :         m_libspdm_use_hash_algo;
     574            1 :     spdm_context->connection_info.algorithm.measurement_spec =
     575              :         m_libspdm_use_measurement_spec;
     576            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     577              :         m_libspdm_use_measurement_hash_algo;
     578            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
     579              :         m_libspdm_use_dhe_algo;
     580            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
     581              :         m_libspdm_use_aead_algo;
     582            1 :     spdm_context->connection_info.algorithm.key_schedule =
     583              :         m_libspdm_use_key_schedule_algo;
     584            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     585              :                                                     m_libspdm_use_asym_algo, &data1,
     586              :                                                     &data_size1, NULL, NULL);
     587            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
     588            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
     589              :         data_size1;
     590            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
     591            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
     592              :         data_size1;
     593              : 
     594            1 :     libspdm_reset_message_a(spdm_context);
     595              : 
     596            1 :     m_libspdm_psk_exchange_request1.psk_hint_length =
     597              :         (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
     598            1 :     m_libspdm_psk_exchange_request1.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
     599            1 :     opaque_psk_exchange_req_size =
     600            1 :         libspdm_get_opaque_data_supported_version_data_size(spdm_context);
     601            1 :     m_libspdm_psk_exchange_request1.opaque_length =
     602            1 :         (uint16_t)opaque_psk_exchange_req_size;
     603            1 :     m_libspdm_psk_exchange_request1.req_session_id = 0xFFFF;
     604            1 :     ptr = m_libspdm_psk_exchange_request1.psk_hint;
     605            1 :     libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request1.psk_hint),
     606              :                      LIBSPDM_TEST_PSK_HINT_STRING,
     607              :                      sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
     608            1 :     ptr += m_libspdm_psk_exchange_request1.psk_hint_length;
     609            1 :     libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
     610            1 :     ptr += m_libspdm_psk_exchange_request1.context_length;
     611            1 :     libspdm_build_opaque_data_supported_version_data(
     612              :         spdm_context, &opaque_psk_exchange_req_size, ptr);
     613            1 :     ptr += opaque_psk_exchange_req_size;
     614            1 :     response_size = sizeof(response);
     615            1 :     status = libspdm_get_response_psk_exchange(
     616              :         spdm_context, m_libspdm_psk_exchange_request1_size,
     617              :         &m_libspdm_psk_exchange_request1, &response_size, response);
     618            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     619            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     620            1 :     spdm_response = (void *)response;
     621            1 :     assert_int_equal(spdm_response->header.request_response_code,
     622              :                      SPDM_ERROR);
     623            1 :     assert_int_equal(spdm_response->header.param1,
     624              :                      SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
     625            1 :     assert_int_equal(spdm_response->header.param2, 0);
     626            1 :     free(data1);
     627            1 : }
     628              : 
     629            1 : static void rsp_psk_exchange_rsp_case7(void **state)
     630              : {
     631              :     libspdm_return_t status;
     632              :     libspdm_test_context_t *spdm_test_context;
     633              :     libspdm_context_t *spdm_context;
     634              :     size_t response_size;
     635              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     636              :     spdm_psk_exchange_response_t *spdm_response;
     637              :     void *data1;
     638              :     size_t data_size1;
     639              :     uint8_t *ptr;
     640              :     size_t opaque_psk_exchange_req_size;
     641              : 
     642            1 :     spdm_test_context = *state;
     643            1 :     spdm_context = spdm_test_context->spdm_context;
     644            1 :     spdm_test_context->case_id = 0x7;
     645            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     646              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     647            1 :     spdm_context->connection_info.connection_state =
     648              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     649            1 :     spdm_context->connection_info.capability.flags |=
     650              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
     651            1 :     spdm_context->local_context.capability.flags |=
     652              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
     653            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
     654              :         m_libspdm_use_hash_algo;
     655            1 :     spdm_context->connection_info.algorithm.measurement_spec =
     656              :         m_libspdm_use_measurement_spec;
     657            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     658              :         m_libspdm_use_measurement_hash_algo;
     659            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
     660              :         m_libspdm_use_dhe_algo;
     661            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
     662              :         m_libspdm_use_aead_algo;
     663            1 :     spdm_context->connection_info.algorithm.key_schedule =
     664              :         m_libspdm_use_key_schedule_algo;
     665            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     666              :                                                     m_libspdm_use_asym_algo, &data1,
     667              :                                                     &data_size1, NULL, NULL);
     668            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
     669            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
     670              :         data_size1;
     671            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
     672            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
     673              :         data_size1;
     674              : 
     675            1 :     libspdm_reset_message_a(spdm_context);
     676              : 
     677            1 :     m_libspdm_psk_exchange_request1.psk_hint_length =
     678              :         (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
     679            1 :     m_libspdm_psk_exchange_request1.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
     680            1 :     opaque_psk_exchange_req_size =
     681            1 :         libspdm_get_opaque_data_supported_version_data_size(spdm_context);
     682            1 :     m_libspdm_psk_exchange_request1.opaque_length =
     683            1 :         (uint16_t)opaque_psk_exchange_req_size;
     684            1 :     m_libspdm_psk_exchange_request1.req_session_id = 0xFFFF;
     685            1 :     ptr = m_libspdm_psk_exchange_request1.psk_hint;
     686            1 :     libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request1.psk_hint),
     687              :                      LIBSPDM_TEST_PSK_HINT_STRING,
     688              :                      sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
     689            1 :     ptr += m_libspdm_psk_exchange_request1.psk_hint_length;
     690            1 :     libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
     691            1 :     ptr += m_libspdm_psk_exchange_request1.context_length;
     692            1 :     libspdm_build_opaque_data_supported_version_data(
     693              :         spdm_context, &opaque_psk_exchange_req_size, ptr);
     694            1 :     ptr += opaque_psk_exchange_req_size;
     695              : 
     696              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     697              :     spdm_context->transcript.message_m.buffer_size =
     698              :         spdm_context->transcript.message_m.max_buffer_size;
     699              :     spdm_context->transcript.message_b.buffer_size =
     700              :         spdm_context->transcript.message_b.max_buffer_size;
     701              :     spdm_context->transcript.message_c.buffer_size =
     702              :         spdm_context->transcript.message_c.max_buffer_size;
     703              :     spdm_context->transcript.message_mut_b.buffer_size =
     704              :         spdm_context->transcript.message_mut_b.max_buffer_size;
     705              :     spdm_context->transcript.message_mut_c.buffer_size =
     706              :         spdm_context->transcript.message_mut_c.max_buffer_size;
     707              : #endif
     708              : 
     709            1 :     response_size = sizeof(response);
     710            1 :     status = libspdm_get_response_psk_exchange(
     711              :         spdm_context, m_libspdm_psk_exchange_request1_size,
     712              :         &m_libspdm_psk_exchange_request1, &response_size, response);
     713            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     714            1 :     assert_int_equal(
     715              :         libspdm_secured_message_get_session_state(
     716              :             spdm_context->session_info[0].secured_message_context),
     717              :         LIBSPDM_SESSION_STATE_HANDSHAKING);
     718            1 :     spdm_response = (void *)response;
     719            1 :     assert_int_equal(spdm_response->header.request_response_code,
     720              :                      SPDM_PSK_EXCHANGE_RSP);
     721              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     722              :     assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
     723              :     assert_int_equal(spdm_context->transcript.message_b.buffer_size, 0);
     724              :     assert_int_equal(spdm_context->transcript.message_c.buffer_size, 0);
     725              :     assert_int_equal(spdm_context->transcript.message_mut_b.buffer_size, 0);
     726              :     assert_int_equal(spdm_context->transcript.message_mut_c.buffer_size, 0);
     727              : #endif
     728              : 
     729            1 :     free(data1);
     730            1 : }
     731              : 
     732            1 : static void rsp_psk_exchange_rsp_case8(void **state)
     733              : {
     734              :     libspdm_return_t status;
     735              :     libspdm_test_context_t *spdm_test_context;
     736              :     libspdm_context_t *spdm_context;
     737              :     size_t current_request_size;
     738              :     size_t response_size;
     739              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     740              :     spdm_psk_exchange_response_t *spdm_response;
     741              :     void *data1;
     742              :     size_t data_size1;
     743              :     uint8_t *ptr;
     744              :     size_t opaque_psk_exchange_req_size;
     745              : 
     746            1 :     spdm_test_context = *state;
     747            1 :     spdm_context = spdm_test_context->spdm_context;
     748              : 
     749            1 :     if(spdm_context->session_info[0].session_id != INVALID_SESSION_ID) {
     750            1 :         libspdm_free_session_id(spdm_context,0xFFFFFFFF);
     751              :     }
     752              : 
     753            1 :     spdm_test_context->case_id = 0x8;
     754            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     755              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     756            1 :     spdm_context->connection_info.connection_state =
     757              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     758            1 :     spdm_context->connection_info.capability.flags |=
     759              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
     760            1 :     spdm_context->local_context.capability.flags |=
     761              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
     762            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     763            1 :     spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
     764            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     765              :         m_libspdm_use_measurement_hash_algo;
     766            1 :     spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
     767            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
     768            1 :     spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
     769            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     770              :                                                     m_libspdm_use_asym_algo, &data1,
     771              :                                                     &data_size1, NULL, NULL);
     772            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
     773            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
     774            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
     775            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size = data_size1;
     776              : 
     777            1 :     libspdm_reset_message_a(spdm_context);
     778              : 
     779            1 :     m_libspdm_psk_exchange_request1.psk_hint_length =
     780              :         (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
     781            1 :     m_libspdm_psk_exchange_request1.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
     782            1 :     opaque_psk_exchange_req_size =
     783            1 :         libspdm_get_opaque_data_supported_version_data_size(spdm_context);
     784            1 :     m_libspdm_psk_exchange_request1.opaque_length =
     785            1 :         (uint16_t)opaque_psk_exchange_req_size;
     786            1 :     m_libspdm_psk_exchange_request1.req_session_id = 0xFFFF;
     787            1 :     ptr = m_libspdm_psk_exchange_request1.psk_hint;
     788            1 :     libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request1.psk_hint),
     789              :                      LIBSPDM_TEST_PSK_HINT_STRING,
     790              :                      sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
     791            1 :     ptr += m_libspdm_psk_exchange_request1.psk_hint_length;
     792            1 :     libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
     793            1 :     ptr += m_libspdm_psk_exchange_request1.context_length;
     794            1 :     libspdm_build_opaque_data_supported_version_data(
     795              :         spdm_context, &opaque_psk_exchange_req_size, ptr);
     796            1 :     ptr += opaque_psk_exchange_req_size;
     797              : 
     798            1 :     current_request_size = sizeof(spdm_psk_exchange_request_t) +
     799            1 :                            m_libspdm_psk_exchange_request1.psk_hint_length +
     800            1 :                            m_libspdm_psk_exchange_request1.context_length +
     801              :                            opaque_psk_exchange_req_size;
     802            1 :     response_size = sizeof(response);
     803            1 :     status = libspdm_get_response_psk_exchange(
     804              :         spdm_context, current_request_size, &m_libspdm_psk_exchange_request1,
     805              :         &response_size, response);
     806            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     807            1 :     assert_int_equal(libspdm_secured_message_get_session_state(
     808              :                          spdm_context->session_info[0].secured_message_context),
     809              :                      LIBSPDM_SESSION_STATE_HANDSHAKING);
     810            1 :     spdm_response = (void *)response;
     811            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_PSK_EXCHANGE_RSP);
     812            1 :     assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
     813              : 
     814              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     815              :     assert_int_equal(spdm_context->session_info[0].session_transcript.message_k.buffer_size,
     816              :                      current_request_size + response_size);
     817              :     assert_memory_equal(spdm_context->session_info[0].session_transcript.message_k.buffer,
     818              :                         &m_libspdm_psk_exchange_request1, current_request_size);
     819              :     assert_memory_equal(spdm_context->session_info[0].session_transcript.message_k.buffer +
     820              :                         current_request_size, response, response_size);
     821              : #endif
     822            1 :     free(data1);
     823            1 : }
     824              : 
     825            1 : static void rsp_psk_exchange_rsp_case9(void **state)
     826              : {
     827              :     libspdm_return_t status;
     828              :     libspdm_test_context_t *spdm_test_context;
     829              :     libspdm_context_t *spdm_context;
     830              :     size_t response_size;
     831              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     832              :     spdm_psk_exchange_response_t *spdm_response;
     833              :     void *data1;
     834              :     size_t data_size1;
     835              :     uint8_t *ptr;
     836              :     size_t opaque_psk_exchange_req_size;
     837              : 
     838            1 :     spdm_test_context = *state;
     839            1 :     spdm_context = spdm_test_context->spdm_context;
     840            1 :     spdm_test_context->case_id = 0x9;
     841            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
     842              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     843            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     844            1 :     spdm_context->connection_info.capability.flags |=
     845              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
     846            1 :     spdm_context->local_context.capability.flags |=
     847              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
     848            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     849            1 :     spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
     850            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     851              :         m_libspdm_use_measurement_hash_algo;
     852            1 :     spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
     853            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
     854            1 :     spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
     855            1 :     spdm_context->connection_info.algorithm.other_params_support =
     856              :         SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
     857            1 :     libspdm_session_info_init(spdm_context,
     858            1 :                               spdm_context->session_info,
     859              :                               0,
     860              :                               INVALID_SESSION_ID, true);
     861            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     862              :                                                     m_libspdm_use_asym_algo, &data1,
     863              :                                                     &data_size1, NULL, NULL);
     864            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
     865            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
     866            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
     867            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size = data_size1;
     868              : 
     869            1 :     libspdm_reset_message_a(spdm_context);
     870              : 
     871            1 :     m_libspdm_psk_exchange_request3.psk_hint_length =
     872              :         (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
     873            1 :     m_libspdm_psk_exchange_request3.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
     874            1 :     opaque_psk_exchange_req_size =
     875            1 :         libspdm_get_opaque_data_supported_version_data_size(spdm_context);
     876            1 :     m_libspdm_psk_exchange_request3.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
     877            1 :     m_libspdm_psk_exchange_request3.req_session_id = 0xFFFF;
     878            1 :     ptr = m_libspdm_psk_exchange_request3.psk_hint;
     879            1 :     libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request3.psk_hint),
     880              :                      LIBSPDM_TEST_PSK_HINT_STRING,
     881              :                      sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
     882            1 :     ptr += m_libspdm_psk_exchange_request3.psk_hint_length;
     883            1 :     libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
     884            1 :     ptr += m_libspdm_psk_exchange_request3.context_length;
     885            1 :     libspdm_build_opaque_data_supported_version_data(
     886              :         spdm_context, &opaque_psk_exchange_req_size, ptr);
     887              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     888              :     spdm_context->transcript.message_m.buffer_size =
     889              :         spdm_context->transcript.message_m.max_buffer_size;
     890              : #endif
     891            1 :     ptr += opaque_psk_exchange_req_size;
     892            1 :     response_size = sizeof(response);
     893            1 :     status = libspdm_get_response_psk_exchange(
     894              :         spdm_context, m_libspdm_psk_exchange_request3_size,
     895              :         &m_libspdm_psk_exchange_request3, &response_size, response);
     896            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     897            1 :     assert_int_equal(
     898              :         libspdm_secured_message_get_session_state(
     899              :             spdm_context->session_info[0].secured_message_context),
     900              :         LIBSPDM_SESSION_STATE_HANDSHAKING);
     901            1 :     assert_int_equal(spdm_context->session_info[0].session_policy, 0);
     902            1 :     spdm_response = (void *)response;
     903            1 :     assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
     904            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_PSK_EXCHANGE_RSP);
     905            1 :     assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
     906              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     907              :     assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
     908              : #endif
     909            1 :     free(data1);
     910            1 : }
     911              : 
     912            1 : static void rsp_psk_exchange_rsp_case10(void **state)
     913              : {
     914              :     libspdm_return_t status;
     915              :     libspdm_test_context_t *spdm_test_context;
     916              :     libspdm_context_t *spdm_context;
     917              :     size_t response_size;
     918              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     919              :     #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
     920              :     uint8_t measurement_hash[LIBSPDM_MAX_HASH_SIZE];
     921              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP */
     922              :     uint32_t measurement_summary_hash_size;
     923              :     spdm_psk_exchange_response_t *spdm_response;
     924              :     void *data1;
     925              :     size_t data_size1;
     926              :     uint8_t *ptr;
     927              :     size_t opaque_psk_exchange_req_size;
     928              :     bool result;
     929              : 
     930            1 :     spdm_test_context = *state;
     931            1 :     spdm_context = spdm_test_context->spdm_context;
     932            1 :     spdm_test_context->case_id = 0xA;
     933              : 
     934              :     /* Clear previous sessions */
     935            1 :     if(spdm_context->session_info[0].session_id != INVALID_SESSION_ID) {
     936            1 :         libspdm_free_session_id(spdm_context,0xFFFFFFFF);
     937              :     }
     938              : 
     939            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     940              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     941            1 :     spdm_context->connection_info.connection_state =
     942              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     943            1 :     spdm_context->connection_info.capability.flags |=
     944              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
     945            1 :     spdm_context->local_context.capability.flags |=
     946              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
     947            1 :     spdm_context->local_context.capability.flags |=
     948              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP;
     949            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
     950              :         m_libspdm_use_hash_algo;
     951            1 :     spdm_context->connection_info.algorithm.measurement_spec =
     952              :         m_libspdm_use_measurement_spec;
     953            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     954              :         m_libspdm_use_measurement_hash_algo;
     955            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
     956              :         m_libspdm_use_dhe_algo;
     957            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
     958              :         m_libspdm_use_aead_algo;
     959            1 :     spdm_context->connection_info.algorithm.key_schedule =
     960              :         m_libspdm_use_key_schedule_algo;
     961            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     962              :                                                     m_libspdm_use_asym_algo, &data1,
     963              :                                                     &data_size1, NULL, NULL);
     964            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
     965            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
     966              :         data_size1;
     967            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
     968            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
     969              :         data_size1;
     970              : 
     971            1 :     libspdm_reset_message_a(spdm_context);
     972              : 
     973            1 :     m_libspdm_psk_exchange_request4.psk_hint_length =
     974              :         (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
     975            1 :     m_libspdm_psk_exchange_request4.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
     976            1 :     opaque_psk_exchange_req_size =
     977            1 :         libspdm_get_opaque_data_supported_version_data_size(spdm_context);
     978            1 :     m_libspdm_psk_exchange_request4.opaque_length =
     979            1 :         (uint16_t)opaque_psk_exchange_req_size;
     980            1 :     m_libspdm_psk_exchange_request4.req_session_id = 0xFFFF;
     981            1 :     ptr = m_libspdm_psk_exchange_request4.psk_hint;
     982            1 :     libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request4.psk_hint),
     983              :                      LIBSPDM_TEST_PSK_HINT_STRING,
     984              :                      sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
     985            1 :     ptr += m_libspdm_psk_exchange_request4.psk_hint_length;
     986            1 :     libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
     987            1 :     ptr += m_libspdm_psk_exchange_request4.context_length;
     988            1 :     libspdm_build_opaque_data_supported_version_data(
     989              :         spdm_context, &opaque_psk_exchange_req_size, ptr);
     990              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     991              :     spdm_context->transcript.message_m.buffer_size =
     992              :         spdm_context->transcript.message_m.max_buffer_size;
     993              : #endif
     994            1 :     ptr += opaque_psk_exchange_req_size;
     995            1 :     response_size = sizeof(response);
     996            1 :     status = libspdm_get_response_psk_exchange(
     997              :         spdm_context, m_libspdm_psk_exchange_request4_size,
     998              :         &m_libspdm_psk_exchange_request4, &response_size, response);
     999            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1000            1 :     assert_int_equal(
    1001              :         libspdm_secured_message_get_session_state(
    1002              :             spdm_context->session_info[0].secured_message_context),
    1003              :         LIBSPDM_SESSION_STATE_HANDSHAKING);
    1004            1 :     spdm_response = (void *)response;
    1005            1 :     assert_int_equal(spdm_response->header.request_response_code,
    1006              :                      SPDM_PSK_EXCHANGE_RSP);
    1007            1 :     assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
    1008              : 
    1009            1 :     measurement_summary_hash_size = libspdm_get_measurement_summary_hash_size(
    1010            1 :         spdm_context, false, m_libspdm_psk_exchange_request4.header.param1);
    1011              : 
    1012              : #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
    1013            1 :     result = libspdm_generate_measurement_summary_hash(
    1014              :         spdm_context,
    1015            1 :         spdm_context->connection_info.version,
    1016              :         spdm_context->connection_info.algorithm.base_hash_algo,
    1017            1 :         spdm_context->connection_info.algorithm.measurement_spec,
    1018              :         spdm_context->connection_info.algorithm.measurement_hash_algo,
    1019            1 :         m_libspdm_psk_exchange_request4.header.param1,
    1020              :         measurement_hash,
    1021              :         measurement_summary_hash_size);
    1022              : 
    1023            1 :     assert_true(result);
    1024              : 
    1025            1 :     assert_memory_equal((uint8_t *)response + sizeof(spdm_psk_exchange_response_t),
    1026              :                         measurement_hash, measurement_summary_hash_size);
    1027              : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP */
    1028              : 
    1029              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
    1030              :     assert_int_equal(spdm_context->transcript.message_m.buffer_size,
    1031              :                      0);
    1032              : #endif
    1033            1 :     free(data1);
    1034            1 : }
    1035              : 
    1036            1 : static void rsp_psk_exchange_rsp_case11(void **state)
    1037              : {
    1038              :     libspdm_return_t status;
    1039              :     libspdm_test_context_t *spdm_test_context;
    1040              :     libspdm_context_t *spdm_context;
    1041              :     size_t response_size;
    1042              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1043              :     #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
    1044              :     uint8_t measurement_hash[LIBSPDM_MAX_HASH_SIZE];
    1045              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP */
    1046              :     uint32_t measurement_summary_hash_size;
    1047              :     spdm_psk_exchange_response_t *spdm_response;
    1048              :     void *data1;
    1049              :     size_t data_size1;
    1050              :     uint8_t *ptr;
    1051              :     size_t opaque_psk_exchange_req_size;
    1052              :     bool result;
    1053              : 
    1054            1 :     spdm_test_context = *state;
    1055            1 :     spdm_context = spdm_test_context->spdm_context;
    1056            1 :     spdm_test_context->case_id = 0xB;
    1057              : 
    1058              :     /* Clear previous sessions */
    1059            1 :     if(spdm_context->session_info[0].session_id != INVALID_SESSION_ID) {
    1060            1 :         libspdm_free_session_id(spdm_context,0xFFFFFFFF);
    1061              :     }
    1062              : 
    1063            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1064              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1065            1 :     spdm_context->connection_info.connection_state =
    1066              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
    1067            1 :     spdm_context->connection_info.capability.flags |=
    1068              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1069            1 :     spdm_context->local_context.capability.flags |=
    1070              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1071            1 :     spdm_context->local_context.capability.flags |=
    1072              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP;
    1073            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
    1074              :         m_libspdm_use_hash_algo;
    1075            1 :     spdm_context->connection_info.algorithm.measurement_spec =
    1076              :         m_libspdm_use_measurement_spec;
    1077            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
    1078              :         m_libspdm_use_measurement_hash_algo;
    1079            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
    1080              :         m_libspdm_use_dhe_algo;
    1081            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
    1082              :         m_libspdm_use_aead_algo;
    1083            1 :     spdm_context->connection_info.algorithm.key_schedule =
    1084              :         m_libspdm_use_key_schedule_algo;
    1085            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
    1086              :                                                     m_libspdm_use_asym_algo, &data1,
    1087              :                                                     &data_size1, NULL, NULL);
    1088            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
    1089            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
    1090              :         data_size1;
    1091            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
    1092            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
    1093              :         data_size1;
    1094              : 
    1095            1 :     libspdm_reset_message_a(spdm_context);
    1096              : 
    1097            1 :     m_libspdm_psk_exchange_request5.psk_hint_length =
    1098              :         (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
    1099            1 :     m_libspdm_psk_exchange_request5.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
    1100            1 :     opaque_psk_exchange_req_size =
    1101            1 :         libspdm_get_opaque_data_supported_version_data_size(spdm_context);
    1102            1 :     m_libspdm_psk_exchange_request5.opaque_length =
    1103            1 :         (uint16_t)opaque_psk_exchange_req_size;
    1104            1 :     m_libspdm_psk_exchange_request5.req_session_id = 0xFFFF;
    1105            1 :     ptr = m_libspdm_psk_exchange_request5.psk_hint;
    1106            1 :     libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request5.psk_hint),
    1107              :                      LIBSPDM_TEST_PSK_HINT_STRING,
    1108              :                      sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
    1109            1 :     ptr += m_libspdm_psk_exchange_request5.psk_hint_length;
    1110            1 :     libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
    1111            1 :     ptr += m_libspdm_psk_exchange_request5.context_length;
    1112            1 :     libspdm_build_opaque_data_supported_version_data(
    1113              :         spdm_context, &opaque_psk_exchange_req_size, ptr);
    1114              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
    1115              :     spdm_context->transcript.message_m.buffer_size =
    1116              :         spdm_context->transcript.message_m.max_buffer_size;
    1117              : #endif
    1118            1 :     ptr += opaque_psk_exchange_req_size;
    1119            1 :     response_size = sizeof(response);
    1120            1 :     status = libspdm_get_response_psk_exchange(
    1121              :         spdm_context, m_libspdm_psk_exchange_request5_size,
    1122              :         &m_libspdm_psk_exchange_request5, &response_size, response);
    1123            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1124            1 :     assert_int_equal(
    1125              :         libspdm_secured_message_get_session_state(
    1126              :             spdm_context->session_info[0].secured_message_context),
    1127              :         LIBSPDM_SESSION_STATE_HANDSHAKING);
    1128            1 :     spdm_response = (void *)response;
    1129            1 :     assert_int_equal(spdm_response->header.request_response_code,
    1130              :                      SPDM_PSK_EXCHANGE_RSP);
    1131            1 :     assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
    1132              : 
    1133            1 :     measurement_summary_hash_size = libspdm_get_measurement_summary_hash_size(
    1134            1 :         spdm_context, false, m_libspdm_psk_exchange_request5.header.param1);
    1135              : 
    1136              : #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
    1137            1 :     result = libspdm_generate_measurement_summary_hash(
    1138              :         spdm_context,
    1139            1 :         spdm_context->connection_info.version,
    1140              :         spdm_context->connection_info.algorithm.base_hash_algo,
    1141            1 :         spdm_context->connection_info.algorithm.measurement_spec,
    1142              :         spdm_context->connection_info.algorithm.measurement_hash_algo,
    1143            1 :         m_libspdm_psk_exchange_request5.header.param1,
    1144              :         measurement_hash,
    1145              :         measurement_summary_hash_size);
    1146              : 
    1147            1 :     assert_true(result);
    1148              : 
    1149            1 :     assert_memory_equal((uint8_t *)response + sizeof(spdm_psk_exchange_response_t),
    1150              :                         measurement_hash, measurement_summary_hash_size);
    1151              : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP */
    1152              : 
    1153              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
    1154              :     assert_int_equal(spdm_context->transcript.message_m.buffer_size,
    1155              :                      0);
    1156              : #endif
    1157            1 :     free(data1);
    1158            1 : }
    1159              : 
    1160            1 : static void rsp_psk_exchange_rsp_case12(void **state)
    1161              : {
    1162              :     libspdm_return_t status;
    1163              :     libspdm_test_context_t *spdm_test_context;
    1164              :     libspdm_context_t *spdm_context;
    1165              :     size_t response_size;
    1166              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1167              :     spdm_psk_exchange_response_t *spdm_response;
    1168              :     void *data1;
    1169              :     size_t data_size1;
    1170              :     uint8_t *ptr;
    1171              :     size_t opaque_psk_exchange_req_size;
    1172              : 
    1173            1 :     spdm_test_context = *state;
    1174            1 :     spdm_context = spdm_test_context->spdm_context;
    1175            1 :     spdm_test_context->case_id = 0xC;
    1176              : 
    1177              :     /* Clear previous sessions */
    1178            1 :     if(spdm_context->session_info[0].session_id != INVALID_SESSION_ID) {
    1179            1 :         libspdm_free_session_id(spdm_context,0xFFFFFFFF);
    1180              :     }
    1181              : 
    1182            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1183              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1184            1 :     spdm_context->connection_info.connection_state =
    1185              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
    1186            1 :     spdm_context->connection_info.capability.flags |=
    1187              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1188            1 :     spdm_context->local_context.capability.flags |=
    1189              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1190            1 :     spdm_context->local_context.capability.flags |=
    1191              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP;
    1192            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
    1193              :         m_libspdm_use_hash_algo;
    1194            1 :     spdm_context->connection_info.algorithm.measurement_spec =
    1195              :         m_libspdm_use_measurement_spec;
    1196            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
    1197              :         m_libspdm_use_measurement_hash_algo;
    1198            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
    1199              :         m_libspdm_use_dhe_algo;
    1200            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
    1201              :         m_libspdm_use_aead_algo;
    1202            1 :     spdm_context->connection_info.algorithm.key_schedule =
    1203              :         m_libspdm_use_key_schedule_algo;
    1204            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
    1205              :                                                     m_libspdm_use_asym_algo, &data1,
    1206              :                                                     &data_size1, NULL, NULL);
    1207            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
    1208            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
    1209              :         data_size1;
    1210            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
    1211            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
    1212              :         data_size1;
    1213              : 
    1214            1 :     libspdm_reset_message_a(spdm_context);
    1215              : 
    1216            1 :     m_libspdm_psk_exchange_request6.psk_hint_length =
    1217              :         (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
    1218            1 :     m_libspdm_psk_exchange_request6.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
    1219            1 :     opaque_psk_exchange_req_size =
    1220            1 :         libspdm_get_opaque_data_supported_version_data_size(spdm_context);
    1221            1 :     m_libspdm_psk_exchange_request6.opaque_length =
    1222            1 :         (uint16_t)opaque_psk_exchange_req_size;
    1223            1 :     m_libspdm_psk_exchange_request6.req_session_id = 0xFFFF;
    1224            1 :     ptr = m_libspdm_psk_exchange_request6.psk_hint;
    1225            1 :     libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request6.psk_hint),
    1226              :                      LIBSPDM_TEST_PSK_HINT_STRING,
    1227              :                      sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
    1228            1 :     ptr += m_libspdm_psk_exchange_request6.psk_hint_length;
    1229            1 :     libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
    1230            1 :     ptr += m_libspdm_psk_exchange_request6.context_length;
    1231            1 :     libspdm_build_opaque_data_supported_version_data(
    1232              :         spdm_context, &opaque_psk_exchange_req_size, ptr);
    1233              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
    1234              :     spdm_context->transcript.message_m.buffer_size =
    1235              :         spdm_context->transcript.message_m.max_buffer_size;
    1236              : #endif
    1237            1 :     ptr += opaque_psk_exchange_req_size;
    1238            1 :     response_size = sizeof(response);
    1239            1 :     status = libspdm_get_response_psk_exchange(
    1240              :         spdm_context, m_libspdm_psk_exchange_request6_size,
    1241              :         &m_libspdm_psk_exchange_request6, &response_size, response);
    1242            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1243              : 
    1244            1 :     spdm_response = (void *)response;
    1245            1 :     assert_int_equal(spdm_response->header.request_response_code,
    1246              :                      SPDM_ERROR);
    1247            1 :     assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    1248              : 
    1249              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
    1250              :     /* Error before libspdm_reset_message_buffer_via_request_code, so will not libspdm_reset_message_m */
    1251              :     assert_int_equal(spdm_context->transcript.message_m.buffer_size,
    1252              :                      spdm_context->transcript.message_m.max_buffer_size);
    1253              : #endif
    1254            1 :     free(data1);
    1255            1 : }
    1256              : 
    1257            1 : static void rsp_psk_exchange_rsp_case13(void **state)
    1258              : {
    1259              :     libspdm_return_t status;
    1260              :     libspdm_test_context_t *spdm_test_context;
    1261              :     libspdm_context_t *spdm_context;
    1262              :     size_t response_size;
    1263              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1264              :     spdm_psk_exchange_response_t *spdm_response;
    1265              :     void *data1;
    1266              :     size_t data_size1;
    1267              :     uint8_t *ptr;
    1268              :     size_t opaque_psk_exchange_req_size;
    1269              : 
    1270            1 :     spdm_test_context = *state;
    1271            1 :     spdm_context = spdm_test_context->spdm_context;
    1272            1 :     spdm_test_context->case_id = 0xD;
    1273              : 
    1274              :     /* Clear previous sessions */
    1275            1 :     if(spdm_context->session_info[0].session_id != INVALID_SESSION_ID) {
    1276            0 :         libspdm_free_session_id(spdm_context,0xFFFFFFFF);
    1277              :     }
    1278              : 
    1279            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1280              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1281            1 :     spdm_context->connection_info.connection_state =
    1282              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
    1283              : 
    1284            1 :     spdm_context->local_context.capability.flags &=
    1285              :         ~SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP;
    1286              : 
    1287            1 :     spdm_context->connection_info.capability.flags |=
    1288              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1289            1 :     spdm_context->local_context.capability.flags |=
    1290              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1291              : 
    1292            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
    1293              :         m_libspdm_use_hash_algo;
    1294            1 :     spdm_context->connection_info.algorithm.measurement_spec =
    1295              :         m_libspdm_use_measurement_spec;
    1296            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
    1297              :         m_libspdm_use_measurement_hash_algo;
    1298            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
    1299              :         m_libspdm_use_dhe_algo;
    1300            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
    1301              :         m_libspdm_use_aead_algo;
    1302            1 :     spdm_context->connection_info.algorithm.key_schedule =
    1303              :         m_libspdm_use_key_schedule_algo;
    1304            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
    1305              :                                                     m_libspdm_use_asym_algo, &data1,
    1306              :                                                     &data_size1, NULL, NULL);
    1307            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
    1308            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
    1309              :         data_size1;
    1310            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
    1311            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
    1312              :         data_size1;
    1313              : 
    1314            1 :     libspdm_reset_message_a(spdm_context);
    1315              : 
    1316            1 :     m_libspdm_psk_exchange_request4.psk_hint_length =
    1317              :         (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
    1318            1 :     m_libspdm_psk_exchange_request4.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
    1319            1 :     opaque_psk_exchange_req_size =
    1320            1 :         libspdm_get_opaque_data_supported_version_data_size(spdm_context);
    1321            1 :     m_libspdm_psk_exchange_request4.opaque_length =
    1322            1 :         (uint16_t)opaque_psk_exchange_req_size;
    1323            1 :     m_libspdm_psk_exchange_request4.req_session_id = 0xFFFF;
    1324            1 :     ptr = m_libspdm_psk_exchange_request4.psk_hint;
    1325            1 :     libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request4.psk_hint),
    1326              :                      LIBSPDM_TEST_PSK_HINT_STRING,
    1327              :                      sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
    1328            1 :     ptr += m_libspdm_psk_exchange_request4.psk_hint_length;
    1329            1 :     libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
    1330            1 :     ptr += m_libspdm_psk_exchange_request4.context_length;
    1331            1 :     libspdm_build_opaque_data_supported_version_data(
    1332              :         spdm_context, &opaque_psk_exchange_req_size, ptr);
    1333              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
    1334              :     spdm_context->transcript.message_m.buffer_size =
    1335              :         spdm_context->transcript.message_m.max_buffer_size;
    1336              : #endif
    1337            1 :     ptr += opaque_psk_exchange_req_size;
    1338            1 :     response_size = sizeof(response);
    1339            1 :     status = libspdm_get_response_psk_exchange(
    1340              :         spdm_context, m_libspdm_psk_exchange_request4_size,
    1341              :         &m_libspdm_psk_exchange_request4, &response_size, response);
    1342            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1343              : 
    1344            1 :     spdm_response = (void *)response;
    1345            1 :     assert_int_equal(spdm_response->header.request_response_code,
    1346              :                      SPDM_ERROR);
    1347            1 :     assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    1348              : 
    1349            1 :     free(data1);
    1350            1 : }
    1351              : 
    1352            1 : static void rsp_psk_exchange_rsp_case14(void **state)
    1353              : {
    1354              :     libspdm_return_t status;
    1355              :     libspdm_test_context_t *spdm_test_context;
    1356              :     libspdm_context_t *spdm_context;
    1357              :     size_t response_size;
    1358              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1359              :     spdm_psk_exchange_response_t *spdm_response;
    1360              :     void *data1;
    1361              :     size_t data_size1;
    1362              :     uint8_t *ptr;
    1363              :     size_t opaque_psk_exchange_req_size;
    1364              : 
    1365            1 :     spdm_test_context = *state;
    1366            1 :     spdm_context = spdm_test_context->spdm_context;
    1367            1 :     spdm_test_context->case_id = 0xE;
    1368              : 
    1369              :     /* Clear previous sessions */
    1370            1 :     if(spdm_context->session_info[0].session_id != INVALID_SESSION_ID) {
    1371            0 :         libspdm_free_session_id(spdm_context,0xFFFFFFFF);
    1372              :     }
    1373              : 
    1374            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1375              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1376            1 :     spdm_context->connection_info.connection_state =
    1377              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
    1378            1 :     spdm_context->connection_info.capability.flags |=
    1379              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1380            1 :     spdm_context->local_context.capability.flags |=
    1381              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1382            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
    1383              :         m_libspdm_use_hash_algo;
    1384            1 :     spdm_context->connection_info.algorithm.measurement_spec =
    1385              :         m_libspdm_use_measurement_spec;
    1386            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
    1387              :         m_libspdm_use_measurement_hash_algo;
    1388            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
    1389              :         m_libspdm_use_dhe_algo;
    1390            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
    1391              :         m_libspdm_use_aead_algo;
    1392            1 :     spdm_context->connection_info.algorithm.key_schedule =
    1393              :         m_libspdm_use_key_schedule_algo;
    1394            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
    1395              :                                                     m_libspdm_use_asym_algo, &data1,
    1396              :                                                     &data_size1, NULL, NULL);
    1397            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
    1398            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
    1399              :         data_size1;
    1400            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
    1401            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
    1402              :         data_size1;
    1403              : 
    1404            1 :     libspdm_reset_message_a(spdm_context);
    1405              : 
    1406            1 :     m_libspdm_psk_exchange_request7.psk_hint_length = 0;
    1407            1 :     m_libspdm_psk_exchange_request7.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
    1408            1 :     opaque_psk_exchange_req_size =
    1409            1 :         libspdm_get_opaque_data_supported_version_data_size(spdm_context);
    1410            1 :     m_libspdm_psk_exchange_request7.opaque_length =
    1411            1 :         (uint16_t)opaque_psk_exchange_req_size;
    1412            1 :     m_libspdm_psk_exchange_request7.req_session_id = 0xFFFF;
    1413            1 :     ptr = m_libspdm_psk_exchange_request7.context;
    1414            1 :     libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
    1415            1 :     ptr += m_libspdm_psk_exchange_request7.context_length;
    1416            1 :     libspdm_build_opaque_data_supported_version_data(
    1417              :         spdm_context, &opaque_psk_exchange_req_size, ptr);
    1418              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
    1419              :     spdm_context->transcript.message_m.buffer_size =
    1420              :         spdm_context->transcript.message_m.max_buffer_size;
    1421              : #endif
    1422            1 :     ptr += opaque_psk_exchange_req_size;
    1423            1 :     response_size = sizeof(response);
    1424            1 :     status = libspdm_get_response_psk_exchange(
    1425              :         spdm_context, m_libspdm_psk_exchange_request7_size,
    1426              :         &m_libspdm_psk_exchange_request7, &response_size, response);
    1427            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1428            1 :     assert_int_equal(
    1429              :         libspdm_secured_message_get_session_state(
    1430              :             spdm_context->session_info[0].secured_message_context),
    1431              :         LIBSPDM_SESSION_STATE_HANDSHAKING);
    1432            1 :     spdm_response = (void *)response;
    1433            1 :     assert_int_equal(spdm_response->header.request_response_code,
    1434              :                      SPDM_PSK_EXCHANGE_RSP);
    1435            1 :     assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
    1436              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
    1437              :     assert_int_equal(spdm_context->transcript.message_m.buffer_size,
    1438              :                      0);
    1439              : #endif
    1440            1 :     free(data1);
    1441            1 : }
    1442              : 
    1443            1 : static void rsp_psk_exchange_rsp_case15(void **state)
    1444              : {
    1445              :     libspdm_return_t status;
    1446              :     libspdm_test_context_t *spdm_test_context;
    1447              :     libspdm_context_t *spdm_context;
    1448              :     size_t response_size;
    1449              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1450              :     spdm_psk_exchange_response_t *spdm_response;
    1451              :     void *data1;
    1452              :     size_t data_size1;
    1453              :     uint8_t *ptr;
    1454              :     size_t opaque_psk_exchange_req_size;
    1455              : 
    1456            1 :     spdm_test_context = *state;
    1457            1 :     spdm_context = spdm_test_context->spdm_context;
    1458            1 :     spdm_test_context->case_id = 0xF;
    1459              : 
    1460              :     /* Clear previous sessions */
    1461            1 :     if(spdm_context->session_info[0].session_id != INVALID_SESSION_ID) {
    1462            1 :         libspdm_free_session_id(spdm_context,0xFFFFFFFF);
    1463              :     }
    1464              : 
    1465            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1466              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1467            1 :     spdm_context->connection_info.connection_state =
    1468              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
    1469            1 :     spdm_context->connection_info.capability.flags |=
    1470              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1471            1 :     spdm_context->local_context.capability.flags |=
    1472              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1473            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
    1474              :         m_libspdm_use_hash_algo;
    1475            1 :     spdm_context->connection_info.algorithm.measurement_spec =
    1476              :         m_libspdm_use_measurement_spec;
    1477            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
    1478              :         m_libspdm_use_measurement_hash_algo;
    1479            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
    1480              :         m_libspdm_use_dhe_algo;
    1481            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
    1482              :         m_libspdm_use_aead_algo;
    1483            1 :     spdm_context->connection_info.algorithm.key_schedule =
    1484              :         m_libspdm_use_key_schedule_algo;
    1485            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
    1486              :                                                     m_libspdm_use_asym_algo, &data1,
    1487              :                                                     &data_size1, NULL, NULL);
    1488            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
    1489            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
    1490              :         data_size1;
    1491            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
    1492            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
    1493              :         data_size1;
    1494              : 
    1495            1 :     libspdm_reset_message_a(spdm_context);
    1496              : 
    1497            1 :     m_libspdm_psk_exchange_request8.psk_hint_length =
    1498              :         (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
    1499            1 :     m_libspdm_psk_exchange_request8.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
    1500            1 :     opaque_psk_exchange_req_size = 0;
    1501            1 :     m_libspdm_psk_exchange_request8.opaque_length =
    1502            1 :         (uint16_t)opaque_psk_exchange_req_size;
    1503            1 :     m_libspdm_psk_exchange_request8.req_session_id = 0xFFFF;
    1504            1 :     ptr = m_libspdm_psk_exchange_request8.psk_hint;
    1505            1 :     libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request8.psk_hint),
    1506              :                      LIBSPDM_TEST_PSK_HINT_STRING,
    1507              :                      sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
    1508            1 :     ptr += m_libspdm_psk_exchange_request8.psk_hint_length;
    1509            1 :     libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
    1510            1 :     ptr += m_libspdm_psk_exchange_request8.context_length;
    1511              : 
    1512              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
    1513              :     spdm_context->transcript.message_m.buffer_size =
    1514              :         spdm_context->transcript.message_m.max_buffer_size;
    1515              : #endif
    1516            1 :     ptr += opaque_psk_exchange_req_size;
    1517            1 :     response_size = sizeof(response);
    1518            1 :     status = libspdm_get_response_psk_exchange(
    1519              :         spdm_context, m_libspdm_psk_exchange_request8_size,
    1520              :         &m_libspdm_psk_exchange_request8, &response_size, response);
    1521            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1522            1 :     assert_int_equal(
    1523              :         libspdm_secured_message_get_session_state(
    1524              :             spdm_context->session_info[0].secured_message_context),
    1525              :         LIBSPDM_SESSION_STATE_HANDSHAKING);
    1526            1 :     spdm_response = (void *)response;
    1527            1 :     assert_int_equal(spdm_response->header.request_response_code,
    1528              :                      SPDM_PSK_EXCHANGE_RSP);
    1529            1 :     assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
    1530              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
    1531              :     assert_int_equal(spdm_context->transcript.message_m.buffer_size,
    1532              :                      0);
    1533              : #endif
    1534            1 :     free(data1);
    1535            1 : }
    1536              : 
    1537            1 : static void rsp_psk_exchange_rsp_case16(void **state)
    1538              : {
    1539              :     libspdm_return_t status;
    1540              :     libspdm_test_context_t *spdm_test_context;
    1541              :     libspdm_context_t *spdm_context;
    1542              :     size_t response_size;
    1543              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1544              :     spdm_psk_exchange_response_t *spdm_response;
    1545              :     void *data1;
    1546              :     size_t data_size1;
    1547              :     uint8_t *ptr;
    1548              :     size_t opaque_psk_exchange_req_size;
    1549              : 
    1550            1 :     spdm_test_context = *state;
    1551            1 :     spdm_context = spdm_test_context->spdm_context;
    1552            1 :     spdm_test_context->case_id = 0x10;
    1553              : 
    1554              :     /* Clear previous sessions */
    1555            1 :     if(spdm_context->session_info[0].session_id != INVALID_SESSION_ID) {
    1556            1 :         libspdm_free_session_id(spdm_context,0xFFFFFFFF);
    1557              :     }
    1558              : 
    1559            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1560              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1561            1 :     spdm_context->connection_info.connection_state =
    1562              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
    1563            1 :     spdm_context->connection_info.capability.flags |=
    1564              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1565            1 :     spdm_context->local_context.capability.flags |=
    1566              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1567            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
    1568              :         m_libspdm_use_hash_algo;
    1569            1 :     spdm_context->connection_info.algorithm.measurement_spec =
    1570              :         m_libspdm_use_measurement_spec;
    1571            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
    1572              :         m_libspdm_use_measurement_hash_algo;
    1573            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
    1574              :         m_libspdm_use_dhe_algo;
    1575            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
    1576              :         m_libspdm_use_aead_algo;
    1577            1 :     spdm_context->connection_info.algorithm.key_schedule =
    1578              :         m_libspdm_use_key_schedule_algo;
    1579            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
    1580              :                                                     m_libspdm_use_asym_algo, &data1,
    1581              :                                                     &data_size1, NULL, NULL);
    1582            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
    1583            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
    1584              :         data_size1;
    1585            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
    1586            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
    1587              :         data_size1;
    1588              : 
    1589            1 :     libspdm_reset_message_a(spdm_context);
    1590              : 
    1591            1 :     m_libspdm_psk_exchange_request9.psk_hint_length = 0;
    1592            1 :     m_libspdm_psk_exchange_request9.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
    1593            1 :     opaque_psk_exchange_req_size = 0;
    1594            1 :     m_libspdm_psk_exchange_request9.opaque_length =
    1595            1 :         (uint16_t)opaque_psk_exchange_req_size;
    1596            1 :     m_libspdm_psk_exchange_request9.req_session_id = 0xFFFF;
    1597            1 :     ptr = m_libspdm_psk_exchange_request9.context;
    1598            1 :     libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
    1599            1 :     ptr += m_libspdm_psk_exchange_request9.context_length;
    1600              : 
    1601              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
    1602              :     spdm_context->transcript.message_m.buffer_size =
    1603              :         spdm_context->transcript.message_m.max_buffer_size;
    1604              : #endif
    1605            1 :     ptr += opaque_psk_exchange_req_size;
    1606            1 :     response_size = sizeof(response);
    1607            1 :     status = libspdm_get_response_psk_exchange(
    1608              :         spdm_context, m_libspdm_psk_exchange_request9_size,
    1609              :         &m_libspdm_psk_exchange_request9, &response_size, response);
    1610            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1611            1 :     assert_int_equal(
    1612              :         libspdm_secured_message_get_session_state(
    1613              :             spdm_context->session_info[0].secured_message_context),
    1614              :         LIBSPDM_SESSION_STATE_HANDSHAKING);
    1615            1 :     spdm_response = (void *)response;
    1616            1 :     assert_int_equal(spdm_response->header.request_response_code,
    1617              :                      SPDM_PSK_EXCHANGE_RSP);
    1618            1 :     assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
    1619              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
    1620              :     assert_int_equal(spdm_context->transcript.message_m.buffer_size,
    1621              :                      0);
    1622              : #endif
    1623            1 :     free(data1);
    1624            1 : }
    1625              : 
    1626            1 : static void rsp_psk_exchange_rsp_case17(void **state)
    1627              : {
    1628              :     libspdm_return_t status;
    1629              :     libspdm_test_context_t *spdm_test_context;
    1630              :     libspdm_context_t *spdm_context;
    1631              :     size_t response_size;
    1632              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1633              :     spdm_psk_exchange_response_t *spdm_response;
    1634              :     void *data1;
    1635              :     size_t data_size1;
    1636              :     uint8_t *ptr;
    1637              :     size_t opaque_psk_exchange_req_size;
    1638              : 
    1639            1 :     spdm_test_context = *state;
    1640            1 :     spdm_context = spdm_test_context->spdm_context;
    1641            1 :     spdm_test_context->case_id = 0x11;
    1642            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
    1643              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1644            1 :     spdm_context->connection_info.connection_state =
    1645              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
    1646            1 :     spdm_context->connection_info.capability.flags |=
    1647              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1648            1 :     spdm_context->local_context.capability.flags |=
    1649              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1650            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
    1651              :         m_libspdm_use_hash_algo;
    1652            1 :     spdm_context->connection_info.algorithm.measurement_spec =
    1653              :         m_libspdm_use_measurement_spec;
    1654            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
    1655              :         m_libspdm_use_measurement_hash_algo;
    1656            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
    1657              :         m_libspdm_use_dhe_algo;
    1658            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
    1659              :         m_libspdm_use_aead_algo;
    1660            1 :     spdm_context->connection_info.algorithm.key_schedule =
    1661              :         m_libspdm_use_key_schedule_algo;
    1662            1 :     spdm_context->connection_info.algorithm.other_params_support =
    1663              :         SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
    1664            1 :     libspdm_session_info_init(spdm_context,
    1665            1 :                               spdm_context->session_info,
    1666              :                               0,
    1667              :                               INVALID_SESSION_ID, true);
    1668            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
    1669              :                                                     m_libspdm_use_asym_algo, &data1,
    1670              :                                                     &data_size1, NULL, NULL);
    1671            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
    1672            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
    1673              :         data_size1;
    1674            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
    1675            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
    1676              :         data_size1;
    1677              : 
    1678            1 :     libspdm_reset_message_a(spdm_context);
    1679              : 
    1680            1 :     m_libspdm_psk_exchange_request3.psk_hint_length =
    1681              :         (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
    1682            1 :     m_libspdm_psk_exchange_request3.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
    1683            1 :     opaque_psk_exchange_req_size =
    1684            1 :         libspdm_get_opaque_data_supported_version_data_size(spdm_context);
    1685            1 :     m_libspdm_psk_exchange_request3.opaque_length =
    1686            1 :         (uint16_t)opaque_psk_exchange_req_size;
    1687            1 :     m_libspdm_psk_exchange_request3.req_session_id = 0xFFFF;
    1688            1 :     ptr = m_libspdm_psk_exchange_request3.psk_hint;
    1689            1 :     libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request3.psk_hint),
    1690              :                      LIBSPDM_TEST_PSK_HINT_STRING,
    1691              :                      sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
    1692            1 :     ptr += m_libspdm_psk_exchange_request3.psk_hint_length;
    1693            1 :     libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
    1694            1 :     ptr += m_libspdm_psk_exchange_request3.context_length;
    1695            1 :     libspdm_build_opaque_data_supported_version_data(
    1696              :         spdm_context, &opaque_psk_exchange_req_size, ptr);
    1697              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
    1698              :     spdm_context->transcript.message_m.buffer_size =
    1699              :         spdm_context->transcript.message_m.max_buffer_size;
    1700              : #endif
    1701            1 :     ptr += opaque_psk_exchange_req_size;
    1702            1 :     response_size = sizeof(response);
    1703            1 :     status = libspdm_get_response_psk_exchange(
    1704              :         spdm_context, m_libspdm_psk_exchange_request3_size,
    1705              :         &m_libspdm_psk_exchange_request3, &response_size, response);
    1706            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1707            1 :     assert_int_equal(
    1708              :         libspdm_secured_message_get_session_state(
    1709              :             spdm_context->session_info[0].secured_message_context),
    1710              :         LIBSPDM_SESSION_STATE_HANDSHAKING);
    1711            1 :     assert_int_equal(spdm_context->session_info[0].session_policy, 0);
    1712            1 :     spdm_response = (void *)response;
    1713            1 :     assert_int_equal(spdm_response->header.spdm_version,
    1714              :                      SPDM_MESSAGE_VERSION_12);
    1715            1 :     assert_int_equal(spdm_response->header.request_response_code,
    1716              :                      SPDM_PSK_EXCHANGE_RSP);
    1717            1 :     assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
    1718              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
    1719              :     assert_int_equal(spdm_context->transcript.message_m.buffer_size,
    1720              :                      0);
    1721              : #endif
    1722            1 :     free(data1);
    1723            1 : }
    1724              : 
    1725            1 : int libspdm_rsp_psk_exchange_rsp_test(void)
    1726              : {
    1727            1 :     const struct CMUnitTest test_cases[] = {
    1728              :         /* Success Case*/
    1729              :         cmocka_unit_test(rsp_psk_exchange_rsp_case1),
    1730              :         /* Bad request size*/
    1731              :         cmocka_unit_test(rsp_psk_exchange_rsp_case2),
    1732              :         /* response_state: SPDM_RESPONSE_STATE_BUSY*/
    1733              :         cmocka_unit_test(rsp_psk_exchange_rsp_case3),
    1734              :         /* response_state: SPDM_RESPONSE_STATE_NEED_RESYNC*/
    1735              :         cmocka_unit_test(rsp_psk_exchange_rsp_case4),
    1736              :         #if LIBSPDM_RESPOND_IF_READY_SUPPORT
    1737              :         /* response_state: SPDM_RESPONSE_STATE_NOT_READY*/
    1738              :         cmocka_unit_test(rsp_psk_exchange_rsp_case5),
    1739              :         #endif /* LIBSPDM_RESPOND_IF_READY_SUPPORT */
    1740              :         /* connection_state Check*/
    1741              :         cmocka_unit_test(rsp_psk_exchange_rsp_case6),
    1742              :         /* Buffer reset*/
    1743              :         cmocka_unit_test(rsp_psk_exchange_rsp_case7),
    1744              :         /* Buffer verification*/
    1745              :         cmocka_unit_test(rsp_psk_exchange_rsp_case8),
    1746              :         /* Successful response V1.2*/
    1747              :         cmocka_unit_test(rsp_psk_exchange_rsp_case9),
    1748              :         /* TCB measurement hash requested */
    1749              :         cmocka_unit_test(rsp_psk_exchange_rsp_case10),
    1750              :         /* All measurement hash requested */
    1751              :         cmocka_unit_test(rsp_psk_exchange_rsp_case11),
    1752              :         /* Reserved value in Measurement summary. Error + Invalid */
    1753              :         cmocka_unit_test(rsp_psk_exchange_rsp_case12),
    1754              :         /* TCB measurement hash requested, measurement flag not set */
    1755              :         cmocka_unit_test(rsp_psk_exchange_rsp_case13),
    1756              :         /* No PSKHint*/
    1757              :         cmocka_unit_test(rsp_psk_exchange_rsp_case14),
    1758              :         /* No OpaqueData*/
    1759              :         cmocka_unit_test(rsp_psk_exchange_rsp_case15),
    1760              :         /* No PSKHint and no OpaqueData*/
    1761              :         cmocka_unit_test(rsp_psk_exchange_rsp_case16),
    1762              :         /* OpaqueData only supports OpaqueDataFmt1, Success Case */
    1763              :         cmocka_unit_test(rsp_psk_exchange_rsp_case17),
    1764              :     };
    1765              : 
    1766            1 :     libspdm_test_context_t test_context = {
    1767              :         LIBSPDM_TEST_CONTEXT_VERSION,
    1768              :         false,
    1769              :     };
    1770              : 
    1771            1 :     libspdm_setup_test_context(&test_context);
    1772              : 
    1773            1 :     return cmocka_run_group_tests(test_cases,
    1774              :                                   libspdm_unit_test_group_setup,
    1775              :                                   libspdm_unit_test_group_teardown);
    1776              : }
    1777              : 
    1778              : #endif /* LIBSPDM_ENABLE_CAPABILITY_PSK_CAP*/
        

Generated by: LCOV version 2.0-1