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 : 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 1 : libspdm_reset_message_a(spdm_context);
1003 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1004 : m_libspdm_use_hash_algo;
1005 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1006 : m_libspdm_use_asym_algo;
1007 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1008 : m_libspdm_use_dhe_algo;
1009 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1010 : m_libspdm_use_aead_algo;
1011 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1012 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1013 : data_size;
1014 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1015 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1016 : data, data_size);
1017 : #endif
1018 :
1019 1 : session_id = 0xFFFFFFFF;
1020 1 : session_info = &spdm_context->session_info[0];
1021 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1022 1 : libspdm_session_info_set_psk_hint(session_info,
1023 : LIBSPDM_TEST_PSK_HINT_STRING,
1024 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1025 1 : libspdm_secured_message_set_session_state(
1026 : session_info->secured_message_context,
1027 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1028 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1029 :
1030 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1031 1 : assert_int_equal(status, LIBSPDM_STATUS_SEND_FAIL);
1032 1 : free(data);
1033 1 : }
1034 :
1035 : /**
1036 : * Test 2: receiving a correct PSK_FINISH_RSP message.
1037 : * Expected behavior: client returns a Status of RETURN_SUCCESS and
1038 : * session is established.
1039 : **/
1040 1 : void libspdm_test_requester_psk_finish_case2(void **state)
1041 : {
1042 : libspdm_return_t status;
1043 : libspdm_test_context_t *spdm_test_context;
1044 : libspdm_context_t *spdm_context;
1045 : uint32_t session_id;
1046 : void *data;
1047 : size_t data_size;
1048 : void *hash;
1049 : size_t hash_size;
1050 : libspdm_session_info_t *session_info;
1051 :
1052 1 : spdm_test_context = *state;
1053 1 : spdm_context = spdm_test_context->spdm_context;
1054 1 : spdm_test_context->case_id = 0x2;
1055 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1056 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1057 1 : spdm_context->connection_info.connection_state =
1058 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1059 1 : spdm_context->connection_info.capability.flags |=
1060 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1061 1 : spdm_context->connection_info.capability.flags |=
1062 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1063 1 : spdm_context->connection_info.capability.flags |=
1064 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1065 1 : spdm_context->local_context.capability.flags |=
1066 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1067 1 : spdm_context->local_context.capability.flags |=
1068 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1069 1 : spdm_context->local_context.capability.flags |=
1070 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1071 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1072 : m_libspdm_use_asym_algo, &data,
1073 : &data_size, &hash, &hash_size);
1074 1 : libspdm_reset_message_a(spdm_context);
1075 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1076 : m_libspdm_use_hash_algo;
1077 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1078 : m_libspdm_use_asym_algo;
1079 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1080 : m_libspdm_use_dhe_algo;
1081 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1082 : m_libspdm_use_aead_algo;
1083 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1084 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1085 : data_size;
1086 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1087 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1088 : data, data_size);
1089 : #endif
1090 :
1091 1 : session_id = 0xFFFFFFFF;
1092 1 : session_info = &spdm_context->session_info[0];
1093 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1094 1 : libspdm_session_info_set_psk_hint(session_info,
1095 : LIBSPDM_TEST_PSK_HINT_STRING,
1096 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1097 1 : libspdm_secured_message_set_session_state(
1098 : session_info->secured_message_context,
1099 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1100 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1101 : ((libspdm_secured_message_context_t
1102 1 : *)(session_info->secured_message_context))
1103 : ->aead_key_size,
1104 : (uint8_t)(0xFF));
1105 1 : libspdm_secured_message_set_response_handshake_encryption_key(
1106 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1107 : ((libspdm_secured_message_context_t
1108 1 : *)(session_info->secured_message_context))
1109 : ->aead_key_size);
1110 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1111 : ((libspdm_secured_message_context_t
1112 1 : *)(session_info->secured_message_context))
1113 : ->aead_iv_size,
1114 : (uint8_t)(0xFF));
1115 1 : libspdm_secured_message_set_response_handshake_salt(
1116 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1117 : ((libspdm_secured_message_context_t
1118 1 : *)(session_info->secured_message_context))
1119 : ->aead_iv_size);
1120 : ((libspdm_secured_message_context_t *)(session_info
1121 1 : ->secured_message_context))
1122 1 : ->handshake_secret.response_handshake_sequence_number = 0;
1123 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1124 :
1125 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1126 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1127 1 : assert_int_equal(
1128 : libspdm_secured_message_get_session_state(
1129 : spdm_context->session_info[0].secured_message_context),
1130 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1131 1 : free(data);
1132 1 : }
1133 :
1134 : /**
1135 : * Test 3: requester state has not been negotiated, as if GET_VERSION,
1136 : * GET_CAPABILITIES and NEGOTIATE_ALGORITHMS had not been exchanged.
1137 : * Expected behavior: client returns a Status of RETURN_UNSUPPORTED.
1138 : **/
1139 1 : void libspdm_test_requester_psk_finish_case3(void **state)
1140 : {
1141 : libspdm_return_t status;
1142 : libspdm_test_context_t *spdm_test_context;
1143 : libspdm_context_t *spdm_context;
1144 : uint32_t session_id;
1145 : void *data;
1146 : size_t data_size;
1147 : void *hash;
1148 : size_t hash_size;
1149 : libspdm_session_info_t *session_info;
1150 :
1151 1 : spdm_test_context = *state;
1152 1 : spdm_context = spdm_test_context->spdm_context;
1153 1 : spdm_test_context->case_id = 0x3;
1154 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1155 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1156 1 : spdm_context->connection_info.connection_state =
1157 : LIBSPDM_CONNECTION_STATE_NOT_STARTED;
1158 1 : spdm_context->connection_info.capability.flags |=
1159 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1160 1 : spdm_context->connection_info.capability.flags |=
1161 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1162 1 : spdm_context->connection_info.capability.flags |=
1163 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1164 1 : spdm_context->local_context.capability.flags |=
1165 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1166 1 : spdm_context->local_context.capability.flags |=
1167 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1168 1 : spdm_context->local_context.capability.flags |=
1169 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1170 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1171 : m_libspdm_use_asym_algo, &data,
1172 : &data_size, &hash, &hash_size);
1173 1 : libspdm_reset_message_a(spdm_context);
1174 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1175 : m_libspdm_use_hash_algo;
1176 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1177 : m_libspdm_use_asym_algo;
1178 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1179 : m_libspdm_use_dhe_algo;
1180 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1181 : m_libspdm_use_aead_algo;
1182 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1183 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1184 : data_size;
1185 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1186 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1187 : data, data_size);
1188 : #endif
1189 :
1190 1 : session_id = 0xFFFFFFFF;
1191 1 : session_info = &spdm_context->session_info[0];
1192 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1193 1 : libspdm_session_info_set_psk_hint(session_info,
1194 : LIBSPDM_TEST_PSK_HINT_STRING,
1195 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1196 1 : libspdm_secured_message_set_session_state(
1197 : session_info->secured_message_context,
1198 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1199 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1200 : ((libspdm_secured_message_context_t
1201 1 : *)(session_info->secured_message_context))
1202 : ->aead_key_size,
1203 : (uint8_t)(0xFF));
1204 1 : libspdm_secured_message_set_response_handshake_encryption_key(
1205 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1206 : ((libspdm_secured_message_context_t
1207 1 : *)(session_info->secured_message_context))
1208 : ->aead_key_size);
1209 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1210 : ((libspdm_secured_message_context_t
1211 1 : *)(session_info->secured_message_context))
1212 : ->aead_iv_size,
1213 : (uint8_t)(0xFF));
1214 1 : libspdm_secured_message_set_response_handshake_salt(
1215 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1216 : ((libspdm_secured_message_context_t
1217 1 : *)(session_info->secured_message_context))
1218 : ->aead_iv_size);
1219 : ((libspdm_secured_message_context_t *)(session_info
1220 1 : ->secured_message_context))
1221 1 : ->handshake_secret.response_handshake_sequence_number = 0;
1222 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1223 :
1224 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1225 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_STATE_LOCAL);
1226 1 : free(data);
1227 1 : }
1228 :
1229 : /**
1230 : * Test 4: the requester is setup correctly, but receives an ERROR message
1231 : * indicating InvalidParameters.
1232 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR.
1233 : **/
1234 1 : void libspdm_test_requester_psk_finish_case4(void **state)
1235 : {
1236 : libspdm_return_t status;
1237 : libspdm_test_context_t *spdm_test_context;
1238 : libspdm_context_t *spdm_context;
1239 : uint32_t session_id;
1240 : void *data;
1241 : size_t data_size;
1242 : void *hash;
1243 : size_t hash_size;
1244 : libspdm_session_info_t *session_info;
1245 :
1246 1 : spdm_test_context = *state;
1247 1 : spdm_context = spdm_test_context->spdm_context;
1248 1 : spdm_test_context->case_id = 0x4;
1249 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1250 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1251 1 : spdm_context->connection_info.connection_state =
1252 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1253 1 : spdm_context->connection_info.capability.flags |=
1254 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1255 1 : spdm_context->connection_info.capability.flags |=
1256 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1257 1 : spdm_context->connection_info.capability.flags |=
1258 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1259 1 : spdm_context->local_context.capability.flags |=
1260 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1261 1 : spdm_context->local_context.capability.flags |=
1262 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1263 1 : spdm_context->local_context.capability.flags |=
1264 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1265 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1266 : m_libspdm_use_asym_algo, &data,
1267 : &data_size, &hash, &hash_size);
1268 1 : libspdm_reset_message_a(spdm_context);
1269 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1270 : m_libspdm_use_hash_algo;
1271 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1272 : m_libspdm_use_asym_algo;
1273 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1274 : m_libspdm_use_dhe_algo;
1275 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1276 : m_libspdm_use_aead_algo;
1277 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1278 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1279 : data_size;
1280 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1281 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1282 : data, data_size);
1283 : #endif
1284 :
1285 1 : session_id = 0xFFFFFFFF;
1286 1 : session_info = &spdm_context->session_info[0];
1287 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1288 1 : libspdm_session_info_set_psk_hint(session_info,
1289 : LIBSPDM_TEST_PSK_HINT_STRING,
1290 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1291 1 : libspdm_secured_message_set_session_state(
1292 : session_info->secured_message_context,
1293 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1294 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1295 : ((libspdm_secured_message_context_t
1296 1 : *)(session_info->secured_message_context))
1297 : ->aead_key_size,
1298 : (uint8_t)(0xFF));
1299 1 : libspdm_secured_message_set_response_handshake_encryption_key(
1300 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1301 : ((libspdm_secured_message_context_t
1302 1 : *)(session_info->secured_message_context))
1303 : ->aead_key_size);
1304 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1305 : ((libspdm_secured_message_context_t
1306 1 : *)(session_info->secured_message_context))
1307 : ->aead_iv_size,
1308 : (uint8_t)(0xFF));
1309 1 : libspdm_secured_message_set_response_handshake_salt(
1310 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1311 : ((libspdm_secured_message_context_t
1312 1 : *)(session_info->secured_message_context))
1313 : ->aead_iv_size);
1314 : ((libspdm_secured_message_context_t *)(session_info
1315 1 : ->secured_message_context))
1316 1 : ->handshake_secret.response_handshake_sequence_number = 0;
1317 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1318 :
1319 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1320 1 : assert_int_equal(status, LIBSPDM_STATUS_ERROR_PEER);
1321 1 : assert_int_equal(spdm_context->session_info->session_id, INVALID_SESSION_ID);
1322 1 : free(data);
1323 1 : }
1324 :
1325 : /**
1326 : * Test 5: the requester is setup correctly, but receives an ERROR message
1327 : * indicating the Busy status of the responder.
1328 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR.
1329 : **/
1330 1 : void libspdm_test_requester_psk_finish_case5(void **state)
1331 : {
1332 : libspdm_return_t status;
1333 : libspdm_test_context_t *spdm_test_context;
1334 : libspdm_context_t *spdm_context;
1335 : uint32_t session_id;
1336 : void *data;
1337 : size_t data_size;
1338 : void *hash;
1339 : size_t hash_size;
1340 : libspdm_session_info_t *session_info;
1341 :
1342 1 : spdm_test_context = *state;
1343 1 : spdm_context = spdm_test_context->spdm_context;
1344 1 : spdm_test_context->case_id = 0x5;
1345 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1346 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1347 1 : spdm_context->connection_info.connection_state =
1348 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1349 1 : spdm_context->connection_info.capability.flags |=
1350 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1351 1 : spdm_context->connection_info.capability.flags |=
1352 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1353 1 : spdm_context->connection_info.capability.flags |=
1354 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1355 1 : spdm_context->local_context.capability.flags |=
1356 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1357 1 : spdm_context->local_context.capability.flags |=
1358 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1359 1 : spdm_context->local_context.capability.flags |=
1360 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1361 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1362 : m_libspdm_use_asym_algo, &data,
1363 : &data_size, &hash, &hash_size);
1364 1 : libspdm_reset_message_a(spdm_context);
1365 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1366 : m_libspdm_use_hash_algo;
1367 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1368 : m_libspdm_use_asym_algo;
1369 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1370 : m_libspdm_use_dhe_algo;
1371 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1372 : m_libspdm_use_aead_algo;
1373 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1374 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1375 : data_size;
1376 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1377 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1378 : data, data_size);
1379 : #endif
1380 :
1381 1 : session_id = 0xFFFFFFFF;
1382 1 : session_info = &spdm_context->session_info[0];
1383 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1384 1 : libspdm_session_info_set_psk_hint(session_info,
1385 : LIBSPDM_TEST_PSK_HINT_STRING,
1386 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1387 1 : libspdm_secured_message_set_session_state(
1388 : session_info->secured_message_context,
1389 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1390 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1391 : ((libspdm_secured_message_context_t
1392 1 : *)(session_info->secured_message_context))
1393 : ->aead_key_size,
1394 : (uint8_t)(0xFF));
1395 1 : libspdm_secured_message_set_response_handshake_encryption_key(
1396 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1397 : ((libspdm_secured_message_context_t
1398 1 : *)(session_info->secured_message_context))
1399 : ->aead_key_size);
1400 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1401 : ((libspdm_secured_message_context_t
1402 1 : *)(session_info->secured_message_context))
1403 : ->aead_iv_size,
1404 : (uint8_t)(0xFF));
1405 1 : libspdm_secured_message_set_response_handshake_salt(
1406 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1407 : ((libspdm_secured_message_context_t
1408 1 : *)(session_info->secured_message_context))
1409 : ->aead_iv_size);
1410 : ((libspdm_secured_message_context_t *)(session_info
1411 1 : ->secured_message_context))
1412 1 : ->handshake_secret.response_handshake_sequence_number = 0;
1413 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1414 :
1415 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1416 1 : assert_int_equal(status, LIBSPDM_STATUS_BUSY_PEER);
1417 1 : free(data);
1418 1 : }
1419 :
1420 : /**
1421 : * Test 6: the requester is setup correctly, but, on the first try, receiving
1422 : * a Busy ERROR message, and, on retry, receiving a correct PSK_FINISH_RSP
1423 : * message.
1424 : * Expected behavior: client returns a Status of RETURN_SUCCESS and session
1425 : * is established.
1426 : **/
1427 1 : void libspdm_test_requester_psk_finish_case6(void **state)
1428 : {
1429 : libspdm_return_t status;
1430 : libspdm_test_context_t *spdm_test_context;
1431 : libspdm_context_t *spdm_context;
1432 : uint32_t session_id;
1433 : void *data;
1434 : size_t data_size;
1435 : void *hash;
1436 : size_t hash_size;
1437 : libspdm_session_info_t *session_info;
1438 :
1439 1 : spdm_test_context = *state;
1440 1 : spdm_context = spdm_test_context->spdm_context;
1441 1 : spdm_test_context->case_id = 0x6;
1442 1 : spdm_context->retry_times = 3;
1443 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1444 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1445 1 : spdm_context->connection_info.connection_state =
1446 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1447 1 : spdm_context->connection_info.capability.flags |=
1448 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1449 1 : spdm_context->connection_info.capability.flags |=
1450 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1451 1 : spdm_context->connection_info.capability.flags |=
1452 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1453 1 : spdm_context->local_context.capability.flags |=
1454 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1455 1 : spdm_context->local_context.capability.flags |=
1456 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1457 1 : spdm_context->local_context.capability.flags |=
1458 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1459 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1460 : m_libspdm_use_asym_algo, &data,
1461 : &data_size, &hash, &hash_size);
1462 1 : libspdm_reset_message_a(spdm_context);
1463 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1464 : m_libspdm_use_hash_algo;
1465 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1466 : m_libspdm_use_asym_algo;
1467 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1468 : m_libspdm_use_dhe_algo;
1469 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1470 : m_libspdm_use_aead_algo;
1471 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1472 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1473 : data_size;
1474 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1475 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1476 : data, data_size);
1477 : #endif
1478 :
1479 1 : session_id = 0xFFFFFFFF;
1480 1 : session_info = &spdm_context->session_info[0];
1481 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1482 1 : libspdm_session_info_set_psk_hint(session_info,
1483 : LIBSPDM_TEST_PSK_HINT_STRING,
1484 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1485 1 : libspdm_secured_message_set_session_state(
1486 : session_info->secured_message_context,
1487 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1488 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1489 : ((libspdm_secured_message_context_t
1490 1 : *)(session_info->secured_message_context))
1491 : ->aead_key_size,
1492 : (uint8_t)(0xFF));
1493 1 : libspdm_secured_message_set_response_handshake_encryption_key(
1494 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1495 : ((libspdm_secured_message_context_t
1496 1 : *)(session_info->secured_message_context))
1497 : ->aead_key_size);
1498 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1499 : ((libspdm_secured_message_context_t
1500 1 : *)(session_info->secured_message_context))
1501 : ->aead_iv_size,
1502 : (uint8_t)(0xFF));
1503 1 : libspdm_secured_message_set_response_handshake_salt(
1504 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1505 : ((libspdm_secured_message_context_t
1506 1 : *)(session_info->secured_message_context))
1507 : ->aead_iv_size);
1508 : ((libspdm_secured_message_context_t *)(session_info
1509 1 : ->secured_message_context))
1510 1 : ->handshake_secret.response_handshake_sequence_number = 0;
1511 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1512 :
1513 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1514 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1515 1 : assert_int_equal(
1516 : libspdm_secured_message_get_session_state(
1517 : spdm_context->session_info[0].secured_message_context),
1518 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1519 1 : free(data);
1520 1 : }
1521 :
1522 : /**
1523 : * Test 7: the requester is setup correctly, but receives an ERROR message
1524 : * indicating the RequestResynch status of the responder.
1525 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR, and the
1526 : * communication is reset to expect a new GET_VERSION message.
1527 : **/
1528 1 : void libspdm_test_requester_psk_finish_case7(void **state)
1529 : {
1530 : libspdm_return_t status;
1531 : libspdm_test_context_t *spdm_test_context;
1532 : libspdm_context_t *spdm_context;
1533 : uint32_t session_id;
1534 : void *data;
1535 : size_t data_size;
1536 : void *hash;
1537 : size_t hash_size;
1538 : libspdm_session_info_t *session_info;
1539 :
1540 1 : spdm_test_context = *state;
1541 1 : spdm_context = spdm_test_context->spdm_context;
1542 1 : spdm_test_context->case_id = 0x7;
1543 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1544 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1545 1 : spdm_context->connection_info.connection_state =
1546 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1547 1 : spdm_context->connection_info.capability.flags |=
1548 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1549 1 : spdm_context->connection_info.capability.flags |=
1550 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1551 1 : spdm_context->connection_info.capability.flags |=
1552 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1553 1 : spdm_context->local_context.capability.flags |=
1554 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1555 1 : spdm_context->local_context.capability.flags |=
1556 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1557 1 : spdm_context->local_context.capability.flags |=
1558 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1559 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1560 : m_libspdm_use_asym_algo, &data,
1561 : &data_size, &hash, &hash_size);
1562 1 : libspdm_reset_message_a(spdm_context);
1563 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1564 : m_libspdm_use_hash_algo;
1565 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1566 : m_libspdm_use_asym_algo;
1567 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1568 : m_libspdm_use_dhe_algo;
1569 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1570 : m_libspdm_use_aead_algo;
1571 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1572 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1573 : data_size;
1574 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1575 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1576 : data, data_size);
1577 : #endif
1578 :
1579 1 : session_id = 0xFFFFFFFF;
1580 1 : session_info = &spdm_context->session_info[0];
1581 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1582 1 : libspdm_session_info_set_psk_hint(session_info,
1583 : LIBSPDM_TEST_PSK_HINT_STRING,
1584 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1585 1 : libspdm_secured_message_set_session_state(
1586 : session_info->secured_message_context,
1587 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1588 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1589 : ((libspdm_secured_message_context_t
1590 1 : *)(session_info->secured_message_context))
1591 : ->aead_key_size,
1592 : (uint8_t)(0xFF));
1593 1 : libspdm_secured_message_set_response_handshake_encryption_key(
1594 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1595 : ((libspdm_secured_message_context_t
1596 1 : *)(session_info->secured_message_context))
1597 : ->aead_key_size);
1598 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1599 : ((libspdm_secured_message_context_t
1600 1 : *)(session_info->secured_message_context))
1601 : ->aead_iv_size,
1602 : (uint8_t)(0xFF));
1603 1 : libspdm_secured_message_set_response_handshake_salt(
1604 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1605 : ((libspdm_secured_message_context_t
1606 1 : *)(session_info->secured_message_context))
1607 : ->aead_iv_size);
1608 : ((libspdm_secured_message_context_t *)(session_info
1609 1 : ->secured_message_context))
1610 1 : ->handshake_secret.response_handshake_sequence_number = 0;
1611 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1612 :
1613 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1614 1 : assert_int_equal(status, LIBSPDM_STATUS_RESYNCH_PEER);
1615 1 : assert_int_equal(spdm_context->connection_info.connection_state,
1616 : LIBSPDM_CONNECTION_STATE_NOT_STARTED);
1617 1 : free(data);
1618 1 : }
1619 :
1620 : /**
1621 : * Test 8: the requester is setup correctly, but receives an ERROR message
1622 : * indicating the ResponseNotReady status of the responder.
1623 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR.
1624 : **/
1625 1 : void libspdm_test_requester_psk_finish_case8(void **state)
1626 : {
1627 : libspdm_return_t status;
1628 : libspdm_test_context_t *spdm_test_context;
1629 : libspdm_context_t *spdm_context;
1630 : uint32_t session_id;
1631 : void *data;
1632 : size_t data_size;
1633 : void *hash;
1634 : size_t hash_size;
1635 : libspdm_session_info_t *session_info;
1636 :
1637 1 : spdm_test_context = *state;
1638 1 : spdm_context = spdm_test_context->spdm_context;
1639 1 : spdm_test_context->case_id = 0x8;
1640 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1641 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1642 1 : spdm_context->connection_info.connection_state =
1643 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1644 1 : spdm_context->connection_info.capability.flags |=
1645 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1646 1 : spdm_context->connection_info.capability.flags |=
1647 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1648 1 : spdm_context->connection_info.capability.flags |=
1649 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1650 1 : spdm_context->local_context.capability.flags |=
1651 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1652 1 : spdm_context->local_context.capability.flags |=
1653 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1654 1 : spdm_context->local_context.capability.flags |=
1655 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1656 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1657 : m_libspdm_use_asym_algo, &data,
1658 : &data_size, &hash, &hash_size);
1659 1 : libspdm_reset_message_a(spdm_context);
1660 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1661 : m_libspdm_use_hash_algo;
1662 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1663 : m_libspdm_use_asym_algo;
1664 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1665 : m_libspdm_use_dhe_algo;
1666 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1667 : m_libspdm_use_aead_algo;
1668 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1669 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1670 : data_size;
1671 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1672 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1673 : data, data_size);
1674 : #endif
1675 :
1676 1 : session_id = 0xFFFFFFFF;
1677 1 : session_info = &spdm_context->session_info[0];
1678 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1679 1 : libspdm_session_info_set_psk_hint(session_info,
1680 : LIBSPDM_TEST_PSK_HINT_STRING,
1681 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1682 1 : libspdm_secured_message_set_session_state(
1683 : session_info->secured_message_context,
1684 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1685 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1686 : ((libspdm_secured_message_context_t
1687 1 : *)(session_info->secured_message_context))
1688 : ->aead_key_size,
1689 : (uint8_t)(0xFF));
1690 1 : libspdm_secured_message_set_response_handshake_encryption_key(
1691 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1692 : ((libspdm_secured_message_context_t
1693 1 : *)(session_info->secured_message_context))
1694 : ->aead_key_size);
1695 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1696 : ((libspdm_secured_message_context_t
1697 1 : *)(session_info->secured_message_context))
1698 : ->aead_iv_size,
1699 : (uint8_t)(0xFF));
1700 1 : libspdm_secured_message_set_response_handshake_salt(
1701 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1702 : ((libspdm_secured_message_context_t
1703 1 : *)(session_info->secured_message_context))
1704 : ->aead_iv_size);
1705 : ((libspdm_secured_message_context_t *)(session_info
1706 1 : ->secured_message_context))
1707 1 : ->handshake_secret.response_handshake_sequence_number = 0;
1708 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1709 :
1710 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1711 1 : assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
1712 1 : free(data);
1713 1 : }
1714 :
1715 : /**
1716 : * Test 9: the requester is setup correctly, but, on the first try, receiving
1717 : * a ResponseNotReady ERROR message, and, on retry, receiving a correct
1718 : * PSK_FINISH_RSP message.
1719 : * Expected behavior: client returns a Status of RETURN_SUCCESS and session
1720 : * is established.
1721 : **/
1722 1 : void libspdm_test_requester_psk_finish_case9(void **state)
1723 : {
1724 : libspdm_return_t status;
1725 : libspdm_test_context_t *spdm_test_context;
1726 : libspdm_context_t *spdm_context;
1727 : uint32_t session_id;
1728 : void *data;
1729 : size_t data_size;
1730 : void *hash;
1731 : size_t hash_size;
1732 : libspdm_session_info_t *session_info;
1733 :
1734 1 : spdm_test_context = *state;
1735 1 : spdm_context = spdm_test_context->spdm_context;
1736 1 : spdm_test_context->case_id = 0x9;
1737 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1738 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1739 1 : spdm_context->connection_info.connection_state =
1740 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1741 1 : spdm_context->connection_info.capability.flags |=
1742 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1743 1 : spdm_context->connection_info.capability.flags |=
1744 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1745 1 : spdm_context->connection_info.capability.flags |=
1746 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1747 1 : spdm_context->local_context.capability.flags |=
1748 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1749 1 : spdm_context->local_context.capability.flags |=
1750 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1751 1 : spdm_context->local_context.capability.flags |=
1752 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1753 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1754 : m_libspdm_use_asym_algo, &data,
1755 : &data_size, &hash, &hash_size);
1756 1 : libspdm_reset_message_a(spdm_context);
1757 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1758 : m_libspdm_use_hash_algo;
1759 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1760 : m_libspdm_use_asym_algo;
1761 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1762 : m_libspdm_use_dhe_algo;
1763 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1764 : m_libspdm_use_aead_algo;
1765 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1766 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1767 : data_size;
1768 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1769 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1770 : data, data_size);
1771 : #endif
1772 :
1773 1 : session_id = 0xFFFFFFFF;
1774 1 : session_info = &spdm_context->session_info[0];
1775 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1776 1 : libspdm_session_info_set_psk_hint(session_info,
1777 : LIBSPDM_TEST_PSK_HINT_STRING,
1778 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1779 1 : libspdm_secured_message_set_session_state(
1780 : session_info->secured_message_context,
1781 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1782 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1783 : ((libspdm_secured_message_context_t
1784 1 : *)(session_info->secured_message_context))
1785 : ->aead_key_size,
1786 : (uint8_t)(0xFF));
1787 1 : libspdm_secured_message_set_response_handshake_encryption_key(
1788 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1789 : ((libspdm_secured_message_context_t
1790 1 : *)(session_info->secured_message_context))
1791 : ->aead_key_size);
1792 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1793 : ((libspdm_secured_message_context_t
1794 1 : *)(session_info->secured_message_context))
1795 : ->aead_iv_size,
1796 : (uint8_t)(0xFF));
1797 1 : libspdm_secured_message_set_response_handshake_salt(
1798 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
1799 : ((libspdm_secured_message_context_t
1800 1 : *)(session_info->secured_message_context))
1801 : ->aead_iv_size);
1802 : ((libspdm_secured_message_context_t *)(session_info
1803 1 : ->secured_message_context))
1804 1 : ->handshake_secret.response_handshake_sequence_number = 0;
1805 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1806 :
1807 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
1808 : if (LIBSPDM_RESPOND_IF_READY_SUPPORT) {
1809 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1810 1 : assert_int_equal(
1811 : libspdm_secured_message_get_session_state(
1812 : spdm_context->session_info[0].secured_message_context),
1813 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1814 : } else {
1815 : assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
1816 : }
1817 :
1818 1 : free(data);
1819 1 : }
1820 :
1821 : /**
1822 : * Test 10: receiving an unexpected ERROR message from the responder.
1823 : * There are tests for all named codes, including some reserved ones
1824 : * (namely, 0x00, 0x0b, 0x0c, 0x3f, 0xfd, 0xfe).
1825 : * However, for having specific test cases, it is excluded from this case:
1826 : * Busy (0x03), ResponseNotReady (0x42), and RequestResync (0x43).
1827 : * Expected behavior: client returns a status of RETURN_DEVICE_ERROR.
1828 : **/
1829 1 : void libspdm_test_requester_psk_finish_case10(void **state) {
1830 : libspdm_return_t status;
1831 : libspdm_test_context_t *spdm_test_context;
1832 : libspdm_context_t *spdm_context;
1833 : uint32_t session_id;
1834 : void *data;
1835 : size_t data_size;
1836 : void *hash;
1837 : size_t hash_size;
1838 : libspdm_session_info_t *session_info;
1839 : uint16_t error_code;
1840 :
1841 1 : spdm_test_context = *state;
1842 1 : spdm_context = spdm_test_context->spdm_context;
1843 1 : spdm_test_context->case_id = 0xA;
1844 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1845 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1846 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1847 1 : spdm_context->connection_info.capability.flags |=
1848 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1849 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1850 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1851 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1852 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1853 1 : libspdm_read_responder_public_certificate_chain (m_libspdm_use_hash_algo,
1854 : m_libspdm_use_asym_algo,
1855 : &data, &data_size,
1856 : &hash, &hash_size);
1857 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1858 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1859 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1860 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1861 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1862 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1863 : data_size;
1864 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1865 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1866 : data, data_size);
1867 : #endif
1868 :
1869 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
1870 19 : while(error_code <= 0xff) {
1871 18 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1872 18 : libspdm_reset_message_a(spdm_context);
1873 :
1874 18 : session_id = 0xFFFFFFFF;
1875 18 : session_info = &spdm_context->session_info[0];
1876 18 : libspdm_session_info_init (spdm_context, session_info, session_id, true);
1877 18 : libspdm_session_info_set_psk_hint(session_info,
1878 : LIBSPDM_TEST_PSK_HINT_STRING,
1879 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1880 18 : libspdm_secured_message_set_session_state (session_info->secured_message_context,
1881 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1882 18 : libspdm_set_mem (m_libspdm_dummy_key_buffer,
1883 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->aead_key_size,
1884 : (uint8_t)(0xFF));
1885 18 : libspdm_secured_message_set_response_handshake_encryption_key (
1886 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1887 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->aead_key_size);
1888 18 : libspdm_set_mem (m_libspdm_dummy_salt_buffer,
1889 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->aead_iv_size,
1890 : (uint8_t)(0xFF));
1891 18 : libspdm_secured_message_set_response_handshake_salt (session_info->secured_message_context,
1892 : m_libspdm_dummy_salt_buffer,
1893 : ((libspdm_secured_message_context_t*)(
1894 18 : session_info->
1895 : secured_message_context))->aead_iv_size);
1896 18 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))->
1897 : handshake_secret
1898 18 : .response_handshake_sequence_number = 0;
1899 18 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
1900 :
1901 18 : status = libspdm_send_receive_psk_finish (spdm_context, session_id);
1902 18 : if(error_code != SPDM_ERROR_CODE_DECRYPT_ERROR) {
1903 17 : LIBSPDM_ASSERT_INT_EQUAL_CASE (status, LIBSPDM_STATUS_ERROR_PEER, error_code);
1904 : } else {
1905 1 : LIBSPDM_ASSERT_INT_EQUAL_CASE (status, LIBSPDM_STATUS_SESSION_MSG_ERROR, error_code);
1906 : }
1907 :
1908 18 : error_code++;
1909 18 : if(error_code == SPDM_ERROR_CODE_BUSY) { /*busy is treated in cases 5 and 6*/
1910 1 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
1911 : }
1912 18 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) { /*skip some reserved error codes (0d to 3e)*/
1913 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
1914 : }
1915 18 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) { /*skip response not ready, request resync, and some reserved codes (44 to fc)*/
1916 1 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
1917 : }
1918 : }
1919 :
1920 1 : free(data);
1921 1 : }
1922 :
1923 1 : void libspdm_test_requester_psk_finish_case11(void **state)
1924 : {
1925 : libspdm_return_t status;
1926 : libspdm_test_context_t *spdm_test_context;
1927 : libspdm_context_t *spdm_context;
1928 : uint32_t session_id;
1929 : void *data;
1930 : size_t data_size;
1931 : void *hash;
1932 : size_t hash_size;
1933 : libspdm_session_info_t *session_info;
1934 :
1935 1 : spdm_test_context = *state;
1936 1 : spdm_context = spdm_test_context->spdm_context;
1937 1 : spdm_test_context->case_id = 0xB;
1938 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1939 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1940 1 : spdm_context->connection_info.connection_state =
1941 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1942 1 : spdm_context->connection_info.capability.flags |=
1943 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1944 1 : spdm_context->connection_info.capability.flags |=
1945 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1946 1 : spdm_context->connection_info.capability.flags |=
1947 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1948 1 : spdm_context->local_context.capability.flags |=
1949 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1950 1 : spdm_context->local_context.capability.flags |=
1951 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1952 1 : spdm_context->local_context.capability.flags |=
1953 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1954 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1955 : m_libspdm_use_asym_algo, &data,
1956 : &data_size, &hash, &hash_size);
1957 1 : libspdm_reset_message_a(spdm_context);
1958 :
1959 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1960 : m_libspdm_use_hash_algo;
1961 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1962 : m_libspdm_use_asym_algo;
1963 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1964 : m_libspdm_use_dhe_algo;
1965 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1966 : m_libspdm_use_aead_algo;
1967 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1968 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
1969 : data_size;
1970 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
1971 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
1972 : data, data_size);
1973 : #endif
1974 :
1975 1 : session_id = 0xFFFFFFFF;
1976 1 : session_info = &spdm_context->session_info[0];
1977 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1978 1 : libspdm_session_info_set_psk_hint(session_info,
1979 : LIBSPDM_TEST_PSK_HINT_STRING,
1980 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
1981 1 : libspdm_secured_message_set_session_state(
1982 : session_info->secured_message_context,
1983 : LIBSPDM_SESSION_STATE_HANDSHAKING);
1984 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
1985 : ((libspdm_secured_message_context_t
1986 1 : *)(session_info->secured_message_context))
1987 : ->aead_key_size,
1988 : (uint8_t)(0xFF));
1989 1 : libspdm_secured_message_set_response_handshake_encryption_key(
1990 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
1991 : ((libspdm_secured_message_context_t
1992 1 : *)(session_info->secured_message_context))
1993 : ->aead_key_size);
1994 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
1995 : ((libspdm_secured_message_context_t
1996 1 : *)(session_info->secured_message_context))
1997 : ->aead_iv_size,
1998 : (uint8_t)(0xFF));
1999 1 : libspdm_secured_message_set_response_handshake_salt(
2000 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
2001 : ((libspdm_secured_message_context_t
2002 1 : *)(session_info->secured_message_context))
2003 : ->aead_iv_size);
2004 : ((libspdm_secured_message_context_t *)(session_info
2005 1 : ->secured_message_context))
2006 1 : ->handshake_secret.response_handshake_sequence_number = 0;
2007 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
2008 :
2009 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2010 : session_info->session_transcript.message_m.buffer_size =
2011 : session_info->session_transcript.message_m.max_buffer_size;
2012 : spdm_context->transcript.message_b.buffer_size =
2013 : spdm_context->transcript.message_b.max_buffer_size;
2014 : spdm_context->transcript.message_c.buffer_size =
2015 : spdm_context->transcript.message_c.max_buffer_size;
2016 : spdm_context->transcript.message_mut_b.buffer_size =
2017 : spdm_context->transcript.message_mut_b.max_buffer_size;
2018 : spdm_context->transcript.message_mut_c.buffer_size =
2019 : spdm_context->transcript.message_mut_c.max_buffer_size;
2020 : #endif
2021 :
2022 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
2023 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2024 1 : assert_int_equal(
2025 : libspdm_secured_message_get_session_state(
2026 : spdm_context->session_info[0].secured_message_context),
2027 : LIBSPDM_SESSION_STATE_ESTABLISHED);
2028 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2029 : assert_int_equal(session_info->session_transcript.message_m.buffer_size, 0);
2030 : assert_int_equal(spdm_context->transcript.message_b.buffer_size, 0);
2031 : assert_int_equal(spdm_context->transcript.message_c.buffer_size, 0);
2032 : assert_int_equal(spdm_context->transcript.message_mut_b.buffer_size, 0);
2033 : assert_int_equal(spdm_context->transcript.message_mut_c.buffer_size, 0);
2034 : #endif
2035 1 : free(data);
2036 1 : }
2037 :
2038 : /**
2039 : * Test 12: requester is not setup correctly to support pre-shared keys
2040 : * (no capabilities). The responder would attempt to return a correct
2041 : * PSK_FINISH_RSP message.
2042 : * Expected behavior: client returns a Status of RETURN_UNSUPPORTED.
2043 : **/
2044 1 : void libspdm_test_requester_psk_finish_case12(void **state)
2045 : {
2046 : libspdm_return_t status;
2047 : libspdm_test_context_t *spdm_test_context;
2048 : libspdm_context_t *spdm_context;
2049 : uint32_t session_id;
2050 : void *data;
2051 : size_t data_size;
2052 : void *hash;
2053 : size_t hash_size;
2054 : libspdm_session_info_t *session_info;
2055 :
2056 1 : spdm_test_context = *state;
2057 1 : spdm_context = spdm_test_context->spdm_context;
2058 1 : spdm_test_context->case_id = 0xC;
2059 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
2060 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2061 1 : spdm_context->connection_info.connection_state =
2062 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
2063 : /*no PSK capabilities*/
2064 1 : spdm_context->connection_info.capability.flags &=
2065 : ~(SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP);
2066 1 : spdm_context->connection_info.capability.flags |=
2067 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2068 1 : spdm_context->connection_info.capability.flags |=
2069 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2070 1 : spdm_context->local_context.capability.flags |=
2071 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2072 1 : spdm_context->local_context.capability.flags |=
2073 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2074 1 : spdm_context->local_context.capability.flags |=
2075 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2076 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2077 : m_libspdm_use_asym_algo, &data,
2078 : &data_size, &hash, &hash_size);
2079 1 : spdm_context->transcript.message_a.buffer_size = 0;
2080 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2081 : m_libspdm_use_hash_algo;
2082 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2083 : m_libspdm_use_asym_algo;
2084 1 : spdm_context->connection_info.algorithm.dhe_named_group =
2085 : m_libspdm_use_dhe_algo;
2086 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
2087 : m_libspdm_use_aead_algo;
2088 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2089 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2090 : data_size;
2091 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2092 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2093 : data, data_size);
2094 : #endif
2095 :
2096 1 : session_id = 0xFFFFFFFF;
2097 1 : session_info = &spdm_context->session_info[0];
2098 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
2099 1 : libspdm_session_info_set_psk_hint(session_info,
2100 : LIBSPDM_TEST_PSK_HINT_STRING,
2101 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
2102 1 : libspdm_secured_message_set_session_state(
2103 : session_info->secured_message_context,
2104 : LIBSPDM_SESSION_STATE_HANDSHAKING);
2105 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
2106 : ((libspdm_secured_message_context_t
2107 1 : *)(session_info->secured_message_context))
2108 : ->aead_key_size,
2109 : (uint8_t)(0xFF));
2110 1 : libspdm_secured_message_set_response_handshake_encryption_key(
2111 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
2112 : ((libspdm_secured_message_context_t
2113 1 : *)(session_info->secured_message_context))
2114 : ->aead_key_size);
2115 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
2116 : ((libspdm_secured_message_context_t
2117 1 : *)(session_info->secured_message_context))
2118 : ->aead_iv_size,
2119 : (uint8_t)(0xFF));
2120 1 : libspdm_secured_message_set_response_handshake_salt(
2121 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
2122 : ((libspdm_secured_message_context_t
2123 1 : *)(session_info->secured_message_context))
2124 : ->aead_iv_size);
2125 : ((libspdm_secured_message_context_t *)(session_info
2126 1 : ->secured_message_context))
2127 1 : ->handshake_secret.response_handshake_sequence_number = 0;
2128 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
2129 :
2130 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
2131 1 : assert_int_equal(status, LIBSPDM_STATUS_UNSUPPORTED_CAP);
2132 1 : free(data);
2133 1 : }
2134 :
2135 : /**
2136 : * Test 13: receiving an incorrect FINISH_RSP message, with wrong response
2137 : * code, but all other field correct.
2138 : * Expected behavior: client returns a Status of RETURN_DEVICE_ERROR.
2139 : **/
2140 1 : void libspdm_test_requester_psk_finish_case13(void **state)
2141 : {
2142 : libspdm_return_t status;
2143 : libspdm_test_context_t *spdm_test_context;
2144 : libspdm_context_t *spdm_context;
2145 : uint32_t session_id;
2146 : void *data;
2147 : size_t data_size;
2148 : void *hash;
2149 : size_t hash_size;
2150 : libspdm_session_info_t *session_info;
2151 :
2152 1 : spdm_test_context = *state;
2153 1 : spdm_context = spdm_test_context->spdm_context;
2154 1 : spdm_test_context->case_id = 0xD;
2155 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
2156 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2157 1 : spdm_context->connection_info.connection_state =
2158 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
2159 : /*no PSK capabilities*/
2160 1 : spdm_context->connection_info.capability.flags |=
2161 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2162 1 : spdm_context->connection_info.capability.flags |=
2163 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2164 1 : spdm_context->connection_info.capability.flags |=
2165 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2166 1 : spdm_context->local_context.capability.flags |=
2167 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2168 1 : spdm_context->local_context.capability.flags |=
2169 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2170 1 : spdm_context->local_context.capability.flags |=
2171 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2172 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2173 : m_libspdm_use_asym_algo, &data,
2174 : &data_size, &hash, &hash_size);
2175 1 : spdm_context->transcript.message_a.buffer_size = 0;
2176 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2177 : m_libspdm_use_hash_algo;
2178 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2179 : m_libspdm_use_asym_algo;
2180 1 : spdm_context->connection_info.algorithm.dhe_named_group =
2181 : m_libspdm_use_dhe_algo;
2182 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
2183 : m_libspdm_use_aead_algo;
2184 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2185 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2186 : data_size;
2187 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2188 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2189 : data, data_size);
2190 : #endif
2191 :
2192 1 : session_id = 0xFFFFFFFF;
2193 1 : session_info = &spdm_context->session_info[0];
2194 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
2195 1 : libspdm_session_info_set_psk_hint(session_info,
2196 : LIBSPDM_TEST_PSK_HINT_STRING,
2197 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
2198 1 : libspdm_secured_message_set_session_state(
2199 : session_info->secured_message_context,
2200 : LIBSPDM_SESSION_STATE_HANDSHAKING);
2201 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
2202 : ((libspdm_secured_message_context_t
2203 1 : *)(session_info->secured_message_context))
2204 : ->aead_key_size,
2205 : (uint8_t)(0xFF));
2206 1 : libspdm_secured_message_set_response_handshake_encryption_key(
2207 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
2208 : ((libspdm_secured_message_context_t
2209 1 : *)(session_info->secured_message_context))
2210 : ->aead_key_size);
2211 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
2212 : ((libspdm_secured_message_context_t
2213 1 : *)(session_info->secured_message_context))
2214 : ->aead_iv_size,
2215 : (uint8_t)(0xFF));
2216 1 : libspdm_secured_message_set_response_handshake_salt(
2217 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
2218 : ((libspdm_secured_message_context_t
2219 1 : *)(session_info->secured_message_context))
2220 : ->aead_iv_size);
2221 : ((libspdm_secured_message_context_t *)(session_info
2222 1 : ->secured_message_context))
2223 1 : ->handshake_secret.response_handshake_sequence_number = 0;
2224 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
2225 :
2226 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
2227 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
2228 1 : free(data);
2229 1 : }
2230 :
2231 : /**
2232 : * Test 14: requester is not setup correctly by not initializing a
2233 : * session during PSK_EXCHANGE. The responder would attempt to
2234 : * return a correct PSK_FINISH_RSP message.
2235 : * Expected behavior: client returns a Status of RETURN_UNSUPPORTED.
2236 : **/
2237 1 : void libspdm_test_requester_psk_finish_case14(void **state)
2238 : {
2239 : libspdm_return_t status;
2240 : libspdm_test_context_t *spdm_test_context;
2241 : libspdm_context_t *spdm_context;
2242 : uint32_t session_id;
2243 : void *data;
2244 : size_t data_size;
2245 : void *hash;
2246 : size_t hash_size;
2247 : libspdm_session_info_t *session_info;
2248 :
2249 1 : spdm_test_context = *state;
2250 1 : spdm_context = spdm_test_context->spdm_context;
2251 1 : spdm_test_context->case_id = 0xE;
2252 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
2253 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2254 1 : spdm_context->connection_info.connection_state =
2255 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
2256 : /*no PSK capabilities*/
2257 1 : spdm_context->connection_info.capability.flags |=
2258 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2259 1 : spdm_context->connection_info.capability.flags |=
2260 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2261 1 : spdm_context->connection_info.capability.flags |=
2262 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2263 1 : spdm_context->local_context.capability.flags |=
2264 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2265 1 : spdm_context->local_context.capability.flags |=
2266 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2267 1 : spdm_context->local_context.capability.flags |=
2268 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2269 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2270 : m_libspdm_use_asym_algo, &data,
2271 : &data_size, &hash, &hash_size);
2272 1 : spdm_context->transcript.message_a.buffer_size = 0;
2273 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2274 : m_libspdm_use_hash_algo;
2275 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2276 : m_libspdm_use_asym_algo;
2277 1 : spdm_context->connection_info.algorithm.dhe_named_group =
2278 : m_libspdm_use_dhe_algo;
2279 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
2280 : m_libspdm_use_aead_algo;
2281 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2282 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2283 : data_size;
2284 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2285 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2286 : data, data_size);
2287 : #endif
2288 :
2289 1 : session_id = 0xFFFFFFFF;
2290 1 : session_info = &spdm_context->session_info[0];
2291 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
2292 1 : libspdm_session_info_set_psk_hint(session_info,
2293 : LIBSPDM_TEST_PSK_HINT_STRING,
2294 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
2295 1 : libspdm_secured_message_set_session_state(
2296 : session_info->secured_message_context,
2297 : LIBSPDM_SESSION_STATE_NOT_STARTED);
2298 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
2299 : ((libspdm_secured_message_context_t
2300 1 : *)(session_info->secured_message_context))
2301 : ->aead_key_size,
2302 : (uint8_t)(0xFF));
2303 1 : libspdm_secured_message_set_response_handshake_encryption_key(
2304 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
2305 : ((libspdm_secured_message_context_t
2306 1 : *)(session_info->secured_message_context))
2307 : ->aead_key_size);
2308 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
2309 : ((libspdm_secured_message_context_t
2310 1 : *)(session_info->secured_message_context))
2311 : ->aead_iv_size,
2312 : (uint8_t)(0xFF));
2313 1 : libspdm_secured_message_set_response_handshake_salt(
2314 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
2315 : ((libspdm_secured_message_context_t
2316 1 : *)(session_info->secured_message_context))
2317 : ->aead_iv_size);
2318 : ((libspdm_secured_message_context_t *)(session_info
2319 1 : ->secured_message_context))
2320 1 : ->handshake_secret.response_handshake_sequence_number = 0;
2321 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
2322 :
2323 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
2324 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_STATE_LOCAL);
2325 1 : free(data);
2326 1 : }
2327 :
2328 : /**
2329 : * Test 15 the requester is setup correctly, but receives an ERROR with SPDM_ERROR_CODE_DECRYPT_ERROR.
2330 : * Expected behavior: client returns a Status of INVALID_SESSION_ID and free the session ID.
2331 : **/
2332 1 : void libspdm_test_requester_psk_finish_case15(void **state)
2333 : {
2334 : libspdm_return_t status;
2335 : libspdm_test_context_t *spdm_test_context;
2336 : libspdm_context_t *spdm_context;
2337 : uint32_t session_id;
2338 : void *data;
2339 : size_t data_size;
2340 : void *hash;
2341 : size_t hash_size;
2342 : libspdm_session_info_t *session_info;
2343 :
2344 1 : spdm_test_context = *state;
2345 1 : spdm_context = spdm_test_context->spdm_context;
2346 1 : spdm_test_context->case_id = 0xF;
2347 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
2348 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2349 1 : spdm_context->connection_info.connection_state =
2350 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
2351 1 : spdm_context->connection_info.capability.flags |=
2352 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2353 1 : spdm_context->connection_info.capability.flags |=
2354 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2355 1 : spdm_context->connection_info.capability.flags |=
2356 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2357 1 : spdm_context->local_context.capability.flags |=
2358 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2359 1 : spdm_context->local_context.capability.flags |=
2360 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2361 1 : spdm_context->local_context.capability.flags |=
2362 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2363 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2364 : m_libspdm_use_asym_algo, &data,
2365 : &data_size, &hash, &hash_size);
2366 1 : libspdm_reset_message_a(spdm_context);
2367 1 : spdm_context->connection_info.algorithm.base_hash_algo =
2368 : m_libspdm_use_hash_algo;
2369 1 : spdm_context->connection_info.algorithm.base_asym_algo =
2370 : m_libspdm_use_asym_algo;
2371 1 : spdm_context->connection_info.algorithm.dhe_named_group =
2372 : m_libspdm_use_dhe_algo;
2373 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
2374 : m_libspdm_use_aead_algo;
2375 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2376 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2377 : data_size;
2378 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2379 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2380 : data, data_size);
2381 : #endif
2382 :
2383 1 : session_id = 0xFFFFFFFF;
2384 1 : session_info = &spdm_context->session_info[0];
2385 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
2386 1 : libspdm_session_info_set_psk_hint(session_info,
2387 : LIBSPDM_TEST_PSK_HINT_STRING,
2388 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
2389 1 : libspdm_secured_message_set_session_state(
2390 : session_info->secured_message_context,
2391 : LIBSPDM_SESSION_STATE_HANDSHAKING);
2392 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
2393 : ((libspdm_secured_message_context_t
2394 1 : *)(session_info->secured_message_context))
2395 : ->aead_key_size,
2396 : (uint8_t)(0xFF));
2397 1 : libspdm_secured_message_set_response_handshake_encryption_key(
2398 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
2399 : ((libspdm_secured_message_context_t
2400 1 : *)(session_info->secured_message_context))
2401 : ->aead_key_size);
2402 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
2403 : ((libspdm_secured_message_context_t
2404 1 : *)(session_info->secured_message_context))
2405 : ->aead_iv_size,
2406 : (uint8_t)(0xFF));
2407 1 : libspdm_secured_message_set_response_handshake_salt(
2408 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
2409 : ((libspdm_secured_message_context_t
2410 1 : *)(session_info->secured_message_context))
2411 : ->aead_iv_size);
2412 : ((libspdm_secured_message_context_t *)(session_info
2413 1 : ->secured_message_context))
2414 1 : ->handshake_secret.response_handshake_sequence_number = 0;
2415 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
2416 :
2417 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
2418 1 : assert_int_equal(status, LIBSPDM_STATUS_SESSION_MSG_ERROR);
2419 1 : assert_int_equal(spdm_context->session_info->session_id, INVALID_SESSION_ID);
2420 1 : free(data);
2421 1 : }
2422 :
2423 : /**
2424 : * Test 16: a request message is successfully sent and a response message is successfully received.
2425 : * Expected Behavior: requester returns the status RETURN_SUCCESS and a PSK_FINISH_RSP message is
2426 : * received, buffer F appends the exchanged PSK_FINISH and PSK_FINISH_RSP messages.
2427 : **/
2428 1 : void libspdm_test_requester_psk_finish_case16(void **state)
2429 : {
2430 : libspdm_return_t status;
2431 : libspdm_test_context_t *spdm_test_context;
2432 : libspdm_context_t *spdm_context;
2433 : uint32_t session_id;
2434 : void *data;
2435 : size_t data_size;
2436 : void *hash;
2437 : size_t hash_size;
2438 : libspdm_session_info_t *session_info;
2439 :
2440 1 : spdm_test_context = *state;
2441 1 : spdm_context = spdm_test_context->spdm_context;
2442 1 : spdm_test_context->case_id = 0x10;
2443 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
2444 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2445 1 : spdm_context->connection_info.connection_state =
2446 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
2447 1 : spdm_context->connection_info.capability.flags |=
2448 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2449 1 : spdm_context->connection_info.capability.flags |=
2450 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2451 1 : spdm_context->connection_info.capability.flags |=
2452 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2453 1 : spdm_context->local_context.capability.flags |=
2454 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2455 1 : spdm_context->local_context.capability.flags |=
2456 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2457 1 : spdm_context->local_context.capability.flags |=
2458 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2459 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2460 : m_libspdm_use_asym_algo, &data,
2461 : &data_size, &hash, &hash_size);
2462 1 : libspdm_reset_message_a(spdm_context);
2463 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2464 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2465 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
2466 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
2467 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2468 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size =
2469 : data_size;
2470 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
2471 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
2472 : data, data_size);
2473 : #endif
2474 :
2475 :
2476 1 : session_id = 0xFFFFFFFF;
2477 1 : session_info = &spdm_context->session_info[0];
2478 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
2479 1 : libspdm_session_info_set_psk_hint(session_info,
2480 : LIBSPDM_TEST_PSK_HINT_STRING,
2481 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
2482 1 : libspdm_secured_message_set_session_state(
2483 : session_info->secured_message_context,
2484 : LIBSPDM_SESSION_STATE_HANDSHAKING);
2485 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
2486 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
2487 : ->aead_key_size, (uint8_t)(0xFF));
2488 1 : libspdm_secured_message_set_response_handshake_encryption_key(
2489 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
2490 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
2491 : ->aead_key_size);
2492 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
2493 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
2494 : ->aead_iv_size, (uint8_t)(0xFF));
2495 1 : libspdm_secured_message_set_response_handshake_salt(
2496 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
2497 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
2498 : ->aead_iv_size);
2499 1 : ((libspdm_secured_message_context_t *)(session_info->secured_message_context))
2500 1 : ->handshake_secret.response_handshake_sequence_number = 0;
2501 1 : ((libspdm_secured_message_context_t *)(session_info->secured_message_context))
2502 1 : ->handshake_secret.request_handshake_sequence_number = 0;
2503 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
2504 :
2505 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
2506 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2507 1 : assert_int_equal(
2508 : libspdm_secured_message_get_session_state(
2509 : spdm_context->session_info[0].secured_message_context),
2510 : LIBSPDM_SESSION_STATE_ESTABLISHED);
2511 :
2512 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
2513 : assert_int_equal(spdm_context->session_info[0].session_transcript.message_f.buffer_size,
2514 : m_libspdm_local_buffer_size);
2515 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "m_libspdm_local_buffer (0x%x):\n",
2516 : m_libspdm_local_buffer_size));
2517 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
2518 : assert_memory_equal(spdm_context->session_info[0].session_transcript.message_f.buffer,
2519 : m_libspdm_local_buffer, m_libspdm_local_buffer_size);
2520 : #endif
2521 1 : free(data);
2522 1 : }
2523 :
2524 : /**
2525 : * Test 17: SPDM version 1.4, with OpaqueData
2526 : * Expected Behavior: requester returns the status RETURN_SUCCESS and a PSK_FINISH_RSP message is
2527 : * received.
2528 : **/
2529 1 : void libspdm_test_requester_psk_finish_case17(void **state)
2530 : {
2531 : libspdm_return_t status;
2532 : libspdm_test_context_t *spdm_test_context;
2533 : libspdm_context_t *spdm_context;
2534 : uint32_t session_id;
2535 : void *data;
2536 : size_t data_size;
2537 : void *hash;
2538 : size_t hash_size;
2539 : libspdm_session_info_t *session_info;
2540 :
2541 1 : spdm_test_context = *state;
2542 1 : spdm_context = spdm_test_context->spdm_context;
2543 1 : spdm_test_context->case_id = 0x11;
2544 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_14 <<
2545 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2546 1 : spdm_context->connection_info.connection_state =
2547 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
2548 1 : spdm_context->connection_info.capability.flags |=
2549 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2550 1 : spdm_context->connection_info.capability.flags |=
2551 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2552 1 : spdm_context->connection_info.capability.flags |=
2553 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2554 1 : spdm_context->local_context.capability.flags |=
2555 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2556 1 : spdm_context->local_context.capability.flags |=
2557 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2558 1 : spdm_context->local_context.capability.flags |=
2559 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2560 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
2561 : m_libspdm_use_asym_algo, &data,
2562 : &data_size, &hash, &hash_size);
2563 1 : libspdm_reset_message_a(spdm_context);
2564 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2565 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2566 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
2567 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
2568 :
2569 1 : session_id = 0xFFFFFFFF;
2570 1 : session_info = &spdm_context->session_info[0];
2571 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
2572 1 : libspdm_session_info_set_psk_hint(session_info,
2573 : LIBSPDM_TEST_PSK_HINT_STRING,
2574 : sizeof(LIBSPDM_TEST_PSK_HINT_STRING));
2575 1 : libspdm_secured_message_set_session_state(
2576 : session_info->secured_message_context,
2577 : LIBSPDM_SESSION_STATE_HANDSHAKING);
2578 1 : libspdm_set_mem(m_libspdm_dummy_key_buffer,
2579 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
2580 : ->aead_key_size, (uint8_t)(0xFF));
2581 1 : libspdm_secured_message_set_response_handshake_encryption_key(
2582 : session_info->secured_message_context, m_libspdm_dummy_key_buffer,
2583 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
2584 : ->aead_key_size);
2585 1 : libspdm_set_mem(m_libspdm_dummy_salt_buffer,
2586 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
2587 : ->aead_iv_size, (uint8_t)(0xFF));
2588 1 : libspdm_secured_message_set_response_handshake_salt(
2589 : session_info->secured_message_context, m_libspdm_dummy_salt_buffer,
2590 1 : ((libspdm_secured_message_context_t*)(session_info->secured_message_context))
2591 : ->aead_iv_size);
2592 1 : ((libspdm_secured_message_context_t *)(session_info->secured_message_context))
2593 1 : ->handshake_secret.response_handshake_sequence_number = 0;
2594 1 : ((libspdm_secured_message_context_t *)(session_info->secured_message_context))
2595 1 : ->handshake_secret.request_handshake_sequence_number = 0;
2596 1 : libspdm_secured_message_set_dummy_finished_key (session_info->secured_message_context);
2597 :
2598 1 : status = libspdm_send_receive_psk_finish(spdm_context, session_id);
2599 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2600 1 : assert_int_equal(
2601 : libspdm_secured_message_get_session_state(
2602 : spdm_context->session_info[0].secured_message_context),
2603 : LIBSPDM_SESSION_STATE_ESTABLISHED);
2604 :
2605 1 : free(data);
2606 1 : }
2607 :
2608 1 : int libspdm_requester_psk_finish_test_main(void)
2609 : {
2610 1 : const struct CMUnitTest spdm_requester_psk_finish_tests[] = {
2611 : /* SendRequest failed*/
2612 : cmocka_unit_test(libspdm_test_requester_psk_finish_case1),
2613 : /* Successful response*/
2614 : cmocka_unit_test(libspdm_test_requester_psk_finish_case2),
2615 : /* connection_state check failed*/
2616 : cmocka_unit_test(libspdm_test_requester_psk_finish_case3),
2617 : /* Error response: SPDM_ERROR_CODE_INVALID_REQUEST*/
2618 : cmocka_unit_test(libspdm_test_requester_psk_finish_case4),
2619 : /* Always SPDM_ERROR_CODE_BUSY*/
2620 : cmocka_unit_test(libspdm_test_requester_psk_finish_case5),
2621 : /* SPDM_ERROR_CODE_BUSY + Successful response*/
2622 : cmocka_unit_test(libspdm_test_requester_psk_finish_case6),
2623 : /* Error response: SPDM_ERROR_CODE_REQUEST_RESYNCH*/
2624 : cmocka_unit_test(libspdm_test_requester_psk_finish_case7),
2625 : /* Always SPDM_ERROR_CODE_RESPONSE_NOT_READY*/
2626 : cmocka_unit_test(libspdm_test_requester_psk_finish_case8),
2627 : /* SPDM_ERROR_CODE_RESPONSE_NOT_READY + Successful response*/
2628 : cmocka_unit_test(libspdm_test_requester_psk_finish_case9),
2629 : /* Unexpected errors*/
2630 : cmocka_unit_test(libspdm_test_requester_psk_finish_case10),
2631 : /* Buffer reset*/
2632 : cmocka_unit_test(libspdm_test_requester_psk_finish_case11),
2633 : /* No correct setup*/
2634 : cmocka_unit_test(libspdm_test_requester_psk_finish_case12),
2635 : /* Wrong response code*/
2636 : cmocka_unit_test(libspdm_test_requester_psk_finish_case13),
2637 : /* Uninitialized session*/
2638 : cmocka_unit_test(libspdm_test_requester_psk_finish_case14),
2639 : /* Error response: SPDM_ERROR_CODE_DECRYPT_ERROR*/
2640 : cmocka_unit_test(libspdm_test_requester_psk_finish_case15),
2641 : /* Buffer verification*/
2642 : cmocka_unit_test(libspdm_test_requester_psk_finish_case16),
2643 : /* SPDM 1.4 with OpaqueData */
2644 : cmocka_unit_test(libspdm_test_requester_psk_finish_case17),
2645 : };
2646 :
2647 1 : libspdm_test_context_t test_context = {
2648 : LIBSPDM_TEST_CONTEXT_VERSION,
2649 : true,
2650 : libspdm_requester_psk_finish_test_send_message,
2651 : libspdm_requester_psk_finish_test_receive_message,
2652 : };
2653 :
2654 1 : libspdm_setup_test_context(&test_context);
2655 :
2656 1 : return cmocka_run_group_tests(spdm_requester_psk_finish_tests,
2657 : libspdm_unit_test_group_setup,
2658 : libspdm_unit_test_group_teardown);
2659 : }
2660 :
2661 : #endif /* LIBSPDM_ENABLE_CAPABILITY_PSK_CAP*/
|
