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_requester_lib.h"
9 : #include "internal/libspdm_secured_message_lib.h"
10 :
11 : #if LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT
12 :
13 : static uint8_t m_libspdm_local_certificate_chain[LIBSPDM_MAX_CERT_CHAIN_SIZE];
14 :
15 : static void *m_libspdm_local_certificate_chain_test_cert;
16 : static size_t m_libspdm_local_certificate_chain_size;
17 :
18 : static size_t m_libspdm_local_buffer_size;
19 : static uint8_t m_libspdm_local_buffer[LIBSPDM_MAX_MESSAGE_M1M2_BUFFER_SIZE];
20 :
21 : static bool m_get_digest;
22 :
23 : static spdm_key_usage_bit_mask_t m_local_key_usage_bit_mask[SPDM_MAX_SLOT_COUNT];
24 : static spdm_certificate_info_t m_local_cert_info[SPDM_MAX_SLOT_COUNT];
25 : static spdm_key_pair_id_t m_local_key_pair_id[SPDM_MAX_SLOT_COUNT];
26 :
27 13 : static libspdm_return_t libspdm_requester_get_digests_test_send_message(
28 : void *spdm_context, size_t request_size, const void *request,
29 : uint64_t timeout)
30 : {
31 : libspdm_test_context_t *spdm_test_context;
32 :
33 13 : spdm_test_context = libspdm_get_test_context();
34 13 : switch (spdm_test_context->case_id) {
35 0 : case 0x1:
36 0 : return LIBSPDM_STATUS_SEND_FAIL;
37 1 : case 0x2:
38 1 : return LIBSPDM_STATUS_SUCCESS;
39 0 : case 0x3:
40 0 : return LIBSPDM_STATUS_SUCCESS;
41 0 : case 0x4:
42 0 : return LIBSPDM_STATUS_SUCCESS;
43 0 : case 0x5:
44 0 : return LIBSPDM_STATUS_SUCCESS;
45 0 : case 0x6:
46 0 : return LIBSPDM_STATUS_SUCCESS;
47 0 : case 0x7:
48 0 : return LIBSPDM_STATUS_SUCCESS;
49 0 : case 0x8:
50 0 : return LIBSPDM_STATUS_SUCCESS;
51 0 : case 0x9:
52 0 : return LIBSPDM_STATUS_SUCCESS;
53 0 : case 0xA:
54 0 : return LIBSPDM_STATUS_SUCCESS;
55 0 : case 0xB:
56 0 : return LIBSPDM_STATUS_SUCCESS;
57 0 : case 0xC:
58 0 : return LIBSPDM_STATUS_SUCCESS;
59 0 : case 0xD:
60 0 : return LIBSPDM_STATUS_SUCCESS;
61 0 : case 0xE:
62 0 : return LIBSPDM_STATUS_SUCCESS;
63 0 : case 0xF:
64 0 : return LIBSPDM_STATUS_SUCCESS;
65 0 : case 0x10:
66 0 : return LIBSPDM_STATUS_SUCCESS;
67 0 : case 0x11:
68 0 : return LIBSPDM_STATUS_SUCCESS;
69 0 : case 0x12:
70 0 : return LIBSPDM_STATUS_SUCCESS;
71 0 : case 0x13:
72 0 : return LIBSPDM_STATUS_SUCCESS;
73 0 : case 0x14:
74 0 : return LIBSPDM_STATUS_SUCCESS;
75 0 : case 0x15:
76 0 : return LIBSPDM_STATUS_SUCCESS;
77 0 : case 0x16:
78 0 : return LIBSPDM_STATUS_SUCCESS;
79 1 : case 0x17: {
80 1 : const uint8_t *ptr = (const uint8_t *)request;
81 :
82 1 : m_libspdm_local_buffer_size = 0;
83 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
84 1 : &ptr[1], request_size - 1);
85 1 : m_libspdm_local_buffer_size += (request_size - 1);
86 : }
87 1 : return LIBSPDM_STATUS_SUCCESS;
88 4 : case 0x18:
89 4 : return LIBSPDM_STATUS_SUCCESS;
90 7 : case 0x19:
91 : case 0x1A:
92 : case 0x1B:
93 : case 0x1C:
94 : case 0x1D:
95 7 : return LIBSPDM_STATUS_SUCCESS;
96 0 : default:
97 0 : return LIBSPDM_STATUS_SEND_FAIL;
98 : }
99 : }
100 :
101 13 : static libspdm_return_t libspdm_requester_get_digests_test_receive_message(
102 : void *spdm_context, size_t *response_size,
103 : void **response, uint64_t timeout)
104 : {
105 : libspdm_test_context_t *spdm_test_context;
106 :
107 13 : spdm_test_context = libspdm_get_test_context();
108 13 : switch (spdm_test_context->case_id) {
109 0 : case 0x1:
110 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
111 :
112 1 : case 0x2: {
113 : spdm_digest_response_t *spdm_response;
114 : uint8_t *digest;
115 : size_t spdm_response_size;
116 : size_t transport_header_size;
117 :
118 : ((libspdm_context_t *)spdm_context)
119 1 : ->connection_info.algorithm.base_hash_algo =
120 : m_libspdm_use_hash_algo;
121 1 : spdm_response_size = sizeof(spdm_digest_response_t) +
122 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo) * SPDM_MAX_SLOT_COUNT;
123 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
124 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
125 :
126 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
127 1 : spdm_response->header.param1 = 0;
128 1 : spdm_response->header.request_response_code = SPDM_DIGESTS;
129 1 : spdm_response->header.param2 = 0;
130 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
131 : sizeof(m_libspdm_local_certificate_chain),
132 : (uint8_t)(0xFF));
133 :
134 1 : digest = (void *)(spdm_response + 1);
135 1 : libspdm_zero_mem (digest,
136 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo) * SPDM_MAX_SLOT_COUNT);
137 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
138 : sizeof(m_libspdm_local_certificate_chain), &digest[0]);
139 1 : spdm_response->header.param2 |= (0x01 << 0);
140 :
141 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
142 : false, spdm_response_size,
143 : spdm_response, response_size,
144 : response);
145 : }
146 1 : return LIBSPDM_STATUS_SUCCESS;
147 :
148 0 : case 0x3: {
149 : spdm_digest_response_t *spdm_response;
150 : uint8_t *digest;
151 : size_t spdm_response_size;
152 : size_t transport_header_size;
153 :
154 : ((libspdm_context_t *)spdm_context)
155 0 : ->connection_info.algorithm.base_hash_algo =
156 : m_libspdm_use_hash_algo;
157 0 : spdm_response_size = sizeof(spdm_digest_response_t) +
158 0 : libspdm_get_hash_size(m_libspdm_use_hash_algo);
159 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
160 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
161 :
162 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
163 0 : spdm_response->header.param1 = 0;
164 0 : spdm_response->header.request_response_code = SPDM_DIGESTS;
165 0 : spdm_response->header.param2 = 0;
166 0 : libspdm_set_mem(m_libspdm_local_certificate_chain,
167 : sizeof(m_libspdm_local_certificate_chain),
168 : (uint8_t)(0xFF));
169 :
170 0 : digest = (void *)(spdm_response + 1);
171 0 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
172 : sizeof(m_libspdm_local_certificate_chain), &digest[0]);
173 0 : spdm_response->header.param2 |= (1 << 0);
174 :
175 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
176 : false, spdm_response_size,
177 : spdm_response, response_size,
178 : response);
179 : }
180 0 : return LIBSPDM_STATUS_SUCCESS;
181 :
182 0 : case 0x4: {
183 : spdm_error_response_t *spdm_response;
184 : size_t spdm_response_size;
185 : size_t transport_header_size;
186 :
187 0 : spdm_response_size = sizeof(spdm_error_response_t);
188 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
189 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
190 :
191 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
192 0 : spdm_response->header.request_response_code = SPDM_ERROR;
193 0 : spdm_response->header.param1 = SPDM_ERROR_CODE_INVALID_REQUEST;
194 0 : spdm_response->header.param2 = 0;
195 :
196 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
197 : false, spdm_response_size,
198 : spdm_response,
199 : response_size, response);
200 : }
201 0 : return LIBSPDM_STATUS_SUCCESS;
202 :
203 0 : case 0x5: {
204 : spdm_error_response_t *spdm_response;
205 : size_t spdm_response_size;
206 : size_t transport_header_size;
207 :
208 0 : spdm_response_size = sizeof(spdm_error_response_t);
209 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
210 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
211 :
212 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
213 0 : spdm_response->header.request_response_code = SPDM_ERROR;
214 0 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
215 0 : spdm_response->header.param2 = 0;
216 :
217 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
218 : false, spdm_response_size,
219 : spdm_response,
220 : response_size, response);
221 : }
222 0 : return LIBSPDM_STATUS_SUCCESS;
223 :
224 0 : case 0x6: {
225 : static size_t sub_index1 = 0;
226 0 : if (sub_index1 == 0) {
227 : spdm_error_response_t *spdm_response;
228 : size_t spdm_response_size;
229 : size_t transport_header_size;
230 :
231 0 : spdm_response_size = sizeof(spdm_error_response_t);
232 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
233 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
234 :
235 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
236 0 : spdm_response->header.request_response_code = SPDM_ERROR;
237 0 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
238 0 : spdm_response->header.param2 = 0;
239 :
240 0 : libspdm_transport_test_encode_message(
241 : spdm_context, NULL, false, false,
242 : spdm_response_size, spdm_response,
243 : response_size, response);
244 0 : } else if (sub_index1 == 1) {
245 : spdm_digest_response_t *spdm_response;
246 : uint8_t *digest;
247 : size_t spdm_response_size;
248 : size_t transport_header_size;
249 :
250 : ((libspdm_context_t *)spdm_context)
251 0 : ->connection_info.algorithm.base_hash_algo =
252 : m_libspdm_use_hash_algo;
253 0 : spdm_response_size = sizeof(spdm_digest_response_t) +
254 0 : libspdm_get_hash_size(m_libspdm_use_hash_algo);
255 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
256 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
257 :
258 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
259 0 : spdm_response->header.param1 = 0;
260 0 : spdm_response->header.request_response_code = SPDM_DIGESTS;
261 0 : spdm_response->header.param2 = 0;
262 0 : libspdm_set_mem(m_libspdm_local_certificate_chain,
263 : sizeof(m_libspdm_local_certificate_chain), (uint8_t)(0xFF));
264 :
265 0 : digest = (void *)(spdm_response + 1);
266 0 : libspdm_hash_all(m_libspdm_use_hash_algo,
267 : m_libspdm_local_certificate_chain,
268 : sizeof(m_libspdm_local_certificate_chain), &digest[0]);
269 0 : spdm_response->header.param2 |= (1 << 0);
270 :
271 0 : libspdm_transport_test_encode_message(
272 : spdm_context, NULL, false, false, spdm_response_size,
273 : spdm_response, response_size, response);
274 : }
275 0 : sub_index1++;
276 : }
277 0 : return LIBSPDM_STATUS_SUCCESS;
278 :
279 0 : case 0x7: {
280 : spdm_error_response_t *spdm_response;
281 : size_t spdm_response_size;
282 : size_t transport_header_size;
283 :
284 0 : spdm_response_size = sizeof(spdm_error_response_t);
285 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
286 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
287 :
288 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
289 0 : spdm_response->header.request_response_code = SPDM_ERROR;
290 0 : spdm_response->header.param1 = SPDM_ERROR_CODE_REQUEST_RESYNCH;
291 0 : spdm_response->header.param2 = 0;
292 :
293 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
294 : false, spdm_response_size,
295 : spdm_response,
296 : response_size, response);
297 : }
298 0 : return LIBSPDM_STATUS_SUCCESS;
299 :
300 0 : case 0x8: {
301 : spdm_error_response_data_response_not_ready_t *spdm_response;
302 : size_t spdm_response_size;
303 : size_t transport_header_size;
304 :
305 0 : spdm_response_size = sizeof(spdm_error_response_data_response_not_ready_t);
306 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
307 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
308 :
309 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
310 0 : spdm_response->header.request_response_code = SPDM_ERROR;
311 0 : spdm_response->header.param1 = SPDM_ERROR_CODE_RESPONSE_NOT_READY;
312 0 : spdm_response->header.param2 = 0;
313 0 : spdm_response->extend_error_data.rd_exponent = 1;
314 0 : spdm_response->extend_error_data.rd_tm = 2;
315 0 : spdm_response->extend_error_data.request_code = SPDM_GET_DIGESTS;
316 0 : spdm_response->extend_error_data.token = 0;
317 :
318 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
319 : false, spdm_response_size,
320 : spdm_response,
321 : response_size, response);
322 : }
323 0 : return LIBSPDM_STATUS_SUCCESS;
324 :
325 0 : case 0x9: {
326 : static size_t sub_index2 = 0;
327 0 : if (sub_index2 == 0) {
328 : spdm_error_response_data_response_not_ready_t
329 : *spdm_response;
330 : size_t spdm_response_size;
331 : size_t transport_header_size;
332 :
333 0 : spdm_response_size = sizeof(spdm_error_response_data_response_not_ready_t);
334 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
335 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
336 :
337 0 : spdm_response->header.spdm_version =
338 : SPDM_MESSAGE_VERSION_10;
339 0 : spdm_response->header.request_response_code = SPDM_ERROR;
340 0 : spdm_response->header.param1 =
341 : SPDM_ERROR_CODE_RESPONSE_NOT_READY;
342 0 : spdm_response->header.param2 = 0;
343 0 : spdm_response->extend_error_data.rd_exponent = 1;
344 0 : spdm_response->extend_error_data.rd_tm = 2;
345 0 : spdm_response->extend_error_data.request_code =
346 : SPDM_GET_DIGESTS;
347 0 : spdm_response->extend_error_data.token = 1;
348 :
349 0 : libspdm_transport_test_encode_message(
350 : spdm_context, NULL, false, false,
351 : spdm_response_size, spdm_response,
352 : response_size, response);
353 0 : } else if (sub_index2 == 1) {
354 : spdm_digest_response_t *spdm_response;
355 : uint8_t *digest;
356 : size_t spdm_response_size;
357 : size_t transport_header_size;
358 :
359 : ((libspdm_context_t *)spdm_context)
360 0 : ->connection_info.algorithm.base_hash_algo =
361 : m_libspdm_use_hash_algo;
362 0 : spdm_response_size = sizeof(spdm_digest_response_t) +
363 0 : libspdm_get_hash_size(m_libspdm_use_hash_algo);
364 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
365 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
366 :
367 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
368 0 : spdm_response->header.param1 = 0;
369 0 : spdm_response->header.request_response_code = SPDM_DIGESTS;
370 0 : spdm_response->header.param2 = 0;
371 0 : libspdm_set_mem(m_libspdm_local_certificate_chain,
372 : sizeof(m_libspdm_local_certificate_chain), (uint8_t)(0xFF));
373 :
374 0 : digest = (void *)(spdm_response + 1);
375 0 : libspdm_hash_all(m_libspdm_use_hash_algo,
376 : m_libspdm_local_certificate_chain,
377 : sizeof(m_libspdm_local_certificate_chain), &digest[0]);
378 0 : spdm_response->header.param2 |= (1 << 0);
379 :
380 0 : libspdm_transport_test_encode_message(
381 : spdm_context, NULL, false, false, spdm_response_size,
382 : spdm_response, response_size, response);
383 : }
384 0 : sub_index2++;
385 : }
386 0 : return LIBSPDM_STATUS_SUCCESS;
387 :
388 0 : case 0xA:
389 0 : return LIBSPDM_STATUS_SUCCESS;
390 :
391 0 : case 0xB:
392 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
393 :
394 0 : case 0xC: {
395 : spdm_digest_response_t *spdm_response;
396 : size_t spdm_response_size;
397 : size_t transport_header_size;
398 :
399 : ((libspdm_context_t *)spdm_context)
400 0 : ->connection_info.algorithm.base_hash_algo =
401 : m_libspdm_use_hash_algo;
402 0 : spdm_response_size = 2;
403 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
404 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
405 :
406 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
407 0 : spdm_response->header.param1 = 0;
408 0 : spdm_response->header.request_response_code = SPDM_DIGESTS;
409 0 : spdm_response->header.param2 = 0;
410 :
411 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
412 : false, spdm_response_size,
413 : spdm_response, response_size,
414 : response);
415 : }
416 0 : return LIBSPDM_STATUS_SUCCESS;
417 :
418 0 : case 0xD: {
419 : spdm_digest_response_t *spdm_response;
420 : uint8_t *digest;
421 : size_t spdm_response_size;
422 : size_t transport_header_size;
423 :
424 : ((libspdm_context_t *)spdm_context)
425 0 : ->connection_info.algorithm.base_hash_algo =
426 : m_libspdm_use_hash_algo;
427 0 : spdm_response_size = sizeof(spdm_digest_response_t) +
428 0 : libspdm_get_hash_size(m_libspdm_use_hash_algo);
429 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
430 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
431 :
432 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
433 0 : spdm_response->header.param1 = 0;
434 0 : spdm_response->header.request_response_code = SPDM_CERTIFICATE;
435 0 : spdm_response->header.param2 = 0;
436 0 : libspdm_set_mem(m_libspdm_local_certificate_chain,
437 : sizeof(m_libspdm_local_certificate_chain),
438 : (uint8_t)(0xFF));
439 :
440 0 : digest = (void *)(spdm_response + 1);
441 0 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
442 : sizeof(m_libspdm_local_certificate_chain), &digest[0]);
443 0 : spdm_response->header.param2 |= (1 << 0);
444 :
445 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
446 : false, spdm_response_size,
447 : spdm_response, response_size,
448 : response);
449 : }
450 0 : return LIBSPDM_STATUS_SUCCESS;
451 :
452 0 : case 0xE: {
453 : spdm_digest_response_t *spdm_response;
454 : size_t spdm_response_size;
455 : size_t transport_header_size;
456 :
457 0 : spdm_response_size = sizeof(spdm_digest_response_t);
458 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
459 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
460 :
461 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
462 0 : spdm_response->header.param1 = 0;
463 0 : spdm_response->header.request_response_code = SPDM_DIGESTS;
464 0 : spdm_response->header.param2 = 0;
465 :
466 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
467 : false, spdm_response_size,
468 : spdm_response,
469 : response_size, response);
470 : }
471 0 : return LIBSPDM_STATUS_SUCCESS;
472 :
473 0 : case 0xF:
474 0 : return LIBSPDM_STATUS_SUCCESS;
475 :
476 0 : case 0x10: {
477 : spdm_digest_response_t *spdm_response;
478 : uint8_t *digest;
479 : size_t spdm_response_size;
480 : size_t transport_header_size;
481 :
482 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
483 : ((libspdm_context_t *)spdm_context)->transcript.message_b.buffer_size =
484 : ((libspdm_context_t *)spdm_context)->transcript.message_b.max_buffer_size -
485 : (sizeof(spdm_digest_response_t));
486 : #endif
487 :
488 : ((libspdm_context_t *)spdm_context)
489 0 : ->connection_info.algorithm.base_hash_algo =
490 : m_libspdm_use_hash_algo;
491 0 : spdm_response_size = sizeof(spdm_digest_response_t) +
492 0 : libspdm_get_hash_size(m_libspdm_use_hash_algo);
493 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
494 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
495 :
496 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
497 0 : spdm_response->header.param1 = 0;
498 0 : spdm_response->header.request_response_code = SPDM_DIGESTS;
499 0 : spdm_response->header.param2 = 0;
500 0 : libspdm_set_mem(m_libspdm_local_certificate_chain,
501 : sizeof(m_libspdm_local_certificate_chain),
502 : (uint8_t)(0xFF));
503 :
504 0 : digest = (void *)(spdm_response + 1);
505 0 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
506 : sizeof(m_libspdm_local_certificate_chain), &digest[0]);
507 0 : spdm_response->header.param2 |= (1 << 0);
508 :
509 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
510 : false, spdm_response_size,
511 : spdm_response, response_size,
512 : response);
513 : }
514 0 : return LIBSPDM_STATUS_SUCCESS;
515 :
516 0 : case 0x11: {
517 : spdm_digest_response_t *spdm_response;
518 : uint8_t *digest;
519 : size_t spdm_response_size;
520 : size_t transport_header_size;
521 :
522 : ((libspdm_context_t *)spdm_context)
523 0 : ->connection_info.algorithm.base_hash_algo =
524 : m_libspdm_use_hash_algo;
525 0 : spdm_response_size = sizeof(spdm_digest_response_t) +
526 0 : libspdm_get_hash_size(m_libspdm_use_hash_algo);
527 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
528 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
529 :
530 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
531 0 : spdm_response->header.param1 = 0;
532 0 : spdm_response->header.request_response_code = SPDM_DIGESTS;
533 0 : spdm_response->header.param2 = 0;
534 0 : libspdm_set_mem(m_libspdm_local_certificate_chain,
535 : sizeof(m_libspdm_local_certificate_chain),
536 : (uint8_t)(0xFF));
537 :
538 0 : digest = (void *)(spdm_response + 1);
539 0 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
540 : sizeof(m_libspdm_local_certificate_chain), &digest[0]);
541 0 : digest[libspdm_get_hash_size(m_libspdm_use_hash_algo) - 1] = 0;
542 0 : spdm_response->header.param2 |= (1 << 0);
543 :
544 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
545 : false, spdm_response_size,
546 : spdm_response, response_size,
547 : response);
548 : }
549 0 : return LIBSPDM_STATUS_SUCCESS;
550 :
551 0 : case 0x12: {
552 : spdm_digest_response_t *spdm_response;
553 : uint8_t *digest;
554 : size_t digest_count;
555 : size_t spdm_response_size;
556 : size_t transport_header_size;
557 : size_t index;
558 :
559 : ((libspdm_context_t *)spdm_context)
560 0 : ->connection_info.algorithm.base_hash_algo =
561 : m_libspdm_use_hash_algo;
562 0 : digest_count = 4;
563 0 : spdm_response_size = sizeof(spdm_digest_response_t) +
564 0 : libspdm_get_hash_size(m_libspdm_use_hash_algo);
565 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
566 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
567 :
568 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
569 0 : spdm_response->header.param1 = 0;
570 0 : spdm_response->header.request_response_code = SPDM_DIGESTS;
571 0 : spdm_response->header.param2 = 0;
572 0 : libspdm_set_mem(m_libspdm_local_certificate_chain,
573 : sizeof(m_libspdm_local_certificate_chain),
574 : (uint8_t)(0xFF));
575 :
576 0 : digest = (void *)(spdm_response + 1);
577 :
578 0 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
579 : sizeof(m_libspdm_local_certificate_chain), &digest[0]);
580 0 : for (index = 0; index < digest_count; index++) {
581 0 : spdm_response->header.param2 |= (1 << index);
582 : }
583 :
584 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
585 : false, spdm_response_size,
586 : spdm_response, response_size,
587 : response);
588 : }
589 0 : return LIBSPDM_STATUS_SUCCESS;
590 :
591 0 : case 0x13: {
592 : spdm_digest_response_t *spdm_response;
593 : uint8_t *digest;
594 : size_t digest_count;
595 : size_t spdm_response_size;
596 : size_t transport_header_size;
597 : size_t index;
598 :
599 : ((libspdm_context_t *)spdm_context)
600 0 : ->connection_info.algorithm.base_hash_algo =
601 : m_libspdm_use_hash_algo;
602 0 : digest_count = 4;
603 0 : spdm_response_size =
604 : sizeof(spdm_digest_response_t) +
605 0 : digest_count * libspdm_get_hash_size(m_libspdm_use_hash_algo);
606 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
607 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
608 :
609 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
610 0 : spdm_response->header.param1 = 0;
611 0 : spdm_response->header.request_response_code = SPDM_DIGESTS;
612 0 : spdm_response->header.param2 = 0;
613 0 : libspdm_set_mem(m_libspdm_local_certificate_chain,
614 : sizeof(m_libspdm_local_certificate_chain),
615 : (uint8_t)(0xFF));
616 :
617 0 : digest = (void *)(spdm_response + 1);
618 :
619 0 : for (index = 0; index < digest_count; index++) {
620 0 : libspdm_hash_all(
621 : m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
622 : sizeof(m_libspdm_local_certificate_chain),
623 0 : &digest[index *
624 0 : libspdm_get_hash_size(m_libspdm_use_hash_algo)]);
625 0 : spdm_response->header.param2 |= (1 << index);
626 0 : if (index == 0) {
627 0 : continue;
628 : }
629 0 : digest[(index + 1) * libspdm_get_hash_size(m_libspdm_use_hash_algo) -
630 0 : 1] = 0;
631 : }
632 :
633 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
634 : false, spdm_response_size,
635 : spdm_response, response_size,
636 : response);
637 : }
638 0 : return LIBSPDM_STATUS_SUCCESS;
639 :
640 0 : case 0x14: {
641 : spdm_digest_response_t *spdm_response;
642 : size_t spdm_response_size;
643 : size_t transport_header_size;
644 :
645 : ((libspdm_context_t *)spdm_context)
646 0 : ->connection_info.algorithm.base_hash_algo =
647 : m_libspdm_use_hash_algo;
648 0 : spdm_response_size = 5;
649 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
650 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
651 :
652 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
653 0 : spdm_response->header.param1 = 0;
654 0 : spdm_response->header.request_response_code = SPDM_DIGESTS;
655 0 : spdm_response->header.param2 = 0;
656 :
657 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
658 : false, spdm_response_size,
659 : spdm_response, response_size,
660 : response);
661 : }
662 0 : return LIBSPDM_STATUS_SUCCESS;
663 :
664 0 : case 0x15: {
665 : spdm_digest_response_t *spdm_response;
666 : uint8_t *digest;
667 : size_t spdm_response_size;
668 : size_t transport_header_size;
669 :
670 : ((libspdm_context_t *)spdm_context)
671 0 : ->connection_info.algorithm.base_hash_algo =
672 : m_libspdm_use_hash_algo;
673 0 : spdm_response_size = sizeof(spdm_message_header_t) +
674 : LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT + 1;
675 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
676 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
677 :
678 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
679 0 : spdm_response->header.param1 = 0;
680 0 : spdm_response->header.request_response_code = SPDM_DIGESTS;
681 0 : spdm_response->header.param2 = 0;
682 0 : libspdm_set_mem(m_libspdm_local_certificate_chain,
683 : sizeof(m_libspdm_local_certificate_chain),
684 : (uint8_t)(0xFF));
685 :
686 0 : digest = (void *)(spdm_response + 1);
687 0 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
688 : sizeof(m_libspdm_local_certificate_chain), &digest[0]);
689 0 : spdm_response->header.param2 |= (1 << 0);
690 :
691 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
692 : false, spdm_response_size,
693 : spdm_response, response_size,
694 : response);
695 : }
696 0 : return LIBSPDM_STATUS_SUCCESS;
697 :
698 0 : case 0x16:
699 : {
700 : static uint16_t error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
701 :
702 : spdm_error_response_t *spdm_response;
703 : size_t spdm_response_size;
704 : size_t transport_header_size;
705 :
706 0 : spdm_response_size = sizeof(spdm_error_response_t);
707 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
708 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
709 :
710 0 : if(error_code <= 0xff) {
711 0 : libspdm_zero_mem (spdm_response, spdm_response_size);
712 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
713 0 : spdm_response->header.request_response_code = SPDM_ERROR;
714 0 : spdm_response->header.param1 = (uint8_t) error_code;
715 0 : spdm_response->header.param2 = 0;
716 :
717 0 : libspdm_transport_test_encode_message (spdm_context, NULL, false, false,
718 : spdm_response_size, spdm_response,
719 : response_size, response);
720 : }
721 :
722 0 : error_code++;
723 0 : if(error_code == SPDM_ERROR_CODE_BUSY) { /*busy is treated in cases 5 and 6*/
724 0 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
725 : }
726 0 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) { /*skip some reserved error codes (0d to 3e)*/
727 0 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
728 : }
729 0 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) { /*skip response not ready, request resync, and some reserved codes (44 to fc)*/
730 0 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
731 : }
732 : }
733 0 : return LIBSPDM_STATUS_SUCCESS;
734 :
735 1 : case 0x17: {
736 : spdm_digest_response_t *spdm_response;
737 : uint8_t *digest;
738 : size_t spdm_response_size;
739 : size_t transport_header_size;
740 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
741 : size_t arbitrary_size;
742 : #endif
743 :
744 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
745 : /*filling B with arbitrary data*/
746 : arbitrary_size = 8;
747 : libspdm_set_mem(((libspdm_context_t *)spdm_context)->transcript.message_b.buffer,
748 : arbitrary_size, (uint8_t) 0xEE);
749 : ((libspdm_context_t *)spdm_context)->transcript.message_b.buffer_size =
750 : arbitrary_size;
751 : #endif
752 :
753 1 : ((libspdm_context_t *)spdm_context)->connection_info.algorithm.base_hash_algo =
754 : m_libspdm_use_hash_algo;
755 1 : spdm_response_size = sizeof(spdm_digest_response_t) +
756 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo);
757 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
758 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
759 :
760 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
761 1 : spdm_response->header.param1 = 0;
762 1 : spdm_response->header.request_response_code = SPDM_DIGESTS;
763 1 : spdm_response->header.param2 = 0;
764 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
765 : sizeof(m_libspdm_local_certificate_chain),
766 : (uint8_t)(0xFF));
767 :
768 1 : digest = (void *)(spdm_response + 1);
769 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
770 : sizeof(m_libspdm_local_certificate_chain), &digest[0]);
771 1 : spdm_response->header.param2 |= (0x01 << 0);
772 :
773 1 : libspdm_copy_mem(&m_libspdm_local_buffer[m_libspdm_local_buffer_size],
774 : sizeof(m_libspdm_local_buffer) - m_libspdm_local_buffer_size,
775 : spdm_response, spdm_response_size);
776 1 : m_libspdm_local_buffer_size += spdm_response_size;
777 :
778 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
779 : false, spdm_response_size,
780 : spdm_response, response_size,
781 : response);
782 : }
783 1 : return LIBSPDM_STATUS_SUCCESS;
784 :
785 4 : case 0x18: {
786 4 : if (m_get_digest) {
787 : spdm_digest_response_t *spdm_response;
788 : uint8_t *digest;
789 : size_t spdm_response_size;
790 : size_t transport_header_size;
791 :
792 : ((libspdm_context_t *)spdm_context)
793 2 : ->connection_info.algorithm.base_hash_algo =
794 : m_libspdm_use_hash_algo;
795 2 : spdm_response_size = sizeof(spdm_digest_response_t) +
796 2 : libspdm_get_hash_size(m_libspdm_use_hash_algo) *
797 : SPDM_MAX_SLOT_COUNT;
798 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
799 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
800 :
801 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
802 2 : spdm_response->header.param1 = 0;
803 2 : spdm_response->header.request_response_code = SPDM_DIGESTS;
804 2 : spdm_response->header.param2 = 0;
805 :
806 2 : if (m_libspdm_local_certificate_chain_test_cert == NULL) {
807 2 : libspdm_read_responder_public_certificate_chain(
808 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
809 : &m_libspdm_local_certificate_chain_test_cert,
810 : &m_libspdm_local_certificate_chain_size, NULL, NULL);
811 : }
812 2 : if (m_libspdm_local_certificate_chain_test_cert == NULL) {
813 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
814 : }
815 2 : digest = (void *)(spdm_response + 1);
816 2 : libspdm_zero_mem(digest,
817 2 : libspdm_get_hash_size(m_libspdm_use_hash_algo) * SPDM_MAX_SLOT_COUNT);
818 2 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain_test_cert,
819 : m_libspdm_local_certificate_chain_size, &digest[0]);
820 2 : spdm_response->header.param2 |= (0x01 << 0);
821 :
822 2 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
823 : false, spdm_response_size,
824 : spdm_response, response_size,
825 : response);
826 : } else {
827 : spdm_certificate_response_t *spdm_response;
828 : size_t spdm_response_size;
829 : size_t transport_header_size;
830 : uint16_t portion_length;
831 : uint16_t remainder_length;
832 : size_t count;
833 : static size_t calling_index = 0;
834 :
835 2 : if (m_libspdm_local_certificate_chain_test_cert == NULL) {
836 0 : libspdm_read_responder_public_certificate_chain(
837 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
838 : &m_libspdm_local_certificate_chain_test_cert,
839 : &m_libspdm_local_certificate_chain_size, NULL, NULL);
840 : }
841 2 : if (m_libspdm_local_certificate_chain_test_cert == NULL) {
842 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
843 : }
844 2 : count = (m_libspdm_local_certificate_chain_size +
845 2 : LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN - 1) /
846 : LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN;
847 2 : if (calling_index != count - 1) {
848 1 : portion_length = LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN;
849 1 : remainder_length =
850 1 : (uint16_t)(m_libspdm_local_certificate_chain_size -
851 : LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN *
852 1 : (calling_index + 1));
853 : } else {
854 1 : portion_length = (uint16_t)(
855 : m_libspdm_local_certificate_chain_size -
856 1 : LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN * (count - 1));
857 1 : remainder_length = 0;
858 : }
859 :
860 2 : spdm_response_size =
861 2 : sizeof(spdm_certificate_response_t) + portion_length;
862 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
863 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
864 :
865 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
866 2 : spdm_response->header.request_response_code = SPDM_CERTIFICATE;
867 2 : spdm_response->header.param1 = 0;
868 2 : spdm_response->header.param2 = 0;
869 2 : spdm_response->portion_length = portion_length;
870 2 : spdm_response->remainder_length = remainder_length;
871 2 : libspdm_copy_mem(spdm_response + 1,
872 2 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
873 2 : (uint8_t *)m_libspdm_local_certificate_chain_test_cert +
874 2 : LIBSPDM_MAX_CERT_CHAIN_BLOCK_LEN * calling_index,
875 : portion_length);
876 :
877 2 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
878 : false, spdm_response_size,
879 : spdm_response, response_size,
880 : response);
881 :
882 2 : calling_index++;
883 2 : if (calling_index == count) {
884 1 : calling_index = 0;
885 1 : free(m_libspdm_local_certificate_chain_test_cert);
886 1 : m_libspdm_local_certificate_chain_test_cert = NULL;
887 1 : m_libspdm_local_certificate_chain_size = 0;
888 : }
889 : }
890 : }
891 4 : return LIBSPDM_STATUS_SUCCESS;
892 :
893 1 : case 0x19: {
894 : spdm_digest_response_t *spdm_response;
895 : uint8_t *digest;
896 : size_t spdm_response_size;
897 : size_t transport_header_size;
898 : uint32_t session_id;
899 : libspdm_session_info_t *session_info;
900 : uint8_t *scratch_buffer;
901 : size_t scratch_buffer_size;
902 :
903 1 : session_id = 0xFFFFFFFF;
904 :
905 : ((libspdm_context_t *)spdm_context)
906 1 : ->connection_info.algorithm.base_hash_algo =
907 : m_libspdm_use_hash_algo;
908 1 : spdm_response_size = sizeof(spdm_digest_response_t) +
909 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo);
910 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
911 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
912 :
913 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
914 1 : spdm_response->header.param1 = 0;
915 1 : spdm_response->header.request_response_code = SPDM_DIGESTS;
916 1 : spdm_response->header.param2 = 0;
917 :
918 : /* For secure message, message is in sender buffer, we need copy it to scratch buffer.
919 : * transport_message is always in sender buffer. */
920 1 : libspdm_get_scratch_buffer (spdm_context, (void **)&scratch_buffer, &scratch_buffer_size);
921 :
922 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
923 : sizeof(m_libspdm_local_certificate_chain),
924 : (uint8_t)(0xFF));
925 :
926 1 : digest = (void *)(spdm_response + 1);
927 : /* send certchain digest of slot 7 */
928 1 : libspdm_zero_mem (digest,
929 1 : libspdm_get_hash_size(m_libspdm_use_hash_algo) * SPDM_MAX_SLOT_COUNT);
930 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
931 : sizeof(m_libspdm_local_certificate_chain), &digest[0]);
932 1 : spdm_response->header.param2 |= (0x80 << 0);
933 :
934 1 : libspdm_copy_mem (scratch_buffer + transport_header_size,
935 : scratch_buffer_size - transport_header_size,
936 : spdm_response, spdm_response_size);
937 1 : spdm_response = (void *)(scratch_buffer + transport_header_size);
938 1 : libspdm_transport_test_encode_message(spdm_context, &session_id, false,
939 : false, spdm_response_size,
940 : spdm_response, response_size,
941 : response);
942 :
943 1 : session_info = libspdm_get_session_info_via_session_id(
944 : spdm_context, session_id);
945 1 : if (session_info == NULL) {
946 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
947 : }
948 : /* WALKAROUND: If just use single context to encode message and then decode message */
949 : ((libspdm_secured_message_context_t
950 1 : *)(session_info->secured_message_context))
951 1 : ->application_secret.response_data_sequence_number--;
952 :
953 : }
954 1 : return LIBSPDM_STATUS_SUCCESS;
955 :
956 2 : case 0x1A: {
957 : spdm_digest_response_t *spdm_response;
958 : uint8_t *digest;
959 : size_t hash_size;
960 : size_t spdm_response_size;
961 : size_t transport_header_size;
962 : spdm_key_pair_id_t *key_pair_id;
963 : spdm_certificate_info_t *cert_info;
964 : spdm_key_usage_bit_mask_t *key_usage_bit_mask;
965 :
966 : ((libspdm_context_t *)spdm_context)
967 2 : ->connection_info.algorithm.base_hash_algo =
968 : m_libspdm_use_hash_algo;
969 2 : hash_size = libspdm_get_hash_size(m_libspdm_use_hash_algo);
970 2 : spdm_response_size = sizeof(spdm_digest_response_t) +
971 : hash_size + sizeof(spdm_key_pair_id_t) +
972 : sizeof(spdm_certificate_info_t) + sizeof(spdm_key_usage_bit_mask_t);
973 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
974 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
975 :
976 2 : spdm_response->header.request_response_code = SPDM_DIGESTS;
977 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
978 2 : spdm_response->header.param1 = (0x01 << 0);
979 2 : spdm_response->header.param2 = 0;
980 2 : spdm_response->header.param2 |= (0x01 << 0);
981 :
982 2 : libspdm_set_mem(m_libspdm_local_certificate_chain,
983 : sizeof(m_libspdm_local_certificate_chain),
984 : (uint8_t)(0xFF));
985 :
986 2 : digest = (void *)(spdm_response + 1);
987 2 : libspdm_zero_mem (digest, hash_size);
988 2 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
989 : sizeof(m_libspdm_local_certificate_chain), &digest[0]);
990 2 : key_pair_id = (spdm_key_pair_id_t *)((uint8_t *)digest + hash_size);
991 2 : cert_info = (spdm_certificate_info_t *)((uint8_t *)key_pair_id +
992 : sizeof(spdm_key_pair_id_t));
993 2 : key_usage_bit_mask = (spdm_key_usage_bit_mask_t *)((uint8_t *)cert_info +
994 : sizeof(spdm_certificate_info_t));
995 2 : *key_pair_id = 0;
996 2 : *cert_info = SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT;
997 2 : *key_usage_bit_mask = SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE |
998 : SPDM_KEY_USAGE_BIT_MASK_CHALLENGE_USE |
999 : SPDM_KEY_USAGE_BIT_MASK_MEASUREMENT_USE |
1000 : SPDM_KEY_USAGE_BIT_MASK_ENDPOINT_INFO_USE;
1001 :
1002 2 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
1003 : false, spdm_response_size,
1004 : spdm_response, response_size,
1005 : response);
1006 : }
1007 2 : return LIBSPDM_STATUS_SUCCESS;
1008 1 : case 0x1B: {
1009 : spdm_digest_response_t *spdm_response;
1010 : uint8_t *digest;
1011 : size_t spdm_response_size;
1012 : size_t transport_header_size;
1013 : spdm_key_pair_id_t *key_pair_id;
1014 : spdm_certificate_info_t *cert_info;
1015 : spdm_key_usage_bit_mask_t *key_usage_bit_mask;
1016 : uint32_t hash_size;
1017 : uint8_t slot_count;
1018 : size_t additional_size;
1019 :
1020 1 : slot_count = SPDM_MAX_SLOT_COUNT;
1021 1 : additional_size = sizeof(spdm_key_pair_id_t) + sizeof(spdm_certificate_info_t) +
1022 : sizeof(spdm_key_usage_bit_mask_t);
1023 1 : hash_size = libspdm_get_hash_size(m_libspdm_use_hash_algo);
1024 :
1025 1 : spdm_response_size = sizeof(spdm_digest_response_t) +
1026 1 : (hash_size + additional_size) * slot_count;
1027 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1028 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1029 :
1030 1 : spdm_response->header.request_response_code = SPDM_DIGESTS;
1031 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1032 1 : spdm_response->header.param1 = 0;
1033 1 : spdm_response->header.param2 = 0;
1034 :
1035 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
1036 : sizeof(m_libspdm_local_certificate_chain),
1037 : (uint8_t)(0xFF));
1038 :
1039 1 : digest = (void *)(spdm_response + 1);
1040 1 : libspdm_zero_mem (digest, hash_size * slot_count);
1041 1 : key_pair_id = (spdm_key_pair_id_t *)((uint8_t *)digest + (hash_size * slot_count));
1042 1 : cert_info = (spdm_certificate_info_t *)((uint8_t *)key_pair_id +
1043 1 : sizeof(spdm_key_pair_id_t) * slot_count);
1044 1 : key_usage_bit_mask = (spdm_key_usage_bit_mask_t *)((uint8_t *)cert_info +
1045 1 : sizeof(spdm_certificate_info_t) *
1046 : slot_count);
1047 :
1048 9 : for (uint8_t index = 0; index < slot_count; index++)
1049 : {
1050 8 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
1051 8 : sizeof(m_libspdm_local_certificate_chain), &digest[hash_size * index]);
1052 :
1053 8 : key_pair_id[index] = m_local_key_pair_id[index];
1054 8 : cert_info[index] = m_local_cert_info[index];
1055 8 : key_usage_bit_mask[index] = m_local_key_usage_bit_mask[index];
1056 :
1057 8 : spdm_response->header.param1 |= (1 << index);
1058 8 : spdm_response->header.param2 |= (1 << index);
1059 : }
1060 :
1061 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
1062 : false, spdm_response_size,
1063 : spdm_response, response_size,
1064 : response);
1065 : }
1066 1 : return LIBSPDM_STATUS_SUCCESS;
1067 2 : case 0x1C: {
1068 : spdm_digest_response_t *spdm_response;
1069 : uint8_t *digest;
1070 : size_t spdm_response_size;
1071 : size_t transport_header_size;
1072 : spdm_key_pair_id_t *key_pair_id;
1073 : spdm_certificate_info_t *cert_info;
1074 : spdm_key_usage_bit_mask_t *key_usage_bit_mask;
1075 : uint32_t hash_size;
1076 : uint8_t slot_count;
1077 : size_t additional_size;
1078 :
1079 2 : slot_count = 1;
1080 2 : additional_size = sizeof(spdm_key_pair_id_t) + sizeof(spdm_certificate_info_t) +
1081 : sizeof(spdm_key_usage_bit_mask_t);
1082 2 : hash_size = libspdm_get_hash_size(m_libspdm_use_hash_algo);
1083 :
1084 2 : spdm_response_size = sizeof(spdm_digest_response_t) +
1085 2 : (hash_size + additional_size) * slot_count;
1086 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1087 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1088 :
1089 2 : spdm_response->header.request_response_code = SPDM_DIGESTS;
1090 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1091 2 : spdm_response->header.param1 = 0;
1092 2 : spdm_response->header.param2 = 0;
1093 :
1094 2 : libspdm_set_mem(m_libspdm_local_certificate_chain,
1095 : sizeof(m_libspdm_local_certificate_chain),
1096 : (uint8_t)(0xFF));
1097 :
1098 2 : digest = (void *)(spdm_response + 1);
1099 2 : key_pair_id = (spdm_key_pair_id_t *)((uint8_t *)digest + (hash_size * slot_count));
1100 2 : cert_info = (spdm_certificate_info_t *)((uint8_t *)key_pair_id +
1101 2 : sizeof(spdm_key_pair_id_t) * slot_count);
1102 2 : key_usage_bit_mask = (spdm_key_usage_bit_mask_t *)((uint8_t *)cert_info +
1103 2 : sizeof(spdm_certificate_info_t) *
1104 : slot_count);
1105 :
1106 : /* Set Digest KeyUsageMask and CertificateInfo to 0*/
1107 2 : libspdm_zero_mem (digest, hash_size * slot_count);
1108 2 : key_pair_id[0] = m_local_key_pair_id[0];
1109 2 : cert_info[0] = m_local_cert_info[0];
1110 2 : key_usage_bit_mask[0] = m_local_key_usage_bit_mask[0];
1111 :
1112 2 : spdm_response->header.param1 |= (1 << 0);
1113 2 : spdm_response->header.param2 |= (1 << 0);
1114 :
1115 2 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
1116 : false, spdm_response_size,
1117 : spdm_response, response_size,
1118 : response);
1119 : }
1120 2 : return LIBSPDM_STATUS_SUCCESS;
1121 1 : case 0x1D: {
1122 : spdm_digest_response_t *spdm_response;
1123 : uint8_t *digest;
1124 : size_t spdm_response_size;
1125 : size_t transport_header_size;
1126 : spdm_key_pair_id_t *key_pair_id;
1127 : spdm_certificate_info_t *cert_info;
1128 : spdm_key_usage_bit_mask_t *key_usage_bit_mask;
1129 : uint32_t hash_size;
1130 : uint8_t slot_count;
1131 : size_t additional_size;
1132 :
1133 1 : slot_count = 2;
1134 1 : additional_size = sizeof(spdm_key_pair_id_t) + sizeof(spdm_certificate_info_t) +
1135 : sizeof(spdm_key_usage_bit_mask_t);
1136 1 : hash_size = libspdm_get_hash_size(m_libspdm_use_hash_algo);
1137 :
1138 1 : spdm_response_size = sizeof(spdm_digest_response_t) +
1139 1 : (hash_size + additional_size) * slot_count;
1140 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
1141 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
1142 :
1143 1 : spdm_response->header.request_response_code = SPDM_DIGESTS;
1144 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1145 1 : spdm_response->header.param1 = 0;
1146 1 : spdm_response->header.param2 = 0;
1147 :
1148 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
1149 : sizeof(m_libspdm_local_certificate_chain),
1150 : (uint8_t)(0xFF));
1151 :
1152 1 : digest = (void *)(spdm_response + 1);
1153 1 : key_pair_id = (spdm_key_pair_id_t *)((uint8_t *)digest + (hash_size * slot_count));
1154 1 : cert_info = (spdm_certificate_info_t *)((uint8_t *)key_pair_id +
1155 1 : sizeof(spdm_key_pair_id_t) * slot_count);
1156 1 : key_usage_bit_mask = (spdm_key_usage_bit_mask_t *)((uint8_t *)cert_info +
1157 1 : sizeof(spdm_certificate_info_t) *
1158 : slot_count);
1159 :
1160 1 : libspdm_zero_mem (digest, hash_size * slot_count);
1161 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
1162 : sizeof(m_libspdm_local_certificate_chain), &digest[hash_size * 0]);
1163 1 : key_pair_id[0] = m_local_key_pair_id[0];
1164 1 : cert_info[0] = m_local_cert_info[0];
1165 1 : key_usage_bit_mask[0] = m_local_key_usage_bit_mask[0];
1166 :
1167 1 : spdm_response->header.param1 |= (1 << 0);
1168 1 : spdm_response->header.param2 |= (1 << 0);
1169 :
1170 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
1171 1 : sizeof(m_libspdm_local_certificate_chain), &digest[hash_size * 1]);
1172 1 : key_pair_id[1] = m_local_key_pair_id[1];
1173 1 : cert_info[1] = m_local_cert_info[1];
1174 1 : key_usage_bit_mask[1] = m_local_key_usage_bit_mask[1];
1175 :
1176 1 : spdm_response->header.param1 |= (1 << 1);
1177 1 : spdm_response->header.param2 |= (1 << 1);
1178 :
1179 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
1180 : false, spdm_response_size,
1181 : spdm_response, response_size,
1182 : response);
1183 : }
1184 1 : return LIBSPDM_STATUS_SUCCESS;
1185 0 : default:
1186 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
1187 : }
1188 : }
1189 :
1190 : /**
1191 : * Test 1:
1192 : * Expected Behavior:
1193 : **/
1194 1 : static void libspdm_test_requester_get_digests_case1(void **state)
1195 : {
1196 1 : }
1197 :
1198 : /**
1199 : * Test 2: a request message is successfully sent and a response message is successfully received
1200 : * Expected Behavior: requester returns the status LIBSPDM_STATUS_SUCCESS and a DIGESTS message is received
1201 : **/
1202 1 : static void libspdm_test_requester_get_digests_case2(void **state)
1203 : {
1204 : libspdm_return_t status;
1205 : libspdm_test_context_t *spdm_test_context;
1206 : libspdm_context_t *spdm_context;
1207 : libspdm_data_parameter_t parameter;
1208 : uint8_t slot_mask;
1209 : uint8_t total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
1210 : uint8_t my_total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
1211 : uint8_t *digest;
1212 : size_t data_return_size;
1213 :
1214 1 : spdm_test_context = *state;
1215 1 : spdm_context = spdm_test_context->spdm_context;
1216 1 : spdm_test_context->case_id = 0x2;
1217 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1218 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1219 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1220 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
1221 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1222 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
1223 : sizeof(m_libspdm_local_certificate_chain),
1224 : (uint8_t)(0xFF));
1225 1 : libspdm_reset_message_b(spdm_context);
1226 :
1227 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1228 : spdm_context->transcript.message_m.buffer_size =
1229 : spdm_context->transcript.message_m.max_buffer_size;
1230 : #endif
1231 1 : libspdm_zero_mem(total_digest_buffer, sizeof(total_digest_buffer));
1232 1 : status = libspdm_get_digest(spdm_context, NULL, &slot_mask, &total_digest_buffer);
1233 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1234 :
1235 1 : assert_int_equal(slot_mask, 0x01);
1236 1 : libspdm_zero_mem(my_total_digest_buffer, sizeof(my_total_digest_buffer));
1237 1 : digest = my_total_digest_buffer;
1238 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
1239 : sizeof(m_libspdm_local_certificate_chain), digest);
1240 1 : assert_memory_equal (total_digest_buffer, my_total_digest_buffer,
1241 : sizeof(my_total_digest_buffer));
1242 :
1243 1 : parameter.location = LIBSPDM_DATA_LOCATION_CONNECTION;
1244 1 : data_return_size = sizeof(uint8_t);
1245 1 : status = libspdm_get_data(spdm_context, LIBSPDM_DATA_PEER_SLOT_MASK,
1246 : ¶meter, &slot_mask, &data_return_size);
1247 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1248 1 : assert_int_equal(data_return_size, sizeof(uint8_t));
1249 1 : assert_int_equal(slot_mask, 0x01);
1250 :
1251 1 : data_return_size = sizeof(total_digest_buffer);
1252 1 : status = libspdm_get_data(spdm_context, LIBSPDM_DATA_PEER_TOTAL_DIGEST_BUFFER,
1253 : ¶meter, total_digest_buffer, &data_return_size);
1254 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1255 1 : assert_int_equal(data_return_size, libspdm_get_hash_size(m_libspdm_use_hash_algo));
1256 1 : assert_memory_equal (total_digest_buffer, my_total_digest_buffer,
1257 : sizeof(my_total_digest_buffer));
1258 :
1259 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1260 : assert_int_equal(
1261 : spdm_context->transcript.message_b.buffer_size,
1262 : sizeof(spdm_get_digest_request_t) +
1263 : sizeof(spdm_digest_response_t) +
1264 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo));
1265 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1266 : #endif
1267 1 : }
1268 :
1269 : /**
1270 : * Test 3:
1271 : * Expected Behavior:
1272 : **/
1273 1 : static void libspdm_test_requester_get_digests_case3(void **state)
1274 : {
1275 1 : }
1276 :
1277 : /**
1278 : * Test 4:
1279 : * Expected Behavior:
1280 : **/
1281 1 : static void libspdm_test_requester_get_digests_case4(void **state)
1282 : {
1283 1 : }
1284 :
1285 : /**
1286 : * Test 5:
1287 : * Expected Behavior:
1288 : **/
1289 1 : static void libspdm_test_requester_get_digests_case5(void **state)
1290 : {
1291 1 : }
1292 :
1293 : /**
1294 : * Test 6:
1295 : * Expected Behavior:
1296 : **/
1297 1 : static void libspdm_test_requester_get_digests_case6(void **state)
1298 : {
1299 1 : }
1300 :
1301 : /**
1302 : * Test 7:
1303 : * Expected Behavior:
1304 : **/
1305 1 : static void libspdm_test_requester_get_digests_case7(void **state)
1306 : {
1307 1 : }
1308 :
1309 : /**
1310 : * Test 8:
1311 : * Expected Behavior:
1312 : **/
1313 1 : static void libspdm_test_requester_get_digests_case8(void **state)
1314 : {
1315 1 : }
1316 :
1317 : /**
1318 : * Test 9:
1319 : * Expected Behavior:
1320 : **/
1321 1 : static void libspdm_test_requester_get_digests_case9(void **state)
1322 : {
1323 1 : }
1324 :
1325 : /**
1326 : * Test 10:
1327 : * Expected Behavior:
1328 : **/
1329 1 : static void libspdm_test_requester_get_digests_case10(void **state)
1330 : {
1331 1 : }
1332 :
1333 : /**
1334 : * Test 11:
1335 : * Expected Behavior:
1336 : **/
1337 1 : static void libspdm_test_requester_get_digests_case11(void **state)
1338 : {
1339 1 : }
1340 :
1341 : /**
1342 : * Test 12:
1343 : * Expected Behavior:
1344 : **/
1345 1 : static void libspdm_test_requester_get_digests_case12(void **state)
1346 : {
1347 1 : }
1348 :
1349 : /**
1350 : * Test 13:
1351 : * Expected Behavior:
1352 : **/
1353 1 : static void libspdm_test_requester_get_digests_case13(void **state)
1354 : {
1355 1 : }
1356 :
1357 : /**
1358 : * Test 14:
1359 : * Expected Behavior:
1360 : **/
1361 1 : static void libspdm_test_requester_get_digests_case14(void **state)
1362 : {
1363 1 : }
1364 :
1365 : /**
1366 : * Test 15:
1367 : * Expected Behavior:
1368 : **/
1369 1 : static void libspdm_test_requester_get_digests_case15(void **state)
1370 : {
1371 1 : }
1372 :
1373 : /**
1374 : * Test 16:
1375 : * Expected Behavior:
1376 : **/
1377 1 : static void libspdm_test_requester_get_digests_case16(void **state)
1378 : {
1379 1 : }
1380 :
1381 : /**
1382 : * Test 17:
1383 : * Expected Behavior:
1384 : **/
1385 1 : static void libspdm_test_requester_get_digests_case17(void **state)
1386 : {
1387 1 : }
1388 :
1389 : /**
1390 : * Test 18:
1391 : * Expected Behavior:
1392 : **/
1393 1 : static void libspdm_test_requester_get_digests_case18(void **state)
1394 : {
1395 1 : }
1396 :
1397 : /**
1398 : * Test 19:
1399 : * Expected Behavior:
1400 : **/
1401 1 : static void libspdm_test_requester_get_digests_case19(void **state)
1402 : {
1403 1 : }
1404 :
1405 : /**
1406 : * Test 20:
1407 : * Expected Behavior:
1408 : **/
1409 1 : static void libspdm_test_requester_get_digests_case20(void **state)
1410 : {
1411 1 : }
1412 :
1413 : /**
1414 : * Test 21:
1415 : * Expected Behavior:
1416 : **/
1417 1 : static void libspdm_test_requester_get_digests_case21(void **state)
1418 : {
1419 1 : }
1420 :
1421 : /**
1422 : * Test 22:
1423 : * Expected behavior:.
1424 : **/
1425 1 : static void libspdm_test_requester_get_digests_case22(void **state)
1426 : {
1427 1 : }
1428 :
1429 : /**
1430 : * Test 23: a request message is successfully sent and a response message is successfully received.
1431 : * Buffer B already has arbitrary data.
1432 : * Expected Behavior: requester returns the status RETURN_SUCCESS and a DIGESTS message is
1433 : * received, buffer B appends the exchanged GET_DIGESTS and DIGESTS messages.
1434 : **/
1435 1 : static void libspdm_test_requester_get_digests_case23(void **state)
1436 : {
1437 : libspdm_return_t status;
1438 : libspdm_test_context_t *spdm_test_context;
1439 : libspdm_context_t *spdm_context;
1440 : uint8_t slot_mask;
1441 : uint8_t total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
1442 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1443 : size_t arbitrary_size;
1444 : #endif
1445 :
1446 1 : spdm_test_context = *state;
1447 1 : spdm_context = spdm_test_context->spdm_context;
1448 1 : spdm_test_context->case_id = 0x17;
1449 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1450 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1451 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1452 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
1453 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1454 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
1455 : sizeof(m_libspdm_local_certificate_chain),
1456 : (uint8_t)(0xFF));
1457 1 : libspdm_reset_message_b(spdm_context);
1458 :
1459 1 : libspdm_zero_mem(total_digest_buffer, sizeof(total_digest_buffer));
1460 1 : status = libspdm_get_digest(spdm_context, NULL, &slot_mask, &total_digest_buffer);
1461 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1462 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1463 : arbitrary_size = 8;
1464 : assert_int_equal(spdm_context->transcript.message_b.buffer_size,
1465 : arbitrary_size + m_libspdm_local_buffer_size);
1466 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "m_libspdm_local_buffer (0x%x):\n",
1467 : m_libspdm_local_buffer_size));
1468 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
1469 : assert_memory_equal(spdm_context->transcript.message_b.buffer + arbitrary_size,
1470 : m_libspdm_local_buffer, m_libspdm_local_buffer_size);
1471 : #endif
1472 1 : }
1473 :
1474 : /**
1475 : * Test 24: Test case for GetDigest, GetCert and GetDigest
1476 : * Expected Behavior: requester returns the status LIBSPDM_STATUS_SUCCESS and a second GetDigest can be sent.
1477 : **/
1478 1 : static void libspdm_test_requester_get_digests_case24(void **state)
1479 : {
1480 : libspdm_return_t status;
1481 : libspdm_test_context_t *spdm_test_context;
1482 : libspdm_context_t *spdm_context;
1483 : libspdm_data_parameter_t parameter;
1484 : uint8_t slot_mask;
1485 : uint8_t total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
1486 : uint8_t my_total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
1487 : uint8_t *digest;
1488 : size_t data_return_size;
1489 : void *data;
1490 : size_t data_size;
1491 : void *hash;
1492 : size_t hash_size;
1493 : const uint8_t *root_cert;
1494 : size_t root_cert_size;
1495 : size_t cert_chain_size;
1496 : uint8_t cert_chain[LIBSPDM_MAX_CERT_CHAIN_SIZE];
1497 :
1498 1 : spdm_test_context = *state;
1499 1 : spdm_context = spdm_test_context->spdm_context;
1500 1 : spdm_test_context->case_id = 0x18;
1501 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1502 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1503 1 : spdm_context->connection_info.capability.flags |=
1504 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
1505 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1506 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1507 : m_libspdm_use_hash_algo;
1508 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1509 : m_libspdm_use_asym_algo;
1510 1 : spdm_context->connection_info.algorithm.req_base_asym_alg =
1511 : m_libspdm_use_req_asym_algo;
1512 1 : spdm_context->local_context.is_requester = true;
1513 :
1514 1 : libspdm_read_responder_public_certificate_chain(m_libspdm_use_hash_algo,
1515 : m_libspdm_use_asym_algo, &data,
1516 : &data_size, &hash, &hash_size);
1517 1 : libspdm_x509_get_cert_from_cert_chain(
1518 1 : (uint8_t *)data + sizeof(spdm_cert_chain_t) + hash_size,
1519 1 : data_size - sizeof(spdm_cert_chain_t) - hash_size, 0,
1520 : &root_cert, &root_cert_size);
1521 1 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "root cert data :\n"));
1522 1 : libspdm_dump_hex(root_cert, root_cert_size);
1523 1 : spdm_context->local_context.peer_root_cert_provision_size[0] =
1524 : root_cert_size;
1525 1 : spdm_context->local_context.peer_root_cert_provision[0] = root_cert;
1526 :
1527 1 : m_get_digest = true;
1528 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1529 : spdm_context->transcript.message_m.buffer_size =
1530 : spdm_context->transcript.message_m.max_buffer_size;
1531 : #endif
1532 1 : libspdm_zero_mem(total_digest_buffer, sizeof(total_digest_buffer));
1533 : /* first GetDigest */
1534 1 : status = libspdm_get_digest(spdm_context, NULL, &slot_mask, &total_digest_buffer);
1535 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1536 1 : assert_int_equal(slot_mask, 0x01);
1537 1 : libspdm_zero_mem(my_total_digest_buffer, sizeof(my_total_digest_buffer));
1538 1 : digest = my_total_digest_buffer;
1539 1 : if (m_libspdm_local_certificate_chain_test_cert == NULL) {
1540 0 : libspdm_read_responder_public_certificate_chain(
1541 : m_libspdm_use_hash_algo, m_libspdm_use_asym_algo,
1542 : &m_libspdm_local_certificate_chain_test_cert,
1543 : &m_libspdm_local_certificate_chain_size, NULL, NULL);
1544 : }
1545 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain_test_cert,
1546 : m_libspdm_local_certificate_chain_size, digest);
1547 1 : assert_memory_equal(total_digest_buffer, my_total_digest_buffer,
1548 : sizeof(my_total_digest_buffer));
1549 :
1550 1 : parameter.location = LIBSPDM_DATA_LOCATION_CONNECTION;
1551 1 : data_return_size = sizeof(uint8_t);
1552 1 : status = libspdm_get_data(spdm_context, LIBSPDM_DATA_PEER_SLOT_MASK,
1553 : ¶meter, &slot_mask, &data_return_size);
1554 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1555 1 : assert_int_equal(data_return_size, sizeof(uint8_t));
1556 1 : assert_int_equal(slot_mask, 0x01);
1557 :
1558 1 : data_return_size = sizeof(total_digest_buffer);
1559 1 : status = libspdm_get_data(spdm_context, LIBSPDM_DATA_PEER_TOTAL_DIGEST_BUFFER,
1560 : ¶meter, total_digest_buffer, &data_return_size);
1561 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1562 1 : assert_int_equal(data_return_size, libspdm_get_hash_size(m_libspdm_use_hash_algo));
1563 1 : assert_memory_equal (total_digest_buffer, my_total_digest_buffer,
1564 : sizeof(my_total_digest_buffer));
1565 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1566 : assert_int_equal(
1567 : spdm_context->transcript.message_b.buffer_size,
1568 : sizeof(spdm_get_digest_request_t) +
1569 : sizeof(spdm_digest_response_t) +
1570 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo));
1571 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1572 : #endif
1573 :
1574 1 : m_get_digest = false;
1575 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1576 : spdm_context->transcript.message_m.buffer_size =
1577 : spdm_context->transcript.message_m.max_buffer_size;
1578 : #endif
1579 1 : cert_chain_size = sizeof(cert_chain);
1580 1 : libspdm_zero_mem(cert_chain, sizeof(cert_chain));
1581 1 : status = libspdm_get_certificate(spdm_context, NULL, 0, &cert_chain_size,
1582 : cert_chain);
1583 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1584 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1585 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1586 : #endif
1587 1 : free(data);
1588 :
1589 1 : m_get_digest = true;
1590 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1591 : spdm_context->transcript.message_m.buffer_size =
1592 : spdm_context->transcript.message_m.max_buffer_size;
1593 : #endif
1594 1 : libspdm_zero_mem(total_digest_buffer, sizeof(total_digest_buffer));
1595 : /* second GetDigest */
1596 1 : status = libspdm_get_digest(spdm_context, NULL, &slot_mask, &total_digest_buffer);
1597 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1598 1 : assert_int_equal(slot_mask, 0x01);
1599 1 : libspdm_zero_mem(my_total_digest_buffer, sizeof(my_total_digest_buffer));
1600 1 : digest = my_total_digest_buffer;
1601 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain_test_cert,
1602 : m_libspdm_local_certificate_chain_size, digest);
1603 1 : assert_memory_equal (total_digest_buffer, my_total_digest_buffer,
1604 : sizeof(my_total_digest_buffer));
1605 1 : data_return_size = sizeof(uint8_t);
1606 1 : status = libspdm_get_data(spdm_context, LIBSPDM_DATA_PEER_SLOT_MASK,
1607 : ¶meter, &slot_mask, &data_return_size);
1608 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1609 1 : assert_int_equal(data_return_size, sizeof(uint8_t));
1610 1 : assert_int_equal(slot_mask, 0x01);
1611 1 : data_return_size = sizeof(total_digest_buffer);
1612 1 : status = libspdm_get_data(spdm_context, LIBSPDM_DATA_PEER_TOTAL_DIGEST_BUFFER,
1613 : ¶meter, total_digest_buffer, &data_return_size);
1614 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1615 1 : assert_int_equal(data_return_size, libspdm_get_hash_size(m_libspdm_use_hash_algo));
1616 1 : assert_memory_equal (total_digest_buffer, my_total_digest_buffer,
1617 : sizeof(my_total_digest_buffer));
1618 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1619 : assert_int_equal(
1620 : spdm_context->transcript.message_b.buffer_size,
1621 : sizeof(spdm_get_digest_request_t) +
1622 : sizeof(spdm_digest_response_t) +
1623 : libspdm_get_hash_size(spdm_context->connection_info.algorithm.base_hash_algo));
1624 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
1625 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_size = 0;
1626 : #else
1627 1 : spdm_context->connection_info.peer_used_cert_chain[0].buffer_hash_size = 0;
1628 : #endif
1629 1 : }
1630 :
1631 : /**
1632 : * Test 25: a request message is successfully sent and a response message is successfully received
1633 : * in a session.
1634 : * Expected Behavior: requester returns the status LIBSPDM_STATUS_SUCCESS and a DIGESTS message is received
1635 : **/
1636 1 : static void libspdm_test_requester_get_digests_case25(void **state)
1637 : {
1638 : libspdm_return_t status;
1639 : libspdm_test_context_t *spdm_test_context;
1640 : libspdm_context_t *spdm_context;
1641 : libspdm_data_parameter_t parameter;
1642 : uint8_t slot_mask;
1643 : uint8_t total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
1644 : uint8_t my_total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
1645 : uint8_t *digest;
1646 : size_t data_return_size;
1647 : uint32_t session_id;
1648 : libspdm_session_info_t *session_info;
1649 :
1650 1 : spdm_test_context = *state;
1651 1 : spdm_context = spdm_test_context->spdm_context;
1652 1 : spdm_test_context->case_id = 0x19;
1653 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1654 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1655 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1656 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
1657 1 : spdm_context->connection_info.capability.flags |=
1658 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1659 1 : spdm_context->connection_info.capability.flags |=
1660 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1661 1 : spdm_context->connection_info.capability.flags |=
1662 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1663 1 : spdm_context->local_context.capability.flags |=
1664 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1665 1 : spdm_context->local_context.capability.flags |=
1666 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1667 1 : spdm_context->local_context.capability.flags |=
1668 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1669 1 : spdm_context->connection_info.algorithm.dhe_named_group =
1670 : m_libspdm_use_dhe_algo;
1671 1 : spdm_context->connection_info.algorithm.aead_cipher_suite =
1672 : m_libspdm_use_aead_algo;
1673 :
1674 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1675 :
1676 1 : session_id = 0xFFFFFFFF;
1677 1 : session_info = &spdm_context->session_info[0];
1678 1 : libspdm_session_info_init(spdm_context, session_info, session_id, true);
1679 1 : libspdm_secured_message_set_session_state(session_info->secured_message_context,
1680 : LIBSPDM_SESSION_STATE_ESTABLISHED);
1681 :
1682 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
1683 : sizeof(m_libspdm_local_certificate_chain),
1684 : (uint8_t)(0xFF));
1685 1 : libspdm_reset_message_b(spdm_context);
1686 :
1687 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1688 : session_info->session_transcript.message_m.buffer_size =
1689 : session_info->session_transcript.message_m.max_buffer_size;
1690 : #endif
1691 1 : libspdm_zero_mem(total_digest_buffer, sizeof(total_digest_buffer));
1692 1 : status = libspdm_get_digest(spdm_context, &session_id, &slot_mask, &total_digest_buffer);
1693 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1694 :
1695 1 : assert_int_equal(slot_mask, 0x80);
1696 1 : libspdm_zero_mem(my_total_digest_buffer, sizeof(my_total_digest_buffer));
1697 1 : digest = my_total_digest_buffer;
1698 1 : libspdm_hash_all(m_libspdm_use_hash_algo, m_libspdm_local_certificate_chain,
1699 : sizeof(m_libspdm_local_certificate_chain), digest);
1700 1 : assert_memory_equal (total_digest_buffer, my_total_digest_buffer,
1701 : sizeof(my_total_digest_buffer));
1702 :
1703 1 : parameter.location = LIBSPDM_DATA_LOCATION_CONNECTION;
1704 1 : data_return_size = sizeof(uint8_t);
1705 1 : status = libspdm_get_data(spdm_context, LIBSPDM_DATA_PEER_SLOT_MASK,
1706 : ¶meter, &slot_mask, &data_return_size);
1707 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1708 1 : assert_int_equal(data_return_size, sizeof(uint8_t));
1709 1 : assert_int_equal(slot_mask, 0x80);
1710 :
1711 1 : data_return_size = sizeof(total_digest_buffer);
1712 1 : status = libspdm_get_data(spdm_context, LIBSPDM_DATA_PEER_TOTAL_DIGEST_BUFFER,
1713 : ¶meter, total_digest_buffer, &data_return_size);
1714 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1715 1 : assert_int_equal(data_return_size, libspdm_get_hash_size(m_libspdm_use_hash_algo));
1716 1 : assert_memory_equal (total_digest_buffer, my_total_digest_buffer,
1717 : sizeof(my_total_digest_buffer));
1718 :
1719 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1720 : assert_int_equal(session_info->session_transcript.message_m.buffer_size, 0);
1721 : #endif
1722 1 : }
1723 :
1724 :
1725 : /**
1726 : * Test 26: a response message is successfully sent ,
1727 : * Set multi_key_conn_rsp to check if it responds correctly
1728 : * Expected Behavior: requester returns the status LIBSPDM_STATUS_SUCCESS
1729 : **/
1730 1 : static void libspdm_test_requester_get_digests_case26(void **state)
1731 : {
1732 : libspdm_return_t status;
1733 : libspdm_test_context_t *spdm_test_context;
1734 : libspdm_context_t *spdm_context;
1735 : uint8_t slot_mask;
1736 : uint8_t total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
1737 :
1738 1 : spdm_test_context = *state;
1739 1 : spdm_context = spdm_test_context->spdm_context;
1740 1 : spdm_test_context->case_id = 0x1A;
1741 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
1742 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1743 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1744 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
1745 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1746 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
1747 : sizeof(m_libspdm_local_certificate_chain),
1748 : (uint8_t)(0xFF));
1749 1 : libspdm_reset_message_b(spdm_context);
1750 :
1751 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1752 : spdm_context->transcript.message_m.buffer_size =
1753 : spdm_context->transcript.message_m.max_buffer_size;
1754 : #endif
1755 : /* Sub Case 1: Set multi_key_conn_rsp to true*/
1756 1 : spdm_context->connection_info.multi_key_conn_rsp = true;
1757 1 : libspdm_reset_message_d(spdm_context);
1758 :
1759 1 : libspdm_zero_mem(total_digest_buffer, sizeof(total_digest_buffer));
1760 1 : status = libspdm_get_digest(spdm_context, NULL, &slot_mask, &total_digest_buffer);
1761 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1762 1 : assert_int_equal(
1763 : spdm_context->transcript.message_d.buffer_size,
1764 : sizeof(spdm_digest_response_t) + sizeof(spdm_key_pair_id_t) + sizeof(spdm_certificate_info_t) +
1765 : sizeof(spdm_key_usage_bit_mask_t) +
1766 : libspdm_get_hash_size(
1767 : spdm_context->connection_info.algorithm.base_hash_algo));
1768 :
1769 : /* Sub Case 2: Set multi_key_conn_rsp to false*/
1770 1 : spdm_context->connection_info.multi_key_conn_rsp = false;
1771 1 : libspdm_reset_message_d(spdm_context);
1772 :
1773 1 : libspdm_zero_mem(total_digest_buffer, sizeof(total_digest_buffer));
1774 1 : status = libspdm_get_digest(spdm_context, NULL, &slot_mask, &total_digest_buffer);
1775 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1776 1 : assert_int_equal(spdm_context->transcript.message_d.buffer_size,0);
1777 1 : }
1778 :
1779 : /**
1780 : * Test 27: a response message is successfully sent ,
1781 : * Set multi_key_conn_rsp to check if it responds correctly
1782 : * Expected Behavior: requester returns the status LIBSPDM_STATUS_SUCCESS
1783 : **/
1784 1 : static void libspdm_test_requester_get_digests_case27(void **state)
1785 : {
1786 : libspdm_return_t status;
1787 : libspdm_test_context_t *spdm_test_context;
1788 : libspdm_context_t *spdm_context;
1789 : uint8_t slot_mask;
1790 : uint8_t total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
1791 : uint32_t hash_size;
1792 : uint8_t slot_count;
1793 : size_t additional_size;
1794 :
1795 1 : spdm_test_context = *state;
1796 1 : spdm_context = spdm_test_context->spdm_context;
1797 1 : spdm_test_context->case_id = 0x1B;
1798 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
1799 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1800 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1801 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
1802 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1803 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
1804 : sizeof(m_libspdm_local_certificate_chain),
1805 : (uint8_t)(0xFF));
1806 1 : libspdm_reset_message_b(spdm_context);
1807 :
1808 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1809 : spdm_context->transcript.message_m.buffer_size =
1810 : spdm_context->transcript.message_m.max_buffer_size;
1811 : #endif
1812 1 : spdm_context->connection_info.multi_key_conn_rsp = true;
1813 1 : libspdm_reset_message_d(spdm_context);
1814 :
1815 1 : m_local_key_pair_id[0] = 0x00;
1816 1 : m_local_cert_info[0] = SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT;
1817 1 : m_local_key_usage_bit_mask[0] = SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE;
1818 :
1819 1 : m_local_key_pair_id[1] = 0x01;
1820 1 : m_local_cert_info[1] = SPDM_CERTIFICATE_INFO_CERT_MODEL_ALIAS_CERT;
1821 1 : m_local_key_usage_bit_mask[1] = SPDM_KEY_USAGE_BIT_MASK_CHALLENGE_USE;
1822 :
1823 1 : m_local_key_pair_id[2] = 0x02;
1824 1 : m_local_cert_info[2] = SPDM_CERTIFICATE_INFO_CERT_MODEL_GENERIC_CERT;
1825 1 : m_local_key_usage_bit_mask[2] = SPDM_KEY_USAGE_BIT_MASK_MEASUREMENT_USE;
1826 :
1827 1 : m_local_key_pair_id[3] = 0x03;
1828 1 : m_local_cert_info[3] = SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT;
1829 1 : m_local_key_usage_bit_mask[3] = SPDM_KEY_USAGE_BIT_MASK_ENDPOINT_INFO_USE;
1830 :
1831 1 : m_local_key_pair_id[4] = 0x04;
1832 1 : m_local_cert_info[4] = SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT;
1833 1 : m_local_key_usage_bit_mask[4] = SPDM_KEY_USAGE_BIT_MASK_STANDARDS_KEY_USE;
1834 :
1835 1 : m_local_key_pair_id[5] = 0x05;
1836 1 : m_local_cert_info[5] = SPDM_CERTIFICATE_INFO_CERT_MODEL_GENERIC_CERT;
1837 1 : m_local_key_usage_bit_mask[5] = SPDM_KEY_USAGE_BIT_MASK_VENDOR_KEY_USE;
1838 :
1839 1 : m_local_key_pair_id[6] = 0x06;
1840 1 : m_local_cert_info[6] = SPDM_CERTIFICATE_INFO_CERT_MODEL_GENERIC_CERT;
1841 1 : m_local_key_usage_bit_mask[6] = SPDM_KEY_USAGE_BIT_MASK_VENDOR_KEY_USE;
1842 :
1843 1 : m_local_key_pair_id[7] = 0x07;
1844 1 : m_local_cert_info[7] = SPDM_CERTIFICATE_INFO_CERT_MODEL_GENERIC_CERT;
1845 1 : m_local_key_usage_bit_mask[7] = SPDM_KEY_USAGE_BIT_MASK_VENDOR_KEY_USE;
1846 :
1847 1 : slot_count = SPDM_MAX_SLOT_COUNT;
1848 1 : additional_size = sizeof(spdm_key_pair_id_t) + sizeof(spdm_certificate_info_t) +
1849 : sizeof(spdm_key_usage_bit_mask_t);
1850 1 : hash_size = libspdm_get_hash_size(m_libspdm_use_hash_algo);
1851 :
1852 1 : libspdm_zero_mem(total_digest_buffer, sizeof(total_digest_buffer));
1853 1 : status = libspdm_get_digest(spdm_context, NULL, &slot_mask, &total_digest_buffer);
1854 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1855 1 : assert_int_equal(
1856 : spdm_context->transcript.message_d.buffer_size,
1857 : sizeof(spdm_digest_response_t) + (additional_size + hash_size) * slot_count);
1858 :
1859 9 : for (uint8_t index = 0; index < SPDM_MAX_SLOT_COUNT; index++) {
1860 8 : assert_memory_equal((void *)&m_local_key_pair_id[index],
1861 : (void *)&spdm_context->connection_info.peer_key_pair_id[index],
1862 : sizeof(spdm_key_pair_id_t));
1863 8 : assert_memory_equal((void *)&m_local_cert_info[index],
1864 : (void *)&spdm_context->connection_info.peer_cert_info[index],
1865 : sizeof(spdm_key_pair_id_t));
1866 8 : assert_memory_equal((void *)&m_local_key_usage_bit_mask[index],
1867 : (void *)&spdm_context->connection_info.peer_key_usage_bit_mask[index],
1868 : sizeof(spdm_key_pair_id_t));
1869 : }
1870 1 : }
1871 :
1872 : /**
1873 : * Test 28:
1874 : * 1.For slot 0, at least one of KeyExUse , ChallengeUse , MeasurementUse , and EndpointInfoUse shall be set. The
1875 : * corresponding capability bits shall be set appropriately
1876 : * 2.In all cases, the certificate model for slot 0 shall be either the device certificate model or the alias certificate model.
1877 : * Set KeyUsageMask to 0 and Set CertificateInfo to SPDM_CERTIFICATE_INFO_CERT_MODEL_GENERIC_CERT(GenericCert model)
1878 : * Expected Behavior: requester returns the status LIBSPDM_STATUS_INVALID_MSG_FIELD
1879 : **/
1880 1 : static void libspdm_test_requester_get_digests_case28(void **state)
1881 : {
1882 : libspdm_return_t status;
1883 : libspdm_test_context_t *spdm_test_context;
1884 : libspdm_context_t *spdm_context;
1885 : uint8_t slot_mask;
1886 : uint8_t total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
1887 :
1888 1 : spdm_test_context = *state;
1889 1 : spdm_context = spdm_test_context->spdm_context;
1890 1 : spdm_test_context->case_id = 0x1C;
1891 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
1892 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1893 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1894 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
1895 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1896 1 : libspdm_set_mem(m_libspdm_local_certificate_chain,
1897 : sizeof(m_libspdm_local_certificate_chain),
1898 : (uint8_t)(0xFF));
1899 1 : libspdm_reset_message_b(spdm_context);
1900 :
1901 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1902 : spdm_context->transcript.message_m.buffer_size =
1903 : spdm_context->transcript.message_m.max_buffer_size;
1904 : #endif
1905 :
1906 1 : spdm_context->connection_info.multi_key_conn_rsp = true;
1907 1 : libspdm_reset_message_d(spdm_context);
1908 :
1909 : /* Sub Case 1: Set KeyUsageMask to 0*/
1910 1 : m_local_key_pair_id[0] = 0x00;
1911 1 : m_local_cert_info[0] = SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT;
1912 1 : m_local_key_usage_bit_mask[0] = 0;
1913 :
1914 1 : libspdm_zero_mem(total_digest_buffer, sizeof(total_digest_buffer));
1915 1 : status = libspdm_get_digest(spdm_context, NULL, &slot_mask, &total_digest_buffer);
1916 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1917 :
1918 : /* Sub Case 2: Set CertificateInfo to SPDM_CERTIFICATE_INFO_CERT_MODEL_GENERIC_CERT*/
1919 1 : m_local_key_pair_id[0] = 0x00;
1920 1 : m_local_cert_info[0] = SPDM_CERTIFICATE_INFO_CERT_MODEL_GENERIC_CERT;
1921 1 : m_local_key_usage_bit_mask[0] = SPDM_KEY_USAGE_BIT_MASK_ENDPOINT_INFO_USE;
1922 :
1923 1 : libspdm_zero_mem(total_digest_buffer, sizeof(total_digest_buffer));
1924 1 : status = libspdm_get_digest(spdm_context, NULL, &slot_mask, &total_digest_buffer);
1925 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1926 1 : }
1927 :
1928 : /**
1929 : * Test 29:
1930 : * Digest: If a certificate chain is not present in this slot, the value of this field shall be all zeros.
1931 : * CertModel: Value of 0 indicates either that the certificate slot does not contain any certificates or that the corresponding
1932 : * MULTI_KEY_CONN_REQ or MULTI_KEY_CONN_RSP is false.
1933 : * Expected Behavior: requester returns the status LIBSPDM_STATUS_INVALID_MSG_FIELD
1934 : **/
1935 1 : static void libspdm_test_requester_get_digests_case29(void **state)
1936 : {
1937 : libspdm_return_t status;
1938 : libspdm_test_context_t *spdm_test_context;
1939 : libspdm_context_t *spdm_context;
1940 : uint8_t slot_mask;
1941 : uint8_t total_digest_buffer[LIBSPDM_MAX_HASH_SIZE * SPDM_MAX_SLOT_COUNT];
1942 :
1943 1 : spdm_test_context = *state;
1944 1 : spdm_context = spdm_test_context->spdm_context;
1945 1 : spdm_test_context->case_id = 0x1D;
1946 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
1947 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1948 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1949 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_CAP;
1950 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1951 1 : libspdm_zero_mem(m_libspdm_local_certificate_chain, sizeof(m_libspdm_local_certificate_chain));
1952 1 : libspdm_reset_message_b(spdm_context);
1953 :
1954 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
1955 : spdm_context->transcript.message_m.buffer_size =
1956 : spdm_context->transcript.message_m.max_buffer_size;
1957 : #endif
1958 :
1959 1 : spdm_context->connection_info.multi_key_conn_rsp = true;
1960 1 : libspdm_reset_message_d(spdm_context);
1961 :
1962 1 : m_local_key_pair_id[0] = 0x00;
1963 1 : m_local_cert_info[0] = SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT;
1964 1 : m_local_key_usage_bit_mask[0] = SPDM_KEY_USAGE_BIT_MASK_ENDPOINT_INFO_USE;
1965 :
1966 : /* CertModel:Value of 0 indicates either that the certificate slot does not contain any certificates or that the corresponding
1967 : * MULTI_KEY_CONN_REQ or MULTI_KEY_CONN_RSP is false. */
1968 1 : m_local_key_pair_id[1] = 0x01;
1969 1 : m_local_cert_info[1] = SPDM_CERTIFICATE_INFO_CERT_MODEL_NONE;
1970 1 : m_local_key_usage_bit_mask[1] = SPDM_KEY_USAGE_BIT_MASK_ENDPOINT_INFO_USE;
1971 :
1972 1 : libspdm_zero_mem(total_digest_buffer, sizeof(total_digest_buffer));
1973 1 : status = libspdm_get_digest(spdm_context, NULL, &slot_mask, &total_digest_buffer);
1974 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1975 1 : }
1976 :
1977 1 : int libspdm_requester_get_digests_test_main(void)
1978 : {
1979 1 : const struct CMUnitTest spdm_requester_get_digests_tests[] = {
1980 : cmocka_unit_test(libspdm_test_requester_get_digests_case1),
1981 : cmocka_unit_test(libspdm_test_requester_get_digests_case2),
1982 : cmocka_unit_test(libspdm_test_requester_get_digests_case3),
1983 : cmocka_unit_test(libspdm_test_requester_get_digests_case4),
1984 : cmocka_unit_test(libspdm_test_requester_get_digests_case5),
1985 : cmocka_unit_test(libspdm_test_requester_get_digests_case6),
1986 : cmocka_unit_test(libspdm_test_requester_get_digests_case7),
1987 : cmocka_unit_test(libspdm_test_requester_get_digests_case8),
1988 : cmocka_unit_test(libspdm_test_requester_get_digests_case9),
1989 : cmocka_unit_test(libspdm_test_requester_get_digests_case10),
1990 : cmocka_unit_test(libspdm_test_requester_get_digests_case11),
1991 : cmocka_unit_test(libspdm_test_requester_get_digests_case12),
1992 : cmocka_unit_test(libspdm_test_requester_get_digests_case13),
1993 : cmocka_unit_test(libspdm_test_requester_get_digests_case14),
1994 : cmocka_unit_test(libspdm_test_requester_get_digests_case15),
1995 : cmocka_unit_test(libspdm_test_requester_get_digests_case16),
1996 : cmocka_unit_test(libspdm_test_requester_get_digests_case17),
1997 : cmocka_unit_test(libspdm_test_requester_get_digests_case18),
1998 : cmocka_unit_test(libspdm_test_requester_get_digests_case19),
1999 : cmocka_unit_test(libspdm_test_requester_get_digests_case20),
2000 : cmocka_unit_test(libspdm_test_requester_get_digests_case21),
2001 : cmocka_unit_test(libspdm_test_requester_get_digests_case22),
2002 : cmocka_unit_test(libspdm_test_requester_get_digests_case23),
2003 : cmocka_unit_test(libspdm_test_requester_get_digests_case24),
2004 : cmocka_unit_test(libspdm_test_requester_get_digests_case25),
2005 : cmocka_unit_test(libspdm_test_requester_get_digests_case26),
2006 : cmocka_unit_test(libspdm_test_requester_get_digests_case27),
2007 : cmocka_unit_test(libspdm_test_requester_get_digests_case28),
2008 : cmocka_unit_test(libspdm_test_requester_get_digests_case29),
2009 : };
2010 :
2011 1 : libspdm_test_context_t test_context = {
2012 : LIBSPDM_TEST_CONTEXT_VERSION,
2013 : true,
2014 : libspdm_requester_get_digests_test_send_message,
2015 : libspdm_requester_get_digests_test_receive_message,
2016 : };
2017 :
2018 1 : libspdm_setup_test_context(&test_context);
2019 :
2020 1 : return cmocka_run_group_tests(spdm_requester_get_digests_tests,
2021 : libspdm_unit_test_group_setup,
2022 : libspdm_unit_test_group_teardown);
2023 : }
2024 :
2025 : #endif /* LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT */
|
