Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2026 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : #include "spdm_unit_test.h"
8 : #include "internal/libspdm_responder_lib.h"
9 :
10 : #if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP) && \
11 : (LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT)
12 :
13 : uint8_t m_local_digests_chain[LIBSPDM_MAX_CERT_CHAIN_SIZE];
14 : static uint8_t m_libspdm_local_certificate_chain[LIBSPDM_MAX_CERT_CHAIN_SIZE];
15 :
16 : /**
17 : * Test 1: Response message received successfully
18 : * Expected Behavior: requester returns the status LIBSPDM_STATUS_SUCCESS and a DIGESTS message is received
19 : **/
20 1 : static void rsp_encap_get_digests_case1(void **state)
21 : {
22 : libspdm_return_t status;
23 : libspdm_test_context_t *spdm_test_context;
24 : libspdm_context_t *spdm_context;
25 : spdm_digest_response_t *spdm_response;
26 : uint8_t *digest;
27 : uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
28 : size_t spdm_response_size;
29 : bool need_continue;
30 :
31 1 : spdm_test_context = *state;
32 1 : spdm_context = spdm_test_context->spdm_context;
33 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
34 : SPDM_VERSION_NUMBER_SHIFT_BIT;
35 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
36 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
37 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
38 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
39 : sizeof(m_libspdm_local_certificate_chain),
40 : (uint8_t)(0xFF));
41 1 : libspdm_reset_message_b(spdm_context);
42 :
43 : ((libspdm_context_t *)spdm_context)
44 1 : ->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
45 1 : spdm_response_size = sizeof(spdm_digest_response_t) +
46 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo);
47 1 : spdm_response = (void *)temp_buf;
48 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
49 1 : spdm_response->header.param1 = 0;
50 1 : spdm_response->header.request_response_code = SPDM_DIGESTS;
51 1 : spdm_response->header.param2 = 0;
52 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
53 : sizeof(m_libspdm_local_certificate_chain),
54 : (uint8_t)(0xFF));
55 :
56 1 : digest = (void *)(spdm_response + 1);
57 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
58 : sizeof(m_libspdm_local_certificate_chain), &digest[0]);
59 1 : spdm_response->header.param2 |= (0x01 << 0);
60 :
61 1 : status = libspdm_process_encap_response_digest(spdm_context, spdm_response_size,
62 : spdm_response, &need_continue);
63 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
64 1 : }
65 :
66 : /**
67 : * Test 2: Error response message with error code busy
68 : * Expected Behavior: requester returns the status RETURN_DEVICE_ERROR, with no DIGESTS message received
69 : **/
70 1 : static void rsp_encap_get_digests_case2(void **state)
71 : {
72 : libspdm_return_t status;
73 : libspdm_test_context_t *spdm_test_context;
74 : libspdm_context_t *spdm_context;
75 : spdm_error_response_t spdm_response;
76 : size_t spdm_response_size;
77 : bool need_continue;
78 :
79 1 : spdm_test_context = *state;
80 1 : spdm_context = spdm_test_context->spdm_context;
81 1 : spdm_test_context->case_id = 0x2;
82 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
83 : SPDM_VERSION_NUMBER_SHIFT_BIT;
84 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
85 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
86 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
87 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
88 : sizeof(m_libspdm_local_certificate_chain),
89 : (uint8_t)(0xFF));
90 1 : libspdm_reset_message_b(spdm_context);
91 :
92 1 : spdm_response_size = sizeof(spdm_error_response_t);
93 1 : spdm_response.header.spdm_version = SPDM_MESSAGE_VERSION_10;
94 1 : spdm_response.header.request_response_code = SPDM_ERROR;
95 1 : spdm_response.header.param1 = SPDM_ERROR_CODE_INVALID_REQUEST;
96 1 : spdm_response.header.param2 = 0;
97 :
98 1 : status = libspdm_process_encap_response_digest(spdm_context, spdm_response_size,
99 : &spdm_response, &need_continue);
100 :
101 1 : assert_int_equal(status, LIBSPDM_STATUS_UNSUPPORTED_CAP);
102 1 : }
103 :
104 : /**
105 : * Test 3: Error response message with error code busy response seize incorrect
106 : * Expected Behavior: Expected Behavior: requester returns the status RETURN_DEVICE_ERROR, with no DIGESTS message received
107 : **/
108 1 : static void rsp_encap_get_digests_case3(void **state)
109 : {
110 : libspdm_return_t status;
111 : libspdm_test_context_t *spdm_test_context;
112 : libspdm_context_t *spdm_context;
113 : bool need_continue;
114 :
115 1 : spdm_test_context = *state;
116 1 : spdm_context = spdm_test_context->spdm_context;
117 1 : spdm_test_context->case_id = 0x3;
118 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
119 : SPDM_VERSION_NUMBER_SHIFT_BIT;
120 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
121 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
122 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
123 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
124 : sizeof(m_libspdm_local_certificate_chain),
125 : (uint8_t)(0xFF));
126 1 : libspdm_reset_message_b(spdm_context);
127 :
128 : spdm_digest_response_t *spdm_response;
129 1 : uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE] = {0};
130 : size_t spdm_response_size;
131 :
132 1 : spdm_response_size = 0;
133 1 : spdm_response = (void *)temp_buf;
134 :
135 1 : status = libspdm_process_encap_response_digest(spdm_context, spdm_response_size,
136 : spdm_response, &need_continue);
137 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_SIZE);
138 1 : }
139 :
140 : /**
141 : * Test 4: The code of the request_response_code summary in the response message is different
142 : * Expected Behavior: requester returns the status RETURN_DEVICE_ERROR, with no DIGESTS message received
143 : **/
144 1 : static void rsp_encap_get_digests_case4(void **state)
145 : {
146 : libspdm_return_t status;
147 : libspdm_test_context_t *spdm_test_context;
148 : libspdm_context_t *spdm_context;
149 : bool need_continue;
150 :
151 1 : spdm_test_context = *state;
152 1 : spdm_context = spdm_test_context->spdm_context;
153 1 : spdm_test_context->case_id = 0x4;
154 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
155 : SPDM_VERSION_NUMBER_SHIFT_BIT;
156 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
157 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
158 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
159 :
160 : spdm_digest_response_t *spdm_response;
161 : uint8_t *digest;
162 : uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
163 : size_t spdm_response_size;
164 :
165 1 : spdm_response_size = sizeof(spdm_digest_response_t) +
166 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo);
167 1 : spdm_response = (void *)temp_buf;
168 :
169 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
170 1 : spdm_response->header.request_response_code = SPDM_CERTIFICATE;
171 1 : spdm_response->header.param1 = 0;
172 1 : spdm_response->header.param2 = 0;
173 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
174 : sizeof(m_libspdm_local_certificate_chain),
175 : (uint8_t)(0xFF));
176 :
177 1 : digest = (void *)(spdm_response + 1);
178 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
179 : sizeof(m_libspdm_local_certificate_chain), &digest[0]);
180 1 : spdm_response->header.param2 |= (1 << 0);
181 :
182 1 : status = libspdm_process_encap_response_digest(spdm_context, spdm_response_size,
183 : spdm_response, &need_continue);
184 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
185 1 : }
186 :
187 : /**
188 : * Test 5: flag cert_cap from CAPABILITIES is not set meaning the Requester does not support DIGESTS and
189 : * CERTIFICATE response messages
190 : * Expected Behavior: requester returns the status RETURN_DEVICE_ERROR, with no DIGESTS message received
191 : **/
192 1 : static void rsp_encap_get_digests_case5(void **state)
193 : {
194 : libspdm_return_t status;
195 : libspdm_test_context_t *spdm_test_context;
196 : libspdm_context_t *spdm_context;
197 : spdm_digest_response_t *spdm_response;
198 1 : uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE] = {0};
199 : size_t spdm_response_size;
200 : bool need_continue;
201 :
202 1 : spdm_test_context = *state;
203 1 : spdm_context = spdm_test_context->spdm_context;
204 1 : spdm_test_context->case_id = 0x5;
205 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
206 : SPDM_VERSION_NUMBER_SHIFT_BIT;
207 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
208 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
209 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
210 : sizeof(m_libspdm_local_certificate_chain),
211 : (uint8_t)(0xFF));
212 1 : libspdm_reset_message_b(spdm_context);
213 :
214 1 : spdm_response_size = sizeof(spdm_digest_response_t);
215 1 : spdm_response = (void *)temp_buf;
216 :
217 1 : status = libspdm_process_encap_response_digest(spdm_context, spdm_response_size,
218 : spdm_response, &need_continue);
219 :
220 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
221 1 : }
222 :
223 : /**
224 : * Test 6: a response message is successfully sent , Set multi_key_conn_req to check if it responds correctly
225 : * Expected Behavior: requester returns the status LIBSPDM_STATUS_SUCCESS
226 : **/
227 1 : static void rsp_encap_get_digests_case6(void **state)
228 : {
229 : libspdm_return_t status;
230 : libspdm_test_context_t *spdm_test_context;
231 : libspdm_context_t *spdm_context;
232 : spdm_digest_response_t *spdm_response;
233 : uint8_t *digest;
234 : size_t hash_size;
235 : uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
236 : size_t spdm_response_size;
237 : bool need_continue;
238 : uint32_t session_id;
239 : libspdm_session_info_t *session_info;
240 : spdm_key_pair_id_t *key_pair_id;
241 : spdm_certificate_info_t *cert_info;
242 : spdm_key_usage_bit_mask_t *key_usage_bit_mask;
243 :
244 1 : spdm_test_context = *state;
245 1 : spdm_context = spdm_test_context->spdm_context;
246 1 : spdm_test_context->case_id = 0x6;
247 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
248 : SPDM_VERSION_NUMBER_SHIFT_BIT;
249 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
250 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
251 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
252 :
253 1 : libspdm_reset_message_b(spdm_context);
254 :
255 1 : spdm_response = (void *)temp_buf;
256 1 : libspdm_zero_mem(temp_buf, sizeof(temp_buf));
257 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
258 1 : spdm_response->header.request_response_code = SPDM_DIGESTS;
259 1 : spdm_response->header.param1 = (0x01 << 0);
260 1 : spdm_response->header.param2 = 0;
261 1 : spdm_response->header.param2 |= (0x01 << 0);
262 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
263 : sizeof(m_libspdm_local_certificate_chain),
264 : (uint8_t)(0xFF));
265 :
266 1 : hash_size = libspdm_get_hash_size(m_libspdm_use_hash_algo);
267 1 : digest = (void *)(spdm_response + 1);
268 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
269 : sizeof(m_libspdm_local_certificate_chain), &digest[0]);
270 1 : key_pair_id = (spdm_key_pair_id_t *)((uint8_t *)digest + hash_size);
271 1 : cert_info = (spdm_certificate_info_t *)((uint8_t *)key_pair_id + sizeof(spdm_key_pair_id_t));
272 1 : key_usage_bit_mask = (spdm_key_usage_bit_mask_t *)((uint8_t *)cert_info +
273 : sizeof(spdm_certificate_info_t));
274 1 : *key_pair_id = 0;
275 1 : *cert_info = SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT;
276 1 : *key_usage_bit_mask = SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE |
277 : SPDM_KEY_USAGE_BIT_MASK_CHALLENGE_USE |
278 : SPDM_KEY_USAGE_BIT_MASK_MEASUREMENT_USE |
279 : SPDM_KEY_USAGE_BIT_MASK_ENDPOINT_INFO_USE;
280 :
281 1 : session_id = 0xFFFFFFFF;
282 1 : spdm_context->latest_session_id = session_id;
283 1 : spdm_context->last_spdm_request_session_id_valid = true;
284 1 : spdm_context->last_spdm_request_session_id = session_id;
285 1 : session_info = &spdm_context->session_info[0];
286 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
287 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
288 1 : libspdm_secured_message_set_session_state(
289 : session_info->secured_message_context,
290 : LIBSPDM_SESSION_STATE_ESTABLISHED);
291 :
292 : /* Sub Case 1: Set multi_key_conn_req to true*/
293 1 : spdm_context->connection_info.multi_key_conn_req = true;
294 1 : libspdm_reset_message_encap_d(session_info);
295 :
296 1 : spdm_response_size = sizeof(spdm_digest_response_t) + sizeof(spdm_key_pair_id_t) +
297 : sizeof(spdm_certificate_info_t) +
298 : sizeof(spdm_key_usage_bit_mask_t) +
299 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo);
300 :
301 1 : status = libspdm_process_encap_response_digest(spdm_context, spdm_response_size,
302 : spdm_response, &need_continue);
303 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
304 1 : assert_int_equal(session_info->session_transcript.message_encap_d.buffer_size,
305 : spdm_response_size);
306 :
307 : /* Sub Case 2: Set multi_key_conn_req to false*/
308 1 : spdm_context->connection_info.multi_key_conn_req = false;
309 1 : libspdm_reset_message_encap_d(session_info);
310 :
311 1 : spdm_response_size = sizeof(spdm_digest_response_t) + sizeof(spdm_key_pair_id_t) +
312 : sizeof(spdm_certificate_info_t) +
313 : sizeof(spdm_key_usage_bit_mask_t) +
314 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo);
315 1 : status = libspdm_process_encap_response_digest(spdm_context, spdm_response_size,
316 : spdm_response, &need_continue);
317 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
318 1 : assert_int_equal(session_info->session_transcript.message_encap_d.buffer_size, 0);
319 1 : }
320 :
321 : /**
322 : * Test 7: a response message is successfully sent ,
323 : * Check KeyPairID CertificateInfo and KeyUsageMask
324 : * Expected Behavior: requester returns the status LIBSPDM_STATUS_SUCCESS
325 : **/
326 1 : static void rsp_encap_get_digests_case7(void **state)
327 : {
328 : libspdm_return_t status;
329 : libspdm_test_context_t *spdm_test_context;
330 : libspdm_context_t *spdm_context;
331 : spdm_digest_response_t *spdm_response;
332 : uint8_t *digest;
333 : uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
334 : size_t spdm_response_size;
335 : bool need_continue;
336 : uint32_t session_id;
337 : libspdm_session_info_t *session_info;
338 : spdm_key_pair_id_t *key_pair_id;
339 : spdm_certificate_info_t *cert_info;
340 : spdm_key_usage_bit_mask_t *key_usage_bit_mask;
341 : uint32_t hash_size;
342 : uint8_t slot_count;
343 : size_t additional_size;
344 :
345 1 : spdm_test_context = *state;
346 1 : spdm_context = spdm_test_context->spdm_context;
347 1 : spdm_test_context->case_id = 0x7;
348 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
349 : SPDM_VERSION_NUMBER_SHIFT_BIT;
350 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
351 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP;
352 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
353 :
354 1 : libspdm_reset_message_b(spdm_context);
355 :
356 1 : spdm_response = (void *)temp_buf;
357 1 : libspdm_zero_mem(temp_buf, sizeof(temp_buf));
358 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
359 1 : spdm_response->header.request_response_code = SPDM_DIGESTS;
360 1 : spdm_response->header.param1 = 0;
361 1 : spdm_response->header.param2 = 0;
362 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
363 : sizeof(m_libspdm_local_certificate_chain),
364 : (uint8_t)(0xFF));
365 :
366 1 : slot_count = SPDM_MAX_SLOT_COUNT;
367 1 : additional_size = sizeof(spdm_key_pair_id_t) + sizeof(spdm_certificate_info_t) +
368 : sizeof(spdm_key_usage_bit_mask_t);
369 1 : hash_size = libspdm_get_hash_size(m_libspdm_use_hash_algo);
370 :
371 1 : digest = (void *)(spdm_response + 1);
372 1 : libspdm_zero_mem (digest, hash_size * slot_count);
373 1 : key_pair_id = (spdm_key_pair_id_t *)((uint8_t *)digest + (hash_size * slot_count));
374 1 : cert_info = (spdm_certificate_info_t *)((uint8_t *)key_pair_id +
375 1 : sizeof(spdm_key_pair_id_t) * slot_count);
376 1 : key_usage_bit_mask = (spdm_key_usage_bit_mask_t *)((uint8_t *)cert_info +
377 1 : sizeof(spdm_certificate_info_t) *
378 : slot_count);
379 :
380 9 : for (uint8_t index = 0; index < slot_count; index++)
381 : {
382 8 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
383 8 : sizeof(m_libspdm_local_certificate_chain), &digest[hash_size * index]);
384 :
385 8 : spdm_response->header.param1 |= (1 << index);
386 8 : spdm_response->header.param2 |= (1 << index);
387 : }
388 1 : key_pair_id[0] = 0x00;
389 1 : cert_info[0] = SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT;
390 1 : key_usage_bit_mask[0] = SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE;
391 :
392 1 : key_pair_id[1] = 0x01;
393 1 : cert_info[1] = SPDM_CERTIFICATE_INFO_CERT_MODEL_ALIAS_CERT;
394 1 : key_usage_bit_mask[1] = SPDM_KEY_USAGE_BIT_MASK_CHALLENGE_USE;
395 :
396 1 : key_pair_id[2] = 0x02;
397 1 : cert_info[2] = SPDM_CERTIFICATE_INFO_CERT_MODEL_GENERIC_CERT;
398 1 : key_usage_bit_mask[2] = SPDM_KEY_USAGE_BIT_MASK_MEASUREMENT_USE;
399 :
400 1 : key_pair_id[3] = 0x03;
401 1 : cert_info[3] = SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT;
402 1 : key_usage_bit_mask[3] = SPDM_KEY_USAGE_BIT_MASK_ENDPOINT_INFO_USE;
403 :
404 1 : key_pair_id[4] = 0x04;
405 1 : cert_info[4] = SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT;
406 1 : key_usage_bit_mask[4] = SPDM_KEY_USAGE_BIT_MASK_STANDARDS_KEY_USE;
407 :
408 1 : key_pair_id[5] = 0x05;
409 1 : cert_info[5] = SPDM_CERTIFICATE_INFO_CERT_MODEL_GENERIC_CERT;
410 1 : key_usage_bit_mask[5] = SPDM_KEY_USAGE_BIT_MASK_VENDOR_KEY_USE;
411 :
412 1 : key_pair_id[6] = 0x06;
413 1 : cert_info[6] = SPDM_CERTIFICATE_INFO_CERT_MODEL_GENERIC_CERT;
414 1 : key_usage_bit_mask[6] = SPDM_KEY_USAGE_BIT_MASK_VENDOR_KEY_USE;
415 :
416 1 : key_pair_id[7] = 0x07;
417 1 : cert_info[7] = SPDM_CERTIFICATE_INFO_CERT_MODEL_GENERIC_CERT;
418 1 : key_usage_bit_mask[7] = SPDM_KEY_USAGE_BIT_MASK_VENDOR_KEY_USE;
419 :
420 1 : session_id = 0xFFFFFFFF;
421 1 : spdm_context->latest_session_id = session_id;
422 1 : spdm_context->last_spdm_request_session_id_valid = true;
423 1 : spdm_context->last_spdm_request_session_id = session_id;
424 1 : session_info = &spdm_context->session_info[0];
425 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
426 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
427 1 : libspdm_secured_message_set_session_state(
428 : session_info->secured_message_context,
429 : LIBSPDM_SESSION_STATE_ESTABLISHED);
430 :
431 1 : spdm_context->connection_info.multi_key_conn_req = true;
432 1 : libspdm_reset_message_encap_d(session_info);
433 :
434 1 : spdm_response_size = sizeof(spdm_digest_response_t) +
435 1 : (hash_size + additional_size) * slot_count;
436 :
437 1 : status = libspdm_process_encap_response_digest(spdm_context, spdm_response_size,
438 : spdm_response, &need_continue);
439 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
440 1 : assert_int_equal(session_info->session_transcript.message_encap_d.buffer_size,
441 : spdm_response_size);
442 :
443 9 : for (uint8_t index = 0; index < SPDM_MAX_SLOT_COUNT; index++) {
444 8 : assert_memory_equal((void *)&key_pair_id[index],
445 : (void *)&spdm_context->connection_info.peer_key_pair_id[index],
446 : sizeof(spdm_key_pair_id_t));
447 8 : assert_memory_equal((void *)&cert_info[index],
448 : (void *)&spdm_context->connection_info.peer_cert_info[index],
449 : sizeof(spdm_certificate_info_t));
450 8 : assert_memory_equal((void *)&key_usage_bit_mask[index],
451 : (void *)&spdm_context->connection_info.peer_key_usage_bit_mask[index],
452 : sizeof(spdm_key_usage_bit_mask_t));
453 : }
454 1 : }
455 :
456 1 : int spdm_rsp_encap_get_digests_test(void)
457 : {
458 1 : const struct CMUnitTest test_cases[] = {
459 : /* Success Case*/
460 : cmocka_unit_test(rsp_encap_get_digests_case1),
461 : /* Error response: SPDM_ERROR*/
462 : cmocka_unit_test(rsp_encap_get_digests_case2),
463 : /* Error response: RETURN_DEVICE_ERROR*/
464 : cmocka_unit_test(rsp_encap_get_digests_case3),
465 : /* request_response_code wrong in response*/
466 : cmocka_unit_test(rsp_encap_get_digests_case4),
467 : /* capability flags check failed*/
468 : cmocka_unit_test(rsp_encap_get_digests_case5),
469 : /* Set multi_key_conn_req to check if it responds correctly */
470 : cmocka_unit_test(rsp_encap_get_digests_case6),
471 : /* Check KeyPairID CertificateInfo and KeyUsageMask*/
472 : cmocka_unit_test(rsp_encap_get_digests_case7),
473 : };
474 :
475 1 : libspdm_test_context_t test_context = {
476 : LIBSPDM_TEST_CONTEXT_VERSION,
477 : false,
478 : };
479 :
480 1 : libspdm_setup_test_context(&test_context);
481 :
482 1 : return cmocka_run_group_tests(test_cases,
483 : libspdm_unit_test_group_setup,
484 : libspdm_unit_test_group_teardown);
485 : }
486 :
487 : #endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (...) */
|
