18#include <freerdp/config.h>
22#include <winpr/assert.h>
23#include <winpr/cast.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>
33#if defined(WINPR_HAVE_POLL_H)
36#include <sys/select.h>
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>
46#include <freerdp/crypto/certificate.h>
48#include "../crypto/certificate.h"
49#include "../crypto/privatekey.h"
51#include "udplistener.h"
55#define RDPTUNNEL_ACTION_CREATEREQUEST 0x0
56#define RDPTUNNEL_ACTION_CREATERESPONSE 0x1
57#define RDPTUNNEL_ACTION_DATA 0x2
59#define RDPTUNNEL_HEADER_LENGTH 4
62#define RDPTUNNEL_SUBHEADER_AUTODETECT_REQUEST 0x00
63#define RDPTUNNEL_SUBHEADER_AUTODETECT_RESPONSE 0x01
66#define RDPEMT_SETUP_TIMEOUT_MS 20000
70#define RDPEMT_SERVER_SETUP_TIMEOUT_MS 7000
74#define RDPEMT_INPUT_BUDGET 256
77#define TLS_RECORD_HEADER_LENGTH 5
80#define TLS_RECORD_OVERHEAD 64
83#define RDPEMT_SERVER_BATCH 16000
87#define RDPEMT_SEND_LIMIT (32768ull * 1232ull)
90static LONG g_emtSerial = 0;
95 CRITICAL_SECTION lock;
104 size_t publicKeyLength;
106 rdpEmtEventFn callback;
111 rdpEmtReceiverFn receiver;
112 void* receiverCustom;
123 UINT16 tlsMinVersion;
124 UINT16 tlsMaxVersion;
139 BOOL responseDueSent;
156 size_t sendQueueBytes;
157 size_t sendQueueItems;
166static BOOL stream_consume(
wStream* s,
size_t count)
170 const size_t used = Stream_GetPosition(s);
173 BYTE* buffer = Stream_Buffer(s);
174 memmove(buffer, &buffer[count], used - count);
175 return Stream_SetPosition(s, used - count);
178static void emt_fail(rdpEmt* emt,
const char* why)
187 WLog_Print(emt->log, WLOG_WARN,
"UDP multitransport tunnel failed: %s", why);
188 emt->callback(emt->custom, emt, RDPEMT_EVENT_FAILED,
nullptr, 0);
192static void emt_hand_up(rdpEmt* emt,
const BYTE* data,
size_t length)
199 emt->callback(emt->custom, emt, RDPEMT_EVENT_DATA, data, length);
204 wStream* s = Stream_New(
nullptr, length);
207 emt_fail(emt,
"out of memory for tunnel data");
210 Stream_Write(s, data, length);
211 Stream_SealLength(s);
212 Stream_ResetPosition(s);
213 if (!emt->receiver(emt->receiverCustom, s))
215 emt_fail(emt,
"the receiver of tunnel data failed");
219 InterlockedExchangeAdd(&emt->directBytes, WINPR_ASSERTING_INT_CAST(LONG, length));
220 WINPR_UNUSED(direct);
223static void log_ssl_errors(rdpEmt* emt,
const char* what)
228 unsigned long err = 0;
229 while ((err = ERR_get_error()) != 0)
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);
241static BOOL emt_flush_tls(rdpEmt* emt)
247 const size_t pending = BIO_ctrl_pending(emt->wbio);
250 if (pending > INT32_MAX)
252 if (!Stream_EnsureRemainingCapacity(emt->out, pending))
255 BIO_read(emt->wbio, Stream_Pointer(emt->out), WINPR_ASSERTING_INT_CAST(
int, pending));
258 Stream_Seek(emt->out, WINPR_ASSERTING_INT_CAST(
size_t, rc));
261 const size_t max = rdpudp_get_max_payload(emt->udp);
267 const BYTE* bytes = Stream_Buffer(emt->out);
268 const size_t total = Stream_GetPosition(emt->out);
270 while (offset < total)
273 const size_t length = (total - offset > max) ? max : total - offset;
274 if (!rdpudp_send(emt->udp, &bytes[offset], length))
278 return stream_consume(emt->out, total);
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));
285 while (Stream_GetRemainingLength(s) >= TLS_RECORD_HEADER_LENGTH)
288 const size_t pos = Stream_GetPosition(s);
290 const size_t record = TLS_RECORD_HEADER_LENGTH + Stream_Get_UINT16_BE(s);
291 if (Stream_GetRemainingLength(s) < record - TLS_RECORD_HEADER_LENGTH)
293 if (!Stream_SetPosition(s, pos))
297 Stream_Seek(s, record - TLS_RECORD_HEADER_LENGTH);
299 if ((pos > chunk) && (pos + record - chunk > max))
301 if (!rdpudp_send(emt->udp, &data[chunk], pos - chunk))
310 for (
size_t offset = 0; offset < record; offset += max)
312 const size_t length = (record - offset > max) ? max : record - offset;
313 if (!rdpudp_send(emt->udp, &data[pos + offset], length))
316 chunk = pos + record;
320 const size_t end = Stream_GetPosition(s);
321 if ((end > chunk) && !rdpudp_send(emt->udp, &data[chunk], end - chunk))
324 return stream_consume(emt->out, end);
328static BOOL emt_write_pdu(rdpEmt* emt, BYTE action,
const BYTE* subHeader,
size_t subHeaderLength,
329 const BYTE* payload,
size_t length)
332 WINPR_ASSERT(subHeader || (subHeaderLength == 0));
333 WINPR_ASSERT(payload || (length == 0));
335 if ((length > UINT16_MAX) || (subHeaderLength > UINT8_MAX - RDPTUNNEL_HEADER_LENGTH))
338 wStream* s = Stream_New(
nullptr, RDPTUNNEL_HEADER_LENGTH + subHeaderLength + length);
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);
348 Stream_Write_UINT16(s, payloadLength);
349 Stream_Write_UINT8(s, headerLength);
350 Stream_Write(s, subHeader, subHeaderLength);
351 Stream_Write(s, payload, length);
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);
358 log_ssl_errors(emt,
"SSL_write");
361 return emt_flush_tls(emt);
366static BOOL emt_write_batch(rdpEmt* emt)
370 const size_t length = emt->batch ? Stream_GetPosition(emt->batch) : 0;
373 if (length > INT32_MAX)
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);
380 log_ssl_errors(emt,
"SSL_write");
383 return emt_flush_tls(emt);
388static BOOL emt_batch_data(rdpEmt* emt,
const BYTE* payload,
size_t length)
391 WINPR_ASSERT(payload || (length == 0));
393 if (length > UINT16_MAX)
397 emt->batch = Stream_New(
nullptr, RDPEMT_SERVER_BATCH);
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))
408 if (!Stream_EnsureRemainingCapacity(emt->batch, pdu))
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);
422#define EMT_QUEUED_DATA 0
423#define EMT_QUEUED_SUBHEADER 1
428static BOOL emt_write_subheader(rdpEmt* emt,
const BYTE* subHeader,
size_t length)
431 return emt_write_batch(emt) &&
432 emt_write_pdu(emt, RDPTUNNEL_ACTION_DATA, subHeader, length,
nullptr, 0);
437static size_t emt_backlog(
const rdpEmt* 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);
446static void emt_update_blocked(rdpEmt* emt)
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))
456 emt->writeBlocked = FALSE;
457 emt->callback(emt->custom, emt, RDPEMT_EVENT_WRITABLE,
nullptr, 0);
462#define EMT_QUEUE_ITEM_COST 64
466static BOOL emt_queue_send(rdpEmt* emt, BYTE kind,
const BYTE* payload,
size_t length)
469 WINPR_ASSERT(payload || (length == 0));
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))
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");
482 wStream* s = Stream_New(
nullptr, 1 + length);
485 Stream_Write_UINT8(s, kind);
486 Stream_Write(s, payload, length);
487 if (!Queue_Enqueue(emt->sendQueue, s))
489 Stream_Free(s, TRUE);
492 emt->sendQueueBytes += length;
493 emt->sendQueueItems++;
494 emt_update_blocked(emt);
500static BOOL emt_flush_queue(rdpEmt* emt)
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))
508 wStream* s = Queue_Dequeue(emt->sendQueue);
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);
522 if (moved && !emt_write_batch(emt))
524 emt_update_blocked(emt);
529static BOOL emt_send_create_request(rdpEmt* emt)
533 BYTE request[24] = WINPR_C_ARRAY_INIT;
534 wStream sbuffer = WINPR_C_ARRAY_INIT;
535 wStream* s = Stream_StaticInit(&sbuffer, request,
sizeof(request));
538 Stream_Write_UINT32(s, emt->requestId);
539 Stream_Write_UINT32(s, 0);
540 Stream_Write(s, emt->cookie,
sizeof(emt->cookie));
542 WLog_Print(emt->log, WLOG_DEBUG,
"sending Tunnel Create Request for request id %" PRIu32,
544 return emt_write_pdu(emt, RDPTUNNEL_ACTION_CREATEREQUEST,
nullptr, 0, Stream_Buffer(s),
545 Stream_GetPosition(s));
551static BOOL emt_verify_peer(rdpEmt* emt)
555 X509* x509 = SSL_get_peer_certificate(emt->ssl);
558 WLog_Print(emt->log, WLOG_WARN,
"the tunnel's TLS session has no server certificate");
565 rdpCertificate* cert = freerdp_certificate_new_from_x509(x509,
nullptr);
566 if (cert && freerdp_certificate_get_public_key(cert, &key, &keyLength))
568 rc = (keyLength == emt->publicKeyLength) && (memcmp(key, emt->publicKey, keyLength) == 0);
571 WLog_Print(emt->log, WLOG_WARN,
572 "the tunnel's TLS certificate differs from the main connection's");
575 freerdp_certificate_free(cert);
584static BOOL emt_process_subheaders(rdpEmt* emt,
const BYTE* data,
size_t length)
587 WINPR_ASSERT(data || (length == 0));
591 const size_t subHeaderLength = data[0];
592 if ((length < 2) || (subHeaderLength < 2) || (subHeaderLength > length))
594 emt_fail(emt,
"invalid tunnel subheader");
598 const BYTE subHeaderType = data[1];
599 if (subHeaderType == RDPTUNNEL_SUBHEADER_AUTODETECT_REQUEST)
600 emt->callback(emt->custom, emt, RDPEMT_EVENT_AUTODETECT, data, subHeaderLength);
602 WLog_Print(emt->log, WLOG_DEBUG,
"ignoring tunnel subheader of type 0x%02" PRIx8,
604 data += subHeaderLength;
605 length -= subHeaderLength;
614static BOOL emt_accept_create_request(rdpEmt* emt,
wStream* s,
size_t payloadLength)
620 if ((payloadLength < 8 +
sizeof(emt->cookie)) ||
621 !Stream_CheckAndLogRequiredLengthWLog(emt->log, s, payloadLength))
623 emt_fail(emt,
"tunnel Create Request is too short");
626 const UINT32 requestId = Stream_Get_UINT32(s);
627 Stream_Seek_UINT32(s);
628 const BYTE* cookie = Stream_ConstPointer(s);
629 Stream_Seek(s, payloadLength - 8);
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));
638 emt_fail(emt,
"unable to construct the Tunnel Create Response");
642 const UINT32 hr = valid ? (UINT32)S_OK : (UINT32)E_ABORT;
643 Stream_Write_UINT32(rs, hr);
644 if (!emt_write_pdu(emt, RDPTUNNEL_ACTION_CREATERESPONSE,
nullptr, 0, response,
647 emt_fail(emt,
"unable to send the Tunnel Create Response");
652 emt_fail(emt,
"the Tunnel Create Request refers to a different request or cookie");
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));
663 emt->callback(emt->custom, emt, RDPEMT_EVENT_READY,
nullptr, 0);
669static BOOL emt_process_pdus(rdpEmt* emt)
673 wStream sbuffer = WINPR_C_ARRAY_INIT;
675 Stream_StaticConstInit(&sbuffer, Stream_Buffer(emt->in), Stream_GetPosition(emt->in));
677 while (Stream_GetRemainingLength(s) >= RDPTUNNEL_HEADER_LENGTH)
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)
686 emt_fail(emt,
"invalid tunnel PDU header");
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)
698 if (!Stream_SetPosition(s, start))
703 if (!emt_process_subheaders(emt, Stream_ConstPointer(s),
704 headerLength - RDPTUNNEL_HEADER_LENGTH))
706 Stream_Seek(s, headerLength - RDPTUNNEL_HEADER_LENGTH);
710 case RDPTUNNEL_ACTION_CREATERESPONSE:
713 if (payloadLength < 4)
715 emt_fail(emt,
"short Tunnel Create Response");
718 const UINT32 hr = Stream_Get_UINT32(s);
719 Stream_Seek(s, payloadLength - 4);
720 if (FAILED((HRESULT)hr))
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");
729 WLog_Print(emt->log, WLOG_INFO,
730 "UDP multitransport tunnel ready (RDP-UDP version 0x%04" PRIx16
")",
731 rdpudp_get_version(emt->udp));
733 emt->callback(emt->custom, emt, RDPEMT_EVENT_READY,
nullptr, 0);
738 case RDPTUNNEL_ACTION_DATA:
740 if (payloadLength > 0)
741 emt_hand_up(emt, Stream_ConstPointer(s), payloadLength);
742 Stream_Seek(s, payloadLength);
746 WLog_Print(emt->log, WLOG_DEBUG,
"ignoring tunnel PDU with action %" PRIu8, action);
747 Stream_Seek(s, payloadLength);
755 return stream_consume(emt->in, Stream_GetPosition(s));
760static BOOL emt_process_server_subheaders(rdpEmt* emt,
const BYTE* data,
size_t length)
763 WINPR_ASSERT(data || (length == 0));
767 const size_t subHeaderLength = data[0];
768 if ((length < 2) || (subHeaderLength < 2) || (subHeaderLength > length))
770 emt_fail(emt,
"incorrect tunnel subheader");
774 const BYTE subHeaderType = data[1];
775 if (subHeaderType == RDPTUNNEL_SUBHEADER_AUTODETECT_RESPONSE)
776 emt->callback(emt->custom, emt, RDPEMT_EVENT_AUTODETECT, data, subHeaderLength);
778 WLog_Print(emt->log, WLOG_DEBUG,
"skipping tunnel subheader of type 0x%02" PRIx8,
780 data += subHeaderLength;
781 length -= subHeaderLength;
791static BOOL emt_process_server_pdus(rdpEmt* emt)
795 wStream sbuffer = WINPR_C_ARRAY_INIT;
797 Stream_StaticConstInit(&sbuffer, Stream_Buffer(emt->in), Stream_GetPosition(emt->in));
799 while (Stream_GetRemainingLength(s) >= RDPTUNNEL_HEADER_LENGTH)
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)
808 emt_fail(emt,
"incorrect tunnel PDU header");
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)
820 if (!Stream_SetPosition(s, start))
825 if (!emt->ready && (headerLength > RDPTUNNEL_HEADER_LENGTH))
827 emt_fail(emt,
"tunnel subheaders received before the Tunnel Create Request");
832 if (!emt_process_server_subheaders(emt, Stream_ConstPointer(s),
833 headerLength - RDPTUNNEL_HEADER_LENGTH))
835 Stream_Seek(s, headerLength - RDPTUNNEL_HEADER_LENGTH);
839 case RDPTUNNEL_ACTION_CREATEREQUEST:
840 if (!emt_accept_create_request(emt, s, payloadLength))
844 case RDPTUNNEL_ACTION_DATA:
848 emt_fail(emt,
"tunnel data received before the Tunnel Create Request");
851 if (payloadLength > 0)
852 emt_hand_up(emt, Stream_ConstPointer(s), payloadLength);
853 Stream_Seek(s, payloadLength);
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");
867 return stream_consume(emt->in, Stream_GetPosition(s));
871static BOOL emt_run_tls(rdpEmt* emt)
875 if (!emt->handshakeDone)
878 const int rc = SSL_do_handshake(emt->ssl);
879 if (!emt_flush_tls(emt))
883 const int err = SSL_get_error(emt->ssl, rc);
884 if ((err == SSL_ERROR_WANT_READ) || (err == SSL_ERROR_WANT_WRITE))
886 log_ssl_errors(emt,
"TLS handshake");
887 emt_fail(emt,
"TLS handshake failed");
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));
897 if (!emt_verify_peer(emt))
899 emt_fail(emt,
"certificate does not match");
902 if (!emt_send_create_request(emt))
904 emt_fail(emt,
"unable to send the Tunnel Create Request");
912 if (!Stream_EnsureRemainingCapacity(emt->in, 16384))
916 const int rc = SSL_read(emt->ssl, Stream_Pointer(emt->in), 16384);
919 Stream_Seek(emt->in, WINPR_ASSERTING_INT_CAST(
size_t, rc));
923 const int err = SSL_get_error(emt->ssl, rc);
924 if (err == SSL_ERROR_WANT_READ)
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");
933 if (!emt_flush_tls(emt))
936 return emt->server ? emt_process_server_pdus(emt) : emt_process_pdus(emt);
940static BOOL emt_receive(
void* custom,
const BYTE* data,
size_t length)
942 rdpEmt* emt = custom;
944 WINPR_ASSERT(data || (length == 0));
946 if (!emt->tlsStarted || emt->failed)
948 if (length > INT32_MAX)
950 const int len = WINPR_ASSERTING_INT_CAST(
int, length);
951 if (BIO_write(emt->rbio, data, len) != len)
953 return emt_run_tls(emt);
956#if defined(WITH_RDPEUDP_SERVER)
958static BOOL emt_flow_send(
void* custom,
const BYTE* data,
size_t length)
960 return freerdp_udp_flow_send(custom, data, length);
965static BOOL emt_start_tls(rdpEmt* emt)
969 emt->ctx = SSL_CTX_new(emt->server ? TLS_server_method() : TLS_client_method());
974 if (emt->server && ((SSL_CTX_use_certificate(emt->ctx, emt->cert) != 1) ||
975 (SSL_CTX_use_PrivateKey(emt->ctx, emt->key) != 1)))
977 WLog_Print(emt->log, WLOG_ERROR,
"unable to use the server certificate for the tunnel");
982 const int minVersion = (emt->server && (emt->tlsMinVersion > TLS1_2_VERSION))
985 if (!SSL_CTX_set_min_proto_version(emt->ctx, minVersion))
987 WLog_Print(emt->log, WLOG_ERROR,
"SSL_CTX_set_min_proto_version failed");
990 if (emt->server && (emt->tlsMaxVersion != 0) &&
991 !SSL_CTX_set_max_proto_version(emt->ctx, emt->tlsMaxVersion))
993 WLog_Print(emt->log, WLOG_ERROR,
"failed to set the maximum SSL protocol version");
996#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
998 SSL_CTX_set_security_level(
999 emt->ctx, (emt->tlsSecLevel > 5)
1001 : (
int)emt->tlsSecLevel);
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)
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");
1009#if defined(SSL_OP_NO_RENEGOTIATION)
1012 SSL_CTX_set_options(emt->ctx, SSL_OP_NO_RENEGOTIATION);
1015 SSL_CTX_set_verify(emt->ctx, SSL_VERIFY_NONE,
nullptr);
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))
1031 WLog_Print(emt->log, WLOG_ERROR,
"SSL_CTX_set_cipher_list failed");
1034#if OPENSSL_VERSION_NUMBER >= 0x10101000L
1035 if (!SSL_CTX_set_ciphersuites(emt->ctx,
"TLS_AES_256_GCM_SHA384:TLS_AES_128_GCM_SHA256"))
1037 WLog_Print(emt->log, WLOG_ERROR,
"SSL_CTX_set_ciphersuites failed");
1043 if (!SSL_CTX_set1_groups_list(emt->ctx,
"X25519:P-256:P-384"))
1045 WLog_Print(emt->log, WLOG_ERROR,
"SSL_CTX_set1_groups_list failed");
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"))
1052 WLog_Print(emt->log, WLOG_ERROR,
"SSL_CTX_set1_sigalgs_list failed");
1055 SSL_CTX_set_read_ahead(emt->ctx, 0);
1057 emt->ssl = SSL_new(emt->ctx);
1061 emt->rbio = BIO_new(BIO_s_mem());
1062 emt->wbio = BIO_new(BIO_s_mem());
1063 if (!emt->rbio || !emt->wbio)
1065 BIO_free(emt->rbio);
1066 BIO_free(emt->wbio);
1067 emt->rbio =
nullptr;
1068 emt->wbio =
nullptr;
1071 SSL_set_bio(emt->ssl, emt->rbio, emt->wbio);
1073 SSL_set_accept_state(emt->ssl);
1076 SSL_set_connect_state(emt->ssl);
1078 (void)SSL_set_tlsext_host_name(emt->ssl, emt->hostname);
1082 const size_t max = rdpudp_get_max_payload(emt->udp);
1083 if (!emt->server && (max > TLS_RECORD_OVERHEAD + 512))
1085 if (!SSL_set_max_send_fragment(emt->ssl,
1086 WINPR_ASSERTING_INT_CAST(
long, max - TLS_RECORD_OVERHEAD)))
1088 WLog_Print(emt->log, WLOG_ERROR,
"SSL_set_max_send_fragment failed");
1093 emt->tlsStarted = TRUE;
1094 return emt_run_tls(emt);
1097#if defined(WITH_RDPEUDP_SERVER)
1100static BOOL emt_server_process_datagrams(rdpEmt* emt)
1104 BYTE data[UDPFLOW_MAX_DATAGRAM] = WINPR_C_ARRAY_INIT;
1107 for (
size_t count = 0;
1108 (count < RDPEMT_INPUT_BUDGET) && !emt->failed && udpflow_read(emt->flow, data, &length);
1112 rdpudp_set_receive_hold(emt->udp, emt->hold && emt->hold(emt->custom));
1113 if (rdpudp_get_state(emt->udp) == RDPUDP_STATE_CLOSED)
1115 if (!rdpudp_accept(emt->udp, emt_flow_send, emt->flow, data, length))
1117 emt_fail(emt,
"unable to accept the client's SYN");
1120 emt->callback(emt->custom, emt, RDPEMT_EVENT_SYN_RECEIVED,
nullptr, 0);
1122 else if (!rdpudp_receive(emt->udp, data, length))
1124 emt_fail(emt,
"the RDP-UDP connection failed");
1127 if (!emt->tlsStarted && (rdpudp_get_state(emt->udp) == RDPUDP_STATE_ESTABLISHED) &&
1128 !emt_start_tls(emt))
1130 log_ssl_errors(emt,
"TLS setup");
1131 emt_fail(emt,
"unable to start TLS");
1135 return !emt->failed;
1140static BOOL emt_setup_timed_out(
const rdpEmt* emt)
1144 return rdpudp_get_time(emt->udp) - emt->started > RDPEMT_SERVER_SETUP_TIMEOUT_MS;
1145 return GetTickCount64() - emt->started > RDPEMT_SETUP_TIMEOUT_MS;
1149static BOOL emt_poll(rdpEmt* emt)
1156#if defined(WITH_RDPEUDP_SERVER)
1157 if (emt->server && !emt_server_process_datagrams(emt))
1161 if (emt->server && (rdpudp_get_state(emt->udp) == RDPUDP_STATE_CLOSED))
1163 if (emt_setup_timed_out(emt))
1165 emt_fail(emt,
"client failed to send SYN");
1171 if (!rdpudp_check(emt->udp))
1173 emt_fail(emt,
"the RDP-UDP connection failed");
1177 if (!emt->tlsStarted && (rdpudp_get_state(emt->udp) == RDPUDP_STATE_ESTABLISHED))
1179 if (!emt_start_tls(emt))
1181 log_ssl_errors(emt,
"TLS setup");
1182 emt_fail(emt,
"failed to start TLS");
1187 if (!emt->ready && emt_setup_timed_out(emt))
1189 emt_fail(emt,
"timed out");
1193 if (emt->server && emt->ready && !emt_flush_queue(emt))
1195 emt_fail(emt,
"unable to send tunnel data");
1200 if (emt->server && !emt->responseDueSent &&
1201 (rdpudp_get_time(emt->udp) - emt->started > RDPEMT_SERVER_RESPONSE_TIMEOUT_MS + 1000))
1203 emt->responseDueSent = TRUE;
1204 emt->callback(emt->custom, emt, RDPEMT_EVENT_RESPONSE_DUE,
nullptr, 0);
1207 return !emt->failed;
1212static void emt_wait_readable(SOCKET sockfd, UINT32 timeout)
1214#if !defined(_WIN32) && defined(WINPR_HAVE_POLL_H)
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));
1224 if (sockfd >= FD_SETSIZE)
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);
1237 (void)select(0, &rset,
nullptr,
nullptr, &tv);
1239 (void)select(WINPR_ASSERTING_INT_CAST(
int, sockfd) + 1, &rset,
nullptr,
nullptr, &tv);
1245static BOOL emt_stopping(rdpEmt* emt)
1248 return InterlockedCompareExchange(&emt->stop, 0, 0) != 0;
1252static DWORD WINAPI emt_thread(LPVOID arg)
1257 while (!emt_stopping(emt))
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);
1264#if defined(WITH_RDPEUDP_SERVER)
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");
1276 emt_wait_readable(sockfd, timeout);
1278 if (emt_stopping(emt))
1281 EnterCriticalSection(&emt->lock);
1282 const BOOL rc = emt_poll(emt);
1283 LeaveCriticalSection(&emt->lock);
1292#if defined(WITH_RDPEUDP_SERVER)
1295static BOOL emt_manual_poll(
void* custom)
1297 rdpEmt* emt = custom;
1300 EnterCriticalSection(&emt->lock);
1301 const BOOL rc = emt_poll(emt);
1302 LeaveCriticalSection(&emt->lock);
1307static UINT32 emt_manual_get_timeout(
void* custom)
1309 rdpEmt* emt = custom;
1312 EnterCriticalSection(&emt->lock);
1313 const UINT32 timeout = rdpudp_get_timeout(emt->udp);
1314 LeaveCriticalSection(&emt->lock);
1322static BOOL emt_cookie_hash(
const BYTE cookie[16], BYTE cookieHash[32])
1324 WINPR_ASSERT(cookie);
1325 WINPR_ASSERT(cookieHash);
1327 BYTE digest[32] = WINPR_C_ARRAY_INIT;
1328 if (!winpr_Digest(WINPR_MD_SHA256, cookie, 16, digest,
sizeof(digest)))
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);
1336 for (
size_t x = 0; x < 32 / 4; x++)
1339 const UINT32 word = Stream_Get_UINT32_BE(ds);
1340 Stream_Write_UINT32(hs, word);
1345rdpEmt* rdpemt_new(wLog* log, UINT32 requestId,
const BYTE* cookie,
const char* hostname,
1346 const BYTE* publicKey,
size_t publicKeyLength, rdpEmtEventFn callback,
1350 WINPR_ASSERT(cookie);
1351 WINPR_ASSERT(publicKey);
1352 WINPR_ASSERT(callback);
1354 rdpEmt* emt = calloc(1,
sizeof(rdpEmt));
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))
1372 emt->hostname = _strdup(hostname);
1377 emt->publicKey = malloc(publicKeyLength);
1378 if (!emt->publicKey)
1380 memcpy(emt->publicKey, publicKey, publicKeyLength);
1381 emt->publicKeyLength = publicKeyLength;
1383 if (!emt_cookie_hash(emt->cookie, emt->cookieHash))
1386 emt->in = Stream_New(
nullptr, 16384);
1387 emt->out = Stream_New(
nullptr, 4096);
1388 if (!emt->in || !emt->out)
1391 emt->udp = rdpudp_new(log, emt->cookieHash, emt_receive, emt);
1397 WINPR_PRAGMA_DIAG_PUSH
1398 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
1400 WINPR_PRAGMA_DIAG_POP
1404void rdpemt_set_receive_hold(rdpEmt* emt, rdpEmtHoldFn hold)
1407 EnterCriticalSection(&emt->lock);
1409 LeaveCriticalSection(&emt->lock);
1412BOOL rdpemt_has_failed(rdpEmt* emt)
1415 EnterCriticalSection(&emt->lock);
1416 const BOOL failed = emt->failed;
1417 LeaveCriticalSection(&emt->lock);
1421BOOL rdpemt_set_tls_settings(rdpEmt* emt, UINT16 minVersion, UINT16 maxVersion, UINT32 secLevel,
1422 const char* ciphers)
1425 WINPR_ASSERT(emt->server);
1428 if ((maxVersion != 0) && (maxVersion < TLS1_2_VERSION))
1430 WLog_Print(emt->log, WLOG_INFO,
1431 "UDP not offered; TLS settings allow no version for the tunnel");
1434 char* copy =
nullptr;
1437 copy = _strdup(ciphers);
1441 free(emt->tlsCiphers);
1442 emt->tlsCiphers = copy;
1443 emt->tlsMinVersion = minVersion;
1444 emt->tlsMaxVersion = maxVersion;
1445 emt->tlsSecLevel = secLevel;
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,
1455 WINPR_ASSERT(cookie);
1458 WINPR_ASSERT(callback);
1460 rdpEmt* emt = calloc(1,
sizeof(rdpEmt));
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))
1478 X509* x509 = freerdp_certificate_get_x509(cert);
1479 if (!x509 || (X509_up_ref(x509) != 1))
1482 emt->key = freerdp_key_get_evp_pkey(key);
1486 if (!emt_cookie_hash(emt->cookie, emt->cookieHash))
1489 emt->in = Stream_New(
nullptr, 16384);
1490 emt->out = Stream_New(
nullptr, 4096);
1491 if (!emt->in || !emt->out)
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)
1499 emt->sendLimit = RDPEMT_SEND_LIMIT;
1500 udpflow_set_worker(emt->flow, emt_manual_poll, emt_manual_get_timeout, emt);
1502 emt->started = rdpudp_get_time(emt->udp);
1505 emt->thread = CreateThread(
nullptr, 0, emt_thread, emt, 0,
nullptr);
1511 WINPR_PRAGMA_DIAG_PUSH
1512 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
1514 WINPR_PRAGMA_DIAG_POP
1519BOOL rdpemt_start(rdpEmt* emt,
const struct sockaddr* addr,
size_t addrlen)
1524 emt->started = GetTickCount64();
1525 if (!rdpudp_connect(emt->udp, addr, addrlen))
1528 emt->thread = CreateThread(
nullptr, 0, emt_thread, emt, 0,
nullptr);
1529 return emt->thread !=
nullptr;
1532void rdpemt_free(rdpEmt* emt)
1538 InterlockedIncrement(&emt->stop);
1539#if defined(WITH_RDPEUDP_SERVER)
1541 udpflow_wake(emt->flow);
1545 (void)WaitForSingleObject(emt->thread, INFINITE);
1546 (void)CloseHandle(emt->thread);
1549#if defined(WITH_RDPEUDP_SERVER)
1552 freerdp_udp_flow_free(emt->flow);
1559 while ((s = Queue_Dequeue(emt->sendQueue)))
1560 Stream_Free(s, TRUE);
1561 Queue_Free(emt->sendQueue);
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);
1581static BOOL emt_must_queue(
const rdpEmt* emt)
1584 return (Queue_Count(emt->sendQueue) > 0) ||
1585 (rdpudp_get_send_backlog(emt->udp) >= rdpudp_get_send_window(emt->udp));
1588BOOL rdpemt_send_data(rdpEmt* emt,
const BYTE* data,
size_t length)
1591 WINPR_ASSERT(data || (length == 0));
1594 EnterCriticalSection(&emt->lock);
1595 if (emt->ready && !emt->failed)
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);
1602 rc = emt_batch_data(emt, data, length);
1604 emt_fail(emt,
"unable to send tunnel data");
1606 LeaveCriticalSection(&emt->lock);
1610BOOL rdpemt_flush(rdpEmt* emt)
1615 EnterCriticalSection(&emt->lock);
1616 if (emt->ready && !emt->failed)
1618 rc = emt_write_batch(emt) && emt_flush_queue(emt);
1620 emt_fail(emt,
"failed to send tunnel data");
1622 LeaveCriticalSection(&emt->lock);
1626#if defined(WITH_RDPEUDP_SERVER)
1627rdpUdpFlow* rdpemt_get_flow(
const rdpEmt* emt)
1637 WINPR_ASSERT(state);
1639 EnterCriticalSection(&emt->lock);
1640 const size_t max = (rdpudp_get_state(emt->udp) == RDPUDP_STATE_ESTABLISHED)
1641 ? rdpudp_get_max_payload(emt->udp)
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;
1647 state->rateBytesPerSecond =
1648 (rtt > 0) ? (1000ull * rdpudp_get_send_window(emt->udp) * max) / rtt : 0;
1649 LeaveCriticalSection(&emt->lock);
1652void rdpemt_set_send_limit(rdpEmt* emt,
size_t limit)
1656 EnterCriticalSection(&emt->lock);
1657 emt->sendLimit = (limit > 0) ? limit : RDPEMT_SEND_LIMIT;
1658 LeaveCriticalSection(&emt->lock);
1661BOOL rdpemt_set_receiver(rdpEmt* emt, rdpEmtReceiverFn receiver,
void* custom, wQueue* pending)
1664 WINPR_ASSERT(receiver);
1665 WINPR_ASSERT(pending);
1670 EnterCriticalSection(&emt->lock);
1671 const BOOL rc = emt->receiver || (Queue_Count(pending) == 0);
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;
1680 LeaveCriticalSection(&emt->lock);
1684void rdpemt_clear_receiver(rdpEmt* emt)
1689 EnterCriticalSection(&emt->lock);
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);
1697UINT32 rdpemt_take_direct_bytes(rdpEmt* emt)
1703 LONG bytes = InterlockedCompareExchange(&emt->directBytes, 0, 0);
1706 const LONG seen = InterlockedCompareExchange(&emt->directBytes, 0, bytes);
1713 return WINPR_CXX_COMPAT_CAST(UINT32, bytes);
1716BOOL rdpemt_send_subheader(rdpEmt* emt,
const BYTE* subHeader,
size_t length)
1719 WINPR_ASSERT(subHeader);
1722 EnterCriticalSection(&emt->lock);
1723 if (emt->ready && !emt->failed)
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);
1730 rc = emt_write_subheader(emt, subHeader, length);
1732 emt_fail(emt,
"failed to send a tunnel subheader");
1734 LeaveCriticalSection(&emt->lock);
1738BOOL rdpemt_is_supported(
void)
1743UINT32 rdpemt_get_request_id(
const rdpEmt* emt)
1746 return emt->requestId;
1749UINT32 rdpemt_get_serial(
const rdpEmt* emt)
1752 return (UINT32)emt->serial;
Comprehensive UDP send state information, including additional metrics.