Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2026 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : #include "spdm_unit_test.h"
8 : #include "internal/libspdm_responder_lib.h"
9 :
10 : #if LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP
11 :
12 : static spdm_get_encapsulated_request_request_t m_libspdm_encapsulated_request_t1 = {
13 : {SPDM_MESSAGE_VERSION_11, SPDM_GET_ENCAPSULATED_REQUEST, 0, 0}
14 : };
15 : static size_t m_libspdm_encapsulated_request_t1_size = sizeof(m_libspdm_encapsulated_request_t1);
16 :
17 : static spdm_get_encapsulated_request_request_t m_libspdm_encapsulated_request_t2 = {
18 : {SPDM_MESSAGE_VERSION_13, SPDM_GET_ENCAPSULATED_REQUEST, 0, 0}
19 : };
20 : static size_t m_libspdm_encapsulated_request_t2_size = sizeof(m_libspdm_encapsulated_request_t2);
21 :
22 : static spdm_deliver_encapsulated_response_request_t m_libspdm_m_deliver_encapsulated_response_request_t1 =
23 : {
24 : {SPDM_MESSAGE_VERSION_11, SPDM_DELIVER_ENCAPSULATED_RESPONSE, 0, 0}
25 : };
26 : static size_t m_libspdm_m_deliver_encapsulated_response_request_t1_size =
27 : sizeof(m_libspdm_m_deliver_encapsulated_response_request_t1);
28 :
29 : #if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT)
30 : static uint8_t m_libspdm_local_certificate_chain[LIBSPDM_MAX_CERT_CHAIN_SIZE];
31 : #endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT) */
32 :
33 : static spdm_deliver_encapsulated_response_request_t m_libspdm_m_deliver_encapsulated_response_request_t2 =
34 : {
35 : {SPDM_MESSAGE_VERSION_12, SPDM_DELIVER_ENCAPSULATED_RESPONSE, 0xFF, 0}
36 : };
37 : static size_t m_libspdm_m_deliver_encapsulated_response_request_t2_size =
38 : sizeof(m_libspdm_m_deliver_encapsulated_response_request_t2);
39 :
40 : #if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT)
41 1 : static void rsp_encapsulated_request_case1(void **State)
42 : {
43 : libspdm_return_t status;
44 : libspdm_test_context_t *spdm_test_context;
45 : spdm_encapsulated_request_response_t *spdm_response_requester;
46 : spdm_get_digest_request_t *spdm_get_digests_request;
47 : libspdm_context_t *spdm_context;
48 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
49 : size_t data_size;
50 : void *data;
51 : size_t response_size;
52 :
53 1 : spdm_test_context = *State;
54 1 : spdm_context = spdm_test_context->spdm_context;
55 1 : spdm_test_context->case_id = 0x1;
56 :
57 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
58 :
59 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
60 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
61 1 : spdm_context->encap_context.request_op_code_count =
62 : LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
63 1 : spdm_context->encap_context.current_request_op_code = 0;
64 1 : spdm_context->encap_context.request_op_code_sequence[0] = SPDM_GET_DIGESTS;
65 1 : spdm_context->encap_context.request_id = 0;
66 :
67 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
68 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
69 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
70 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
71 : SPDM_VERSION_NUMBER_SHIFT_BIT;
72 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
73 : m_libspdm_use_asym_algo, &data,
74 : &data_size,
75 : NULL, NULL)) {
76 0 : return;
77 : }
78 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
79 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
80 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
81 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
82 1 : libspdm_reset_message_b(spdm_context);
83 :
84 1 : response_size = sizeof(response);
85 1 : status = libspdm_get_response_encapsulated_request(spdm_context,
86 : m_libspdm_encapsulated_request_t1_size,
87 : &m_libspdm_encapsulated_request_t1,
88 : &response_size,
89 : response);
90 :
91 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
92 1 : assert_int_equal(response_size,
93 : sizeof(spdm_encapsulated_request_response_t) + sizeof(spdm_digest_response_t));
94 1 : spdm_response_requester = (void *)response;
95 :
96 1 : assert_int_equal(spdm_response_requester->header.spdm_version, SPDM_MESSAGE_VERSION_11);
97 1 : assert_int_equal(spdm_response_requester->header.request_response_code,
98 : SPDM_ENCAPSULATED_REQUEST);
99 1 : assert_int_equal(spdm_response_requester->header.param1, 0x1);
100 1 : assert_int_equal(spdm_response_requester->header.param2, 0);
101 :
102 1 : spdm_get_digests_request = (spdm_get_digest_request_t *)(spdm_response_requester + 1);
103 1 : assert_int_equal(spdm_get_digests_request->header.spdm_version, SPDM_MESSAGE_VERSION_11);
104 1 : assert_int_equal(spdm_get_digests_request->header.request_response_code, SPDM_GET_DIGESTS);
105 1 : assert_int_equal(spdm_get_digests_request->header.param1, 0);
106 1 : assert_int_equal(spdm_get_digests_request->header.param2, 0);
107 :
108 1 : free(data);
109 : }
110 :
111 1 : static void rsp_encapsulated_request_case2(void **State)
112 : {
113 : libspdm_return_t status;
114 : libspdm_test_context_t *spdm_test_context;
115 : spdm_encapsulated_request_response_t *spdm_response_requester;
116 : spdm_get_certificate_request_t *spdm_get_certificate_request;
117 : libspdm_context_t *spdm_context;
118 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
119 : size_t data_size;
120 : void *data;
121 : size_t response_size;
122 :
123 1 : spdm_test_context = *State;
124 1 : spdm_context = spdm_test_context->spdm_context;
125 1 : spdm_test_context->case_id = 0x2;
126 :
127 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
128 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
129 1 : spdm_context->encap_context.request_op_code_count =
130 : LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
131 1 : spdm_context->encap_context.current_request_op_code = 0;
132 1 : spdm_context->encap_context.request_op_code_sequence[0] = SPDM_GET_CERTIFICATE;
133 1 : spdm_context->encap_context.request_id = 0;
134 :
135 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
136 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
137 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
138 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
139 : SPDM_VERSION_NUMBER_SHIFT_BIT;
140 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
141 : m_libspdm_use_asym_algo, &data,
142 : &data_size,
143 : NULL, NULL)) {
144 0 : return;
145 : }
146 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
147 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
148 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
149 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
150 1 : libspdm_reset_message_b(spdm_context);
151 :
152 1 : response_size = sizeof(response);
153 :
154 1 : status = libspdm_get_response_encapsulated_request(spdm_context,
155 : m_libspdm_encapsulated_request_t1_size,
156 : &m_libspdm_encapsulated_request_t1,
157 : &response_size,
158 : response);
159 :
160 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
161 1 : assert_int_equal(response_size,
162 : sizeof(spdm_encapsulated_request_response_t) +
163 : sizeof(spdm_certificate_response_t));
164 1 : spdm_response_requester = (void *)response;
165 1 : assert_int_equal(spdm_response_requester->header.spdm_version, SPDM_MESSAGE_VERSION_11);
166 1 : assert_int_equal(spdm_response_requester->header.request_response_code,
167 : SPDM_ENCAPSULATED_REQUEST);
168 1 : assert_int_equal(spdm_response_requester->header.param1, 0x1);
169 1 : assert_int_equal(spdm_response_requester->header.param2, 0);
170 :
171 1 : spdm_get_certificate_request = (spdm_get_certificate_request_t *)(spdm_response_requester + 1);
172 1 : assert_int_equal(spdm_get_certificate_request->header.spdm_version, SPDM_MESSAGE_VERSION_11);
173 1 : assert_int_equal(spdm_get_certificate_request->header.request_response_code,
174 : SPDM_GET_CERTIFICATE);
175 1 : assert_int_equal(spdm_get_certificate_request->header.param1, 0);
176 1 : assert_int_equal(spdm_get_certificate_request->header.param2, 0);
177 1 : assert_int_equal(spdm_get_certificate_request->offset, 0);
178 :
179 1 : const size_t length = spdm_context->local_context.capability.max_spdm_msg_size -
180 : sizeof(spdm_deliver_encapsulated_response_request_t) -
181 : sizeof(spdm_get_certificate_request_t);
182 :
183 1 : assert_int_equal(spdm_get_certificate_request->length, length);
184 1 : free(data);
185 : }
186 :
187 1 : static void rsp_encapsulated_request_case3(void **State)
188 : {
189 : libspdm_return_t status;
190 : libspdm_test_context_t *spdm_test_context;
191 : spdm_error_response_t *spdm_response_requester;
192 : libspdm_context_t *spdm_context;
193 : size_t response_size;
194 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
195 : uint8_t m_local_certificate_chain[LIBSPDM_MAX_CERT_CHAIN_SIZE];
196 :
197 1 : spdm_test_context = *State;
198 1 : spdm_context = spdm_test_context->spdm_context;
199 1 : spdm_test_context->case_id = 0x3;
200 :
201 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
202 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
203 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
204 :
205 1 : spdm_context->encap_context.current_request_op_code = 0;
206 1 : spdm_context->encap_context.request_id = 0;
207 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
208 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
209 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
210 1 : spdm_context->local_context.local_cert_chain_provision[0] = m_local_certificate_chain;
211 1 : spdm_context->local_context.local_cert_chain_provision_size[0] =
212 : sizeof(m_local_certificate_chain);
213 1 : libspdm_set_mem(m_local_certificate_chain, sizeof(m_local_certificate_chain), (uint8_t)(0xFF));
214 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
215 : SPDM_VERSION_NUMBER_SHIFT_BIT;
216 :
217 1 : response_size = sizeof(response);
218 1 : status = libspdm_get_response_encapsulated_request(spdm_context,
219 : m_libspdm_encapsulated_request_t1_size,
220 : &m_libspdm_encapsulated_request_t1,
221 : &response_size,
222 : response);
223 :
224 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
225 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
226 1 : spdm_response_requester = (void *)response;
227 1 : assert_int_equal(spdm_response_requester->header.spdm_version, SPDM_MESSAGE_VERSION_11);
228 1 : assert_int_equal(spdm_response_requester->header.request_response_code, SPDM_ERROR);
229 1 : assert_int_equal(spdm_response_requester->header.param1, SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
230 1 : assert_int_equal(spdm_response_requester->header.param2, 0);
231 1 : }
232 :
233 1 : static void rsp_encapsulated_request_case4(void **State)
234 : {
235 : libspdm_return_t status;
236 : libspdm_test_context_t *spdm_test_context;
237 : spdm_error_response_t *spdm_response_requester;
238 : libspdm_context_t *spdm_context;
239 : size_t response_size;
240 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
241 : uint8_t m_local_certificate_chain[LIBSPDM_MAX_CERT_CHAIN_SIZE];
242 :
243 1 : spdm_test_context = *State;
244 1 : spdm_context = spdm_test_context->spdm_context;
245 1 : spdm_test_context->case_id = 0x4;
246 :
247 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NEED_RESYNC;
248 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
249 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
250 :
251 1 : spdm_context->encap_context.current_request_op_code = SPDM_GET_DIGESTS;
252 :
253 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
254 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
255 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
256 1 : spdm_context->local_context.local_cert_chain_provision[0] = m_local_certificate_chain;
257 1 : spdm_context->local_context.local_cert_chain_provision_size[0] =
258 : sizeof(m_local_certificate_chain);
259 1 : libspdm_set_mem(m_local_certificate_chain, sizeof(m_local_certificate_chain), (uint8_t)(0xFF));
260 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
261 : SPDM_VERSION_NUMBER_SHIFT_BIT;
262 :
263 1 : response_size = sizeof(response);
264 1 : status = libspdm_get_response_encapsulated_request(spdm_context,
265 : m_libspdm_encapsulated_request_t1_size,
266 : &m_libspdm_encapsulated_request_t1,
267 : &response_size,
268 : response);
269 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
270 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
271 1 : spdm_response_requester = (void *)response;
272 1 : assert_int_equal(spdm_response_requester->header.spdm_version, SPDM_MESSAGE_VERSION_11);
273 1 : assert_int_equal(spdm_response_requester->header.request_response_code, SPDM_ERROR);
274 1 : assert_int_equal(spdm_response_requester->header.param1, SPDM_ERROR_CODE_REQUEST_RESYNCH);
275 1 : assert_int_equal(spdm_response_requester->header.param2, 0);
276 1 : }
277 : #endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT) */
278 :
279 : #if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_CHALLENGE_SUPPORT)
280 1 : static void rsp_encapsulated_request_case5(void **State)
281 : {
282 : libspdm_return_t status;
283 : libspdm_test_context_t *spdm_test_context;
284 : spdm_encapsulated_request_response_t *spdm_response_requester;
285 : libspdm_context_t *spdm_context;
286 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
287 : size_t data_size;
288 : void *data;
289 : size_t response_size;
290 :
291 1 : spdm_test_context = *State;
292 1 : spdm_context = spdm_test_context->spdm_context;
293 1 : spdm_test_context->case_id = 0x5;
294 :
295 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
296 1 : spdm_context->connection_info.capability.flags = 0;
297 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP;
298 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
299 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
300 1 : spdm_context->encap_context.request_op_code_count =
301 : LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
302 1 : spdm_context->encap_context.current_request_op_code = 0;
303 1 : spdm_context->encap_context.request_op_code_sequence[0] = SPDM_CHALLENGE;
304 1 : spdm_context->encap_context.request_id = 0;
305 :
306 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
307 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
308 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
309 : SPDM_VERSION_NUMBER_SHIFT_BIT;
310 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
311 : m_libspdm_use_asym_algo, &data,
312 : &data_size,
313 : NULL, NULL)) {
314 0 : return;
315 : }
316 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
317 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
318 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
319 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
320 1 : libspdm_reset_message_b(spdm_context);
321 :
322 1 : response_size = sizeof(response);
323 1 : status = libspdm_get_response_encapsulated_request(spdm_context,
324 : m_libspdm_encapsulated_request_t1_size,
325 : &m_libspdm_encapsulated_request_t1,
326 : &response_size,
327 : response);
328 :
329 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
330 1 : assert_int_equal(response_size,
331 : sizeof(spdm_encapsulated_request_response_t) +
332 : sizeof(spdm_challenge_request_t));
333 1 : spdm_response_requester = (void *)response;
334 1 : assert_int_equal(spdm_response_requester->header.spdm_version, SPDM_MESSAGE_VERSION_11);
335 1 : assert_int_equal(spdm_response_requester->header.request_response_code,
336 : SPDM_ENCAPSULATED_REQUEST);
337 1 : assert_int_equal(spdm_response_requester->header.param1, 0x1);
338 1 : assert_int_equal(spdm_response_requester->header.param2, 0);
339 1 : free(data);
340 : }
341 : #endif /* LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_CHALLENGE_SUPPORT) */
342 :
343 1 : static void rsp_encapsulated_request_case6(void **State)
344 : {
345 : libspdm_return_t status;
346 : libspdm_test_context_t *spdm_test_context;
347 : spdm_encapsulated_request_response_t *spdm_response_requester;
348 : libspdm_context_t *spdm_context;
349 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
350 : size_t data_size;
351 : void *data;
352 : size_t response_size;
353 : uint32_t session_id;
354 : libspdm_session_info_t *session_info;
355 :
356 1 : spdm_test_context = *State;
357 1 : spdm_context = spdm_test_context->spdm_context;
358 1 : spdm_test_context->case_id = 0x6;
359 :
360 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
361 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
362 1 : spdm_context->connection_info.capability.flags |=
363 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP;
364 1 : spdm_context->local_context.capability.flags |=
365 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_UPD_CAP;
366 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
367 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
368 1 : spdm_context->encap_context.request_op_code_count =
369 : LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
370 1 : spdm_context->encap_context.current_request_op_code = 0;
371 1 : spdm_context->encap_context.request_op_code_sequence[0] = SPDM_KEY_UPDATE;
372 1 : spdm_context->encap_context.request_id = 0;
373 :
374 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
375 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
376 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
377 : SPDM_VERSION_NUMBER_SHIFT_BIT;
378 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
379 : m_libspdm_use_asym_algo, &data,
380 : &data_size,
381 : NULL, NULL)) {
382 0 : return;
383 : }
384 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
385 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
386 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
387 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
388 1 : libspdm_reset_message_b(spdm_context);
389 :
390 1 : session_id = 0xFFFFFFFF;
391 1 : spdm_context->latest_session_id = session_id;
392 1 : spdm_context->last_spdm_request_session_id_valid = true;
393 1 : spdm_context->last_spdm_request_session_id = session_id;
394 1 : session_info = &spdm_context->session_info[0];
395 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
396 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
397 1 : libspdm_secured_message_set_session_state(session_info->secured_message_context,
398 : LIBSPDM_SESSION_STATE_ESTABLISHED);
399 :
400 1 : response_size = sizeof(response);
401 1 : status = libspdm_get_response_encapsulated_request(spdm_context,
402 : m_libspdm_encapsulated_request_t1_size,
403 : &m_libspdm_encapsulated_request_t1,
404 : &response_size,
405 : response);
406 :
407 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
408 1 : assert_int_equal(response_size,
409 : sizeof(spdm_encapsulated_request_response_t) +
410 : sizeof(spdm_key_update_response_t));
411 1 : spdm_response_requester = (void *)response;
412 1 : assert_int_equal(spdm_response_requester->header.request_response_code,
413 : SPDM_ENCAPSULATED_REQUEST);
414 1 : assert_int_equal(spdm_response_requester->header.param1, 0x1);
415 1 : assert_int_equal(spdm_response_requester->header.param2, 0);
416 1 : free(data);
417 : }
418 :
419 1 : static void rsp_encapsulated_request_case7(void **State)
420 : {
421 : libspdm_return_t status;
422 : libspdm_test_context_t *spdm_test_context;
423 : spdm_error_response_t *spdm_response_requester;
424 : libspdm_context_t *spdm_context;
425 : size_t response_size;
426 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
427 : uint8_t m_local_certificate_chain[LIBSPDM_MAX_CERT_CHAIN_SIZE];
428 :
429 1 : spdm_test_context = *State;
430 1 : spdm_context = spdm_test_context->spdm_context;
431 1 : spdm_test_context->case_id = 0x7;
432 :
433 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
434 : SPDM_VERSION_NUMBER_SHIFT_BIT;
435 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
436 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
437 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
438 :
439 1 : spdm_context->encap_context.current_request_op_code = 0;
440 1 : spdm_context->encap_context.request_id = 0;
441 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
442 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
443 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
444 1 : spdm_context->local_context.local_cert_chain_provision[0] = m_local_certificate_chain;
445 1 : spdm_context->local_context.local_cert_chain_provision_size[0] =
446 : sizeof(m_local_certificate_chain);
447 1 : libspdm_set_mem(m_local_certificate_chain, sizeof(m_local_certificate_chain), 0xFF);
448 :
449 1 : response_size = sizeof(response);
450 1 : status = libspdm_get_response_encapsulated_request(spdm_context,
451 : m_libspdm_encapsulated_request_t2_size,
452 : &m_libspdm_encapsulated_request_t2,
453 : &response_size,
454 : response);
455 :
456 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
457 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
458 1 : spdm_response_requester = (void *)response;
459 1 : assert_int_equal(spdm_response_requester->header.request_response_code, SPDM_ERROR);
460 1 : assert_int_equal(spdm_response_requester->header.param1, SPDM_ERROR_CODE_NO_PENDING_REQUESTS);
461 1 : assert_int_equal(spdm_response_requester->header.param2, 0);
462 1 : }
463 :
464 : #if LIBSPDM_SEND_GET_ENDPOINT_INFO_SUPPORT
465 0 : static libspdm_return_t get_endpoint_info_callback_encap_response (
466 : void *spdm_context,
467 : uint8_t subcode,
468 : uint8_t param2,
469 : uint8_t request_attributes,
470 : uint32_t endpoint_info_size,
471 : const void *endpoint_info)
472 : {
473 : /* should never reach here */
474 0 : LIBSPDM_ASSERT (0);
475 0 : return LIBSPDM_STATUS_UNSUPPORTED_CAP;
476 : }
477 :
478 1 : static void rsp_encapsulated_request_case8(void **State)
479 : {
480 : libspdm_return_t status;
481 : libspdm_test_context_t *spdm_test_context;
482 : spdm_encapsulated_request_response_t *spdm_response_requester;
483 : libspdm_context_t *spdm_context;
484 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
485 : size_t data_size;
486 : void *data;
487 : size_t response_size;
488 : uint32_t session_id;
489 : libspdm_session_info_t *session_info;
490 :
491 1 : spdm_test_context = *State;
492 1 : spdm_context = spdm_test_context->spdm_context;
493 1 : spdm_test_context->case_id = 0x6;
494 :
495 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
496 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
497 1 : spdm_context->connection_info.capability.flags |=
498 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_EP_INFO_CAP_SIG;
499 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
500 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
501 1 : spdm_context->encap_context.request_op_code_count =
502 : LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
503 1 : spdm_context->encap_context.current_request_op_code = 0;
504 1 : spdm_context->encap_context.request_op_code_sequence[0] = SPDM_GET_ENDPOINT_INFO;
505 1 : spdm_context->encap_context.request_id = 0;
506 :
507 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
508 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
509 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
510 : SPDM_VERSION_NUMBER_SHIFT_BIT;
511 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
512 : m_libspdm_use_req_asym_algo, &data,
513 : &data_size,
514 : NULL, NULL)) {
515 0 : return;
516 : }
517 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
518 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
519 1 : spdm_context->connection_info.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
520 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
521 1 : spdm_context->get_endpoint_info_callback = get_endpoint_info_callback_encap_response;
522 :
523 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
524 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
525 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
526 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
527 : data, data_size);
528 : #else
529 1 : libspdm_hash_all(
530 : spdm_context->connection_info.algorithm.base_hash_algo,
531 : data, data_size,
532 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
533 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
534 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
535 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
536 : spdm_context->connection_info.algorithm.base_hash_algo,
537 : spdm_context->connection_info.algorithm.base_asym_algo,
538 : data, data_size,
539 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
540 : #endif
541 :
542 1 : session_id = 0xFFFFFFFF;
543 1 : spdm_context->latest_session_id = session_id;
544 1 : spdm_context->last_spdm_request_session_id_valid = true;
545 1 : spdm_context->last_spdm_request_session_id = session_id;
546 1 : session_info = &spdm_context->session_info[0];
547 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
548 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
549 1 : libspdm_secured_message_set_session_state(session_info->secured_message_context,
550 : LIBSPDM_SESSION_STATE_ESTABLISHED);
551 :
552 1 : libspdm_reset_message_a(spdm_context);
553 1 : libspdm_reset_message_encap_e(spdm_context, session_info);
554 :
555 1 : response_size = sizeof(response);
556 1 : status = libspdm_get_response_encapsulated_request(spdm_context,
557 : m_libspdm_encapsulated_request_t2_size,
558 : &m_libspdm_encapsulated_request_t2,
559 : &response_size,
560 : response);
561 :
562 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
563 :
564 1 : assert_int_equal(response_size,
565 : sizeof(spdm_encapsulated_request_response_t) +
566 : sizeof(spdm_get_endpoint_info_request_t) +
567 : SPDM_NONCE_SIZE);
568 1 : spdm_response_requester = (void *)response;
569 1 : assert_int_equal(spdm_response_requester->header.request_response_code,
570 : SPDM_ENCAPSULATED_REQUEST);
571 1 : assert_int_equal(spdm_response_requester->header.param1, 0x1);
572 1 : assert_int_equal(spdm_response_requester->header.param2, 0);
573 1 : free(data);
574 : }
575 : #endif /* LIBSPDM_SEND_GET_ENDPOINT_INFO_SUPPORT */
576 :
577 : #if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT)
578 1 : static void rsp_encapsulated_response_ack_case1(void **State)
579 : {
580 : libspdm_return_t status;
581 : libspdm_test_context_t *spdm_test_context;
582 : libspdm_context_t *spdm_context;
583 : spdm_deliver_encapsulated_response_request_t *spdm_response_requester;
584 : spdm_digest_response_t *spdm_response_requester_digest;
585 : uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
586 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
587 : size_t spdm_response_requester_size;
588 : size_t spdm_response_requester_digest_size;
589 : size_t data_size;
590 : size_t response_size;
591 : uint8_t *digest;
592 : void *data;
593 :
594 1 : spdm_test_context = *State;
595 1 : spdm_context = spdm_test_context->spdm_context;
596 :
597 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
598 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
599 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
600 1 : spdm_context->encap_context.request_op_code_count =
601 : LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
602 :
603 1 : spdm_context->encap_context.current_request_op_code = SPDM_GET_DIGESTS;
604 1 : spdm_context->encap_context.request_op_code_sequence[0] = SPDM_GET_DIGESTS;
605 :
606 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
607 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
608 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
609 : SPDM_VERSION_NUMBER_SHIFT_BIT;
610 1 : spdm_context->encap_context.request_id = 0;
611 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
612 : m_libspdm_use_asym_algo, &data,
613 : &data_size,
614 : NULL, NULL)) {
615 0 : return;
616 : }
617 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
618 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
619 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
620 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
621 1 : libspdm_reset_message_b(spdm_context);
622 :
623 1 : spdm_response_requester_size = sizeof(spdm_digest_response_t) +
624 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo) +
625 : sizeof(spdm_deliver_encapsulated_response_request_t);
626 :
627 1 : spdm_response_requester = (void *)temp_buf;
628 1 : libspdm_copy_mem(spdm_response_requester,
629 : sizeof(temp_buf),
630 : &m_libspdm_m_deliver_encapsulated_response_request_t1,
631 : m_libspdm_m_deliver_encapsulated_response_request_t1_size);
632 :
633 1 : spdm_response_requester_digest_size = sizeof(spdm_digest_response_t) +
634 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo);
635 1 : spdm_response_requester_digest =
636 : (void *)(temp_buf + sizeof(spdm_deliver_encapsulated_response_request_t));
637 1 : spdm_response_requester_digest->header.spdm_version = SPDM_MESSAGE_VERSION_11;
638 1 : spdm_response_requester_digest->header.param1 = 0;
639 1 : spdm_response_requester_digest->header.request_response_code = SPDM_DIGESTS;
640 1 : spdm_response_requester_digest->header.param2 = 0;
641 :
642 1 : digest = (void *)(spdm_response_requester_digest + 1);
643 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
644 : sizeof(m_libspdm_local_certificate_chain), &digest[0]);
645 1 : spdm_response_requester_digest->header.param2 |= (0x01 << 0);
646 :
647 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
648 : sizeof(m_libspdm_local_certificate_chain),
649 : (uint8_t)(0xFF));
650 :
651 1 : libspdm_copy_mem(spdm_response_requester + 1,
652 : spdm_response_requester_digest_size,
653 : spdm_response_requester_digest,
654 : spdm_response_requester_digest_size);
655 :
656 1 : response_size = sizeof(response);
657 1 : status = libspdm_get_response_encapsulated_response_ack(spdm_context,
658 : spdm_response_requester_size,
659 : spdm_response_requester, &response_size,
660 : response);
661 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
662 1 : free(data);
663 : }
664 :
665 1 : static void rsp_encapsulated_response_ack_case2(void **State)
666 : {
667 : libspdm_return_t status;
668 : libspdm_test_context_t *spdm_test_context;
669 : libspdm_context_t *spdm_context;
670 : spdm_deliver_encapsulated_response_request_t *spdm_response_requester;
671 : spdm_certificate_response_t *spdm_response_requester_certificate;
672 : uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
673 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
674 : size_t spdm_response_requester_size;
675 : size_t data_size;
676 : size_t response_size;
677 : void *data;
678 : uint16_t portion_length;
679 : uint16_t remainder_length;
680 : static size_t calling_index = 0;
681 :
682 : static void *libspdm_local_certificate_chain;
683 : static size_t libspdm_local_certificate_chain_size;
684 :
685 1 : spdm_test_context = *State;
686 1 : spdm_context = spdm_test_context->spdm_context;
687 :
688 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
689 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
690 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
691 1 : spdm_context->encap_context.request_op_code_count =
692 : LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
693 :
694 1 : spdm_context->encap_context.current_request_op_code = SPDM_GET_CERTIFICATE;
695 1 : spdm_context->encap_context.request_op_code_sequence[0] = SPDM_GET_CERTIFICATE;
696 :
697 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
698 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
699 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
700 : SPDM_VERSION_NUMBER_SHIFT_BIT;
701 1 : spdm_context->encap_context.request_id = 0;
702 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
703 : m_libspdm_use_asym_algo, &data,
704 : &data_size,
705 : NULL, NULL)) {
706 0 : return;
707 : }
708 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
709 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
710 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
711 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
712 1 : libspdm_reset_message_b(spdm_context);
713 :
714 1 : spdm_response_requester = (void *)temp_buf;
715 1 : libspdm_copy_mem(spdm_response_requester,
716 : sizeof(temp_buf),
717 : &m_libspdm_m_deliver_encapsulated_response_request_t1,
718 : m_libspdm_m_deliver_encapsulated_response_request_t1_size);
719 :
720 1 : spdm_response_requester_certificate =
721 : (void *)(temp_buf + sizeof(spdm_deliver_encapsulated_response_request_t));
722 :
723 1 : if (!libspdm_read_responder_public_certificate_chain(
724 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
725 : &libspdm_local_certificate_chain,
726 : &libspdm_local_certificate_chain_size, NULL, NULL)) {
727 0 : return;
728 : }
729 :
730 1 : portion_length = LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN;
731 1 : remainder_length = (uint16_t)(libspdm_local_certificate_chain_size -
732 1 : (LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN * (calling_index + 1)));
733 :
734 1 : spdm_response_requester_certificate->header.spdm_version = SPDM_MESSAGE_VERSION_11;
735 1 : spdm_response_requester_certificate->header.request_response_code = SPDM_CERTIFICATE;
736 1 : spdm_response_requester_certificate->header.param1 = 0;
737 1 : spdm_response_requester_certificate->header.param2 = 0;
738 1 : spdm_response_requester_certificate->portion_length = portion_length;
739 1 : spdm_response_requester_certificate->remainder_length = remainder_length;
740 :
741 1 : libspdm_copy_mem(spdm_response_requester_certificate + 1,
742 : sizeof(temp_buf) - sizeof(*spdm_response_requester_certificate),
743 1 : (uint8_t *)libspdm_local_certificate_chain +
744 1 : LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN * calling_index,
745 : portion_length);
746 :
747 1 : free(libspdm_local_certificate_chain);
748 :
749 1 : response_size = sizeof(response);
750 1 : spdm_response_requester_size = sizeof(spdm_certificate_response_t) + portion_length +
751 : sizeof(spdm_deliver_encapsulated_response_request_t);
752 1 : status = libspdm_get_response_encapsulated_response_ack(spdm_context,
753 : spdm_response_requester_size,
754 : spdm_response_requester, &response_size,
755 : response);
756 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
757 1 : free(data);
758 : }
759 : #endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT) */
760 :
761 1 : static void rsp_encapsulated_response_ack_case3(void **State)
762 : {
763 : libspdm_return_t status;
764 : libspdm_test_context_t *spdm_test_context;
765 : libspdm_context_t *spdm_context;
766 : spdm_deliver_encapsulated_response_request_t *spdm_response_requester;
767 : spdm_key_update_response_t *spdm_response_requester_key_update;
768 : uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
769 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
770 : size_t spdm_response_requester_size;
771 : size_t data_size;
772 : size_t response_size;
773 : void *data;
774 : uint32_t session_id;
775 : libspdm_session_info_t *session_info;
776 :
777 1 : spdm_test_context = *State;
778 1 : spdm_context = spdm_test_context->spdm_context;
779 :
780 1 : spdm_context->last_spdm_request_session_id_valid = true;
781 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
782 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
783 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
784 1 : spdm_context->encap_context.request_op_code_count =
785 : LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
786 :
787 1 : spdm_context->encap_context.current_request_op_code = SPDM_KEY_UPDATE;
788 1 : spdm_context->encap_context.request_op_code_sequence[0] = SPDM_KEY_UPDATE;
789 :
790 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
791 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
792 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
793 : SPDM_VERSION_NUMBER_SHIFT_BIT;
794 1 : spdm_context->encap_context.request_id = 0;
795 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
796 : m_libspdm_use_asym_algo, &data,
797 : &data_size,
798 : NULL, NULL)) {
799 0 : return;
800 : }
801 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
802 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
803 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
804 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
805 :
806 1 : libspdm_reset_message_b(spdm_context);
807 :
808 1 : session_id = 0xFFFFFFFF;
809 1 : spdm_context->latest_session_id = session_id;
810 1 : spdm_context->last_spdm_request_session_id_valid = true;
811 1 : spdm_context->last_spdm_request_session_id = session_id;
812 1 : session_info = &spdm_context->session_info[0];
813 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
814 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
815 1 : libspdm_secured_message_set_session_state(session_info->secured_message_context,
816 : LIBSPDM_SESSION_STATE_ESTABLISHED);
817 :
818 1 : spdm_context->encap_context.last_encap_request_header.spdm_version = SPDM_MESSAGE_VERSION_11;
819 1 : spdm_context->encap_context.last_encap_request_header.request_response_code =
820 : SPDM_KEY_UPDATE_ACK;
821 1 : spdm_context->encap_context.last_encap_request_header.param1 =
822 : SPDM_KEY_UPDATE_OPERATIONS_UPDATE_KEY;
823 1 : spdm_context->encap_context.last_encap_request_header.param2 = 0;
824 :
825 1 : spdm_response_requester = (void *)temp_buf;
826 1 : libspdm_copy_mem(spdm_response_requester,
827 : sizeof(temp_buf),
828 : &m_libspdm_m_deliver_encapsulated_response_request_t1,
829 : m_libspdm_m_deliver_encapsulated_response_request_t1_size);
830 :
831 1 : spdm_response_requester_key_update =
832 : (void *)(temp_buf + sizeof(spdm_deliver_encapsulated_response_request_t));
833 :
834 1 : spdm_response_requester_key_update->header.spdm_version = SPDM_MESSAGE_VERSION_11;
835 1 : spdm_response_requester_key_update->header.request_response_code = SPDM_KEY_UPDATE_ACK;
836 1 : spdm_response_requester_key_update->header.param1 = SPDM_KEY_UPDATE_OPERATIONS_UPDATE_KEY;
837 1 : spdm_response_requester_key_update->header.param2 = 0;
838 :
839 1 : response_size = sizeof(response);
840 1 : spdm_response_requester_size = sizeof(spdm_key_update_response_t) +
841 : sizeof(spdm_deliver_encapsulated_response_request_t);
842 1 : status = libspdm_get_response_encapsulated_response_ack(spdm_context,
843 : spdm_response_requester_size,
844 : spdm_response_requester, &response_size,
845 : response);
846 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
847 1 : free(data);
848 : }
849 :
850 1 : static void rsp_encapsulated_response_ack_case4(void **State)
851 : {
852 : libspdm_return_t status;
853 : spdm_encapsulated_request_response_t *spdm_response_requester;
854 : libspdm_test_context_t *spdm_test_context;
855 : libspdm_context_t *spdm_context;
856 : size_t response_size;
857 1 : spdm_test_context = *State;
858 1 : spdm_context = spdm_test_context->spdm_context;
859 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
860 :
861 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
862 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
863 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
864 1 : spdm_context->encap_context.request_op_code_count =
865 : LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
866 1 : spdm_context->encap_context.current_request_op_code = 0;
867 1 : libspdm_reset_message_b(spdm_context);
868 :
869 1 : response_size = sizeof(response);
870 1 : status = libspdm_get_response_encapsulated_response_ack(spdm_context,
871 : m_libspdm_m_deliver_encapsulated_response_request_t1_size,
872 : &m_libspdm_m_deliver_encapsulated_response_request_t1,
873 : &response_size,
874 : response);
875 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
876 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
877 1 : spdm_response_requester = (void *)response;
878 1 : assert_int_equal(spdm_response_requester->header.request_response_code, SPDM_ERROR);
879 1 : assert_int_equal(spdm_response_requester->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
880 1 : assert_int_equal(spdm_response_requester->header.param2, 0);
881 1 : }
882 :
883 1 : static void rsp_encapsulated_response_ack_case5(void **State)
884 : {
885 : libspdm_return_t status;
886 : spdm_encapsulated_request_response_t *spdm_response_requester;
887 : libspdm_test_context_t *spdm_test_context;
888 : libspdm_context_t *spdm_context;
889 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
890 : size_t response_size;
891 1 : spdm_test_context = *State;
892 1 : spdm_context = spdm_test_context->spdm_context;
893 :
894 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
895 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
896 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
897 1 : spdm_context->encap_context.request_op_code_count =
898 : LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
899 1 : spdm_context->encap_context.current_request_op_code = 0;
900 :
901 1 : response_size = sizeof(response);
902 1 : status = libspdm_get_response_encapsulated_response_ack(spdm_context,
903 : m_libspdm_m_deliver_encapsulated_response_request_t1_size,
904 : &m_libspdm_m_deliver_encapsulated_response_request_t1,
905 : &response_size,
906 : response);
907 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
908 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
909 1 : spdm_response_requester = (void *)response;
910 1 : assert_int_equal(spdm_response_requester->header.request_response_code, SPDM_ERROR);
911 1 : assert_int_equal(spdm_response_requester->header.param1, SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
912 1 : assert_int_equal(spdm_response_requester->header.param2, 0);
913 1 : }
914 :
915 1 : static void rsp_encapsulated_response_ack_case6(void **State)
916 : {
917 : libspdm_return_t status;
918 : spdm_encapsulated_request_response_t *spdm_response_requester;
919 : libspdm_test_context_t *spdm_test_context;
920 : libspdm_context_t *spdm_context;
921 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
922 : size_t response_size;
923 : size_t data_size;
924 : void *data;
925 :
926 1 : spdm_test_context = *State;
927 1 : spdm_context = spdm_test_context->spdm_context;
928 :
929 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NEED_RESYNC;
930 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
931 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
932 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
933 1 : spdm_context->encap_context.request_op_code_count =
934 : LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
935 :
936 1 : status = libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
937 : m_libspdm_use_asym_algo, &data,
938 : &data_size,
939 : NULL, NULL);
940 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
941 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
942 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
943 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
944 :
945 1 : response_size = sizeof(response);
946 1 : status = libspdm_get_response_encapsulated_response_ack(spdm_context,
947 : m_libspdm_m_deliver_encapsulated_response_request_t1_size,
948 : &m_libspdm_m_deliver_encapsulated_response_request_t1,
949 : &response_size,
950 : response);
951 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
952 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
953 1 : spdm_response_requester = (void *)response;
954 1 : assert_int_equal(spdm_response_requester->header.request_response_code, SPDM_ERROR);
955 1 : assert_int_equal(spdm_response_requester->header.param1, SPDM_ERROR_CODE_REQUEST_RESYNCH);
956 1 : assert_int_equal(spdm_response_requester->header.param2, 0);
957 1 : }
958 :
959 : #if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT)
960 1 : static void rsp_encapsulated_response_ack_case7(void **State)
961 : {
962 : libspdm_return_t status;
963 : libspdm_test_context_t *spdm_test_context;
964 : libspdm_context_t *spdm_context;
965 : spdm_deliver_encapsulated_response_request_t *spdm_response_requester;
966 : spdm_certificate_response_t *spdm_response_requester_certificate;
967 : uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
968 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
969 : size_t spdm_response_requester_size;
970 : size_t data_size;
971 : size_t response_size;
972 : void *data;
973 : uint16_t portion_length;
974 : uint16_t remainder_length;
975 : static size_t calling_index = 0;
976 :
977 : static void *libspdm_local_certificate_chain;
978 : static size_t libspdm_local_certificate_chain_size;
979 :
980 1 : spdm_test_context = *State;
981 1 : spdm_context = spdm_test_context->spdm_context;
982 :
983 1 : spdm_context->encap_context.request_id = 0xFF;
984 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
985 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
986 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
987 1 : spdm_context->encap_context.request_op_code_count =
988 : LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
989 :
990 1 : spdm_context->encap_context.current_request_op_code = SPDM_GET_CERTIFICATE;
991 1 : spdm_context->encap_context.request_op_code_sequence[0] = SPDM_GET_CERTIFICATE;
992 :
993 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
994 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
995 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
996 : SPDM_VERSION_NUMBER_SHIFT_BIT;
997 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
998 : m_libspdm_use_asym_algo, &data,
999 : &data_size,
1000 : NULL, NULL)) {
1001 0 : return;
1002 : }
1003 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
1004 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
1005 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1006 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1007 1 : libspdm_reset_message_b(spdm_context);
1008 :
1009 1 : spdm_response_requester = (void *)temp_buf;
1010 1 : libspdm_copy_mem(spdm_response_requester,
1011 : sizeof(temp_buf),
1012 : &m_libspdm_m_deliver_encapsulated_response_request_t1,
1013 : m_libspdm_m_deliver_encapsulated_response_request_t1_size);
1014 :
1015 1 : spdm_response_requester_certificate =
1016 : (void *)(temp_buf + sizeof(spdm_deliver_encapsulated_response_request_t));
1017 :
1018 1 : if (!libspdm_read_responder_public_certificate_chain(
1019 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
1020 : &libspdm_local_certificate_chain,
1021 : &libspdm_local_certificate_chain_size, NULL, NULL)) {
1022 0 : return;
1023 : }
1024 :
1025 1 : portion_length = LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN;
1026 1 : remainder_length = (uint16_t)(libspdm_local_certificate_chain_size -
1027 1 : (LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN * (calling_index + 1)));
1028 :
1029 1 : spdm_response_requester_certificate->header.spdm_version = SPDM_MESSAGE_VERSION_11;
1030 1 : spdm_response_requester_certificate->header.request_response_code = SPDM_CERTIFICATE;
1031 1 : spdm_response_requester_certificate->header.param1 = 0;
1032 1 : spdm_response_requester_certificate->header.param2 = 0;
1033 1 : spdm_response_requester_certificate->portion_length = portion_length;
1034 1 : spdm_response_requester_certificate->remainder_length = remainder_length;
1035 :
1036 1 : libspdm_copy_mem(spdm_response_requester_certificate + 1,
1037 : sizeof(temp_buf) - sizeof(*spdm_response_requester_certificate),
1038 1 : (uint8_t *)libspdm_local_certificate_chain +
1039 1 : LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN * calling_index,
1040 : portion_length);
1041 :
1042 1 : free(libspdm_local_certificate_chain);
1043 :
1044 1 : response_size = sizeof(response);
1045 1 : spdm_response_requester_size = sizeof(spdm_certificate_response_t) + portion_length +
1046 : sizeof(spdm_deliver_encapsulated_response_request_t);
1047 1 : status = libspdm_get_response_encapsulated_response_ack(spdm_context,
1048 : spdm_response_requester_size,
1049 : spdm_response_requester, &response_size,
1050 : response);
1051 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1052 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1053 1 : spdm_response_requester = (void *)response;
1054 1 : assert_int_equal(spdm_response_requester->header.request_response_code, SPDM_ERROR);
1055 1 : assert_int_equal(spdm_response_requester->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1056 1 : assert_int_equal(spdm_response_requester->header.param2, 0);
1057 1 : free(data);
1058 : }
1059 :
1060 1 : static void rsp_encapsulated_response_ack_case8(void **State)
1061 : {
1062 : libspdm_return_t status;
1063 : libspdm_test_context_t *spdm_test_context;
1064 : libspdm_context_t *spdm_context;
1065 : spdm_encapsulated_response_ack_response_t *spdm_response;
1066 : spdm_deliver_encapsulated_response_request_t *spdm_response_requester;
1067 : spdm_digest_response_t *spdm_response_requester_digest;
1068 : uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
1069 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1070 : size_t spdm_response_requester_size;
1071 : size_t spdm_response_requester_digest_size;
1072 : size_t data_size;
1073 : size_t response_size;
1074 : uint8_t *digest;
1075 : void *data;
1076 :
1077 1 : spdm_test_context = *State;
1078 1 : spdm_context = spdm_test_context->spdm_context;
1079 :
1080 1 : spdm_context->encap_context.request_id = 0xFF;
1081 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
1082 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
1083 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
1084 1 : spdm_context->encap_context.request_op_code_count =
1085 : LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
1086 :
1087 1 : spdm_context->encap_context.current_request_op_code = SPDM_GET_DIGESTS;
1088 1 : spdm_context->encap_context.request_op_code_sequence[0] = SPDM_GET_DIGESTS;
1089 :
1090 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1091 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
1092 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1093 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1094 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1095 : m_libspdm_use_asym_algo, &data,
1096 : &data_size,
1097 : NULL, NULL)) {
1098 0 : return;
1099 : }
1100 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
1101 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
1102 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1103 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1104 1 : libspdm_reset_message_b(spdm_context);
1105 :
1106 1 : spdm_response_requester_size = sizeof(spdm_digest_response_t) +
1107 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo) +
1108 : sizeof(spdm_deliver_encapsulated_response_request_t);
1109 :
1110 1 : spdm_response_requester = (void *)temp_buf;
1111 1 : libspdm_copy_mem(spdm_response_requester,
1112 : sizeof(temp_buf),
1113 : &m_libspdm_m_deliver_encapsulated_response_request_t2,
1114 : m_libspdm_m_deliver_encapsulated_response_request_t2_size);
1115 :
1116 1 : spdm_response_requester_digest_size = sizeof(spdm_digest_response_t) +
1117 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo);
1118 1 : spdm_response_requester_digest =
1119 : (void *)(temp_buf + sizeof(spdm_deliver_encapsulated_response_request_t));
1120 1 : spdm_response_requester_digest->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1121 1 : spdm_response_requester_digest->header.param1 = 0;
1122 1 : spdm_response_requester_digest->header.request_response_code = SPDM_DIGESTS;
1123 1 : spdm_response_requester_digest->header.param2 = 0;
1124 :
1125 1 : digest = (void *)(spdm_response_requester_digest + 1);
1126 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
1127 : sizeof(m_libspdm_local_certificate_chain), &digest[0]);
1128 1 : spdm_response_requester_digest->header.param2 |= (0x01 << 0);
1129 :
1130 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
1131 : sizeof(m_libspdm_local_certificate_chain),
1132 : (uint8_t)(0xFF));
1133 :
1134 1 : libspdm_copy_mem(spdm_response_requester + 1,
1135 : spdm_response_requester_digest_size,
1136 : spdm_response_requester_digest,
1137 : spdm_response_requester_digest_size);
1138 :
1139 1 : response_size = sizeof(response);
1140 1 : status = libspdm_get_response_encapsulated_response_ack(spdm_context,
1141 : spdm_response_requester_size,
1142 : spdm_response_requester, &response_size,
1143 : response);
1144 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1145 1 : assert_int_equal(response_size, sizeof(spdm_encapsulated_response_ack_response_t));
1146 1 : spdm_response = (void *)response;
1147 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1148 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ENCAPSULATED_RESPONSE_ACK);
1149 1 : assert_int_equal(spdm_response->header.param1, 0);
1150 1 : assert_int_equal(spdm_response->header.param2,
1151 : SPDM_ENCAPSULATED_RESPONSE_ACK_RESPONSE_PAYLOAD_TYPE_ABSENT);
1152 1 : assert_int_equal(spdm_response->ack_request_id,
1153 : m_libspdm_m_deliver_encapsulated_response_request_t2.header.param1);
1154 1 : free(data);
1155 : }
1156 : #endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT) */
1157 :
1158 : /**
1159 : * Test 9: In an encapsulated request flow, a Responder issue an encapsulated request that can take up to CT time to
1160 : * fulfill, then the Requester deliver an encapsulated ERROR message with a ResponseNotReady error code.
1161 : * Expected behavior: the Responder shall not encapsulate another request by setting Param2 in ENCAPSULATED_RESPONSE_ACK
1162 : * to a value of zero.
1163 : **/
1164 1 : static void rsp_encapsulated_response_ack_case9(void **State)
1165 : {
1166 : libspdm_return_t status;
1167 : libspdm_test_context_t *spdm_test_context;
1168 : libspdm_context_t *spdm_context;
1169 : spdm_encapsulated_response_ack_response_t *spdm_response;
1170 : spdm_deliver_encapsulated_response_request_t *spdm_request;
1171 : spdm_error_response_data_response_not_ready_t *EncapsulatedResponse;
1172 : uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
1173 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1174 : size_t spdm_request_size;
1175 : size_t EncapsulatedResponse_size;
1176 : size_t response_size;
1177 :
1178 1 : spdm_test_context = *State;
1179 1 : spdm_context = spdm_test_context->spdm_context;
1180 :
1181 1 : spdm_context->encap_context.request_id = 0xFF;
1182 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_PROCESSING_ENCAP;
1183 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP;
1184 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
1185 1 : spdm_context->encap_context.request_op_code_count =
1186 : LIBSPDM_MAX_ENCAP_REQUEST_OP_CODE_SEQUENCE_COUNT;
1187 :
1188 1 : spdm_context->encap_context.current_request_op_code = SPDM_GET_DIGESTS;
1189 1 : spdm_context->encap_context.request_op_code_sequence[0] = SPDM_GET_DIGESTS;
1190 :
1191 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1192 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
1193 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1194 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1195 1 : libspdm_reset_message_b(spdm_context);
1196 :
1197 1 : spdm_request_size = sizeof(spdm_deliver_encapsulated_response_request_t) +
1198 : sizeof(spdm_error_response_data_response_not_ready_t);
1199 :
1200 1 : spdm_request = (void *)temp_buf;
1201 1 : libspdm_copy_mem(spdm_request,
1202 : sizeof(temp_buf),
1203 : &m_libspdm_m_deliver_encapsulated_response_request_t2,
1204 : m_libspdm_m_deliver_encapsulated_response_request_t2_size);
1205 :
1206 1 : EncapsulatedResponse_size = sizeof(spdm_error_response_data_response_not_ready_t);
1207 1 : EncapsulatedResponse =
1208 : (void *)(temp_buf + sizeof(spdm_deliver_encapsulated_response_request_t));
1209 1 : EncapsulatedResponse->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1210 1 : EncapsulatedResponse->header.request_response_code = SPDM_ERROR;
1211 1 : EncapsulatedResponse->header.param1 = SPDM_ERROR_CODE_RESPONSE_NOT_READY;
1212 1 : EncapsulatedResponse->header.param2 = 0;
1213 1 : EncapsulatedResponse->extend_error_data.rd_exponent = 1;
1214 1 : EncapsulatedResponse->extend_error_data.rd_tm = 1;
1215 1 : EncapsulatedResponse->extend_error_data.request_code = SPDM_GET_DIGESTS;
1216 1 : EncapsulatedResponse->extend_error_data.token = 0;
1217 :
1218 1 : libspdm_copy_mem(spdm_request + 1,
1219 : EncapsulatedResponse_size,
1220 : EncapsulatedResponse,
1221 : EncapsulatedResponse_size);
1222 :
1223 1 : response_size = sizeof(response);
1224 1 : status = libspdm_get_response_encapsulated_response_ack(spdm_context,
1225 : spdm_request_size,
1226 : spdm_request, &response_size,
1227 : response);
1228 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1229 1 : assert_int_equal(response_size, sizeof(spdm_encapsulated_response_ack_response_t));
1230 1 : spdm_response = (void *)response;
1231 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1232 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ENCAPSULATED_RESPONSE_ACK);
1233 1 : assert_int_equal(spdm_response->header.param1, 0);
1234 1 : assert_int_equal(spdm_response->header.param2,
1235 : SPDM_ENCAPSULATED_RESPONSE_ACK_RESPONSE_PAYLOAD_TYPE_ABSENT);
1236 1 : assert_int_equal(spdm_response->ack_request_id,
1237 : m_libspdm_m_deliver_encapsulated_response_request_t2.header.param1);
1238 1 : }
1239 :
1240 1 : int libspdm_rsp_encapsulated_request_test(void)
1241 : {
1242 1 : const struct CMUnitTest test_cases[] = {
1243 : #if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT)
1244 : /*Success Case request_op_code_sequence: SPDM_GET_DIGESTS*/
1245 : cmocka_unit_test(rsp_encapsulated_request_case1),
1246 : /*Success Case current_request_op_code: SPDM_GET_CERTIFICATE */
1247 : cmocka_unit_test(rsp_encapsulated_request_case2),
1248 : /*response_state : LIBSPDM_RESPONSE_STATE_NORMAL with UnexpectedRequest error. */
1249 : cmocka_unit_test(rsp_encapsulated_request_case3),
1250 : /*response_state : LIBSPDM_RESPONSE_STATE_NEED_RESYNC */
1251 : cmocka_unit_test(rsp_encapsulated_request_case4),
1252 : #endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT) */
1253 : #if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_CHALLENGE_SUPPORT)
1254 : /*Success Case current_request_op_code: SPDM_CHALLENGE */
1255 : cmocka_unit_test(rsp_encapsulated_request_case5),
1256 : #endif
1257 : /* Success Case current_request_op_code: SPDM_KEY_UPDATE */
1258 : cmocka_unit_test(rsp_encapsulated_request_case6),
1259 : /*response_state : LIBSPDM_RESPONSE_STATE_NORMAL with NoPendingRequests error. */
1260 : cmocka_unit_test(rsp_encapsulated_request_case7),
1261 : #if LIBSPDM_SEND_GET_ENDPOINT_INFO_SUPPORT
1262 : /* Success Case current_request_op_code: SPDM_GET_ENDPOINT_INFO */
1263 : cmocka_unit_test(rsp_encapsulated_request_case8),
1264 : #endif /* LIBSPDM_SEND_GET_ENDPOINT_INFO_SUPPORT */
1265 :
1266 : #if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT)
1267 : /*Success Case current_request_op_code: SPDM_GET_DIGESTS*/
1268 : cmocka_unit_test(rsp_encapsulated_response_ack_case1),
1269 : /*Success Case current_request_op_code: SPDM_GET_CERTIFICATE*/
1270 : cmocka_unit_test(rsp_encapsulated_response_ack_case2),
1271 : #endif
1272 : /* Success Case current_request_op_code: SPDM_KEY_UPDATE */
1273 : cmocka_unit_test(rsp_encapsulated_response_ack_case3),
1274 : /* current_request_op_code: NULL */
1275 : cmocka_unit_test(rsp_encapsulated_response_ack_case4),
1276 : /*response_state : LIBSPDM_RESPONSE_STATE_NORMAL */
1277 : cmocka_unit_test(rsp_encapsulated_response_ack_case5),
1278 : /*response_state : LIBSPDM_RESPONSE_STATE_NEED_RESYNC */
1279 : cmocka_unit_test(rsp_encapsulated_response_ack_case6),
1280 : #if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT)
1281 : /*spdm_request->header.param1 != spdm_context->encap_context.request_id */
1282 : cmocka_unit_test(rsp_encapsulated_response_ack_case7),
1283 : /*Success Case When version is greater than V1.2 */
1284 : cmocka_unit_test(rsp_encapsulated_response_ack_case8),
1285 : #endif
1286 : /*When the Requester delivers an encapsulated ERROR message with a ResponseNotReady error code*/
1287 : cmocka_unit_test(rsp_encapsulated_response_ack_case9),
1288 : };
1289 :
1290 1 : libspdm_test_context_t test_context = {
1291 : LIBSPDM_TEST_CONTEXT_VERSION,
1292 : false,
1293 : };
1294 :
1295 1 : libspdm_setup_test_context(&test_context);
1296 :
1297 1 : return cmocka_run_group_tests(test_cases,
1298 : libspdm_unit_test_group_setup,
1299 : libspdm_unit_test_group_teardown);
1300 : }
1301 :
1302 : #endif /* LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP */
|
