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 "library/spdm_transport_pcidoe_lib.h"
8 : : #include "library/spdm_secured_message_lib.h"
9 : : #include "hal/library/debuglib.h"
10 : :
11 : : /**
12 : : * Encode a normal message or secured message to a transport message.
13 : : *
14 : : * @param session_id Indicates if it is a secured message protected via SPDM session.
15 : : * If session_id is NULL, it is a normal message.
16 : : * If session_id is NOT NULL, it is a secured message.
17 : : * @param message_size size in bytes of the message data buffer.
18 : : * @param message A pointer to a source buffer to store the message.
19 : : * @param transport_message_size size in bytes of the transport message data buffer.
20 : : * @param transport_message A pointer to a destination buffer to store the transport message.
21 : : **/
22 : : libspdm_return_t libspdm_pci_doe_encode_message(const uint32_t *session_id,
23 : : size_t message_size, void *message,
24 : : size_t *transport_message_size,
25 : : void **transport_message);
26 : :
27 : : /**
28 : : * Decode a transport message to a normal message or secured message.
29 : : *
30 : : * @param session_id Indicates if it is a secured message protected via SPDM session.
31 : : * If *session_id is NULL, it is a normal message.
32 : : * If *session_id is NOT NULL, it is a secured message.
33 : : * @param transport_message_size size in bytes of the transport message data buffer.
34 : : * @param transport_message A pointer to a source buffer to store the transport message.
35 : : * @param message_size size in bytes of the message data buffer.
36 : : * @param message A pointer to a destination buffer to store the message.
37 : : **/
38 : : libspdm_return_t libspdm_pci_doe_decode_message(uint32_t **session_id,
39 : : size_t transport_message_size,
40 : : void *transport_message,
41 : : size_t *message_size,
42 : : void **message);
43 : :
44 : 1 : libspdm_return_t libspdm_transport_pci_doe_encode_message(
45 : : void *spdm_context, const uint32_t *session_id, bool is_app_message,
46 : : bool is_request_message, size_t message_size, void *message,
47 : : size_t *transport_message_size, void **transport_message)
48 : : {
49 : : libspdm_return_t status;
50 : : uint8_t *secured_message;
51 : : size_t secured_message_size;
52 : : libspdm_secured_message_callbacks_t spdm_secured_message_callbacks;
53 : : void *secured_message_context;
54 : : size_t sec_trans_header_size;
55 : :
56 : 1 : spdm_secured_message_callbacks.version =
57 : : LIBSPDM_SECURED_MESSAGE_CALLBACKS_VERSION;
58 : 1 : spdm_secured_message_callbacks.get_sequence_number =
59 : : libspdm_pci_doe_get_sequence_number;
60 : 1 : spdm_secured_message_callbacks.get_max_random_number_count =
61 : : libspdm_pci_doe_get_max_random_number_count;
62 : 1 : spdm_secured_message_callbacks.get_secured_spdm_version =
63 : : libspdm_pci_doe_get_secured_spdm_version;
64 : :
65 [ - + ]: 1 : if (is_app_message) {
66 : 0 : return LIBSPDM_STATUS_UNSUPPORTED_CAP;
67 : : }
68 : :
69 [ - + ]: 1 : if (session_id != NULL) {
70 : : secured_message_context =
71 : 0 : libspdm_get_secured_message_context_via_session_id(
72 : : spdm_context, *session_id);
73 [ # # ]: 0 : if (secured_message_context == NULL) {
74 : 0 : return LIBSPDM_STATUS_UNSUPPORTED_CAP;
75 : : }
76 : :
77 : : /* message to secured message*/
78 : 0 : sec_trans_header_size = sizeof(pci_doe_data_object_header_t);
79 : 0 : secured_message = (uint8_t *)*transport_message + sec_trans_header_size;
80 : 0 : secured_message_size = *transport_message_size - sec_trans_header_size;
81 : 0 : status = libspdm_encode_secured_message(
82 : : secured_message_context, *session_id, is_request_message,
83 : : message_size, message, &secured_message_size,
84 : : secured_message, &spdm_secured_message_callbacks);
85 [ # # ]: 0 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
86 : 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR,
87 : : "libspdm_encode_secured_message - %x\n", status));
88 : 0 : return status;
89 : : }
90 : :
91 : : /* secured message to secured PCI DOE message*/
92 : 0 : status = libspdm_pci_doe_encode_message(
93 : : session_id, secured_message_size, secured_message,
94 : : transport_message_size, transport_message);
95 [ # # ]: 0 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
96 : 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "transport_encode_message - %x\n",
97 : : status));
98 : 0 : return status;
99 : : }
100 : : } else {
101 : : /* SPDM message to normal PCI DOE message*/
102 : 1 : status = libspdm_pci_doe_encode_message(NULL, message_size, message,
103 : : transport_message_size,
104 : : transport_message);
105 [ - + ]: 1 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
106 : 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "transport_encode_message - %x\n",
107 : : status));
108 : 0 : return status;
109 : : }
110 : : }
111 : :
112 : 1 : return LIBSPDM_STATUS_SUCCESS;
113 : : }
114 : :
115 : 1 : libspdm_return_t libspdm_transport_pci_doe_decode_message(
116 : : void *spdm_context, uint32_t **session_id,
117 : : bool *is_app_message, bool is_request_message,
118 : : size_t transport_message_size, void *transport_message,
119 : : size_t *message_size, void **message)
120 : : {
121 : : libspdm_return_t status;
122 : : uint32_t *secured_message_session_id;
123 : : uint8_t *secured_message;
124 : : size_t secured_message_size;
125 : : libspdm_secured_message_callbacks_t spdm_secured_message_callbacks;
126 : : void *secured_message_context;
127 : : libspdm_error_struct_t spdm_error;
128 : :
129 : 1 : spdm_error.error_code = 0;
130 : 1 : spdm_error.session_id = 0;
131 : 1 : libspdm_set_last_spdm_error_struct(spdm_context, &spdm_error);
132 : :
133 : 1 : spdm_secured_message_callbacks.version =
134 : : LIBSPDM_SECURED_MESSAGE_CALLBACKS_VERSION;
135 : 1 : spdm_secured_message_callbacks.get_sequence_number =
136 : : libspdm_pci_doe_get_sequence_number;
137 : 1 : spdm_secured_message_callbacks.get_max_random_number_count =
138 : : libspdm_pci_doe_get_max_random_number_count;
139 : 1 : spdm_secured_message_callbacks.get_secured_spdm_version =
140 : : libspdm_pci_doe_get_secured_spdm_version;
141 : :
142 [ - + - - ]: 1 : if ((session_id == NULL) || (is_app_message == NULL)) {
143 : 1 : return LIBSPDM_STATUS_UNSUPPORTED_CAP;
144 : : }
145 : 0 : *is_app_message = false;
146 : :
147 : 0 : secured_message_session_id = NULL;
148 : : /* Detect received message*/
149 : 0 : status = libspdm_pci_doe_decode_message(
150 : : &secured_message_session_id, transport_message_size,
151 : : transport_message, &secured_message_size, (void **)&secured_message);
152 [ # # ]: 0 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
153 : 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "transport_decode_message - %x\n", status));
154 : 0 : return status;
155 : : }
156 : :
157 [ # # ]: 0 : if (secured_message_session_id != NULL) {
158 : 0 : *session_id = secured_message_session_id;
159 : :
160 : : secured_message_context =
161 : 0 : libspdm_get_secured_message_context_via_session_id(
162 : : spdm_context, *secured_message_session_id);
163 [ # # ]: 0 : if (secured_message_context == NULL) {
164 : 0 : spdm_error.error_code = SPDM_ERROR_CODE_INVALID_SESSION;
165 : 0 : spdm_error.session_id = *secured_message_session_id;
166 : 0 : libspdm_set_last_spdm_error_struct(spdm_context,
167 : : &spdm_error);
168 : 0 : return LIBSPDM_STATUS_UNSUPPORTED_CAP;
169 : : }
170 : :
171 : : /* Secured message to message*/
172 : 0 : status = libspdm_decode_secured_message(
173 : : secured_message_context, *secured_message_session_id,
174 : : is_request_message, secured_message_size, secured_message,
175 : : message_size, message,
176 : : &spdm_secured_message_callbacks);
177 [ # # ]: 0 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
178 : 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR,
179 : : "libspdm_decode_secured_message - %x\n", status));
180 : 0 : libspdm_secured_message_get_last_spdm_error_struct(
181 : : secured_message_context, &spdm_error);
182 : 0 : libspdm_set_last_spdm_error_struct(spdm_context,
183 : : &spdm_error);
184 : 0 : return status;
185 : : }
186 : 0 : return LIBSPDM_STATUS_SUCCESS;
187 : : } else {
188 : : /* get non-secured message*/
189 : 0 : status = libspdm_pci_doe_decode_message(&secured_message_session_id,
190 : : transport_message_size,
191 : : transport_message,
192 : : message_size, message);
193 [ # # ]: 0 : if (LIBSPDM_STATUS_IS_ERROR(status)) {
194 : 0 : LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "transport_decode_message - %x\n",
195 : : status));
196 : 0 : return status;
197 : : }
198 [ # # ]: 0 : LIBSPDM_ASSERT(secured_message_session_id == NULL);
199 : 0 : *session_id = NULL;
200 : 0 : return LIBSPDM_STATUS_SUCCESS;
201 : : }
202 : : }
|
