Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAttacker operates malicious SSH server
-
DeliveryRussh client initiates TCP connection and KEXINIT
-
ExploitServer responds with KEX_ECDH_REPLY containing 16-byte ephemeral
-
ExecutionClient calls clone_from_slice without length validation
-
PersistRust runtime panics at curve25519.rs:113
-
ImpactSession task terminated via JoinError
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Correct type conversion
|
| Exploitation Conditions | The russh client must negotiate curve25519-sha256 as the key exchange algorithm, which is the default and preferred KEX in russh and most modern SSH implementations, so no non-default client configuration is required. The attacker must control or impersonate the SSH server that the russh client connects to - the attack cannot be initiated from client to server, and russh servers are not exploitable via this path because the server-side code already validates the ephemeral length. Exploitation is bounded to a session-level DoS: the spawned client session task panics and terminates, but the embedding Rust process remains running. There is no remote code execution path, no credential exposure, and no impact on the server side. The attack fires before any authentication or host key check, so no credentials or known-host entries assist in limiting it beyond preventing the connection entirely. |
| Impact | The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L) scores 5.3 and accurately reflects the attack surface: remote, zero-complexity, unauthenticated exploitation yielding limited availability impact (session crash, not process crash). No EPSS data was provided in the intelligence feed, so exploitation probability cannot be quantified numerically. The absence of a CISA KEV listing indicates no confirmed active exploitation at analysis time, and the attack requires attacker control of an SSH server that a russh client connects to - meaning opportunistic mass exploitation is constrained by the need to lure or intercept client connections. A publicly available proof-of-concept is included in the GHSA advisory, lowering the bar for exploitation considerably. Real-world priority is moderate: the impact is a reliable session-level DoS (not RCE, no data exposure), but the zero-authentication, zero-complexity trigger against any russh client connecting to an attacker-controlled server makes this a credible threat in environments that programmatically SSH to untrusted hosts. Applications relying on russh for automated SSH connections to third-party or user-supplied servers are at elevated risk. |
| Exploit ScenarioDerived | An attacker operates a rogue SSH server and causes a russh-based client application to connect to it - through DNS poisoning, a man-in-the-middle redirect, or by advertising a malicious endpoint to a user. During key exchange, the rogue server sends a KEX_ECDH_REPLY with a 16-byte server ephemeral (instead of the required 32 bytes), triggering a deterministic Rust panic in clone_from_slice at curve25519.rs:113 before host key verification is reached. A self-contained POC demonstrating this exact scenario is included in the GHSA advisory. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 12, 2026
Denial-of-service in russh's Curve25519 key exchange client path allows any malicious SSH server to crash a connecting russh client session deterministically and pre-authentication, before host key verification occurs. Affected are all russh client deployments running versions prior to 0.62.4. An attacker operating or controlling an SSH server can terminate the client's spawned session task with a single malformed KEX_ECDH_REPLY packet; a working proof-of-concept is included in the GHSA advisory. No public exploit identified at time of analysis for active exploitation, and CISA KEV listing is absent, but the attack is reliable, requires no authentication, and a POC is publicly available.
RemediationAI
Upgrade russh to version 0.62.4 immediately; this is the vendor-released patch confirmed by the tagged release at https://github.com/Eugeny/russh/releases/tag/v0.62.4 and the patch commit at https://github.com/Eugeny/russh/commit/a7fc1eb5717264e31c3c5f7dd849b73989a08f3d. The fix adds an explicit length check (if remote_pubkey_.len() != 32 { return Err(crate::Error::Kex); }) before the clone_from_slice call, mirroring the validation already present in the server-side path. If an immediate upgrade is not feasible, a compensating control is to restrict the KEX algorithms offered by the russh client to non-curve25519 paths (e.g., ecdh-sha2-nistp256 or diffie-hellman-group14-sha256), which are not affected by this specific missing check - though this trades off forward secrecy characteristics and depends on whether russh's Preferred::kex API allows per-connection algorithm pinning. Applications that only connect to a fixed, trusted set of SSH servers can additionally enforce strict host key verification, but note this does not prevent the panic since it triggers before host key verification occurs.
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 (CPE: cpe:2.3:a:eugeny:russh:*:*:*:*:*:*:*:*) is a pure-Rust SSH client and server library. The flaw resides in the client-side Curve25519 key-exchange implementation at russh/src/kex/curve25519.rs:110-117. During a curve25519-sha256 key exchange, the client processes a KEX_ECDH_REPLY message containing a 32-byte server ephemeral public key. The function compute_shared_secret calls clone_from_slice on the decoded exchange.server_ephemeral bytes without first validating that the slice is exactly 32 bytes, causing a deterministic Rust runtime panic when the length mismatches. The server-side counterpart server_dh (lines 61-65 of the same file) correctly performs this length check before cloning - creating an asymmetric validation gap exploitable only by a malicious server against a russh client, not vice versa. The assigned CWE-704 (Incorrect Type Conversion or Cast) is an imprecise fit; the actual root cause class is CWE-20 (Improper Input Validation) - a missing bounds check on attacker-supplied data prior to a fixed-length memory copy. The panic surfaces through Tokio's task runtime as a JoinError, terminating the session task while leaving the embedding process alive.
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:N/A:L
Network vector confirmed; attacker needs no privileges, only server control; impact is session-only availability loss with no C or I component.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Russh is a Rust SSH client & server library. Prior to 0.62.4, a malicious SSH server can crash a russh client session with a malformed KEX_ECDH_REPLY containing a server ephemeral value that is not 32 bytes long. The client-side Curve25519Kex::compute_shared_secret function in russh/src/kex/curve25519.rs passes the decoded exchange.server_ephemeral value to clone_from_slice without validating its length, causing a deterministic panic before the server host key is verified. The panic terminates the spawned client session task and surfaces as a JoinError, while the embedding process normally remains running. This issue is fixed in version 0.62.4.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
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
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
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-57624
GHSA-g9hv-x236-4qp3
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB