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