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