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_requester_lib.h"
9 :
10 : #if (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (LIBSPDM_ENABLE_CAPABILITY_CERT_CAP)
11 :
12 : /* #define TEST_DEBUG*/
13 : #ifdef TEST_DEBUG
14 : #define TEST_DEBUG_PRINT(format, ...) printf(format, ## __VA_ARGS__)
15 : #else
16 : #define TEST_DEBUG_PRINT(...)
17 : #endif
18 :
19 : spdm_get_certificate_request_t m_spdm_get_certificate_request1 = {
20 : {SPDM_MESSAGE_VERSION_11, SPDM_GET_CERTIFICATE, 0, 0},
21 : 0,
22 : LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN
23 : };
24 : size_t m_spdm_get_certificate_request1_size =
25 : sizeof(m_spdm_get_certificate_request1);
26 :
27 : spdm_get_certificate_request_t m_spdm_get_certificate_request3 = {
28 : {SPDM_MESSAGE_VERSION_11, SPDM_GET_CERTIFICATE, 0, 0}, 0, 0
29 : };
30 : size_t m_spdm_get_certificate_request3_size =
31 : sizeof(m_spdm_get_certificate_request3);
32 :
33 : spdm_get_certificate_request_t m_spdm_get_certificate_request4 = {
34 : {SPDM_MESSAGE_VERSION_13, SPDM_GET_CERTIFICATE, 0, 0},
35 : 0,
36 : LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN
37 : };
38 : size_t m_spdm_get_certificate_request4_size =
39 : sizeof(m_spdm_get_certificate_request4);
40 :
41 : /**
42 : * Test 1: request the first LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN bytes of the
43 : * certificate chain Expected Behavior: generate a correctly formed Certificate
44 : * message, including its portion_length and remainder_length fields
45 : **/
46 1 : void libspdm_test_requester_encap_certificate_case1(void **state)
47 : {
48 : libspdm_return_t status;
49 : libspdm_test_context_t *spdm_test_context;
50 : libspdm_context_t *spdm_context;
51 : size_t response_size;
52 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
53 : spdm_certificate_response_t *spdm_response;
54 : void *data;
55 : size_t data_size;
56 :
57 1 : spdm_test_context = *state;
58 1 : spdm_context = spdm_test_context->spdm_context;
59 1 : spdm_test_context->case_id = 0x1;
60 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11
61 : << SPDM_VERSION_NUMBER_SHIFT_BIT;
62 1 : spdm_context->connection_info.connection_state =
63 : LIBSPDM_CONNECTION_STATE_AFTER_DIGESTS;
64 1 : spdm_context->local_context.capability.flags |=
65 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
66 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
67 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
68 : m_libspdm_use_asym_algo,
69 : &data, &data_size, NULL, NULL);
70 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
71 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
72 :
73 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
74 : spdm_context->transcript.message_m.buffer_size =
75 : spdm_context->transcript.message_m.max_buffer_size;
76 : #endif
77 :
78 1 : response_size = sizeof(response);
79 1 : status = libspdm_get_encap_response_certificate(
80 : spdm_context, m_spdm_get_certificate_request1_size,
81 : &m_spdm_get_certificate_request1, &response_size, response);
82 :
83 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
84 1 : assert_int_equal(response_size, sizeof(spdm_certificate_response_t) +
85 : LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN);
86 1 : spdm_response = (void *)response;
87 1 : assert_int_equal(spdm_response->header.request_response_code,
88 : SPDM_CERTIFICATE);
89 1 : assert_int_equal(spdm_response->header.param1, 0);
90 1 : assert_int_equal(spdm_response->portion_length,
91 : LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN);
92 1 : assert_int_equal(spdm_response->remainder_length,
93 : data_size - LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN);
94 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
95 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
96 : #endif
97 1 : free(data);
98 1 : }
99 :
100 : /**
101 : * Test 2:
102 : * Expected Behavior:
103 : **/
104 1 : void libspdm_test_requester_encap_certificate_case2(void **state)
105 : {
106 1 : }
107 :
108 : /**
109 : * Test 3: request length at the boundary of maximum integer values, while
110 : * keeping offset 0 Expected Behavior: generate correctly formed Certificate
111 : * messages, including its portion_length and remainder_length fields
112 : **/
113 0 : void libspdm_test_requester_encap_certificate_case3(void **state)
114 : {
115 : libspdm_return_t status;
116 : libspdm_test_context_t *spdm_test_context;
117 : libspdm_context_t *spdm_context;
118 : size_t response_size;
119 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
120 : spdm_certificate_response_t *spdm_response;
121 : void *data;
122 : size_t data_size;
123 :
124 : /* Testing Lengths at the boundary of maximum integer values*/
125 0 : uint16_t test_lengths[] = {
126 : 0,
127 : 0x7F,
128 : (uint16_t)(0x7F + 1),
129 : 0xFF,
130 : 0x7FFF,
131 : (uint16_t)(0x7FFF + 1),
132 : 0xFFFF,
133 : };
134 : uint16_t expected_chunk_size;
135 :
136 : /* Setting up the spdm_context and loading a sample certificate chain*/
137 0 : spdm_test_context = *state;
138 0 : spdm_context = spdm_test_context->spdm_context;
139 0 : spdm_test_context->case_id = 0x3;
140 0 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11
141 : << SPDM_VERSION_NUMBER_SHIFT_BIT;
142 0 : spdm_context->local_context.capability.flags |=
143 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
144 0 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
145 0 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
146 : m_libspdm_use_asym_algo,
147 : &data, &data_size, NULL, NULL);
148 0 : spdm_context->local_context.local_cert_chain_provision[0] = data;
149 0 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
150 :
151 : /* This tests considers only offset = 0, other tests vary offset value*/
152 0 : m_spdm_get_certificate_request3.offset = 0;
153 :
154 0 : for (int i = 0; i < sizeof(test_lengths) / sizeof(test_lengths[0]); i++)
155 : {
156 : TEST_DEBUG_PRINT("i:%d test_lengths[i]:%u\n", i, test_lengths[i]);
157 0 : m_spdm_get_certificate_request3.length = test_lengths[i];
158 : /* Expected received length is limited by LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN
159 : * (implementation specific?)*/
160 0 : expected_chunk_size = LIBSPDM_MIN(m_spdm_get_certificate_request3.length,
161 : LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN);
162 :
163 : /* resetting an internal buffer to avoid overflow and prevent tests to
164 : * succeed*/
165 0 : libspdm_reset_message_mut_b(spdm_context);
166 0 : response_size = sizeof(response);
167 0 : m_spdm_get_certificate_request3_size =
168 : sizeof(m_spdm_get_certificate_request3);
169 0 : status = libspdm_get_encap_response_certificate(
170 : spdm_context, m_spdm_get_certificate_request3_size,
171 : &m_spdm_get_certificate_request3, &response_size, response);
172 0 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
173 0 : assert_int_equal(response_size,
174 : sizeof(spdm_certificate_response_t) + expected_chunk_size);
175 0 : spdm_response = (void *)response;
176 0 : assert_int_equal(spdm_response->header.request_response_code,
177 : SPDM_CERTIFICATE);
178 0 : assert_int_equal(spdm_response->header.param1, 0);
179 0 : assert_int_equal(spdm_response->portion_length, expected_chunk_size);
180 0 : assert_int_equal(spdm_response->remainder_length,
181 : data_size - expected_chunk_size);
182 : }
183 0 : free(data);
184 0 : }
185 :
186 : /**
187 : * Test 4: request offset at the boundary of maximum integer values, while
188 : * keeping length 0 Expected Behavior: generate correctly formed Certificate
189 : * messages, including its portion_length and remainder_length fields
190 : **/
191 1 : void libspdm_test_requester_encap_certificate_case4(void **state)
192 : {
193 : libspdm_return_t status;
194 : libspdm_test_context_t *spdm_test_context;
195 : libspdm_context_t *spdm_context;
196 : size_t response_size;
197 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
198 : spdm_certificate_response_t *spdm_response;
199 : spdm_error_response_t *spdm_responseError;
200 : void *data;
201 : size_t data_size;
202 :
203 : /* Testing offsets at the boundary of maximum integer values and at the
204 : * boundary of certificate length (first three positions)*/
205 1 : uint16_t test_offsets[] = {(uint16_t)(-1),
206 : 0,
207 : +1,
208 : 0,
209 : 0x7F,
210 : (uint16_t)(0x7F + 1),
211 : 0xFF,
212 : 0x7FFF,
213 : (uint16_t)(0x7FFF + 1),
214 : 0xFFFF,
215 : (uint16_t)(-1)};
216 :
217 : /* Setting up the spdm_context and loading a sample certificate chain*/
218 1 : spdm_test_context = *state;
219 1 : spdm_context = spdm_test_context->spdm_context;
220 1 : spdm_test_context->case_id = 0x4;
221 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11
222 : << SPDM_VERSION_NUMBER_SHIFT_BIT;
223 1 : spdm_context->local_context.capability.flags |=
224 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
225 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
226 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
227 : m_libspdm_use_asym_algo,
228 : &data, &data_size, NULL, NULL);
229 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
230 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
231 :
232 : /* This tests considers only length = 0, other tests vary length value*/
233 1 : m_spdm_get_certificate_request3.length = 0;
234 : /* Setting up offset values at the boundary of certificate length*/
235 1 : test_offsets[0] = (uint16_t)(test_offsets[0] + data_size);
236 1 : test_offsets[1] = (uint16_t)(test_offsets[1] + data_size);
237 1 : test_offsets[2] = (uint16_t)(test_offsets[2] + data_size);
238 :
239 12 : for (int i = 0; i < sizeof(test_offsets) / sizeof(test_offsets[0]); i++)
240 : {
241 : TEST_DEBUG_PRINT("i:%d test_offsets[i]:%u\n", i, test_offsets[i]);
242 11 : m_spdm_get_certificate_request3.offset = test_offsets[i];
243 :
244 : /* resetting an internal buffer to avoid overflow and prevent tests to
245 : * succeed*/
246 11 : libspdm_reset_message_mut_b(spdm_context);
247 11 : response_size = sizeof(response);
248 11 : status = libspdm_get_encap_response_certificate(
249 : spdm_context, m_spdm_get_certificate_request3_size,
250 : &m_spdm_get_certificate_request3, &response_size, response);
251 11 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
252 :
253 11 : if (m_spdm_get_certificate_request3.offset >= data_size) {
254 : /* A too long of an offset should return an error*/
255 6 : spdm_responseError = (void *)response;
256 6 : assert_int_equal(spdm_responseError->header.request_response_code,
257 : SPDM_ERROR);
258 6 : assert_int_equal(spdm_responseError->header.param1,
259 : SPDM_ERROR_CODE_INVALID_REQUEST);
260 : } else {
261 : /* Otherwise it should work properly, considering length = 0*/
262 5 : assert_int_equal(response_size, sizeof(spdm_certificate_response_t));
263 5 : spdm_response = (void *)response;
264 5 : assert_int_equal(spdm_response->header.request_response_code,
265 : SPDM_CERTIFICATE);
266 5 : assert_int_equal(spdm_response->header.param1, 0);
267 5 : assert_int_equal(spdm_response->portion_length, 0);
268 5 : assert_int_equal(
269 : spdm_response->remainder_length,
270 : (uint16_t)(data_size - m_spdm_get_certificate_request3.offset));
271 : }
272 : }
273 1 : free(data);
274 1 : }
275 :
276 : /**
277 : * Test 5: request LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN bytes of long certificate
278 : * chains, with the largest valid offset Expected Behavior: generate correctly
279 : * formed Certificate messages, including its portion_length and remainder_length
280 : * fields
281 : **/
282 1 : void libspdm_test_requester_encap_certificate_case5(void **state)
283 : {
284 : libspdm_return_t status;
285 : libspdm_test_context_t *spdm_test_context;
286 : libspdm_context_t *spdm_context;
287 : size_t response_size;
288 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
289 : spdm_certificate_response_t *spdm_response;
290 : spdm_error_response_t *spdm_responseError;
291 : void *data;
292 : size_t data_size;
293 :
294 1 : uint16_t test_cases[] = {LIBSPDM_TEST_CERT_MAXINT16, LIBSPDM_TEST_CERT_MAXUINT16};
295 :
296 : size_t expected_chunk_size;
297 : size_t expected_remainder;
298 :
299 : /* Setting up the spdm_context and loading a sample certificate chain*/
300 1 : spdm_test_context = *state;
301 1 : spdm_context = spdm_test_context->spdm_context;
302 1 : spdm_test_context->case_id = 0x5;
303 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11
304 : << SPDM_VERSION_NUMBER_SHIFT_BIT;
305 1 : spdm_context->local_context.capability.flags |=
306 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
307 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
308 :
309 1 : m_spdm_get_certificate_request3.length = LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN;
310 :
311 3 : for (int i = 0; i < sizeof(test_cases) / sizeof(test_cases[0]); i++)
312 : {
313 2 : libspdm_read_responder_public_certificate_chain_by_size(
314 : /*MAXUINT16_CERT signature_algo is SHA256RSA */
315 : m_libspdm_use_hash_algo, SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048,
316 2 : test_cases[i], &data, &data_size, NULL, NULL);
317 :
318 2 : spdm_context->local_context.local_cert_chain_provision[0] = data;
319 2 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
320 :
321 2 : m_spdm_get_certificate_request3.offset =
322 2 : (uint16_t)(LIBSPDM_MIN(data_size - 1, 0xFFFF));
323 : TEST_DEBUG_PRINT("data_size: %u\n", data_size);
324 : TEST_DEBUG_PRINT("m_spdm_get_certificate_request3.offset: %u\n",
325 : m_spdm_get_certificate_request3.offset);
326 : TEST_DEBUG_PRINT("m_spdm_get_certificate_request3.length: %u\n",
327 : m_spdm_get_certificate_request3.length);
328 : TEST_DEBUG_PRINT("offset + length: %u\n",
329 : m_spdm_get_certificate_request3.offset +
330 : m_spdm_get_certificate_request3.length);
331 :
332 : /* resetting an internal buffer to avoid overflow and prevent tests to
333 : * succeed*/
334 2 : libspdm_reset_message_mut_b(spdm_context);
335 2 : response_size = sizeof(response);
336 2 : status = libspdm_get_encap_response_certificate(
337 : spdm_context, m_spdm_get_certificate_request3_size,
338 : &m_spdm_get_certificate_request3, &response_size, response);
339 2 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
340 :
341 : /* Expected received length is limited by LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN
342 : * and by the remaining length*/
343 2 : expected_chunk_size =
344 2 : (uint16_t)(LIBSPDM_MIN(m_spdm_get_certificate_request3.length,
345 : data_size - m_spdm_get_certificate_request3.offset));
346 2 : expected_chunk_size =
347 : LIBSPDM_MIN(expected_chunk_size, LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN);
348 : /* Expected certificate length left*/
349 2 : expected_remainder =
350 2 : (uint16_t)(data_size - m_spdm_get_certificate_request3.offset -
351 : expected_chunk_size);
352 :
353 : TEST_DEBUG_PRINT("expected_chunk_size %u\n", expected_chunk_size);
354 : TEST_DEBUG_PRINT("expected_remainder %u\n", expected_remainder);
355 :
356 2 : if (expected_remainder > 0xFFFF || expected_chunk_size > 0xFFFF) {
357 0 : spdm_responseError = (void *)response;
358 0 : assert_int_equal(spdm_responseError->header.request_response_code,
359 : SPDM_ERROR);
360 0 : assert_int_equal(spdm_responseError->header.param1,
361 : SPDM_ERROR_CODE_INVALID_REQUEST);
362 : } else {
363 2 : assert_int_equal(response_size, sizeof(spdm_certificate_response_t) +
364 : expected_chunk_size);
365 2 : spdm_response = (void *)response;
366 2 : assert_int_equal(spdm_response->header.request_response_code,
367 : SPDM_CERTIFICATE);
368 2 : assert_int_equal(spdm_response->header.param1, 0);
369 2 : assert_int_equal(spdm_response->portion_length, expected_chunk_size);
370 2 : assert_int_equal(spdm_response->remainder_length, expected_remainder);
371 : }
372 :
373 : TEST_DEBUG_PRINT("\n");
374 :
375 2 : spdm_context->local_context.local_cert_chain_provision[0] = NULL;
376 2 : spdm_context->local_context.local_cert_chain_provision_size[0] = 0;
377 2 : free(data);
378 : }
379 1 : }
380 :
381 : /**
382 : * Test 6: request a whole certificate chain byte by byte
383 : * Expected Behavior: generate correctly formed Certificate messages, including
384 : * its portion_length and remainder_length fields
385 : **/
386 1 : void libspdm_test_requester_encap_certificate_case6(void **state)
387 : {
388 : libspdm_return_t status;
389 : libspdm_test_context_t *spdm_test_context;
390 : libspdm_context_t *spdm_context;
391 : size_t response_size;
392 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
393 : spdm_certificate_response_t *spdm_response;
394 : void *data;
395 : size_t data_size;
396 : uint16_t expected_chunk_size;
397 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
398 : size_t count;
399 : #endif
400 : /* Setting up the spdm_context and loading a sample certificate chain*/
401 1 : spdm_test_context = *state;
402 1 : spdm_context = spdm_test_context->spdm_context;
403 1 : spdm_test_context->case_id = 0x6;
404 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11
405 : << SPDM_VERSION_NUMBER_SHIFT_BIT;
406 1 : spdm_context->local_context.capability.flags |=
407 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
408 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
409 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
410 : m_libspdm_use_asym_algo,
411 : &data, &data_size, NULL, NULL);
412 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
413 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
414 :
415 : /* This tests considers only length = 1*/
416 1 : m_spdm_get_certificate_request3.length = 1;
417 1 : expected_chunk_size = 1;
418 :
419 : /* resetting an internal buffer to avoid overflow and prevent tests to
420 : * succeed*/
421 1 : libspdm_reset_message_mut_b(spdm_context);
422 :
423 1 : spdm_response = NULL;
424 1391 : for (size_t offset = 0; offset < data_size; offset++)
425 : {
426 : TEST_DEBUG_PRINT("offset:%u \n", offset);
427 1390 : m_spdm_get_certificate_request3.offset = (uint16_t)offset;
428 :
429 1390 : response_size = sizeof(response);
430 1390 : status = libspdm_get_encap_response_certificate(
431 : spdm_context, m_spdm_get_certificate_request3_size,
432 : &m_spdm_get_certificate_request3, &response_size, response);
433 1390 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
434 1390 : spdm_response = (void *)response;
435 : /* It may fail because the spdm does not support too many messages.
436 : * assert_int_equal (spdm_response->header.request_response_code,
437 : * SPDM_CERTIFICATE);*/
438 1390 : if (spdm_response->header.request_response_code == SPDM_CERTIFICATE) {
439 1390 : assert_int_equal(spdm_response->header.request_response_code,
440 : SPDM_CERTIFICATE);
441 1390 : assert_int_equal(response_size, sizeof(spdm_certificate_response_t) +
442 : expected_chunk_size);
443 1390 : assert_int_equal(spdm_response->header.param1, 0);
444 1390 : assert_int_equal(spdm_response->portion_length, expected_chunk_size);
445 1390 : assert_int_equal(spdm_response->remainder_length,
446 : data_size - offset - expected_chunk_size);
447 1390 : assert_int_equal(((uint8_t *)data)[offset],
448 : (response + sizeof(spdm_certificate_response_t))[0]);
449 : } else {
450 0 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
451 0 : break;
452 : }
453 : }
454 1 : if (spdm_response != NULL) {
455 1 : if (spdm_response->header.request_response_code == SPDM_CERTIFICATE) {
456 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
457 : count = (data_size + m_spdm_get_certificate_request3.length - 1) /
458 : m_spdm_get_certificate_request3.length;
459 : assert_int_equal(spdm_context->transcript.message_mut_b.buffer_size,
460 : sizeof(spdm_get_certificate_request_t) * count +
461 : sizeof(spdm_certificate_response_t) * count +
462 : data_size);
463 : #endif
464 : }
465 : }
466 1 : free(data);
467 1 : }
468 :
469 : /**
470 : * Test 7: check request attributes and response attributes , SlotSizeRequested=1b the Offset and Length fields in the
471 : * GET_CERTIFICATE request shall be ignored by the Responder
472 : * Expected Behavior: generate a correctly formed Certificate message, including its portion_length and remainder_length fields
473 : **/
474 1 : void libspdm_test_requester_encap_certificate_case7(void **state)
475 : {
476 : libspdm_return_t status;
477 : libspdm_test_context_t *spdm_test_context;
478 : libspdm_context_t *spdm_context;
479 : size_t response_size;
480 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
481 : spdm_certificate_response_t *spdm_response;
482 : void *data;
483 : size_t data_size;
484 :
485 1 : spdm_test_context = *state;
486 1 : spdm_context = spdm_test_context->spdm_context;
487 1 : spdm_test_context->case_id = 0x7;
488 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13
489 : << SPDM_VERSION_NUMBER_SHIFT_BIT;
490 1 : spdm_context->connection_info.connection_state =
491 : LIBSPDM_CONNECTION_STATE_AFTER_DIGESTS;
492 1 : spdm_context->local_context.capability.flags = 0;
493 1 : spdm_context->local_context.capability.flags |=
494 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
495 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
496 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
497 : m_libspdm_use_asym_algo,
498 : &data, &data_size, NULL, NULL);
499 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
500 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
501 :
502 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
503 : spdm_context->transcript.message_mut_b.buffer_size = 0;
504 : #endif
505 :
506 : /* When SlotSizeRequested=1b , the Offset and Length fields in the GET_CERTIFICATE request shall be ignored by the Responder */
507 1 : m_spdm_get_certificate_request4.header.param2 =
508 : SPDM_GET_CERTIFICATE_REQUEST_ATTRIBUTES_SLOT_SIZE_REQUESTED;
509 1 : m_spdm_get_certificate_request4.length = LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN;
510 1 : m_spdm_get_certificate_request4.offset = 0xFF;
511 :
512 1 : response_size = sizeof(response);
513 1 : status = libspdm_get_encap_response_certificate(
514 : spdm_context, m_spdm_get_certificate_request4_size,
515 : &m_spdm_get_certificate_request4, &response_size, response);
516 :
517 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
518 1 : assert_int_equal(response_size, sizeof(spdm_certificate_response_t));
519 1 : spdm_response = (void *)response;
520 1 : assert_int_equal(spdm_response->header.request_response_code,
521 : SPDM_CERTIFICATE);
522 1 : assert_int_equal(spdm_response->header.param1, 0);
523 1 : assert_int_equal(spdm_response->portion_length,0);
524 1 : assert_int_equal(spdm_response->remainder_length, data_size);
525 :
526 1 : free(data);
527 1 : }
528 :
529 1 : int libspdm_requester_encap_certificate_test_main(void)
530 : {
531 1 : const struct CMUnitTest spdm_requester_encap_certificate_tests[] = {
532 : /* Success Case*/
533 : cmocka_unit_test(libspdm_test_requester_encap_certificate_case1),
534 : /* Can be populated with new test.*/
535 : cmocka_unit_test(libspdm_test_requester_encap_certificate_case2),
536 : /* Tests varying offset*/
537 : cmocka_unit_test(libspdm_test_requester_encap_certificate_case4),
538 : /* Tests large certificate chains*/
539 : cmocka_unit_test(libspdm_test_requester_encap_certificate_case5),
540 : /* Requests byte by byte*/
541 : cmocka_unit_test(libspdm_test_requester_encap_certificate_case6),
542 : /* check request attributes and response attributes*/
543 : cmocka_unit_test(libspdm_test_requester_encap_certificate_case7),
544 : };
545 :
546 1 : libspdm_test_context_t test_context = {
547 : LIBSPDM_TEST_CONTEXT_VERSION,
548 : false,
549 : };
550 :
551 1 : libspdm_setup_test_context(&test_context);
552 :
553 1 : return cmocka_run_group_tests(spdm_requester_encap_certificate_tests,
554 : libspdm_unit_test_group_setup,
555 : libspdm_unit_test_group_teardown);
556 : }
557 :
558 : #endif /* (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (..) */
|
