Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2025 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : #include "spdm_unit_test.h"
8 : #include "internal/libspdm_requester_lib.h"
9 : #include "internal/libspdm_responder_lib.h"
10 : #include "internal/libspdm_secured_message_lib.h"
11 :
12 : libspdm_return_t spdm_device_acquire_sender_buffer (
13 : void *context, void **msg_buf_ptr);
14 :
15 : void spdm_device_release_sender_buffer (void *context, const void *msg_buf_ptr);
16 :
17 : libspdm_return_t spdm_device_acquire_receiver_buffer (
18 : void *context, void **msg_buf_ptr);
19 :
20 : void spdm_device_release_receiver_buffer (void *context, const void *msg_buf_ptr);
21 :
22 : static uint32_t libspdm_opaque_data = 0xDEADBEEF;
23 :
24 : /**
25 : * This function verifies peer certificate chain buffer including spdm_cert_chain_t header.
26 : *
27 : * @param spdm_context A pointer to the SPDM context.
28 : * @param cert_chain_buffer Certificate chain buffer including spdm_cert_chain_t header.
29 : * @param cert_chain_buffer_size Size in bytes of the certificate chain buffer.
30 : * @param trust_anchor A buffer to hold the trust_anchor which is used to validate the
31 : * peer certificate, if not NULL.
32 : * @param trust_anchor_size A buffer to hold the trust_anchor_size, if not NULL.
33 : *
34 : * @retval true Peer certificate chain buffer verification passed.
35 : * @retval false Peer certificate chain buffer verification failed.
36 : **/
37 9 : static bool libspdm_verify_peer_cert_chain_buffer(void *spdm_context,
38 : const void *cert_chain_buffer,
39 : size_t cert_chain_buffer_size,
40 : const void **trust_anchor,
41 : size_t *trust_anchor_size)
42 : {
43 : bool result;
44 :
45 : /*verify peer cert chain integrity*/
46 9 : result = libspdm_verify_peer_cert_chain_buffer_integrity(spdm_context, cert_chain_buffer,
47 : cert_chain_buffer_size);
48 9 : if (!result) {
49 0 : return false;
50 : }
51 :
52 : /*verify peer cert chain authority*/
53 9 : result = libspdm_verify_peer_cert_chain_buffer_authority(spdm_context, cert_chain_buffer,
54 : cert_chain_buffer_size, trust_anchor,
55 : trust_anchor_size);
56 9 : if (!result) {
57 3 : return false;
58 : }
59 :
60 6 : return true;
61 : }
62 :
63 : /**
64 : * Return the size in bytes of multi element opaque data supported version.
65 : *
66 : * @param version_count Secure version count.
67 : *
68 : * @return the size in bytes of opaque data supported version.
69 : **/
70 38 : size_t libspdm_get_multi_element_opaque_data_supported_version_data_size(
71 : libspdm_context_t *spdm_context, uint8_t version_count, uint8_t element_num)
72 : {
73 : size_t size;
74 : uint8_t element_index;
75 :
76 38 : if (libspdm_get_connection_version (spdm_context) >= SPDM_MESSAGE_VERSION_12) {
77 19 : size = sizeof(spdm_general_opaque_data_table_header_t);
78 64 : for (element_index = 0; element_index < element_num; element_index++) {
79 45 : size += sizeof(secured_message_opaque_element_table_header_t) +
80 : sizeof(secured_message_opaque_element_supported_version_t) +
81 45 : sizeof(spdm_version_number_t) * version_count;
82 : /* Add Padding*/
83 45 : size = (size + 3) & ~3;
84 : }
85 : } else {
86 19 : size = sizeof(secured_message_general_opaque_data_table_header_t);
87 64 : for (element_index = 0; element_index < element_num; element_index++) {
88 45 : size += sizeof(secured_message_opaque_element_table_header_t) +
89 : sizeof(secured_message_opaque_element_supported_version_t) +
90 45 : sizeof(spdm_version_number_t) * version_count;
91 : /* Add Padding*/
92 45 : size = (size + 3) & ~3;
93 : }
94 : }
95 :
96 38 : return size;
97 : }
98 :
99 : /**
100 : * Build opaque data supported version test.
101 : *
102 : * @param data_out_size[in] size in bytes of the data_out.
103 : * On input, it means the size in bytes of data_out buffer.
104 : * On output, it means the size in bytes of copied data_out buffer if LIBSPDM_STATUS_SUCCESS is returned,
105 : * and means the size in bytes of desired data_out buffer if RETURN_BUFFER_TOO_SMALL is returned.
106 : * @param data_out[in] A pointer to the destination buffer to store the opaque data supported version.
107 : * @param element_num[in] in this test function, the element number < 9 is right. because element id is changed with element_index
108 : **/
109 : libspdm_return_t
110 4 : libspdm_build_multi_element_opaque_data_supported_version_test(libspdm_context_t *spdm_context,
111 : size_t *data_out_size,
112 : void *data_out,
113 : uint8_t element_num)
114 : {
115 : size_t final_data_size;
116 : secured_message_general_opaque_data_table_header_t
117 : *general_opaque_data_table_header;
118 : spdm_general_opaque_data_table_header_t
119 : *spdm_general_opaque_data_table_header;
120 : secured_message_opaque_element_table_header_t
121 : *opaque_element_table_header;
122 : secured_message_opaque_element_supported_version_t
123 : *opaque_element_support_version;
124 : spdm_version_number_t *versions_list;
125 : void *end;
126 : uint8_t element_index;
127 :
128 4 : if (spdm_context->local_context.secured_message_version.secured_message_version_count == 0) {
129 0 : *data_out_size = 0;
130 0 : return LIBSPDM_STATUS_SUCCESS;
131 : }
132 :
133 : final_data_size =
134 4 : libspdm_get_multi_element_opaque_data_supported_version_data_size(
135 : spdm_context,
136 4 : spdm_context->local_context.secured_message_version.secured_message_version_count,
137 : element_num);
138 4 : if (*data_out_size < final_data_size) {
139 0 : *data_out_size = final_data_size;
140 0 : return LIBSPDM_STATUS_BUFFER_TOO_SMALL;
141 : }
142 :
143 4 : if (libspdm_get_connection_version (spdm_context) >= SPDM_MESSAGE_VERSION_12) {
144 2 : spdm_general_opaque_data_table_header = data_out;
145 2 : spdm_general_opaque_data_table_header->total_elements = element_num;
146 2 : libspdm_write_uint24(spdm_general_opaque_data_table_header->reserved, 0);
147 2 : opaque_element_table_header =
148 : (void *)(spdm_general_opaque_data_table_header + 1);
149 : } else {
150 2 : general_opaque_data_table_header = data_out;
151 2 : general_opaque_data_table_header->spec_id =
152 : SECURED_MESSAGE_OPAQUE_DATA_SPEC_ID;
153 2 : general_opaque_data_table_header->opaque_version =
154 : SECURED_MESSAGE_OPAQUE_VERSION;
155 2 : general_opaque_data_table_header->total_elements = element_num;
156 2 : general_opaque_data_table_header->reserved = 0;
157 2 : opaque_element_table_header =
158 : (void *)(general_opaque_data_table_header + 1);
159 : }
160 :
161 34 : for (element_index = 0; element_index < element_num; element_index++) {
162 : /*id is changed with element_index*/
163 30 : opaque_element_table_header->id = element_index;
164 30 : opaque_element_table_header->vendor_len = 0;
165 30 : opaque_element_table_header->opaque_element_data_len =
166 30 : sizeof(secured_message_opaque_element_supported_version_t) +
167 30 : sizeof(spdm_version_number_t) *
168 30 : spdm_context->local_context.secured_message_version.secured_message_version_count;
169 :
170 30 : opaque_element_support_version =
171 : (void *)(opaque_element_table_header + 1);
172 30 : opaque_element_support_version->sm_data_version =
173 : SECURED_MESSAGE_OPAQUE_ELEMENT_SMDATA_DATA_VERSION;
174 30 : opaque_element_support_version->sm_data_id =
175 : SECURED_MESSAGE_OPAQUE_ELEMENT_SMDATA_ID_SUPPORTED_VERSION;
176 30 : opaque_element_support_version->version_count =
177 30 : spdm_context->local_context.secured_message_version.secured_message_version_count;
178 :
179 30 : versions_list = (void *)(opaque_element_support_version + 1);
180 :
181 30 : libspdm_copy_mem(versions_list,
182 30 : *data_out_size - ((uint8_t*)versions_list - (uint8_t*)data_out),
183 30 : spdm_context->local_context.secured_message_version.secured_message_version,
184 30 : spdm_context->local_context.secured_message_version.secured_message_version_count *
185 : sizeof(spdm_version_number_t));
186 :
187 : /*move to next element*/
188 30 : if (libspdm_get_connection_version (spdm_context) >= SPDM_MESSAGE_VERSION_12) {
189 15 : opaque_element_table_header =
190 : (secured_message_opaque_element_table_header_t *)(
191 : (uint8_t *)opaque_element_table_header +
192 15 : libspdm_get_multi_element_opaque_data_supported_version_data_size(
193 : spdm_context,
194 15 : spdm_context->local_context.secured_message_version.secured_message_version_count,
195 15 : 1) -
196 : sizeof(spdm_general_opaque_data_table_header_t));
197 : } else {
198 15 : opaque_element_table_header =
199 : (secured_message_opaque_element_table_header_t *)(
200 : (uint8_t *)opaque_element_table_header +
201 15 : libspdm_get_multi_element_opaque_data_supported_version_data_size(
202 : spdm_context,
203 15 : spdm_context->local_context.secured_message_version.secured_message_version_count,
204 15 : 1) -
205 : sizeof(secured_message_general_opaque_data_table_header_t));
206 : }
207 :
208 : /* Zero Padding. *data_out_size does not need to be changed, because data is 0 padded */
209 30 : end = versions_list +
210 30 : spdm_context->local_context.secured_message_version.secured_message_version_count;
211 30 : libspdm_zero_mem(end, (size_t)data_out + final_data_size - (size_t)end);
212 : }
213 :
214 4 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO,
215 : "successful build multi element opaque data supported version! \n"));
216 4 : return LIBSPDM_STATUS_SUCCESS;
217 : }
218 :
219 : /**
220 : * Return the size in bytes of multi element opaque data selection version.
221 : *
222 : * @param version_count Secure version count.
223 : *
224 : * @return the size in bytes of opaque data selection version.
225 : **/
226 8 : size_t libspdm_get_multi_element_opaque_data_version_selection_data_size(
227 : const libspdm_context_t *spdm_context, uint8_t element_num)
228 : {
229 : size_t size;
230 : uint8_t element_index;
231 :
232 8 : if (spdm_context->local_context.secured_message_version.secured_message_version_count == 0) {
233 0 : return 0;
234 : }
235 :
236 8 : if (libspdm_get_connection_version (spdm_context) >= SPDM_MESSAGE_VERSION_12) {
237 4 : size = sizeof(spdm_general_opaque_data_table_header_t);
238 34 : for (element_index = 0; element_index < element_num; element_index++) {
239 30 : size += sizeof(secured_message_opaque_element_table_header_t) +
240 : sizeof(secured_message_opaque_element_version_selection_t);
241 : /* Add Padding*/
242 30 : size = (size + 3) & ~3;
243 : }
244 : } else {
245 4 : size = sizeof(secured_message_general_opaque_data_table_header_t);
246 34 : for (element_index = 0; element_index < element_num; element_index++) {
247 30 : size += sizeof(secured_message_opaque_element_table_header_t) +
248 : sizeof(secured_message_opaque_element_version_selection_t);
249 : /* Add Padding*/
250 30 : size = (size + 3) & ~3;
251 : }
252 : }
253 :
254 8 : return size;
255 : }
256 :
257 4 : static libspdm_return_t libspdm_build_opaque_data_version_selection_data_test(
258 : const libspdm_context_t *spdm_context, spdm_version_number_t secured_message_version,
259 : size_t *data_out_size, void *data_out, uint8_t element_num)
260 : {
261 : size_t final_data_size;
262 : secured_message_general_opaque_data_table_header_t
263 : *general_opaque_data_table_header;
264 : spdm_general_opaque_data_table_header_t
265 : *spdm_general_opaque_data_table_header;
266 : secured_message_opaque_element_table_header_t
267 : *opaque_element_table_header;
268 : secured_message_opaque_element_version_selection_t
269 : *opaque_element_version_section;
270 : void *end;
271 : uint8_t element_index;
272 : size_t current_element_len;
273 :
274 4 : if (spdm_context->local_context.secured_message_version.secured_message_version_count == 0) {
275 0 : *data_out_size = 0;
276 0 : return LIBSPDM_STATUS_SUCCESS;
277 : }
278 :
279 4 : final_data_size = libspdm_get_multi_element_opaque_data_version_selection_data_size(
280 : spdm_context, element_num);
281 :
282 4 : if (*data_out_size < final_data_size) {
283 0 : *data_out_size = final_data_size;
284 0 : return LIBSPDM_STATUS_BUFFER_TOO_SMALL;
285 : }
286 :
287 4 : if (libspdm_get_connection_version (spdm_context) >= SPDM_MESSAGE_VERSION_12) {
288 2 : spdm_general_opaque_data_table_header = data_out;
289 2 : spdm_general_opaque_data_table_header->total_elements = element_num;
290 2 : libspdm_write_uint24(spdm_general_opaque_data_table_header->reserved, 0);
291 :
292 2 : opaque_element_table_header = (void *)(spdm_general_opaque_data_table_header + 1);
293 : } else {
294 2 : general_opaque_data_table_header = data_out;
295 2 : general_opaque_data_table_header->spec_id = SECURED_MESSAGE_OPAQUE_DATA_SPEC_ID;
296 2 : general_opaque_data_table_header->opaque_version = SECURED_MESSAGE_OPAQUE_VERSION;
297 2 : general_opaque_data_table_header->total_elements = element_num;
298 2 : general_opaque_data_table_header->reserved = 0;
299 :
300 2 : opaque_element_table_header = (void *)(general_opaque_data_table_header + 1);
301 : }
302 :
303 34 : for (element_index = 0; element_index < element_num; element_index++) {
304 : /*id is changed with element_index*/
305 30 : opaque_element_table_header->id = element_index;
306 30 : opaque_element_table_header->vendor_len = 0;
307 30 : opaque_element_table_header->opaque_element_data_len =
308 : sizeof(secured_message_opaque_element_version_selection_t);
309 :
310 30 : opaque_element_version_section = (void *)(opaque_element_table_header + 1);
311 30 : opaque_element_version_section->sm_data_version =
312 : SECURED_MESSAGE_OPAQUE_ELEMENT_SMDATA_DATA_VERSION;
313 30 : opaque_element_version_section->sm_data_id =
314 : SECURED_MESSAGE_OPAQUE_ELEMENT_SMDATA_ID_VERSION_SELECTION;
315 30 : opaque_element_version_section->selected_version = secured_message_version;
316 :
317 : /*move to next element*/
318 30 : current_element_len = sizeof(secured_message_opaque_element_table_header_t) +
319 30 : opaque_element_table_header->opaque_element_data_len;
320 : /* Add Padding*/
321 30 : current_element_len = (current_element_len + 3) & ~3;
322 :
323 30 : opaque_element_table_header =
324 : (secured_message_opaque_element_table_header_t *)(
325 : (uint8_t *)opaque_element_table_header + current_element_len);
326 : }
327 :
328 : /* Zero Padding*/
329 4 : end = opaque_element_version_section + 1;
330 4 : libspdm_zero_mem(end, (size_t)data_out + final_data_size - (size_t)end);
331 :
332 4 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO,
333 : "successful build multi element opaque data selection version! \n"));
334 :
335 4 : return LIBSPDM_STATUS_SUCCESS;
336 : }
337 :
338 :
339 : /**
340 : * Test 1: Basic test - tests happy path of setting and getting opaque data from
341 : * context successfully.
342 : **/
343 1 : static void libspdm_test_common_context_data_case1(void **state)
344 : {
345 : libspdm_return_t status;
346 : libspdm_test_context_t *spdm_test_context;
347 : libspdm_context_t *spdm_context;
348 1 : void *data = (void *)&libspdm_opaque_data;
349 1 : void *return_data = NULL;
350 1 : size_t data_return_size = 0;
351 :
352 1 : spdm_test_context = *state;
353 1 : spdm_context = spdm_test_context->spdm_context;
354 1 : spdm_test_context->case_id = 0x1;
355 :
356 1 : status = libspdm_set_data(spdm_context, LIBSPDM_DATA_APP_CONTEXT_DATA,
357 : NULL, &data, sizeof(data));
358 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
359 :
360 1 : data_return_size = sizeof(return_data);
361 1 : status = libspdm_get_data(spdm_context, LIBSPDM_DATA_APP_CONTEXT_DATA,
362 : NULL, &return_data, &data_return_size);
363 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
364 :
365 1 : assert_memory_equal(data, return_data, sizeof(data));
366 1 : assert_int_equal(data_return_size, sizeof(void*));
367 :
368 : /* check that nothing changed at the data location */
369 1 : assert_int_equal(libspdm_opaque_data, 0xDEADBEEF);
370 1 : }
371 :
372 : /**
373 : * Test 2: Test failure paths of setting opaque data in context. libspdm_set_data
374 : * should fail when an invalid size is passed.
375 : **/
376 1 : static void libspdm_test_common_context_data_case2(void **state)
377 : {
378 : libspdm_return_t status;
379 : libspdm_test_context_t *spdm_test_context;
380 : libspdm_context_t *spdm_context;
381 1 : void *data = (void *)&libspdm_opaque_data;
382 1 : void *return_data = NULL;
383 1 : void *current_return_data = NULL;
384 1 : size_t data_return_size = 0;
385 :
386 1 : spdm_test_context = *state;
387 1 : spdm_context = spdm_test_context->spdm_context;
388 1 : spdm_test_context->case_id = 0x2;
389 :
390 : /**
391 : * Get current opaque data in context. May have been set in previous
392 : * tests. This will be used to compare later to ensure the value hasn't
393 : * changed after a failed set data.
394 : */
395 1 : data_return_size = sizeof(current_return_data);
396 1 : status = libspdm_get_data(spdm_context, LIBSPDM_DATA_APP_CONTEXT_DATA,
397 : NULL, ¤t_return_data, &data_return_size);
398 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
399 1 : assert_int_equal(data_return_size, sizeof(void*));
400 :
401 : /* Ensure nothing has changed between subsequent calls to get data */
402 1 : assert_ptr_equal(current_return_data, &libspdm_opaque_data);
403 :
404 : /*
405 : * Set data with invalid size, it should fail. Read back to ensure that
406 : * no data was set.
407 : */
408 1 : status = libspdm_set_data(spdm_context, LIBSPDM_DATA_APP_CONTEXT_DATA,
409 : NULL, &data, 500);
410 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_PARAMETER);
411 :
412 1 : data_return_size = sizeof(return_data);
413 1 : status = libspdm_get_data(spdm_context, LIBSPDM_DATA_APP_CONTEXT_DATA,
414 : NULL, &return_data, &data_return_size);
415 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
416 1 : assert_ptr_equal(return_data, current_return_data);
417 1 : assert_int_equal(data_return_size, sizeof(void*));
418 :
419 : /* check that nothing changed at the data location */
420 1 : assert_int_equal(libspdm_opaque_data, 0xDEADBEEF);
421 1 : }
422 :
423 : /**
424 : * Test 3: Test failure paths of setting opaque data in context. libspdm_set_data
425 : * should fail when data contains NULL value.
426 : **/
427 1 : static void libspdm_test_common_context_data_case3(void **state)
428 : {
429 : libspdm_return_t status;
430 : libspdm_test_context_t *spdm_test_context;
431 : libspdm_context_t *spdm_context;
432 1 : void *data = NULL;
433 1 : void *return_data = NULL;
434 1 : void *current_return_data = NULL;
435 1 : size_t data_return_size = 0;
436 :
437 1 : spdm_test_context = *state;
438 1 : spdm_context = spdm_test_context->spdm_context;
439 1 : spdm_test_context->case_id = 0x3;
440 :
441 : /**
442 : * Get current opaque data in context. May have been set in previous
443 : * tests. This will be used to compare later to ensure the value hasn't
444 : * changed after a failed set data.
445 : */
446 1 : data_return_size = sizeof(current_return_data);
447 1 : status = libspdm_get_data(spdm_context, LIBSPDM_DATA_APP_CONTEXT_DATA,
448 : NULL, ¤t_return_data, &data_return_size);
449 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
450 1 : assert_int_equal(data_return_size, sizeof(void*));
451 :
452 : /* Ensure nothing has changed between subsequent calls to get data */
453 1 : assert_ptr_equal(current_return_data, &libspdm_opaque_data);
454 :
455 :
456 : /*
457 : * Set data with NULL data, it should fail. Read back to ensure that
458 : * no data was set.
459 : */
460 1 : status = libspdm_set_data(spdm_context, LIBSPDM_DATA_APP_CONTEXT_DATA,
461 : NULL, &data, sizeof(void *));
462 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_PARAMETER);
463 :
464 1 : data_return_size = sizeof(return_data);
465 1 : status = libspdm_get_data(spdm_context, LIBSPDM_DATA_APP_CONTEXT_DATA,
466 : NULL, &return_data, &data_return_size);
467 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
468 1 : assert_ptr_equal(return_data, current_return_data);
469 1 : assert_int_equal(data_return_size, sizeof(void*));
470 :
471 : /* check that nothing changed at the data location */
472 1 : assert_int_equal(libspdm_opaque_data, 0xDEADBEEF);
473 :
474 1 : }
475 :
476 : /**
477 : * Test 4: Test failure paths of getting opaque data in context. libspdm_get_data
478 : * should fail when the size of buffer to get is too small.
479 : **/
480 1 : static void libspdm_test_common_context_data_case4(void **state)
481 : {
482 : libspdm_return_t status;
483 : libspdm_test_context_t *spdm_test_context;
484 : libspdm_context_t *spdm_context;
485 1 : void *data = (void *)&libspdm_opaque_data;
486 1 : void *return_data = NULL;
487 1 : size_t data_return_size = 0;
488 :
489 1 : spdm_test_context = *state;
490 1 : spdm_context = spdm_test_context->spdm_context;
491 1 : spdm_test_context->case_id = 0x4;
492 :
493 : /*
494 : * Set data successfully.
495 : */
496 1 : status = libspdm_set_data(spdm_context, LIBSPDM_DATA_APP_CONTEXT_DATA,
497 : NULL, &data, sizeof(void *));
498 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
499 :
500 : /*
501 : * Fail get data due to insufficient buffer for return value. returned
502 : * data size must return required buffer size.
503 : */
504 1 : data_return_size = sizeof(void*) - 1;
505 1 : status = libspdm_get_data(spdm_context, LIBSPDM_DATA_APP_CONTEXT_DATA,
506 : NULL, &return_data, &data_return_size);
507 1 : assert_int_equal(status, LIBSPDM_STATUS_BUFFER_TOO_SMALL);
508 1 : assert_int_equal(data_return_size, sizeof(void*));
509 :
510 : /* check that nothing changed at the data location */
511 1 : assert_int_equal(libspdm_opaque_data, 0xDEADBEEF);
512 1 : }
513 :
514 : /**
515 : * Test 5: There is no root cert.
516 : * Expected Behavior: Return true result.
517 : **/
518 1 : void libspdm_test_verify_peer_cert_chain_buffer_case5(void **state)
519 : {
520 : libspdm_test_context_t *spdm_test_context;
521 : libspdm_context_t *spdm_context;
522 : void *data;
523 : size_t data_size;
524 : void *hash;
525 : size_t hash_size;
526 : const uint8_t *root_cert;
527 : size_t root_cert_size;
528 :
529 : const void *trust_anchor;
530 : size_t trust_anchor_size;
531 : bool result;
532 : uint8_t root_cert_index;
533 :
534 1 : spdm_test_context = *state;
535 1 : spdm_context = spdm_test_context->spdm_context;
536 1 : spdm_test_context->case_id = 0x5;
537 : /* Setting SPDM context as the first steps of the protocol has been accomplished*/
538 1 : spdm_context->connection_info.connection_state =
539 : LIBSPDM_CONNECTION_STATE_AFTER_DIGESTS;
540 1 : spdm_context->connection_info.capability.flags |=
541 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
542 : /* Loading Root certificate and saving its hash*/
543 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
544 : m_libspdm_use_asym_algo, &data,
545 : &data_size, &hash, &hash_size)) {
546 0 : assert(false);
547 : }
548 1 : if (!libspdm_x509_get_cert_from_cert_chain(
549 1 : (uint8_t *)data + sizeof(spdm_cert_chain_t) + hash_size,
550 1 : data_size - sizeof(spdm_cert_chain_t) - hash_size, 0, &root_cert, &root_cert_size)) {
551 0 : assert(false);
552 : }
553 :
554 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
555 1 : spdm_context->connection_info.algorithm.base_asym_algo= m_libspdm_use_asym_algo;
556 1 : spdm_context->local_context.is_requester = true;
557 :
558 : /*clear root cert array*/
559 11 : for (root_cert_index = 0; root_cert_index < LIBSPDM_MAX_ROOT_CERT_SUPPORT; root_cert_index++) {
560 10 : spdm_context->local_context.peer_root_cert_provision_size[root_cert_index] = 0;
561 10 : spdm_context->local_context.peer_root_cert_provision[root_cert_index] = NULL;
562 : }
563 1 : result = libspdm_verify_peer_cert_chain_buffer(spdm_context, data, data_size, &trust_anchor,
564 : &trust_anchor_size);
565 1 : assert_int_equal (result, true);
566 :
567 1 : free(data);
568 1 : }
569 :
570 : /**
571 : * Test 6: There is one root cert. And the root cert has two case: match root cert, mismatch root cert.
572 : *
573 : * case Expected Behavior
574 : * there is one match root cert; return false
575 : * there is one mismatch root cert; return true, and the return trust_anchor is root cert.
576 : **/
577 1 : void libspdm_test_verify_peer_cert_chain_buffer_case6(void **state)
578 : {
579 : libspdm_test_context_t *spdm_test_context;
580 : libspdm_context_t *spdm_context;
581 : void *data;
582 : size_t data_size;
583 : void *hash;
584 : size_t hash_size;
585 : const uint8_t *root_cert;
586 : size_t root_cert_size;
587 :
588 : void *data_test;
589 : size_t data_size_test;
590 : void *hash_test;
591 : size_t hash_size_test;
592 : const uint8_t *root_cert_test;
593 : size_t root_cert_size_test;
594 1 : uint32_t m_libspdm_use_asym_algo_test =SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048;
595 :
596 : const void *trust_anchor;
597 : size_t trust_anchor_size;
598 : bool result;
599 : uint8_t root_cert_index;
600 :
601 1 : spdm_test_context = *state;
602 1 : spdm_context = spdm_test_context->spdm_context;
603 1 : spdm_test_context->case_id = 0x6;
604 : /* Setting SPDM context as the first steps of the protocol has been accomplished*/
605 1 : spdm_context->connection_info.connection_state =
606 : LIBSPDM_CONNECTION_STATE_AFTER_DIGESTS;
607 1 : spdm_context->connection_info.capability.flags |=
608 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
609 1 : spdm_context->local_context.is_requester = true;
610 :
611 : /* Loading Root certificate and saving its hash*/
612 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
613 : m_libspdm_use_asym_algo, &data,
614 : &data_size, &hash, &hash_size)) {
615 0 : assert(false);
616 : }
617 1 : if (!libspdm_x509_get_cert_from_cert_chain(
618 1 : (uint8_t *)data + sizeof(spdm_cert_chain_t) + hash_size,
619 1 : data_size - sizeof(spdm_cert_chain_t) - hash_size, 0, &root_cert, &root_cert_size)) {
620 0 : assert(false);
621 : }
622 : /* Loading Other test Root certificate and saving its hash*/
623 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
624 : m_libspdm_use_asym_algo_test, &data_test,
625 : &data_size_test, &hash_test, &hash_size_test);
626 1 : libspdm_x509_get_cert_from_cert_chain(
627 1 : (uint8_t *)data_test + sizeof(spdm_cert_chain_t) + hash_size_test,
628 1 : data_size_test - sizeof(spdm_cert_chain_t) - hash_size_test, 0,
629 : &root_cert_test, &root_cert_size_test);
630 :
631 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
632 1 : spdm_context->connection_info.algorithm.base_asym_algo= m_libspdm_use_asym_algo;
633 :
634 : /*clear root cert array*/
635 11 : for (root_cert_index = 0; root_cert_index < LIBSPDM_MAX_ROOT_CERT_SUPPORT; root_cert_index++) {
636 10 : spdm_context->local_context.peer_root_cert_provision_size[root_cert_index] = 0;
637 10 : spdm_context->local_context.peer_root_cert_provision[root_cert_index] = NULL;
638 : }
639 :
640 : /*case: match root cert case*/
641 1 : spdm_context->local_context.peer_root_cert_provision_size[0] =root_cert_size_test;
642 1 : spdm_context->local_context.peer_root_cert_provision[0] = root_cert_test;
643 1 : result = libspdm_verify_peer_cert_chain_buffer(spdm_context, data, data_size, &trust_anchor,
644 : &trust_anchor_size);
645 1 : assert_int_equal (result, false);
646 :
647 : /*case: mismatch root cert case*/
648 1 : spdm_context->local_context.peer_root_cert_provision_size[0] =root_cert_size;
649 1 : spdm_context->local_context.peer_root_cert_provision[0] = root_cert;
650 1 : result = libspdm_verify_peer_cert_chain_buffer(spdm_context, data, data_size, &trust_anchor,
651 : &trust_anchor_size);
652 1 : assert_int_equal (result, true);
653 1 : assert_ptr_equal (trust_anchor, root_cert);
654 :
655 1 : free(data);
656 1 : free(data_test);
657 1 : }
658 :
659 : /**
660 : * Test 7: There are LIBSPDM_MAX_ROOT_CERT_SUPPORT/2 root cert.
661 : *
662 : * case Expected Behavior
663 : * there is no match root cert; return false
664 : * there is one match root cert in the end; return true, and the return trust_anchor is root cert.
665 : * there is one match root cert in the middle; return true, and the return trust_anchor is root cert.
666 : **/
667 1 : void libspdm_test_verify_peer_cert_chain_buffer_case7(void **state)
668 : {
669 : libspdm_test_context_t *spdm_test_context;
670 : libspdm_context_t *spdm_context;
671 : void *data;
672 : size_t data_size;
673 : void *hash;
674 : size_t hash_size;
675 : const uint8_t *root_cert;
676 : size_t root_cert_size;
677 :
678 : void *data_test;
679 : size_t data_size_test;
680 : void *hash_test;
681 : size_t hash_size_test;
682 : const uint8_t *root_cert_test;
683 : size_t root_cert_size_test;
684 1 : uint32_t m_libspdm_use_asym_algo_test =SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048;
685 :
686 : const void *trust_anchor;
687 : size_t trust_anchor_size;
688 : bool result;
689 : uint8_t root_cert_index;
690 :
691 1 : spdm_test_context = *state;
692 1 : spdm_context = spdm_test_context->spdm_context;
693 1 : spdm_test_context->case_id = 0x7;
694 : /* Setting SPDM context as the first steps of the protocol has been accomplished*/
695 1 : spdm_context->connection_info.connection_state =
696 : LIBSPDM_CONNECTION_STATE_AFTER_DIGESTS;
697 1 : spdm_context->connection_info.capability.flags |=
698 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
699 1 : spdm_context->local_context.is_requester = true;
700 : /* Loading Root certificate and saving its hash*/
701 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
702 : m_libspdm_use_asym_algo, &data,
703 : &data_size, &hash, &hash_size)) {
704 0 : assert(false);
705 : }
706 1 : if (!libspdm_x509_get_cert_from_cert_chain(
707 1 : (uint8_t *)data + sizeof(spdm_cert_chain_t) + hash_size,
708 1 : data_size - sizeof(spdm_cert_chain_t) - hash_size, 0, &root_cert, &root_cert_size)) {
709 0 : assert(false);
710 : }
711 : /* Loading Other test Root certificate and saving its hash*/
712 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
713 : m_libspdm_use_asym_algo_test, &data_test,
714 : &data_size_test, &hash_test, &hash_size_test);
715 1 : libspdm_x509_get_cert_from_cert_chain(
716 1 : (uint8_t *)data_test + sizeof(spdm_cert_chain_t) + hash_size_test,
717 1 : data_size_test - sizeof(spdm_cert_chain_t) - hash_size_test, 0,
718 : &root_cert_test, &root_cert_size_test);
719 :
720 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
721 1 : spdm_context->connection_info.algorithm.base_asym_algo= m_libspdm_use_asym_algo;
722 :
723 : /*clear root cert array*/
724 11 : for (root_cert_index = 0; root_cert_index < LIBSPDM_MAX_ROOT_CERT_SUPPORT; root_cert_index++) {
725 10 : spdm_context->local_context.peer_root_cert_provision_size[root_cert_index] = 0;
726 10 : spdm_context->local_context.peer_root_cert_provision[root_cert_index] = NULL;
727 : }
728 :
729 : /*case: there is no match root cert*/
730 6 : for (root_cert_index = 0; root_cert_index < (LIBSPDM_MAX_ROOT_CERT_SUPPORT / 2);
731 5 : root_cert_index++) {
732 5 : spdm_context->local_context.peer_root_cert_provision_size[root_cert_index] =
733 : root_cert_size_test;
734 5 : spdm_context->local_context.peer_root_cert_provision[root_cert_index] = root_cert_test;
735 : }
736 1 : result = libspdm_verify_peer_cert_chain_buffer(spdm_context, data, data_size, &trust_anchor,
737 : &trust_anchor_size);
738 1 : assert_int_equal (result, false);
739 :
740 : /*case: there is no match root cert in the end*/
741 : spdm_context->local_context.peer_root_cert_provision_size[LIBSPDM_MAX_ROOT_CERT_SUPPORT / 2 -
742 1 : 1] =root_cert_size;
743 : spdm_context->local_context.peer_root_cert_provision[LIBSPDM_MAX_ROOT_CERT_SUPPORT / 2 -
744 1 : 1] = root_cert;
745 1 : result = libspdm_verify_peer_cert_chain_buffer(spdm_context, data, data_size, &trust_anchor,
746 : &trust_anchor_size);
747 1 : assert_int_equal (result, true);
748 1 : assert_ptr_equal (trust_anchor, root_cert);
749 :
750 : /*case: there is no match root cert in the middle*/
751 : spdm_context->local_context.peer_root_cert_provision_size[LIBSPDM_MAX_ROOT_CERT_SUPPORT /
752 1 : 4] =root_cert_size;
753 : spdm_context->local_context.peer_root_cert_provision[LIBSPDM_MAX_ROOT_CERT_SUPPORT /
754 1 : 4] = root_cert;
755 1 : result = libspdm_verify_peer_cert_chain_buffer(spdm_context, data, data_size, &trust_anchor,
756 : &trust_anchor_size);
757 1 : assert_int_equal (result, true);
758 1 : assert_ptr_equal (trust_anchor, root_cert);
759 :
760 1 : free(data);
761 1 : free(data_test);
762 1 : }
763 :
764 :
765 : /**
766 : * Test 8: There are full(LIBSPDM_MAX_ROOT_CERT_SUPPORT - 1) root cert.
767 : *
768 : * case Expected Behavior
769 : * there is no match root cert; return false
770 : * there is one match root cert in the end; return true, and the return trust_anchor is root cert.
771 : * there is one match root cert in the middle; return true, and the return trust_anchor is root cert.
772 : **/
773 1 : void libspdm_test_verify_peer_cert_chain_buffer_case8(void **state)
774 : {
775 : libspdm_test_context_t *spdm_test_context;
776 : libspdm_context_t *spdm_context;
777 : void *data;
778 : size_t data_size;
779 : void *hash;
780 : size_t hash_size;
781 : const uint8_t *root_cert;
782 : size_t root_cert_size;
783 :
784 : void *data_test;
785 : size_t data_size_test;
786 : void *hash_test;
787 : size_t hash_size_test;
788 : const uint8_t *root_cert_test;
789 : size_t root_cert_size_test;
790 1 : uint32_t m_libspdm_use_asym_algo_test =SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048;
791 :
792 : const void *trust_anchor;
793 : size_t trust_anchor_size;
794 : bool result;
795 : uint8_t root_cert_index;
796 :
797 1 : spdm_test_context = *state;
798 1 : spdm_context = spdm_test_context->spdm_context;
799 1 : spdm_test_context->case_id = 0x8;
800 : /* Setting SPDM context as the first steps of the protocol has been accomplished*/
801 1 : spdm_context->connection_info.connection_state =
802 : LIBSPDM_CONNECTION_STATE_AFTER_DIGESTS;
803 1 : spdm_context->connection_info.capability.flags |=
804 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
805 1 : spdm_context->local_context.is_requester = true;
806 : /* Loading Root certificate and saving its hash*/
807 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
808 : m_libspdm_use_asym_algo, &data,
809 : &data_size, &hash, &hash_size)) {
810 0 : assert(false);
811 : }
812 1 : if (!libspdm_x509_get_cert_from_cert_chain(
813 1 : (uint8_t *)data + sizeof(spdm_cert_chain_t) + hash_size,
814 1 : data_size - sizeof(spdm_cert_chain_t) - hash_size, 0, &root_cert, &root_cert_size)) {
815 0 : assert(false);
816 : }
817 : /* Loading Other test Root certificate and saving its hash*/
818 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
819 : m_libspdm_use_asym_algo_test, &data_test,
820 : &data_size_test, &hash_test, &hash_size_test);
821 1 : libspdm_x509_get_cert_from_cert_chain(
822 1 : (uint8_t *)data_test + sizeof(spdm_cert_chain_t) + hash_size_test,
823 1 : data_size_test - sizeof(spdm_cert_chain_t) - hash_size_test, 0,
824 : &root_cert_test, &root_cert_size_test);
825 :
826 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
827 1 : spdm_context->connection_info.algorithm.base_asym_algo= m_libspdm_use_asym_algo;
828 :
829 : /*case: there is no match root cert*/
830 11 : for (root_cert_index = 0; root_cert_index < LIBSPDM_MAX_ROOT_CERT_SUPPORT; root_cert_index++) {
831 10 : spdm_context->local_context.peer_root_cert_provision_size[root_cert_index] =
832 : root_cert_size_test;
833 10 : spdm_context->local_context.peer_root_cert_provision[root_cert_index] = root_cert_test;
834 : }
835 1 : result = libspdm_verify_peer_cert_chain_buffer(spdm_context, data, data_size, &trust_anchor,
836 : &trust_anchor_size);
837 1 : assert_int_equal (result, false);
838 :
839 : /*case: there is no match root cert in the end*/
840 : spdm_context->local_context.peer_root_cert_provision_size[LIBSPDM_MAX_ROOT_CERT_SUPPORT -
841 1 : 1] =root_cert_size;
842 : spdm_context->local_context.peer_root_cert_provision[LIBSPDM_MAX_ROOT_CERT_SUPPORT -
843 1 : 1] = root_cert;
844 1 : result = libspdm_verify_peer_cert_chain_buffer(spdm_context, data, data_size, &trust_anchor,
845 : &trust_anchor_size);
846 1 : assert_int_equal (result, true);
847 1 : assert_ptr_equal (trust_anchor, root_cert);
848 :
849 : /*case: there is no match root cert in the middle*/
850 11 : for (root_cert_index = 0; root_cert_index < LIBSPDM_MAX_ROOT_CERT_SUPPORT; root_cert_index++) {
851 10 : spdm_context->local_context.peer_root_cert_provision_size[root_cert_index] =
852 : root_cert_size_test;
853 10 : spdm_context->local_context.peer_root_cert_provision[root_cert_index] = root_cert_test;
854 : }
855 : spdm_context->local_context.peer_root_cert_provision_size[LIBSPDM_MAX_ROOT_CERT_SUPPORT /
856 1 : 2] =root_cert_size;
857 : spdm_context->local_context.peer_root_cert_provision[LIBSPDM_MAX_ROOT_CERT_SUPPORT /
858 1 : 2] = root_cert;
859 1 : result = libspdm_verify_peer_cert_chain_buffer(spdm_context, data, data_size, &trust_anchor,
860 : &trust_anchor_size);
861 1 : assert_int_equal (result, true);
862 1 : assert_ptr_equal (trust_anchor, root_cert);
863 :
864 1 : free(data);
865 1 : free(data_test);
866 1 : }
867 :
868 : /**
869 : * Test 9: test set data for root cert.
870 : *
871 : * case Expected Behavior
872 : * there is null root cert; return LIBSPDM_STATUS_SUCCESS, and the root cert is set successfully.
873 : * there is full root cert; return RETURN_OUT_OF_RESOURCES.
874 : **/
875 1 : static void libspdm_test_set_data_case9(void **state)
876 : {
877 : libspdm_return_t status;
878 : libspdm_test_context_t *spdm_test_context;
879 : libspdm_context_t *spdm_context;
880 : libspdm_data_parameter_t parameter;
881 :
882 : void *data;
883 : size_t data_size;
884 : void *hash;
885 : size_t hash_size;
886 : const uint8_t *root_cert;
887 : uint8_t root_cert_buffer[LIBSPDM_MAX_CERT_CHAIN_SIZE];
888 : size_t root_cert_size;
889 :
890 : uint8_t root_cert_index;
891 :
892 1 : spdm_test_context = *state;
893 1 : spdm_context = spdm_test_context->spdm_context;
894 1 : spdm_test_context->case_id = 0x9;
895 :
896 : /* Loading Root certificate and saving its hash*/
897 1 : if (!libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
898 : m_libspdm_use_asym_algo, &data,
899 : &data_size, &hash, &hash_size)) {
900 0 : assert(false);
901 : }
902 1 : if (!libspdm_x509_get_cert_from_cert_chain(
903 1 : (uint8_t *)data + sizeof(spdm_cert_chain_t) + hash_size,
904 1 : data_size - sizeof(spdm_cert_chain_t) - hash_size, 0, &root_cert, &root_cert_size)) {
905 0 : assert(false);
906 : }
907 1 : memcpy(root_cert_buffer, root_cert, root_cert_size);
908 :
909 : /*case: there is null root cert*/
910 11 : for (root_cert_index = 0; root_cert_index < LIBSPDM_MAX_ROOT_CERT_SUPPORT; root_cert_index++) {
911 10 : spdm_context->local_context.peer_root_cert_provision_size[root_cert_index] = 0;
912 10 : spdm_context->local_context.peer_root_cert_provision[root_cert_index] = NULL;
913 : }
914 1 : parameter.location = LIBSPDM_DATA_LOCATION_LOCAL;
915 1 : status = libspdm_set_data(spdm_context, LIBSPDM_DATA_PEER_PUBLIC_ROOT_CERT,
916 : ¶meter, root_cert_buffer, root_cert_size);
917 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
918 1 : assert_int_equal (spdm_context->local_context.peer_root_cert_provision_size[0], root_cert_size);
919 1 : assert_ptr_equal (spdm_context->local_context.peer_root_cert_provision[0], root_cert_buffer);
920 :
921 : /*case: there is full root cert*/
922 11 : for (root_cert_index = 0; root_cert_index < LIBSPDM_MAX_ROOT_CERT_SUPPORT; root_cert_index++) {
923 10 : spdm_context->local_context.peer_root_cert_provision_size[root_cert_index] = root_cert_size;
924 10 : spdm_context->local_context.peer_root_cert_provision[root_cert_index] = root_cert_buffer;
925 : }
926 1 : status = libspdm_set_data(spdm_context, LIBSPDM_DATA_PEER_PUBLIC_ROOT_CERT,
927 : ¶meter, root_cert_buffer, root_cert_size);
928 1 : assert_int_equal (status, LIBSPDM_STATUS_BUFFER_FULL);
929 :
930 1 : free(data);
931 1 : }
932 :
933 :
934 : /**
935 : * Test 10: There is no root cert.
936 : * Expected Behavior: Return true result.
937 : **/
938 1 : void libspdm_test_process_opaque_data_supported_version_data_case10(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 opaque_data_size;
944 : uint8_t element_num;
945 : spdm_version_number_t secured_message_version;
946 :
947 1 : spdm_test_context = *state;
948 1 : spdm_context = spdm_test_context->spdm_context;
949 1 : spdm_test_context->case_id = 0xA;
950 :
951 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
952 : SPDM_VERSION_NUMBER_SHIFT_BIT;
953 :
954 1 : spdm_context->local_context.secured_message_version.secured_message_version_count = 1;
955 :
956 1 : element_num = 2;
957 1 : opaque_data_size =
958 1 : libspdm_get_multi_element_opaque_data_supported_version_data_size(
959 : spdm_context,
960 1 : spdm_context->local_context.secured_message_version.secured_message_version_count,
961 : element_num);
962 :
963 : uint8_t *opaque_data_ptr;
964 1 : opaque_data_ptr = malloc(opaque_data_size);
965 :
966 1 : libspdm_build_multi_element_opaque_data_supported_version_test(
967 : spdm_context, &opaque_data_size, opaque_data_ptr, element_num);
968 :
969 1 : status = libspdm_process_opaque_data_supported_version_data(spdm_context,
970 : opaque_data_size,
971 : opaque_data_ptr,
972 : &secured_message_version);
973 :
974 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
975 :
976 1 : free(opaque_data_ptr);
977 1 : }
978 :
979 1 : void libspdm_test_process_opaque_data_supported_version_data_case11(void **state)
980 : {
981 : libspdm_return_t status;
982 : libspdm_test_context_t *spdm_test_context;
983 : libspdm_context_t *spdm_context;
984 : size_t opaque_data_size;
985 : uint8_t element_num;
986 : spdm_version_number_t secured_message_version;
987 :
988 1 : spdm_test_context = *state;
989 1 : spdm_context = spdm_test_context->spdm_context;
990 1 : spdm_test_context->case_id = 0xB;
991 :
992 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
993 : SPDM_VERSION_NUMBER_SHIFT_BIT;
994 :
995 1 : spdm_context->local_context.secured_message_version.secured_message_version_count = 1;
996 :
997 : /*make element id wrong*/
998 1 : element_num = SPDM_REGISTRY_ID_MAX + 2;
999 1 : opaque_data_size =
1000 1 : libspdm_get_multi_element_opaque_data_supported_version_data_size(
1001 : spdm_context,
1002 1 : spdm_context->local_context.secured_message_version.secured_message_version_count,
1003 : element_num);
1004 :
1005 : uint8_t *opaque_data_ptr;
1006 1 : opaque_data_ptr = malloc(opaque_data_size);
1007 :
1008 1 : libspdm_build_multi_element_opaque_data_supported_version_test(
1009 : spdm_context, &opaque_data_size, opaque_data_ptr, element_num);
1010 :
1011 1 : status = libspdm_process_opaque_data_supported_version_data(spdm_context,
1012 : opaque_data_size,
1013 : opaque_data_ptr,
1014 : &secured_message_version);
1015 :
1016 1 : assert_int_equal (status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1017 :
1018 1 : free(opaque_data_ptr);
1019 1 : }
1020 :
1021 1 : void libspdm_test_process_opaque_data_supported_version_data_case12(void **state)
1022 : {
1023 : libspdm_return_t status;
1024 : libspdm_test_context_t *spdm_test_context;
1025 : libspdm_context_t *spdm_context;
1026 : size_t opaque_data_size;
1027 : uint8_t element_num;
1028 : spdm_version_number_t secured_message_version;
1029 :
1030 1 : spdm_test_context = *state;
1031 1 : spdm_context = spdm_test_context->spdm_context;
1032 1 : spdm_test_context->case_id = 0xC;
1033 :
1034 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1035 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1036 :
1037 1 : spdm_context->local_context.secured_message_version.secured_message_version_count = 1;
1038 :
1039 1 : element_num = 2;
1040 1 : opaque_data_size =
1041 1 : libspdm_get_multi_element_opaque_data_supported_version_data_size(
1042 : spdm_context,
1043 1 : spdm_context->local_context.secured_message_version.secured_message_version_count,
1044 : element_num);
1045 :
1046 : uint8_t *opaque_data_ptr;
1047 1 : opaque_data_ptr = malloc(opaque_data_size);
1048 :
1049 1 : libspdm_build_multi_element_opaque_data_supported_version_test(
1050 : spdm_context, &opaque_data_size, opaque_data_ptr, element_num);
1051 :
1052 1 : status = libspdm_process_opaque_data_supported_version_data(spdm_context,
1053 : opaque_data_size,
1054 : opaque_data_ptr,
1055 : &secured_message_version);
1056 :
1057 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
1058 :
1059 1 : free(opaque_data_ptr);
1060 1 : }
1061 :
1062 1 : void libspdm_test_process_opaque_data_supported_version_data_case13(void **state)
1063 : {
1064 : libspdm_return_t status;
1065 : libspdm_test_context_t *spdm_test_context;
1066 : libspdm_context_t *spdm_context;
1067 : size_t opaque_data_size;
1068 : uint8_t element_num;
1069 : spdm_version_number_t secured_message_version;
1070 :
1071 1 : spdm_test_context = *state;
1072 1 : spdm_context = spdm_test_context->spdm_context;
1073 1 : spdm_test_context->case_id = 0xD;
1074 :
1075 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1076 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1077 :
1078 1 : spdm_context->local_context.secured_message_version.secured_message_version_count = 1;
1079 :
1080 : /*make element id wrong*/
1081 1 : element_num = SPDM_REGISTRY_ID_MAX + 2;
1082 1 : opaque_data_size =
1083 1 : libspdm_get_multi_element_opaque_data_supported_version_data_size(
1084 : spdm_context,
1085 1 : spdm_context->local_context.secured_message_version.secured_message_version_count,
1086 : element_num);
1087 :
1088 : uint8_t *opaque_data_ptr;
1089 1 : opaque_data_ptr = malloc(opaque_data_size);
1090 :
1091 1 : libspdm_build_multi_element_opaque_data_supported_version_test(
1092 : spdm_context, &opaque_data_size, opaque_data_ptr, element_num);
1093 :
1094 1 : status = libspdm_process_opaque_data_supported_version_data(spdm_context,
1095 : opaque_data_size,
1096 : opaque_data_ptr,
1097 : &secured_message_version);
1098 :
1099 1 : assert_int_equal (status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1100 :
1101 1 : free(opaque_data_ptr);
1102 1 : }
1103 :
1104 :
1105 1 : void libspdm_test_process_opaque_data_selection_version_data_case14(void **state)
1106 : {
1107 : libspdm_return_t status;
1108 : libspdm_test_context_t *spdm_test_context;
1109 : libspdm_context_t *spdm_context;
1110 : size_t opaque_data_size;
1111 : uint8_t element_num;
1112 : spdm_version_number_t secured_message_version;
1113 :
1114 1 : spdm_test_context = *state;
1115 1 : spdm_context = spdm_test_context->spdm_context;
1116 1 : spdm_test_context->case_id = 0xE;
1117 :
1118 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1119 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1120 :
1121 1 : spdm_context->local_context.secured_message_version.secured_message_version_count = 1;
1122 1 : spdm_context->local_context.secured_message_version.secured_message_version[0] =
1123 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT;
1124 :
1125 1 : element_num = 2;
1126 1 : opaque_data_size =
1127 1 : libspdm_get_multi_element_opaque_data_version_selection_data_size(
1128 : spdm_context,
1129 : element_num);
1130 :
1131 : uint8_t *opaque_data_ptr;
1132 1 : opaque_data_ptr = malloc(opaque_data_size);
1133 :
1134 1 : libspdm_build_opaque_data_version_selection_data_test(
1135 : spdm_context, SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, &opaque_data_size,
1136 : opaque_data_ptr, element_num);
1137 :
1138 1 : status = libspdm_process_opaque_data_version_selection_data(spdm_context,
1139 : opaque_data_size,
1140 : opaque_data_ptr,
1141 : &secured_message_version);
1142 :
1143 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
1144 1 : assert_int_equal (secured_message_version,
1145 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT);
1146 :
1147 1 : free(opaque_data_ptr);
1148 1 : }
1149 :
1150 :
1151 1 : void libspdm_test_process_opaque_data_selection_version_data_case15(void **state)
1152 : {
1153 : libspdm_return_t status;
1154 : libspdm_test_context_t *spdm_test_context;
1155 : libspdm_context_t *spdm_context;
1156 : size_t opaque_data_size;
1157 : uint8_t element_num;
1158 : spdm_version_number_t secured_message_version;
1159 :
1160 1 : spdm_test_context = *state;
1161 1 : spdm_context = spdm_test_context->spdm_context;
1162 1 : spdm_test_context->case_id = 0xF;
1163 :
1164 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1165 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1166 :
1167 1 : spdm_context->local_context.secured_message_version.secured_message_version_count = 1;
1168 1 : spdm_context->local_context.secured_message_version.secured_message_version[0] =
1169 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT;
1170 :
1171 : /*make element id wrong*/
1172 1 : element_num = SPDM_REGISTRY_ID_MAX + 2;
1173 1 : opaque_data_size =
1174 1 : libspdm_get_multi_element_opaque_data_version_selection_data_size(
1175 : spdm_context,
1176 : element_num);
1177 :
1178 : uint8_t *opaque_data_ptr;
1179 1 : opaque_data_ptr = malloc(opaque_data_size);
1180 :
1181 1 : libspdm_build_opaque_data_version_selection_data_test(
1182 : spdm_context, SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, &opaque_data_size,
1183 : opaque_data_ptr, element_num);
1184 :
1185 1 : status = libspdm_process_opaque_data_version_selection_data(spdm_context,
1186 : opaque_data_size,
1187 : opaque_data_ptr,
1188 : &secured_message_version);
1189 :
1190 1 : assert_int_equal (status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1191 :
1192 1 : free(opaque_data_ptr);
1193 1 : }
1194 :
1195 :
1196 1 : void libspdm_test_process_opaque_data_selection_version_data_case16(void **state)
1197 : {
1198 : libspdm_return_t status;
1199 : libspdm_test_context_t *spdm_test_context;
1200 : libspdm_context_t *spdm_context;
1201 : size_t opaque_data_size;
1202 : uint8_t element_num;
1203 : spdm_version_number_t secured_message_version;
1204 :
1205 1 : spdm_test_context = *state;
1206 1 : spdm_context = spdm_test_context->spdm_context;
1207 1 : spdm_test_context->case_id = 0x10;
1208 :
1209 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1210 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1211 :
1212 1 : spdm_context->local_context.secured_message_version.secured_message_version_count = 1;
1213 1 : spdm_context->local_context.secured_message_version.secured_message_version[0] =
1214 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT;
1215 :
1216 1 : element_num = 2;
1217 1 : opaque_data_size = libspdm_get_multi_element_opaque_data_version_selection_data_size(
1218 : spdm_context, element_num);
1219 :
1220 : uint8_t *opaque_data_ptr;
1221 1 : opaque_data_ptr = malloc(opaque_data_size);
1222 :
1223 1 : libspdm_build_opaque_data_version_selection_data_test(
1224 : spdm_context, SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, &opaque_data_size,
1225 : opaque_data_ptr, element_num);
1226 :
1227 1 : status = libspdm_process_opaque_data_version_selection_data(spdm_context,
1228 : opaque_data_size,
1229 : opaque_data_ptr,
1230 : &secured_message_version);
1231 :
1232 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
1233 :
1234 1 : free(opaque_data_ptr);
1235 1 : }
1236 :
1237 1 : void libspdm_test_process_opaque_data_selection_version_data_case17(void **state)
1238 : {
1239 : libspdm_return_t status;
1240 : libspdm_test_context_t *spdm_test_context;
1241 : libspdm_context_t *spdm_context;
1242 : size_t opaque_data_size;
1243 : uint8_t element_num;
1244 : spdm_version_number_t secured_message_version;
1245 :
1246 1 : spdm_test_context = *state;
1247 1 : spdm_context = spdm_test_context->spdm_context;
1248 1 : spdm_test_context->case_id = 0x11;
1249 :
1250 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1251 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1252 :
1253 1 : spdm_context->local_context.secured_message_version.secured_message_version_count = 1;
1254 1 : spdm_context->local_context.secured_message_version.secured_message_version[0] =
1255 : SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT;
1256 :
1257 : /*make element id wrong*/
1258 1 : element_num = SPDM_REGISTRY_ID_MAX + 2;
1259 1 : opaque_data_size =
1260 1 : libspdm_get_multi_element_opaque_data_version_selection_data_size(
1261 : spdm_context,
1262 : element_num);
1263 :
1264 : uint8_t *opaque_data_ptr;
1265 1 : opaque_data_ptr = malloc(opaque_data_size);
1266 :
1267 1 : libspdm_build_opaque_data_version_selection_data_test(
1268 : spdm_context, SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, &opaque_data_size,
1269 : opaque_data_ptr, element_num);
1270 :
1271 1 : status = libspdm_process_opaque_data_version_selection_data(spdm_context,
1272 : opaque_data_size,
1273 : opaque_data_ptr,
1274 : &secured_message_version);
1275 :
1276 1 : assert_int_equal (status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1277 :
1278 1 : free(opaque_data_ptr);
1279 1 : }
1280 :
1281 1 : void libspdm_test_secured_message_context_location_selection_case18(void **state)
1282 : {
1283 : libspdm_return_t status;
1284 : libspdm_test_context_t *spdm_test_context;
1285 : libspdm_context_t *spdm_context;
1286 : void *secured_message_contexts[LIBSPDM_MAX_SESSION_COUNT];
1287 : size_t index;
1288 :
1289 1 : spdm_test_context = *state;
1290 1 : spdm_test_context->case_id = 0x12;
1291 :
1292 1 : spdm_context = (libspdm_context_t *)malloc(libspdm_get_context_size_without_secured_context());
1293 :
1294 5 : for (index = 0; index < LIBSPDM_MAX_SESSION_COUNT; index++)
1295 : {
1296 4 : secured_message_contexts[index] =
1297 4 : (void *)malloc(libspdm_secured_message_get_context_size());
1298 : }
1299 :
1300 1 : status = libspdm_init_context_with_secured_context(spdm_context, secured_message_contexts,
1301 : LIBSPDM_MAX_SESSION_COUNT);
1302 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
1303 :
1304 5 : for (index = 0; index < LIBSPDM_MAX_SESSION_COUNT; index++)
1305 : {
1306 : /* Ensure the SPDM context points to the specified memory. */
1307 4 : assert_ptr_equal(spdm_context->session_info[index].secured_message_context,
1308 : secured_message_contexts[index]);
1309 : }
1310 :
1311 1 : free(spdm_context);
1312 5 : for (index = 0; index < LIBSPDM_MAX_SESSION_COUNT; index++)
1313 : {
1314 4 : free(secured_message_contexts[index]);
1315 : }
1316 1 : }
1317 :
1318 1 : static void libspdm_test_export_master_secret_case19(void **state)
1319 : {
1320 : uint8_t target_buffer[LIBSPDM_MAX_HASH_SIZE];
1321 : bool result;
1322 : libspdm_secured_message_context_t secured_message_context;
1323 : size_t export_master_secret_size;
1324 :
1325 : /* Get the entire EMS when the reported size of the target buffer is larger than the size of the
1326 : * EMS. */
1327 65 : for (int index = 0; index < LIBSPDM_MAX_HASH_SIZE; index++) {
1328 64 : secured_message_context.export_master_secret[index] = (uint8_t)index;
1329 64 : target_buffer[index] = 0x00;
1330 : }
1331 :
1332 1 : secured_message_context.hash_size = LIBSPDM_MAX_HASH_SIZE;
1333 1 : export_master_secret_size = LIBSPDM_MAX_HASH_SIZE + 0x100;
1334 :
1335 1 : result = libspdm_secured_message_export_master_secret(&secured_message_context,
1336 : &target_buffer,
1337 : &export_master_secret_size);
1338 1 : assert_int_equal(result, true);
1339 :
1340 1 : libspdm_secured_message_clear_export_master_secret(&secured_message_context);
1341 :
1342 65 : for (int index = 0; index < LIBSPDM_MAX_HASH_SIZE; index++) {
1343 64 : assert_int_equal(target_buffer[index], index);
1344 64 : assert_int_equal(secured_message_context.export_master_secret[index], 0x00);
1345 : }
1346 1 : assert_int_equal(export_master_secret_size, LIBSPDM_MAX_HASH_SIZE);
1347 :
1348 : /* Get the entire EMS when the size of the target buffer is the same size as the EMS. */
1349 65 : for (int index = 0; index < LIBSPDM_MAX_HASH_SIZE; index++) {
1350 64 : secured_message_context.export_master_secret[index] = (uint8_t)index;
1351 64 : target_buffer[index] = 0x00;
1352 : }
1353 :
1354 1 : secured_message_context.hash_size = LIBSPDM_MAX_HASH_SIZE;
1355 1 : export_master_secret_size = LIBSPDM_MAX_HASH_SIZE;
1356 :
1357 1 : result = libspdm_secured_message_export_master_secret(&secured_message_context,
1358 : &target_buffer,
1359 : &export_master_secret_size);
1360 1 : assert_int_equal(result, true);
1361 :
1362 65 : for (int index = 0; index < LIBSPDM_MAX_HASH_SIZE; index++) {
1363 64 : assert_int_equal(target_buffer[index], index);
1364 : }
1365 1 : assert_int_equal(export_master_secret_size, LIBSPDM_MAX_HASH_SIZE);
1366 :
1367 : /* Get the truncated EMS when the size of the target buffer is less than the size of the EMS. */
1368 65 : for (int index = 0; index < LIBSPDM_MAX_HASH_SIZE; index++) {
1369 64 : secured_message_context.export_master_secret[index] = (uint8_t)index;
1370 64 : target_buffer[index] = 0x00;
1371 : }
1372 :
1373 1 : secured_message_context.hash_size = LIBSPDM_MAX_HASH_SIZE;
1374 1 : export_master_secret_size = LIBSPDM_MAX_HASH_SIZE - 4;
1375 :
1376 1 : result = libspdm_secured_message_export_master_secret(&secured_message_context,
1377 : &target_buffer,
1378 : &export_master_secret_size);
1379 1 : assert_int_equal(result, true);
1380 :
1381 65 : for (int index = 0; index < LIBSPDM_MAX_HASH_SIZE; index++) {
1382 64 : if (index < LIBSPDM_MAX_HASH_SIZE - 4) {
1383 60 : assert_int_equal(target_buffer[index], index);
1384 : } else {
1385 4 : assert_int_equal(target_buffer[index], 0x00);
1386 : }
1387 : }
1388 1 : assert_int_equal(export_master_secret_size, LIBSPDM_MAX_HASH_SIZE - 4);
1389 1 : }
1390 :
1391 1 : static void libspdm_test_check_context_case20(void **state)
1392 : {
1393 : void *context;
1394 : bool result;
1395 :
1396 1 : context = (void *)malloc (libspdm_get_context_size());
1397 :
1398 1 : libspdm_init_context (context);
1399 :
1400 1 : result = libspdm_check_context (context);
1401 1 : assert_int_equal(false, result);
1402 :
1403 1 : libspdm_register_transport_layer_func(context,
1404 : LIBSPDM_MAX_SPDM_MSG_SIZE,
1405 : LIBSPDM_TEST_TRANSPORT_HEADER_SIZE,
1406 : LIBSPDM_TEST_TRANSPORT_TAIL_SIZE,
1407 : libspdm_transport_test_encode_message,
1408 : libspdm_transport_test_decode_message);
1409 :
1410 1 : libspdm_register_device_buffer_func(context,
1411 : LIBSPDM_MAX_SENDER_RECEIVER_BUFFER_SIZE,
1412 : LIBSPDM_MAX_SENDER_RECEIVER_BUFFER_SIZE,
1413 : spdm_device_acquire_sender_buffer,
1414 : spdm_device_release_sender_buffer,
1415 : spdm_device_acquire_receiver_buffer,
1416 : spdm_device_release_receiver_buffer);
1417 :
1418 1 : result = libspdm_check_context (context);
1419 1 : assert_int_equal(true, result);
1420 :
1421 1 : libspdm_register_transport_layer_func(context,
1422 : SPDM_MIN_DATA_TRANSFER_SIZE_VERSION_12,
1423 : LIBSPDM_TEST_TRANSPORT_HEADER_SIZE,
1424 : LIBSPDM_TEST_TRANSPORT_TAIL_SIZE,
1425 : libspdm_transport_test_encode_message,
1426 : libspdm_transport_test_decode_message);
1427 :
1428 1 : result = libspdm_check_context (context);
1429 1 : assert_int_equal(false, result);
1430 1 : }
1431 :
1432 1 : static void libspdm_test_max_session_count_case21(void **state)
1433 : {
1434 : libspdm_context_t *spdm_context;
1435 : libspdm_data_parameter_t parameter;
1436 : size_t index;
1437 : size_t round;
1438 : uint16_t req_id;
1439 : uint16_t rsp_id;
1440 : uint32_t session_id;
1441 : void *session_info;
1442 : uint32_t dhe_session_count;
1443 : uint32_t psk_session_count;
1444 :
1445 7 : for (round = 0; round <= 5; round++) {
1446 : /* prepare parameter */
1447 6 : switch (round) {
1448 1 : case 0:
1449 1 : dhe_session_count = 1;
1450 1 : psk_session_count = 1;
1451 1 : break;
1452 1 : case 1:
1453 1 : dhe_session_count = LIBSPDM_MAX_SESSION_COUNT / 2;
1454 1 : psk_session_count = LIBSPDM_MAX_SESSION_COUNT - dhe_session_count;
1455 1 : break;
1456 1 : case 2:
1457 1 : dhe_session_count = 1;
1458 1 : psk_session_count = LIBSPDM_MAX_SESSION_COUNT - 1;
1459 1 : break;
1460 1 : case 3:
1461 1 : dhe_session_count = LIBSPDM_MAX_SESSION_COUNT - 1;
1462 1 : psk_session_count = 1;
1463 1 : break;
1464 1 : case 4:
1465 1 : dhe_session_count = 0;
1466 1 : psk_session_count = LIBSPDM_MAX_SESSION_COUNT;
1467 1 : break;
1468 1 : case 5:
1469 1 : dhe_session_count = LIBSPDM_MAX_SESSION_COUNT;
1470 1 : psk_session_count = 0;
1471 1 : break;
1472 0 : default:
1473 0 : dhe_session_count = 0;
1474 0 : psk_session_count = 0;
1475 0 : break;
1476 : }
1477 :
1478 : /* test */
1479 6 : spdm_context = (libspdm_context_t *)malloc(libspdm_get_context_size());
1480 6 : libspdm_init_context (spdm_context);
1481 6 : spdm_context->connection_info.capability.flags =
1482 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP |
1483 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1484 6 : spdm_context->local_context.capability.flags =
1485 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP |
1486 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1487 6 : spdm_context->connection_info.algorithm.base_hash_algo =
1488 : SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256;
1489 6 : spdm_context->connection_info.algorithm.dhe_named_group =
1490 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1;
1491 6 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1492 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM;
1493 6 : spdm_context->connection_info.algorithm.key_schedule =
1494 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM;
1495 :
1496 6 : libspdm_zero_mem(¶meter, sizeof(parameter));
1497 6 : parameter.location = LIBSPDM_DATA_LOCATION_LOCAL;
1498 6 : if (dhe_session_count != 0) {
1499 5 : libspdm_set_data (spdm_context, LIBSPDM_DATA_MAX_DHE_SESSION_COUNT, ¶meter,
1500 : &dhe_session_count, sizeof(dhe_session_count));
1501 : }
1502 6 : if (psk_session_count != 0) {
1503 5 : libspdm_set_data (spdm_context, LIBSPDM_DATA_MAX_PSK_SESSION_COUNT, ¶meter,
1504 : &psk_session_count, sizeof(psk_session_count));
1505 : }
1506 :
1507 6 : if (dhe_session_count != 0) {
1508 16 : for (index = 0; index < dhe_session_count; index++)
1509 : {
1510 11 : req_id = libspdm_allocate_req_session_id (spdm_context, false);
1511 11 : assert_int_not_equal (req_id, INVALID_SESSION_ID & 0xFFFF);
1512 :
1513 11 : rsp_id = libspdm_allocate_rsp_session_id (spdm_context, false);
1514 11 : assert_int_not_equal (rsp_id, (INVALID_SESSION_ID & 0xFFFF0000) >> 16);
1515 :
1516 11 : session_id = libspdm_generate_session_id (req_id, rsp_id);
1517 11 : session_info = libspdm_assign_session_id (spdm_context, session_id,
1518 : SECURED_SPDM_VERSION_11 <<
1519 : SPDM_VERSION_NUMBER_SHIFT_BIT,
1520 : false);
1521 11 : assert_ptr_not_equal (session_info, NULL);
1522 : }
1523 5 : req_id = libspdm_allocate_req_session_id (spdm_context, false);
1524 5 : assert_int_equal (req_id, INVALID_SESSION_ID & 0xFFFF);
1525 :
1526 5 : rsp_id = libspdm_allocate_rsp_session_id (spdm_context, false);
1527 5 : assert_int_equal (rsp_id, (INVALID_SESSION_ID & 0xFFFF0000) >> 16);
1528 : }
1529 :
1530 6 : if (psk_session_count != 0) {
1531 16 : for (index = 0; index < psk_session_count; index++)
1532 : {
1533 11 : req_id = libspdm_allocate_req_session_id (spdm_context, true);
1534 11 : assert_int_not_equal (req_id, INVALID_SESSION_ID & 0xFFFF);
1535 :
1536 11 : rsp_id = libspdm_allocate_rsp_session_id (spdm_context, true);
1537 11 : assert_int_not_equal (rsp_id, (INVALID_SESSION_ID & 0xFFFF0000) >> 16);
1538 :
1539 11 : session_id = libspdm_generate_session_id (req_id, rsp_id);
1540 11 : session_info = libspdm_assign_session_id (spdm_context, session_id,
1541 : SECURED_SPDM_VERSION_11 <<
1542 : SPDM_VERSION_NUMBER_SHIFT_BIT,
1543 : true);
1544 11 : assert_ptr_not_equal (session_info, NULL);
1545 : }
1546 5 : req_id = libspdm_allocate_req_session_id (spdm_context, true);
1547 5 : assert_int_equal (req_id, INVALID_SESSION_ID & 0xFFFF);
1548 :
1549 5 : rsp_id = libspdm_allocate_rsp_session_id (spdm_context, true);
1550 5 : assert_int_equal (rsp_id, (INVALID_SESSION_ID & 0xFFFF0000) >> 16);
1551 : }
1552 :
1553 6 : free(spdm_context);
1554 : }
1555 1 : }
1556 :
1557 : #pragma pack(1)
1558 :
1559 : typedef struct {
1560 : spdm_general_opaque_data_table_header_t opaque_header;
1561 : spdm_svh_iana_cbor_header_t cbor_header;
1562 : uint8_t cbor_vendor_id[10];
1563 : uint16_t cbor_opaque_len;
1564 : uint8_t cbor_opaque[10];
1565 : /* uint8_t cbor_align[]; */
1566 : spdm_svh_vesa_header_t vesa_header;
1567 : uint16_t vesa_opaque_len;
1568 : uint8_t vesa_opaque[9];
1569 : uint8_t vesa_align[3];
1570 : spdm_svh_jedec_header_t jedec_header;
1571 : uint16_t jedec_opaque_len;
1572 : uint8_t jedec_opaque[8];
1573 : uint8_t jedec_align[2];
1574 : spdm_svh_cxl_header_t cxl_header;
1575 : uint16_t cxl_opaque_len;
1576 : uint8_t cxl_opaque[7];
1577 : uint8_t cxl_align[3];
1578 : spdm_svh_mipi_header_t mipi_header;
1579 : uint16_t mipi_opaque_len;
1580 : uint8_t mipi_opaque[6];
1581 : /* uint8_t mipi_align[0]; */
1582 : spdm_svh_hdbaset_header_t hdbaset_header;
1583 : uint16_t hdbaset_opaque_len;
1584 : uint8_t hdbaset_opaque[5];
1585 : uint8_t hdbaset_align[3];
1586 : spdm_svh_iana_header_t iana_header;
1587 : uint16_t iana_opaque_len;
1588 : uint8_t iana_opaque[4];
1589 : /* uint8_t iana_align[0]; */
1590 : spdm_svh_pcisig_header_t pcisig_header;
1591 : uint16_t pcisig_opaque_len;
1592 : uint8_t pcisig_opaque[3];
1593 : uint8_t pcisig_align[3];
1594 : spdm_svh_usb_header_t usb_header;
1595 : uint16_t usb_opaque_len;
1596 : uint8_t usb_opaque[2];
1597 : /* uint8_t usb_align[0]; */
1598 : spdm_svh_tcg_header_t tcg_header;
1599 : uint16_t tcg_opaque_len;
1600 : uint8_t tcg_opaque[1];
1601 : uint8_t tcg_align[1];
1602 : spdm_svh_dmtf_dsp_header_t dmtf_dsp_header;
1603 : uint16_t dmtf_dsp_opaque_len;
1604 : uint8_t dmtf_dsp_opaque[11];
1605 : uint8_t dmtf_dsp_align[3];
1606 : spdm_svh_dmtf_header_t dmtf_sm_ver_sel_header;
1607 : uint16_t dmtf_sm_ver_sel_opaque_len;
1608 : secured_message_opaque_element_version_selection_t dmtf_sm_ver_sel_opaque;
1609 : /* uint8_t dmtf_sm_ver_sel_align[0]; */
1610 : spdm_svh_dmtf_header_t dmtf_sm_sup_ver_header;
1611 : uint16_t dmtf_sm_sup_ver_opaque_len;
1612 : secured_message_opaque_element_supported_version_t dmtf_sm_sup_ver_opaque;
1613 : spdm_version_number_t dmtf_sm_sup_ver_versions_list[3];
1614 : uint8_t dmtf_sm_sup_ver_align[3];
1615 : } test_spdm12_opaque_data_table_t;
1616 :
1617 : #pragma pack()
1618 :
1619 1 : static void libspdm_test_process_opaque_data_case22(void **state)
1620 : {
1621 : libspdm_return_t status;
1622 : libspdm_test_context_t *spdm_test_context;
1623 : libspdm_context_t *spdm_context;
1624 : const void *get_element_ptr;
1625 : size_t get_element_len;
1626 : size_t opaque_data_size;
1627 : uint8_t *opaque_data_ptr;
1628 : test_spdm12_opaque_data_table_t opaque_data;
1629 :
1630 1 : spdm_test_context = *state;
1631 1 : spdm_context = spdm_test_context->spdm_context;
1632 1 : spdm_test_context->case_id = 0x16;
1633 :
1634 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1635 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1636 :
1637 1 : spdm_context->local_context.secured_message_version.secured_message_version_count = 1;
1638 :
1639 1 : libspdm_set_mem ((uint8_t *)&opaque_data, sizeof(opaque_data), 0xFF);
1640 1 : opaque_data.opaque_header.total_elements = SPDM_REGISTRY_ID_MAX + 2;
1641 1 : opaque_data.cbor_header.header.id = SPDM_REGISTRY_ID_IANA_CBOR;
1642 1 : opaque_data.cbor_header.header.vendor_id_len = sizeof(opaque_data.cbor_vendor_id);
1643 1 : opaque_data.cbor_opaque_len = sizeof(opaque_data.cbor_opaque);
1644 1 : opaque_data.vesa_header.header.id = SPDM_REGISTRY_ID_VESA;
1645 1 : opaque_data.vesa_header.header.vendor_id_len = 0;
1646 1 : opaque_data.vesa_opaque_len = sizeof(opaque_data.vesa_opaque);
1647 1 : opaque_data.jedec_header.header.id = SPDM_REGISTRY_ID_JEDEC;
1648 1 : opaque_data.jedec_header.header.vendor_id_len = sizeof(opaque_data.jedec_header.vendor_id);
1649 1 : opaque_data.jedec_opaque_len = sizeof(opaque_data.jedec_opaque);
1650 1 : opaque_data.cxl_header.header.id = SPDM_REGISTRY_ID_CXL;
1651 1 : opaque_data.cxl_header.header.vendor_id_len = sizeof(opaque_data.cxl_header.vendor_id);
1652 1 : opaque_data.cxl_opaque_len = sizeof(opaque_data.cxl_opaque);
1653 1 : opaque_data.mipi_header.header.id = SPDM_REGISTRY_ID_MIPI;
1654 1 : opaque_data.mipi_header.header.vendor_id_len = sizeof(opaque_data.mipi_header.vendor_id);
1655 1 : opaque_data.mipi_opaque_len = sizeof(opaque_data.mipi_opaque);
1656 1 : opaque_data.hdbaset_header.header.id = SPDM_REGISTRY_ID_HDBASET;
1657 1 : opaque_data.hdbaset_header.header.vendor_id_len = sizeof(opaque_data.hdbaset_header.vendor_id);
1658 1 : opaque_data.hdbaset_opaque_len = sizeof(opaque_data.hdbaset_opaque);
1659 1 : opaque_data.iana_header.header.id = SPDM_REGISTRY_ID_IANA;
1660 1 : opaque_data.iana_header.header.vendor_id_len = sizeof(opaque_data.iana_header.vendor_id);
1661 1 : opaque_data.iana_opaque_len = sizeof(opaque_data.iana_opaque);
1662 1 : opaque_data.pcisig_header.header.id = SPDM_REGISTRY_ID_PCISIG;
1663 1 : opaque_data.pcisig_header.header.vendor_id_len = sizeof(opaque_data.pcisig_header.vendor_id);
1664 1 : opaque_data.pcisig_opaque_len = sizeof(opaque_data.pcisig_opaque);
1665 1 : opaque_data.usb_header.header.id = SPDM_REGISTRY_ID_USB;
1666 1 : opaque_data.usb_header.header.vendor_id_len = sizeof(opaque_data.usb_header.vendor_id);
1667 1 : opaque_data.usb_opaque_len = sizeof(opaque_data.usb_opaque);
1668 1 : opaque_data.tcg_header.header.id = SPDM_REGISTRY_ID_TCG;
1669 1 : opaque_data.tcg_header.header.vendor_id_len = sizeof(opaque_data.tcg_header.vendor_id);
1670 1 : opaque_data.tcg_opaque_len = sizeof(opaque_data.tcg_opaque);
1671 1 : opaque_data.dmtf_dsp_header.header.id = SPDM_REGISTRY_ID_DMTF_DSP;
1672 1 : opaque_data.dmtf_dsp_header.header.vendor_id_len = sizeof(opaque_data.dmtf_dsp_header.vendor_id);
1673 1 : opaque_data.dmtf_dsp_opaque_len = sizeof(opaque_data.dmtf_dsp_opaque);
1674 1 : opaque_data.dmtf_sm_ver_sel_header.header.id = SPDM_REGISTRY_ID_DMTF;
1675 1 : opaque_data.dmtf_sm_ver_sel_header.header.vendor_id_len = 0;
1676 1 : opaque_data.dmtf_sm_ver_sel_opaque_len = sizeof(opaque_data.dmtf_sm_ver_sel_opaque);
1677 1 : opaque_data.dmtf_sm_ver_sel_opaque.sm_data_version =
1678 : SECURED_MESSAGE_OPAQUE_ELEMENT_SMDATA_DATA_VERSION;
1679 1 : opaque_data.dmtf_sm_ver_sel_opaque.sm_data_id =
1680 : SECURED_MESSAGE_OPAQUE_ELEMENT_SMDATA_ID_VERSION_SELECTION;
1681 1 : opaque_data.dmtf_sm_ver_sel_opaque.selected_version = SECURED_SPDM_VERSION_12 << 8;
1682 1 : opaque_data.dmtf_sm_sup_ver_header.header.id = SPDM_REGISTRY_ID_DMTF;
1683 1 : opaque_data.dmtf_sm_sup_ver_header.header.vendor_id_len = 0;
1684 1 : opaque_data.dmtf_sm_sup_ver_opaque_len = sizeof(opaque_data.dmtf_sm_sup_ver_opaque) +
1685 : sizeof(opaque_data.dmtf_sm_sup_ver_versions_list);
1686 1 : opaque_data.dmtf_sm_sup_ver_opaque.sm_data_version =
1687 : SECURED_MESSAGE_OPAQUE_ELEMENT_SMDATA_DATA_VERSION;
1688 1 : opaque_data.dmtf_sm_sup_ver_opaque.sm_data_id =
1689 : SECURED_MESSAGE_OPAQUE_ELEMENT_SMDATA_ID_SUPPORTED_VERSION;
1690 1 : opaque_data.dmtf_sm_sup_ver_opaque.version_count =
1691 : LIBSPDM_ARRAY_SIZE(opaque_data.dmtf_sm_sup_ver_versions_list);
1692 1 : opaque_data.dmtf_sm_sup_ver_versions_list[0] = SECURED_SPDM_VERSION_10 << 8;
1693 1 : opaque_data.dmtf_sm_sup_ver_versions_list[1] = SECURED_SPDM_VERSION_11 << 8;
1694 1 : opaque_data.dmtf_sm_sup_ver_versions_list[2] = SECURED_SPDM_VERSION_12 << 8;
1695 :
1696 1 : opaque_data_ptr = (uint8_t *)&opaque_data;
1697 1 : opaque_data_size = sizeof(opaque_data);
1698 1 : status = libspdm_get_element_from_opaque_data(spdm_context,
1699 : opaque_data_size, opaque_data_ptr,
1700 : SPDM_REGISTRY_ID_DMTF,
1701 : SECURED_MESSAGE_OPAQUE_ELEMENT_SMDATA_ID_VERSION_SELECTION,
1702 : &get_element_ptr, &get_element_len
1703 : );
1704 1 : assert_int_equal (status, true);
1705 1 : status = libspdm_get_element_from_opaque_data(spdm_context,
1706 : opaque_data_size, opaque_data_ptr,
1707 : SPDM_REGISTRY_ID_DMTF,
1708 : SECURED_MESSAGE_OPAQUE_ELEMENT_SMDATA_ID_SUPPORTED_VERSION,
1709 : &get_element_ptr, &get_element_len
1710 : );
1711 1 : assert_int_equal (status, true);
1712 1 : }
1713 :
1714 : static libspdm_test_context_t m_libspdm_common_context_data_test_context = {
1715 : LIBSPDM_TEST_CONTEXT_VERSION,
1716 : true,
1717 : NULL,
1718 : NULL,
1719 : };
1720 :
1721 1 : int libspdm_common_context_data_test_main(void)
1722 : {
1723 1 : const struct CMUnitTest spdm_common_context_data_tests[] = {
1724 : cmocka_unit_test(libspdm_test_common_context_data_case1),
1725 : cmocka_unit_test(libspdm_test_common_context_data_case2),
1726 : cmocka_unit_test(libspdm_test_common_context_data_case3),
1727 : cmocka_unit_test(libspdm_test_common_context_data_case4),
1728 :
1729 : cmocka_unit_test(libspdm_test_verify_peer_cert_chain_buffer_case5),
1730 : cmocka_unit_test(libspdm_test_verify_peer_cert_chain_buffer_case6),
1731 : cmocka_unit_test(libspdm_test_verify_peer_cert_chain_buffer_case7),
1732 : cmocka_unit_test(libspdm_test_verify_peer_cert_chain_buffer_case8),
1733 :
1734 : cmocka_unit_test(libspdm_test_set_data_case9),
1735 :
1736 : /* Successful response V1.1 for multi element opaque data supported version, element number is 2*/
1737 : cmocka_unit_test(libspdm_test_process_opaque_data_supported_version_data_case10),
1738 : /* Failed response V1.1 for multi element opaque data supported version, element id is wrong*/
1739 : cmocka_unit_test(libspdm_test_process_opaque_data_supported_version_data_case11),
1740 : /* Successful response V1.2 for multi element opaque data supported version, element number is 2*/
1741 : cmocka_unit_test(libspdm_test_process_opaque_data_supported_version_data_case12),
1742 : /* Failed response V1.2 for multi element opaque data supported version, element id is wrong*/
1743 : cmocka_unit_test(libspdm_test_process_opaque_data_supported_version_data_case13),
1744 : /* Successful response V1.1 for multi element opaque data selection version, element number is 2*/
1745 : cmocka_unit_test(libspdm_test_process_opaque_data_selection_version_data_case14),
1746 : /* Failed response V1.1 for multi element opaque data selection version, element number is wrong*/
1747 : cmocka_unit_test(libspdm_test_process_opaque_data_selection_version_data_case15),
1748 : /* Successful response V1.2 for multi element opaque data selection version, element number is 2*/
1749 : cmocka_unit_test(libspdm_test_process_opaque_data_selection_version_data_case16),
1750 : /* Failed response V1.2 for multi element opaque data selection version, element number is wrong*/
1751 : cmocka_unit_test(libspdm_test_process_opaque_data_selection_version_data_case17),
1752 :
1753 : /* Successful initialization and setting of secured message context location. */
1754 : cmocka_unit_test(libspdm_test_secured_message_context_location_selection_case18),
1755 :
1756 : /* Test that the Export Master Secret can be exported and cleared. */
1757 : cmocka_unit_test(libspdm_test_export_master_secret_case19),
1758 : cmocka_unit_test(libspdm_test_check_context_case20),
1759 :
1760 : /* Test the max DHE/PSK session count */
1761 : cmocka_unit_test(libspdm_test_max_session_count_case21),
1762 :
1763 : /* Successful response V1.2 for multi element */
1764 : cmocka_unit_test(libspdm_test_process_opaque_data_case22),
1765 : };
1766 :
1767 1 : libspdm_setup_test_context(&m_libspdm_common_context_data_test_context);
1768 :
1769 1 : return cmocka_run_group_tests(spdm_common_context_data_tests,
1770 : libspdm_unit_test_group_setup,
1771 : libspdm_unit_test_group_teardown);
1772 : }
|
