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