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