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