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_requester_lib.h"
9 : #include "internal/libspdm_secured_message_lib.h"
10 :
11 : #if LIBSPDM_ENABLE_CAPABILITY_PSK_CAP
12 :
13 : static uint8_t m_libspdm_dummy_key_buffer[LIBSPDM_MAX_AEAD_KEY_SIZE];
14 : static uint8_t m_libspdm_dummy_salt_buffer[LIBSPDM_MAX_AEAD_IV_SIZE];
15 :
16 : static size_t m_libspdm_local_buffer_size;
17 : static uint8_t m_libspdm_local_buffer[LIBSPDM_MAX_MESSAGE_TH_BUFFER_SIZE];
18 :
19 34 : static void libspdm_secured_message_set_dummy_finished_key(
20 : void *spdm_secured_message_context)
21 : {
22 34 : }
23 :
24 33 : void libspdm_secured_message_set_response_handshake_encryption_key(
25 : void *spdm_secured_message_context, const void *key, size_t key_size)
26 : {
27 : libspdm_secured_message_context_t *secured_message_context;
28 :
29 33 : secured_message_context = spdm_secured_message_context;
30 33 : LIBSPDM_ASSERT(key_size == secured_message_context->aead_key_size);
31 33 : libspdm_copy_mem(secured_message_context->handshake_secret.response_handshake_encryption_key,
32 : sizeof(secured_message_context->handshake_secret.
33 : response_handshake_encryption_key),
34 : key, secured_message_context->aead_key_size);
35 33 : }
36 :
37 33 : void libspdm_secured_message_set_response_handshake_salt(
38 : void *spdm_secured_message_context, const void *salt,
39 : size_t salt_size)
40 : {
41 : libspdm_secured_message_context_t *secured_message_context;
42 :
43 33 : secured_message_context = spdm_secured_message_context;
44 33 : LIBSPDM_ASSERT(salt_size == secured_message_context->aead_iv_size);
45 33 : libspdm_copy_mem(secured_message_context->handshake_secret.response_handshake_salt,
46 : sizeof(secured_message_context->handshake_secret.response_handshake_salt),
47 : salt, secured_message_context->aead_iv_size);
48 33 : }
49 :
50 34 : libspdm_return_t libspdm_requester_psk_finish_test_send_message(void *spdm_context,
51 : size_t request_size,
52 : const void *request,
53 : uint64_t timeout)
54 : {
55 : libspdm_test_context_t *spdm_test_context;
56 :
57 34 : spdm_test_context = libspdm_get_test_context();
58 34 : switch (spdm_test_context->case_id) {
59 1 : case 0x1:
60 1 : return LIBSPDM_STATUS_SEND_FAIL;
61 1 : case 0x2:
62 1 : return LIBSPDM_STATUS_SUCCESS;
63 0 : case 0x3:
64 0 : return LIBSPDM_STATUS_SUCCESS;
65 1 : case 0x4:
66 1 : return LIBSPDM_STATUS_SUCCESS;
67 1 : case 0x5:
68 1 : return LIBSPDM_STATUS_SUCCESS;
69 2 : case 0x6:
70 2 : return LIBSPDM_STATUS_SUCCESS;
71 1 : case 0x7:
72 1 : return LIBSPDM_STATUS_SUCCESS;
73 2 : case 0x8:
74 2 : return LIBSPDM_STATUS_SUCCESS;
75 2 : case 0x9:
76 2 : return LIBSPDM_STATUS_SUCCESS;
77 18 : case 0xA:
78 18 : return LIBSPDM_STATUS_SUCCESS;
79 1 : case 0xB:
80 1 : return LIBSPDM_STATUS_SUCCESS;
81 0 : case 0xC:
82 0 : return LIBSPDM_STATUS_SUCCESS;
83 1 : case 0xD:
84 1 : return LIBSPDM_STATUS_SUCCESS;
85 0 : case 0xE:
86 0 : return LIBSPDM_STATUS_SUCCESS;
87 1 : case 0xF:
88 1 : return LIBSPDM_STATUS_SUCCESS;
89 2 : case 0x10:
90 : case 0x11:
91 : {
92 : libspdm_return_t status;
93 : uint8_t *decoded_message;
94 : size_t decoded_message_size;
95 : uint32_t session_id;
96 : uint32_t *message_session_id;
97 : bool is_app_message;
98 : libspdm_session_info_t *session_info;
99 : uint8_t message_buffer[LIBSPDM_SENDER_BUFFER_SIZE];
100 :
101 2 : message_session_id = NULL;
102 2 : session_id = 0xFFFFFFFF;
103 2 : decoded_message = (uint8_t *) &m_libspdm_local_buffer[0];
104 2 : decoded_message_size = sizeof(m_libspdm_local_buffer);
105 :
106 2 : session_info = libspdm_get_session_info_via_session_id(spdm_context, session_id);
107 2 : if (session_info == NULL) {
108 0 : return LIBSPDM_STATUS_SEND_FAIL;
109 : }
110 :
111 2 : memcpy(message_buffer, request, request_size);
112 :
113 2 : ((libspdm_secured_message_context_t *)(session_info->secured_message_context))
114 2 : ->handshake_secret.request_handshake_sequence_number--;
115 2 : m_libspdm_local_buffer_size = 0;
116 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&decoded_message, &decoded_message_size);
117 2 : status = libspdm_transport_test_decode_message(
118 : spdm_context,
119 : &message_session_id, &is_app_message, true, request_size, message_buffer,
120 : &decoded_message_size, (void **)&decoded_message);
121 2 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
122 0 : return LIBSPDM_STATUS_SEND_FAIL;
123 : }
124 2 : libspdm_copy_mem(&m_libspdm_local_buffer[m_libspdm_local_buffer_size],
125 : sizeof(m_libspdm_local_buffer) - m_libspdm_local_buffer_size,
126 : decoded_message, decoded_message_size);
127 2 : m_libspdm_local_buffer_size += decoded_message_size;
128 : }
129 2 : return LIBSPDM_STATUS_SUCCESS;
130 0 : default:
131 0 : return LIBSPDM_STATUS_SEND_FAIL;
132 : }
133 : }
134 :
135 33 : libspdm_return_t libspdm_requester_psk_finish_test_receive_message(
136 : void *spdm_context, size_t *response_size,
137 : void **response, uint64_t timeout)
138 : {
139 : libspdm_test_context_t *spdm_test_context;
140 :
141 33 : spdm_test_context = libspdm_get_test_context();
142 33 : switch (spdm_test_context->case_id) {
143 0 : case 0x1:
144 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
145 :
146 1 : case 0x2: {
147 : spdm_psk_finish_response_t *spdm_response;
148 : size_t spdm_response_size;
149 : size_t transport_header_size;
150 : uint32_t session_id;
151 : libspdm_session_info_t *session_info;
152 : uint8_t *scratch_buffer;
153 : size_t scratch_buffer_size;
154 :
155 1 : session_id = 0xFFFFFFFF;
156 1 : spdm_response_size = sizeof(spdm_psk_finish_response_t);
157 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
158 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
159 :
160 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
161 1 : spdm_response->header.request_response_code =
162 : SPDM_PSK_FINISH_RSP;
163 1 : spdm_response->header.param1 = 0;
164 1 : spdm_response->header.param2 = 0;
165 :
166 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
167 : * transport_message is always in sender buffer. */
168 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
169 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
170 : scratch_buffer_size - transport_header_size,
171 : spdm_response, spdm_response_size);
172 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
173 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
174 : false, false, spdm_response_size,
175 : spdm_response, response_size,
176 : response);
177 1 : session_info = libspdm_get_session_info_via_session_id(
178 : spdm_context, session_id);
179 1 : if (session_info == NULL) {
180 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
181 : }
182 : /* WALKAROUND: If just use single context to encode message and then decode message */
183 : ((libspdm_secured_message_context_t
184 1 : *)(session_info->secured_message_context))
185 1 : ->handshake_secret.response_handshake_sequence_number--;
186 : }
187 1 : return LIBSPDM_STATUS_SUCCESS;
188 :
189 0 : case 0x3: {
190 : spdm_psk_finish_response_t *spdm_response;
191 : size_t spdm_response_size;
192 : size_t transport_header_size;
193 : uint32_t session_id;
194 : libspdm_session_info_t *session_info;
195 : uint8_t *scratch_buffer;
196 : size_t scratch_buffer_size;
197 :
198 0 : session_id = 0xFFFFFFFF;
199 0 : spdm_response_size = sizeof(spdm_psk_finish_response_t);
200 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
201 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
202 :
203 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
204 0 : spdm_response->header.request_response_code =
205 : SPDM_PSK_FINISH_RSP;
206 0 : spdm_response->header.param1 = 0;
207 0 : spdm_response->header.param2 = 0;
208 :
209 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
210 : * transport_message is always in sender buffer. */
211 0 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
212 0 : libspdm_copy_mem (scratch_buffer + transport_header_size,
213 : scratch_buffer_size - transport_header_size,
214 : spdm_response, spdm_response_size);
215 0 : spdm_response = (void *)(scratch_buffer + transport_header_size);
216 0 : libspdm_transport_test_encode_message(spdm_context, &session_id,
217 : false, false, spdm_response_size,
218 : spdm_response, response_size,
219 : response);
220 0 : session_info = libspdm_get_session_info_via_session_id(
221 : spdm_context, session_id);
222 0 : if (session_info == NULL) {
223 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
224 : }
225 : ((libspdm_secured_message_context_t
226 0 : *)(session_info->secured_message_context))
227 0 : ->handshake_secret.response_handshake_sequence_number--;
228 : }
229 0 : return LIBSPDM_STATUS_SUCCESS;
230 :
231 1 : case 0x4: {
232 : spdm_error_response_t *spdm_response;
233 : size_t spdm_response_size;
234 : size_t transport_header_size;
235 : uint32_t session_id;
236 : libspdm_session_info_t *session_info;
237 : uint8_t *scratch_buffer;
238 : size_t scratch_buffer_size;
239 :
240 1 : spdm_response_size = sizeof(spdm_error_response_t);
241 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
242 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
243 :
244 1 : session_id = 0xFFFFFFFF;
245 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
246 1 : spdm_response->header.request_response_code = SPDM_ERROR;
247 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_INVALID_REQUEST;
248 1 : spdm_response->header.param2 = 0;
249 :
250 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
251 : * transport_message is always in sender buffer. */
252 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
253 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
254 : scratch_buffer_size - transport_header_size,
255 : spdm_response, spdm_response_size);
256 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
257 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
258 : false, false,
259 : spdm_response_size,
260 : spdm_response,
261 : response_size, response);
262 1 : session_info = libspdm_get_session_info_via_session_id(
263 : spdm_context, session_id);
264 1 : if (session_info == NULL) {
265 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
266 : }
267 : ((libspdm_secured_message_context_t
268 1 : *)(session_info->secured_message_context))
269 1 : ->handshake_secret.response_handshake_sequence_number--;
270 : }
271 1 : return LIBSPDM_STATUS_SUCCESS;
272 :
273 1 : case 0x5: {
274 : spdm_error_response_t *spdm_response;
275 : size_t spdm_response_size;
276 : size_t transport_header_size;
277 : uint32_t session_id;
278 : libspdm_session_info_t *session_info;
279 : uint8_t *scratch_buffer;
280 : size_t scratch_buffer_size;
281 :
282 1 : spdm_response_size = sizeof(spdm_error_response_t);
283 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
284 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
285 :
286 1 : session_id = 0xFFFFFFFF;
287 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
288 1 : spdm_response->header.request_response_code = SPDM_ERROR;
289 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
290 1 : spdm_response->header.param2 = 0;
291 :
292 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
293 : * transport_message is always in sender buffer. */
294 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
295 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
296 : scratch_buffer_size - transport_header_size,
297 : spdm_response, spdm_response_size);
298 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
299 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
300 : false, false,
301 : spdm_response_size,
302 : spdm_response,
303 : response_size, response);
304 1 : session_info = libspdm_get_session_info_via_session_id(
305 : spdm_context, session_id);
306 1 : if (session_info == NULL) {
307 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
308 : }
309 : ((libspdm_secured_message_context_t
310 1 : *)(session_info->secured_message_context))
311 1 : ->handshake_secret.response_handshake_sequence_number--;
312 : }
313 1 : return LIBSPDM_STATUS_SUCCESS;
314 :
315 2 : case 0x6: {
316 : static size_t sub_index1 = 0;
317 2 : if (sub_index1 == 0) {
318 : spdm_error_response_t *spdm_response;
319 : size_t spdm_response_size;
320 : size_t transport_header_size;
321 : uint32_t session_id;
322 : libspdm_session_info_t *session_info;
323 : uint8_t *scratch_buffer;
324 : size_t scratch_buffer_size;
325 :
326 1 : spdm_response_size = sizeof(spdm_error_response_t);
327 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
328 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
329 :
330 1 : session_id = 0xFFFFFFFF;
331 1 : spdm_response->header.spdm_version =
332 : SPDM_MESSAGE_VERSION_11;
333 1 : spdm_response->header.request_response_code = SPDM_ERROR;
334 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
335 1 : spdm_response->header.param2 = 0;
336 :
337 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
338 : * transport_message is always in sender buffer. */
339 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
340 : &scratch_buffer_size);
341 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
342 : scratch_buffer_size - transport_header_size,
343 : spdm_response, spdm_response_size);
344 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
345 1 : libspdm_transport_test_encode_message(
346 : spdm_context, &session_id, false, false,
347 : spdm_response_size, spdm_response,
348 : response_size, response);
349 1 : sub_index1++;
350 1 : session_info = libspdm_get_session_info_via_session_id(
351 : spdm_context, session_id);
352 1 : if (session_info == NULL) {
353 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
354 : }
355 : ((libspdm_secured_message_context_t
356 1 : *)(session_info->secured_message_context))
357 : ->handshake_secret
358 1 : .response_handshake_sequence_number--;
359 1 : } else if (sub_index1 == 1) {
360 : spdm_psk_finish_response_t *spdm_response;
361 : size_t spdm_response_size;
362 : size_t transport_header_size;
363 : uint32_t session_id;
364 : libspdm_session_info_t *session_info;
365 : uint8_t *scratch_buffer;
366 : size_t scratch_buffer_size;
367 :
368 1 : session_id = 0xFFFFFFFF;
369 1 : spdm_response_size = sizeof(spdm_psk_finish_response_t);
370 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
371 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
372 :
373 1 : spdm_response->header.spdm_version =
374 : SPDM_MESSAGE_VERSION_11;
375 1 : spdm_response->header.request_response_code =
376 : SPDM_PSK_FINISH_RSP;
377 1 : spdm_response->header.param1 = 0;
378 1 : spdm_response->header.param2 = 0;
379 :
380 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
381 : * transport_message is always in sender buffer. */
382 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
383 : &scratch_buffer_size);
384 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
385 : scratch_buffer_size - transport_header_size,
386 : spdm_response, spdm_response_size);
387 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
388 1 : libspdm_transport_test_encode_message(
389 : spdm_context, &session_id, false, false,
390 : spdm_response_size, spdm_response, response_size,
391 : response);
392 1 : session_info = libspdm_get_session_info_via_session_id(
393 : spdm_context, session_id);
394 1 : if (session_info == NULL) {
395 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
396 : }
397 : ((libspdm_secured_message_context_t
398 1 : *)(session_info->secured_message_context))
399 : ->handshake_secret
400 1 : .response_handshake_sequence_number--;
401 : }
402 : }
403 2 : return LIBSPDM_STATUS_SUCCESS;
404 :
405 1 : case 0x7: {
406 : spdm_error_response_t *spdm_response;
407 : size_t spdm_response_size;
408 : size_t transport_header_size;
409 : uint32_t session_id;
410 : libspdm_session_info_t *session_info;
411 : uint8_t *scratch_buffer;
412 : size_t scratch_buffer_size;
413 :
414 1 : spdm_response_size = sizeof(spdm_error_response_t);
415 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
416 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
417 :
418 1 : session_id = 0xFFFFFFFF;
419 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
420 1 : spdm_response->header.request_response_code = SPDM_ERROR;
421 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_REQUEST_RESYNCH;
422 1 : spdm_response->header.param2 = 0;
423 :
424 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
425 : * transport_message is always in sender buffer. */
426 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
427 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
428 : scratch_buffer_size - transport_header_size,
429 : spdm_response, spdm_response_size);
430 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
431 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
432 : false, false,
433 : spdm_response_size,
434 : spdm_response,
435 : response_size, response);
436 1 : session_info = libspdm_get_session_info_via_session_id(
437 : spdm_context, session_id);
438 1 : if (session_info == NULL) {
439 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
440 : }
441 : ((libspdm_secured_message_context_t
442 1 : *)(session_info->secured_message_context))
443 1 : ->handshake_secret.response_handshake_sequence_number--;
444 : }
445 1 : return LIBSPDM_STATUS_SUCCESS;
446 :
447 2 : case 0x8: {
448 : spdm_error_response_data_response_not_ready_t *spdm_response;
449 : size_t spdm_response_size;
450 : size_t transport_header_size;
451 : uint32_t session_id;
452 : libspdm_session_info_t *session_info;
453 : uint8_t *scratch_buffer;
454 : size_t scratch_buffer_size;
455 :
456 2 : spdm_response_size = sizeof(spdm_error_response_data_response_not_ready_t);
457 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
458 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
459 :
460 2 : session_id = 0xFFFFFFFF;
461 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
462 2 : spdm_response->header.request_response_code = SPDM_ERROR;
463 2 : spdm_response->header.param1 =
464 : SPDM_ERROR_CODE_RESPONSE_NOT_READY;
465 2 : spdm_response->header.param2 = 0;
466 2 : spdm_response->extend_error_data.rd_exponent = 1;
467 2 : spdm_response->extend_error_data.rd_tm = 2;
468 2 : spdm_response->extend_error_data.request_code = SPDM_PSK_FINISH;
469 2 : spdm_response->extend_error_data.token = 0;
470 :
471 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
472 : * transport_message is always in sender buffer. */
473 2 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
474 2 : libspdm_copy_mem (scratch_buffer + transport_header_size,
475 : scratch_buffer_size - transport_header_size,
476 : spdm_response, spdm_response_size);
477 2 : spdm_response = (void *)(scratch_buffer + transport_header_size);
478 2 : libspdm_transport_test_encode_message(spdm_context, &session_id,
479 : false, false,
480 : spdm_response_size,
481 : spdm_response,
482 : response_size, response);
483 2 : session_info = libspdm_get_session_info_via_session_id(
484 : spdm_context, session_id);
485 2 : if (session_info == NULL) {
486 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
487 : }
488 : ((libspdm_secured_message_context_t
489 2 : *)(session_info->secured_message_context))
490 2 : ->handshake_secret.response_handshake_sequence_number--;
491 : }
492 2 : return LIBSPDM_STATUS_SUCCESS;
493 :
494 2 : case 0x9: {
495 : static size_t sub_index2 = 0;
496 2 : if (sub_index2 == 0) {
497 : spdm_error_response_data_response_not_ready_t
498 : *spdm_response;
499 : size_t spdm_response_size;
500 : size_t transport_header_size;
501 : uint32_t session_id;
502 : libspdm_session_info_t *session_info;
503 : uint8_t *scratch_buffer;
504 : size_t scratch_buffer_size;
505 :
506 1 : spdm_response_size = sizeof(spdm_error_response_data_response_not_ready_t);
507 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
508 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
509 :
510 1 : session_id = 0xFFFFFFFF;
511 1 : spdm_response->header.spdm_version =
512 : SPDM_MESSAGE_VERSION_11;
513 1 : spdm_response->header.request_response_code = SPDM_ERROR;
514 1 : spdm_response->header.param1 =
515 : SPDM_ERROR_CODE_RESPONSE_NOT_READY;
516 1 : spdm_response->header.param2 = 0;
517 1 : spdm_response->extend_error_data.rd_exponent = 1;
518 1 : spdm_response->extend_error_data.rd_tm = 2;
519 1 : spdm_response->extend_error_data.request_code =
520 : SPDM_PSK_FINISH;
521 1 : spdm_response->extend_error_data.token = 1;
522 :
523 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
524 : * transport_message is always in sender buffer. */
525 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
526 : &scratch_buffer_size);
527 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
528 : scratch_buffer_size - transport_header_size,
529 : spdm_response, spdm_response_size);
530 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
531 1 : libspdm_transport_test_encode_message(
532 : spdm_context, &session_id, false, false,
533 : spdm_response_size, spdm_response,
534 : response_size, response);
535 1 : sub_index2++;
536 1 : session_info = libspdm_get_session_info_via_session_id(
537 : spdm_context, session_id);
538 1 : if (session_info == NULL) {
539 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
540 : }
541 : ((libspdm_secured_message_context_t
542 1 : *)(session_info->secured_message_context))
543 : ->handshake_secret
544 1 : .response_handshake_sequence_number--;
545 1 : } else if (sub_index2 == 1) {
546 : spdm_psk_finish_response_t *spdm_response;
547 : size_t spdm_response_size;
548 : size_t transport_header_size;
549 : uint32_t session_id;
550 : libspdm_session_info_t *session_info;
551 : uint8_t *scratch_buffer;
552 : size_t scratch_buffer_size;
553 :
554 1 : session_id = 0xFFFFFFFF;
555 1 : spdm_response_size = sizeof(spdm_psk_finish_response_t);
556 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
557 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
558 :
559 1 : spdm_response->header.spdm_version =
560 : SPDM_MESSAGE_VERSION_11;
561 1 : spdm_response->header.request_response_code =
562 : SPDM_PSK_FINISH_RSP;
563 1 : spdm_response->header.param1 = 0;
564 1 : spdm_response->header.param2 = 0;
565 :
566 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
567 : * transport_message is always in sender buffer. */
568 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
569 : &scratch_buffer_size);
570 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
571 : scratch_buffer_size - transport_header_size,
572 : spdm_response, spdm_response_size);
573 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
574 1 : libspdm_transport_test_encode_message(
575 : spdm_context, &session_id, false, false,
576 : spdm_response_size, spdm_response, response_size,
577 : response);
578 1 : session_info = libspdm_get_session_info_via_session_id(
579 : spdm_context, session_id);
580 1 : if (session_info == NULL) {
581 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
582 : }
583 : ((libspdm_secured_message_context_t
584 1 : *)(session_info->secured_message_context))
585 : ->handshake_secret
586 1 : .response_handshake_sequence_number--;
587 : }
588 : }
589 2 : return LIBSPDM_STATUS_SUCCESS;
590 :
591 18 : case 0xA:
592 : {
593 : static uint16_t error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
594 :
595 : spdm_error_response_t *spdm_response;
596 : size_t spdm_response_size;
597 : size_t transport_header_size;
598 : uint32_t session_id;
599 : libspdm_session_info_t *session_info;
600 : uint8_t *scratch_buffer;
601 : size_t scratch_buffer_size;
602 :
603 18 : session_id = 0xFFFFFFFF;
604 :
605 18 : spdm_response_size = sizeof(spdm_error_response_t);
606 18 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
607 18 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
608 :
609 18 : if(error_code <= 0xff) {
610 18 : libspdm_zero_mem (spdm_response, spdm_response_size);
611 18 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
612 18 : spdm_response->header.request_response_code = SPDM_ERROR;
613 18 : spdm_response->header.param1 = (uint8_t) error_code;
614 18 : spdm_response->header.param2 = 0;
615 :
616 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
617 : * transport_message is always in sender buffer. */
618 18 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer,
619 : &scratch_buffer_size);
620 18 : libspdm_copy_mem (scratch_buffer + transport_header_size,
621 : scratch_buffer_size - transport_header_size,
622 : spdm_response, spdm_response_size);
623 18 : spdm_response = (void *)(scratch_buffer + transport_header_size);
624 18 : libspdm_transport_test_encode_message (spdm_context, &session_id, false, false,
625 : spdm_response_size, spdm_response,
626 : response_size, response);
627 18 : session_info = libspdm_get_session_info_via_session_id (spdm_context, session_id);
628 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->
629 18 : handshake_secret.response_handshake_sequence_number--;
630 : }
631 :
632 18 : error_code++;
633 18 : if(error_code == SPDM_ERROR_CODE_BUSY) { /*busy is treated in cases 5 and 6*/
634 1 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
635 : }
636 18 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) { /*skip some reserved error codes (0d to 3e)*/
637 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
638 : }
639 18 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) { /*skip response not ready, request resync, and some reserved codes (44 to fc)*/
640 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
641 : }
642 : }
643 18 : return LIBSPDM_STATUS_SUCCESS;
644 1 : case 0xB: {
645 : spdm_psk_finish_response_t *spdm_response;
646 : size_t spdm_response_size;
647 : size_t transport_header_size;
648 : uint32_t session_id;
649 : libspdm_session_info_t *session_info;
650 : uint8_t *scratch_buffer;
651 : size_t scratch_buffer_size;
652 :
653 1 : session_id = 0xFFFFFFFF;
654 1 : spdm_response_size = sizeof(spdm_psk_finish_response_t);
655 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
656 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
657 :
658 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
659 1 : spdm_response->header.request_response_code =
660 : SPDM_PSK_FINISH_RSP;
661 1 : spdm_response->header.param1 = 0;
662 1 : spdm_response->header.param2 = 0;
663 :
664 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
665 : * transport_message is always in sender buffer. */
666 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
667 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
668 : scratch_buffer_size - transport_header_size,
669 : spdm_response, spdm_response_size);
670 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
671 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
672 : false, false, spdm_response_size,
673 : spdm_response, response_size,
674 : response);
675 1 : session_info = libspdm_get_session_info_via_session_id(
676 : spdm_context, session_id);
677 1 : if (session_info == NULL) {
678 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
679 : }
680 : /* WALKAROUND: If just use single context to encode message and then decode message */
681 : ((libspdm_secured_message_context_t
682 1 : *)(session_info->secured_message_context))
683 1 : ->handshake_secret.response_handshake_sequence_number--;
684 : }
685 1 : return LIBSPDM_STATUS_SUCCESS;
686 :
687 0 : case 0xC: {
688 : spdm_psk_finish_response_t *spdm_response;
689 : size_t spdm_response_size;
690 : size_t transport_header_size;
691 : uint32_t session_id;
692 : libspdm_session_info_t *session_info;
693 : uint8_t *scratch_buffer;
694 : size_t scratch_buffer_size;
695 :
696 0 : session_id = 0xFFFFFFFF;
697 0 : spdm_response_size = sizeof(spdm_psk_finish_response_t);
698 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
699 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
700 :
701 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
702 0 : spdm_response->header.request_response_code =
703 : SPDM_PSK_FINISH_RSP;
704 0 : spdm_response->header.param1 = 0;
705 0 : spdm_response->header.param2 = 0;
706 :
707 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
708 : * transport_message is always in sender buffer. */
709 0 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
710 0 : libspdm_copy_mem (scratch_buffer + transport_header_size,
711 : scratch_buffer_size - transport_header_size,
712 : spdm_response, spdm_response_size);
713 0 : spdm_response = (void *)(scratch_buffer + transport_header_size);
714 0 : libspdm_transport_test_encode_message(spdm_context, &session_id,
715 : false, false, spdm_response_size,
716 : spdm_response, response_size,
717 : response);
718 0 : session_info = libspdm_get_session_info_via_session_id(
719 : spdm_context, session_id);
720 0 : if (session_info == NULL) {
721 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
722 : }
723 : /* WALKAROUND: If just use single context to encode message and then decode message */
724 : ((libspdm_secured_message_context_t
725 0 : *)(session_info->secured_message_context))
726 0 : ->handshake_secret.response_handshake_sequence_number--;
727 : }
728 0 : return LIBSPDM_STATUS_SUCCESS;
729 :
730 1 : case 0xD: {
731 : spdm_psk_finish_response_t *spdm_response;
732 : size_t spdm_response_size;
733 : size_t transport_header_size;
734 : uint32_t session_id;
735 : libspdm_session_info_t *session_info;
736 : uint8_t *scratch_buffer;
737 : size_t scratch_buffer_size;
738 :
739 1 : session_id = 0xFFFFFFFF;
740 1 : spdm_response_size = sizeof(spdm_psk_finish_response_t);
741 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
742 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
743 :
744 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
745 1 : spdm_response->header.request_response_code =
746 : SPDM_FINISH_RSP; /*wrong response code*/
747 1 : spdm_response->header.param1 = 0;
748 1 : spdm_response->header.param2 = 0;
749 :
750 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
751 : * transport_message is always in sender buffer. */
752 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
753 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
754 : scratch_buffer_size - transport_header_size,
755 : spdm_response, spdm_response_size);
756 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
757 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
758 : false, false, spdm_response_size,
759 : spdm_response, response_size,
760 : response);
761 1 : session_info = libspdm_get_session_info_via_session_id(
762 : spdm_context, session_id);
763 1 : if (session_info == NULL) {
764 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
765 : }
766 : /* WALKAROUND: If just use single context to encode message and then decode message */
767 : ((libspdm_secured_message_context_t
768 1 : *)(session_info->secured_message_context))
769 1 : ->handshake_secret.response_handshake_sequence_number--;
770 : }
771 1 : return LIBSPDM_STATUS_SUCCESS;
772 :
773 0 : case 0xE: {
774 : spdm_psk_finish_response_t *spdm_response;
775 : size_t spdm_response_size;
776 : size_t transport_header_size;
777 : uint32_t session_id;
778 : libspdm_session_info_t *session_info;
779 : uint8_t *scratch_buffer;
780 : size_t scratch_buffer_size;
781 :
782 0 : session_id = 0xFFFFFFFF;
783 0 : spdm_response_size = sizeof(spdm_psk_finish_response_t);
784 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
785 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
786 :
787 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
788 0 : spdm_response->header.request_response_code =
789 : SPDM_PSK_FINISH_RSP;
790 0 : spdm_response->header.param1 = 0;
791 0 : spdm_response->header.param2 = 0;
792 :
793 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
794 : * transport_message is always in sender buffer. */
795 0 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
796 0 : libspdm_copy_mem (scratch_buffer + transport_header_size,
797 : scratch_buffer_size - transport_header_size,
798 : spdm_response, spdm_response_size);
799 0 : spdm_response = (void *)(scratch_buffer + transport_header_size);
800 0 : libspdm_transport_test_encode_message(spdm_context, &session_id,
801 : false, false, spdm_response_size,
802 : spdm_response, response_size,
803 : response);
804 0 : session_info = libspdm_get_session_info_via_session_id(
805 : spdm_context, session_id);
806 0 : if (session_info == NULL) {
807 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
808 : }
809 : /* WALKAROUND: If just use single context to encode message and then decode message */
810 : ((libspdm_secured_message_context_t
811 0 : *)(session_info->secured_message_context))
812 0 : ->handshake_secret.response_handshake_sequence_number--;
813 : }
814 0 : return LIBSPDM_STATUS_SUCCESS;
815 :
816 1 : case 0xF: {
817 : spdm_error_response_t *spdm_response;
818 : size_t spdm_response_size;
819 : size_t transport_header_size;
820 : uint32_t session_id;
821 : libspdm_session_info_t *session_info;
822 : uint8_t *scratch_buffer;
823 : size_t scratch_buffer_size;
824 :
825 1 : session_id = 0xFFFFFFFF;
826 :
827 1 : spdm_response_size = sizeof(spdm_error_response_t);
828 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
829 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
830 :
831 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
832 1 : spdm_response->header.request_response_code = SPDM_ERROR;
833 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_DECRYPT_ERROR;
834 1 : spdm_response->header.param2 = 0;
835 :
836 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
837 : * transport_message is always in sender buffer. */
838 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
839 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
840 : scratch_buffer_size - transport_header_size,
841 : spdm_response, spdm_response_size);
842 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
843 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
844 : false, false,
845 : spdm_response_size,
846 : spdm_response,
847 : response_size, response);
848 1 : session_info = libspdm_get_session_info_via_session_id(
849 : spdm_context, session_id);
850 1 : if (session_info == NULL) {
851 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
852 : }
853 : ((libspdm_secured_message_context_t
854 1 : *)(session_info->secured_message_context))
855 1 : ->handshake_secret.response_handshake_sequence_number--;
856 : }
857 1 : return LIBSPDM_STATUS_SUCCESS;
858 :
859 1 : case 0x10: {
860 : spdm_psk_finish_response_t *spdm_response;
861 : size_t spdm_response_size;
862 : size_t transport_header_size;
863 : uint32_t session_id;
864 : libspdm_session_info_t *session_info;
865 : uint8_t *scratch_buffer;
866 : size_t scratch_buffer_size;
867 :
868 1 : session_id = 0xFFFFFFFF;
869 1 : spdm_response_size = sizeof(spdm_psk_finish_response_t);
870 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
871 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
872 :
873 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
874 1 : spdm_response->header.request_response_code =
875 : SPDM_PSK_FINISH_RSP;
876 1 : spdm_response->header.param1 = 0;
877 1 : spdm_response->header.param2 = 0;
878 :
879 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
880 : * transport_message is always in sender buffer. */
881 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
882 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
883 : scratch_buffer_size - transport_header_size,
884 : spdm_response, spdm_response_size);
885 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
886 :
887 1 : libspdm_copy_mem(&m_libspdm_local_buffer[m_libspdm_local_buffer_size],
888 : sizeof(m_libspdm_local_buffer) - m_libspdm_local_buffer_size,
889 : spdm_response, spdm_response_size);
890 1 : m_libspdm_local_buffer_size += spdm_response_size;
891 :
892 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
893 : false, false, spdm_response_size,
894 : spdm_response, response_size,
895 : response);
896 1 : session_info = libspdm_get_session_info_via_session_id(spdm_context, session_id);
897 1 : if (session_info == NULL) {
898 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
899 : }
900 : /* WALKAROUND: If just use single context to encode message and then decode message */
901 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
902 1 : ->handshake_secret.response_handshake_sequence_number--;
903 : }
904 1 : return LIBSPDM_STATUS_SUCCESS;
905 :
906 1 : case 0x11: {
907 : spdm_psk_finish_response_t *spdm_response;
908 : size_t spdm_response_size;
909 : size_t transport_header_size;
910 : uint32_t session_id;
911 : libspdm_session_info_t *session_info;
912 : uint8_t *scratch_buffer;
913 : size_t scratch_buffer_size;
914 : uint16_t opaque_data_size;
915 : uint8_t *ptr;
916 :
917 1 : session_id = 0xFFFFFFFF;
918 1 : opaque_data_size = 8;
919 1 : spdm_response_size = sizeof(spdm_psk_finish_response_t) + sizeof(uint16_t) + opaque_data_size;
920 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
921 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
922 :
923 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_14;
924 1 : spdm_response->header.request_response_code =
925 : SPDM_PSK_FINISH_RSP;
926 1 : spdm_response->header.param1 = 0;
927 1 : spdm_response->header.param2 = 0;
928 1 : ptr = (uint8_t *)spdm_response + sizeof(spdm_psk_finish_response_t);
929 1 : libspdm_write_uint16(ptr, opaque_data_size);
930 :
931 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
932 : * transport_message is always in sender buffer. */
933 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
934 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
935 : scratch_buffer_size - transport_header_size,
936 : spdm_response, spdm_response_size);
937 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
938 :
939 1 : libspdm_copy_mem(&m_libspdm_local_buffer[m_libspdm_local_buffer_size],
940 : sizeof(m_libspdm_local_buffer) - m_libspdm_local_buffer_size,
941 : spdm_response, spdm_response_size);
942 1 : m_libspdm_local_buffer_size += spdm_response_size;
943 :
944 1 : libspdm_transport_test_encode_message(spdm_context, &session_id,
945 : false, false, spdm_response_size,
946 : spdm_response, response_size,
947 : response);
948 1 : session_info = libspdm_get_session_info_via_session_id(spdm_context, session_id);
949 1 : if (session_info == NULL) {
950 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
951 : }
952 : /* WALKAROUND: If just use single context to encode message and then decode message */
953 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
954 1 : ->handshake_secret.response_handshake_sequence_number--;
955 : }
956 1 : return LIBSPDM_STATUS_SUCCESS;
957 :
958 0 : default:
959 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
960 : }
961 : }
962 :
963 : /**
964 : * Test 1: when no PSK_FINISH_RSP message is received, and the client returns
965 : * a device error.
966 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR.
967 : **/
968 1 : void libspdm_test_requester_psk_finish_case1(void **state)
969 : {
970 : libspdm_return_t status;
971 : libspdm_test_context_t *spdm_test_context;
972 : libspdm_context_t *spdm_context;
973 : uint32_t session_id;
974 : void *data;
975 : size_t data_size;
976 : void *hash;
977 : size_t hash_size;
978 : libspdm_session_info_t *session_info;
979 :
980 1 : spdm_test_context = *state;
981 1 : spdm_context = spdm_test_context->spdm_context;
982 1 : spdm_test_context->case_id = 0x1;
983 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
984 : SPDM_VERSION_NUMBER_SHIFT_BIT;
985 1 : spdm_context->connection_info.connection_state =
986 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
987 1 : spdm_context->connection_info.capability.flags |=
988 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
989 1 : spdm_context->connection_info.capability.flags |=
990 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
991 1 : spdm_context->connection_info.capability.flags |=
992 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
993 1 : spdm_context->local_context.capability.flags |=
994 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
995 1 : spdm_context->local_context.capability.flags |=
996 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
997 1 : spdm_context->local_context.capability.flags |=
998 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
999 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1000 : m_libspdm_use_asym_algo, &data,
1001 : &data_size, &hash, &hash_size)) {
1002 0 : assert(false);
1003 : }
1004 1 : libspdm_reset_message_a(spdm_context);
1005 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1006 : m_libspdm_use_hash_algo;
1007 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1008 : m_libspdm_use_asym_algo;
1009 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1010 : m_libspdm_use_dhe_algo;
1011 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1012 : m_libspdm_use_aead_algo;
1013 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1014 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1015 : data_size;
1016 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1017 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1018 : data, data_size);
1019 : #endif
1020 :
1021 1 : session_id = 0xFFFFFFFF;
1022 1 : session_info = &spdm_context->session_info[0];
1023 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1024 1 : libspdm_session_info_set_psk_hint(session_info,
1025 : LIBSPDM_TEST_PSK_HINT_STRING,
1026 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1027 1 : libspdm_secured_message_set_session_state(
1028 : session_info->secured_message_context,
1029 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1030 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1031 :
1032 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1033 1 : assert_int_equal(status, LIBSPDM_STATUS_SEND_FAIL);
1034 1 : free(data);
1035 1 : }
1036 :
1037 : /**
1038 : * Test 2: receiving a correct PSK_FINISH_RSP message.
1039 : * Expected behavior: client returns a Status of RETURN_SUCCESS and
1040 : * session is established.
1041 : **/
1042 1 : void libspdm_test_requester_psk_finish_case2(void **state)
1043 : {
1044 : libspdm_return_t status;
1045 : libspdm_test_context_t *spdm_test_context;
1046 : libspdm_context_t *spdm_context;
1047 : uint32_t session_id;
1048 : void *data;
1049 : size_t data_size;
1050 : void *hash;
1051 : size_t hash_size;
1052 : libspdm_session_info_t *session_info;
1053 :
1054 1 : spdm_test_context = *state;
1055 1 : spdm_context = spdm_test_context->spdm_context;
1056 1 : spdm_test_context->case_id = 0x2;
1057 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1058 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1059 1 : spdm_context->connection_info.connection_state =
1060 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1061 1 : spdm_context->connection_info.capability.flags |=
1062 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1063 1 : spdm_context->connection_info.capability.flags |=
1064 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1065 1 : spdm_context->connection_info.capability.flags |=
1066 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1067 1 : spdm_context->local_context.capability.flags |=
1068 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1069 1 : spdm_context->local_context.capability.flags |=
1070 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1071 1 : spdm_context->local_context.capability.flags |=
1072 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1073 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1074 : m_libspdm_use_asym_algo, &data,
1075 : &data_size, &hash, &hash_size)) {
1076 0 : assert(false);
1077 : }
1078 1 : libspdm_reset_message_a(spdm_context);
1079 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1080 : m_libspdm_use_hash_algo;
1081 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1082 : m_libspdm_use_asym_algo;
1083 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1084 : m_libspdm_use_dhe_algo;
1085 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1086 : m_libspdm_use_aead_algo;
1087 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1088 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1089 : data_size;
1090 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1091 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1092 : data, data_size);
1093 : #endif
1094 :
1095 1 : session_id = 0xFFFFFFFF;
1096 1 : session_info = &spdm_context->session_info[0];
1097 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1098 1 : libspdm_session_info_set_psk_hint(session_info,
1099 : LIBSPDM_TEST_PSK_HINT_STRING,
1100 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1101 1 : libspdm_secured_message_set_session_state(
1102 : session_info->secured_message_context,
1103 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1104 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1105 : ((libspdm_secured_message_context_t
1106 1 : *)(session_info->secured_message_context))
1107 : ->aead_key_size,
1108 : (uint8_t)(0xFF));
1109 1 : libspdm_secured_message_set_response_handshake_encryption_key(
1110 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1111 : ((libspdm_secured_message_context_t
1112 1 : *)(session_info->secured_message_context))
1113 : ->aead_key_size);
1114 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1115 : ((libspdm_secured_message_context_t
1116 1 : *)(session_info->secured_message_context))
1117 : ->aead_iv_size,
1118 : (uint8_t)(0xFF));
1119 1 : libspdm_secured_message_set_response_handshake_salt(
1120 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1121 : ((libspdm_secured_message_context_t
1122 1 : *)(session_info->secured_message_context))
1123 : ->aead_iv_size);
1124 : ((libspdm_secured_message_context_t *)(session_info
1125 1 : ->secured_message_context))
1126 1 : ->handshake_secret.response_handshake_sequence_number = 0;
1127 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1128 :
1129 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1130 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1131 1 : assert_int_equal(
1132 : libspdm_secured_message_get_session_state(
1133 : spdm_context->session_info[0].secured_message_context),
1134 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1135 1 : free(data);
1136 1 : }
1137 :
1138 : /**
1139 : * Test 3: requester state has not been negotiated, as if GET_VERSION,
1140 : * GET_CAPABILITIES and NEGOTIATE_ALGORITHMS had not been exchanged.
1141 : * Expected behavior: client returns a Status of RETURN_UNSUPPORTED.
1142 : **/
1143 1 : void libspdm_test_requester_psk_finish_case3(void **state)
1144 : {
1145 : libspdm_return_t status;
1146 : libspdm_test_context_t *spdm_test_context;
1147 : libspdm_context_t *spdm_context;
1148 : uint32_t session_id;
1149 : void *data;
1150 : size_t data_size;
1151 : void *hash;
1152 : size_t hash_size;
1153 : libspdm_session_info_t *session_info;
1154 :
1155 1 : spdm_test_context = *state;
1156 1 : spdm_context = spdm_test_context->spdm_context;
1157 1 : spdm_test_context->case_id = 0x3;
1158 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1159 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1160 1 : spdm_context->connection_info.connection_state =
1161 : LIBSPDM_CONNECTION_STATE_NOT_STARTED;
1162 1 : spdm_context->connection_info.capability.flags |=
1163 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1164 1 : spdm_context->connection_info.capability.flags |=
1165 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1166 1 : spdm_context->connection_info.capability.flags |=
1167 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1168 1 : spdm_context->local_context.capability.flags |=
1169 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1170 1 : spdm_context->local_context.capability.flags |=
1171 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1172 1 : spdm_context->local_context.capability.flags |=
1173 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1174 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1175 : m_libspdm_use_asym_algo, &data,
1176 : &data_size, &hash, &hash_size)) {
1177 0 : assert(false);
1178 : }
1179 1 : libspdm_reset_message_a(spdm_context);
1180 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1181 : m_libspdm_use_hash_algo;
1182 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1183 : m_libspdm_use_asym_algo;
1184 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1185 : m_libspdm_use_dhe_algo;
1186 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1187 : m_libspdm_use_aead_algo;
1188 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1189 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1190 : data_size;
1191 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1192 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1193 : data, data_size);
1194 : #endif
1195 :
1196 1 : session_id = 0xFFFFFFFF;
1197 1 : session_info = &spdm_context->session_info[0];
1198 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1199 1 : libspdm_session_info_set_psk_hint(session_info,
1200 : LIBSPDM_TEST_PSK_HINT_STRING,
1201 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1202 1 : libspdm_secured_message_set_session_state(
1203 : session_info->secured_message_context,
1204 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1205 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1206 : ((libspdm_secured_message_context_t
1207 1 : *)(session_info->secured_message_context))
1208 : ->aead_key_size,
1209 : (uint8_t)(0xFF));
1210 1 : libspdm_secured_message_set_response_handshake_encryption_key(
1211 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1212 : ((libspdm_secured_message_context_t
1213 1 : *)(session_info->secured_message_context))
1214 : ->aead_key_size);
1215 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1216 : ((libspdm_secured_message_context_t
1217 1 : *)(session_info->secured_message_context))
1218 : ->aead_iv_size,
1219 : (uint8_t)(0xFF));
1220 1 : libspdm_secured_message_set_response_handshake_salt(
1221 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1222 : ((libspdm_secured_message_context_t
1223 1 : *)(session_info->secured_message_context))
1224 : ->aead_iv_size);
1225 : ((libspdm_secured_message_context_t *)(session_info
1226 1 : ->secured_message_context))
1227 1 : ->handshake_secret.response_handshake_sequence_number = 0;
1228 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1229 :
1230 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1231 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_STATE_LOCAL);
1232 1 : free(data);
1233 1 : }
1234 :
1235 : /**
1236 : * Test 4: the requester is setup correctly, but receives an ERROR message
1237 : * indicating InvalidParameters.
1238 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR.
1239 : **/
1240 1 : void libspdm_test_requester_psk_finish_case4(void **state)
1241 : {
1242 : libspdm_return_t status;
1243 : libspdm_test_context_t *spdm_test_context;
1244 : libspdm_context_t *spdm_context;
1245 : uint32_t session_id;
1246 : void *data;
1247 : size_t data_size;
1248 : void *hash;
1249 : size_t hash_size;
1250 : libspdm_session_info_t *session_info;
1251 :
1252 1 : spdm_test_context = *state;
1253 1 : spdm_context = spdm_test_context->spdm_context;
1254 1 : spdm_test_context->case_id = 0x4;
1255 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1256 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1257 1 : spdm_context->connection_info.connection_state =
1258 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1259 1 : spdm_context->connection_info.capability.flags |=
1260 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1261 1 : spdm_context->connection_info.capability.flags |=
1262 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1263 1 : spdm_context->connection_info.capability.flags |=
1264 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1265 1 : spdm_context->local_context.capability.flags |=
1266 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1267 1 : spdm_context->local_context.capability.flags |=
1268 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1269 1 : spdm_context->local_context.capability.flags |=
1270 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1271 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1272 : m_libspdm_use_asym_algo, &data,
1273 : &data_size, &hash, &hash_size)) {
1274 0 : assert(false);
1275 : }
1276 1 : libspdm_reset_message_a(spdm_context);
1277 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1278 : m_libspdm_use_hash_algo;
1279 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1280 : m_libspdm_use_asym_algo;
1281 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1282 : m_libspdm_use_dhe_algo;
1283 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1284 : m_libspdm_use_aead_algo;
1285 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1286 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1287 : data_size;
1288 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1289 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1290 : data, data_size);
1291 : #endif
1292 :
1293 1 : session_id = 0xFFFFFFFF;
1294 1 : session_info = &spdm_context->session_info[0];
1295 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1296 1 : libspdm_session_info_set_psk_hint(session_info,
1297 : LIBSPDM_TEST_PSK_HINT_STRING,
1298 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1299 1 : libspdm_secured_message_set_session_state(
1300 : session_info->secured_message_context,
1301 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1302 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1303 : ((libspdm_secured_message_context_t
1304 1 : *)(session_info->secured_message_context))
1305 : ->aead_key_size,
1306 : (uint8_t)(0xFF));
1307 1 : libspdm_secured_message_set_response_handshake_encryption_key(
1308 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1309 : ((libspdm_secured_message_context_t
1310 1 : *)(session_info->secured_message_context))
1311 : ->aead_key_size);
1312 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1313 : ((libspdm_secured_message_context_t
1314 1 : *)(session_info->secured_message_context))
1315 : ->aead_iv_size,
1316 : (uint8_t)(0xFF));
1317 1 : libspdm_secured_message_set_response_handshake_salt(
1318 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1319 : ((libspdm_secured_message_context_t
1320 1 : *)(session_info->secured_message_context))
1321 : ->aead_iv_size);
1322 : ((libspdm_secured_message_context_t *)(session_info
1323 1 : ->secured_message_context))
1324 1 : ->handshake_secret.response_handshake_sequence_number = 0;
1325 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1326 :
1327 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1328 1 : assert_int_equal(status, LIBSPDM_STATUS_ERROR_PEER);
1329 1 : assert_int_equal(spdm_context->session_info->session_id, INVALID_SESSION_ID);
1330 1 : free(data);
1331 1 : }
1332 :
1333 : /**
1334 : * Test 5: the requester is setup correctly, but receives an ERROR message
1335 : * indicating the Busy status of the responder.
1336 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR.
1337 : **/
1338 1 : void libspdm_test_requester_psk_finish_case5(void **state)
1339 : {
1340 : libspdm_return_t status;
1341 : libspdm_test_context_t *spdm_test_context;
1342 : libspdm_context_t *spdm_context;
1343 : uint32_t session_id;
1344 : void *data;
1345 : size_t data_size;
1346 : void *hash;
1347 : size_t hash_size;
1348 : libspdm_session_info_t *session_info;
1349 :
1350 1 : spdm_test_context = *state;
1351 1 : spdm_context = spdm_test_context->spdm_context;
1352 1 : spdm_test_context->case_id = 0x5;
1353 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1354 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1355 1 : spdm_context->connection_info.connection_state =
1356 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1357 1 : spdm_context->connection_info.capability.flags |=
1358 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1359 1 : spdm_context->connection_info.capability.flags |=
1360 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1361 1 : spdm_context->connection_info.capability.flags |=
1362 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1363 1 : spdm_context->local_context.capability.flags |=
1364 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1365 1 : spdm_context->local_context.capability.flags |=
1366 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1367 1 : spdm_context->local_context.capability.flags |=
1368 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1369 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1370 : m_libspdm_use_asym_algo, &data,
1371 : &data_size, &hash, &hash_size)) {
1372 0 : assert(false);
1373 : }
1374 1 : libspdm_reset_message_a(spdm_context);
1375 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1376 : m_libspdm_use_hash_algo;
1377 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1378 : m_libspdm_use_asym_algo;
1379 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1380 : m_libspdm_use_dhe_algo;
1381 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1382 : m_libspdm_use_aead_algo;
1383 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1384 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1385 : data_size;
1386 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1387 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1388 : data, data_size);
1389 : #endif
1390 :
1391 1 : session_id = 0xFFFFFFFF;
1392 1 : session_info = &spdm_context->session_info[0];
1393 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1394 1 : libspdm_session_info_set_psk_hint(session_info,
1395 : LIBSPDM_TEST_PSK_HINT_STRING,
1396 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1397 1 : libspdm_secured_message_set_session_state(
1398 : session_info->secured_message_context,
1399 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1400 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1401 : ((libspdm_secured_message_context_t
1402 1 : *)(session_info->secured_message_context))
1403 : ->aead_key_size,
1404 : (uint8_t)(0xFF));
1405 1 : libspdm_secured_message_set_response_handshake_encryption_key(
1406 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1407 : ((libspdm_secured_message_context_t
1408 1 : *)(session_info->secured_message_context))
1409 : ->aead_key_size);
1410 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1411 : ((libspdm_secured_message_context_t
1412 1 : *)(session_info->secured_message_context))
1413 : ->aead_iv_size,
1414 : (uint8_t)(0xFF));
1415 1 : libspdm_secured_message_set_response_handshake_salt(
1416 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1417 : ((libspdm_secured_message_context_t
1418 1 : *)(session_info->secured_message_context))
1419 : ->aead_iv_size);
1420 : ((libspdm_secured_message_context_t *)(session_info
1421 1 : ->secured_message_context))
1422 1 : ->handshake_secret.response_handshake_sequence_number = 0;
1423 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1424 :
1425 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1426 1 : assert_int_equal(status, LIBSPDM_STATUS_BUSY_PEER);
1427 1 : free(data);
1428 1 : }
1429 :
1430 : /**
1431 : * Test 6: the requester is setup correctly, but, on the first try, receiving
1432 : * a Busy ERROR message, and, on retry, receiving a correct PSK_FINISH_RSP
1433 : * message.
1434 : * Expected behavior: client returns a Status of RETURN_SUCCESS and session
1435 : * is established.
1436 : **/
1437 1 : void libspdm_test_requester_psk_finish_case6(void **state)
1438 : {
1439 : libspdm_return_t status;
1440 : libspdm_test_context_t *spdm_test_context;
1441 : libspdm_context_t *spdm_context;
1442 : uint32_t session_id;
1443 : void *data;
1444 : size_t data_size;
1445 : void *hash;
1446 : size_t hash_size;
1447 : libspdm_session_info_t *session_info;
1448 :
1449 1 : spdm_test_context = *state;
1450 1 : spdm_context = spdm_test_context->spdm_context;
1451 1 : spdm_test_context->case_id = 0x6;
1452 1 : spdm_context->retry_times = 3;
1453 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1454 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1455 1 : spdm_context->connection_info.connection_state =
1456 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1457 1 : spdm_context->connection_info.capability.flags |=
1458 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1459 1 : spdm_context->connection_info.capability.flags |=
1460 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1461 1 : spdm_context->connection_info.capability.flags |=
1462 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1463 1 : spdm_context->local_context.capability.flags |=
1464 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1465 1 : spdm_context->local_context.capability.flags |=
1466 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1467 1 : spdm_context->local_context.capability.flags |=
1468 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1469 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1470 : m_libspdm_use_asym_algo, &data,
1471 : &data_size, &hash, &hash_size)) {
1472 0 : assert(false);
1473 : }
1474 1 : libspdm_reset_message_a(spdm_context);
1475 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1476 : m_libspdm_use_hash_algo;
1477 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1478 : m_libspdm_use_asym_algo;
1479 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1480 : m_libspdm_use_dhe_algo;
1481 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1482 : m_libspdm_use_aead_algo;
1483 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1484 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1485 : data_size;
1486 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1487 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1488 : data, data_size);
1489 : #endif
1490 :
1491 1 : session_id = 0xFFFFFFFF;
1492 1 : session_info = &spdm_context->session_info[0];
1493 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1494 1 : libspdm_session_info_set_psk_hint(session_info,
1495 : LIBSPDM_TEST_PSK_HINT_STRING,
1496 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1497 1 : libspdm_secured_message_set_session_state(
1498 : session_info->secured_message_context,
1499 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1500 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1501 : ((libspdm_secured_message_context_t
1502 1 : *)(session_info->secured_message_context))
1503 : ->aead_key_size,
1504 : (uint8_t)(0xFF));
1505 1 : libspdm_secured_message_set_response_handshake_encryption_key(
1506 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1507 : ((libspdm_secured_message_context_t
1508 1 : *)(session_info->secured_message_context))
1509 : ->aead_key_size);
1510 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1511 : ((libspdm_secured_message_context_t
1512 1 : *)(session_info->secured_message_context))
1513 : ->aead_iv_size,
1514 : (uint8_t)(0xFF));
1515 1 : libspdm_secured_message_set_response_handshake_salt(
1516 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1517 : ((libspdm_secured_message_context_t
1518 1 : *)(session_info->secured_message_context))
1519 : ->aead_iv_size);
1520 : ((libspdm_secured_message_context_t *)(session_info
1521 1 : ->secured_message_context))
1522 1 : ->handshake_secret.response_handshake_sequence_number = 0;
1523 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1524 :
1525 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1526 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1527 1 : assert_int_equal(
1528 : libspdm_secured_message_get_session_state(
1529 : spdm_context->session_info[0].secured_message_context),
1530 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1531 1 : free(data);
1532 1 : }
1533 :
1534 : /**
1535 : * Test 7: the requester is setup correctly, but receives an ERROR message
1536 : * indicating the RequestResynch status of the responder.
1537 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR, and the
1538 : * communication is reset to expect a new GET_VERSION message.
1539 : **/
1540 1 : void libspdm_test_requester_psk_finish_case7(void **state)
1541 : {
1542 : libspdm_return_t status;
1543 : libspdm_test_context_t *spdm_test_context;
1544 : libspdm_context_t *spdm_context;
1545 : uint32_t session_id;
1546 : void *data;
1547 : size_t data_size;
1548 : void *hash;
1549 : size_t hash_size;
1550 : libspdm_session_info_t *session_info;
1551 :
1552 1 : spdm_test_context = *state;
1553 1 : spdm_context = spdm_test_context->spdm_context;
1554 1 : spdm_test_context->case_id = 0x7;
1555 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1556 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1557 1 : spdm_context->connection_info.connection_state =
1558 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1559 1 : spdm_context->connection_info.capability.flags |=
1560 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1561 1 : spdm_context->connection_info.capability.flags |=
1562 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1563 1 : spdm_context->connection_info.capability.flags |=
1564 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1565 1 : spdm_context->local_context.capability.flags |=
1566 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1567 1 : spdm_context->local_context.capability.flags |=
1568 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1569 1 : spdm_context->local_context.capability.flags |=
1570 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1571 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1572 : m_libspdm_use_asym_algo, &data,
1573 : &data_size, &hash, &hash_size)) {
1574 0 : assert(false);
1575 : }
1576 1 : libspdm_reset_message_a(spdm_context);
1577 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1578 : m_libspdm_use_hash_algo;
1579 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1580 : m_libspdm_use_asym_algo;
1581 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1582 : m_libspdm_use_dhe_algo;
1583 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1584 : m_libspdm_use_aead_algo;
1585 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1586 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1587 : data_size;
1588 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1589 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1590 : data, data_size);
1591 : #endif
1592 :
1593 1 : session_id = 0xFFFFFFFF;
1594 1 : session_info = &spdm_context->session_info[0];
1595 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1596 1 : libspdm_session_info_set_psk_hint(session_info,
1597 : LIBSPDM_TEST_PSK_HINT_STRING,
1598 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1599 1 : libspdm_secured_message_set_session_state(
1600 : session_info->secured_message_context,
1601 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1602 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1603 : ((libspdm_secured_message_context_t
1604 1 : *)(session_info->secured_message_context))
1605 : ->aead_key_size,
1606 : (uint8_t)(0xFF));
1607 1 : libspdm_secured_message_set_response_handshake_encryption_key(
1608 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1609 : ((libspdm_secured_message_context_t
1610 1 : *)(session_info->secured_message_context))
1611 : ->aead_key_size);
1612 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1613 : ((libspdm_secured_message_context_t
1614 1 : *)(session_info->secured_message_context))
1615 : ->aead_iv_size,
1616 : (uint8_t)(0xFF));
1617 1 : libspdm_secured_message_set_response_handshake_salt(
1618 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1619 : ((libspdm_secured_message_context_t
1620 1 : *)(session_info->secured_message_context))
1621 : ->aead_iv_size);
1622 : ((libspdm_secured_message_context_t *)(session_info
1623 1 : ->secured_message_context))
1624 1 : ->handshake_secret.response_handshake_sequence_number = 0;
1625 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1626 :
1627 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1628 1 : assert_int_equal(status, LIBSPDM_STATUS_RESYNCH_PEER);
1629 1 : assert_int_equal(spdm_context->connection_info.connection_state,
1630 : LIBSPDM_CONNECTION_STATE_NOT_STARTED);
1631 1 : free(data);
1632 1 : }
1633 :
1634 : /**
1635 : * Test 8: the requester is setup correctly, but receives an ERROR message
1636 : * indicating the ResponseNotReady status of the responder.
1637 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR.
1638 : **/
1639 1 : void libspdm_test_requester_psk_finish_case8(void **state)
1640 : {
1641 : libspdm_return_t status;
1642 : libspdm_test_context_t *spdm_test_context;
1643 : libspdm_context_t *spdm_context;
1644 : uint32_t session_id;
1645 : void *data;
1646 : size_t data_size;
1647 : void *hash;
1648 : size_t hash_size;
1649 : libspdm_session_info_t *session_info;
1650 :
1651 1 : spdm_test_context = *state;
1652 1 : spdm_context = spdm_test_context->spdm_context;
1653 1 : spdm_test_context->case_id = 0x8;
1654 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1655 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1656 1 : spdm_context->connection_info.connection_state =
1657 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1658 1 : spdm_context->connection_info.capability.flags |=
1659 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1660 1 : spdm_context->connection_info.capability.flags |=
1661 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1662 1 : spdm_context->connection_info.capability.flags |=
1663 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1664 1 : spdm_context->local_context.capability.flags |=
1665 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1666 1 : spdm_context->local_context.capability.flags |=
1667 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1668 1 : spdm_context->local_context.capability.flags |=
1669 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1670 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1671 : m_libspdm_use_asym_algo, &data,
1672 : &data_size, &hash, &hash_size)) {
1673 0 : assert(false);
1674 : }
1675 1 : libspdm_reset_message_a(spdm_context);
1676 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1677 : m_libspdm_use_hash_algo;
1678 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1679 : m_libspdm_use_asym_algo;
1680 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1681 : m_libspdm_use_dhe_algo;
1682 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1683 : m_libspdm_use_aead_algo;
1684 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1685 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1686 : data_size;
1687 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1688 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1689 : data, data_size);
1690 : #endif
1691 :
1692 1 : session_id = 0xFFFFFFFF;
1693 1 : session_info = &spdm_context->session_info[0];
1694 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1695 1 : libspdm_session_info_set_psk_hint(session_info,
1696 : LIBSPDM_TEST_PSK_HINT_STRING,
1697 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1698 1 : libspdm_secured_message_set_session_state(
1699 : session_info->secured_message_context,
1700 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1701 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1702 : ((libspdm_secured_message_context_t
1703 1 : *)(session_info->secured_message_context))
1704 : ->aead_key_size,
1705 : (uint8_t)(0xFF));
1706 1 : libspdm_secured_message_set_response_handshake_encryption_key(
1707 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1708 : ((libspdm_secured_message_context_t
1709 1 : *)(session_info->secured_message_context))
1710 : ->aead_key_size);
1711 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1712 : ((libspdm_secured_message_context_t
1713 1 : *)(session_info->secured_message_context))
1714 : ->aead_iv_size,
1715 : (uint8_t)(0xFF));
1716 1 : libspdm_secured_message_set_response_handshake_salt(
1717 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1718 : ((libspdm_secured_message_context_t
1719 1 : *)(session_info->secured_message_context))
1720 : ->aead_iv_size);
1721 : ((libspdm_secured_message_context_t *)(session_info
1722 1 : ->secured_message_context))
1723 1 : ->handshake_secret.response_handshake_sequence_number = 0;
1724 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1725 :
1726 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1727 1 : assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
1728 1 : free(data);
1729 1 : }
1730 :
1731 : /**
1732 : * Test 9: the requester is setup correctly, but, on the first try, receiving
1733 : * a ResponseNotReady ERROR message, and, on retry, receiving a correct
1734 : * PSK_FINISH_RSP message.
1735 : * Expected behavior: client returns a Status of RETURN_SUCCESS and session
1736 : * is established.
1737 : **/
1738 1 : void libspdm_test_requester_psk_finish_case9(void **state)
1739 : {
1740 : libspdm_return_t status;
1741 : libspdm_test_context_t *spdm_test_context;
1742 : libspdm_context_t *spdm_context;
1743 : uint32_t session_id;
1744 : void *data;
1745 : size_t data_size;
1746 : void *hash;
1747 : size_t hash_size;
1748 : libspdm_session_info_t *session_info;
1749 :
1750 1 : spdm_test_context = *state;
1751 1 : spdm_context = spdm_test_context->spdm_context;
1752 1 : spdm_test_context->case_id = 0x9;
1753 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1754 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1755 1 : spdm_context->connection_info.connection_state =
1756 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1757 1 : spdm_context->connection_info.capability.flags |=
1758 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1759 1 : spdm_context->connection_info.capability.flags |=
1760 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1761 1 : spdm_context->connection_info.capability.flags |=
1762 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1763 1 : spdm_context->local_context.capability.flags |=
1764 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1765 1 : spdm_context->local_context.capability.flags |=
1766 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1767 1 : spdm_context->local_context.capability.flags |=
1768 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1769 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1770 : m_libspdm_use_asym_algo, &data,
1771 : &data_size, &hash, &hash_size)) {
1772 0 : assert(false);
1773 : }
1774 1 : libspdm_reset_message_a(spdm_context);
1775 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1776 : m_libspdm_use_hash_algo;
1777 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1778 : m_libspdm_use_asym_algo;
1779 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1780 : m_libspdm_use_dhe_algo;
1781 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1782 : m_libspdm_use_aead_algo;
1783 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1784 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1785 : data_size;
1786 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1787 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1788 : data, data_size);
1789 : #endif
1790 :
1791 1 : session_id = 0xFFFFFFFF;
1792 1 : session_info = &spdm_context->session_info[0];
1793 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1794 1 : libspdm_session_info_set_psk_hint(session_info,
1795 : LIBSPDM_TEST_PSK_HINT_STRING,
1796 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1797 1 : libspdm_secured_message_set_session_state(
1798 : session_info->secured_message_context,
1799 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1800 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1801 : ((libspdm_secured_message_context_t
1802 1 : *)(session_info->secured_message_context))
1803 : ->aead_key_size,
1804 : (uint8_t)(0xFF));
1805 1 : libspdm_secured_message_set_response_handshake_encryption_key(
1806 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1807 : ((libspdm_secured_message_context_t
1808 1 : *)(session_info->secured_message_context))
1809 : ->aead_key_size);
1810 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1811 : ((libspdm_secured_message_context_t
1812 1 : *)(session_info->secured_message_context))
1813 : ->aead_iv_size,
1814 : (uint8_t)(0xFF));
1815 1 : libspdm_secured_message_set_response_handshake_salt(
1816 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1817 : ((libspdm_secured_message_context_t
1818 1 : *)(session_info->secured_message_context))
1819 : ->aead_iv_size);
1820 : ((libspdm_secured_message_context_t *)(session_info
1821 1 : ->secured_message_context))
1822 1 : ->handshake_secret.response_handshake_sequence_number = 0;
1823 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1824 :
1825 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1826 : if (LIBSPDM_RESPOND_IF_READY_SUPPORT) {
1827 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1828 1 : assert_int_equal(
1829 : libspdm_secured_message_get_session_state(
1830 : spdm_context->session_info[0].secured_message_context),
1831 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1832 : } else {
1833 : assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
1834 : }
1835 :
1836 1 : free(data);
1837 1 : }
1838 :
1839 : /**
1840 : * Test 10: receiving an unexpected ERROR message from the responder.
1841 : * There are tests for all named codes, including some reserved ones
1842 : * (namely, 0x00, 0x0b, 0x0c, 0x3f, 0xfd, 0xfe).
1843 : * However, for having specific test cases, it is excluded from this case:
1844 : * Busy (0x03), ResponseNotReady (0x42), and RequestResync (0x43).
1845 : * Expected behavior: client returns a status of RETURN_DEVICE_ERROR.
1846 : **/
1847 1 : void libspdm_test_requester_psk_finish_case10(void **state) {
1848 : libspdm_return_t status;
1849 : libspdm_test_context_t *spdm_test_context;
1850 : libspdm_context_t *spdm_context;
1851 : uint32_t session_id;
1852 : void *data;
1853 : size_t data_size;
1854 : void *hash;
1855 : size_t hash_size;
1856 : libspdm_session_info_t *session_info;
1857 : uint16_t error_code;
1858 :
1859 1 : spdm_test_context = *state;
1860 1 : spdm_context = spdm_test_context->spdm_context;
1861 1 : spdm_test_context->case_id = 0xA;
1862 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1863 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1864 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1865 1 : spdm_context->connection_info.capability.flags |=
1866 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1867 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1868 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1869 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1870 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1871 1 : libspdm_read_responder_public_certificate_chain (m_libspdm_use_hash_algo,
1872 : m_libspdm_use_asym_algo,
1873 : &data, &data_size,
1874 : &hash, &hash_size);
1875 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1876 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1877 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1878 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1879 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1880 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1881 : data_size;
1882 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1883 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1884 : data, data_size);
1885 : #endif
1886 :
1887 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
1888 19 : while(error_code <= 0xff) {
1889 18 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1890 18 : libspdm_reset_message_a(spdm_context);
1891 :
1892 18 : session_id = 0xFFFFFFFF;
1893 18 : session_info = &spdm_context->session_info[0];
1894 18 : libspdm_session_info_init (spdm_context, session_info, session_id, true);
1895 18 : libspdm_session_info_set_psk_hint(session_info,
1896 : LIBSPDM_TEST_PSK_HINT_STRING,
1897 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1898 18 : libspdm_secured_message_set_session_state (session_info->secured_message_context,
1899 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1900 18 : libspdm_set_mem (m_libspdm_dummy_key_buffer,
1901 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->aead_key_size,
1902 : (uint8_t)(0xFF));
1903 18 : libspdm_secured_message_set_response_handshake_encryption_key (
1904 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1905 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->aead_key_size);
1906 18 : libspdm_set_mem (m_libspdm_dummy_salt_buffer,
1907 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->aead_iv_size,
1908 : (uint8_t)(0xFF));
1909 18 : libspdm_secured_message_set_response_handshake_salt (session_info->secured_message_context,
1910 : m_libspdm_dummy_salt_buffer,
1911 : ((libspdm_secured_message_context_t*)(
1912 18 : session_info->
1913 : secured_message_context))->aead_iv_size);
1914 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->
1915 : handshake_secret
1916 18 : .response_handshake_sequence_number = 0;
1917 18 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1918 :
1919 18 : status = libspdm_send_receive_psk_finish (spdm_context, session_id);
1920 18 : if(error_code != SPDM_ERROR_CODE_DECRYPT_ERROR) {
1921 17 : LIBSPDM_ASSERT_INT_EQUAL_CASE (status, LIBSPDM_STATUS_ERROR_PEER, error_code);
1922 : } else {
1923 1 : LIBSPDM_ASSERT_INT_EQUAL_CASE (status, LIBSPDM_STATUS_SESSION_MSG_ERROR, error_code);
1924 : }
1925 :
1926 18 : error_code++;
1927 18 : if(error_code == SPDM_ERROR_CODE_BUSY) { /*busy is treated in cases 5 and 6*/
1928 1 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
1929 : }
1930 18 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) { /*skip some reserved error codes (0d to 3e)*/
1931 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
1932 : }
1933 18 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) { /*skip response not ready, request resync, and some reserved codes (44 to fc)*/
1934 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
1935 : }
1936 : }
1937 :
1938 1 : free(data);
1939 1 : }
1940 :
1941 1 : void libspdm_test_requester_psk_finish_case11(void **state)
1942 : {
1943 : libspdm_return_t status;
1944 : libspdm_test_context_t *spdm_test_context;
1945 : libspdm_context_t *spdm_context;
1946 : uint32_t session_id;
1947 : void *data;
1948 : size_t data_size;
1949 : void *hash;
1950 : size_t hash_size;
1951 : libspdm_session_info_t *session_info;
1952 :
1953 1 : spdm_test_context = *state;
1954 1 : spdm_context = spdm_test_context->spdm_context;
1955 1 : spdm_test_context->case_id = 0xB;
1956 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1957 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1958 1 : spdm_context->connection_info.connection_state =
1959 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1960 1 : spdm_context->connection_info.capability.flags |=
1961 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1962 1 : spdm_context->connection_info.capability.flags |=
1963 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1964 1 : spdm_context->connection_info.capability.flags |=
1965 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1966 1 : spdm_context->local_context.capability.flags |=
1967 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1968 1 : spdm_context->local_context.capability.flags |=
1969 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1970 1 : spdm_context->local_context.capability.flags |=
1971 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1972 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1973 : m_libspdm_use_asym_algo, &data,
1974 : &data_size, &hash, &hash_size)) {
1975 0 : assert(false);
1976 : }
1977 1 : libspdm_reset_message_a(spdm_context);
1978 :
1979 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1980 : m_libspdm_use_hash_algo;
1981 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1982 : m_libspdm_use_asym_algo;
1983 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1984 : m_libspdm_use_dhe_algo;
1985 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1986 : m_libspdm_use_aead_algo;
1987 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1988 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1989 : data_size;
1990 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1991 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1992 : data, data_size);
1993 : #endif
1994 :
1995 1 : session_id = 0xFFFFFFFF;
1996 1 : session_info = &spdm_context->session_info[0];
1997 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1998 1 : libspdm_session_info_set_psk_hint(session_info,
1999 : LIBSPDM_TEST_PSK_HINT_STRING,
2000 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
2001 1 : libspdm_secured_message_set_session_state(
2002 : session_info->secured_message_context,
2003 : LIBSPDM_SESSION_STATE_HANDSHAKING);
2004 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
2005 : ((libspdm_secured_message_context_t
2006 1 : *)(session_info->secured_message_context))
2007 : ->aead_key_size,
2008 : (uint8_t)(0xFF));
2009 1 : libspdm_secured_message_set_response_handshake_encryption_key(
2010 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
2011 : ((libspdm_secured_message_context_t
2012 1 : *)(session_info->secured_message_context))
2013 : ->aead_key_size);
2014 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
2015 : ((libspdm_secured_message_context_t
2016 1 : *)(session_info->secured_message_context))
2017 : ->aead_iv_size,
2018 : (uint8_t)(0xFF));
2019 1 : libspdm_secured_message_set_response_handshake_salt(
2020 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
2021 : ((libspdm_secured_message_context_t
2022 1 : *)(session_info->secured_message_context))
2023 : ->aead_iv_size);
2024 : ((libspdm_secured_message_context_t *)(session_info
2025 1 : ->secured_message_context))
2026 1 : ->handshake_secret.response_handshake_sequence_number = 0;
2027 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
2028 :
2029 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2030 : session_info->session_transcript.message_m.buffer_size =
2031 : session_info->session_transcript.message_m.max_buffer_size;
2032 : spdm_context->transcript.message_b.buffer_size =
2033 : spdm_context->transcript.message_b.max_buffer_size;
2034 : spdm_context->transcript.message_c.buffer_size =
2035 : spdm_context->transcript.message_c.max_buffer_size;
2036 : spdm_context->transcript.message_mut_b.buffer_size =
2037 : spdm_context->transcript.message_mut_b.max_buffer_size;
2038 : spdm_context->transcript.message_mut_c.buffer_size =
2039 : spdm_context->transcript.message_mut_c.max_buffer_size;
2040 : #endif
2041 :
2042 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
2043 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2044 1 : assert_int_equal(
2045 : libspdm_secured_message_get_session_state(
2046 : spdm_context->session_info[0].secured_message_context),
2047 : LIBSPDM_SESSION_STATE_ESTABLISHED);
2048 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2049 : assert_int_equal(session_info->session_transcript.message_m.buffer_size, 0);
2050 : assert_int_equal(spdm_context->transcript.message_b.buffer_size, 0);
2051 : assert_int_equal(spdm_context->transcript.message_c.buffer_size, 0);
2052 : assert_int_equal(spdm_context->transcript.message_mut_b.buffer_size, 0);
2053 : assert_int_equal(spdm_context->transcript.message_mut_c.buffer_size, 0);
2054 : #endif
2055 1 : free(data);
2056 1 : }
2057 :
2058 : /**
2059 : * Test 12: requester is not setup correctly to support pre-shared keys
2060 : * (no capabilities). The responder would attempt to return a correct
2061 : * PSK_FINISH_RSP message.
2062 : * Expected behavior: client returns a Status of RETURN_UNSUPPORTED.
2063 : **/
2064 1 : void libspdm_test_requester_psk_finish_case12(void **state)
2065 : {
2066 : libspdm_return_t status;
2067 : libspdm_test_context_t *spdm_test_context;
2068 : libspdm_context_t *spdm_context;
2069 : uint32_t session_id;
2070 : void *data;
2071 : size_t data_size;
2072 : void *hash;
2073 : size_t hash_size;
2074 : libspdm_session_info_t *session_info;
2075 :
2076 1 : spdm_test_context = *state;
2077 1 : spdm_context = spdm_test_context->spdm_context;
2078 1 : spdm_test_context->case_id = 0xC;
2079 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
2080 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2081 1 : spdm_context->connection_info.connection_state =
2082 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
2083 : /*no PSK capabilities*/
2084 1 : spdm_context->connection_info.capability.flags &=
2085 : ~(SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP);
2086 1 : spdm_context->connection_info.capability.flags |=
2087 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2088 1 : spdm_context->connection_info.capability.flags |=
2089 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2090 1 : spdm_context->local_context.capability.flags |=
2091 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2092 1 : spdm_context->local_context.capability.flags |=
2093 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2094 1 : spdm_context->local_context.capability.flags |=
2095 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2096 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2097 : m_libspdm_use_asym_algo, &data,
2098 : &data_size, &hash, &hash_size)) {
2099 0 : assert(false);
2100 : }
2101 1 : spdm_context->transcript.message_a.buffer_size = 0;
2102 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2103 : m_libspdm_use_hash_algo;
2104 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2105 : m_libspdm_use_asym_algo;
2106 1 : spdm_context->connection_info.algorithm.dhe_named_group =
2107 : m_libspdm_use_dhe_algo;
2108 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
2109 : m_libspdm_use_aead_algo;
2110 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2111 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2112 : data_size;
2113 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2114 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2115 : data, data_size);
2116 : #endif
2117 :
2118 1 : session_id = 0xFFFFFFFF;
2119 1 : session_info = &spdm_context->session_info[0];
2120 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
2121 1 : libspdm_session_info_set_psk_hint(session_info,
2122 : LIBSPDM_TEST_PSK_HINT_STRING,
2123 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
2124 1 : libspdm_secured_message_set_session_state(
2125 : session_info->secured_message_context,
2126 : LIBSPDM_SESSION_STATE_HANDSHAKING);
2127 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
2128 : ((libspdm_secured_message_context_t
2129 1 : *)(session_info->secured_message_context))
2130 : ->aead_key_size,
2131 : (uint8_t)(0xFF));
2132 1 : libspdm_secured_message_set_response_handshake_encryption_key(
2133 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
2134 : ((libspdm_secured_message_context_t
2135 1 : *)(session_info->secured_message_context))
2136 : ->aead_key_size);
2137 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
2138 : ((libspdm_secured_message_context_t
2139 1 : *)(session_info->secured_message_context))
2140 : ->aead_iv_size,
2141 : (uint8_t)(0xFF));
2142 1 : libspdm_secured_message_set_response_handshake_salt(
2143 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
2144 : ((libspdm_secured_message_context_t
2145 1 : *)(session_info->secured_message_context))
2146 : ->aead_iv_size);
2147 : ((libspdm_secured_message_context_t *)(session_info
2148 1 : ->secured_message_context))
2149 1 : ->handshake_secret.response_handshake_sequence_number = 0;
2150 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
2151 :
2152 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
2153 1 : assert_int_equal(status, LIBSPDM_STATUS_UNSUPPORTED_CAP);
2154 1 : free(data);
2155 1 : }
2156 :
2157 : /**
2158 : * Test 13: receiving an incorrect FINISH_RSP message, with wrong response
2159 : * code, but all other field correct.
2160 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR.
2161 : **/
2162 1 : void libspdm_test_requester_psk_finish_case13(void **state)
2163 : {
2164 : libspdm_return_t status;
2165 : libspdm_test_context_t *spdm_test_context;
2166 : libspdm_context_t *spdm_context;
2167 : uint32_t session_id;
2168 : void *data;
2169 : size_t data_size;
2170 : void *hash;
2171 : size_t hash_size;
2172 : libspdm_session_info_t *session_info;
2173 :
2174 1 : spdm_test_context = *state;
2175 1 : spdm_context = spdm_test_context->spdm_context;
2176 1 : spdm_test_context->case_id = 0xD;
2177 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
2178 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2179 1 : spdm_context->connection_info.connection_state =
2180 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
2181 : /*no PSK capabilities*/
2182 1 : spdm_context->connection_info.capability.flags |=
2183 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2184 1 : spdm_context->connection_info.capability.flags |=
2185 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2186 1 : spdm_context->connection_info.capability.flags |=
2187 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2188 1 : spdm_context->local_context.capability.flags |=
2189 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2190 1 : spdm_context->local_context.capability.flags |=
2191 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2192 1 : spdm_context->local_context.capability.flags |=
2193 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2194 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2195 : m_libspdm_use_asym_algo, &data,
2196 : &data_size, &hash, &hash_size)) {
2197 0 : assert(false);
2198 : }
2199 1 : spdm_context->transcript.message_a.buffer_size = 0;
2200 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2201 : m_libspdm_use_hash_algo;
2202 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2203 : m_libspdm_use_asym_algo;
2204 1 : spdm_context->connection_info.algorithm.dhe_named_group =
2205 : m_libspdm_use_dhe_algo;
2206 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
2207 : m_libspdm_use_aead_algo;
2208 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2209 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2210 : data_size;
2211 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2212 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2213 : data, data_size);
2214 : #endif
2215 :
2216 1 : session_id = 0xFFFFFFFF;
2217 1 : session_info = &spdm_context->session_info[0];
2218 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
2219 1 : libspdm_session_info_set_psk_hint(session_info,
2220 : LIBSPDM_TEST_PSK_HINT_STRING,
2221 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
2222 1 : libspdm_secured_message_set_session_state(
2223 : session_info->secured_message_context,
2224 : LIBSPDM_SESSION_STATE_HANDSHAKING);
2225 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
2226 : ((libspdm_secured_message_context_t
2227 1 : *)(session_info->secured_message_context))
2228 : ->aead_key_size,
2229 : (uint8_t)(0xFF));
2230 1 : libspdm_secured_message_set_response_handshake_encryption_key(
2231 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
2232 : ((libspdm_secured_message_context_t
2233 1 : *)(session_info->secured_message_context))
2234 : ->aead_key_size);
2235 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
2236 : ((libspdm_secured_message_context_t
2237 1 : *)(session_info->secured_message_context))
2238 : ->aead_iv_size,
2239 : (uint8_t)(0xFF));
2240 1 : libspdm_secured_message_set_response_handshake_salt(
2241 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
2242 : ((libspdm_secured_message_context_t
2243 1 : *)(session_info->secured_message_context))
2244 : ->aead_iv_size);
2245 : ((libspdm_secured_message_context_t *)(session_info
2246 1 : ->secured_message_context))
2247 1 : ->handshake_secret.response_handshake_sequence_number = 0;
2248 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
2249 :
2250 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
2251 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
2252 1 : free(data);
2253 1 : }
2254 :
2255 : /**
2256 : * Test 14: requester is not setup correctly by not initializing a
2257 : * session during PSK_EXCHANGE. The responder would attempt to
2258 : * return a correct PSK_FINISH_RSP message.
2259 : * Expected behavior: client returns a Status of RETURN_UNSUPPORTED.
2260 : **/
2261 1 : void libspdm_test_requester_psk_finish_case14(void **state)
2262 : {
2263 : libspdm_return_t status;
2264 : libspdm_test_context_t *spdm_test_context;
2265 : libspdm_context_t *spdm_context;
2266 : uint32_t session_id;
2267 : void *data;
2268 : size_t data_size;
2269 : void *hash;
2270 : size_t hash_size;
2271 : libspdm_session_info_t *session_info;
2272 :
2273 1 : spdm_test_context = *state;
2274 1 : spdm_context = spdm_test_context->spdm_context;
2275 1 : spdm_test_context->case_id = 0xE;
2276 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
2277 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2278 1 : spdm_context->connection_info.connection_state =
2279 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
2280 : /*no PSK capabilities*/
2281 1 : spdm_context->connection_info.capability.flags |=
2282 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2283 1 : spdm_context->connection_info.capability.flags |=
2284 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2285 1 : spdm_context->connection_info.capability.flags |=
2286 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2287 1 : spdm_context->local_context.capability.flags |=
2288 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2289 1 : spdm_context->local_context.capability.flags |=
2290 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2291 1 : spdm_context->local_context.capability.flags |=
2292 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2293 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2294 : m_libspdm_use_asym_algo, &data,
2295 : &data_size, &hash, &hash_size)) {
2296 0 : assert(false);
2297 : }
2298 1 : spdm_context->transcript.message_a.buffer_size = 0;
2299 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2300 : m_libspdm_use_hash_algo;
2301 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2302 : m_libspdm_use_asym_algo;
2303 1 : spdm_context->connection_info.algorithm.dhe_named_group =
2304 : m_libspdm_use_dhe_algo;
2305 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
2306 : m_libspdm_use_aead_algo;
2307 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2308 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2309 : data_size;
2310 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2311 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2312 : data, data_size);
2313 : #endif
2314 :
2315 1 : session_id = 0xFFFFFFFF;
2316 1 : session_info = &spdm_context->session_info[0];
2317 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
2318 1 : libspdm_session_info_set_psk_hint(session_info,
2319 : LIBSPDM_TEST_PSK_HINT_STRING,
2320 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
2321 1 : libspdm_secured_message_set_session_state(
2322 : session_info->secured_message_context,
2323 : LIBSPDM_SESSION_STATE_NOT_STARTED);
2324 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
2325 : ((libspdm_secured_message_context_t
2326 1 : *)(session_info->secured_message_context))
2327 : ->aead_key_size,
2328 : (uint8_t)(0xFF));
2329 1 : libspdm_secured_message_set_response_handshake_encryption_key(
2330 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
2331 : ((libspdm_secured_message_context_t
2332 1 : *)(session_info->secured_message_context))
2333 : ->aead_key_size);
2334 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
2335 : ((libspdm_secured_message_context_t
2336 1 : *)(session_info->secured_message_context))
2337 : ->aead_iv_size,
2338 : (uint8_t)(0xFF));
2339 1 : libspdm_secured_message_set_response_handshake_salt(
2340 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
2341 : ((libspdm_secured_message_context_t
2342 1 : *)(session_info->secured_message_context))
2343 : ->aead_iv_size);
2344 : ((libspdm_secured_message_context_t *)(session_info
2345 1 : ->secured_message_context))
2346 1 : ->handshake_secret.response_handshake_sequence_number = 0;
2347 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
2348 :
2349 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
2350 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_STATE_LOCAL);
2351 1 : free(data);
2352 1 : }
2353 :
2354 : /**
2355 : * Test 15 the requester is setup correctly, but receives an ERROR with SPDM_ERROR_CODE_DECRYPT_ERROR.
2356 : * Expected behavior: client returns a Status of INVALID_SESSION_ID and free the session ID.
2357 : **/
2358 1 : void libspdm_test_requester_psk_finish_case15(void **state)
2359 : {
2360 : libspdm_return_t status;
2361 : libspdm_test_context_t *spdm_test_context;
2362 : libspdm_context_t *spdm_context;
2363 : uint32_t session_id;
2364 : void *data;
2365 : size_t data_size;
2366 : void *hash;
2367 : size_t hash_size;
2368 : libspdm_session_info_t *session_info;
2369 :
2370 1 : spdm_test_context = *state;
2371 1 : spdm_context = spdm_test_context->spdm_context;
2372 1 : spdm_test_context->case_id = 0xF;
2373 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
2374 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2375 1 : spdm_context->connection_info.connection_state =
2376 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
2377 1 : spdm_context->connection_info.capability.flags |=
2378 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2379 1 : spdm_context->connection_info.capability.flags |=
2380 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2381 1 : spdm_context->connection_info.capability.flags |=
2382 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2383 1 : spdm_context->local_context.capability.flags |=
2384 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2385 1 : spdm_context->local_context.capability.flags |=
2386 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2387 1 : spdm_context->local_context.capability.flags |=
2388 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2389 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2390 : m_libspdm_use_asym_algo, &data,
2391 : &data_size, &hash, &hash_size)) {
2392 0 : assert(false);
2393 : }
2394 1 : libspdm_reset_message_a(spdm_context);
2395 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2396 : m_libspdm_use_hash_algo;
2397 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2398 : m_libspdm_use_asym_algo;
2399 1 : spdm_context->connection_info.algorithm.dhe_named_group =
2400 : m_libspdm_use_dhe_algo;
2401 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
2402 : m_libspdm_use_aead_algo;
2403 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2404 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2405 : data_size;
2406 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2407 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2408 : data, data_size);
2409 : #endif
2410 :
2411 1 : session_id = 0xFFFFFFFF;
2412 1 : session_info = &spdm_context->session_info[0];
2413 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
2414 1 : libspdm_session_info_set_psk_hint(session_info,
2415 : LIBSPDM_TEST_PSK_HINT_STRING,
2416 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
2417 1 : libspdm_secured_message_set_session_state(
2418 : session_info->secured_message_context,
2419 : LIBSPDM_SESSION_STATE_HANDSHAKING);
2420 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
2421 : ((libspdm_secured_message_context_t
2422 1 : *)(session_info->secured_message_context))
2423 : ->aead_key_size,
2424 : (uint8_t)(0xFF));
2425 1 : libspdm_secured_message_set_response_handshake_encryption_key(
2426 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
2427 : ((libspdm_secured_message_context_t
2428 1 : *)(session_info->secured_message_context))
2429 : ->aead_key_size);
2430 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
2431 : ((libspdm_secured_message_context_t
2432 1 : *)(session_info->secured_message_context))
2433 : ->aead_iv_size,
2434 : (uint8_t)(0xFF));
2435 1 : libspdm_secured_message_set_response_handshake_salt(
2436 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
2437 : ((libspdm_secured_message_context_t
2438 1 : *)(session_info->secured_message_context))
2439 : ->aead_iv_size);
2440 : ((libspdm_secured_message_context_t *)(session_info
2441 1 : ->secured_message_context))
2442 1 : ->handshake_secret.response_handshake_sequence_number = 0;
2443 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
2444 :
2445 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
2446 1 : assert_int_equal(status, LIBSPDM_STATUS_SESSION_MSG_ERROR);
2447 1 : assert_int_equal(spdm_context->session_info->session_id, INVALID_SESSION_ID);
2448 1 : free(data);
2449 1 : }
2450 :
2451 : /**
2452 : * Test 16: a request message is successfully sent and a response message is successfully received.
2453 : * Expected Behavior: requester returns the status RETURN_SUCCESS and a PSK_FINISH_RSP message is
2454 : * received, buffer F appends the exchanged PSK_FINISH and PSK_FINISH_RSP messages.
2455 : **/
2456 1 : void libspdm_test_requester_psk_finish_case16(void **state)
2457 : {
2458 : libspdm_return_t status;
2459 : libspdm_test_context_t *spdm_test_context;
2460 : libspdm_context_t *spdm_context;
2461 : uint32_t session_id;
2462 : void *data;
2463 : size_t data_size;
2464 : void *hash;
2465 : size_t hash_size;
2466 : libspdm_session_info_t *session_info;
2467 :
2468 1 : spdm_test_context = *state;
2469 1 : spdm_context = spdm_test_context->spdm_context;
2470 1 : spdm_test_context->case_id = 0x10;
2471 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
2472 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2473 1 : spdm_context->connection_info.connection_state =
2474 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
2475 1 : spdm_context->connection_info.capability.flags |=
2476 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2477 1 : spdm_context->connection_info.capability.flags |=
2478 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2479 1 : spdm_context->connection_info.capability.flags |=
2480 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2481 1 : spdm_context->local_context.capability.flags |=
2482 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2483 1 : spdm_context->local_context.capability.flags |=
2484 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2485 1 : spdm_context->local_context.capability.flags |=
2486 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2487 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2488 : m_libspdm_use_asym_algo, &data,
2489 : &data_size, &hash, &hash_size)) {
2490 0 : assert(false);
2491 : }
2492 1 : libspdm_reset_message_a(spdm_context);
2493 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2494 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2495 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
2496 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
2497 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2498 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2499 : data_size;
2500 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2501 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2502 : data, data_size);
2503 : #endif
2504 :
2505 :
2506 1 : session_id = 0xFFFFFFFF;
2507 1 : session_info = &spdm_context->session_info[0];
2508 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
2509 1 : libspdm_session_info_set_psk_hint(session_info,
2510 : LIBSPDM_TEST_PSK_HINT_STRING,
2511 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
2512 1 : libspdm_secured_message_set_session_state(
2513 : session_info->secured_message_context,
2514 : LIBSPDM_SESSION_STATE_HANDSHAKING);
2515 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
2516 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
2517 : ->aead_key_size, (uint8_t)(0xFF));
2518 1 : libspdm_secured_message_set_response_handshake_encryption_key(
2519 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
2520 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
2521 : ->aead_key_size);
2522 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
2523 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
2524 : ->aead_iv_size, (uint8_t)(0xFF));
2525 1 : libspdm_secured_message_set_response_handshake_salt(
2526 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
2527 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
2528 : ->aead_iv_size);
2529 1 : ((libspdm_secured_message_context_t *)(session_info->secured_message_context))
2530 1 : ->handshake_secret.response_handshake_sequence_number = 0;
2531 1 : ((libspdm_secured_message_context_t *)(session_info->secured_message_context))
2532 1 : ->handshake_secret.request_handshake_sequence_number = 0;
2533 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
2534 :
2535 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
2536 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2537 1 : assert_int_equal(
2538 : libspdm_secured_message_get_session_state(
2539 : spdm_context->session_info[0].secured_message_context),
2540 : LIBSPDM_SESSION_STATE_ESTABLISHED);
2541 :
2542 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2543 : assert_int_equal(spdm_context->session_info[0].session_transcript.message_f.buffer_size,
2544 : m_libspdm_local_buffer_size);
2545 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "m_libspdm_local_buffer (0x%x):\n",
2546 : m_libspdm_local_buffer_size));
2547 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
2548 : assert_memory_equal(spdm_context->session_info[0].session_transcript.message_f.buffer,
2549 : m_libspdm_local_buffer, m_libspdm_local_buffer_size);
2550 : #endif
2551 1 : free(data);
2552 1 : }
2553 :
2554 : /**
2555 : * Test 17: SPDM version 1.4, with OpaqueData
2556 : * Expected Behavior: requester returns the status RETURN_SUCCESS and a PSK_FINISH_RSP message is
2557 : * received.
2558 : **/
2559 1 : void libspdm_test_requester_psk_finish_case17(void **state)
2560 : {
2561 : libspdm_return_t status;
2562 : libspdm_test_context_t *spdm_test_context;
2563 : libspdm_context_t *spdm_context;
2564 : uint32_t session_id;
2565 : void *data;
2566 : size_t data_size;
2567 : void *hash;
2568 : size_t hash_size;
2569 : libspdm_session_info_t *session_info;
2570 :
2571 1 : spdm_test_context = *state;
2572 1 : spdm_context = spdm_test_context->spdm_context;
2573 1 : spdm_test_context->case_id = 0x11;
2574 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_14 <<
2575 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2576 1 : spdm_context->connection_info.connection_state =
2577 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
2578 1 : spdm_context->connection_info.capability.flags |=
2579 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2580 1 : spdm_context->connection_info.capability.flags |=
2581 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2582 1 : spdm_context->connection_info.capability.flags |=
2583 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2584 1 : spdm_context->local_context.capability.flags |=
2585 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2586 1 : spdm_context->local_context.capability.flags |=
2587 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2588 1 : spdm_context->local_context.capability.flags |=
2589 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2590 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2591 : m_libspdm_use_asym_algo, &data,
2592 : &data_size, &hash, &hash_size)) {
2593 0 : assert(false);
2594 : }
2595 1 : libspdm_reset_message_a(spdm_context);
2596 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2597 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2598 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
2599 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
2600 :
2601 1 : session_id = 0xFFFFFFFF;
2602 1 : session_info = &spdm_context->session_info[0];
2603 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
2604 1 : libspdm_session_info_set_psk_hint(session_info,
2605 : LIBSPDM_TEST_PSK_HINT_STRING,
2606 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
2607 1 : libspdm_secured_message_set_session_state(
2608 : session_info->secured_message_context,
2609 : LIBSPDM_SESSION_STATE_HANDSHAKING);
2610 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
2611 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
2612 : ->aead_key_size, (uint8_t)(0xFF));
2613 1 : libspdm_secured_message_set_response_handshake_encryption_key(
2614 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
2615 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
2616 : ->aead_key_size);
2617 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
2618 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
2619 : ->aead_iv_size, (uint8_t)(0xFF));
2620 1 : libspdm_secured_message_set_response_handshake_salt(
2621 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
2622 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
2623 : ->aead_iv_size);
2624 1 : ((libspdm_secured_message_context_t *)(session_info->secured_message_context))
2625 1 : ->handshake_secret.response_handshake_sequence_number = 0;
2626 1 : ((libspdm_secured_message_context_t *)(session_info->secured_message_context))
2627 1 : ->handshake_secret.request_handshake_sequence_number = 0;
2628 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
2629 :
2630 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
2631 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2632 1 : assert_int_equal(
2633 : libspdm_secured_message_get_session_state(
2634 : spdm_context->session_info[0].secured_message_context),
2635 : LIBSPDM_SESSION_STATE_ESTABLISHED);
2636 :
2637 1 : free(data);
2638 1 : }
2639 :
2640 1 : int libspdm_requester_psk_finish_test_main(void)
2641 : {
2642 1 : const struct CMUnitTest spdm_requester_psk_finish_tests[] = {
2643 : /* SendRequest failed*/
2644 : cmocka_unit_test(libspdm_test_requester_psk_finish_case1),
2645 : /* Successful response*/
2646 : cmocka_unit_test(libspdm_test_requester_psk_finish_case2),
2647 : /* connection_state check failed*/
2648 : cmocka_unit_test(libspdm_test_requester_psk_finish_case3),
2649 : /* Error response: SPDM_ERROR_CODE_INVALID_REQUEST*/
2650 : cmocka_unit_test(libspdm_test_requester_psk_finish_case4),
2651 : /* Always SPDM_ERROR_CODE_BUSY*/
2652 : cmocka_unit_test(libspdm_test_requester_psk_finish_case5),
2653 : /* SPDM_ERROR_CODE_BUSY + Successful response*/
2654 : cmocka_unit_test(libspdm_test_requester_psk_finish_case6),
2655 : /* Error response: SPDM_ERROR_CODE_REQUEST_RESYNCH*/
2656 : cmocka_unit_test(libspdm_test_requester_psk_finish_case7),
2657 : /* Always SPDM_ERROR_CODE_RESPONSE_NOT_READY*/
2658 : cmocka_unit_test(libspdm_test_requester_psk_finish_case8),
2659 : /* SPDM_ERROR_CODE_RESPONSE_NOT_READY + Successful response*/
2660 : cmocka_unit_test(libspdm_test_requester_psk_finish_case9),
2661 : /* Unexpected errors*/
2662 : cmocka_unit_test(libspdm_test_requester_psk_finish_case10),
2663 : /* Buffer reset*/
2664 : cmocka_unit_test(libspdm_test_requester_psk_finish_case11),
2665 : /* No correct setup*/
2666 : cmocka_unit_test(libspdm_test_requester_psk_finish_case12),
2667 : /* Wrong response code*/
2668 : cmocka_unit_test(libspdm_test_requester_psk_finish_case13),
2669 : /* Uninitialized session*/
2670 : cmocka_unit_test(libspdm_test_requester_psk_finish_case14),
2671 : /* Error response: SPDM_ERROR_CODE_DECRYPT_ERROR*/
2672 : cmocka_unit_test(libspdm_test_requester_psk_finish_case15),
2673 : /* Buffer verification*/
2674 : cmocka_unit_test(libspdm_test_requester_psk_finish_case16),
2675 : /* SPDM 1.4 with OpaqueData */
2676 : cmocka_unit_test(libspdm_test_requester_psk_finish_case17),
2677 : };
2678 :
2679 1 : libspdm_test_context_t test_context = {
2680 : LIBSPDM_TEST_CONTEXT_VERSION,
2681 : true,
2682 : libspdm_requester_psk_finish_test_send_message,
2683 : libspdm_requester_psk_finish_test_receive_message,
2684 : };
2685 :
2686 1 : libspdm_setup_test_context(&test_context);
2687 :
2688 1 : return cmocka_run_group_tests(spdm_requester_psk_finish_tests,
2689 : libspdm_unit_test_group_setup,
2690 : libspdm_unit_test_group_teardown);
2691 : }
2692 :
2693 : #endif /* LIBSPDM_ENABLE_CAPABILITY_PSK_CAP*/
|
