LCOV - code coverage report
Current view: top level - unit_test/test_spdm_responder - set_key_pair_info_ack.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 100.0 % 260 260
Test Date: 2025-06-29 08:09:00 Functions: 100.0 % 4 4

            Line data    Source code
       1              : /**
       2              :  *  Copyright Notice:
       3              :  *  Copyright 2024 DMTF. All rights reserved.
       4              :  *  License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
       5              :  **/
       6              : 
       7              : #include "spdm_unit_test.h"
       8              : #include "internal/libspdm_responder_lib.h"
       9              : #include "internal/libspdm_requester_lib.h"
      10              : 
      11              : #if LIBSPDM_ENABLE_CAPABILITY_SET_KEY_PAIR_INFO_CAP
      12              : 
      13              : /**
      14              :  * Test 1: Successful response to set key pair info with key pair id 4
      15              :  * Expected Behavior: get a RETURN_SUCCESS return code, and correct response message size and fields
      16              :  **/
      17            1 : void libspdm_test_responder_set_key_pair_info_ack_case1(void **state)
      18              : {
      19              :     libspdm_return_t status;
      20              :     libspdm_test_context_t *spdm_test_context;
      21              :     libspdm_context_t *spdm_context;
      22              :     size_t response_size;
      23              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
      24              :     spdm_set_key_pair_info_ack_response_t *spdm_response;
      25              : 
      26              :     uint8_t key_pair_id;
      27              :     size_t set_key_pair_info_request_size;
      28              :     spdm_set_key_pair_info_request_t *set_key_pair_info_request;
      29              :     uint8_t *ptr;
      30              :     uint16_t desired_key_usage;
      31              :     uint32_t desired_asym_algo;
      32              :     uint8_t desired_assoc_cert_slot_mask;
      33              : 
      34            1 :     set_key_pair_info_request = malloc(sizeof(spdm_set_key_pair_info_request_t) +
      35              :                                        sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) +
      36              :                                        sizeof(uint8_t));
      37              : 
      38            1 :     spdm_test_context = *state;
      39            1 :     spdm_context = spdm_test_context->spdm_context;
      40            1 :     spdm_test_context->case_id = 0x1;
      41            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
      42              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
      43            1 :     spdm_context->connection_info.connection_state =
      44              :         LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
      45            1 :     spdm_context->connection_info.algorithm.base_asym_algo =
      46              :         m_libspdm_use_asym_algo;
      47            1 :     spdm_context->local_context.capability.flags |=
      48              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_SET_KEY_PAIR_INFO_CAP;
      49            1 :     spdm_context->local_context.total_key_pairs = libspdm_read_total_key_pairs();
      50            1 :     key_pair_id = 4;
      51              : 
      52            1 :     response_size = sizeof(response);
      53              : 
      54              :     /*change: remove an association with slot*/
      55            1 :     set_key_pair_info_request_size =
      56              :         sizeof(spdm_set_key_pair_info_request_t) +
      57              :         sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t);
      58              : 
      59            1 :     libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
      60            1 :     set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
      61            1 :     set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
      62            1 :     set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
      63            1 :     set_key_pair_info_request->header.param2 = 0;
      64            1 :     set_key_pair_info_request->key_pair_id = key_pair_id;
      65              : 
      66            1 :     status = libspdm_get_response_set_key_pair_info_ack(
      67              :         spdm_context, set_key_pair_info_request_size,
      68              :         set_key_pair_info_request, &response_size, response);
      69            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
      70            1 :     assert_int_equal(response_size,
      71              :                      sizeof(spdm_set_key_pair_info_ack_response_t));
      72            1 :     spdm_response = (void *)response;
      73            1 :     assert_int_equal(spdm_response->header.request_response_code,
      74              :                      SPDM_SET_KEY_PAIR_INFO_ACK);
      75              : 
      76              :     /*erase: erase the keyusage and asymalgo*/
      77            1 :     set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_ERASE_OPERATION;
      78            1 :     set_key_pair_info_request_size =
      79              :         sizeof(spdm_set_key_pair_info_request_t);
      80            1 :     status = libspdm_get_response_set_key_pair_info_ack(
      81              :         spdm_context, set_key_pair_info_request_size,
      82              :         set_key_pair_info_request, &response_size, response);
      83            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
      84            1 :     assert_int_equal(response_size,
      85              :                      sizeof(spdm_set_key_pair_info_ack_response_t));
      86            1 :     spdm_response = (void *)response;
      87            1 :     assert_int_equal(spdm_response->header.request_response_code,
      88              :                      SPDM_SET_KEY_PAIR_INFO_ACK);
      89              : 
      90              :     /*generate: generate a new key pair*/
      91            1 :     desired_key_usage = SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE;
      92            1 :     desired_asym_algo = SPDM_KEY_PAIR_ASYM_ALGO_CAP_ECC256;
      93            1 :     desired_assoc_cert_slot_mask = 0x08;
      94            1 :     set_key_pair_info_request_size =
      95              :         sizeof(spdm_set_key_pair_info_request_t) +
      96              :         sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t);
      97              : 
      98            1 :     libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
      99            1 :     set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     100            1 :     set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
     101            1 :     set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
     102            1 :     set_key_pair_info_request->header.param2 = 0;
     103            1 :     set_key_pair_info_request->key_pair_id = key_pair_id;
     104              : 
     105            1 :     ptr = (uint8_t*)(set_key_pair_info_request + 1);
     106            1 :     ptr += sizeof(uint8_t);
     107              : 
     108            1 :     libspdm_write_uint16(ptr, desired_key_usage);
     109            1 :     ptr += sizeof(uint16_t);
     110              : 
     111            1 :     libspdm_write_uint32(ptr, desired_asym_algo);
     112            1 :     ptr += sizeof(uint32_t);
     113              : 
     114            1 :     *ptr = desired_assoc_cert_slot_mask;
     115              : 
     116            1 :     status = libspdm_get_response_set_key_pair_info_ack(
     117              :         spdm_context, set_key_pair_info_request_size,
     118              :         set_key_pair_info_request, &response_size, response);
     119            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     120            1 :     assert_int_equal(response_size,
     121              :                      sizeof(spdm_set_key_pair_info_ack_response_t));
     122            1 :     spdm_response = (void *)response;
     123            1 :     assert_int_equal(spdm_response->header.request_response_code,
     124              :                      SPDM_SET_KEY_PAIR_INFO_ACK);
     125            1 :     free(set_key_pair_info_request);
     126            1 : }
     127              : 
     128              : /**
     129              :  * Test 2: Successful response to set key pair info with key pair id 4: need reset
     130              :  * Expected Behavior: get a RETURN_SUCCESS return code, and correct response message size and fields
     131              :  **/
     132            1 : void libspdm_test_responder_set_key_pair_info_ack_case2(void **state)
     133              : {
     134              :     libspdm_return_t status;
     135              :     libspdm_test_context_t *spdm_test_context;
     136              :     libspdm_context_t *spdm_context;
     137              :     size_t response_size;
     138              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     139              :     spdm_set_key_pair_info_ack_response_t *spdm_response;
     140              : 
     141              :     uint8_t key_pair_id;
     142              :     size_t set_key_pair_info_request_size;
     143              :     spdm_set_key_pair_info_request_t *set_key_pair_info_request;
     144              :     uint8_t *ptr;
     145              :     uint16_t desired_key_usage;
     146              :     uint32_t desired_asym_algo;
     147              :     uint8_t desired_assoc_cert_slot_mask;
     148              : 
     149            1 :     set_key_pair_info_request = malloc(sizeof(spdm_set_key_pair_info_request_t) +
     150              :                                        sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) +
     151              :                                        sizeof(uint8_t));
     152              : 
     153            1 :     spdm_test_context = *state;
     154            1 :     spdm_context = spdm_test_context->spdm_context;
     155            1 :     spdm_test_context->case_id = 0x2;
     156            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
     157              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     158            1 :     spdm_context->connection_info.connection_state =
     159              :         LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
     160            1 :     spdm_context->connection_info.algorithm.base_asym_algo =
     161              :         m_libspdm_use_asym_algo;
     162            1 :     spdm_context->local_context.capability.flags |=
     163              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_SET_KEY_PAIR_INFO_CAP;
     164            1 :     spdm_context->local_context.total_key_pairs = libspdm_read_total_key_pairs();
     165            1 :     key_pair_id = 4;
     166              : 
     167              :     /*set responder need reset*/
     168            1 :     spdm_context->local_context.capability.flags |=
     169              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_INSTALL_RESET_CAP;
     170              : 
     171            1 :     response_size = sizeof(response);
     172              : 
     173              :     /*Before reset, change: remove an association with slot*/
     174            1 :     set_key_pair_info_request_size =
     175              :         sizeof(spdm_set_key_pair_info_request_t) +
     176              :         sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t);
     177              : 
     178            1 :     libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
     179            1 :     set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     180            1 :     set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
     181            1 :     set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
     182            1 :     set_key_pair_info_request->header.param2 = 0;
     183            1 :     set_key_pair_info_request->key_pair_id = key_pair_id;
     184              : 
     185            1 :     status = libspdm_get_response_set_key_pair_info_ack(
     186              :         spdm_context, set_key_pair_info_request_size,
     187              :         set_key_pair_info_request, &response_size, response);
     188            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     189            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     190            1 :     spdm_response = (void *)response;
     191            1 :     assert_int_equal(spdm_response->header.request_response_code,
     192              :                      SPDM_ERROR);
     193            1 :     assert_int_equal(spdm_response->header.param1,
     194              :                      SPDM_ERROR_CODE_RESET_REQUIRED);
     195            1 :     assert_int_equal(spdm_response->header.param2, 0);
     196              : 
     197              :     /*After reset, change: remove an association with slot*/
     198            1 :     status = libspdm_get_response_set_key_pair_info_ack(
     199              :         spdm_context, set_key_pair_info_request_size,
     200              :         set_key_pair_info_request, &response_size, response);
     201            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     202            1 :     assert_int_equal(response_size,
     203              :                      sizeof(spdm_set_key_pair_info_ack_response_t));
     204            1 :     spdm_response = (void *)response;
     205            1 :     assert_int_equal(spdm_response->header.request_response_code,
     206              :                      SPDM_SET_KEY_PAIR_INFO_ACK);
     207              : 
     208              :     /*Before reset, erase: erase the keyusage and asymalgo*/
     209            1 :     set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_ERASE_OPERATION;
     210            1 :     set_key_pair_info_request_size =
     211              :         sizeof(spdm_set_key_pair_info_request_t);
     212            1 :     status = libspdm_get_response_set_key_pair_info_ack(
     213              :         spdm_context, set_key_pair_info_request_size,
     214              :         set_key_pair_info_request, &response_size, response);
     215            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     216            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     217            1 :     spdm_response = (void *)response;
     218            1 :     assert_int_equal(spdm_response->header.request_response_code,
     219              :                      SPDM_ERROR);
     220            1 :     assert_int_equal(spdm_response->header.param1,
     221              :                      SPDM_ERROR_CODE_RESET_REQUIRED);
     222            1 :     assert_int_equal(spdm_response->header.param2, 0);
     223              : 
     224              :     /*After reset, erase: erase the keyusage and asymalgo*/
     225            1 :     status = libspdm_get_response_set_key_pair_info_ack(
     226              :         spdm_context, set_key_pair_info_request_size,
     227              :         set_key_pair_info_request, &response_size, response);
     228            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     229            1 :     assert_int_equal(response_size,
     230              :                      sizeof(spdm_set_key_pair_info_ack_response_t));
     231            1 :     spdm_response = (void *)response;
     232            1 :     assert_int_equal(spdm_response->header.request_response_code,
     233              :                      SPDM_SET_KEY_PAIR_INFO_ACK);
     234              : 
     235              : 
     236              :     /*Before reset, generate: generate a new key pair*/
     237            1 :     desired_key_usage = SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE;
     238            1 :     desired_asym_algo = SPDM_KEY_PAIR_ASYM_ALGO_CAP_ECC256;
     239            1 :     desired_assoc_cert_slot_mask = 0x08;
     240            1 :     set_key_pair_info_request_size =
     241              :         sizeof(spdm_set_key_pair_info_request_t) +
     242              :         sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t);
     243              : 
     244            1 :     libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
     245            1 :     set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     246            1 :     set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
     247            1 :     set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
     248            1 :     set_key_pair_info_request->header.param2 = 0;
     249            1 :     set_key_pair_info_request->key_pair_id = key_pair_id;
     250              : 
     251            1 :     ptr = (uint8_t*)(set_key_pair_info_request + 1);
     252            1 :     ptr += sizeof(uint8_t);
     253              : 
     254            1 :     libspdm_write_uint16(ptr, desired_key_usage);
     255            1 :     ptr += sizeof(uint16_t);
     256              : 
     257            1 :     libspdm_write_uint32(ptr, desired_asym_algo);
     258            1 :     ptr += sizeof(uint32_t);
     259              : 
     260            1 :     *ptr = desired_assoc_cert_slot_mask;
     261              : 
     262            1 :     status = libspdm_get_response_set_key_pair_info_ack(
     263              :         spdm_context, set_key_pair_info_request_size,
     264              :         set_key_pair_info_request, &response_size, response);
     265            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     266            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     267            1 :     spdm_response = (void *)response;
     268            1 :     assert_int_equal(spdm_response->header.request_response_code,
     269              :                      SPDM_ERROR);
     270            1 :     assert_int_equal(spdm_response->header.param1,
     271              :                      SPDM_ERROR_CODE_RESET_REQUIRED);
     272            1 :     assert_int_equal(spdm_response->header.param2, 0);
     273              : 
     274              :     /*After reset, generate: generate a new key pair*/
     275            1 :     status = libspdm_get_response_set_key_pair_info_ack(
     276              :         spdm_context, set_key_pair_info_request_size,
     277              :         set_key_pair_info_request, &response_size, response);
     278            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     279            1 :     assert_int_equal(response_size,
     280              :                      sizeof(spdm_set_key_pair_info_ack_response_t));
     281            1 :     spdm_response = (void *)response;
     282            1 :     assert_int_equal(spdm_response->header.request_response_code,
     283              :                      SPDM_SET_KEY_PAIR_INFO_ACK);
     284            1 :     free(set_key_pair_info_request);
     285            1 : }
     286              : 
     287              : /**
     288              :  * Test 2: The collection of multiple sub-cases.
     289              :  **/
     290            1 : void libspdm_test_responder_set_key_pair_info_ack_case3(void **state)
     291              : {
     292              :     libspdm_return_t status;
     293              :     libspdm_test_context_t *spdm_test_context;
     294              :     libspdm_context_t *spdm_context;
     295              :     size_t response_size;
     296              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     297              :     spdm_set_key_pair_info_ack_response_t *spdm_response;
     298              : 
     299              :     uint8_t key_pair_id;
     300              :     size_t set_key_pair_info_request_size;
     301              :     spdm_set_key_pair_info_request_t *set_key_pair_info_request;
     302              :     uint8_t *ptr;
     303              :     uint16_t desired_key_usage;
     304              :     uint32_t desired_asym_algo;
     305              :     uint8_t desired_assoc_cert_slot_mask;
     306              : 
     307              :     uint8_t temp_buf[LIBSPDM_RECEIVER_BUFFER_SIZE];
     308            1 :     set_key_pair_info_request = (spdm_set_key_pair_info_request_t *)temp_buf;
     309              : 
     310            1 :     spdm_test_context = *state;
     311            1 :     spdm_context = spdm_test_context->spdm_context;
     312            1 :     spdm_test_context->case_id = 0x3;
     313            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
     314              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     315            1 :     spdm_context->connection_info.connection_state =
     316              :         LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
     317            1 :     spdm_context->connection_info.algorithm.base_asym_algo =
     318              :         m_libspdm_use_asym_algo;
     319            1 :     spdm_context->local_context.capability.flags |=
     320              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_SET_KEY_PAIR_INFO_CAP;
     321            1 :     spdm_context->local_context.total_key_pairs = libspdm_read_total_key_pairs();
     322            1 :     key_pair_id = 4;
     323              : 
     324              :     /*set responder need reset*/
     325            1 :     spdm_context->local_context.capability.flags |=
     326              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_INSTALL_RESET_CAP;
     327              : 
     328              :     /*Before reset, change: remove an association with slot*/
     329            1 :     set_key_pair_info_request_size =
     330              :         sizeof(spdm_set_key_pair_info_request_t) +
     331              :         sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t);
     332              : 
     333            1 :     libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
     334            1 :     set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     335            1 :     set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
     336            1 :     set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
     337            1 :     set_key_pair_info_request->header.param2 = 0;
     338            1 :     set_key_pair_info_request->key_pair_id = key_pair_id;
     339              : 
     340            1 :     response_size = sizeof(response);
     341            1 :     status = libspdm_get_response_set_key_pair_info_ack(
     342              :         spdm_context, set_key_pair_info_request_size,
     343              :         set_key_pair_info_request, &response_size, response);
     344            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     345            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     346            1 :     spdm_response = (void *)response;
     347            1 :     assert_int_equal(spdm_response->header.request_response_code,
     348              :                      SPDM_ERROR);
     349            1 :     assert_int_equal(spdm_response->header.param1,
     350              :                      SPDM_ERROR_CODE_RESET_REQUIRED);
     351            1 :     assert_int_equal(spdm_response->header.param2, 0);
     352              : 
     353              :     /* Sub Case 1: If KeyPairErase is set, all fields after the KeyPairID field in this request should not exist. */
     354            1 :     desired_key_usage = SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE;
     355            1 :     desired_asym_algo = SPDM_KEY_PAIR_ASYM_ALGO_CAP_ECC256;
     356            1 :     desired_assoc_cert_slot_mask = 0x08;
     357            1 :     set_key_pair_info_request_size =
     358              :         sizeof(spdm_set_key_pair_info_request_t) +
     359              :         sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t);
     360              : 
     361            1 :     libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
     362            1 :     set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     363            1 :     set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
     364            1 :     set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_ERASE_OPERATION;
     365            1 :     set_key_pair_info_request->header.param2 = 0;
     366            1 :     set_key_pair_info_request->key_pair_id = key_pair_id;
     367              : 
     368            1 :     ptr = (uint8_t*)(set_key_pair_info_request + 1);
     369            1 :     ptr += sizeof(uint8_t);
     370              : 
     371            1 :     libspdm_write_uint16(ptr, desired_key_usage);
     372            1 :     ptr += sizeof(uint16_t);
     373              : 
     374            1 :     libspdm_write_uint32(ptr, desired_asym_algo);
     375            1 :     ptr += sizeof(uint32_t);
     376              : 
     377            1 :     *ptr = desired_assoc_cert_slot_mask;
     378              : 
     379            1 :     response_size = sizeof(response);
     380            1 :     status = libspdm_get_response_set_key_pair_info_ack(
     381              :         spdm_context, set_key_pair_info_request_size,
     382              :         set_key_pair_info_request, &response_size, response);
     383            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     384            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     385            1 :     spdm_response = (void *)response;
     386            1 :     assert_int_equal(spdm_response->header.request_response_code,
     387              :                      SPDM_ERROR);
     388            1 :     assert_int_equal(spdm_response->header.param1,
     389              :                      SPDM_ERROR_CODE_OPERATION_FAILED);
     390            1 :     assert_int_equal(spdm_response->header.param2, 0);
     391              : 
     392              :     /*Sub Case 2: When GenerateKeyPair is set, the fields of DesiredKeyUsage, DesiredAsymAlgo and DesiredAssocCertSlotMask should exist. */
     393            1 :     set_key_pair_info_request_size =
     394              :         sizeof(spdm_set_key_pair_info_request_t);
     395              : 
     396            1 :     libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
     397            1 :     set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     398            1 :     set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
     399            1 :     set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_GENERATE_OPERATION;
     400            1 :     set_key_pair_info_request->header.param2 = 0;
     401            1 :     set_key_pair_info_request->key_pair_id = key_pair_id;
     402              : 
     403            1 :     response_size = sizeof(response);
     404            1 :     status = libspdm_get_response_set_key_pair_info_ack(
     405              :         spdm_context, set_key_pair_info_request_size,
     406              :         set_key_pair_info_request, &response_size, response);
     407            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     408            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     409            1 :     spdm_response = (void *)response;
     410            1 :     assert_int_equal(spdm_response->header.request_response_code,
     411              :                      SPDM_ERROR);
     412            1 :     assert_int_equal(spdm_response->header.param1,
     413              :                      SPDM_ERROR_CODE_INVALID_REQUEST);
     414            1 :     assert_int_equal(spdm_response->header.param2, 0);
     415              : 
     416              :     /*Sub Case 3: key_pair_id = 0 */
     417            1 :     set_key_pair_info_request_size =
     418              :         sizeof(spdm_set_key_pair_info_request_t);
     419              : 
     420            1 :     libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
     421            1 :     set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     422            1 :     set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
     423            1 :     set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_GENERATE_OPERATION;
     424            1 :     set_key_pair_info_request->header.param2 = 0;
     425            1 :     set_key_pair_info_request->key_pair_id = 0;
     426              : 
     427            1 :     response_size = sizeof(response);
     428            1 :     status = libspdm_get_response_set_key_pair_info_ack(
     429              :         spdm_context, set_key_pair_info_request_size,
     430              :         set_key_pair_info_request, &response_size, response);
     431            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     432            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     433            1 :     spdm_response = (void *)response;
     434            1 :     assert_int_equal(spdm_response->header.request_response_code,
     435              :                      SPDM_ERROR);
     436            1 :     assert_int_equal(spdm_response->header.param1,
     437              :                      SPDM_ERROR_CODE_INVALID_REQUEST);
     438            1 :     assert_int_equal(spdm_response->header.param2, 0);
     439              : 
     440              :     /* Sub Case 4: DesiredAsymAlgo must not have multiple bits set. */
     441            1 :     desired_key_usage = SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE;
     442            1 :     desired_asym_algo = SPDM_KEY_PAIR_ASYM_ALGO_CAP_ECC256 |
     443              :                         SPDM_KEY_PAIR_ASYM_ALGO_CAP_ECC384;
     444            1 :     desired_assoc_cert_slot_mask = 0x08;
     445            1 :     set_key_pair_info_request_size =
     446              :         sizeof(spdm_set_key_pair_info_request_t) +
     447              :         sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t);
     448              : 
     449            1 :     libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
     450            1 :     set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     451            1 :     set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
     452            1 :     set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
     453            1 :     set_key_pair_info_request->header.param2 = 0;
     454            1 :     set_key_pair_info_request->key_pair_id = key_pair_id;
     455              : 
     456            1 :     ptr = (uint8_t*)(set_key_pair_info_request + 1);
     457            1 :     ptr += sizeof(uint8_t);
     458              : 
     459            1 :     libspdm_write_uint16(ptr, desired_key_usage);
     460            1 :     ptr += sizeof(uint16_t);
     461              : 
     462            1 :     libspdm_write_uint32(ptr, desired_asym_algo);
     463            1 :     ptr += sizeof(uint32_t);
     464              : 
     465            1 :     *ptr = desired_assoc_cert_slot_mask;
     466              : 
     467            1 :     response_size = sizeof(response);
     468            1 :     status = libspdm_get_response_set_key_pair_info_ack(
     469              :         spdm_context, set_key_pair_info_request_size,
     470              :         set_key_pair_info_request, &response_size, response);
     471            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     472            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     473            1 :     spdm_response = (void *)response;
     474            1 :     assert_int_equal(spdm_response->header.request_response_code,
     475              :                      SPDM_ERROR);
     476            1 :     assert_int_equal(spdm_response->header.param1,
     477              :                      SPDM_ERROR_CODE_INVALID_REQUEST);
     478            1 :     assert_int_equal(spdm_response->header.param2, 0);
     479              : 
     480              :     /*Before reset, change: remove an association with slot*/
     481            1 :     set_key_pair_info_request_size =
     482              :         sizeof(spdm_set_key_pair_info_request_t) +
     483              :         sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t);
     484              : 
     485            1 :     libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
     486            1 :     set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     487            1 :     set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
     488            1 :     set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
     489            1 :     set_key_pair_info_request->header.param2 = 0;
     490            1 :     set_key_pair_info_request->key_pair_id = 0x1;
     491              : 
     492            1 :     response_size = sizeof(response);
     493            1 :     status = libspdm_get_response_set_key_pair_info_ack(
     494              :         spdm_context, set_key_pair_info_request_size,
     495              :         set_key_pair_info_request, &response_size, response);
     496            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     497            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
     498            1 :     spdm_response = (void *)response;
     499            1 :     assert_int_equal(spdm_response->header.request_response_code,
     500              :                      SPDM_ERROR);
     501            1 :     assert_int_equal(spdm_response->header.param1,
     502              :                      SPDM_ERROR_CODE_RESET_REQUIRED);
     503            1 :     assert_int_equal(spdm_response->header.param2, 0);
     504            1 : }
     505              : 
     506            1 : int libspdm_responder_set_key_pair_info_ack_test_main(void)
     507              : {
     508            1 :     const struct CMUnitTest spdm_responder_set_key_pair_info_ack_tests[] = {
     509              :         /* Success Case to set key pair info*/
     510              :         cmocka_unit_test(libspdm_test_responder_set_key_pair_info_ack_case1),
     511              :         /* Success Case to set key pair info with reset*/
     512              :         cmocka_unit_test(libspdm_test_responder_set_key_pair_info_ack_case2),
     513              :         /* The collection of multiple sub-cases.*/
     514              :         cmocka_unit_test(libspdm_test_responder_set_key_pair_info_ack_case3),
     515              :     };
     516              : 
     517            1 :     libspdm_test_context_t test_context = {
     518              :         LIBSPDM_TEST_CONTEXT_VERSION,
     519              :         false,
     520              :     };
     521            1 :     libspdm_setup_test_context(&test_context);
     522              : 
     523            1 :     return cmocka_run_group_tests(spdm_responder_set_key_pair_info_ack_tests,
     524              :                                   libspdm_unit_test_group_setup,
     525              :                                   libspdm_unit_test_group_teardown);
     526              : }
     527              : 
     528              : #endif /* LIBSPDM_ENABLE_CAPABILITY_SET_KEY_PAIR_INFO_CAP*/
        

Generated by: LCOV version 2.0-1