Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2026 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : #include "spdm_unit_test.h"
8 : #include "internal/libspdm_responder_lib.h"
9 :
10 : #if LIBSPDM_ENABLE_CAPABILITY_CHUNK_CAP
11 :
12 : #define CHUNK_SEND_ACK_RESPONDER_UNIT_TEST_DATA_TRANSFER_SIZE (42)
13 :
14 : typedef struct {
15 : spdm_negotiate_algorithms_request_t spdm_request_version10;
16 : spdm_negotiate_algorithms_common_struct_table_t struct_table[4];
17 : } libspdm_negotiate_algorithms_request_spdm_tables_t;
18 :
19 : libspdm_negotiate_algorithms_request_spdm_tables_t
20 : m_libspdm_chunk_send_negotiate_algorithm_request1 = {
21 : {
22 : {
23 : SPDM_MESSAGE_VERSION_12,
24 : SPDM_NEGOTIATE_ALGORITHMS,
25 : 4,
26 : 0
27 : },
28 : sizeof(libspdm_negotiate_algorithms_request_spdm_tables_t),
29 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
30 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1,
31 : },
32 : {
33 : {
34 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
35 : 0x20,
36 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
37 : },
38 : {
39 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
40 : 0x20,
41 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
42 : },
43 : {
44 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
45 : 0x20,
46 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
47 : },
48 : {
49 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
50 : 0x20,
51 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
52 : }
53 : }
54 : };
55 :
56 : size_t m_libspdm_chunk_send_negotiate_algorithm_request1_size =
57 : sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
58 :
59 : libspdm_negotiate_algorithms_request_spdm_tables_t
60 : m_libspdm_chunk_send_negotiate_algorithm_request22 = {
61 : {
62 : {
63 : SPDM_MESSAGE_VERSION_14,
64 : SPDM_NEGOTIATE_ALGORITHMS,
65 : 4,
66 : 0
67 : },
68 : sizeof(libspdm_negotiate_algorithms_request_spdm_tables_t),
69 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
70 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1,
71 : },
72 : {
73 : {
74 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
75 : 0x20,
76 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
77 : },
78 : {
79 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
80 : 0x20,
81 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
82 : },
83 : {
84 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
85 : 0x20,
86 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
87 : },
88 : {
89 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
90 : 0x20,
91 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
92 : }
93 : }
94 : };
95 :
96 23 : void libspdm_test_responder_chunk_send_ack_setup_algo_state(libspdm_context_t* spdm_context)
97 : {
98 : /* This state is copied form Algorithms test case 22 */
99 23 : m_libspdm_chunk_send_negotiate_algorithm_request1.spdm_request_version10.base_hash_algo =
100 : m_libspdm_use_hash_algo;
101 23 : m_libspdm_chunk_send_negotiate_algorithm_request1.spdm_request_version10.base_asym_algo =
102 : m_libspdm_use_asym_algo;
103 :
104 23 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
105 23 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
106 :
107 23 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
108 : SPDM_VERSION_NUMBER_SHIFT_BIT;
109 23 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
110 23 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
111 23 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
112 23 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
113 23 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
114 23 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
115 23 : spdm_context->local_context.algorithm.other_params_support =
116 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
117 : /* spdm_context->connection_info.algorithm.other_params_support = SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1; */
118 23 : libspdm_reset_message_a(spdm_context);
119 23 : spdm_context->local_context.capability.flags = 0;
120 23 : spdm_context->connection_info.capability.flags = 0;
121 23 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
122 23 : spdm_context->connection_info.capability.flags |=
123 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
124 :
125 23 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
126 23 : spdm_context->connection_info.capability.flags |=
127 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
128 :
129 23 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
130 23 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
131 :
132 23 : spdm_context->local_context.capability.flags |=
133 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
134 23 : spdm_context->connection_info.capability.flags |=
135 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
136 :
137 23 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
138 23 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
139 :
140 23 : spdm_context->local_context.capability.data_transfer_size =
141 : CHUNK_SEND_ACK_RESPONDER_UNIT_TEST_DATA_TRANSFER_SIZE;
142 :
143 23 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP;
144 23 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP;
145 23 : }
146 :
147 : /* Test sending large NegAlg Request in multiple chunks. */
148 1 : static void rsp_chunk_send_ack_case0(void** state)
149 : {
150 : libspdm_return_t status;
151 :
152 : libspdm_test_context_t* spdm_test_context;
153 : libspdm_context_t* spdm_context;
154 :
155 : size_t request_size;
156 : size_t response_size;
157 :
158 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
159 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
160 :
161 : spdm_chunk_send_request_t *chunk_send_request;
162 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
163 : spdm_algorithms_response_t *algorithms_response;
164 : size_t algorithms_response_size;
165 :
166 : const uint8_t* chunk_src;
167 : uint8_t* chunk_dst;
168 : uint16_t chunk_num;
169 : uint32_t bytes_sent;
170 : uint32_t bytes_total;
171 :
172 : void *scratch_buffer;
173 : size_t scratch_buffer_size;
174 : uint8_t *large_message;
175 : size_t large_message_capacity;
176 : size_t i;
177 :
178 1 : spdm_test_context = *state;
179 1 : spdm_context = spdm_test_context->spdm_context;
180 1 : spdm_test_context->case_id = 0;
181 :
182 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
183 :
184 1 : chunk_num = 0;
185 1 : bytes_sent = 0;
186 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
187 1 : chunk_src = (const uint8_t *)&m_libspdm_chunk_send_negotiate_algorithm_request1;
188 :
189 : do {
190 2 : libspdm_zero_mem(request, sizeof(request));
191 2 : chunk_send_request = (spdm_chunk_send_request_t*)request;
192 :
193 2 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
194 2 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
195 2 : chunk_send_request->header.param1 = 0;
196 2 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
197 2 : chunk_send_request->chunk_seq_no = chunk_num;
198 :
199 2 : if (chunk_num == 0) {
200 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
201 1 : chunk_send_request->chunk_size =
202 1 : spdm_context->local_context.capability.data_transfer_size
203 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
204 :
205 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
206 :
207 1 : request_size = sizeof(spdm_chunk_send_request_t)
208 : + sizeof(uint32_t)
209 1 : + chunk_send_request->chunk_size;
210 : } else {
211 1 : chunk_send_request->chunk_size =
212 1 : LIBSPDM_MIN(
213 : spdm_context->local_context.capability.data_transfer_size
214 : - sizeof(spdm_chunk_send_request_t),
215 : bytes_total - bytes_sent);
216 :
217 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1));
218 :
219 1 : request_size = sizeof(spdm_chunk_send_request_t)
220 1 : + chunk_send_request->chunk_size;
221 :
222 1 : if (bytes_total - bytes_sent == chunk_send_request->chunk_size) {
223 1 : chunk_send_request->header.param1 = SPDM_CHUNK_SEND_REQUEST_ATTRIBUTE_LAST_CHUNK;
224 : }
225 : }
226 :
227 2 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
228 2 : chunk_src, chunk_send_request->chunk_size);
229 :
230 2 : chunk_src += chunk_send_request->chunk_size;
231 2 : bytes_sent += chunk_send_request->chunk_size;
232 2 : chunk_num++;
233 :
234 2 : response_size = sizeof(response);
235 2 : status = libspdm_get_response_chunk_send(
236 : spdm_context,
237 : request_size, request,
238 : &response_size, response);
239 :
240 2 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
241 2 : assert_true(response_size >= sizeof(spdm_chunk_send_ack_response_t));
242 :
243 2 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
244 2 : assert_int_equal(chunk_send_ack_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
245 2 : assert_int_equal(chunk_send_ack_response->header.request_response_code,
246 : SPDM_CHUNK_SEND_ACK);
247 2 : assert_int_equal(chunk_send_ack_response->header.param1, 0);
248 2 : assert_int_equal(chunk_send_ack_response->header.param2, spdm_test_context->case_id);
249 2 : assert_int_equal(chunk_send_ack_response->chunk_seq_no, chunk_send_request->chunk_seq_no);
250 :
251 2 : } while (bytes_sent < bytes_total);
252 :
253 1 : algorithms_response = (spdm_algorithms_response_t*) (chunk_send_ack_response + 1);
254 1 : algorithms_response_size = response_size - sizeof(spdm_chunk_send_ack_response_t);
255 1 : assert_int_equal(algorithms_response->header.request_response_code, SPDM_ALGORITHMS);
256 :
257 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
258 1 : assert_int_equal(algorithms_response_size,
259 : sizeof(spdm_algorithms_response_t) + 4 *
260 : sizeof(spdm_negotiate_algorithms_common_struct_table_t));
261 1 : assert_int_equal(algorithms_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
262 1 : assert_int_equal(algorithms_response->header.request_response_code, SPDM_ALGORITHMS);
263 1 : assert_int_equal(algorithms_response->header.param1, 4);
264 :
265 : /* Verify the completion cleanup fully reset large_message state and
266 : * scrubbed the scratch buffer, so the consumed large request does not linger. */
267 1 : assert_false(spdm_context->chunk_context.send.chunk_in_use);
268 1 : assert_null(spdm_context->chunk_context.send.large_message);
269 1 : assert_int_equal(spdm_context->chunk_context.send.large_message_size, 0);
270 1 : assert_int_equal(spdm_context->chunk_context.send.large_message_capacity, 0);
271 :
272 1 : libspdm_get_scratch_buffer(spdm_context, &scratch_buffer, &scratch_buffer_size);
273 2 : large_message = (uint8_t *)scratch_buffer +
274 1 : libspdm_get_scratch_buffer_large_message_offset(spdm_context);
275 1 : large_message_capacity = libspdm_get_scratch_buffer_large_message_capacity(spdm_context);
276 4609 : for (i = 0; i < large_message_capacity; i++) {
277 4608 : assert_int_equal(large_message[i], 0);
278 : }
279 1 : }
280 :
281 : /**
282 : * Test 1: Responder receives a CHUNK_SEND request without chunk capabilities.
283 : * Expected Behavior: Returns ERROR response message with an error code.
284 : **/
285 1 : static void rsp_chunk_send_ack_case1(void** state)
286 : {
287 : libspdm_return_t status;
288 :
289 : libspdm_test_context_t* spdm_test_context;
290 : libspdm_context_t* spdm_context;
291 :
292 : size_t request_size;
293 : size_t response_size;
294 :
295 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
296 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
297 :
298 : spdm_chunk_send_request_t* chunk_send_request;
299 : spdm_error_response_t* error_response;
300 :
301 : const uint8_t* chunk_src;
302 : uint8_t* chunk_dst;
303 : uint16_t chunk_num;
304 : uint32_t bytes_total;
305 :
306 1 : spdm_test_context = *state;
307 1 : spdm_context = spdm_test_context->spdm_context;
308 1 : spdm_test_context->case_id = 1;
309 :
310 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
311 :
312 1 : spdm_context->local_context.capability.flags &= ~SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP;
313 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP;
314 :
315 1 : chunk_num = 0;
316 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
317 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
318 :
319 1 : libspdm_zero_mem(request, sizeof(request));
320 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
321 :
322 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
323 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
324 1 : chunk_send_request->header.param1 = 0;
325 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
326 1 : chunk_send_request->chunk_seq_no = chunk_num;
327 :
328 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
329 1 : chunk_send_request->chunk_size =
330 1 : spdm_context->local_context.capability.data_transfer_size
331 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
332 :
333 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
334 :
335 1 : request_size = sizeof(spdm_chunk_send_request_t)
336 : + sizeof(uint32_t)
337 1 : + chunk_send_request->chunk_size;
338 :
339 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
340 1 : chunk_src, chunk_send_request->chunk_size);
341 :
342 1 : response_size = sizeof(response);
343 1 : status = libspdm_get_response_chunk_send(
344 : spdm_context,
345 : request_size, request,
346 : &response_size, response);
347 :
348 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
349 1 : assert_true(response_size == sizeof(spdm_error_response_t));
350 :
351 1 : error_response = (spdm_error_response_t*) response;
352 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
353 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
354 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_UNSUPPORTED_REQUEST);
355 1 : assert_int_equal(error_response->header.param2, SPDM_CHUNK_SEND);
356 1 : }
357 :
358 : /**
359 : * Test 2: Responder receives a CHUNK_SEND request with bad response state.
360 : * Expected Behavior: Returns ERROR response message
361 : * with request_response_code as error code.
362 : **/
363 1 : static void rsp_chunk_send_ack_case2(void** state)
364 : {
365 : libspdm_return_t status;
366 :
367 : libspdm_test_context_t* spdm_test_context;
368 : libspdm_context_t* spdm_context;
369 :
370 : size_t request_size;
371 : size_t response_size;
372 :
373 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
374 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
375 :
376 : spdm_chunk_send_request_t* chunk_send_request;
377 : spdm_error_response_t* error_response;
378 :
379 : const uint8_t* chunk_src;
380 : uint8_t* chunk_dst;
381 : uint16_t chunk_num;
382 : uint32_t bytes_total;
383 :
384 1 : spdm_test_context = *state;
385 1 : spdm_context = spdm_test_context->spdm_context;
386 1 : spdm_test_context->case_id = 2;
387 :
388 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
389 :
390 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_BUSY;
391 :
392 1 : chunk_num = 0;
393 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
394 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
395 :
396 1 : libspdm_zero_mem(request, sizeof(request));
397 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
398 :
399 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
400 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
401 1 : chunk_send_request->header.param1 = 0;
402 1 : chunk_send_request->header.param2 = (uint8_t)spdm_test_context->case_id; /* chunk_handle */
403 1 : chunk_send_request->chunk_seq_no = chunk_num;
404 :
405 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
406 1 : chunk_send_request->chunk_size =
407 1 : spdm_context->local_context.capability.data_transfer_size
408 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
409 :
410 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
411 :
412 1 : request_size = sizeof(spdm_chunk_send_request_t)
413 : + sizeof(uint32_t)
414 1 : + chunk_send_request->chunk_size;
415 :
416 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
417 1 : chunk_src, chunk_send_request->chunk_size);
418 :
419 1 : response_size = sizeof(response);
420 1 : status = libspdm_get_response_chunk_send(
421 : spdm_context,
422 : request_size, request,
423 : &response_size, response);
424 :
425 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
426 1 : assert_true(response_size == sizeof(spdm_error_response_t));
427 :
428 1 : error_response = (spdm_error_response_t*) response;
429 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
430 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
431 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_BUSY);
432 1 : assert_int_equal(error_response->header.param2, 0);
433 1 : }
434 :
435 : /**
436 : * Test 3: Responder receives a CHUNK_SEND request with bad connection state.
437 : * Expected Behavior: Returns ERROR response message
438 : * with SPDM_ERROR_CODE_UNEXPECTED_REQUEST error code.
439 : **/
440 1 : static void rsp_chunk_send_ack_case3(void** state)
441 : {
442 : libspdm_return_t status;
443 :
444 : libspdm_test_context_t* spdm_test_context;
445 : libspdm_context_t* spdm_context;
446 :
447 : size_t request_size;
448 : size_t response_size;
449 :
450 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
451 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
452 :
453 : spdm_chunk_send_request_t* chunk_send_request;
454 : spdm_error_response_t* error_response;
455 :
456 : const uint8_t* chunk_src;
457 : uint8_t* chunk_dst;
458 : uint16_t chunk_num;
459 : uint32_t bytes_total;
460 :
461 1 : spdm_test_context = *state;
462 1 : spdm_context = spdm_test_context->spdm_context;
463 1 : spdm_test_context->case_id = 3;
464 :
465 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
466 :
467 : spdm_context->connection_info.connection_state
468 1 : = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES - 1;
469 :
470 1 : chunk_num = 0;
471 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
472 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
473 :
474 1 : libspdm_zero_mem(request, sizeof(request));
475 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
476 :
477 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
478 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
479 1 : chunk_send_request->header.param1 = 0;
480 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
481 1 : chunk_send_request->chunk_seq_no = chunk_num;
482 :
483 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
484 1 : chunk_send_request->chunk_size =
485 1 : spdm_context->local_context.capability.data_transfer_size
486 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
487 :
488 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
489 :
490 1 : request_size = sizeof(spdm_chunk_send_request_t)
491 : + sizeof(uint32_t)
492 1 : + chunk_send_request->chunk_size;
493 :
494 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
495 1 : chunk_src, chunk_send_request->chunk_size);
496 :
497 1 : response_size = sizeof(response);
498 1 : status = libspdm_get_response_chunk_send(
499 : spdm_context,
500 : request_size, request,
501 : &response_size, response);
502 :
503 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
504 1 : assert_true(response_size == sizeof(spdm_error_response_t));
505 :
506 1 : error_response = (spdm_error_response_t*) response;
507 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
508 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
509 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
510 1 : assert_int_equal(error_response->header.param2, 0);
511 1 : }
512 :
513 :
514 : /**
515 : * Test 4: Responder receives a CHUNK_SEND request with bad size.
516 : * Expected Behavior: Returns ERROR response message
517 : * with SPDM_ERROR_CODE_INVALID_REQUEST error code.
518 : **/
519 1 : static void rsp_chunk_send_ack_case4(void** state)
520 : {
521 : libspdm_return_t status;
522 :
523 : libspdm_test_context_t* spdm_test_context;
524 : libspdm_context_t* spdm_context;
525 :
526 : size_t request_size;
527 : size_t response_size;
528 :
529 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
530 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
531 :
532 : spdm_chunk_send_request_t* chunk_send_request;
533 : spdm_error_response_t* error_response;
534 :
535 : const uint8_t* chunk_src;
536 : uint8_t* chunk_dst;
537 : uint16_t chunk_num;
538 : uint32_t bytes_total;
539 :
540 1 : spdm_test_context = *state;
541 1 : spdm_context = spdm_test_context->spdm_context;
542 1 : spdm_test_context->case_id = 4;
543 :
544 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
545 :
546 1 : chunk_num = 0;
547 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
548 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
549 :
550 1 : libspdm_zero_mem(request, sizeof(request));
551 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
552 :
553 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
554 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
555 1 : chunk_send_request->header.param1 = 0;
556 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
557 1 : chunk_send_request->chunk_seq_no = chunk_num;
558 :
559 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
560 1 : chunk_send_request->chunk_size =
561 1 : spdm_context->local_context.capability.data_transfer_size
562 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
563 :
564 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
565 :
566 1 : request_size = sizeof(spdm_chunk_send_request_t)
567 : + sizeof(uint32_t)
568 1 : + chunk_send_request->chunk_size;
569 :
570 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
571 1 : chunk_src, chunk_send_request->chunk_size);
572 :
573 1 : response_size = sizeof(response);
574 1 : request_size = sizeof(spdm_chunk_send_request_t) - 1;
575 1 : status = libspdm_get_response_chunk_send(
576 : spdm_context,
577 : request_size, request,
578 : &response_size, response);
579 :
580 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
581 1 : assert_true(response_size == sizeof(spdm_error_response_t));
582 :
583 1 : error_response = (spdm_error_response_t*) response;
584 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
585 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
586 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
587 1 : assert_int_equal(error_response->header.param2, 0);
588 1 : }
589 : /**
590 : * Test 5: Responder receives a CHUNK_SEND request SPDM version less than 1.2.
591 : * Expected Behavior: Returns ERROR response message
592 : * with SPDM_ERROR_CODE_UNSUPPORTED_REQUEST error code.
593 : **/
594 1 : static void rsp_chunk_send_ack_case5(void** state)
595 : {
596 : libspdm_return_t status;
597 :
598 : libspdm_test_context_t* spdm_test_context;
599 : libspdm_context_t* spdm_context;
600 :
601 : size_t request_size;
602 : size_t response_size;
603 :
604 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
605 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
606 :
607 : spdm_chunk_send_request_t* chunk_send_request;
608 : spdm_error_response_t* error_response;
609 :
610 : const uint8_t* chunk_src;
611 : uint8_t* chunk_dst;
612 : uint16_t chunk_num;
613 : uint32_t bytes_total;
614 :
615 1 : spdm_test_context = *state;
616 1 : spdm_context = spdm_test_context->spdm_context;
617 1 : spdm_test_context->case_id = 5;
618 :
619 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
620 :
621 1 : chunk_num = 0;
622 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
623 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
624 :
625 1 : libspdm_zero_mem(request, sizeof(request));
626 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
627 :
628 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_11;
629 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
630 1 : chunk_send_request->header.param1 = 0;
631 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
632 1 : chunk_send_request->chunk_seq_no = chunk_num;
633 :
634 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
635 1 : chunk_send_request->chunk_size =
636 1 : spdm_context->local_context.capability.data_transfer_size
637 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
638 :
639 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
640 :
641 1 : request_size = sizeof(spdm_chunk_send_request_t)
642 : + sizeof(uint32_t)
643 1 : + chunk_send_request->chunk_size;
644 :
645 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
646 1 : chunk_src, chunk_send_request->chunk_size);
647 :
648 1 : response_size = sizeof(response);
649 1 : status = libspdm_get_response_chunk_send(
650 : spdm_context,
651 : request_size, request,
652 : &response_size, response);
653 :
654 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
655 1 : assert_true(response_size == sizeof(spdm_error_response_t));
656 :
657 1 : error_response = (spdm_error_response_t*) response;
658 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
659 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
660 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_UNSUPPORTED_REQUEST);
661 1 : assert_int_equal(error_response->header.param2, SPDM_CHUNK_SEND);
662 1 : }
663 : /**
664 : * Test 6: Responder receives a CHUNK_SEND request with wrong SPDM version.
665 : * Expected Behavior: Returns ERROR response message
666 : * with SPDM_ERROR_CODE_VERSION_MISMATCH error code.
667 : **/
668 1 : static void rsp_chunk_send_ack_case6(void** state)
669 : {
670 : libspdm_return_t status;
671 :
672 : libspdm_test_context_t* spdm_test_context;
673 : libspdm_context_t* spdm_context;
674 :
675 : size_t request_size;
676 : size_t response_size;
677 :
678 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
679 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
680 :
681 : spdm_chunk_send_request_t* chunk_send_request;
682 : spdm_error_response_t* error_response;
683 :
684 : const uint8_t* chunk_src;
685 : uint8_t* chunk_dst;
686 : uint16_t chunk_num;
687 : uint32_t bytes_total;
688 :
689 1 : spdm_test_context = *state;
690 1 : spdm_context = spdm_test_context->spdm_context;
691 1 : spdm_test_context->case_id = 6;
692 :
693 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
694 :
695 1 : chunk_num = 0;
696 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
697 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
698 :
699 1 : libspdm_zero_mem(request, sizeof(request));
700 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
701 :
702 1 : chunk_send_request->header.spdm_version = 0x13;
703 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
704 1 : chunk_send_request->header.param1 = 0;
705 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
706 1 : chunk_send_request->chunk_seq_no = chunk_num;
707 :
708 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
709 1 : chunk_send_request->chunk_size =
710 1 : spdm_context->local_context.capability.data_transfer_size
711 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
712 :
713 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
714 :
715 1 : request_size = sizeof(spdm_chunk_send_request_t)
716 : + sizeof(uint32_t)
717 1 : + chunk_send_request->chunk_size;
718 :
719 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
720 1 : chunk_src, chunk_send_request->chunk_size);
721 :
722 1 : response_size = sizeof(response);
723 1 : status = libspdm_get_response_chunk_send(
724 : spdm_context,
725 : request_size, request,
726 : &response_size, response);
727 :
728 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
729 1 : assert_true(response_size == sizeof(spdm_error_response_t));
730 :
731 1 : error_response = (spdm_error_response_t*) response;
732 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
733 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
734 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_VERSION_MISMATCH);
735 1 : assert_int_equal(error_response->header.param2, 0);
736 1 : }
737 :
738 : /**
739 : * Test 7: Responder gets chunk send when chunk get already in use.
740 : **/
741 1 : static void rsp_chunk_send_ack_case7(void** state)
742 : {
743 : libspdm_return_t status;
744 :
745 : libspdm_test_context_t* spdm_test_context;
746 : libspdm_context_t* spdm_context;
747 :
748 : size_t request_size;
749 : size_t response_size;
750 :
751 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
752 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
753 :
754 : spdm_chunk_send_request_t* chunk_send_request;
755 : spdm_error_response_t* error_response;
756 :
757 : const uint8_t* chunk_src;
758 : uint8_t* chunk_dst;
759 : uint16_t chunk_num;
760 : uint32_t bytes_total;
761 :
762 1 : spdm_test_context = *state;
763 1 : spdm_context = spdm_test_context->spdm_context;
764 1 : spdm_test_context->case_id = 7;
765 :
766 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
767 1 : spdm_context->chunk_context.get.chunk_in_use = true;
768 :
769 1 : chunk_num = 0;
770 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
771 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
772 :
773 1 : libspdm_zero_mem(request, sizeof(request));
774 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
775 :
776 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
777 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
778 1 : chunk_send_request->header.param1 = 0;
779 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
780 1 : chunk_send_request->chunk_seq_no = chunk_num;
781 :
782 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
783 1 : chunk_send_request->chunk_size =
784 1 : spdm_context->local_context.capability.data_transfer_size
785 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
786 :
787 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
788 :
789 1 : request_size = sizeof(spdm_chunk_send_request_t)
790 : + sizeof(uint32_t)
791 1 : + chunk_send_request->chunk_size;
792 :
793 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
794 1 : chunk_src, chunk_send_request->chunk_size);
795 :
796 1 : response_size = sizeof(response);
797 1 : status = libspdm_get_response_chunk_send(
798 : spdm_context,
799 : request_size, request,
800 : &response_size, response);
801 :
802 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
803 1 : assert_true(response_size == sizeof(spdm_error_response_t));
804 :
805 1 : error_response = (spdm_error_response_t*) response;
806 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
807 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
808 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
809 1 : assert_int_equal(error_response->header.param2, 0);
810 :
811 1 : spdm_context->chunk_context.get.chunk_in_use = false;
812 1 : }
813 :
814 : /**
815 : * Test 8: First request has bad sequence number.
816 : **/
817 1 : static void rsp_chunk_send_ack_case8(void** state)
818 : {
819 : libspdm_return_t status;
820 :
821 : libspdm_test_context_t* spdm_test_context;
822 : libspdm_context_t* spdm_context;
823 :
824 : size_t request_size;
825 : size_t response_size;
826 :
827 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
828 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
829 :
830 : spdm_chunk_send_request_t *chunk_send_request;
831 : spdm_chunk_send_ack_response_t *chunk_send_ack_response;
832 : spdm_error_response_t *error_response;
833 :
834 : const uint8_t *chunk_src;
835 : uint8_t *chunk_dst;
836 : uint32_t bytes_total;
837 :
838 1 : spdm_test_context = *state;
839 1 : spdm_context = spdm_test_context->spdm_context;
840 1 : spdm_test_context->case_id = 8;
841 :
842 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
843 :
844 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
845 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
846 :
847 1 : libspdm_zero_mem(request, sizeof(request));
848 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
849 :
850 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
851 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
852 1 : chunk_send_request->header.param1 = 0;
853 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
854 1 : chunk_send_request->chunk_seq_no = 1; /* Bad seq num */
855 :
856 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
857 1 : chunk_send_request->chunk_size =
858 1 : spdm_context->local_context.capability.data_transfer_size
859 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
860 :
861 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
862 :
863 1 : request_size = sizeof(spdm_chunk_send_request_t)
864 : + sizeof(uint32_t)
865 1 : + chunk_send_request->chunk_size;
866 :
867 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
868 1 : chunk_src, chunk_send_request->chunk_size);
869 :
870 1 : response_size = sizeof(response);
871 1 : status = libspdm_get_response_chunk_send(
872 : spdm_context,
873 : request_size, request,
874 : &response_size, response);
875 :
876 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
877 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
878 : + sizeof(spdm_error_response_t));
879 :
880 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
881 1 : assert_int_equal(chunk_send_ack_response->header.param1,
882 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
883 :
884 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
885 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
886 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
887 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
888 1 : assert_int_equal(error_response->header.param2, 0);
889 1 : }
890 :
891 : /**
892 : * Test 9: First request has chunk size too large.
893 : **/
894 1 : static void rsp_chunk_send_ack_case9(void** state)
895 : {
896 : libspdm_return_t status;
897 :
898 : libspdm_test_context_t* spdm_test_context;
899 : libspdm_context_t* spdm_context;
900 :
901 : size_t request_size;
902 : size_t response_size;
903 :
904 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
905 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
906 :
907 : spdm_chunk_send_request_t* chunk_send_request;
908 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
909 : spdm_error_response_t* error_response;
910 :
911 : const uint8_t* chunk_src;
912 : uint8_t* chunk_dst;
913 : uint32_t bytes_total;
914 :
915 1 : spdm_test_context = *state;
916 1 : spdm_context = spdm_test_context->spdm_context;
917 1 : spdm_test_context->case_id = 9;
918 :
919 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
920 :
921 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
922 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
923 :
924 1 : libspdm_zero_mem(request, sizeof(request));
925 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
926 :
927 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
928 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
929 1 : chunk_send_request->header.param1 = 0;
930 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
931 1 : chunk_send_request->chunk_seq_no = 0;
932 :
933 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
934 1 : chunk_send_request->chunk_size =
935 1 : spdm_context->local_context.capability.data_transfer_size
936 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
937 :
938 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
939 :
940 1 : request_size = sizeof(spdm_chunk_send_request_t)
941 : + sizeof(uint32_t)
942 1 : + chunk_send_request->chunk_size;
943 :
944 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
945 1 : chunk_src, chunk_send_request->chunk_size);
946 :
947 1 : chunk_send_request->chunk_size += 1; /* chunk size too large */
948 :
949 1 : response_size = sizeof(response);
950 1 : status = libspdm_get_response_chunk_send(
951 : spdm_context,
952 : request_size, request,
953 : &response_size, response);
954 :
955 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
956 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
957 : + sizeof(spdm_error_response_t));
958 :
959 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
960 1 : assert_int_equal(chunk_send_ack_response->header.param1,
961 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
962 :
963 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
964 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
965 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
966 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
967 1 : assert_int_equal(error_response->header.param2, 0);
968 1 : }
969 :
970 : /**
971 : * Test 10: First request has size larger than data transfer size.
972 : **/
973 1 : static void rsp_chunk_send_ack_case10(void** state)
974 : {
975 : libspdm_return_t status;
976 :
977 : libspdm_test_context_t* spdm_test_context;
978 : libspdm_context_t* spdm_context;
979 :
980 : size_t request_size;
981 : size_t response_size;
982 :
983 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
984 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
985 :
986 : spdm_chunk_send_request_t* chunk_send_request;
987 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
988 : spdm_error_response_t* error_response;
989 :
990 : const uint8_t* chunk_src;
991 : uint8_t* chunk_dst;
992 : uint32_t bytes_total;
993 :
994 1 : spdm_test_context = *state;
995 1 : spdm_context = spdm_test_context->spdm_context;
996 1 : spdm_test_context->case_id = 10;
997 :
998 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
999 :
1000 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
1001 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1002 :
1003 1 : libspdm_zero_mem(request, sizeof(request));
1004 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1005 :
1006 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1007 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1008 1 : chunk_send_request->header.param1 = 0;
1009 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
1010 1 : chunk_send_request->chunk_seq_no = 0;
1011 :
1012 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
1013 1 : chunk_send_request->chunk_size =
1014 1 : spdm_context->local_context.capability.data_transfer_size
1015 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
1016 :
1017 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
1018 :
1019 1 : request_size = sizeof(spdm_chunk_send_request_t)
1020 : + sizeof(uint32_t)
1021 1 : + chunk_send_request->chunk_size
1022 : + 1; /* Request size too large */
1023 :
1024 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1025 1 : chunk_src, chunk_send_request->chunk_size);
1026 :
1027 1 : response_size = sizeof(response);
1028 1 : status = libspdm_get_response_chunk_send(
1029 : spdm_context,
1030 : request_size, request,
1031 : &response_size, response);
1032 :
1033 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1034 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1035 : + sizeof(spdm_error_response_t));
1036 :
1037 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1038 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1039 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1040 :
1041 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1042 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1043 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1044 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1045 1 : assert_int_equal(error_response->header.param2, 0);
1046 1 : }
1047 :
1048 : /**
1049 : * Test 11: First request has LAST CHUNK bit set.
1050 : **/
1051 1 : static void rsp_chunk_send_ack_case11(void** state)
1052 : {
1053 : libspdm_return_t status;
1054 :
1055 : libspdm_test_context_t* spdm_test_context;
1056 : libspdm_context_t* spdm_context;
1057 :
1058 : size_t request_size;
1059 : size_t response_size;
1060 :
1061 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1062 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1063 :
1064 : spdm_chunk_send_request_t* chunk_send_request;
1065 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1066 : spdm_error_response_t* error_response;
1067 :
1068 : const uint8_t* chunk_src;
1069 : uint8_t* chunk_dst;
1070 :
1071 1 : spdm_test_context = *state;
1072 1 : spdm_context = spdm_test_context->spdm_context;
1073 1 : spdm_test_context->case_id = 11;
1074 :
1075 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1076 :
1077 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1078 :
1079 1 : libspdm_zero_mem(request, sizeof(request));
1080 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1081 :
1082 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1083 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1084 1 : chunk_send_request->header.param1 = 0;
1085 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
1086 1 : chunk_send_request->chunk_seq_no = 0;
1087 :
1088 1 : *((uint32_t*) (chunk_send_request + 1)) = LIBSPDM_MAX_SPDM_MSG_SIZE + 1;
1089 :
1090 1 : chunk_send_request->chunk_size =
1091 1 : spdm_context->local_context.capability.data_transfer_size
1092 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
1093 :
1094 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
1095 :
1096 1 : request_size = sizeof(spdm_chunk_send_request_t)
1097 : + sizeof(uint32_t)
1098 1 : + chunk_send_request->chunk_size;
1099 :
1100 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1101 1 : chunk_src, chunk_send_request->chunk_size);
1102 :
1103 1 : response_size = sizeof(response);
1104 1 : status = libspdm_get_response_chunk_send(
1105 : spdm_context,
1106 : request_size, request,
1107 : &response_size, response);
1108 :
1109 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1110 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1111 : + sizeof(spdm_error_response_t));
1112 :
1113 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1114 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1115 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1116 :
1117 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1118 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1119 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1120 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1121 1 : assert_int_equal(error_response->header.param2, 0);
1122 1 : }
1123 :
1124 : /**
1125 : * Test 12: First request has LAST CHUNK bit set.
1126 : **/
1127 1 : static void rsp_chunk_send_ack_case12(void** state)
1128 : {
1129 : libspdm_return_t status;
1130 :
1131 : libspdm_test_context_t* spdm_test_context;
1132 : libspdm_context_t* spdm_context;
1133 :
1134 : size_t request_size;
1135 : size_t response_size;
1136 :
1137 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1138 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1139 :
1140 : spdm_chunk_send_request_t* chunk_send_request;
1141 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1142 : spdm_error_response_t* error_response;
1143 :
1144 : const uint8_t* chunk_src;
1145 : uint8_t* chunk_dst;
1146 : uint32_t bytes_total;
1147 :
1148 1 : spdm_test_context = *state;
1149 1 : spdm_context = spdm_test_context->spdm_context;
1150 1 : spdm_test_context->case_id = 12;
1151 :
1152 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1153 :
1154 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
1155 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1156 :
1157 1 : libspdm_zero_mem(request, sizeof(request));
1158 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1159 :
1160 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1161 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1162 1 : chunk_send_request->header.param1 = SPDM_CHUNK_SEND_REQUEST_ATTRIBUTE_LAST_CHUNK;
1163 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
1164 1 : chunk_send_request->chunk_seq_no = 0;
1165 :
1166 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
1167 :
1168 1 : chunk_send_request->chunk_size =
1169 1 : spdm_context->local_context.capability.data_transfer_size
1170 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
1171 :
1172 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
1173 :
1174 1 : request_size = sizeof(spdm_chunk_send_request_t)
1175 : + sizeof(uint32_t)
1176 1 : + chunk_send_request->chunk_size;
1177 :
1178 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1179 1 : chunk_src, chunk_send_request->chunk_size);
1180 :
1181 1 : response_size = sizeof(response);
1182 1 : status = libspdm_get_response_chunk_send(
1183 : spdm_context,
1184 : request_size, request,
1185 : &response_size, response);
1186 :
1187 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1188 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1189 : + sizeof(spdm_error_response_t));
1190 :
1191 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1192 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1193 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1194 :
1195 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1196 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1197 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1198 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1199 1 : assert_int_equal(error_response->header.param2, 0);
1200 1 : }
1201 :
1202 9 : void libspdm_test_responder_chunk_send_ack_reset_send_state(libspdm_context_t* spdm_context)
1203 : {
1204 : libspdm_chunk_info_t* send_info;
1205 :
1206 9 : send_info = &spdm_context->chunk_context.send;
1207 9 : send_info->chunk_in_use = false;
1208 9 : send_info->chunk_handle = 0;
1209 9 : send_info->chunk_seq_no = 0;
1210 9 : send_info->chunk_bytes_transferred = 0;
1211 9 : send_info->large_message = NULL;
1212 9 : send_info->large_message_size = 0;
1213 9 : send_info->large_message_capacity = 0;
1214 9 : }
1215 :
1216 : /**
1217 : * Test 13: Request has bad sequence number.
1218 : **/
1219 1 : static void rsp_chunk_send_ack_case13(void** state)
1220 : {
1221 : libspdm_return_t status;
1222 :
1223 : libspdm_test_context_t* spdm_test_context;
1224 : libspdm_context_t* spdm_context;
1225 :
1226 : size_t request_size;
1227 : size_t response_size;
1228 :
1229 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1230 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1231 :
1232 : spdm_chunk_send_request_t* chunk_send_request;
1233 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1234 : spdm_error_response_t* error_response;
1235 :
1236 : const uint8_t* chunk_src;
1237 : uint8_t* chunk_dst;
1238 :
1239 : void *scratch_buffer;
1240 : size_t scratch_buffer_size;
1241 : uint8_t *large_message;
1242 : size_t large_message_capacity;
1243 : size_t i;
1244 :
1245 1 : spdm_test_context = *state;
1246 1 : spdm_context = spdm_test_context->spdm_context;
1247 1 : spdm_test_context->case_id = 13;
1248 :
1249 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1250 :
1251 1 : libspdm_get_scratch_buffer(spdm_context, &scratch_buffer, &scratch_buffer_size);
1252 2 : large_message = (uint8_t *)scratch_buffer +
1253 1 : libspdm_get_scratch_buffer_large_message_offset(spdm_context);
1254 1 : large_message_capacity = libspdm_get_scratch_buffer_large_message_capacity(spdm_context);
1255 1 : libspdm_set_mem(large_message, large_message_capacity, 0xa5);
1256 :
1257 1 : spdm_context->chunk_context.send.chunk_in_use = true;
1258 1 : spdm_context->chunk_context.send.chunk_handle = (uint8_t) spdm_test_context->case_id;
1259 1 : spdm_context->chunk_context.send.chunk_seq_no = 0;
1260 1 : spdm_context->chunk_context.send.large_message = large_message;
1261 1 : spdm_context->chunk_context.send.large_message_capacity = large_message_capacity;
1262 1 : spdm_context->chunk_context.send.large_message_size = large_message_capacity;
1263 1 : spdm_context->chunk_context.send.chunk_bytes_transferred = large_message_capacity;
1264 :
1265 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1266 :
1267 1 : libspdm_zero_mem(request, sizeof(request));
1268 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1269 :
1270 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1271 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1272 1 : chunk_send_request->header.param1 = 0;
1273 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
1274 1 : chunk_send_request->chunk_seq_no = 2; /* Bad seq num */
1275 :
1276 1 : chunk_send_request->chunk_size =
1277 1 : spdm_context->local_context.capability.data_transfer_size
1278 1 : - sizeof(spdm_chunk_send_request_t);
1279 :
1280 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1));
1281 :
1282 1 : request_size = sizeof(spdm_chunk_send_request_t)
1283 1 : + chunk_send_request->chunk_size;
1284 :
1285 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1286 1 : chunk_src, chunk_send_request->chunk_size);
1287 :
1288 1 : response_size = sizeof(response);
1289 1 : status = libspdm_get_response_chunk_send(
1290 : spdm_context,
1291 : request_size, request,
1292 : &response_size, response);
1293 :
1294 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1295 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1296 : + sizeof(spdm_error_response_t));
1297 :
1298 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1299 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1300 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1301 :
1302 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1303 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1304 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1305 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1306 1 : assert_int_equal(error_response->header.param2, 0);
1307 :
1308 1 : assert_null(spdm_context->chunk_context.send.large_message);
1309 1 : assert_int_equal(spdm_context->chunk_context.send.large_message_size, 0);
1310 1 : assert_int_equal(spdm_context->chunk_context.send.large_message_capacity, 0);
1311 4609 : for (i = 0; i < large_message_capacity; i++) {
1312 4608 : assert_int_equal(large_message[i], 0);
1313 : }
1314 :
1315 1 : libspdm_test_responder_chunk_send_ack_reset_send_state(spdm_context);
1316 1 : }
1317 :
1318 : /**
1319 : * Test 14: Request has bad chunk handle.
1320 : **/
1321 1 : static void rsp_chunk_send_ack_case14(void** state)
1322 : {
1323 : libspdm_return_t status;
1324 :
1325 : libspdm_test_context_t* spdm_test_context;
1326 : libspdm_context_t* spdm_context;
1327 :
1328 : size_t request_size;
1329 : size_t response_size;
1330 :
1331 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1332 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1333 :
1334 : spdm_chunk_send_request_t* chunk_send_request;
1335 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1336 : spdm_error_response_t* error_response;
1337 :
1338 : const uint8_t* chunk_src;
1339 : uint8_t* chunk_dst;
1340 :
1341 1 : spdm_test_context = *state;
1342 1 : spdm_context = spdm_test_context->spdm_context;
1343 1 : spdm_test_context->case_id = 14;
1344 :
1345 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1346 1 : spdm_context->chunk_context.send.chunk_in_use = true;
1347 1 : spdm_context->chunk_context.send.chunk_handle = (uint8_t) spdm_test_context->case_id;
1348 1 : spdm_context->chunk_context.send.chunk_seq_no = 0;
1349 :
1350 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1351 :
1352 1 : libspdm_zero_mem(request, sizeof(request));
1353 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1354 :
1355 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1356 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1357 1 : chunk_send_request->header.param1 = 0;
1358 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id + 1; /* bad chunk_handle */
1359 1 : chunk_send_request->chunk_seq_no = 1;
1360 1 : chunk_send_request->chunk_size =
1361 1 : spdm_context->local_context.capability.data_transfer_size
1362 1 : - sizeof(spdm_chunk_send_request_t);
1363 :
1364 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1));
1365 :
1366 1 : request_size = sizeof(spdm_chunk_send_request_t)
1367 1 : + chunk_send_request->chunk_size;
1368 :
1369 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1370 1 : chunk_src, chunk_send_request->chunk_size);
1371 :
1372 1 : response_size = sizeof(response);
1373 1 : status = libspdm_get_response_chunk_send(
1374 : spdm_context,
1375 : request_size, request,
1376 : &response_size, response);
1377 :
1378 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1379 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1380 : + sizeof(spdm_error_response_t));
1381 :
1382 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1383 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1384 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1385 :
1386 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1387 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1388 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1389 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1390 1 : assert_int_equal(error_response->header.param2, 0);
1391 :
1392 1 : libspdm_test_responder_chunk_send_ack_reset_send_state(spdm_context);
1393 1 : }
1394 :
1395 : /**
1396 : * Test 15: Request has size larger than data transfer size.
1397 : **/
1398 1 : static void rsp_chunk_send_ack_case15(void** state)
1399 : {
1400 : libspdm_return_t status;
1401 :
1402 : libspdm_test_context_t* spdm_test_context;
1403 : libspdm_context_t* spdm_context;
1404 :
1405 : size_t request_size;
1406 : size_t response_size;
1407 :
1408 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1409 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1410 :
1411 : spdm_chunk_send_request_t* chunk_send_request;
1412 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1413 : spdm_error_response_t* error_response;
1414 :
1415 : const uint8_t* chunk_src;
1416 : uint8_t* chunk_dst;
1417 :
1418 1 : spdm_test_context = *state;
1419 1 : spdm_context = spdm_test_context->spdm_context;
1420 1 : spdm_test_context->case_id = 15;
1421 :
1422 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1423 1 : spdm_context->chunk_context.send.chunk_in_use = true;
1424 1 : spdm_context->chunk_context.send.chunk_handle = (uint8_t) spdm_test_context->case_id;
1425 1 : spdm_context->chunk_context.send.chunk_seq_no = 0;
1426 :
1427 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1428 :
1429 1 : libspdm_zero_mem(request, sizeof(request));
1430 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1431 :
1432 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1433 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1434 1 : chunk_send_request->header.param1 = 0;
1435 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
1436 1 : chunk_send_request->chunk_seq_no = 1;
1437 :
1438 1 : chunk_send_request->chunk_size =
1439 1 : spdm_context->local_context.capability.data_transfer_size
1440 1 : - sizeof(spdm_chunk_send_request_t);
1441 :
1442 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1));
1443 :
1444 1 : request_size = sizeof(spdm_chunk_send_request_t)
1445 1 : + chunk_send_request->chunk_size
1446 : + 1; /* Request size too large */
1447 :
1448 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1449 1 : chunk_src, chunk_send_request->chunk_size);
1450 :
1451 1 : response_size = sizeof(response);
1452 1 : status = libspdm_get_response_chunk_send(
1453 : spdm_context,
1454 : request_size, request,
1455 : &response_size, response);
1456 :
1457 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1458 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1459 : + sizeof(spdm_error_response_t));
1460 :
1461 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1462 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1463 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1464 :
1465 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1466 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1467 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1468 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1469 1 : assert_int_equal(error_response->header.param2, 0);
1470 :
1471 1 : libspdm_test_responder_chunk_send_ack_reset_send_state(spdm_context);
1472 1 : }
1473 :
1474 : /**
1475 : * Test 16: Request has chunk size + transferred size > large message size
1476 : **/
1477 1 : static void rsp_chunk_send_ack_case16(void** state)
1478 : {
1479 : libspdm_return_t status;
1480 :
1481 : libspdm_test_context_t* spdm_test_context;
1482 : libspdm_context_t* spdm_context;
1483 :
1484 : size_t request_size;
1485 : size_t response_size;
1486 :
1487 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1488 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1489 :
1490 : spdm_chunk_send_request_t* chunk_send_request;
1491 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1492 : spdm_error_response_t* error_response;
1493 :
1494 : const uint8_t* chunk_src;
1495 : uint8_t* chunk_dst;
1496 :
1497 1 : spdm_test_context = *state;
1498 1 : spdm_context = spdm_test_context->spdm_context;
1499 1 : spdm_test_context->case_id = 16;
1500 :
1501 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1502 1 : spdm_context->chunk_context.send.chunk_in_use = true;
1503 1 : spdm_context->chunk_context.send.chunk_handle = (uint8_t) spdm_test_context->case_id;
1504 1 : spdm_context->chunk_context.send.chunk_seq_no = 0;
1505 1 : spdm_context->chunk_context.send.large_message_size = 1024;
1506 1 : spdm_context->chunk_context.send.chunk_bytes_transferred = 1023;
1507 :
1508 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1509 :
1510 1 : libspdm_zero_mem(request, sizeof(request));
1511 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1512 :
1513 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1514 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1515 1 : chunk_send_request->header.param1 = 0;
1516 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
1517 1 : chunk_send_request->chunk_seq_no = 1;
1518 1 : chunk_send_request->chunk_size = 2; /* Bad size. Over large message size */
1519 :
1520 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1));
1521 :
1522 1 : request_size = sizeof(spdm_chunk_send_request_t)
1523 1 : + chunk_send_request->chunk_size;
1524 :
1525 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1526 1 : chunk_src, chunk_send_request->chunk_size);
1527 :
1528 1 : response_size = sizeof(response);
1529 1 : status = libspdm_get_response_chunk_send(
1530 : spdm_context,
1531 : request_size, request,
1532 : &response_size, response);
1533 :
1534 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1535 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1536 : + sizeof(spdm_error_response_t));
1537 :
1538 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1539 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1540 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1541 :
1542 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1543 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1544 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1545 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1546 1 : assert_int_equal(error_response->header.param2, 0);
1547 :
1548 1 : libspdm_test_responder_chunk_send_ack_reset_send_state(spdm_context);
1549 1 : }
1550 :
1551 : /**
1552 : * Test 17: Request has LAST_CHUNK indicated before all bytes transferred.
1553 : **/
1554 1 : static void rsp_chunk_send_ack_case17(void** state)
1555 : {
1556 : libspdm_return_t status;
1557 :
1558 : libspdm_test_context_t* spdm_test_context;
1559 : libspdm_context_t* spdm_context;
1560 :
1561 : size_t request_size;
1562 : size_t response_size;
1563 :
1564 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1565 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1566 :
1567 : spdm_chunk_send_request_t* chunk_send_request;
1568 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1569 : spdm_error_response_t* error_response;
1570 :
1571 : const uint8_t* chunk_src;
1572 : uint8_t* chunk_dst;
1573 :
1574 1 : spdm_test_context = *state;
1575 1 : spdm_context = spdm_test_context->spdm_context;
1576 1 : spdm_test_context->case_id = 17;
1577 :
1578 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1579 1 : spdm_context->chunk_context.send.chunk_in_use = true;
1580 1 : spdm_context->chunk_context.send.chunk_handle = (uint8_t) spdm_test_context->case_id;
1581 1 : spdm_context->chunk_context.send.chunk_seq_no = 0;
1582 1 : spdm_context->chunk_context.send.large_message_size = 1024;
1583 1 : spdm_context->chunk_context.send.chunk_bytes_transferred = 1023;
1584 :
1585 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1586 :
1587 1 : libspdm_zero_mem(request, sizeof(request));
1588 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1589 :
1590 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1591 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1592 1 : chunk_send_request->header.param1 = 0;
1593 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
1594 1 : chunk_send_request->chunk_seq_no = 0;
1595 1 : chunk_send_request->chunk_size = 1;
1596 :
1597 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1));
1598 :
1599 1 : request_size = sizeof(spdm_chunk_send_request_t)
1600 1 : + chunk_send_request->chunk_size;
1601 :
1602 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1603 1 : chunk_src, chunk_send_request->chunk_size);
1604 :
1605 1 : response_size = sizeof(response);
1606 1 : status = libspdm_get_response_chunk_send(
1607 : spdm_context,
1608 : request_size, request,
1609 : &response_size, response);
1610 :
1611 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1612 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1613 : + sizeof(spdm_error_response_t));
1614 :
1615 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1616 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1617 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1618 :
1619 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1620 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1621 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1622 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1623 1 : assert_int_equal(error_response->header.param2, 0);
1624 :
1625 1 : libspdm_test_responder_chunk_send_ack_reset_send_state(spdm_context);
1626 1 : }
1627 :
1628 : /**
1629 : * Test 18: Request missing LAST_CHUNK after all bytes transferred.
1630 : **/
1631 1 : static void rsp_chunk_send_ack_case18(void** state)
1632 : {
1633 : libspdm_return_t status;
1634 :
1635 : libspdm_test_context_t* spdm_test_context;
1636 : libspdm_context_t* spdm_context;
1637 :
1638 : size_t request_size;
1639 : size_t response_size;
1640 :
1641 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1642 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1643 :
1644 : spdm_chunk_send_request_t* chunk_send_request;
1645 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1646 : spdm_error_response_t* error_response;
1647 :
1648 : const uint8_t* chunk_src;
1649 : uint8_t* chunk_dst;
1650 :
1651 1 : spdm_test_context = *state;
1652 1 : spdm_context = spdm_test_context->spdm_context;
1653 1 : spdm_test_context->case_id = 18;
1654 :
1655 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1656 1 : spdm_context->chunk_context.send.chunk_in_use = true;
1657 1 : spdm_context->chunk_context.send.chunk_handle = (uint8_t) spdm_test_context->case_id;
1658 1 : spdm_context->chunk_context.send.chunk_seq_no = 0;
1659 1 : spdm_context->chunk_context.send.large_message_size = 1024;
1660 1 : spdm_context->chunk_context.send.chunk_bytes_transferred = 1022;
1661 :
1662 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1663 :
1664 1 : libspdm_zero_mem(request, sizeof(request));
1665 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1666 :
1667 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1668 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1669 1 : chunk_send_request->header.param1 = 0;
1670 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
1671 1 : chunk_send_request->chunk_seq_no = 0;
1672 1 : chunk_send_request->chunk_size = 2;
1673 :
1674 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1));
1675 :
1676 1 : request_size = sizeof(spdm_chunk_send_request_t)
1677 1 : + chunk_send_request->chunk_size;
1678 :
1679 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1680 1 : chunk_src, chunk_send_request->chunk_size);
1681 :
1682 1 : response_size = sizeof(response);
1683 1 : status = libspdm_get_response_chunk_send(
1684 : spdm_context,
1685 : request_size, request,
1686 : &response_size, response);
1687 :
1688 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1689 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1690 : + sizeof(spdm_error_response_t));
1691 :
1692 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1693 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1694 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1695 :
1696 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1697 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1698 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1699 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1700 1 : assert_int_equal(error_response->header.param2, 0);
1701 :
1702 1 : libspdm_test_responder_chunk_send_ack_reset_send_state(spdm_context);
1703 1 : }
1704 :
1705 : /**
1706 : * Test 19: Request missing LAST_CHUNK when request size != data transfer size.
1707 : **/
1708 1 : static void rsp_chunk_send_ack_case19(void** state)
1709 : {
1710 : libspdm_return_t status;
1711 :
1712 : libspdm_test_context_t* spdm_test_context;
1713 : libspdm_context_t* spdm_context;
1714 :
1715 : size_t request_size;
1716 : size_t response_size;
1717 :
1718 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1719 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1720 :
1721 : spdm_chunk_send_request_t* chunk_send_request;
1722 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1723 : spdm_error_response_t* error_response;
1724 :
1725 : const uint8_t* chunk_src;
1726 : uint8_t* chunk_dst;
1727 :
1728 1 : spdm_test_context = *state;
1729 1 : spdm_context = spdm_test_context->spdm_context;
1730 1 : spdm_test_context->case_id = 19;
1731 :
1732 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1733 1 : spdm_context->chunk_context.send.chunk_in_use = true;
1734 1 : spdm_context->chunk_context.send.chunk_handle = (uint8_t) spdm_test_context->case_id;
1735 1 : spdm_context->chunk_context.send.chunk_seq_no = 0;
1736 1 : spdm_context->chunk_context.send.large_message_size = 1024;
1737 1 : spdm_context->chunk_context.send.chunk_bytes_transferred = 0;
1738 :
1739 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1740 :
1741 1 : libspdm_zero_mem(request, sizeof(request));
1742 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1743 :
1744 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1745 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1746 1 : chunk_send_request->header.param1 = 0;
1747 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
1748 1 : chunk_send_request->chunk_seq_no = 0;
1749 1 : chunk_send_request->chunk_size =
1750 1 : spdm_context->local_context.capability.data_transfer_size
1751 : - sizeof(spdm_chunk_send_request_t)
1752 1 : - 1; /* Chunk size too small. */
1753 :
1754 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1));
1755 :
1756 1 : request_size = sizeof(spdm_chunk_send_request_t)
1757 1 : + chunk_send_request->chunk_size;
1758 :
1759 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1760 1 : chunk_src, chunk_send_request->chunk_size);
1761 :
1762 1 : response_size = sizeof(response);
1763 1 : status = libspdm_get_response_chunk_send(
1764 : spdm_context,
1765 : request_size, request,
1766 : &response_size, response);
1767 :
1768 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1769 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1770 : + sizeof(spdm_error_response_t));
1771 :
1772 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1773 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1774 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1775 :
1776 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1777 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1778 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1779 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1780 1 : assert_int_equal(error_response->header.param2, 0);
1781 :
1782 1 : libspdm_test_responder_chunk_send_ack_reset_send_state(spdm_context);
1783 1 : }
1784 :
1785 : /**
1786 : * Test 20: Request chunk seq wrapped.
1787 : **/
1788 1 : static void rsp_chunk_send_ack_case20(void** state)
1789 : {
1790 : libspdm_return_t status;
1791 :
1792 : libspdm_test_context_t* spdm_test_context;
1793 : libspdm_context_t* spdm_context;
1794 :
1795 : size_t request_size;
1796 : size_t response_size;
1797 :
1798 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1799 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1800 :
1801 : spdm_chunk_send_request_t* chunk_send_request;
1802 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1803 : spdm_error_response_t* error_response;
1804 :
1805 : const uint8_t* chunk_src;
1806 : uint8_t* chunk_dst;
1807 :
1808 : /* Format the last chunk. */
1809 1 : spdm_test_context = *state;
1810 1 : spdm_context = spdm_test_context->spdm_context;
1811 1 : spdm_test_context->case_id = 20;
1812 :
1813 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1814 1 : spdm_context->chunk_context.send.chunk_in_use = true;
1815 1 : spdm_context->chunk_context.send.chunk_handle = (uint8_t) spdm_test_context->case_id;
1816 1 : spdm_context->chunk_context.send.chunk_seq_no = 65535; /* maximum chunk seq received */
1817 1 : spdm_context->chunk_context.send.large_message_size = 0x10000;
1818 1 : spdm_context->chunk_context.send.chunk_bytes_transferred = 0x8000;
1819 :
1820 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1821 :
1822 1 : libspdm_zero_mem(request, sizeof(request));
1823 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1824 :
1825 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1826 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1827 1 : chunk_send_request->header.param1 = 0;
1828 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
1829 1 : chunk_send_request->chunk_seq_no = 0; /* chunk seq wrapped */
1830 :
1831 1 : chunk_send_request->chunk_size =
1832 1 : spdm_context->local_context.capability.data_transfer_size
1833 1 : - sizeof(spdm_chunk_send_request_t);
1834 :
1835 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1));
1836 :
1837 1 : request_size = sizeof(spdm_chunk_send_request_t)
1838 1 : + chunk_send_request->chunk_size;
1839 :
1840 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1841 1 : chunk_src, chunk_send_request->chunk_size);
1842 :
1843 1 : response_size = sizeof(response);
1844 1 : status = libspdm_get_response_chunk_send(
1845 : spdm_context,
1846 : request_size, request,
1847 : &response_size, response);
1848 :
1849 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1850 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1851 : + sizeof(spdm_error_response_t));
1852 :
1853 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1854 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1855 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1856 :
1857 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1858 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1859 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1860 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1861 1 : assert_int_equal(error_response->header.param2, 0);
1862 :
1863 1 : libspdm_test_responder_chunk_send_ack_reset_send_state(spdm_context);
1864 1 : }
1865 :
1866 : /**
1867 : * Test 21: Request size exceed max chunk seq no.
1868 : **/
1869 1 : static void rsp_chunk_send_ack_case21(void** state)
1870 : {
1871 : libspdm_return_t status;
1872 :
1873 : libspdm_test_context_t* spdm_test_context;
1874 : libspdm_context_t* spdm_context;
1875 :
1876 : size_t request_size;
1877 : size_t response_size;
1878 :
1879 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1880 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1881 :
1882 : spdm_chunk_send_request_t* chunk_send_request;
1883 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1884 : spdm_error_response_t* error_response;
1885 :
1886 : const uint8_t* chunk_src;
1887 : uint8_t* chunk_dst;
1888 :
1889 : /* Format the last chunk. */
1890 1 : spdm_test_context = *state;
1891 1 : spdm_context = spdm_test_context->spdm_context;
1892 1 : spdm_test_context->case_id = 21;
1893 :
1894 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1895 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1896 :
1897 1 : libspdm_zero_mem(request, sizeof(request));
1898 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1899 :
1900 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1901 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1902 1 : chunk_send_request->header.param1 = 0;
1903 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
1904 1 : chunk_send_request->chunk_seq_no = 0;
1905 :
1906 :
1907 1 : *((uint32_t*) (chunk_send_request + 1)) = 0x1000000; /* a size exceed max chunk seq */
1908 1 : chunk_send_request->chunk_size =
1909 1 : spdm_context->local_context.capability.data_transfer_size
1910 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
1911 :
1912 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
1913 :
1914 1 : request_size = sizeof(spdm_chunk_send_request_t)
1915 : + sizeof(uint32_t)
1916 1 : + chunk_send_request->chunk_size;
1917 :
1918 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1919 1 : chunk_src, chunk_send_request->chunk_size);
1920 :
1921 1 : response_size = sizeof(response);
1922 1 : status = libspdm_get_response_chunk_send(
1923 : spdm_context,
1924 : request_size, request,
1925 : &response_size, response);
1926 :
1927 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1928 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1929 : + sizeof(spdm_error_response_t));
1930 :
1931 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1932 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1933 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1934 :
1935 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1936 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1937 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1938 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1939 1 : assert_int_equal(error_response->header.param2, 0);
1940 :
1941 1 : libspdm_test_responder_chunk_send_ack_reset_send_state(spdm_context);
1942 1 : }
1943 :
1944 :
1945 : /* Test sending large NegAlg Request in multiple chunks, spdm 1.4 */
1946 1 : static void rsp_chunk_send_ack_case22(void** state)
1947 : {
1948 : libspdm_return_t status;
1949 :
1950 : libspdm_test_context_t* spdm_test_context;
1951 : libspdm_context_t* spdm_context;
1952 :
1953 : size_t request_size;
1954 : size_t response_size;
1955 :
1956 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1957 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1958 :
1959 : spdm_chunk_send_request_14_t *chunk_send_request;
1960 : spdm_chunk_send_ack_response_14_t* chunk_send_ack_response;
1961 : spdm_algorithms_response_t *algorithms_response;
1962 : size_t algorithms_response_size;
1963 :
1964 : const uint8_t* chunk_src;
1965 : uint8_t* chunk_dst;
1966 : uint16_t chunk_num;
1967 : uint32_t bytes_sent;
1968 : uint32_t bytes_total;
1969 :
1970 : void *scratch_buffer;
1971 : size_t scratch_buffer_size;
1972 : uint8_t *large_message;
1973 : size_t large_message_capacity;
1974 : size_t i;
1975 :
1976 1 : spdm_test_context = *state;
1977 1 : spdm_context = spdm_test_context->spdm_context;
1978 1 : spdm_test_context->case_id = 22;
1979 :
1980 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1981 :
1982 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_14 <<
1983 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1984 1 : m_libspdm_chunk_send_negotiate_algorithm_request22.spdm_request_version10.base_hash_algo =
1985 : m_libspdm_use_hash_algo;
1986 1 : m_libspdm_chunk_send_negotiate_algorithm_request22.spdm_request_version10.base_asym_algo =
1987 : m_libspdm_use_asym_algo;
1988 :
1989 1 : chunk_num = 0;
1990 1 : bytes_sent = 0;
1991 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request22);
1992 1 : chunk_src = (const uint8_t *)&m_libspdm_chunk_send_negotiate_algorithm_request22;
1993 :
1994 : do {
1995 2 : libspdm_zero_mem(request, sizeof(request));
1996 2 : chunk_send_request = (spdm_chunk_send_request_14_t*)request;
1997 :
1998 2 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_14;
1999 2 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
2000 2 : chunk_send_request->header.param1 = 0;
2001 2 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
2002 2 : chunk_send_request->chunk_seq_no = chunk_num;
2003 :
2004 2 : if (chunk_num == 0) {
2005 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
2006 1 : chunk_send_request->chunk_size =
2007 1 : spdm_context->local_context.capability.data_transfer_size
2008 1 : - sizeof(spdm_chunk_send_request_14_t) - sizeof(uint32_t);
2009 :
2010 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
2011 :
2012 1 : request_size = sizeof(spdm_chunk_send_request_14_t)
2013 : + sizeof(uint32_t)
2014 1 : + chunk_send_request->chunk_size;
2015 : } else {
2016 1 : chunk_send_request->chunk_size =
2017 1 : LIBSPDM_MIN(
2018 : spdm_context->local_context.capability.data_transfer_size
2019 : - sizeof(spdm_chunk_send_request_14_t),
2020 : bytes_total - bytes_sent);
2021 :
2022 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1));
2023 :
2024 1 : request_size = sizeof(spdm_chunk_send_request_14_t)
2025 1 : + chunk_send_request->chunk_size;
2026 :
2027 1 : if (bytes_total - bytes_sent == chunk_send_request->chunk_size) {
2028 1 : chunk_send_request->header.param1 = SPDM_CHUNK_SEND_REQUEST_ATTRIBUTE_LAST_CHUNK;
2029 : }
2030 : }
2031 :
2032 2 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
2033 2 : chunk_src, chunk_send_request->chunk_size);
2034 :
2035 2 : chunk_src += chunk_send_request->chunk_size;
2036 2 : bytes_sent += chunk_send_request->chunk_size;
2037 2 : chunk_num++;
2038 :
2039 2 : response_size = sizeof(response);
2040 2 : status = libspdm_get_response_chunk_send(
2041 : spdm_context,
2042 : request_size, request,
2043 : &response_size, response);
2044 :
2045 2 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2046 2 : assert_true(response_size >= sizeof(spdm_chunk_send_ack_response_14_t));
2047 :
2048 2 : chunk_send_ack_response = (spdm_chunk_send_ack_response_14_t*) response;
2049 2 : assert_int_equal(chunk_send_ack_response->header.spdm_version, SPDM_MESSAGE_VERSION_14);
2050 2 : assert_int_equal(chunk_send_ack_response->header.request_response_code,
2051 : SPDM_CHUNK_SEND_ACK);
2052 2 : assert_int_equal(chunk_send_ack_response->header.param1, 0);
2053 2 : assert_int_equal(chunk_send_ack_response->header.param2, spdm_test_context->case_id);
2054 2 : assert_int_equal(chunk_send_ack_response->chunk_seq_no, chunk_send_request->chunk_seq_no);
2055 :
2056 2 : } while (bytes_sent < bytes_total);
2057 :
2058 1 : algorithms_response = (spdm_algorithms_response_t*) (chunk_send_ack_response + 1);
2059 1 : algorithms_response_size = response_size - sizeof(spdm_chunk_send_ack_response_14_t);
2060 1 : assert_int_equal(algorithms_response->header.request_response_code, SPDM_ALGORITHMS);
2061 :
2062 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2063 1 : assert_int_equal(algorithms_response_size,
2064 : sizeof(spdm_algorithms_response_t) + 4 *
2065 : sizeof(spdm_negotiate_algorithms_common_struct_table_t));
2066 1 : assert_int_equal(algorithms_response->header.spdm_version, SPDM_MESSAGE_VERSION_14);
2067 1 : assert_int_equal(algorithms_response->header.request_response_code, SPDM_ALGORITHMS);
2068 1 : assert_int_equal(algorithms_response->header.param1, 4);
2069 :
2070 1 : assert_false(spdm_context->chunk_context.send.chunk_in_use);
2071 1 : assert_null(spdm_context->chunk_context.send.large_message);
2072 1 : assert_int_equal(spdm_context->chunk_context.send.large_message_size, 0);
2073 1 : assert_int_equal(spdm_context->chunk_context.send.large_message_capacity, 0);
2074 :
2075 1 : libspdm_get_scratch_buffer(spdm_context, &scratch_buffer, &scratch_buffer_size);
2076 2 : large_message = (uint8_t *)scratch_buffer +
2077 1 : libspdm_get_scratch_buffer_large_message_offset(spdm_context);
2078 1 : large_message_capacity = libspdm_get_scratch_buffer_large_message_capacity(spdm_context);
2079 4609 : for (i = 0; i < large_message_capacity; i++) {
2080 4608 : assert_int_equal(large_message[i], 0);
2081 : }
2082 1 : }
2083 :
2084 1 : int libspdm_rsp_chunk_send_ack_test(void)
2085 : {
2086 1 : const struct CMUnitTest test_cases[] = {
2087 : /* Responder sent multiple chunks and processed correctly */
2088 : cmocka_unit_test(rsp_chunk_send_ack_case0),
2089 : /* Responder has no response flag chunk cap */
2090 : cmocka_unit_test(rsp_chunk_send_ack_case1),
2091 : /* Responder has bad response state */
2092 : cmocka_unit_test(rsp_chunk_send_ack_case2),
2093 : /* Responder has connection state <= NOT_START */
2094 : cmocka_unit_test(rsp_chunk_send_ack_case3),
2095 : /* Request has wrong size */
2096 : cmocka_unit_test(rsp_chunk_send_ack_case4),
2097 : /* Request has SPDM version less than 1.2*/
2098 : cmocka_unit_test(rsp_chunk_send_ack_case5),
2099 : /* Request has SPDM version not matching connection */
2100 : cmocka_unit_test(rsp_chunk_send_ack_case6),
2101 : /* Responder is already in chunking mode */
2102 : cmocka_unit_test(rsp_chunk_send_ack_case7),
2103 :
2104 : /* First request has bad sequence number */
2105 : cmocka_unit_test(rsp_chunk_send_ack_case8),
2106 : /* First request has chunk size too large */
2107 : cmocka_unit_test(rsp_chunk_send_ack_case9),
2108 : /* First request has size larger than data transfer size */
2109 : cmocka_unit_test(rsp_chunk_send_ack_case10),
2110 : /* Large message size larger than max SPDM message size. */
2111 : cmocka_unit_test(rsp_chunk_send_ack_case11),
2112 : /* First request has LAST CHUNK bit set. */
2113 : cmocka_unit_test(rsp_chunk_send_ack_case12),
2114 :
2115 : /* Request has bad sequence number */
2116 : cmocka_unit_test(rsp_chunk_send_ack_case13),
2117 : /* Request has bad chunk handle */
2118 : cmocka_unit_test(rsp_chunk_send_ack_case14),
2119 : /* Request has chunk size too large for request*/
2120 : cmocka_unit_test(rsp_chunk_send_ack_case15),
2121 : /* Request has chunk size + transferred size > large message size */
2122 : cmocka_unit_test(rsp_chunk_send_ack_case16),
2123 : /* Request has LAST_CHUNK indicated before all bytes transferred. */
2124 : cmocka_unit_test(rsp_chunk_send_ack_case17),
2125 : /* Request missing LAST_CHUNK after all bytes transferred. */
2126 : cmocka_unit_test(rsp_chunk_send_ack_case18),
2127 : /* Request missing LAST_CHUNK when request size != data transfer size. */
2128 : cmocka_unit_test(rsp_chunk_send_ack_case19),
2129 : /* Request chunk seq wrapped. */
2130 : cmocka_unit_test(rsp_chunk_send_ack_case20),
2131 : /* Request size exceed max chunk seq no. */
2132 : cmocka_unit_test(rsp_chunk_send_ack_case21),
2133 :
2134 : /* Responder sent multiple chunks and processed correctly, spdm 1.4 */
2135 : cmocka_unit_test(rsp_chunk_send_ack_case22),
2136 : };
2137 :
2138 1 : libspdm_test_context_t test_context = {
2139 : LIBSPDM_TEST_CONTEXT_VERSION,
2140 : false,
2141 : };
2142 :
2143 1 : libspdm_setup_test_context(&test_context);
2144 :
2145 1 : return cmocka_run_group_tests(test_cases,
2146 : libspdm_unit_test_group_setup,
2147 : libspdm_unit_test_group_teardown);
2148 : }
2149 :
2150 : #endif /* LIBSPDM_ENABLE_CAPABILITY_CHUNK_CAP*/
|
