Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure victim to malicious RDP server
-
DeliveryVictim client opens redirected serial device
-
ExploitServer sends IRP_MJ_DEVICE_CONTROL with IOCTL_USBPRINT_GET_1284_ID and near-max OutputBufferLength
-
ExecutionClient calloc + stream grow uses uncapped BytesReturned
-
ImpactClient memory exhausted (~4 GiB)
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation limits
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires a non-default redirection setup on the FreeRDP client: serial device redirection (RDPDR serial channel) must be enabled AND a redirected serial device must be successfully opened (a prior successful IRP_MJ_CREATE is a stated prerequisite). The victim must also initiate a connection to an attacker-controlled RDP server (UI:P / user-initiated session), so this cannot be triggered against a client that does not connect out or does not expose serial redirection. The trigger is a server-sent serial IRP_MJ_DEVICE_CONTROL carrying IOCTL_USBPRINT_GET_1284_ID with a near-maximum 32-bit OutputBufferLength (e.g. 0xFFFFFF00/0xFFFFFFFF). Limiting factors: no authentication to the client is needed but the attacker must control the server the victim connects to; impact is availability-only; the vendor observed that the maximal case exceeded the UINT32_MAX send guard and was not transmitted, and that tight process virtual-address limits yield clean STATUS_NO_MEMORY handling rather than exhaustion. Affected versions are FreeRDP <= 3.32.1; updating to 3.32.2 is the fix. |
| Impact | This is a medium-severity, availability-only denial-of-service flaw (CWE-770 uncapped allocation) and the signals are internally consistent rather than conflicting. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:P/VA:L, score 5.3) describes a network-reachable but victim-initiated issue with no confidentiality or integrity impact and only limited availability impact - matching the GHSA description. No EPSS score and no CISA KEV entry are provided, and the vuln.today decision label is 'this_month' (not act_now/emergency), so there is no indication of active exploitation. The practical risk is bounded by preconditions and by the vendor's own measurements: exploitation requires the victim client to connect to an attacker-controlled server AND have serial device redirection enabled, and the advisory notes that the largest tested allocation (0xFFFFFFFF → ~4.01 GiB) produced a stream position beyond the production UINT32_MAX send guard and was not transmitted, while a near-maximum sendable case (0xFFFFFF00) was not observed to transmit over the network either. Net: a genuine resource-exhaustion bug worth patching on a normal cycle, not a high-CVSS/low-real-risk mislabel, but also not an emergency - the real-world outcome (full client memory exhaustion vs. a clean STATUS_NO_MEMORY) depends on the client's process memory limits, as the vendor itself demonstrated. |
| Exploit ScenarioDerived | A user is lured into connecting their FreeRDP-based client (with serial port redirection enabled and a serial device opened) to an RDP server the attacker controls. The malicious server replies to the redirected serial channel with an IRP_MJ_DEVICE_CONTROL request using IOCTL_USBPRINT_GET_1284_ID and a near-maximum 32-bit OutputBufferLength, causing the client to allocate and fill multiple gigabytes of memory (~4 GiB measured) and potentially exhaust client memory. A public PoC reference exists in the GHSA advisory as a reproduction harness, but it is not verified as working remote exploit code - the vendor's own tests did not observe network transmission of the oversized response. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 03, 2026
FreeRDP clients up to and including 3.32.1 can be driven into excessive memory allocation by a malicious RDP server when serial device redirection is enabled, because the serial channel fails to cap the server-supplied OutputBufferLength carried in an IRP_MJ_DEVICE_CONTROL request before allocating and echoing it back. Only availability is affected: the vendor measured roughly 4.01 GiB peak RSS and about 3.8 seconds of handler time from a single IOCTL_USBPRINT_GET_1284_ID request, with no confidentiality or integrity impact observed. Exploitation requires the victim to connect out to an attacker-controlled server and to have serial redirection configured with a redirected device successfully opened; no public exploit is identified beyond the reproduction harness published in the vendor advisory, and there is no CISA KEV confirmation of active exploitation.
RemediationAI
Update FreeRDP to 3.32.2 or later, which is the version the project ships as the fix for this issue (package data: vulnerable <= 3.32.1, fixed in 3.32.2); the details and the vendor's guidance are in https://github.com/FreeRDP/FreeRDP/security/advisories/GHSA-r387-jjq3-87hv, with the third-party write-up at https://www.vulncheck.com/advisories/freerdp-before-3.32.2-memory-exhaustion-via-serial-rdpdr-device-control. Where upgrading cannot be done immediately, the practical compensating control is to stop exercising the vulnerable path: do not enable serial device redirection on the client and do not attach redirected serial devices for sessions to hosts you do not fully trust, accepting that this removes serial redirection functionality for all sessions, not only untrusted ones. Because a successful IRP_MJ_CREATE against an open redirected serial device is a stated prerequisite, keeping serial redirection off also removes the preconditions the advisory identifies. Running the client under an enforced process memory limit turns the pathological request into a clean STATUS_NO_MEMORY instead of host memory pressure, at the cost of possibly terminating or degrading legitimate memory-heavy sessions. The vendor's test noted that the maximal length exceeded the UINT32_MAX send guard, but that is an observed artefact of the specific case, not a mitigation to rely on. Given the 'this_month' priority label rather than an act-now emergency, schedule the 3.32.2 upgrade in the current monthly patch cycle.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
FreeRDP implements the RDPDR (device redirection) protocol, where a server issues IRPs to the client for redirected devices; the serial client lives in channels/serial/client/serial_main.c and services device-control IRPs through serial_process_irp_device_control(). That function reads the wire-supplied OutputBufferLength and passes it to calloc without any upper bound, mapping to CWE-770 (allocation of resources without limits or throttling) and, per the advisory, also CWE-20 (improper input validation). The companion WinPR layer, CommDeviceIoControl() in winpr/libwinpr/comm/comm_ioctl.c, does not support the USBPRINT 1284-ID IOCTL: it returns FALSE but still sets *lpBytesReturned to the full requested nOutBufferSize. The serial completion path then trusts BytesReturned to grow and fill its response stream, so the attacker-controlled length is turned into a multi-gigabyte allocation plus a matching write. The vendor's harness measured about 4.01 GiB committed RSS and ~3.8 seconds in the handler for OutputBufferLength=0xFFFFFFFF. Practical limits matter: a successful IRP_MJ_CREATE and an actually open redirected serial device are prerequisites, a supported baud-rate IOCTL returned only four bytes and kept RSS near 7.5 MiB regardless of the large requested length, a tight process virtual-address limit produced a clean STATUS_NO_MEMORY, the maximal 0xFFFFFFFF case pushed the stream position past the production UINT32_MAX send guard so it was not transmitted, and the 0xFFFFFF00 case committed similarly while network transmission was not observed. Concurrent amplification and OOM-killer behaviour were not executed.
Know when Freerdp gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:P/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
Malicious server reaches the client over the network (AV:N/AC:L) with no client-side auth (PR:N) but the victim must connect out with serial redirection enabled (UI:R); impact is partial availability only (A:L).
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
FreeRDP before 3.32.2 fails to cap the OutputBufferLength in serial device-control IRP requests, allowing malicious servers to trigger excessive memory allocation. Attackers running a server with serial redirection can send an IRP_MJ_DEVICE_CONTROL request with IOCTL_USBPRINT_GET_1284_ID and a near-maximum length to exhaust client memory.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Use-after-free in FreeRDP xf_clipboard_format_equal before 3.23.0. Clipboard format comparison uses freed memory. Fifth
Use-after-free in FreeRDP xf_AppUpdateWindowFromSurface before 3.23.0. Surface-to-window update triggers memory corrupti
Use-after-free in FreeRDP xf_SetWindowMinMaxInfo before version 3.23.0. X11 client window management triggers memory cor
Use-after-free in FreeRDP xf_cliprdr_provide_data clipboard handling before 3.23.0. Clipboard data exchange triggers mem
FreeRDP IRP thread handler has a use-after-free where the IRP is freed by Complete() then accessed on the error path. Fi
FreeRDP drive read heap overflow when server-controlled read length exceeds IRP output buffer. Fixed in 3.20.1. PoC avai
FreeRDP client before 3.20.1 has a heap buffer overflow in AUDIN format processing. A malicious RDP server can corrupt m
Use-after-free in FreeRDP xf_AppUpdateWindowFromSurface before 3.23.0. Different code path from CVE-2026-25953. PoC and
FreeRDP is a free implementation of the Remote Desktop Protocol. Rated critical severity (CVSS 9.8), this vulnerability
FreeRDP is a free implementation of the Remote Desktop Protocol (RDP), released under the Apache license. Rated critical
FreeRDP is a free implementation of the Remote Desktop Protocol (RDP), released under the Apache license. Rated critical
FreeRDP is a free implementation of the Remote Desktop Protocol (RDP), released under the Apache license. Rated critical
EUVD-2026-115937
GHSA-f3vp-w46f-jr9h
NVD
CVE.org
Vulnrichment
Exploit-DB