LCOV - code coverage report
Current view: top level - unit_test/test_spdm_requester - chunk_get.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 99.2 % 492 488
Test Date: 2025-08-24 08:11:14 Functions: 100.0 % 15 15

            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_requester_lib.h"
       9              : #include "internal/libspdm_secured_message_lib.h"
      10              : 
      11              : #if LIBSPDM_ENABLE_CAPABILITY_CHUNK_CAP
      12              : 
      13              : static void *m_libspdm_local_certificate_chain_test_case_1;
      14              : static size_t m_libspdm_local_certificate_chain_size_test_case_1;
      15              : 
      16              : static uint8_t m_libspdm_local_large_response_buffer[LIBSPDM_MAX_SPDM_MSG_SIZE];
      17              : 
      18              : #define BUFFER_SIZE_FOR_CHUNK_SEQ_NO_WRAP_TEST 0x200000
      19              : static uint8_t m_libspdm_local_response_buffer_for_chunk_seq_no_wrap_test[
      20              :     BUFFER_SIZE_FOR_CHUNK_SEQ_NO_WRAP_TEST];
      21              : 
      22              : static size_t m_libspdm_local_buffer_size;
      23              : static uint8_t m_libspdm_local_buffer[LIBSPDM_MAX_MESSAGE_M1M2_BUFFER_SIZE];
      24              : 
      25              : static uint8_t m_libspdm_local_certificate_chain_test_case_4[LIBSPDM_MAX_CERT_CHAIN_SIZE];
      26              : 
      27              : /* Override the LIBSPDM_DATA_TRANSFER_SIZE just for the unit tests in this file.
      28              :  * All other unit tests have the default data transfer size due to the specific
      29              :  * unit tests requests and responses hardcode for each test case. */
      30              : #define CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE (42)
      31              : 
      32              : /* Loading the target expiration certificate chain and saving root certificate hash
      33              :  * "rsa3072_Expiration/bundle_responder.certchain.der"*/
      34              : bool libspdm_libspdm_read_responder_public_certificate_chain_expiration(
      35              :     void** data, size_t* size, void** hash, size_t* hash_size);
      36              : 
      37              : #define CHUNK_GET_UNIT_TEST_CHUNK_HANDLE (10)
      38              : 
      39            2 : void libspdm_requester_chunk_get_test_case1_build_certificates_response(
      40              :     void *context, void *response, size_t *response_size,
      41              :     size_t sub_cert_index, size_t *sub_cert_count)
      42              : {
      43              :     spdm_certificate_response_t *cert_rsp;
      44              :     uint16_t sub_cert_portion_length;
      45              :     uint16_t sub_cert_remainder_length;
      46              : 
      47            2 :     if (m_libspdm_local_certificate_chain_test_case_1 == NULL) {
      48            1 :         libspdm_read_responder_public_certificate_chain(
      49              :             m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
      50              :             &m_libspdm_local_certificate_chain_test_case_1,
      51              :             &m_libspdm_local_certificate_chain_size_test_case_1, NULL, NULL);
      52              :     }
      53            2 :     LIBSPDM_ASSERT(m_libspdm_local_certificate_chain_test_case_1 != NULL);
      54              : 
      55            2 :     *sub_cert_count = (m_libspdm_local_certificate_chain_size_test_case_1 +
      56            2 :                        LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN - 1) /
      57              :                       LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN;
      58              : 
      59            2 :     if (sub_cert_index != *sub_cert_count - 1) {
      60            1 :         sub_cert_portion_length = LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN;
      61            1 :         sub_cert_remainder_length =
      62            1 :             (uint16_t) (m_libspdm_local_certificate_chain_size_test_case_1 -
      63              :                         LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN *
      64            1 :                         (sub_cert_index + 1));
      65              :     } else {
      66            1 :         sub_cert_portion_length = (uint16_t) (
      67              :             m_libspdm_local_certificate_chain_size_test_case_1 -
      68            1 :             LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN * (*sub_cert_count - 1));
      69            1 :         sub_cert_remainder_length = 0;
      70              :     }
      71              : 
      72            2 :     cert_rsp = (spdm_certificate_response_t*) ((uint8_t*) response);
      73              : 
      74            2 :     cert_rsp->header.spdm_version = SPDM_MESSAGE_VERSION_12;
      75            2 :     cert_rsp->header.request_response_code = SPDM_CERTIFICATE;
      76            2 :     cert_rsp->header.param1 = 0;
      77            2 :     cert_rsp->header.param2 = 0;
      78            2 :     cert_rsp->portion_length = sub_cert_portion_length;
      79            2 :     cert_rsp->remainder_length = sub_cert_remainder_length;
      80              : 
      81            2 :     libspdm_copy_mem(
      82            2 :         cert_rsp + 1, sub_cert_portion_length,
      83            2 :         (uint8_t*) m_libspdm_local_certificate_chain_test_case_1 +
      84            2 :         LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN * sub_cert_index,
      85              :         sub_cert_portion_length);
      86              : 
      87            2 :     *response_size = sizeof(spdm_certificate_response_t) + sub_cert_portion_length;
      88            2 : }
      89              : 
      90            1 : void libspdm_requester_chunk_get_test_case2_build_measurements_response(
      91              :     void* context, void* response, size_t* response_size)
      92              : {
      93              :     libspdm_context_t* spdm_context;
      94            1 :     spdm_measurements_response_t* meas_rsp = NULL;
      95              :     spdm_measurement_block_dmtf_t* measurment_block;
      96              : 
      97            1 :     spdm_context = (libspdm_context_t*) context;
      98              :     /* This is get measurements test case 20, but changed to SPDM version 1.2
      99              :      * which includes opaque data */
     100              : 
     101              :     uint8_t* ptr;
     102            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     103              :         m_libspdm_use_measurement_hash_algo;
     104              : 
     105            1 :     *response_size = sizeof(spdm_measurements_response_t) +
     106              :                      2 * (sizeof(spdm_measurement_block_dmtf_t) +
     107            1 :                           libspdm_get_measurement_hash_size(
     108              :                               m_libspdm_use_measurement_hash_algo)) +
     109            1 :                      SPDM_NONCE_SIZE + sizeof(uint16_t);
     110              : 
     111            1 :     meas_rsp = (spdm_measurements_response_t*)((uint8_t*) response);
     112            1 :     meas_rsp->header.spdm_version = SPDM_MESSAGE_VERSION_12;
     113            1 :     meas_rsp->header.request_response_code = SPDM_MEASUREMENTS;
     114            1 :     meas_rsp->header.param1 = 0;
     115            1 :     meas_rsp->header.param2 = 0;
     116            1 :     meas_rsp->number_of_blocks = 2;
     117            1 :     *(uint32_t*) meas_rsp->measurement_record_length =
     118            1 :         2 * ((uint32_t) (sizeof(spdm_measurement_block_dmtf_t) +
     119            1 :                          libspdm_get_measurement_hash_size(
     120              :                              m_libspdm_use_measurement_hash_algo)));
     121            1 :     measurment_block = (void*) (meas_rsp + 1);
     122            1 :     libspdm_set_mem(
     123              :         measurment_block,
     124            1 :         2 * (sizeof(spdm_measurement_block_dmtf_t) +
     125            1 :              libspdm_get_measurement_hash_size(
     126              :                  m_libspdm_use_measurement_hash_algo)),
     127              :         1);
     128            1 :     measurment_block->measurement_block_common_header.index = 1;
     129            1 :     measurment_block->measurement_block_common_header.measurement_specification =
     130              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF;
     131            1 :     measurment_block->measurement_block_common_header.measurement_size =
     132            1 :         (uint16_t) (sizeof(spdm_measurement_block_dmtf_header_t) +
     133            1 :                     libspdm_get_measurement_hash_size(
     134              :                         m_libspdm_use_measurement_hash_algo));
     135            1 :     measurment_block =
     136              :         (void*) (((uint8_t*) measurment_block) +
     137            1 :                  (sizeof(spdm_measurement_block_dmtf_t) +
     138            1 :                   libspdm_get_measurement_hash_size(
     139              :                       m_libspdm_use_measurement_hash_algo)));
     140            1 :     measurment_block->measurement_block_common_header.index = 2;
     141            1 :     measurment_block->measurement_block_common_header.measurement_specification =
     142              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF;
     143            1 :     measurment_block->measurement_block_common_header.measurement_size =
     144            1 :         (uint16_t) (sizeof(spdm_measurement_block_dmtf_header_t) +
     145            1 :                     libspdm_get_measurement_hash_size(
     146              :                         m_libspdm_use_measurement_hash_algo));
     147            1 :     ptr = (uint8_t*) meas_rsp + *response_size - SPDM_NONCE_SIZE - sizeof(uint16_t);
     148            1 :     libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
     149            1 :     ptr += SPDM_NONCE_SIZE;
     150              :     /* Set opaque data length to 0 */
     151            1 :     *ptr = 0;
     152            1 :     ptr++;
     153            1 :     *ptr = 0;
     154            1 : }
     155              : 
     156            1 : void libspdm_requester_chunk_get_test_case3_build_challenge_response(
     157              :     void* context, void* response, size_t* response_size)
     158              : {
     159              :     libspdm_context_t* spdm_context;
     160              :     spdm_challenge_auth_response_t* spdm_response;
     161              :     void* data;
     162              :     size_t data_size;
     163              :     uint8_t* ptr;
     164              :     uint8_t hash_data[LIBSPDM_MAX_HASH_SIZE];
     165              :     size_t sig_size;
     166              : 
     167            1 :     spdm_context = (libspdm_context_t*) context;
     168            1 :     libspdm_read_responder_public_certificate_chain(
     169              :         m_libspdm_use_hash_algo,
     170              :         m_libspdm_use_asym_algo, &data,
     171              :         &data_size, NULL, NULL);
     172            1 :     spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
     173            1 :     spdm_context->local_context.local_cert_chain_provision[0] = data;
     174            1 :     spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
     175            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     176            1 :     *response_size = sizeof(spdm_challenge_auth_response_t) +
     177            1 :                      libspdm_get_hash_size(m_libspdm_use_hash_algo) +
     178            1 :                      SPDM_NONCE_SIZE + 0 + sizeof(uint16_t) + 0 +
     179            1 :                      libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
     180            1 :     spdm_response = response;
     181              : 
     182            1 :     spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_12;
     183            1 :     spdm_response->header.request_response_code = SPDM_CHALLENGE_AUTH;
     184            1 :     spdm_response->header.param1 = 0;
     185            1 :     spdm_response->header.param2 = (1 << 0);
     186            1 :     ptr = (void*) (spdm_response + 1);
     187            1 :     libspdm_hash_all(
     188              :         m_libspdm_use_hash_algo,
     189              :         spdm_context->local_context.local_cert_chain_provision[0],
     190              :         spdm_context->local_context.local_cert_chain_provision_size[0],
     191              :         ptr);
     192            1 :     free(data);
     193            1 :     data = NULL;
     194              : 
     195            1 :     ptr += libspdm_get_hash_size(m_libspdm_use_hash_algo);
     196            1 :     libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
     197            1 :     ptr += SPDM_NONCE_SIZE;
     198              :     /* libspdm_zero_mem (ptr, libspdm_get_hash_size (m_libspdm_use_hash_algo));
     199              :      * ptr += libspdm_get_hash_size (m_libspdm_use_hash_algo);*/
     200            1 :     *(uint16_t*) ptr = 0;
     201            1 :     ptr += sizeof(uint16_t);
     202              : 
     203            1 :     libspdm_copy_mem(
     204            1 :         &m_libspdm_local_buffer[m_libspdm_local_buffer_size],
     205              :         sizeof(m_libspdm_local_buffer) -
     206            1 :         (&m_libspdm_local_buffer[m_libspdm_local_buffer_size] - m_libspdm_local_buffer),
     207            1 :         spdm_response, (size_t) ptr - (size_t) spdm_response);
     208            1 :     m_libspdm_local_buffer_size += ((size_t) ptr - (size_t) spdm_response);
     209            1 :     LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "m_libspdm_local_buffer_size (0x%zx):\n",
     210              :                    m_libspdm_local_buffer_size));
     211            1 :     libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
     212            1 :     libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_buffer,
     213              :                      m_libspdm_local_buffer_size, hash_data);
     214            1 :     LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "HashDataSize (0x%x):\n",
     215              :                    libspdm_get_hash_size(m_libspdm_use_hash_algo)));
     216            1 :     libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
     217            1 :     sig_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
     218            1 :     libspdm_responder_data_sign(
     219              : #if LIBSPDM_HAL_PASS_SPDM_CONTEXT
     220              :         spdm_context,
     221              : #endif
     222            1 :         spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
     223              :             SPDM_CHALLENGE_AUTH,
     224              :             m_libspdm_use_asym_algo, m_libspdm_use_pqc_asym_algo, m_libspdm_use_hash_algo,
     225              :             false, m_libspdm_local_buffer, m_libspdm_local_buffer_size,
     226              :             ptr, &sig_size);
     227            1 :     ptr += sig_size;
     228            1 : }
     229              : 
     230            1 : void libspdm_requester_chunk_get_test_case4_build_digest_response(
     231              :     void* context, void* response, size_t* response_size)
     232              : {
     233              :     libspdm_context_t *spdm_context;
     234              :     spdm_digest_response_t* spdm_response;
     235              :     uint8_t* digest;
     236              :     uint8_t slot_id;
     237              : 
     238            1 :     spdm_context = (libspdm_context_t*)context;
     239            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
     240              :         m_libspdm_use_hash_algo;
     241            1 :     *response_size = sizeof(spdm_digest_response_t) +
     242            1 :                      libspdm_get_hash_size(m_libspdm_use_hash_algo) * SPDM_MAX_SLOT_COUNT;
     243            1 :     spdm_response = response;
     244              : 
     245            1 :     spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_12;
     246            1 :     spdm_response->header.param1 = 0;
     247            1 :     spdm_response->header.request_response_code = SPDM_DIGESTS;
     248            1 :     spdm_response->header.param2 = 0;
     249            1 :     libspdm_set_mem(m_libspdm_local_certificate_chain_test_case_4,
     250              :                     sizeof(m_libspdm_local_certificate_chain_test_case_4),
     251              :                     (uint8_t) (0xFF));
     252              : 
     253            1 :     digest = (void*) (spdm_response + 1);
     254            1 :     libspdm_zero_mem(digest,
     255            1 :                      libspdm_get_hash_size(m_libspdm_use_hash_algo) * SPDM_MAX_SLOT_COUNT);
     256            9 :     for (slot_id = 0; slot_id < SPDM_MAX_SLOT_COUNT; slot_id++) {
     257            8 :         libspdm_hash_all(
     258              :             m_libspdm_use_hash_algo,
     259              :             m_libspdm_local_certificate_chain_test_case_4,
     260              :             sizeof(m_libspdm_local_certificate_chain_test_case_4), &digest[0]);
     261            8 :         digest += libspdm_get_hash_size(m_libspdm_use_hash_algo);
     262              :     }
     263            1 :     spdm_response->header.param2 |= (0xFF << 0);
     264            1 : }
     265              : 
     266            2 : void libspdm_requester_chunk_get_test_case5_case6_build_vendor_response(
     267              :     void* context, void* response, size_t* response_size)
     268              : {
     269              :     spdm_vendor_defined_response_msg_t *spdm_response;
     270              : 
     271              :     /* For exceed max chunk seq no */
     272            2 :     *response_size =
     273              :         (CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE -
     274              :          sizeof(spdm_chunk_response_response_t)) * 65536 - sizeof(uint32_t) + 0x10;
     275              : 
     276            2 :     libspdm_set_mem(response, *response_size, 0xff);
     277              : 
     278            2 :     spdm_response = response;
     279              : 
     280            2 :     spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_12;
     281            2 :     spdm_response->header.request_response_code = SPDM_VENDOR_DEFINED_RESPONSE;
     282            2 :     spdm_response->header.param1 = 0;
     283            2 :     spdm_response->header.param2 = 0;
     284              : 
     285            2 :     spdm_response->standard_id = 6;
     286            2 :     spdm_response->len = 2;
     287            2 : }
     288              : 
     289        65613 : libspdm_return_t libspdm_requester_chunk_get_test_send_message(
     290              :     void* spdm_context, size_t request_size, const void* request,
     291              :     uint64_t timeout)
     292              : {
     293              :     libspdm_test_context_t* spdm_test_context;
     294              : 
     295        65613 :     spdm_test_context = libspdm_get_test_context();
     296        65613 :     if (spdm_test_context->case_id == 0x1) {
     297           50 :         return LIBSPDM_STATUS_SUCCESS;
     298        65563 :     } else if (spdm_test_context->case_id == 0x2) {
     299            7 :         return LIBSPDM_STATUS_SUCCESS;
     300        65556 :     } else if (spdm_test_context->case_id == 0x3) {
     301              :         const uint8_t* ptr;
     302            6 :         ptr = (const uint8_t*) request;
     303              : 
     304            6 :         if (ptr[2] == SPDM_CHALLENGE) {
     305            1 :             m_libspdm_local_buffer_size = 0;
     306            1 :             libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
     307            1 :                              &ptr[1], request_size - 1);
     308            1 :             m_libspdm_local_buffer_size += (request_size - 1);
     309              :         }
     310            6 :         return LIBSPDM_STATUS_SUCCESS;
     311        65550 :     } else if (spdm_test_context->case_id == 0x4) {
     312           10 :         return LIBSPDM_STATUS_SUCCESS;
     313        65540 :     } else if (spdm_test_context->case_id == 0x5) {
     314            2 :         return LIBSPDM_STATUS_SUCCESS;
     315        65538 :     } else if (spdm_test_context->case_id == 0x6) {
     316        65537 :         return LIBSPDM_STATUS_SUCCESS;
     317            1 :     } else if (spdm_test_context->case_id == 0x7) {
     318            1 :         return LIBSPDM_STATUS_SUCCESS;
     319              :     } else {
     320            0 :         return LIBSPDM_STATUS_SEND_FAIL;
     321              :     }
     322              : }
     323              : 
     324        65613 : libspdm_return_t libspdm_requester_chunk_get_test_receive_message(
     325              :     void* spdm_context, size_t* response_size,
     326              :     void** response, uint64_t timeout)
     327              : {
     328              :     libspdm_test_context_t* spdm_test_context;
     329        65613 :     uint8_t chunk_handle = CHUNK_GET_UNIT_TEST_CHUNK_HANDLE;
     330              :     static bool error_large_response_sent = false;
     331              : 
     332              :     static spdm_message_header_t* sub_rsp = NULL;
     333              :     static size_t sub_rsp_size = 0;
     334              :     static size_t sub_rsp_copied = 0;
     335              :     static size_t sub_rsp_remaining = 0;
     336              :     static uint16_t chunk_seq_no = 0;
     337              : 
     338              :     spdm_chunk_response_response_t* chunk_rsp;
     339              :     size_t chunk_rsp_size;
     340              :     uint8_t* chunk_copy_to;
     341              :     size_t chunk_copy_size;
     342              :     size_t transport_header_size;
     343              :     void (*build_response_func)(void*, void*, size_t *);
     344              : 
     345        65613 :     build_response_func = NULL;
     346              : 
     347        65613 :     spdm_test_context = libspdm_get_test_context();
     348              : 
     349              :     /* First response to these tests should always be error large response */
     350        65613 :     if (error_large_response_sent == false) {
     351            7 :         error_large_response_sent = true;
     352              : 
     353              :         spdm_error_response_t* error_rsp;
     354              :         size_t error_rsp_size;
     355              : 
     356            7 :         transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
     357            7 :         error_rsp = (void*) ((uint8_t*) *response + transport_header_size);
     358            7 :         error_rsp_size = sizeof(spdm_error_response_t) + sizeof(uint8_t);
     359              : 
     360            7 :         error_rsp->header.spdm_version = SPDM_MESSAGE_VERSION_12;
     361            7 :         error_rsp->header.request_response_code = SPDM_ERROR;
     362            7 :         error_rsp->header.param1 = SPDM_ERROR_CODE_LARGE_RESPONSE;
     363            7 :         error_rsp->header.param2 = 0;
     364            7 :         *((uint16_t*) (error_rsp + 1)) = chunk_handle;
     365              : 
     366            7 :         libspdm_transport_test_encode_message(
     367              :             spdm_context, NULL, false, false,
     368              :             error_rsp_size, error_rsp,
     369              :             response_size, response);
     370              : 
     371            7 :         return LIBSPDM_STATUS_SUCCESS;
     372              :     }
     373              : 
     374        65606 :     if (spdm_test_context->case_id == 0x1) {
     375              : 
     376              :         /* Refers to just the certificate portion in the cert response */
     377              :         static size_t sub_cert_index = 0;
     378              :         static size_t sub_cert_count = 0;
     379              : 
     380           48 :         transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
     381           48 :         chunk_rsp = (void*) ((uint8_t*) *response + transport_header_size);
     382              : 
     383           48 :         chunk_rsp->header.spdm_version = SPDM_MESSAGE_VERSION_12;
     384           48 :         chunk_rsp->header.request_response_code = SPDM_CHUNK_RESPONSE;
     385           48 :         chunk_rsp->header.param1 = 0;
     386           48 :         chunk_rsp->header.param2 = chunk_handle;
     387              : 
     388           48 :         chunk_copy_to = (uint8_t*) (chunk_rsp + 1);
     389           48 :         chunk_copy_size = CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE
     390              :                           - sizeof(spdm_chunk_response_response_t);
     391              : 
     392           48 :         if (sub_rsp_copied == 0) {
     393            2 :             sub_rsp = (spdm_message_header_t*) m_libspdm_local_large_response_buffer;
     394            2 :             sub_rsp_size = sizeof(m_libspdm_local_large_response_buffer);
     395            2 :             libspdm_zero_mem(sub_rsp, sub_rsp_size);
     396              : 
     397            2 :             libspdm_requester_chunk_get_test_case1_build_certificates_response(
     398              :                 spdm_context, sub_rsp, &sub_rsp_size, sub_cert_index, &sub_cert_count);
     399              : 
     400            2 :             sub_rsp_remaining = sub_rsp_size;
     401            2 :             sub_rsp_copied = 0;
     402              : 
     403              :             /* first chunk has size of large response */
     404            2 :             chunk_seq_no = 0;
     405            2 :             *((uint32_t*) (chunk_rsp + 1)) = (uint32_t) sub_rsp_size;
     406              : 
     407            2 :             chunk_copy_to += sizeof(uint32_t);
     408            2 :             chunk_copy_size -= sizeof(uint32_t);
     409            2 :             chunk_copy_size = LIBSPDM_MIN(sub_rsp_remaining, chunk_copy_size);
     410            2 :             chunk_rsp_size = sizeof(spdm_chunk_response_response_t)
     411              :                              + sizeof(uint32_t) + chunk_copy_size;
     412              :         } else {
     413           46 :             chunk_copy_size = LIBSPDM_MIN(sub_rsp_remaining, chunk_copy_size);
     414           46 :             chunk_rsp_size = sizeof(spdm_chunk_response_response_t) + chunk_copy_size;
     415              :         }
     416              : 
     417           48 :         if (chunk_copy_size == sub_rsp_remaining) {
     418            2 :             chunk_rsp->header.param1 = SPDM_CHUNK_GET_RESPONSE_ATTRIBUTE_LAST_CHUNK;
     419              :         }
     420              : 
     421           48 :         libspdm_copy_mem(chunk_copy_to,
     422           48 :                          *response_size - (chunk_copy_to - (uint8_t*)*response),
     423           48 :                          (uint8_t*) sub_rsp + sub_rsp_copied,
     424              :                          chunk_copy_size);
     425              : 
     426           48 :         sub_rsp_copied += chunk_copy_size;
     427           48 :         sub_rsp_remaining -= chunk_copy_size;
     428           48 :         chunk_rsp->chunk_size = (uint32_t) chunk_copy_size;
     429           48 :         chunk_rsp->chunk_seq_no = chunk_seq_no;
     430           48 :         chunk_seq_no++;
     431              : 
     432           48 :         libspdm_transport_test_encode_message(
     433              :             spdm_context, NULL, false, false,
     434              :             chunk_rsp_size, chunk_rsp,
     435              :             response_size, response);
     436              : 
     437           48 :         if (sub_rsp_copied >= sub_rsp_size) {
     438            2 :             sub_cert_index++;
     439            2 :             sub_rsp = NULL;
     440            2 :             sub_rsp_size = 0;
     441            2 :             sub_rsp_copied = 0;
     442            2 :             sub_rsp_remaining = 0;
     443            2 :             chunk_seq_no = 0;
     444            2 :             error_large_response_sent = false;
     445              : 
     446            2 :             if (sub_cert_index == sub_cert_count) {
     447            1 :                 sub_cert_index = 0;
     448              : 
     449            1 :                 free(m_libspdm_local_certificate_chain_test_case_1);
     450            1 :                 m_libspdm_local_certificate_chain_test_case_1 = NULL;
     451            1 :                 m_libspdm_local_certificate_chain_size_test_case_1 = 0;
     452              :             }
     453              :         }
     454              : 
     455           48 :         return LIBSPDM_STATUS_SUCCESS;
     456        65558 :     } else if (spdm_test_context->case_id == 0x2) {
     457            6 :         build_response_func =
     458              :             libspdm_requester_chunk_get_test_case2_build_measurements_response;
     459        65552 :     } else if (spdm_test_context->case_id == 0x3) {
     460            5 :         build_response_func =
     461              :             libspdm_requester_chunk_get_test_case3_build_challenge_response;
     462        65547 :     } else if (spdm_test_context->case_id == 0x4) {
     463            9 :         build_response_func =
     464              :             libspdm_requester_chunk_get_test_case4_build_digest_response;
     465        65538 :     } else if (spdm_test_context->case_id == 0x5) {
     466            1 :         build_response_func =
     467              :             libspdm_requester_chunk_get_test_case5_case6_build_vendor_response;
     468        65537 :     } else if (spdm_test_context->case_id == 0x6) {
     469        65536 :         build_response_func =
     470              :             libspdm_requester_chunk_get_test_case5_case6_build_vendor_response;
     471            1 :     } else if (spdm_test_context->case_id == 0x7) {
     472              :         /* This case only return one error message with RequestResynch */
     473              :         spdm_error_response_t* error_rsp;
     474              :         size_t error_rsp_size;
     475              : 
     476            1 :         transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
     477            1 :         error_rsp = (void*) ((uint8_t*) *response + transport_header_size);
     478            1 :         error_rsp_size = sizeof(spdm_error_response_t) + sizeof(uint8_t);
     479              : 
     480            1 :         error_rsp->header.spdm_version = SPDM_MESSAGE_VERSION_10;
     481            1 :         error_rsp->header.request_response_code = SPDM_ERROR;
     482            1 :         error_rsp->header.param1 = SPDM_ERROR_CODE_REQUEST_RESYNCH;
     483            1 :         error_rsp->header.param2 = 0;
     484              : 
     485            1 :         libspdm_transport_test_encode_message(
     486              :             spdm_context, NULL, false, false,
     487              :             error_rsp_size, error_rsp,
     488              :             response_size, response);
     489              : 
     490            1 :         return LIBSPDM_STATUS_SUCCESS;
     491              :     } else {
     492            0 :         LIBSPDM_ASSERT(0);
     493            0 :         return LIBSPDM_STATUS_RECEIVE_FAIL;
     494              :     }
     495              : 
     496        65557 :     if (build_response_func) {
     497        65557 :         transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
     498        65557 :         chunk_rsp = (void*) ((uint8_t*) *response + transport_header_size);
     499              : 
     500        65557 :         chunk_rsp->header.spdm_version = SPDM_MESSAGE_VERSION_12;
     501        65557 :         chunk_rsp->header.request_response_code = SPDM_CHUNK_RESPONSE;
     502        65557 :         chunk_rsp->header.param1 = 0;
     503        65557 :         chunk_rsp->header.param2 = chunk_handle;
     504              : 
     505        65557 :         chunk_copy_to = (uint8_t*) (chunk_rsp + 1);
     506        65557 :         chunk_copy_size = CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE
     507              :                           - sizeof(spdm_chunk_response_response_t);
     508              : 
     509        65557 :         if (sub_rsp_copied == 0) {
     510              : 
     511            5 :             sub_rsp = (spdm_message_header_t*) m_libspdm_local_large_response_buffer;
     512            5 :             sub_rsp_size = sizeof(m_libspdm_local_large_response_buffer);
     513            5 :             if (spdm_test_context->case_id == 0x5 ||
     514            4 :                 spdm_test_context->case_id == 0x6) {
     515            2 :                 sub_rsp =
     516              :                     (spdm_message_header_t*)
     517              :                     m_libspdm_local_response_buffer_for_chunk_seq_no_wrap_test;
     518            2 :                 sub_rsp_size = sizeof(m_libspdm_local_response_buffer_for_chunk_seq_no_wrap_test);
     519              :             }
     520            5 :             libspdm_zero_mem(sub_rsp, sub_rsp_size);
     521              : 
     522            5 :             build_response_func(spdm_context, sub_rsp, &sub_rsp_size);
     523              : 
     524            5 :             sub_rsp_remaining = sub_rsp_size;
     525            5 :             sub_rsp_copied = 0;
     526              : 
     527              :             /* first chunk has size of large response */
     528            5 :             chunk_seq_no = 0;
     529            5 :             *((uint32_t*) (chunk_rsp + 1)) = (uint32_t) sub_rsp_size;
     530              : 
     531            5 :             chunk_copy_to += sizeof(uint32_t);
     532            5 :             chunk_copy_size -= sizeof(uint32_t);
     533            5 :             chunk_copy_size = LIBSPDM_MIN(sub_rsp_remaining, chunk_copy_size);
     534            5 :             chunk_rsp_size = sizeof(spdm_chunk_response_response_t)
     535              :                              + sizeof(uint32_t) + chunk_copy_size;
     536              : 
     537              :             /* case_id 0x5 will only get 1 chunk message */
     538            5 :             if (spdm_test_context->case_id == 0x5) {
     539            1 :                 sub_rsp_size = sub_rsp_copied;
     540              :             }
     541              : 
     542              :         } else {
     543        65552 :             chunk_copy_size = LIBSPDM_MIN(sub_rsp_remaining, chunk_copy_size);
     544        65552 :             chunk_rsp_size = sizeof(spdm_chunk_response_response_t) + chunk_copy_size;
     545              :         }
     546              : 
     547        65557 :         if (chunk_copy_size == sub_rsp_remaining) {
     548            3 :             chunk_rsp->header.param1 = SPDM_CHUNK_GET_RESPONSE_ATTRIBUTE_LAST_CHUNK;
     549              :         }
     550              : 
     551        65557 :         libspdm_copy_mem(chunk_copy_to,
     552        65557 :                          *response_size - (chunk_copy_to - (uint8_t*) *response),
     553        65557 :                          (uint8_t*) sub_rsp + sub_rsp_copied,
     554              :                          chunk_copy_size);
     555              : 
     556        65557 :         sub_rsp_copied += chunk_copy_size;
     557        65557 :         sub_rsp_remaining -= chunk_copy_size;
     558        65557 :         chunk_rsp->chunk_size = (uint32_t) chunk_copy_size;
     559        65557 :         chunk_rsp->chunk_seq_no = chunk_seq_no++;
     560              : 
     561        65557 :         libspdm_transport_test_encode_message(
     562              :             spdm_context, NULL, false, false,
     563              :             chunk_rsp_size, chunk_rsp,
     564              :             response_size, response);
     565              : 
     566        65557 :         if (sub_rsp_copied >= sub_rsp_size) {
     567            4 :             sub_rsp = NULL;
     568            4 :             sub_rsp_size = 0;
     569            4 :             sub_rsp_copied = 0;
     570            4 :             sub_rsp_remaining = 0;
     571            4 :             chunk_seq_no = 0;
     572            4 :             error_large_response_sent = false;
     573              :         }
     574        65557 :         return LIBSPDM_STATUS_SUCCESS;
     575              :     }
     576            0 :     return LIBSPDM_STATUS_SEND_FAIL;
     577              : 
     578              : }
     579              : #if LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT
     580            1 : void libspdm_test_requester_chunk_get_case1(void** state)
     581              : {
     582              :     libspdm_return_t status;
     583              :     libspdm_test_context_t* spdm_test_context;
     584              :     libspdm_context_t* spdm_context;
     585              :     size_t cert_chain_size;
     586              :     uint8_t cert_chain[LIBSPDM_MAX_CERT_CHAIN_SIZE];
     587              :     void* data;
     588              :     size_t data_size;
     589              :     void* hash;
     590              :     size_t hash_size;
     591              :     const uint8_t* root_cert;
     592              :     size_t root_cert_size;
     593              :     #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     594              :     size_t count;
     595              :     #endif
     596              : 
     597            1 :     spdm_test_context = *state;
     598            1 :     spdm_context = spdm_test_context->spdm_context;
     599            1 :     spdm_test_context->case_id = 0x1;
     600            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
     601              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     602            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_DIGESTS;
     603            1 :     spdm_context->connection_info.capability.flags |=
     604              :         (SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP
     605              :          | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP
     606              :          | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP);
     607              : 
     608            1 :     spdm_context->local_context.capability.flags |=  SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP;
     609              :     spdm_context->local_context.capability.data_transfer_size
     610            1 :         = CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
     611            1 :     spdm_context->local_context.is_requester = true;
     612              : 
     613            1 :     libspdm_read_responder_public_certificate_chain(
     614              :         m_libspdm_use_hash_algo,
     615              :         m_libspdm_use_asym_algo, &data,
     616              :         &data_size, &hash, &hash_size);
     617            1 :     libspdm_x509_get_cert_from_cert_chain(
     618            1 :         (uint8_t*) data + sizeof(spdm_cert_chain_t) + hash_size,
     619            1 :         data_size - sizeof(spdm_cert_chain_t) - hash_size, 0,
     620              :         &root_cert, &root_cert_size);
     621            1 :     LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "root cert data :\n"));
     622            1 :     libspdm_dump_hex(root_cert, root_cert_size);
     623            1 :     spdm_context->local_context.peer_root_cert_provision_size[0] = root_cert_size;
     624              : 
     625            1 :     spdm_context->local_context.peer_root_cert_provision[0] = root_cert;
     626            1 :     libspdm_reset_message_b(spdm_context);
     627            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     628            1 :     spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
     629            1 :     spdm_context->connection_info.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
     630              : 
     631              :     #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     632              :     spdm_context->transcript.message_m.buffer_size =
     633              :         spdm_context->transcript.message_m.max_buffer_size;
     634              :     #endif
     635            1 :     cert_chain_size = sizeof(cert_chain);
     636            1 :     libspdm_zero_mem(cert_chain, sizeof(cert_chain));
     637            1 :     status = libspdm_get_certificate(spdm_context, NULL, 0, &cert_chain_size, cert_chain);
     638            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     639              :     #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     640              :     count = (data_size + LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN - 1) / LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN;
     641              :     assert_int_equal(spdm_context->transcript.message_b.buffer_size,
     642              :                      sizeof(spdm_get_certificate_request_t) * count +
     643              :                      sizeof(spdm_certificate_response_t) * count +
     644              :                      data_size);
     645              :     assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
     646              :     spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = 0;
     647              :     #else
     648            1 :     spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size = 0;
     649              :     #endif
     650            1 :     free(data);
     651            1 : }
     652              : #endif
     653              : #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
     654            1 : void libspdm_test_requester_chunk_get_case2(void** state)
     655              : {
     656              :     /* Copied from Get Measurements Test Case 0x20 */
     657              :     libspdm_return_t status;
     658              :     libspdm_test_context_t* spdm_test_context;
     659              :     libspdm_context_t* spdm_context;
     660              :     uint8_t number_of_block;
     661              :     uint32_t measurement_record_length;
     662              :     uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
     663              :     uint8_t request_attribute;
     664              :     void* data;
     665              :     size_t data_size;
     666              :     void* hash;
     667              :     size_t hash_size;
     668              : 
     669            1 :     spdm_test_context = *state;
     670            1 :     spdm_context = spdm_test_context->spdm_context;
     671            1 :     spdm_test_context->case_id = 0x02;
     672            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
     673              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     674            1 :     spdm_context->connection_info.connection_state =
     675              :         LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
     676            1 :     spdm_context->connection_info.capability.flags |=
     677              :         (SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG
     678              :          | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP);
     679              : 
     680            1 :     spdm_context->local_context.capability.flags |=
     681              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP;
     682              :     spdm_context->local_context.capability.data_transfer_size
     683            1 :         = CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
     684              : 
     685            1 :     libspdm_read_responder_public_certificate_chain(
     686              :         m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
     687              :         &data, &data_size, &hash, &hash_size);
     688            1 :     libspdm_reset_message_m(spdm_context, NULL);
     689            1 :     spdm_context->connection_info.algorithm.measurement_spec =
     690              :         m_libspdm_use_measurement_spec;
     691            1 :     spdm_context->connection_info.algorithm.measurement_hash_algo =
     692              :         m_libspdm_use_measurement_hash_algo;
     693            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
     694              :         m_libspdm_use_hash_algo;
     695            1 :     spdm_context->connection_info.algorithm.base_asym_algo =
     696              :         m_libspdm_use_asym_algo;
     697            1 :     spdm_context->local_context.algorithm.measurement_spec =
     698              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF;
     699              :     #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     700              :     spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
     701              :     libspdm_copy_mem(
     702              :         spdm_context->connection_info.peer_used_cert_chain[0].buffer,
     703              :         sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
     704              :         data, data_size);
     705              :     #else
     706            1 :     libspdm_hash_all(
     707              :         spdm_context->connection_info.algorithm.base_hash_algo,
     708              :         data, data_size,
     709            1 :         spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
     710            1 :     spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
     711            1 :         libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
     712            1 :     libspdm_get_leaf_cert_public_key_from_cert_chain(
     713              :         spdm_context->connection_info.algorithm.base_hash_algo,
     714              :         spdm_context->connection_info.algorithm.base_asym_algo,
     715              :         data, data_size,
     716              :         &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
     717              :     #endif
     718            1 :     request_attribute = 0;
     719              : 
     720            1 :     measurement_record_length = sizeof(measurement_record);
     721            1 :     status = libspdm_get_measurement(
     722              :         spdm_context, NULL, request_attribute,
     723              :         SPDM_GET_MEASUREMENTS_REQUEST_MEASUREMENT_OPERATION_ALL_MEASUREMENTS,
     724              :         0, NULL, &number_of_block, &measurement_record_length,
     725              :         measurement_record);
     726            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     727              :     #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     728              :     assert_int_equal(spdm_context->transcript.message_m.buffer_size,
     729              :                      sizeof(spdm_message_header_t) +
     730              :                      sizeof(spdm_measurements_response_t) +
     731              :                      2 * (sizeof(spdm_measurement_block_dmtf_t) +
     732              :                           libspdm_get_measurement_hash_size(
     733              :                               m_libspdm_use_measurement_hash_algo)) +
     734              :                      sizeof(uint16_t) + SPDM_NONCE_SIZE);
     735              :     spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = 0;
     736              :     #else
     737            1 :     spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size = 0;
     738              :     #endif
     739            1 :     free(data);
     740            1 : }
     741              : #endif
     742              : #if LIBSPDM_ENABLE_CAPABILITY_CHAL_CAP
     743            1 : void libspdm_test_requester_chunk_get_case3(void** state)
     744              : {
     745              :     /* Copied from Challenge Test Case 2*/
     746              :     libspdm_return_t status;
     747              :     libspdm_test_context_t* spdm_test_context;
     748              :     libspdm_context_t* spdm_context;
     749              :     uint8_t measurement_hash[LIBSPDM_MAX_HASH_SIZE];
     750              :     void* data;
     751              :     size_t data_size;
     752              :     void* hash;
     753              :     size_t hash_size;
     754              : 
     755            1 :     spdm_test_context = *state;
     756            1 :     spdm_context = spdm_test_context->spdm_context;
     757            1 :     spdm_test_context->case_id = 0x3;
     758            1 :     spdm_context->connection_info.connection_state =
     759              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     760            1 :     spdm_context->connection_info.capability.flags = 0;
     761            1 :     spdm_context->connection_info.capability.flags |=
     762              :         (SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP
     763              :          | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP);
     764              : 
     765            1 :     spdm_context->local_context.capability.flags |=
     766              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP;
     767              :     spdm_context->local_context.capability.data_transfer_size
     768            1 :         = CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
     769              : 
     770            1 :     libspdm_read_responder_public_certificate_chain(
     771              :         m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
     772              :         &data, &data_size, &hash, &hash_size);
     773            1 :     libspdm_reset_message_a(spdm_context);
     774            1 :     libspdm_reset_message_b(spdm_context);
     775            1 :     libspdm_reset_message_c(spdm_context);
     776            1 :     spdm_context->connection_info.algorithm.base_hash_algo =
     777              :         m_libspdm_use_hash_algo;
     778            1 :     spdm_context->connection_info.algorithm.base_asym_algo =
     779              :         m_libspdm_use_asym_algo;
     780              : 
     781            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
     782              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     783              : 
     784              :     #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     785              :     spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
     786              :     libspdm_copy_mem(
     787              :         spdm_context->connection_info.peer_used_cert_chain[0].buffer,
     788              :         sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
     789              :         data, data_size);
     790              :     #else
     791            1 :     libspdm_hash_all(
     792              :         spdm_context->connection_info.algorithm.base_hash_algo,
     793              :         data, data_size,
     794            1 :         spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
     795            1 :     spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
     796            1 :         libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
     797            1 :     libspdm_get_leaf_cert_public_key_from_cert_chain(
     798              :         spdm_context->connection_info.algorithm.base_hash_algo,
     799              :         spdm_context->connection_info.algorithm.base_asym_algo,
     800              :         data, data_size,
     801              :         &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
     802              :     #endif
     803              : 
     804            1 :     libspdm_zero_mem(measurement_hash, sizeof(measurement_hash));
     805            1 :     status = libspdm_challenge(
     806              :         spdm_context, NULL, 0,
     807              :         SPDM_CHALLENGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH,
     808              :         measurement_hash, NULL);
     809            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     810            1 :     free(data);
     811              :     #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     812              :     spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = 0;
     813              :     #else
     814            1 :     spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size = 0;
     815              :     #endif
     816            1 : }
     817              : #endif
     818              : #if LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT
     819            1 : void libspdm_test_requester_chunk_get_case4(void** state)
     820              : {
     821              :     /* Copied from Get Digests Test Case 2*/
     822              :     libspdm_return_t status;
     823              :     libspdm_test_context_t* spdm_test_context;
     824              :     libspdm_context_t* spdm_context;
     825              :     libspdm_data_parameter_t parameter;
     826              :     uint8_t slot_mask;
     827              :     uint8_t slot_id;
     828              :     uint8_t total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
     829              :     uint8_t my_total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
     830              :     uint8_t* digest;
     831              :     size_t data_return_size;
     832              : 
     833            1 :     spdm_test_context = *state;
     834            1 :     spdm_context = spdm_test_context->spdm_context;
     835            1 :     spdm_test_context->case_id = 0x4;
     836            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
     837              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     838            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     839            1 :     spdm_context->connection_info.capability.flags |=
     840              :         (SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP
     841              :          | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP);
     842              : 
     843            1 :     spdm_context->local_context.capability.flags |=
     844              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP;
     845              :     spdm_context->local_context.capability.data_transfer_size
     846            1 :         = CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
     847              : 
     848            1 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     849              : 
     850            1 :     libspdm_set_mem(
     851              :         m_libspdm_local_certificate_chain_test_case_4,
     852              :         sizeof(m_libspdm_local_certificate_chain_test_case_4),
     853              :         (uint8_t) (0xFF));
     854            1 :     libspdm_reset_message_b(spdm_context);
     855              : 
     856              :     #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     857              :     spdm_context->transcript.message_m.buffer_size =
     858              :         spdm_context->transcript.message_m.max_buffer_size;
     859              :     #endif
     860            1 :     libspdm_zero_mem(total_digest_buffer, sizeof(total_digest_buffer));
     861            1 :     status = libspdm_get_digest(spdm_context, NULL, &slot_mask, &total_digest_buffer);
     862            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     863              : 
     864            1 :     assert_int_equal(slot_mask, 0xFF);
     865            1 :     libspdm_zero_mem(my_total_digest_buffer, sizeof(my_total_digest_buffer));
     866            1 :     digest = my_total_digest_buffer;
     867            9 :     for (slot_id = 0; slot_id < SPDM_MAX_SLOT_COUNT; slot_id++) {
     868            8 :         libspdm_hash_all(m_libspdm_use_hash_algo,
     869              :                          m_libspdm_local_certificate_chain_test_case_4,
     870              :                          sizeof(m_libspdm_local_certificate_chain_test_case_4), digest);
     871            8 :         digest += libspdm_get_hash_size(m_libspdm_use_hash_algo);
     872              :     }
     873            1 :     assert_memory_equal(total_digest_buffer, my_total_digest_buffer,
     874              :                         sizeof(my_total_digest_buffer));
     875              : 
     876            1 :     parameter.location = LIBSPDM_DATA_LOCATION_CONNECTION;
     877            1 :     data_return_size = sizeof(uint8_t);
     878            1 :     status = libspdm_get_data(spdm_context, LIBSPDM_DATA_PEER_SLOT_MASK,
     879              :                               &parameter, &slot_mask, &data_return_size);
     880            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     881            1 :     assert_int_equal(data_return_size, sizeof(uint8_t));
     882            1 :     assert_int_equal(slot_mask, 0xFF);
     883              : 
     884            1 :     data_return_size = sizeof(total_digest_buffer);
     885            1 :     status = libspdm_get_data(spdm_context, LIBSPDM_DATA_PEER_TOTAL_DIGEST_BUFFER,
     886              :                               &parameter, total_digest_buffer, &data_return_size);
     887            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     888            1 :     assert_int_equal(data_return_size, libspdm_get_hash_size(
     889              :                          m_libspdm_use_hash_algo) * SPDM_MAX_SLOT_COUNT);
     890            1 :     assert_memory_equal(total_digest_buffer, my_total_digest_buffer,
     891              :                         sizeof(my_total_digest_buffer));
     892              : 
     893              :     #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     894              :     assert_int_equal(
     895              :         spdm_context->transcript.message_b.buffer_size,
     896              :         sizeof(spdm_get_digest_request_t) +
     897              :         sizeof(spdm_digest_response_t) +
     898              :         libspdm_get_hash_size(spdm_context->connection_info
     899              :                               .algorithm.base_hash_algo) * SPDM_MAX_SLOT_COUNT);
     900              :     assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
     901              :     #endif
     902            1 : }
     903              : #endif
     904              : 
     905              : #if LIBSPDM_ENABLE_VENDOR_DEFINED_MESSAGES
     906            1 : static void libspdm_test_requester_chunk_get_case5(void **state)
     907              : {
     908              :     /* Copied from Vendor Request case 1*/
     909              :     libspdm_return_t status;
     910              :     libspdm_test_context_t *spdm_test_context;
     911              :     libspdm_context_t *spdm_context;
     912              : 
     913            1 :     uint16_t standard_id = 6;
     914            1 :     uint8_t vendor_id_len = 2;
     915            1 :     uint8_t vendor_id[SPDM_MAX_VENDOR_ID_LENGTH] = {0xAA, 0xAA};
     916            1 :     uint16_t data_len = 16;
     917              :     uint8_t data[16];
     918              : 
     919            1 :     spdm_test_context = *state;
     920            1 :     spdm_context = spdm_test_context->spdm_context;
     921            1 :     spdm_test_context->case_id = 0x5;
     922            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
     923              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     924              :     /* Large response need a large scratch buffer. */
     925            1 :     spdm_context->connection_info.capability.max_spdm_msg_size =
     926              :         BUFFER_SIZE_FOR_CHUNK_SEQ_NO_WRAP_TEST;
     927            1 :     spdm_context->local_context.capability.max_spdm_msg_size =
     928              :         BUFFER_SIZE_FOR_CHUNK_SEQ_NO_WRAP_TEST;
     929            1 :     spdm_context->connection_info.connection_state =
     930              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     931            1 :     spdm_context->local_context.capability.data_transfer_size =
     932              :         CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
     933            1 :     spdm_context->connection_info.capability.data_transfer_size =
     934              :         CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
     935            1 :     spdm_context->local_context.capability.sender_data_transfer_size =
     936              :         CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
     937            1 :     spdm_context->local_context.is_requester = true;
     938              : 
     939            1 :     spdm_test_context->scratch_buffer_size =
     940            1 :         libspdm_get_sizeof_required_scratch_buffer(spdm_context);
     941            1 :     spdm_test_context->scratch_buffer = (void *)malloc(spdm_test_context->scratch_buffer_size);
     942            1 :     libspdm_set_scratch_buffer (spdm_context,
     943              :                                 spdm_test_context->scratch_buffer,
     944              :                                 spdm_test_context->scratch_buffer_size);
     945              : 
     946            1 :     libspdm_set_mem(data, sizeof(data), 0xAA);
     947              : 
     948            1 :     status = libspdm_vendor_send_request_receive_response(spdm_context, NULL,
     949              :                                                           standard_id, vendor_id_len, vendor_id,
     950              :                                                           data_len, data,
     951              :                                                           &standard_id, &vendor_id_len, vendor_id,
     952              :                                                           &data_len, data);
     953              : 
     954            1 :     assert_int_equal(status, LIBSPDM_STATUS_RECEIVE_FAIL);
     955            1 : }
     956              : 
     957            1 : static void libspdm_test_requester_chunk_get_case6(void **state)
     958              : {
     959              :     /* Copied from Chunk Get Request case 5*/
     960              :     libspdm_return_t status;
     961              :     libspdm_test_context_t *spdm_test_context;
     962              :     libspdm_context_t *spdm_context;
     963              : 
     964            1 :     uint16_t standard_id = 6;
     965            1 :     uint8_t vendor_id_len = 2;
     966            1 :     uint8_t vendor_id[SPDM_MAX_VENDOR_ID_LENGTH] = {0xAA, 0xAA};
     967            1 :     uint16_t data_len = 16;
     968              :     uint8_t data[16];
     969              : 
     970            1 :     spdm_test_context = *state;
     971            1 :     spdm_context = spdm_test_context->spdm_context;
     972            1 :     spdm_test_context->case_id = 0x6;
     973            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
     974              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     975              :     /* Large response need a large scratch buffer. */
     976            1 :     spdm_context->connection_info.capability.max_spdm_msg_size =
     977              :         BUFFER_SIZE_FOR_CHUNK_SEQ_NO_WRAP_TEST;
     978            1 :     spdm_context->local_context.capability.max_spdm_msg_size =
     979              :         BUFFER_SIZE_FOR_CHUNK_SEQ_NO_WRAP_TEST;
     980            1 :     spdm_context->connection_info.connection_state =
     981              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
     982              :     /* to pass the exam of max_chunk_data_transfer_size*/
     983            1 :     spdm_context->local_context.capability.data_transfer_size =
     984              :         CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE + 0x10;
     985            1 :     spdm_context->connection_info.capability.data_transfer_size =
     986              :         CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE + 0x10;
     987            1 :     spdm_context->local_context.capability.sender_data_transfer_size =
     988              :         CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE + 0x10;
     989            1 :     spdm_context->local_context.is_requester = true;
     990              : 
     991            1 :     spdm_test_context->scratch_buffer_size =
     992            1 :         libspdm_get_sizeof_required_scratch_buffer(spdm_context);
     993            1 :     spdm_test_context->scratch_buffer = (void *)malloc(spdm_test_context->scratch_buffer_size);
     994            1 :     libspdm_set_scratch_buffer (spdm_context,
     995              :                                 spdm_test_context->scratch_buffer,
     996              :                                 spdm_test_context->scratch_buffer_size);
     997              : 
     998            1 :     libspdm_set_mem(data, sizeof(data), 0xAA);
     999              : 
    1000            1 :     status = libspdm_vendor_send_request_receive_response(spdm_context, NULL,
    1001              :                                                           standard_id, vendor_id_len, vendor_id,
    1002              :                                                           data_len, data,
    1003              :                                                           &standard_id, &vendor_id_len, vendor_id,
    1004              :                                                           &data_len, data);
    1005              : 
    1006            1 :     assert_int_equal(status, LIBSPDM_STATUS_RECEIVE_FAIL);
    1007            1 : }
    1008              : 
    1009            1 : static void libspdm_test_requester_chunk_get_case7(void **state)
    1010              : {
    1011              :     /* Copied from Chunk Get Request case 5*/
    1012              :     libspdm_return_t status;
    1013              :     libspdm_test_context_t *spdm_test_context;
    1014              :     libspdm_context_t *spdm_context;
    1015              : 
    1016            1 :     uint16_t standard_id = 6;
    1017            1 :     uint8_t vendor_id_len = 2;
    1018            1 :     uint8_t vendor_id[SPDM_MAX_VENDOR_ID_LENGTH] = {0xAA, 0xAA};
    1019            1 :     uint16_t data_len = 16;
    1020              :     uint8_t data[16];
    1021              : 
    1022            1 :     spdm_test_context = *state;
    1023            1 :     spdm_context = spdm_test_context->spdm_context;
    1024            1 :     spdm_test_context->case_id = 0x7;
    1025            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
    1026              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1027              :     /* Large response need a large scratch buffer. */
    1028            1 :     spdm_context->connection_info.capability.max_spdm_msg_size =
    1029              :         BUFFER_SIZE_FOR_CHUNK_SEQ_NO_WRAP_TEST;
    1030            1 :     spdm_context->local_context.capability.max_spdm_msg_size =
    1031              :         BUFFER_SIZE_FOR_CHUNK_SEQ_NO_WRAP_TEST;
    1032            1 :     spdm_context->connection_info.connection_state =
    1033              :         LIBSPDM_CONNECTION_STATE_NEGOTIATED;
    1034            1 :     spdm_context->local_context.capability.data_transfer_size =
    1035              :         CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
    1036            1 :     spdm_context->connection_info.capability.data_transfer_size =
    1037              :         CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
    1038            1 :     spdm_context->local_context.capability.sender_data_transfer_size =
    1039              :         CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
    1040            1 :     spdm_context->local_context.is_requester = true;
    1041              : 
    1042            1 :     spdm_test_context->scratch_buffer_size =
    1043            1 :         libspdm_get_sizeof_required_scratch_buffer(spdm_context);
    1044            1 :     spdm_test_context->scratch_buffer = (void *)malloc(spdm_test_context->scratch_buffer_size);
    1045            1 :     libspdm_set_scratch_buffer (spdm_context,
    1046              :                                 spdm_test_context->scratch_buffer,
    1047              :                                 spdm_test_context->scratch_buffer_size);
    1048              : 
    1049            1 :     libspdm_set_mem(data, sizeof(data), 0xAA);
    1050              : 
    1051            1 :     status = libspdm_vendor_send_request_receive_response(spdm_context, NULL,
    1052              :                                                           standard_id, vendor_id_len, vendor_id,
    1053              :                                                           data_len, data,
    1054              :                                                           &standard_id, &vendor_id_len, vendor_id,
    1055              :                                                           &data_len, data);
    1056              : 
    1057            1 :     assert_int_equal(status, LIBSPDM_STATUS_RESYNCH_PEER);
    1058            1 :     assert_int_equal(spdm_context->connection_info.connection_state,
    1059              :                      LIBSPDM_CONNECTION_STATE_NOT_STARTED);
    1060            1 : }
    1061              : #endif /* LIBSPDM_ENABLE_VENDOR_DEFINED_MESSAGES */
    1062              : 
    1063            1 : int libspdm_requester_chunk_get_test_main(void)
    1064              : {
    1065              :     /* Test the CHUNK_GET handlers in various requester handlers */
    1066            1 :     const struct CMUnitTest spdm_requester_chunk_get_tests[] = {
    1067              : #if LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT
    1068              :         /* Request a certificate in portions */
    1069              :         cmocka_unit_test(libspdm_test_requester_chunk_get_case1),
    1070              : #endif
    1071              : #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
    1072              :         /* Request all measurements */
    1073              :         cmocka_unit_test(libspdm_test_requester_chunk_get_case2),
    1074              : #endif
    1075              : #if LIBSPDM_ENABLE_CAPABILITY_CHAL_CAP
    1076              :         /* Request Challenge */
    1077              :         cmocka_unit_test(libspdm_test_requester_chunk_get_case3),
    1078              : #endif
    1079              : #if LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT
    1080              :         /* Request Digests */
    1081              :         cmocka_unit_test(libspdm_test_requester_chunk_get_case4),
    1082              : #endif
    1083              : #if LIBSPDM_ENABLE_VENDOR_DEFINED_MESSAGES
    1084              :         /* Request Vendor Specific Response and chunk data size
    1085              :          * exceed max_chunk_data_transfer_size
    1086              :          */
    1087              :         cmocka_unit_test(libspdm_test_requester_chunk_get_case5),
    1088              :         /* Request Vendor Specific Response and chunk seq no wrapped */
    1089              :         cmocka_unit_test(libspdm_test_requester_chunk_get_case6),
    1090              :         /* Request Vendor Specific Response
    1091              :          * and recieve error code RequestResync */
    1092              :         cmocka_unit_test(libspdm_test_requester_chunk_get_case7),
    1093              : #endif
    1094              :     };
    1095              : 
    1096            1 :     libspdm_test_context_t test_context = {
    1097              :         LIBSPDM_TEST_CONTEXT_VERSION,
    1098              :         true,
    1099              :         libspdm_requester_chunk_get_test_send_message,
    1100              :         libspdm_requester_chunk_get_test_receive_message,
    1101              :     };
    1102              : 
    1103            1 :     libspdm_setup_test_context(&test_context);
    1104              : 
    1105            1 :     return cmocka_run_group_tests(spdm_requester_chunk_get_tests,
    1106              :                                   libspdm_unit_test_group_setup,
    1107              :                                   libspdm_unit_test_group_teardown);
    1108              : }
    1109              : 
    1110              : #endif /* LIBSPDM_ENABLE_CAPABILITY_CHUNK_CAP*/
        

Generated by: LCOV version 2.0-1