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