Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure FreeRDP client to malicious RDP server
-
DeliveryNegotiate smartcard redirection channel
-
ExploitSend ATR mask with oversized cbAtr
-
ExecutionTrigger out-of-bounds heap read in comparison
-
PersistUse query timing as leak oracle
-
ImpactReconstruct heap layout, defeat ASLR
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 the victim to initiate an RDP session to an attacker-controlled or compromised server (direction is server-attacks-client, matching UI:P), and the client must have smartcard device redirection negotiated so the LocateCardsByATRA handler is reachable to process the malicious LocateCards_ATRMask array. The specific trigger is a LocateCards_ATRMask (or SCARD_READERSTATEA/W) whose cbAtr exceeds the fixed 36-byte rgbAtr/rgbMask buffers, which the pre-patch code did not cap. Limiting factors: no code execution is direct (confidentiality-only leak), the attack needs repeated timing-oracle queries to extract memory, smartcard redirection must be in use, and the user must actively connect - so default clients that never enable smartcard redirection or never connect to hostile servers are not exposed. |
| Impact | This is a client-side out-of-bounds read in FreeRDP's smartcard channel (CVE-2026-109677), where a malicious or compromised RDP server abuses an uncapped cbAtr byte count in smartcard_LocateCardsByATRA_Call to read past the fixed 36-byte rgbAtr/rgbMask arrays and leak heap memory bit-by-bit via a query-timing oracle. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:P/VC:H/VI:N/VA:N) for 7.1 is directionally consistent with the description: network reach, low complexity, no attacker-side privileges, but passive user interaction is required (the victim must initiate a connection to the attacker's server) and impact is confidentiality-only. No EPSS score, KEV listing, or public POC was supplied; exploitation status is therefore 'no public exploit identified at time of analysis' and there is no evidence of active exploitation. The realistic risk is a sophisticated information-disclosure primitive that defeats ASLR to enable follow-on RCE - serious as a building block, but it is reversed-direction (server attacks client), needs the smartcard redirection channel to be reachable, and depends on the victim connecting to a hostile server, so it is a lower operational priority than an unauthenticated server-side RCE despite the memory-disclosure severity. Confidentiality impact rated high reflects a controllable, repeatable heap-read oracle rather than a one-shot leak. |
| Exploit ScenarioDerived | An attacker stands up or compromises an RDP server and lures a FreeRDP-based client (with smartcard redirection active) into connecting to it. The malicious server returns crafted LocateCards_ATRMask structures with an oversized cbAtr, then uses the timing of ATR mask comparison queries as an oracle to read adjacent heap memory bit-by-bit, recovering pointers to defeat ASLR and chain toward remote code execution. No public exploit code was identified in the provided data, though the vendor commit ships a unit test that reproduces the over-range cbAtr condition. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 13, 2026
An out-of-bounds read in FreeRDP's smartcard redirection channel (CVE-2026-109677) lets a malicious or compromised RDP server leak heap memory from the connecting client by sending a LocateCardsByATRA request whose cbAtr byte count exceeds the fixed 36-byte rgbAtr/rgbMask buffers. Affected versions are 2.0.0-beta1 through 3.27.x (fixed in 3.28.0), and per the independent assessment the impact is confidentiality-only: the client must initiate the RDP session to the hostile server and must have smartcard device redirection negotiated so the LocateCardsByATRA handler is reachable. Repeated timing-oracle queries can extract memory bit-by-bit to defeat ASLR as a precursor to remote code execution, but no code execution occurs directly; no public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis.
RemediationAI
Vendor-released patch: upgrade FreeRDP to 3.28.0 or later, which caps cbAtr at the 36-byte rgbAtr/rgbMask array size; the fix is implemented in commit ececc5cbd0646ef012ca178322e6ef922a11f0c1 and described in advisory GHSA-8m97-wwx3-r8vj. Distributors maintaining older branches should backport the validation added to smartcard_ndr_read_atrmask and to the smartcard_unpack_reader_state_a and smartcard_unpack_reader_state_w paths, which now reject any entry whose cbAtr exceeds ARRAYSIZE(rgbAtr) with STATUS_DATA_ERROR; the accompanying TestSmartcardPack.c asserts that cbAtr values of 0 and 36 are accepted while 37 and 0xFFFFFFFF are rejected. If immediate upgrading is not possible, the most effective compensating control is to disable smartcard device redirection on the client (do not enable the smartcard channel), which makes the LocateCardsByATRA handler unreachable - the trade-off is loss of smartcard-based authentication, so environments that depend on it must instead prioritize the patch. Additional practical mitigations include restricting users from connecting RDP clients to untrusted or unverified servers (this attack is client-side and requires the user to initiate the session), and monitoring for repeated or malformed smartcard-channel requests exhibiting anomalous query timing. Note that because the flaw is a confidentiality-only heap leak used to defeat ASLR, patching removes the intelligence-gathering primitive that would otherwise precede a separate memory-corruption exploit, so remediation should be treated as time-sensitive even though no public exploit or KEV-listed active exploitation was identified at time of analysis.
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 Microsoft Remote Desktop Protocol, and this flaw lives in the smartcard device-redirection channel, which marshals SCARD_* calls using NDR encoding as specified in MS-RDPESC. The vulnerable handler, smartcard_LocateCardsByATRA_Call, unpacks a LocateCards_ATRMask structure consisting of a 32-bit cbAtr count plus two fixed-size arrays, rgbAtr[36] and rgbMask[36]. MS-RDPESC section 2.2.1.5 constrains cbAtr to the range 0..36, but the pre-patch code trusted the wire value and never validated it, so a byte-by-byte mask comparison could walk past the end of the fixed arrays (CWE-125, out-of-bounds read). The same missing cap existed in the SCARD_READERSTATEA and SCARD_READERSTATEW unpacking paths, which the upstream fix also hardens. Because the leaked data is only observable indirectly through how long matching queries take, the bug functions as a query-timing oracle that can disclose adjacent heap contents incrementally - a classic ASLR-bypass primitive rather than a direct memory-corruption bug. The CPE string cpe:2.3:a:freerdp:freerdp:*:*:*:*:*:*:*:* covers the FreeRDP product family, matching releases from 2.0.0-beta1 up to but not including 3.28.0.
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
Malicious server attacks a connecting client so UI:R and PR:N; low complexity oracle yields a controllable heap-memory read (C:H) with no integrity or availability impact.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
FreeRDP from 2.0.0-beta1 before 3.28.0 contains an out-of-bounds read vulnerability in smartcard_LocateCardsByATRA_Call because the ATR pattern cbAtr byte count is not capped. Malicious RDP servers can send crafted ATR mask arrays to use query timing as an oracle, leaking heap memory bit-by-bit to defeat ASLR and aid RCE exploits.
Technical POC Analysis
Bug class: CWE-125 out-of-bounds read (the advisory also tags CWE-20 improper input validation).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
FreeRDP client versions 2.0.0-beta1 through 3.27.x contain a high-severity memory disclosure issue affecting organizations that use smartcard redirection to connect to untrusted or compromised RDP servers. A successful attack can expose client process memory, potentially revealing sensitive data and weakening defenses such as ASLR, though no public exploit identified at time of analysis and no code execution occurs directly. Leadership should prioritize upgrading to the vendor-released patch: 3.28.0 and limiting FreeRDP connections to trusted RDP endpoints.
Apply vendor patch.
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-98699
GHSA-fwx5-6r67-r722
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB