FreeRDP vulnerabilities

FreeRDP before version 3.21.0 has a vulnerability in FastGlyph parsing where data length is not validated against the minimum size implied by cx/cy. A malicious server can trigger a client-side global buffer overflow, causing a crash (DoS).

FreeRDP is a free implementation of the Remote Desktop Protocol. Prior to 3.20.1, a race in the serial channel IRP thread tracking allows a heap use‑after‑free when one thread removes an entry from serial->IrpThreads while another reads it. This vulnerability is fixed in 3.20.1.

FreeRDP before 1.1.0-beta+2013071101 allows remote attackers to cause a denial of service (NULL pointer dereference and application crash) by disconnecting before authentication has finished.

FreeRDP before 1.1.0-beta1 allows remote attackers to cause a denial of service via NULL pointer dereference, leading to application crash.

Multiple integer overflows in client/X11/xf_graphics.c in FreeRDP allow remote attackers to have an unspecified impact via the width and height to the xf_Pointer_New or xf_Bitmap_Decompress function, which causes an incorrect amount of memory to be allocated.

FreeRDP before 3.30.0 has a heap-based buffer overflow in CliprdrStream_Read. A malicious RDP server can send an oversized response, causing an out-of-bounds write.

FreeRDP Windows client before version 3.29.0 contains a heap buffer overflow vulnerability in the clipboard virtual channel when processing CLIPRDR_FILE_CONTENTS_RESPONSE PDUs without validating the server-provided size against the destination buffer. A malicious RDP server can send a response with a data payload significantly larger than requested, causing arbitrary heap memory corruption that may enable remote code execution when a user performs a paste operation.

FreeRDP before version 3.29.0 (affected versions <= 3.28.0) does not validate CRLF and control characters in the server-controlled RDP redirection TargetNetAddress field. This value is copied into the client's ServerHostname and, when the client connects through an HTTP proxy, is written directly into the proxy CONNECT request line and Host header by http_proxy_connect() without filtering. A malicious or compromised RDP server can send a crafted redirection PDU containing embedded control characters to inject arbitrary headers/requests into the HTTP proxy CONNECT request.

FreeRDP before version 3.29.0 (affected versions <= 3.28.0) contains multiple TLS certificate identity validation weaknesses in tls_verify_certificate(), tls_match_hostname(), and x509_utils_get_dns_names(). Because FreeRDP performs custom Common Name and DNS SAN string matching instead of using OpenSSL's length-aware identity validation APIs, it (1) truncates DNS SAN values at embedded NUL bytes (accepting e.g. 'victim.example\0.attacker.example' as 'victim.example'), (2) accepts a matching Common Name even when non-matching DNS SAN entries are present, and (3) accepts IP-literal targets via DNS/CN matching without comparing iPAddress SANs. Under a trusted or misissued certificate chain, an attacker positioned to present such a certificate can bypass server identity verification, weakening TLS server authentication.

A heap-based buffer overflow in FreeRDP before version 3.28.0 (affected <=3.27.1) in the crypto_rsa_common() function. The function writes the modular exponentiation result to the output buffer before checking bounds, allowing out-of-bounds writes.

FreeRDP versions 3.21.0 through 3.27.9 contain an incomplete fix for CVE-2026-23530 in the planar_decompress_plane_rle_only function in planar.c. A malicious RDP server can send a crafted planar RDPGFX_CMDID_WIRETOSURFACE_1 payload that reads one byte past the input buffer.

In 32-bit builds of FreeRDP prior to 3.28.0, an integer overflow occurs in the update_read_delta_points function in libfreerdp/core/orders.c. A malicious RDP server can exploit this to allocate an undersized heap buffer and write beyond its bounds.

FreeRDP prior to 3.26.0 has an out-of-bounds heap write in the planar bitmap decoder. An attacker can bypass coordinate validation and write past the internal buffer.

In FreeRDP prior to 3.24.0, the gdi_surface_bits() function fails to properly validate bmp.width and bmp.height values from the RDP server. A malicious server can supply crafted values exceeding the surface size, causing a heap buffer overflow during bitmap decoding. The attacker controls pixel data, potentially allowing overwriting adjacent heap memory.

In FreeRDP prior to version 3.21.0, offscreen bitmap deletion leaves `gdi->drawing` pointing to freed memory, causing a use-after-free (UAF) when related update packets arrive. A malicious server can trigger this client-side vulnerability, causing a crash (DoS) and potential heap corruption with code-execution risk.

In FreeRDP prior to version 3.21.0, the `xf_Pointer_New` function frees `cursorPixels` on failure, then `pointer_free` calls `xf_Pointer_Free` which frees it again, triggering an ASan-detected use-after-free. A malicious server can trigger a client-side use after free, causing a crash (DoS) and potential heap corruption with code-execution risk depending on allocator behavior and surrounding heap layout.

In FreeRDP prior to version 3.21.0, a client-side heap buffer overflow occurs in the ClearCodec bands decode path when crafted band coordinates allow writes past the end of the destination surface buffer.

In FreeRDP prior to version 3.21.0, a client-side heap buffer overflow exists in the RDPGFX ClearCodec decode path. Maliciously crafted residual data causes out-of-bounds writes during color output, potentially leading to a crash and code execution.

In FreeRDP prior to version 3.21.0, a client-side heap buffer overflow exists in the `gdi_SurfaceToSurface` path due to a mismatch between destination rectangle clamping and the actual copy size. This can cause a crash and potential heap corruption with code-execution risk.

In FreeRDP prior to version 3.21.0, in ClearCodec, when `glyphData` is present, `clear_decompress` calls `freerdp_image_copy_no_overlap` without validating the destination rectangle, allowing an out-of-bounds read/write via crafted RDPGFX surface updates. A malicious server can trigger a client-side heap buffer overflow, causing a crash (DoS) and potential heap corruption with code-execution risk.

In FreeRDP prior to version 3.21.0, the `freerdp_bitmap_decompress_planar` function does not validate `nSrcWidth`/`nSrcHeight` against `planar->maxWidth`/`maxHeight` before RLE decode. A malicious server can trigger a client-side heap buffer overflow, causing a crash (DoS) and potential heap corruption with code-execution risk.

In FreeRDP prior to version 3.20.1, a vulnerability exists due to missing bounds checking on server-supplied MSUSB_INTERFACE_DESCRIPTOR values. The URBDRC client uses these values as indices in libusb_udev_complete_msconfig_setup, causing an out-of-bounds read.

In FreeRDP before version 3.20.1, a global buffer overflow was observed in the Base64 decoding path. The root cause is implementation-defined char signedness: on Arm/AArch64 builds, plain char is treated as unsigned, so the guard c <= 0 can be optimized into a simple c != 0 check, allowing non-ASCII bytes (0x80-0xFF) to bypass the intended range restriction and be used as an index into a global lookup table, causing out-of-bounds access.

FreeRDP before version 3.20.1 contains a use-after-free vulnerability in the irp_thread_func function. The IRP object is freed by irp->Complete() and then accessed again on the error path, potentially leading to memory corruption.

In FreeRDP prior to 3.20.1, a heap out-of-bounds read vulnerability exists in the smartcard SetAttrib path when cbAttrLen does not match the actual NDR buffer length.

FreeRDP before version 3.20.1 contains a heap-buffer-overflow vulnerability in drive read. A server-controlled read length is used without a hard upper bound, allowing an oversized read to overwrite heap memory.

In FreeRDP prior to version 3.20.1, a vulnerability exists due to missing bounds checking on the element count in the NDR array reader of the RDPEAR protocol. An attacker can exploit this to write beyond the allocated heap buffer, causing a heap buffer overflow in the ndr_read_uint8Array function.

FreeRDP before version 3.20.1 contains a heap-buffer-overflow write vulnerability when processing Audio Input (AUDIN) format lists. audin_process_formats reuses callback->formats_count across multiple PDUs and writes past the newly allocated array, causing memory corruption and a crash.

FreeRDP prior to version 3.20.0 contains a vulnerability in certificate handling code on Windows platforms. The function `freerdp_certificate_data_hash_uses` uses the Microsoft-specific `_snprintf` function to format certificate cache filenames without guaranteeing NUL termination when truncation occurs. If an attacker controls the hostname value (for example via server redirection or a crafted .rdp file), the resulting filename buffer may not be NUL-terminated, leading to a heap-based out-of-bounds read. In default configurations, the connection is typically terminated before sensitive data can be meaningfully exposed, but unintended memory read or a client crash may still occur.

In FreeRDP before 3.28.0, rdpsnd_server_recv_formats frees context->client_formats on a malformed Client Audio Formats PDU without clearing the pointer or count. An authenticated RDP client can trigger an error, leaving a dangling pointer, leading to a double-free at session teardown. This can crash the server and cause heap corruption.

