FreeRDP Memory Safety and Resource Exhaustion Flaws

Heap out-of-bounds write in FreeRDP's Apple audio-input (audin) backends affects macOS and iOS clients running versions 3.29.0 through 3.31.x, where a malicious or compromised RDP server can send an audin Open PDU with FramesPerPacket set to 2^30 to wrap a UINT32 buffer-size calculation and corrupt the heap. The vulnerable server interaction is unauthenticated from the RDP perspective (CVSS PR:N), but exploitation depends on the victim actively initiating an RDP session in which audio-input redirection is negotiated, so there is no drive-by or server-side vector and only Apple builds using audin_mac.m or audin_ios.m are exposed. No public exploit code has been identified at time of analysis, and there is no confirmation of active exploitation (CISA KEV).

Heap out-of-bounds write in FreeRDP before 3.32.0 allows a malicious RDP server to corrupt a connecting client's memory by sending crafted RDPGFX AVC444 or AVC444v2 frames, potentially enabling code execution through heap corruption. The flaw is in general_LumaToYUV444 and general_ChromaV2ToYUV444 and triggers when an odd-height region rectangle ends exactly at the surface height, causing writes past the U/V planes. Exploitation requires the victim's client to initiate or accept an RDP session with an attacker-controlled or compromised server and negotiate the affected H.264 YUV444 codec; no public exploit identified at time of analysis, and clients limited to trusted RDP hosts face substantially lower realistic risk.

Unauthenticated memory exhaustion in the FreeRDP server-side component (3.0.0 through 3.31.x) allows a remote attacker to drive the process toward out-of-memory failure by completing a TLS handshake and then streaming bytes that do not begin with the DER SEQUENCE tag 0x30, which causes parse_nla_mode_pdu to grow the receive buffer without bound before NLA authentication ever completes. No credentials, user interaction, or non-default feature flag are required, but the attack surface is limited to hosts running a FreeRDP-based server with TLS reachable on its listening port; the far more common client role is not affected. Impact is availability-only (no code execution, no data disclosure), and no public exploit code or confirmed active exploitation has been identified at time of analysis.

Memory exhaustion in FreeRDP 2.0.0 through 3.31.x lets an authenticated RDP client degrade or crash a server that exposes FreeRDP's listener role: the attacker opens a static virtual channel message and then streams endless channel-data fragments while withholding the CHANNEL_FLAG_LAST terminator, so the server-side reassembly buffer grows without bound. The issue is scored 7.1 under CVSS 4.0 and independently assessed as CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H, meaning availability-only impact with no confidentiality or integrity loss. Exploitation is not confirmed in the wild (no CISA KEV listing) and no public exploit identified at time of analysis; the practical exposure is narrowed because the vulnerable code path is server-side and the attacker must already hold an authenticated RDP session.

Heap buffer overflow in FreeRDP before 3.32.0 can let a local attacker corrupt heap memory and potentially execute code when the victim loads a crafted persistent bitmap cache v2 file, because persistent_cache_read_entry_v2 miscalculates bitmap sizes via integer wraparound and then performs fixed 16 KiB reads against mismatched entry-size accounting. Exploitation requires the local attacker to place a malicious cache file in the client's load path and relies on low-level local privileges plus user interaction (PR:L/UI:P), so there is no remote unauthenticated path; no public exploit identified at time of analysis. No CISA KEV entry was provided, making this a moderate-priority local risk rather than a mass-exploitation threat.

Heap buffer overflow in FreeRDP before 3.32.0 allows a local attacker with low privileges to corrupt memory and potentially execute code by supplying a crafted v3 persistent bitmap cache file. The vulnerability is triggered when the FreeRDP client processes a malicious cache file with crafted width and height values, causing an integer overflow in size calculation and a subsequent heap overflow via fread. Exploitation requires the victim to load the poisoned cache during a session (passive user interaction); no public exploit code has been identified at time of analysis.

Denial of service in FreeRDP clients before 3.32.0: a NULL pointer dereference in the websocket transport lets a malicious or man-in-the-middle gateway crash the client by sending a zero-length websocket ping frame. Affected are all FreeRDP builds prior to 3.32.0 that connect through the websocket gateway transport; the attacker must occupy the gateway position rather than being an arbitrary remote host, and the outcome is limited to terminating the client process with no code execution, privilege gain, or data disclosure. No public exploit code has been identified at time of analysis and there is no confirmed active exploitation, though the low attack complexity and lack of authentication or user interaction keep the practical bar for abuse low for anyone controlling the gateway path.

An out-of-bounds read (heap over-read) in the FreeRDP Windows RAIL client (wfreerdp) versions 3.0.0 through 3.31.x can be triggered by a malicious or compromised RDP server that sends a full-length WINDOW_ORDER_FIELD_TITLE window-title update lacking NUL termination, a value that wf_rail_window_common passes directly to SetWindowTextW. This reverse (server-to-client) attack requires the victim to initiate a connection to the attacker-controlled server with RemoteApp/RAIL in use; impact is limited to window-title corruption, disclosure of adjacent heap memory, and client crashes, with no code execution or integrity impact assessed (CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:L/I:N/A:L). No public exploit code or confirmed active exploitation was identified at time of analysis.

Resource exhaustion in FreeRDP's rdpecam camera-redirection channel affects client builds from 3.30.0 up to (but not including) 3.32.0, where a malicious or compromised RDP server can send a StartStreamsRequest for an unadvertised camera media type with oversized dimensions, forcing large pending-sample allocations and reconfiguring the local camera through the HAL. Impact is availability-only (client memory exhaustion leading to hang or crash) with no code execution or data disclosure, and exploitation requires the victim to have camera redirection enabled and to intentionally connect to an untrusted server. Independent assessment rates this a moderate-severity denial-of-service issue rather than a top-tier priority, with high attack complexity; no public exploit identified at time of analysis.

Heap out-of-bounds read in the FreeRDP Windows client (versions 3.30.0 up to but not including 3.32.0) lets a malicious or compromised RDP server feed a malformed clipboard file-transfer reply that the client misinterprets, crashing the client or corrupting an internal stream-size value. The attack is only reachable when a user connects to the hostile server and then actively pastes a remote file, so the attacker must control the server side and the victim must perform the triggering UI action; there is no public exploit identified at time of analysis and no confirmed active exploitation (CISA KEV). Scoring is low by every available signal - CVSS 4.0 base 2.3 and an independently assessed CVSS 3.1 vector of AV:N/AC:H/PR:N/UI:R/S:U/C:L/I:L/A:L - so this should not be treated as a priority patch under normal circumstances.