Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure victim to malicious RDP server
-
DeliveryDeliver crafted low-bit-depth PNG clipboard payload
-
ExploitVictim pastes, triggering CF_DIB synthesis
-
ExecutionOut-of-bounds read past bit-packed buffer
-
ImpactHeap memory disclosed to attacker server
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK
1 technique across 1 tactic: Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires (1) the victim's FreeRDP/WinPR-based client to connect to an attacker-controlled or compromised RDP server, (2) the clipboard redirection (CLIPRDR) channel to be active so the server can push clipboard formats, and (3) the victim to actually paste the attacker-supplied clipboard content, which triggers the PNG-to-CF_DIB conversion. The specific trigger is a crafted PNG with bit depth below 8 bits/pixel, where winpr_read_png_from_buffer() allocates a bit-packed buffer but winpr_bitmap_write_buffer() copies rows at one byte per pixel, reading out of bounds. Limiting factors: this is a client-side flaw (attacker must control the server, not a listening service), it needs user interaction (the paste), and impact is limited to heap memory disclosure (no code execution). Affected: FreeRDP before 3.32.1. |
| Impact | This is a client-side heap out-of-bounds read (CWE-125) with information-disclosure impact only. The vendor-supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:P/VC:H/VI:N/VA:N) scores 7.1 and correctly captures the key tension: the attack is network-reachable and requires no attacker authentication, but it is NOT a drive-by remote exploit - the UI:P (passive user interaction) flag reflects that the victim must both connect to an attacker-controlled RDP server AND actively paste the malicious clipboard content before the leak triggers. Impact is confidentiality-only (VC:H, VI:N/VA:N) - up to megabytes of heap memory disclosed, with no code execution or integrity/availability effect, so the 'Buffer Overflow' tag overstates it; this is a read primitive, not a write/overflow. No EPSS score, CISA KEV entry, or public POC is present in the provided data, so there is no public exploit identified at time of analysis and no evidence of active exploitation. Net assessment: a legitimate but moderate-priority issue - meaningful because it enables memory disclosure (potentially leaking secrets/credentials from client heap) against widely-used RDP client software, but materially constrained by the requirement to lure a victim onto a hostile server and have them paste. Prioritize patching for environments where users connect out to untrusted or third-party RDP endpoints; lower urgency where clients only reach trusted internal servers. |
| Exploit ScenarioDerived | An attacker operates or compromises an RDP server and lures a victim into connecting to it (e.g., a malicious remote-support session or a spoofed corporate gateway). The server sends a crafted low-bit-depth (<8bpp) PNG clipboard payload; when the victim copies/pastes clipboard data during the session, WinPR's PNG-to-CF_DIB synthesis reads past the under-allocated bit-packed buffer and returns megabytes of adjacent client heap memory to the attacker-controlled server. No public exploit code is identified at time of analysis, but the bug is well-specified in the FreeRDP advisory. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Heap-based out-of-bounds read in FreeRDP before 3.32.1 allows an attacker-controlled RDP server to disclose heap memory when a victim pastes a crafted low-bit-depth PNG clipboard payload. The client-side flaw occurs in WinPR's PNG-to-CF_DIB conversion, where a bit-packed buffer is allocated for sub-8-bit PNGs but rows are copied as one byte per pixel, and exploitation requires clipboard redirection plus user paste interaction. Impact is information disclosure only; no public exploit code or confirmed active exploitation was identified at time of analysis.
RemediationAI
Vendor-released patch: upgrade FreeRDP to 3.32.1 or later; see https://github.com/FreeRDP/FreeRDP/security/advisories/GHSA-f3vg-h45x-6wgf and https://www.vulncheck.com/advisories/vulnerability-in-freerdp. If upgrading immediately is not possible, disable clipboard redirection (the CLIPRDR channel) in the FreeRDP client or via RDP policy, accepting the loss of copy/paste between local and remote sessions, and restrict client connections to trusted RDP servers. These are compensating controls only; they do not fix the underlying out-of-bounds read, and connecting to untrusted servers while clipboard redirection remains enabled leaves the disclosure trigger reachable.
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 is an open-source Remote Desktop Protocol implementation, and WinPR provides its Windows Portable Runtime compatibility layer. The clipboard redirection channel (CLIPRDR) lets an RDP server advertise clipboard formats to the client. In affected versions, winpr_read_png_from_buffer() processes a PNG with bit depth below 8 by allocating a bit-packed output buffer, while winpr_bitmap_write_buffer() later copies scanlines assuming one byte per pixel. This mismatch causes out-of-bounds row reads during PNG-to-CF_DIB synthesis, classified as CWE-125 (out-of-bounds read). The CPE cpe:2.3:a:freerdp:freerdp:*:*:*:*:*:*:*:* represents FreeRDP releases before the 3.32.1 fix. The primitive leaks heap contents but does not provide write capability or code execution.
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:H/VI:N/VA:N/SC:N/SI:N/SA:N
Network-reachable malicious server, no attacker auth (PR:N), but victim must paste (UI:R); confidentiality-only heap disclosure so C:H, I:N, A:N, scope unchanged.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
FreeRDP before 3.32.1 contains a heap-based out-of-bounds read in WinPR's clipboard PNG-to-CF_DIB synthesis because winpr_read_png_from_buffer() allocates a bit-packed buffer for PNGs with bit depth below 8, while winpr_bitmap_write_buffer() copies rows assuming one byte per pixel. A malicious RDP server can send a crafted low-bit-depth PNG clipboard payload that, when pasted by the victim, discloses megabytes of heap memory.
Technical POC Analysis
CWE-125 (Out-of-bounds Read).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
FreeRDP before 3.32.1 carries a high-severity heap-based out-of-bounds read that can disclose client-side heap memory to a malicious RDP server when a user pastes a crafted low-bit-depth PNG clipboard payload. The flaw requires clipboard redirection plus user paste interaction, and no public exploit identified at time of analysis. Leadership should care because affected endpoints could leak sensitive data from memory, though the attack preconditions limit practical exposure.
No vendor-released patch identified at time of analysis. Disable RDP clipboard redirection, restrict RDP client connections to trusted servers, block untrusted RDP endpoints, and train users not to paste clipboard content from untrusted remote sessions.
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
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Related Vulnerabilities in FreeRDP Memory Safety and Certificate Vulnerabilities
View all 7Use-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-106994
GHSA-wfxj-44r2-v2c3
NVD
CVE.org
EPSS
Exploit-DB