Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2025-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 : #include "spdm_unit_test.h"
7 : #include "internal/libspdm_responder_lib.h"
8 :
9 : #if (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (LIBSPDM_SEND_GET_ENDPOINT_INFO_SUPPORT) && \
10 : (LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP)
11 :
12 : #define LIBSPDM_TEST_ENDPOINT_INFO_BUFFER_SIZE 0x20
13 :
14 : static uint8_t m_endpoint_info_buffer_receive[LIBSPDM_TEST_ENDPOINT_INFO_BUFFER_SIZE];
15 : static uint8_t m_endpoint_info_buffer_send[LIBSPDM_TEST_ENDPOINT_INFO_BUFFER_SIZE];
16 :
17 5 : libspdm_return_t get_endpoint_info_callback (
18 : void *spdm_context,
19 : uint8_t subcode,
20 : uint8_t param2,
21 : uint8_t request_attributes,
22 : uint32_t endpoint_info_size,
23 : const void *endpoint_info)
24 : {
25 5 : LIBSPDM_ASSERT (endpoint_info_size <= LIBSPDM_TEST_ENDPOINT_INFO_BUFFER_SIZE);
26 5 : libspdm_copy_mem (m_endpoint_info_buffer_send, endpoint_info_size,
27 : endpoint_info, endpoint_info_size);
28 5 : return LIBSPDM_STATUS_SUCCESS;
29 : }
30 :
31 : /**
32 : * Test 1: Normal case, request a endpoint info with signature
33 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, correct endpoint_info
34 : * and an empty transcript.message_encap_e
35 : **/
36 1 : static void rsp_encap_get_endpoint_info_case1(void **state)
37 : {
38 : libspdm_return_t status;
39 : libspdm_test_context_t *spdm_test_context;
40 : libspdm_context_t *spdm_context;
41 : spdm_endpoint_info_response_t *spdm_response;
42 : uint8_t temp_buf[LIBSPDM_SENDER_BUFFER_SIZE];
43 : bool need_continue;
44 : uint8_t *ptr;
45 : size_t sig_size;
46 : size_t response_size;
47 : uint32_t endpoint_info_size;
48 : void *data;
49 : size_t data_size;
50 :
51 1 : spdm_test_context = *state;
52 1 : spdm_test_context->case_id = 0x1;
53 1 : spdm_context = spdm_test_context->spdm_context;
54 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
55 : SPDM_VERSION_NUMBER_SHIFT_BIT;
56 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
57 1 : spdm_context->connection_info.capability.flags = 0;
58 1 : spdm_context->connection_info.capability.flags |=
59 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_EP_INFO_CAP_SIG;
60 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
61 1 : spdm_context->connection_info.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
62 1 : spdm_context->get_endpoint_info_callback = get_endpoint_info_callback;
63 :
64 1 : if (!libspdm_read_requester_public_certificate_chain(m_libspdm_use_hash_algo,
65 : m_libspdm_use_req_asym_algo, &data,
66 : &data_size, NULL, NULL)) {
67 0 : return;
68 : }
69 1 : libspdm_reset_message_a(spdm_context);
70 1 : libspdm_reset_message_encap_e(spdm_context, NULL);
71 :
72 3 : for (uint32_t index = 0; index < 2; index++) {
73 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
74 : spdm_context->connection_info.peer_used_cert_chain[index].buffer_size = data_size;
75 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[index].buffer,
76 : sizeof(spdm_context->connection_info.peer_used_cert_chain[index].buffer),
77 : data, data_size);
78 : #else
79 2 : libspdm_hash_all(
80 : spdm_context->connection_info.algorithm.base_hash_algo,
81 : data, data_size,
82 2 : spdm_context->connection_info.peer_used_cert_chain[index].buffer_hash);
83 2 : spdm_context->connection_info.peer_used_cert_chain[index].buffer_hash_size =
84 2 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
85 2 : libspdm_get_leaf_cert_public_key_from_cert_chain(
86 : spdm_context->connection_info.algorithm.base_hash_algo,
87 2 : spdm_context->connection_info.algorithm.req_base_asym_alg,
88 : data, data_size,
89 : &spdm_context->connection_info.peer_used_cert_chain[index].leaf_cert_public_key);
90 : #endif
91 : }
92 :
93 : /* Subcase 1: slot_id = 0 */
94 1 : spdm_context->encap_context.req_slot_id = 0;
95 1 : endpoint_info_size = LIBSPDM_TEST_ENDPOINT_INFO_BUFFER_SIZE;
96 1 : libspdm_generate_device_endpoint_info(
97 : spdm_context, SPDM_GET_ENDPOINT_INFO_REQUEST_SUBCODE_DEVICE_CLASS_IDENTIFIER,
98 : SPDM_GET_ENDPOINT_INFO_REQUEST_ATTRIBUTE_SIGNATURE_REQUESTED,
99 : &endpoint_info_size, m_endpoint_info_buffer_receive);
100 1 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_req_asym_algo);
101 :
102 1 : response_size = sizeof(spdm_endpoint_info_response_t) +
103 : SPDM_NONCE_SIZE + sizeof(uint32_t) +
104 1 : endpoint_info_size + sig_size;
105 :
106 1 : spdm_response = (void *)temp_buf;
107 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
108 1 : spdm_response->header.request_response_code = SPDM_ENDPOINT_INFO;
109 1 : spdm_response->header.param1 = 0;
110 1 : spdm_response->header.param2 = spdm_context->encap_context.req_slot_id &
111 : SPDM_ENDPOINT_INFO_RESPONSE_SLOT_ID_MASK;
112 1 : spdm_response->reserved = 0;
113 :
114 1 : ptr = (void *)(spdm_response + 1);
115 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
116 1 : ptr += SPDM_NONCE_SIZE;
117 :
118 1 : libspdm_write_uint32(ptr, endpoint_info_size); /* ep_info_len */
119 1 : ptr += sizeof(uint32_t);
120 :
121 1 : libspdm_copy_mem(ptr, endpoint_info_size, m_endpoint_info_buffer_receive, endpoint_info_size);
122 1 : ptr += endpoint_info_size;
123 :
124 1 : libspdm_requester_data_sign(
125 : spdm_context,
126 1 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
127 : 0, SPDM_ENDPOINT_INFO,
128 : m_libspdm_use_req_asym_algo, m_libspdm_use_req_pqc_asym_algo, m_libspdm_use_hash_algo,
129 : false, (uint8_t*)spdm_response, response_size - sig_size,
130 : ptr, &sig_size);
131 :
132 1 : status = libspdm_process_encap_response_endpoint_info(spdm_context, response_size,
133 : spdm_response, &need_continue);
134 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
135 13 : for (uint32_t index = 0; index < endpoint_info_size; index++) {
136 12 : assert_int_equal (m_endpoint_info_buffer_receive[index],
137 : m_endpoint_info_buffer_send[index]);
138 : }
139 : /* Completion of GET_ENDPOINT_INFO sets mut IL1/IL2 to null. */
140 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
141 : assert_int_equal(spdm_context->transcript.message_encap_e.buffer_size, 0);
142 : #else
143 1 : assert_null(spdm_context->transcript.digest_context_encap_il1il2);
144 : #endif
145 :
146 :
147 : /* Subcase 2: slot_id = 1 */
148 1 : spdm_context->encap_context.req_slot_id = 1;
149 1 : endpoint_info_size = LIBSPDM_TEST_ENDPOINT_INFO_BUFFER_SIZE;
150 1 : libspdm_generate_device_endpoint_info(
151 : spdm_context, SPDM_GET_ENDPOINT_INFO_REQUEST_SUBCODE_DEVICE_CLASS_IDENTIFIER,
152 : SPDM_GET_ENDPOINT_INFO_REQUEST_ATTRIBUTE_SIGNATURE_REQUESTED,
153 : &endpoint_info_size, m_endpoint_info_buffer_receive);
154 1 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_req_asym_algo);
155 :
156 1 : response_size = sizeof(spdm_endpoint_info_response_t) +
157 : SPDM_NONCE_SIZE + sizeof(uint32_t) +
158 1 : endpoint_info_size + sig_size;
159 :
160 1 : spdm_response = (void *)temp_buf;
161 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
162 1 : spdm_response->header.request_response_code = SPDM_ENDPOINT_INFO;
163 1 : spdm_response->header.param1 = 0;
164 1 : spdm_response->header.param2 = spdm_context->encap_context.req_slot_id &
165 : SPDM_ENDPOINT_INFO_RESPONSE_SLOT_ID_MASK;
166 1 : spdm_response->reserved = 0;
167 :
168 1 : ptr = (void *)(spdm_response + 1);
169 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
170 1 : ptr += SPDM_NONCE_SIZE;
171 :
172 1 : libspdm_write_uint32(ptr, endpoint_info_size); /* ep_info_len */
173 1 : ptr += sizeof(uint32_t);
174 :
175 1 : libspdm_copy_mem(ptr, endpoint_info_size, m_endpoint_info_buffer_receive, endpoint_info_size);
176 1 : ptr += endpoint_info_size;
177 :
178 1 : libspdm_requester_data_sign(
179 : spdm_context,
180 1 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
181 : 0, SPDM_ENDPOINT_INFO,
182 : m_libspdm_use_req_asym_algo, m_libspdm_use_req_pqc_asym_algo, m_libspdm_use_hash_algo,
183 : false, (uint8_t*)spdm_response, response_size - sig_size,
184 : ptr, &sig_size);
185 :
186 1 : status = libspdm_process_encap_response_endpoint_info(spdm_context, response_size,
187 : spdm_response, &need_continue);
188 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
189 13 : for (uint32_t index = 0; index < endpoint_info_size; index++) {
190 12 : assert_int_equal (m_endpoint_info_buffer_receive[index],
191 : m_endpoint_info_buffer_send[index]);
192 : }
193 : /* Completion of GET_ENDPOINT_INFO sets mut IL1/IL2 to null. */
194 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
195 : assert_int_equal(spdm_context->transcript.message_encap_e.buffer_size, 0);
196 : #else
197 1 : assert_null(spdm_context->transcript.digest_context_encap_il1il2);
198 : #endif
199 : }
200 :
201 : /**
202 : * Test 2: Normal case, request a endpoint info with signature, req_slot_id = 0xFF
203 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, correct endpoint_info
204 : * and an empty transcript.message_encap_e
205 : **/
206 1 : static void rsp_encap_get_endpoint_info_case2(void **state)
207 : {
208 : libspdm_return_t status;
209 : libspdm_test_context_t *spdm_test_context;
210 : libspdm_context_t *spdm_context;
211 : spdm_endpoint_info_response_t *spdm_response;
212 : uint8_t temp_buf[LIBSPDM_SENDER_BUFFER_SIZE];
213 : bool need_continue;
214 : uint8_t *ptr;
215 : size_t sig_size;
216 : size_t response_size;
217 : uint32_t endpoint_info_size;
218 : void *data;
219 : size_t data_size;
220 :
221 1 : spdm_test_context = *state;
222 1 : spdm_test_context->case_id = 0x2;
223 1 : spdm_context = spdm_test_context->spdm_context;
224 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
225 : SPDM_VERSION_NUMBER_SHIFT_BIT;
226 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
227 1 : spdm_context->connection_info.capability.flags = 0;
228 1 : spdm_context->connection_info.capability.flags |=
229 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_EP_INFO_CAP_SIG;
230 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
231 1 : spdm_context->connection_info.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
232 1 : spdm_context->get_endpoint_info_callback = get_endpoint_info_callback;
233 :
234 1 : if (!libspdm_read_requester_public_key(m_libspdm_use_req_asym_algo, &data, &data_size)) {
235 0 : return;
236 : }
237 1 : spdm_context->local_context.peer_public_key_provision = data;
238 1 : spdm_context->local_context.peer_public_key_provision_size = data_size;
239 :
240 1 : spdm_context->encap_context.req_slot_id = 0xFF;
241 1 : endpoint_info_size = LIBSPDM_TEST_ENDPOINT_INFO_BUFFER_SIZE;
242 1 : libspdm_generate_device_endpoint_info(
243 : spdm_context, SPDM_GET_ENDPOINT_INFO_REQUEST_SUBCODE_DEVICE_CLASS_IDENTIFIER,
244 : SPDM_GET_ENDPOINT_INFO_REQUEST_ATTRIBUTE_SIGNATURE_REQUESTED,
245 : &endpoint_info_size, m_endpoint_info_buffer_receive);
246 1 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_req_asym_algo);
247 :
248 1 : response_size = sizeof(spdm_endpoint_info_response_t) +
249 : SPDM_NONCE_SIZE + sizeof(uint32_t) +
250 1 : endpoint_info_size + sig_size;
251 :
252 1 : spdm_response = (void *)temp_buf;
253 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
254 1 : spdm_response->header.request_response_code = SPDM_ENDPOINT_INFO;
255 1 : spdm_response->header.param1 = 0;
256 1 : spdm_response->header.param2 = spdm_context->encap_context.req_slot_id &
257 : SPDM_ENDPOINT_INFO_RESPONSE_SLOT_ID_MASK;
258 1 : spdm_response->reserved = 0;
259 :
260 1 : ptr = (void *)(spdm_response + 1);
261 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
262 1 : ptr += SPDM_NONCE_SIZE;
263 :
264 1 : libspdm_write_uint32(ptr, endpoint_info_size); /* ep_info_len */
265 1 : ptr += sizeof(uint32_t);
266 :
267 1 : libspdm_copy_mem(ptr, endpoint_info_size, m_endpoint_info_buffer_receive, endpoint_info_size);
268 1 : ptr += endpoint_info_size;
269 :
270 1 : libspdm_requester_data_sign(
271 : spdm_context,
272 1 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
273 : 0, SPDM_ENDPOINT_INFO,
274 : m_libspdm_use_req_asym_algo, m_libspdm_use_req_pqc_asym_algo, m_libspdm_use_hash_algo,
275 : false, (uint8_t*)spdm_response, response_size - sig_size,
276 : ptr, &sig_size);
277 :
278 1 : status = libspdm_process_encap_response_endpoint_info(spdm_context, response_size,
279 : spdm_response, &need_continue);
280 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
281 13 : for (uint32_t index = 0; index < endpoint_info_size; index++) {
282 12 : assert_int_equal (m_endpoint_info_buffer_receive[index],
283 : m_endpoint_info_buffer_send[index]);
284 : }
285 : /* Completion of GET_ENDPOINT_INFO sets mut IL1/IL2 to null. */
286 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
287 : assert_int_equal(spdm_context->transcript.message_encap_e.buffer_size, 0);
288 : #else
289 1 : assert_null(spdm_context->transcript.digest_context_encap_il1il2);
290 : #endif
291 : }
292 :
293 : /**
294 : * Test 3: Normal case, request a endpoint info without signature
295 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, correct endpoint_info
296 : **/
297 1 : static void rsp_encap_get_endpoint_info_case3(void **state)
298 : {
299 : libspdm_return_t status;
300 : libspdm_test_context_t *spdm_test_context;
301 : libspdm_context_t *spdm_context;
302 : spdm_endpoint_info_response_t *spdm_response;
303 : uint8_t temp_buf[LIBSPDM_SENDER_BUFFER_SIZE];
304 : bool need_continue;
305 : uint8_t *ptr;
306 : size_t response_size;
307 : uint32_t endpoint_info_size;
308 :
309 1 : spdm_test_context = *state;
310 1 : spdm_test_context->case_id = 0x3;
311 1 : spdm_context = spdm_test_context->spdm_context;
312 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
313 : SPDM_VERSION_NUMBER_SHIFT_BIT;
314 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
315 1 : spdm_context->connection_info.capability.flags = 0;
316 1 : spdm_context->connection_info.capability.flags |=
317 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_EP_INFO_CAP_NO_SIG;
318 1 : spdm_context->get_endpoint_info_callback = get_endpoint_info_callback;
319 :
320 1 : spdm_context->encap_context.req_slot_id = 0;
321 1 : endpoint_info_size = LIBSPDM_TEST_ENDPOINT_INFO_BUFFER_SIZE;
322 1 : libspdm_generate_device_endpoint_info(
323 : spdm_context, SPDM_GET_ENDPOINT_INFO_REQUEST_SUBCODE_DEVICE_CLASS_IDENTIFIER,
324 : SPDM_GET_ENDPOINT_INFO_REQUEST_ATTRIBUTE_SIGNATURE_REQUESTED,
325 : &endpoint_info_size, m_endpoint_info_buffer_receive);
326 :
327 1 : response_size = sizeof(spdm_endpoint_info_response_t) +
328 1 : sizeof(uint32_t) + endpoint_info_size;
329 :
330 1 : spdm_response = (void *)temp_buf;
331 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
332 1 : spdm_response->header.request_response_code = SPDM_ENDPOINT_INFO;
333 1 : spdm_response->header.param1 = 0;
334 1 : spdm_response->header.param2 = spdm_context->encap_context.req_slot_id &
335 : SPDM_ENDPOINT_INFO_RESPONSE_SLOT_ID_MASK;
336 1 : spdm_response->reserved = 0;
337 :
338 1 : ptr = (void *)(spdm_response + 1);
339 1 : libspdm_write_uint32(ptr, endpoint_info_size); /* ep_info_len */
340 1 : ptr += sizeof(uint32_t);
341 :
342 1 : libspdm_copy_mem(ptr, endpoint_info_size, m_endpoint_info_buffer_receive, endpoint_info_size);
343 1 : ptr += endpoint_info_size;
344 :
345 1 : status = libspdm_process_encap_response_endpoint_info(spdm_context, response_size,
346 : spdm_response, &need_continue);
347 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
348 13 : for (uint32_t index = 0; index < endpoint_info_size; index++) {
349 12 : assert_int_equal (m_endpoint_info_buffer_receive[index],
350 : m_endpoint_info_buffer_send[index]);
351 : }
352 1 : }
353 :
354 : /**
355 : * Test 4: Normal case, request a endpoint info with signature within session
356 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, correct endpoint_info
357 : * and an empty session_transcript.message_encap_e
358 : **/
359 1 : static void rsp_encap_get_endpoint_info_case4(void **state)
360 : {
361 : libspdm_return_t status;
362 : libspdm_test_context_t *spdm_test_context;
363 : libspdm_context_t *spdm_context;
364 : spdm_endpoint_info_response_t *spdm_response;
365 : uint8_t temp_buf[LIBSPDM_SENDER_BUFFER_SIZE];
366 : bool need_continue;
367 : uint8_t *ptr;
368 : size_t sig_size;
369 : size_t response_size;
370 : uint32_t endpoint_info_size;
371 : void *data;
372 : size_t data_size;
373 : uint32_t session_id;
374 : libspdm_session_info_t *session_info;
375 :
376 1 : spdm_test_context = *state;
377 1 : spdm_test_context->case_id = 0x4;
378 1 : spdm_context = spdm_test_context->spdm_context;
379 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
380 : SPDM_VERSION_NUMBER_SHIFT_BIT;
381 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
382 1 : spdm_context->connection_info.capability.flags = 0;
383 1 : spdm_context->connection_info.capability.flags |=
384 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_EP_INFO_CAP_SIG;
385 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
386 1 : spdm_context->connection_info.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
387 1 : spdm_context->get_endpoint_info_callback = get_endpoint_info_callback;
388 :
389 1 : if (!libspdm_read_requester_public_certificate_chain(m_libspdm_use_hash_algo,
390 : m_libspdm_use_req_asym_algo, &data,
391 : &data_size, NULL, NULL)) {
392 0 : return;
393 : }
394 :
395 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
396 1 : spdm_context->connection_info.capability.flags |=
397 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
398 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
399 :
400 1 : spdm_context->local_context.capability.flags = 0;
401 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
402 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
403 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
404 1 : spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
405 1 : spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
406 :
407 1 : session_id = 0xFFFFFFFF;
408 1 : session_info = &spdm_context->session_info[0];
409 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
410 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
411 1 : libspdm_secured_message_set_session_state(
412 : session_info->secured_message_context,
413 : LIBSPDM_SESSION_STATE_ESTABLISHED);
414 :
415 1 : libspdm_reset_message_a(spdm_context);
416 1 : libspdm_reset_message_encap_e(spdm_context, session_info);
417 :
418 3 : for (uint32_t index = 0; index < 2; index++) {
419 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
420 : spdm_context->connection_info.peer_used_cert_chain[index].buffer_size = data_size;
421 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[index].buffer,
422 : sizeof(spdm_context->connection_info.peer_used_cert_chain[index].buffer),
423 : data, data_size);
424 : #else
425 2 : libspdm_hash_all(
426 : spdm_context->connection_info.algorithm.base_hash_algo,
427 : data, data_size,
428 2 : spdm_context->connection_info.peer_used_cert_chain[index].buffer_hash);
429 2 : spdm_context->connection_info.peer_used_cert_chain[index].buffer_hash_size =
430 2 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
431 2 : libspdm_get_leaf_cert_public_key_from_cert_chain(
432 : spdm_context->connection_info.algorithm.base_hash_algo,
433 2 : spdm_context->connection_info.algorithm.req_base_asym_alg,
434 : data, data_size,
435 : &spdm_context->connection_info.peer_used_cert_chain[index].leaf_cert_public_key);
436 : #endif
437 : }
438 :
439 1 : spdm_context->encap_context.req_slot_id = 0;
440 1 : endpoint_info_size = LIBSPDM_TEST_ENDPOINT_INFO_BUFFER_SIZE;
441 1 : libspdm_generate_device_endpoint_info(
442 : spdm_context, SPDM_GET_ENDPOINT_INFO_REQUEST_SUBCODE_DEVICE_CLASS_IDENTIFIER,
443 : SPDM_GET_ENDPOINT_INFO_REQUEST_ATTRIBUTE_SIGNATURE_REQUESTED,
444 : &endpoint_info_size, m_endpoint_info_buffer_receive);
445 1 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_req_asym_algo);
446 :
447 1 : response_size = sizeof(spdm_endpoint_info_response_t) +
448 : SPDM_NONCE_SIZE + sizeof(uint32_t) +
449 1 : endpoint_info_size + sig_size;
450 :
451 1 : spdm_response = (void *)temp_buf;
452 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
453 1 : spdm_response->header.request_response_code = SPDM_ENDPOINT_INFO;
454 1 : spdm_response->header.param1 = 0;
455 1 : spdm_response->header.param2 = spdm_context->encap_context.req_slot_id &
456 : SPDM_ENDPOINT_INFO_RESPONSE_SLOT_ID_MASK;
457 1 : spdm_response->reserved = 0;
458 :
459 1 : ptr = (void *)(spdm_response + 1);
460 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
461 1 : ptr += SPDM_NONCE_SIZE;
462 :
463 1 : libspdm_write_uint32(ptr, endpoint_info_size); /* ep_info_len */
464 1 : ptr += sizeof(uint32_t);
465 :
466 1 : libspdm_copy_mem(ptr, endpoint_info_size, m_endpoint_info_buffer_receive, endpoint_info_size);
467 1 : ptr += endpoint_info_size;
468 :
469 1 : libspdm_requester_data_sign(
470 : spdm_context,
471 1 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
472 : 0, SPDM_ENDPOINT_INFO,
473 : m_libspdm_use_req_asym_algo, m_libspdm_use_req_pqc_asym_algo, m_libspdm_use_hash_algo,
474 : false, (uint8_t*)spdm_response, response_size - sig_size,
475 : ptr, &sig_size);
476 :
477 1 : status = libspdm_process_encap_response_endpoint_info(spdm_context, response_size,
478 : spdm_response, &need_continue);
479 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
480 13 : for (uint32_t index = 0; index < endpoint_info_size; index++) {
481 12 : assert_int_equal (m_endpoint_info_buffer_receive[index],
482 : m_endpoint_info_buffer_send[index]);
483 : }
484 : /* Completion of GET_ENDPOINT_INFO sets mut IL1/IL2 to null. */
485 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
486 : assert_int_equal(session_info->session_transcript.message_encap_e.buffer_size, 0);
487 : #else
488 1 : assert_null(session_info->session_transcript.digest_context_encap_il1il2);
489 : #endif
490 : }
491 :
492 1 : int libspdm_rsp_encap_get_endpoint_info_test(void)
493 : {
494 1 : const struct CMUnitTest test_cases[] = {
495 : /* Success request endpoint info with signature */
496 : cmocka_unit_test(rsp_encap_get_endpoint_info_case1),
497 : /* Success request endpoint info with signature, req_slot_id = 0xFF */
498 : cmocka_unit_test(rsp_encap_get_endpoint_info_case2),
499 : /* Success request endpoint info without signature */
500 : cmocka_unit_test(rsp_encap_get_endpoint_info_case3),
501 : /* Success request endpoint info with signature in a session */
502 : cmocka_unit_test(rsp_encap_get_endpoint_info_case4),
503 : };
504 :
505 1 : libspdm_test_context_t test_context = {
506 : LIBSPDM_TEST_CONTEXT_VERSION,
507 : false,
508 : };
509 :
510 1 : libspdm_setup_test_context(&test_context);
511 :
512 1 : return cmocka_run_group_tests(test_cases,
513 : libspdm_unit_test_group_setup,
514 : libspdm_unit_test_group_teardown);
515 : }
516 :
517 : #endif /* (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && (...) */
|
