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

            Line data    Source code
       1              : /**
       2              :  *  Copyright Notice:
       3              :  *  Copyright 2021-2025 DMTF. All rights reserved.
       4              :  *  License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
       5              :  **/
       6              : 
       7              : #include "spdm_unit_test.h"
       8              : #include "internal/libspdm_responder_lib.h"
       9              : 
      10              : #pragma pack(1)
      11              : typedef struct {
      12              :     spdm_negotiate_algorithms_request_t spdm_request_version10;
      13              :     spdm_negotiate_algorithms_common_struct_table_t struct_table[4];
      14              : } libspdm_negotiate_algorithms_request_spdm11_t;
      15              : 
      16              : typedef struct {
      17              :     spdm_negotiate_algorithms_request_t spdm_request_version10;
      18              :     uint32_t extra[21];
      19              :     spdm_negotiate_algorithms_common_struct_table_t struct_table[4];
      20              : } libspdm_negotiate_algorithms_request_spdm11_oversized_t;
      21              : 
      22              : typedef struct {
      23              :     spdm_negotiate_algorithms_request_t spdm_request_version10;
      24              :     spdm_negotiate_algorithms_common_struct_table_t struct_table[12];
      25              : } libspdm_negotiate_algorithms_request_spdm11_multiple_tables_t;
      26              : 
      27              : typedef struct {
      28              :     spdm_negotiate_algorithms_request_t spdm_request_version10;
      29              :     spdm_negotiate_algorithms_common_struct_table_t struct_table[4];
      30              : } libspdm_negotiate_algorithms_request_spdm12_t;
      31              : 
      32              : typedef struct {
      33              :     spdm_negotiate_algorithms_request_t spdm_request_version10;
      34              :     spdm_negotiate_algorithms_common_struct_table_t struct_table[5];
      35              : } libspdm_negotiate_algorithms_request_spdm12_more_algo_t;
      36              : 
      37              : typedef struct {
      38              :     spdm_message_header_t header;
      39              :     uint16_t length;
      40              :     uint8_t measurement_specification_sel;
      41              :     uint8_t reserved;
      42              :     uint32_t measurement_hash_algo;
      43              :     uint32_t base_asym_sel;
      44              :     uint32_t base_hash_sel;
      45              :     uint8_t reserved2[12];
      46              :     uint8_t ext_asym_sel_count;
      47              :     uint8_t ext_hash_sel_count;
      48              :     uint16_t reserved3;
      49              :     spdm_negotiate_algorithms_common_struct_table_t struct_table[4];
      50              : } libspdm_algorithms_response_mine_t;
      51              : #pragma pack()
      52              : 
      53              : spdm_negotiate_algorithms_request_t m_libspdm_negotiate_algorithms_request1 = {
      54              :     { SPDM_MESSAGE_VERSION_10, SPDM_NEGOTIATE_ALGORITHMS, 0, 0 },
      55              :     sizeof(spdm_negotiate_algorithms_request_t),
      56              :     SPDM_MEASUREMENT_SPECIFICATION_DMTF,
      57              : };
      58              : size_t m_libspdm_negotiate_algorithms_request1_size =
      59              :     sizeof(m_libspdm_negotiate_algorithms_request1);
      60              : 
      61              : spdm_negotiate_algorithms_request_t m_libspdm_negotiate_algorithms_request2 = {
      62              :     { SPDM_MESSAGE_VERSION_10, SPDM_NEGOTIATE_ALGORITHMS, 0, 0 },
      63              :     sizeof(spdm_negotiate_algorithms_request_t),
      64              :     SPDM_MEASUREMENT_SPECIFICATION_DMTF,
      65              : };
      66              : size_t m_libspdm_negotiate_algorithms_request2_size = sizeof(spdm_message_header_t);
      67              : 
      68              : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request3 = {
      69              :     {
      70              :         {
      71              :             SPDM_MESSAGE_VERSION_11,
      72              :             SPDM_NEGOTIATE_ALGORITHMS,
      73              :             4,
      74              :             0
      75              :         },
      76              :         sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
      77              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
      78              :     },
      79              :     {
      80              :         {
      81              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
      82              :             0x20,
      83              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
      84              :         },
      85              :         {
      86              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
      87              :             0x20,
      88              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
      89              :         },
      90              :         {
      91              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
      92              :             0x20,
      93              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
      94              :         },
      95              :         {
      96              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
      97              :             0x20,
      98              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
      99              :         }
     100              :     }
     101              : };
     102              : size_t m_libspdm_negotiate_algorithm_request3_size = sizeof(m_libspdm_negotiate_algorithm_request3);
     103              : 
     104              : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request4 = {
     105              :     {
     106              :         {
     107              :             SPDM_MESSAGE_VERSION_11,
     108              :             SPDM_NEGOTIATE_ALGORITHMS,
     109              :             4,
     110              :             0
     111              :         },
     112              :         sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
     113              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     114              :     },
     115              :     {
     116              :         {
     117              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     118              :             0x20,
     119              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     120              :         },
     121              :         {
     122              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     123              :             0x20,
     124              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
     125              :         },
     126              :         {
     127              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     128              :             0x20,
     129              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     130              :         },
     131              :         {
     132              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     133              :             0x20,
     134              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     135              :         }
     136              :     }
     137              : };
     138              : size_t m_libspdm_negotiate_algorithm_request4_size = sizeof(m_libspdm_negotiate_algorithm_request4);
     139              : 
     140              : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request5 = {
     141              :     {
     142              :         {
     143              :             SPDM_MESSAGE_VERSION_11,
     144              :             SPDM_NEGOTIATE_ALGORITHMS,
     145              :             4,
     146              :             0
     147              :         },
     148              :         sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
     149              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     150              :     },
     151              :     {
     152              :         {
     153              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     154              :             0x20,
     155              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     156              :         },
     157              :         {
     158              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     159              :             0x20,
     160              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
     161              :         },
     162              :         {
     163              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     164              :             0x20,
     165              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     166              :         },
     167              :         {
     168              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     169              :             0x20,
     170              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     171              :         }
     172              :     }
     173              : };
     174              : size_t m_libspdm_negotiate_algorithm_request5_size = sizeof(m_libspdm_negotiate_algorithm_request5);
     175              : 
     176              : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request6 = {
     177              :     {
     178              :         {
     179              :             SPDM_MESSAGE_VERSION_11,
     180              :             SPDM_NEGOTIATE_ALGORITHMS,
     181              :             4,
     182              :             0
     183              :         },
     184              :         sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
     185              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     186              :     },
     187              :     {
     188              :         {
     189              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     190              :             0x20,
     191              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_521_R1
     192              :         },
     193              :         {
     194              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     195              :             0x20,
     196              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
     197              :         },
     198              :         {
     199              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     200              :             0x20,
     201              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     202              :         },
     203              :         {
     204              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     205              :             0x20,
     206              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     207              :         }
     208              :     }
     209              : };
     210              : size_t m_libspdm_negotiate_algorithm_request6_size = sizeof(m_libspdm_negotiate_algorithm_request6);
     211              : 
     212              : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request7 = {
     213              :     {
     214              :         {
     215              :             SPDM_MESSAGE_VERSION_11,
     216              :             SPDM_NEGOTIATE_ALGORITHMS,
     217              :             4,
     218              :             0
     219              :         },
     220              :         sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
     221              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     222              :     },
     223              :     {
     224              :         {
     225              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     226              :             0x20,
     227              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     228              :         },
     229              :         {
     230              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     231              :             0x20,
     232              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_CHACHA20_POLY1305
     233              :         },
     234              :         {
     235              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     236              :             0x20,
     237              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     238              :         },
     239              :         {
     240              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     241              :             0x20,
     242              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     243              :         }
     244              :     }
     245              : };
     246              : size_t m_libspdm_negotiate_algorithm_request7_size = sizeof(m_libspdm_negotiate_algorithm_request7);
     247              : 
     248              : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request8 = {
     249              :     {
     250              :         {
     251              :             SPDM_MESSAGE_VERSION_11,
     252              :             SPDM_NEGOTIATE_ALGORITHMS,
     253              :             4,
     254              :             0
     255              :         },
     256              :         sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
     257              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     258              :     },
     259              :     {
     260              :         {
     261              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     262              :             0x20,
     263              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     264              :         },
     265              :         {
     266              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     267              :             0x20,
     268              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
     269              :         },
     270              :         {
     271              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     272              :             0x20,
     273              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521
     274              :         },
     275              :         {
     276              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     277              :             0x20,
     278              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     279              :         }
     280              :     }
     281              : };
     282              : size_t m_libspdm_negotiate_algorithm_request8_size = sizeof(m_libspdm_negotiate_algorithm_request8);
     283              : 
     284              : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request9 = {
     285              :     {
     286              :         {
     287              :             SPDM_MESSAGE_VERSION_11,
     288              :             SPDM_NEGOTIATE_ALGORITHMS,
     289              :             4,
     290              :             0
     291              :         },
     292              :         sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
     293              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     294              :     },
     295              :     {
     296              :         {
     297              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     298              :             0x20,
     299              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     300              :         },
     301              :         {
     302              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     303              :             0x20,
     304              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
     305              :         },
     306              :         {
     307              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     308              :             0x20,
     309              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     310              :         },
     311              :         {
     312              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     313              :             0x20,
     314              :             0x00000020
     315              :         }
     316              :     }
     317              : };
     318              : size_t m_libspdm_negotiate_algorithm_request9_size = sizeof(m_libspdm_negotiate_algorithm_request9);
     319              : 
     320              : spdm_negotiate_algorithms_request_t m_libspdm_negotiate_algorithm_request10 = {
     321              :     {
     322              :         SPDM_MESSAGE_VERSION_10,
     323              :         SPDM_NEGOTIATE_ALGORITHMS,
     324              :         0,
     325              :         0
     326              :     },
     327              :     0x44,
     328              :     SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     329              : };
     330              : size_t m_libspdm_negotiate_algorithm_request10_size = 0x44;
     331              : 
     332              : libspdm_negotiate_algorithms_request_spdm11_oversized_t m_libspdm_negotiate_algorithm_request11 = {
     333              :     {
     334              :         {
     335              :             SPDM_MESSAGE_VERSION_11,
     336              :             SPDM_NEGOTIATE_ALGORITHMS,
     337              :             4,
     338              :             0
     339              :         },
     340              :         sizeof(libspdm_negotiate_algorithms_request_spdm11_oversized_t),
     341              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     342              :     },
     343              :     {0},
     344              :     {
     345              :         {
     346              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     347              :             0x20,
     348              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     349              :         },
     350              :         {
     351              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     352              :             0x20,
     353              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
     354              :         },
     355              :         {
     356              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     357              :             0x20,
     358              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     359              :         },
     360              :         {
     361              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     362              :             0x20,
     363              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     364              :         }
     365              :     }
     366              : };
     367              : size_t m_libspdm_negotiate_algorithm_request11_size =
     368              :     sizeof(m_libspdm_negotiate_algorithm_request11);
     369              : 
     370              : libspdm_negotiate_algorithms_request_spdm11_multiple_tables_t
     371              :     m_libspdm_negotiate_algorithm_request12 =
     372              : {
     373              :     {
     374              :         {
     375              :             SPDM_MESSAGE_VERSION_11,
     376              :             SPDM_NEGOTIATE_ALGORITHMS,
     377              :             12,
     378              :             0
     379              :         },
     380              :         sizeof(libspdm_negotiate_algorithms_request_spdm11_multiple_tables_t),
     381              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     382              :     },
     383              :     {
     384              :         {
     385              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     386              :             0x20,
     387              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_FFDHE_2048
     388              :         },
     389              :         {
     390              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     391              :             0x20,
     392              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_128_GCM
     393              :         },
     394              :         {
     395              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     396              :             0x20,
     397              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256
     398              :         },
     399              :         {
     400              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     401              :             0x20,
     402              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     403              :         },
     404              :         {
     405              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     406              :             0x20,
     407              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_FFDHE_3072
     408              :         },
     409              :         {
     410              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     411              :             0x20,
     412              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_CHACHA20_POLY1305
     413              :         },
     414              :         {
     415              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     416              :             0x20,
     417              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384
     418              :         },
     419              :         {
     420              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     421              :             0x20,
     422              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     423              :         },
     424              :         {
     425              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     426              :             0x20,
     427              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     428              :         },
     429              :         {
     430              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     431              :             0x20,
     432              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
     433              :         },
     434              :         {
     435              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     436              :             0x20,
     437              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     438              :         },
     439              :         {
     440              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     441              :             0x20,
     442              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     443              :         }
     444              :     }
     445              : };
     446              : size_t m_libspdm_negotiate_algorithm_request12_size =
     447              :     sizeof(m_libspdm_negotiate_algorithm_request12);
     448              : 
     449              : libspdm_negotiate_algorithms_request_spdm11_t
     450              :     m_libspdm_negotiate_algorithm_request13 =
     451              : {
     452              :     {
     453              :         {
     454              :             SPDM_MESSAGE_VERSION_11,
     455              :             SPDM_NEGOTIATE_ALGORITHMS,
     456              :             3,
     457              :             0
     458              :         },
     459              :         sizeof(libspdm_negotiate_algorithms_request_spdm11_t)-
     460              :         sizeof(spdm_negotiate_algorithms_common_struct_table_t),
     461              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     462              :     },
     463              :     {
     464              :         {
     465              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     466              :             0x20,
     467              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     468              :         },
     469              :         {
     470              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     471              :             0x20,
     472              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
     473              :         },
     474              :         {
     475              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     476              :             0x20,
     477              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     478              :         },
     479              :         {
     480              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     481              :             0x20,
     482              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     483              :         }
     484              :     }
     485              : };
     486              : size_t m_libspdm_negotiate_algorithm_request13_size =
     487              :     sizeof(m_libspdm_negotiate_algorithm_request13)-
     488              :     sizeof(
     489              :         spdm_negotiate_algorithms_common_struct_table_t);
     490              : 
     491              : libspdm_negotiate_algorithms_request_spdm11_t
     492              :     m_libspdm_negotiate_algorithm_request14 =
     493              : {
     494              :     {
     495              :         {
     496              :             SPDM_MESSAGE_VERSION_11,
     497              :             SPDM_NEGOTIATE_ALGORITHMS,
     498              :             5,
     499              :             0
     500              :         },
     501              :         sizeof(libspdm_negotiate_algorithms_request_spdm11_t)+
     502              :         sizeof(spdm_negotiate_algorithms_common_struct_table_t),
     503              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     504              :     },
     505              :     {
     506              :         {
     507              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     508              :             0x20,
     509              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_FFDHE_2048
     510              :         },
     511              :         {
     512              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     513              :             0x20,
     514              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_128_GCM
     515              :         },
     516              :         {
     517              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     518              :             0x20,
     519              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256
     520              :         },
     521              :         {
     522              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     523              :             0x20,
     524              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     525              :         },
     526              :     }
     527              : };
     528              : size_t m_libspdm_negotiate_algorithm_request14_size =
     529              :     sizeof(m_libspdm_negotiate_algorithm_request14)+
     530              :     sizeof(
     531              :         spdm_negotiate_algorithms_common_struct_table_t);
     532              : 
     533              : libspdm_negotiate_algorithms_request_spdm11_t
     534              :     m_libspdm_negotiate_algorithm_request15 =
     535              : {
     536              :     {
     537              :         {
     538              :             SPDM_MESSAGE_VERSION_11,
     539              :             SPDM_NEGOTIATE_ALGORITHMS,
     540              :             12,
     541              :             0
     542              :         },
     543              :         sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
     544              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     545              :     },
     546              :     {
     547              :         {
     548              :             1,
     549              :             0x20,
     550              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     551              :         },
     552              :         {
     553              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     554              :             0x20,
     555              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
     556              :         },
     557              :         {
     558              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     559              :             0x20,
     560              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     561              :         },
     562              :         {
     563              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     564              :             0x20,
     565              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     566              :         }
     567              :     }
     568              : };
     569              : size_t m_libspdm_negotiate_algorithm_request15_size =
     570              :     sizeof(m_libspdm_negotiate_algorithm_request15);
     571              : 
     572              : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request16 = {
     573              :     {
     574              :         {
     575              :             SPDM_MESSAGE_VERSION_11,
     576              :             SPDM_NEGOTIATE_ALGORITHMS,
     577              :             4,
     578              :             0
     579              :         },
     580              :         sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
     581              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     582              :     },
     583              :     {
     584              :         {
     585              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     586              :             0x20,
     587              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1 |
     588              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_384_R1
     589              :         },
     590              :         {
     591              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     592              :             0x20,
     593              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
     594              :         },
     595              :         {
     596              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     597              :             0x20,
     598              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     599              :         },
     600              :         {
     601              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     602              :             0x20,
     603              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     604              :         }
     605              :     }
     606              : };
     607              : size_t m_libspdm_negotiate_algorithm_request16_size =
     608              :     sizeof(m_libspdm_negotiate_algorithm_request16);
     609              : 
     610              : libspdm_negotiate_algorithms_request_spdm12_t
     611              :     m_libspdm_negotiate_algorithm_request17 =
     612              : {
     613              :     {
     614              :         {
     615              :             SPDM_MESSAGE_VERSION_12,
     616              :             SPDM_NEGOTIATE_ALGORITHMS,
     617              :             4,
     618              :             0
     619              :         },
     620              :         sizeof(libspdm_negotiate_algorithms_request_spdm12_t),
     621              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     622              :         SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1,
     623              :     },
     624              :     {
     625              :         {
     626              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     627              :             0x20,
     628              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     629              :         },
     630              :         {
     631              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     632              :             0x20,
     633              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
     634              :         },
     635              :         {
     636              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     637              :             0x20,
     638              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     639              :         },
     640              :         {
     641              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     642              :             0x20,
     643              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     644              :         }
     645              :     }
     646              : };
     647              : size_t m_libspdm_negotiate_algorithm_request17_size =
     648              :     sizeof(m_libspdm_negotiate_algorithm_request17);
     649              : 
     650              : libspdm_negotiate_algorithms_request_spdm12_t
     651              :     m_libspdm_negotiate_algorithm_request18 =
     652              : {
     653              :     {
     654              :         {
     655              :             SPDM_MESSAGE_VERSION_12,
     656              :             SPDM_NEGOTIATE_ALGORITHMS,
     657              :             4,
     658              :             0
     659              :         },
     660              :         sizeof(libspdm_negotiate_algorithms_request_spdm12_t),
     661              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     662              :         /* Illegal OpaqueDataFmt. */
     663              :         0x04,
     664              :     },
     665              :     {
     666              :         {
     667              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     668              :             0x20,
     669              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     670              :         },
     671              :         {
     672              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     673              :             0x20,
     674              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
     675              :         },
     676              :         {
     677              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     678              :             0x20,
     679              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     680              :         },
     681              :         {
     682              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     683              :             0x20,
     684              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     685              :         }
     686              :     }
     687              : };
     688              : size_t m_libspdm_negotiate_algorithm_request18_size =
     689              :     sizeof(m_libspdm_negotiate_algorithm_request18);
     690              : 
     691              : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request24 = {
     692              :     {
     693              :         {
     694              :             SPDM_MESSAGE_VERSION_12,
     695              :             SPDM_NEGOTIATE_ALGORITHMS,
     696              :             4,
     697              :             0
     698              :         },
     699              :         sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
     700              :         0, /* SPDM_MEASUREMENT_SPECIFICATION_DMTF */
     701              :         SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1,
     702              :         SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256,
     703              :         SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256,
     704              :     },
     705              :     {
     706              :         {
     707              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     708              :             0x20,
     709              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     710              :         },
     711              :         {
     712              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     713              :             0x20,
     714              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
     715              :         },
     716              :         {
     717              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     718              :             0x20,
     719              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     720              :         },
     721              :         {
     722              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     723              :             0x20,
     724              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     725              :         }
     726              :     }
     727              : };
     728              : size_t m_libspdm_negotiate_algorithm_request24_size =
     729              :     sizeof(m_libspdm_negotiate_algorithm_request24);
     730              : 
     731              : libspdm_negotiate_algorithms_request_spdm12_t
     732              :     m_libspdm_negotiate_algorithm_request25 =
     733              : {
     734              :     {
     735              :         {
     736              :             SPDM_MESSAGE_VERSION_12,
     737              :             SPDM_NEGOTIATE_ALGORITHMS,
     738              :             4,
     739              :             0
     740              :         },
     741              :         sizeof(libspdm_negotiate_algorithms_request_spdm12_t),
     742              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     743              :         SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1,
     744              :         SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256,
     745              :         SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256,
     746              :     },
     747              :     {
     748              :         {
     749              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     750              :             0x20,
     751              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     752              :         },
     753              :         {
     754              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     755              :             0x20,
     756              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     757              :         },
     758              :         {
     759              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     760              :             0x20,
     761              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     762              :         },
     763              :         {
     764              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     765              :             0x20,
     766              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     767              :         }
     768              :     }
     769              : };
     770              : size_t m_libspdm_negotiate_algorithm_request25_size =
     771              :     sizeof(m_libspdm_negotiate_algorithm_request25);
     772              : 
     773              : libspdm_negotiate_algorithms_request_spdm12_t
     774              :     m_libspdm_negotiate_algorithm_request26 =
     775              : {
     776              :     {
     777              :         {
     778              :             SPDM_MESSAGE_VERSION_12,
     779              :             SPDM_NEGOTIATE_ALGORITHMS,
     780              :             4,
     781              :             0
     782              :         },
     783              :         sizeof(libspdm_negotiate_algorithms_request_spdm12_t),
     784              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     785              :         SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1,
     786              :         SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256,
     787              :         SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256,
     788              :     },
     789              :     {
     790              :         {
     791              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     792              :             0x20,
     793              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     794              :         },
     795              :         {
     796              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     797              :             0x20,
     798              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     799              :         },
     800              :         {
     801              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     802              :             0x20,
     803              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     804              :         },
     805              :         {
     806              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     807              :             0x20,
     808              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
     809              :         }
     810              :     }
     811              : };
     812              : size_t m_libspdm_negotiate_algorithm_request26_size =
     813              :     sizeof(m_libspdm_negotiate_algorithm_request26);
     814              : 
     815              : libspdm_negotiate_algorithms_request_spdm12_more_algo_t
     816              :     m_libspdm_negotiate_algorithm_request27 =
     817              : {
     818              :     {
     819              :         {
     820              :             SPDM_MESSAGE_VERSION_12,
     821              :             SPDM_NEGOTIATE_ALGORITHMS,
     822              :             5,
     823              :             0
     824              :         },
     825              :         sizeof(libspdm_negotiate_algorithms_request_spdm12_more_algo_t),
     826              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     827              :         SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1,
     828              :         SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256,
     829              :         SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256,
     830              :     },
     831              :     {
     832              :         {
     833              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE - 1,
     834              :             0x20,
     835              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     836              :         },
     837              :         {
     838              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     839              :             0x20,
     840              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     841              :         },
     842              :         {
     843              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     844              :             0x20,
     845              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
     846              :         },
     847              :         {
     848              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     849              :             0x20,
     850              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     851              :         },
     852              :         {
     853              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     854              :             0x20,
     855              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     856              :         },
     857              :     }
     858              : };
     859              : size_t m_libspdm_negotiate_algorithm_request27_size =
     860              :     sizeof(m_libspdm_negotiate_algorithm_request27);
     861              : 
     862              : libspdm_negotiate_algorithms_request_spdm12_more_algo_t
     863              :     m_libspdm_negotiate_algorithm_request28 =
     864              : {
     865              :     {
     866              :         {
     867              :             SPDM_MESSAGE_VERSION_12,
     868              :             SPDM_NEGOTIATE_ALGORITHMS,
     869              :             5,
     870              :             0
     871              :         },
     872              :         sizeof(libspdm_negotiate_algorithms_request_spdm12_more_algo_t),
     873              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     874              :         SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1,
     875              :         SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256,
     876              :         SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256,
     877              :     },
     878              :     {
     879              :         {
     880              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     881              :             0x20,
     882              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     883              :         },
     884              :         {
     885              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     886              :             0x20,
     887              :             SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
     888              :         },
     889              :         {
     890              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     891              :             0x20,
     892              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     893              :         },
     894              :         {
     895              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     896              :             0x20,
     897              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     898              :         },
     899              :         {
     900              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE + 1,
     901              :             0x20,
     902              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     903              :         }
     904              :     }
     905              : };
     906              : size_t m_libspdm_negotiate_algorithm_request28_size =
     907              :     sizeof(m_libspdm_negotiate_algorithm_request28);
     908              : 
     909              : libspdm_negotiate_algorithms_request_spdm12_t
     910              :     m_libspdm_negotiate_algorithm_request29 =
     911              : {
     912              :     {
     913              :         {
     914              :             SPDM_MESSAGE_VERSION_12,
     915              :             SPDM_NEGOTIATE_ALGORITHMS,
     916              :             4,
     917              :             0
     918              :         },
     919              :         sizeof(libspdm_negotiate_algorithms_request_spdm12_t),
     920              :         SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     921              :         SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1,
     922              :         SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256,
     923              :         SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256,
     924              :     },
     925              :     {
     926              :         {
     927              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
     928              :             0x20,
     929              :             SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
     930              :         },
     931              :         {
     932              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
     933              :             0x20,
     934              :             /* No supported AlgTypes */
     935              :             0x00
     936              :         },
     937              :         {
     938              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
     939              :             0x20,
     940              :             SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
     941              :         },
     942              :         {
     943              :             SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
     944              :             0x20,
     945              :             SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
     946              :         }
     947              :     }
     948              : };
     949              : size_t m_libspdm_negotiate_algorithm_request29_size =
     950              :     sizeof(m_libspdm_negotiate_algorithm_request29);
     951              : 
     952              : spdm_negotiate_algorithms_request_t m_libspdm_negotiate_algorithms_request30 = {
     953              :     { SPDM_MESSAGE_VERSION_13, SPDM_NEGOTIATE_ALGORITHMS, 0, 0 },
     954              :     sizeof(spdm_negotiate_algorithms_request_t),
     955              :     SPDM_MEASUREMENT_SPECIFICATION_DMTF,
     956              :     SPDM_ALGORITHMS_MULTI_KEY_CONN,
     957              : };
     958              : size_t m_libspdm_negotiate_algorithms_request30_size =
     959              :     sizeof(m_libspdm_negotiate_algorithms_request30);
     960              : 
     961            1 : void libspdm_test_responder_algorithms_case1(void **state)
     962              : {
     963              :     libspdm_return_t status;
     964              :     libspdm_test_context_t *spdm_test_context;
     965              :     libspdm_context_t *spdm_context;
     966              :     size_t response_size;
     967              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     968              :     spdm_algorithms_response_t *spdm_response;
     969              : 
     970            1 :     spdm_test_context = *state;
     971            1 :     spdm_context = spdm_test_context->spdm_context;
     972            1 :     spdm_test_context->case_id = 0x1;
     973            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
     974              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
     975            1 :     spdm_context->connection_info.connection_state =
     976              :         LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
     977            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
     978            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
     979              : 
     980            1 :     response_size = sizeof(response);
     981            1 :     status = libspdm_get_response_algorithms(
     982              :         spdm_context, m_libspdm_negotiate_algorithms_request1_size,
     983              :         &m_libspdm_negotiate_algorithms_request1, &response_size,
     984              :         response);
     985            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     986            1 :     assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
     987            1 :     spdm_response = (void *)response;
     988            1 :     assert_int_equal(spdm_response->header.request_response_code,
     989              :                      SPDM_ALGORITHMS);
     990            1 : }
     991              : 
     992            1 : void libspdm_test_responder_algorithms_case2(void **state)
     993              : {
     994              :     libspdm_return_t status;
     995              :     libspdm_test_context_t *spdm_test_context;
     996              :     libspdm_context_t *spdm_context;
     997              :     size_t response_size;
     998              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
     999              :     spdm_algorithms_response_t *spdm_response;
    1000              : 
    1001            1 :     spdm_test_context = *state;
    1002            1 :     spdm_context = spdm_test_context->spdm_context;
    1003            1 :     spdm_test_context->case_id = 0x2;
    1004            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
    1005              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1006            1 :     spdm_context->connection_info.connection_state =
    1007              :         LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1008            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1009            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1010              : 
    1011            1 :     response_size = sizeof(response);
    1012            1 :     status = libspdm_get_response_algorithms(
    1013              :         spdm_context, m_libspdm_negotiate_algorithms_request2_size,
    1014              :         &m_libspdm_negotiate_algorithms_request2, &response_size,
    1015              :         response);
    1016            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1017            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
    1018            1 :     spdm_response = (void *)response;
    1019            1 :     assert_int_equal(spdm_response->header.request_response_code,
    1020              :                      SPDM_ERROR);
    1021            1 :     assert_int_equal(spdm_response->header.param1,
    1022              :                      SPDM_ERROR_CODE_INVALID_REQUEST);
    1023            1 :     assert_int_equal(spdm_response->header.param2, 0);
    1024            1 : }
    1025              : 
    1026            1 : void libspdm_test_responder_algorithms_case3(void **state)
    1027              : {
    1028              :     libspdm_return_t status;
    1029              :     libspdm_test_context_t *spdm_test_context;
    1030              :     libspdm_context_t *spdm_context;
    1031              :     size_t response_size;
    1032              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1033              :     spdm_algorithms_response_t *spdm_response;
    1034              : 
    1035            1 :     spdm_test_context = *state;
    1036            1 :     spdm_context = spdm_test_context->spdm_context;
    1037            1 :     spdm_test_context->case_id = 0x3;
    1038            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
    1039              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1040            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_BUSY;
    1041            1 :     spdm_context->connection_info.connection_state =
    1042              :         LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1043            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1044            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1045              : 
    1046            1 :     response_size = sizeof(response);
    1047            1 :     status = libspdm_get_response_algorithms(
    1048              :         spdm_context, m_libspdm_negotiate_algorithms_request1_size,
    1049              :         &m_libspdm_negotiate_algorithms_request1, &response_size,
    1050              :         response);
    1051            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1052            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
    1053            1 :     spdm_response = (void *)response;
    1054            1 :     assert_int_equal(spdm_response->header.request_response_code,
    1055              :                      SPDM_ERROR);
    1056            1 :     assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_BUSY);
    1057            1 :     assert_int_equal(spdm_response->header.param2, 0);
    1058            1 :     assert_int_equal(spdm_context->response_state,
    1059              :                      LIBSPDM_RESPONSE_STATE_BUSY);
    1060            1 : }
    1061              : 
    1062            1 : void libspdm_test_responder_algorithms_case4(void **state)
    1063              : {
    1064              :     libspdm_return_t status;
    1065              :     libspdm_test_context_t *spdm_test_context;
    1066              :     libspdm_context_t *spdm_context;
    1067              :     size_t response_size;
    1068              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1069              :     spdm_algorithms_response_t *spdm_response;
    1070              : 
    1071            1 :     spdm_test_context = *state;
    1072            1 :     spdm_context = spdm_test_context->spdm_context;
    1073            1 :     spdm_test_context->case_id = 0x4;
    1074            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
    1075              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1076            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NEED_RESYNC;
    1077            1 :     spdm_context->connection_info.connection_state =
    1078              :         LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1079            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1080            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1081              : 
    1082            1 :     response_size = sizeof(response);
    1083            1 :     status = libspdm_get_response_algorithms(
    1084              :         spdm_context, m_libspdm_negotiate_algorithms_request1_size,
    1085              :         &m_libspdm_negotiate_algorithms_request1, &response_size,
    1086              :         response);
    1087            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1088            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
    1089            1 :     spdm_response = (void *)response;
    1090            1 :     assert_int_equal(spdm_response->header.request_response_code,
    1091              :                      SPDM_ERROR);
    1092            1 :     assert_int_equal(spdm_response->header.param1,
    1093              :                      SPDM_ERROR_CODE_REQUEST_RESYNCH);
    1094            1 :     assert_int_equal(spdm_response->header.param2, 0);
    1095            1 :     assert_int_equal(spdm_context->response_state,
    1096              :                      LIBSPDM_RESPONSE_STATE_NEED_RESYNC);
    1097            1 : }
    1098              : 
    1099            1 : void libspdm_test_responder_algorithms_case6(void **state)
    1100              : {
    1101              :     libspdm_return_t status;
    1102              :     libspdm_test_context_t *spdm_test_context;
    1103              :     libspdm_context_t *spdm_context;
    1104              :     size_t response_size;
    1105              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1106              :     spdm_algorithms_response_t *spdm_response;
    1107              : 
    1108            1 :     spdm_test_context = *state;
    1109            1 :     spdm_context = spdm_test_context->spdm_context;
    1110            1 :     spdm_test_context->case_id = 0x6;
    1111            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
    1112              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1113            1 :     spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
    1114            1 :     spdm_context->connection_info.connection_state =
    1115              :         LIBSPDM_CONNECTION_STATE_NOT_STARTED;
    1116            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1117            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1118              : 
    1119            1 :     response_size = sizeof(response);
    1120            1 :     status = libspdm_get_response_algorithms(
    1121              :         spdm_context, m_libspdm_negotiate_algorithms_request1_size,
    1122              :         &m_libspdm_negotiate_algorithms_request1, &response_size,
    1123              :         response);
    1124            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1125            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
    1126            1 :     spdm_response = (void *)response;
    1127            1 :     assert_int_equal(spdm_response->header.request_response_code,
    1128              :                      SPDM_ERROR);
    1129            1 :     assert_int_equal(spdm_response->header.param1,
    1130              :                      SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
    1131            1 :     assert_int_equal(spdm_response->header.param2, 0);
    1132            1 : }
    1133              : 
    1134            1 : void libspdm_test_responder_algorithms_case7(void **state) {
    1135              :     libspdm_return_t status;
    1136              :     libspdm_test_context_t    *spdm_test_context;
    1137              :     libspdm_context_t  *spdm_context;
    1138              :     size_t response_size;
    1139              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1140              :     libspdm_algorithms_response_mine_t *spdm_response;
    1141              : 
    1142            1 :     spdm_test_context = *state;
    1143            1 :     spdm_context = spdm_test_context->spdm_context;
    1144            1 :     spdm_test_context->case_id = 0x7;
    1145            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1146              : 
    1147            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1148              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1149            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1150            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1151            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    1152            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    1153            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    1154            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    1155              : 
    1156            1 :     libspdm_reset_message_a(spdm_context);
    1157              : 
    1158            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    1159            1 :     spdm_context->connection_info.capability.flags |=
    1160              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    1161              : 
    1162            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    1163            1 :     spdm_context->connection_info.capability.flags |=
    1164              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    1165              : 
    1166            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    1167            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    1168              : 
    1169            1 :     spdm_context->local_context.capability.flags |=
    1170              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    1171            1 :     spdm_context->connection_info.capability.flags |=
    1172              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    1173              : 
    1174            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1175            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1176              : 
    1177            1 :     response_size = sizeof(response);
    1178            1 :     status = libspdm_get_response_algorithms (spdm_context,
    1179              :                                               m_libspdm_negotiate_algorithm_request3_size,
    1180              :                                               &m_libspdm_negotiate_algorithm_request3,
    1181              :                                               &response_size,
    1182              :                                               response);
    1183            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    1184            1 :     assert_int_equal (response_size,
    1185              :                       sizeof(spdm_algorithms_response_t)+4*
    1186              :                       sizeof(spdm_negotiate_algorithms_common_struct_table_t));
    1187            1 :     spdm_response = (void *)response;
    1188            1 :     assert_int_equal (spdm_response->header.request_response_code, SPDM_ALGORITHMS);
    1189            1 :     assert_int_equal (spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_11);
    1190              : 
    1191            1 :     assert_int_equal (spdm_response->struct_table[0].alg_supported,
    1192              :                       spdm_context->local_context.algorithm.dhe_named_group);
    1193            1 :     assert_int_equal (spdm_response->struct_table[1].alg_supported,
    1194              :                       spdm_context->local_context.algorithm.aead_cipher_suite);
    1195            1 :     assert_int_equal (spdm_response->struct_table[2].alg_supported,
    1196              :                       spdm_context->local_context.algorithm.req_base_asym_alg);
    1197            1 :     assert_int_equal (spdm_response->struct_table[3].alg_supported,
    1198              :                       spdm_context->local_context.algorithm.key_schedule);
    1199            1 : }
    1200              : 
    1201            1 : void libspdm_test_responder_algorithms_case8(void **state) {
    1202              :     libspdm_return_t status;
    1203              :     libspdm_test_context_t    *spdm_test_context;
    1204              :     libspdm_context_t  *spdm_context;
    1205              :     size_t response_size;
    1206              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1207              :     spdm_algorithms_response_t *spdm_response;
    1208              : 
    1209            1 :     spdm_test_context = *state;
    1210            1 :     spdm_context = spdm_test_context->spdm_context;
    1211            1 :     spdm_test_context->case_id = 0x8;
    1212            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1213              : 
    1214            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1215              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1216            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1217            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1218            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    1219            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    1220            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    1221            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    1222              : 
    1223            1 :     libspdm_reset_message_a(spdm_context);
    1224              : 
    1225            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP;
    1226            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
    1227              : 
    1228            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    1229            1 :     spdm_context->connection_info.capability.flags |=
    1230              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    1231              : 
    1232            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    1233            1 :     spdm_context->connection_info.capability.flags |=
    1234              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    1235              : 
    1236            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    1237            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    1238              : 
    1239            1 :     spdm_context->local_context.capability.flags |=
    1240              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    1241            1 :     spdm_context->connection_info.capability.flags |=
    1242              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    1243              : 
    1244            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1245            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1246              : 
    1247            1 :     response_size = sizeof(response);
    1248            1 :     status = libspdm_get_response_algorithms (spdm_context,
    1249              :                                               m_libspdm_negotiate_algorithm_request4_size,
    1250              :                                               &m_libspdm_negotiate_algorithm_request4,
    1251              :                                               &response_size,
    1252              :                                               response);
    1253            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    1254            1 :     assert_int_equal (response_size, sizeof(spdm_error_response_t));
    1255            1 :     spdm_response = (void *)response;
    1256            1 :     assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
    1257            1 :     assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    1258            1 :     assert_int_equal (spdm_response->header.param2, 0);
    1259            1 : }
    1260              : 
    1261            1 : void libspdm_test_responder_algorithms_case9(void **state) {
    1262              :     libspdm_return_t status;
    1263              :     libspdm_test_context_t    *spdm_test_context;
    1264              :     libspdm_context_t  *spdm_context;
    1265              :     size_t response_size;
    1266              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1267              :     spdm_algorithms_response_t *spdm_response;
    1268              : 
    1269            1 :     spdm_test_context = *state;
    1270            1 :     spdm_context = spdm_test_context->spdm_context;
    1271            1 :     spdm_test_context->case_id = 0x9;
    1272            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1273              : 
    1274            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1275              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1276            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1277            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1278            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    1279            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    1280            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    1281            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    1282              : 
    1283            1 :     libspdm_reset_message_a(spdm_context);
    1284              : 
    1285            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP;
    1286            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
    1287              : 
    1288            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    1289            1 :     spdm_context->connection_info.capability.flags |=
    1290              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    1291              : 
    1292            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    1293            1 :     spdm_context->connection_info.capability.flags |=
    1294              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    1295              : 
    1296            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    1297            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    1298              : 
    1299            1 :     spdm_context->local_context.capability.flags |=
    1300              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    1301            1 :     spdm_context->connection_info.capability.flags |=
    1302              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    1303              : 
    1304            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1305            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1306              : 
    1307            1 :     response_size = sizeof(response);
    1308            1 :     status = libspdm_get_response_algorithms (spdm_context,
    1309              :                                               m_libspdm_negotiate_algorithm_request5_size,
    1310              :                                               &m_libspdm_negotiate_algorithm_request5,
    1311              :                                               &response_size,
    1312              :                                               response);
    1313            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    1314            1 :     assert_int_equal (response_size, sizeof(spdm_error_response_t));
    1315            1 :     spdm_response = (void *)response;
    1316            1 :     assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
    1317            1 :     assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    1318            1 :     assert_int_equal (spdm_response->header.param2, 0);
    1319            1 : }
    1320              : 
    1321            1 : void libspdm_test_responder_algorithms_case10(void **state) {
    1322              :     libspdm_return_t status;
    1323              :     libspdm_test_context_t    *spdm_test_context;
    1324              :     libspdm_context_t  *spdm_context;
    1325              :     size_t response_size;
    1326              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1327              :     spdm_algorithms_response_t *spdm_response;
    1328              : 
    1329            1 :     spdm_test_context = *state;
    1330            1 :     spdm_context = spdm_test_context->spdm_context;
    1331            1 :     spdm_test_context->case_id = 0xA;
    1332            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1333              : 
    1334            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1335              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1336            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1337            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1338            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    1339            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    1340            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    1341            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    1342              : 
    1343            1 :     libspdm_reset_message_a(spdm_context);
    1344              : 
    1345            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP;
    1346            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
    1347              : 
    1348            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    1349            1 :     spdm_context->connection_info.capability.flags |=
    1350              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    1351              : 
    1352            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    1353            1 :     spdm_context->connection_info.capability.flags |=
    1354              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    1355              : 
    1356            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    1357            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    1358              : 
    1359            1 :     spdm_context->local_context.capability.flags |=
    1360              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    1361            1 :     spdm_context->connection_info.capability.flags |=
    1362              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    1363              : 
    1364            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1365            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1366              : 
    1367            1 :     response_size = sizeof(response);
    1368            1 :     status = libspdm_get_response_algorithms (spdm_context,
    1369              :                                               m_libspdm_negotiate_algorithm_request6_size,
    1370              :                                               &m_libspdm_negotiate_algorithm_request6,
    1371              :                                               &response_size,
    1372              :                                               response);
    1373            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    1374            1 :     assert_int_equal (response_size, sizeof(spdm_error_response_t));
    1375            1 :     spdm_response = (void *)response;
    1376            1 :     assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
    1377            1 :     assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    1378            1 :     assert_int_equal (spdm_response->header.param2, 0);
    1379            1 : }
    1380              : 
    1381            1 : void libspdm_test_responder_algorithms_case11(void **state) {
    1382              :     libspdm_return_t status;
    1383              :     libspdm_test_context_t    *spdm_test_context;
    1384              :     libspdm_context_t  *spdm_context;
    1385              :     size_t response_size;
    1386              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1387              :     spdm_algorithms_response_t *spdm_response;
    1388              : 
    1389            1 :     spdm_test_context = *state;
    1390            1 :     spdm_context = spdm_test_context->spdm_context;
    1391            1 :     spdm_test_context->case_id = 0xB;
    1392            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1393              : 
    1394            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1395              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1396            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1397            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1398            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    1399            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    1400            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    1401            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    1402              : 
    1403            1 :     libspdm_reset_message_a(spdm_context);
    1404              : 
    1405            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP;
    1406            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
    1407              : 
    1408            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    1409            1 :     spdm_context->connection_info.capability.flags |=
    1410              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    1411              : 
    1412            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    1413            1 :     spdm_context->connection_info.capability.flags |=
    1414              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    1415              : 
    1416            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    1417            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    1418              : 
    1419            1 :     spdm_context->local_context.capability.flags |=
    1420              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    1421            1 :     spdm_context->connection_info.capability.flags |=
    1422              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    1423              : 
    1424            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1425            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1426              : 
    1427            1 :     response_size = sizeof(response);
    1428            1 :     status = libspdm_get_response_algorithms (spdm_context,
    1429              :                                               m_libspdm_negotiate_algorithm_request7_size,
    1430              :                                               &m_libspdm_negotiate_algorithm_request7,
    1431              :                                               &response_size,
    1432              :                                               response);
    1433            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    1434            1 :     assert_int_equal (response_size, sizeof(spdm_error_response_t));
    1435            1 :     spdm_response = (void *)response;
    1436            1 :     assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
    1437            1 :     assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    1438            1 :     assert_int_equal (spdm_response->header.param2, 0);
    1439            1 : }
    1440              : 
    1441            1 : void libspdm_test_responder_algorithms_case12(void **state) {
    1442              :     libspdm_return_t status;
    1443              :     libspdm_test_context_t    *spdm_test_context;
    1444              :     libspdm_context_t  *spdm_context;
    1445              :     size_t response_size;
    1446              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1447              :     spdm_algorithms_response_t *spdm_response;
    1448              : 
    1449            1 :     spdm_test_context = *state;
    1450            1 :     spdm_context = spdm_test_context->spdm_context;
    1451            1 :     spdm_test_context->case_id = 0xC;
    1452            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1453              : 
    1454            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1455              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1456            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1457            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1458            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    1459            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    1460            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    1461            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    1462              : 
    1463            1 :     libspdm_reset_message_a(spdm_context);
    1464              : 
    1465            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP;
    1466            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
    1467              : 
    1468            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    1469            1 :     spdm_context->connection_info.capability.flags |=
    1470              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    1471              : 
    1472            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    1473            1 :     spdm_context->connection_info.capability.flags |=
    1474              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    1475              : 
    1476            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    1477            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    1478              : 
    1479            1 :     spdm_context->local_context.capability.flags |=
    1480              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    1481            1 :     spdm_context->connection_info.capability.flags |=
    1482              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    1483              : 
    1484            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1485            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1486              : 
    1487            1 :     response_size = sizeof(response);
    1488            1 :     status = libspdm_get_response_algorithms (spdm_context,
    1489              :                                               m_libspdm_negotiate_algorithm_request8_size,
    1490              :                                               &m_libspdm_negotiate_algorithm_request8,
    1491              :                                               &response_size,
    1492              :                                               response);
    1493            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    1494            1 :     assert_int_equal (response_size, sizeof(spdm_error_response_t));
    1495            1 :     spdm_response = (void *)response;
    1496            1 :     assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
    1497            1 :     assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    1498            1 :     assert_int_equal (spdm_response->header.param2, 0);
    1499            1 : }
    1500              : 
    1501            1 : void libspdm_test_responder_algorithms_case13(void **state) {
    1502              :     libspdm_return_t status;
    1503              :     libspdm_test_context_t    *spdm_test_context;
    1504              :     libspdm_context_t  *spdm_context;
    1505              :     size_t response_size;
    1506              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1507              :     spdm_algorithms_response_t *spdm_response;
    1508              : 
    1509            1 :     spdm_test_context = *state;
    1510            1 :     spdm_context = spdm_test_context->spdm_context;
    1511            1 :     spdm_test_context->case_id = 0xD;
    1512            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1513              : 
    1514            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1515              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1516            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1517            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1518            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    1519            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    1520            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    1521            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    1522              : 
    1523            1 :     libspdm_reset_message_a(spdm_context);
    1524              : 
    1525            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP;
    1526            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
    1527              : 
    1528            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    1529            1 :     spdm_context->connection_info.capability.flags |=
    1530              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    1531              : 
    1532            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    1533            1 :     spdm_context->connection_info.capability.flags |=
    1534              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    1535              : 
    1536            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    1537            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    1538              : 
    1539            1 :     spdm_context->local_context.capability.flags |=
    1540              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    1541            1 :     spdm_context->connection_info.capability.flags |=
    1542              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    1543              : 
    1544            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1545            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1546              : 
    1547            1 :     response_size = sizeof(response);
    1548            1 :     status = libspdm_get_response_algorithms (spdm_context,
    1549              :                                               m_libspdm_negotiate_algorithm_request9_size,
    1550              :                                               &m_libspdm_negotiate_algorithm_request9,
    1551              :                                               &response_size,
    1552              :                                               response);
    1553            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    1554            1 :     assert_int_equal (response_size, sizeof(spdm_error_response_t));
    1555            1 :     spdm_response = (void *)response;
    1556            1 :     assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
    1557            1 :     assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    1558            1 :     assert_int_equal (spdm_response->header.param2, 0);
    1559            1 : }
    1560              : 
    1561            1 : void libspdm_test_responder_algorithms_case14(void **state) {
    1562              :     libspdm_return_t status;
    1563              :     libspdm_test_context_t    *spdm_test_context;
    1564              :     libspdm_context_t  *spdm_context;
    1565              :     size_t response_size;
    1566              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1567              :     spdm_algorithms_response_t *spdm_response;
    1568              : 
    1569            1 :     spdm_test_context = *state;
    1570            1 :     spdm_context = spdm_test_context->spdm_context;
    1571            1 :     spdm_test_context->case_id = 0xE;
    1572            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1573              : 
    1574            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
    1575              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1576            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1577            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1578              : 
    1579            1 :     libspdm_reset_message_a(spdm_context);
    1580              : 
    1581            1 :     response_size = sizeof(response);
    1582            1 :     status = libspdm_get_response_algorithms (spdm_context,
    1583              :                                               m_libspdm_negotiate_algorithm_request10_size,
    1584              :                                               &m_libspdm_negotiate_algorithm_request10,
    1585              :                                               &response_size,
    1586              :                                               response);
    1587            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    1588            1 :     assert_int_equal (response_size, sizeof(spdm_error_response_t));
    1589            1 :     spdm_response = (void *)response;
    1590            1 :     assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
    1591            1 :     assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    1592            1 :     assert_int_equal (spdm_response->header.param2, 0);
    1593            1 : }
    1594              : 
    1595            1 : void libspdm_test_responder_algorithms_case15(void **state) {
    1596              :     libspdm_return_t status;
    1597              :     libspdm_test_context_t    *spdm_test_context;
    1598              :     libspdm_context_t  *spdm_context;
    1599              :     size_t response_size;
    1600              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1601              :     spdm_algorithms_response_t *spdm_response;
    1602              : 
    1603            1 :     spdm_test_context = *state;
    1604            1 :     spdm_context = spdm_test_context->spdm_context;
    1605            1 :     spdm_test_context->case_id = 0xF;
    1606            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1607              : 
    1608            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1609              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1610            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1611            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1612            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    1613            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    1614            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    1615            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    1616              : 
    1617            1 :     libspdm_reset_message_a(spdm_context);
    1618              : 
    1619            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    1620            1 :     spdm_context->connection_info.capability.flags |=
    1621              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    1622              : 
    1623            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    1624            1 :     spdm_context->connection_info.capability.flags |=
    1625              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    1626              : 
    1627            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    1628            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    1629              : 
    1630            1 :     spdm_context->local_context.capability.flags |=
    1631              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    1632            1 :     spdm_context->connection_info.capability.flags |=
    1633              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    1634              : 
    1635            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1636            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1637              : 
    1638            1 :     response_size = sizeof(response);
    1639            1 :     status = libspdm_get_response_algorithms (spdm_context,
    1640              :                                               m_libspdm_negotiate_algorithm_request11_size,
    1641              :                                               &m_libspdm_negotiate_algorithm_request11,
    1642              :                                               &response_size,
    1643              :                                               response);
    1644            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    1645            1 :     assert_int_equal (response_size, sizeof(spdm_error_response_t));
    1646            1 :     spdm_response = (void *)response;
    1647            1 :     assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
    1648            1 :     assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    1649            1 :     assert_int_equal (spdm_response->header.param2, 0);
    1650            1 : }
    1651              : 
    1652            1 : void libspdm_test_responder_algorithms_case16(void **state) {
    1653              :     libspdm_return_t status;
    1654              :     libspdm_test_context_t    *spdm_test_context;
    1655              :     libspdm_context_t  *spdm_context;
    1656              :     size_t response_size;
    1657              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1658              :     libspdm_algorithms_response_mine_t *spdm_response;
    1659              : 
    1660            1 :     spdm_test_context = *state;
    1661            1 :     spdm_context = spdm_test_context->spdm_context;
    1662            1 :     spdm_test_context->case_id = 0x10;
    1663            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1664              : 
    1665            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1666              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1667            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1668            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1669            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    1670            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    1671            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    1672            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    1673              : 
    1674            1 :     libspdm_reset_message_a(spdm_context);
    1675              : 
    1676            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    1677            1 :     spdm_context->connection_info.capability.flags |=
    1678              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    1679              : 
    1680            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    1681            1 :     spdm_context->connection_info.capability.flags |=
    1682              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    1683              : 
    1684            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    1685            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    1686              : 
    1687            1 :     spdm_context->local_context.capability.flags |=
    1688              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    1689            1 :     spdm_context->connection_info.capability.flags |=
    1690              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    1691              : 
    1692            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1693            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1694              : 
    1695            1 :     response_size = sizeof(response);
    1696            1 :     status = libspdm_get_response_algorithms (spdm_context,
    1697              :                                               m_libspdm_negotiate_algorithm_request12_size,
    1698              :                                               &m_libspdm_negotiate_algorithm_request12,
    1699              :                                               &response_size,
    1700              :                                               response);
    1701            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1702            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
    1703            1 :     spdm_response = (void*)response;
    1704            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
    1705            1 :     assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    1706            1 :     assert_int_equal(spdm_response->header.param2, 0);
    1707            1 : }
    1708              : 
    1709            1 : void libspdm_test_responder_algorithms_case17(void **state) {
    1710              :     libspdm_return_t status;
    1711              :     libspdm_test_context_t    *spdm_test_context;
    1712              :     libspdm_context_t  *spdm_context;
    1713              :     size_t response_size;
    1714              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1715              :     libspdm_algorithms_response_mine_t *spdm_response;
    1716              : 
    1717            1 :     spdm_test_context = *state;
    1718            1 :     spdm_context = spdm_test_context->spdm_context;
    1719            1 :     spdm_test_context->case_id = 0x11;
    1720            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1721              : 
    1722            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1723              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1724            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1725            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1726            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    1727            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    1728            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    1729            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    1730              : 
    1731            1 :     libspdm_reset_message_a(spdm_context);
    1732              : 
    1733            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    1734            1 :     spdm_context->connection_info.capability.flags |=
    1735              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    1736              : 
    1737            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    1738            1 :     spdm_context->connection_info.capability.flags |=
    1739              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    1740              : 
    1741            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    1742            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    1743              : 
    1744            1 :     spdm_context->local_context.capability.flags |=
    1745              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    1746            1 :     spdm_context->connection_info.capability.flags |=
    1747              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    1748              : 
    1749            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1750            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1751              : 
    1752            1 :     response_size = sizeof(response);
    1753            1 :     status = libspdm_get_response_algorithms (spdm_context,
    1754              :                                               m_libspdm_negotiate_algorithm_request13_size,
    1755              :                                               &m_libspdm_negotiate_algorithm_request13,
    1756              :                                               &response_size,
    1757              :                                               response);
    1758            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1759            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
    1760            1 :     spdm_response = (void*)response;
    1761            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
    1762            1 :     assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    1763            1 :     assert_int_equal(spdm_response->header.param2, 0);
    1764            1 : }
    1765              : 
    1766            1 : void libspdm_test_responder_algorithms_case18(void **state) {
    1767              :     libspdm_return_t status;
    1768              :     libspdm_test_context_t    *spdm_test_context;
    1769              :     libspdm_context_t  *spdm_context;
    1770              :     size_t response_size;
    1771              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1772              :     libspdm_algorithms_response_mine_t *spdm_response;
    1773              : 
    1774            1 :     spdm_test_context = *state;
    1775            1 :     spdm_context = spdm_test_context->spdm_context;
    1776            1 :     spdm_test_context->case_id = 0x12;
    1777            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1778              : 
    1779            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1780              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1781            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1782            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1783            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    1784            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    1785            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    1786            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    1787              : 
    1788            1 :     libspdm_reset_message_a(spdm_context);
    1789              : 
    1790            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    1791            1 :     spdm_context->connection_info.capability.flags |=
    1792              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    1793              : 
    1794            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    1795            1 :     spdm_context->connection_info.capability.flags |=
    1796              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    1797              : 
    1798            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    1799            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    1800              : 
    1801            1 :     spdm_context->local_context.capability.flags |=
    1802              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    1803            1 :     spdm_context->connection_info.capability.flags |=
    1804              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    1805              : 
    1806            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1807            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1808              : 
    1809            1 :     response_size = sizeof(response);
    1810            1 :     status = libspdm_get_response_algorithms (spdm_context,
    1811              :                                               m_libspdm_negotiate_algorithm_request14_size,
    1812              :                                               &m_libspdm_negotiate_algorithm_request14,
    1813              :                                               &response_size,
    1814              :                                               response);
    1815            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    1816            1 :     assert_int_equal (response_size, sizeof(spdm_error_response_t));
    1817            1 :     spdm_response = (void *)response;
    1818            1 :     assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
    1819            1 :     assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    1820            1 :     assert_int_equal (spdm_response->header.param2, 0);
    1821            1 : }
    1822              : 
    1823            1 : void libspdm_test_responder_algorithms_case19(void **state) {
    1824              :     libspdm_return_t status;
    1825              :     libspdm_test_context_t    *spdm_test_context;
    1826              :     libspdm_context_t  *spdm_context;
    1827              :     size_t response_size;
    1828              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1829              :     libspdm_algorithms_response_mine_t *spdm_response;
    1830              : 
    1831            1 :     spdm_test_context = *state;
    1832            1 :     spdm_context = spdm_test_context->spdm_context;
    1833            1 :     spdm_test_context->case_id = 0x13;
    1834            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1835              : 
    1836            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1837              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1838            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1839            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1840            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    1841            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    1842            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    1843            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    1844              : 
    1845            1 :     libspdm_reset_message_a(spdm_context);
    1846              : 
    1847            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    1848            1 :     spdm_context->connection_info.capability.flags |=
    1849              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    1850              : 
    1851            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    1852            1 :     spdm_context->connection_info.capability.flags |=
    1853              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    1854              : 
    1855            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    1856            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    1857              : 
    1858            1 :     spdm_context->local_context.capability.flags |=
    1859              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    1860            1 :     spdm_context->connection_info.capability.flags |=
    1861              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    1862              : 
    1863            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1864            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1865              : 
    1866            1 :     response_size = sizeof(response);
    1867            1 :     status = libspdm_get_response_algorithms (spdm_context,
    1868              :                                               m_libspdm_negotiate_algorithm_request15_size,
    1869              :                                               &m_libspdm_negotiate_algorithm_request15,
    1870              :                                               &response_size,
    1871              :                                               response);
    1872            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    1873            1 :     assert_int_equal(response_size, sizeof(spdm_error_response_t));
    1874            1 :     spdm_response = (void*)response;
    1875            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
    1876            1 :     assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    1877            1 :     assert_int_equal(spdm_response->header.param2, 0);
    1878            1 : }
    1879              : 
    1880              : /* When both of requester and responder support multiple algorithms, then defaults to choose the strongest available algorithm*/
    1881            1 : void libspdm_test_responder_algorithms_case20(void **state) {
    1882              :     libspdm_return_t status;
    1883              :     libspdm_test_context_t    *spdm_test_context;
    1884              :     libspdm_context_t  *spdm_context;
    1885              :     size_t response_size;
    1886              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1887              :     libspdm_algorithms_response_mine_t *spdm_response;
    1888              : 
    1889            1 :     spdm_test_context = *state;
    1890            1 :     spdm_context = spdm_test_context->spdm_context;
    1891            1 :     spdm_test_context->case_id = 0x14;
    1892            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1893              : 
    1894            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1895              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1896            1 :     spdm_context->local_context.algorithm.base_hash_algo =
    1897              :         SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512 |
    1898              :         SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256;
    1899            1 :     spdm_context->local_context.algorithm.base_asym_algo =
    1900              :         SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521 |
    1901              :         SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384 |
    1902              :         SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048;
    1903            1 :     spdm_context->local_context.algorithm.dhe_named_group =
    1904              :         SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_521_R1 |
    1905              :         SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_384_R1 |
    1906              :         SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1;
    1907            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    1908            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    1909            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    1910              : 
    1911            1 :     libspdm_reset_message_a(spdm_context);
    1912              : 
    1913            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    1914            1 :     spdm_context->connection_info.capability.flags |=
    1915              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    1916              : 
    1917            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    1918            1 :     spdm_context->connection_info.capability.flags |=
    1919              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    1920              : 
    1921            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    1922            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    1923              : 
    1924            1 :     spdm_context->local_context.capability.flags |=
    1925              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    1926            1 :     spdm_context->connection_info.capability.flags |=
    1927              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    1928              : 
    1929            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    1930            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    1931              : 
    1932            1 :     response_size = sizeof(response);
    1933            1 :     status = libspdm_get_response_algorithms (spdm_context,
    1934              :                                               m_libspdm_negotiate_algorithm_request16_size,
    1935              :                                               &m_libspdm_negotiate_algorithm_request16,
    1936              :                                               &response_size,
    1937              :                                               response);
    1938            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    1939            1 :     assert_int_equal (response_size,
    1940              :                       sizeof(spdm_algorithms_response_t)+4*
    1941              :                       sizeof(spdm_negotiate_algorithms_common_struct_table_t));
    1942            1 :     spdm_response = (void *)response;
    1943            1 :     assert_int_equal (spdm_response->header.request_response_code, SPDM_ALGORITHMS);
    1944            1 :     assert_int_equal (spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_11);
    1945              : 
    1946            1 :     assert_int_equal (spdm_response->base_hash_sel, SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512);
    1947            1 :     assert_int_equal (spdm_response->base_hash_sel,
    1948              :                       spdm_context->connection_info.algorithm.base_hash_algo);
    1949              : 
    1950            1 :     assert_int_equal (spdm_response->base_asym_sel,
    1951              :                       SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521);
    1952            1 :     assert_int_equal (spdm_response->base_asym_sel,
    1953              :                       spdm_context->connection_info.algorithm.base_asym_algo);
    1954              : 
    1955            1 :     assert_int_equal (spdm_response->struct_table[0].alg_supported,
    1956              :                       SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_384_R1);
    1957            1 :     assert_int_equal (spdm_response->struct_table[0].alg_supported,
    1958              :                       spdm_context->connection_info.algorithm.dhe_named_group);
    1959              : 
    1960            1 :     assert_int_equal (spdm_response->struct_table[1].alg_supported,
    1961              :                       spdm_context->connection_info.algorithm.aead_cipher_suite);
    1962            1 :     assert_int_equal (spdm_response->struct_table[2].alg_supported,
    1963              :                       spdm_context->connection_info.algorithm.req_base_asym_alg);
    1964            1 :     assert_int_equal (spdm_response->struct_table[3].alg_supported,
    1965              :                       spdm_context->connection_info.algorithm.key_schedule);
    1966            1 : }
    1967              : 
    1968            1 : void libspdm_test_responder_algorithms_case21(void **state) {
    1969              :     libspdm_return_t status;
    1970              :     libspdm_test_context_t *spdm_test_context;
    1971              :     libspdm_context_t *spdm_context;
    1972              :     size_t response_size;
    1973              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    1974              :     libspdm_algorithms_response_mine_t *spdm_response;
    1975              :     size_t arbitrary_size;
    1976              : 
    1977            1 :     spdm_test_context = *state;
    1978            1 :     spdm_context = spdm_test_context->spdm_context;
    1979            1 :     spdm_test_context->case_id = 0x15;
    1980            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    1981              : 
    1982            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
    1983              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    1984            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    1985            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    1986            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    1987            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    1988            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    1989            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    1990              : 
    1991            1 :     libspdm_reset_message_a(spdm_context);
    1992              : 
    1993            1 :     spdm_context->local_context.capability.flags |=
    1994              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    1995            1 :     spdm_context->connection_info.capability.flags |=
    1996              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    1997              : 
    1998            1 :     spdm_context->local_context.capability.flags |=
    1999              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    2000            1 :     spdm_context->connection_info.capability.flags |=
    2001              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    2002              : 
    2003            1 :     spdm_context->local_context.capability.flags |=
    2004              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    2005            1 :     spdm_context->connection_info.capability.flags |=
    2006              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    2007              : 
    2008            1 :     spdm_context->local_context.capability.flags |=
    2009              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    2010            1 :     spdm_context->connection_info.capability.flags |=
    2011              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    2012              : 
    2013            1 :     spdm_context->local_context.capability.flags |=
    2014              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    2015            1 :     spdm_context->connection_info.capability.flags |=
    2016              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    2017              : 
    2018              :     /*filling A with arbitrary data*/
    2019            1 :     arbitrary_size = 10;
    2020            1 :     libspdm_set_mem(spdm_context->transcript.message_a.buffer, arbitrary_size, (uint8_t) 0xFF);
    2021            1 :     spdm_context->transcript.message_a.buffer_size = arbitrary_size;
    2022              : 
    2023            1 :     response_size = sizeof(response);
    2024            1 :     status = libspdm_get_response_algorithms(
    2025              :         spdm_context,
    2026              :         m_libspdm_negotiate_algorithm_request3_size, &m_libspdm_negotiate_algorithm_request3,
    2027              :         &response_size, response);
    2028            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    2029            1 :     assert_int_equal(response_size,
    2030              :                      sizeof(spdm_algorithms_response_t) +
    2031              :                      4*sizeof(spdm_negotiate_algorithms_common_struct_table_t));
    2032            1 :     spdm_response = (void *)response;
    2033            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_ALGORITHMS);
    2034            1 :     assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_11);
    2035              : 
    2036            1 :     assert_int_equal(spdm_response->struct_table[0].alg_supported,
    2037              :                      spdm_context->local_context.algorithm.dhe_named_group);
    2038            1 :     assert_int_equal(spdm_response->struct_table[1].alg_supported,
    2039              :                      spdm_context->local_context.algorithm.aead_cipher_suite);
    2040            1 :     assert_int_equal(spdm_response->struct_table[2].alg_supported,
    2041              :                      spdm_context->local_context.algorithm.req_base_asym_alg);
    2042            1 :     assert_int_equal(spdm_response->struct_table[3].alg_supported,
    2043              :                      spdm_context->local_context.algorithm.key_schedule);
    2044              : 
    2045            1 :     assert_int_equal(spdm_context->transcript.message_a.buffer_size,
    2046              :                      arbitrary_size + m_libspdm_negotiate_algorithm_request3_size + response_size);
    2047            1 :     assert_memory_equal(spdm_context->transcript.message_a.buffer + arbitrary_size,
    2048              :                         &m_libspdm_negotiate_algorithm_request3,
    2049              :                         m_libspdm_negotiate_algorithm_request3_size);
    2050            1 :     assert_memory_equal(spdm_context->transcript.message_a.buffer + arbitrary_size +
    2051              :                         m_libspdm_negotiate_algorithm_request3_size, response, response_size);
    2052            1 : }
    2053              : 
    2054            1 : void libspdm_test_responder_algorithms_case22(void **state)
    2055              : {
    2056              :     libspdm_return_t status;
    2057              :     libspdm_test_context_t    *spdm_test_context;
    2058              :     libspdm_context_t  *spdm_context;
    2059              :     size_t response_size;
    2060              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    2061              :     libspdm_algorithms_response_mine_t *spdm_response;
    2062              : 
    2063            1 :     spdm_test_context = *state;
    2064            1 :     spdm_context = spdm_test_context->spdm_context;
    2065            1 :     spdm_test_context->case_id = 0x16;
    2066            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2067              : 
    2068            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
    2069              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    2070            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    2071            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    2072            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    2073            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    2074            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    2075            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    2076            1 :     spdm_context->local_context.algorithm.other_params_support =
    2077              :         SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
    2078              :     /* spdm_context->connection_info.algorithm.other_params_support = SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1; */
    2079            1 :     libspdm_reset_message_a(spdm_context);
    2080            1 :     spdm_context->local_context.capability.flags = 0;
    2081            1 :     spdm_context->connection_info.capability.flags = 0;
    2082            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    2083            1 :     spdm_context->connection_info.capability.flags |=
    2084              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    2085              : 
    2086            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    2087            1 :     spdm_context->connection_info.capability.flags |=
    2088              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    2089              : 
    2090            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    2091            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    2092              : 
    2093            1 :     spdm_context->local_context.capability.flags |=
    2094              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    2095            1 :     spdm_context->connection_info.capability.flags |=
    2096              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    2097              : 
    2098            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    2099            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    2100              : 
    2101            1 :     response_size = sizeof(response);
    2102            1 :     status = libspdm_get_response_algorithms (spdm_context,
    2103              :                                               m_libspdm_negotiate_algorithm_request17_size,
    2104              :                                               &m_libspdm_negotiate_algorithm_request17,
    2105              :                                               &response_size,
    2106              :                                               response);
    2107            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    2108            1 :     assert_int_equal (response_size,
    2109              :                       sizeof(spdm_algorithms_response_t)+4*
    2110              :                       sizeof(spdm_negotiate_algorithms_common_struct_table_t));
    2111            1 :     spdm_response = (void *)response;
    2112            1 :     assert_int_equal (spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
    2113            1 :     assert_int_equal (spdm_response->header.request_response_code, SPDM_ALGORITHMS);
    2114            1 :     assert_int_equal(spdm_response->header.param1, 4);
    2115            1 :     assert_int_equal (spdm_response->struct_table[0].alg_supported,
    2116              :                       spdm_context->local_context.algorithm.dhe_named_group);
    2117            1 :     assert_int_equal (spdm_response->struct_table[1].alg_supported,
    2118              :                       spdm_context->local_context.algorithm.aead_cipher_suite);
    2119            1 :     assert_int_equal (spdm_response->struct_table[2].alg_supported,
    2120              :                       spdm_context->local_context.algorithm.req_base_asym_alg);
    2121            1 :     assert_int_equal (spdm_response->struct_table[3].alg_supported,
    2122              :                       spdm_context->local_context.algorithm.key_schedule);
    2123            1 : }
    2124              : 
    2125            1 : void libspdm_test_responder_algorithms_case23(void **state)
    2126              : {
    2127              :     libspdm_return_t status;
    2128              :     libspdm_test_context_t    *spdm_test_context;
    2129              :     libspdm_context_t  *spdm_context;
    2130              :     size_t response_size;
    2131              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    2132              :     spdm_algorithms_response_t *spdm_response;
    2133              : 
    2134            1 :     spdm_test_context = *state;
    2135            1 :     spdm_context = spdm_test_context->spdm_context;
    2136            1 :     spdm_test_context->case_id = 0x17;
    2137            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2138              : 
    2139            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
    2140              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    2141            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    2142            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    2143            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    2144            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    2145            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    2146            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    2147            1 :     libspdm_reset_message_a(spdm_context);
    2148            1 :     spdm_context->local_context.capability.flags = 0;
    2149            1 :     spdm_context->connection_info.capability.flags = 0;
    2150            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    2151            1 :     spdm_context->connection_info.capability.flags |=
    2152              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    2153              : 
    2154            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    2155            1 :     spdm_context->connection_info.capability.flags |=
    2156              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    2157              : 
    2158            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    2159            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    2160              : 
    2161            1 :     spdm_context->local_context.capability.flags |=
    2162              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    2163            1 :     spdm_context->connection_info.capability.flags |=
    2164              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    2165              : 
    2166            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    2167            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    2168              : 
    2169              :     /* Sub Case 1: other_params_support set OpaqueDataFmt1 */
    2170            1 :     m_libspdm_negotiate_algorithm_request18.spdm_request_version10.other_params_support =
    2171              :         SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
    2172            1 :     spdm_context->local_context.algorithm.other_params_support =
    2173              :         SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
    2174            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2175            1 :     libspdm_reset_message_a(spdm_context);
    2176              : 
    2177            1 :     response_size = sizeof(response);
    2178            1 :     status = libspdm_get_response_algorithms (spdm_context,
    2179              :                                               m_libspdm_negotiate_algorithm_request18_size,
    2180              :                                               &m_libspdm_negotiate_algorithm_request18,
    2181              :                                               &response_size,
    2182              :                                               response);
    2183            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    2184            1 :     assert_int_equal(response_size,
    2185              :                      sizeof(spdm_algorithms_response_t) + 4*
    2186              :                      sizeof(spdm_negotiate_algorithms_common_struct_table_t));
    2187            1 :     spdm_response = (void *)response;
    2188            1 :     assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
    2189            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_ALGORITHMS);
    2190            1 :     assert_int_equal(spdm_response->other_params_selection, SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1);
    2191            1 :     assert_int_equal(spdm_context->connection_info.algorithm.other_params_support,
    2192              :                      SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1);
    2193              : 
    2194              :     /* Sub Case 2: Populate reserved field for version 1.2.
    2195              :      * Field values marked as Reserved shall be written as zero (0). */
    2196            1 :     spdm_context->local_context.algorithm.other_params_support =
    2197              :         SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1 |
    2198              :         SPDM_ALGORITHMS_MULTI_KEY_CONN;
    2199            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2200            1 :     libspdm_reset_message_a(spdm_context);
    2201            1 :     response_size = sizeof(response);
    2202            1 :     status = libspdm_get_response_algorithms (spdm_context,
    2203              :                                               m_libspdm_negotiate_algorithm_request18_size,
    2204              :                                               &m_libspdm_negotiate_algorithm_request18,
    2205              :                                               &response_size,
    2206              :                                               response);
    2207            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    2208            1 :     assert_int_equal(response_size,
    2209              :                      sizeof(spdm_algorithms_response_t) + 4*
    2210              :                      sizeof(spdm_negotiate_algorithms_common_struct_table_t));
    2211            1 :     spdm_response = (void *)response;
    2212            1 :     assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
    2213            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_ALGORITHMS);
    2214            1 :     assert_int_equal(spdm_response->other_params_selection, SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1);
    2215            1 :     assert_int_equal(spdm_context->connection_info.algorithm.other_params_support,
    2216              :                      SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1);
    2217              : 
    2218              :     /* Sub Case 3: OpaqueDataFmt. Supports both SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_0 and
    2219              :      * SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1. */
    2220            1 :     m_libspdm_negotiate_algorithm_request18.spdm_request_version10.other_params_support =
    2221              :         SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_0 |
    2222              :         SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
    2223            1 :     spdm_context->local_context.algorithm.other_params_support =
    2224              :         SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_0 |
    2225              :         SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
    2226            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2227            1 :     libspdm_reset_message_a(spdm_context);
    2228            1 :     response_size = sizeof(response);
    2229            1 :     status = libspdm_get_response_algorithms (spdm_context,
    2230              :                                               m_libspdm_negotiate_algorithm_request18_size,
    2231              :                                               &m_libspdm_negotiate_algorithm_request18,
    2232              :                                               &response_size,
    2233              :                                               response);
    2234            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    2235            1 :     assert_int_equal(response_size,
    2236              :                      sizeof(spdm_algorithms_response_t) + 4*
    2237              :                      sizeof(spdm_negotiate_algorithms_common_struct_table_t));
    2238            1 :     spdm_response = (void *)response;
    2239            1 :     assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
    2240            1 :     assert_int_equal(spdm_response->header.request_response_code, SPDM_ALGORITHMS);
    2241            1 :     assert_int_equal(spdm_response->other_params_selection, SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1);
    2242            1 :     assert_int_equal(spdm_context->connection_info.algorithm.other_params_support,
    2243              :                      SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1);
    2244            1 : }
    2245              : 
    2246            1 : void libspdm_test_responder_algorithms_case24(void **state)
    2247              : {
    2248              :     libspdm_return_t status;
    2249              :     libspdm_test_context_t    *spdm_test_context;
    2250              :     libspdm_context_t  *spdm_context;
    2251              :     size_t response_size;
    2252              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    2253              :     spdm_algorithms_response_t *spdm_response;
    2254              : 
    2255            1 :     spdm_test_context = *state;
    2256            1 :     spdm_context = spdm_test_context->spdm_context;
    2257            1 :     spdm_test_context->case_id = 0x18;
    2258            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2259              : 
    2260            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
    2261              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    2262            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    2263            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    2264            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    2265            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    2266            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    2267            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    2268            1 :     spdm_context->local_context.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
    2269            1 :     spdm_context->local_context.algorithm.measurement_hash_algo =
    2270              :         m_libspdm_use_measurement_hash_algo;
    2271            1 :     libspdm_reset_message_a(spdm_context);
    2272            1 :     spdm_context->local_context.capability.flags =
    2273              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
    2274            1 :     spdm_context->connection_info.capability.flags = 0;
    2275              : 
    2276            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    2277            1 :     spdm_context->connection_info.capability.flags |=
    2278              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    2279              : 
    2280            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    2281            1 :     spdm_context->connection_info.capability.flags |=
    2282              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    2283              : 
    2284            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    2285            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    2286              : 
    2287            1 :     spdm_context->local_context.capability.flags |=
    2288              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    2289            1 :     spdm_context->connection_info.capability.flags |=
    2290              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    2291              : 
    2292            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    2293            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    2294              : 
    2295            1 :     response_size = sizeof(response);
    2296            1 :     status = libspdm_get_response_algorithms (spdm_context,
    2297              :                                               m_libspdm_negotiate_algorithm_request24_size,
    2298              :                                               &m_libspdm_negotiate_algorithm_request24,
    2299              :                                               &response_size,
    2300              :                                               response);
    2301            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    2302            1 :     assert_int_equal(response_size,
    2303              :                      sizeof(spdm_algorithms_response_t) +
    2304              :                      4*sizeof(spdm_negotiate_algorithms_common_struct_table_t));
    2305            1 :     spdm_response = (void *)response;
    2306            1 :     assert_int_equal(spdm_response->header.request_response_code,
    2307              :                      SPDM_ALGORITHMS);
    2308            1 :     assert_int_equal(spdm_response->measurement_hash_algo, 0);
    2309            1 :     assert_int_equal(spdm_response->measurement_specification_sel, 0);
    2310            1 : }
    2311              : 
    2312            1 : void libspdm_test_responder_algorithms_case25(void **state)
    2313              : {
    2314              :     libspdm_return_t status;
    2315              :     libspdm_test_context_t    *spdm_test_context;
    2316              :     libspdm_context_t  *spdm_context;
    2317              :     size_t response_size;
    2318              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    2319              :     spdm_algorithms_response_t *spdm_response;
    2320              : 
    2321            1 :     spdm_test_context = *state;
    2322            1 :     spdm_context = spdm_test_context->spdm_context;
    2323            1 :     spdm_test_context->case_id = 0x19;
    2324            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2325              : 
    2326            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
    2327              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    2328            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    2329            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    2330            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    2331            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    2332            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    2333            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    2334            1 :     spdm_context->local_context.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
    2335            1 :     spdm_context->local_context.algorithm.measurement_hash_algo =
    2336              :         m_libspdm_use_measurement_hash_algo;
    2337            1 :     libspdm_reset_message_a(spdm_context);
    2338            1 :     spdm_context->local_context.capability.flags =
    2339              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
    2340            1 :     spdm_context->connection_info.capability.flags = 0;
    2341              : 
    2342            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    2343            1 :     spdm_context->connection_info.capability.flags |=
    2344              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    2345              : 
    2346            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    2347            1 :     spdm_context->connection_info.capability.flags |=
    2348              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    2349              : 
    2350            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    2351            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    2352              : 
    2353            1 :     spdm_context->local_context.capability.flags |=
    2354              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    2355            1 :     spdm_context->connection_info.capability.flags |=
    2356              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    2357              : 
    2358            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    2359            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    2360              : 
    2361            1 :     response_size = sizeof(response);
    2362            1 :     status = libspdm_get_response_algorithms (spdm_context,
    2363              :                                               m_libspdm_negotiate_algorithm_request25_size,
    2364              :                                               &m_libspdm_negotiate_algorithm_request25,
    2365              :                                               &response_size,
    2366              :                                               response);
    2367            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    2368            1 :     assert_int_equal (response_size, sizeof(spdm_error_response_t));
    2369            1 :     spdm_response = (void *)response;
    2370            1 :     assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
    2371            1 :     assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    2372            1 :     assert_int_equal (spdm_response->header.param2, 0);
    2373            1 : }
    2374              : 
    2375            1 : void libspdm_test_responder_algorithms_case26(void **state)
    2376              : {
    2377              :     libspdm_return_t status;
    2378              :     libspdm_test_context_t    *spdm_test_context;
    2379              :     libspdm_context_t  *spdm_context;
    2380              :     size_t response_size;
    2381              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    2382              :     spdm_algorithms_response_t *spdm_response;
    2383              : 
    2384            1 :     spdm_test_context = *state;
    2385            1 :     spdm_context = spdm_test_context->spdm_context;
    2386            1 :     spdm_test_context->case_id = 0x1A;
    2387            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2388              : 
    2389            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
    2390              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    2391            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    2392            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    2393            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    2394            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    2395            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    2396            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    2397            1 :     spdm_context->local_context.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
    2398            1 :     spdm_context->local_context.algorithm.measurement_hash_algo =
    2399              :         m_libspdm_use_measurement_hash_algo;
    2400            1 :     libspdm_reset_message_a(spdm_context);
    2401            1 :     spdm_context->local_context.capability.flags =
    2402              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
    2403            1 :     spdm_context->connection_info.capability.flags = 0;
    2404              : 
    2405            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    2406            1 :     spdm_context->connection_info.capability.flags |=
    2407              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    2408              : 
    2409            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    2410            1 :     spdm_context->connection_info.capability.flags |=
    2411              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    2412              : 
    2413            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    2414            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    2415              : 
    2416            1 :     spdm_context->local_context.capability.flags |=
    2417              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    2418            1 :     spdm_context->connection_info.capability.flags |=
    2419              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    2420              : 
    2421            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    2422            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    2423              : 
    2424            1 :     response_size = sizeof(response);
    2425            1 :     status = libspdm_get_response_algorithms (spdm_context,
    2426              :                                               m_libspdm_negotiate_algorithm_request26_size,
    2427              :                                               &m_libspdm_negotiate_algorithm_request26,
    2428              :                                               &response_size,
    2429              :                                               response);
    2430            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    2431            1 :     assert_int_equal (response_size, sizeof(spdm_error_response_t));
    2432            1 :     spdm_response = (void *)response;
    2433            1 :     assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
    2434            1 :     assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    2435            1 :     assert_int_equal (spdm_response->header.param2, 0);
    2436            1 : }
    2437              : 
    2438            1 : void libspdm_test_responder_algorithms_case27(void **state)
    2439              : {
    2440              :     libspdm_return_t status;
    2441              :     libspdm_test_context_t    *spdm_test_context;
    2442              :     libspdm_context_t  *spdm_context;
    2443              :     size_t response_size;
    2444              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    2445              :     spdm_algorithms_response_t *spdm_response;
    2446              : 
    2447            1 :     spdm_test_context = *state;
    2448            1 :     spdm_context = spdm_test_context->spdm_context;
    2449            1 :     spdm_test_context->case_id = 0x1B;
    2450            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2451              : 
    2452            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
    2453              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    2454            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    2455            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    2456            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    2457            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    2458            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    2459            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    2460            1 :     spdm_context->local_context.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
    2461            1 :     spdm_context->local_context.algorithm.measurement_hash_algo =
    2462              :         m_libspdm_use_measurement_hash_algo;
    2463            1 :     libspdm_reset_message_a(spdm_context);
    2464            1 :     spdm_context->local_context.capability.flags =
    2465              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
    2466            1 :     spdm_context->connection_info.capability.flags = 0;
    2467              : 
    2468            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    2469            1 :     spdm_context->connection_info.capability.flags |=
    2470              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    2471              : 
    2472            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    2473            1 :     spdm_context->connection_info.capability.flags |=
    2474              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    2475              : 
    2476            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    2477            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    2478              : 
    2479            1 :     spdm_context->local_context.capability.flags |=
    2480              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    2481            1 :     spdm_context->connection_info.capability.flags |=
    2482              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    2483              : 
    2484            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    2485            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    2486              : 
    2487            1 :     response_size = sizeof(response);
    2488            1 :     status = libspdm_get_response_algorithms (spdm_context,
    2489              :                                               m_libspdm_negotiate_algorithm_request27_size,
    2490              :                                               &m_libspdm_negotiate_algorithm_request27,
    2491              :                                               &response_size,
    2492              :                                               response);
    2493            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    2494            1 :     assert_int_equal (response_size, sizeof(spdm_error_response_t));
    2495            1 :     spdm_response = (void *)response;
    2496            1 :     assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
    2497            1 :     assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    2498            1 :     assert_int_equal (spdm_response->header.param2, 0);
    2499            1 : }
    2500              : 
    2501            1 : void libspdm_test_responder_algorithms_case28(void **state)
    2502              : {
    2503              :     libspdm_return_t status;
    2504              :     libspdm_test_context_t    *spdm_test_context;
    2505              :     libspdm_context_t  *spdm_context;
    2506              :     size_t response_size;
    2507              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    2508              :     spdm_algorithms_response_t *spdm_response;
    2509              : 
    2510            1 :     spdm_test_context = *state;
    2511            1 :     spdm_context = spdm_test_context->spdm_context;
    2512            1 :     spdm_test_context->case_id = 0x1C;
    2513            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2514              : 
    2515            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
    2516              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    2517            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    2518            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    2519            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    2520            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    2521            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    2522            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    2523            1 :     spdm_context->local_context.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
    2524            1 :     spdm_context->local_context.algorithm.measurement_hash_algo =
    2525              :         m_libspdm_use_measurement_hash_algo;
    2526            1 :     libspdm_reset_message_a(spdm_context);
    2527            1 :     spdm_context->local_context.capability.flags =
    2528              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
    2529            1 :     spdm_context->connection_info.capability.flags = 0;
    2530              : 
    2531            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
    2532            1 :     spdm_context->connection_info.capability.flags |=
    2533              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
    2534              : 
    2535            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
    2536            1 :     spdm_context->connection_info.capability.flags |=
    2537              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
    2538              : 
    2539            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
    2540            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
    2541              : 
    2542            1 :     spdm_context->local_context.capability.flags |=
    2543              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
    2544            1 :     spdm_context->connection_info.capability.flags |=
    2545              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
    2546              : 
    2547            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
    2548            1 :     spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
    2549              : 
    2550            1 :     response_size = sizeof(response);
    2551            1 :     status = libspdm_get_response_algorithms (spdm_context,
    2552              :                                               m_libspdm_negotiate_algorithm_request28_size,
    2553              :                                               &m_libspdm_negotiate_algorithm_request28,
    2554              :                                               &response_size,
    2555              :                                               response);
    2556            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    2557            1 :     assert_int_equal (response_size, sizeof(spdm_error_response_t));
    2558            1 :     spdm_response = (void *)response;
    2559            1 :     assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
    2560            1 :     assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    2561            1 :     assert_int_equal (spdm_response->header.param2, 0);
    2562            1 : }
    2563              : 
    2564            1 : void libspdm_test_responder_algorithms_case29(void **state)
    2565              : {
    2566              :     libspdm_return_t status;
    2567              :     libspdm_test_context_t    *spdm_test_context;
    2568              :     libspdm_context_t  *spdm_context;
    2569              :     size_t response_size;
    2570              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    2571              :     spdm_algorithms_response_t *spdm_response;
    2572              : 
    2573            1 :     spdm_test_context = *state;
    2574            1 :     spdm_context = spdm_test_context->spdm_context;
    2575            1 :     spdm_test_context->case_id = 0x1C;
    2576            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2577              : 
    2578            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
    2579              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    2580            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    2581            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    2582            1 :     spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
    2583            1 :     spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
    2584            1 :     spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
    2585            1 :     spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
    2586            1 :     spdm_context->local_context.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
    2587            1 :     spdm_context->local_context.algorithm.measurement_hash_algo =
    2588              :         m_libspdm_use_measurement_hash_algo;
    2589            1 :     libspdm_reset_message_a(spdm_context);
    2590              : 
    2591            1 :     response_size = sizeof(response);
    2592            1 :     status = libspdm_get_response_algorithms (spdm_context,
    2593              :                                               m_libspdm_negotiate_algorithm_request29_size,
    2594              :                                               &m_libspdm_negotiate_algorithm_request29,
    2595              :                                               &response_size,
    2596              :                                               response);
    2597            1 :     assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
    2598            1 :     assert_int_equal (response_size, sizeof(spdm_error_response_t));
    2599            1 :     spdm_response = (void *)response;
    2600            1 :     assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
    2601            1 :     assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
    2602            1 :     assert_int_equal (spdm_response->header.param2, 0);
    2603            1 : }
    2604              : 
    2605              : /**
    2606              :  * Test 30: MULTI_KEY_CONN_REQ and MULTI_KEY_CONN_RSP value calculation
    2607              :  * +---------------+--------------------------+--------------------+
    2608              :  * | MULTI_KEY_CAP | RequesterMultiKeyConnSel | MULTI_KEY_CONN_REQ |
    2609              :  * +---------------+--------------------------+--------------------+
    2610              :  * | 00b           | 0                        | false              |
    2611              :  *  ----------------------------------------------------------------
    2612              :  * | 00b           | 1                        | invalid            |
    2613              :  *  ----------------------------------------------------------------
    2614              :  * | 01b           | 0                        | invalid            |
    2615              :  *  ----------------------------------------------------------------
    2616              :  * | 01b           | 1                        | true               |
    2617              :  *  ----------------------------------------------------------------
    2618              :  * | 10b           | 0                        | false              |
    2619              :  *  ----------------------------------------------------------------
    2620              :  * | 10b           | 1                        | true               |
    2621              :  * +---------------+--------------------------+--------------------+
    2622              :  * | MULTI_KEY_CAP | ResponderMultiKeyConn    | MULTI_KEY_CONN_RSP |
    2623              :  * +---------------+--------------------------+--------------------+
    2624              :  * | 00b           | 0                        | false              |
    2625              :  *  ----------------------------------------------------------------
    2626              :  * | 00b           | 1                        | invalid            |
    2627              :  *  ----------------------------------------------------------------
    2628              :  * | 01b           | 0                        | invalid            |
    2629              :  *  ----------------------------------------------------------------
    2630              :  * | 01b           | 1                        | true               |
    2631              :  *  ----------------------------------------------------------------
    2632              :  * | 10b           | 0                        | false              |
    2633              :  *  ----------------------------------------------------------------
    2634              :  * | 10b           | 1                        | true               |
    2635              :  *  ----------------------------------------------------------------
    2636              :  **/
    2637            1 : void libspdm_test_responder_algorithms_case30(void **state)
    2638              : {
    2639              :     libspdm_return_t status;
    2640              :     libspdm_test_context_t *spdm_test_context;
    2641              :     libspdm_context_t *spdm_context;
    2642              :     size_t response_size;
    2643              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    2644              :     spdm_algorithms_response_t *spdm_response;
    2645              : 
    2646            1 :     spdm_test_context = *state;
    2647            1 :     spdm_context = spdm_test_context->spdm_context;
    2648            1 :     spdm_test_context->case_id = 0x1D;
    2649            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
    2650              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    2651              : 
    2652            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    2653            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    2654            1 :     spdm_context->local_context.algorithm.measurement_hash_algo = 0;
    2655            1 :     spdm_context->local_context.algorithm.measurement_spec = 0;
    2656            1 :     spdm_context->local_context.capability.flags = 0;
    2657              : 
    2658            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2659            1 :     libspdm_reset_message_a(spdm_context);
    2660              : 
    2661            1 :     spdm_context->local_context.capability.flags = 0;
    2662            1 :     spdm_context->local_context.algorithm.other_params_support = 0;
    2663            1 :     spdm_context->connection_info.capability.flags = 0;
    2664            1 :     m_libspdm_negotiate_algorithms_request30.other_params_support = 0;
    2665              : 
    2666            1 :     response_size = sizeof(response);
    2667            1 :     status = libspdm_get_response_algorithms(
    2668              :         spdm_context, m_libspdm_negotiate_algorithms_request30_size,
    2669              :         &m_libspdm_negotiate_algorithms_request30, &response_size,
    2670              :         response);
    2671              : 
    2672            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    2673            1 :     assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
    2674            1 :     spdm_response = (void *)response;
    2675            1 :     assert_int_equal(spdm_response->header.request_response_code,
    2676              :                      SPDM_ALGORITHMS);
    2677            1 :     assert_int_equal(spdm_context->connection_info.multi_key_conn_rsp, false);
    2678            1 :     assert_int_equal(spdm_context->connection_info.multi_key_conn_req, false);
    2679              : 
    2680            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2681            1 :     libspdm_reset_message_a(spdm_context);
    2682              : 
    2683            1 :     spdm_context->local_context.capability.flags = 0;
    2684            1 :     spdm_context->local_context.algorithm.other_params_support = SPDM_ALGORITHMS_MULTI_KEY_CONN;
    2685            1 :     spdm_context->connection_info.capability.flags = 0;
    2686            1 :     m_libspdm_negotiate_algorithms_request30.other_params_support = SPDM_ALGORITHMS_MULTI_KEY_CONN;
    2687              : 
    2688            1 :     response_size = sizeof(response);
    2689            1 :     status = libspdm_get_response_algorithms(
    2690              :         spdm_context, m_libspdm_negotiate_algorithms_request30_size,
    2691              :         &m_libspdm_negotiate_algorithms_request30, &response_size,
    2692              :         response);
    2693              :     /* MULTI_KEY_CONN_REQ and MULTI_KEY_CONN_RSP invalid */
    2694            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    2695            1 :     assert_int_equal (response_size, sizeof(spdm_error_response_t));
    2696            1 :     spdm_response = (void *)response;
    2697            1 :     assert_int_equal(spdm_response->header.request_response_code,
    2698              :                      SPDM_ERROR);
    2699              : 
    2700            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2701            1 :     libspdm_reset_message_a(spdm_context);
    2702              : 
    2703            1 :     spdm_context->local_context.capability.flags =
    2704              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MULTI_KEY_CAP_ONLY;
    2705            1 :     spdm_context->local_context.algorithm.other_params_support = 0;
    2706            1 :     spdm_context->connection_info.capability.flags =
    2707              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MULTI_KEY_CAP_ONLY;
    2708            1 :     m_libspdm_negotiate_algorithms_request30.other_params_support = 0;
    2709              : 
    2710            1 :     response_size = sizeof(response);
    2711            1 :     status = libspdm_get_response_algorithms(
    2712              :         spdm_context, m_libspdm_negotiate_algorithms_request30_size,
    2713              :         &m_libspdm_negotiate_algorithms_request30, &response_size,
    2714              :         response);
    2715              :     /* MULTI_KEY_CONN_REQ and MULTI_KEY_CONN_RSP invalid */
    2716            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    2717            1 :     assert_int_equal (response_size, sizeof(spdm_error_response_t));
    2718            1 :     spdm_response = (void *)response;
    2719            1 :     assert_int_equal(spdm_response->header.request_response_code,
    2720              :                      SPDM_ERROR);
    2721              : 
    2722            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2723            1 :     libspdm_reset_message_a(spdm_context);
    2724              : 
    2725            1 :     spdm_context->local_context.capability.flags =
    2726              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MULTI_KEY_CAP_ONLY;
    2727            1 :     spdm_context->local_context.algorithm.other_params_support = SPDM_ALGORITHMS_MULTI_KEY_CONN;
    2728            1 :     spdm_context->connection_info.capability.flags =
    2729              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MULTI_KEY_CAP_ONLY;
    2730            1 :     m_libspdm_negotiate_algorithms_request30.other_params_support = SPDM_ALGORITHMS_MULTI_KEY_CONN;
    2731              : 
    2732            1 :     response_size = sizeof(response);
    2733            1 :     status = libspdm_get_response_algorithms(
    2734              :         spdm_context, m_libspdm_negotiate_algorithms_request30_size,
    2735              :         &m_libspdm_negotiate_algorithms_request30, &response_size,
    2736              :         response);
    2737            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    2738            1 :     assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
    2739            1 :     spdm_response = (void *)response;
    2740            1 :     assert_int_equal(spdm_response->header.request_response_code,
    2741              :                      SPDM_ALGORITHMS);
    2742            1 :     assert_int_equal(spdm_context->connection_info.multi_key_conn_rsp, true);
    2743            1 :     assert_int_equal(spdm_context->connection_info.multi_key_conn_req, true);
    2744              : 
    2745            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2746            1 :     libspdm_reset_message_a(spdm_context);
    2747              : 
    2748            1 :     spdm_context->local_context.capability.flags =
    2749              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MULTI_KEY_CAP_NEG;
    2750            1 :     spdm_context->local_context.algorithm.other_params_support = 0;
    2751            1 :     spdm_context->connection_info.capability.flags =
    2752              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MULTI_KEY_CAP_NEG;
    2753            1 :     m_libspdm_negotiate_algorithms_request30.other_params_support = 0;
    2754              : 
    2755            1 :     response_size = sizeof(response);
    2756            1 :     status = libspdm_get_response_algorithms(
    2757              :         spdm_context, m_libspdm_negotiate_algorithms_request30_size,
    2758              :         &m_libspdm_negotiate_algorithms_request30, &response_size,
    2759              :         response);
    2760            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    2761            1 :     assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
    2762            1 :     spdm_response = (void *)response;
    2763            1 :     assert_int_equal(spdm_response->header.request_response_code,
    2764              :                      SPDM_ALGORITHMS);
    2765            1 :     assert_int_equal(spdm_context->connection_info.multi_key_conn_rsp, false);
    2766            1 :     assert_int_equal(spdm_context->connection_info.multi_key_conn_req, false);
    2767              : 
    2768            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2769            1 :     libspdm_reset_message_a(spdm_context);
    2770              : 
    2771            1 :     spdm_context->local_context.capability.flags =
    2772              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MULTI_KEY_CAP_NEG;
    2773            1 :     spdm_context->local_context.algorithm.other_params_support = SPDM_ALGORITHMS_MULTI_KEY_CONN;
    2774            1 :     spdm_context->connection_info.capability.flags =
    2775              :         SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MULTI_KEY_CAP_NEG;
    2776            1 :     m_libspdm_negotiate_algorithms_request30.other_params_support = SPDM_ALGORITHMS_MULTI_KEY_CONN;
    2777              : 
    2778            1 :     response_size = sizeof(response);
    2779            1 :     status = libspdm_get_response_algorithms(
    2780              :         spdm_context, m_libspdm_negotiate_algorithms_request30_size,
    2781              :         &m_libspdm_negotiate_algorithms_request30, &response_size,
    2782              :         response);
    2783            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    2784            1 :     assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
    2785            1 :     spdm_response = (void *)response;
    2786            1 :     assert_int_equal(spdm_response->header.request_response_code,
    2787              :                      SPDM_ALGORITHMS);
    2788            1 :     assert_int_equal(spdm_context->connection_info.multi_key_conn_rsp, true);
    2789            1 :     assert_int_equal(spdm_context->connection_info.multi_key_conn_req, true);
    2790            1 : }
    2791              : 
    2792              : 
    2793              : /**
    2794              :  * Test 31: NEGOTIATE_ALGORITHMS message received with MEL correct
    2795              :  * Expected Behavior: get a RETURN_SUCCESS return code
    2796              :  **/
    2797            1 : void libspdm_test_responder_algorithms_case31(void **state)
    2798              : {
    2799              :     libspdm_return_t status;
    2800              :     libspdm_test_context_t *spdm_test_context;
    2801              :     libspdm_context_t *spdm_context;
    2802              :     size_t response_size;
    2803              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    2804              :     spdm_algorithms_response_t *spdm_response;
    2805              : 
    2806            1 :     spdm_test_context = *state;
    2807            1 :     spdm_context = spdm_test_context->spdm_context;
    2808            1 :     spdm_test_context->case_id = 0x1E;
    2809            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
    2810              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    2811            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2812            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    2813            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    2814            1 :     spdm_context->local_context.algorithm.measurement_hash_algo = 0;
    2815            1 :     spdm_context->local_context.algorithm.measurement_spec = 0;
    2816            1 :     spdm_context->local_context.capability.flags = 0;
    2817            1 :     spdm_context->local_context.algorithm.other_params_support = 0;
    2818            1 :     spdm_context->local_context.algorithm.mel_spec = SPDM_MEL_SPECIFICATION_DMTF;
    2819            1 :     libspdm_reset_message_a(spdm_context);
    2820              : 
    2821              :     /* Sub Case 1: MEL_CAP set 1, mel_specification set SPDM_MEL_SPECIFICATION_DMTF*/
    2822            1 :     m_libspdm_negotiate_algorithms_request30.other_params_support = 0;
    2823            1 :     m_libspdm_negotiate_algorithms_request30.mel_specification = SPDM_MEL_SPECIFICATION_DMTF;
    2824            1 :     spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
    2825              : 
    2826            1 :     response_size = sizeof(response);
    2827            1 :     status = libspdm_get_response_algorithms(
    2828              :         spdm_context, m_libspdm_negotiate_algorithms_request30_size,
    2829              :         &m_libspdm_negotiate_algorithms_request30, &response_size,
    2830              :         response);
    2831              : 
    2832            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    2833            1 :     assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
    2834            1 :     spdm_response = (void *)response;
    2835            1 :     assert_int_equal(spdm_response->header.request_response_code,
    2836              :                      SPDM_ALGORITHMS);
    2837            1 :     assert_int_equal(spdm_response->mel_specification_sel, SPDM_MEL_SPECIFICATION_DMTF);
    2838            1 :     assert_int_equal(spdm_context->connection_info.algorithm.mel_spec, SPDM_MEL_SPECIFICATION_DMTF);
    2839              : 
    2840              :     /* Sub Case 2: MEL_CAP set 0, mel_specification set SPDM_MEL_SPECIFICATION_DMTF*/
    2841            1 :     m_libspdm_negotiate_algorithms_request30.mel_specification = SPDM_MEL_SPECIFICATION_DMTF;
    2842            1 :     spdm_context->local_context.capability.flags = 0;
    2843            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2844            1 :     libspdm_reset_message_a(spdm_context);
    2845              : 
    2846            1 :     response_size = sizeof(response);
    2847            1 :     status = libspdm_get_response_algorithms(
    2848              :         spdm_context, m_libspdm_negotiate_algorithms_request30_size,
    2849              :         &m_libspdm_negotiate_algorithms_request30, &response_size,
    2850              :         response);
    2851              : 
    2852            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    2853            1 :     assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
    2854            1 :     spdm_response = (void *)response;
    2855            1 :     assert_int_equal(spdm_response->header.request_response_code,
    2856              :                      SPDM_ALGORITHMS);
    2857            1 :     assert_int_equal(spdm_response->mel_specification_sel, 0);
    2858            1 :     assert_int_equal(spdm_context->connection_info.algorithm.mel_spec, 0);
    2859            1 : }
    2860              : 
    2861              : /**
    2862              :  * Test 32: NEGOTIATE_ALGORITHMS message received with MEAS correct
    2863              :  * Expected Behavior: get a RETURN_SUCCESS return code
    2864              :  **/
    2865            1 : void libspdm_test_responder_algorithms_case32(void **state)
    2866              : {
    2867              :     libspdm_return_t status;
    2868              :     libspdm_test_context_t *spdm_test_context;
    2869              :     libspdm_context_t *spdm_context;
    2870              :     size_t response_size;
    2871              :     uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
    2872              :     spdm_algorithms_response_t *spdm_response;
    2873              : 
    2874            1 :     spdm_test_context = *state;
    2875            1 :     spdm_context = spdm_test_context->spdm_context;
    2876            1 :     spdm_test_context->case_id = 0x1F;
    2877            1 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
    2878              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
    2879            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2880            1 :     spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
    2881            1 :     spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
    2882            1 :     spdm_context->local_context.algorithm.measurement_spec = 0;
    2883            1 :     spdm_context->local_context.algorithm.measurement_spec |= SPDM_MEASUREMENT_SPECIFICATION_DMTF;
    2884            1 :     spdm_context->local_context.capability.flags = 0;
    2885            1 :     spdm_context->local_context.algorithm.other_params_support = 0;
    2886            1 :     libspdm_reset_message_a(spdm_context);
    2887              : 
    2888              :     /* Sub Case 1: MEL_CAP set 1, measurement_spec set SPDM_MEASUREMENT_SPECIFICATION_DMTF*/
    2889            1 :     spdm_context->local_context.capability.flags |=
    2890              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
    2891            1 :     spdm_context->local_context.algorithm.measurement_spec |= SPDM_MEASUREMENT_SPECIFICATION_DMTF;
    2892            1 :     spdm_context->local_context.algorithm.measurement_hash_algo =
    2893              :         m_libspdm_use_measurement_hash_algo;
    2894              : 
    2895            1 :     response_size = sizeof(response);
    2896            1 :     status = libspdm_get_response_algorithms(
    2897              :         spdm_context, m_libspdm_negotiate_algorithms_request1_size,
    2898              :         &m_libspdm_negotiate_algorithms_request1, &response_size,
    2899              :         response);
    2900              : 
    2901            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    2902            1 :     assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
    2903            1 :     spdm_response = (void *)response;
    2904            1 :     assert_int_equal(spdm_response->header.request_response_code,
    2905              :                      SPDM_ALGORITHMS);
    2906            1 :     assert_int_equal(spdm_response->measurement_specification_sel,
    2907              :                      SPDM_MEASUREMENT_SPECIFICATION_DMTF);
    2908            1 :     assert_int_equal(spdm_context->connection_info.algorithm.measurement_spec,
    2909              :                      SPDM_MEASUREMENT_SPECIFICATION_DMTF);
    2910              : 
    2911              :     /* Sub Case 2: MEL_CAP set 0, measurement_spec set 0*/
    2912            1 :     spdm_context->local_context.capability.flags = 0;
    2913            1 :     spdm_context->local_context.algorithm.measurement_hash_algo = 0;
    2914            1 :     spdm_context->local_context.algorithm.measurement_spec = 0;
    2915            1 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
    2916            1 :     m_libspdm_negotiate_algorithms_request1.measurement_specification = 0;
    2917            1 :     libspdm_reset_message_a(spdm_context);
    2918              : 
    2919            1 :     response_size = sizeof(response);
    2920            1 :     status = libspdm_get_response_algorithms(
    2921              :         spdm_context, m_libspdm_negotiate_algorithms_request1_size,
    2922              :         &m_libspdm_negotiate_algorithms_request1, &response_size,
    2923              :         response);
    2924              : 
    2925            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
    2926            1 :     assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
    2927            1 :     spdm_response = (void *)response;
    2928            1 :     assert_int_equal(spdm_response->header.request_response_code,
    2929              :                      SPDM_ALGORITHMS);
    2930            1 :     assert_int_equal(spdm_response->measurement_specification_sel, 0);
    2931            1 :     assert_int_equal(spdm_context->connection_info.algorithm.measurement_spec, 0);
    2932            1 : }
    2933              : 
    2934            1 : int libspdm_responder_algorithms_test_main(void)
    2935              : {
    2936            1 :     const struct CMUnitTest spdm_responder_algorithms_tests[] = {
    2937              :         /* Success Case*/
    2938              :         cmocka_unit_test(libspdm_test_responder_algorithms_case1),
    2939              :         /* Bad request size*/
    2940              :         cmocka_unit_test(libspdm_test_responder_algorithms_case2),
    2941              :         /* response_state: LIBSPDM_RESPONSE_STATE_BUSY*/
    2942              :         cmocka_unit_test(libspdm_test_responder_algorithms_case3),
    2943              :         /* response_state: LIBSPDM_RESPONSE_STATE_NEED_RESYNC*/
    2944              :         cmocka_unit_test(libspdm_test_responder_algorithms_case4),
    2945              :         /* connection_state Check*/
    2946              :         cmocka_unit_test(libspdm_test_responder_algorithms_case6),
    2947              :         /* Success case V1.1*/
    2948              :         cmocka_unit_test(libspdm_test_responder_algorithms_case7),
    2949              :         /* No match for base_asym_algo*/
    2950              :         cmocka_unit_test(libspdm_test_responder_algorithms_case8),
    2951              :         /* No match for base_hash_algo*/
    2952              :         cmocka_unit_test(libspdm_test_responder_algorithms_case9),
    2953              :         /* No match for dhe_named_group*/
    2954              :         cmocka_unit_test(libspdm_test_responder_algorithms_case10),
    2955              :         /* No match for aead_cipher_suite*/
    2956              :         cmocka_unit_test(libspdm_test_responder_algorithms_case11),
    2957              :         /* No match for req_base_asym_alg*/
    2958              :         cmocka_unit_test(libspdm_test_responder_algorithms_case12),
    2959              :         /* No match for key_schedule*/
    2960              :         cmocka_unit_test(libspdm_test_responder_algorithms_case13),
    2961              :         /* Spdm length greater than 64 bytes for V1.0*/
    2962              :         cmocka_unit_test(libspdm_test_responder_algorithms_case14),
    2963              :         /* Spdm length greater than 128 bytes for V1.1*/
    2964              :         cmocka_unit_test(libspdm_test_responder_algorithms_case15),
    2965              :         /* Multiple repeated Alg structs for V1.1*/
    2966              :         cmocka_unit_test(libspdm_test_responder_algorithms_case16),
    2967              :         /* param1 is smaller than the number of Alg structs for V1.1*/
    2968              :         cmocka_unit_test(libspdm_test_responder_algorithms_case17),
    2969              :         /* param1 is bigger than the number of  Alg structs for V1.1*/
    2970              :         cmocka_unit_test(libspdm_test_responder_algorithms_case18),
    2971              :         /* Invalid  Alg structs + valid Alg Structs for V1.1*/
    2972              :         cmocka_unit_test(libspdm_test_responder_algorithms_case19),
    2973              :         /* When support multiple algorithms, then defaults to choose the strongest available algorithm*/
    2974              :         cmocka_unit_test(libspdm_test_responder_algorithms_case20),
    2975              :         /* Buffer verification*/
    2976              :         cmocka_unit_test(libspdm_test_responder_algorithms_case21),
    2977              :         /* Success case V1.2*/
    2978              :         cmocka_unit_test(libspdm_test_responder_algorithms_case22),
    2979              :         /* Version 1.2 Check other_params_support */
    2980              :         cmocka_unit_test(libspdm_test_responder_algorithms_case23),
    2981              :         /* No support for MEASUREMENT from requester*/
    2982              :         cmocka_unit_test(libspdm_test_responder_algorithms_case24),
    2983              :         /* Invalid (Redundant) alg_type value*/
    2984              :         cmocka_unit_test(libspdm_test_responder_algorithms_case25),
    2985              :         /* Invalid (Decreasing) alg_type value*/
    2986              :         cmocka_unit_test(libspdm_test_responder_algorithms_case26),
    2987              :         /* Invalid (smaller than DHE) alg_type value*/
    2988              :         cmocka_unit_test(libspdm_test_responder_algorithms_case27),
    2989              :         /* Invalid (bigger than KEY_SCHEDULE) alg_type value*/
    2990              :         cmocka_unit_test(libspdm_test_responder_algorithms_case28),
    2991              :         /* Invalid AlgStruct, contains an AlgSupported=0 (Non-supported)*/
    2992              :         cmocka_unit_test(libspdm_test_responder_algorithms_case29),
    2993              :         /* MULTI_KEY_CONN_REQ and MULTI_KEY_CONN_RSP value validation*/
    2994              :         cmocka_unit_test(libspdm_test_responder_algorithms_case30),
    2995              :         /* Success Case , set MELspecificationSel*/
    2996              :         cmocka_unit_test(libspdm_test_responder_algorithms_case31),
    2997              :         /* Success Case , set MeasurementSpecification*/
    2998              :         cmocka_unit_test(libspdm_test_responder_algorithms_case32),
    2999              :     };
    3000              : 
    3001            1 :     m_libspdm_negotiate_algorithms_request1.base_asym_algo = m_libspdm_use_asym_algo;
    3002            1 :     m_libspdm_negotiate_algorithms_request1.base_hash_algo = m_libspdm_use_hash_algo;
    3003            1 :     m_libspdm_negotiate_algorithms_request2.base_asym_algo = m_libspdm_use_asym_algo;
    3004            1 :     m_libspdm_negotiate_algorithms_request2.base_hash_algo = m_libspdm_use_hash_algo;
    3005            1 :     m_libspdm_negotiate_algorithm_request3.spdm_request_version10.base_asym_algo =
    3006              :         m_libspdm_use_asym_algo;
    3007            1 :     m_libspdm_negotiate_algorithm_request3.spdm_request_version10.base_hash_algo =
    3008              :         m_libspdm_use_hash_algo;
    3009            1 :     m_libspdm_negotiate_algorithm_request4.spdm_request_version10.base_asym_algo =
    3010            1 :         (m_libspdm_use_asym_algo >> 1);
    3011            1 :     m_libspdm_negotiate_algorithm_request4.spdm_request_version10.base_hash_algo =
    3012              :         m_libspdm_use_hash_algo;
    3013            1 :     m_libspdm_negotiate_algorithm_request5.spdm_request_version10.base_asym_algo =
    3014              :         m_libspdm_use_asym_algo;
    3015            1 :     m_libspdm_negotiate_algorithm_request5.spdm_request_version10.base_hash_algo =
    3016              :         SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512;
    3017            1 :     m_libspdm_negotiate_algorithm_request6.spdm_request_version10.base_asym_algo =
    3018              :         m_libspdm_use_asym_algo;
    3019            1 :     m_libspdm_negotiate_algorithm_request6.spdm_request_version10.base_hash_algo =
    3020              :         m_libspdm_use_hash_algo;
    3021            1 :     m_libspdm_negotiate_algorithm_request7.spdm_request_version10.base_asym_algo =
    3022              :         m_libspdm_use_asym_algo;
    3023            1 :     m_libspdm_negotiate_algorithm_request7.spdm_request_version10.base_hash_algo =
    3024              :         m_libspdm_use_hash_algo;
    3025            1 :     m_libspdm_negotiate_algorithm_request8.spdm_request_version10.base_asym_algo =
    3026              :         m_libspdm_use_asym_algo;
    3027            1 :     m_libspdm_negotiate_algorithm_request8.spdm_request_version10.base_hash_algo =
    3028              :         m_libspdm_use_hash_algo;
    3029            1 :     m_libspdm_negotiate_algorithm_request9.spdm_request_version10.base_asym_algo =
    3030              :         m_libspdm_use_asym_algo;
    3031            1 :     m_libspdm_negotiate_algorithm_request9.spdm_request_version10.base_hash_algo =
    3032              :         m_libspdm_use_hash_algo;
    3033            1 :     m_libspdm_negotiate_algorithm_request10.base_asym_algo = m_libspdm_use_asym_algo;
    3034            1 :     m_libspdm_negotiate_algorithm_request10.base_hash_algo = m_libspdm_use_hash_algo;
    3035            1 :     m_libspdm_negotiate_algorithm_request10.ext_asym_count = 0x09;
    3036            1 :     m_libspdm_negotiate_algorithm_request11.spdm_request_version10.base_asym_algo =
    3037              :         m_libspdm_use_asym_algo;
    3038            1 :     m_libspdm_negotiate_algorithm_request11.spdm_request_version10.base_hash_algo =
    3039              :         m_libspdm_use_hash_algo;
    3040            1 :     m_libspdm_negotiate_algorithm_request11.spdm_request_version10.ext_asym_count = 0x15;
    3041            1 :     m_libspdm_negotiate_algorithm_request12.spdm_request_version10.base_asym_algo =
    3042              :         m_libspdm_use_asym_algo;
    3043            1 :     m_libspdm_negotiate_algorithm_request12.spdm_request_version10.base_hash_algo =
    3044              :         m_libspdm_use_hash_algo;
    3045            1 :     m_libspdm_negotiate_algorithm_request13.spdm_request_version10.base_asym_algo =
    3046              :         m_libspdm_use_asym_algo;
    3047            1 :     m_libspdm_negotiate_algorithm_request13.spdm_request_version10.base_hash_algo =
    3048              :         m_libspdm_use_hash_algo;
    3049            1 :     m_libspdm_negotiate_algorithm_request14.spdm_request_version10.base_asym_algo =
    3050              :         m_libspdm_use_asym_algo;
    3051            1 :     m_libspdm_negotiate_algorithm_request14.spdm_request_version10.base_hash_algo =
    3052              :         m_libspdm_use_hash_algo;
    3053            1 :     m_libspdm_negotiate_algorithm_request15.spdm_request_version10.base_asym_algo =
    3054              :         m_libspdm_use_asym_algo;
    3055            1 :     m_libspdm_negotiate_algorithm_request15.spdm_request_version10.base_hash_algo =
    3056              :         m_libspdm_use_hash_algo;
    3057            1 :     m_libspdm_negotiate_algorithm_request16.spdm_request_version10.base_asym_algo =
    3058              :         SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521 |
    3059              :         SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384 |
    3060              :         SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256 |
    3061              :         SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_3072 |
    3062              :         SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048;
    3063            1 :     m_libspdm_negotiate_algorithm_request16.spdm_request_version10.base_hash_algo =
    3064              :         SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512 |
    3065              :         SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384 |
    3066              :         SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256;
    3067            1 :     m_libspdm_negotiate_algorithm_request17.spdm_request_version10.base_hash_algo =
    3068              :         m_libspdm_use_hash_algo;
    3069            1 :     m_libspdm_negotiate_algorithm_request17.spdm_request_version10.base_asym_algo =
    3070              :         m_libspdm_use_asym_algo;
    3071            1 :     m_libspdm_negotiate_algorithm_request18.spdm_request_version10.base_hash_algo =
    3072              :         m_libspdm_use_hash_algo;
    3073            1 :     m_libspdm_negotiate_algorithm_request18.spdm_request_version10.base_asym_algo =
    3074              :         m_libspdm_use_asym_algo;
    3075            1 :     m_libspdm_negotiate_algorithm_request24.spdm_request_version10.base_asym_algo =
    3076              :         m_libspdm_use_asym_algo;
    3077              : 
    3078            1 :     libspdm_test_context_t test_context = {
    3079              :         LIBSPDM_TEST_CONTEXT_VERSION,
    3080              :         false,
    3081              :     };
    3082              : 
    3083            1 :     libspdm_setup_test_context(&test_context);
    3084              : 
    3085            1 :     return cmocka_run_group_tests(spdm_responder_algorithms_tests,
    3086              :                                   libspdm_unit_test_group_setup,
    3087              :                                   libspdm_unit_test_group_teardown);
    3088              : }
        

Generated by: LCOV version 2.0-1