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