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