Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2026 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : #include "spdm_unit_test.h"
8 : #include "internal/libspdm_responder_lib.h"
9 : #include "internal/libspdm_requester_lib.h"
10 :
11 : #if LIBSPDM_ENABLE_CAPABILITY_PSK_CAP
12 :
13 : #pragma pack(1)
14 :
15 : typedef struct {
16 : spdm_message_header_t header;
17 : uint16_t req_session_id;
18 : uint16_t psk_hint_length;
19 : uint16_t context_length;
20 : uint16_t opaque_length;
21 : uint8_t psk_hint[LIBSPDM_PSK_MAX_HINT_LENGTH];
22 : uint8_t context[LIBSPDM_PSK_CONTEXT_LENGTH];
23 : uint8_t opaque_data[SPDM_MAX_OPAQUE_DATA_SIZE];
24 : } libspdm_psk_exchange_request_mine_t;
25 :
26 : typedef struct {
27 : spdm_message_header_t header;
28 : uint16_t req_session_id;
29 : uint16_t psk_hint_length;
30 : uint16_t context_length;
31 : uint16_t opaque_length;
32 : uint8_t context[LIBSPDM_PSK_CONTEXT_LENGTH];
33 : uint8_t opaque_data[SPDM_MAX_OPAQUE_DATA_SIZE];
34 : } libspdm_psk_exchange_request_mine_t_noPSKHINT;
35 :
36 : typedef struct {
37 : spdm_message_header_t header;
38 : uint16_t req_session_id;
39 : uint16_t psk_hint_length;
40 : uint16_t context_length;
41 : uint16_t opaque_length;
42 : uint8_t psk_hint[LIBSPDM_PSK_MAX_HINT_LENGTH];
43 : uint8_t context[LIBSPDM_PSK_CONTEXT_LENGTH];
44 : } libspdm_psk_exchange_request_mine_t_noOPAQUE;
45 :
46 : typedef struct {
47 : spdm_message_header_t header;
48 : uint16_t req_session_id;
49 : uint16_t psk_hint_length;
50 : uint16_t context_length;
51 : uint16_t opaque_length;
52 : uint8_t context[LIBSPDM_PSK_CONTEXT_LENGTH];
53 : } libspdm_psk_exchange_request_mine_t_noPSKHINT_noOPAQUE;
54 :
55 : #pragma pack()
56 :
57 :
58 : libspdm_psk_exchange_request_mine_t m_libspdm_psk_exchange_request1 = {
59 : { SPDM_MESSAGE_VERSION_11, SPDM_PSK_EXCHANGE,
60 : SPDM_PSK_EXCHANGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH, 0 },
61 : };
62 : size_t m_libspdm_psk_exchange_request1_size = sizeof(m_libspdm_psk_exchange_request1);
63 :
64 : libspdm_psk_exchange_request_mine_t m_libspdm_psk_exchange_request2 = {
65 : { SPDM_MESSAGE_VERSION_11, SPDM_PSK_EXCHANGE,
66 : SPDM_PSK_EXCHANGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH, 0 },
67 : };
68 : size_t m_libspdm_psk_exchange_request2_size = sizeof(spdm_psk_exchange_request_t);
69 :
70 : libspdm_psk_exchange_request_mine_t m_libspdm_psk_exchange_request3 = {
71 : { SPDM_MESSAGE_VERSION_12, SPDM_PSK_EXCHANGE,
72 : SPDM_PSK_EXCHANGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH, 0 },
73 : };
74 : size_t m_libspdm_psk_exchange_request3_size = sizeof(m_libspdm_psk_exchange_request3);
75 :
76 : /* Request TCB measurement hash */
77 : libspdm_psk_exchange_request_mine_t m_libspdm_psk_exchange_request4 = {
78 : { SPDM_MESSAGE_VERSION_11, SPDM_PSK_EXCHANGE,
79 : SPDM_PSK_EXCHANGE_REQUEST_TCB_COMPONENT_MEASUREMENT_HASH, 0 },
80 : };
81 : size_t m_libspdm_psk_exchange_request4_size = sizeof(m_libspdm_psk_exchange_request4);
82 :
83 : /* Request all measurement hash */
84 : libspdm_psk_exchange_request_mine_t m_libspdm_psk_exchange_request5 = {
85 : { SPDM_MESSAGE_VERSION_11, SPDM_PSK_EXCHANGE,
86 : SPDM_PSK_EXCHANGE_REQUEST_ALL_MEASUREMENTS_HASH, 0 },
87 : };
88 : size_t m_libspdm_psk_exchange_request5_size = sizeof(m_libspdm_psk_exchange_request5);
89 :
90 : /* Uses a reserved value in measurement hash */
91 : libspdm_psk_exchange_request_mine_t m_libspdm_psk_exchange_request6 = {
92 : { SPDM_MESSAGE_VERSION_11, SPDM_PSK_EXCHANGE,
93 : 0x50, 0 },
94 : };
95 : size_t m_libspdm_psk_exchange_request6_size = sizeof(m_libspdm_psk_exchange_request6);
96 :
97 : libspdm_psk_exchange_request_mine_t_noPSKHINT m_libspdm_psk_exchange_request7 = {
98 : { SPDM_MESSAGE_VERSION_11, SPDM_PSK_EXCHANGE,
99 : SPDM_PSK_EXCHANGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH, 0 },
100 : };
101 : size_t m_libspdm_psk_exchange_request7_size = sizeof(m_libspdm_psk_exchange_request7);
102 :
103 : libspdm_psk_exchange_request_mine_t_noOPAQUE m_libspdm_psk_exchange_request8 = {
104 : { SPDM_MESSAGE_VERSION_11, SPDM_PSK_EXCHANGE,
105 : SPDM_PSK_EXCHANGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH, 0 },
106 : };
107 : size_t m_libspdm_psk_exchange_request8_size = sizeof(m_libspdm_psk_exchange_request8);
108 :
109 : libspdm_psk_exchange_request_mine_t_noPSKHINT_noOPAQUE m_libspdm_psk_exchange_request9 = {
110 : { SPDM_MESSAGE_VERSION_11, SPDM_PSK_EXCHANGE,
111 : SPDM_PSK_EXCHANGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH, 0 },
112 : };
113 : size_t m_libspdm_psk_exchange_request9_size = sizeof(m_libspdm_psk_exchange_request9);
114 :
115 1 : static void rsp_psk_exchange_rsp_case1(void **state)
116 : {
117 : libspdm_return_t status;
118 : libspdm_test_context_t *spdm_test_context;
119 : libspdm_context_t *spdm_context;
120 : size_t response_size;
121 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
122 : spdm_psk_exchange_response_t *spdm_response;
123 : void *data1;
124 : size_t data_size1;
125 : uint8_t *ptr;
126 : size_t opaque_psk_exchange_req_size;
127 :
128 1 : spdm_test_context = *state;
129 1 : spdm_context = spdm_test_context->spdm_context;
130 1 : spdm_test_context->case_id = 0x1;
131 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
132 : SPDM_VERSION_NUMBER_SHIFT_BIT;
133 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
134 1 : spdm_context->connection_info.capability.flags |=
135 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP |
136 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
137 1 : spdm_context->local_context.capability.flags |=
138 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP |
139 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
140 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
141 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
142 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
143 : m_libspdm_use_measurement_hash_algo;
144 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
145 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
146 1 : spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
147 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
148 : m_libspdm_use_asym_algo, &data1,
149 : &data_size1, NULL, NULL);
150 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
151 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
152 :
153 1 : libspdm_reset_message_a(spdm_context);
154 :
155 1 : m_libspdm_psk_exchange_request1.psk_hint_length =
156 : (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
157 1 : m_libspdm_psk_exchange_request1.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
158 1 : opaque_psk_exchange_req_size =
159 1 : libspdm_get_opaque_data_supported_version_data_size(spdm_context);
160 1 : m_libspdm_psk_exchange_request1.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
161 1 : m_libspdm_psk_exchange_request1.req_session_id = 0xFFFF;
162 1 : ptr = m_libspdm_psk_exchange_request1.psk_hint;
163 1 : libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request1.psk_hint),
164 : LIBSPDM_TEST_PSK_HINT_STRING,
165 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
166 1 : ptr += m_libspdm_psk_exchange_request1.psk_hint_length;
167 1 : libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
168 1 : ptr += m_libspdm_psk_exchange_request1.context_length;
169 1 : libspdm_build_opaque_data_supported_version_data(
170 : spdm_context, &opaque_psk_exchange_req_size, ptr);
171 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
172 : spdm_context->transcript.message_m.buffer_size =
173 : spdm_context->transcript.message_m.max_buffer_size;
174 : #endif
175 1 : ptr += opaque_psk_exchange_req_size;
176 1 : response_size = sizeof(response);
177 1 : status = libspdm_get_response_psk_exchange(
178 : spdm_context, m_libspdm_psk_exchange_request1_size,
179 : &m_libspdm_psk_exchange_request1, &response_size, response);
180 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
181 1 : assert_int_equal(
182 : libspdm_secured_message_get_session_state(
183 : spdm_context->session_info[0].secured_message_context),
184 : LIBSPDM_SESSION_STATE_HANDSHAKING);
185 1 : spdm_response = (void *)response;
186 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_PSK_EXCHANGE_RSP);
187 1 : assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
188 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
189 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
190 : #endif
191 1 : free(data1);
192 1 : }
193 :
194 1 : static void rsp_psk_exchange_rsp_case2(void **state)
195 : {
196 : libspdm_return_t status;
197 : libspdm_test_context_t *spdm_test_context;
198 : libspdm_context_t *spdm_context;
199 : size_t response_size;
200 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
201 : spdm_psk_exchange_response_t *spdm_response;
202 : void *data1;
203 : size_t data_size1;
204 : uint8_t *ptr;
205 : size_t opaque_psk_exchange_req_size;
206 :
207 1 : spdm_test_context = *state;
208 1 : spdm_context = spdm_test_context->spdm_context;
209 1 : spdm_test_context->case_id = 0x2;
210 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
211 : SPDM_VERSION_NUMBER_SHIFT_BIT;
212 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
213 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
214 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
215 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
216 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
217 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
218 : m_libspdm_use_measurement_hash_algo;
219 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
220 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
221 1 : spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
222 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
223 : m_libspdm_use_asym_algo, &data1,
224 : &data_size1, NULL, NULL);
225 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
226 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
227 :
228 1 : libspdm_reset_message_a(spdm_context);
229 :
230 1 : m_libspdm_psk_exchange_request2.psk_hint_length =
231 : (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
232 1 : m_libspdm_psk_exchange_request2.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
233 1 : opaque_psk_exchange_req_size =
234 1 : libspdm_get_opaque_data_supported_version_data_size(spdm_context);
235 1 : m_libspdm_psk_exchange_request2.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
236 1 : m_libspdm_psk_exchange_request2.req_session_id = 0xFFFF;
237 1 : ptr = m_libspdm_psk_exchange_request2.psk_hint;
238 1 : libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request2.psk_hint),
239 : LIBSPDM_TEST_PSK_HINT_STRING,
240 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
241 1 : ptr += m_libspdm_psk_exchange_request2.psk_hint_length;
242 1 : libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
243 1 : ptr += m_libspdm_psk_exchange_request2.context_length;
244 1 : libspdm_build_opaque_data_supported_version_data(
245 : spdm_context, &opaque_psk_exchange_req_size, ptr);
246 1 : ptr += opaque_psk_exchange_req_size;
247 1 : response_size = sizeof(response);
248 1 : status = libspdm_get_response_psk_exchange(
249 : spdm_context, m_libspdm_psk_exchange_request2_size,
250 : &m_libspdm_psk_exchange_request2, &response_size, response);
251 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
252 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
253 1 : spdm_response = (void *)response;
254 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
255 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
256 1 : assert_int_equal(spdm_response->header.param2, 0);
257 1 : free(data1);
258 1 : }
259 :
260 1 : static void rsp_psk_exchange_rsp_case3(void **state)
261 : {
262 : libspdm_return_t status;
263 : libspdm_test_context_t *spdm_test_context;
264 : libspdm_context_t *spdm_context;
265 : size_t response_size;
266 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
267 : spdm_psk_exchange_response_t *spdm_response;
268 : void *data1;
269 : size_t data_size1;
270 : uint8_t *ptr;
271 : size_t opaque_psk_exchange_req_size;
272 :
273 1 : spdm_test_context = *state;
274 1 : spdm_context = spdm_test_context->spdm_context;
275 1 : spdm_test_context->case_id = 0x3;
276 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
277 : SPDM_VERSION_NUMBER_SHIFT_BIT;
278 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_BUSY;
279 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
280 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
281 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
282 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
283 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
284 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
285 : m_libspdm_use_measurement_hash_algo;
286 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
287 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
288 1 : spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
289 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
290 : m_libspdm_use_asym_algo, &data1,
291 : &data_size1, NULL, NULL);
292 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
293 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
294 :
295 1 : libspdm_reset_message_a(spdm_context);
296 :
297 1 : m_libspdm_psk_exchange_request1.psk_hint_length =
298 : (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
299 1 : m_libspdm_psk_exchange_request1.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
300 1 : opaque_psk_exchange_req_size =
301 1 : libspdm_get_opaque_data_supported_version_data_size(spdm_context);
302 1 : m_libspdm_psk_exchange_request1.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
303 1 : m_libspdm_psk_exchange_request1.req_session_id = 0xFFFF;
304 1 : ptr = m_libspdm_psk_exchange_request1.psk_hint;
305 1 : libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request1.psk_hint),
306 : LIBSPDM_TEST_PSK_HINT_STRING,
307 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
308 1 : ptr += m_libspdm_psk_exchange_request1.psk_hint_length;
309 1 : libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
310 1 : ptr += m_libspdm_psk_exchange_request1.context_length;
311 1 : libspdm_build_opaque_data_supported_version_data(
312 : spdm_context, &opaque_psk_exchange_req_size, ptr);
313 1 : ptr += opaque_psk_exchange_req_size;
314 1 : response_size = sizeof(response);
315 1 : status = libspdm_get_response_psk_exchange(
316 : spdm_context, m_libspdm_psk_exchange_request1_size,
317 : &m_libspdm_psk_exchange_request1, &response_size, response);
318 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
319 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
320 1 : spdm_response = (void *)response;
321 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
322 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_BUSY);
323 1 : assert_int_equal(spdm_response->header.param2, 0);
324 1 : assert_int_equal(spdm_context->response_state, LIBSPDM_RESPONSE_STATE_BUSY);
325 1 : free(data1);
326 1 : }
327 :
328 1 : static void rsp_psk_exchange_rsp_case4(void **state)
329 : {
330 : libspdm_return_t status;
331 : libspdm_test_context_t *spdm_test_context;
332 : libspdm_context_t *spdm_context;
333 : size_t response_size;
334 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
335 : spdm_psk_exchange_response_t *spdm_response;
336 : void *data1;
337 : size_t data_size1;
338 : uint8_t *ptr;
339 : size_t opaque_psk_exchange_req_size;
340 :
341 1 : spdm_test_context = *state;
342 1 : spdm_context = spdm_test_context->spdm_context;
343 1 : spdm_test_context->case_id = 0x4;
344 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
345 : SPDM_VERSION_NUMBER_SHIFT_BIT;
346 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NEED_RESYNC;
347 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
348 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
349 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
350 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
351 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
352 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
353 : m_libspdm_use_measurement_hash_algo;
354 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
355 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
356 1 : spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
357 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
358 : m_libspdm_use_asym_algo, &data1,
359 : &data_size1, NULL, NULL);
360 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
361 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
362 :
363 1 : libspdm_reset_message_a(spdm_context);
364 :
365 1 : m_libspdm_psk_exchange_request1.psk_hint_length =
366 : (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
367 1 : m_libspdm_psk_exchange_request1.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
368 1 : opaque_psk_exchange_req_size =
369 1 : libspdm_get_opaque_data_supported_version_data_size(spdm_context);
370 1 : m_libspdm_psk_exchange_request1.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
371 1 : m_libspdm_psk_exchange_request1.req_session_id = 0xFFFF;
372 1 : ptr = m_libspdm_psk_exchange_request1.psk_hint;
373 1 : libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request1.psk_hint),
374 : LIBSPDM_TEST_PSK_HINT_STRING,
375 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
376 1 : ptr += m_libspdm_psk_exchange_request1.psk_hint_length;
377 1 : libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
378 1 : ptr += m_libspdm_psk_exchange_request1.context_length;
379 1 : libspdm_build_opaque_data_supported_version_data(
380 : spdm_context, &opaque_psk_exchange_req_size, ptr);
381 1 : ptr += opaque_psk_exchange_req_size;
382 1 : response_size = sizeof(response);
383 1 : status = libspdm_get_response_psk_exchange(
384 : spdm_context, m_libspdm_psk_exchange_request1_size,
385 : &m_libspdm_psk_exchange_request1, &response_size, response);
386 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
387 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
388 1 : spdm_response = (void *)response;
389 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
390 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_REQUEST_RESYNCH);
391 1 : assert_int_equal(spdm_response->header.param2, 0);
392 1 : assert_int_equal(spdm_context->response_state, LIBSPDM_RESPONSE_STATE_NEED_RESYNC);
393 1 : free(data1);
394 1 : }
395 :
396 : #if LIBSPDM_RESPOND_IF_READY_SUPPORT
397 1 : static void rsp_psk_exchange_rsp_case5(void **state)
398 : {
399 : libspdm_return_t status;
400 : libspdm_test_context_t *spdm_test_context;
401 : libspdm_context_t *spdm_context;
402 : size_t response_size;
403 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
404 : spdm_psk_exchange_response_t *spdm_response;
405 : void *data1;
406 : size_t data_size1;
407 : uint8_t *ptr;
408 : size_t opaque_psk_exchange_req_size;
409 : spdm_error_data_response_not_ready_t *error_data;
410 :
411 1 : spdm_test_context = *state;
412 1 : spdm_context = spdm_test_context->spdm_context;
413 1 : spdm_test_context->case_id = 0x5;
414 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
415 : SPDM_VERSION_NUMBER_SHIFT_BIT;
416 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NOT_READY;
417 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
418 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
419 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
420 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
421 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
422 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
423 : m_libspdm_use_measurement_hash_algo;
424 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
425 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
426 1 : spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
427 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
428 : m_libspdm_use_asym_algo, &data1,
429 : &data_size1, NULL, NULL);
430 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
431 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
432 :
433 1 : libspdm_reset_message_a(spdm_context);
434 :
435 1 : m_libspdm_psk_exchange_request1.psk_hint_length =
436 : (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
437 1 : m_libspdm_psk_exchange_request1.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
438 1 : opaque_psk_exchange_req_size =
439 1 : libspdm_get_opaque_data_supported_version_data_size(spdm_context);
440 1 : m_libspdm_psk_exchange_request1.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
441 1 : m_libspdm_psk_exchange_request1.req_session_id = 0xFFFF;
442 1 : ptr = m_libspdm_psk_exchange_request1.psk_hint;
443 1 : libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request1.psk_hint),
444 : LIBSPDM_TEST_PSK_HINT_STRING,
445 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
446 1 : ptr += m_libspdm_psk_exchange_request1.psk_hint_length;
447 1 : libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
448 1 : ptr += m_libspdm_psk_exchange_request1.context_length;
449 1 : libspdm_build_opaque_data_supported_version_data(
450 : spdm_context, &opaque_psk_exchange_req_size, ptr);
451 1 : ptr += opaque_psk_exchange_req_size;
452 1 : response_size = sizeof(response);
453 1 : status = libspdm_get_response_psk_exchange(
454 : spdm_context, m_libspdm_psk_exchange_request1_size,
455 : &m_libspdm_psk_exchange_request1, &response_size, response);
456 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
457 1 : assert_int_equal(response_size,
458 : sizeof(spdm_error_response_t) +
459 : sizeof(spdm_error_data_response_not_ready_t));
460 1 : spdm_response = (void *)response;
461 1 : error_data = (spdm_error_data_response_not_ready_t
462 : *)(&spdm_response->rsp_session_id);
463 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
464 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_RESPONSE_NOT_READY);
465 1 : assert_int_equal(spdm_response->header.param2, 0);
466 1 : assert_int_equal(spdm_context->response_state, LIBSPDM_RESPONSE_STATE_NOT_READY);
467 1 : assert_int_equal(error_data->request_code, SPDM_PSK_EXCHANGE);
468 1 : free(data1);
469 1 : }
470 : #endif /* LIBSPDM_RESPOND_IF_READY_SUPPORT */
471 :
472 1 : static void rsp_psk_exchange_rsp_case6(void **state)
473 : {
474 : libspdm_return_t status;
475 : libspdm_test_context_t *spdm_test_context;
476 : libspdm_context_t *spdm_context;
477 : size_t response_size;
478 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
479 : spdm_psk_exchange_response_t *spdm_response;
480 : void *data1;
481 : size_t data_size1;
482 : uint8_t *ptr;
483 : size_t opaque_psk_exchange_req_size;
484 :
485 1 : spdm_test_context = *state;
486 1 : spdm_context = spdm_test_context->spdm_context;
487 1 : spdm_test_context->case_id = 0x6;
488 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
489 : SPDM_VERSION_NUMBER_SHIFT_BIT;
490 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
491 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NOT_STARTED;
492 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
493 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
494 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
495 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
496 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
497 : m_libspdm_use_measurement_hash_algo;
498 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
499 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
500 1 : spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
501 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
502 : m_libspdm_use_asym_algo, &data1,
503 : &data_size1, NULL, NULL);
504 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
505 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
506 :
507 1 : libspdm_reset_message_a(spdm_context);
508 :
509 1 : m_libspdm_psk_exchange_request1.psk_hint_length =
510 : (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
511 1 : m_libspdm_psk_exchange_request1.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
512 1 : opaque_psk_exchange_req_size =
513 1 : libspdm_get_opaque_data_supported_version_data_size(spdm_context);
514 1 : m_libspdm_psk_exchange_request1.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
515 1 : m_libspdm_psk_exchange_request1.req_session_id = 0xFFFF;
516 1 : ptr = m_libspdm_psk_exchange_request1.psk_hint;
517 1 : libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request1.psk_hint),
518 : LIBSPDM_TEST_PSK_HINT_STRING,
519 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
520 1 : ptr += m_libspdm_psk_exchange_request1.psk_hint_length;
521 1 : libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
522 1 : ptr += m_libspdm_psk_exchange_request1.context_length;
523 1 : libspdm_build_opaque_data_supported_version_data(
524 : spdm_context, &opaque_psk_exchange_req_size, ptr);
525 1 : ptr += opaque_psk_exchange_req_size;
526 1 : response_size = sizeof(response);
527 1 : status = libspdm_get_response_psk_exchange(
528 : spdm_context, m_libspdm_psk_exchange_request1_size,
529 : &m_libspdm_psk_exchange_request1, &response_size, response);
530 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
531 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
532 1 : spdm_response = (void *)response;
533 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
534 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
535 1 : assert_int_equal(spdm_response->header.param2, 0);
536 1 : free(data1);
537 1 : }
538 :
539 1 : static void rsp_psk_exchange_rsp_case7(void **state)
540 : {
541 : libspdm_return_t status;
542 : libspdm_test_context_t *spdm_test_context;
543 : libspdm_context_t *spdm_context;
544 : size_t response_size;
545 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
546 : spdm_psk_exchange_response_t *spdm_response;
547 : void *data1;
548 : size_t data_size1;
549 : uint8_t *ptr;
550 : size_t opaque_psk_exchange_req_size;
551 :
552 1 : spdm_test_context = *state;
553 1 : spdm_context = spdm_test_context->spdm_context;
554 1 : spdm_test_context->case_id = 0x7;
555 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
556 : SPDM_VERSION_NUMBER_SHIFT_BIT;
557 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
558 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
559 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
560 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
561 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
562 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
563 : m_libspdm_use_measurement_hash_algo;
564 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
565 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
566 1 : spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
567 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
568 : m_libspdm_use_asym_algo, &data1,
569 : &data_size1, NULL, NULL);
570 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
571 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
572 :
573 1 : libspdm_reset_message_a(spdm_context);
574 :
575 1 : m_libspdm_psk_exchange_request1.psk_hint_length =
576 : (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
577 1 : m_libspdm_psk_exchange_request1.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
578 1 : opaque_psk_exchange_req_size =
579 1 : libspdm_get_opaque_data_supported_version_data_size(spdm_context);
580 1 : m_libspdm_psk_exchange_request1.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
581 1 : m_libspdm_psk_exchange_request1.req_session_id = 0xFFFF;
582 1 : ptr = m_libspdm_psk_exchange_request1.psk_hint;
583 1 : libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request1.psk_hint),
584 : LIBSPDM_TEST_PSK_HINT_STRING,
585 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
586 1 : ptr += m_libspdm_psk_exchange_request1.psk_hint_length;
587 1 : libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
588 1 : ptr += m_libspdm_psk_exchange_request1.context_length;
589 1 : libspdm_build_opaque_data_supported_version_data(
590 : spdm_context, &opaque_psk_exchange_req_size, ptr);
591 1 : ptr += opaque_psk_exchange_req_size;
592 :
593 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
594 : spdm_context->transcript.message_m.buffer_size =
595 : spdm_context->transcript.message_m.max_buffer_size;
596 : spdm_context->transcript.message_b.buffer_size =
597 : spdm_context->transcript.message_b.max_buffer_size;
598 : spdm_context->transcript.message_c.buffer_size =
599 : spdm_context->transcript.message_c.max_buffer_size;
600 : spdm_context->transcript.message_mut_b.buffer_size =
601 : spdm_context->transcript.message_mut_b.max_buffer_size;
602 : spdm_context->transcript.message_mut_c.buffer_size =
603 : spdm_context->transcript.message_mut_c.max_buffer_size;
604 : #endif
605 :
606 1 : response_size = sizeof(response);
607 1 : status = libspdm_get_response_psk_exchange(
608 : spdm_context, m_libspdm_psk_exchange_request1_size,
609 : &m_libspdm_psk_exchange_request1, &response_size, response);
610 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
611 1 : assert_int_equal(
612 : libspdm_secured_message_get_session_state(
613 : spdm_context->session_info[0].secured_message_context),
614 : LIBSPDM_SESSION_STATE_HANDSHAKING);
615 1 : spdm_response = (void *)response;
616 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_PSK_EXCHANGE_RSP);
617 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
618 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
619 : assert_int_equal(spdm_context->transcript.message_b.buffer_size, 0);
620 : assert_int_equal(spdm_context->transcript.message_c.buffer_size, 0);
621 : assert_int_equal(spdm_context->transcript.message_mut_b.buffer_size, 0);
622 : assert_int_equal(spdm_context->transcript.message_mut_c.buffer_size, 0);
623 : #endif
624 :
625 1 : free(data1);
626 1 : }
627 :
628 1 : static void rsp_psk_exchange_rsp_case8(void **state)
629 : {
630 : libspdm_return_t status;
631 : libspdm_test_context_t *spdm_test_context;
632 : libspdm_context_t *spdm_context;
633 : size_t current_request_size;
634 : size_t response_size;
635 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
636 : spdm_psk_exchange_response_t *spdm_response;
637 : void *data1;
638 : size_t data_size1;
639 : uint8_t *ptr;
640 : size_t opaque_psk_exchange_req_size;
641 :
642 1 : spdm_test_context = *state;
643 1 : spdm_context = spdm_test_context->spdm_context;
644 :
645 1 : if(spdm_context->session_info[0].session_id != INVALID_SESSION_ID) {
646 1 : libspdm_free_session_id(spdm_context,0xFFFFFFFF);
647 : }
648 :
649 1 : spdm_test_context->case_id = 0x8;
650 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
651 : SPDM_VERSION_NUMBER_SHIFT_BIT;
652 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
653 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
654 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
655 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
656 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
657 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
658 : m_libspdm_use_measurement_hash_algo;
659 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
660 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
661 1 : spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
662 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
663 : m_libspdm_use_asym_algo, &data1,
664 : &data_size1, NULL, NULL);
665 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
666 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
667 :
668 1 : libspdm_reset_message_a(spdm_context);
669 :
670 1 : m_libspdm_psk_exchange_request1.psk_hint_length =
671 : (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
672 1 : m_libspdm_psk_exchange_request1.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
673 1 : opaque_psk_exchange_req_size =
674 1 : libspdm_get_opaque_data_supported_version_data_size(spdm_context);
675 1 : m_libspdm_psk_exchange_request1.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
676 1 : m_libspdm_psk_exchange_request1.req_session_id = 0xFFFF;
677 1 : ptr = m_libspdm_psk_exchange_request1.psk_hint;
678 1 : libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request1.psk_hint),
679 : LIBSPDM_TEST_PSK_HINT_STRING,
680 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
681 1 : ptr += m_libspdm_psk_exchange_request1.psk_hint_length;
682 1 : libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
683 1 : ptr += m_libspdm_psk_exchange_request1.context_length;
684 1 : libspdm_build_opaque_data_supported_version_data(
685 : spdm_context, &opaque_psk_exchange_req_size, ptr);
686 1 : ptr += opaque_psk_exchange_req_size;
687 :
688 1 : current_request_size = sizeof(spdm_psk_exchange_request_t) +
689 1 : m_libspdm_psk_exchange_request1.psk_hint_length +
690 1 : m_libspdm_psk_exchange_request1.context_length +
691 : opaque_psk_exchange_req_size;
692 1 : response_size = sizeof(response);
693 1 : status = libspdm_get_response_psk_exchange(
694 : spdm_context, current_request_size, &m_libspdm_psk_exchange_request1,
695 : &response_size, response);
696 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
697 1 : assert_int_equal(libspdm_secured_message_get_session_state(
698 : spdm_context->session_info[0].secured_message_context),
699 : LIBSPDM_SESSION_STATE_HANDSHAKING);
700 1 : spdm_response = (void *)response;
701 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_PSK_EXCHANGE_RSP);
702 1 : assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
703 :
704 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
705 : assert_int_equal(spdm_context->session_info[0].session_transcript.message_k.buffer_size,
706 : current_request_size + response_size);
707 : assert_memory_equal(spdm_context->session_info[0].session_transcript.message_k.buffer,
708 : &m_libspdm_psk_exchange_request1, current_request_size);
709 : assert_memory_equal(spdm_context->session_info[0].session_transcript.message_k.buffer +
710 : current_request_size, response, response_size);
711 : #endif
712 1 : free(data1);
713 1 : }
714 :
715 1 : static void rsp_psk_exchange_rsp_case9(void **state)
716 : {
717 : libspdm_return_t status;
718 : libspdm_test_context_t *spdm_test_context;
719 : libspdm_context_t *spdm_context;
720 : size_t response_size;
721 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
722 : spdm_psk_exchange_response_t *spdm_response;
723 : void *data1;
724 : size_t data_size1;
725 : uint8_t *ptr;
726 : size_t opaque_psk_exchange_req_size;
727 :
728 1 : spdm_test_context = *state;
729 1 : spdm_context = spdm_test_context->spdm_context;
730 1 : spdm_test_context->case_id = 0x9;
731 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
732 : SPDM_VERSION_NUMBER_SHIFT_BIT;
733 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
734 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
735 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
736 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
737 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
738 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
739 : m_libspdm_use_measurement_hash_algo;
740 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
741 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
742 1 : spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
743 1 : spdm_context->connection_info.algorithm.other_params_support =
744 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
745 1 : libspdm_session_info_init(spdm_context,
746 1 : spdm_context->session_info,
747 : 0,
748 : INVALID_SESSION_ID, true);
749 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
750 : m_libspdm_use_asym_algo, &data1,
751 : &data_size1, NULL, NULL);
752 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
753 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
754 :
755 1 : libspdm_reset_message_a(spdm_context);
756 :
757 1 : m_libspdm_psk_exchange_request3.psk_hint_length =
758 : (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
759 1 : m_libspdm_psk_exchange_request3.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
760 1 : opaque_psk_exchange_req_size =
761 1 : libspdm_get_opaque_data_supported_version_data_size(spdm_context);
762 1 : m_libspdm_psk_exchange_request3.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
763 1 : m_libspdm_psk_exchange_request3.req_session_id = 0xFFFF;
764 1 : ptr = m_libspdm_psk_exchange_request3.psk_hint;
765 1 : libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request3.psk_hint),
766 : LIBSPDM_TEST_PSK_HINT_STRING,
767 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
768 1 : ptr += m_libspdm_psk_exchange_request3.psk_hint_length;
769 1 : libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
770 1 : ptr += m_libspdm_psk_exchange_request3.context_length;
771 1 : libspdm_build_opaque_data_supported_version_data(
772 : spdm_context, &opaque_psk_exchange_req_size, ptr);
773 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
774 : spdm_context->transcript.message_m.buffer_size =
775 : spdm_context->transcript.message_m.max_buffer_size;
776 : #endif
777 1 : ptr += opaque_psk_exchange_req_size;
778 1 : response_size = sizeof(response);
779 1 : status = libspdm_get_response_psk_exchange(
780 : spdm_context, m_libspdm_psk_exchange_request3_size,
781 : &m_libspdm_psk_exchange_request3, &response_size, response);
782 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
783 1 : assert_int_equal(
784 : libspdm_secured_message_get_session_state(
785 : spdm_context->session_info[0].secured_message_context),
786 : LIBSPDM_SESSION_STATE_HANDSHAKING);
787 1 : assert_int_equal(spdm_context->session_info[0].session_policy, 0);
788 1 : spdm_response = (void *)response;
789 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
790 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_PSK_EXCHANGE_RSP);
791 1 : assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
792 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
793 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
794 : #endif
795 1 : free(data1);
796 1 : }
797 :
798 1 : static void rsp_psk_exchange_rsp_case10(void **state)
799 : {
800 : libspdm_return_t status;
801 : libspdm_test_context_t *spdm_test_context;
802 : libspdm_context_t *spdm_context;
803 : size_t response_size;
804 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
805 : #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
806 : uint8_t measurement_hash[LIBSPDM_MAX_HASH_SIZE];
807 : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP */
808 : uint32_t measurement_summary_hash_size;
809 : spdm_psk_exchange_response_t *spdm_response;
810 : void *data1;
811 : size_t data_size1;
812 : uint8_t *ptr;
813 : size_t opaque_psk_exchange_req_size;
814 : bool result;
815 :
816 1 : spdm_test_context = *state;
817 1 : spdm_context = spdm_test_context->spdm_context;
818 1 : spdm_test_context->case_id = 0xA;
819 :
820 : /* Clear previous sessions */
821 1 : if(spdm_context->session_info[0].session_id != INVALID_SESSION_ID) {
822 1 : libspdm_free_session_id(spdm_context,0xFFFFFFFF);
823 : }
824 :
825 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
826 : SPDM_VERSION_NUMBER_SHIFT_BIT;
827 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
828 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
829 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
830 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP;
831 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
832 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
833 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
834 : m_libspdm_use_measurement_hash_algo;
835 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
836 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
837 1 : spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
838 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
839 : m_libspdm_use_asym_algo, &data1,
840 : &data_size1, NULL, NULL);
841 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
842 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
843 :
844 1 : libspdm_reset_message_a(spdm_context);
845 :
846 1 : m_libspdm_psk_exchange_request4.psk_hint_length =
847 : (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
848 1 : m_libspdm_psk_exchange_request4.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
849 1 : opaque_psk_exchange_req_size =
850 1 : libspdm_get_opaque_data_supported_version_data_size(spdm_context);
851 1 : m_libspdm_psk_exchange_request4.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
852 1 : m_libspdm_psk_exchange_request4.req_session_id = 0xFFFF;
853 1 : ptr = m_libspdm_psk_exchange_request4.psk_hint;
854 1 : libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request4.psk_hint),
855 : LIBSPDM_TEST_PSK_HINT_STRING,
856 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
857 1 : ptr += m_libspdm_psk_exchange_request4.psk_hint_length;
858 1 : libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
859 1 : ptr += m_libspdm_psk_exchange_request4.context_length;
860 1 : libspdm_build_opaque_data_supported_version_data(
861 : spdm_context, &opaque_psk_exchange_req_size, ptr);
862 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
863 : spdm_context->transcript.message_m.buffer_size =
864 : spdm_context->transcript.message_m.max_buffer_size;
865 : #endif
866 1 : ptr += opaque_psk_exchange_req_size;
867 1 : response_size = sizeof(response);
868 1 : status = libspdm_get_response_psk_exchange(
869 : spdm_context, m_libspdm_psk_exchange_request4_size,
870 : &m_libspdm_psk_exchange_request4, &response_size, response);
871 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
872 1 : assert_int_equal(
873 : libspdm_secured_message_get_session_state(
874 : spdm_context->session_info[0].secured_message_context),
875 : LIBSPDM_SESSION_STATE_HANDSHAKING);
876 1 : spdm_response = (void *)response;
877 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_PSK_EXCHANGE_RSP);
878 1 : assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
879 :
880 1 : measurement_summary_hash_size = libspdm_get_measurement_summary_hash_size(
881 1 : spdm_context, false, m_libspdm_psk_exchange_request4.header.param1);
882 :
883 : #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
884 1 : result = libspdm_generate_measurement_summary_hash(
885 : spdm_context,
886 1 : spdm_context->connection_info.version,
887 : spdm_context->connection_info.algorithm.base_hash_algo,
888 1 : spdm_context->connection_info.algorithm.measurement_spec,
889 : spdm_context->connection_info.algorithm.measurement_hash_algo,
890 1 : m_libspdm_psk_exchange_request4.header.param1,
891 : measurement_hash,
892 : measurement_summary_hash_size);
893 :
894 1 : assert_true(result);
895 :
896 1 : assert_memory_equal((uint8_t *)response + sizeof(spdm_psk_exchange_response_t),
897 : measurement_hash, measurement_summary_hash_size);
898 : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP */
899 :
900 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
901 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
902 : #endif
903 1 : free(data1);
904 1 : }
905 :
906 1 : static void rsp_psk_exchange_rsp_case11(void **state)
907 : {
908 : libspdm_return_t status;
909 : libspdm_test_context_t *spdm_test_context;
910 : libspdm_context_t *spdm_context;
911 : size_t response_size;
912 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
913 : #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
914 : uint8_t measurement_hash[LIBSPDM_MAX_HASH_SIZE];
915 : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP */
916 : uint32_t measurement_summary_hash_size;
917 : spdm_psk_exchange_response_t *spdm_response;
918 : void *data1;
919 : size_t data_size1;
920 : uint8_t *ptr;
921 : size_t opaque_psk_exchange_req_size;
922 : bool result;
923 :
924 1 : spdm_test_context = *state;
925 1 : spdm_context = spdm_test_context->spdm_context;
926 1 : spdm_test_context->case_id = 0xB;
927 :
928 : /* Clear previous sessions */
929 1 : if(spdm_context->session_info[0].session_id != INVALID_SESSION_ID) {
930 1 : libspdm_free_session_id(spdm_context,0xFFFFFFFF);
931 : }
932 :
933 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
934 : SPDM_VERSION_NUMBER_SHIFT_BIT;
935 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
936 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
937 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
938 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP;
939 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
940 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
941 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
942 : m_libspdm_use_measurement_hash_algo;
943 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
944 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
945 1 : spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
946 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
947 : m_libspdm_use_asym_algo, &data1,
948 : &data_size1, NULL, NULL);
949 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
950 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
951 :
952 1 : libspdm_reset_message_a(spdm_context);
953 :
954 1 : m_libspdm_psk_exchange_request5.psk_hint_length =
955 : (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
956 1 : m_libspdm_psk_exchange_request5.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
957 1 : opaque_psk_exchange_req_size =
958 1 : libspdm_get_opaque_data_supported_version_data_size(spdm_context);
959 1 : m_libspdm_psk_exchange_request5.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
960 1 : m_libspdm_psk_exchange_request5.req_session_id = 0xFFFF;
961 1 : ptr = m_libspdm_psk_exchange_request5.psk_hint;
962 1 : libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request5.psk_hint),
963 : LIBSPDM_TEST_PSK_HINT_STRING,
964 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
965 1 : ptr += m_libspdm_psk_exchange_request5.psk_hint_length;
966 1 : libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
967 1 : ptr += m_libspdm_psk_exchange_request5.context_length;
968 1 : libspdm_build_opaque_data_supported_version_data(
969 : spdm_context, &opaque_psk_exchange_req_size, ptr);
970 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
971 : spdm_context->transcript.message_m.buffer_size =
972 : spdm_context->transcript.message_m.max_buffer_size;
973 : #endif
974 1 : ptr += opaque_psk_exchange_req_size;
975 1 : response_size = sizeof(response);
976 1 : status = libspdm_get_response_psk_exchange(
977 : spdm_context, m_libspdm_psk_exchange_request5_size,
978 : &m_libspdm_psk_exchange_request5, &response_size, response);
979 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
980 1 : assert_int_equal(
981 : libspdm_secured_message_get_session_state(
982 : spdm_context->session_info[0].secured_message_context),
983 : LIBSPDM_SESSION_STATE_HANDSHAKING);
984 1 : spdm_response = (void *)response;
985 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_PSK_EXCHANGE_RSP);
986 1 : assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
987 :
988 1 : measurement_summary_hash_size = libspdm_get_measurement_summary_hash_size(
989 1 : spdm_context, false, m_libspdm_psk_exchange_request5.header.param1);
990 :
991 : #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
992 1 : result = libspdm_generate_measurement_summary_hash(
993 : spdm_context,
994 1 : spdm_context->connection_info.version,
995 : spdm_context->connection_info.algorithm.base_hash_algo,
996 1 : spdm_context->connection_info.algorithm.measurement_spec,
997 : spdm_context->connection_info.algorithm.measurement_hash_algo,
998 1 : m_libspdm_psk_exchange_request5.header.param1,
999 : measurement_hash,
1000 : measurement_summary_hash_size);
1001 :
1002 1 : assert_true(result);
1003 :
1004 1 : assert_memory_equal((uint8_t *)response + sizeof(spdm_psk_exchange_response_t),
1005 : measurement_hash, measurement_summary_hash_size);
1006 : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP */
1007 :
1008 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1009 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1010 : #endif
1011 1 : free(data1);
1012 1 : }
1013 :
1014 1 : static void rsp_psk_exchange_rsp_case12(void **state)
1015 : {
1016 : libspdm_return_t status;
1017 : libspdm_test_context_t *spdm_test_context;
1018 : libspdm_context_t *spdm_context;
1019 : size_t response_size;
1020 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1021 : spdm_psk_exchange_response_t *spdm_response;
1022 : void *data1;
1023 : size_t data_size1;
1024 : uint8_t *ptr;
1025 : size_t opaque_psk_exchange_req_size;
1026 :
1027 1 : spdm_test_context = *state;
1028 1 : spdm_context = spdm_test_context->spdm_context;
1029 1 : spdm_test_context->case_id = 0xC;
1030 :
1031 : /* Clear previous sessions */
1032 1 : if(spdm_context->session_info[0].session_id != INVALID_SESSION_ID) {
1033 1 : libspdm_free_session_id(spdm_context,0xFFFFFFFF);
1034 : }
1035 :
1036 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1037 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1038 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1039 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1040 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1041 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP;
1042 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1043 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1044 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1045 : m_libspdm_use_measurement_hash_algo;
1046 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1047 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1048 1 : spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1049 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1050 : m_libspdm_use_asym_algo, &data1,
1051 : &data_size1, NULL, NULL);
1052 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
1053 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
1054 :
1055 1 : libspdm_reset_message_a(spdm_context);
1056 :
1057 1 : m_libspdm_psk_exchange_request6.psk_hint_length =
1058 : (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
1059 1 : m_libspdm_psk_exchange_request6.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
1060 1 : opaque_psk_exchange_req_size =
1061 1 : libspdm_get_opaque_data_supported_version_data_size(spdm_context);
1062 1 : m_libspdm_psk_exchange_request6.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
1063 1 : m_libspdm_psk_exchange_request6.req_session_id = 0xFFFF;
1064 1 : ptr = m_libspdm_psk_exchange_request6.psk_hint;
1065 1 : libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request6.psk_hint),
1066 : LIBSPDM_TEST_PSK_HINT_STRING,
1067 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1068 1 : ptr += m_libspdm_psk_exchange_request6.psk_hint_length;
1069 1 : libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
1070 1 : ptr += m_libspdm_psk_exchange_request6.context_length;
1071 1 : libspdm_build_opaque_data_supported_version_data(
1072 : spdm_context, &opaque_psk_exchange_req_size, ptr);
1073 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1074 : spdm_context->transcript.message_m.buffer_size =
1075 : spdm_context->transcript.message_m.max_buffer_size;
1076 : #endif
1077 1 : ptr += opaque_psk_exchange_req_size;
1078 1 : response_size = sizeof(response);
1079 1 : status = libspdm_get_response_psk_exchange(
1080 : spdm_context, m_libspdm_psk_exchange_request6_size,
1081 : &m_libspdm_psk_exchange_request6, &response_size, response);
1082 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1083 :
1084 1 : spdm_response = (void *)response;
1085 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1086 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1087 :
1088 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1089 : /* Error before libspdm_reset_message_buffer_via_request_code, so will not libspdm_reset_message_m */
1090 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
1091 : spdm_context->transcript.message_m.max_buffer_size);
1092 : #endif
1093 1 : free(data1);
1094 1 : }
1095 :
1096 1 : static void rsp_psk_exchange_rsp_case13(void **state)
1097 : {
1098 : libspdm_return_t status;
1099 : libspdm_test_context_t *spdm_test_context;
1100 : libspdm_context_t *spdm_context;
1101 : size_t response_size;
1102 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1103 : spdm_psk_exchange_response_t *spdm_response;
1104 : void *data1;
1105 : size_t data_size1;
1106 : uint8_t *ptr;
1107 : size_t opaque_psk_exchange_req_size;
1108 :
1109 1 : spdm_test_context = *state;
1110 1 : spdm_context = spdm_test_context->spdm_context;
1111 1 : spdm_test_context->case_id = 0xD;
1112 :
1113 : /* Clear previous sessions */
1114 1 : if(spdm_context->session_info[0].session_id != INVALID_SESSION_ID) {
1115 0 : libspdm_free_session_id(spdm_context,0xFFFFFFFF);
1116 : }
1117 :
1118 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1119 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1120 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1121 :
1122 1 : spdm_context->local_context.capability.flags &= ~SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP;
1123 :
1124 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1125 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1126 :
1127 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1128 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1129 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1130 : m_libspdm_use_measurement_hash_algo;
1131 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1132 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1133 1 : spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1134 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1135 : m_libspdm_use_asym_algo, &data1,
1136 : &data_size1, NULL, NULL);
1137 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
1138 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
1139 :
1140 1 : libspdm_reset_message_a(spdm_context);
1141 :
1142 1 : m_libspdm_psk_exchange_request4.psk_hint_length =
1143 : (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
1144 1 : m_libspdm_psk_exchange_request4.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
1145 1 : opaque_psk_exchange_req_size =
1146 1 : libspdm_get_opaque_data_supported_version_data_size(spdm_context);
1147 1 : m_libspdm_psk_exchange_request4.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
1148 1 : m_libspdm_psk_exchange_request4.req_session_id = 0xFFFF;
1149 1 : ptr = m_libspdm_psk_exchange_request4.psk_hint;
1150 1 : libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request4.psk_hint),
1151 : LIBSPDM_TEST_PSK_HINT_STRING,
1152 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1153 1 : ptr += m_libspdm_psk_exchange_request4.psk_hint_length;
1154 1 : libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
1155 1 : ptr += m_libspdm_psk_exchange_request4.context_length;
1156 1 : libspdm_build_opaque_data_supported_version_data(
1157 : spdm_context, &opaque_psk_exchange_req_size, ptr);
1158 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1159 : spdm_context->transcript.message_m.buffer_size =
1160 : spdm_context->transcript.message_m.max_buffer_size;
1161 : #endif
1162 1 : ptr += opaque_psk_exchange_req_size;
1163 1 : response_size = sizeof(response);
1164 1 : status = libspdm_get_response_psk_exchange(
1165 : spdm_context, m_libspdm_psk_exchange_request4_size,
1166 : &m_libspdm_psk_exchange_request4, &response_size, response);
1167 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1168 :
1169 1 : spdm_response = (void *)response;
1170 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1171 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1172 :
1173 1 : free(data1);
1174 1 : }
1175 :
1176 1 : static void rsp_psk_exchange_rsp_case14(void **state)
1177 : {
1178 : libspdm_return_t status;
1179 : libspdm_test_context_t *spdm_test_context;
1180 : libspdm_context_t *spdm_context;
1181 : size_t response_size;
1182 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1183 : spdm_psk_exchange_response_t *spdm_response;
1184 : void *data1;
1185 : size_t data_size1;
1186 : uint8_t *ptr;
1187 : size_t opaque_psk_exchange_req_size;
1188 :
1189 1 : spdm_test_context = *state;
1190 1 : spdm_context = spdm_test_context->spdm_context;
1191 1 : spdm_test_context->case_id = 0xE;
1192 :
1193 : /* Clear previous sessions */
1194 1 : if(spdm_context->session_info[0].session_id != INVALID_SESSION_ID) {
1195 0 : libspdm_free_session_id(spdm_context,0xFFFFFFFF);
1196 : }
1197 :
1198 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1199 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1200 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1201 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1202 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1203 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1204 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1205 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1206 : m_libspdm_use_measurement_hash_algo;
1207 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1208 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1209 1 : spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1210 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1211 : m_libspdm_use_asym_algo, &data1,
1212 : &data_size1, NULL, NULL);
1213 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
1214 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
1215 :
1216 1 : libspdm_reset_message_a(spdm_context);
1217 :
1218 1 : m_libspdm_psk_exchange_request7.psk_hint_length = 0;
1219 1 : m_libspdm_psk_exchange_request7.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
1220 1 : opaque_psk_exchange_req_size =
1221 1 : libspdm_get_opaque_data_supported_version_data_size(spdm_context);
1222 1 : m_libspdm_psk_exchange_request7.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
1223 1 : m_libspdm_psk_exchange_request7.req_session_id = 0xFFFF;
1224 1 : ptr = m_libspdm_psk_exchange_request7.context;
1225 1 : libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
1226 1 : ptr += m_libspdm_psk_exchange_request7.context_length;
1227 1 : libspdm_build_opaque_data_supported_version_data(
1228 : spdm_context, &opaque_psk_exchange_req_size, ptr);
1229 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1230 : spdm_context->transcript.message_m.buffer_size =
1231 : spdm_context->transcript.message_m.max_buffer_size;
1232 : #endif
1233 1 : ptr += opaque_psk_exchange_req_size;
1234 1 : response_size = sizeof(response);
1235 1 : status = libspdm_get_response_psk_exchange(
1236 : spdm_context, m_libspdm_psk_exchange_request7_size,
1237 : &m_libspdm_psk_exchange_request7, &response_size, response);
1238 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1239 1 : assert_int_equal(
1240 : libspdm_secured_message_get_session_state(
1241 : spdm_context->session_info[0].secured_message_context),
1242 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1243 1 : spdm_response = (void *)response;
1244 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_PSK_EXCHANGE_RSP);
1245 1 : assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
1246 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1247 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1248 : #endif
1249 1 : free(data1);
1250 1 : }
1251 :
1252 1 : static void rsp_psk_exchange_rsp_case15(void **state)
1253 : {
1254 : libspdm_return_t status;
1255 : libspdm_test_context_t *spdm_test_context;
1256 : libspdm_context_t *spdm_context;
1257 : size_t response_size;
1258 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1259 : spdm_psk_exchange_response_t *spdm_response;
1260 : void *data1;
1261 : size_t data_size1;
1262 : uint8_t *ptr;
1263 : size_t opaque_psk_exchange_req_size;
1264 :
1265 1 : spdm_test_context = *state;
1266 1 : spdm_context = spdm_test_context->spdm_context;
1267 1 : spdm_test_context->case_id = 0xF;
1268 :
1269 : /* Clear previous sessions */
1270 1 : if(spdm_context->session_info[0].session_id != INVALID_SESSION_ID) {
1271 1 : libspdm_free_session_id(spdm_context,0xFFFFFFFF);
1272 : }
1273 :
1274 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1275 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1276 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1277 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1278 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1279 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1280 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1281 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1282 : m_libspdm_use_measurement_hash_algo;
1283 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1284 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1285 1 : spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1286 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1287 : m_libspdm_use_asym_algo, &data1,
1288 : &data_size1, NULL, NULL);
1289 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
1290 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
1291 :
1292 1 : libspdm_reset_message_a(spdm_context);
1293 :
1294 1 : m_libspdm_psk_exchange_request8.psk_hint_length =
1295 : (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
1296 1 : m_libspdm_psk_exchange_request8.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
1297 1 : opaque_psk_exchange_req_size = 0;
1298 1 : m_libspdm_psk_exchange_request8.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
1299 1 : m_libspdm_psk_exchange_request8.req_session_id = 0xFFFF;
1300 1 : ptr = m_libspdm_psk_exchange_request8.psk_hint;
1301 1 : libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request8.psk_hint),
1302 : LIBSPDM_TEST_PSK_HINT_STRING,
1303 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1304 1 : ptr += m_libspdm_psk_exchange_request8.psk_hint_length;
1305 1 : libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
1306 1 : ptr += m_libspdm_psk_exchange_request8.context_length;
1307 :
1308 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1309 : spdm_context->transcript.message_m.buffer_size =
1310 : spdm_context->transcript.message_m.max_buffer_size;
1311 : #endif
1312 1 : ptr += opaque_psk_exchange_req_size;
1313 1 : response_size = sizeof(response);
1314 1 : status = libspdm_get_response_psk_exchange(
1315 : spdm_context, m_libspdm_psk_exchange_request8_size,
1316 : &m_libspdm_psk_exchange_request8, &response_size, response);
1317 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1318 1 : assert_int_equal(
1319 : libspdm_secured_message_get_session_state(
1320 : spdm_context->session_info[0].secured_message_context),
1321 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1322 1 : spdm_response = (void *)response;
1323 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_PSK_EXCHANGE_RSP);
1324 1 : assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
1325 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1326 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1327 : #endif
1328 1 : free(data1);
1329 1 : }
1330 :
1331 1 : static void rsp_psk_exchange_rsp_case16(void **state)
1332 : {
1333 : libspdm_return_t status;
1334 : libspdm_test_context_t *spdm_test_context;
1335 : libspdm_context_t *spdm_context;
1336 : size_t response_size;
1337 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1338 : spdm_psk_exchange_response_t *spdm_response;
1339 : void *data1;
1340 : size_t data_size1;
1341 : uint8_t *ptr;
1342 : size_t opaque_psk_exchange_req_size;
1343 :
1344 1 : spdm_test_context = *state;
1345 1 : spdm_context = spdm_test_context->spdm_context;
1346 1 : spdm_test_context->case_id = 0x10;
1347 :
1348 : /* Clear previous sessions */
1349 1 : if(spdm_context->session_info[0].session_id != INVALID_SESSION_ID) {
1350 1 : libspdm_free_session_id(spdm_context,0xFFFFFFFF);
1351 : }
1352 :
1353 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1354 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1355 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1356 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1357 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1358 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1359 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1360 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1361 : m_libspdm_use_measurement_hash_algo;
1362 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1363 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1364 1 : spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1365 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1366 : m_libspdm_use_asym_algo, &data1,
1367 : &data_size1, NULL, NULL);
1368 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
1369 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
1370 :
1371 1 : libspdm_reset_message_a(spdm_context);
1372 :
1373 1 : m_libspdm_psk_exchange_request9.psk_hint_length = 0;
1374 1 : m_libspdm_psk_exchange_request9.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
1375 1 : opaque_psk_exchange_req_size = 0;
1376 1 : m_libspdm_psk_exchange_request9.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
1377 1 : m_libspdm_psk_exchange_request9.req_session_id = 0xFFFF;
1378 1 : ptr = m_libspdm_psk_exchange_request9.context;
1379 1 : libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
1380 1 : ptr += m_libspdm_psk_exchange_request9.context_length;
1381 :
1382 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1383 : spdm_context->transcript.message_m.buffer_size =
1384 : spdm_context->transcript.message_m.max_buffer_size;
1385 : #endif
1386 1 : ptr += opaque_psk_exchange_req_size;
1387 1 : response_size = sizeof(response);
1388 1 : status = libspdm_get_response_psk_exchange(
1389 : spdm_context, m_libspdm_psk_exchange_request9_size,
1390 : &m_libspdm_psk_exchange_request9, &response_size, response);
1391 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1392 1 : assert_int_equal(
1393 : libspdm_secured_message_get_session_state(
1394 : spdm_context->session_info[0].secured_message_context),
1395 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1396 1 : spdm_response = (void *)response;
1397 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_PSK_EXCHANGE_RSP);
1398 1 : assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
1399 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1400 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1401 : #endif
1402 1 : free(data1);
1403 1 : }
1404 :
1405 1 : static void rsp_psk_exchange_rsp_case17(void **state)
1406 : {
1407 : libspdm_return_t status;
1408 : libspdm_test_context_t *spdm_test_context;
1409 : libspdm_context_t *spdm_context;
1410 : size_t response_size;
1411 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1412 : spdm_psk_exchange_response_t *spdm_response;
1413 : void *data1;
1414 : size_t data_size1;
1415 : uint8_t *ptr;
1416 : size_t opaque_psk_exchange_req_size;
1417 :
1418 1 : spdm_test_context = *state;
1419 1 : spdm_context = spdm_test_context->spdm_context;
1420 1 : spdm_test_context->case_id = 0x11;
1421 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1422 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1423 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1424 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1425 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1426 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1427 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1428 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1429 : m_libspdm_use_measurement_hash_algo;
1430 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1431 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1432 1 : spdm_context->connection_info.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1433 1 : spdm_context->connection_info.algorithm.other_params_support =
1434 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
1435 1 : libspdm_session_info_init(spdm_context,
1436 1 : spdm_context->session_info,
1437 : 0,
1438 : INVALID_SESSION_ID, true);
1439 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1440 : m_libspdm_use_asym_algo, &data1,
1441 : &data_size1, NULL, NULL);
1442 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
1443 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
1444 :
1445 1 : libspdm_reset_message_a(spdm_context);
1446 :
1447 1 : m_libspdm_psk_exchange_request3.psk_hint_length =
1448 : (uint16_t)sizeof(LIBSPDM_TEST_PSK_HINT_STRING);
1449 1 : m_libspdm_psk_exchange_request3.context_length = LIBSPDM_PSK_CONTEXT_LENGTH;
1450 1 : opaque_psk_exchange_req_size =
1451 1 : libspdm_get_opaque_data_supported_version_data_size(spdm_context);
1452 1 : m_libspdm_psk_exchange_request3.opaque_length = (uint16_t)opaque_psk_exchange_req_size;
1453 1 : m_libspdm_psk_exchange_request3.req_session_id = 0xFFFF;
1454 1 : ptr = m_libspdm_psk_exchange_request3.psk_hint;
1455 1 : libspdm_copy_mem(ptr, sizeof(m_libspdm_psk_exchange_request3.psk_hint),
1456 : LIBSPDM_TEST_PSK_HINT_STRING,
1457 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1458 1 : ptr += m_libspdm_psk_exchange_request3.psk_hint_length;
1459 1 : libspdm_get_random_number(LIBSPDM_PSK_CONTEXT_LENGTH, ptr);
1460 1 : ptr += m_libspdm_psk_exchange_request3.context_length;
1461 1 : libspdm_build_opaque_data_supported_version_data(
1462 : spdm_context, &opaque_psk_exchange_req_size, ptr);
1463 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1464 : spdm_context->transcript.message_m.buffer_size =
1465 : spdm_context->transcript.message_m.max_buffer_size;
1466 : #endif
1467 1 : ptr += opaque_psk_exchange_req_size;
1468 1 : response_size = sizeof(response);
1469 1 : status = libspdm_get_response_psk_exchange(
1470 : spdm_context, m_libspdm_psk_exchange_request3_size,
1471 : &m_libspdm_psk_exchange_request3, &response_size, response);
1472 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1473 1 : assert_int_equal(
1474 : libspdm_secured_message_get_session_state(
1475 : spdm_context->session_info[0].secured_message_context),
1476 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1477 1 : assert_int_equal(spdm_context->session_info[0].session_policy, 0);
1478 1 : spdm_response = (void *)response;
1479 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1480 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_PSK_EXCHANGE_RSP);
1481 1 : assert_int_equal(spdm_response->rsp_session_id, 0xFFFF);
1482 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1483 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1484 : #endif
1485 1 : free(data1);
1486 1 : }
1487 :
1488 1 : int libspdm_rsp_psk_exchange_rsp_test(void)
1489 : {
1490 1 : const struct CMUnitTest test_cases[] = {
1491 : /* Success Case*/
1492 : cmocka_unit_test(rsp_psk_exchange_rsp_case1),
1493 : /* Bad request size*/
1494 : cmocka_unit_test(rsp_psk_exchange_rsp_case2),
1495 : /* response_state: SPDM_RESPONSE_STATE_BUSY*/
1496 : cmocka_unit_test(rsp_psk_exchange_rsp_case3),
1497 : /* response_state: SPDM_RESPONSE_STATE_NEED_RESYNC*/
1498 : cmocka_unit_test(rsp_psk_exchange_rsp_case4),
1499 : #if LIBSPDM_RESPOND_IF_READY_SUPPORT
1500 : /* response_state: SPDM_RESPONSE_STATE_NOT_READY*/
1501 : cmocka_unit_test(rsp_psk_exchange_rsp_case5),
1502 : #endif /* LIBSPDM_RESPOND_IF_READY_SUPPORT */
1503 : /* connection_state Check*/
1504 : cmocka_unit_test(rsp_psk_exchange_rsp_case6),
1505 : /* Buffer reset*/
1506 : cmocka_unit_test(rsp_psk_exchange_rsp_case7),
1507 : /* Buffer verification*/
1508 : cmocka_unit_test(rsp_psk_exchange_rsp_case8),
1509 : /* Successful response V1.2*/
1510 : cmocka_unit_test(rsp_psk_exchange_rsp_case9),
1511 : /* TCB measurement hash requested */
1512 : cmocka_unit_test(rsp_psk_exchange_rsp_case10),
1513 : /* All measurement hash requested */
1514 : cmocka_unit_test(rsp_psk_exchange_rsp_case11),
1515 : /* Reserved value in Measurement summary. Error + Invalid */
1516 : cmocka_unit_test(rsp_psk_exchange_rsp_case12),
1517 : /* TCB measurement hash requested, measurement flag not set */
1518 : cmocka_unit_test(rsp_psk_exchange_rsp_case13),
1519 : /* No PSKHint*/
1520 : cmocka_unit_test(rsp_psk_exchange_rsp_case14),
1521 : /* No OpaqueData*/
1522 : cmocka_unit_test(rsp_psk_exchange_rsp_case15),
1523 : /* No PSKHint and no OpaqueData*/
1524 : cmocka_unit_test(rsp_psk_exchange_rsp_case16),
1525 : /* OpaqueData only supports OpaqueDataFmt1, Success Case */
1526 : cmocka_unit_test(rsp_psk_exchange_rsp_case17),
1527 : };
1528 :
1529 1 : libspdm_test_context_t test_context = {
1530 : LIBSPDM_TEST_CONTEXT_VERSION,
1531 : false,
1532 : };
1533 :
1534 1 : libspdm_setup_test_context(&test_context);
1535 :
1536 1 : return cmocka_run_group_tests(test_cases,
1537 : libspdm_unit_test_group_setup,
1538 : libspdm_unit_test_group_teardown);
1539 : }
1540 :
1541 : #endif /* LIBSPDM_ENABLE_CAPABILITY_PSK_CAP*/
|
