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_CHAL_CAP
11 :
12 : extern uint64_t g_challenge_request_context;
13 : extern bool g_check_challenge_request_context;
14 :
15 : spdm_challenge_request_t m_libspdm_challenge_request1 = {
16 : { SPDM_MESSAGE_VERSION_11, SPDM_CHALLENGE, 0,
17 : SPDM_CHALLENGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH },
18 : };
19 : size_t m_libspdm_challenge_request1_size = sizeof(m_libspdm_challenge_request1);
20 :
21 : spdm_challenge_request_t m_libspdm_challenge_request3 = {
22 : { SPDM_MESSAGE_VERSION_11, SPDM_CHALLENGE, SPDM_MAX_SLOT_COUNT,
23 : SPDM_CHALLENGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH },
24 : };
25 : size_t m_libspdm_challenge_request3_size = sizeof(m_libspdm_challenge_request3);
26 :
27 : spdm_challenge_request_t m_libspdm_challenge_request4 = {
28 : { SPDM_MESSAGE_VERSION_11, SPDM_CHALLENGE, 1,
29 : SPDM_CHALLENGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH },
30 : };
31 : size_t m_libspdm_challenge_request4_size = sizeof(m_libspdm_challenge_request4);
32 :
33 : spdm_challenge_request_t m_libspdm_challenge_request5 = {
34 : { SPDM_MESSAGE_VERSION_11, SPDM_CHALLENGE, 0,
35 : SPDM_CHALLENGE_REQUEST_TCB_COMPONENT_MEASUREMENT_HASH },
36 : };
37 : size_t m_libspdm_challenge_request5_size = sizeof(m_libspdm_challenge_request5);
38 :
39 : spdm_challenge_request_t m_libspdm_challenge_request6 = {
40 : { SPDM_MESSAGE_VERSION_11, SPDM_CHALLENGE, 0,
41 : SPDM_CHALLENGE_REQUEST_ALL_MEASUREMENTS_HASH },
42 : };
43 : size_t m_libspdm_challenge_request6_size = sizeof(m_libspdm_challenge_request6);
44 :
45 : spdm_challenge_request_t m_libspdm_challenge_request7 = {
46 : { SPDM_MESSAGE_VERSION_11, SPDM_CHALLENGE, 0xFF,
47 : SPDM_CHALLENGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH },
48 : };
49 : size_t m_libspdm_challenge_request7_size = sizeof(m_libspdm_challenge_request7);
50 :
51 : spdm_challenge_request_t m_libspdm_challenge_request8 = {
52 : {SPDM_MESSAGE_VERSION_13, SPDM_CHALLENGE, 0,
53 : SPDM_CHALLENGE_REQUEST_NO_MEASUREMENT_SUMMARY_HASH},
54 : };
55 : size_t m_libspdm_challenge_request8_size = sizeof(m_libspdm_challenge_request8);
56 :
57 : extern size_t libspdm_secret_lib_challenge_opaque_data_size;
58 :
59 : /**
60 : * Test 1: receiving a correct CHALLENGE message from the requester with
61 : * no opaque data, no measurements, and slot number 0.
62 : * Expected behavior: the responder accepts the request and produces a valid
63 : * CHALLENGE_AUTH response message.
64 : **/
65 1 : static void rsp_challenge_auth_case1(void **state)
66 : {
67 : libspdm_return_t status;
68 : libspdm_test_context_t *spdm_test_context;
69 : libspdm_context_t *spdm_context;
70 : size_t response_size;
71 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
72 : spdm_challenge_auth_response_t *spdm_response;
73 : void *data1;
74 : size_t data_size1;
75 :
76 1 : spdm_test_context = *state;
77 1 : spdm_context = spdm_test_context->spdm_context;
78 1 : spdm_test_context->case_id = 0x1;
79 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
80 1 : spdm_context->local_context.capability.flags = 0;
81 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
82 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
83 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
84 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
85 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
86 : m_libspdm_use_measurement_hash_algo;
87 :
88 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
89 : SPDM_VERSION_NUMBER_SHIFT_BIT;
90 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
91 : m_libspdm_use_asym_algo, &data1,
92 : &data_size1, NULL, NULL);
93 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
94 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
95 :
96 1 : libspdm_secret_lib_challenge_opaque_data_size = 0;
97 1 : libspdm_reset_message_c(spdm_context);
98 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
99 : spdm_context->transcript.message_m.buffer_size =
100 : spdm_context->transcript.message_m.max_buffer_size;
101 : #endif
102 :
103 1 : response_size = sizeof(response);
104 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_challenge_request1.nonce);
105 1 : status = libspdm_get_response_challenge_auth(
106 : spdm_context, m_libspdm_challenge_request1_size,
107 : &m_libspdm_challenge_request1, &response_size, response);
108 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
109 1 : assert_int_equal(response_size,
110 : sizeof(spdm_challenge_auth_response_t) +
111 : libspdm_get_hash_size(m_libspdm_use_hash_algo) +
112 : SPDM_NONCE_SIZE + 0 + sizeof(uint16_t) + 0 +
113 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo));
114 1 : spdm_response = (void *)response;
115 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_CHALLENGE_AUTH);
116 1 : assert_int_equal(spdm_response->header.param1, 0);
117 1 : assert_int_equal(spdm_response->header.param2, 1 << 0);
118 : /* Completion of CHALLENGE sets M1/M2 to null. */
119 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
120 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
121 : assert_int_equal(spdm_context->transcript.message_c.buffer_size, 0);
122 : #else
123 1 : assert_null(spdm_context->transcript.digest_context_m1m2);
124 : #endif
125 1 : free(data1);
126 1 : }
127 :
128 : /**
129 : * Test 2:
130 : * Expected behavior:
131 : **/
132 1 : static void rsp_challenge_auth_case2(void **state)
133 : {
134 1 : }
135 :
136 : /**
137 : * Test 3: receiving a correct CHALLENGE from the requester, but the responder is in
138 : * a Busy state.
139 : * Expected behavior: the responder accepts the request, but produces an ERROR message
140 : * indicating the Busy state.
141 : **/
142 1 : static void rsp_challenge_auth_case3(void **state)
143 : {
144 : libspdm_return_t status;
145 : libspdm_test_context_t *spdm_test_context;
146 : libspdm_context_t *spdm_context;
147 : size_t response_size;
148 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
149 : spdm_challenge_auth_response_t *spdm_response;
150 : void *data1;
151 : size_t data_size1;
152 :
153 1 : spdm_test_context = *state;
154 1 : spdm_context = spdm_test_context->spdm_context;
155 1 : spdm_test_context->case_id = 0x3;
156 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_BUSY;
157 1 : spdm_context->connection_info.connection_state =
158 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
159 1 : spdm_context->local_context.capability.flags = 0;
160 1 : spdm_context->local_context.capability.flags |=
161 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
162 1 : spdm_context->connection_info.algorithm.base_hash_algo =
163 : m_libspdm_use_hash_algo;
164 1 : spdm_context->connection_info.algorithm.base_asym_algo =
165 : m_libspdm_use_asym_algo;
166 1 : spdm_context->connection_info.algorithm.measurement_spec =
167 : m_libspdm_use_measurement_spec;
168 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
169 : m_libspdm_use_measurement_hash_algo;
170 :
171 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
172 : SPDM_VERSION_NUMBER_SHIFT_BIT;
173 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
174 : m_libspdm_use_asym_algo, &data1,
175 : &data_size1, NULL, NULL);
176 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
177 1 : spdm_context->local_context.local_cert_chain_provision_size[0] =
178 : data_size1;
179 :
180 1 : libspdm_secret_lib_challenge_opaque_data_size = 0;
181 1 : libspdm_reset_message_c(spdm_context);
182 :
183 1 : response_size = sizeof(response);
184 1 : libspdm_get_random_number(SPDM_NONCE_SIZE,
185 : m_libspdm_challenge_request1.nonce);
186 1 : status = libspdm_get_response_challenge_auth(
187 : spdm_context, m_libspdm_challenge_request1_size,
188 : &m_libspdm_challenge_request1, &response_size, response);
189 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
190 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
191 1 : spdm_response = (void *)response;
192 1 : assert_int_equal(spdm_response->header.request_response_code,
193 : SPDM_ERROR);
194 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_BUSY);
195 1 : assert_int_equal(spdm_response->header.param2, 0);
196 1 : assert_int_equal(spdm_context->response_state,
197 : LIBSPDM_RESPONSE_STATE_BUSY);
198 1 : free(data1);
199 1 : }
200 :
201 : /**
202 : * Test 4: receiving a correct CHALLENGE from the requester, but the responder requires
203 : * resynchronization with the requester.
204 : * Expected behavior: the responder accepts the request, but produces an ERROR message
205 : * indicating the NeedResynch state.
206 : **/
207 1 : static void rsp_challenge_auth_case4(void **state)
208 : {
209 : libspdm_return_t status;
210 : libspdm_test_context_t *spdm_test_context;
211 : libspdm_context_t *spdm_context;
212 : size_t response_size;
213 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
214 : spdm_challenge_auth_response_t *spdm_response;
215 : void *data1;
216 : size_t data_size1;
217 :
218 1 : spdm_test_context = *state;
219 1 : spdm_context = spdm_test_context->spdm_context;
220 1 : spdm_test_context->case_id = 0x4;
221 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NEED_RESYNC;
222 1 : spdm_context->connection_info.connection_state =
223 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
224 1 : spdm_context->local_context.capability.flags = 0;
225 1 : spdm_context->local_context.capability.flags |=
226 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
227 1 : spdm_context->connection_info.algorithm.base_hash_algo =
228 : m_libspdm_use_hash_algo;
229 1 : spdm_context->connection_info.algorithm.base_asym_algo =
230 : m_libspdm_use_asym_algo;
231 1 : spdm_context->connection_info.algorithm.measurement_spec =
232 : m_libspdm_use_measurement_spec;
233 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
234 : m_libspdm_use_measurement_hash_algo;
235 :
236 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
237 : SPDM_VERSION_NUMBER_SHIFT_BIT;
238 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
239 : m_libspdm_use_asym_algo, &data1,
240 : &data_size1, NULL, NULL);
241 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
242 1 : spdm_context->local_context.local_cert_chain_provision_size[0] =
243 : data_size1;
244 :
245 1 : libspdm_secret_lib_challenge_opaque_data_size = 0;
246 1 : libspdm_reset_message_c(spdm_context);
247 :
248 1 : response_size = sizeof(response);
249 1 : libspdm_get_random_number(SPDM_NONCE_SIZE,
250 : m_libspdm_challenge_request1.nonce);
251 1 : status = libspdm_get_response_challenge_auth(
252 : spdm_context, m_libspdm_challenge_request1_size,
253 : &m_libspdm_challenge_request1, &response_size, response);
254 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
255 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
256 1 : spdm_response = (void *)response;
257 1 : assert_int_equal(spdm_response->header.request_response_code,
258 : SPDM_ERROR);
259 1 : assert_int_equal(spdm_response->header.param1,
260 : SPDM_ERROR_CODE_REQUEST_RESYNCH);
261 1 : assert_int_equal(spdm_response->header.param2, 0);
262 1 : assert_int_equal(spdm_context->response_state,
263 : LIBSPDM_RESPONSE_STATE_NEED_RESYNC);
264 1 : free(data1);
265 1 : }
266 :
267 : #if LIBSPDM_RESPOND_IF_READY_SUPPORT
268 : /**
269 : * Test 5: receiving a correct CHALLENGE from the requester, but the responder could not
270 : * produce the response in time.
271 : * Expected behavior: the responder accepts the request, but produces an ERROR message
272 : * indicating the ResponseNotReady state.
273 : **/
274 1 : static void rsp_challenge_auth_case5(void **state)
275 : {
276 : libspdm_return_t status;
277 : libspdm_test_context_t *spdm_test_context;
278 : libspdm_context_t *spdm_context;
279 : size_t response_size;
280 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
281 : spdm_challenge_auth_response_t *spdm_response;
282 : void *data1;
283 : size_t data_size1;
284 : spdm_error_data_response_not_ready_t *error_data;
285 :
286 1 : spdm_test_context = *state;
287 1 : spdm_context = spdm_test_context->spdm_context;
288 1 : spdm_test_context->case_id = 0x5;
289 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NOT_READY;
290 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
291 1 : spdm_context->local_context.capability.flags = 0;
292 1 : spdm_context->local_context.capability.flags |=
293 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
294 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
295 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
296 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
297 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
298 : m_libspdm_use_measurement_hash_algo;
299 :
300 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
301 : SPDM_VERSION_NUMBER_SHIFT_BIT;
302 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
303 : m_libspdm_use_asym_algo, &data1,
304 : &data_size1, NULL, NULL);
305 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
306 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
307 :
308 1 : libspdm_secret_lib_challenge_opaque_data_size = 0;
309 1 : libspdm_reset_message_c(spdm_context);
310 :
311 1 : response_size = sizeof(response);
312 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_challenge_request1.nonce);
313 1 : status = libspdm_get_response_challenge_auth(
314 : spdm_context, m_libspdm_challenge_request1_size,
315 : &m_libspdm_challenge_request1, &response_size, response);
316 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
317 1 : assert_int_equal(response_size,
318 : sizeof(spdm_error_response_t) +
319 : sizeof(spdm_error_data_response_not_ready_t));
320 1 : spdm_response = (void *)response;
321 1 : error_data = (spdm_error_data_response_not_ready_t *)(spdm_response + 1);
322 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
323 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_RESPONSE_NOT_READY);
324 1 : assert_int_equal(spdm_response->header.param2, 0);
325 1 : assert_int_equal(spdm_context->response_state, LIBSPDM_RESPONSE_STATE_NOT_READY);
326 1 : assert_int_equal(error_data->request_code, SPDM_CHALLENGE);
327 1 : free(data1);
328 1 : }
329 : #endif /* LIBSPDM_RESPOND_IF_READY_SUPPORT */
330 :
331 : /**
332 : * Test 6: receiving a correct CHALLENGE from the requester, but the responder is not set
333 : * no receive a CHALLENGE message because previous messages (namely, GET_CAPABILITIES,
334 : * NEGOTIATE_ALGORITHMS or GET_DIGESTS) have not been received.
335 : * Expected behavior: the responder rejects the request, and produces an ERROR message
336 : * indicating the UnexpectedRequest.
337 : **/
338 1 : static void rsp_challenge_auth_case6(void **state)
339 : {
340 : libspdm_return_t status;
341 : libspdm_test_context_t *spdm_test_context;
342 : libspdm_context_t *spdm_context;
343 : size_t response_size;
344 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
345 : spdm_challenge_auth_response_t *spdm_response;
346 : void *data1;
347 : size_t data_size1;
348 :
349 1 : spdm_test_context = *state;
350 1 : spdm_context = spdm_test_context->spdm_context;
351 1 : spdm_test_context->case_id = 0x6;
352 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
353 1 : spdm_context->connection_info.connection_state =
354 : LIBSPDM_CONNECTION_STATE_NOT_STARTED;
355 1 : spdm_context->local_context.capability.flags = 0;
356 1 : spdm_context->local_context.capability.flags |=
357 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
358 1 : spdm_context->connection_info.algorithm.base_hash_algo =
359 : m_libspdm_use_hash_algo;
360 1 : spdm_context->connection_info.algorithm.base_asym_algo =
361 : m_libspdm_use_asym_algo;
362 1 : spdm_context->connection_info.algorithm.measurement_spec =
363 : m_libspdm_use_measurement_spec;
364 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
365 : m_libspdm_use_measurement_hash_algo;
366 :
367 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
368 : SPDM_VERSION_NUMBER_SHIFT_BIT;
369 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
370 : m_libspdm_use_asym_algo, &data1,
371 : &data_size1, NULL, NULL);
372 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
373 1 : spdm_context->local_context.local_cert_chain_provision_size[0] =
374 : data_size1;
375 :
376 1 : libspdm_secret_lib_challenge_opaque_data_size = 0;
377 1 : libspdm_reset_message_c(spdm_context);
378 :
379 1 : response_size = sizeof(response);
380 1 : libspdm_get_random_number(SPDM_NONCE_SIZE,
381 : m_libspdm_challenge_request1.nonce);
382 1 : status = libspdm_get_response_challenge_auth(
383 : spdm_context, m_libspdm_challenge_request1_size,
384 : &m_libspdm_challenge_request1, &response_size, response);
385 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
386 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
387 1 : spdm_response = (void *)response;
388 1 : assert_int_equal(spdm_response->header.request_response_code,
389 : SPDM_ERROR);
390 1 : assert_int_equal(spdm_response->header.param1,
391 : SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
392 1 : assert_int_equal(spdm_response->header.param2, 0);
393 1 : free(data1);
394 1 : }
395 :
396 : /**
397 : * Test 7: receiving a correct CHALLENGE from the requester, but the responder does not
398 : * have the challenge capability set.
399 : * Expected behavior: the responder accepts the request and produces a valid
400 : * CHALLENGE_AUTH response message.
401 : **/
402 1 : static void rsp_challenge_auth_case7(void **state) {
403 : libspdm_return_t status;
404 : libspdm_test_context_t *spdm_test_context;
405 : libspdm_context_t *spdm_context;
406 : size_t response_size;
407 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
408 : spdm_challenge_auth_response_t *spdm_response;
409 : void *data1;
410 : size_t data_size1;
411 :
412 1 : spdm_test_context = *state;
413 1 : spdm_context = spdm_test_context->spdm_context;
414 1 : spdm_test_context->case_id = 0x7;
415 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
416 1 : spdm_context->local_context.capability.flags = 0;
417 : /* spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;*/
418 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
419 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
420 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
421 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
422 : m_libspdm_use_measurement_hash_algo;
423 :
424 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
425 : SPDM_VERSION_NUMBER_SHIFT_BIT;
426 1 : libspdm_read_responder_public_certificate_chain (m_libspdm_use_hash_algo,
427 : m_libspdm_use_asym_algo,
428 : &data1, &data_size1,
429 : NULL, NULL);
430 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
431 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
432 :
433 1 : libspdm_secret_lib_challenge_opaque_data_size = 0;
434 1 : libspdm_reset_message_c(spdm_context);
435 :
436 1 : response_size = sizeof(response);
437 1 : libspdm_get_random_number (SPDM_NONCE_SIZE, m_libspdm_challenge_request1.nonce);
438 1 : status = libspdm_get_response_challenge_auth (spdm_context, m_libspdm_challenge_request1_size,
439 : &m_libspdm_challenge_request1, &response_size,
440 : response);
441 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
442 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
443 1 : spdm_response = (void *)response;
444 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
445 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_UNSUPPORTED_REQUEST);
446 1 : assert_int_equal (spdm_response->header.param2, SPDM_CHALLENGE);
447 1 : free(data1);
448 1 : }
449 :
450 : /**
451 : * Test 8: receiving an incorrect CHALLENGE from the requester, with the slot number
452 : * larger than the specification limit.
453 : * Expected behavior: the responder rejects the request, and produces an ERROR message
454 : * indicating the UnexpectedRequest.
455 : **/
456 1 : static void rsp_challenge_auth_case8(void **state) {
457 : libspdm_return_t status;
458 : libspdm_test_context_t *spdm_test_context;
459 : libspdm_context_t *spdm_context;
460 : size_t response_size;
461 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
462 : spdm_challenge_auth_response_t *spdm_response;
463 : void *data1;
464 : size_t data_size1;
465 :
466 1 : spdm_test_context = *state;
467 1 : spdm_context = spdm_test_context->spdm_context;
468 1 : spdm_test_context->case_id = 0x8;
469 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
470 1 : spdm_context->local_context.capability.flags = 0;
471 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
472 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
473 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
474 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
475 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
476 : m_libspdm_use_measurement_hash_algo;
477 :
478 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
479 : SPDM_VERSION_NUMBER_SHIFT_BIT;
480 1 : libspdm_read_responder_public_certificate_chain (m_libspdm_use_hash_algo,
481 : m_libspdm_use_asym_algo,
482 : &data1, &data_size1,
483 : NULL, NULL);
484 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
485 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
486 :
487 1 : libspdm_secret_lib_challenge_opaque_data_size = 0;
488 1 : libspdm_reset_message_c(spdm_context);
489 :
490 1 : response_size = sizeof(response);
491 1 : libspdm_get_random_number (SPDM_NONCE_SIZE, m_libspdm_challenge_request3.nonce);
492 1 : status = libspdm_get_response_challenge_auth (spdm_context, m_libspdm_challenge_request3_size,
493 : &m_libspdm_challenge_request3, &response_size,
494 : response);
495 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
496 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
497 1 : spdm_response = (void *)response;
498 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
499 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
500 1 : assert_int_equal (spdm_response->header.param2, 0);
501 1 : free(data1);
502 1 : }
503 :
504 : /**
505 : * Test 9: eceiving a correct CHALLENGE message from the requester with
506 : * no opaque data, no measurements, and slot number 1.
507 : * Expected behavior: the responder accepts the request and produces a valid
508 : * CHALLENGE_AUTH response message.
509 : **/
510 1 : static void rsp_challenge_auth_case9(void **state) {
511 : libspdm_return_t status;
512 : libspdm_test_context_t *spdm_test_context;
513 : libspdm_context_t *spdm_context;
514 : size_t response_size;
515 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
516 : spdm_challenge_auth_response_t *spdm_response;
517 : void *data1;
518 : size_t data_size1;
519 : size_t index;
520 : uint8_t slot_mask;
521 :
522 1 : spdm_test_context = *state;
523 1 : spdm_context = spdm_test_context->spdm_context;
524 1 : spdm_test_context->case_id = 0x9;
525 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
526 1 : spdm_context->local_context.capability.flags = 0;
527 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
528 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
529 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
530 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
531 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
532 : m_libspdm_use_measurement_hash_algo;
533 :
534 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
535 : SPDM_VERSION_NUMBER_SHIFT_BIT;
536 1 : libspdm_read_responder_public_certificate_chain (m_libspdm_use_hash_algo,
537 : m_libspdm_use_asym_algo,
538 : &data1, &data_size1,
539 : NULL, NULL);
540 1 : spdm_context->local_context.local_cert_chain_provision[1] = data1;
541 1 : spdm_context->local_context.local_cert_chain_provision_size[1] = data_size1;
542 1 : libspdm_secret_lib_challenge_opaque_data_size = 0;
543 1 : libspdm_reset_message_c(spdm_context);
544 :
545 1 : response_size = sizeof(response);
546 1 : libspdm_get_random_number (SPDM_NONCE_SIZE, m_libspdm_challenge_request4.nonce);
547 1 : status = libspdm_get_response_challenge_auth (spdm_context, m_libspdm_challenge_request4_size,
548 : &m_libspdm_challenge_request4, &response_size,
549 : response);
550 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
551 1 : assert_int_equal (response_size, sizeof(spdm_challenge_auth_response_t) + libspdm_get_hash_size (
552 : m_libspdm_use_hash_algo) + SPDM_NONCE_SIZE + 0 + sizeof(uint16_t) + 0 +
553 : libspdm_get_asym_signature_size (
554 : m_libspdm_use_asym_algo));
555 1 : spdm_response = (void *)response;
556 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_CHALLENGE_AUTH);
557 1 : assert_int_equal (spdm_response->header.param1, 1);
558 :
559 1 : slot_mask = 0;
560 9 : for (index = 0; index < SPDM_MAX_SLOT_COUNT; index++) {
561 8 : if (spdm_context->local_context
562 8 : .local_cert_chain_provision[index] != NULL) {
563 2 : slot_mask |= (1 << index);
564 : }
565 : }
566 1 : assert_int_equal (spdm_response->header.param2, slot_mask);
567 1 : free(data1);
568 1 : }
569 :
570 : /**
571 : * Test 10: receiving a correct CHALLENGE from the requester, but with certificate
572 : * unavailable at the requested slot number (1).
573 : * Expected behavior: the responder rejects the request, and produces an ERROR message
574 : * indicating the UnexpectedRequest.
575 : **/
576 1 : static void rsp_challenge_auth_case10(void **state) {
577 : libspdm_return_t status;
578 : libspdm_test_context_t *spdm_test_context;
579 : libspdm_context_t *spdm_context;
580 : size_t response_size;
581 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
582 : spdm_challenge_auth_response_t *spdm_response;
583 : void *data1;
584 : size_t data_size1;
585 : size_t index;
586 :
587 1 : spdm_test_context = *state;
588 1 : spdm_context = spdm_test_context->spdm_context;
589 1 : spdm_test_context->case_id = 0xA;
590 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
591 1 : spdm_context->local_context.capability.flags = 0;
592 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
593 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
594 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
595 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
596 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
597 : m_libspdm_use_measurement_hash_algo;
598 :
599 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
600 : SPDM_VERSION_NUMBER_SHIFT_BIT;
601 1 : libspdm_read_responder_public_certificate_chain (m_libspdm_use_hash_algo,
602 : m_libspdm_use_asym_algo,
603 : &data1, &data_size1,
604 : NULL, NULL);
605 : /*clear local_cert_chain_provision*/
606 9 : for (index = 0; index <SPDM_MAX_SLOT_COUNT; index++) {
607 8 : spdm_context->local_context.local_cert_chain_provision[index] = NULL;
608 8 : spdm_context->local_context.local_cert_chain_provision_size[index] = 0;
609 : }
610 :
611 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
612 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
613 :
614 1 : libspdm_secret_lib_challenge_opaque_data_size = 0;
615 1 : libspdm_reset_message_c(spdm_context);
616 :
617 1 : response_size = sizeof(response);
618 1 : libspdm_get_random_number (SPDM_NONCE_SIZE, m_libspdm_challenge_request4.nonce);
619 1 : status = libspdm_get_response_challenge_auth (spdm_context, m_libspdm_challenge_request4_size,
620 : &m_libspdm_challenge_request4, &response_size,
621 : response);
622 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
623 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
624 1 : spdm_response = (void *)response;
625 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
626 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
627 1 : assert_int_equal (spdm_response->header.param2, 0);
628 1 : free(data1);
629 1 : }
630 :
631 : /**
632 : * Test 11: receiving a correct CHALLENGE message from the requester with opaque
633 : * data as the bytes of the string "libspdm", no measurements, and slot number 0.
634 : * Expected behavior: the responder accepts the request and produces a valid
635 : * CHALLENGE_AUTH response message.
636 : **/
637 1 : static void rsp_challenge_auth_case11(void **state) {
638 : libspdm_return_t status;
639 : libspdm_test_context_t *spdm_test_context;
640 : libspdm_context_t *spdm_context;
641 : size_t response_size;
642 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
643 : spdm_challenge_auth_response_t *spdm_response;
644 : void *data1;
645 : size_t data_size1;
646 :
647 1 : spdm_test_context = *state;
648 1 : spdm_context = spdm_test_context->spdm_context;
649 1 : spdm_test_context->case_id = 0xB;
650 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
651 1 : spdm_context->local_context.capability.flags = 0;
652 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
653 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
654 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
655 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
656 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
657 : m_libspdm_use_measurement_hash_algo;
658 :
659 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
660 : SPDM_VERSION_NUMBER_SHIFT_BIT;
661 1 : libspdm_read_responder_public_certificate_chain (m_libspdm_use_hash_algo,
662 : m_libspdm_use_asym_algo,
663 : &data1, &data_size1,
664 : NULL, NULL);
665 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
666 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
667 :
668 1 : libspdm_secret_lib_challenge_opaque_data_size = 8;
669 1 : libspdm_reset_message_c(spdm_context);
670 :
671 1 : response_size = sizeof(response);
672 1 : libspdm_get_random_number (SPDM_NONCE_SIZE, m_libspdm_challenge_request1.nonce);
673 1 : status = libspdm_get_response_challenge_auth (spdm_context, m_libspdm_challenge_request1_size,
674 : &m_libspdm_challenge_request1, &response_size,
675 : response);
676 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
677 1 : assert_int_equal (response_size, sizeof(spdm_challenge_auth_response_t) + libspdm_get_hash_size (
678 : m_libspdm_use_hash_algo) + SPDM_NONCE_SIZE + 0 + sizeof(uint16_t) + 8 +
679 : libspdm_get_asym_signature_size (
680 : m_libspdm_use_asym_algo));
681 1 : spdm_response = (void *)response;
682 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_CHALLENGE_AUTH);
683 1 : assert_int_equal (spdm_response->header.param1, 0);
684 1 : assert_int_equal (spdm_response->header.param2, 1 << 0);
685 1 : free(data1);
686 1 : }
687 :
688 : /**
689 : * Test 12: receiving a correct CHALLENGE message from the requester with
690 : * no opaque data, TCB measurement hash, and slot number 0.
691 : * Expected behavior: the responder accepts the request and produces a valid
692 : * CHALLENGE_AUTH response message.
693 : **/
694 1 : static void rsp_challenge_auth_case12(void **state) {
695 : libspdm_return_t status;
696 : libspdm_test_context_t *spdm_test_context;
697 : libspdm_context_t *spdm_context;
698 : size_t response_size;
699 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
700 : spdm_challenge_auth_response_t *spdm_response;
701 : void *data1;
702 : size_t data_size1;
703 :
704 1 : spdm_test_context = *state;
705 1 : spdm_context = spdm_test_context->spdm_context;
706 1 : spdm_test_context->case_id = 0xC;
707 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
708 1 : spdm_context->local_context.capability.flags = 0;
709 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
710 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP; /*additional measurement capability*/
711 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
712 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
713 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
714 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
715 : m_libspdm_use_measurement_hash_algo;
716 :
717 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
718 : SPDM_VERSION_NUMBER_SHIFT_BIT;
719 1 : libspdm_read_responder_public_certificate_chain (m_libspdm_use_hash_algo,
720 : m_libspdm_use_asym_algo,
721 : &data1, &data_size1,
722 : NULL, NULL);
723 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
724 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
725 :
726 1 : libspdm_secret_lib_challenge_opaque_data_size = 0;
727 1 : libspdm_reset_message_c(spdm_context);
728 :
729 1 : response_size = sizeof(response);
730 1 : libspdm_get_random_number (SPDM_NONCE_SIZE, m_libspdm_challenge_request5.nonce);
731 1 : status = libspdm_get_response_challenge_auth (spdm_context, m_libspdm_challenge_request5_size,
732 : &m_libspdm_challenge_request5, &response_size,
733 : response);
734 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
735 1 : assert_int_equal (response_size, sizeof(spdm_challenge_auth_response_t) + libspdm_get_hash_size (
736 : m_libspdm_use_hash_algo) + SPDM_NONCE_SIZE +
737 : libspdm_get_hash_size (m_libspdm_use_hash_algo) +
738 : sizeof(uint16_t) + 0 +
739 : libspdm_get_asym_signature_size (m_libspdm_use_asym_algo));
740 1 : spdm_response = (void *)response;
741 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_CHALLENGE_AUTH);
742 1 : assert_int_equal (spdm_response->header.param1, 0);
743 1 : assert_int_equal (spdm_response->header.param2, 1 << 0);
744 1 : free(data1);
745 1 : }
746 :
747 : /**
748 : * Test 13: receiving a correct CHALLENGE message from the requester with
749 : * no opaque data, all measurement hashes, and slot number 0.
750 : * Expected behavior: the responder accepts the request and produces a valid
751 : * CHALLENGE_AUTH response message.
752 : **/
753 1 : static void rsp_challenge_auth_case13(void **state) {
754 : libspdm_return_t status;
755 : libspdm_test_context_t *spdm_test_context;
756 : libspdm_context_t *spdm_context;
757 : size_t response_size;
758 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
759 : spdm_challenge_auth_response_t *spdm_response;
760 : void *data1;
761 : size_t data_size1;
762 :
763 1 : spdm_test_context = *state;
764 1 : spdm_context = spdm_test_context->spdm_context;
765 1 : spdm_test_context->case_id = 0xD;
766 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
767 1 : spdm_context->local_context.capability.flags = 0;
768 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
769 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP; /*additional measurement capability*/
770 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
771 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
772 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
773 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
774 : m_libspdm_use_measurement_hash_algo;
775 :
776 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
777 : SPDM_VERSION_NUMBER_SHIFT_BIT;
778 1 : libspdm_read_responder_public_certificate_chain (m_libspdm_use_hash_algo,
779 : m_libspdm_use_asym_algo,
780 : &data1, &data_size1,
781 : NULL, NULL);
782 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
783 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
784 :
785 1 : libspdm_secret_lib_challenge_opaque_data_size = 0;
786 1 : libspdm_reset_message_c(spdm_context);
787 :
788 1 : response_size = sizeof(response);
789 1 : libspdm_get_random_number (SPDM_NONCE_SIZE, m_libspdm_challenge_request6.nonce);
790 1 : status = libspdm_get_response_challenge_auth (spdm_context, m_libspdm_challenge_request6_size,
791 : &m_libspdm_challenge_request6, &response_size,
792 : response);
793 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
794 1 : assert_int_equal (response_size, sizeof(spdm_challenge_auth_response_t) + libspdm_get_hash_size (
795 : m_libspdm_use_hash_algo) + SPDM_NONCE_SIZE +
796 : libspdm_get_hash_size (m_libspdm_use_hash_algo) +
797 : sizeof(uint16_t) + 0 +
798 : libspdm_get_asym_signature_size (m_libspdm_use_asym_algo));
799 1 : spdm_response = (void *)response;
800 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_CHALLENGE_AUTH);
801 1 : assert_int_equal (spdm_response->header.param1, 0);
802 1 : assert_int_equal (spdm_response->header.param2, 1 << 0);
803 1 : free(data1);
804 1 : }
805 :
806 : /**
807 : * Test 14: the responder does not have measurements capabilities, but
808 : * receives a correct CHALLENGE message from the requester with
809 : * no opaque data, all measurement hashes, and slot number 0.
810 : * Expected behavior: the responder refuses the CHALLENGE message and produces an
811 : * ERROR message indicating the InvalidRequest.
812 : **/
813 1 : static void rsp_challenge_auth_case14(void **state) {
814 : libspdm_return_t status;
815 : libspdm_test_context_t *spdm_test_context;
816 : libspdm_context_t *spdm_context;
817 : size_t response_size;
818 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
819 : spdm_challenge_auth_response_t *spdm_response;
820 : void *data1;
821 : size_t data_size1;
822 :
823 1 : spdm_test_context = *state;
824 1 : spdm_context = spdm_test_context->spdm_context;
825 1 : spdm_test_context->case_id = 0xE;
826 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
827 1 : spdm_context->local_context.capability.flags = 0;
828 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
829 : /* spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP; no measurement capability*/
830 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
831 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
832 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
833 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
834 : m_libspdm_use_measurement_hash_algo;
835 :
836 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
837 : SPDM_VERSION_NUMBER_SHIFT_BIT;
838 1 : libspdm_read_responder_public_certificate_chain (m_libspdm_use_hash_algo,
839 : m_libspdm_use_asym_algo,
840 : &data1, &data_size1,
841 : NULL, NULL);
842 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
843 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
844 :
845 1 : libspdm_secret_lib_challenge_opaque_data_size = 0;
846 1 : libspdm_reset_message_c(spdm_context);
847 :
848 1 : response_size = sizeof(response);
849 1 : libspdm_get_random_number (SPDM_NONCE_SIZE, m_libspdm_challenge_request6.nonce);
850 1 : status = libspdm_get_response_challenge_auth (spdm_context, m_libspdm_challenge_request6_size,
851 : &m_libspdm_challenge_request6, &response_size,
852 : response);
853 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
854 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
855 1 : spdm_response = (void *)response;
856 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
857 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
858 1 : assert_int_equal (spdm_response->header.param2, 0);
859 1 : free(data1);
860 1 : }
861 :
862 : /**
863 : * Test 15: receiving a correct CHALLENGE from the requester. Buffers A, B and
864 : * C already have arbitrary data.
865 : * Expected behavior: the responder accepts the request and produces a valid
866 : * CHALLENGE_AUTH response message, and buffer C receives the exchanged CHALLENGE
867 : * and CHALLENGE_AUTH (without signature) messages.
868 : **/
869 1 : static void rsp_challenge_auth_case15(void **state)
870 : {
871 : libspdm_return_t status;
872 : libspdm_test_context_t *spdm_test_context;
873 : libspdm_context_t *spdm_context;
874 : size_t response_size;
875 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
876 : spdm_challenge_auth_response_t *spdm_response;
877 : void *data1;
878 : size_t data_size1;
879 :
880 1 : spdm_test_context = *state;
881 1 : spdm_context = spdm_test_context->spdm_context;
882 1 : spdm_test_context->case_id = 0xF;
883 1 : spdm_context->connection_info.connection_state =
884 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
885 1 : spdm_context->local_context.capability.flags = 0;
886 1 : spdm_context->local_context.capability.flags |=
887 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
888 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
889 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
890 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
891 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
892 : m_libspdm_use_measurement_hash_algo;
893 :
894 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
895 : SPDM_VERSION_NUMBER_SHIFT_BIT;
896 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
897 : m_libspdm_use_asym_algo, &data1,
898 : &data_size1, NULL, NULL);
899 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
900 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
901 :
902 1 : libspdm_secret_lib_challenge_opaque_data_size = 0;
903 1 : libspdm_reset_message_c(spdm_context);
904 :
905 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
906 : /*filling buffers with arbitrary data*/
907 : libspdm_set_mem(spdm_context->transcript.message_a.buffer, 10, (uint8_t) 0xFF);
908 : spdm_context->transcript.message_a.buffer_size = 10;
909 : libspdm_set_mem(spdm_context->transcript.message_b.buffer, 8, (uint8_t) 0xEE);
910 : spdm_context->transcript.message_b.buffer_size = 8;
911 : libspdm_set_mem(spdm_context->transcript.message_c.buffer, 12, (uint8_t) 0xDD);
912 : spdm_context->transcript.message_c.buffer_size = 12;
913 : #endif
914 :
915 1 : response_size = sizeof(response);
916 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_challenge_request1.nonce);
917 1 : status = libspdm_get_response_challenge_auth(
918 : spdm_context, m_libspdm_challenge_request1_size,
919 : &m_libspdm_challenge_request1, &response_size, response);
920 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
921 1 : assert_int_equal(response_size,
922 : sizeof(spdm_challenge_auth_response_t) +
923 : libspdm_get_hash_size(m_libspdm_use_hash_algo) +
924 : SPDM_NONCE_SIZE + 0 + sizeof(uint16_t) + 0 +
925 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo));
926 1 : spdm_response = (void *)response;
927 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_CHALLENGE_AUTH);
928 1 : assert_int_equal(spdm_response->header.param1, 0);
929 1 : assert_int_equal(spdm_response->header.param2, 1 << 0);
930 :
931 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
932 : assert_int_equal(spdm_context->transcript.message_a.buffer_size, 10);
933 : #endif
934 1 : free(data1);
935 1 : }
936 :
937 : /**
938 : * Test 16: Receive a CHALLENGE request within a secure session.
939 : * Expected behavior: the Responder replies with error UnexpectedRequest as that is not legal.
940 : **/
941 1 : static void rsp_challenge_auth_case16(void **state)
942 : {
943 : libspdm_return_t status;
944 : libspdm_test_context_t *spdm_test_context;
945 : libspdm_context_t *spdm_context;
946 : size_t response_size;
947 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
948 : spdm_challenge_auth_response_t *spdm_response;
949 : libspdm_session_info_t *session_info;
950 : uint32_t session_id;
951 :
952 1 : spdm_test_context = *state;
953 1 : spdm_context = spdm_test_context->spdm_context;
954 1 : spdm_test_context->case_id = 0x10;
955 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
956 1 : spdm_context->local_context.capability.flags = 0;
957 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
958 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
959 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
960 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
961 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
962 : m_libspdm_use_measurement_hash_algo;
963 :
964 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
965 : SPDM_VERSION_NUMBER_SHIFT_BIT;
966 :
967 1 : session_id = 0xFFFFFFFF;
968 1 : spdm_context->latest_session_id = session_id;
969 1 : spdm_context->last_spdm_request_session_id_valid = true;
970 1 : spdm_context->last_spdm_request_session_id = session_id;
971 1 : session_info = &spdm_context->session_info[0];
972 1 : libspdm_session_info_init(spdm_context, session_info, session_id,
973 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
974 1 : libspdm_secured_message_set_session_state(
975 : session_info->secured_message_context, LIBSPDM_SESSION_STATE_ESTABLISHED);
976 :
977 1 : response_size = sizeof(response);
978 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_challenge_request1.nonce);
979 1 : status = libspdm_get_response_challenge_auth(
980 : spdm_context, m_libspdm_challenge_request1_size,
981 : &m_libspdm_challenge_request1, &response_size, response);
982 :
983 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
984 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
985 1 : spdm_response = (void *)response;
986 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
987 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
988 1 : assert_int_equal (spdm_response->header.param2, 0);
989 :
990 : /* Clear session */
991 1 : libspdm_free_session_id(spdm_context, 0xFFFFFFFF);
992 1 : spdm_context->latest_session_id = 0;
993 1 : spdm_context->last_spdm_request_session_id_valid = false;
994 1 : }
995 :
996 : /**
997 : * Test 16: receiving a correct CHALLENGE message from the requester with
998 : * slot number 0xFF.
999 : * Expected behavior: the responder accepts the request and produces a valid
1000 : * CHALLENGE_AUTH response message.
1001 : **/
1002 1 : static void rsp_challenge_auth_case17(void **state)
1003 : {
1004 : libspdm_return_t status;
1005 : libspdm_test_context_t *spdm_test_context;
1006 : libspdm_context_t *spdm_context;
1007 : size_t response_size;
1008 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1009 : spdm_challenge_auth_response_t *spdm_response;
1010 : void *data1;
1011 : size_t data_size1;
1012 :
1013 1 : spdm_test_context = *state;
1014 1 : spdm_context = spdm_test_context->spdm_context;
1015 1 : spdm_test_context->case_id = 0x11;
1016 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1017 1 : spdm_context->local_context.capability.flags = 0;
1018 1 : spdm_context->local_context.capability.flags |=
1019 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
1020 1 : spdm_context->local_context.capability.flags |=
1021 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PUB_KEY_ID_CAP;
1022 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1023 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1024 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1025 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1026 : m_libspdm_use_measurement_hash_algo;
1027 :
1028 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1029 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1030 1 : libspdm_read_responder_public_key(m_libspdm_use_asym_algo, &data1, &data_size1);
1031 1 : spdm_context->local_context.local_public_key_provision = data1;
1032 1 : spdm_context->local_context.local_public_key_provision_size = data_size1;
1033 :
1034 1 : libspdm_secret_lib_challenge_opaque_data_size = 0;
1035 1 : libspdm_reset_message_c(spdm_context);
1036 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1037 : spdm_context->transcript.message_m.buffer_size =
1038 : spdm_context->transcript.message_m.max_buffer_size;
1039 : #endif
1040 :
1041 1 : response_size = sizeof(response);
1042 1 : libspdm_get_random_number(SPDM_NONCE_SIZE,
1043 : m_libspdm_challenge_request7.nonce);
1044 1 : status = libspdm_get_response_challenge_auth(
1045 : spdm_context, m_libspdm_challenge_request7_size,
1046 : &m_libspdm_challenge_request7, &response_size, response);
1047 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1048 1 : assert_int_equal(response_size,
1049 : sizeof(spdm_challenge_auth_response_t) +
1050 : libspdm_get_hash_size(m_libspdm_use_hash_algo) +
1051 : SPDM_NONCE_SIZE + 0 + sizeof(uint16_t) + 0 +
1052 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo));
1053 1 : spdm_response = (void *)response;
1054 1 : assert_int_equal(spdm_response->header.request_response_code,
1055 : SPDM_CHALLENGE_AUTH);
1056 1 : assert_int_equal(spdm_response->header.param1, 0xF);
1057 1 : assert_int_equal(spdm_response->header.param2, 0);
1058 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1059 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1060 : #endif
1061 1 : free(data1);
1062 1 : }
1063 :
1064 : /**
1065 : * Test 18: Successfully reply to V1.3 to get CHALLENGE message with context field
1066 : * no opaque data, no measurements, and slot number 0.
1067 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, correct context field
1068 : **/
1069 1 : static void rsp_challenge_auth_case18(void **state)
1070 : {
1071 : libspdm_return_t status;
1072 : libspdm_test_context_t *spdm_test_context;
1073 : libspdm_context_t *spdm_context;
1074 : size_t response_size;
1075 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1076 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1077 :
1078 : spdm_challenge_auth_response_t *spdm_response;
1079 : void *data1;
1080 : size_t data_size1;
1081 : uint8_t *requester_context;
1082 : uint8_t *responder_context;
1083 :
1084 1 : spdm_test_context = *state;
1085 1 : spdm_context = spdm_test_context->spdm_context;
1086 1 : spdm_test_context->case_id = 0x12;
1087 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1088 1 : spdm_context->local_context.capability.flags = 0;
1089 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
1090 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1091 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1092 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1093 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1094 : m_libspdm_use_measurement_hash_algo;
1095 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
1096 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1097 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1098 : m_libspdm_use_asym_algo, &data1,
1099 : &data_size1, NULL, NULL);
1100 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
1101 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
1102 1 : libspdm_secret_lib_challenge_opaque_data_size = 0;
1103 1 : libspdm_reset_message_c(spdm_context);
1104 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1105 : spdm_context->transcript.message_m.buffer_size =
1106 : spdm_context->transcript.message_m.max_buffer_size;
1107 : #endif
1108 1 : response_size = sizeof(response);
1109 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_challenge_request8.nonce);
1110 :
1111 1 : libspdm_zero_mem(request, sizeof(request));
1112 1 : libspdm_copy_mem(request, sizeof(spdm_challenge_request_t),
1113 : &m_libspdm_challenge_request8, m_libspdm_challenge_request8_size);
1114 1 : requester_context = request + m_libspdm_challenge_request8_size;
1115 :
1116 1 : libspdm_set_mem(requester_context, SPDM_REQ_CONTEXT_SIZE, 0xAA);
1117 1 : g_check_challenge_request_context = true;
1118 1 : g_challenge_request_context = 0xAAAAAAAA;
1119 1 : m_libspdm_challenge_request8_size += SPDM_REQ_CONTEXT_SIZE;
1120 :
1121 1 : status = libspdm_get_response_challenge_auth(
1122 : spdm_context, m_libspdm_challenge_request8_size,
1123 : request, &response_size, response);
1124 :
1125 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1126 1 : assert_int_equal(response_size,
1127 : sizeof(spdm_challenge_auth_response_t) +
1128 : libspdm_get_hash_size(m_libspdm_use_hash_algo) +
1129 : SPDM_NONCE_SIZE + 0 + sizeof(uint16_t) + 0 +
1130 : libspdm_get_asym_signature_size(m_libspdm_use_asym_algo) +
1131 : SPDM_REQ_CONTEXT_SIZE);
1132 1 : spdm_response = (void *)response;
1133 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_CHALLENGE_AUTH);
1134 1 : assert_int_equal(spdm_response->header.param1, 0);
1135 1 : assert_int_equal(spdm_response->header.param2, 1 << 0);
1136 :
1137 1 : responder_context = (void *)response;
1138 1 : responder_context += sizeof(spdm_challenge_auth_response_t) +
1139 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo) +
1140 1 : SPDM_NONCE_SIZE + 0 + sizeof(uint16_t);
1141 1 : assert_memory_equal(requester_context, responder_context, SPDM_REQ_CONTEXT_SIZE);
1142 :
1143 1 : g_check_challenge_request_context = false;
1144 :
1145 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1146 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1147 : #endif
1148 1 : free(data1);
1149 1 : }
1150 :
1151 : /**
1152 : * Test 19: The key usage bit mask is not set, the SlotID fields in CHALLENGE and CHALLENGE_AUTH shall not specify this certificate slot
1153 : * Expected behavior: the responder accepts the request, but produces an ERROR message
1154 : * indicating the invalid state.
1155 : **/
1156 1 : static void rsp_challenge_auth_case19(void **state)
1157 : {
1158 : libspdm_return_t status;
1159 : libspdm_test_context_t *spdm_test_context;
1160 : libspdm_context_t *spdm_context;
1161 : size_t response_size;
1162 : spdm_challenge_auth_response_t *spdm_response;
1163 : void *data1;
1164 : size_t data_size1;
1165 : uint8_t *requester_context;
1166 : uint8_t request[LIBSPDM_MAX_SPDM_MSG_SIZE];
1167 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1168 : uint8_t slot_id;
1169 :
1170 1 : spdm_test_context = *state;
1171 1 : spdm_context = spdm_test_context->spdm_context;
1172 1 : spdm_test_context->case_id = 0x13;
1173 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1174 1 : spdm_context->local_context.capability.flags = 0;
1175 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
1176 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1177 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1178 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1179 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1180 : m_libspdm_use_measurement_hash_algo;
1181 1 : spdm_context->connection_info.multi_key_conn_rsp = true;
1182 :
1183 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
1184 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1185 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1186 : m_libspdm_use_asym_algo, &data1,
1187 : &data_size1, NULL, NULL);
1188 1 : spdm_context->local_context.local_cert_chain_provision[0] = data1;
1189 1 : spdm_context->local_context.local_cert_chain_provision_size[0] = data_size1;
1190 :
1191 1 : libspdm_secret_lib_challenge_opaque_data_size = 0;
1192 1 : libspdm_reset_message_c(spdm_context);
1193 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1194 : spdm_context->transcript.message_m.buffer_size =
1195 : spdm_context->transcript.message_m.max_buffer_size;
1196 : #endif
1197 :
1198 : /* If set, the SlotID fields in CHALLENGE and CHALLENGE_AUTH can specify this certificate slot. If not set, the
1199 : * SlotID fields in CHALLENGE and CHALLENGE_AUTH shall not specify this certificate slot. */
1200 1 : slot_id = 0;
1201 1 : m_libspdm_challenge_request8.header.param1 = slot_id;
1202 1 : spdm_context->local_context.local_key_usage_bit_mask[slot_id] =
1203 : SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE |
1204 : SPDM_KEY_USAGE_BIT_MASK_MEASUREMENT_USE;
1205 :
1206 1 : libspdm_get_random_number(SPDM_NONCE_SIZE, m_libspdm_challenge_request8.nonce);
1207 :
1208 1 : libspdm_zero_mem(request, sizeof(request));
1209 1 : libspdm_copy_mem(request, sizeof(spdm_challenge_request_t),
1210 : &m_libspdm_challenge_request8, sizeof(m_libspdm_challenge_request8));
1211 1 : requester_context = request + sizeof(m_libspdm_challenge_request8);
1212 1 : libspdm_set_mem(requester_context, SPDM_REQ_CONTEXT_SIZE, 0xAA);
1213 1 : m_libspdm_challenge_request8_size = sizeof(m_libspdm_challenge_request8) +
1214 : SPDM_REQ_CONTEXT_SIZE;
1215 :
1216 1 : response_size = sizeof(response);
1217 1 : status = libspdm_get_response_challenge_auth(
1218 : spdm_context, m_libspdm_challenge_request8_size,
1219 : request, &response_size, response);
1220 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1221 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
1222 1 : spdm_response = (void *)response;
1223 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
1224 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1225 1 : assert_int_equal (spdm_response->header.param2, 0);
1226 1 : free(data1);
1227 1 : }
1228 :
1229 1 : int libspdm_rsp_challenge_auth_test(void)
1230 : {
1231 1 : const struct CMUnitTest test_cases[] = {
1232 : /* Success Case*/
1233 : cmocka_unit_test(rsp_challenge_auth_case1),
1234 : /* Can be populated with new test.*/
1235 : cmocka_unit_test(rsp_challenge_auth_case2),
1236 : /* response_state: LIBSPDM_RESPONSE_STATE_BUSY*/
1237 : cmocka_unit_test(rsp_challenge_auth_case3),
1238 : /* response_state: LIBSPDM_RESPONSE_STATE_NEED_RESYNC*/
1239 : cmocka_unit_test(rsp_challenge_auth_case4),
1240 : #if LIBSPDM_RESPOND_IF_READY_SUPPORT
1241 : /* response_state: LIBSPDM_RESPONSE_STATE_NOT_READY*/
1242 : cmocka_unit_test(rsp_challenge_auth_case5),
1243 : #endif /* LIBSPDM_RESPOND_IF_READY_SUPPORT */
1244 : /* connection_state Check*/
1245 : cmocka_unit_test(rsp_challenge_auth_case6),
1246 : cmocka_unit_test(rsp_challenge_auth_case7),
1247 : cmocka_unit_test(rsp_challenge_auth_case8),
1248 : cmocka_unit_test(rsp_challenge_auth_case9),
1249 : cmocka_unit_test(rsp_challenge_auth_case10),
1250 : cmocka_unit_test(rsp_challenge_auth_case11),
1251 : cmocka_unit_test(rsp_challenge_auth_case12),
1252 : cmocka_unit_test(rsp_challenge_auth_case13),
1253 : cmocka_unit_test(rsp_challenge_auth_case14),
1254 : /* Buffer verification*/
1255 : cmocka_unit_test(rsp_challenge_auth_case15),
1256 : cmocka_unit_test(rsp_challenge_auth_case16),
1257 : /* using provisioned public key (slot_id 0xFF) */
1258 : cmocka_unit_test(rsp_challenge_auth_case17),
1259 : /* Success Case: V1.3 get a correct context field */
1260 : cmocka_unit_test(rsp_challenge_auth_case18),
1261 : /* The key usage bit mask is not set, failed Case*/
1262 : cmocka_unit_test(rsp_challenge_auth_case19),
1263 :
1264 : };
1265 :
1266 1 : libspdm_test_context_t test_context = {
1267 : LIBSPDM_TEST_CONTEXT_VERSION,
1268 : false,
1269 : };
1270 :
1271 1 : libspdm_setup_test_context(&test_context);
1272 :
1273 1 : return cmocka_run_group_tests(test_cases,
1274 : libspdm_unit_test_group_setup,
1275 : libspdm_unit_test_group_teardown);
1276 : }
1277 :
1278 : #endif /* LIBSPDM_ENABLE_CAPABILITY_CHAL_CAP*/
|
