Skip to main content

Russh CVE-2026-102821

| EUVDEUVD-2026-89204 MEDIUM
Uncontrolled Resource Consumption (CWE-400)
2026-09-29 GitHub_M GHSA-35g8-35p8-c8fw
6.5
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Authenticate to russh SSH server
  2. Delivery
    Send SSH_MSG_KEXINIT, withhold KEX_ECDH_INIT
  3. Exploit
    Stall session in KexState::InProgress
  4. Execution
    Flood SSH_MSG_CHANNEL_OPEN messages
  5. Persist
    Unbounded reply queue grows memory
  6. Impact
    Process OOM-killed, service down

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

Requires an authenticated remote peer to a russh server (or client) prior to 0.63.2 (PR:L). The attacker then abuses the rekey state machine: send SSH_MSG_KEXINIT but never send the required SSH_MSG_KEX_ECDH_INIT so the session stays in SessionKexState::InProgress and priority_receiver in russh/src/server/session.rs is never drained, then flood SSH_MSG_CHANNEL_OPEN messages whose ChannelOpenReply entries pile up on an unbounded channel until memory is exhausted. The primary limiting factor is that valid authentication is required first - this is not reachable pre-auth - so exposure scales with how trusted the server's authenticated user population is; no user interaction, no special non-default configuration, and no platform constraint beyond running an affected russh version (<0.63.2) apply.

Impact

This is a legitimate but moderate-priority availability issue. The CVSS 3.1 vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H (base 6.5) is internally consistent with the description: network-reachable (AV:N), low complexity (AC:L, a deterministic protocol-state abuse requiring no race), no user interaction, and pure availability impact (A:H) with no confidentiality or integrity loss. Critically, PR:L confirms the attacker must FIRST be an authenticated remote peer - the description explicitly says 'an authenticated remote peer,' so this is NOT an unauthenticated pre-auth DoS. That materially narrows the threat: an attacker needs valid credentials (or a permitted auth method) on the russh server before the memory-exhaustion primitive is reachable. No EPSS score, no CISA KEV listing, and no standalone weaponized exploit were provided, so exploitation status is: no public exploit identified at time of analysis. However, the fixing commit ships a regression test (channel_open_after_peer_kexinit_during_rekey_is_rejected) that demonstrates the exact trigger sequence, so a working reproduction path is effectively documented in the source tree even though it is not packaged as a public PoC. Signals are not conflicting: every source (description, CWE-400 resource exhaustion, CVSS A:H-only vector, tag 'Denial Of Service') agrees this is a memory-exhaustion DoS. The main gap between raw CVSS and real-world risk is the PR:L gate - for servers that only admit trusted authenticated users, real risk is low; for servers exposing russh to semi-trusted or large user populations, a single authenticated connection killing the process is a genuine availability concern.

Exploit ScenarioDerived

An attacker who has authenticated to a russh-based SSH server initiates a key re-exchange by sending SSH_MSG_KEXINIT but deliberately withholds the follow-up SSH_MSG_KEX_ECDH_INIT, parking the session in SessionKexState::InProgress. While the priority_receiver is thus never drained, the attacker floods SSH_MSG_CHANNEL_OPEN messages; the server keeps enqueuing a ChannelOpenReply for each onto an unbounded channel, driving process memory up until the OS terminates it. No public exploit is packaged, but the fix commit includes a test reproducing the stalled-rekey-plus-channel-flood sequence.

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 – Sep 29, 2026

Memory exhaustion in the Russh Rust SSH client/server library prior to 0.63.2 allows an authenticated remote peer to stall the rekey state machine and flood SSH_MSG_CHANNEL_OPEN requests, causing ChannelOpenReply entries to accumulate on an unbounded channel until the process is terminated (CVSS 6.5, AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H). The attack requires a valid authenticated session first and abuses the SSH rekey window: the peer sends SSH_MSG_KEXINIT but withholds the required SSH_MSG_KEX_ECDH_INIT, leaving SessionKexState::InProgress so priority_receiver in russh/src/server/session.rs is never drained while the server keeps enqueuing replies. There is no public exploit identified at time of analysis and no CISA KEV listing, so exploitation remains a moderate-priority availability concern gated by how trusted the server's authenticated user population is.

RemediationAI

