Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate to russh server as client
-
DeliveryOpen session channel advertising max_packet_size=0
-
ExploitServer AsyncWrite stalls forever in poll_writable
-
ExecutionRepeat per channel and connection
-
ImpactSilent resource exhaustion / denial of service
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource consumption limits
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Server-side (authenticated remote DoS): an authenticated client (PR:L) opens a session channel advertising maximum_packet_size = 0, and the server application must write to that channel via the AsyncWrite path specifically - Channel::data(), Channel::make_writer(), or Channel::into_stream(); the *_bytes write variants are NOT affected because they already enforce the Error::Inconsistent guard. Client-side: a malicious or buggy server confirms the channel (CHANNEL_OPEN_CONFIRMATION) with maximum_packet_size = 0, stalling the client's writes. LIMITING FACTORS: the server path requires valid authentication; exploitation only strands tasks if the application uses the AsyncWrite API rather than the guarded *_bytes calls; and affected versions are strictly 0.60.0-0.64.1. Note that the server inactivity_timeout (default 600 s) is reset by keep-alive traffic so stranded resources persist, and the client inactivity_timeout defaults to None so nothing tears a stalled client session down - both factors extend, rather than limit, the impact. |
| Impact | This is a genuine but moderate-priority availability issue, not a critical emergency. The CVSS vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:L (NVD base 4.3) describes a network-reachable, low-complexity flaw requiring low privileges and no user interaction, with no confidentiality or integrity impact - consistent with the authenticated-client-against-server scenario. Note a signal conflict on impact magnitude: the vendor GHSA-fw5c-8223-6h42 scores the same vector with A:H (6.5, medium) because stranded tasks/channels/connections accumulate silently into resource exhaustion, while NVD uses A:L (4.3); the A:H reading is better supported by the CWE-400/CWE-835 mechanism and the permanent, non-self-healing nature of the stall. No EPSS score was provided, so exploitation probability cannot be quantified. The issue is NOT on CISA KEV and there is no confirmed public exploit; the vuln.today Decision label is this_month, indicating scheduled remediation rather than emergency action. Overall: a real, easy-to-trigger DoS against a niche Rust library - worth patching on a normal cycle, but lacking the exploitation-in-the-wild or confidentiality/integrity signals that would make it urgent. |
| Exploit ScenarioDerived | An authenticated client opens a session channel to a russh-based server and advertises maximum_packet_size = 0 in CHANNEL_OPEN; when the server application later writes to that channel through the AsyncWrite path (Channel::data, make_writer, or into_stream - the pattern used by russh's own echo/SFTP examples), the write future parks in ChannelTx::poll_writable and never completes or errors, silently stranding the handler task. The same works in reverse: a malicious server confirms a channel with maximum_packet_size = 0 to permanently stall a client's writes. No public exploit code is published, but the advisory documents a reproducer verified end-to-end against stock russh v0.64.1 (default config plus a single maximum_packet_size = 0 toggle), and AC:L/PR:L confirm the trigger is trivial for any authenticated peer. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 28, 2026
Authenticated denial of service in russh 0.60.0 through 0.64.1: a client can open a session channel advertising a maximum packet size of zero, and any server write through Channel::data(), Channel::make_writer(), or Channel::into_stream() then remains pending forever instead of returning an error. A malicious server can cause the same silent stall in a client by confirming a channel with a zero maximum packet size. The vendor fixed the defect in 0.65.0 by rejecting zero at parse time; the advisory includes a verified end-to-end reproducer, no CISA KEV entry is reported, and this is assessed as a moderate-priority availability problem rather than a critical emergency.
RemediationAI
Upgrade to russh 0.65.0, which rejects maximum_packet_size == 0 in OpenChannelMessage::parse and ChannelOpenConfirmation::parse and returns Error::Inconsistent; the vendor advisory is https://github.com/Eugeny/russh/security/advisories/GHSA-fw5c-8223-6h42, the fix commit is https://github.com/Eugeny/russh/commit/39cb9dbaa37caf555d34c6c22efa3bbbff9e186c, and the release is https://github.com/Eugeny/russh/releases/tag/v0.65.0. If upgrading is not immediately possible, replace Channel::data(), Channel::make_writer(), and Channel::into_stream() write paths with the guarded data_bytes or extended_data_bytes methods, which already return Error::Inconsistent on a zero maximum packet size; the trade-off is losing the AsyncWrite and stream-style interface and requiring explicit error handling. Add an application-level timeout around channel writes and tear down the channel or connection when it fires, because the default client inactivity_timeout is None and the server inactivity_timeout default of 600 seconds is refreshed by keep-alive traffic, so stranded tasks, channels, and connections otherwise persist. Rejecting or closing channels whose peer maximum packet size is zero at the application layer is a compensating control but does not fix the library and may reject noncompliant peers, since RFC 4254 section 5.1 recommends a minimum of 32768. The vendor fix delivered in 0.65.0 is the complete remediation for the underlying parsing and write-path defect.
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
russh is a Rust SSH client and server library that implements RFC 4254 channel flow control. Each CHANNEL_OPEN (server attack path) and CHANNEL_OPEN_CONFIRMATION (client attack path) carries a peer-declared maximum packet size, a static upper bound on outgoing data chunks. From 0.60.0, parsing stored this value without range validation. In ChannelTx::poll_writable (russh/src/channels/io/tx.rs), writable is calculated as max_packet_size.min(window_size).min(buf_len); when the peer value is zero the result is always zero, so the future parks on a window notification and is re-polled on every CHANNEL_WINDOW_ADJUST without ever becoming Ready. Because a static zero maximum can never be satisfied by any amount of peer-granted window, the write neither completes nor errors. This is CWE-400 uncontrolled resource consumption combined with a CWE-835 loop with an unreachable exit condition. Other write paths (Channel::reserve_writable_chunk and the session packetizers) already returned Error::Inconsistent for a zero maximum packet size, so only the AsyncWrite path was vulnerable. The 0.65.0 fix changes OpenChannelMessage::parse and ChannelOpenConfirmation::parse to reject zero with Error::Inconsistent; the CPE cpe:2.3:a:eugeny:russh confirms the eugeny/russh crate, and EUVD-2026-111389 lists russh 0.60.0, < 0.65.0.
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:L/UI:N/S:U/C:N/I:N/A:L
Network-reachable (AV:N), trivial trigger (AC:L), requires an authenticated client for the server attack (PR:L), no user interaction; availability A:H because stalls are permanent and accumulate into resource exhaustion, with no C/I impact.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
russh is a Rust SSH client and server library that includes an SSH agent protocol implementation. From 0.60.0 until 0.65.0, channel-open parsing accepts a peer-declared maximum_packet_size of zero and passes it into ChannelTx::poll_writable in russh/src/channels/io/tx.rs. The Channel::data, Channel::make_writer, and Channel::into_stream asynchronous write paths then calculate a writable size of zero and remain pending forever because window adjustments cannot satisfy a static zero packet maximum. An authenticated client can strand server writes, and a malicious server can strand client writes, allowing affected tasks, channels, and connections to accumulate without surfacing an error. This issue is fixed in version 0.65.0.
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
Denial-of-service in russh's Curve25519 key exchange client path allows any malicious SSH server to crash a connecting r
russh's SSH agent server signs with keys loaded under the confirm constraint without ever invoking the application's app
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
EUVD-2026-111389
NVD
CVE.org
EPSS
GitHub
Exploit-DB