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