Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach user's russh agent socket (local or forwarded)
-
DeliveryRequest signature using confirm-constrained key
-
Exploittry_sign returns hard-coded success, skips Agent::confirm
-
ExecutionObtain valid signature without approval
-
ImpactAuthenticate or sign data as the user
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Authorization checks on every request
MITRE ATT&CK
1 technique across 1 tactic: Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires ALL of the following concrete prerequisites: (1) the application embeds russh in the affected range 0.50.0-beta.12 to 0.64.1 and acts as an SSH agent server via russh::keys::agent::server; (2) the application OVERRIDES Agent::confirm to implement a real approval or policy check - the default always-true implementation is NOT affected, and checks placed in Agent::confirm_request are NOT bypassed because that hook still runs for every sign request; (3) a key was loaded with the SSH_AGENT_CONSTRAIN_CONFIRM constraint, i.e. via 'ssh-add -c', and remains loaded; and (4) the attacker can reach the agent socket, meaning either another local process running as the same user or the remote host when the agent is forwarded with 'ssh -A'. Limiting factors: the private key is never exposed (abuse lasts only while the attacker can reach the agent), and unaffected configurations (default confirm, confirm_request-based checks, non-forwarded agents with no hostile local processes) remove the risk entirely. |
| Impact | This is a genuine but conditional authorization-bypass (CWE-862) in russh's SSH agent server, not an inflated high-CVSS issue - though its real-world blast radius is narrower than the 8.3 score alone suggests. The supplied CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:L/UI:N) correctly reflects that exploitation requires reaching the agent's local Unix socket (or the remote end of a forwarded agent), low privileges, no user interaction and no special attack conditions, with high integrity impact on both the vulnerable system (VI:H) and subsequent systems (SI:H/SC:H) because the agent can be driven to authenticate or sign as the user. No EPSS probability and no CISA KEV status were provided in the input, so there is no signal of active or widespread exploitation; the vuln.today decision label is 'this_week' (not act_now/emergency). The GHSA advisory ships a working reproducer test demonstrating the regression, so a public PoC reference exists; it is not verified in the input as a packaged weaponized exploit, and PoC availability must not be conflated with active exploitation. The crucial limiting signal, stated explicitly by the vendor, is that only applications that OVERRIDE Agent::confirm to enforce an approval/policy check are affected - implementations keeping the default always-true confirm, and any checks placed in Agent::confirm_request (still invoked for every sign request), are unaffected. Net: a real priority for the specific downstream applications that rely on ssh-add -c confirmation (e.g. the reporter names Proton Pass desktop, untested), but low urgency for the general russh population. |
| Exploit ScenarioDerived | A user runs a russh-based agent application that overrides Agent::confirm to prompt for approval, and loads a key with 'ssh-add -c' expecting per-use confirmation. An attacker who can reach the agent socket - another local process running as that user, or the remote host when the agent is forwarded with 'ssh -A' - issues a signature request for that key; the agent returns a hard-coded success and signs without the confirmation prompt ever firing, letting the attacker authenticate to other hosts or sign data (e.g. git commits) as the user while the key stays loaded. The GHSA advisory includes a reproducer test confirming the confirm callback is never invoked. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 28, 2026
russh's SSH agent server signs with keys loaded under the confirm constraint without ever invoking the application's approval hook, so any process able to reach the agent socket - another local process running as the same user, or the remote host when the agent is forwarded with ssh -A - can authenticate or sign data as the user while the key stays loaded. The regression spans russh 0.50.0-beta.12 through 0.64.1 and only affects applications that override Agent::confirm with a real approval or policy check; the default always-true confirm and checks implemented in Agent::confirm_request remain effective, and the private key itself is never exposed. The vendor advisory ships a reproducible test PoC demonstrating the bypass (a unit test, not working exploit code); the issue is not listed in CISA KEV and active exploitation is not confirmed.
RemediationAI
Vendor-released patch: upgrade russh to 0.65.0 and rebuild, per the advisory at https://github.com/Eugeny/russh/security/advisories/GHSA-vp5q-ff62-jwqv and the release at https://github.com/Eugeny/russh/releases/tag/v0.65.0 (fix commits 3e04597dc54e36bfc85c21996f7d8d9d224e9826 and 62db6e7defd6d244159da962ccccb029e785ce0f; the regression originated in 3e04597). Note the documented compatibility side effect: because Agent::confirm is called again for confirm-constrained keys, any implementation that stubs it (e.g. todo!()) will now be reached - each connection runs in its own task, so such a panic terminates only that connection. Until upgrading, move the approval or policy check into Agent::confirm_request, which still receives MessageType::Sign for every signing request, or refuse keys carrying the Confirm constraint outright as RFC 9987 §5.2.7 requires of agents that do not support a constraint; both trade-offs are that the trusted-prompt semantics of ssh-add -c change and clients relying on the constraint will see the key rejected. Also avoid forwarding the agent (ssh -A) to untrusted hosts and avoid running untrusted local processes that can reach the agent socket, since those are the two paths the advisory identifies for reaching the agent.
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 lives in russh::keys::agent::server, the SSH agent server implementation of the russh Rust SSH library, and concerns the SSH agent protocol constraint extension (SSH_AGENT_CONSTRAIN_CONFIRM, RFC 9987 §5.2.7.2) that ssh-add -c attaches to a key so the agent must ask the user before each signature. Connection::try_sign detects needs_confirm but replaces the awaited Agent::confirm call with a hard-coded futures::future::ready((agent, true)) - a missing authorization check (CWE-862) introduced by commit 3e04597 ("Native async traits encore", PR #455) and shipped from 0.50.0-beta.12 onward; every one of the 52 published releases up to and including 0.64.1 contains the hard-coded true, while 0.50.0-beta.8 through beta.11 still called agent.confirm, and older releases have no agent server at all (it lived in russh-keys, where no release is affected). Two design details bound the impact: Agent::confirm_request is still invoked with MessageType::Sign on every signing request, so policy checks placed there still run, and implementations that keep the trait's default confirm (which returns true unconditionally) lose no check through this regression. Because the agent accepts the constraint without enforcing it, ssh-add -c reports success and the user wrongly believes the key is protected; RFC 9987 §5.2.7 requires an agent that does not support a constraint to refuse the key instead.
Know when Russh 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:L/AC:L/AT:N/PR:L/UI:N/VC:N/VI:H/VA:N/SC:H/SI:H/SA:N
Attacker needs access to the user's agent socket (AV:L, PR:L); no key disclosure so C:N; unauthorized signing/authentication gives I:H; the agent is driven to authenticate to other systems, so S:C; no availability impact.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
russh is a Rust SSH client and server library that includes an SSH agent protocol implementation. From 0.50.0-beta.12 until 0.65.0, the agent server's Connection::try_sign path in russh/src/keys/agent/server.rs recognizes SSH_AGENT_CONSTRAIN_CONFIRM but returns a hard-coded successful result instead of calling Agent::confirm. In applications that override Agent::confirm to require user approval or another policy check, a process that can reach the agent socket, including the remote side of a forwarded agent, can use a key added through ssh-add -c without that check and can authenticate or sign data as the user while the key remains loaded. The separate Agent::confirm_request hook still runs for every signing request, so checks implemented there remain effective, and implementations that retain the default always-successful Agent::confirm do not lose an approval check through this regression. This issue is fixed in version 0.65.0.
Executive ViewAI
CVE-2026-116794 is a high-severity flaw in the russh SSH agent server (versions 0.50.0-beta.12 through 0.64.1) that allows local or remote processes to sign with keys loaded under the 'confirm' constraint without triggering the application's approval prompt, enabling unauthorized authentication as the user. Organizations that have overridden the Agent::confirm hook with a real policy check are at risk; the private key is not exposed but improper signing can lead to account compromise. Given the ease of exploitation (low complexity, local or forwarded access) and the absence of a patch, leadership should prioritize identifying affected applications and implementing workarounds.
Disable SSH agent forwarding, restrict agent socket access to trusted local processes, implement alternative approval mechanisms outside russh (e.g., external policy enforcement or key confirmation at a higher layer), and monitor for suspicious authentication activity. No vendor patch identified at time of analysis.
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
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
The SSH transport protocol with certain OpenSSH extensions, found in OpenSSH before 9.6 and other products, allows remot
Russh is a Rust SSH client & server library. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable,
russh is a Rust SSH client and server library. Rated medium severity (CVSS 5.9), this vulnerability is remotely exploita
Unauthenticated remote denial of service in the Russh SSH library (versions ≤ 0.62.3) allows any network attacker to cra
Denial-of-service in russh's Curve25519 key exchange client path allows any malicious SSH server to crash a connecting r
Improper validation in the Russh Rust SSH library (versions prior to 0.63.1) lets a malicious or compromised SSH server
Pre-authentication denial-of-service in russh SSH server library allows remote attackers to crash servers implementing k
Denial of service in Russh (Rust SSH client/server library) versions 0.34.0 through 0.60.x allows remote SSH peers to tr
Denial of service in Russh (versions 0.37.0-0.60.x), a Rust SSH client and server library, allows a malicious SSH server
Memory exhaustion in the Russh Rust SSH client/server library prior to 0.63.2 allows an authenticated remote peer to sta
The Windows Pageant client inside the pageant Rust crate (pageant/src/wmmessage.rs) trusts a peer-controlled u32 respons
Resource exhaustion in Russh's SSH server identification-string reader allows unauthenticated remote attackers to hold c
EUVD-2026-112267
NVD
CVE.org
GitHub
Exploit-DB