Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2025 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : #include "spdm_unit_test.h"
8 : #include "internal/libspdm_responder_lib.h"
9 :
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 : {
24 : SPDM_MESSAGE_VERSION_12,
25 : SPDM_NEGOTIATE_ALGORITHMS,
26 : 4,
27 : 0
28 : },
29 : sizeof(libspdm_negotiate_algorithms_request_spdm_tables_t),
30 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
31 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1,
32 : },
33 : {
34 : {
35 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
36 : 0x20,
37 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
38 : },
39 : {
40 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
41 : 0x20,
42 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
43 : },
44 : {
45 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
46 : 0x20,
47 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
48 : },
49 : {
50 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
51 : 0x20,
52 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
53 : }
54 : }
55 : };
56 :
57 : size_t m_libspdm_chunk_send_negotiate_algorithm_request1_size =
58 : sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
59 :
60 22 : void libspdm_test_responder_chunk_send_ack_setup_algo_state(libspdm_context_t* spdm_context)
61 : {
62 : /* This state is copied form Algorithms test case 22 */
63 22 : m_libspdm_chunk_send_negotiate_algorithm_request1.spdm_request_version10.base_hash_algo =
64 : m_libspdm_use_hash_algo;
65 22 : m_libspdm_chunk_send_negotiate_algorithm_request1.spdm_request_version10.base_asym_algo =
66 : m_libspdm_use_asym_algo;
67 :
68 22 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
69 22 : spdm_context->connection_info.connection_state =
70 : LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
71 :
72 22 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
73 : SPDM_VERSION_NUMBER_SHIFT_BIT;
74 22 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
75 22 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
76 22 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
77 22 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
78 22 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
79 22 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
80 22 : spdm_context->local_context.algorithm.other_params_support =
81 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
82 : /* spdm_context->connection_info.algorithm.other_params_support = SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1; */
83 22 : libspdm_reset_message_a(spdm_context);
84 22 : spdm_context->local_context.capability.flags = 0;
85 22 : spdm_context->connection_info.capability.flags = 0;
86 22 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
87 22 : spdm_context->connection_info.capability.flags |=
88 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
89 :
90 22 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
91 22 : spdm_context->connection_info.capability.flags |=
92 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
93 :
94 22 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
95 22 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
96 :
97 22 : spdm_context->local_context.capability.flags |=
98 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
99 22 : spdm_context->connection_info.capability.flags |=
100 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
101 :
102 22 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
103 22 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
104 :
105 22 : spdm_context->local_context.capability.data_transfer_size =
106 : CHUNK_SEND_ACK_RESPONDER_UNIT_TEST_DATA_TRANSFER_SIZE;
107 :
108 22 : spdm_context->local_context.capability.flags |=
109 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP;
110 22 : spdm_context->connection_info.capability.flags |=
111 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP;
112 22 : }
113 :
114 : /* Test sending large NegAlg Request in multiple chunks. */
115 1 : void libspdm_test_responder_chunk_send_ack_rsp_case0(void** state)
116 : {
117 : libspdm_return_t status;
118 :
119 : libspdm_test_context_t* spdm_test_context;
120 : libspdm_context_t* spdm_context;
121 :
122 : size_t request_size;
123 : size_t response_size;
124 :
125 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
126 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
127 :
128 : spdm_chunk_send_request_t *chunk_send_request;
129 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
130 : spdm_algorithms_response_t *algorithms_response;
131 : size_t algorithms_response_size;
132 :
133 : const uint8_t* chunk_src;
134 : uint8_t* chunk_dst;
135 : uint16_t chunk_num;
136 : uint32_t bytes_sent;
137 : uint32_t bytes_total;
138 :
139 1 : spdm_test_context = *state;
140 1 : spdm_context = spdm_test_context->spdm_context;
141 1 : spdm_test_context->case_id = 0;
142 :
143 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
144 :
145 1 : chunk_num = 0;
146 1 : bytes_sent = 0;
147 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
148 1 : chunk_src = (const uint8_t *)&m_libspdm_chunk_send_negotiate_algorithm_request1;
149 :
150 : do {
151 2 : libspdm_zero_mem(request, sizeof(request));
152 2 : chunk_send_request = (spdm_chunk_send_request_t*)request;
153 :
154 2 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
155 2 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
156 2 : chunk_send_request->header.param1 = 0;
157 2 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
158 2 : chunk_send_request->chunk_seq_no = chunk_num;
159 :
160 2 : if (chunk_num == 0) {
161 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
162 1 : chunk_send_request->chunk_size =
163 1 : spdm_context->local_context.capability.data_transfer_size
164 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
165 :
166 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
167 :
168 1 : request_size = sizeof(spdm_chunk_send_request_t)
169 : + sizeof(uint32_t)
170 1 : + chunk_send_request->chunk_size;
171 : } else {
172 1 : chunk_send_request->chunk_size =
173 1 : LIBSPDM_MIN(
174 : spdm_context->local_context.capability.data_transfer_size
175 : - sizeof(spdm_chunk_send_request_t),
176 : bytes_total - bytes_sent);
177 :
178 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1));
179 :
180 1 : request_size = sizeof(spdm_chunk_send_request_t)
181 1 : + chunk_send_request->chunk_size;
182 :
183 1 : if (bytes_total - bytes_sent == chunk_send_request->chunk_size) {
184 1 : chunk_send_request->header.param1 = SPDM_CHUNK_SEND_REQUEST_ATTRIBUTE_LAST_CHUNK;
185 : }
186 : }
187 :
188 2 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
189 2 : chunk_src, chunk_send_request->chunk_size);
190 :
191 2 : chunk_src += chunk_send_request->chunk_size;
192 2 : bytes_sent += chunk_send_request->chunk_size;
193 2 : chunk_num++;
194 :
195 2 : response_size = sizeof(response);
196 2 : status = libspdm_get_response_chunk_send(
197 : spdm_context,
198 : request_size, request,
199 : &response_size, response);
200 :
201 2 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
202 2 : assert_true(response_size >= sizeof(spdm_chunk_send_ack_response_t));
203 :
204 2 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
205 2 : assert_int_equal(chunk_send_ack_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
206 2 : assert_int_equal(chunk_send_ack_response->header.request_response_code,
207 : SPDM_CHUNK_SEND_ACK);
208 2 : assert_int_equal(chunk_send_ack_response->header.param1, 0);
209 2 : assert_int_equal(chunk_send_ack_response->header.param2, spdm_test_context->case_id);
210 2 : assert_int_equal(chunk_send_ack_response->chunk_seq_no, chunk_send_request->chunk_seq_no);
211 :
212 2 : } while (bytes_sent < bytes_total);
213 :
214 1 : algorithms_response = (spdm_algorithms_response_t*) (chunk_send_ack_response + 1);
215 1 : algorithms_response_size = response_size - sizeof(spdm_chunk_send_ack_response_t);
216 1 : assert_int_equal(algorithms_response->header.request_response_code, SPDM_ALGORITHMS);
217 :
218 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
219 1 : assert_int_equal(algorithms_response_size,
220 : sizeof(spdm_algorithms_response_t) + 4 *
221 : sizeof(spdm_negotiate_algorithms_common_struct_table_t));
222 1 : assert_int_equal(algorithms_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
223 1 : assert_int_equal(algorithms_response->header.request_response_code, SPDM_ALGORITHMS);
224 1 : assert_int_equal(algorithms_response->header.param1, 4);
225 1 : }
226 :
227 : /**
228 : * Test 1: Responder receives a CHUNK_SEND request without chunk capabilities.
229 : * Expected Behavior: Returns ERROR response message with an error code.
230 : **/
231 1 : void libspdm_test_responder_chunk_send_ack_rsp_case1(void** state)
232 : {
233 : libspdm_return_t status;
234 :
235 : libspdm_test_context_t* spdm_test_context;
236 : libspdm_context_t* spdm_context;
237 :
238 : size_t request_size;
239 : size_t response_size;
240 :
241 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
242 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
243 :
244 : spdm_chunk_send_request_t* chunk_send_request;
245 : spdm_error_response_t* error_response;
246 :
247 : const uint8_t* chunk_src;
248 : uint8_t* chunk_dst;
249 : uint16_t chunk_num;
250 : uint32_t bytes_total;
251 :
252 1 : spdm_test_context = *state;
253 1 : spdm_context = spdm_test_context->spdm_context;
254 1 : spdm_test_context->case_id = 1;
255 :
256 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
257 :
258 1 : spdm_context->local_context.capability.flags &=
259 : ~SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP;
260 1 : spdm_context->connection_info.capability.flags |=
261 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP;
262 :
263 1 : chunk_num = 0;
264 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
265 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
266 :
267 1 : libspdm_zero_mem(request, sizeof(request));
268 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
269 :
270 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
271 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
272 1 : chunk_send_request->header.param1 = 0;
273 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
274 1 : chunk_send_request->chunk_seq_no = chunk_num;
275 :
276 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
277 1 : chunk_send_request->chunk_size =
278 1 : spdm_context->local_context.capability.data_transfer_size
279 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
280 :
281 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
282 :
283 1 : request_size = sizeof(spdm_chunk_send_request_t)
284 : + sizeof(uint32_t)
285 1 : + chunk_send_request->chunk_size;
286 :
287 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
288 1 : chunk_src, chunk_send_request->chunk_size);
289 :
290 1 : response_size = sizeof(response);
291 1 : status = libspdm_get_response_chunk_send(
292 : spdm_context,
293 : request_size, request,
294 : &response_size, response);
295 :
296 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
297 1 : assert_true(response_size == sizeof(spdm_error_response_t));
298 :
299 1 : error_response = (spdm_error_response_t*) response;
300 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
301 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
302 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
303 1 : assert_int_equal(error_response->header.param2, 0);
304 1 : }
305 :
306 : /**
307 : * Test 2: Responder receives a CHUNK_SEND request with bad response state.
308 : * Expected Behavior: Returns ERROR response message
309 : * with request_response_code as error code.
310 : **/
311 1 : void libspdm_test_responder_chunk_send_ack_rsp_case2(void** state)
312 : {
313 : libspdm_return_t status;
314 :
315 : libspdm_test_context_t* spdm_test_context;
316 : libspdm_context_t* spdm_context;
317 :
318 : size_t request_size;
319 : size_t response_size;
320 :
321 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
322 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
323 :
324 : spdm_chunk_send_request_t* chunk_send_request;
325 : spdm_error_response_t* error_response;
326 :
327 : const uint8_t* chunk_src;
328 : uint8_t* chunk_dst;
329 : uint16_t chunk_num;
330 : uint32_t bytes_total;
331 :
332 1 : spdm_test_context = *state;
333 1 : spdm_context = spdm_test_context->spdm_context;
334 1 : spdm_test_context->case_id = 2;
335 :
336 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
337 :
338 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_BUSY;
339 :
340 1 : chunk_num = 0;
341 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
342 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
343 :
344 1 : libspdm_zero_mem(request, sizeof(request));
345 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
346 :
347 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
348 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
349 1 : chunk_send_request->header.param1 = 0;
350 1 : chunk_send_request->header.param2 = (uint8_t)spdm_test_context->case_id; /* chunk_handle */
351 1 : chunk_send_request->chunk_seq_no = chunk_num;
352 :
353 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
354 1 : chunk_send_request->chunk_size =
355 1 : spdm_context->local_context.capability.data_transfer_size
356 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
357 :
358 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
359 :
360 1 : request_size = sizeof(spdm_chunk_send_request_t)
361 : + sizeof(uint32_t)
362 1 : + chunk_send_request->chunk_size;
363 :
364 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
365 1 : chunk_src, chunk_send_request->chunk_size);
366 :
367 1 : response_size = sizeof(response);
368 1 : status = libspdm_get_response_chunk_send(
369 : spdm_context,
370 : request_size, request,
371 : &response_size, response);
372 :
373 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
374 1 : assert_true(response_size == sizeof(spdm_error_response_t));
375 :
376 1 : error_response = (spdm_error_response_t*) response;
377 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
378 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
379 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_BUSY);
380 1 : assert_int_equal(error_response->header.param2, 0);
381 1 : }
382 :
383 : /**
384 : * Test 3: Responder receives a CHUNK_SEND request with bad connection state.
385 : * Expected Behavior: Returns ERROR response message
386 : * with SPDM_ERROR_CODE_UNEXPECTED_REQUEST error code.
387 : **/
388 1 : void libspdm_test_responder_chunk_send_ack_rsp_case3(void** state)
389 : {
390 : libspdm_return_t status;
391 :
392 : libspdm_test_context_t* spdm_test_context;
393 : libspdm_context_t* spdm_context;
394 :
395 : size_t request_size;
396 : size_t response_size;
397 :
398 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
399 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
400 :
401 : spdm_chunk_send_request_t* chunk_send_request;
402 : spdm_error_response_t* error_response;
403 :
404 : const uint8_t* chunk_src;
405 : uint8_t* chunk_dst;
406 : uint16_t chunk_num;
407 : uint32_t bytes_total;
408 :
409 1 : spdm_test_context = *state;
410 1 : spdm_context = spdm_test_context->spdm_context;
411 1 : spdm_test_context->case_id = 3;
412 :
413 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
414 :
415 : spdm_context->connection_info.connection_state
416 1 : = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES - 1;
417 :
418 1 : chunk_num = 0;
419 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
420 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
421 :
422 1 : libspdm_zero_mem(request, sizeof(request));
423 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
424 :
425 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
426 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
427 1 : chunk_send_request->header.param1 = 0;
428 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
429 1 : chunk_send_request->chunk_seq_no = chunk_num;
430 :
431 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
432 1 : chunk_send_request->chunk_size =
433 1 : spdm_context->local_context.capability.data_transfer_size
434 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
435 :
436 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
437 :
438 1 : request_size = sizeof(spdm_chunk_send_request_t)
439 : + sizeof(uint32_t)
440 1 : + chunk_send_request->chunk_size;
441 :
442 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
443 1 : chunk_src, chunk_send_request->chunk_size);
444 :
445 1 : response_size = sizeof(response);
446 1 : status = libspdm_get_response_chunk_send(
447 : spdm_context,
448 : request_size, request,
449 : &response_size, response);
450 :
451 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
452 1 : assert_true(response_size == sizeof(spdm_error_response_t));
453 :
454 1 : error_response = (spdm_error_response_t*) response;
455 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
456 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
457 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
458 1 : assert_int_equal(error_response->header.param2, 0);
459 1 : }
460 :
461 :
462 : /**
463 : * Test 4: Responder receives a CHUNK_SEND request with bad size.
464 : * Expected Behavior: Returns ERROR response message
465 : * with SPDM_ERROR_CODE_INVALID_REQUEST error code.
466 : **/
467 1 : void libspdm_test_responder_chunk_send_ack_rsp_case4(void** state)
468 : {
469 : libspdm_return_t status;
470 :
471 : libspdm_test_context_t* spdm_test_context;
472 : libspdm_context_t* spdm_context;
473 :
474 : size_t request_size;
475 : size_t response_size;
476 :
477 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
478 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
479 :
480 : spdm_chunk_send_request_t* chunk_send_request;
481 : spdm_error_response_t* error_response;
482 :
483 : const uint8_t* chunk_src;
484 : uint8_t* chunk_dst;
485 : uint16_t chunk_num;
486 : uint32_t bytes_total;
487 :
488 1 : spdm_test_context = *state;
489 1 : spdm_context = spdm_test_context->spdm_context;
490 1 : spdm_test_context->case_id = 4;
491 :
492 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
493 :
494 1 : chunk_num = 0;
495 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
496 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
497 :
498 1 : libspdm_zero_mem(request, sizeof(request));
499 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
500 :
501 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
502 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
503 1 : chunk_send_request->header.param1 = 0;
504 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
505 1 : chunk_send_request->chunk_seq_no = chunk_num;
506 :
507 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
508 1 : chunk_send_request->chunk_size =
509 1 : spdm_context->local_context.capability.data_transfer_size
510 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
511 :
512 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
513 :
514 1 : request_size = sizeof(spdm_chunk_send_request_t)
515 : + sizeof(uint32_t)
516 1 : + chunk_send_request->chunk_size;
517 :
518 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
519 1 : chunk_src, chunk_send_request->chunk_size);
520 :
521 1 : response_size = sizeof(response);
522 1 : request_size = sizeof(spdm_chunk_send_request_t) - 1;
523 1 : status = libspdm_get_response_chunk_send(
524 : spdm_context,
525 : request_size, request,
526 : &response_size, response);
527 :
528 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
529 1 : assert_true(response_size == sizeof(spdm_error_response_t));
530 :
531 1 : error_response = (spdm_error_response_t*) response;
532 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
533 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
534 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
535 1 : assert_int_equal(error_response->header.param2, 0);
536 1 : }
537 : /**
538 : * Test 5: Responder receives a CHUNK_SEND request SPDM version less than 1.2.
539 : * Expected Behavior: Returns ERROR response message
540 : * with SPDM_ERROR_CODE_UNSUPPORTED_REQUEST error code.
541 : **/
542 1 : void libspdm_test_responder_chunk_send_ack_rsp_case5(void** state)
543 : {
544 : libspdm_return_t status;
545 :
546 : libspdm_test_context_t* spdm_test_context;
547 : libspdm_context_t* spdm_context;
548 :
549 : size_t request_size;
550 : size_t response_size;
551 :
552 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
553 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
554 :
555 : spdm_chunk_send_request_t* chunk_send_request;
556 : spdm_error_response_t* error_response;
557 :
558 : const uint8_t* chunk_src;
559 : uint8_t* chunk_dst;
560 : uint16_t chunk_num;
561 : uint32_t bytes_total;
562 :
563 1 : spdm_test_context = *state;
564 1 : spdm_context = spdm_test_context->spdm_context;
565 1 : spdm_test_context->case_id = 5;
566 :
567 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
568 :
569 1 : chunk_num = 0;
570 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
571 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
572 :
573 1 : libspdm_zero_mem(request, sizeof(request));
574 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
575 :
576 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_11;
577 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
578 1 : chunk_send_request->header.param1 = 0;
579 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
580 1 : chunk_send_request->chunk_seq_no = chunk_num;
581 :
582 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
583 1 : chunk_send_request->chunk_size =
584 1 : spdm_context->local_context.capability.data_transfer_size
585 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
586 :
587 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
588 :
589 1 : request_size = sizeof(spdm_chunk_send_request_t)
590 : + sizeof(uint32_t)
591 1 : + chunk_send_request->chunk_size;
592 :
593 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
594 1 : chunk_src, chunk_send_request->chunk_size);
595 :
596 1 : response_size = sizeof(response);
597 1 : status = libspdm_get_response_chunk_send(
598 : spdm_context,
599 : request_size, request,
600 : &response_size, response);
601 :
602 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
603 1 : assert_true(response_size == sizeof(spdm_error_response_t));
604 :
605 1 : error_response = (spdm_error_response_t*) response;
606 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
607 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
608 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_UNSUPPORTED_REQUEST);
609 1 : assert_int_equal(error_response->header.param2, SPDM_CHUNK_SEND);
610 1 : }
611 : /**
612 : * Test 6: Responder receives a CHUNK_SEND request with wrong SPDM version.
613 : * Expected Behavior: Returns ERROR response message
614 : * with SPDM_ERROR_CODE_VERSION_MISMATCH error code.
615 : **/
616 1 : void libspdm_test_responder_chunk_send_ack_rsp_case6(void** state)
617 : {
618 : libspdm_return_t status;
619 :
620 : libspdm_test_context_t* spdm_test_context;
621 : libspdm_context_t* spdm_context;
622 :
623 : size_t request_size;
624 : size_t response_size;
625 :
626 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
627 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
628 :
629 : spdm_chunk_send_request_t* chunk_send_request;
630 : spdm_error_response_t* error_response;
631 :
632 : const uint8_t* chunk_src;
633 : uint8_t* chunk_dst;
634 : uint16_t chunk_num;
635 : uint32_t bytes_total;
636 :
637 1 : spdm_test_context = *state;
638 1 : spdm_context = spdm_test_context->spdm_context;
639 1 : spdm_test_context->case_id = 6;
640 :
641 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
642 :
643 1 : chunk_num = 0;
644 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
645 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
646 :
647 1 : libspdm_zero_mem(request, sizeof(request));
648 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
649 :
650 1 : chunk_send_request->header.spdm_version = 0x13;
651 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
652 1 : chunk_send_request->header.param1 = 0;
653 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
654 1 : chunk_send_request->chunk_seq_no = chunk_num;
655 :
656 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
657 1 : chunk_send_request->chunk_size =
658 1 : spdm_context->local_context.capability.data_transfer_size
659 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
660 :
661 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
662 :
663 1 : request_size = sizeof(spdm_chunk_send_request_t)
664 : + sizeof(uint32_t)
665 1 : + chunk_send_request->chunk_size;
666 :
667 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
668 1 : chunk_src, chunk_send_request->chunk_size);
669 :
670 1 : response_size = sizeof(response);
671 1 : status = libspdm_get_response_chunk_send(
672 : spdm_context,
673 : request_size, request,
674 : &response_size, response);
675 :
676 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
677 1 : assert_true(response_size == sizeof(spdm_error_response_t));
678 :
679 1 : error_response = (spdm_error_response_t*) response;
680 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
681 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
682 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_VERSION_MISMATCH);
683 1 : assert_int_equal(error_response->header.param2, 0);
684 1 : }
685 :
686 : /**
687 : * Test 7: Responder gets chunk send when chunk get already in use.
688 : **/
689 1 : void libspdm_test_responder_chunk_send_ack_rsp_case7(void** state)
690 : {
691 : libspdm_return_t status;
692 :
693 : libspdm_test_context_t* spdm_test_context;
694 : libspdm_context_t* spdm_context;
695 :
696 : size_t request_size;
697 : size_t response_size;
698 :
699 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
700 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
701 :
702 : spdm_chunk_send_request_t* chunk_send_request;
703 : spdm_error_response_t* error_response;
704 :
705 : const uint8_t* chunk_src;
706 : uint8_t* chunk_dst;
707 : uint16_t chunk_num;
708 : uint32_t bytes_total;
709 :
710 1 : spdm_test_context = *state;
711 1 : spdm_context = spdm_test_context->spdm_context;
712 1 : spdm_test_context->case_id = 7;
713 :
714 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
715 1 : spdm_context->chunk_context.get.chunk_in_use = true;
716 :
717 1 : chunk_num = 0;
718 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
719 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
720 :
721 1 : libspdm_zero_mem(request, sizeof(request));
722 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
723 :
724 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
725 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
726 1 : chunk_send_request->header.param1 = 0;
727 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
728 1 : chunk_send_request->chunk_seq_no = chunk_num;
729 :
730 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
731 1 : chunk_send_request->chunk_size =
732 1 : spdm_context->local_context.capability.data_transfer_size
733 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
734 :
735 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
736 :
737 1 : request_size = sizeof(spdm_chunk_send_request_t)
738 : + sizeof(uint32_t)
739 1 : + chunk_send_request->chunk_size;
740 :
741 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
742 1 : chunk_src, chunk_send_request->chunk_size);
743 :
744 1 : response_size = sizeof(response);
745 1 : status = libspdm_get_response_chunk_send(
746 : spdm_context,
747 : request_size, request,
748 : &response_size, response);
749 :
750 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
751 1 : assert_true(response_size == sizeof(spdm_error_response_t));
752 :
753 1 : error_response = (spdm_error_response_t*) response;
754 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
755 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
756 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
757 1 : assert_int_equal(error_response->header.param2, 0);
758 :
759 1 : spdm_context->chunk_context.get.chunk_in_use = false;
760 1 : }
761 :
762 : /**
763 : * Test 8: First request has bad sequence number.
764 : **/
765 1 : void libspdm_test_responder_chunk_send_ack_rsp_case8(void** state)
766 : {
767 : libspdm_return_t status;
768 :
769 : libspdm_test_context_t* spdm_test_context;
770 : libspdm_context_t* spdm_context;
771 :
772 : size_t request_size;
773 : size_t response_size;
774 :
775 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
776 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
777 :
778 : spdm_chunk_send_request_t *chunk_send_request;
779 : spdm_chunk_send_ack_response_t *chunk_send_ack_response;
780 : spdm_error_response_t *error_response;
781 :
782 : const uint8_t *chunk_src;
783 : uint8_t *chunk_dst;
784 : uint32_t bytes_total;
785 :
786 1 : spdm_test_context = *state;
787 1 : spdm_context = spdm_test_context->spdm_context;
788 1 : spdm_test_context->case_id = 8;
789 :
790 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
791 :
792 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
793 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
794 :
795 1 : libspdm_zero_mem(request, sizeof(request));
796 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
797 :
798 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
799 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
800 1 : chunk_send_request->header.param1 = 0;
801 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
802 1 : chunk_send_request->chunk_seq_no = 1; /* Bad seq num */
803 :
804 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
805 1 : chunk_send_request->chunk_size =
806 1 : spdm_context->local_context.capability.data_transfer_size
807 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
808 :
809 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
810 :
811 1 : request_size = sizeof(spdm_chunk_send_request_t)
812 : + sizeof(uint32_t)
813 1 : + chunk_send_request->chunk_size;
814 :
815 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
816 1 : chunk_src, chunk_send_request->chunk_size);
817 :
818 1 : response_size = sizeof(response);
819 1 : status = libspdm_get_response_chunk_send(
820 : spdm_context,
821 : request_size, request,
822 : &response_size, response);
823 :
824 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
825 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
826 : + sizeof(spdm_error_response_t));
827 :
828 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
829 1 : assert_int_equal(chunk_send_ack_response->header.param1,
830 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
831 :
832 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
833 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
834 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
835 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
836 1 : assert_int_equal(error_response->header.param2, 0);
837 1 : }
838 :
839 : /**
840 : * Test 9: First request has chunk size too large.
841 : **/
842 1 : void libspdm_test_responder_chunk_send_ack_rsp_case9(void** state)
843 : {
844 : libspdm_return_t status;
845 :
846 : libspdm_test_context_t* spdm_test_context;
847 : libspdm_context_t* spdm_context;
848 :
849 : size_t request_size;
850 : size_t response_size;
851 :
852 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
853 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
854 :
855 : spdm_chunk_send_request_t* chunk_send_request;
856 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
857 : spdm_error_response_t* error_response;
858 :
859 : const uint8_t* chunk_src;
860 : uint8_t* chunk_dst;
861 : uint32_t bytes_total;
862 :
863 1 : spdm_test_context = *state;
864 1 : spdm_context = spdm_test_context->spdm_context;
865 1 : spdm_test_context->case_id = 9;
866 :
867 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
868 :
869 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
870 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
871 :
872 1 : libspdm_zero_mem(request, sizeof(request));
873 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
874 :
875 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
876 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
877 1 : chunk_send_request->header.param1 = 0;
878 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
879 1 : chunk_send_request->chunk_seq_no = 0;
880 :
881 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
882 1 : chunk_send_request->chunk_size =
883 1 : spdm_context->local_context.capability.data_transfer_size
884 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
885 :
886 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
887 :
888 1 : request_size = sizeof(spdm_chunk_send_request_t)
889 : + sizeof(uint32_t)
890 1 : + chunk_send_request->chunk_size;
891 :
892 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
893 1 : chunk_src, chunk_send_request->chunk_size);
894 :
895 1 : chunk_send_request->chunk_size += 1; /* chunk size too large */
896 :
897 1 : response_size = sizeof(response);
898 1 : status = libspdm_get_response_chunk_send(
899 : spdm_context,
900 : request_size, request,
901 : &response_size, response);
902 :
903 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
904 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
905 : + sizeof(spdm_error_response_t));
906 :
907 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
908 1 : assert_int_equal(chunk_send_ack_response->header.param1,
909 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
910 :
911 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
912 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
913 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
914 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
915 1 : assert_int_equal(error_response->header.param2, 0);
916 1 : }
917 :
918 : /**
919 : * Test 10: First request has size larger than data transfer size.
920 : **/
921 1 : void libspdm_test_responder_chunk_send_ack_rsp_case10(void** state)
922 : {
923 : libspdm_return_t status;
924 :
925 : libspdm_test_context_t* spdm_test_context;
926 : libspdm_context_t* spdm_context;
927 :
928 : size_t request_size;
929 : size_t response_size;
930 :
931 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
932 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
933 :
934 : spdm_chunk_send_request_t* chunk_send_request;
935 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
936 : spdm_error_response_t* error_response;
937 :
938 : const uint8_t* chunk_src;
939 : uint8_t* chunk_dst;
940 : uint32_t bytes_total;
941 :
942 1 : spdm_test_context = *state;
943 1 : spdm_context = spdm_test_context->spdm_context;
944 1 : spdm_test_context->case_id = 10;
945 :
946 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
947 :
948 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
949 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
950 :
951 1 : libspdm_zero_mem(request, sizeof(request));
952 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
953 :
954 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
955 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
956 1 : chunk_send_request->header.param1 = 0;
957 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
958 1 : chunk_send_request->chunk_seq_no = 0;
959 :
960 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
961 1 : chunk_send_request->chunk_size =
962 1 : spdm_context->local_context.capability.data_transfer_size
963 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
964 :
965 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
966 :
967 1 : request_size = sizeof(spdm_chunk_send_request_t)
968 : + sizeof(uint32_t)
969 1 : + chunk_send_request->chunk_size
970 : + 1; /* Request size too large */
971 :
972 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
973 1 : chunk_src, chunk_send_request->chunk_size);
974 :
975 1 : response_size = sizeof(response);
976 1 : status = libspdm_get_response_chunk_send(
977 : spdm_context,
978 : request_size, request,
979 : &response_size, response);
980 :
981 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
982 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
983 : + sizeof(spdm_error_response_t));
984 :
985 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
986 1 : assert_int_equal(chunk_send_ack_response->header.param1,
987 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
988 :
989 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
990 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
991 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
992 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
993 1 : assert_int_equal(error_response->header.param2, 0);
994 1 : }
995 :
996 : /**
997 : * Test 11: First request has LAST CHUNK bit set.
998 : **/
999 1 : void libspdm_test_responder_chunk_send_ack_rsp_case11(void** state)
1000 : {
1001 : libspdm_return_t status;
1002 :
1003 : libspdm_test_context_t* spdm_test_context;
1004 : libspdm_context_t* spdm_context;
1005 :
1006 : size_t request_size;
1007 : size_t response_size;
1008 :
1009 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1010 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1011 :
1012 : spdm_chunk_send_request_t* chunk_send_request;
1013 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1014 : spdm_error_response_t* error_response;
1015 :
1016 : const uint8_t* chunk_src;
1017 : uint8_t* chunk_dst;
1018 :
1019 1 : spdm_test_context = *state;
1020 1 : spdm_context = spdm_test_context->spdm_context;
1021 1 : spdm_test_context->case_id = 11;
1022 :
1023 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1024 :
1025 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1026 :
1027 1 : libspdm_zero_mem(request, sizeof(request));
1028 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1029 :
1030 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1031 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1032 1 : chunk_send_request->header.param1 = 0;
1033 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
1034 1 : chunk_send_request->chunk_seq_no = 0;
1035 :
1036 1 : *((uint32_t*) (chunk_send_request + 1)) = LIBSPDM_MAX_SPDM_MSG_SIZE + 1;
1037 :
1038 1 : chunk_send_request->chunk_size =
1039 1 : spdm_context->local_context.capability.data_transfer_size
1040 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
1041 :
1042 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
1043 :
1044 1 : request_size = sizeof(spdm_chunk_send_request_t)
1045 : + sizeof(uint32_t)
1046 1 : + chunk_send_request->chunk_size;
1047 :
1048 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1049 1 : chunk_src, chunk_send_request->chunk_size);
1050 :
1051 1 : response_size = sizeof(response);
1052 1 : status = libspdm_get_response_chunk_send(
1053 : spdm_context,
1054 : request_size, request,
1055 : &response_size, response);
1056 :
1057 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1058 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1059 : + sizeof(spdm_error_response_t));
1060 :
1061 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1062 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1063 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1064 :
1065 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1066 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1067 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1068 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1069 1 : assert_int_equal(error_response->header.param2, 0);
1070 1 : }
1071 :
1072 : /**
1073 : * Test 12: First request has LAST CHUNK bit set.
1074 : **/
1075 1 : void libspdm_test_responder_chunk_send_ack_rsp_case12(void** state)
1076 : {
1077 : libspdm_return_t status;
1078 :
1079 : libspdm_test_context_t* spdm_test_context;
1080 : libspdm_context_t* spdm_context;
1081 :
1082 : size_t request_size;
1083 : size_t response_size;
1084 :
1085 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1086 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1087 :
1088 : spdm_chunk_send_request_t* chunk_send_request;
1089 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1090 : spdm_error_response_t* error_response;
1091 :
1092 : const uint8_t* chunk_src;
1093 : uint8_t* chunk_dst;
1094 : uint32_t bytes_total;
1095 :
1096 1 : spdm_test_context = *state;
1097 1 : spdm_context = spdm_test_context->spdm_context;
1098 1 : spdm_test_context->case_id = 12;
1099 :
1100 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1101 :
1102 1 : bytes_total = sizeof(m_libspdm_chunk_send_negotiate_algorithm_request1);
1103 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1104 :
1105 1 : libspdm_zero_mem(request, sizeof(request));
1106 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1107 :
1108 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1109 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1110 1 : chunk_send_request->header.param1 = SPDM_CHUNK_SEND_REQUEST_ATTRIBUTE_LAST_CHUNK;
1111 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
1112 1 : chunk_send_request->chunk_seq_no = 0;
1113 :
1114 1 : *((uint32_t*) (chunk_send_request + 1)) = bytes_total;
1115 :
1116 1 : chunk_send_request->chunk_size =
1117 1 : spdm_context->local_context.capability.data_transfer_size
1118 1 : - sizeof(spdm_chunk_send_request_t) - sizeof(uint32_t);
1119 :
1120 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
1121 :
1122 1 : request_size = sizeof(spdm_chunk_send_request_t)
1123 : + sizeof(uint32_t)
1124 1 : + chunk_send_request->chunk_size;
1125 :
1126 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1127 1 : chunk_src, chunk_send_request->chunk_size);
1128 :
1129 1 : response_size = sizeof(response);
1130 1 : status = libspdm_get_response_chunk_send(
1131 : spdm_context,
1132 : request_size, request,
1133 : &response_size, response);
1134 :
1135 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1136 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1137 : + sizeof(spdm_error_response_t));
1138 :
1139 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1140 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1141 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1142 :
1143 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1144 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1145 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1146 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1147 1 : assert_int_equal(error_response->header.param2, 0);
1148 1 : }
1149 :
1150 9 : void libspdm_test_responder_chunk_send_ack_reset_send_state(libspdm_context_t* spdm_context)
1151 : {
1152 : libspdm_chunk_info_t* send_info;
1153 :
1154 9 : send_info = &spdm_context->chunk_context.send;
1155 9 : send_info->chunk_in_use = false;
1156 9 : send_info->chunk_handle = 0;
1157 9 : send_info->chunk_seq_no = 0;
1158 9 : send_info->chunk_bytes_transferred = 0;
1159 9 : send_info->large_message = NULL;
1160 9 : send_info->large_message_size = 0;
1161 9 : }
1162 :
1163 : /**
1164 : * Test 13: Request has bad sequence number.
1165 : **/
1166 1 : void libspdm_test_responder_chunk_send_ack_rsp_case13(void** state)
1167 : {
1168 : libspdm_return_t status;
1169 :
1170 : libspdm_test_context_t* spdm_test_context;
1171 : libspdm_context_t* spdm_context;
1172 :
1173 : size_t request_size;
1174 : size_t response_size;
1175 :
1176 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1177 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1178 :
1179 : spdm_chunk_send_request_t* chunk_send_request;
1180 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1181 : spdm_error_response_t* error_response;
1182 :
1183 : const uint8_t* chunk_src;
1184 : uint8_t* chunk_dst;
1185 :
1186 1 : spdm_test_context = *state;
1187 1 : spdm_context = spdm_test_context->spdm_context;
1188 1 : spdm_test_context->case_id = 13;
1189 :
1190 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1191 1 : spdm_context->chunk_context.send.chunk_in_use = true;
1192 1 : spdm_context->chunk_context.send.chunk_handle = (uint8_t) spdm_test_context->case_id;
1193 1 : spdm_context->chunk_context.send.chunk_seq_no = 0;
1194 :
1195 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1196 :
1197 1 : libspdm_zero_mem(request, sizeof(request));
1198 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1199 :
1200 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1201 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1202 1 : chunk_send_request->header.param1 = 0;
1203 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
1204 1 : chunk_send_request->chunk_seq_no = 2; /* Bad seq num */
1205 :
1206 1 : chunk_send_request->chunk_size =
1207 1 : spdm_context->local_context.capability.data_transfer_size
1208 1 : - sizeof(spdm_chunk_send_request_t);
1209 :
1210 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1));
1211 :
1212 1 : request_size = sizeof(spdm_chunk_send_request_t)
1213 1 : + chunk_send_request->chunk_size;
1214 :
1215 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1216 1 : chunk_src, chunk_send_request->chunk_size);
1217 :
1218 1 : response_size = sizeof(response);
1219 1 : status = libspdm_get_response_chunk_send(
1220 : spdm_context,
1221 : request_size, request,
1222 : &response_size, response);
1223 :
1224 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1225 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1226 : + sizeof(spdm_error_response_t));
1227 :
1228 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1229 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1230 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1231 :
1232 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1233 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1234 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1235 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1236 1 : assert_int_equal(error_response->header.param2, 0);
1237 :
1238 1 : libspdm_test_responder_chunk_send_ack_reset_send_state(spdm_context);
1239 1 : }
1240 :
1241 : /**
1242 : * Test 14: Request has bad chunk handle.
1243 : **/
1244 1 : void libspdm_test_responder_chunk_send_ack_rsp_case14(void** state)
1245 : {
1246 : libspdm_return_t status;
1247 :
1248 : libspdm_test_context_t* spdm_test_context;
1249 : libspdm_context_t* spdm_context;
1250 :
1251 : size_t request_size;
1252 : size_t response_size;
1253 :
1254 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1255 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1256 :
1257 : spdm_chunk_send_request_t* chunk_send_request;
1258 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1259 : spdm_error_response_t* error_response;
1260 :
1261 : const uint8_t* chunk_src;
1262 : uint8_t* chunk_dst;
1263 :
1264 1 : spdm_test_context = *state;
1265 1 : spdm_context = spdm_test_context->spdm_context;
1266 1 : spdm_test_context->case_id = 14;
1267 :
1268 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1269 1 : spdm_context->chunk_context.send.chunk_in_use = true;
1270 1 : spdm_context->chunk_context.send.chunk_handle = (uint8_t) spdm_test_context->case_id;
1271 1 : spdm_context->chunk_context.send.chunk_seq_no = 0;
1272 :
1273 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1274 :
1275 1 : libspdm_zero_mem(request, sizeof(request));
1276 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1277 :
1278 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1279 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1280 1 : chunk_send_request->header.param1 = 0;
1281 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id + 1; /* bad chunk_handle */
1282 1 : chunk_send_request->chunk_seq_no = 1;
1283 1 : chunk_send_request->chunk_size =
1284 1 : spdm_context->local_context.capability.data_transfer_size
1285 1 : - sizeof(spdm_chunk_send_request_t);
1286 :
1287 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1));
1288 :
1289 1 : request_size = sizeof(spdm_chunk_send_request_t)
1290 1 : + chunk_send_request->chunk_size;
1291 :
1292 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1293 1 : chunk_src, chunk_send_request->chunk_size);
1294 :
1295 1 : response_size = sizeof(response);
1296 1 : status = libspdm_get_response_chunk_send(
1297 : spdm_context,
1298 : request_size, request,
1299 : &response_size, response);
1300 :
1301 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1302 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1303 : + sizeof(spdm_error_response_t));
1304 :
1305 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1306 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1307 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1308 :
1309 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1310 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1311 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1312 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1313 1 : assert_int_equal(error_response->header.param2, 0);
1314 :
1315 1 : libspdm_test_responder_chunk_send_ack_reset_send_state(spdm_context);
1316 1 : }
1317 :
1318 : /**
1319 : * Test 15: Request has size larger than data transfer size.
1320 : **/
1321 1 : void libspdm_test_responder_chunk_send_ack_rsp_case15(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 = 15;
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; /* chunk_handle */
1359 1 : chunk_send_request->chunk_seq_no = 1;
1360 :
1361 1 : chunk_send_request->chunk_size =
1362 1 : spdm_context->local_context.capability.data_transfer_size
1363 1 : - sizeof(spdm_chunk_send_request_t);
1364 :
1365 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1));
1366 :
1367 1 : request_size = sizeof(spdm_chunk_send_request_t)
1368 1 : + chunk_send_request->chunk_size
1369 : + 1; /* Request size too large */
1370 :
1371 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1372 1 : chunk_src, chunk_send_request->chunk_size);
1373 :
1374 1 : response_size = sizeof(response);
1375 1 : status = libspdm_get_response_chunk_send(
1376 : spdm_context,
1377 : request_size, request,
1378 : &response_size, response);
1379 :
1380 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1381 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1382 : + sizeof(spdm_error_response_t));
1383 :
1384 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1385 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1386 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1387 :
1388 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1389 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1390 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1391 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1392 1 : assert_int_equal(error_response->header.param2, 0);
1393 :
1394 1 : libspdm_test_responder_chunk_send_ack_reset_send_state(spdm_context);
1395 1 : }
1396 :
1397 : /**
1398 : * Test 16: Request has chunk size + transferred size > large message size
1399 : **/
1400 1 : void libspdm_test_responder_chunk_send_ack_rsp_case16(void** state)
1401 : {
1402 : libspdm_return_t status;
1403 :
1404 : libspdm_test_context_t* spdm_test_context;
1405 : libspdm_context_t* spdm_context;
1406 :
1407 : size_t request_size;
1408 : size_t response_size;
1409 :
1410 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1411 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1412 :
1413 : spdm_chunk_send_request_t* chunk_send_request;
1414 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1415 : spdm_error_response_t* error_response;
1416 :
1417 : const uint8_t* chunk_src;
1418 : uint8_t* chunk_dst;
1419 :
1420 1 : spdm_test_context = *state;
1421 1 : spdm_context = spdm_test_context->spdm_context;
1422 1 : spdm_test_context->case_id = 16;
1423 :
1424 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1425 1 : spdm_context->chunk_context.send.chunk_in_use = true;
1426 1 : spdm_context->chunk_context.send.chunk_handle = (uint8_t) spdm_test_context->case_id;
1427 1 : spdm_context->chunk_context.send.chunk_seq_no = 0;
1428 1 : spdm_context->chunk_context.send.large_message_size = 1024;
1429 1 : spdm_context->chunk_context.send.chunk_bytes_transferred = 1023;
1430 :
1431 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1432 :
1433 1 : libspdm_zero_mem(request, sizeof(request));
1434 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1435 :
1436 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1437 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1438 1 : chunk_send_request->header.param1 = 0;
1439 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
1440 1 : chunk_send_request->chunk_seq_no = 1;
1441 1 : chunk_send_request->chunk_size = 2; /* Bad size. Over large message size */
1442 :
1443 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1));
1444 :
1445 1 : request_size = sizeof(spdm_chunk_send_request_t)
1446 1 : + chunk_send_request->chunk_size;
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_INVALID_MSG_FIELD);
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 17: Request has LAST_CHUNK indicated before all bytes transferred.
1476 : **/
1477 1 : void libspdm_test_responder_chunk_send_ack_rsp_case17(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 = 17;
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 = 0;
1518 1 : chunk_send_request->chunk_size = 1;
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_INVALID_MSG_FIELD);
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 18: Request missing LAST_CHUNK after all bytes transferred.
1553 : **/
1554 1 : void libspdm_test_responder_chunk_send_ack_rsp_case18(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 = 18;
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 = 1022;
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 = 2;
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_INVALID_MSG_FIELD);
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 19: Request missing LAST_CHUNK when request size != data transfer size.
1630 : **/
1631 1 : void libspdm_test_responder_chunk_send_ack_rsp_case19(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 = 19;
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 = 0;
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 =
1673 1 : spdm_context->local_context.capability.data_transfer_size
1674 : - sizeof(spdm_chunk_send_request_t)
1675 1 : - 1; /* Chunk size too small. */
1676 :
1677 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1));
1678 :
1679 1 : request_size = sizeof(spdm_chunk_send_request_t)
1680 1 : + chunk_send_request->chunk_size;
1681 :
1682 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1683 1 : chunk_src, chunk_send_request->chunk_size);
1684 :
1685 1 : response_size = sizeof(response);
1686 1 : status = libspdm_get_response_chunk_send(
1687 : spdm_context,
1688 : request_size, request,
1689 : &response_size, response);
1690 :
1691 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1692 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1693 : + sizeof(spdm_error_response_t));
1694 :
1695 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1696 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1697 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1698 :
1699 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1700 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1701 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1702 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1703 1 : assert_int_equal(error_response->header.param2, 0);
1704 :
1705 1 : libspdm_test_responder_chunk_send_ack_reset_send_state(spdm_context);
1706 1 : }
1707 :
1708 : /**
1709 : * Test 20: Request chunk seq wrapped.
1710 : **/
1711 1 : void libspdm_test_responder_chunk_send_ack_rsp_case20(void** state)
1712 : {
1713 : libspdm_return_t status;
1714 :
1715 : libspdm_test_context_t* spdm_test_context;
1716 : libspdm_context_t* spdm_context;
1717 :
1718 : size_t request_size;
1719 : size_t response_size;
1720 :
1721 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1722 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1723 :
1724 : spdm_chunk_send_request_t* chunk_send_request;
1725 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1726 : spdm_error_response_t* error_response;
1727 :
1728 : const uint8_t* chunk_src;
1729 : uint8_t* chunk_dst;
1730 :
1731 : /* Format the last chunk. */
1732 1 : spdm_test_context = *state;
1733 1 : spdm_context = spdm_test_context->spdm_context;
1734 1 : spdm_test_context->case_id = 20;
1735 :
1736 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1737 1 : spdm_context->chunk_context.send.chunk_in_use = true;
1738 1 : spdm_context->chunk_context.send.chunk_handle = (uint8_t) spdm_test_context->case_id;
1739 1 : spdm_context->chunk_context.send.chunk_seq_no = 65535; /* maximum chunk seq received */
1740 1 : spdm_context->chunk_context.send.large_message_size = 0x10000;
1741 1 : spdm_context->chunk_context.send.chunk_bytes_transferred = 0x8000;
1742 :
1743 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1744 :
1745 1 : libspdm_zero_mem(request, sizeof(request));
1746 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1747 :
1748 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1749 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1750 1 : chunk_send_request->header.param1 = 0;
1751 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
1752 1 : chunk_send_request->chunk_seq_no = 0; /* chunk seq wrapped */
1753 :
1754 1 : chunk_send_request->chunk_size =
1755 1 : spdm_context->local_context.capability.data_transfer_size
1756 1 : - sizeof(spdm_chunk_send_request_t);
1757 :
1758 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1));
1759 :
1760 1 : request_size = sizeof(spdm_chunk_send_request_t)
1761 1 : + chunk_send_request->chunk_size;
1762 :
1763 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1764 1 : chunk_src, chunk_send_request->chunk_size);
1765 :
1766 1 : response_size = sizeof(response);
1767 1 : status = libspdm_get_response_chunk_send(
1768 : spdm_context,
1769 : request_size, request,
1770 : &response_size, response);
1771 :
1772 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1773 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1774 : + sizeof(spdm_error_response_t));
1775 :
1776 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1777 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1778 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1779 :
1780 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1781 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1782 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1783 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1784 1 : assert_int_equal(error_response->header.param2, 0);
1785 :
1786 1 : libspdm_test_responder_chunk_send_ack_reset_send_state(spdm_context);
1787 1 : }
1788 :
1789 : /**
1790 : * Test 21: Request size exceed max chunk seq no.
1791 : **/
1792 1 : void libspdm_test_responder_chunk_send_ack_rsp_case21(void** state)
1793 : {
1794 : libspdm_return_t status;
1795 :
1796 : libspdm_test_context_t* spdm_test_context;
1797 : libspdm_context_t* spdm_context;
1798 :
1799 : size_t request_size;
1800 : size_t response_size;
1801 :
1802 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1803 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1804 :
1805 : spdm_chunk_send_request_t* chunk_send_request;
1806 : spdm_chunk_send_ack_response_t* chunk_send_ack_response;
1807 : spdm_error_response_t* error_response;
1808 :
1809 : const uint8_t* chunk_src;
1810 : uint8_t* chunk_dst;
1811 :
1812 : /* Format the last chunk. */
1813 1 : spdm_test_context = *state;
1814 1 : spdm_context = spdm_test_context->spdm_context;
1815 1 : spdm_test_context->case_id = 21;
1816 :
1817 1 : libspdm_test_responder_chunk_send_ack_setup_algo_state(spdm_context);
1818 1 : chunk_src = (const uint8_t*) &m_libspdm_chunk_send_negotiate_algorithm_request1;
1819 :
1820 1 : libspdm_zero_mem(request, sizeof(request));
1821 1 : chunk_send_request = (spdm_chunk_send_request_t*) request;
1822 :
1823 1 : chunk_send_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1824 1 : chunk_send_request->header.request_response_code = SPDM_CHUNK_SEND;
1825 1 : chunk_send_request->header.param1 = 0;
1826 1 : chunk_send_request->header.param2 = (uint8_t) spdm_test_context->case_id; /* chunk_handle */
1827 1 : chunk_send_request->chunk_seq_no = 0;
1828 :
1829 :
1830 1 : *((uint32_t*) (chunk_send_request + 1)) = 0x1000000; /* a size exceed max chunk seq */
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) - sizeof(uint32_t);
1834 :
1835 1 : chunk_dst = ((uint8_t*) (chunk_send_request + 1)) + sizeof(uint32_t);
1836 :
1837 1 : request_size = sizeof(spdm_chunk_send_request_t)
1838 : + sizeof(uint32_t)
1839 1 : + chunk_send_request->chunk_size;
1840 :
1841 1 : libspdm_copy_mem(chunk_dst, chunk_send_request->chunk_size,
1842 1 : chunk_src, chunk_send_request->chunk_size);
1843 :
1844 1 : response_size = sizeof(response);
1845 1 : status = libspdm_get_response_chunk_send(
1846 : spdm_context,
1847 : request_size, request,
1848 : &response_size, response);
1849 :
1850 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1851 1 : assert_true(response_size == sizeof(spdm_chunk_send_ack_response_t)
1852 : + sizeof(spdm_error_response_t));
1853 :
1854 1 : chunk_send_ack_response = (spdm_chunk_send_ack_response_t*) response;
1855 1 : assert_int_equal(chunk_send_ack_response->header.param1,
1856 : SPDM_CHUNK_SEND_ACK_RESPONSE_ATTRIBUTE_EARLY_ERROR_DETECTED);
1857 :
1858 1 : error_response = (spdm_error_response_t*) (chunk_send_ack_response + 1);
1859 1 : assert_int_equal(error_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1860 1 : assert_int_equal(error_response->header.request_response_code, SPDM_ERROR);
1861 1 : assert_int_equal(error_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1862 1 : assert_int_equal(error_response->header.param2, 0);
1863 :
1864 1 : libspdm_test_responder_chunk_send_ack_reset_send_state(spdm_context);
1865 1 : }
1866 :
1867 1 : int libspdm_responder_chunk_send_ack_test_main(void)
1868 : {
1869 1 : const struct CMUnitTest spdm_responder_chunk_send_ack_tests[] = {
1870 : /* Responder sent multiple chunks and processed correctly */
1871 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case0),
1872 : /* Responder has no response flag chunk cap */
1873 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case1),
1874 : /* Responder has bad response state */
1875 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case2),
1876 : /* Responder has connection state <= NOT_START */
1877 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case3),
1878 : /* Request has wrong size */
1879 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case4),
1880 : /* Request has SPDM version less than 1.2*/
1881 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case5),
1882 : /* Request has SPDM version not matching connection */
1883 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case6),
1884 : /* Responder is already in chunking mode */
1885 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case7),
1886 :
1887 : /* First request has bad sequence number */
1888 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case8),
1889 : /* First request has chunk size too large */
1890 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case9),
1891 : /* First request has size larger than data transfer size */
1892 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case10),
1893 : /* Large message size larger than max SPDM message size. */
1894 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case11),
1895 : /* First request has LAST CHUNK bit set. */
1896 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case12),
1897 :
1898 : /* Request has bad sequence number */
1899 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case13),
1900 : /* Request has bad chunk handle */
1901 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case14),
1902 : /* Request has chunk size too large for request*/
1903 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case15),
1904 : /* Request has chunk size + transferred size > large message size */
1905 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case16),
1906 : /* Request has LAST_CHUNK indicated before all bytes transferred. */
1907 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case17),
1908 : /* Request missing LAST_CHUNK after all bytes transferred. */
1909 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case18),
1910 : /* Request missing LAST_CHUNK when request size != data transfer size. */
1911 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case19),
1912 : /* Request chunk seq wrapped. */
1913 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case20),
1914 : /* Request size exceed max chunk seq no. */
1915 : cmocka_unit_test(libspdm_test_responder_chunk_send_ack_rsp_case21),
1916 : };
1917 :
1918 1 : libspdm_test_context_t test_context = {
1919 : LIBSPDM_TEST_CONTEXT_VERSION,
1920 : false,
1921 : };
1922 :
1923 1 : libspdm_setup_test_context(&test_context);
1924 :
1925 1 : return cmocka_run_group_tests(spdm_responder_chunk_send_ack_tests,
1926 : libspdm_unit_test_group_setup,
1927 : libspdm_unit_test_group_teardown);
1928 : }
1929 :
1930 : #endif /* LIBSPDM_ENABLE_CAPABILITY_CHUNK_CAP*/
|
