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