Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure client to connect to malicious SSH server
-
DeliveryComplete/negotiate SSH session
-
ExploitSend channel lifecycle events for unopened channel IDs
-
ExecutionTrigger unvalidated Handler callbacks in client
-
ImpactClient panics or records corrupted exit-code state
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Input validation, allowlisting
|
| Exploitation Conditions | Requires the russh-based application to act as an SSH CLIENT (versions prior to 0.63.1) and to connect to a server the attacker controls or has compromised; the malicious server then sends channel-scoped protocol messages (CHANNEL_DATA, CHANNEL_EXTENDED_DATA, CHANNEL_EOF, CHANNEL_CLOSE, CHANNEL_OPEN_FAILURE, CHANNEL_SUCCESS, CHANNEL_FAILURE, or CHANNEL_REQUEST exit-status/exit-signal/xon-xoff) referencing channel IDs the client never opened, whose open was denied, or that are not yet confirmed. The key LIMITING factor is the trust model: exploitation is not possible against an arbitrary victim over the open network - the attacker must occupy the server side of a connection the client initiates and trusts, so risk concentrates in scenarios with untrusted or attacker-influenced SSH endpoints (malicious jump hosts, MITM, automation connecting to untrusted hosts). |
| Impact | The vendor-assigned CVSS is 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N), scoring this as a network-reachable integrity break with no confidentiality or availability impact. That labeling is internally inconsistent with the description, which explicitly states the primary consequence is 'application panics' - a denial-of-service (availability) effect - alongside 'corrupting command completion and exit-code tracking' (the integrity effect). A more defensible read is I:H plus a real availability component; there is no confidentiality impact, so the 'Information Disclosure' tag is wrong. Critically, the AV:N/PR:N/UI:N framing understates the trust model: this is a CLIENT-side library flaw, and exploitation requires the victim client to connect to a MALICIOUS or compromised SSH server. There is no EPSS score, no CISA KEV listing, and no public exploit code in the provided data, so this is not confirmed as actively exploited - no public exploit identified at time of analysis. Net: it is a legitimate correctness/robustness bug (CWE-20) fixed cleanly in 0.63.1 and worth patching for any Rust project embedding russh as a client, but it is a moderate-priority issue, not an urgent one - the 7.5 rating overstates real-world urgency because the attacker must already control the SSH server the client trusts, and the realistic outcome is a client crash or corrupted exit-status bookkeeping rather than code execution or data theft. |
| Exploit ScenarioDerived | A victim application built on russh (versions prior to 0.63.1) connects as an SSH client to a server the attacker controls or has compromised (e.g. a malicious jump host, a spoofed endpoint, or an untrusted host in an automation/CI pipeline). The malicious server sends CHANNEL_DATA, CHANNEL_CLOSE, CHANNEL_REQUEST exit-status/exit-signal, or similar lifecycle messages referencing channel IDs the client never opened or that are unconfirmed, driving Handler callbacks for phantom channels and causing the client to panic or record bogus exit codes. No public proof-of-concept is referenced in the provided intelligence. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 29, 2026
Improper validation in the Russh Rust SSH library (versions prior to 0.63.1) lets a malicious or compromised SSH server drive client-side channel lifecycle callbacks for channel identifiers the client never opened, never confirmed, or already released. The affected code path is client_read_authenticated in russh/src/client/encrypted.rs, which forwards CHANNEL_DATA, CHANNEL_EXTENDED_DATA, CHANNEL_EOF, CHANNEL_CLOSE, CHANNEL_OPEN_FAILURE, CHANNEL_SUCCESS, CHANNEL_FAILURE, and CHANNEL_REQUEST subtypes (exit-status, exit-signal, xon-xoff) to public client::Handler callbacks without checking that the ChannelId belongs to a channel the client opened and established. Exploitation requires the russh-based application to act as an SSH client and connect to a server the attacker controls or has compromised - so risk concentrates in untrusted jump hosts, MITM positions, and automation that reaches attacker-influenced endpoints rather than arbitrary internet-facing victims; no public exploit code has been identified at time of analysis. Successful abuse can panic the application or corrupt command-completion and exit-code tracking, and the vendor assigns CVSS 7.5 while the independent assessment scores integrity and availability impact at High.
RemediationAI
Vendor-released patch: upgrade the russh crate to version 0.63.1 or later (release tag https://github.com/Eugeny/russh/releases/tag/v0.63.1), which applies the fix commit 3430fd26ecafc0dc3705210f5f39a9119fa22774 adding is_established_channel validation before any client::Handler callback dispatch and special-casing CHANNEL_CLOSE to require the channel to exist in the encrypted table; see the advisory at https://github.com/Eugeny/russh/security/advisories/GHSA-47hw-gvq5-r2gm for the full list of gated message types. Because this is a library, remediation has two layers: bump the direct dependency and then rebuild/redeploy every downstream binary that statically links russh, since a stale compiled artifact will not pick up the patched source even after the manifest is updated; run cargo update -p russh and verify with cargo tree that no transitive dependency still pins a pre-0.63.1 version, watching for crates that vendor or fork russh internals. Where an immediate upgrade is not possible, the effective compensating control is trust-model hardening rather than code-level firewalling, because the exploit surface is the SSH server the client voluntarily connects to: restrict russh client deployments to a curated allowlist of known-good SSH endpoints, avoid connecting to untrusted or attacker-influenced hosts (including third-party jump hosts and automation targets in shared environments), and enforce strict host-key pinning and known_hosts verification so an attacker cannot easily insert itself as the server; the trade-off is reduced operational flexibility and the need to maintain and rotate trust anchors. Because the library only exposes a parse-time validation gap, there is no port to block or feature flag to disable that removes the risk without the version bump; host-key verification and endpoint allowlisting reduce, but do not eliminate, exposure to a server-side attacker who already holds a legitimate trusted position.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in cargo
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Russh is a Rust implementation of the SSH client and server protocol used by applications that need programmatic SSH sessions. The vulnerability is rooted in CWE-20 (Improper Input Validation): the SSH transport and channel layer of the protocol is attacker-controlled in the sense that the peer server dictates which channel numbers appear in channel-scoped messages, but the client failed to cross-check those numbers against its own authoritative encrypted-channel table before dispatching them to application-facing Handler callbacks. The upstream fix introduces a shared is_established_channel helper on the common session state that only returns true when the channel exists in the encrypted channel table AND is marked confirmed, and adds early-return gates in client_read_authenticated for CHANNEL_DATA, CHANNEL_EXTENDED_DATA, CHANNEL_EOF, CHANNEL_CLOSE, CHANNEL_OPEN_FAILURE, CHANNEL_SUCCESS, CHANNEL_FAILURE, and CHANNEL_REQUEST subtypes exit-status, exit-signal, and xon-xoff. The CHANNEL_CLOSE handling is deliberately special-cased: because close can legitimately arrive for a client-opened but not-yet-confirmed channel, it gates on presence in the encrypted table (removing the entry) rather than on the confirmed flag, ensuring that a single forged close cannot be reused to evict or corrupt legitimate channel state. The same helper was hoisted out of the server-side Session impl and repointed at common state, so the fix is shared across both client and server paths. CPE cpe:2.3:a:eugeny:russh:*:*:*:*:*:*:*:* covers all released versions before the 0.63.1 fix; downstream crates that embed russh inherit the exposure through their dependency chain. The practical consequence class is state-machine desynchronization - callbacks like data, channel_close, exec_request, and exit-status handlers fire for channels the application believes do not exist, leading to panics on missing channel maps or to incorrect exit-code and command-completion accounting in automation built on the library.
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
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N
Malicious server needs no client-side auth (PR:N) and sends crafted messages over the network (AV:N/AC:L); panic gives A:H and exit-code corruption gives I:H; no confidentiality impact.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Russh is a Rust SSH client and server library. Prior to 0.63.1, client_read_authenticated in russh/src/client/encrypted.rs forwards CHANNEL_DATA, CHANNEL_EXTENDED_DATA, CHANNEL_EOF, CHANNEL_CLOSE, CHANNEL_OPEN_FAILURE, CHANNEL_SUCCESS, CHANNEL_FAILURE, and CHANNEL_REQUEST subtypes exit-status, exit-signal, and xon-xoff to public client::Handler callbacks without confirming that the ChannelId belongs to a channel the client opened and established. A malicious SSH server can send lifecycle events for predicted, unopened, unconfirmed, or released channel identifiers, causing application panics or corrupting command completion and exit-code tracking. This issue is fixed in version 0.63.1.
Technical POC Analysis
CWE-20 (Improper Input Validation) in the client's SSH transport message dispatcher.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A validation flaw in the Russh Rust SSH library (all versions before 0.63.1) allows a hostile or compromised SSH server to trigger channel-handling callbacks in applications that use Russh as a client, even for channels the application never opened or already closed. The exposure is concentrated in engineering and operations workflows that connect to endpoints outside the organization's direct control-untrusted jump hosts, third-party automation targets, and connections traversing networks where an adversary could interpose-rather than in internet-facing services. Because Russh is embedded in internally built tooling rather than sold as a standalone product, leadership should care about the breadth of internal automation that silently depends on it and the absence of a vendor fix at this time.
No vendor-released patch identified at time of analysis. Interim mitigations: confine affected Russh-based clients to trusted, internally controlled SSH servers; enforce strict host-key verification and pinning to reduce man-in-the-middle exposure; block or monitor outbound SSH to untrusted or attacker-influenceable endpoints; and add application-side validation of ChannelId values so handler callbacks for unopened or released channels are ignored. Plan to upgrade to the fixed release (0.63.1 or later) once vendor confirmation and validation are complete.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
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
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
Cryptographic weakness in the Russh SSH library before 0.63.0 lets a malicious remote SSH peer send an all-zero 32-byte
EUVD-2026-89206
GHSA-47hw-gvq5-r2gm
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB