FreeRDP
Loading...
Searching...
No Matches
rdpemt.c
1
17
18#include <freerdp/config.h>
19
20#include <string.h>
21
22#include <winpr/assert.h>
23#include <winpr/cast.h>
24#include <winpr/crt.h>
25#include <winpr/interlocked.h>
26#include <winpr/synch.h>
27#include <winpr/thread.h>
28#include <winpr/sysinfo.h>
29#include <winpr/winsock.h>
30#include <winpr/stream.h>
31
32#if !defined(_WIN32)
33#if defined(WINPR_HAVE_POLL_H)
34#include <poll.h>
35#else
36#include <sys/select.h>
37#endif
38#endif
39
40#include <openssl/crypto.h>
41#include <openssl/ssl.h>
42#include <openssl/err.h>
43#include <openssl/bio.h>
44#include <openssl/x509.h>
45
46#include <freerdp/crypto/certificate.h>
47
48#include "../crypto/certificate.h"
49#include "../crypto/privatekey.h"
50#include "rdpudp.h"
51#include "udplistener.h"
52#include "rdpemt.h"
53
54/* [MS-RDPEMT] 2.2.1.1 RDP_TUNNEL_HEADER Action */
55#define RDPTUNNEL_ACTION_CREATEREQUEST 0x0
56#define RDPTUNNEL_ACTION_CREATERESPONSE 0x1
57#define RDPTUNNEL_ACTION_DATA 0x2
58
59#define RDPTUNNEL_HEADER_LENGTH 4
60
61/* [MS-RDPEMT] 2.2.1.1.1 RDP_TUNNEL_SUBHEADER SubHeaderType */
62#define RDPTUNNEL_SUBHEADER_AUTODETECT_REQUEST 0x00
63#define RDPTUNNEL_SUBHEADER_AUTODETECT_RESPONSE 0x01
64
65/* Time allowed from the first SYN until the server accepts the tunnel. */
66#define RDPEMT_SETUP_TIMEOUT_MS 20000
67
68/* Server: timeout for client to prove cookie after offer. Short timeout prevents resource
69 * exhaustion (flow, thread, memory) from pending tunnels. */
70#define RDPEMT_SERVER_SETUP_TIMEOUT_MS 7000
71
72/* Server: max datagrams processed per iteration before updating timers, flushing data, and
73 * releasing the lock to prevent client-driven starvation. */
74#define RDPEMT_INPUT_BUDGET 256
75
76/* TLS record header: type, version, length */
77#define TLS_RECORD_HEADER_LENGTH 5
78
79/* Room per datagram for the TLS record header, padding and authentication tag. */
80#define TLS_RECORD_OVERHEAD 64
81
82/* Target plaintext size for server-side tunnel PDU batching into TLS records. */
83#define RDPEMT_SERVER_BATCH 16000
84
85/* Default link queue limit: 32768 datagrams (~16s at 20 Mbit/s). Since reliable tunnels
86 * cannot drop data, exceeding this limit indicates a pacing failure and triggers tunnel failure. */
87#define RDPEMT_SEND_LIMIT (32768ull * 1232ull)
88
89/* Assigns unique IDs to tunnels to differentiate events when a tunnel is replaced. */
90static LONG g_emtSerial = 0;
91
92struct rdp_emt
93{
94 wLog* log;
95 CRITICAL_SECTION lock;
96 HANDLE thread;
97 LONG stop; /* set by rdpemt_free, read by the thread; Interlocked functions only */
98
99 LONG serial; /* Unique identifier for each tunnel in the process; see rdpemt_get_serial(). */
100 UINT32 requestId;
101 BYTE cookie[16];
102 char* hostname;
103 BYTE* publicKey;
104 size_t publicKeyLength;
105
106 rdpEmtEventFn callback;
107 void* custom;
108 rdpEmtHoldFn hold; /* guarded by lock, see rdpemt_set_receive_hold() */
109
110 /* guarded by lock: tunnel data goes to receiver instead of callback when it is set */
111 rdpEmtReceiverFn receiver;
112 void* receiverCustom;
113 /* handed to receiver and not yet taken; Interlocked functions only */
114 LONG directBytes;
115
116 /* Server-side: main connection certificate, key, and expected cookie hash for client SYN. */
117 BOOL server;
118 X509* cert;
119 EVP_PKEY* key;
120 BYTE cookieHash[32];
121
122 /* Server-side: main connection TLS settings; see rdpemt_set_tls_settings. */
123 UINT16 tlsMinVersion;
124 UINT16 tlsMaxVersion;
125 UINT32 tlsSecLevel;
126 char* tlsCiphers;
127
128 rdpUdp* udp;
129 SSL_CTX* ctx;
130 SSL* ssl;
131 BIO* rbio;
132 BIO* wbio;
133
134 BOOL tlsStarted;
135 BOOL handshakeDone;
136 BOOL ready;
137 BOOL failed;
138 UINT64 started;
139 BOOL responseDueSent; /* Server-side: one-shot flag indicating RDPEMT_EVENT_RESPONSE_DUE has
140 been raised. */
141
142 /* TLS output not yet on the connection, and plaintext not yet parsed into tunnel PDUs;
143 * the position of each is how much they hold */
144 wStream* out;
145 wStream* in;
146
147 /* Server-side: tunnel PDUs batched for the next TLS record. */
148 wStream* batch;
149
150 /* Server-side: source and destination for datagrams. */
151 rdpUdpFlow* flow;
152
153 /* Server-side: plaintext data pending link availability (see EMT_QUEUED_DATA). Kept as
154 * plaintext to allow packing into full TLS records while preserving order. */
155 wQueue* sendQueue;
156 size_t sendQueueBytes;
157 size_t sendQueueItems; /* Number of items in sendQueue; each incurs EMT_QUEUE_ITEM_COST against
158 the limit. */
159 size_t sendLimit;
160 BOOL writeBlocked; /* Indicates the send backlog is full; clearing it triggers
161 RDPEMT_EVENT_WRITABLE. */
162};
163
164/* Drops the first count bytes of a stream that is filled up to its position. */
165WINPR_ATTR_NODISCARD
166static BOOL stream_consume(wStream* s, size_t count)
167{
168 WINPR_ASSERT(s);
169
170 const size_t used = Stream_GetPosition(s);
171 if (count > used)
172 return FALSE;
173 BYTE* buffer = Stream_Buffer(s);
174 memmove(buffer, &buffer[count], used - count);
175 return Stream_SetPosition(s, used - count);
176}
177
178static void emt_fail(rdpEmt* emt, const char* why)
179{
180 WINPR_ASSERT(emt);
181 WINPR_ASSERT(why);
182
183 if (emt->failed)
184 return;
185 emt->failed = TRUE;
186 emt->ready = FALSE;
187 WLog_Print(emt->log, WLOG_WARN, "UDP multitransport tunnel failed: %s", why);
188 emt->callback(emt->custom, emt, RDPEMT_EVENT_FAILED, nullptr, 0);
189}
190
191/* Called with lock held. */
192static void emt_hand_up(rdpEmt* emt, const BYTE* data, size_t length)
193{
194 WINPR_ASSERT(emt);
195 WINPR_ASSERT(data);
196
197 if (!emt->receiver)
198 {
199 emt->callback(emt->custom, emt, RDPEMT_EVENT_DATA, data, length);
200 return;
201 }
202
203 /* the receiver takes this stream over, the data is not copied again on the way */
204 wStream* s = Stream_New(nullptr, length);
205 if (!s)
206 {
207 emt_fail(emt, "out of memory for tunnel data");
208 return;
209 }
210 Stream_Write(s, data, length);
211 Stream_SealLength(s);
212 Stream_ResetPosition(s);
213 if (!emt->receiver(emt->receiverCustom, s))
214 {
215 emt_fail(emt, "the receiver of tunnel data failed");
216 return;
217 }
218 const LONG direct =
219 InterlockedExchangeAdd(&emt->directBytes, WINPR_ASSERTING_INT_CAST(LONG, length));
220 WINPR_UNUSED(direct);
221}
222
223static void log_ssl_errors(rdpEmt* emt, const char* what)
224{
225 WINPR_ASSERT(emt);
226 WINPR_ASSERT(what);
227
228 unsigned long err = 0;
229 while ((err = ERR_get_error()) != 0)
230 {
231 char buffer[256] = WINPR_C_ARRAY_INIT;
232 ERR_error_string_n(err, buffer, sizeof(buffer));
233 WLog_Print(emt->log, WLOG_WARN, "%s: %s", what, buffer);
234 }
235}
236
237/* Moves whatever TLS produced onto the RDP-UDP connection. Records are packed whole into
238 * datagrams, so a peer that reads one record per datagram works as well as one that reads the
239 * connection as a stream. */
240WINPR_ATTR_NODISCARD
241static BOOL emt_flush_tls(rdpEmt* emt)
242{
243 WINPR_ASSERT(emt);
244
245 while (TRUE)
246 {
247 const size_t pending = BIO_ctrl_pending(emt->wbio);
248 if (pending == 0)
249 break;
250 if (pending > INT32_MAX)
251 return FALSE;
252 if (!Stream_EnsureRemainingCapacity(emt->out, pending))
253 return FALSE;
254 const int rc =
255 BIO_read(emt->wbio, Stream_Pointer(emt->out), WINPR_ASSERTING_INT_CAST(int, pending));
256 if (rc <= 0)
257 break;
258 Stream_Seek(emt->out, WINPR_ASSERTING_INT_CAST(size_t, rc));
259 }
260
261 const size_t max = rdpudp_get_max_payload(emt->udp);
262 if (max == 0)
263 return FALSE;
264 if (emt->server)
265 {
266 /* Connection is a byte stream; server fills every datagram. */
267 const BYTE* bytes = Stream_Buffer(emt->out);
268 const size_t total = Stream_GetPosition(emt->out);
269 size_t offset = 0;
270 while (offset < total)
271 {
272 /* Compare remainder to avoid overflow from offset + max. */
273 const size_t length = (total - offset > max) ? max : total - offset;
274 if (!rdpudp_send(emt->udp, &bytes[offset], length))
275 return FALSE;
276 offset += length;
277 }
278 return stream_consume(emt->out, total);
279 }
280 const BYTE* data = Stream_Buffer(emt->out);
281 wStream sbuffer = WINPR_C_ARRAY_INIT;
282 wStream* s = Stream_StaticConstInit(&sbuffer, data, Stream_GetPosition(emt->out));
283
284 size_t chunk = 0;
285 while (Stream_GetRemainingLength(s) >= TLS_RECORD_HEADER_LENGTH)
286 {
287 /* TLS record header: ContentType, ProtocolVersion, length */
288 const size_t pos = Stream_GetPosition(s);
289 Stream_Seek(s, 3);
290 const size_t record = TLS_RECORD_HEADER_LENGTH + Stream_Get_UINT16_BE(s);
291 if (Stream_GetRemainingLength(s) < record - TLS_RECORD_HEADER_LENGTH)
292 {
293 if (!Stream_SetPosition(s, pos))
294 return FALSE;
295 break;
296 }
297 Stream_Seek(s, record - TLS_RECORD_HEADER_LENGTH);
298
299 if ((pos > chunk) && (pos + record - chunk > max))
300 {
301 if (!rdpudp_send(emt->udp, &data[chunk], pos - chunk))
302 return FALSE;
303 chunk = pos;
304 }
305
306 if (record > max)
307 {
308 /* should not happen with max_send_fragment set, the connection is a byte stream so
309 * a record split over datagrams still arrives intact */
310 for (size_t offset = 0; offset < record; offset += max)
311 {
312 const size_t length = (record - offset > max) ? max : record - offset;
313 if (!rdpudp_send(emt->udp, &data[pos + offset], length))
314 return FALSE;
315 }
316 chunk = pos + record;
317 }
318 }
319
320 const size_t end = Stream_GetPosition(s);
321 if ((end > chunk) && !rdpudp_send(emt->udp, &data[chunk], end - chunk))
322 return FALSE;
323
324 return stream_consume(emt->out, end);
325}
326
327WINPR_ATTR_NODISCARD
328static BOOL emt_write_pdu(rdpEmt* emt, BYTE action, const BYTE* subHeader, size_t subHeaderLength,
329 const BYTE* payload, size_t length)
330{
331 WINPR_ASSERT(emt);
332 WINPR_ASSERT(subHeader || (subHeaderLength == 0));
333 WINPR_ASSERT(payload || (length == 0));
334
335 if ((length > UINT16_MAX) || (subHeaderLength > UINT8_MAX - RDPTUNNEL_HEADER_LENGTH))
336 return FALSE;
337
338 wStream* s = Stream_New(nullptr, RDPTUNNEL_HEADER_LENGTH + subHeaderLength + length);
339 if (!s)
340 return FALSE;
341
342 /* [MS-RDPEMT] 2.2.1.1 RDP_TUNNEL_HEADER, HeaderLength includes the SubHeaders */
343 const UINT8 actionByte = WINPR_ASSERTING_INT_CAST(UINT8, action & 0x0F);
344 const UINT16 payloadLength = WINPR_ASSERTING_INT_CAST(UINT16, length);
345 const UINT8 headerLength =
346 WINPR_ASSERTING_INT_CAST(UINT8, RDPTUNNEL_HEADER_LENGTH + subHeaderLength);
347 Stream_Write_UINT8(s, actionByte); /* Action (4 bits), Flags (4 bits) */
348 Stream_Write_UINT16(s, payloadLength); /* PayloadLength */
349 Stream_Write_UINT8(s, headerLength); /* HeaderLength */
350 Stream_Write(s, subHeader, subHeaderLength);
351 Stream_Write(s, payload, length);
352
353 const int total = WINPR_ASSERTING_INT_CAST(int, Stream_GetPosition(s));
354 const int rc = SSL_write(emt->ssl, Stream_Buffer(s), total);
355 Stream_Free(s, TRUE);
356 if (rc != total)
357 {
358 log_ssl_errors(emt, "SSL_write");
359 return FALSE;
360 }
361 return emt_flush_tls(emt);
362}
363
364/* Writes batched tunnel PDUs as one or more TLS records. */
365WINPR_ATTR_NODISCARD
366static BOOL emt_write_batch(rdpEmt* emt)
367{
368 WINPR_ASSERT(emt);
369
370 const size_t length = emt->batch ? Stream_GetPosition(emt->batch) : 0;
371 if (length == 0)
372 return TRUE;
373 if (length > INT32_MAX)
374 return FALSE;
375 const int total = WINPR_ASSERTING_INT_CAST(int, length);
376 const int rc = SSL_write(emt->ssl, Stream_Buffer(emt->batch), total);
377 Stream_ResetPosition(emt->batch);
378 if (rc != total)
379 {
380 log_ssl_errors(emt, "SSL_write");
381 return FALSE;
382 }
383 return emt_flush_tls(emt);
384}
385
386/* Appends a tunnel data PDU to the batch, flushing the current batch if the PDU does not fit. */
387WINPR_ATTR_NODISCARD
388static BOOL emt_batch_data(rdpEmt* emt, const BYTE* payload, size_t length)
389{
390 WINPR_ASSERT(emt);
391 WINPR_ASSERT(payload || (length == 0));
392
393 if (length > UINT16_MAX)
394 return FALSE;
395 if (!emt->batch)
396 {
397 emt->batch = Stream_New(nullptr, RDPEMT_SERVER_BATCH);
398 if (!emt->batch)
399 return FALSE;
400 }
401 /* Check remaining capacity to avoid overflow. PDUs larger than a batch are sent
402 * individually. */
403 const size_t pdu = RDPTUNNEL_HEADER_LENGTH + length;
404 const size_t used = Stream_GetPosition(emt->batch);
405 if (((used > RDPEMT_SERVER_BATCH) || (RDPEMT_SERVER_BATCH - used < pdu)) &&
406 !emt_write_batch(emt))
407 return FALSE;
408 if (!Stream_EnsureRemainingCapacity(emt->batch, pdu))
409 return FALSE;
410
411 /* Implements the RDP_TUNNEL_HEADER as defined in [MS-RDPEMT] section 2.2.1.1. */
412 const UINT8 actionByte = RDPTUNNEL_ACTION_DATA;
413 const UINT16 payloadLength = WINPR_ASSERTING_INT_CAST(UINT16, length);
414 Stream_Write_UINT8(emt->batch, actionByte);
415 Stream_Write_UINT16(emt->batch, payloadLength);
416 Stream_Write_UINT8(emt->batch, RDPTUNNEL_HEADER_LENGTH);
417 Stream_Write(emt->batch, payload, length);
418 return TRUE;
419}
420
421/* Send queue item types, stored in the first byte of each item. */
422#define EMT_QUEUED_DATA 0
423#define EMT_QUEUED_SUBHEADER 1
424
425/* A Tunnel Data PDU without HigherLayerData, used by Windows for auto-detect requests.
426 * The batch is flushed first because bandwidth measurements count data between these PDUs. */
427WINPR_ATTR_NODISCARD
428static BOOL emt_write_subheader(rdpEmt* emt, const BYTE* subHeader, size_t length)
429{
430 WINPR_ASSERT(emt);
431 return emt_write_batch(emt) &&
432 emt_write_pdu(emt, RDPTUNNEL_ACTION_DATA, subHeader, length, nullptr, 0);
433}
434
435/* Data queued for the link, measured in datagrams. */
436WINPR_ATTR_NODISCARD
437static size_t emt_backlog(const rdpEmt* emt)
438{
439 WINPR_ASSERT(emt);
440 const size_t max = rdpudp_get_max_payload(emt->udp);
441 return rdpudp_get_send_backlog(emt->udp) + ((max > 0) ? emt->sendQueueBytes / max : 0);
442}
443
444/* Block when backlog reaches two windows and unblock at one. This maintains a backlog
445 * of approximately two round trips regardless of link speed, requiring no tuning. */
446static void emt_update_blocked(rdpEmt* emt)
447{
448 WINPR_ASSERT(emt);
449
450 const size_t window = rdpudp_get_send_window(emt->udp);
451 const size_t backlog = emt_backlog(emt);
452 if (!emt->writeBlocked && (backlog >= 2 * window))
453 emt->writeBlocked = TRUE;
454 else if (emt->writeBlocked && (backlog <= window))
455 {
456 emt->writeBlocked = FALSE;
457 emt->callback(emt->custom, emt, RDPEMT_EVENT_WRITABLE, nullptr, 0);
458 }
459}
460
461/* Per-item send queue overhead excluding data (e.g., stream and allocation costs). */
462#define EMT_QUEUE_ITEM_COST 64
463
464/* Queues tunnel PDU data until the link has capacity. */
465WINPR_ATTR_NODISCARD
466static BOOL emt_queue_send(rdpEmt* emt, BYTE kind, const BYTE* payload, size_t length)
467{
468 WINPR_ASSERT(emt);
469 WINPR_ASSERT(payload || (length == 0));
470
471 /* Account for memory overhead, not just data, as many small items accumulate. */
472 const size_t used = emt->sendQueueBytes + emt->sendQueueItems * EMT_QUEUE_ITEM_COST;
473 if ((used > emt->sendLimit) || (length + EMT_QUEUE_ITEM_COST > emt->sendLimit - used))
474 {
475 WLog_Print(emt->log, WLOG_ERROR,
476 "%" PRIuz " bytes wait for a link that takes less than the server sends, "
477 "ending the tunnel: the server does not pace itself",
478 emt->sendQueueBytes);
479 emt_fail(emt, "the server is sending more data than the link can handle");
480 return FALSE;
481 }
482 wStream* s = Stream_New(nullptr, 1 + length);
483 if (!s)
484 return FALSE;
485 Stream_Write_UINT8(s, kind);
486 Stream_Write(s, payload, length);
487 if (!Queue_Enqueue(emt->sendQueue, s))
488 {
489 Stream_Free(s, TRUE);
490 return FALSE;
491 }
492 emt->sendQueueBytes += length;
493 emt->sendQueueItems++;
494 emt_update_blocked(emt);
495 return TRUE;
496}
497
498/* Drains the send queue until the link is full. */
499WINPR_ATTR_NODISCARD
500static BOOL emt_flush_queue(rdpEmt* emt)
501{
502 WINPR_ASSERT(emt);
503
504 BOOL moved = FALSE;
505 const size_t window = rdpudp_get_send_window(emt->udp);
506 while ((Queue_Count(emt->sendQueue) > 0) && (rdpudp_get_send_backlog(emt->udp) < window))
507 {
508 wStream* s = Queue_Dequeue(emt->sendQueue);
509 if (!s)
510 break;
511 const BYTE* item = Stream_Buffer(s);
512 const size_t length = Stream_GetPosition(s) - 1;
513 emt->sendQueueBytes -= length;
514 emt->sendQueueItems--;
515 const BOOL rc = (item[0] == EMT_QUEUED_DATA) ? emt_batch_data(emt, &item[1], length)
516 : emt_write_subheader(emt, &item[1], length);
517 Stream_Free(s, TRUE);
518 if (!rc)
519 return FALSE;
520 moved = TRUE;
521 }
522 if (moved && !emt_write_batch(emt))
523 return FALSE;
524 emt_update_blocked(emt);
525 return TRUE;
526}
527
528WINPR_ATTR_NODISCARD
529static BOOL emt_send_create_request(rdpEmt* emt)
530{
531 WINPR_ASSERT(emt);
532
533 BYTE request[24] = WINPR_C_ARRAY_INIT;
534 wStream sbuffer = WINPR_C_ARRAY_INIT;
535 wStream* s = Stream_StaticInit(&sbuffer, request, sizeof(request));
536
537 /* [MS-RDPEMT] 2.2.2.1 RDP_TUNNEL_CREATEREQUEST */
538 Stream_Write_UINT32(s, emt->requestId); /* RequestID */
539 Stream_Write_UINT32(s, 0); /* Reserved */
540 Stream_Write(s, emt->cookie, sizeof(emt->cookie)); /* SecurityCookie */
541
542 WLog_Print(emt->log, WLOG_DEBUG, "sending Tunnel Create Request for request id %" PRIu32,
543 emt->requestId);
544 return emt_write_pdu(emt, RDPTUNNEL_ACTION_CREATEREQUEST, nullptr, 0, Stream_Buffer(s),
545 Stream_GetPosition(s));
546}
547
548/* The TLS session inside the tunnel ends at the same server as the main connection, so it has
549 * to present the certificate that one was accepted with. */
550WINPR_ATTR_NODISCARD
551static BOOL emt_verify_peer(rdpEmt* emt)
552{
553 WINPR_ASSERT(emt);
554
555 X509* x509 = SSL_get_peer_certificate(emt->ssl);
556 if (!x509)
557 {
558 WLog_Print(emt->log, WLOG_WARN, "the tunnel's TLS session has no server certificate");
559 return FALSE;
560 }
561
562 BOOL rc = FALSE;
563 BYTE* key = nullptr;
564 DWORD keyLength = 0;
565 rdpCertificate* cert = freerdp_certificate_new_from_x509(x509, nullptr);
566 if (cert && freerdp_certificate_get_public_key(cert, &key, &keyLength))
567 {
568 rc = (keyLength == emt->publicKeyLength) && (memcmp(key, emt->publicKey, keyLength) == 0);
569 }
570 if (!rc)
571 WLog_Print(emt->log, WLOG_WARN,
572 "the tunnel's TLS certificate differs from the main connection's");
573
574 free(key);
575 freerdp_certificate_free(cert);
576 X509_free(x509);
577 return rc;
578}
579
580/* [MS-RDPEMT] 2.2.1.1.1: the SubHeaders field holds any number of RDP_TUNNEL_SUBHEADER. An
581 * auto-detect request is a whole subheader, its headerLength and headerTypeId are the
582 * SubHeaderLength and SubHeaderType ([MS-RDPBCGR] 2.2.14.1). */
583WINPR_ATTR_NODISCARD
584static BOOL emt_process_subheaders(rdpEmt* emt, const BYTE* data, size_t length)
585{
586 WINPR_ASSERT(emt);
587 WINPR_ASSERT(data || (length == 0));
588
589 while (length > 0)
590 {
591 const size_t subHeaderLength = data[0];
592 if ((length < 2) || (subHeaderLength < 2) || (subHeaderLength > length))
593 {
594 emt_fail(emt, "invalid tunnel subheader");
595 return FALSE;
596 }
597
598 const BYTE subHeaderType = data[1];
599 if (subHeaderType == RDPTUNNEL_SUBHEADER_AUTODETECT_REQUEST)
600 emt->callback(emt->custom, emt, RDPEMT_EVENT_AUTODETECT, data, subHeaderLength);
601 else
602 WLog_Print(emt->log, WLOG_DEBUG, "ignoring tunnel subheader of type 0x%02" PRIx8,
603 subHeaderType);
604 data += subHeaderLength;
605 length -= subHeaderLength;
606 }
607 return TRUE;
608}
609
610/* Server: handles [MS-RDPEMT] 2.2.2.1 RDP_TUNNEL_CREATEREQUEST and responds with 2.2.2.2
611 * RDP_TUNNEL_CREATERESPONSE. The request ID and cookie must match the tunnel's
612 * Initiate Multitransport Request. */
613WINPR_ATTR_NODISCARD
614static BOOL emt_accept_create_request(rdpEmt* emt, wStream* s, size_t payloadLength)
615{
616 WINPR_ASSERT(emt);
617 WINPR_ASSERT(s);
618
619 /* emt_process_server_pdus verified payload presence; re-verify before reading. */
620 if ((payloadLength < 8 + sizeof(emt->cookie)) ||
621 !Stream_CheckAndLogRequiredLengthWLog(emt->log, s, payloadLength))
622 {
623 emt_fail(emt, "tunnel Create Request is too short");
624 return FALSE;
625 }
626 const UINT32 requestId = Stream_Get_UINT32(s); /* Read the RequestID field */
627 Stream_Seek_UINT32(s); /* Skip the reserved field */
628 const BYTE* cookie = Stream_ConstPointer(s); /* The SecurityCookie field */
629 Stream_Seek(s, payloadLength - 8);
630
631 const BOOL valid = (requestId == emt->requestId) &&
632 (CRYPTO_memcmp(cookie, emt->cookie, sizeof(emt->cookie)) == 0);
633 BYTE response[4] = WINPR_C_ARRAY_INIT;
634 wStream rbuffer = WINPR_C_ARRAY_INIT;
635 wStream* rs = Stream_StaticInit(&rbuffer, response, sizeof(response));
636 if (!rs)
637 {
638 emt_fail(emt, "unable to construct the Tunnel Create Response");
639 return FALSE;
640 }
641 /* HRESULT values; E_ABORT is negative in int32. */
642 const UINT32 hr = valid ? (UINT32)S_OK : (UINT32)E_ABORT;
643 Stream_Write_UINT32(rs, hr); /* Write the HrResponse field */
644 if (!emt_write_pdu(emt, RDPTUNNEL_ACTION_CREATERESPONSE, nullptr, 0, response,
645 sizeof(response)))
646 {
647 emt_fail(emt, "unable to send the Tunnel Create Response");
648 return FALSE;
649 }
650 if (!valid)
651 {
652 emt_fail(emt, "the Tunnel Create Request refers to a different request or cookie");
653 return FALSE;
654 }
655 if (!emt->ready)
656 {
657 /* The client has proven the cookie, so the full receive window may now be used. */
658 rdpudp_set_peer_verified(emt->udp);
659 WLog_Print(emt->log, WLOG_INFO,
660 "UDP multitransport tunnel is now ready (RDP-UDP version 0x%04" PRIx16 ")",
661 rdpudp_get_version(emt->udp));
662 emt->ready = TRUE;
663 emt->callback(emt->custom, emt, RDPEMT_EVENT_READY, nullptr, 0);
664 }
665 return TRUE;
666}
667
668WINPR_ATTR_NODISCARD
669static BOOL emt_process_pdus(rdpEmt* emt)
670{
671 WINPR_ASSERT(emt);
672
673 wStream sbuffer = WINPR_C_ARRAY_INIT;
674 wStream* s =
675 Stream_StaticConstInit(&sbuffer, Stream_Buffer(emt->in), Stream_GetPosition(emt->in));
676
677 while (Stream_GetRemainingLength(s) >= RDPTUNNEL_HEADER_LENGTH)
678 {
679 /* [MS-RDPEMT] 2.2.1.1 RDP_TUNNEL_HEADER */
680 const size_t start = Stream_GetPosition(s);
681 const BYTE action = Stream_Get_UINT8(s) & 0x0F;
682 const size_t payloadLength = Stream_Get_UINT16(s);
683 const size_t headerLength = Stream_Get_UINT8(s);
684 if (headerLength < RDPTUNNEL_HEADER_LENGTH)
685 {
686 emt_fail(emt, "invalid tunnel PDU header");
687 return FALSE;
688 }
689
690 /* HeaderLength includes any subheaders, PayloadLength does not. Both are bounded by
691 * their wire types (UINT8, UINT16), the sum cannot overflow. */
692 WINPR_ASSERT(payloadLength <= UINT16_MAX);
693 WINPR_ASSERT(headerLength <= UINT8_MAX);
694 const size_t rest = headerLength - RDPTUNNEL_HEADER_LENGTH + payloadLength;
695 if (Stream_GetRemainingLength(s) < rest)
696 {
697 /* not all here yet */
698 if (!Stream_SetPosition(s, start))
699 return FALSE;
700 break;
701 }
702 /* the subheaders go up ahead of the payload of their PDU */
703 if (!emt_process_subheaders(emt, Stream_ConstPointer(s),
704 headerLength - RDPTUNNEL_HEADER_LENGTH))
705 return FALSE;
706 Stream_Seek(s, headerLength - RDPTUNNEL_HEADER_LENGTH);
707
708 switch (action)
709 {
710 case RDPTUNNEL_ACTION_CREATERESPONSE:
711 {
712 /* [MS-RDPEMT] 2.2.2.2 RDP_TUNNEL_CREATERESPONSE */
713 if (payloadLength < 4)
714 {
715 emt_fail(emt, "short Tunnel Create Response");
716 return FALSE;
717 }
718 const UINT32 hr = Stream_Get_UINT32(s); /* HrResponse */
719 Stream_Seek(s, payloadLength - 4);
720 if (FAILED((HRESULT)hr))
721 {
722 WLog_Print(emt->log, WLOG_WARN,
723 "the server refused the tunnel, hrResponse 0x%08" PRIx32, hr);
724 emt_fail(emt, "Tunnel Create Response reported a failure");
725 return FALSE;
726 }
727 if (!emt->ready)
728 {
729 WLog_Print(emt->log, WLOG_INFO,
730 "UDP multitransport tunnel ready (RDP-UDP version 0x%04" PRIx16 ")",
731 rdpudp_get_version(emt->udp));
732 emt->ready = TRUE;
733 emt->callback(emt->custom, emt, RDPEMT_EVENT_READY, nullptr, 0);
734 }
735 }
736 break;
737
738 case RDPTUNNEL_ACTION_DATA:
739 /* [MS-RDPEMT] 2.2.2.3 RDP_TUNNEL_DATA, HigherLayerData is a DVC PDU */
740 if (payloadLength > 0)
741 emt_hand_up(emt, Stream_ConstPointer(s), payloadLength);
742 Stream_Seek(s, payloadLength);
743 break;
744
745 default:
746 WLog_Print(emt->log, WLOG_DEBUG, "ignoring tunnel PDU with action %" PRIu8, action);
747 Stream_Seek(s, payloadLength);
748 break;
749 }
750
751 if (emt->failed)
752 return FALSE;
753 }
754
755 return stream_consume(emt->in, Stream_GetPosition(s));
756}
757
758/* Server: only auto-detect responses are passed up. */
759WINPR_ATTR_NODISCARD
760static BOOL emt_process_server_subheaders(rdpEmt* emt, const BYTE* data, size_t length)
761{
762 WINPR_ASSERT(emt);
763 WINPR_ASSERT(data || (length == 0));
764
765 while (length > 0)
766 {
767 const size_t subHeaderLength = data[0];
768 if ((length < 2) || (subHeaderLength < 2) || (subHeaderLength > length))
769 {
770 emt_fail(emt, "incorrect tunnel subheader");
771 return FALSE;
772 }
773
774 const BYTE subHeaderType = data[1];
775 if (subHeaderType == RDPTUNNEL_SUBHEADER_AUTODETECT_RESPONSE)
776 emt->callback(emt->custom, emt, RDPEMT_EVENT_AUTODETECT, data, subHeaderLength);
777 else
778 WLog_Print(emt->log, WLOG_DEBUG, "skipping tunnel subheader of type 0x%02" PRIx8,
779 subHeaderType);
780 data += subHeaderLength;
781 length -= subHeaderLength;
782 }
783 return TRUE;
784}
785
786/* Server: parses client PDUs. The client is authenticated by the Tunnel Create Request
787 * cookie, so no other PDUs are accepted before it. Only Create Request and Data
788 * actions are valid; any other action (e.g. Tunnel Create Response) terminates
789 * the tunnel. */
790WINPR_ATTR_NODISCARD
791static BOOL emt_process_server_pdus(rdpEmt* emt)
792{
793 WINPR_ASSERT(emt);
794
795 wStream sbuffer = WINPR_C_ARRAY_INIT;
796 wStream* s =
797 Stream_StaticConstInit(&sbuffer, Stream_Buffer(emt->in), Stream_GetPosition(emt->in));
798
799 while (Stream_GetRemainingLength(s) >= RDPTUNNEL_HEADER_LENGTH)
800 {
801 /* See [MS-RDPEMT] 2.2.1.1 for RDP_TUNNEL_HEADER */
802 const size_t start = Stream_GetPosition(s);
803 const BYTE action = Stream_Get_UINT8(s) & 0x0F;
804 const size_t payloadLength = Stream_Get_UINT16(s);
805 const size_t headerLength = Stream_Get_UINT8(s);
806 if (headerLength < RDPTUNNEL_HEADER_LENGTH)
807 {
808 emt_fail(emt, "incorrect tunnel PDU header");
809 return FALSE;
810 }
811
812 /* HeaderLength includes subheaders, while PayloadLength does not. Both are bounded by
813 * their wire types (UINT8, UINT16), so the sum cannot overflow. */
814 WINPR_ASSERT(payloadLength <= UINT16_MAX);
815 WINPR_ASSERT(headerLength <= UINT8_MAX);
816 const size_t rest = headerLength - RDPTUNNEL_HEADER_LENGTH + payloadLength;
817 if (Stream_GetRemainingLength(s) < rest)
818 {
819 /* The complete PDU has not yet arrived. */
820 if (!Stream_SetPosition(s, start))
821 return FALSE;
822 break;
823 }
824
825 if (!emt->ready && (headerLength > RDPTUNNEL_HEADER_LENGTH))
826 {
827 emt_fail(emt, "tunnel subheaders received before the Tunnel Create Request");
828 return FALSE;
829 }
830
831 /* subheaders precede the PDU payload */
832 if (!emt_process_server_subheaders(emt, Stream_ConstPointer(s),
833 headerLength - RDPTUNNEL_HEADER_LENGTH))
834 return FALSE;
835 Stream_Seek(s, headerLength - RDPTUNNEL_HEADER_LENGTH);
836
837 switch (action)
838 {
839 case RDPTUNNEL_ACTION_CREATEREQUEST:
840 if (!emt_accept_create_request(emt, s, payloadLength))
841 return FALSE;
842 break;
843
844 case RDPTUNNEL_ACTION_DATA:
845 /* [MS-RDPEMT] 2.2.2.3 RDP_TUNNEL_DATA: HigherLayerData is a DVC PDU. */
846 if (!emt->ready)
847 {
848 emt_fail(emt, "tunnel data received before the Tunnel Create Request");
849 return FALSE;
850 }
851 if (payloadLength > 0)
852 emt_hand_up(emt, Stream_ConstPointer(s), payloadLength);
853 Stream_Seek(s, payloadLength);
854 break;
855
856 default:
857 WLog_Print(emt->log, WLOG_WARN,
858 "received tunnel PDU with action %" PRIu8 " from a client", action);
859 emt_fail(emt, "a tunnel PDU that should not be sent by the client");
860 return FALSE;
861 }
862
863 if (emt->failed)
864 return FALSE;
865 }
866
867 return stream_consume(emt->in, Stream_GetPosition(s));
868}
869
870WINPR_ATTR_NODISCARD
871static BOOL emt_run_tls(rdpEmt* emt)
872{
873 WINPR_ASSERT(emt);
874
875 if (!emt->handshakeDone)
876 {
877 ERR_clear_error();
878 const int rc = SSL_do_handshake(emt->ssl);
879 if (!emt_flush_tls(emt))
880 return FALSE;
881 if (rc != 1)
882 {
883 const int err = SSL_get_error(emt->ssl, rc);
884 if ((err == SSL_ERROR_WANT_READ) || (err == SSL_ERROR_WANT_WRITE))
885 return TRUE;
886 log_ssl_errors(emt, "TLS handshake");
887 emt_fail(emt, "TLS handshake failed");
888 return FALSE;
889 }
890
891 emt->handshakeDone = TRUE;
892 WLog_Print(emt->log, WLOG_DEBUG, "tunnel TLS session established (%s, %s)",
893 SSL_get_version(emt->ssl), SSL_get_cipher_name(emt->ssl));
894 /* Client: send the Tunnel Create Request. */
895 if (!emt->server)
896 {
897 if (!emt_verify_peer(emt))
898 {
899 emt_fail(emt, "certificate does not match");
900 return FALSE;
901 }
902 if (!emt_send_create_request(emt))
903 {
904 emt_fail(emt, "unable to send the Tunnel Create Request");
905 return FALSE;
906 }
907 }
908 }
909
910 while (TRUE)
911 {
912 if (!Stream_EnsureRemainingCapacity(emt->in, 16384))
913 return FALSE;
914
915 ERR_clear_error();
916 const int rc = SSL_read(emt->ssl, Stream_Pointer(emt->in), 16384);
917 if (rc > 0)
918 {
919 Stream_Seek(emt->in, WINPR_ASSERTING_INT_CAST(size_t, rc));
920 continue;
921 }
922
923 const int err = SSL_get_error(emt->ssl, rc);
924 if (err == SSL_ERROR_WANT_READ)
925 break;
926 log_ssl_errors(emt, "SSL_read");
927 emt_fail(emt, (err == SSL_ERROR_ZERO_RETURN) ? "the remote peer closed the tunnel"
928 : "TLS error inside the tunnel");
929 return FALSE;
930 }
931
932 /* post handshake messages and alerts */
933 if (!emt_flush_tls(emt))
934 return FALSE;
935
936 return emt->server ? emt_process_server_pdus(emt) : emt_process_pdus(emt);
937}
938
939WINPR_ATTR_NODISCARD
940static BOOL emt_receive(void* custom, const BYTE* data, size_t length)
941{
942 rdpEmt* emt = custom;
943 WINPR_ASSERT(emt);
944 WINPR_ASSERT(data || (length == 0));
945
946 if (!emt->tlsStarted || emt->failed)
947 return TRUE;
948 if (length > INT32_MAX)
949 return FALSE;
950 const int len = WINPR_ASSERTING_INT_CAST(int, length);
951 if (BIO_write(emt->rbio, data, len) != len)
952 return FALSE;
953 return emt_run_tls(emt);
954}
955
956#if defined(WITH_RDPEUDP_SERVER)
957WINPR_ATTR_NODISCARD
958static BOOL emt_flow_send(void* custom, const BYTE* data, size_t length)
959{
960 return freerdp_udp_flow_send(custom, data, length);
961}
962#endif
963
964WINPR_ATTR_NODISCARD
965static BOOL emt_start_tls(rdpEmt* emt)
966{
967 WINPR_ASSERT(emt);
968
969 emt->ctx = SSL_CTX_new(emt->server ? TLS_server_method() : TLS_client_method());
970 if (!emt->ctx)
971 return FALSE;
972
973 /* Server: present the main connection's certificate. */
974 if (emt->server && ((SSL_CTX_use_certificate(emt->ctx, emt->cert) != 1) ||
975 (SSL_CTX_use_PrivateKey(emt->ctx, emt->key) != 1)))
976 {
977 WLog_Print(emt->log, WLOG_ERROR, "unable to use the server certificate for the tunnel");
978 return FALSE;
979 }
980
981 /* Server: use main connection's TLS settings, with a minimum of TLS 1.2. */
982 const int minVersion = (emt->server && (emt->tlsMinVersion > TLS1_2_VERSION))
983 ? emt->tlsMinVersion
984 : TLS1_2_VERSION;
985 if (!SSL_CTX_set_min_proto_version(emt->ctx, minVersion))
986 {
987 WLog_Print(emt->log, WLOG_ERROR, "SSL_CTX_set_min_proto_version failed");
988 return FALSE;
989 }
990 if (emt->server && (emt->tlsMaxVersion != 0) &&
991 !SSL_CTX_set_max_proto_version(emt->ctx, emt->tlsMaxVersion))
992 {
993 WLog_Print(emt->log, WLOG_ERROR, "failed to set the maximum SSL protocol version");
994 return FALSE;
995 }
996#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
997 if (emt->server)
998 SSL_CTX_set_security_level(
999 emt->ctx, (emt->tlsSecLevel > 5)
1000 ? 5
1001 : (int)emt->tlsSecLevel); /* 5 is the maximum security level */
1002#endif
1003 SSL_CTX_set_options(emt->ctx, SSL_OP_NO_TICKET | SSL_OP_NO_COMPRESSION);
1004#if (OPENSSL_VERSION_NUMBER >= 0x10101000L) && !defined(LIBRESSL_VERSION_NUMBER)
1005 /* SSL_OP_NO_TICKET does not disable TLS 1.3 tickets; tunnels never resume sessions. */
1006 if (SSL_CTX_set_num_tickets(emt->ctx, 0) != 1)
1007 WLog_Print(emt->log, WLOG_DEBUG, "unable to disable TLS 1.3 session tickets");
1008#endif
1009#if defined(SSL_OP_NO_RENEGOTIATION)
1010 /* Renegotiation requires a private key operation and is not needed for the tunnel. */
1011 if (emt->server)
1012 SSL_CTX_set_options(emt->ctx, SSL_OP_NO_RENEGOTIATION);
1013#endif
1014 /* the certificate is checked against the main connection's in emt_verify_peer */
1015 SSL_CTX_set_verify(emt->ctx, SSL_VERIFY_NONE, nullptr);
1016 /* Server: accept only ECDHE unless other ciphers are specified. RSA key exchange lacks
1017 * forward secrecy, allowing decryption with the server's private key. */
1018 const char* ciphers = emt->server ? "ECDHE-RSA-AES256-GCM-SHA384:"
1019 "ECDHE-RSA-AES128-GCM-SHA256:"
1020 "ECDHE-ECDSA-AES256-GCM-SHA384:"
1021 "ECDHE-ECDSA-AES128-GCM-SHA256"
1022 : "ECDHE-RSA-AES256-GCM-SHA384:"
1023 "ECDHE-RSA-AES128-GCM-SHA256:"
1024 "ECDHE-ECDSA-AES256-GCM-SHA384:"
1025 "ECDHE-ECDSA-AES128-GCM-SHA256:"
1026 "AES256-GCM-SHA384:AES128-GCM-SHA256";
1027 if (emt->server && emt->tlsCiphers)
1028 ciphers = emt->tlsCiphers;
1029 if (!SSL_CTX_set_cipher_list(emt->ctx, ciphers))
1030 {
1031 WLog_Print(emt->log, WLOG_ERROR, "SSL_CTX_set_cipher_list failed");
1032 return FALSE;
1033 }
1034#if OPENSSL_VERSION_NUMBER >= 0x10101000L
1035 if (!SSL_CTX_set_ciphersuites(emt->ctx, "TLS_AES_256_GCM_SHA384:TLS_AES_128_GCM_SHA256"))
1036 {
1037 WLog_Print(emt->log, WLOG_ERROR, "SSL_CTX_set_ciphersuites failed");
1038 return FALSE;
1039 }
1040#endif
1041 /* The ClientHello has to fit in one datagram. Default groups with post quantum key shares
1042 * add more than a kilobyte. */
1043 if (!SSL_CTX_set1_groups_list(emt->ctx, "X25519:P-256:P-384"))
1044 {
1045 WLog_Print(emt->log, WLOG_ERROR, "SSL_CTX_set1_groups_list failed");
1046 return FALSE;
1047 }
1048 if (!SSL_CTX_set1_sigalgs_list(emt->ctx, "rsa_pss_rsae_sha256:rsa_pss_rsae_sha384:"
1049 "rsa_pkcs1_sha256:rsa_pkcs1_sha384:"
1050 "ecdsa_secp256r1_sha256:ecdsa_secp384r1_sha384"))
1051 {
1052 WLog_Print(emt->log, WLOG_ERROR, "SSL_CTX_set1_sigalgs_list failed");
1053 return FALSE;
1054 }
1055 SSL_CTX_set_read_ahead(emt->ctx, 0);
1056
1057 emt->ssl = SSL_new(emt->ctx);
1058 if (!emt->ssl)
1059 return FALSE;
1060
1061 emt->rbio = BIO_new(BIO_s_mem());
1062 emt->wbio = BIO_new(BIO_s_mem());
1063 if (!emt->rbio || !emt->wbio)
1064 {
1065 BIO_free(emt->rbio);
1066 BIO_free(emt->wbio);
1067 emt->rbio = nullptr;
1068 emt->wbio = nullptr;
1069 return FALSE;
1070 }
1071 SSL_set_bio(emt->ssl, emt->rbio, emt->wbio);
1072 if (emt->server)
1073 SSL_set_accept_state(emt->ssl);
1074 else
1075 {
1076 SSL_set_connect_state(emt->ssl);
1077 if (emt->hostname)
1078 (void)SSL_set_tlsext_host_name(emt->ssl, emt->hostname);
1079 }
1080
1081 /* Client records must fit in a single datagram; the server sends a byte stream. */
1082 const size_t max = rdpudp_get_max_payload(emt->udp);
1083 if (!emt->server && (max > TLS_RECORD_OVERHEAD + 512))
1084 {
1085 if (!SSL_set_max_send_fragment(emt->ssl,
1086 WINPR_ASSERTING_INT_CAST(long, max - TLS_RECORD_OVERHEAD)))
1087 {
1088 WLog_Print(emt->log, WLOG_ERROR, "SSL_set_max_send_fragment failed");
1089 return FALSE;
1090 }
1091 }
1092
1093 emt->tlsStarted = TRUE;
1094 return emt_run_tls(emt);
1095}
1096
1097#if defined(WITH_RDPEUDP_SERVER)
1098/* Process pending client datagrams on the tunnel thread; the listener only demultiplexes. */
1099WINPR_ATTR_NODISCARD
1100static BOOL emt_server_process_datagrams(rdpEmt* emt)
1101{
1102 WINPR_ASSERT(emt);
1103
1104 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
1105 size_t length = 0;
1106 /* Flow event remains set while datagrams are pending, so the next pass executes immediately. */
1107 for (size_t count = 0;
1108 (count < RDPEMT_INPUT_BUDGET) && !emt->failed && udpflow_read(emt->flow, data, &length);
1109 count++)
1110 {
1111 /* asked for every datagram: what the owner has queued changes while this loop runs */
1112 rdpudp_set_receive_hold(emt->udp, emt->hold && emt->hold(emt->custom));
1113 if (rdpudp_get_state(emt->udp) == RDPUDP_STATE_CLOSED)
1114 {
1115 if (!rdpudp_accept(emt->udp, emt_flow_send, emt->flow, data, length))
1116 {
1117 emt_fail(emt, "unable to accept the client's SYN");
1118 return FALSE;
1119 }
1120 emt->callback(emt->custom, emt, RDPEMT_EVENT_SYN_RECEIVED, nullptr, 0);
1121 }
1122 else if (!rdpudp_receive(emt->udp, data, length))
1123 {
1124 emt_fail(emt, "the RDP-UDP connection failed");
1125 return FALSE;
1126 }
1127 if (!emt->tlsStarted && (rdpudp_get_state(emt->udp) == RDPUDP_STATE_ESTABLISHED) &&
1128 !emt_start_tls(emt))
1129 {
1130 log_ssl_errors(emt, "TLS setup");
1131 emt_fail(emt, "unable to start TLS");
1132 return FALSE;
1133 }
1134 }
1135 return !emt->failed;
1136}
1137#endif
1138
1139WINPR_ATTR_NODISCARD
1140static BOOL emt_setup_timed_out(const rdpEmt* emt)
1141{
1142 WINPR_ASSERT(emt);
1143 if (emt->server)
1144 return rdpudp_get_time(emt->udp) - emt->started > RDPEMT_SERVER_SETUP_TIMEOUT_MS;
1145 return GetTickCount64() - emt->started > RDPEMT_SETUP_TIMEOUT_MS;
1146}
1147
1148WINPR_ATTR_NODISCARD
1149static BOOL emt_poll(rdpEmt* emt)
1150{
1151 WINPR_ASSERT(emt);
1152
1153 if (emt->failed)
1154 return FALSE;
1155
1156#if defined(WITH_RDPEUDP_SERVER)
1157 if (emt->server && !emt_server_process_datagrams(emt))
1158 return FALSE;
1159#endif
1160
1161 if (emt->server && (rdpudp_get_state(emt->udp) == RDPUDP_STATE_CLOSED))
1162 {
1163 if (emt_setup_timed_out(emt))
1164 {
1165 emt_fail(emt, "client failed to send SYN");
1166 return FALSE;
1167 }
1168 return TRUE;
1169 }
1170
1171 if (!rdpudp_check(emt->udp))
1172 {
1173 emt_fail(emt, "the RDP-UDP connection failed");
1174 return FALSE;
1175 }
1176
1177 if (!emt->tlsStarted && (rdpudp_get_state(emt->udp) == RDPUDP_STATE_ESTABLISHED))
1178 {
1179 if (!emt_start_tls(emt))
1180 {
1181 log_ssl_errors(emt, "TLS setup");
1182 emt_fail(emt, "failed to start TLS");
1183 return FALSE;
1184 }
1185 }
1186
1187 if (!emt->ready && emt_setup_timed_out(emt))
1188 {
1189 emt_fail(emt, "timed out");
1190 return FALSE;
1191 }
1192
1193 if (emt->server && emt->ready && !emt_flush_queue(emt))
1194 {
1195 emt_fail(emt, "unable to send tunnel data");
1196 return FALSE;
1197 }
1198 /* The main loop is not woken if the client is silent over TCP; the tunnel signals it when a
1199 * response is due, including a margin to ensure the main loop sees the timeout as expired. */
1200 if (emt->server && !emt->responseDueSent &&
1201 (rdpudp_get_time(emt->udp) - emt->started > RDPEMT_SERVER_RESPONSE_TIMEOUT_MS + 1000))
1202 {
1203 emt->responseDueSent = TRUE;
1204 emt->callback(emt->custom, emt, RDPEMT_EVENT_RESPONSE_DUE, nullptr, 0);
1205 }
1206
1207 return !emt->failed;
1208}
1209
1210/* Waits until a datagram arrives or the timeout in milliseconds passes. Waking up early, or
1211 * from an interrupted wait, only makes the timers run sooner. */
1212static void emt_wait_readable(SOCKET sockfd, UINT32 timeout)
1213{
1214#if !defined(_WIN32) && defined(WINPR_HAVE_POLL_H)
1215 /* unlike an fd_set, poll takes any descriptor number */
1216 struct pollfd pollset = WINPR_C_ARRAY_INIT;
1217 pollset.fd = WINPR_ASSERTING_INT_CAST(int, sockfd);
1218 pollset.events = POLLIN;
1219 const UINT32 ms = (timeout > INT32_MAX) ? INT32_MAX : timeout;
1220 (void)poll(&pollset, 1, WINPR_ASSERTING_INT_CAST(int, ms));
1221#else
1222#if !defined(_WIN32)
1223 /* an fd_set only holds descriptors below FD_SETSIZE */
1224 if (sockfd >= FD_SETSIZE)
1225 {
1226 Sleep(timeout);
1227 return;
1228 }
1229#endif
1230 fd_set rset;
1231 FD_ZERO(&rset);
1232 FD_SET(sockfd, &rset);
1233 struct timeval tv = WINPR_C_ARRAY_INIT;
1234 tv.tv_sec = WINPR_ASSERTING_INT_CAST(long, timeout / 1000);
1235 tv.tv_usec = WINPR_ASSERTING_INT_CAST(long, (timeout % 1000) * 1000);
1236#if defined(_WIN32)
1237 (void)select(0, &rset, nullptr, nullptr, &tv); /* the first argument is ignored */
1238#else
1239 (void)select(WINPR_ASSERTING_INT_CAST(int, sockfd) + 1, &rset, nullptr, nullptr, &tv);
1240#endif
1241#endif
1242}
1243
1244WINPR_ATTR_NODISCARD
1245static BOOL emt_stopping(rdpEmt* emt)
1246{
1247 WINPR_ASSERT(emt);
1248 return InterlockedCompareExchange(&emt->stop, 0, 0) != 0;
1249}
1250
1251WINPR_ATTR_NODISCARD
1252static DWORD WINAPI emt_thread(LPVOID arg)
1253{
1254 rdpEmt* emt = arg;
1255 WINPR_ASSERT(emt);
1256
1257 while (!emt_stopping(emt))
1258 {
1259 EnterCriticalSection(&emt->lock);
1260 const UINT32 timeout = rdpudp_get_timeout(emt->udp);
1261 const SOCKET sockfd = rdpudp_get_socket(emt->udp);
1262 LeaveCriticalSection(&emt->lock);
1263
1264#if defined(WITH_RDPEUDP_SERVER)
1265 /* Server connections lack a socket; the flow signals incoming datagrams. */
1266 if (emt->server)
1267 {
1268 /* udpflow_wake() sets the flow event, including relayed flows. */
1269 HANDLE events[2] = WINPR_C_ARRAY_INIT;
1270 const DWORD count = udpflow_get_events(emt->flow, events);
1271 if (WaitForMultipleObjects(count, events, FALSE, timeout) == WAIT_FAILED)
1272 WLog_Print(emt->log, WLOG_DEBUG, "failed to wait for the flow");
1273 }
1274 else
1275#endif
1276 emt_wait_readable(sockfd, timeout);
1277
1278 if (emt_stopping(emt))
1279 break;
1280
1281 EnterCriticalSection(&emt->lock);
1282 const BOOL rc = emt_poll(emt);
1283 LeaveCriticalSection(&emt->lock);
1284 if (!rc)
1285 break;
1286 }
1287
1288 ExitThread(0);
1289 return 0;
1290}
1291
1292#if defined(WITH_RDPEUDP_SERVER)
1293/* Worker for tunnels without a dedicated thread; see freerdp_udp_flow_check(). */
1294WINPR_ATTR_NODISCARD
1295static BOOL emt_manual_poll(void* custom)
1296{
1297 rdpEmt* emt = custom;
1298 WINPR_ASSERT(emt);
1299
1300 EnterCriticalSection(&emt->lock);
1301 const BOOL rc = emt_poll(emt);
1302 LeaveCriticalSection(&emt->lock);
1303 return rc;
1304}
1305
1306WINPR_ATTR_NODISCARD
1307static UINT32 emt_manual_get_timeout(void* custom)
1308{
1309 rdpEmt* emt = custom;
1310 WINPR_ASSERT(emt);
1311
1312 EnterCriticalSection(&emt->lock);
1313 const UINT32 timeout = rdpudp_get_timeout(emt->udp);
1314 LeaveCriticalSection(&emt->lock);
1315 return timeout;
1316}
1317#endif
1318
1319/* [MS-RDPEUDP] 2.2.2.9: cookieHash is the SHA-256 hash of the securityCookie, sent with
1320 * each 32-bit word byte-swapped as required by Windows. */
1321WINPR_ATTR_NODISCARD
1322static BOOL emt_cookie_hash(const BYTE cookie[16], BYTE cookieHash[32])
1323{
1324 WINPR_ASSERT(cookie);
1325 WINPR_ASSERT(cookieHash);
1326
1327 BYTE digest[32] = WINPR_C_ARRAY_INIT;
1328 if (!winpr_Digest(WINPR_MD_SHA256, cookie, 16, digest, sizeof(digest)))
1329 return FALSE;
1330 wStream dbuffer = WINPR_C_ARRAY_INIT;
1331 wStream hbuffer = WINPR_C_ARRAY_INIT;
1332 wStream* ds = Stream_StaticConstInit(&dbuffer, digest, sizeof(digest));
1333 wStream* hs = Stream_StaticInit(&hbuffer, cookieHash, 32);
1334 if (!ds || !hs)
1335 return FALSE;
1336 for (size_t x = 0; x < 32 / 4; x++)
1337 {
1338 /* Stream_Write macros may evaluate their arguments multiple times */
1339 const UINT32 word = Stream_Get_UINT32_BE(ds);
1340 Stream_Write_UINT32(hs, word);
1341 }
1342 return TRUE;
1343}
1344
1345rdpEmt* rdpemt_new(wLog* log, UINT32 requestId, const BYTE* cookie, const char* hostname,
1346 const BYTE* publicKey, size_t publicKeyLength, rdpEmtEventFn callback,
1347 void* custom)
1348{
1349 WINPR_ASSERT(log);
1350 WINPR_ASSERT(cookie);
1351 WINPR_ASSERT(publicKey);
1352 WINPR_ASSERT(callback);
1353
1354 rdpEmt* emt = calloc(1, sizeof(rdpEmt));
1355 if (!emt)
1356 return nullptr;
1357
1358 emt->log = log;
1359 emt->serial = InterlockedIncrement(&g_emtSerial);
1360 emt->requestId = requestId;
1361 memcpy(emt->cookie, cookie, sizeof(emt->cookie));
1362 emt->callback = callback;
1363 emt->custom = custom;
1364 if (!InitializeCriticalSectionAndSpinCount(&emt->lock, 4000))
1365 {
1366 free(emt);
1367 return nullptr;
1368 }
1369
1370 if (hostname)
1371 {
1372 emt->hostname = _strdup(hostname);
1373 if (!emt->hostname)
1374 goto fail;
1375 }
1376
1377 emt->publicKey = malloc(publicKeyLength);
1378 if (!emt->publicKey)
1379 goto fail;
1380 memcpy(emt->publicKey, publicKey, publicKeyLength);
1381 emt->publicKeyLength = publicKeyLength;
1382
1383 if (!emt_cookie_hash(emt->cookie, emt->cookieHash))
1384 goto fail;
1385
1386 emt->in = Stream_New(nullptr, 16384);
1387 emt->out = Stream_New(nullptr, 4096);
1388 if (!emt->in || !emt->out)
1389 goto fail;
1390
1391 emt->udp = rdpudp_new(log, emt->cookieHash, emt_receive, emt);
1392 if (!emt->udp)
1393 goto fail;
1394
1395 return emt;
1396fail:
1397 WINPR_PRAGMA_DIAG_PUSH
1398 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
1399 rdpemt_free(emt);
1400 WINPR_PRAGMA_DIAG_POP
1401 return nullptr;
1402}
1403
1404void rdpemt_set_receive_hold(rdpEmt* emt, rdpEmtHoldFn hold)
1405{
1406 WINPR_ASSERT(emt);
1407 EnterCriticalSection(&emt->lock);
1408 emt->hold = hold;
1409 LeaveCriticalSection(&emt->lock);
1410}
1411
1412BOOL rdpemt_has_failed(rdpEmt* emt)
1413{
1414 WINPR_ASSERT(emt);
1415 EnterCriticalSection(&emt->lock);
1416 const BOOL failed = emt->failed;
1417 LeaveCriticalSection(&emt->lock);
1418 return failed;
1419}
1420
1421BOOL rdpemt_set_tls_settings(rdpEmt* emt, UINT16 minVersion, UINT16 maxVersion, UINT32 secLevel,
1422 const char* ciphers)
1423{
1424 WINPR_ASSERT(emt);
1425 WINPR_ASSERT(emt->server);
1426
1427 /* Tunnel requires TLS 1.2 or later. */
1428 if ((maxVersion != 0) && (maxVersion < TLS1_2_VERSION))
1429 {
1430 WLog_Print(emt->log, WLOG_INFO,
1431 "UDP not offered; TLS settings allow no version for the tunnel");
1432 return FALSE;
1433 }
1434 char* copy = nullptr;
1435 if (ciphers)
1436 {
1437 copy = _strdup(ciphers);
1438 if (!copy)
1439 return FALSE;
1440 }
1441 free(emt->tlsCiphers);
1442 emt->tlsCiphers = copy;
1443 emt->tlsMinVersion = minVersion;
1444 emt->tlsMaxVersion = maxVersion;
1445 emt->tlsSecLevel = secLevel;
1446 return TRUE;
1447}
1448
1449#if defined(WITH_RDPEUDP_SERVER)
1450rdpEmt* rdpemt_new_server(wLog* log, UINT32 requestId, const BYTE* cookie, rdpCertificate* cert,
1451 const rdpPrivateKey* key, BOOL manual, rdpEmtEventFn callback,
1452 void* custom)
1453{
1454 WINPR_ASSERT(log);
1455 WINPR_ASSERT(cookie);
1456 WINPR_ASSERT(cert);
1457 WINPR_ASSERT(key);
1458 WINPR_ASSERT(callback);
1459
1460 rdpEmt* emt = calloc(1, sizeof(rdpEmt));
1461 if (!emt)
1462 return nullptr;
1463
1464 emt->log = log;
1465 emt->server = TRUE;
1466 emt->serial = InterlockedIncrement(&g_emtSerial);
1467 emt->requestId = requestId;
1468 memcpy(emt->cookie, cookie, sizeof(emt->cookie));
1469 emt->callback = callback;
1470 emt->custom = custom;
1471 if (!InitializeCriticalSectionAndSpinCount(&emt->lock, 4000))
1472 {
1473 free(emt);
1474 return nullptr;
1475 }
1476
1477 /* Store references immediately so rdpemt_free can release them on failure. */
1478 X509* x509 = freerdp_certificate_get_x509(cert);
1479 if (!x509 || (X509_up_ref(x509) != 1))
1480 goto fail;
1481 emt->cert = x509;
1482 emt->key = freerdp_key_get_evp_pkey(key); /* Obtains a new reference */
1483 if (!emt->key)
1484 goto fail;
1485
1486 if (!emt_cookie_hash(emt->cookie, emt->cookieHash))
1487 goto fail;
1488
1489 emt->in = Stream_New(nullptr, 16384);
1490 emt->out = Stream_New(nullptr, 4096);
1491 if (!emt->in || !emt->out)
1492 goto fail;
1493
1494 emt->udp = rdpudp_new(log, nullptr, emt_receive, emt);
1495 emt->flow = freerdp_udp_flow_new(emt->cookieHash);
1496 emt->sendQueue = Queue_New(FALSE, -1, -1);
1497 if (!emt->udp || !emt->flow || !emt->sendQueue)
1498 goto fail;
1499 emt->sendLimit = RDPEMT_SEND_LIMIT;
1500 udpflow_set_worker(emt->flow, emt_manual_poll, emt_manual_get_timeout, emt);
1501
1502 emt->started = rdpudp_get_time(emt->udp);
1503 if (!manual)
1504 {
1505 emt->thread = CreateThread(nullptr, 0, emt_thread, emt, 0, nullptr);
1506 if (!emt->thread)
1507 goto fail;
1508 }
1509 return emt;
1510fail:
1511 WINPR_PRAGMA_DIAG_PUSH
1512 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
1513 rdpemt_free(emt);
1514 WINPR_PRAGMA_DIAG_POP
1515 return nullptr;
1516}
1517#endif
1518
1519BOOL rdpemt_start(rdpEmt* emt, const struct sockaddr* addr, size_t addrlen)
1520{
1521 WINPR_ASSERT(emt);
1522 WINPR_ASSERT(addr);
1523
1524 emt->started = GetTickCount64();
1525 if (!rdpudp_connect(emt->udp, addr, addrlen))
1526 return FALSE;
1527
1528 emt->thread = CreateThread(nullptr, 0, emt_thread, emt, 0, nullptr);
1529 return emt->thread != nullptr;
1530}
1531
1532void rdpemt_free(rdpEmt* emt)
1533{
1534 if (!emt)
1535 return;
1536
1537 /* not InterlockedExchange: WinPR's reads the old value non-atomically */
1538 InterlockedIncrement(&emt->stop);
1539#if defined(WITH_RDPEUDP_SERVER)
1540 if (emt->flow)
1541 udpflow_wake(emt->flow);
1542#endif
1543 if (emt->thread)
1544 {
1545 (void)WaitForSingleObject(emt->thread, INFINITE);
1546 (void)CloseHandle(emt->thread);
1547 }
1548
1549#if defined(WITH_RDPEUDP_SERVER)
1550 /* Thread terminated and sending stopped; listener can now release the flow, potentially
1551 * closing the socket. */
1552 freerdp_udp_flow_free(emt->flow);
1553#endif
1554
1555 if (emt->sendQueue)
1556 {
1557 /* Queue_Free does not free items for this queue. */
1558 wStream* s = nullptr;
1559 while ((s = Queue_Dequeue(emt->sendQueue)))
1560 Stream_Free(s, TRUE);
1561 Queue_Free(emt->sendQueue);
1562 }
1563
1564 SSL_free(emt->ssl); /* frees both BIOs */
1565 SSL_CTX_free(emt->ctx);
1566 X509_free(emt->cert);
1567 EVP_PKEY_free(emt->key);
1568 rdpudp_free(emt->udp);
1569 free(emt->hostname);
1570 free(emt->publicKey);
1571 free(emt->tlsCiphers);
1572 Stream_Free(emt->in, TRUE);
1573 Stream_Free(emt->out, TRUE);
1574 Stream_Free(emt->batch, TRUE);
1575 DeleteCriticalSection(&emt->lock);
1576 free(emt);
1577}
1578
1579/* Return TRUE if the link is full or pending data must be sent first. */
1580WINPR_ATTR_NODISCARD
1581static BOOL emt_must_queue(const rdpEmt* emt)
1582{
1583 WINPR_ASSERT(emt);
1584 return (Queue_Count(emt->sendQueue) > 0) ||
1585 (rdpudp_get_send_backlog(emt->udp) >= rdpudp_get_send_window(emt->udp));
1586}
1587
1588BOOL rdpemt_send_data(rdpEmt* emt, const BYTE* data, size_t length)
1589{
1590 WINPR_ASSERT(emt);
1591 WINPR_ASSERT(data || (length == 0));
1592
1593 BOOL rc = FALSE;
1594 EnterCriticalSection(&emt->lock);
1595 if (emt->ready && !emt->failed)
1596 {
1597 if (!emt->server)
1598 rc = emt_write_pdu(emt, RDPTUNNEL_ACTION_DATA, nullptr, 0, data, length);
1599 else if (emt_must_queue(emt))
1600 rc = emt_queue_send(emt, EMT_QUEUED_DATA, data, length);
1601 else
1602 rc = emt_batch_data(emt, data, length);
1603 if (!rc)
1604 emt_fail(emt, "unable to send tunnel data");
1605 }
1606 LeaveCriticalSection(&emt->lock);
1607 return rc;
1608}
1609
1610BOOL rdpemt_flush(rdpEmt* emt)
1611{
1612 WINPR_ASSERT(emt);
1613
1614 BOOL rc = TRUE;
1615 EnterCriticalSection(&emt->lock);
1616 if (emt->ready && !emt->failed)
1617 {
1618 rc = emt_write_batch(emt) && emt_flush_queue(emt);
1619 if (!rc)
1620 emt_fail(emt, "failed to send tunnel data");
1621 }
1622 LeaveCriticalSection(&emt->lock);
1623 return rc;
1624}
1625
1626#if defined(WITH_RDPEUDP_SERVER)
1627rdpUdpFlow* rdpemt_get_flow(const rdpEmt* emt)
1628{
1629 WINPR_ASSERT(emt);
1630 return emt->flow;
1631}
1632#endif
1633
1634void rdpemt_get_send_state(rdpEmt* emt, rdpUdpSendState* state)
1635{
1636 WINPR_ASSERT(emt);
1637 WINPR_ASSERT(state);
1638
1639 EnterCriticalSection(&emt->lock);
1640 const size_t max = (rdpudp_get_state(emt->udp) == RDPUDP_STATE_ESTABLISHED)
1641 ? rdpudp_get_max_payload(emt->udp)
1642 : 0;
1643 const UINT32 rtt = rdpudp_get_rtt(emt->udp);
1644 state->writeBlocked = emt->writeBlocked;
1645 state->queuedBytes = emt->sendQueueBytes + rdpudp_get_send_backlog(emt->udp) * max;
1646 state->rttMs = rtt;
1647 state->rateBytesPerSecond =
1648 (rtt > 0) ? (1000ull * rdpudp_get_send_window(emt->udp) * max) / rtt : 0;
1649 LeaveCriticalSection(&emt->lock);
1650}
1651
1652void rdpemt_set_send_limit(rdpEmt* emt, size_t limit)
1653{
1654 WINPR_ASSERT(emt);
1655
1656 EnterCriticalSection(&emt->lock);
1657 emt->sendLimit = (limit > 0) ? limit : RDPEMT_SEND_LIMIT;
1658 LeaveCriticalSection(&emt->lock);
1659}
1660
1661BOOL rdpemt_set_receiver(rdpEmt* emt, rdpEmtReceiverFn receiver, void* custom, wQueue* pending)
1662{
1663 WINPR_ASSERT(emt);
1664 WINPR_ASSERT(receiver);
1665 WINPR_ASSERT(pending);
1666
1667 /* The tunnel thread raises its events while it holds the lock, so pending does not fill up
1668 * meanwhile. Once a receiver is set no data goes to pending any more, so whatever waits there
1669 * then may be overtaken. */
1670 EnterCriticalSection(&emt->lock);
1671 const BOOL rc = emt->receiver || (Queue_Count(pending) == 0);
1672 if (rc)
1673 {
1674 if (!emt->receiver)
1675 WLog_Print(emt->log, WLOG_DEBUG,
1676 "tunnel data goes to its receiver on the tunnel thread");
1677 emt->receiver = receiver;
1678 emt->receiverCustom = custom;
1679 }
1680 LeaveCriticalSection(&emt->lock);
1681 return rc;
1682}
1683
1684void rdpemt_clear_receiver(rdpEmt* emt)
1685{
1686 WINPR_ASSERT(emt);
1687
1688 /* the tunnel thread hands data up while it holds the lock, so it is out of the receiver now */
1689 EnterCriticalSection(&emt->lock);
1690 if (emt->receiver)
1691 WLog_Print(emt->log, WLOG_DEBUG, "tunnel data goes to the event callback again");
1692 emt->receiver = nullptr;
1693 emt->receiverCustom = nullptr;
1694 LeaveCriticalSection(&emt->lock);
1695}
1696
1697UINT32 rdpemt_take_direct_bytes(rdpEmt* emt)
1698{
1699 WINPR_ASSERT(emt);
1700
1701 /* Not the lock: the main loop calls this on every pass. Swapped for 0 with compare-exchange,
1702 * WinPR's InterlockedExchange reads the old value non-atomically. */
1703 LONG bytes = InterlockedCompareExchange(&emt->directBytes, 0, 0);
1704 while (bytes != 0)
1705 {
1706 const LONG seen = InterlockedCompareExchange(&emt->directBytes, 0, bytes);
1707 if (seen == bytes)
1708 break;
1709 bytes = seen;
1710 }
1711 /* The counter wraps when the main loop leaves more than 2 GiB untaken. The count stays right
1712 * modulo 2^32, like the UINT32 of a bandwidth measurement. */
1713 return WINPR_CXX_COMPAT_CAST(UINT32, bytes);
1714}
1715
1716BOOL rdpemt_send_subheader(rdpEmt* emt, const BYTE* subHeader, size_t length)
1717{
1718 WINPR_ASSERT(emt);
1719 WINPR_ASSERT(subHeader);
1720
1721 BOOL rc = FALSE;
1722 EnterCriticalSection(&emt->lock);
1723 if (emt->ready && !emt->failed)
1724 {
1725 if (!emt->server)
1726 rc = emt_write_pdu(emt, RDPTUNNEL_ACTION_DATA, subHeader, length, nullptr, 0);
1727 else if (emt_must_queue(emt))
1728 rc = emt_queue_send(emt, EMT_QUEUED_SUBHEADER, subHeader, length);
1729 else
1730 rc = emt_write_subheader(emt, subHeader, length);
1731 if (!rc)
1732 emt_fail(emt, "failed to send a tunnel subheader");
1733 }
1734 LeaveCriticalSection(&emt->lock);
1735 return rc;
1736}
1737
1738BOOL rdpemt_is_supported(void)
1739{
1740 return TRUE;
1741}
1742
1743UINT32 rdpemt_get_request_id(const rdpEmt* emt)
1744{
1745 WINPR_ASSERT(emt);
1746 return emt->requestId;
1747}
1748
1749UINT32 rdpemt_get_serial(const rdpEmt* emt)
1750{
1751 WINPR_ASSERT(emt);
1752 return (UINT32)emt->serial;
1753}
Comprehensive UDP send state information, including additional metrics.
Definition udplistener.h:71