In FreeRDP before 3.28.0, freerdp_dsp_decode_opus calls Stream_EnsureRemainingCapacity on the context buffer even though opus_decode writes to the caller-supplied stream. A malicious RDP server negotiating WAVE_FORMAT_OPUS can cause large decoded frames to be written beyond the allocated buffer, leading to client heap corruption, crash, and potential code execution.

FreeRDP prior to 3.28.0 has a vulnerability where an authenticated RDP client can advertise DVI ADPCM with nBlockAlign equal to 8 and nChannels equal to 2 to make the `bs` calculation in rdpsnd_server_select_format in channels/rdpsnd/server/rdpsnd_main.c equal zero. The subsequent out_frames modulo `bs` operation raises SIGFPE and terminates the server-side rdpsnd channel process. This vulnerability fixed in 3.28.0.

FreeRDP prior to 3.27.0 has a vulnerability in freerdp_image_copy_from_icon_data in libfreerdp/codec/color.c where nWidth multiplied by nHeight multiplied by FreeRDPGetBytesPerPixel(format) is calculated in 32-bit arithmetic. A malicious RDP server can send a RAIL TS_ICON_INFO update with dimensions such as 32768 by 32768 and 32 bits per pixel so the required-size calculation wraps, bypassing the cbBitsColor source bounds check before freerdp_image_copy_no_overlap reads attacker-controlled icon data. This affects RemoteApp clients using the vulnerable library path, while xfreerdp has a caller-side mitigation. This issue is fixed in version 3.27.0.

FreeRDP prior to 3.27.0 has a vulnerability in the glyph_cache_get function in libfreerdp/cache/glyph.c which checks whether index is greater than cache->number instead of greater than or equal to it. A malicious RDP server can use GLYPH_FRAGMENT_USE replay in update_process_glyph_fragments to make the default cache receive index 254 when cache->number is 254, reading one pointer beyond the entries array and dereferencing it as a glyph. This can crash the client and may disclose adjacent heap data. This issue is fixed in version 3.27.0.

In FreeRDP before 3.27.0, rpc_client_recv_fragment ensures response reassembly stream capacity using only the server-declared alloc_hint rather than the actual StubLength. A malicious TS Gateway can send a response with a small alloc_hint and a much larger frag_length, causing a buffer overflow in the pdu->s buffer. This can crash the client and may permit code execution.

In FreeRDP before 3.27.0, clients using TS Gateway accept a server-controlled max_xmit_frag value without bounding it to the ReceiveFragment allocation. A malicious gateway can advertise 65535 and send a response fragment of that length, causing a buffer overflow in the ReceiveFragment buffer. This can crash the client and may permit code execution.

In FreeRDP before 3.27.0, H.264 decoder backends can return YUV planes sized from the bitstream without comparing to the RDPGFX surface dimensions. A malicious RDP server can provide an AVC420 or AVC444 bitstream with a smaller decoded frame, causing out-of-bounds reads in the decoder. This can disclose client memory or crash the client.

In FreeRDP before 3.27.0, clients negotiating RDPGFX AVC444 calculate the intermediate YUV444 allocation size using 32-bit multiplication in avc444_ensure_buffer. A malicious RDP server can supply surface dimensions causing integer wrap, leading to an undersized buffer allocation. This can cause a client crash and may permit code execution.

FreeRDP, a free implementation of the Remote Desktop Protocol, prior to version 3.30.0 has a vulnerability in the kerberos_DecryptMessage function that fails to bound the peer-controlled GSS Wrap-token EC field before using it with RRC in IOV pointer offsets. A malicious RDP peer can trigger out-of-bounds reads and in-place writes during CredSSP/NLA Kerberos decryption.

FreeRDP prior to version 3.30.0 has a vulnerability in server-side RDSTLS that accepts an attacker-supplied RDSTLS_TYPE_CAPABILITIES PDU while rdstls_server_authenticate is waiting for RDSTLS_TYPE_AUTHREQ. This allows a remote unauthenticated client to bypass RedirectionGuid, username, domain, or password checks.

FreeRDP before 3.29.0 has integer overflows in the audin channel across ALSA, sndio, WinMM, and OpenSL ES backends. A malicious server can supply a FramesPerPacket value causing allocation size wraparound.

FreeRDP versions up to 3.28.0 contain an out-of-bounds read vulnerability in the RDP6 planar RLE bitmap decoder functions planar_decompress_plane_rle and planar_decompress_plane_rle_only in libfreerdp/codec/planar.c. Only the 1-byte control byte is bounds-checked; the subsequent 0–15 attacker-declared raw bytes are read without validating that the source buffer contains them. A malicious or compromised RDP server can send a truncated planar-encoded bitmap or surface update, causing the client to read past the end of the source buffer.