Upgrade to the vendor-released patch: russh 0.63.2 (release tag https://github.com/Eugeny/russh/releases/tag/v0.63.2, advisory GHSA-35g8-35p8-c8fw), which implements the RFC 4253 section 7.1 enforcement and the 2x window_size pending-data cap; the individual fix is commit a282af361ac99bc76b80876d1aae128e89dbf66b for teams tracking a git dependency. If immediate upgrade is not possible, the most effective compensating control is to treat the authenticated user population as the trust boundary, since the issue is only reachable after successful authentication (PR:L): restrict and audit which accounts and keys may log in, disable password auth in favor of tightly scoped keys, and revoke or rotate credentials for untrusted or shared accounts, at the cost of reduced access flexibility for legitimate users. Operators should also configure a finite config.inactivity_timeout rather than None (the regression test explicitly sets inactivity_timeout = None for the stalled-rekey scenario), enforce per-identity and per-IP connection limits at the network edge or in a reverse proxy to blunt a single-connection flood, and cap the russh process's memory via cgroup/systemd MemoryMax or a container limit so exhaustion kills one constrained unit instead of the host; each of these trades some availability or throughput headroom under load, and none fully closes the unbounded-queue condition the way 0.63.2 does. Continuous RSS monitoring and alerting on rapid per-connection memory growth provides detection during the window before patching.

Affected VersionsENISA

russh < 0.63.2

Affected Packages

cargo russh fix: 0.63.2

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 implements the SSH-2 transport (RFC 4253) and connection protocols in Rust. Per RFC 4253 section 7.1, once a KEXINIT message has been exchanged, only transport-layer (message types 1-19) and key-exchange (20-49) messages may flow until NEWKEYS completes; application-layer traffic such as SSH_MSG_USERAUTH_REQUEST and SSH_MSG_CHANNEL_OPEN (>= 50) is a protocol violation during that window. The vulnerability is a CWE-400 uncontrolled resource consumption issue rooted in the rekey state machine: a peer that sends SSH_MSG_KEXINIT but never the matching SSH_MSG_KEX_ECDH_INIT leaves the session in SessionKexState::InProgress, which prevents the priority_receiver path from being drained. Non-kex packets are still processed, and each SSH_MSG_CHANNEL_OPEN produces a ChannelOpenReply that is queued onto an unbounded channel, so a single connection can grow memory without limit. The upstream fix (commit a282af361ac99bc76b80876d1aae128e89dbf66b) hardens both the client (russh/src/client/mod.rs, client/kex.rs) and server (russh/src/server/mod.rs, server/kex.rs, server/session.rs) paths: it adds a peer_kexinit_received() predicate that distinguishes the Created state (our KEXINIT sent, peer's not yet received) from later states, rejects non-transport messages outright once the peer's own KEXINIT has arrived, and otherwise bounds the accumulated pending bytes at 2x the configured window_size via a pending_len counter that is reset when the rekey completes. The wildcard CPE cpe:2.3:a:eugeny:russh:*:*:*:*:*:*:*:* indicates the advisory covers all pre-fix releases of the crate, and the regression test channel_open_after_peer_kexinit_during_rekey_is_rejected documents the stalled-rekey scenario with a curve25519-only rekey.

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 6.5 MEDIUM
AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 6.5 MEDIUM

Network-reachable with low-complexity deterministic protocol abuse, but requires prior authentication (PR:L); impact is pure availability (memory exhaustion) with no confidentiality or integrity loss.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

Lifecycle Timeline

1
Patch available
Sep 29, 2026 - 19:34 EUVD

DescriptionCVE.org

Russh is a Rust SSH client and server library. Prior to 0.63.2, an authenticated remote peer can send SSH_MSG_KEXINIT without the required SSH_MSG_KEX_ECDH_INIT and then flood SSH_MSG_CHANNEL_OPEN messages while SessionKexState::InProgress prevents priority_receiver in russh/src/server/session.rs from being drained. The server continues processing network input and enqueues a ChannelOpenReply for each request on an unbounded channel, allowing one connection to grow memory until the process is terminated. This issue is fixed in version 0.63.2.

Threat Intelligence Overview

EPSS Score
0.3%
Top 80% exploitable
Prevalence
Medium
popular Rust SSH client/server library, but niche vs OpenSSH
Threat Intel
1
1 sources
Exploit
POC
Public exploit code exists
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA Vendor GitHub

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
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

52
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +32
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-73429 MEDIUM POC
5.3 Aug 12

Denial-of-service in russh's Curve25519 key exchange client path allows any malicious SSH server to crash a connecting r

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

Vendor StatusVendor

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