Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessRun local process on victim Windows host
-
DeliveryImpersonate Pageant window/shared memory
-
ExploitReturn oversized u32 response length
-
ExecutionMemoryMap::read copies past mapped view
-
ImpactCrash russh client, conditionally leak adjacent 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 | Requires a local, co-located process on the same Windows host as the victim, and the victim must be running a russh-based SSH client that queries a Pageant agent via AgentClient::connect_pageant / query_pageant_direct (pageant crate before 0.2.3 / russh before v0.63.2). The attacker must impersonate the Pageant window to control the u32 response length written into the 8192-byte shared-memory mapping. Limiting factors: exploitation is local-only (no remote reach), depends on the client actually initiating a Pageant query, and requires winning the window-impersonation against the real Pageant; the memory-disclosure outcome is only conditional whereas the client crash is reliable. |
| Impact | This is a genuine but moderate-severity local availability issue, correctly scored around CVSS 6.2. The vendor vector CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H is internally consistent with the description: exploitation requires a LOCAL attacker process (AV:L), the impact is a reliable crash of the russh client (A:H), and the vector lists no confidentiality impact (C:N) even though the description notes a CONDITIONAL adjacent-memory disclosure - so an argument exists for C:L, a point where the vector slightly understates the read primitive. No EPSS score, KEV listing, or public POC was supplied, so exploitation status is: no public exploit identified at time of analysis. There is no signal conflict on attack vector (both the vector and description agree this is local-only, requiring a co-located process able to impersonate the Pageant window). The realistic priority is MEDIUM: it is a local DoS with conditional info-leak against a specific Rust SSH client configuration on Windows, not a remotely-reachable critical flaw. The presence of a clear upstream fix and confirming source diff raises confidence in the technical claim while the local-only vector and absence of exploitation evidence cap the urgency. |
| Exploit ScenarioDerived | A malicious unprivileged process running on the same Windows host creates a window impersonating Pageant, then when a victim russh-based SSH client calls query_pageant_direct it returns a crafted u32 length (up to ~4 GiB) through the 8192-byte shared-memory mapping. MemoryMap::read trusts that length and copies beyond the mapped view, reliably crashing the SSH client and conditionally leaking adjacent committed process memory. No public exploit code was identified at time of analysis; exploitation is local-only and requires winning the Pageant-window impersonation. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 29, 2026
The Windows Pageant client inside the pageant Rust crate (pageant/src/wmmessage.rs) trusts a peer-controlled u32 response length read from the 8192-byte Pageant shared-memory mapping, so a local process that impersonates the Pageant window can drive MemoryMap::read to allocate up to roughly 4 GiB and copy past the end of the mapped view. In practice this reliably crashes a russh-based SSH client that queries the agent via AgentClient::connect_pageant, and can conditionally expose adjacent committed memory. The issue is fixed in pageant 0.2.3 (russh v0.63.2); exploitation is local-only (CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 6.2), with no CISA KEV entry and no public exploit identified at time of analysis.
RemediationAI
Upgrade the pageant crate to 0.2.3 or later and, for russh users, move to v0.63.2 or later, which vendors the bounds-checked MemoryMap::read implementation (vendor advisory https://github.com/Eugeny/russh/security/advisories/GHSA-g4mp-vgx3-xrvm, fix commit https://github.com/Eugeny/russh/commit/5d566989ebabfdebfe6b33243d31765a0812260b, release https://github.com/Eugeny/russh/releases/tag/v0.63.2). Because the flaw requires a local process on the same Windows host to impersonate the Pageant window before the client initiates its agent query, prioritise hosts that run other untrusted or lower-integrity local code alongside a russh-based SSH client. If the upgrade cannot be applied immediately, mitigations include avoiding the Pageant agent query path entirely by authenticating with explicit key files or a different agent (e.g. the OpenSSH named-pipe agent), which removes the shared-memory/window-message surface at the cost of losing Pageant-backed single-sign-on, or confining the SSH client to a session where unprivileged co-resident processes cannot create a competing pageant window, which is operationally restrictive but eliminates the impersonation precondition. Note that the reliable outcome is a client crash (denial of service); the adjacent-memory disclosure is only conditional and was not reproduced as a guaranteed primitive.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in cargo, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Pageant is the SSH authentication agent shipped with PuTTY on Windows, and the pageant crate (part of the russh ecosystem, repository Eugeny/russh) provides a PageantStream type implementing AsyncRead/AsyncWrite so Rust SSH clients can speak to a running Pageant instance. The Windows transport uses window messages plus a fixed 8192-byte shared-memory section: the client requests data and the agent responds with a u32 length followed by the payload. The vulnerable MemoryMap::read function at pageant/src/wmmessage.rs used that peer-supplied length without validating it against the remaining mapping size, a classic CWE-125 out-of-bounds read, and the caller query_pageant_direct then extended its buffer with read(size), driving the allocation and the out-of-view copy. The upstream fix (commit 5d566989ebabfdebfe6b33243d31765a0812260b) changes read() to return a Result and rejects requests where self.pos.checked_add(n) is None or exceeds self.length, propagating the error through the call sites that previously used unwrapped buffer extensions.
Know when Pageant 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
AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Local unprivileged process impersonating Pageant (AV:L/PR:N); reliable client crash gives A:H and the conditional adjacent-memory read gives C:L, above the vendor's C:N.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
pageant provides a [PageantStream] type that implements [AsyncRead] and [AsyncWrite] traits and can be used to talk to a running Pageant instance. Prior to pageant 0.2.3, the Windows pageant crate's pageant/src/wmmessage.rs MemoryMap::read function trusts a peer-controlled u32 response length supplied through the 8192-byte Pageant shared-memory mapping reached by AgentClient::connect_pageant. A local process that impersonates the Pageant window can make query_pageant_direct allocate up to approximately 4 GiB and copy beyond the mapped view, reliably crashing a russh client and conditionally exposing adjacent committed memory. This issue is fixed in pageant 0.2.3.
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.
EUVD-2026-89203
GHSA-g4mp-vgx3-xrvm
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB