Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure client to malicious RDP server
-
DeliveryOffer 16 bpp CF_DIB BI_BITFIELDS clipboard data
-
ExploitLocal app requests clipboard as image/png
-
ExecutionTrigger heap over-read in save_png_to_buffer
-
ImpactEmbed adjacent client heap bytes into PNG, leaking memory
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 a victim FreeRDP client at version 3.32.1 or earlier, built with WINPR_UTILS_IMAGE_PNG, that connects to an attacker-controlled or compromised RDP server with clipboard redirection active. The server must offer a CF_DIB clipboard format carrying a 16 bpp BI_BITFIELDS DIB, and a local application on the client side must request that clipboard content as image/png (the clipboard_synthesize_image_bmp_to_png path exercised by the SDL3 client and any client converting CF_DIB to image/png via ClipboardGetData). Limiting factors: the attacker does not control the client directly but must induce the connection (passive user interaction, UI:P), clipboard redirection and the specific PNG conversion must occur, builds without WINPR_UTILS_IMAGE_PNG are unaffected, and only a limited amount of adjacent heap memory is leaked into the clipboard image rather than full memory read or code execution. |
| Impact | This is a moderate, not urgent, issue. The input CVSS is 5.3 (CVSS 4.0: AV:N/AC:L/AT:N/PR:N/UI:P with only VC:L, all other impacts N), reflecting a limited client-side memory disclosure rather than code execution. The vuln.today decision label is 'this_month' (not act_now/emergency), and there is no CISA KEV listing, so there is no confirmed active exploitation. No EPSS score was provided in the input, so probabilistic exploitation likelihood cannot be stated. The attack model is a 'reverse RDP' one: the victim's FreeRDP client must connect to a malicious or compromised RDP server (AV:N), and exploitation additionally depends on passive user interaction (UI:P) plus clipboard redirection and a local application requesting the clipboard as image/png - the SDL3 client path verified in the advisory. The impact is confined to leaking limited client heap bytes into a clipboard PNG (VC:L), with no integrity or availability impact for this specific over-read. Net: a real, confirmed bug worth patching on a normal cycle, but the preconditions (attacker-controlled server, specific clipboard conversion path, limited info leak) keep real-world risk well below what a raw network/unauthenticated label might suggest. Note the advisory bundles two additional process-abort/exit (DoS) defects in the same file, but the CVSS vector supplied here scores only the information-disclosure over-read (VA:N). |
| Exploit ScenarioDerived | An attacker who operates or has compromised an RDP server lures a victim running a vulnerable FreeRDP-based client (e.g. the SDL3 client with clipboard redirection, versions <= 3.32.1). The server offers a 16 bpp BI_BITFIELDS CF_DIB clipboard image; when a local application asks the client for the clipboard as image/png, save_png_to_buffer reads 3 bytes per pixel from rows that hold only 2, embedding adjacent client heap bytes into the resulting PNG and disclosing client memory. A public PoC reproduction harness (ct.c) exists in the vendor advisory; it is not verified as working weaponized exploit code. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 03, 2026
Heap buffer over-read in FreeRDP's winpr PNG encoder (save_png_to_buffer) allows a malicious or compromised RDP server to embed a limited amount of client heap memory into a clipboard image and disclose it to a local application. FreeRDP 3.x through 3.32.1 built with WINPR_UTILS_IMAGE_PNG and clipboard redirection enabled is affected when the server offers a 16 bpp BI_BITFIELDS CF_DIB and a local application requests that clipboard content as image/png. The impact is limited to low confidentiality, with no integrity or availability effect and no code execution; no active exploitation or confirmed public exploit code is identified, although the vendor advisory includes a public reproduction harness that triggers the over-read under ASan.
RemediationAI
Upgrade to FreeRDP 3.32.2, which contains the vendor-released fix that restricts save_png_to_buffer to 24 and 32 bpp and rejects other depths. If upgrading is not immediately possible, disable clipboard redirection in the client, accepting that clipboard text, file, and image sharing with the RDP session will stop working, or avoid connecting to untrusted RDP servers; building without WINPR_UTILS_IMAGE_PNG removes this encoder path but also disables PNG clipboard image conversion. The vendor advisory at https://github.com/FreeRDP/FreeRDP/security/advisories/GHSA-x7w3-32ch-x2jq and the VulnCheck advisory at https://www.vulncheck.com/advisories/freerdp-before-3.32.2-heap-over-read-via-winpr-save-png-to-buffer provide the fix and reproduction details; no additional vendor workaround beyond updating is described in the available sources.
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
The flaw is a CWE-125 out-of-bounds read in winpr/libwinpr/utils/image.c. save_png_to_buffer() selects PNG_COLOR_TYPE_RGB for any bit depth above 8, so a 16 bpp DIB row is allocated with a stride of 2 bytes per pixel while libpng's png_write_row reads 3 bytes per pixel. Each row write therefore reads past the end of the row allocation, and the adjacent heap bytes are encoded into the PNG handed to the local clipboard. Reachability for this CVE is through the winpr clipboard synthesizers used for clipboard redirection: clipboard_synthesize_image_bmp_to_png -> winpr_image_write_buffer -> save_png_to_buffer, which requires a build with WINPR_UTILS_IMAGE_PNG. The advisory also describes two related robustness defects in the same file (a missing setjmp handler causing abort on malformed PNG input, and libjpeg's default error_exit causing process exit on malformed JPEG input); those are separate from the heap over-read tracked here.
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:L/VI:N/VA:N/SC:N/SI:N/SA:N
Malicious server over the network (AV:N) with no client auth (PR:N) but requires the victim to connect and a local PNG conversion (UI:R); only limited heap bytes leak (C:L, I:N, A:N).
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
1DescriptionCVE.org
FreeRDP before 3.32.2 contains a heap buffer over-read vulnerability in save_png_to_buffer() that allows malicious RDP servers to leak client memory by sending 16 bpp DIB clipboard data. Attackers can offer a CF_DIB BI_BITFIELDS image that, when converted to PNG for a local application, embeds client heap bytes into the clipboard image.
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.
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-115929
GHSA-4v6v-rqm8-m7cj
NVD
CVE.org
Vulnrichment
Exploit-DB