CVE-2026-116774: russh: peer-declared zero maximum packet size permanently stalls channel writes (silent AsyncWrite hang)
russh 0.60.0 through 0.64.1 accepts a peer-declared maximum packet size of 0 on a channel, and then every AsyncWrite on that channel hangs forever without an error. A malicious authenticated client or a malicious server can strand tasks and connections in any russh-based app. Upgrade to russh 0.65.
Published Oct 30, 2026 · Analysis Oct 31, 2026
What an attacker can do
A peer sends maximum packet size = 0 in CHANNEL_OPEN (against a server) or CHANNEL_OPEN_CONFIRMATION (against a client). OpenChannelMessage::parse and the confirmation decoder in russh/src/parsing.rs do not validate it. The value flows into the channel write state.
In ChannelTx::poll_writable (russh/src/channels/io/tx.rs), the writable size is the minimum of max packet size, window size and buffer length. With a cap of 0 this is always 0, so the write future returns Poll::Pending and no window adjust can change that. This path serves Channel::data(), make_writer() and into_stream(). The *_bytes variants already return Error::Inconsistent for a zero cap, so only the AsyncWrite path hangs.
The failure is silent. Nothing is logged and no error reaches the handler, so write timeouts and cleanup paths do not run. On a server, an authenticated client opens a session channel with size 0. The next echo, shell prompt or SFTP write strands the handler task. Keep-alive traffic resets the default 600 s inactivity_timeout, so the attacker can keep resources held. A client has inactivity_timeout set to None by default, so a malicious server can stall its writes indefinitely.
The attacker needs a login on a server, or must control the server a client connects to. The impact is availability only.
Who is affected
Versions 0.60.0 through 0.64.1 are affected. The reporter says the ChannelTx logic predates 0.60, so treat older releases that ship channels::io::ChannelTx as affected too. Both server and client code are exposed if they write through Channel::data(), make_writer() or into_stream(). Check your version:
cargo tree -i russhOn 0.60.x the other write paths also lack the zero guard, because it was added in 0.61.0.
russh
- Ecosystem
- Rust (crates.io)
- Affected
- >= 0.60.0, <= 0.64.1
- Fixed in
- 0.65
- Check
cargo tree -i russh
How to fix it
Upgrade to russh 0.65.
cargo update -p russhThe fix (commit 39cb9db) makes OpenChannelMessage::parse and a new ChannelOpenConfirmation::parse return Error::Inconsistent when the maximum packet size is 0. The client and server handlers use the new parse method. The advisory lists no other workaround.
How to tell if you were hit
Look for server or client tasks that are parked in a write on a channel and never finish, while the connection stays up. Typical signs are echo or SFTP handlers that never return, growing counts of open channels or tasks, and connections that do not time out. Nothing is logged, so inspect the channel open packets: a maximum packet size of 0 is the trigger, and legitimate peers use 32768 or more (RFC 4254 section 5.1). On a server, check which authenticated users hold stalled channels.
Original advisory
From the GitHub Advisory Database (CC BY 4.0).
Summary
A peer can advertise maximum packet size = 0 in its channel-open message (CHANNEL_OPEN when attacking a server, CHANNEL_OPEN_CONFIRMATION when attacking a client). russh accepts the value without validation and copies it into the channel write state, where it caps the size of every outgoing data chunk. In the AsyncWrite code path (ChannelTx::poll_writable, used by Channel::data(), Channel::make_writer() and Channel::into_stream()), a cap of 0 makes every write future stay Poll::Pending forever: writable = max_packet_size.min(window_size).min(buf_len) is always 0, and no future event can ever raise it (a static maximum packet size of 0 can never be satisfied by any amount of peer-granted window). The write neither completes nor errors, so the application task hangs silently.
Every other write path in russh already treats max_packet_size == 0 as an error (Error::Inconsistent): Channel::reserve_writable_chunk (russh/src/channels/mod.rs:363-365) and the session packetizers (russh/src/session.rs:489-492 and 549-552). The AsyncWrite path is the only one that lacks the guard - it contradicts the crate's own invariant.
Root cause
(1) Peer value accepted without validation:
russh/src/parsing.rs:44(OpenChannelMessage::parse):let maxpacket = map_err!(u32::decode(r))?;stored asrecipient_maximum_packet_size(:25-30); no range check. Same forChannelOpenConfirmation::decodeatrussh/src/parsing.rs:194-207.- The only packet-size validation anywhere is an upper bound on the *local* config that merely logs (
russh/src/client/mod.rs:1189-1194,russh/src/server/mod.rs:912-917). Nothing validates the peer's value - 0 passes silently.
(2) The value flows into the channel write state verbatim:
- Server:
russh/src/server/encrypted.rs:1877-1900-ChannelParams { recipient_maximum_packet_size: msg.recipient_maximum_packet_size, .. }, thenChannel::new(..., channel_params.recipient_maximum_packet_size, ...). - Client:
russh/src/client/encrypted.rs:471-488-parameters.confirm(&msg)(russh/src/lib_inner.rs:519-523) andChannelMsg::Open { max_packet_size: msg.maximum_packet_size, .. }, consumed bywait_channel_confirmation(russh/src/client/mod.rs:698-722), which buildsChannelWriteHalf { max_packet_size, .. }. - The write half hands the value to the writer:
make_writer_ext(russh/src/channels/mod.rs:433-441) andinto_stream(russh/src/channels/mod.rs:661-670) passself.max_packet_sizetoChannelTx::new.
(3) The hang - russh/src/channels/io/tx.rs:82-108 (current v0.64.1, byte-identical in v0.60.0):
fn poll_writable(&mut self, cx: &mut Context<'_>, buf_len: usize) -> Poll<NonZeroUsize> {
...
let writable = (self.max_packet_size).min(*window_size).min(buf_len as u32) as usize;
match NonZeroUsize::try_from(writable) {
Ok(w) => {
*window_size -= writable as u32;
if *window_size > 0 {
self.notify.notify_one();
}
Poll::Ready(w)
}
Err(_) => {
drop(window_size);
ready!(self.window_size_notication.poll_unpin(cx));
self.window_size_notication = WatchNotification::new(Arc::clone(&self.notify));
cx.waker().wake_by_ref();
Poll::Pending
}
}
}With max_packet_size == 0, writable is always 0 regardless of window_size and buf_len; the task parks on the window notification, gets re-polled on every CHANNEL_WINDOW_ADJUST, recomputes 0, and parks again - forever.
(4) The guard exists everywhere else:
// russh/src/channels/mod.rs:363-365 (used by send_bytes -> data_bytes / extended_data_bytes)
if self.max_packet_size == 0 {
return Err(Error::Inconsistent);
}
// russh/src/session.rs:490-492 and :550-552 (packetizer)
if max_packet_size == 0 {
return Err(crate::Error::Inconsistent);
}Note that Channel::data(reader) (russh/src/channels/mod.rs:321-323) goes through send_data -> tokio::io::copy(&mut data, &mut tx) (:350-360) into the same ChannelTx, so the primary documented data API hangs as well; only the *_bytes variants reach the guard.
Attack scenarios
- Server (authenticated remote DoS): with the default configuration, an authenticated client opens a session channel advertising
maximum packet size = 0. Whenever the server application writes on that channel throughAsyncWrite(echo, shell prompts, SFTP - russh's own examples echo viainto_stream()), the write future never completes. The handler task is stranded and no error surfaces, so application cleanup paths do not trigger. Repeat per channel and per connection; keep-alive traffic resets the serverinactivity_timeout(default 600 s), so stranded resources persist as long as the attacker wants. - Client (malicious server): a malicious or buggy server confirms an opened channel with
maximum packet size = 0; the client application's writes on that channel stall forever. The clientinactivity_timeoutdefaults toNone, so nothing ever tears the session down. - This is distinct from a
window_size == 0stall: a zero window is dynamic flow control that a well-behaved peer releases as soon as its buffers drain, whilemaximum packet sizeis a static peer declaration where 0 can never be satisfied by any future packet. RFC 4254 section 5.1 recommends a minimum of 32768 - legitimate peers do not send 0.
Impact
Permanent, silent denial of service for the affected writes, with stranded tasks/channels/connections that accumulate for the attacker - resource exhaustion of a server or of a client application. Because the failure mode is Poll::Pending instead of Err, ordinary application mitigations (error handling, timeouts on writes, connection teardown) do not engage on their own.
Reproducer
Two stock russh instances are enough (no raw SSH crafting required):
- Server: default config plus a host key;
channel_open_sessionaccepts and echoes usingtokio::io::copyintochannel.into_stream()(the pattern from russh's own examples). - Client: default config except
config.maximum_packet_size = 0(accepted silently; see above), thenauthenticate_publickey,channel_open_session().await,channel.data(&b"hello"[..]).await.
The client's CHANNEL_OPEN goes out with maximum packet size = 0 (russh/src/client/session.rs:21-44 encodes self.common.config.maximum_packet_size verbatim). All three scenarios below were verified end-to-end against a stock russh v0.64.1 build (ring backend), default settings otherwise:
- control (both sides default, 32768): the server echoes and the client receives
hello; - client
maximum_packet_size = 0: the server prints the received bytes and then the echo write never completes - no data, no error, the client times out; - server
maximum_packet_size = 0: the client'schannel.data(...)future never completes - no error, it times out.
Observed output (abridged):
=== SCENARIO A (control): both sides default (maxpacket 32768) ===
[server] read 5 bytes; echoing via AsyncWrite ...
[server] echo write completed
RESULT A: echo received: "hello"
=== SCENARIO B: client advertises maximum_packet_size = 0 ===
[server] read 5 bytes; echoing via AsyncWrite ...
RESULT B: TIMEOUT after 6s - server-side echo write is permanently stalled (no error, no data)
=== SCENARIO C: server advertises maximum_packet_size = 0 ===
RESULT C: TIMEOUT after 6s - client-side channel.data() is permanently stalledThe server task stays parked inside ChannelTx::poll_writable; nothing is logged and nothing is returned to the handler. The harness source (server: into_stream() echo; client: one config toggle) can be attached on request.
Unit-level sketch of the core defect:
let mut tx = ChannelTx::<Msg>::new(
sender, ChannelId(0),
Arc::new(Mutex::new(4096)), // window_size
Arc::new(Notify::new()), // notify
0, // max_packet_size
None,
);
// poll_write(&mut tx, cx, b"x") stays Poll::Pending forever,
// even after CHANNEL_WINDOW_ADJUST raises `window_size`.Suggested fix
- Validate at parse time (preferred): reject
maximum_packet_size == 0withError::InconsistentinOpenChannelMessage::parseandChannelOpenConfirmation::decode(russh/src/parsing.rs), consistent with the existing guards; optionally clamp any value below the RFC 4254 recommended minimum (32768) instead. - Defense in depth: in
ChannelTx::poll_writable(russh/src/channels/io/tx.rs:82), whenself.max_packet_size == 0, surface anio::Errorfrompoll_writeinstead of returningPoll::Pending.
Both match the treatment PR #695 already applied to the other write paths in v0.61.0 (the reserve_writable_chunk and session packetizer guards).
Affected versions
Verified by inspecting the release artifacts: 0.60.0 through 0.64.1 (current) are affected - poll_writable is byte-identical in v0.60.0 and the peer-value plumbing is present in all of them. The ChannelTx write logic and the peer-value flow predate 0.60 (they go back to the channels::io refactor), so we recommend treating all releases that ship channels::io::ChannelTx as affected. The zero-guards in the other write paths were only added in 0.61.0, so on 0.60.x those paths do not even fail with an error.
Reporter
Tshellauth
Questions
- Does the attacker need credentials?
Against a russh server, yes: the CVSS vector requires low privileges, so the attacker must authenticate and open a session channel. Against a russh client, the attacker must control the server it connects to.
- Why don't write timeouts or errors fire?
The write future returns
Poll::Pendinginstead of an error, so no failure reaches the application. Only a timeout you wrap around the write yourself would end the wait.- Is russh 0.64.1 affected by CVE-2026-116774?
Yes. Versions 0.60.0 through 0.64.1 are listed as vulnerable. The patched version is 0.65.
- Is it exploited in the wild?
No source reports exploitation, and the entry is not in CISA's KEV catalog. The reporter verified it with stock russh v0.64.1 builds in a test.
References
How this page is made: the data panel comes from the GitHub Advisory Database, CISA’s KEV catalog, the NVD and FIRST EPSS, and updates twice a day. The analysis is written by an AI model from the sources listed above and checked by automated rules before it is published. Check versions against the vendor's advisory before you act. Methodology
More Rust (crates.io) vulnerabilities
All Rust (crates.io) entriesCVE-2026-128087
russh kex_done: Shared-secret callback runs before server host-key verification
low3.7Nov 13, 2026CVE-2026-128088
russh try_sign: asynchronous confirmation can sign after agent lock
low2.2Nov 13, 2026CVE-2026-116696
russh's SSH agent server is susceptible to unbound allocations via repeated SSH_AGENT_CONSTRAIN_CONFIRM messages
low3.3Oct 30, 2026CVE-2026-116773
russh's SSH client is susceptible to unbounded allocations via EXT_INFO packets
medium4.3Oct 30, 2026CVE-2026-116794
russh: Agent server never calls `Agent::confirm`, so keys added with the confirm constraint (`ssh-add -c`) sign without confirmation
high8.3Oct 30, 2026CVE-2026-111061
russh: Unbounded memory allocation in agent protocol server via crafted constraint records
medium4.3Oct 19, 2026
