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