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_requester_lib.h"
9 : #include "internal/libspdm_secured_message_lib.h"
10 :
11 : #if LIBSPDM_ENABLE_CAPABILITY_CHUNK_CAP
12 :
13 : static void *m_libspdm_local_certificate_chain_test_case_1;
14 : static size_t m_libspdm_local_certificate_chain_size_test_case_1;
15 : static uint16_t m_libspdm_local_req_msg_size_test_case_1;
16 :
17 : static uint8_t m_libspdm_local_large_response_buffer[LIBSPDM_MAX_SPDM_MSG_SIZE];
18 :
19 : #define BUFFER_SIZE_FOR_CHUNK_SEQ_NO_WRAP_TEST 0x200000
20 : static uint8_t m_libspdm_local_response_buffer_for_chunk_seq_no_wrap_test[
21 : BUFFER_SIZE_FOR_CHUNK_SEQ_NO_WRAP_TEST];
22 :
23 : static size_t m_libspdm_local_buffer_size;
24 : static uint8_t m_libspdm_local_buffer[LIBSPDM_MAX_MESSAGE_M1M2_BUFFER_SIZE];
25 :
26 : static size_t m_libspdm_local_request_buffer_size;
27 : static uint8_t m_libspdm_local_request_buffer[LIBSPDM_MAX_SPDM_MSG_SIZE];
28 :
29 : static uint8_t m_libspdm_local_certificate_chain_test_case_4[LIBSPDM_MAX_CERT_CHAIN_SIZE];
30 :
31 : /* Override the LIBSPDM_DATA_TRANSFER_SIZE just for the unit tests in this file.
32 : * All other unit tests have the default data transfer size due to the specific
33 : * unit tests requests and responses hardcode for each test case. */
34 : #define CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE (42)
35 :
36 : /* Loading the target expiration certificate chain and saving root certificate hash
37 : * "rsa3072_Expiration/bundle_responder.certchain.der"*/
38 : bool libspdm_libspdm_read_responder_public_certificate_chain_expiration(
39 : void** data, size_t* size, void** hash, size_t* hash_size);
40 :
41 : #define CHUNK_GET_UNIT_TEST_CHUNK_HANDLE (10)
42 :
43 1 : void libspdm_requester_chunk_get_test_case1_build_certificates_response(
44 : void *context, void *response, size_t *response_size,
45 : size_t sub_cert_index, size_t *sub_cert_count)
46 : {
47 : spdm_certificate_response_t *cert_rsp;
48 : uint16_t sub_cert_portion_length;
49 : uint16_t sub_cert_remainder_length;
50 :
51 1 : if (m_libspdm_local_certificate_chain_test_case_1 == NULL) {
52 1 : libspdm_read_responder_public_certificate_chain(
53 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
54 : &m_libspdm_local_certificate_chain_test_case_1,
55 : &m_libspdm_local_certificate_chain_size_test_case_1, NULL, NULL);
56 : }
57 1 : LIBSPDM_ASSERT(m_libspdm_local_certificate_chain_test_case_1 != NULL);
58 :
59 1 : *sub_cert_count = (m_libspdm_local_certificate_chain_size_test_case_1 +
60 1 : m_libspdm_local_req_msg_size_test_case_1 - 1) /
61 : m_libspdm_local_req_msg_size_test_case_1;
62 :
63 1 : if (sub_cert_index != *sub_cert_count - 1) {
64 0 : sub_cert_portion_length = m_libspdm_local_req_msg_size_test_case_1;
65 0 : sub_cert_remainder_length =
66 0 : (uint16_t) (m_libspdm_local_certificate_chain_size_test_case_1 -
67 : m_libspdm_local_req_msg_size_test_case_1 *
68 0 : (sub_cert_index + 1));
69 : } else {
70 1 : sub_cert_portion_length = (uint16_t) (
71 : m_libspdm_local_certificate_chain_size_test_case_1 -
72 1 : m_libspdm_local_req_msg_size_test_case_1 * (*sub_cert_count - 1));
73 1 : sub_cert_remainder_length = 0;
74 : }
75 :
76 1 : cert_rsp = (spdm_certificate_response_t*) ((uint8_t*) response);
77 :
78 1 : cert_rsp->header.spdm_version = SPDM_MESSAGE_VERSION_12;
79 1 : cert_rsp->header.request_response_code = SPDM_CERTIFICATE;
80 1 : cert_rsp->header.param1 = 0;
81 1 : cert_rsp->header.param2 = 0;
82 1 : cert_rsp->portion_length = sub_cert_portion_length;
83 1 : cert_rsp->remainder_length = sub_cert_remainder_length;
84 :
85 1 : libspdm_copy_mem(
86 1 : cert_rsp + 1, sub_cert_portion_length,
87 1 : (uint8_t*) m_libspdm_local_certificate_chain_test_case_1 +
88 1 : m_libspdm_local_req_msg_size_test_case_1 * sub_cert_index,
89 : sub_cert_portion_length);
90 :
91 1 : *response_size = sizeof(spdm_certificate_response_t) + sub_cert_portion_length;
92 1 : }
93 :
94 1 : void libspdm_requester_chunk_get_test_case2_build_measurements_response(
95 : void* context, void* response, size_t* response_size)
96 : {
97 : libspdm_context_t* spdm_context;
98 1 : spdm_measurements_response_t* meas_rsp = NULL;
99 : spdm_measurement_block_dmtf_t* measurment_block;
100 :
101 1 : spdm_context = (libspdm_context_t*) context;
102 : /* This is get measurements test case 20, but changed to SPDM version 1.2
103 : * which includes opaque data */
104 :
105 : uint8_t* ptr;
106 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
107 : m_libspdm_use_measurement_hash_algo;
108 :
109 1 : *response_size = sizeof(spdm_measurements_response_t) +
110 : 2 * (sizeof(spdm_measurement_block_dmtf_t) +
111 1 : libspdm_get_measurement_hash_size(
112 : m_libspdm_use_measurement_hash_algo)) +
113 1 : SPDM_NONCE_SIZE + sizeof(uint16_t);
114 :
115 1 : meas_rsp = (spdm_measurements_response_t*)((uint8_t*) response);
116 1 : meas_rsp->header.spdm_version = SPDM_MESSAGE_VERSION_12;
117 1 : meas_rsp->header.request_response_code = SPDM_MEASUREMENTS;
118 1 : meas_rsp->header.param1 = 0;
119 1 : meas_rsp->header.param2 = 0;
120 1 : meas_rsp->number_of_blocks = 2;
121 1 : libspdm_write_uint32(meas_rsp->measurement_record_length,
122 1 : 2 * ((uint32_t) (sizeof(spdm_measurement_block_dmtf_t) +
123 1 : libspdm_get_measurement_hash_size( m_libspdm_use_measurement_hash_algo))));
124 1 : measurment_block = (void*) (meas_rsp + 1);
125 1 : libspdm_set_mem(
126 : measurment_block,
127 1 : 2 * (sizeof(spdm_measurement_block_dmtf_t) +
128 1 : libspdm_get_measurement_hash_size( m_libspdm_use_measurement_hash_algo)), 1);
129 1 : measurment_block->measurement_block_common_header.index = 1;
130 1 : measurment_block->measurement_block_common_header.measurement_specification =
131 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
132 1 : measurment_block->measurement_block_common_header.measurement_size =
133 1 : (uint16_t) (sizeof(spdm_measurement_block_dmtf_header_t) +
134 1 : libspdm_get_measurement_hash_size( m_libspdm_use_measurement_hash_algo));
135 1 : measurment_block =
136 : (void*) (((uint8_t*) measurment_block) +
137 1 : (sizeof(spdm_measurement_block_dmtf_t) +
138 1 : libspdm_get_measurement_hash_size( m_libspdm_use_measurement_hash_algo)));
139 1 : measurment_block->measurement_block_common_header.index = 2;
140 1 : measurment_block->measurement_block_common_header.measurement_specification =
141 : SPDM_MEASUREMENT_SPECIFICATION_DMTF;
142 1 : measurment_block->measurement_block_common_header.measurement_size =
143 1 : (uint16_t) (sizeof(spdm_measurement_block_dmtf_header_t) +
144 1 : libspdm_get_measurement_hash_size( m_libspdm_use_measurement_hash_algo));
145 1 : ptr = (uint8_t*) meas_rsp + *response_size - SPDM_NONCE_SIZE - sizeof(uint16_t);
146 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
147 1 : ptr += SPDM_NONCE_SIZE;
148 : /* Set opaque data length to 0 */
149 1 : *ptr = 0;
150 1 : ptr++;
151 1 : *ptr = 0;
152 1 : }
153 :
154 1 : void libspdm_requester_chunk_get_test_case3_build_challenge_response(
155 : void* context, void* response, size_t* response_size)
156 : {
157 : libspdm_context_t* spdm_context;
158 : spdm_challenge_auth_response_t* spdm_response;
159 : void* data;
160 : size_t data_size;
161 : uint8_t* ptr;
162 : uint8_t hash_data[LIBSPDM_MAX_HASH_SIZE];
163 : size_t sig_size;
164 :
165 1 : spdm_context = (libspdm_context_t*) context;
166 1 : libspdm_read_responder_public_certificate_chain(
167 : m_libspdm_use_hash_algo,
168 : m_libspdm_use_asym_algo, &data,
169 : &data_size, NULL, NULL);
170 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
171 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
172 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
173 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
174 1 : *response_size = sizeof(spdm_challenge_auth_response_t) +
175 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo) +
176 1 : SPDM_NONCE_SIZE + 0 + sizeof(uint16_t) + 0 +
177 1 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
178 1 : spdm_response = response;
179 :
180 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_12;
181 1 : spdm_response->header.request_response_code = SPDM_CHALLENGE_AUTH;
182 1 : spdm_response->header.param1 = 0;
183 1 : spdm_response->header.param2 = (1 << 0);
184 1 : ptr = (void*) (spdm_response + 1);
185 1 : libspdm_hash_all(
186 : m_libspdm_use_hash_algo,
187 : spdm_context->local_context.local_cert_chain_provision[0],
188 : spdm_context->local_context.local_cert_chain_provision_size[0],
189 : ptr);
190 1 : free(data);
191 1 : data = NULL;
192 :
193 1 : ptr += libspdm_get_hash_size(m_libspdm_use_hash_algo);
194 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
195 1 : ptr += SPDM_NONCE_SIZE;
196 : /* libspdm_zero_mem (ptr, libspdm_get_hash_size (m_libspdm_use_hash_algo));
197 : * ptr += libspdm_get_hash_size (m_libspdm_use_hash_algo);*/
198 1 : libspdm_write_uint16(ptr, 0);
199 1 : ptr += sizeof(uint16_t);
200 :
201 1 : libspdm_copy_mem(
202 1 : &m_libspdm_local_buffer[m_libspdm_local_buffer_size],
203 : sizeof(m_libspdm_local_buffer) -
204 1 : (&m_libspdm_local_buffer[m_libspdm_local_buffer_size] - m_libspdm_local_buffer),
205 1 : spdm_response, (size_t) ptr - (size_t) spdm_response);
206 1 : m_libspdm_local_buffer_size += ((size_t) ptr - (size_t) spdm_response);
207 1 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "m_libspdm_local_buffer_size (0x%zx):\n",
208 : m_libspdm_local_buffer_size));
209 1 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
210 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_buffer,
211 : m_libspdm_local_buffer_size, hash_data);
212 1 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "HashDataSize (0x%x):\n",
213 : libspdm_get_hash_size(m_libspdm_use_hash_algo)));
214 1 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
215 1 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_asym_algo);
216 1 : libspdm_responder_data_sign(
217 : spdm_context,
218 1 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
219 : 0, SPDM_CHALLENGE_AUTH,
220 : m_libspdm_use_asym_algo, m_libspdm_use_pqc_asym_algo, m_libspdm_use_hash_algo,
221 : false, m_libspdm_local_buffer, m_libspdm_local_buffer_size,
222 : ptr, &sig_size);
223 1 : ptr += sig_size;
224 1 : }
225 :
226 2 : void libspdm_requester_chunk_get_test_case4_build_digest_response(
227 : void* context, void* response, size_t* response_size)
228 : {
229 : libspdm_context_t *spdm_context;
230 : spdm_digest_response_t* spdm_response;
231 : uint8_t* digest;
232 : uint8_t slot_id;
233 :
234 2 : spdm_context = (libspdm_context_t*)context;
235 2 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
236 2 : *response_size = sizeof(spdm_digest_response_t) +
237 2 : libspdm_get_hash_size(m_libspdm_use_hash_algo) * SPDM_MAX_SLOT_COUNT;
238 2 : spdm_response = response;
239 :
240 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_12;
241 2 : spdm_response->header.param1 = 0;
242 2 : spdm_response->header.request_response_code = SPDM_DIGESTS;
243 2 : spdm_response->header.param2 = 0;
244 2 : libspdm_set_mem(m_libspdm_local_certificate_chain_test_case_4,
245 : sizeof(m_libspdm_local_certificate_chain_test_case_4),
246 : (uint8_t) (0xFF));
247 :
248 2 : digest = (void*) (spdm_response + 1);
249 2 : libspdm_zero_mem(digest, libspdm_get_hash_size(m_libspdm_use_hash_algo) * SPDM_MAX_SLOT_COUNT);
250 18 : for (slot_id = 0; slot_id < SPDM_MAX_SLOT_COUNT; slot_id++) {
251 16 : libspdm_hash_all(
252 : m_libspdm_use_hash_algo,
253 : m_libspdm_local_certificate_chain_test_case_4,
254 : sizeof(m_libspdm_local_certificate_chain_test_case_4), &digest[0]);
255 16 : digest += libspdm_get_hash_size(m_libspdm_use_hash_algo);
256 : }
257 2 : spdm_response->header.param2 |= (0xFF << 0);
258 2 : }
259 :
260 2 : void libspdm_requester_chunk_get_test_case5_case6_build_vendor_response(
261 : void* context, void* response, size_t* response_size)
262 : {
263 : spdm_vendor_defined_response_msg_t *spdm_response;
264 :
265 : /* For exceed max chunk seq no */
266 2 : *response_size =
267 : (CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE -
268 : sizeof(spdm_chunk_response_response_t)) * 65536 - sizeof(uint32_t) + 0x10;
269 :
270 2 : libspdm_set_mem(response, *response_size, 0xff);
271 :
272 2 : spdm_response = response;
273 :
274 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_12;
275 2 : spdm_response->header.request_response_code = SPDM_VENDOR_DEFINED_RESPONSE;
276 2 : spdm_response->header.param1 = 0;
277 2 : spdm_response->header.param2 = 0;
278 :
279 2 : spdm_response->standard_id = 6;
280 2 : spdm_response->len = 2;
281 2 : }
282 :
283 1 : void libspdm_requester_chunk_get_test_case8_build_digest_response(
284 : void* context, void* response, size_t* response_size)
285 : {
286 : /* this is referenced from case 4, but use spdm 1.4 */
287 : libspdm_context_t *spdm_context;
288 : spdm_digest_response_t* spdm_response;
289 : uint8_t* digest;
290 : uint8_t slot_id;
291 :
292 1 : spdm_context = (libspdm_context_t*)context;
293 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
294 1 : *response_size = sizeof(spdm_digest_response_t) +
295 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo) * SPDM_MAX_SLOT_COUNT;
296 1 : spdm_response = response;
297 :
298 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_14;
299 1 : spdm_response->header.param1 = 0;
300 1 : spdm_response->header.request_response_code = SPDM_DIGESTS;
301 1 : spdm_response->header.param2 = 0;
302 1 : libspdm_set_mem(m_libspdm_local_certificate_chain_test_case_4,
303 : sizeof(m_libspdm_local_certificate_chain_test_case_4),
304 : (uint8_t) (0xFF));
305 :
306 1 : digest = (void*) (spdm_response + 1);
307 1 : libspdm_zero_mem(digest, libspdm_get_hash_size(m_libspdm_use_hash_algo) * SPDM_MAX_SLOT_COUNT);
308 9 : for (slot_id = 0; slot_id < SPDM_MAX_SLOT_COUNT; slot_id++) {
309 8 : libspdm_hash_all(
310 : m_libspdm_use_hash_algo,
311 : m_libspdm_local_certificate_chain_test_case_4,
312 : sizeof(m_libspdm_local_certificate_chain_test_case_4), &digest[0]);
313 8 : digest += libspdm_get_hash_size(m_libspdm_use_hash_algo);
314 : }
315 1 : spdm_response->header.param1 |= (0xFF << 0); /* 1.3+ supported_slot_mask */
316 1 : spdm_response->header.param2 |= (0xFF << 0);
317 1 : }
318 :
319 65624 : static libspdm_return_t send_message(
320 : void *spdm_context, size_t request_size, const void *request, uint64_t timeout)
321 : {
322 : libspdm_test_context_t* spdm_test_context;
323 65624 : size_t header_size = sizeof(libspdm_test_message_header_t);
324 :
325 65624 : spdm_test_context = libspdm_get_test_context();
326 :
327 65624 : m_libspdm_local_request_buffer_size = 0;
328 65624 : libspdm_copy_mem(m_libspdm_local_request_buffer, sizeof(m_libspdm_local_request_buffer),
329 : (const uint8_t *)request + header_size, request_size - header_size);
330 65624 : m_libspdm_local_request_buffer_size += request_size - header_size;
331 :
332 65624 : if (spdm_test_context->case_id == 0x1) {
333 48 : const spdm_get_certificate_request_t *spdm_request =
334 : (const void *)((const uint8_t *)request + header_size);
335 48 : if (spdm_request->header.request_response_code == SPDM_GET_CERTIFICATE) {
336 1 : m_libspdm_local_req_msg_size_test_case_1 = spdm_request->length;
337 : }
338 48 : return LIBSPDM_STATUS_SUCCESS;
339 65576 : } else if (spdm_test_context->case_id == 0x2) {
340 7 : return LIBSPDM_STATUS_SUCCESS;
341 65569 : } else if (spdm_test_context->case_id == 0x3) {
342 : const uint8_t* ptr;
343 6 : ptr = (const uint8_t*) request;
344 :
345 6 : if (ptr[2] == SPDM_CHALLENGE) {
346 1 : m_libspdm_local_buffer_size = 0;
347 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
348 1 : &ptr[1], request_size - 1);
349 1 : m_libspdm_local_buffer_size += (request_size - 1);
350 : }
351 6 : return LIBSPDM_STATUS_SUCCESS;
352 65563 : } else if (spdm_test_context->case_id == 0x4) {
353 10 : return LIBSPDM_STATUS_SUCCESS;
354 65553 : } else if (spdm_test_context->case_id == 0x5) {
355 2 : return LIBSPDM_STATUS_SUCCESS;
356 65551 : } else if (spdm_test_context->case_id == 0x6) {
357 65537 : return LIBSPDM_STATUS_SUCCESS;
358 14 : } else if (spdm_test_context->case_id == 0x7) {
359 1 : return LIBSPDM_STATUS_SUCCESS;
360 13 : } else if (spdm_test_context->case_id == 0x8) {
361 10 : return LIBSPDM_STATUS_SUCCESS;
362 3 : } else if (spdm_test_context->case_id == 0x9) {
363 2 : return LIBSPDM_STATUS_SUCCESS;
364 1 : } else if (spdm_test_context->case_id == 0xA) {
365 1 : return LIBSPDM_STATUS_SUCCESS;
366 : } else {
367 0 : return LIBSPDM_STATUS_SEND_FAIL;
368 : }
369 : }
370 :
371 65624 : static libspdm_return_t receive_message(
372 : void *spdm_context, size_t *response_size, void **response, uint64_t timeout)
373 : {
374 : libspdm_test_context_t* spdm_test_context;
375 65624 : uint8_t chunk_handle = CHUNK_GET_UNIT_TEST_CHUNK_HANDLE;
376 : static bool error_large_response_sent = false;
377 :
378 : static spdm_message_header_t* sub_rsp = NULL;
379 : static size_t sub_rsp_size = 0;
380 : static size_t sub_rsp_copied = 0;
381 : static size_t sub_rsp_remaining = 0;
382 : static uint16_t chunk_seq_no = 0;
383 :
384 : spdm_message_header_t* spdm_request_header;
385 : spdm_chunk_response_response_t* chunk_rsp;
386 : spdm_chunk_response_response_14_t* chunk_rsp_14;
387 : size_t chunk_rsp_size;
388 : uint8_t* chunk_copy_to;
389 : size_t chunk_copy_size;
390 : size_t transport_header_size;
391 : void (*build_response_func)(void*, void*, size_t *);
392 :
393 65624 : build_response_func = NULL;
394 :
395 65624 : spdm_test_context = libspdm_get_test_context();
396 65624 : spdm_request_header = (spdm_message_header_t*) m_libspdm_local_request_buffer;
397 :
398 : /* First response to these tests should always be error large response */
399 65624 : if (error_large_response_sent == false) {
400 8 : error_large_response_sent = true;
401 :
402 : spdm_error_response_t* error_rsp;
403 : size_t error_rsp_size;
404 :
405 8 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
406 8 : error_rsp = (void*) ((uint8_t*) *response + transport_header_size);
407 8 : error_rsp_size = sizeof(spdm_error_response_t) + sizeof(uint8_t);
408 :
409 8 : error_rsp->header.spdm_version = spdm_request_header->spdm_version;
410 8 : error_rsp->header.request_response_code = SPDM_ERROR;
411 8 : error_rsp->header.param1 = SPDM_ERROR_CODE_LARGE_RESPONSE;
412 8 : error_rsp->header.param2 = 0;
413 8 : *((uint16_t*) (error_rsp + 1)) = chunk_handle;
414 :
415 8 : libspdm_transport_test_encode_message(
416 : spdm_context, NULL, false, false,
417 : error_rsp_size, error_rsp,
418 : response_size, response);
419 :
420 8 : return LIBSPDM_STATUS_SUCCESS;
421 : }
422 :
423 65616 : if (spdm_test_context->case_id == 0x1) {
424 :
425 : /* Refers to just the certificate portion in the cert response */
426 : static size_t sub_cert_index = 0;
427 : static size_t sub_cert_count = 0;
428 :
429 47 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
430 47 : chunk_rsp = (void*) ((uint8_t*) *response + transport_header_size);
431 :
432 47 : chunk_rsp->header.spdm_version = SPDM_MESSAGE_VERSION_12;
433 47 : chunk_rsp->header.request_response_code = SPDM_CHUNK_RESPONSE;
434 47 : chunk_rsp->header.param1 = 0;
435 47 : chunk_rsp->header.param2 = chunk_handle;
436 :
437 47 : chunk_copy_to = (uint8_t*) (chunk_rsp + 1);
438 47 : chunk_copy_size = CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE
439 : - sizeof(spdm_chunk_response_response_t);
440 :
441 47 : if (sub_rsp_copied == 0) {
442 1 : sub_rsp = (spdm_message_header_t*) m_libspdm_local_large_response_buffer;
443 1 : sub_rsp_size = sizeof(m_libspdm_local_large_response_buffer);
444 1 : libspdm_zero_mem(sub_rsp, sub_rsp_size);
445 :
446 1 : libspdm_requester_chunk_get_test_case1_build_certificates_response(
447 : spdm_context, sub_rsp, &sub_rsp_size, sub_cert_index, &sub_cert_count);
448 :
449 1 : sub_rsp_remaining = sub_rsp_size;
450 1 : sub_rsp_copied = 0;
451 :
452 : /* first chunk has size of large response */
453 1 : chunk_seq_no = 0;
454 1 : *((uint32_t*) (chunk_rsp + 1)) = (uint32_t) sub_rsp_size;
455 :
456 1 : chunk_copy_to += sizeof(uint32_t);
457 1 : chunk_copy_size -= sizeof(uint32_t);
458 1 : chunk_copy_size = LIBSPDM_MIN(sub_rsp_remaining, chunk_copy_size);
459 1 : chunk_rsp_size = sizeof(spdm_chunk_response_response_t)
460 : + sizeof(uint32_t) + chunk_copy_size;
461 : } else {
462 46 : chunk_copy_size = LIBSPDM_MIN(sub_rsp_remaining, chunk_copy_size);
463 46 : chunk_rsp_size = sizeof(spdm_chunk_response_response_t) + chunk_copy_size;
464 : }
465 :
466 47 : if (chunk_copy_size == sub_rsp_remaining) {
467 1 : chunk_rsp->header.param1 = SPDM_CHUNK_GET_RESPONSE_ATTRIBUTE_LAST_CHUNK;
468 : }
469 :
470 47 : libspdm_copy_mem(chunk_copy_to,
471 47 : *response_size - (chunk_copy_to - (uint8_t*)*response),
472 47 : (uint8_t*) sub_rsp + sub_rsp_copied,
473 : chunk_copy_size);
474 :
475 47 : sub_rsp_copied += chunk_copy_size;
476 47 : sub_rsp_remaining -= chunk_copy_size;
477 47 : chunk_rsp->chunk_size = (uint32_t) chunk_copy_size;
478 47 : chunk_rsp->chunk_seq_no = chunk_seq_no;
479 47 : chunk_seq_no++;
480 :
481 47 : libspdm_transport_test_encode_message(
482 : spdm_context, NULL, false, false,
483 : chunk_rsp_size, chunk_rsp,
484 : response_size, response);
485 :
486 47 : if (sub_rsp_copied >= sub_rsp_size) {
487 1 : sub_cert_index++;
488 1 : sub_rsp = NULL;
489 1 : sub_rsp_size = 0;
490 1 : sub_rsp_copied = 0;
491 1 : sub_rsp_remaining = 0;
492 1 : chunk_seq_no = 0;
493 1 : error_large_response_sent = false;
494 :
495 1 : if (sub_cert_index == sub_cert_count) {
496 1 : sub_cert_index = 0;
497 :
498 1 : free(m_libspdm_local_certificate_chain_test_case_1);
499 1 : m_libspdm_local_certificate_chain_test_case_1 = NULL;
500 1 : m_libspdm_local_certificate_chain_size_test_case_1 = 0;
501 : }
502 : }
503 :
504 47 : return LIBSPDM_STATUS_SUCCESS;
505 65569 : } else if (spdm_test_context->case_id == 0x2) {
506 6 : build_response_func = libspdm_requester_chunk_get_test_case2_build_measurements_response;
507 65563 : } else if (spdm_test_context->case_id == 0x3) {
508 5 : build_response_func = libspdm_requester_chunk_get_test_case3_build_challenge_response;
509 65558 : } else if (spdm_test_context->case_id == 0x4) {
510 9 : build_response_func = libspdm_requester_chunk_get_test_case4_build_digest_response;
511 65549 : } else if (spdm_test_context->case_id == 0x5) {
512 1 : build_response_func = libspdm_requester_chunk_get_test_case5_case6_build_vendor_response;
513 65548 : } else if (spdm_test_context->case_id == 0x6) {
514 65536 : build_response_func = libspdm_requester_chunk_get_test_case5_case6_build_vendor_response;
515 12 : } else if (spdm_test_context->case_id == 0x7) {
516 : /* This case only return one error message with RequestResynch */
517 : spdm_error_response_t* error_rsp;
518 : size_t error_rsp_size;
519 :
520 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
521 1 : error_rsp = (void*) ((uint8_t*) *response + transport_header_size);
522 1 : error_rsp_size = sizeof(spdm_error_response_t) + sizeof(uint8_t);
523 :
524 1 : error_rsp->header.spdm_version = SPDM_MESSAGE_VERSION_10;
525 1 : error_rsp->header.request_response_code = SPDM_ERROR;
526 1 : error_rsp->header.param1 = SPDM_ERROR_CODE_REQUEST_RESYNCH;
527 1 : error_rsp->header.param2 = 0;
528 :
529 1 : libspdm_transport_test_encode_message(
530 : spdm_context, NULL, false, false,
531 : error_rsp_size, error_rsp,
532 : response_size, response);
533 :
534 : /* reset static status for next case */
535 1 : sub_rsp = NULL;
536 1 : sub_rsp_size = 0;
537 1 : sub_rsp_copied = 0;
538 1 : sub_rsp_remaining = 0;
539 1 : chunk_seq_no = 0;
540 1 : error_large_response_sent = false;
541 :
542 1 : return LIBSPDM_STATUS_SUCCESS;
543 11 : } else if (spdm_test_context->case_id == 0x8) {
544 9 : build_response_func = libspdm_requester_chunk_get_test_case8_build_digest_response;
545 2 : } else if (spdm_test_context->case_id == 0x9) {
546 1 : build_response_func = libspdm_requester_chunk_get_test_case4_build_digest_response;
547 1 : } else if (spdm_test_context->case_id == 0xA) {
548 1 : build_response_func = libspdm_requester_chunk_get_test_case8_build_digest_response;
549 : } else {
550 0 : LIBSPDM_ASSERT(0);
551 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
552 : }
553 :
554 65568 : if (build_response_func) {
555 65568 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
556 65568 : chunk_rsp = (void*) ((uint8_t*) *response + transport_header_size);
557 :
558 65568 : chunk_rsp->header.spdm_version = spdm_request_header->spdm_version;
559 65568 : chunk_rsp->header.request_response_code = SPDM_CHUNK_RESPONSE;
560 65568 : chunk_rsp->header.param1 = 0;
561 65568 : chunk_rsp->header.param2 = chunk_handle;
562 65568 : if (spdm_test_context->case_id == 0x9 || spdm_test_context->case_id == 0xA) {
563 2 : chunk_rsp->header.param2 = (uint8_t)(chunk_handle + 1);
564 : }
565 :
566 65568 : chunk_copy_to = (uint8_t*) (chunk_rsp + 1);
567 65568 : chunk_copy_size = CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE
568 : - sizeof(spdm_chunk_response_response_t);
569 :
570 65568 : if (sub_rsp_copied == 0) {
571 :
572 7 : sub_rsp = (spdm_message_header_t*) m_libspdm_local_large_response_buffer;
573 7 : sub_rsp_size = sizeof(m_libspdm_local_large_response_buffer);
574 7 : if (spdm_test_context->case_id == 0x5 || spdm_test_context->case_id == 0x6) {
575 2 : sub_rsp =
576 : (spdm_message_header_t*)
577 : m_libspdm_local_response_buffer_for_chunk_seq_no_wrap_test;
578 2 : sub_rsp_size = sizeof(m_libspdm_local_response_buffer_for_chunk_seq_no_wrap_test);
579 : }
580 7 : libspdm_zero_mem(sub_rsp, sub_rsp_size);
581 :
582 7 : build_response_func(spdm_context, sub_rsp, &sub_rsp_size);
583 :
584 7 : sub_rsp_remaining = sub_rsp_size;
585 7 : sub_rsp_copied = 0;
586 :
587 : /* first chunk has size of large response */
588 7 : chunk_seq_no = 0;
589 7 : *((uint32_t*) (chunk_rsp + 1)) = (uint32_t) sub_rsp_size;
590 :
591 7 : chunk_copy_to += sizeof(uint32_t);
592 7 : chunk_copy_size -= sizeof(uint32_t);
593 7 : chunk_copy_size = LIBSPDM_MIN(sub_rsp_remaining, chunk_copy_size);
594 7 : chunk_rsp_size = sizeof(spdm_chunk_response_response_t)
595 : + sizeof(uint32_t) + chunk_copy_size;
596 :
597 : /* case_id 0x5 will only get 1 chunk message */
598 7 : if (spdm_test_context->case_id == 0x5) {
599 1 : sub_rsp_size = sub_rsp_copied;
600 : }
601 :
602 : } else {
603 65561 : chunk_copy_size = LIBSPDM_MIN(sub_rsp_remaining, chunk_copy_size);
604 65561 : chunk_rsp_size = sizeof(spdm_chunk_response_response_t) + chunk_copy_size;
605 : }
606 :
607 65568 : if (chunk_copy_size == sub_rsp_remaining) {
608 4 : chunk_rsp->header.param1 = SPDM_CHUNK_GET_RESPONSE_ATTRIBUTE_LAST_CHUNK;
609 : }
610 :
611 65568 : libspdm_copy_mem(chunk_copy_to,
612 65568 : *response_size - (chunk_copy_to - (uint8_t*) *response),
613 65568 : (uint8_t*) sub_rsp + sub_rsp_copied,
614 : chunk_copy_size);
615 :
616 65568 : sub_rsp_copied += chunk_copy_size;
617 65568 : sub_rsp_remaining -= chunk_copy_size;
618 65568 : chunk_rsp->chunk_size = (uint32_t) chunk_copy_size;
619 65568 : if (spdm_request_header->spdm_version < SPDM_MESSAGE_VERSION_14) {
620 65558 : chunk_rsp->chunk_seq_no = chunk_seq_no++;
621 : } else {
622 10 : chunk_rsp_14 = (spdm_chunk_response_response_14_t*) chunk_rsp;
623 10 : chunk_rsp_14->chunk_seq_no = chunk_seq_no++;
624 : }
625 :
626 65568 : libspdm_transport_test_encode_message(
627 : spdm_context, NULL, false, false,
628 : chunk_rsp_size, chunk_rsp,
629 : response_size, response);
630 :
631 65568 : if (sub_rsp_copied >= sub_rsp_size) {
632 5 : sub_rsp = NULL;
633 5 : sub_rsp_size = 0;
634 5 : sub_rsp_copied = 0;
635 5 : sub_rsp_remaining = 0;
636 5 : chunk_seq_no = 0;
637 5 : error_large_response_sent = false;
638 : }
639 65568 : return LIBSPDM_STATUS_SUCCESS;
640 : }
641 0 : return LIBSPDM_STATUS_SEND_FAIL;
642 :
643 : }
644 : #if LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT
645 1 : static void req_chunk_get_case1(void** state)
646 : {
647 : libspdm_return_t status;
648 : libspdm_test_context_t* spdm_test_context;
649 : libspdm_context_t* spdm_context;
650 : size_t cert_chain_size;
651 : uint8_t cert_chain[LIBSPDM_MAX_CERT_CHAIN_SIZE];
652 : void* data;
653 : size_t data_size;
654 : void* hash;
655 : size_t hash_size;
656 : const uint8_t* root_cert;
657 : size_t root_cert_size;
658 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
659 : size_t count;
660 : #endif
661 :
662 1 : spdm_test_context = *state;
663 1 : spdm_context = spdm_test_context->spdm_context;
664 1 : spdm_test_context->case_id = 0x1;
665 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
666 : SPDM_VERSION_NUMBER_SHIFT_BIT;
667 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_DIGESTS;
668 1 : spdm_context->connection_info.capability.flags |=
669 : (SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP
670 : | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP
671 : | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP);
672 :
673 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP;
674 : spdm_context->local_context.capability.data_transfer_size
675 1 : = CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
676 1 : spdm_context->local_context.is_requester = true;
677 :
678 1 : libspdm_read_responder_public_certificate_chain(
679 : m_libspdm_use_hash_algo,
680 : m_libspdm_use_asym_algo, &data,
681 : &data_size, &hash, &hash_size);
682 1 : libspdm_x509_get_cert_from_cert_chain(
683 1 : (uint8_t*) data + sizeof(spdm_cert_chain_t) + hash_size,
684 1 : data_size - sizeof(spdm_cert_chain_t) - hash_size, 0,
685 : &root_cert, &root_cert_size);
686 1 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "root cert data :\n"));
687 1 : libspdm_dump_hex(root_cert, root_cert_size);
688 1 : spdm_context->local_context.peer_root_cert_provision_size[0] = root_cert_size;
689 :
690 1 : spdm_context->local_context.peer_root_cert_provision[0] = root_cert;
691 1 : libspdm_reset_message_b(spdm_context);
692 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
693 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
694 1 : spdm_context->connection_info.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
695 :
696 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
697 : spdm_context->transcript.message_m.buffer_size =
698 : spdm_context->transcript.message_m.max_buffer_size;
699 : #endif
700 1 : cert_chain_size = sizeof(cert_chain);
701 1 : libspdm_zero_mem(cert_chain, sizeof(cert_chain));
702 1 : status = libspdm_get_certificate(spdm_context, NULL, 0, &cert_chain_size, cert_chain);
703 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
704 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
705 : count = (data_size + m_libspdm_local_req_msg_size_test_case_1 - 1) / m_libspdm_local_req_msg_size_test_case_1;
706 : assert_int_equal(spdm_context->transcript.message_b.buffer_size,
707 : sizeof(spdm_get_certificate_request_t) * count +
708 : sizeof(spdm_certificate_response_t) * count +
709 : data_size);
710 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
711 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = 0;
712 : #else
713 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size = 0;
714 : #endif
715 1 : free(data);
716 1 : }
717 : #endif
718 : #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
719 1 : static void req_chunk_get_case2(void** state)
720 : {
721 : /* Copied from Get Measurements Test Case 0x20 */
722 : libspdm_return_t status;
723 : libspdm_test_context_t* spdm_test_context;
724 : libspdm_context_t* spdm_context;
725 : uint8_t number_of_block;
726 : uint32_t measurement_record_length;
727 : uint8_t measurement_record[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE];
728 : uint8_t request_attribute;
729 : void* data;
730 : size_t data_size;
731 : void* hash;
732 : size_t hash_size;
733 :
734 1 : spdm_test_context = *state;
735 1 : spdm_context = spdm_test_context->spdm_context;
736 1 : spdm_test_context->case_id = 0x02;
737 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
738 : SPDM_VERSION_NUMBER_SHIFT_BIT;
739 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
740 1 : spdm_context->connection_info.capability.flags |=
741 : (SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG
742 : | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP);
743 :
744 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP;
745 : spdm_context->local_context.capability.data_transfer_size
746 1 : = CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
747 :
748 1 : libspdm_read_responder_public_certificate_chain(
749 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
750 : &data, &data_size, &hash, &hash_size);
751 1 : libspdm_reset_message_m(spdm_context, NULL);
752 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
753 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
754 : m_libspdm_use_measurement_hash_algo;
755 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
756 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
757 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
758 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
759 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
760 : libspdm_copy_mem(
761 : spdm_context->connection_info.peer_used_cert_chain[0].buffer,
762 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
763 : data, data_size);
764 : #else
765 1 : libspdm_hash_all(
766 : spdm_context->connection_info.algorithm.base_hash_algo,
767 : data, data_size,
768 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
769 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
770 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
771 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
772 : spdm_context->connection_info.algorithm.base_hash_algo,
773 : spdm_context->connection_info.algorithm.base_asym_algo,
774 : data, data_size,
775 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
776 : #endif
777 1 : request_attribute = 0;
778 :
779 1 : measurement_record_length = sizeof(measurement_record);
780 1 : status = libspdm_get_measurement(
781 : spdm_context, NULL, request_attribute,
782 : SPDM_GET_MEASUREMENTS_REQUEST_MEASUREMENT_OPERATION_ALL_MEASUREMENTS,
783 : 0, NULL, &number_of_block, &measurement_record_length,
784 : measurement_record);
785 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
786 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
787 : assert_int_equal(spdm_context->transcript.message_m.buffer_size,
788 : sizeof(spdm_message_header_t) +
789 : sizeof(spdm_measurements_response_t) +
790 : 2 * (sizeof(spdm_measurement_block_dmtf_t) +
791 : libspdm_get_measurement_hash_size(
792 : m_libspdm_use_measurement_hash_algo)) +
793 : sizeof(uint16_t) + SPDM_NONCE_SIZE);
794 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = 0;
795 : #else
796 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size = 0;
797 : #endif
798 1 : free(data);
799 1 : }
800 : #endif
801 :
802 : #if LIBSPDM_SEND_CHALLENGE_SUPPORT
803 1 : static void req_chunk_get_case3(void** state)
804 : {
805 : /* Copied from Challenge Test Case 2*/
806 : libspdm_return_t status;
807 : libspdm_test_context_t* spdm_test_context;
808 : libspdm_context_t* spdm_context;
809 : uint8_t measurement_hash[LIBSPDM_MAX_HASH_SIZE];
810 : void* data;
811 : size_t data_size;
812 : void* hash;
813 : size_t hash_size;
814 :
815 1 : spdm_test_context = *state;
816 1 : spdm_context = spdm_test_context->spdm_context;
817 1 : spdm_test_context->case_id = 0x3;
818 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
819 1 : spdm_context->connection_info.capability.flags = 0;
820 1 : spdm_context->connection_info.capability.flags |=
821 : (SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP
822 : | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP);
823 :
824 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP;
825 : spdm_context->local_context.capability.data_transfer_size
826 1 : = CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
827 :
828 1 : libspdm_read_responder_public_certificate_chain(
829 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
830 : &data, &data_size, &hash, &hash_size);
831 1 : libspdm_reset_message_a(spdm_context);
832 1 : libspdm_reset_message_b(spdm_context);
833 1 : libspdm_reset_message_c(spdm_context);
834 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
835 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
836 :
837 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
838 : SPDM_VERSION_NUMBER_SHIFT_BIT;
839 :
840 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
841 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
842 : libspdm_copy_mem(
843 : spdm_context->connection_info.peer_used_cert_chain[0].buffer,
844 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
845 : data, data_size);
846 : #else
847 1 : libspdm_hash_all(
848 : spdm_context->connection_info.algorithm.base_hash_algo,
849 : data, data_size,
850 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
851 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
852 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
853 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
854 : spdm_context->connection_info.algorithm.base_hash_algo,
855 : spdm_context->connection_info.algorithm.base_asym_algo,
856 : data, data_size,
857 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
858 : #endif
859 :
860 1 : libspdm_zero_mem(measurement_hash, sizeof(measurement_hash));
861 1 : status = libspdm_challenge(
862 : spdm_context, NULL, 0,
863 : SPDM_CHALLENGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH,
864 : measurement_hash, NULL);
865 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
866 1 : free(data);
867 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
868 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = 0;
869 : #else
870 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size = 0;
871 : #endif
872 1 : }
873 : #endif /* LIBSPDM_SEND_CHALLENGE_SUPPORT */
874 :
875 : #if LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT
876 1 : static void req_chunk_get_case4(void** state)
877 : {
878 : /* Copied from Get Digests Test Case 2*/
879 : libspdm_return_t status;
880 : libspdm_test_context_t* spdm_test_context;
881 : libspdm_context_t* spdm_context;
882 : libspdm_data_parameter_t parameter;
883 : uint8_t slot_mask;
884 : uint8_t slot_id;
885 : uint8_t total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
886 : uint8_t my_total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
887 : uint8_t* digest;
888 : size_t data_return_size;
889 :
890 1 : spdm_test_context = *state;
891 1 : spdm_context = spdm_test_context->spdm_context;
892 1 : spdm_test_context->case_id = 0x4;
893 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
894 : SPDM_VERSION_NUMBER_SHIFT_BIT;
895 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
896 1 : spdm_context->connection_info.capability.flags |=
897 : (SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP
898 : | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP);
899 :
900 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP;
901 : spdm_context->local_context.capability.data_transfer_size
902 1 : = CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
903 :
904 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
905 :
906 1 : libspdm_set_mem(
907 : m_libspdm_local_certificate_chain_test_case_4,
908 : sizeof(m_libspdm_local_certificate_chain_test_case_4),
909 : (uint8_t) (0xFF));
910 1 : libspdm_reset_message_b(spdm_context);
911 :
912 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
913 : spdm_context->transcript.message_m.buffer_size =
914 : spdm_context->transcript.message_m.max_buffer_size;
915 : #endif
916 1 : libspdm_zero_mem(total_digest_buffer, sizeof(total_digest_buffer));
917 1 : status = libspdm_get_digest(spdm_context, NULL, &slot_mask, &total_digest_buffer);
918 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
919 :
920 1 : assert_int_equal(slot_mask, 0xFF);
921 1 : libspdm_zero_mem(my_total_digest_buffer, sizeof(my_total_digest_buffer));
922 1 : digest = my_total_digest_buffer;
923 9 : for (slot_id = 0; slot_id < SPDM_MAX_SLOT_COUNT; slot_id++) {
924 8 : libspdm_hash_all(m_libspdm_use_hash_algo,
925 : m_libspdm_local_certificate_chain_test_case_4,
926 : sizeof(m_libspdm_local_certificate_chain_test_case_4), digest);
927 8 : digest += libspdm_get_hash_size(m_libspdm_use_hash_algo);
928 : }
929 1 : assert_memory_equal(total_digest_buffer, my_total_digest_buffer,
930 : sizeof(my_total_digest_buffer));
931 :
932 1 : parameter.location = LIBSPDM_DATA_LOCATION_CONNECTION;
933 1 : data_return_size = sizeof(uint8_t);
934 1 : status = libspdm_get_data(spdm_context, LIBSPDM_DATA_PEER_SLOT_MASK,
935 : ¶meter, &slot_mask, &data_return_size);
936 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
937 1 : assert_int_equal(data_return_size, sizeof(uint8_t));
938 1 : assert_int_equal(slot_mask, 0xFF);
939 :
940 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
941 : assert_int_equal(
942 : spdm_context->transcript.message_b.buffer_size,
943 : sizeof(spdm_get_digest_request_t) +
944 : sizeof(spdm_digest_response_t) +
945 : libspdm_get_hash_size(spdm_context->connection_info
946 : .algorithm.base_hash_algo) * SPDM_MAX_SLOT_COUNT);
947 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
948 : #endif
949 1 : }
950 : #endif
951 :
952 : #if LIBSPDM_ENABLE_VENDOR_DEFINED_MESSAGES
953 1 : static void req_chunk_get_case5(void **state)
954 : {
955 : /* Copied from Vendor Request case 1*/
956 : libspdm_return_t status;
957 : libspdm_test_context_t *spdm_test_context;
958 : libspdm_context_t *spdm_context;
959 :
960 1 : uint16_t standard_id = 6;
961 1 : uint8_t vendor_id_len = 2;
962 1 : uint8_t vendor_id[SPDM_MAX_VENDOR_ID_LENGTH] = {0xAA, 0xAA};
963 1 : uint32_t data_len = 16;
964 : uint8_t data[16];
965 :
966 1 : spdm_test_context = *state;
967 1 : spdm_context = spdm_test_context->spdm_context;
968 1 : spdm_test_context->case_id = 0x5;
969 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
970 : SPDM_VERSION_NUMBER_SHIFT_BIT;
971 : /* Large response need a large scratch buffer. */
972 1 : spdm_context->connection_info.capability.max_spdm_msg_size =
973 : BUFFER_SIZE_FOR_CHUNK_SEQ_NO_WRAP_TEST;
974 1 : spdm_context->local_context.capability.max_spdm_msg_size =
975 : BUFFER_SIZE_FOR_CHUNK_SEQ_NO_WRAP_TEST;
976 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
977 1 : spdm_context->local_context.capability.data_transfer_size =
978 : CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
979 1 : spdm_context->connection_info.capability.data_transfer_size =
980 : CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
981 1 : spdm_context->local_context.capability.sender_data_transfer_size =
982 : CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
983 1 : spdm_context->local_context.is_requester = true;
984 :
985 1 : spdm_test_context->scratch_buffer_size =
986 1 : libspdm_get_sizeof_required_scratch_buffer(spdm_context);
987 1 : spdm_test_context->scratch_buffer = (void *)malloc(spdm_test_context->scratch_buffer_size);
988 1 : libspdm_set_scratch_buffer (spdm_context,
989 : spdm_test_context->scratch_buffer,
990 : spdm_test_context->scratch_buffer_size);
991 :
992 1 : libspdm_set_mem(data, sizeof(data), 0xAA);
993 :
994 1 : status = libspdm_vendor_send_request_receive_response(spdm_context, NULL,
995 : standard_id, vendor_id_len, vendor_id,
996 : data_len, data,
997 : &standard_id, &vendor_id_len, vendor_id,
998 : &data_len, data);
999 :
1000 1 : assert_int_equal(status, LIBSPDM_STATUS_RECEIVE_FAIL);
1001 1 : }
1002 :
1003 1 : static void req_chunk_get_case6(void **state)
1004 : {
1005 : /* Copied from Chunk Get Request case 5*/
1006 : libspdm_return_t status;
1007 : libspdm_test_context_t *spdm_test_context;
1008 : libspdm_context_t *spdm_context;
1009 :
1010 1 : uint16_t standard_id = 6;
1011 1 : uint8_t vendor_id_len = 2;
1012 1 : uint8_t vendor_id[SPDM_MAX_VENDOR_ID_LENGTH] = {0xAA, 0xAA};
1013 1 : uint32_t data_len = 16;
1014 : uint8_t data[16];
1015 :
1016 1 : spdm_test_context = *state;
1017 1 : spdm_context = spdm_test_context->spdm_context;
1018 1 : spdm_test_context->case_id = 0x6;
1019 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1020 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1021 : /* Large response need a large scratch buffer. */
1022 1 : spdm_context->connection_info.capability.max_spdm_msg_size =
1023 : BUFFER_SIZE_FOR_CHUNK_SEQ_NO_WRAP_TEST;
1024 1 : spdm_context->local_context.capability.max_spdm_msg_size =
1025 : BUFFER_SIZE_FOR_CHUNK_SEQ_NO_WRAP_TEST;
1026 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1027 : /* to pass the exam of max_chunk_data_transfer_size*/
1028 1 : spdm_context->local_context.capability.data_transfer_size =
1029 : CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE + 0x10;
1030 1 : spdm_context->connection_info.capability.data_transfer_size =
1031 : CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE + 0x10;
1032 1 : spdm_context->local_context.capability.sender_data_transfer_size =
1033 : CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE + 0x10;
1034 1 : spdm_context->local_context.is_requester = true;
1035 :
1036 1 : spdm_test_context->scratch_buffer_size =
1037 1 : libspdm_get_sizeof_required_scratch_buffer(spdm_context);
1038 1 : spdm_test_context->scratch_buffer = (void *)malloc(spdm_test_context->scratch_buffer_size);
1039 1 : libspdm_set_scratch_buffer (spdm_context,
1040 : spdm_test_context->scratch_buffer,
1041 : spdm_test_context->scratch_buffer_size);
1042 :
1043 1 : libspdm_set_mem(data, sizeof(data), 0xAA);
1044 :
1045 1 : status = libspdm_vendor_send_request_receive_response(spdm_context, NULL,
1046 : standard_id, vendor_id_len, vendor_id,
1047 : data_len, data,
1048 : &standard_id, &vendor_id_len, vendor_id,
1049 : &data_len, data);
1050 :
1051 1 : assert_int_equal(status, LIBSPDM_STATUS_RECEIVE_FAIL);
1052 1 : }
1053 :
1054 1 : static void req_chunk_get_case7(void **state)
1055 : {
1056 : /* Copied from Chunk Get Request case 5*/
1057 : libspdm_return_t status;
1058 : libspdm_test_context_t *spdm_test_context;
1059 : libspdm_context_t *spdm_context;
1060 :
1061 1 : uint16_t standard_id = 6;
1062 1 : uint8_t vendor_id_len = 2;
1063 1 : uint8_t vendor_id[SPDM_MAX_VENDOR_ID_LENGTH] = {0xAA, 0xAA};
1064 1 : uint32_t data_len = 16;
1065 : uint8_t data[16];
1066 :
1067 1 : spdm_test_context = *state;
1068 1 : spdm_context = spdm_test_context->spdm_context;
1069 1 : spdm_test_context->case_id = 0x7;
1070 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1071 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1072 : /* Large response need a large scratch buffer. */
1073 1 : spdm_context->connection_info.capability.max_spdm_msg_size =
1074 : BUFFER_SIZE_FOR_CHUNK_SEQ_NO_WRAP_TEST;
1075 1 : spdm_context->local_context.capability.max_spdm_msg_size =
1076 : BUFFER_SIZE_FOR_CHUNK_SEQ_NO_WRAP_TEST;
1077 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1078 1 : spdm_context->local_context.capability.data_transfer_size =
1079 : CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
1080 1 : spdm_context->connection_info.capability.data_transfer_size =
1081 : CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
1082 1 : spdm_context->local_context.capability.sender_data_transfer_size =
1083 : CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
1084 1 : spdm_context->local_context.is_requester = true;
1085 :
1086 1 : spdm_test_context->scratch_buffer_size =
1087 1 : libspdm_get_sizeof_required_scratch_buffer(spdm_context);
1088 1 : spdm_test_context->scratch_buffer = (void *)malloc(spdm_test_context->scratch_buffer_size);
1089 1 : libspdm_set_scratch_buffer (spdm_context,
1090 : spdm_test_context->scratch_buffer,
1091 : spdm_test_context->scratch_buffer_size);
1092 :
1093 1 : libspdm_set_mem(data, sizeof(data), 0xAA);
1094 :
1095 1 : status = libspdm_vendor_send_request_receive_response(spdm_context, NULL,
1096 : standard_id, vendor_id_len, vendor_id,
1097 : data_len, data,
1098 : &standard_id, &vendor_id_len, vendor_id,
1099 : &data_len, data);
1100 :
1101 1 : assert_int_equal(status, LIBSPDM_STATUS_RESYNCH_PEER);
1102 1 : assert_int_equal(spdm_context->connection_info.connection_state,
1103 : LIBSPDM_CONNECTION_STATE_NOT_STARTED);
1104 1 : }
1105 : #endif /* LIBSPDM_ENABLE_VENDOR_DEFINED_MESSAGES */
1106 :
1107 : #if LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT
1108 1 : static void req_chunk_get_case8(void** state)
1109 : {
1110 : /* Copied from Chunk Send Test Case 4, use spdm 1.4*/
1111 : libspdm_return_t status;
1112 : libspdm_test_context_t* spdm_test_context;
1113 : libspdm_context_t* spdm_context;
1114 : libspdm_data_parameter_t parameter;
1115 : uint8_t slot_mask;
1116 : uint8_t slot_id;
1117 : uint8_t total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
1118 : uint8_t my_total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
1119 : uint8_t* digest;
1120 : size_t data_return_size;
1121 :
1122 1 : spdm_test_context = *state;
1123 1 : spdm_context = spdm_test_context->spdm_context;
1124 1 : spdm_test_context->case_id = 0x8;
1125 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_14 <<
1126 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1127 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1128 1 : spdm_context->connection_info.capability.flags |=
1129 : (SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP
1130 : | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP);
1131 :
1132 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP;
1133 : spdm_context->local_context.capability.data_transfer_size
1134 1 : = CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
1135 :
1136 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1137 :
1138 1 : libspdm_set_mem(
1139 : m_libspdm_local_certificate_chain_test_case_4,
1140 : sizeof(m_libspdm_local_certificate_chain_test_case_4),
1141 : (uint8_t) (0xFF));
1142 1 : libspdm_reset_message_b(spdm_context);
1143 :
1144 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1145 : spdm_context->transcript.message_m.buffer_size =
1146 : spdm_context->transcript.message_m.max_buffer_size;
1147 : #endif
1148 1 : libspdm_zero_mem(total_digest_buffer, sizeof(total_digest_buffer));
1149 1 : status = libspdm_get_digest(spdm_context, NULL, &slot_mask, &total_digest_buffer);
1150 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1151 :
1152 1 : assert_int_equal(slot_mask, 0xFF);
1153 1 : libspdm_zero_mem(my_total_digest_buffer, sizeof(my_total_digest_buffer));
1154 1 : digest = my_total_digest_buffer;
1155 9 : for (slot_id = 0; slot_id < SPDM_MAX_SLOT_COUNT; slot_id++) {
1156 8 : libspdm_hash_all(m_libspdm_use_hash_algo,
1157 : m_libspdm_local_certificate_chain_test_case_4,
1158 : sizeof(m_libspdm_local_certificate_chain_test_case_4), digest);
1159 8 : digest += libspdm_get_hash_size(m_libspdm_use_hash_algo);
1160 : }
1161 1 : assert_memory_equal(total_digest_buffer, my_total_digest_buffer,
1162 : sizeof(my_total_digest_buffer));
1163 :
1164 1 : parameter.location = LIBSPDM_DATA_LOCATION_CONNECTION;
1165 1 : data_return_size = sizeof(uint8_t);
1166 1 : status = libspdm_get_data(spdm_context, LIBSPDM_DATA_PEER_SLOT_MASK,
1167 : ¶meter, &slot_mask, &data_return_size);
1168 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1169 1 : assert_int_equal(data_return_size, sizeof(uint8_t));
1170 1 : assert_int_equal(slot_mask, 0xFF);
1171 :
1172 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1173 : assert_int_equal(
1174 : spdm_context->transcript.message_b.buffer_size,
1175 : sizeof(spdm_get_digest_request_t) +
1176 : sizeof(spdm_digest_response_t) +
1177 : libspdm_get_hash_size(spdm_context->connection_info
1178 : .algorithm.base_hash_algo) * SPDM_MAX_SLOT_COUNT);
1179 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1180 : #endif
1181 1 : }
1182 : #endif
1183 :
1184 : #if LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT
1185 1 : static void req_chunk_get_case9(void** state)
1186 : {
1187 : libspdm_return_t status;
1188 : libspdm_test_context_t* spdm_test_context;
1189 : libspdm_context_t* spdm_context;
1190 : uint8_t slot_mask;
1191 : uint8_t total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
1192 :
1193 1 : spdm_test_context = *state;
1194 1 : spdm_context = spdm_test_context->spdm_context;
1195 1 : spdm_test_context->case_id = 0x9;
1196 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1197 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1198 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1199 1 : spdm_context->connection_info.capability.flags |=
1200 : (SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP
1201 : | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP);
1202 :
1203 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP;
1204 : spdm_context->local_context.capability.data_transfer_size
1205 1 : = CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
1206 :
1207 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1208 :
1209 1 : libspdm_set_mem(
1210 : m_libspdm_local_certificate_chain_test_case_4,
1211 : sizeof(m_libspdm_local_certificate_chain_test_case_4),
1212 : (uint8_t) (0xFF));
1213 1 : libspdm_reset_message_b(spdm_context);
1214 :
1215 1 : libspdm_zero_mem(total_digest_buffer, sizeof(total_digest_buffer));
1216 1 : status = libspdm_get_digest(spdm_context, NULL, &slot_mask, &total_digest_buffer);
1217 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1218 1 : }
1219 :
1220 1 : static void req_chunk_get_case10(void** state)
1221 : {
1222 : libspdm_return_t status;
1223 : libspdm_test_context_t* spdm_test_context;
1224 : libspdm_context_t* spdm_context;
1225 : uint8_t slot_mask;
1226 : uint8_t total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
1227 :
1228 1 : spdm_test_context = *state;
1229 1 : spdm_context = spdm_test_context->spdm_context;
1230 1 : spdm_test_context->case_id = 0xA;
1231 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_14 <<
1232 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1233 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1234 1 : spdm_context->connection_info.capability.flags |=
1235 : (SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP
1236 : | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP);
1237 :
1238 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP;
1239 : spdm_context->local_context.capability.data_transfer_size
1240 1 : = CHUNK_GET_REQUESTER_UNIT_TEST_DATA_TRANSFER_SIZE;
1241 :
1242 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1243 :
1244 1 : libspdm_set_mem(
1245 : m_libspdm_local_certificate_chain_test_case_4,
1246 : sizeof(m_libspdm_local_certificate_chain_test_case_4),
1247 : (uint8_t) (0xFF));
1248 1 : libspdm_reset_message_b(spdm_context);
1249 :
1250 1 : libspdm_zero_mem(total_digest_buffer, sizeof(total_digest_buffer));
1251 1 : status = libspdm_get_digest(spdm_context, NULL, &slot_mask, &total_digest_buffer);
1252 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1253 1 : }
1254 : #endif
1255 :
1256 :
1257 1 : int libspdm_req_chunk_get_test(void)
1258 : {
1259 : /* Test the CHUNK_GET handlers in various requester handlers */
1260 1 : const struct CMUnitTest test_cases[] = {
1261 : #if LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT
1262 : /* Request a certificate in portions */
1263 : cmocka_unit_test(req_chunk_get_case1),
1264 : #endif
1265 : #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
1266 : /* Request all measurements */
1267 : cmocka_unit_test(req_chunk_get_case2),
1268 : #endif
1269 : #if LIBSPDM_SEND_CHALLENGE_SUPPORT
1270 : /* Request Challenge */
1271 : cmocka_unit_test(req_chunk_get_case3),
1272 : #endif
1273 : #if LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT
1274 : /* Request Digests */
1275 : cmocka_unit_test(req_chunk_get_case4),
1276 : #endif
1277 : #if LIBSPDM_ENABLE_VENDOR_DEFINED_MESSAGES
1278 : /* Request Vendor Specific Response and chunk data size
1279 : * exceed max_chunk_data_transfer_size
1280 : */
1281 : cmocka_unit_test(req_chunk_get_case5),
1282 : /* Request Vendor Specific Response and chunk seq no wrapped */
1283 : cmocka_unit_test(req_chunk_get_case6),
1284 : /* Request Vendor Specific Response
1285 : * and receive error code RequestResync */
1286 : cmocka_unit_test(req_chunk_get_case7),
1287 : #endif
1288 : #if LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT
1289 : /* Request Digests with spdm 1.4 */
1290 : cmocka_unit_test(req_chunk_get_case8),
1291 : /* Reject CHUNK_RESPONSE with mismatched handle */
1292 : cmocka_unit_test(req_chunk_get_case9),
1293 : /* Reject CHUNK_RESPONSE with mismatched handle in spdm 1.4 */
1294 : cmocka_unit_test(req_chunk_get_case10),
1295 : #endif
1296 : };
1297 :
1298 1 : libspdm_test_context_t test_context = {
1299 : LIBSPDM_TEST_CONTEXT_VERSION,
1300 : true,
1301 : send_message,
1302 : receive_message,
1303 : };
1304 :
1305 1 : libspdm_setup_test_context(&test_context);
1306 :
1307 1 : return cmocka_run_group_tests(test_cases,
1308 : libspdm_unit_test_group_setup,
1309 : libspdm_unit_test_group_teardown);
1310 : }
1311 :
1312 : #endif /* LIBSPDM_ENABLE_CAPABILITY_CHUNK_CAP*/
|
