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