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