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

            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_secured_message_lib.h"
      10              : 
      11              : #if (LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP) || (LIBSPDM_ENABLE_CAPABILITY_PSK_CAP)
      12              : 
      13              : spdm_end_session_request_t m_libspdm_end_session_request1 = {
      14              :     { SPDM_MESSAGE_VERSION_11, SPDM_END_SESSION, 0, 0 }
      15              : };
      16              : size_t m_libspdm_end_session_request1_size = sizeof(m_libspdm_end_session_request1);
      17              : 
      18              : spdm_end_session_request_t m_libspdm_end_session_request2 = {
      19              :     { SPDM_MESSAGE_VERSION_11, SPDM_END_SESSION, 0, 0 }
      20              : };
      21              : size_t m_libspdm_end_session_request2_size = LIBSPDM_MAX_SPDM_MSG_SIZE;
      22              : 
      23              : spdm_end_session_request_t m_libspdm_end_session_request3 = {
      24              :     { SPDM_MESSAGE_VERSION_11, SPDM_END_SESSION,
      25              :       SPDM_END_SESSION_REQUEST_ATTRIBUTES_PRESERVE_NEGOTIATED_STATE_CLEAR, 0 }
      26              : };
      27              : size_t m_libspdm_end_session_request3_size = sizeof(m_libspdm_end_session_request1);
      28              : 
      29            1 : static void rsp_end_session_ack_case1(void **state)
      30              : {
      31              :     libspdm_return_t status;
      32              :     libspdm_test_context_t *spdm_test_context;
      33              :     libspdm_context_t *spdm_context;
      34              :     size_t response_size;
      35              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
      36              :     spdm_end_session_response_t *spdm_response;
      37              :     void *data1;
      38              :     size_t data_size1;
      39              :     libspdm_session_info_t *session_info;
      40              :     uint32_t session_id;
      41              : 
      42            1 :     spdm_test_context = *state;
      43            1 :     spdm_context = spdm_test_context->spdm_context;
      44            1 :     spdm_test_context->case_id = 0x1;
      45            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
      46              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
      47            1 :     spdm_context->connection_info.connection_state =
      48              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
      49            1 :     spdm_context->connection_info.capability.flags |=
      50              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
      51            1 :     spdm_context->local_context.capability.flags |=
      52              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
      53            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
      54              :         m_libspdm_use_hash_algo;
      55            1 :     spdm_context->connection_info.algorithm.base_asym_algo =
      56              :         m_libspdm_use_asym_algo;
      57            1 :     spdm_context->connection_info.algorithm.measurement_spec =
      58              :         m_libspdm_use_measurement_spec;
      59            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
      60              :         m_libspdm_use_measurement_hash_algo;
      61            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
      62              :         m_libspdm_use_dhe_algo;
      63            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
      64              :         m_libspdm_use_aead_algo;
      65            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
      66              :                                                     m_libspdm_use_asym_algo, &data1,
      67              :                                                     &data_size1, NULL, NULL);
      68            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
      69            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
      70              :         data_size1;
      71            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
      72            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
      73              :         data_size1;
      74              : 
      75            1 :     libspdm_reset_message_a(spdm_context);
      76            1 :     spdm_context->local_context.mut_auth_requested = 0;
      77              : 
      78            1 :     session_id = 0xFFFFFFFF;
      79            1 :     spdm_context->latest_session_id = session_id;
      80            1 :     spdm_context->last_spdm_request_session_id_valid = true;
      81            1 :     spdm_context->last_spdm_request_session_id = session_id;
      82            1 :     session_info = &spdm_context->session_info[0];
      83            1 :     libspdm_session_info_init(spdm_context, session_info, session_id,
      84              :                               SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
      85            1 :     libspdm_secured_message_set_session_state(
      86              :         session_info->secured_message_context,
      87              :         LIBSPDM_SESSION_STATE_ESTABLISHED);
      88              : 
      89            1 :     response_size = sizeof(response);
      90            1 :     status = libspdm_get_response_end_session(spdm_context,
      91              :                                               m_libspdm_end_session_request1_size,
      92              :                                               &m_libspdm_end_session_request1,
      93              :                                               &response_size, response);
      94            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
      95            1 :     assert_int_equal(response_size, sizeof(spdm_end_session_response_t));
      96            1 :     spdm_response = (void *)response;
      97            1 :     assert_int_equal(spdm_response->header.request_response_code,
      98              :                      SPDM_END_SESSION_ACK);
      99            1 :     free(data1);
     100            1 : }
     101              : 
     102            1 : static void rsp_end_session_ack_case2(void **state)
     103              : {
     104              :     libspdm_return_t status;
     105              :     libspdm_test_context_t *spdm_test_context;
     106              :     libspdm_context_t *spdm_context;
     107              :     size_t response_size;
     108              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     109              :     spdm_end_session_response_t *spdm_response;
     110              :     void *data1;
     111              :     size_t data_size1;
     112              :     libspdm_session_info_t *session_info;
     113              :     uint32_t session_id;
     114              : 
     115            1 :     spdm_test_context = *state;
     116            1 :     spdm_context = spdm_test_context->spdm_context;
     117            1 :     spdm_test_context->case_id = 0x2;
     118            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     119              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     120            1 :     spdm_context->connection_info.connection_state =
     121              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     122            1 :     spdm_context->connection_info.capability.flags |=
     123              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
     124            1 :     spdm_context->local_context.capability.flags |=
     125              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
     126            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
     127              :         m_libspdm_use_hash_algo;
     128            1 :     spdm_context->connection_info.algorithm.base_asym_algo =
     129              :         m_libspdm_use_asym_algo;
     130            1 :     spdm_context->connection_info.algorithm.measurement_spec =
     131              :         m_libspdm_use_measurement_spec;
     132            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     133              :         m_libspdm_use_measurement_hash_algo;
     134            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
     135              :         m_libspdm_use_dhe_algo;
     136            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
     137              :         m_libspdm_use_aead_algo;
     138            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     139              :                                                     m_libspdm_use_asym_algo, &data1,
     140              :                                                     &data_size1, NULL, NULL);
     141            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
     142            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
     143              :         data_size1;
     144            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
     145            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
     146              :         data_size1;
     147              : 
     148            1 :     libspdm_reset_message_a(spdm_context);
     149            1 :     spdm_context->local_context.mut_auth_requested = 0;
     150              : 
     151            1 :     session_id = 0xFFFFFFFF;
     152            1 :     spdm_context->latest_session_id = session_id;
     153            1 :     spdm_context->last_spdm_request_session_id_valid = true;
     154            1 :     spdm_context->last_spdm_request_session_id = session_id;
     155            1 :     session_info = &spdm_context->session_info[0];
     156            1 :     libspdm_session_info_init(spdm_context, session_info, session_id,
     157              :                               SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
     158            1 :     libspdm_secured_message_set_session_state(
     159              :         session_info->secured_message_context,
     160              :         LIBSPDM_SESSION_STATE_ESTABLISHED);
     161              : 
     162            1 :     response_size = sizeof(response);
     163            1 :     status = libspdm_get_response_end_session(spdm_context,
     164              :                                               m_libspdm_end_session_request2_size,
     165              :                                               &m_libspdm_end_session_request2,
     166              :                                               &response_size, response);
     167            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     168            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     169            1 :     spdm_response = (void *)response;
     170            1 :     assert_int_equal(spdm_response->header.request_response_code,
     171              :                      SPDM_ERROR);
     172            1 :     assert_int_equal(spdm_response->header.param1,
     173              :                      SPDM_ERROR_CODE_INVALID_REQUEST);
     174            1 :     assert_int_equal(spdm_response->header.param2, 0);
     175            1 :     free(data1);
     176            1 : }
     177              : 
     178            1 : static void rsp_end_session_ack_case3(void **state)
     179              : {
     180              :     libspdm_return_t status;
     181              :     libspdm_test_context_t *spdm_test_context;
     182              :     libspdm_context_t *spdm_context;
     183              :     size_t response_size;
     184              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     185              :     spdm_end_session_response_t *spdm_response;
     186              :     void *data1;
     187              :     size_t data_size1;
     188              :     libspdm_session_info_t *session_info;
     189              :     uint32_t session_id;
     190              : 
     191            1 :     spdm_test_context = *state;
     192            1 :     spdm_context = spdm_test_context->spdm_context;
     193            1 :     spdm_test_context->case_id = 0x3;
     194            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     195              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     196            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_BUSY;
     197            1 :     spdm_context->connection_info.connection_state =
     198              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     199            1 :     spdm_context->connection_info.capability.flags |=
     200              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
     201            1 :     spdm_context->local_context.capability.flags |=
     202              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
     203            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
     204              :         m_libspdm_use_hash_algo;
     205            1 :     spdm_context->connection_info.algorithm.base_asym_algo =
     206              :         m_libspdm_use_asym_algo;
     207            1 :     spdm_context->connection_info.algorithm.measurement_spec =
     208              :         m_libspdm_use_measurement_spec;
     209            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     210              :         m_libspdm_use_measurement_hash_algo;
     211            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
     212              :         m_libspdm_use_dhe_algo;
     213            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
     214              :         m_libspdm_use_aead_algo;
     215            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     216              :                                                     m_libspdm_use_asym_algo, &data1,
     217              :                                                     &data_size1, NULL, NULL);
     218            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
     219            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
     220              :         data_size1;
     221            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
     222            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
     223              :         data_size1;
     224              : 
     225            1 :     libspdm_reset_message_a(spdm_context);
     226            1 :     spdm_context->local_context.mut_auth_requested = 0;
     227              : 
     228            1 :     session_id = 0xFFFFFFFF;
     229            1 :     spdm_context->latest_session_id = session_id;
     230            1 :     spdm_context->last_spdm_request_session_id_valid = true;
     231            1 :     spdm_context->last_spdm_request_session_id = session_id;
     232            1 :     session_info = &spdm_context->session_info[0];
     233            1 :     libspdm_session_info_init(spdm_context, session_info, session_id,
     234              :                               SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
     235            1 :     libspdm_secured_message_set_session_state(
     236              :         session_info->secured_message_context,
     237              :         LIBSPDM_SESSION_STATE_ESTABLISHED);
     238              : 
     239            1 :     response_size = sizeof(response);
     240            1 :     status = libspdm_get_response_end_session(spdm_context,
     241              :                                               m_libspdm_end_session_request1_size,
     242              :                                               &m_libspdm_end_session_request1,
     243              :                                               &response_size, response);
     244            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     245            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     246            1 :     spdm_response = (void *)response;
     247            1 :     assert_int_equal(spdm_response->header.request_response_code,
     248              :                      SPDM_ERROR);
     249            1 :     assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_BUSY);
     250            1 :     assert_int_equal(spdm_response->header.param2, 0);
     251            1 :     assert_int_equal(spdm_context->response_state,
     252              :                      LIBSPDM_RESPONSE_STATE_BUSY);
     253            1 :     free(data1);
     254            1 : }
     255              : 
     256            1 : static void rsp_end_session_ack_case4(void **state)
     257              : {
     258              :     libspdm_return_t status;
     259              :     libspdm_test_context_t *spdm_test_context;
     260              :     libspdm_context_t *spdm_context;
     261              :     size_t response_size;
     262              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     263              :     spdm_end_session_response_t *spdm_response;
     264              :     void *data1;
     265              :     size_t data_size1;
     266              :     libspdm_session_info_t *session_info;
     267              :     uint32_t session_id;
     268              : 
     269            1 :     spdm_test_context = *state;
     270            1 :     spdm_context = spdm_test_context->spdm_context;
     271            1 :     spdm_test_context->case_id = 0x4;
     272            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     273              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     274            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NEED_RESYNC;
     275            1 :     spdm_context->connection_info.connection_state =
     276              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     277            1 :     spdm_context->connection_info.capability.flags |=
     278              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
     279            1 :     spdm_context->local_context.capability.flags |=
     280              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
     281            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
     282              :         m_libspdm_use_hash_algo;
     283            1 :     spdm_context->connection_info.algorithm.base_asym_algo =
     284              :         m_libspdm_use_asym_algo;
     285            1 :     spdm_context->connection_info.algorithm.measurement_spec =
     286              :         m_libspdm_use_measurement_spec;
     287            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     288              :         m_libspdm_use_measurement_hash_algo;
     289            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
     290              :         m_libspdm_use_dhe_algo;
     291            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
     292              :         m_libspdm_use_aead_algo;
     293            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     294              :                                                     m_libspdm_use_asym_algo, &data1,
     295              :                                                     &data_size1, NULL, NULL);
     296            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
     297            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
     298              :         data_size1;
     299            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
     300            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
     301              :         data_size1;
     302              : 
     303            1 :     libspdm_reset_message_a(spdm_context);
     304            1 :     spdm_context->local_context.mut_auth_requested = 0;
     305              : 
     306            1 :     session_id = 0xFFFFFFFF;
     307            1 :     spdm_context->latest_session_id = session_id;
     308            1 :     spdm_context->last_spdm_request_session_id_valid = true;
     309            1 :     spdm_context->last_spdm_request_session_id = session_id;
     310            1 :     session_info = &spdm_context->session_info[0];
     311            1 :     libspdm_session_info_init(spdm_context, session_info, session_id,
     312              :                               SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
     313            1 :     libspdm_secured_message_set_session_state(
     314              :         session_info->secured_message_context,
     315              :         LIBSPDM_SESSION_STATE_ESTABLISHED);
     316              : 
     317            1 :     response_size = sizeof(response);
     318            1 :     status = libspdm_get_response_end_session(spdm_context,
     319              :                                               m_libspdm_end_session_request1_size,
     320              :                                               &m_libspdm_end_session_request1,
     321              :                                               &response_size, response);
     322            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     323            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     324            1 :     spdm_response = (void *)response;
     325            1 :     assert_int_equal(spdm_response->header.request_response_code,
     326              :                      SPDM_ERROR);
     327            1 :     assert_int_equal(spdm_response->header.param1,
     328              :                      SPDM_ERROR_CODE_REQUEST_RESYNCH);
     329            1 :     assert_int_equal(spdm_response->header.param2, 0);
     330            1 :     assert_int_equal(spdm_context->response_state,
     331              :                      LIBSPDM_RESPONSE_STATE_NEED_RESYNC);
     332            1 :     free(data1);
     333            1 : }
     334              : 
     335              : #if LIBSPDM_RESPOND_IF_READY_SUPPORT
     336            1 : static void rsp_end_session_ack_case5(void **state)
     337              : {
     338              :     libspdm_return_t status;
     339              :     libspdm_test_context_t *spdm_test_context;
     340              :     libspdm_context_t *spdm_context;
     341              :     size_t response_size;
     342              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     343              :     spdm_end_session_response_t *spdm_response;
     344              :     void *data1;
     345              :     size_t data_size1;
     346              :     libspdm_session_info_t *session_info;
     347              :     uint32_t session_id;
     348              :     spdm_error_data_response_not_ready_t *error_data;
     349              : 
     350            1 :     spdm_test_context = *state;
     351            1 :     spdm_context = spdm_test_context->spdm_context;
     352            1 :     spdm_test_context->case_id = 0x5;
     353            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     354              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     355            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NOT_READY;
     356            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     357            1 :     spdm_context->connection_info.capability.flags |=
     358              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
     359            1 :     spdm_context->local_context.capability.flags |=
     360              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
     361            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     362            1 :     spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
     363            1 :     spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
     364            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     365              :         m_libspdm_use_measurement_hash_algo;
     366            1 :     spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
     367            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
     368            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     369              :                                                     m_libspdm_use_asym_algo, &data1,
     370              :                                                     &data_size1, NULL, NULL);
     371            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
     372            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
     373            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
     374            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size = data_size1;
     375              : 
     376            1 :     libspdm_reset_message_a(spdm_context);
     377            1 :     spdm_context->local_context.mut_auth_requested = 0;
     378              : 
     379            1 :     session_id = 0xFFFFFFFF;
     380            1 :     spdm_context->latest_session_id = session_id;
     381            1 :     spdm_context->last_spdm_request_session_id_valid = true;
     382            1 :     spdm_context->last_spdm_request_session_id = session_id;
     383            1 :     session_info = &spdm_context->session_info[0];
     384            1 :     libspdm_session_info_init(spdm_context, session_info, session_id,
     385              :                               SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
     386            1 :     libspdm_secured_message_set_session_state(
     387              :         session_info->secured_message_context,
     388              :         LIBSPDM_SESSION_STATE_ESTABLISHED);
     389              : 
     390            1 :     response_size = sizeof(response);
     391            1 :     status = libspdm_get_response_end_session(spdm_context,
     392              :                                               m_libspdm_end_session_request1_size,
     393              :                                               &m_libspdm_end_session_request1,
     394              :                                               &response_size, response);
     395            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     396            1 :     assert_int_equal(response_size,
     397              :                      sizeof(spdm_error_response_t) +
     398              :                      sizeof(spdm_error_data_response_not_ready_t));
     399            1 :     spdm_response = (void *)response;
     400            1 :     error_data = (spdm_error_data_response_not_ready_t *)(spdm_response + 1);
     401            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
     402            1 :     assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_RESPONSE_NOT_READY);
     403            1 :     assert_int_equal(spdm_response->header.param2, 0);
     404            1 :     assert_int_equal(spdm_context->response_state, LIBSPDM_RESPONSE_STATE_NOT_READY);
     405            1 :     assert_int_equal(error_data->request_code, SPDM_END_SESSION);
     406            1 :     free(data1);
     407            1 : }
     408              : #endif /* LIBSPDM_RESPOND_IF_READY_SUPPORT */
     409              : 
     410            1 : static void rsp_end_session_ack_case6(void **state)
     411              : {
     412              :     libspdm_return_t status;
     413              :     libspdm_test_context_t *spdm_test_context;
     414              :     libspdm_context_t *spdm_context;
     415              :     size_t response_size;
     416              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     417              :     spdm_end_session_response_t *spdm_response;
     418              :     void *data1;
     419              :     size_t data_size1;
     420              :     libspdm_session_info_t *session_info;
     421              :     uint32_t session_id;
     422              : 
     423            1 :     spdm_test_context = *state;
     424            1 :     spdm_context = spdm_test_context->spdm_context;
     425            1 :     spdm_test_context->case_id = 0x6;
     426            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     427              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     428            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
     429            1 :     spdm_context->connection_info.connection_state =
     430              :         LIBSPDM_CONNECTION_STATE_NOT_STARTED;
     431            1 :     spdm_context->connection_info.capability.flags |=
     432              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
     433            1 :     spdm_context->local_context.capability.flags |=
     434              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
     435            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
     436              :         m_libspdm_use_hash_algo;
     437            1 :     spdm_context->connection_info.algorithm.base_asym_algo =
     438              :         m_libspdm_use_asym_algo;
     439            1 :     spdm_context->connection_info.algorithm.measurement_spec =
     440              :         m_libspdm_use_measurement_spec;
     441            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     442              :         m_libspdm_use_measurement_hash_algo;
     443            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
     444              :         m_libspdm_use_dhe_algo;
     445            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
     446              :         m_libspdm_use_aead_algo;
     447            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     448              :                                                     m_libspdm_use_asym_algo, &data1,
     449              :                                                     &data_size1, NULL, NULL);
     450            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
     451            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
     452              :         data_size1;
     453            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
     454            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
     455              :         data_size1;
     456              : 
     457            1 :     libspdm_reset_message_a(spdm_context);
     458            1 :     spdm_context->local_context.mut_auth_requested = 0;
     459              : 
     460            1 :     session_id = 0xFFFFFFFF;
     461            1 :     spdm_context->latest_session_id = session_id;
     462            1 :     spdm_context->last_spdm_request_session_id_valid = true;
     463            1 :     spdm_context->last_spdm_request_session_id = session_id;
     464            1 :     session_info = &spdm_context->session_info[0];
     465            1 :     libspdm_session_info_init(spdm_context, session_info, session_id,
     466              :                               SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
     467            1 :     libspdm_secured_message_set_session_state(
     468              :         session_info->secured_message_context,
     469              :         LIBSPDM_SESSION_STATE_ESTABLISHED);
     470              : 
     471            1 :     response_size = sizeof(response);
     472            1 :     status = libspdm_get_response_end_session(spdm_context,
     473              :                                               m_libspdm_end_session_request1_size,
     474              :                                               &m_libspdm_end_session_request1,
     475              :                                               &response_size, response);
     476            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     477            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     478            1 :     spdm_response = (void *)response;
     479            1 :     assert_int_equal(spdm_response->header.request_response_code,
     480              :                      SPDM_ERROR);
     481            1 :     assert_int_equal(spdm_response->header.param1,
     482              :                      SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
     483            1 :     assert_int_equal(spdm_response->header.param2, 0);
     484            1 :     free(data1);
     485            1 : }
     486              : 
     487            1 : static void rsp_end_session_ack_case7(void **state)
     488              : {
     489              :     libspdm_return_t status;
     490              :     libspdm_test_context_t *spdm_test_context;
     491              :     libspdm_context_t *spdm_context;
     492              :     size_t response_size;
     493              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     494              :     spdm_end_session_response_t *spdm_response;
     495              :     void *data1;
     496              :     size_t data_size1;
     497              :     libspdm_session_info_t *session_info;
     498              :     uint32_t session_id;
     499              : 
     500            1 :     spdm_test_context = *state;
     501            1 :     spdm_context = spdm_test_context->spdm_context;
     502            1 :     spdm_test_context->case_id = 0x7;
     503            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     504              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     505            1 :     spdm_context->connection_info.connection_state =
     506              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     507            1 :     spdm_context->connection_info.capability.flags |=
     508              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
     509            1 :     spdm_context->local_context.capability.flags |=
     510              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
     511            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
     512              :         m_libspdm_use_hash_algo;
     513            1 :     spdm_context->connection_info.algorithm.base_asym_algo =
     514              :         m_libspdm_use_asym_algo;
     515            1 :     spdm_context->connection_info.algorithm.measurement_spec =
     516              :         m_libspdm_use_measurement_spec;
     517            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     518              :         m_libspdm_use_measurement_hash_algo;
     519            1 :     spdm_context->connection_info.algorithm.dhe_named_group =
     520              :         m_libspdm_use_dhe_algo;
     521            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite =
     522              :         m_libspdm_use_aead_algo;
     523            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     524              :                                                     m_libspdm_use_asym_algo, &data1,
     525              :                                                     &data_size1, NULL, NULL);
     526            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
     527            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
     528              :         data_size1;
     529            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
     530            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size =
     531              :         data_size1;
     532              : 
     533            1 :     libspdm_reset_message_a(spdm_context);
     534            1 :     spdm_context->local_context.mut_auth_requested = 0;
     535              : 
     536            1 :     session_id = 0xFFFFFFFF;
     537            1 :     spdm_context->latest_session_id = session_id;
     538            1 :     spdm_context->last_spdm_request_session_id_valid = true;
     539            1 :     spdm_context->last_spdm_request_session_id = session_id;
     540            1 :     session_info = &spdm_context->session_info[0];
     541            1 :     libspdm_session_info_init(spdm_context, session_info, session_id,
     542              :                               SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
     543            1 :     libspdm_secured_message_set_session_state(
     544              :         session_info->secured_message_context,
     545              :         LIBSPDM_SESSION_STATE_ESTABLISHED);
     546              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     547              :     session_info->session_transcript.message_m.buffer_size =
     548              :         session_info->session_transcript.message_m.max_buffer_size;
     549              :     spdm_context->transcript.message_b.buffer_size =
     550              :         spdm_context->transcript.message_b.max_buffer_size;
     551              :     spdm_context->transcript.message_c.buffer_size =
     552              :         spdm_context->transcript.message_c.max_buffer_size;
     553              :     spdm_context->transcript.message_mut_b.buffer_size =
     554              :         spdm_context->transcript.message_mut_b.max_buffer_size;
     555              :     spdm_context->transcript.message_mut_c.buffer_size =
     556              :         spdm_context->transcript.message_mut_c.max_buffer_size;
     557              : #endif
     558              : 
     559            1 :     response_size = sizeof(response);
     560            1 :     status = libspdm_get_response_end_session(spdm_context,
     561              :                                               m_libspdm_end_session_request1_size,
     562              :                                               &m_libspdm_end_session_request1,
     563              :                                               &response_size, response);
     564            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     565            1 :     assert_int_equal(response_size, sizeof(spdm_end_session_response_t));
     566            1 :     spdm_response = (void *)response;
     567            1 :     assert_int_equal(spdm_response->header.request_response_code,
     568              :                      SPDM_END_SESSION_ACK);
     569              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     570              :     assert_int_equal(session_info->session_transcript.message_m.buffer_size, 0);
     571              :     assert_int_equal(spdm_context->transcript.message_b.buffer_size, 0);
     572              :     assert_int_equal(spdm_context->transcript.message_c.buffer_size, 0);
     573              :     assert_int_equal(spdm_context->transcript.message_mut_b.buffer_size, 0);
     574              :     assert_int_equal(spdm_context->transcript.message_mut_c.buffer_size, 0);
     575              : #endif
     576              : 
     577            1 :     free(data1);
     578            1 : }
     579              : 
     580            1 : static void rsp_end_session_ack_case8(void **state)
     581              : {
     582              :     libspdm_return_t status;
     583              :     libspdm_test_context_t *spdm_test_context;
     584              :     libspdm_context_t *spdm_context;
     585              :     size_t response_size;
     586              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     587              :     spdm_end_session_response_t *spdm_response;
     588              :     void *data1;
     589              :     size_t data_size1;
     590              :     libspdm_session_info_t *session_info;
     591              :     uint32_t session_id;
     592              : 
     593            1 :     spdm_test_context = *state;
     594            1 :     spdm_context = spdm_test_context->spdm_context;
     595            1 :     spdm_test_context->case_id = 0x1;
     596            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     597              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     598            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     599            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
     600            1 :     spdm_context->local_context.capability.flags |=
     601              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
     602            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     603            1 :     spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
     604            1 :     spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
     605            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     606              :         m_libspdm_use_measurement_hash_algo;
     607            1 :     spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
     608            1 :     spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
     609            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     610              :                                                     m_libspdm_use_asym_algo, &data1,
     611              :                                                     &data_size1, NULL, NULL);
     612            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data1;
     613            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
     614            1 :     spdm_context->connection_info.local_used_cert_chain_buffer = data1;
     615            1 :     spdm_context->connection_info.local_used_cert_chain_buffer_size = data_size1;
     616              : 
     617            1 :     libspdm_reset_message_a(spdm_context);
     618            1 :     spdm_context->local_context.mut_auth_requested = 0;
     619              : 
     620            1 :     session_id = 0xFFFFFFFF;
     621            1 :     spdm_context->latest_session_id = session_id;
     622            1 :     spdm_context->last_spdm_request_session_id_valid = true;
     623            1 :     spdm_context->last_spdm_request_session_id = session_id;
     624            1 :     session_info = &spdm_context->session_info[0];
     625            1 :     libspdm_session_info_init(spdm_context, session_info, session_id,
     626              :                               SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
     627            1 :     libspdm_secured_message_set_session_state(
     628              :         session_info->secured_message_context,
     629              :         LIBSPDM_SESSION_STATE_ESTABLISHED);
     630              : 
     631            1 :     response_size = sizeof(response);
     632            1 :     status = libspdm_get_response_end_session(spdm_context,
     633              :                                               m_libspdm_end_session_request3_size,
     634              :                                               &m_libspdm_end_session_request3,
     635              :                                               &response_size, response);
     636            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     637            1 :     assert_int_equal(response_size, sizeof(spdm_end_session_response_t));
     638            1 :     spdm_response = (void *)response;
     639            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_END_SESSION_ACK);
     640            1 :     assert_int_not_equal(spdm_context->connection_info.end_session_attributes &
     641              :                          SPDM_END_SESSION_REQUEST_ATTRIBUTES_PRESERVE_NEGOTIATED_STATE_CLEAR, 0);
     642            1 :     free(data1);
     643            1 : }
     644              : 
     645            1 : int libspdm_rsp_end_session_ack_test(void)
     646              : {
     647            1 :     const struct CMUnitTest test_cases[] = {
     648              :         /* Success Case*/
     649              :         cmocka_unit_test(rsp_end_session_ack_case1),
     650              :         /* Bad request size*/
     651              :         cmocka_unit_test(rsp_end_session_ack_case2),
     652              :         /* response_state: SPDM_RESPONSE_STATE_BUSY*/
     653              :         cmocka_unit_test(rsp_end_session_ack_case3),
     654              :         /* response_state: LIBSPDM_RESPONSE_STATE_NEED_RESYNC*/
     655              :         cmocka_unit_test(rsp_end_session_ack_case4),
     656              :         #if LIBSPDM_RESPOND_IF_READY_SUPPORT
     657              :         /* response_state: LIBSPDM_RESPONSE_STATE_NOT_READY*/
     658              :         cmocka_unit_test(rsp_end_session_ack_case5),
     659              :         #endif /* LIBSPDM_RESPOND_IF_READY_SUPPORT */
     660              :         /* connection_state Check*/
     661              :         cmocka_unit_test(rsp_end_session_ack_case6),
     662              :         /* Buffer reset*/
     663              :         cmocka_unit_test(rsp_end_session_ack_case7),
     664              :         /* Success Case with end_session_attribute set */
     665              :         cmocka_unit_test(rsp_end_session_ack_case8),
     666              :     };
     667              : 
     668            1 :     libspdm_test_context_t test_context = {
     669              :         LIBSPDM_TEST_CONTEXT_VERSION,
     670              :         false,
     671              :     };
     672              : 
     673            1 :     libspdm_setup_test_context(&test_context);
     674              : 
     675            1 :     return cmocka_run_group_tests(test_cases,
     676              :                                   libspdm_unit_test_group_setup,
     677              :                                   libspdm_unit_test_group_teardown);
     678              : }
     679              : 
     680              : #endif /* (LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP) || (LIBSPDM_ENABLE_CAPABILITY_PSK_CAP) */
        

Generated by: LCOV version 2.0-1