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_CHALLENGE_SUPPORT)
12 :
13 : static uint8_t m_requester_context[SPDM_REQ_CONTEXT_SIZE];
14 :
15 1 : void libspdm_test_responder_encap_challenge_case1(void **state)
16 : {
17 : libspdm_return_t status;
18 : libspdm_test_context_t *spdm_test_context;
19 : libspdm_context_t *spdm_context;
20 : spdm_challenge_auth_response_t *spdm_response;
21 : uint8_t temp_buf[LIBSPDM_SENDER_BUFFER_SIZE];
22 : uint8_t *ptr;
23 : size_t response_size;
24 : size_t sig_size;
25 : bool need_continue;
26 : void *data;
27 : size_t data_size;
28 :
29 1 : spdm_test_context = *state;
30 1 : spdm_context = spdm_test_context->spdm_context;
31 :
32 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
33 : SPDM_VERSION_NUMBER_SHIFT_BIT;
34 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
35 1 : spdm_context->connection_info.capability.flags = 0;
36 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
37 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
38 1 : spdm_context->connection_info.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
39 1 : libspdm_read_requester_public_certificate_chain(m_libspdm_use_hash_algo,
40 : m_libspdm_use_req_asym_algo, &data,
41 : &data_size,
42 : NULL, NULL);
43 1 : libspdm_reset_message_mut_c(spdm_context);
44 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
45 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
46 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
47 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
48 : data, data_size);
49 : #else
50 1 : libspdm_hash_all(
51 : spdm_context->connection_info.algorithm.base_hash_algo,
52 : data, data_size,
53 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
54 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
55 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
56 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
57 : spdm_context->connection_info.algorithm.base_hash_algo,
58 1 : spdm_context->connection_info.algorithm.req_base_asym_alg,
59 : data, data_size,
60 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
61 : #endif
62 1 : spdm_context->encap_context.req_slot_id = 0;
63 :
64 1 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_req_asym_algo);
65 1 : response_size = sizeof(spdm_challenge_auth_response_t) +
66 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo) +
67 1 : SPDM_NONCE_SIZE + 0 + sizeof(uint16_t) + 0 + sig_size;
68 1 : spdm_response = (void *)temp_buf;
69 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
70 1 : spdm_response->header.request_response_code = SPDM_CHALLENGE_AUTH;
71 1 : spdm_response->header.param1 = 0;
72 1 : spdm_response->header.param2 = (1 << 0);
73 :
74 1 : ptr = (void *)(spdm_response + 1);
75 1 : libspdm_hash_all(m_libspdm_use_hash_algo, data, data_size, ptr);
76 1 : ptr += libspdm_get_hash_size(m_libspdm_use_hash_algo);
77 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
78 1 : ptr += SPDM_NONCE_SIZE;
79 :
80 1 : *(uint16_t *)ptr = 0;
81 1 : ptr += sizeof(uint16_t);
82 :
83 1 : libspdm_requester_data_sign(
84 : spdm_context,
85 1 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
86 : SPDM_CHALLENGE_AUTH,
87 : m_libspdm_use_req_asym_algo, m_libspdm_use_req_pqc_asym_algo, m_libspdm_use_hash_algo,
88 : false, (uint8_t*)spdm_response, response_size - sig_size,
89 : ptr, &sig_size);
90 :
91 1 : status = libspdm_process_encap_response_challenge_auth(spdm_context, response_size,
92 : spdm_response,
93 : &need_continue);
94 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
95 : /* Completion of CHALLENGE sets M1/M2 to null. */
96 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
97 : assert_int_equal(spdm_context->transcript.message_mut_c.buffer_size, 0);
98 : #else
99 1 : assert_null(spdm_context->transcript.digest_context_mut_m1m2);
100 : #endif
101 1 : free(data);
102 1 : }
103 :
104 1 : void libspdm_test_responder_encap_challenge_case2(void **state)
105 : {
106 : libspdm_return_t status;
107 : libspdm_test_context_t *spdm_test_context;
108 : libspdm_context_t *spdm_context;
109 : spdm_error_response_t *spdm_response;
110 : uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
111 : size_t response_size;
112 : void *data;
113 : size_t data_size;
114 :
115 1 : spdm_test_context = *state;
116 1 : spdm_context = spdm_test_context->spdm_context;
117 :
118 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
119 1 : spdm_context->connection_info.capability.flags = 0;
120 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
121 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
122 : m_libspdm_use_asym_algo, &data,
123 : &data_size,
124 : NULL, NULL);
125 1 : libspdm_reset_message_a(spdm_context);
126 1 : libspdm_reset_message_b(spdm_context);
127 1 : libspdm_reset_message_c(spdm_context);
128 :
129 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
130 1 : spdm_context->connection_info.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
131 :
132 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
133 : SPDM_VERSION_NUMBER_SHIFT_BIT;
134 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
135 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
136 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
137 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
138 : data, data_size);
139 : #else
140 1 : libspdm_hash_all(
141 : spdm_context->connection_info.algorithm.base_hash_algo,
142 : data, data_size,
143 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
144 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
145 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
146 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
147 : spdm_context->connection_info.algorithm.base_hash_algo,
148 1 : spdm_context->connection_info.algorithm.req_base_asym_alg,
149 : data, data_size,
150 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
151 : #endif
152 1 : spdm_context->encap_context.req_slot_id = 0;
153 :
154 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
155 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
156 :
157 1 : response_size = sizeof(spdm_error_response_t);
158 1 : spdm_response = (void *)temp_buf;
159 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
160 1 : spdm_response->header.request_response_code = SPDM_ERROR;
161 1 : spdm_response->header.param1 = 0;
162 1 : spdm_response->header.param2 = 0;
163 :
164 1 : status = libspdm_process_encap_response_challenge_auth(spdm_context, response_size,
165 : spdm_response,
166 : NULL);
167 1 : assert_int_equal(status, LIBSPDM_STATUS_UNSUPPORTED_CAP);
168 1 : free(data);
169 1 : }
170 :
171 :
172 1 : void libspdm_test_responder_encap_challenge_case3(void **state)
173 : {
174 : libspdm_return_t status;
175 : libspdm_test_context_t *spdm_test_context;
176 : libspdm_context_t *spdm_context;
177 : spdm_challenge_auth_response_t *spdm_response;
178 : uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
179 : size_t response_size;
180 : void *data;
181 : size_t data_size;
182 :
183 1 : spdm_test_context = *state;
184 1 : spdm_context = spdm_test_context->spdm_context;
185 :
186 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
187 1 : spdm_context->connection_info.capability.flags = 0;
188 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
189 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
190 : m_libspdm_use_asym_algo, &data,
191 : &data_size,
192 : NULL, NULL);
193 1 : libspdm_reset_message_a(spdm_context);
194 1 : libspdm_reset_message_b(spdm_context);
195 1 : libspdm_reset_message_c(spdm_context);
196 :
197 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
198 1 : spdm_context->connection_info.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
199 :
200 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
201 : SPDM_VERSION_NUMBER_SHIFT_BIT;
202 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
203 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
204 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
205 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
206 : data, data_size);
207 : #else
208 1 : libspdm_hash_all(
209 : spdm_context->connection_info.algorithm.base_hash_algo,
210 : data, data_size,
211 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
212 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
213 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
214 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
215 : spdm_context->connection_info.algorithm.base_hash_algo,
216 1 : spdm_context->connection_info.algorithm.req_base_asym_alg,
217 : data, data_size,
218 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
219 : #endif
220 1 : spdm_context->encap_context.req_slot_id = 0;
221 :
222 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
223 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
224 :
225 1 : response_size = sizeof(spdm_error_response_t);
226 1 : spdm_response = (void *)temp_buf;
227 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
228 1 : spdm_response->header.request_response_code = SPDM_CERTIFICATE;
229 1 : spdm_response->header.param1 = 0;
230 1 : spdm_response->header.param2 = 0;
231 :
232 1 : status = libspdm_process_encap_response_challenge_auth(spdm_context, response_size,
233 : spdm_response,
234 : NULL);
235 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
236 1 : free(data);
237 1 : }
238 :
239 1 : void libspdm_test_responder_encap_challenge_case4(void **state)
240 : {
241 : libspdm_return_t status;
242 : libspdm_test_context_t *spdm_test_context;
243 : libspdm_context_t *spdm_context;
244 : spdm_challenge_auth_response_t *spdm_response;
245 : uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
246 : size_t response_size;
247 : void *data;
248 : size_t data_size;
249 :
250 1 : spdm_test_context = *state;
251 1 : spdm_context = spdm_test_context->spdm_context;
252 :
253 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
254 1 : spdm_context->connection_info.capability.flags = 0;
255 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
256 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
257 : m_libspdm_use_asym_algo, &data,
258 : &data_size,
259 : NULL, NULL);
260 1 : libspdm_reset_message_a(spdm_context);
261 1 : libspdm_reset_message_b(spdm_context);
262 1 : libspdm_reset_message_c(spdm_context);
263 :
264 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
265 1 : spdm_context->connection_info.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
266 :
267 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
268 : SPDM_VERSION_NUMBER_SHIFT_BIT;
269 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
270 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
271 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
272 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
273 : data, data_size);
274 : #else
275 1 : libspdm_hash_all(
276 : spdm_context->connection_info.algorithm.base_hash_algo,
277 : data, data_size,
278 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
279 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
280 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
281 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
282 : spdm_context->connection_info.algorithm.base_hash_algo,
283 1 : spdm_context->connection_info.algorithm.req_base_asym_alg,
284 : data, data_size,
285 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
286 : #endif
287 1 : spdm_context->encap_context.req_slot_id = 0;
288 :
289 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size;
290 1 : spdm_context->local_context.local_cert_chain_provision[0] = data;
291 :
292 1 : response_size = sizeof(spdm_error_response_t);
293 1 : spdm_response = (void *)temp_buf;
294 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
295 1 : spdm_response->header.request_response_code = SPDM_CHALLENGE_AUTH;
296 1 : spdm_response->header.param1 = 0;
297 1 : spdm_response->header.param2 = 0;
298 :
299 1 : status = libspdm_process_encap_response_challenge_auth(spdm_context, response_size,
300 : spdm_response,
301 : NULL);
302 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
303 1 : free(data);
304 1 : }
305 :
306 1 : void libspdm_test_responder_encap_challenge_case5(void **state)
307 : {
308 : libspdm_return_t status;
309 : libspdm_test_context_t *spdm_test_context;
310 : libspdm_context_t *spdm_context;
311 : spdm_challenge_auth_response_t *spdm_response;
312 : uint8_t temp_buf[LIBSPDM_MAX_SPDM_MSG_SIZE];
313 : size_t response_size;
314 : size_t sig_size;
315 : uint8_t *ptr;
316 : bool need_continue;
317 : void *data;
318 : size_t data_size;
319 :
320 1 : spdm_test_context = *state;
321 1 : spdm_context = spdm_test_context->spdm_context;
322 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
323 : SPDM_VERSION_NUMBER_SHIFT_BIT;
324 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
325 1 : spdm_context->connection_info.capability.flags = 0;
326 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
327 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
328 1 : spdm_context->connection_info.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
329 :
330 1 : libspdm_read_requester_public_key(m_libspdm_use_req_asym_algo, &data, &data_size);
331 1 : spdm_context->local_context.peer_public_key_provision = data;
332 1 : spdm_context->local_context.peer_public_key_provision_size = data_size;
333 :
334 1 : spdm_context->encap_context.req_slot_id = 0xFF;
335 :
336 1 : libspdm_reset_message_a(spdm_context);
337 1 : libspdm_reset_message_b(spdm_context);
338 1 : libspdm_reset_message_c(spdm_context);
339 :
340 1 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_req_asym_algo);
341 1 : response_size = sizeof(spdm_challenge_auth_response_t) +
342 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo) +
343 1 : SPDM_NONCE_SIZE + 0 + sizeof(uint16_t) + 0 + sig_size;
344 1 : spdm_response = (void *)temp_buf;
345 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
346 1 : spdm_response->header.request_response_code = SPDM_CHALLENGE_AUTH;
347 1 : spdm_response->header.param1 = (0xFF & SPDM_CHALLENGE_AUTH_RESPONSE_ATTRIBUTE_SLOT_ID_MASK);
348 1 : spdm_response->header.param2 = 0;
349 :
350 1 : ptr = (void *)(spdm_response + 1);
351 1 : libspdm_hash_all(m_libspdm_use_hash_algo, data, data_size, ptr);
352 1 : ptr += libspdm_get_hash_size(m_libspdm_use_hash_algo);
353 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
354 1 : ptr += SPDM_NONCE_SIZE;
355 :
356 1 : *(uint16_t *)ptr = 0;
357 1 : ptr += sizeof(uint16_t);
358 :
359 1 : libspdm_requester_data_sign(
360 : spdm_context,
361 1 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
362 : SPDM_CHALLENGE_AUTH,
363 : m_libspdm_use_req_asym_algo, m_libspdm_use_req_pqc_asym_algo, m_libspdm_use_hash_algo,
364 : false, (uint8_t*)spdm_response, response_size - sig_size,
365 : ptr, &sig_size);
366 :
367 1 : status = libspdm_process_encap_response_challenge_auth(spdm_context, response_size,
368 : spdm_response,
369 : &need_continue);
370 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
371 1 : free(data);
372 1 : }
373 :
374 : /**
375 : * Test 6: Successful case , With the correct challenge context field
376 : * Expected Behavior: client returns a status of RETURN_SUCCESS.
377 : **/
378 1 : void libspdm_test_responder_encap_challenge_case6(void **state)
379 : {
380 : libspdm_return_t status;
381 : libspdm_test_context_t *spdm_test_context;
382 : libspdm_context_t *spdm_context;
383 : spdm_challenge_auth_response_t *spdm_response;
384 : uint8_t temp_buf[LIBSPDM_SENDER_BUFFER_SIZE];
385 : uint8_t *ptr;
386 : size_t response_size;
387 : size_t sig_size;
388 : bool need_continue;
389 : void *data;
390 : size_t data_size;
391 :
392 1 : spdm_test_context = *state;
393 1 : spdm_context = spdm_test_context->spdm_context;
394 :
395 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
396 : SPDM_VERSION_NUMBER_SHIFT_BIT;
397 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
398 1 : spdm_context->connection_info.capability.flags = 0;
399 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
400 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
401 1 : spdm_context->connection_info.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
402 1 : libspdm_read_requester_public_certificate_chain(m_libspdm_use_hash_algo,
403 : m_libspdm_use_req_asym_algo, &data,
404 : &data_size,
405 : NULL, NULL);
406 1 : libspdm_reset_message_mut_c(spdm_context);
407 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
408 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = data_size;
409 : libspdm_copy_mem(spdm_context->connection_info.peer_used_cert_chain[0].buffer,
410 : sizeof(spdm_context->connection_info.peer_used_cert_chain[0].buffer),
411 : data, data_size);
412 : #else
413 1 : libspdm_hash_all(
414 : spdm_context->connection_info.algorithm.base_hash_algo,
415 : data, data_size,
416 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash);
417 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size =
418 1 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo);
419 1 : libspdm_get_leaf_cert_public_key_from_cert_chain(
420 : spdm_context->connection_info.algorithm.base_hash_algo,
421 1 : spdm_context->connection_info.algorithm.req_base_asym_alg,
422 : data, data_size,
423 : &spdm_context->connection_info.peer_used_cert_chain[0].leaf_cert_public_key);
424 : #endif
425 1 : spdm_context->encap_context.req_slot_id = 0;
426 1 : libspdm_set_mem(m_requester_context, SPDM_REQ_CONTEXT_SIZE, 0xAA);
427 1 : libspdm_copy_mem(spdm_context->encap_context.req_context, SPDM_REQ_CONTEXT_SIZE,
428 : m_requester_context, SPDM_REQ_CONTEXT_SIZE);
429 :
430 :
431 1 : sig_size = libspdm_get_asym_signature_size(m_libspdm_use_req_asym_algo);
432 1 : response_size = sizeof(spdm_challenge_auth_response_t) +
433 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo) +
434 1 : SPDM_NONCE_SIZE + 0 + sizeof(uint16_t) + 0 + SPDM_REQ_CONTEXT_SIZE + sig_size;
435 1 : spdm_response = (void *)temp_buf;
436 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
437 1 : spdm_response->header.request_response_code = SPDM_CHALLENGE_AUTH;
438 1 : spdm_response->header.param1 = 0;
439 1 : spdm_response->header.param2 = (1 << 0);
440 :
441 1 : ptr = (void *)(spdm_response + 1);
442 1 : libspdm_hash_all(m_libspdm_use_hash_algo, data, data_size, ptr);
443 1 : ptr += libspdm_get_hash_size(m_libspdm_use_hash_algo);
444 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, ptr);
445 1 : ptr += SPDM_NONCE_SIZE;
446 :
447 1 : *(uint16_t *)ptr = 0;
448 1 : ptr += sizeof(uint16_t);
449 :
450 1 : libspdm_set_mem(ptr, SPDM_REQ_CONTEXT_SIZE, 0xAA);
451 1 : ptr += SPDM_REQ_CONTEXT_SIZE;
452 :
453 1 : libspdm_requester_data_sign(
454 : spdm_context,
455 1 : spdm_response->header.spdm_version << SPDM_VERSION_NUMBER_SHIFT_BIT,
456 : SPDM_CHALLENGE_AUTH,
457 : m_libspdm_use_req_asym_algo, m_libspdm_use_req_pqc_asym_algo, m_libspdm_use_hash_algo,
458 : false, (uint8_t*)spdm_response, response_size - sig_size,
459 : ptr, &sig_size);
460 :
461 1 : status = libspdm_process_encap_response_challenge_auth(spdm_context, response_size,
462 : spdm_response,
463 : &need_continue);
464 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
465 :
466 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
467 : assert_int_equal(spdm_context->transcript.message_mut_c.buffer_size, 0);
468 : #else
469 1 : assert_null(spdm_context->transcript.digest_context_mut_m1m2);
470 : #endif
471 1 : free(data);
472 1 : }
473 :
474 1 : int libspdm_responder_encap_challenge_auth_test_main(void)
475 : {
476 1 : const struct CMUnitTest spdm_responder_challenge_tests[] = {
477 : cmocka_unit_test(libspdm_test_responder_encap_challenge_case1),
478 : /* Error response: SPDM_ERROR*/
479 : cmocka_unit_test(libspdm_test_responder_encap_challenge_case2),
480 : /* Error request_response_code : SPDM_CERTIFICATE */
481 : cmocka_unit_test(libspdm_test_responder_encap_challenge_case3),
482 : /* Error spdm_response_size */
483 : cmocka_unit_test(libspdm_test_responder_encap_challenge_case4),
484 : /* Success Case, use provisioned public key (slot 0xFF) */
485 : cmocka_unit_test(libspdm_test_responder_encap_challenge_case5),
486 : /* Success Case, V1.3 With the correct challenge context field */
487 : cmocka_unit_test(libspdm_test_responder_encap_challenge_case6),
488 : };
489 :
490 1 : libspdm_test_context_t test_context = {
491 : LIBSPDM_TEST_CONTEXT_VERSION,
492 : false,
493 : };
494 :
495 1 : libspdm_setup_test_context(&test_context);
496 :
497 1 : return cmocka_run_group_tests(spdm_responder_challenge_tests,
498 : libspdm_unit_test_group_setup,
499 : libspdm_unit_test_group_teardown);
500 : }
501 :
502 : #endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) && (...) */
|
