Embedded SDK
Embedded SDK
Loading...
Searching...
No Matches
u2f_transport.c
Go to the documentation of this file.
1/*****************************************************************************
2 * (c) 2025 Ledger SAS.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *****************************************************************************/
16
17/* Includes ------------------------------------------------------------------*/
18#include <string.h>
19
20#include "os.h"
21#include "os_math.h"
22#include "os_utils.h"
23#include "os_io.h"
24
25#include "u2f_types.h"
26#include "u2f_transport.h"
27
28/* Private enumerations ------------------------------------------------------*/
29
30/* Private types, structures, unions -----------------------------------------*/
31
32/* Private defines------------------------------------------------------------*/
33#ifdef HAVE_PRINTF
34// #define LOG_IO PRINTF
35#define LOG_IO(...)
36#else // !HAVE_PRINTF
37#define LOG_IO(...)
38#endif // !HAVE_PRINTF
39
40/* Private macros-------------------------------------------------------------*/
41
42/* Private functions prototypes ----------------------------------------------*/
43static u2f_error_t process_packet(u2f_transport_t *handle, uint8_t *buffer, uint16_t length);
44
45/* Exported variables --------------------------------------------------------*/
46
47/* Private variables ---------------------------------------------------------*/
48
49/* Private functions ---------------------------------------------------------*/
50static u2f_error_t process_packet(u2f_transport_t *handle, uint8_t *buffer, uint16_t length)
51{
53 uint32_t message_cid = U2F_FORBIDDEN_CID;
54
55 // Check CID for USB HID transport
56 if (handle->type == U2F_TRANSPORT_TYPE_USB_HID) {
57 if ((length < 5) || ((buffer[4] & 0x80) && (length < 7))) {
58 // Header not complete: the packet is dropped before it can claim the channel
59 error = CTAP1_ERR_OTHER;
60 goto end;
61 }
62 message_cid = U4BE(buffer, 0);
63 bool is_owner = (handle->cid == message_cid);
64 bool is_cancel = (buffer[4] == (U2F_COMMAND_HID_CANCEL | 0x80));
65 bool command_in_app = ((handle->state == U2F_STATE_CMD_PROCESSING)
67 && !handle->tx_ends_transaction;
68 if (!(buffer[4] & 0x80) && (!is_owner || (handle->state != U2F_STATE_CMD_FRAMING))) {
69 // Continuation packet outside the message being received: not answered
70 error = CTAP1_ERR_OTHER;
71 goto end;
72 }
73 if (is_cancel && (!is_owner || (U2BE(buffer, 5) != 0) || !command_in_app)) {
74 // CANCEL is never answered, has no data, and only cancels its sender's command.
75 error = CTAP1_ERR_OTHER;
76 goto end;
77 }
78 // A new client must not be locked out by a sender that stopped mid-message.
79 if ((message_cid == U2F_BROADCAST_CID) && (buffer[4] == (U2F_COMMAND_HID_INIT | 0x80))
80 && (handle->state == U2F_STATE_CMD_FRAMING)) {
81 handle->state = U2F_STATE_IDLE;
82 handle->cid = U2F_FORBIDDEN_CID;
83 }
84 if (message_cid == U2F_FORBIDDEN_CID) {
85 // Forbidden CID
87 goto reject;
88 }
89 else if ((message_cid == U2F_BROADCAST_CID)
90 && (buffer[4] != (U2F_COMMAND_HID_INIT | 0x80))) {
91 // Broadcast CID but not an init message
93 goto reject;
94 }
95 else if ((handle->cid != U2F_FORBIDDEN_CID) && (handle->cid != message_cid)) {
96 // CID is already set
98 goto reject;
99 }
100 else if (handle->tx_ends_transaction) {
101 // The reply's last packet has not reached the host yet: the transaction is still on.
103 goto reject;
104 }
105 else if ((handle->state > U2F_STATE_CMD_FRAMING) && !is_cancel) {
106 // Good CID but a request is already in process, even a cancelled one.
108 goto reject;
109 }
110 else if (handle->cid == U2F_FORBIDDEN_CID) {
111 // Set new CID
112 handle->cid = message_cid;
113 }
114 handle->tx_cid = message_cid;
115 buffer += 4;
116 length -= 4;
117 }
118
119 // Check header length
120 if (length < 1) {
121 error = CTAP1_ERR_OTHER;
122 goto end;
123 }
124
125 if (buffer[0] & 0x80) {
126 // Initialization packet
127 if (length < 3) {
128 error = CTAP1_ERR_OTHER;
129 goto end;
130 }
131
132 // A new first packet ends the message being received, even when it is refused.
133 if (handle->state == U2F_STATE_CMD_FRAMING) {
134 handle->state = U2F_STATE_IDLE;
135 }
136
137 // Check if packet will fit in the rx buffer
138 uint32_t message_length = (uint32_t) U2BE(buffer, 1) + 3;
139 if (message_length > handle->rx_message_buffer_size) {
141 goto end;
142 }
143
144 if ((message_length <= 3) && (buffer[0] == (U2F_COMMAND_HID_CBOR | 0x80))) {
147 goto end;
148 }
149
150 handle->rx_message_length = (uint16_t) message_length;
152 handle->rx_message_offset = 0;
153 handle->rx_message_buffer[handle->rx_message_offset++] = buffer[0] & 0x7F; // CMD
154 handle->rx_message_buffer[handle->rx_message_offset++] = buffer[1]; // BCNTH
155 handle->rx_message_buffer[handle->rx_message_offset++] = buffer[2]; // BCNTL
157 buffer += 3;
158 length -= 3;
159 }
160 else {
161 // Continuation packet
162 if (handle->state != U2F_STATE_CMD_FRAMING) {
163 error = CTAP1_ERR_OTHER;
164 goto end;
165 }
166 else if (buffer[0] != handle->rx_message_expected_sequence_number) {
167 error = CTAP1_ERR_INVALID_SEQ;
168 goto end;
169 }
171 buffer += 1;
172 length -= 1;
173 }
174
175 // prevent integer underflows and buffer overflows in the rest of the operations
176 if ((handle->rx_message_length > handle->rx_message_buffer_size)
177 || (handle->rx_message_length < handle->rx_message_offset)) {
178 error = CTAP1_ERR_OTHER;
179 goto end;
180 }
181 if (length > handle->rx_message_length - handle->rx_message_offset) {
182 length = handle->rx_message_length - handle->rx_message_offset;
183 }
184 memcpy(&handle->rx_message_buffer[handle->rx_message_offset], buffer, length);
185 handle->rx_message_offset += length;
186
187 if (handle->rx_message_offset == handle->rx_message_length) {
189 }
190
191end:
192 return error;
193
194reject:
195 // Answered later without touching the channel. One waits at a time: later senders retry.
196 if (!handle->reject_pending) {
197 handle->reject_pending = true;
198 handle->reject_cid = message_cid;
199 handle->reject_error = error;
200 }
201 return CTAP1_ERR_OTHER;
202}
203
204/* Exported functions --------------------------------------------------------*/
205void U2F_TRANSPORT_init(u2f_transport_t *handle, uint8_t type)
206{
207 if (!handle) {
208 return;
209 }
210
211 handle->state = U2F_STATE_IDLE;
212 handle->cid = U2F_FORBIDDEN_CID;
213 handle->type = type;
214 handle->reject_pending = false;
215}
216
217void U2F_TRANSPORT_rx(u2f_transport_t *handle, uint8_t *buffer, uint16_t length)
218{
219 if (!handle || !buffer || length < 3) {
220 return;
221 }
222
223 handle->error = process_packet(handle, buffer, length);
224}
225
227{
228 if (!handle || handle->tx_message_buffer || !handle->tx_ends_transaction) {
229 return;
230 }
231 // The transaction lasts until the host has the last packet of the response.
232 handle->tx_ends_transaction = false;
233 handle->cid = U2F_FORBIDDEN_CID;
234 if ((handle->state == U2F_STATE_CMD_PROCESSING)
235 || (handle->state == U2F_STATE_CMD_PROCESSING_CANCEL)) {
236 handle->state = U2F_STATE_IDLE;
237 }
238}
239
241 uint8_t cmd,
242 const uint8_t *buffer,
243 uint16_t length,
244 uint8_t *tx_packet_buffer,
245 uint16_t tx_packet_buffer_size)
246{
247 if (!handle || (!buffer && !handle->tx_message_buffer)) {
248 return;
249 }
250
251 if (buffer) {
252 LOG_IO("Tx : INITIALIZATION PACKET\n");
253 // A keepalive is sent while the command is still being processed.
255 handle->tx_message_buffer = buffer;
256 handle->tx_message_length = length;
257 handle->tx_message_sequence_number = 0;
258 handle->tx_message_offset = 0;
259 handle->tx_packet_length = 0;
260 memset(tx_packet_buffer, 0, tx_packet_buffer_size);
261 }
262 else {
263 LOG_IO("Tx : CONTINUATION PACKET\n");
264 }
265
266 uint16_t tx_packet_offset = 0;
267 memset(tx_packet_buffer, 0, tx_packet_buffer_size);
268
269 // Add CID if necessary
270 if (handle->type == U2F_TRANSPORT_TYPE_USB_HID) {
271 U4BE_ENCODE(tx_packet_buffer, 0, handle->tx_cid);
272 tx_packet_offset += 4;
273 }
274
275 // Fill header
276 if (buffer) {
277 tx_packet_buffer[tx_packet_offset++] = cmd | 0x80; // CMD
278 U2BE_ENCODE(tx_packet_buffer, tx_packet_offset, length); // BCNT
279 tx_packet_offset += 2;
280 }
281 else {
282 tx_packet_buffer[tx_packet_offset++] = handle->tx_message_sequence_number++; // SEQ
283 }
284
285 if ((handle->tx_message_length + tx_packet_offset)
286 > (tx_packet_buffer_size + handle->tx_message_offset)) {
287 // Remaining message length doesn't fit the max packet size
288 memcpy(&tx_packet_buffer[tx_packet_offset],
289 &handle->tx_message_buffer[handle->tx_message_offset],
290 tx_packet_buffer_size - tx_packet_offset);
291 handle->tx_message_offset += tx_packet_buffer_size - tx_packet_offset;
292 tx_packet_offset = tx_packet_buffer_size;
293 }
294 else {
295 // Remaining message fits the max packet size
296 memcpy(&tx_packet_buffer[tx_packet_offset],
297 &handle->tx_message_buffer[handle->tx_message_offset],
298 handle->tx_message_length - handle->tx_message_offset);
299 tx_packet_offset += (handle->tx_message_length - handle->tx_message_offset);
300 handle->tx_message_offset = handle->tx_message_length;
301 handle->tx_message_buffer = NULL;
302 }
303
304 handle->tx_packet_length = tx_packet_offset;
305 LOG_IO(" %d\n", handle->tx_packet_length);
306}
uint16_t rx_message_buffer_size
uint32_t reject_cid
uint8_t * rx_message_buffer
uint16_t rx_message_length
uint16_t rx_message_expected_sequence_number
u2f_error_t reject_error
uint16_t tx_message_sequence_number
uint16_t tx_message_offset
u2f_transport_type_t type
uint16_t tx_message_length
uint16_t rx_message_offset
const uint8_t * tx_message_buffer
u2f_error_t error
uint8_t tx_packet_length
#define LOG_IO(...)
void U2F_TRANSPORT_tx(u2f_transport_t *handle, uint8_t cmd, const uint8_t *buffer, uint16_t length, uint8_t *tx_packet_buffer, uint16_t tx_packet_buffer_size)
void U2F_TRANSPORT_init(u2f_transport_t *handle, uint8_t type)
void U2F_TRANSPORT_rx(u2f_transport_t *handle, uint8_t *buffer, uint16_t length)
void U2F_TRANSPORT_tx_done(u2f_transport_t *handle)
static u2f_error_t process_packet(u2f_transport_t *handle, uint8_t *buffer, uint16_t length)
@ U2F_TRANSPORT_TYPE_USB_HID
#define U2F_FORBIDDEN_CID
#define U2F_BROADCAST_CID
@ U2F_STATE_IDLE
Definition u2f_types.h:26
@ U2F_STATE_CMD_PROCESSING_CANCEL
Definition u2f_types.h:30
@ U2F_STATE_CMD_PROCESSING
Definition u2f_types.h:29
@ U2F_STATE_CMD_FRAMING
Definition u2f_types.h:27
@ U2F_STATE_CMD_COMPLETE
Definition u2f_types.h:28
u2f_error_t
Definition u2f_types.h:64
@ CTAP1_ERR_INVALID_CHANNEL
Definition u2f_types.h:74
@ CTAP1_ERR_SUCCESS
Definition u2f_types.h:66
@ CTAP1_ERR_OTHER
Definition u2f_types.h:75
@ CTAP1_ERR_CHANNEL_BUSY
Definition u2f_types.h:72
@ CTAP1_ERR_INVALID_LENGTH
Definition u2f_types.h:69
@ CTAP2_ERR_INVALID_CBOR
Definition u2f_types.h:80
@ CTAP1_ERR_INVALID_SEQ
Definition u2f_types.h:70
@ U2F_COMMAND_HID_CBOR
Definition u2f_types.h:43
@ U2F_COMMAND_HID_INIT
Definition u2f_types.h:41
@ U2F_COMMAND_HID_CANCEL
Definition u2f_types.h:44
@ U2F_COMMAND_HID_KEEP_ALIVE
Definition u2f_types.h:45