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