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