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