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