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