Skip to main content

russh CVE-2026-73429

| EUVDEUVD-2026-57624 MEDIUM
Incorrect Type Conversion or Cast (CWE-704)
2026-08-12 GitHub_M GHSA-g9hv-x236-4qp3
5.3
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Attacker operates malicious SSH server
  2. Delivery
    Russh client initiates TCP connection and KEXINIT
  3. Exploit
    Server responds with KEX_ECDH_REPLY containing 16-byte ephemeral
  4. Execution
    Client calls clone_from_slice without length validation
  5. Persist
    Rust runtime panics at curve25519.rs:113
  6. Impact
    Session 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

russh < 0.62.4

Affected Packages

cargo russh fix: 0.62.4

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

Vendor (GitHub_M) PRIMARY 5.3 MEDIUM
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
vuln.today AI 5.3 MEDIUM

Network vector confirmed; attacker needs no privileges, only server control; impact is session-only availability loss with no C or I component.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
Low

Lifecycle Timeline

2
Patch available
Aug 12, 2026 - 22:03 EUVD
CVE Published
Aug 12, 2026 - 20:53 cve.org
MEDIUM 5.3

DescriptionCVE.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

EPSS Score
0.3%
Top 78% exploitable
Prevalence
Low
niche Rust-specific SSH library, limited production footprint
Threat Intel
1
1 source
Exploit
POC
Public exploit code exists
Social Media
1
Sightings
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA CIRCL GitHub VulDB

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.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC Yes
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

46
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +26
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

More in Russh

View all
CVE-2023-48795 MEDIUM POC
5.9 Dec 18

The SSH transport protocol with certain OpenSSH extensions, found in OpenSSH before 9.6 and other products, allows remot

CVE-2024-43410 HIGH POC
7.5 Aug 21

Russh is a Rust SSH client & server library. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable,

CVE-2023-28113 MEDIUM POC
5.9 Mar 16

russh is a Rust SSH client and server library. Rated medium severity (CVSS 5.9), this vulnerability is remotely exploita

CVE-2026-73430 MEDIUM POC
5.3 Aug 12

Unauthenticated remote denial of service in the Russh SSH library (versions ≤ 0.62.3) allows any network attacker to cra

CVE-2026-102823 HIGH
7.5 Sep 29

Improper validation in the Russh Rust SSH library (versions prior to 0.63.1) lets a malicious or compromised SSH server

CVE-2026-42189 HIGH
7.5 May 08

Pre-authentication denial-of-service in russh SSH server library allows remote attackers to crash servers implementing k

CVE-2026-48110 HIGH
7.5 Jun 10

Denial of service in Russh (Rust SSH client/server library) versions 0.34.0 through 0.60.x allows remote SSH peers to tr

CVE-2026-48107 MEDIUM
6.5 Jun 10

Denial of service in Russh (versions 0.37.0-0.60.x), a Rust SSH client and server library, allows a malicious SSH server

CVE-2026-102821 MEDIUM POC
6.5 Sep 29

Memory exhaustion in the Russh Rust SSH client/server library prior to 0.63.2 allows an authenticated remote peer to sta

CVE-2026-102820 MEDIUM POC
6.2 Sep 29

The Windows Pageant client inside the pageant Rust crate (pageant/src/wmmessage.rs) trusts a peer-controlled u32 respons

CVE-2026-48108 MEDIUM
5.3 Jun 10

Resource exhaustion in Russh's SSH server identification-string reader allows unauthenticated remote attackers to hold c

CVE-2026-102824 MEDIUM
4.3 Sep 29

Cryptographic weakness in the Russh SSH library before 0.63.0 lets a malicious remote SSH peer send an all-zero 32-byte

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy