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