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

Generated by: LCOV version 2.0-1