FreeRDP before 3.29.0 contains a null pointer dereference vulnerability in smartcard device control request cleanup when reader-state decoding fails. Attackers can send malformed smartcard IRP requests with non-zero cReaders and truncated reader-state data to crash the process via null pointer access in free_reader_states functions.

FreeRDP before version 3.29.0 contains a reachable assertion (WINPR_ASSERT(OutputBufferLength == BytesReturned)) in serial_process_irp_device_control() in channels/serial/client/serial_main.c. When serial device redirection is enabled and a server-controlled IRP_MJ_DEVICE_CONTROL request specifies an unsupported IOCTL with a non-zero OutputBufferLength, CommDeviceIoControl() can fail with BytesReturned = 0, causing the mismatch to trigger the assertion and abort the client process (denial of service).

FreeRDP before version 3.29.0 (affected versions <= 3.28.0) contains a divide-by-zero vulnerability in the rdpecam camera redirection client. ecam_dev_process_start_streams_request() parses a server-controlled CAM_MEDIA_TYPE_DESCRIPTION from a StartStreamsRequest PDU but validates only Format and Flags, not FrameRateDenominator. When a malicious or compromised RDP server sends a StartStreamsRequest with FrameRateDenominator set to zero, ecam_encoder_context_init() computes FrameRateNumerator / FrameRateDenominator, causing an integer division by zero (SIGFPE) and termination of the FreeRDP client process.

FreeRDP before 3.29.0 contains out-of-bounds read vulnerabilities in the async update message proxy for the PolygonSC and PolygonCB primary drawing orders. When AsyncUpdate is enabled (e.g., xfreerdp /async-update), update_message_PolygonSC() and update_message_PolygonCB() allocate a fresh points array but copy point data from the address of the order structure instead of from polygonSC->points / polygonCB->points, resulting in a client-side out-of-bounds read. A malicious or compromised RDP server sending crafted PolygonSC/PolygonCB update orders can trigger memory disclosure or a client crash.

FreeRDP before 3.29.0 contains client-side heap use-after-free vulnerabilities in the async update message proxy for RAIL WINDOW_STATE_ORDER and NOTIFY_ICON_STATE_ORDER when AsyncUpdate is enabled. When a malicious or compromised RDP server sends crafted update orders, the message proxy shallow-copies structures containing nested parser-owned pointers (e.g., titleInfo.string, windowRects, visibilityRects, icon buffers). The parser frees those nested buffers after the callback returns, so the queued async message later dispatches stale pointers, potentially causing memory corruption or a client crash.

FreeRDP before 3.29.0 contains a client-side heap use-after-free in the async update message proxy for WINDOW_ICON_ORDER when AsyncUpdate is enabled (e.g. xfreerdp /async-update). In update_message_WindowIcon() a shallow CopyMemory() overwrites a freshly allocated lParam->iconInfo with the parser-owned windowIcon->iconInfo pointer. After the parser callback returns, update_recv_window_info_order() frees window_icon.iconInfo, but the queued async message still retains and later dispatches that stale pointer. A malicious or compromised RDP server sending a crafted RAIL Window Alternate Secondary Order with WINDOW_ORDER_ICON can trigger use-after-free, leading to memory corruption and client crash.

FreeRDP versions 3.28.0 and earlier contain a heap buffer overflow in the server-side RAIL channel handler (rail_server_handle_messages() in channels/rail/server/rail_main.c). When processing a RAIL PDU header, the code subtracts RAIL_PDU_HEADER_LENGTH from the peer-controlled orderLength field without first verifying orderLength is at least the header length. For orderLength values 0..3 this causes an unsigned integer underflow to a very large size, which bypasses the Stream_EnsureRemainingCapacity() capacity check (due to pointer arithmetic wraparound) and is then passed to WTSVirtualChannelRead(), resulting in an out-of-bounds heap write. A malicious or compromised RDP client can exploit this to corrupt the heap and crash the server. Fixed in FreeRDP 3.29.0.

FreeRDP before 3.29.0 fails to enforce the RESPONSE_SIZE_LIMIT when processing Transfer-Encoding: chunked HTTP responses in http_response_recv_body(). Attackers controlling a malicious RD Gateway endpoint can send oversized chunked response bodies to exhaust client memory resources without triggering the configured size limit.