Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2026 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : #include "spdm_unit_test.h"
8 : #include "internal/libspdm_requester_lib.h"
9 :
10 : #pragma pack(1)
11 : typedef struct {
12 : spdm_message_header_t header;
13 : uint8_t reserved;
14 : uint8_t version_number_entry_count;
15 : spdm_version_number_t version_number_entry[LIBSPDM_MAX_VERSION_COUNT];
16 : } libspdm_version_response_mine_t;
17 : #pragma pack()
18 :
19 : static size_t m_libspdm_local_buffer_size;
20 : static uint8_t m_libspdm_local_buffer[LIBSPDM_MAX_MESSAGE_VCA_BUFFER_SIZE];
21 :
22 6 : static libspdm_return_t send_message(
23 : void *spdm_context, size_t request_size, const void *request, uint64_t timeout)
24 : {
25 : libspdm_test_context_t *spdm_test_context;
26 :
27 6 : spdm_test_context = libspdm_get_test_context();
28 6 : switch (spdm_test_context->case_id) {
29 0 : case 0x1:
30 0 : return LIBSPDM_STATUS_SUCCESS;
31 1 : case 0x2:
32 1 : return LIBSPDM_STATUS_SUCCESS;
33 0 : case 0x3:
34 0 : return LIBSPDM_STATUS_SUCCESS;
35 0 : case 0x4:
36 0 : return LIBSPDM_STATUS_SUCCESS;
37 0 : case 0x5:
38 0 : return LIBSPDM_STATUS_SUCCESS;
39 2 : case 0x6:
40 2 : return LIBSPDM_STATUS_SUCCESS;
41 0 : case 0x7:
42 0 : return LIBSPDM_STATUS_SUCCESS;
43 0 : case 0x8:
44 0 : return LIBSPDM_STATUS_SUCCESS;
45 0 : case 0x9:
46 0 : return LIBSPDM_STATUS_SUCCESS;
47 1 : case 0xA:
48 1 : return LIBSPDM_STATUS_SUCCESS;
49 0 : case 0xB:
50 0 : return LIBSPDM_STATUS_SUCCESS;
51 0 : case 0xC:
52 0 : return LIBSPDM_STATUS_SUCCESS;
53 0 : case 0xD:
54 0 : return LIBSPDM_STATUS_SUCCESS;
55 0 : case 0xE:
56 0 : return LIBSPDM_STATUS_SUCCESS;
57 1 : case 0xF:
58 1 : return LIBSPDM_STATUS_SUCCESS;
59 1 : case 0x10: {
60 1 : const uint8_t *ptr = (const uint8_t *)request;
61 :
62 1 : m_libspdm_local_buffer_size = 0;
63 1 : libspdm_copy_mem(m_libspdm_local_buffer, sizeof(m_libspdm_local_buffer),
64 1 : &ptr[1], request_size - 1);
65 1 : m_libspdm_local_buffer_size += (request_size - 1);
66 : }
67 1 : return LIBSPDM_STATUS_SUCCESS;
68 0 : case 0x11:
69 0 : return LIBSPDM_STATUS_SUCCESS;
70 0 : case 0x12:
71 0 : return LIBSPDM_STATUS_SUCCESS;
72 0 : default:
73 0 : return LIBSPDM_STATUS_SEND_FAIL;
74 : }
75 : }
76 :
77 6 : static libspdm_return_t receive_message(
78 : void *spdm_context, size_t *response_size, void **response, uint64_t timeout)
79 : {
80 : libspdm_test_context_t *spdm_test_context;
81 :
82 6 : spdm_test_context = libspdm_get_test_context();
83 6 : switch (spdm_test_context->case_id) {
84 0 : case 0x1:
85 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
86 :
87 1 : case 0x2: {
88 : libspdm_version_response_mine_t *spdm_response;
89 : size_t spdm_response_size;
90 : size_t transport_header_size;
91 :
92 1 : spdm_response_size = sizeof(libspdm_version_response_mine_t);
93 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
94 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
95 :
96 1 : libspdm_zero_mem(spdm_response, spdm_response_size);
97 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
98 1 : spdm_response->header.request_response_code = SPDM_VERSION;
99 1 : spdm_response->header.param1 = 0;
100 1 : spdm_response->header.param2 = 0;
101 1 : spdm_response->version_number_entry_count = 2;
102 1 : spdm_response->version_number_entry[0] = 0x10 << SPDM_VERSION_NUMBER_SHIFT_BIT;
103 1 : spdm_response->version_number_entry[1] = 0x11 << SPDM_VERSION_NUMBER_SHIFT_BIT;
104 :
105 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
106 : false, spdm_response_size,
107 : spdm_response,
108 : response_size, response);
109 : }
110 1 : return LIBSPDM_STATUS_SUCCESS;
111 :
112 0 : case 0x3: {
113 : spdm_version_response_t *spdm_response;
114 : size_t spdm_response_size;
115 : size_t transport_header_size;
116 :
117 0 : spdm_response_size = sizeof(spdm_version_response_t);
118 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
119 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
120 :
121 0 : libspdm_zero_mem(spdm_response, spdm_response_size);
122 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
123 0 : spdm_response->header.request_response_code = SPDM_VERSION;
124 0 : spdm_response->header.param1 = 0;
125 0 : spdm_response->header.param2 = 0;
126 0 : spdm_response->version_number_entry_count = 0;
127 :
128 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
129 : false, spdm_response_size,
130 : spdm_response,
131 : response_size, response);
132 : }
133 0 : return LIBSPDM_STATUS_SUCCESS;
134 :
135 0 : case 0x4: {
136 : spdm_error_response_t *spdm_response;
137 : size_t spdm_response_size;
138 : size_t transport_header_size;
139 :
140 0 : spdm_response_size = sizeof(spdm_error_response_t);
141 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
142 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
143 :
144 0 : libspdm_zero_mem(spdm_response, spdm_response_size);
145 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
146 0 : spdm_response->header.request_response_code = SPDM_ERROR;
147 0 : spdm_response->header.param1 = SPDM_ERROR_CODE_INVALID_REQUEST;
148 0 : spdm_response->header.param2 = 0;
149 :
150 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
151 : false, spdm_response_size,
152 : spdm_response,
153 : response_size, response);
154 : }
155 0 : return LIBSPDM_STATUS_SUCCESS;
156 :
157 0 : case 0x5: {
158 : spdm_error_response_t *spdm_response;
159 : size_t spdm_response_size;
160 : size_t transport_header_size;
161 :
162 0 : spdm_response_size = sizeof(spdm_error_response_t);
163 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
164 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
165 :
166 0 : libspdm_zero_mem(spdm_response, spdm_response_size);
167 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
168 0 : spdm_response->header.request_response_code = SPDM_ERROR;
169 0 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
170 0 : spdm_response->header.param2 = 0;
171 :
172 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
173 : false, spdm_response_size,
174 : spdm_response,
175 : response_size, response);
176 : }
177 0 : return LIBSPDM_STATUS_SUCCESS;
178 :
179 2 : case 0x6: {
180 : static size_t sub_index1 = 0;
181 2 : if (sub_index1 == 0) {
182 : spdm_error_response_t *spdm_response;
183 : size_t spdm_response_size;
184 : size_t transport_header_size;
185 :
186 1 : spdm_response_size = sizeof(spdm_error_response_t);
187 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
188 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
189 :
190 1 : libspdm_zero_mem(spdm_response, spdm_response_size);
191 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
192 1 : spdm_response->header.request_response_code = SPDM_ERROR;
193 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_BUSY;
194 1 : spdm_response->header.param2 = 0;
195 :
196 1 : libspdm_transport_test_encode_message(
197 : spdm_context, NULL, false, false,
198 : spdm_response_size, spdm_response,
199 : response_size, response);
200 1 : } else if (sub_index1 == 1) {
201 : libspdm_version_response_mine_t *spdm_response;
202 : size_t spdm_response_size;
203 : size_t transport_header_size;
204 :
205 1 : spdm_response_size = sizeof(libspdm_version_response_mine_t);
206 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
207 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
208 :
209 1 : libspdm_zero_mem(spdm_response, spdm_response_size);
210 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
211 1 : spdm_response->header.request_response_code = SPDM_VERSION;
212 1 : spdm_response->header.param1 = 0;
213 1 : spdm_response->header.param2 = 0;
214 1 : spdm_response->version_number_entry_count = 2;
215 1 : spdm_response->version_number_entry[0] = 0x10 << SPDM_VERSION_NUMBER_SHIFT_BIT;
216 1 : spdm_response->version_number_entry[1] = 0x11 << SPDM_VERSION_NUMBER_SHIFT_BIT;
217 :
218 1 : libspdm_transport_test_encode_message(
219 : spdm_context, NULL, false, false,
220 : spdm_response_size, spdm_response,
221 : response_size, response);
222 : }
223 2 : sub_index1++;
224 : }
225 2 : return LIBSPDM_STATUS_SUCCESS;
226 :
227 0 : case 0x7: {
228 : spdm_error_response_t *spdm_response;
229 : size_t spdm_response_size;
230 : size_t transport_header_size;
231 :
232 0 : spdm_response_size = sizeof(spdm_error_response_t);
233 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
234 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
235 :
236 0 : libspdm_zero_mem(spdm_response, spdm_response_size);
237 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
238 0 : spdm_response->header.request_response_code = SPDM_ERROR;
239 0 : spdm_response->header.param1 = SPDM_ERROR_CODE_REQUEST_RESYNCH;
240 0 : spdm_response->header.param2 = 0;
241 :
242 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
243 : false, spdm_response_size,
244 : spdm_response,
245 : response_size, response);
246 : }
247 0 : return LIBSPDM_STATUS_SUCCESS;
248 :
249 0 : case 0x8: {
250 : spdm_error_response_data_response_not_ready_t *spdm_response;
251 : size_t spdm_response_size;
252 : size_t transport_header_size;
253 :
254 0 : spdm_response_size = sizeof(spdm_error_response_data_response_not_ready_t);
255 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
256 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
257 :
258 0 : libspdm_zero_mem(spdm_response, spdm_response_size);
259 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
260 0 : spdm_response->header.request_response_code = SPDM_ERROR;
261 0 : spdm_response->header.param1 = SPDM_ERROR_CODE_RESPONSE_NOT_READY;
262 0 : spdm_response->header.param2 = 0;
263 0 : spdm_response->extend_error_data.rd_exponent = 1;
264 0 : spdm_response->extend_error_data.rd_tm = 2;
265 0 : spdm_response->extend_error_data.request_code = SPDM_GET_VERSION;
266 0 : spdm_response->extend_error_data.token = 0;
267 :
268 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
269 : false, spdm_response_size,
270 : spdm_response,
271 : response_size, response);
272 : }
273 0 : return LIBSPDM_STATUS_SUCCESS;
274 :
275 0 : case 0x9:
276 0 : return LIBSPDM_STATUS_SUCCESS;
277 :
278 1 : case 0xA: {
279 : libspdm_version_response_mine_t *spdm_response;
280 : size_t spdm_response_size;
281 : size_t transport_header_size;
282 :
283 1 : spdm_response_size = sizeof(libspdm_version_response_mine_t);
284 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
285 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
286 :
287 1 : libspdm_zero_mem(spdm_response, spdm_response_size);
288 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
289 1 : spdm_response->header.request_response_code = SPDM_VERSION;
290 1 : spdm_response->header.param1 = 0;
291 1 : spdm_response->header.param2 = 0;
292 1 : spdm_response->version_number_entry_count = 2;
293 1 : spdm_response->version_number_entry[0] = 0x10 << SPDM_VERSION_NUMBER_SHIFT_BIT;
294 1 : spdm_response->version_number_entry[1] = 0x11 << SPDM_VERSION_NUMBER_SHIFT_BIT;
295 1 : spdm_response->version_number_entry[2] = 0x12 << SPDM_VERSION_NUMBER_SHIFT_BIT;
296 :
297 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
298 : false, spdm_response_size,
299 : spdm_response,
300 : response_size, response);
301 : }
302 1 : return LIBSPDM_STATUS_SUCCESS;
303 :
304 0 : case 0xB: {
305 : libspdm_version_response_mine_t *spdm_response;
306 : size_t spdm_response_size;
307 : size_t transport_header_size;
308 :
309 0 : spdm_response_size = sizeof(libspdm_version_response_mine_t);
310 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
311 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
312 :
313 0 : libspdm_zero_mem(spdm_response, spdm_response_size);
314 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
315 0 : spdm_response->header.request_response_code = SPDM_VERSION;
316 0 : spdm_response->header.param1 = 0;
317 0 : spdm_response->header.param2 = 0;
318 0 : spdm_response->version_number_entry_count = 2;
319 0 : spdm_response->version_number_entry[0] = 0xA0 << SPDM_VERSION_NUMBER_SHIFT_BIT;
320 0 : spdm_response->version_number_entry[1] = 0xA1 << SPDM_VERSION_NUMBER_SHIFT_BIT;
321 :
322 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
323 : false, spdm_response_size,
324 : spdm_response,
325 : response_size, response);
326 : }
327 0 : return LIBSPDM_STATUS_SUCCESS;
328 :
329 0 : case 0xC: {
330 : libspdm_version_response_mine_t *spdm_response;
331 : size_t spdm_response_size;
332 : size_t transport_header_size;
333 :
334 0 : spdm_response_size = sizeof(libspdm_version_response_mine_t);
335 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
336 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
337 :
338 0 : libspdm_zero_mem(spdm_response, spdm_response_size);
339 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_11;
340 0 : spdm_response->header.request_response_code = SPDM_VERSION;
341 0 : spdm_response->header.param1 = 0;
342 0 : spdm_response->header.param2 = 0;
343 0 : spdm_response->version_number_entry_count = 2;
344 0 : spdm_response->version_number_entry[0] = 0x10 << SPDM_VERSION_NUMBER_SHIFT_BIT;
345 0 : spdm_response->version_number_entry[1] = 0x11 << SPDM_VERSION_NUMBER_SHIFT_BIT;
346 :
347 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
348 : false, spdm_response_size,
349 : spdm_response,
350 : response_size, response);
351 : }
352 0 : return LIBSPDM_STATUS_SUCCESS;
353 :
354 0 : case 0xD: {
355 : libspdm_version_response_mine_t *spdm_response;
356 : size_t spdm_response_size;
357 : size_t transport_header_size;
358 :
359 0 : spdm_response_size = sizeof(libspdm_version_response_mine_t);
360 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
361 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
362 :
363 0 : libspdm_zero_mem(spdm_response, spdm_response_size);
364 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
365 0 : spdm_response->header.request_response_code = SPDM_GET_VERSION;
366 0 : spdm_response->header.param1 = 0;
367 0 : spdm_response->header.param2 = 0;
368 0 : spdm_response->version_number_entry_count = 2;
369 0 : spdm_response->version_number_entry[0] = 0x10 << SPDM_VERSION_NUMBER_SHIFT_BIT;
370 0 : spdm_response->version_number_entry[1] = 0x11 << SPDM_VERSION_NUMBER_SHIFT_BIT;
371 :
372 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
373 : false, spdm_response_size,
374 : spdm_response,
375 : response_size, response);
376 : }
377 0 : return LIBSPDM_STATUS_SUCCESS;
378 :
379 0 : case 0xE:
380 : {
381 : static uint16_t error_code = LIBSPDM_ERROR_CODE_RESERVED_00;
382 :
383 : spdm_error_response_t *spdm_response;
384 : size_t spdm_response_size;
385 : size_t transport_header_size;
386 :
387 0 : spdm_response_size = sizeof(libspdm_version_response_mine_t);
388 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
389 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
390 :
391 0 : if(error_code <= 0xff) {
392 0 : libspdm_zero_mem (spdm_response, spdm_response_size);
393 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
394 0 : spdm_response->header.request_response_code = SPDM_ERROR;
395 0 : spdm_response->header.param1 = (uint8_t) error_code;
396 :
397 0 : libspdm_transport_test_encode_message (spdm_context, NULL, false, false,
398 : spdm_response_size, spdm_response,
399 : response_size, response);
400 : }
401 :
402 0 : error_code++;
403 0 : if(error_code == SPDM_ERROR_CODE_BUSY) { /*busy is treated in cases 5 and 6*/
404 0 : error_code = SPDM_ERROR_CODE_UNEXPECTED_REQUEST;
405 : }
406 : /* skip some reserved error codes (0d to 3e) */
407 0 : if(error_code == LIBSPDM_ERROR_CODE_RESERVED_0D) {
408 0 : error_code = LIBSPDM_ERROR_CODE_RESERVED_3F;
409 : }
410 : /* skip response not ready, request resync, and some reserved codes (44 to fc) */
411 0 : if(error_code == SPDM_ERROR_CODE_RESPONSE_NOT_READY) {
412 0 : error_code = LIBSPDM_ERROR_CODE_RESERVED_FD;
413 : }
414 : }
415 0 : return LIBSPDM_STATUS_SUCCESS;
416 :
417 1 : case 0xF: {
418 : libspdm_version_response_mine_t *spdm_response;
419 : size_t spdm_response_size;
420 : size_t transport_header_size;
421 :
422 1 : spdm_response_size = sizeof(libspdm_version_response_mine_t);
423 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
424 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
425 :
426 1 : libspdm_zero_mem(spdm_response, spdm_response_size);
427 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
428 1 : spdm_response->header.request_response_code = SPDM_VERSION;
429 1 : spdm_response->header.param1 = 0;
430 1 : spdm_response->header.param2 = 0;
431 1 : spdm_response->version_number_entry_count = 5;
432 1 : spdm_response->version_number_entry[0] = 0x42 << SPDM_VERSION_NUMBER_SHIFT_BIT;
433 1 : spdm_response->version_number_entry[1] = 0x52 << SPDM_VERSION_NUMBER_SHIFT_BIT;
434 1 : spdm_response->version_number_entry[2] = 0x12 << SPDM_VERSION_NUMBER_SHIFT_BIT;
435 1 : spdm_response->version_number_entry[3] = 0x11 << SPDM_VERSION_NUMBER_SHIFT_BIT;
436 1 : spdm_response->version_number_entry[4] = 0x10 << SPDM_VERSION_NUMBER_SHIFT_BIT;
437 :
438 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
439 : false, spdm_response_size,
440 : spdm_response,
441 : response_size, response);
442 : }
443 1 : return LIBSPDM_STATUS_SUCCESS;
444 :
445 1 : case 0x10: {
446 : libspdm_version_response_mine_t *spdm_response;
447 : size_t spdm_response_size;
448 : size_t transport_header_size;
449 :
450 1 : spdm_response_size = sizeof(libspdm_version_response_mine_t);
451 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
452 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
453 :
454 1 : libspdm_zero_mem(spdm_response, spdm_response_size);
455 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
456 1 : spdm_response->header.request_response_code = SPDM_VERSION;
457 1 : spdm_response->header.param1 = 0;
458 1 : spdm_response->header.param2 = 0;
459 1 : spdm_response->version_number_entry_count = 2;
460 1 : spdm_response->version_number_entry[0] = 0x10 << SPDM_VERSION_NUMBER_SHIFT_BIT;
461 1 : spdm_response->version_number_entry[1] = 0x11 << SPDM_VERSION_NUMBER_SHIFT_BIT;
462 :
463 1 : spdm_response_size = 10;
464 :
465 1 : libspdm_copy_mem(&m_libspdm_local_buffer[m_libspdm_local_buffer_size],
466 : sizeof(m_libspdm_local_buffer) - m_libspdm_local_buffer_size,
467 : (uint8_t *)spdm_response, spdm_response_size);
468 1 : m_libspdm_local_buffer_size += spdm_response_size;
469 :
470 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
471 : false, spdm_response_size,
472 : spdm_response,
473 : response_size, response);
474 : }
475 1 : return LIBSPDM_STATUS_SUCCESS;
476 :
477 0 : case 0x11: {
478 : spdm_message_header_t *spdm_response;
479 : size_t spdm_response_size;
480 : size_t transport_header_size;
481 :
482 0 : spdm_response_size = sizeof(spdm_message_header_t);
483 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
484 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
485 :
486 0 : libspdm_zero_mem(spdm_response, spdm_response_size);
487 0 : spdm_response->spdm_version = SPDM_MESSAGE_VERSION_10;
488 0 : spdm_response->request_response_code = SPDM_VERSION;
489 0 : spdm_response->param1 = 0;
490 0 : spdm_response->param2 = 0;
491 :
492 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
493 : false, spdm_response_size,
494 : spdm_response,
495 : response_size, response);
496 :
497 : }
498 0 : return LIBSPDM_STATUS_SUCCESS;
499 :
500 0 : case 0x12: {
501 : spdm_version_response_t *spdm_response;
502 : size_t spdm_response_size;
503 : size_t transport_header_size;
504 :
505 0 : spdm_response_size = sizeof(spdm_version_response_t);
506 0 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
507 0 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
508 :
509 0 : libspdm_zero_mem(spdm_response, spdm_response_size);
510 0 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_10;
511 0 : spdm_response->header.request_response_code = SPDM_VERSION;
512 0 : spdm_response->header.param1 = 0;
513 0 : spdm_response->header.param2 = 0;
514 0 : spdm_response->version_number_entry_count = LIBSPDM_MAX_VERSION_COUNT;
515 :
516 0 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
517 : false, spdm_response_size,
518 : spdm_response,
519 : response_size, response);
520 :
521 : }
522 0 : return LIBSPDM_STATUS_SUCCESS;
523 :
524 0 : default:
525 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
526 : }
527 : }
528 :
529 : /**
530 : * Test 1: Can be populated with new test.
531 : **/
532 :
533 : /*
534 : * static void req_get_version_case1(void **state)
535 : * {
536 : * }
537 : */
538 :
539 : /**
540 : * Test 2: receiving a correct VERSION message with available version 1.0 and 1.1.
541 : * Expected behavior: client returns a status of LIBSPDM_STATUS_SUCCESS.
542 : **/
543 1 : static void req_get_version_case2(void **state)
544 : {
545 : libspdm_return_t status;
546 : libspdm_test_context_t *spdm_test_context;
547 : libspdm_context_t *spdm_context;
548 :
549 1 : spdm_test_context = *state;
550 1 : spdm_context = spdm_test_context->spdm_context;
551 1 : spdm_test_context->case_id = 0x2;
552 :
553 1 : status = libspdm_get_version(spdm_context, NULL, NULL);
554 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
555 1 : }
556 :
557 : /**
558 : * Test 3: Can be populated with new test.
559 : **/
560 :
561 : /*
562 : * static void req_get_version_case3(void **state)
563 : * {
564 : * }
565 : */
566 :
567 : /**
568 : * Test 4: Can be populated with new test.
569 : **/
570 :
571 : /*
572 : * static void req_get_version_case4(void **state)
573 : * {
574 : * }
575 : */
576 :
577 : /**
578 : * Test 5: Can be populated with new test.
579 : **/
580 :
581 : /*
582 : * static void req_get_version_case5(void **state)
583 : * {
584 : * }
585 : */
586 :
587 : /**
588 : * Test 6: on the first try, receiving a Busy ERROR message, and on retry, receiving
589 : * a correct VERSION message with available version 1.0 and 1.1.
590 : * Expected behavior: client returns a status of LIBSPDM_STATUS_SUCCESS.
591 : **/
592 1 : static void req_get_version_case6(void **state)
593 : {
594 : libspdm_return_t status;
595 : libspdm_test_context_t *spdm_test_context;
596 : libspdm_context_t *spdm_context;
597 :
598 1 : spdm_test_context = *state;
599 1 : spdm_context = spdm_test_context->spdm_context;
600 1 : spdm_test_context->case_id = 0x6;
601 :
602 1 : spdm_context->retry_times = 3;
603 1 : status = libspdm_get_version(spdm_context, NULL, NULL);
604 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
605 1 : }
606 :
607 : /**
608 : * Test 7: Can be populated with new test.
609 : **/
610 :
611 : /*
612 : * static void req_get_version_case7(void **state)
613 : * {
614 : * }
615 : */
616 :
617 : /**
618 : * Test 8: Can be populated with new test.
619 : **/
620 :
621 : /*
622 : * static void req_get_version_case8(void **state)
623 : * {
624 : * }
625 : */
626 :
627 : /**
628 : * Test 9: Can be populated with new test.
629 : **/
630 :
631 : /*
632 : * static void req_get_version_case9(void **state)
633 : * {
634 : * }
635 : */
636 :
637 : /**
638 : * Test 10: receiving a VERSION message with a larger list of available versions than indicated.
639 : * The presence of only two versions are indicated, but the VERSION message presents a list
640 : * with 3 versions: 1.0, 1.1 and 1.2.
641 : * Expected behavior: client returns a status of LIBSPDM_STATUS_SUCCESS, but truncate the message
642 : * to consider only the two first versions, as indicated in the message.
643 : **/
644 1 : static void req_get_version_case10(void **state)
645 : {
646 : libspdm_return_t status;
647 : libspdm_test_context_t *spdm_test_context;
648 : libspdm_context_t *spdm_context;
649 :
650 1 : spdm_test_context = *state;
651 1 : spdm_context = spdm_test_context->spdm_context;
652 1 : spdm_test_context->case_id = 0xA;
653 :
654 1 : status = libspdm_get_version(spdm_context, NULL, NULL);
655 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
656 1 : }
657 :
658 : /**
659 : * Test 11: Can be populated with new test.
660 : **/
661 :
662 : /*
663 : * static void req_get_version_case11(void **state)
664 : * {
665 : * }
666 : */
667 :
668 : /**
669 : * Test 12: Can be populated with new test.
670 : **/
671 :
672 : /*
673 : * static void req_get_version_case12(void **state)
674 : * {
675 : * }
676 : */
677 :
678 : /**
679 : * Test 13: Can be populated with new test.
680 : **/
681 :
682 : /*
683 : * static void req_get_version_case13(void **state)
684 : * {
685 : * }
686 : */
687 :
688 : /**
689 : * Test 14: Can be populated with new test.
690 : **/
691 :
692 : /*
693 : * static void req_get_version_case14(void **state)
694 : * {
695 : * }
696 : */
697 :
698 : /**
699 : * Test 15: receiving a VERSION message with unordered version list.
700 : * Requester list:5.5, 0.9, 1.0, 1.1
701 : * Responder list:4.2, 5.2, 1.2, 1.1, 1.0
702 : * Expected behavior: client returns a status of LIBSPDM_STATUS_SUCCESS and right negotiated version 1.1.
703 : **/
704 1 : static void req_get_version_case15(void **state)
705 : {
706 : libspdm_return_t status;
707 : libspdm_test_context_t *spdm_test_context;
708 : libspdm_context_t *spdm_context;
709 :
710 1 : spdm_test_context = *state;
711 1 : spdm_context = spdm_test_context->spdm_context;
712 1 : spdm_test_context->case_id = 0xF;
713 1 : spdm_context->local_context.version.spdm_version_count = 4;
714 1 : spdm_context->local_context.version.spdm_version[0] = 0x55 << SPDM_VERSION_NUMBER_SHIFT_BIT;
715 1 : spdm_context->local_context.version.spdm_version[1] = 0x09 << SPDM_VERSION_NUMBER_SHIFT_BIT;
716 1 : spdm_context->local_context.version.spdm_version[2] = 0x10 << SPDM_VERSION_NUMBER_SHIFT_BIT;
717 1 : spdm_context->local_context.version.spdm_version[3] = 0x11 << SPDM_VERSION_NUMBER_SHIFT_BIT;
718 1 : status = libspdm_get_version(spdm_context, NULL, NULL);
719 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
720 1 : assert_int_equal( spdm_context->connection_info.version >> SPDM_VERSION_NUMBER_SHIFT_BIT, 0x11);
721 1 : }
722 :
723 : /**
724 : * Test 16: receiving a correct VERSION message with available version 1.0 and 1.1.
725 : * Buffers A, B and C already have arbitrary data.
726 : * Expected behavior: client returns a status of LIBSPDM_STATUS_SUCCESS, buffers A, B and C
727 : * should be first reset, and then buffer A receives only the exchanged GET_VERSION
728 : * and VERSION messages.
729 : **/
730 1 : static void req_get_version_case16(void **state)
731 : {
732 : libspdm_return_t status;
733 : libspdm_test_context_t *spdm_test_context;
734 : libspdm_context_t *spdm_context;
735 :
736 1 : spdm_test_context = *state;
737 1 : spdm_context = spdm_test_context->spdm_context;
738 1 : spdm_test_context->case_id = 0x10;
739 :
740 : /*filling buffers with arbitrary data*/
741 1 : libspdm_set_mem(spdm_context->transcript.message_a.buffer, 10, (uint8_t) 0xFF);
742 1 : spdm_context->transcript.message_a.buffer_size = 10;
743 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
744 : libspdm_set_mem(spdm_context->transcript.message_b.buffer, 8, (uint8_t) 0xEE);
745 : spdm_context->transcript.message_b.buffer_size = 8;
746 : libspdm_set_mem(spdm_context->transcript.message_c.buffer, 12, (uint8_t) 0xDD);
747 : spdm_context->transcript.message_c.buffer_size = 12;
748 : #endif
749 :
750 1 : status = libspdm_get_version(spdm_context, NULL, NULL);
751 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
752 1 : assert_int_equal(spdm_context->transcript.message_a.buffer_size, m_libspdm_local_buffer_size);
753 1 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "m_libspdm_local_buffer (0x%zx):\n",
754 : m_libspdm_local_buffer_size));
755 1 : libspdm_dump_hex(m_libspdm_local_buffer, m_libspdm_local_buffer_size);
756 1 : assert_memory_equal(spdm_context->transcript.message_a.buffer,
757 : m_libspdm_local_buffer, m_libspdm_local_buffer_size);
758 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
759 : assert_int_equal(spdm_context->transcript.message_b.buffer_size, 0);
760 : assert_int_equal(spdm_context->transcript.message_c.buffer_size, 0);
761 : #endif
762 1 : }
763 :
764 : /**
765 : * Test 17: Can be populated with new test.
766 : **/
767 :
768 : /*
769 : * static void req_get_version_case17(void **state)
770 : * {
771 : * }
772 : */
773 :
774 : /**
775 : * Test 18: Can be populated with new test.
776 : **/
777 :
778 : /*
779 : * static void req_get_version_case18(void **state)
780 : * {
781 : * }
782 : */
783 :
784 1 : int libspdm_req_get_version_test(void)
785 : {
786 1 : const struct CMUnitTest test_cases[] = {
787 : /* cmocka_unit_test(req_get_version_case1), */
788 : cmocka_unit_test(req_get_version_case2),
789 : /* cmocka_unit_test(req_get_version_case3),
790 : * cmocka_unit_test(req_get_version_case4),
791 : * cmocka_unit_test(req_get_version_case5), */
792 : cmocka_unit_test(req_get_version_case6),
793 : /* cmocka_unit_test(req_get_version_case7),
794 : * cmocka_unit_test(req_get_version_case8),
795 : * cmocka_unit_test(req_get_version_case9), */
796 : cmocka_unit_test(req_get_version_case10),
797 : /* cmocka_unit_test(req_get_version_case11),
798 : * cmocka_unit_test(req_get_version_case12),
799 : * cmocka_unit_test(req_get_version_case13),
800 : * cmocka_unit_test(req_get_version_case14), */
801 : cmocka_unit_test(req_get_version_case15),
802 : cmocka_unit_test(req_get_version_case16),
803 : /* cmocka_unit_test(req_get_version_case17),
804 : * cmocka_unit_test(req_get_version_case18), */
805 : };
806 :
807 1 : libspdm_test_context_t test_context = {
808 : LIBSPDM_TEST_CONTEXT_VERSION,
809 : true,
810 : send_message,
811 : receive_message,
812 : };
813 :
814 1 : libspdm_setup_test_context(&test_context);
815 :
816 1 : return cmocka_run_group_tests(test_cases,
817 : libspdm_unit_test_group_setup,
818 : libspdm_unit_test_group_teardown);
819 : }
|
