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