LCOV - code coverage report
Current view: top level - unit_test/test_spdm_responder - encap_response.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 99.5 % 578 575
Test Date: 2025-06-29 08:09:00 Functions: 94.7 % 19 18

            Line data    Source code
       1              : /**
       2              :  *  Copyright Notice:
       3              :  *  Copyright 2021-2025 DMTF. All rights reserved.
       4              :  *  License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
       5              :  **/
       6              : 
       7              : #include "spdm_unit_test.h"
       8              : #include "internal/libspdm_responder_lib.h"
       9              : 
      10              : #if LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP
      11              : 
      12              : spdm_get_encapsulated_request_request_t m_libspdm_encapsulated_request_t1 = {
      13              :     {SPDM_MESSAGE_VERSION_11, SPDM_GET_ENCAPSULATED_REQUEST, 0, 0}
      14              : };
      15              : size_t m_libspdm_encapsulated_request_t1_size = sizeof(m_libspdm_encapsulated_request_t1);
      16              : 
      17              : spdm_get_encapsulated_request_request_t m_libspdm_encapsulated_request_t2 = {
      18              :     {SPDM_MESSAGE_VERSION_13, SPDM_GET_ENCAPSULATED_REQUEST, 0, 0}
      19              : };
      20              : size_t m_libspdm_encapsulated_request_t2_size = sizeof(m_libspdm_encapsulated_request_t2);
      21              : 
      22              : spdm_deliver_encapsulated_response_request_t m_libspdm_m_deliver_encapsulated_response_request_t1 =
      23              : {
      24              :     {SPDM_MESSAGE_VERSION_11, SPDM_DELIVER_ENCAPSULATED_RESPONSE, 0, 0}
      25              : };
      26              : size_t m_libspdm_m_deliver_encapsulated_response_request_t1_size =
      27              :     sizeof(m_libspdm_m_deliver_encapsulated_response_request_t1);
      28              : 
      29              : static uint8_t m_libspdm_local_certificate_chain[LIBSPDM_MAX_CERT_CHAIN_SIZE];
      30              : 
      31              : spdm_deliver_encapsulated_response_request_t m_libspdm_m_deliver_encapsulated_response_request_t2 =
      32              : {
      33              :     {SPDM_MESSAGE_VERSION_12, SPDM_DELIVER_ENCAPSULATED_RESPONSE, 0xFF, 0}
      34              : };
      35              : size_t m_libspdm_m_deliver_encapsulated_response_request_t2_size =
      36              :     sizeof(m_libspdm_m_deliver_encapsulated_response_request_t2);
      37              : 
      38              : #if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT)
      39              : 
      40            1 : void libspdm_test_get_response_encapsulated_request_case1(void **State)
      41              : {
      42              :     libspdm_return_t status;
      43              :     libspdm_test_context_t *spdm_test_context;
      44              :     spdm_encapsulated_request_response_t *spdm_response_requester;
      45              :     libspdm_context_t *spdm_context;
      46              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
      47              :     size_t data_size;
      48              :     void *data;
      49              :     size_t response_size;
      50              : 
      51            1 :     spdm_test_context = *State;
      52            1 :     spdm_context = spdm_test_context->spdm_context;
      53            1 :     spdm_test_context->case_id = 0x1;
      54              : 
      55            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
      56              : 
      57            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
      58            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
      59            1 :     spdm_context->encap_context.request_op_code_count =
      60              :         LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
      61            1 :     spdm_context->encap_context.current_request_op_code = 0;
      62            1 :     spdm_context->encap_context.request_op_code_sequence[0] = SPDM_GET_DIGESTS;
      63            1 :     spdm_context->encap_context.request_id = 0;
      64              : 
      65            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
      66            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
      67              : 
      68            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
      69            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
      70            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
      71              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
      72            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
      73              :                                                     m_libspdm_use_asym_algo, &data,
      74              :                                                     &data_size,
      75              :                                                     NULL, NULL);
      76            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
      77            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data;
      78            1 :     spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
      79            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
      80            1 :     libspdm_reset_message_b(spdm_context);
      81              : 
      82            1 :     response_size = sizeof(response);
      83            1 :     status = libspdm_get_response_encapsulated_request(spdm_context,
      84              :                                                        m_libspdm_encapsulated_request_t1_size,
      85              :                                                        &m_libspdm_encapsulated_request_t1,
      86              :                                                        &response_size,
      87              :                                                        response);
      88              : 
      89            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
      90            1 :     assert_int_equal(response_size,
      91              :                      sizeof(spdm_encapsulated_request_response_t) + sizeof(spdm_digest_response_t));
      92            1 :     spdm_response_requester = (void *)response;
      93            1 :     assert_int_equal(spdm_response_requester->header.request_response_code,
      94              :                      SPDM_ENCAPSULATED_REQUEST);
      95            1 :     assert_int_equal(spdm_response_requester->header.param1,
      96              :                      0x1);
      97            1 :     assert_int_equal(spdm_response_requester->header.param2, 0);
      98            1 :     free(data);
      99            1 : }
     100              : 
     101            1 : void libspdm_test_get_response_encapsulated_request_case2(void **State)
     102              : {
     103              :     libspdm_return_t status;
     104              :     libspdm_test_context_t *spdm_test_context;
     105              :     spdm_encapsulated_request_response_t *spdm_response_requester;
     106              :     libspdm_context_t *spdm_context;
     107              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     108              :     size_t data_size;
     109              :     void *data;
     110              :     size_t response_size;
     111              : 
     112            1 :     spdm_test_context = *State;
     113            1 :     spdm_context = spdm_test_context->spdm_context;
     114            1 :     spdm_test_context->case_id = 0x2;
     115              : 
     116            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
     117            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
     118            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
     119            1 :     spdm_context->encap_context.request_op_code_count =
     120              :         LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
     121            1 :     spdm_context->encap_context.current_request_op_code = 0;
     122            1 :     spdm_context->encap_context.request_op_code_sequence[0] = SPDM_GET_CERTIFICATE;
     123            1 :     spdm_context->encap_context.request_id = 0;
     124              : 
     125            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     126            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
     127            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     128              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     129            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     130              :                                                     m_libspdm_use_asym_algo, &data,
     131              :                                                     &data_size,
     132              :                                                     NULL, NULL);
     133            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
     134            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data;
     135            1 :     spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
     136            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     137            1 :     libspdm_reset_message_b(spdm_context);
     138              : 
     139            1 :     response_size = sizeof(response);
     140              : 
     141            1 :     status = libspdm_get_response_encapsulated_request(spdm_context,
     142              :                                                        m_libspdm_encapsulated_request_t1_size,
     143              :                                                        &m_libspdm_encapsulated_request_t1,
     144              :                                                        &response_size,
     145              :                                                        response);
     146              : 
     147            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     148            1 :     assert_int_equal(response_size,
     149              :                      sizeof(spdm_encapsulated_request_response_t) +
     150              :                      sizeof(spdm_certificate_response_t));
     151            1 :     spdm_response_requester = (void *)response;
     152            1 :     assert_int_equal(spdm_response_requester->header.request_response_code,
     153              :                      SPDM_ENCAPSULATED_REQUEST);
     154            1 :     assert_int_equal(spdm_response_requester->header.param1,
     155              :                      0x1);
     156            1 :     assert_int_equal(spdm_response_requester->header.param2, 0);
     157            1 :     free(data);
     158            1 : }
     159              : 
     160            1 : void libspdm_test_get_response_encapsulated_request_case3(void **State)
     161              : {
     162              :     libspdm_return_t status;
     163              :     libspdm_test_context_t *spdm_test_context;
     164              :     spdm_encapsulated_request_response_t *spdm_response_requester;
     165              :     libspdm_context_t *spdm_context;
     166              :     size_t response_size;
     167              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     168              :     uint8_t m_local_certificate_chain[LIBSPDM_MAX_CERT_CHAIN_SIZE];
     169              : 
     170            1 :     spdm_test_context = *State;
     171            1 :     spdm_context = spdm_test_context->spdm_context;
     172            1 :     spdm_test_context->case_id = 0x3;
     173              : 
     174            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
     175            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
     176            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
     177              : 
     178            1 :     spdm_context->encap_context.current_request_op_code = 0;
     179            1 :     spdm_context->encap_context.request_id = 0;
     180            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     181            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
     182            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     183            1 :     spdm_context->local_context.local_cert_chain_provision[0] = m_local_certificate_chain;
     184            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
     185              :         sizeof(m_local_certificate_chain);
     186            1 :     libspdm_set_mem(m_local_certificate_chain, sizeof(m_local_certificate_chain), (uint8_t)(0xFF));
     187              : 
     188            1 :     response_size = sizeof(response);
     189            1 :     status = libspdm_get_response_encapsulated_request(spdm_context,
     190              :                                                        m_libspdm_encapsulated_request_t1_size,
     191              :                                                        &m_libspdm_encapsulated_request_t1,
     192              :                                                        &response_size,
     193              :                                                        response);
     194              : 
     195            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     196            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     197            1 :     spdm_response_requester = (void *)response;
     198            1 :     assert_int_equal(spdm_response_requester->header.request_response_code,
     199              :                      SPDM_ERROR);
     200            1 :     assert_int_equal(spdm_response_requester->header.param1,
     201              :                      SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
     202            1 :     assert_int_equal(spdm_response_requester->header.param2, 0);
     203            1 : }
     204              : 
     205            1 : void libspdm_test_get_response_encapsulated_request_case4(void **State)
     206              : {
     207              :     libspdm_return_t status;
     208              :     libspdm_test_context_t *spdm_test_context;
     209              :     spdm_encapsulated_request_response_t *spdm_response_requester;
     210              :     libspdm_context_t *spdm_context;
     211              :     size_t response_size;
     212              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     213              :     uint8_t m_local_certificate_chain[LIBSPDM_MAX_CERT_CHAIN_SIZE];
     214              : 
     215            1 :     spdm_test_context = *State;
     216            1 :     spdm_context = spdm_test_context->spdm_context;
     217            1 :     spdm_test_context->case_id = 0x4;
     218              : 
     219            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NEED_RESYNC;
     220            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
     221            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
     222              : 
     223            1 :     spdm_context->encap_context.current_request_op_code = SPDM_GET_DIGESTS;
     224              : 
     225            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     226            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
     227            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     228            1 :     spdm_context->local_context.local_cert_chain_provision[0] = m_local_certificate_chain;
     229            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
     230              :         sizeof(m_local_certificate_chain);
     231            1 :     libspdm_set_mem(m_local_certificate_chain, sizeof(m_local_certificate_chain), (uint8_t)(0xFF));
     232              : 
     233            1 :     response_size = sizeof(response);
     234            1 :     status = libspdm_get_response_encapsulated_request(spdm_context,
     235              :                                                        m_libspdm_encapsulated_request_t1_size,
     236              :                                                        &m_libspdm_encapsulated_request_t1,
     237              :                                                        &response_size,
     238              :                                                        response);
     239            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     240            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     241            1 :     spdm_response_requester = (void *)response;
     242            1 :     assert_int_equal(spdm_response_requester->header.request_response_code,
     243              :                      SPDM_ERROR);
     244            1 :     assert_int_equal(spdm_response_requester->header.param1,
     245              :                      SPDM_ERROR_CODE_REQUEST_RESYNCH);
     246            1 :     assert_int_equal(spdm_response_requester->header.param2, 0);
     247            1 : }
     248              : #endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT) */
     249              : #if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_CHALLENGE_SUPPORT)
     250            1 : void libspdm_test_get_response_encapsulated_request_case5(void **State)
     251              : {
     252              :     libspdm_return_t status;
     253              :     libspdm_test_context_t *spdm_test_context;
     254              :     spdm_encapsulated_request_response_t *spdm_response_requester;
     255              :     libspdm_context_t *spdm_context;
     256              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     257              :     size_t data_size;
     258              :     void *data;
     259              :     size_t response_size;
     260              : 
     261            1 :     spdm_test_context = *State;
     262            1 :     spdm_context = spdm_test_context->spdm_context;
     263            1 :     spdm_test_context->case_id = 0x5;
     264              : 
     265            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
     266            1 :     spdm_context->connection_info.capability.flags = 0;
     267            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
     268            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
     269            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
     270            1 :     spdm_context->encap_context.request_op_code_count =
     271              :         LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
     272            1 :     spdm_context->encap_context.current_request_op_code = 0;
     273            1 :     spdm_context->encap_context.request_op_code_sequence[0] = SPDM_CHALLENGE;
     274            1 :     spdm_context->encap_context.request_id = 0;
     275              : 
     276            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     277            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
     278            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     279              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     280            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     281              :                                                     m_libspdm_use_asym_algo, &data,
     282              :                                                     &data_size,
     283              :                                                     NULL, NULL);
     284            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
     285            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data;
     286            1 :     spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
     287            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     288            1 :     libspdm_reset_message_b(spdm_context);
     289              : 
     290            1 :     response_size = sizeof(response);
     291            1 :     status = libspdm_get_response_encapsulated_request(spdm_context,
     292              :                                                        m_libspdm_encapsulated_request_t1_size,
     293              :                                                        &m_libspdm_encapsulated_request_t1,
     294              :                                                        &response_size,
     295              :                                                        response);
     296              : 
     297            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     298            1 :     assert_int_equal(response_size,
     299              :                      sizeof(spdm_encapsulated_request_response_t) +
     300              :                      sizeof(spdm_challenge_request_t));
     301            1 :     spdm_response_requester = (void *)response;
     302            1 :     assert_int_equal(spdm_response_requester->header.request_response_code,
     303              :                      SPDM_ENCAPSULATED_REQUEST);
     304            1 :     assert_int_equal(spdm_response_requester->header.param1,
     305              :                      0x1);
     306            1 :     assert_int_equal(spdm_response_requester->header.param2, 0);
     307            1 :     free(data);
     308            1 : }
     309              : 
     310              : #endif /* LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_CHALLENGE_SUPPORT) */
     311              : 
     312            1 : void libspdm_test_get_response_encapsulated_request_case6(void **State)
     313              : {
     314              :     libspdm_return_t status;
     315              :     libspdm_test_context_t *spdm_test_context;
     316              :     spdm_encapsulated_request_response_t *spdm_response_requester;
     317              :     libspdm_context_t *spdm_context;
     318              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     319              :     size_t data_size;
     320              :     void *data;
     321              :     size_t response_size;
     322              :     uint32_t session_id;
     323              :     libspdm_session_info_t *session_info;
     324              : 
     325            1 :     spdm_test_context = *State;
     326            1 :     spdm_context = spdm_test_context->spdm_context;
     327            1 :     spdm_test_context->case_id = 0x6;
     328              : 
     329            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
     330            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     331            1 :     spdm_context->connection_info.capability.flags |=
     332              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP;
     333            1 :     spdm_context->local_context.capability.flags |=
     334              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_UPD_CAP;
     335            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
     336            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
     337            1 :     spdm_context->encap_context.request_op_code_count =
     338              :         LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
     339            1 :     spdm_context->encap_context.current_request_op_code = 0;
     340            1 :     spdm_context->encap_context.request_op_code_sequence[0] = SPDM_KEY_UPDATE;
     341            1 :     spdm_context->encap_context.request_id = 0;
     342              : 
     343            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     344            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
     345            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     346              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     347            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     348              :                                                     m_libspdm_use_asym_algo, &data,
     349              :                                                     &data_size,
     350              :                                                     NULL, NULL);
     351            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
     352            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data;
     353            1 :     spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
     354            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     355            1 :     libspdm_reset_message_b(spdm_context);
     356              : 
     357            1 :     session_id = 0xFFFFFFFF;
     358            1 :     spdm_context->latest_session_id = session_id;
     359            1 :     spdm_context->last_spdm_request_session_id_valid = true;
     360            1 :     spdm_context->last_spdm_request_session_id = session_id;
     361            1 :     session_info = &spdm_context->session_info[0];
     362            1 :     libspdm_session_info_init(spdm_context, session_info, session_id, true);
     363            1 :     libspdm_secured_message_set_session_state(session_info->secured_message_context,
     364              :                                               LIBSPDM_SESSION_STATE_ESTABLISHED);
     365              : 
     366            1 :     response_size = sizeof(response);
     367            1 :     status = libspdm_get_response_encapsulated_request(spdm_context,
     368              :                                                        m_libspdm_encapsulated_request_t1_size,
     369              :                                                        &m_libspdm_encapsulated_request_t1,
     370              :                                                        &response_size,
     371              :                                                        response);
     372              : 
     373            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     374            1 :     assert_int_equal(response_size,
     375              :                      sizeof(spdm_encapsulated_request_response_t) +
     376              :                      sizeof(spdm_key_update_response_t));
     377            1 :     spdm_response_requester = (void *)response;
     378            1 :     assert_int_equal(spdm_response_requester->header.request_response_code,
     379              :                      SPDM_ENCAPSULATED_REQUEST);
     380            1 :     assert_int_equal(spdm_response_requester->header.param1,
     381              :                      0x1);
     382            1 :     assert_int_equal(spdm_response_requester->header.param2, 0);
     383            1 :     free(data);
     384            1 : }
     385              : 
     386            1 : void libspdm_test_get_response_encapsulated_request_case7(void **State)
     387              : {
     388              :     libspdm_return_t status;
     389              :     libspdm_test_context_t *spdm_test_context;
     390              :     spdm_error_response_t *spdm_response_requester;
     391              :     libspdm_context_t *spdm_context;
     392              :     size_t response_size;
     393              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     394              :     uint8_t m_local_certificate_chain[LIBSPDM_MAX_CERT_CHAIN_SIZE];
     395              : 
     396            1 :     spdm_test_context = *State;
     397            1 :     spdm_context = spdm_test_context->spdm_context;
     398            1 :     spdm_test_context->case_id = 0x7;
     399              : 
     400            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
     401              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     402            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
     403            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
     404            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
     405              : 
     406            1 :     spdm_context->encap_context.current_request_op_code = 0;
     407            1 :     spdm_context->encap_context.request_id = 0;
     408            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     409            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
     410            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     411            1 :     spdm_context->local_context.local_cert_chain_provision[0] = m_local_certificate_chain;
     412            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] =
     413              :         sizeof(m_local_certificate_chain);
     414            1 :     libspdm_set_mem(m_local_certificate_chain, sizeof(m_local_certificate_chain), 0xFF);
     415              : 
     416            1 :     response_size = sizeof(response);
     417            1 :     status = libspdm_get_response_encapsulated_request(spdm_context,
     418              :                                                        m_libspdm_encapsulated_request_t1_size,
     419              :                                                        &m_libspdm_encapsulated_request_t1,
     420              :                                                        &response_size,
     421              :                                                        response);
     422              : 
     423            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     424            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     425            1 :     spdm_response_requester = (void *)response;
     426            1 :     assert_int_equal(spdm_response_requester->header.request_response_code, SPDM_ERROR);
     427            1 :     assert_int_equal(spdm_response_requester->header.param1, SPDM_ERROR_CODE_NO_PENDING_REQUESTS);
     428            1 :     assert_int_equal(spdm_response_requester->header.param2, 0);
     429            1 : }
     430              : 
     431              : #if LIBSPDM_SEND_GET_ENDPOINT_INFO_SUPPORT
     432            0 : libspdm_return_t get_endpoint_info_callback_encap_response (
     433              :     void *spdm_context,
     434              :     uint8_t subcode,
     435              :     uint8_t param2,
     436              :     uint8_t request_attributes,
     437              :     uint32_t endpoint_info_size,
     438              :     const void *endpoint_info)
     439              : {
     440              :     /* should never reach here */
     441            0 :     LIBSPDM_ASSERT (0);
     442            0 :     return LIBSPDM_STATUS_UNSUPPORTED_CAP;
     443              : }
     444              : 
     445            1 : void libspdm_test_get_response_encapsulated_request_case8(void **State)
     446              : {
     447              :     libspdm_return_t status;
     448              :     libspdm_test_context_t *spdm_test_context;
     449              :     spdm_encapsulated_request_response_t *spdm_response_requester;
     450              :     libspdm_context_t *spdm_context;
     451              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     452              :     size_t data_size;
     453              :     void *data;
     454              :     size_t response_size;
     455              :     uint32_t session_id;
     456              :     libspdm_session_info_t *session_info;
     457              : 
     458            1 :     spdm_test_context = *State;
     459            1 :     spdm_context = spdm_test_context->spdm_context;
     460            1 :     spdm_test_context->case_id = 0x6;
     461              : 
     462            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
     463            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     464            1 :     spdm_context->connection_info.capability.flags |=
     465              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_EP_INFO_CAP_SIG;
     466            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
     467            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
     468            1 :     spdm_context->encap_context.request_op_code_count =
     469              :         LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
     470            1 :     spdm_context->encap_context.current_request_op_code = 0;
     471            1 :     spdm_context->encap_context.request_op_code_sequence[0] = SPDM_GET_ENDPOINT_INFO;
     472            1 :     spdm_context->encap_context.request_id = 0;
     473              : 
     474            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     475            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
     476            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
     477              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     478            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     479              :                                                     m_libspdm_use_req_asym_algo, &data,
     480              :                                                     &data_size,
     481              :                                                     NULL, NULL);
     482            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
     483            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data;
     484            1 :     spdm_context->connection_info.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
     485            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     486            1 :     spdm_context->get_endpoint_info_callback = get_endpoint_info_callback_encap_response;
     487              : 
     488              : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     489              :     spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
     490              :         data_size;
     491              :     libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
     492              :                      sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
     493              :                      data, data_size);
     494              : #else
     495            1 :     libspdm_hash_all(
     496              :         spdm_context->connection_info.algorithm.base_hash_algo,
     497              :         data, data_size,
     498            1 :         spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
     499            1 :     spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
     500            1 :         libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
     501            1 :     libspdm_get_leaf_cert_public_key_from_cert_chain(
     502              :         spdm_context->connection_info.algorithm.base_hash_algo,
     503              :         spdm_context->connection_info.algorithm.base_asym_algo,
     504              :         data, data_size,
     505              :         &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
     506              : #endif
     507              : 
     508            1 :     session_id = 0xFFFFFFFF;
     509            1 :     spdm_context->latest_session_id = session_id;
     510            1 :     spdm_context->last_spdm_request_session_id_valid = true;
     511            1 :     spdm_context->last_spdm_request_session_id = session_id;
     512            1 :     session_info = &spdm_context->session_info[0];
     513            1 :     libspdm_session_info_init(spdm_context, session_info, session_id, true);
     514            1 :     libspdm_secured_message_set_session_state(session_info->secured_message_context,
     515              :                                               LIBSPDM_SESSION_STATE_ESTABLISHED);
     516              : 
     517            1 :     libspdm_reset_message_a(spdm_context);
     518            1 :     libspdm_reset_message_encap_e(spdm_context, session_info);
     519              : 
     520            1 :     response_size = sizeof(response);
     521            1 :     status = libspdm_get_response_encapsulated_request(spdm_context,
     522              :                                                        m_libspdm_encapsulated_request_t2_size,
     523              :                                                        &m_libspdm_encapsulated_request_t2,
     524              :                                                        &response_size,
     525              :                                                        response);
     526              : 
     527            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     528              : 
     529            1 :     assert_int_equal(response_size,
     530              :                      sizeof(spdm_encapsulated_request_response_t) +
     531              :                      sizeof(spdm_get_endpoint_info_request_t) +
     532              :                      SPDM_NONCE_SIZE);
     533            1 :     spdm_response_requester = (void *)response;
     534            1 :     assert_int_equal(spdm_response_requester->header.request_response_code,
     535              :                      SPDM_ENCAPSULATED_REQUEST);
     536            1 :     assert_int_equal(spdm_response_requester->header.param1,
     537              :                      0x1);
     538            1 :     assert_int_equal(spdm_response_requester->header.param2, 0);
     539            1 :     free(data);
     540            1 : }
     541              : #endif /* LIBSPDM_SEND_GET_ENDPOINT_INFO_SUPPORT */
     542              : 
     543            1 : void libspdm_test_get_response_encapsulated_response_ack_case1(void **State)
     544              : {
     545              :     libspdm_return_t status;
     546              :     libspdm_test_context_t *spdm_test_context;
     547              :     libspdm_context_t *spdm_context;
     548              :     spdm_deliver_encapsulated_response_request_t *spdm_response_requester;
     549              :     spdm_digest_response_t *spdm_response_requester_digest;
     550              :     uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
     551              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     552              :     size_t spdm_response_requester_size;
     553              :     size_t spdm_response_requester_digest_size;
     554              :     size_t data_size;
     555              :     size_t response_size;
     556              :     uint8_t *digest;
     557              :     void *data;
     558              : 
     559            1 :     spdm_test_context = *State;
     560            1 :     spdm_context = spdm_test_context->spdm_context;
     561              : 
     562            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
     563            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
     564            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
     565            1 :     spdm_context->encap_context.request_op_code_count =
     566              :         LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
     567              : 
     568            1 :     spdm_context->encap_context.current_request_op_code = SPDM_GET_DIGESTS;
     569            1 :     spdm_context->encap_context.request_op_code_sequence[0] = SPDM_GET_DIGESTS;
     570              : 
     571            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     572            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
     573            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     574              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     575            1 :     spdm_context->encap_context.request_id = 0;
     576            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     577              :                                                     m_libspdm_use_asym_algo, &data,
     578              :                                                     &data_size,
     579              :                                                     NULL, NULL);
     580            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
     581            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data;
     582            1 :     spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
     583            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     584            1 :     libspdm_reset_message_b(spdm_context);
     585              : 
     586            1 :     spdm_response_requester_size = sizeof(spdm_digest_response_t) +
     587            1 :                                    libspdm_get_hash_size(m_libspdm_use_hash_algo) +
     588              :                                    sizeof(spdm_deliver_encapsulated_response_request_t);
     589              : 
     590            1 :     spdm_response_requester = (void *)temp_buf;
     591            1 :     libspdm_copy_mem(spdm_response_requester,
     592              :                      sizeof(temp_buf),
     593              :                      &m_libspdm_m_deliver_encapsulated_response_request_t1,
     594              :                      m_libspdm_m_deliver_encapsulated_response_request_t1_size);
     595              : 
     596            1 :     spdm_response_requester_digest_size = sizeof(spdm_digest_response_t) +
     597            1 :                                           libspdm_get_hash_size(m_libspdm_use_hash_algo);
     598            1 :     spdm_response_requester_digest =
     599              :         (void *)(temp_buf + sizeof(spdm_deliver_encapsulated_response_request_t));
     600            1 :     spdm_response_requester_digest->header.spdm_version = SPDM_MESSAGE_VERSION_11;
     601            1 :     spdm_response_requester_digest->header.param1 = 0;
     602            1 :     spdm_response_requester_digest->header.request_response_code = SPDM_DIGESTS;
     603            1 :     spdm_response_requester_digest->header.param2 = 0;
     604              : 
     605            1 :     digest = (void *)(spdm_response_requester_digest + 1);
     606            1 :     libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
     607              :                      sizeof(m_libspdm_local_certificate_chain), &digest[0]);
     608            1 :     spdm_response_requester_digest->header.param2 |= (0x01 << 0);
     609              : 
     610            1 :     libspdm_set_mem(m_libspdm_local_certificate_chain,
     611              :                     sizeof(m_libspdm_local_certificate_chain),
     612              :                     (uint8_t)(0xFF));
     613              : 
     614            1 :     libspdm_copy_mem(spdm_response_requester + 1,
     615              :                      spdm_response_requester_digest_size,
     616              :                      spdm_response_requester_digest,
     617              :                      spdm_response_requester_digest_size);
     618              : 
     619            1 :     response_size = sizeof(response);
     620            1 :     status = libspdm_get_response_encapsulated_response_ack(spdm_context,
     621              :                                                             spdm_response_requester_size,
     622              :                                                             spdm_response_requester, &response_size,
     623              :                                                             response);
     624            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     625            1 :     free(data);
     626            1 : }
     627              : 
     628            1 : void libspdm_test_get_response_encapsulated_response_ack_case2(void **State)
     629              : {
     630              :     libspdm_return_t status;
     631              :     libspdm_test_context_t *spdm_test_context;
     632              :     libspdm_context_t *spdm_context;
     633              :     spdm_deliver_encapsulated_response_request_t *spdm_response_requester;
     634              :     spdm_certificate_response_t *spdm_response_requester_certificate;
     635              :     uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
     636              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     637              :     size_t spdm_response_requester_size;
     638              :     size_t data_size;
     639              :     size_t response_size;
     640              :     void *data;
     641              :     uint16_t portion_length;
     642              :     uint16_t remainder_length;
     643              :     static size_t calling_index = 0;
     644              : 
     645              :     static void *libspdm_local_certificate_chain;
     646              :     static size_t libspdm_local_certificate_chain_size;
     647              : 
     648            1 :     spdm_test_context = *State;
     649            1 :     spdm_context = spdm_test_context->spdm_context;
     650              : 
     651            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
     652            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
     653            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
     654            1 :     spdm_context->encap_context.request_op_code_count =
     655              :         LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
     656              : 
     657            1 :     spdm_context->encap_context.current_request_op_code = SPDM_GET_CERTIFICATE;
     658            1 :     spdm_context->encap_context.request_op_code_sequence[0] = SPDM_GET_CERTIFICATE;
     659              : 
     660            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     661            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
     662            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     663              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     664            1 :     spdm_context->encap_context.request_id = 0;
     665            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     666              :                                                     m_libspdm_use_asym_algo, &data,
     667              :                                                     &data_size,
     668              :                                                     NULL, NULL);
     669            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
     670            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data;
     671            1 :     spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
     672            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     673            1 :     libspdm_reset_message_b(spdm_context);
     674              : 
     675            1 :     spdm_response_requester = (void *)temp_buf;
     676            1 :     libspdm_copy_mem(spdm_response_requester,
     677              :                      sizeof(temp_buf),
     678              :                      &m_libspdm_m_deliver_encapsulated_response_request_t1,
     679              :                      m_libspdm_m_deliver_encapsulated_response_request_t1_size);
     680              : 
     681            1 :     spdm_response_requester_certificate =
     682              :         (void *)(temp_buf + sizeof(spdm_deliver_encapsulated_response_request_t));
     683              : 
     684            1 :     libspdm_read_responder_public_certificate_chain(
     685              :         m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
     686              :         &libspdm_local_certificate_chain,
     687              :         &libspdm_local_certificate_chain_size, NULL, NULL);
     688              : 
     689            1 :     portion_length = LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN;
     690            1 :     remainder_length =
     691            1 :         (uint16_t)(libspdm_local_certificate_chain_size -
     692              :                    LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN *
     693            1 :                    (calling_index + 1));
     694              : 
     695            1 :     spdm_response_requester_certificate->header.spdm_version = SPDM_MESSAGE_VERSION_11;
     696            1 :     spdm_response_requester_certificate->header.request_response_code = SPDM_CERTIFICATE;
     697            1 :     spdm_response_requester_certificate->header.param1 = 0;
     698            1 :     spdm_response_requester_certificate->header.param2 = 0;
     699            1 :     spdm_response_requester_certificate->portion_length = portion_length;
     700            1 :     spdm_response_requester_certificate->remainder_length = remainder_length;
     701              : 
     702            1 :     libspdm_copy_mem(spdm_response_requester_certificate + 1,
     703              :                      sizeof(temp_buf) - sizeof(*spdm_response_requester_certificate),
     704            1 :                      (uint8_t *)libspdm_local_certificate_chain +
     705            1 :                      LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN * calling_index,
     706              :                      portion_length);
     707              : 
     708            1 :     free(libspdm_local_certificate_chain);
     709              : 
     710            1 :     response_size = sizeof(response);
     711            1 :     spdm_response_requester_size = sizeof(spdm_certificate_response_t) + portion_length +
     712              :                                    sizeof(spdm_deliver_encapsulated_response_request_t);
     713            1 :     status = libspdm_get_response_encapsulated_response_ack(spdm_context,
     714              :                                                             spdm_response_requester_size,
     715              :                                                             spdm_response_requester, &response_size,
     716              :                                                             response);
     717            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     718            1 :     free(data);
     719            1 : }
     720              : 
     721            1 : void libspdm_test_get_response_encapsulated_response_ack_case3(void **State)
     722              : {
     723              :     libspdm_return_t status;
     724              :     libspdm_test_context_t *spdm_test_context;
     725              :     libspdm_context_t *spdm_context;
     726              :     spdm_deliver_encapsulated_response_request_t *spdm_response_requester;
     727              :     spdm_key_update_response_t *spdm_response_requester_key_update;
     728              :     uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
     729              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     730              :     size_t spdm_response_requester_size;
     731              :     size_t data_size;
     732              :     size_t response_size;
     733              :     void *data;
     734              :     uint32_t session_id;
     735              :     libspdm_session_info_t *session_info;
     736              : 
     737            1 :     spdm_test_context = *State;
     738            1 :     spdm_context = spdm_test_context->spdm_context;
     739              : 
     740            1 :     spdm_context->last_spdm_request_session_id_valid = true;
     741            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
     742            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
     743            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
     744            1 :     spdm_context->encap_context.request_op_code_count =
     745              :         LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
     746              : 
     747            1 :     spdm_context->encap_context.current_request_op_code = SPDM_KEY_UPDATE;
     748            1 :     spdm_context->encap_context.request_op_code_sequence[0] = SPDM_KEY_UPDATE;
     749              : 
     750            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     751            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
     752            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     753              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     754            1 :     spdm_context->encap_context.request_id = 0;
     755            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     756              :                                                     m_libspdm_use_asym_algo, &data,
     757              :                                                     &data_size,
     758              :                                                     NULL, NULL);
     759            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
     760            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data;
     761            1 :     spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
     762            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     763              : 
     764            1 :     libspdm_reset_message_b(spdm_context);
     765              : 
     766            1 :     session_id = 0xFFFFFFFF;
     767            1 :     spdm_context->latest_session_id = session_id;
     768            1 :     spdm_context->last_spdm_request_session_id_valid = true;
     769            1 :     spdm_context->last_spdm_request_session_id = session_id;
     770            1 :     session_info = &spdm_context->session_info[0];
     771            1 :     libspdm_session_info_init(spdm_context, session_info, session_id, true);
     772            1 :     libspdm_secured_message_set_session_state(session_info->secured_message_context,
     773              :                                               LIBSPDM_SESSION_STATE_ESTABLISHED);
     774              : 
     775            1 :     spdm_context->encap_context.last_encap_request_header.spdm_version = SPDM_MESSAGE_VERSION_11;
     776            1 :     spdm_context->encap_context.last_encap_request_header.request_response_code =
     777              :         SPDM_KEY_UPDATE_ACK;
     778            1 :     spdm_context->encap_context.last_encap_request_header.param1 =
     779              :         SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
     780            1 :     spdm_context->encap_context.last_encap_request_header.param2 = 0;
     781              : 
     782            1 :     spdm_response_requester = (void *)temp_buf;
     783            1 :     libspdm_copy_mem(spdm_response_requester,
     784              :                      sizeof(temp_buf),
     785              :                      &m_libspdm_m_deliver_encapsulated_response_request_t1,
     786              :                      m_libspdm_m_deliver_encapsulated_response_request_t1_size);
     787              : 
     788            1 :     spdm_response_requester_key_update =
     789              :         (void *)(temp_buf + sizeof(spdm_deliver_encapsulated_response_request_t));
     790              : 
     791            1 :     spdm_response_requester_key_update->header.spdm_version = SPDM_MESSAGE_VERSION_11;
     792            1 :     spdm_response_requester_key_update->header.request_response_code =
     793              :         SPDM_KEY_UPDATE_ACK;
     794            1 :     spdm_response_requester_key_update->header.param1 =
     795              :         SPDM_KEY_UPDATE_OPERATIONS_TABLE_UPDATE_KEY;
     796            1 :     spdm_response_requester_key_update->header.param2 = 0;
     797              : 
     798            1 :     response_size = sizeof(response);
     799            1 :     spdm_response_requester_size = sizeof(spdm_key_update_response_t) +
     800              :                                    sizeof(spdm_deliver_encapsulated_response_request_t);
     801            1 :     status = libspdm_get_response_encapsulated_response_ack(spdm_context,
     802              :                                                             spdm_response_requester_size,
     803              :                                                             spdm_response_requester, &response_size,
     804              :                                                             response);
     805            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     806            1 :     free(data);
     807            1 : }
     808              : 
     809            1 : void libspdm_test_get_response_encapsulated_response_ack_case4(void **State)
     810              : {
     811              :     libspdm_return_t status;
     812              :     spdm_encapsulated_request_response_t *spdm_response_requester;
     813              :     libspdm_test_context_t *spdm_test_context;
     814              :     libspdm_context_t *spdm_context;
     815              :     size_t response_size;
     816            1 :     spdm_test_context = *State;
     817            1 :     spdm_context = spdm_test_context->spdm_context;
     818              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     819              : 
     820            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
     821            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
     822            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
     823            1 :     spdm_context->encap_context.request_op_code_count =
     824              :         LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
     825            1 :     spdm_context->encap_context.current_request_op_code = 0;
     826            1 :     libspdm_reset_message_b(spdm_context);
     827              : 
     828            1 :     response_size = sizeof(response);
     829            1 :     status = libspdm_get_response_encapsulated_response_ack(spdm_context,
     830              :                                                             m_libspdm_m_deliver_encapsulated_response_request_t1_size,
     831              :                                                             &m_libspdm_m_deliver_encapsulated_response_request_t1,
     832              :                                                             &response_size,
     833              :                                                             response);
     834            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     835            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     836            1 :     spdm_response_requester = (void *)response;
     837            1 :     assert_int_equal(spdm_response_requester->header.request_response_code,
     838              :                      SPDM_ERROR);
     839            1 :     assert_int_equal(spdm_response_requester->header.param1,
     840              :                      SPDM_ERROR_CODE_INVALID_REQUEST);
     841            1 :     assert_int_equal(spdm_response_requester->header.param2, 0);
     842            1 : }
     843              : 
     844            1 : void libspdm_test_get_response_encapsulated_response_ack_case5(void **State)
     845              : {
     846              :     libspdm_return_t status;
     847              :     spdm_encapsulated_request_response_t *spdm_response_requester;
     848              :     libspdm_test_context_t *spdm_test_context;
     849              :     libspdm_context_t *spdm_context;
     850              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     851              :     size_t response_size;
     852            1 :     spdm_test_context = *State;
     853            1 :     spdm_context = spdm_test_context->spdm_context;
     854              : 
     855            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
     856            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
     857            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
     858            1 :     spdm_context->encap_context.request_op_code_count =
     859              :         LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
     860            1 :     spdm_context->encap_context.current_request_op_code = 0;
     861              : 
     862            1 :     response_size = sizeof(response);
     863            1 :     status = libspdm_get_response_encapsulated_response_ack(spdm_context,
     864              :                                                             m_libspdm_m_deliver_encapsulated_response_request_t1_size,
     865              :                                                             &m_libspdm_m_deliver_encapsulated_response_request_t1,
     866              :                                                             &response_size,
     867              :                                                             response);
     868            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     869            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     870            1 :     spdm_response_requester = (void *)response;
     871            1 :     assert_int_equal(spdm_response_requester->header.request_response_code,
     872              :                      SPDM_ERROR);
     873            1 :     assert_int_equal(spdm_response_requester->header.param1,
     874              :                      SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
     875            1 :     assert_int_equal(spdm_response_requester->header.param2, 0);
     876            1 : }
     877              : 
     878            1 : void libspdm_test_get_response_encapsulated_response_ack_case6(void **State)
     879              : {
     880              :     libspdm_return_t status;
     881              :     spdm_encapsulated_request_response_t *spdm_response_requester;
     882              :     libspdm_test_context_t *spdm_test_context;
     883              :     libspdm_context_t *spdm_context;
     884              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     885              :     size_t response_size;
     886              :     size_t data_size;
     887              :     void *data;
     888              : 
     889            1 :     spdm_test_context = *State;
     890            1 :     spdm_context = spdm_test_context->spdm_context;
     891              : 
     892            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NEED_RESYNC;
     893            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     894            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
     895            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
     896            1 :     spdm_context->encap_context.request_op_code_count =
     897              :         LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
     898              : 
     899            1 :     status = libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     900              :                                                              m_libspdm_use_asym_algo, &data,
     901              :                                                              &data_size,
     902              :                                                              NULL, NULL);
     903            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
     904            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data;
     905            1 :     spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
     906            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     907              : 
     908            1 :     response_size = sizeof(response);
     909            1 :     status = libspdm_get_response_encapsulated_response_ack(spdm_context,
     910              :                                                             m_libspdm_m_deliver_encapsulated_response_request_t1_size,
     911              :                                                             &m_libspdm_m_deliver_encapsulated_response_request_t1,
     912              :                                                             &response_size,
     913              :                                                             response);
     914            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     915            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     916            1 :     spdm_response_requester = (void *)response;
     917            1 :     assert_int_equal(spdm_response_requester->header.request_response_code,
     918              :                      SPDM_ERROR);
     919            1 :     assert_int_equal(spdm_response_requester->header.param1,
     920              :                      SPDM_ERROR_CODE_REQUEST_RESYNCH);
     921            1 :     assert_int_equal(spdm_response_requester->header.param2, 0);
     922            1 : }
     923              : 
     924            1 : void libspdm_test_get_response_encapsulated_response_ack_case7(void **State)
     925              : {
     926              :     libspdm_return_t status;
     927              :     libspdm_test_context_t *spdm_test_context;
     928              :     libspdm_context_t *spdm_context;
     929              :     spdm_deliver_encapsulated_response_request_t *spdm_response_requester;
     930              :     spdm_certificate_response_t *spdm_response_requester_certificate;
     931              :     uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
     932              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     933              :     size_t spdm_response_requester_size;
     934              :     size_t data_size;
     935              :     size_t response_size;
     936              :     void *data;
     937              :     uint16_t portion_length;
     938              :     uint16_t remainder_length;
     939              :     static size_t calling_index = 0;
     940              : 
     941              :     static void *libspdm_local_certificate_chain;
     942              :     static size_t libspdm_local_certificate_chain_size;
     943              : 
     944            1 :     spdm_test_context = *State;
     945            1 :     spdm_context = spdm_test_context->spdm_context;
     946              : 
     947            1 :     spdm_context->encap_context.request_id = 0xFF;
     948            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
     949            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
     950            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
     951            1 :     spdm_context->encap_context.request_op_code_count =
     952              :         LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
     953              : 
     954            1 :     spdm_context->encap_context.current_request_op_code = SPDM_GET_CERTIFICATE;
     955            1 :     spdm_context->encap_context.request_op_code_sequence[0] = SPDM_GET_CERTIFICATE;
     956              : 
     957            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     958            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
     959            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
     960              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     961            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
     962              :                                                     m_libspdm_use_asym_algo, &data,
     963              :                                                     &data_size,
     964              :                                                     NULL, NULL);
     965            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
     966            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data;
     967            1 :     spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
     968            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     969            1 :     libspdm_reset_message_b(spdm_context);
     970              : 
     971            1 :     spdm_response_requester = (void *)temp_buf;
     972            1 :     libspdm_copy_mem(spdm_response_requester,
     973              :                      sizeof(temp_buf),
     974              :                      &m_libspdm_m_deliver_encapsulated_response_request_t1,
     975              :                      m_libspdm_m_deliver_encapsulated_response_request_t1_size);
     976              : 
     977            1 :     spdm_response_requester_certificate =
     978              :         (void *)(temp_buf + sizeof(spdm_deliver_encapsulated_response_request_t));
     979              : 
     980            1 :     libspdm_read_responder_public_certificate_chain(
     981              :         m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
     982              :         &libspdm_local_certificate_chain,
     983              :         &libspdm_local_certificate_chain_size, NULL, NULL);
     984              : 
     985            1 :     portion_length = LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN;
     986            1 :     remainder_length =
     987            1 :         (uint16_t)(libspdm_local_certificate_chain_size -
     988              :                    LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN *
     989            1 :                    (calling_index + 1));
     990              : 
     991            1 :     spdm_response_requester_certificate->header.spdm_version = SPDM_MESSAGE_VERSION_11;
     992            1 :     spdm_response_requester_certificate->header.request_response_code = SPDM_CERTIFICATE;
     993            1 :     spdm_response_requester_certificate->header.param1 = 0;
     994            1 :     spdm_response_requester_certificate->header.param2 = 0;
     995            1 :     spdm_response_requester_certificate->portion_length = portion_length;
     996            1 :     spdm_response_requester_certificate->remainder_length = remainder_length;
     997              : 
     998            1 :     libspdm_copy_mem(spdm_response_requester_certificate + 1,
     999              :                      sizeof(temp_buf) - sizeof(*spdm_response_requester_certificate),
    1000            1 :                      (uint8_t *)libspdm_local_certificate_chain +
    1001            1 :                      LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN * calling_index,
    1002              :                      portion_length);
    1003              : 
    1004            1 :     free(libspdm_local_certificate_chain);
    1005              : 
    1006            1 :     response_size = sizeof(response);
    1007            1 :     spdm_response_requester_size = sizeof(spdm_certificate_response_t) + portion_length +
    1008              :                                    sizeof(spdm_deliver_encapsulated_response_request_t);
    1009            1 :     status = libspdm_get_response_encapsulated_response_ack(spdm_context,
    1010              :                                                             spdm_response_requester_size,
    1011              :                                                             spdm_response_requester, &response_size,
    1012              :                                                             response);
    1013            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1014            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
    1015            1 :     spdm_response_requester = (void *)response;
    1016            1 :     assert_int_equal(spdm_response_requester->header.request_response_code,
    1017              :                      SPDM_ERROR);
    1018            1 :     assert_int_equal(spdm_response_requester->header.param1,
    1019              :                      SPDM_ERROR_CODE_INVALID_REQUEST);
    1020            1 :     assert_int_equal(spdm_response_requester->header.param2, 0);
    1021            1 :     free(data);
    1022            1 : }
    1023              : 
    1024            1 : void libspdm_test_get_response_encapsulated_response_ack_case8(void **State)
    1025              : {
    1026              :     libspdm_return_t status;
    1027              :     libspdm_test_context_t *spdm_test_context;
    1028              :     libspdm_context_t *spdm_context;
    1029              :     spdm_encapsulated_response_ack_response_t *spdm_response;
    1030              :     spdm_deliver_encapsulated_response_request_t *spdm_response_requester;
    1031              :     spdm_digest_response_t *spdm_response_requester_digest;
    1032              :     uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1033              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1034              :     size_t spdm_response_requester_size;
    1035              :     size_t spdm_response_requester_digest_size;
    1036              :     size_t data_size;
    1037              :     size_t response_size;
    1038              :     uint8_t *digest;
    1039              :     void *data;
    1040              : 
    1041            1 :     spdm_test_context = *State;
    1042            1 :     spdm_context = spdm_test_context->spdm_context;
    1043              : 
    1044            1 :     spdm_context->encap_context.request_id = 0xFF;
    1045            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
    1046            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
    1047            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
    1048            1 :     spdm_context->encap_context.request_op_code_count =
    1049              :         LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
    1050              : 
    1051            1 :     spdm_context->encap_context.current_request_op_code = SPDM_GET_DIGESTS;
    1052            1 :     spdm_context->encap_context.request_op_code_sequence[0] = SPDM_GET_DIGESTS;
    1053              : 
    1054            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
    1055            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
    1056            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
    1057              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1058            1 :     libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
    1059              :                                                     m_libspdm_use_asym_algo, &data,
    1060              :                                                     &data_size,
    1061              :                                                     NULL, NULL);
    1062            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
    1063            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data;
    1064            1 :     spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1065            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1066            1 :     libspdm_reset_message_b(spdm_context);
    1067              : 
    1068            1 :     spdm_response_requester_size = sizeof(spdm_digest_response_t) +
    1069            1 :                                    libspdm_get_hash_size(m_libspdm_use_hash_algo) +
    1070              :                                    sizeof(spdm_deliver_encapsulated_response_request_t);
    1071              : 
    1072            1 :     spdm_response_requester = (void *)temp_buf;
    1073            1 :     libspdm_copy_mem(spdm_response_requester,
    1074              :                      sizeof(temp_buf),
    1075              :                      &m_libspdm_m_deliver_encapsulated_response_request_t2,
    1076              :                      m_libspdm_m_deliver_encapsulated_response_request_t2_size);
    1077              : 
    1078            1 :     spdm_response_requester_digest_size = sizeof(spdm_digest_response_t) +
    1079            1 :                                           libspdm_get_hash_size(m_libspdm_use_hash_algo);
    1080            1 :     spdm_response_requester_digest =
    1081              :         (void *)(temp_buf + sizeof(spdm_deliver_encapsulated_response_request_t));
    1082            1 :     spdm_response_requester_digest->header.spdm_version = SPDM_MESSAGE_VERSION_12;
    1083            1 :     spdm_response_requester_digest->header.param1 = 0;
    1084            1 :     spdm_response_requester_digest->header.request_response_code = SPDM_DIGESTS;
    1085            1 :     spdm_response_requester_digest->header.param2 = 0;
    1086              : 
    1087            1 :     digest = (void *)(spdm_response_requester_digest + 1);
    1088            1 :     libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
    1089              :                      sizeof(m_libspdm_local_certificate_chain), &digest[0]);
    1090            1 :     spdm_response_requester_digest->header.param2 |= (0x01 << 0);
    1091              : 
    1092            1 :     libspdm_set_mem(m_libspdm_local_certificate_chain,
    1093              :                     sizeof(m_libspdm_local_certificate_chain),
    1094              :                     (uint8_t)(0xFF));
    1095              : 
    1096            1 :     libspdm_copy_mem(spdm_response_requester + 1,
    1097              :                      spdm_response_requester_digest_size,
    1098              :                      spdm_response_requester_digest,
    1099              :                      spdm_response_requester_digest_size);
    1100              : 
    1101            1 :     response_size = sizeof(response);
    1102            1 :     status = libspdm_get_response_encapsulated_response_ack(spdm_context,
    1103              :                                                             spdm_response_requester_size,
    1104              :                                                             spdm_response_requester, &response_size,
    1105              :                                                             response);
    1106            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1107            1 :     assert_int_equal(response_size, sizeof(spdm_encapsulated_response_ack_response_t));
    1108            1 :     spdm_response = (void *)response;
    1109            1 :     assert_int_equal(spdm_response->header.spdm_version,
    1110              :                      SPDM_MESSAGE_VERSION_12);
    1111            1 :     assert_int_equal(spdm_response->header.request_response_code,
    1112              :                      SPDM_ENCAPSULATED_RESPONSE_ACK);
    1113            1 :     assert_int_equal(spdm_response->header.param1, 0);
    1114            1 :     assert_int_equal(spdm_response->header.param2,
    1115              :                      SPDM_ENCAPSULATED_RESPONSE_ACK_RESPONSE_PAYLOAD_TYPE_ABSENT);
    1116            1 :     assert_int_equal(spdm_response->ack_request_id,
    1117              :                      m_libspdm_m_deliver_encapsulated_response_request_t2.header.param1);
    1118            1 :     free(data);
    1119            1 : }
    1120              : 
    1121              : /**
    1122              :  * Test 9: In an encapsulated request flow, a Responder issue an encapsulated request that can take up to CT time to
    1123              :  * fulfill, then the Requester deliver an encapsulated ERROR message with a ResponseNotReady error code.
    1124              :  * Expected behavior: the Responder shall not encapsulate another request by setting Param2 in ENCAPSULATED_RESPONSE_ACK
    1125              :  * to a value of zero.
    1126              :  **/
    1127            1 : void libspdm_test_get_response_encapsulated_response_ack_case9(void **State)
    1128              : {
    1129              :     libspdm_return_t status;
    1130              :     libspdm_test_context_t *spdm_test_context;
    1131              :     libspdm_context_t *spdm_context;
    1132              :     spdm_encapsulated_response_ack_response_t *spdm_response;
    1133              :     spdm_deliver_encapsulated_response_request_t *spdm_request;
    1134              :     spdm_error_response_data_response_not_ready_t *EncapsulatedResponse;
    1135              :     uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1136              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1137              :     size_t spdm_request_size;
    1138              :     size_t EncapsulatedResponse_size;
    1139              :     size_t response_size;
    1140              : 
    1141            1 :     spdm_test_context = *State;
    1142            1 :     spdm_context = spdm_test_context->spdm_context;
    1143              : 
    1144            1 :     spdm_context->encap_context.request_id = 0xFF;
    1145            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
    1146            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
    1147            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
    1148            1 :     spdm_context->encap_context.request_op_code_count =
    1149              :         LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
    1150              : 
    1151            1 :     spdm_context->encap_context.current_request_op_code = SPDM_GET_DIGESTS;
    1152            1 :     spdm_context->encap_context.request_op_code_sequence[0] = SPDM_GET_DIGESTS;
    1153              : 
    1154            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
    1155            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
    1156            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
    1157              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1158            1 :     libspdm_reset_message_b(spdm_context);
    1159              : 
    1160            1 :     spdm_request_size = sizeof(spdm_deliver_encapsulated_response_request_t) +
    1161              :                         sizeof(spdm_error_response_data_response_not_ready_t);
    1162              : 
    1163            1 :     spdm_request = (void *)temp_buf;
    1164            1 :     libspdm_copy_mem(spdm_request,
    1165              :                      sizeof(temp_buf),
    1166              :                      &m_libspdm_m_deliver_encapsulated_response_request_t2,
    1167              :                      m_libspdm_m_deliver_encapsulated_response_request_t2_size);
    1168              : 
    1169            1 :     EncapsulatedResponse_size = sizeof(spdm_error_response_data_response_not_ready_t);
    1170            1 :     EncapsulatedResponse =
    1171              :         (void *)(temp_buf + sizeof(spdm_deliver_encapsulated_response_request_t));
    1172            1 :     EncapsulatedResponse->header.spdm_version = SPDM_MESSAGE_VERSION_12;
    1173            1 :     EncapsulatedResponse->header.request_response_code = SPDM_ERROR;
    1174            1 :     EncapsulatedResponse->header.param1 =
    1175              :         SPDM_ERROR_CODE_RESPONSE_NOT_READY;
    1176            1 :     EncapsulatedResponse->header.param2 = 0;
    1177            1 :     EncapsulatedResponse->extend_error_data.rd_exponent = 1;
    1178            1 :     EncapsulatedResponse->extend_error_data.rd_tm = 1;
    1179            1 :     EncapsulatedResponse->extend_error_data.request_code =
    1180              :         SPDM_GET_DIGESTS;
    1181            1 :     EncapsulatedResponse->extend_error_data.token = 0;
    1182              : 
    1183            1 :     libspdm_copy_mem(spdm_request + 1,
    1184              :                      EncapsulatedResponse_size,
    1185              :                      EncapsulatedResponse,
    1186              :                      EncapsulatedResponse_size);
    1187              : 
    1188            1 :     response_size = sizeof(response);
    1189            1 :     status = libspdm_get_response_encapsulated_response_ack(spdm_context,
    1190              :                                                             spdm_request_size,
    1191              :                                                             spdm_request, &response_size,
    1192              :                                                             response);
    1193            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1194            1 :     assert_int_equal(response_size, sizeof(spdm_encapsulated_response_ack_response_t));
    1195            1 :     spdm_response = (void *)response;
    1196            1 :     assert_int_equal(spdm_response->header.spdm_version,
    1197              :                      SPDM_MESSAGE_VERSION_12);
    1198            1 :     assert_int_equal(spdm_response->header.request_response_code,
    1199              :                      SPDM_ENCAPSULATED_RESPONSE_ACK);
    1200            1 :     assert_int_equal(spdm_response->header.param1, 0);
    1201            1 :     assert_int_equal(spdm_response->header.param2,
    1202              :                      SPDM_ENCAPSULATED_RESPONSE_ACK_RESPONSE_PAYLOAD_TYPE_ABSENT);
    1203            1 :     assert_int_equal(spdm_response->ack_request_id,
    1204              :                      m_libspdm_m_deliver_encapsulated_response_request_t2.header.param1);
    1205            1 : }
    1206              : 
    1207            1 : int libspdm_responder_encapsulated_response_test_main(void)
    1208              : {
    1209            1 :     const struct CMUnitTest spdm_responder_encapsulated_response_tests[] = {
    1210              : #if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT)
    1211              :         /*Success Case request_op_code_sequence: SPDM_GET_DIGESTS*/
    1212              :         cmocka_unit_test(libspdm_test_get_response_encapsulated_request_case1),
    1213              :         /*Success Case current_request_op_code: SPDM_GET_CERTIFICATE */
    1214              :         cmocka_unit_test(libspdm_test_get_response_encapsulated_request_case2),
    1215              :         /*response_state : LIBSPDM_RESPONSE_STATE_NORMAL with UnexpectedRequest error. */
    1216              :         cmocka_unit_test(libspdm_test_get_response_encapsulated_request_case3),
    1217              :         /*response_state : LIBSPDM_RESPONSE_STATE_NEED_RESYNC */
    1218              :         cmocka_unit_test(libspdm_test_get_response_encapsulated_request_case4),
    1219              : #endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT) */
    1220              : #if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_CHALLENGE_SUPPORT)
    1221              :         /*Success Case current_request_op_code: SPDM_CHALLENGE */
    1222              :         cmocka_unit_test(libspdm_test_get_response_encapsulated_request_case5),
    1223              : #endif
    1224              :         /* Success Case current_request_op_code: SPDM_KEY_UPDATE */
    1225              :         cmocka_unit_test(libspdm_test_get_response_encapsulated_request_case6),
    1226              :         /*response_state : LIBSPDM_RESPONSE_STATE_NORMAL with NoPendingRequests error. */
    1227              :         cmocka_unit_test(libspdm_test_get_response_encapsulated_request_case7),
    1228              : #if LIBSPDM_SEND_GET_ENDPOINT_INFO_SUPPORT
    1229              :         /* Success Case current_request_op_code: SPDM_GET_ENDPOINT_INFO */
    1230              :         cmocka_unit_test(libspdm_test_get_response_encapsulated_request_case8),
    1231              : #endif /* LIBSPDM_SEND_GET_ENDPOINT_INFO_SUPPORT */
    1232              : 
    1233              : #if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT)
    1234              :         /*Success Case current_request_op_code: SPDM_GET_DIGESTS*/
    1235              :         cmocka_unit_test(libspdm_test_get_response_encapsulated_response_ack_case1),
    1236              :         /*Success Case current_request_op_code: SPDM_GET_CERTIFICATE*/
    1237              :         cmocka_unit_test(libspdm_test_get_response_encapsulated_response_ack_case2),
    1238              : #endif
    1239              :         /* Success Case current_request_op_code: SPDM_KEY_UPDATE */
    1240              :         cmocka_unit_test(libspdm_test_get_response_encapsulated_response_ack_case3),
    1241              :         /* current_request_op_code: NULL */
    1242              :         cmocka_unit_test(libspdm_test_get_response_encapsulated_response_ack_case4),
    1243              :         /*response_state : LIBSPDM_RESPONSE_STATE_NORMAL */
    1244              :         cmocka_unit_test(libspdm_test_get_response_encapsulated_response_ack_case5),
    1245              :         /*response_state : LIBSPDM_RESPONSE_STATE_NEED_RESYNC */
    1246              :         cmocka_unit_test(libspdm_test_get_response_encapsulated_response_ack_case6),
    1247              : #if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT)
    1248              :         /*spdm_request->header.param1 != spdm_context->encap_context.request_id */
    1249              :         cmocka_unit_test(libspdm_test_get_response_encapsulated_response_ack_case7),
    1250              :         /*Success Case  When version is greater than V1.2 */
    1251              :         cmocka_unit_test(libspdm_test_get_response_encapsulated_response_ack_case8),
    1252              : #endif
    1253              :         /*When the Requester delivers an encapsulated ERROR message with a ResponseNotReady error code*/
    1254              :         cmocka_unit_test(libspdm_test_get_response_encapsulated_response_ack_case9),
    1255              :     };
    1256              : 
    1257            1 :     libspdm_test_context_t test_context = {
    1258              :         LIBSPDM_TEST_CONTEXT_VERSION,
    1259              :         false,
    1260              :     };
    1261              : 
    1262            1 :     libspdm_setup_test_context(&test_context);
    1263              : 
    1264            1 :     return cmocka_run_group_tests(spdm_responder_encapsulated_response_tests,
    1265              :                                   libspdm_unit_test_group_setup,
    1266              :                                   libspdm_unit_test_group_teardown);
    1267              : }
    1268              : 
    1269              : #endif /* LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP */
        

Generated by: LCOV version 2.0-1