Branch data 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 "internal/libspdm_common_lib.h"
8 : :
9 : : #if LIBSPDM_DEBUG_PRINT_ENABLE
10 : 137177 : const char *libspdm_get_code_str(uint8_t request_code)
11 : : {
12 [ + + + + : 137177 : switch (request_code) {
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + +
+ ]
13 : : /* SPDM response code (1.0) */
14 : 21 : case SPDM_DIGESTS: return "SPDM_DIGESTS";
15 : 1535 : case SPDM_CERTIFICATE: return "SPDM_CERTIFICATE";
16 : 23 : case SPDM_CHALLENGE_AUTH: return "SPDM_CHALLENGE_AUTH";
17 : 38 : case SPDM_VERSION: return "SPDM_VERSION";
18 : 255 : case SPDM_MEASUREMENTS: return "SPDM_MEASUREMENTS";
19 : 73 : case SPDM_CAPABILITIES: return "SPDM_CAPABILITIES";
20 : 99 : case SPDM_ALGORITHMS: return "SPDM_ALGORITHMS";
21 : 7 : case SPDM_VENDOR_DEFINED_RESPONSE: return "SPDM_VENDOR_DEFINED_RESPONSE";
22 : 564 : case SPDM_ERROR: return "SPDM_ERROR";
23 : :
24 : : /* SPDM response code (1.1) */
25 : 44 : case SPDM_KEY_EXCHANGE_RSP: return "SPDM_KEY_EXCHANGE_RSP";
26 : 16 : case SPDM_FINISH_RSP: return "SPDM_FINISH_RSP";
27 : 31 : case SPDM_PSK_EXCHANGE_RSP: return "SPDM_PSK_EXCHANGE_RSP";
28 : 14 : case SPDM_PSK_FINISH_RSP: return "SPDM_PSK_FINISH_RSP";
29 : 5 : case SPDM_HEARTBEAT_ACK: return "SPDM_HEARTBEAT_ACK";
30 : 50 : case SPDM_KEY_UPDATE_ACK: return "SPDM_KEY_UPDATE_ACK";
31 : 26 : case SPDM_ENCAPSULATED_REQUEST: return "SPDM_ENCAPSULATED_REQUEST";
32 : 16 : case SPDM_ENCAPSULATED_RESPONSE_ACK: return "SPDM_ENCAPSULATED_RESPONSE_ACK";
33 : 6 : case SPDM_END_SESSION_ACK: return "SPDM_END_SESSION_ACK";
34 : :
35 : : /* SPDM response code (1.2) */
36 : 8 : case SPDM_CSR: return "SPDM_CSR";
37 : 4 : case SPDM_SET_CERTIFICATE_RSP: return "SPDM_SET_CERTIFICATE_RSP";
38 : 13 : case SPDM_CHUNK_SEND_ACK: return "SPDM_CHUNK_SEND_ACK";
39 : 65624 : case SPDM_CHUNK_RESPONSE: return "SPDM_CHUNK_RESPONSE";
40 : :
41 : : /* SPDM response code (1.3 )*/
42 : 8 : case SPDM_SUPPORTED_EVENT_TYPES: return "SPDM_SUPPORTED_EVENT_TYPES";
43 : 6 : case SPDM_SUBSCRIBE_EVENT_TYPES_ACK: return "SPDM_SUBSCRIBE_EVENT_TYPES_ACK";
44 : 3 : case SPDM_EVENT_ACK: return "SPDM_EVENT_ACK";
45 : 22 : case SPDM_MEASUREMENT_EXTENSION_LOG: return "SPDM_MEASUREMENT_EXTENSION_LOG";
46 : 21 : case SPDM_KEY_PAIR_INFO: return "SPDM_KEY_PAIR_INFO";
47 : 5 : case SPDM_SET_KEY_PAIR_INFO_ACK: return "SPDM_SET_KEY_PAIR_INFO_ACK";
48 : 17 : case SPDM_ENDPOINT_INFO: return "SPDM_ENDPOINT_INFO";
49 : :
50 : : /* SPDM request code (1.0) */
51 : 50 : case SPDM_GET_DIGESTS: return "SPDM_GET_DIGESTS";
52 : 1564 : case SPDM_GET_CERTIFICATE: return "SPDM_GET_CERTIFICATE";
53 : 50 : case SPDM_CHALLENGE: return "SPDM_CHALLENGE";
54 : 90 : case SPDM_GET_VERSION: return "SPDM_GET_VERSION";
55 : 306 : case SPDM_GET_MEASUREMENTS: return "SPDM_GET_MEASUREMENTS";
56 : 131 : case SPDM_GET_CAPABILITIES: return "SPDM_GET_CAPABILITIES";
57 : 115 : case SPDM_NEGOTIATE_ALGORITHMS: return "SPDM_NEGOTIATE_ALGORITHMS";
58 : 10 : case SPDM_VENDOR_DEFINED_REQUEST: return "SPDM_VENDOR_DEFINED_REQUEST";
59 : 29 : case SPDM_RESPOND_IF_READY: return "SPDM_RESPOND_IF_READY";
60 : :
61 : : /* SPDM request code (1.1) */
62 : 92 : case SPDM_KEY_EXCHANGE: return "SPDM_KEY_EXCHANGE";
63 : 42 : case SPDM_FINISH: return "SPDM_FINISH";
64 : 60 : case SPDM_PSK_EXCHANGE: return "SPDM_PSK_EXCHANGE";
65 : 40 : case SPDM_PSK_FINISH: return "SPDM_PSK_FINISH";
66 : 31 : case SPDM_HEARTBEAT: return "SPDM_HEARTBEAT";
67 : 127 : case SPDM_KEY_UPDATE: return "SPDM_KEY_UPDATE";
68 : 31 : case SPDM_GET_ENCAPSULATED_REQUEST: return "SPDM_GET_ENCAPSULATED_REQUEST";
69 : 20 : case SPDM_DELIVER_ENCAPSULATED_RESPONSE: return "SPDM_DELIVER_ENCAPSULATED_RESPONSE";
70 : 31 : case SPDM_END_SESSION: return "SPDM_END_SESSION";
71 : :
72 : : /* SPDM request code (1.2) */
73 : 17 : case SPDM_GET_CSR: return "SPDM_GET_CSR";
74 : 6 : case SPDM_SET_CERTIFICATE: return "SPDM_SET_CERTIFICATE";
75 : 18 : case SPDM_CHUNK_SEND: return "SPDM_CHUNK_SEND";
76 : 65622 : case SPDM_CHUNK_GET: return "SPDM_CHUNK_GET";
77 : :
78 : : /* SPDM request code (1.3) */
79 : 13 : case SPDM_GET_SUPPORTED_EVENT_TYPES: return "SPDM_GET_SUPPORTED_EVENT_TYPES";
80 : 11 : case SPDM_SUBSCRIBE_EVENT_TYPES: return "SPDM_SUBSCRIBE_EVENT_TYPES";
81 : 7 : case SPDM_SEND_EVENT: return "SPDM_SEND_EVENT";
82 : 28 : case SPDM_GET_MEASUREMENT_EXTENSION_LOG: return "SPDM_GET_MEASUREMENT_EXTENSION_LOG";
83 : 21 : case SPDM_GET_KEY_PAIR_INFO: return "SPDM_GET_KEY_PAIR_INFO";
84 : 8 : case SPDM_SET_KEY_PAIR_INFO: return "SPDM_SET_KEY_PAIR_INFO";
85 : 45 : case SPDM_GET_ENDPOINT_INFO: return "SPDM_GET_ENDPOINT_INFO";
86 : :
87 : 8 : default:
88 : 8 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "RequestResponseCode 0x%x not found.\n", request_code));
89 : 8 : return "<unknown>";
90 : : }
91 : : }
92 : :
93 : 47 : void libspdm_internal_dump_hex_str(const uint8_t *data, size_t size)
94 : : {
95 : : size_t index;
96 [ + + ]: 1551 : for (index = 0; index < size; index++) {
97 : 1504 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "%02x", data[index]));
98 : : }
99 : 47 : }
100 : :
101 : 219589 : void libspdm_internal_dump_data(const uint8_t *data, size_t size)
102 : : {
103 : : size_t index;
104 [ + + ]: 4025913 : for (index = 0; index < size; index++) {
105 : 3806324 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "%02x ", data[index]));
106 : : }
107 : 219589 : }
108 : :
109 : 140121 : void libspdm_internal_dump_hex(const uint8_t *data, size_t size)
110 : : {
111 : : size_t index;
112 : : size_t count;
113 : : size_t left;
114 : :
115 : : #define COLUMN_SIZE (16 * 2)
116 : :
117 : 140121 : count = size / COLUMN_SIZE;
118 : 140121 : left = size % COLUMN_SIZE;
119 [ + + ]: 217251 : for (index = 0; index < count; index++) {
120 : 77130 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "%04zx: ", index * COLUMN_SIZE));
121 : 77130 : LIBSPDM_INTERNAL_DUMP_DATA(data + index * COLUMN_SIZE, COLUMN_SIZE);
122 : 77130 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
123 : : }
124 : :
125 [ + + ]: 140121 : if (left != 0) {
126 : 139711 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "%04zx: ", index * COLUMN_SIZE));
127 : 139711 : LIBSPDM_INTERNAL_DUMP_DATA(data + index * COLUMN_SIZE, left);
128 : 139711 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, "\n"));
129 : : }
130 : 140121 : }
131 : : #endif /* LIBSPDM_DEBUG_PRINT_ENABLE */
132 : :
133 : 1187 : uint16_t libspdm_read_uint16(const uint8_t *buffer)
134 : : {
135 : 2374 : return (uint16_t)
136 : 1187 : ((uint16_t)buffer[0] |
137 : 1187 : ((uint16_t)buffer[1] << 8));
138 : : }
139 : :
140 : 737 : void libspdm_write_uint16(uint8_t *buffer, uint16_t value)
141 : : {
142 : 737 : buffer[0] = (uint8_t)(value & 0xFF);
143 : 737 : buffer[1] = (uint8_t)((value >> 8) & 0xFF);
144 : 737 : }
145 : :
146 : 261 : uint32_t libspdm_read_uint24(const uint8_t *buffer)
147 : : {
148 : 522 : return (uint32_t)
149 : 261 : ((uint32_t)buffer[0] |
150 : 261 : ((uint32_t)buffer[1] << 8) |
151 : 261 : ((uint32_t)buffer[2] << 16));
152 : : }
153 : :
154 : 2367 : void libspdm_write_uint24(uint8_t *buffer, uint32_t value)
155 : : {
156 : 2367 : buffer[0] = (uint8_t)(value & 0xFF);
157 : 2367 : buffer[1] = (uint8_t)((value >> 8) & 0xFF);
158 : 2367 : buffer[2] = (uint8_t)((value >> 16) & 0xFF);
159 : 2367 : }
160 : :
161 : 712 : uint32_t libspdm_read_uint32(const uint8_t *buffer)
162 : : {
163 : 1424 : return (uint32_t)
164 : 712 : ((uint32_t)buffer[0] |
165 : 712 : ((uint32_t)buffer[1] << 8) |
166 : 712 : ((uint32_t)buffer[2] << 16) |
167 : 712 : ((uint32_t)buffer[3] << 24));
168 : : }
169 : :
170 : 106 : void libspdm_write_uint32(uint8_t *buffer, uint32_t value)
171 : : {
172 : 106 : buffer[0] = (uint8_t)(value & 0xFF);
173 : 106 : buffer[1] = (uint8_t)((value >> 8) & 0xFF);
174 : 106 : buffer[2] = (uint8_t)((value >> 16) & 0xFF);
175 : 106 : buffer[3] = (uint8_t)((value >> 24) & 0xFF);
176 : 106 : }
177 : :
178 : 3 : uint64_t libspdm_read_uint64(const uint8_t *buffer)
179 : : {
180 : 6 : return (uint64_t)
181 : 3 : ((uint64_t)buffer[0] |
182 : 3 : ((uint64_t)buffer[1] << 8) |
183 : 3 : ((uint64_t)buffer[2] << 16) |
184 : 3 : ((uint64_t)buffer[3] << 24) |
185 : 3 : ((uint64_t)buffer[4] << 32) |
186 : 3 : ((uint64_t)buffer[5] << 40) |
187 : 3 : ((uint64_t)buffer[6] << 48) |
188 : 3 : ((uint64_t)buffer[7] << 56));
189 : : }
190 : :
191 : 3 : void libspdm_write_uint64(uint8_t *buffer, uint64_t value)
192 : : {
193 : 3 : buffer[0] = (uint8_t)(value & 0xFF);
194 : 3 : buffer[1] = (uint8_t)((value >> 8) & 0xFF);
195 : 3 : buffer[2] = (uint8_t)((value >> 16) & 0xFF);
196 : 3 : buffer[3] = (uint8_t)((value >> 24) & 0xFF);
197 : 3 : buffer[4] = (uint8_t)((value >> 32) & 0xFF);
198 : 3 : buffer[5] = (uint8_t)((value >> 40) & 0xFF);
199 : 3 : buffer[6] = (uint8_t)((value >> 48) & 0xFF);
200 : 3 : buffer[7] = (uint8_t)((value >> 56) & 0xFF);
201 : 3 : }
202 : :
203 : 606 : libspdm_return_t libspdm_append_managed_buffer(void *m_buffer, const void *buffer,
204 : : size_t buffer_size)
205 : : {
206 : : libspdm_managed_buffer_t *managed_buffer;
207 : :
208 [ - + ]: 606 : LIBSPDM_ASSERT(buffer != NULL);
209 : :
210 [ - + ]: 606 : if (buffer_size == 0) {
211 : 0 : return LIBSPDM_STATUS_SUCCESS;
212 : : }
213 : :
214 : 606 : managed_buffer = m_buffer;
215 : :
216 [ - + ]: 606 : LIBSPDM_ASSERT(buffer_size != 0);
217 [ - + ]: 606 : LIBSPDM_ASSERT(managed_buffer->max_buffer_size >= managed_buffer->buffer_size);
218 : :
219 [ + + ]: 606 : if (buffer_size > managed_buffer->max_buffer_size - managed_buffer->buffer_size) {
220 : : /* Do not LIBSPDM_ASSERT here, because command processor will append message from external.*/
221 : 8 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR,
222 : : "libspdm_append_managed_buffer 0x%x fail, rest 0x%x only\n",
223 : : (uint32_t)buffer_size,
224 : : (uint32_t)(managed_buffer->max_buffer_size - managed_buffer->buffer_size)));
225 : 8 : return LIBSPDM_STATUS_BUFFER_FULL;
226 : : }
227 [ - + ]: 598 : LIBSPDM_ASSERT(buffer_size <= managed_buffer->max_buffer_size - managed_buffer->buffer_size);
228 : :
229 : 598 : libspdm_copy_mem((uint8_t *)(managed_buffer + 1) + managed_buffer->buffer_size,
230 : : buffer_size, buffer, buffer_size);
231 : 598 : managed_buffer->buffer_size += buffer_size;
232 : :
233 : 598 : return LIBSPDM_STATUS_SUCCESS;
234 : : }
235 : :
236 : 3022 : void libspdm_reset_managed_buffer(void *m_buffer)
237 : : {
238 : : libspdm_managed_buffer_t *managed_buffer;
239 : :
240 : 3022 : managed_buffer = m_buffer;
241 : 3022 : managed_buffer->buffer_size = 0;
242 : :
243 : 3022 : libspdm_zero_mem(managed_buffer + 1, managed_buffer->max_buffer_size);
244 : 3022 : }
245 : :
246 : 781 : size_t libspdm_get_managed_buffer_size(void *m_buffer)
247 : : {
248 : : libspdm_managed_buffer_t *managed_buffer;
249 : :
250 : 781 : managed_buffer = m_buffer;
251 : :
252 : 781 : return managed_buffer->buffer_size;
253 : : }
254 : :
255 : 760 : void *libspdm_get_managed_buffer(void *m_buffer)
256 : : {
257 : : libspdm_managed_buffer_t *managed_buffer;
258 : :
259 : 760 : managed_buffer = m_buffer;
260 : :
261 : 760 : return (managed_buffer + 1);
262 : : }
263 : :
264 : 127 : void libspdm_init_managed_buffer(void *m_buffer, size_t max_buffer_size)
265 : : {
266 : : libspdm_managed_buffer_t *managed_buffer;
267 : :
268 : 127 : managed_buffer = m_buffer;
269 : 127 : managed_buffer->max_buffer_size = max_buffer_size;
270 : :
271 : 127 : libspdm_reset_managed_buffer(m_buffer);
272 : 127 : }
273 : :
274 : 0 : uint32_t libspdm_module_version(void)
275 : : {
276 : 0 : return (LIBSPDM_MAJOR_VERSION << 24) |
277 : : (LIBSPDM_MINOR_VERSION << 16) |
278 : : (LIBSPDM_PATCH_VERSION << 8) |
279 : : (LIBSPDM_ALPHA);
280 : : }
281 : :
282 : : /*true: FIPS enabled, false: FIPS disabled*/
283 : 0 : bool libspdm_get_fips_mode(void)
284 : : {
285 : : #if LIBSPDM_FIPS_MODE
286 : 0 : return true;
287 : : #else
288 : : return false;
289 : : #endif
290 : : }
291 : :
292 : 143 : uint32_t libspdm_mask_capability_flags(libspdm_context_t *spdm_context,
293 : : bool is_request_flags, uint32_t flags)
294 : : {
295 [ + + + + : 143 : switch (libspdm_get_connection_version(spdm_context)) {
+ - ]
296 : 13 : case SPDM_MESSAGE_VERSION_10:
297 [ - + ]: 13 : if (is_request_flags) {
298 : : /* A 1.0 Requester does not have any capability flags. */
299 : 0 : return 0;
300 : : } else {
301 : 13 : return (flags & SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_10_MASK);
302 : : }
303 : 77 : case SPDM_MESSAGE_VERSION_11:
304 [ + + ]: 77 : if (is_request_flags) {
305 : 67 : return (flags & SPDM_GET_CAPABILITIES_REQUEST_FLAGS_11_MASK);
306 : : } else {
307 : 10 : return (flags & SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_11_MASK);
308 : : }
309 : 17 : case SPDM_MESSAGE_VERSION_12:
310 [ + + ]: 17 : if (is_request_flags) {
311 : 15 : return (flags & SPDM_GET_CAPABILITIES_REQUEST_FLAGS_12_MASK);
312 : : } else {
313 : 2 : return (flags & SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_12_MASK);
314 : : }
315 : 23 : case SPDM_MESSAGE_VERSION_13:
316 [ + + ]: 23 : if (is_request_flags) {
317 : 18 : return (flags & SPDM_GET_CAPABILITIES_REQUEST_FLAGS_13_MASK);
318 : : } else {
319 : 5 : return (flags & SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_13_MASK);
320 : : }
321 : 13 : case SPDM_MESSAGE_VERSION_14:
322 [ + + ]: 13 : if (is_request_flags) {
323 : 8 : return (flags & SPDM_GET_CAPABILITIES_REQUEST_FLAGS_14_MASK);
324 : : } else {
325 : 5 : return (flags & SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_14_MASK);
326 : : }
327 : 0 : default:
328 : 0 : LIBSPDM_ASSERT(false);
329 : 0 : return 0;
330 : : }
331 : : }
332 : :
333 : 13 : uint16_t libspdm_mask_capability_ext_flags(libspdm_context_t *spdm_context,
334 : : bool is_request_flags, uint16_t ext_flags)
335 : : {
336 [ - + - ]: 13 : switch (libspdm_get_connection_version(spdm_context)) {
337 : 0 : case SPDM_MESSAGE_VERSION_10:
338 : : case SPDM_MESSAGE_VERSION_11:
339 : : case SPDM_MESSAGE_VERSION_12:
340 : : case SPDM_MESSAGE_VERSION_13:
341 : : /* No extended capability flags are defined for SPDM 1.0 - 1.3. */
342 : 0 : return 0;
343 : 13 : case SPDM_MESSAGE_VERSION_14:
344 [ + + ]: 13 : if (is_request_flags) {
345 : : /* No extended request flags are defined for SPDM 1.4. */
346 : 8 : return 0;
347 : : } else {
348 : 5 : return (ext_flags & SPDM_GET_CAPABILITIES_EXTENDED_RESPONSE_FLAGS_14_MASK);
349 : : }
350 : 0 : default:
351 : 0 : LIBSPDM_ASSERT(false);
352 : 0 : return 0;
353 : : }
354 : : }
355 : :
356 : 0 : uint32_t libspdm_mask_base_hash_algo(libspdm_context_t *spdm_context, uint32_t base_hash_algo)
357 : : {
358 : 0 : const uint8_t spdm_version = libspdm_get_connection_version(spdm_context);
359 : :
360 [ # # ]: 0 : if (spdm_version >= SPDM_MESSAGE_VERSION_12) {
361 : 0 : return (base_hash_algo & SPDM_ALGORITHMS_BASE_HASH_ALGO_12_MASK);
362 : : } else {
363 : 0 : return (base_hash_algo & SPDM_ALGORITHMS_BASE_HASH_ALGO_10_MASK);
364 : : }
365 : : }
366 : :
367 : 0 : uint32_t libspdm_mask_measurement_hash_algo(libspdm_context_t *spdm_context,
368 : : uint32_t measurement_hash_algo)
369 : : {
370 : 0 : const uint8_t spdm_version = libspdm_get_connection_version(spdm_context);
371 : :
372 [ # # ]: 0 : if (spdm_version >= SPDM_MESSAGE_VERSION_12) {
373 : 0 : return (measurement_hash_algo & SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_12_MASK);
374 : : } else {
375 : 0 : return (measurement_hash_algo & SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_10_MASK);
376 : : }
377 : : }
378 : :
379 : 0 : uint8_t libspdm_mask_measurement_specification(uint8_t measurement_specification)
380 : : {
381 : 0 : return (measurement_specification & SPDM_MEASUREMENT_SPECIFICATION_10_MASK);
382 : : }
383 : :
384 : 0 : uint8_t libspdm_mask_mel_specification(libspdm_context_t *spdm_context, uint8_t mel_specification)
385 : : {
386 [ # # ]: 0 : LIBSPDM_ASSERT(libspdm_get_connection_version(spdm_context) >= SPDM_MESSAGE_VERSION_13);
387 : :
388 : 0 : return (mel_specification & SPDM_MEL_SPECIFICATION_13_MASK);
389 : : }
390 : :
391 : 0 : uint32_t libspdm_mask_base_asym_algo(libspdm_context_t *spdm_context, uint32_t base_asym_algo)
392 : : {
393 : 0 : const uint8_t spdm_version = libspdm_get_connection_version(spdm_context);
394 : :
395 [ # # ]: 0 : if (spdm_version >= SPDM_MESSAGE_VERSION_12) {
396 : 0 : return (base_asym_algo & SPDM_ALGORITHMS_BASE_ASYM_ALGO_12_MASK);
397 : : } else {
398 : 0 : return (base_asym_algo & SPDM_ALGORITHMS_BASE_ASYM_ALGO_10_MASK);
399 : : }
400 : : }
401 : :
402 : 0 : uint16_t libspdm_mask_alg_supported(libspdm_context_t *spdm_context, uint8_t alg_type,
403 : : uint16_t alg_supported)
404 : : {
405 : 0 : const uint8_t spdm_version = libspdm_get_connection_version(spdm_context);
406 : :
407 [ # # ]: 0 : LIBSPDM_ASSERT(spdm_version >= SPDM_MESSAGE_VERSION_11);
408 : :
409 [ # # # # : 0 : switch (alg_type) {
# ]
410 : 0 : case SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE:
411 [ # # ]: 0 : if (spdm_version >= SPDM_MESSAGE_VERSION_12) {
412 : 0 : return (alg_supported & SPDM_NEGOTIATE_ALGORITHMS_ALG_SUPPORTED_DHE_12_MASK);
413 : : } else {
414 : 0 : return (alg_supported & SPDM_NEGOTIATE_ALGORITHMS_ALG_SUPPORTED_DHE_11_MASK);
415 : : }
416 : 0 : case SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD:
417 [ # # ]: 0 : if (spdm_version >= SPDM_MESSAGE_VERSION_12) {
418 : 0 : return (alg_supported & SPDM_NEGOTIATE_ALGORITHMS_ALG_SUPPORTED_AEAD_12_MASK);
419 : : } else {
420 : 0 : return (alg_supported & SPDM_NEGOTIATE_ALGORITHMS_ALG_SUPPORTED_AEAD_11_MASK);
421 : : }
422 : 0 : case SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG:
423 [ # # ]: 0 : if (spdm_version >= SPDM_MESSAGE_VERSION_12) {
424 : 0 : return (alg_supported &
425 : : SPDM_NEGOTIATE_ALGORITHMS_ALG_SUPPORTED_REQ_BASE_ASYM_ALG_12_MASK);
426 : : } else {
427 : 0 : return (alg_supported &
428 : : SPDM_NEGOTIATE_ALGORITHMS_ALG_SUPPORTED_REQ_BASE_ASYM_ALG_11_MASK);
429 : : }
430 : 0 : case SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE:
431 : 0 : return (alg_supported & SPDM_NEGOTIATE_ALGORITHMS_ALG_SUPPORTED_KEY_SCHEDULE_11_MASK);
432 : 0 : default:
433 : 0 : LIBSPDM_ASSERT(false);
434 : 0 : return 0;
435 : : }
436 : : }
437 : :
438 : 38 : bool libspdm_validate_svh_vendor_id_len(uint16_t id, uint8_t vendor_id_len)
439 : : {
440 [ + + - - : 38 : switch (id) {
- - ]
441 : 28 : case SPDM_REGISTRY_ID_DMTF:
442 : : case SPDM_REGISTRY_ID_VESA:
443 : 28 : return (vendor_id_len == 0);
444 : 10 : case SPDM_REGISTRY_ID_TCG:
445 : : case SPDM_REGISTRY_ID_USB:
446 : : case SPDM_REGISTRY_ID_PCISIG:
447 : : case SPDM_REGISTRY_ID_MIPI:
448 : : case SPDM_REGISTRY_ID_CXL:
449 : : case SPDM_REGISTRY_ID_JEDEC:
450 [ + - + - ]: 10 : return ((vendor_id_len == 0) || (vendor_id_len == 2));
451 : 0 : case SPDM_REGISTRY_ID_IANA:
452 : : case SPDM_REGISTRY_ID_HDBASET:
453 [ # # # # ]: 0 : return ((vendor_id_len == 0) || (vendor_id_len == 4));
454 : 0 : case SPDM_REGISTRY_ID_IANA_CBOR:
455 [ # # ]: 0 : switch (vendor_id_len) {
456 : : /* A CBOR-encoded tag number is either a simple one byte identifier, or a one byte
457 : : * identifier followed by a one, two, four, or eight byte unsigned integer. */
458 : 0 : case 1:
459 : : case 2:
460 : : case 3:
461 : : case 5:
462 : : case 9:
463 : 0 : return true;
464 : 0 : default:
465 : 0 : return false;
466 : : }
467 : 0 : case SPDM_REGISTRY_ID_DMTF_DSP:
468 : 0 : return (vendor_id_len == 2);
469 : 0 : default:
470 : 0 : return false;
471 : : }
472 : : }
473 : :
474 : 100 : bool libspdm_check_for_space(const uint8_t *ptr, const uint8_t *end_ptr, size_t increment)
475 : : {
476 [ - + ]: 100 : LIBSPDM_ASSERT(ptr <= end_ptr);
477 : :
478 : 100 : return ((uintptr_t)(end_ptr - ptr) >= increment);
479 : : }
|
