CVE-2026-102821

Executive Summary

CVE-2026-102821 is a memory exhaustion vulnerability in Russh, a Rust SSH client and server library, affecting versions prior to 0.63.2. An authenticated remote peer can exploit a state-machine flaw during key exchange to make the server enqueue unbounded channel-open replies, causing one connection to grow process memory until termination. Impact is limited to availability (CVSS 6.5, A:H) and requires prior authentication (PR:L).

Technical Analysis

Russh is a Rust implementation of the SSH protocol supporting both client and server roles. The vulnerability resides in the server session handling in russh/src/server/session.rs and involves the interaction between two components: the key-exchange state machine (SessionKexState) and the channel-open reply path (priority_receiver).

In a normal SSH handshake, the server expects the peer to progress the key exchange by sending SSH_MSG_KEX_ECDH_INIT after the initial SSH_MSG_KEXINIT. Both messages are part of the key exchange (KEX) phase that establishes shared secrets before any channel operations are permitted.

Per the NVD description, an authenticated remote peer can:

1. Send SSH_MSG_KEXINIT without the required follow-up SSH_MSG_KEX_ECDH_INIT.
2. While SessionKexState::InProgress remains set, the priority_receiver in russh/src/server/session.rs is not drained.
3. The server nevertheless continues processing network input and, for each SSH_MSG_CHANNEL_OPEN message received, enqueues a ChannelOpenReply.
4. Because the reply queue (described as an unbounded channel) is not being consumed while KEX is stuck in progress, each channel-open request accumulates memory.
5. A single connection can flood channel-open requests and drive memory growth until the process is terminated.

This is a classic unbounded-resource-consumption / missing-flow-control defect (CWE-400). The root cause is that the server does not enforce KEX completion before accepting and queueing responses to channel-level messages, combined with an unbounded internal channel providing no back-pressure.

The CVSS vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H confirms: network reachable, low attack complexity, low privileges required (authenticated SSH peer), no user interaction, scope unchanged, no confidentiality or integrity impact, and high availability impact. EPSS has not yet scored this CVE, so no probabilistic exploitation estimate is available. No public PoC, no Nuclei template, and no exploit code were identified.

Exploitation Scenarios

Because no public PoC exists, the following chain is inferred from the vulnerability class (unbounded memory growth via un-drained queue) and the mechanics stated in the NVD description. No specific function names beyond those in the description are asserted.

1. Reconnaissance / target identification. The attacker identifies hosts exposing SSH services backed by Russh. Russh is a library, so the banner may be generic; identification may rely on service fingerprinting or knowledge that the target application embeds the library. Any deployment where the attacker can reach the SSH listener and possess valid credentials or an authenticated session qualifies.

2. Triggering the flaw class. After authenticating as a low-privileged remote peer, the attacker initiates a key exchange by sending SSH_MSG_KEXINIT but deliberately omits SSH_MSG_KEX_ECDH_INIT. This leaves SessionKexState::InProgress set and prevents the priority_receiver from being drained.

3. Payload / execution method. With KEX stuck, the attacker sends a sustained stream of SSH_MSG_CHANNEL_OPEN messages over the same connection. The server continues to accept network input and enqueues a ChannelOpenReply per request. Because the reply channel is unbounded and un-drained, memory grows monotonically with the volume of channel-open messages.

4. Post-exploitation impact. The result is a denial of service: process memory is exhausted and the process is terminated, taking down the SSH service for all users. Note this requires an authenticated session (PR:L), so it is not a pre-auth remote DoS. No data disclosure, modification, or code execution is claimed by the available data.

Impact Assessment

The vulnerability is an availability-only defect. CVSS 3.1 base score is 6.5 (Medium) with subscores: AV:N (remotely reachable), AC:L (no special conditions), PR:L (valid low-privileged SSH credentials required), UI:N (no victim interaction), S:U (impact confined to the vulnerable component), C:N, I:N, and A:H (high availability impact).

Affected systems are any services or applications that embed Russh versions prior to 0.63.2 as an SSH server. Blast radius is bounded by authentication: an attacker must first obtain valid credentials, so this is primarily a concern for multi-tenant services, shared SSH gateways, or any environment where authenticated users are untrusted. Successful exploitation consumes process memory on the host, potentially terminating the SSH daemon and any co-located application logic, denying service to legitimate users. Because the library processes untrusted network input, a single malicious authenticated connection is sufficient; scale grows if many sessions can be established. No integrity or confidentiality loss is indicated. Since CVSS scope is unchanged, exploitation does not escape the vulnerable component's security authority.

Detection Guidance

Sigma Rule

title: Suspected Russh SSH Memory Exhaustion via KEX Stalling and Channel-Open Flood
id: 8f2a1c44-5b7e-4d19-9a3e-7c0d2f6b9a12
status: experimental
description: Detects a single SSH session producing an abnormal volume of channel-open events relative to completed key exchange, consistent with CVE-2026-102821.
author: Valters IT Threat Intelligence
date: 2026-01-01
logsource:
  product: linux
  service: sshd
  definition: Requires application or library-level telemetry for Russh server events.
detection:
  selection_channel_open:
    event.action: 'SSH_MSG_CHANNEL_OPEN'
  selection_kex_stalled:
    event.kex_state: 'InProgress'
  timeframe: 1m
  condition: selection_channel_open | count() by source.ip, session.id > 50
fields:
  - source.ip
  - session.id
  - event.action
falsepositives:
  - Legitimate automation opening many parallel channels after a normal handshake.
level: medium
tags:
  - attack.t1499
  - cve.2026.102821

YARA Rule

rule CVE_2026_102821_Russh_KexStall_Artifacts
{
    meta:
        description = "Flags Russh source trees referencing the vulnerable KEX state and channel-open reply handling described in CVE-2026-102821"
        author = "Valters IT Threat Intelligence"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-102821"
        date = "2026-01-01"
        severity = "medium"
    strings:
        $ver_target = /russh[^\n]{0,32}0\.6[0-2]\.[0-9]+/
        $s1 = "SessionKexState" ascii
        $s2 = "priority_receiver" ascii
        $s3 = "ChannelOpenReply" ascii
        $s4 = "SSH_MSG_CHANNEL_OPEN" ascii
        $s5 = "SSH_MSG_KEX_ECDH_INIT" ascii
    condition:
        ($ver_target or 2 of ($s1,$s2,$s3,$s4,$s5)) and filesize < 5MB
}

Suricata IDS Rule

alert tcp any any -> any 22 (msg:"CVE-2026-102821 Possible Russh SSH KEX Stall and Channel-Open Flood (Memory Exhaustion)"; flow:established,to_server; flags:AP; dsize:>0; threshold:type both, track by_src, count 100, seconds 30; classtype:attempted-dos; reference:cve,2026-102821; reference:url,https://nvd.nist.gov/vuln/detail/CVE-2026-102821; sid:2026102821; rev:1; metadata:service ssh;)

Elastic Detection

sequence by source.ip with maxspan=1m
  [network where process.name == "sshd" and network.transport == "tcp" and network.destination.port == 22]
  [any where event.action == "SSH_MSG_CHANNEL_OPEN" and session.kex_state == "InProgress"]

Splunk SPL Query

index=ssh sourcetype=russh:server OR sourcetype=sshd
| search "SSH_MSG_CHANNEL_OPEN"
| stats count AS channel_opens values(kex_state) AS kex_states BY src_ip session_id
| where channel_opens > 50 AND mvfind(kex_states, "InProgress") >= 0
| sort - channel_opens

Wazuh OSSEC Rule

<group name="ssh,russh,">
  <rule id="2026105" level="10" frequency="1" timeframe="60">
    <if_matched_sid>5710</if_matched_sid>
    <match>SSH_MSG_CHANNEL_OPEN</match>
    <field name="kex_state">InProgress</field>
    <description>CVE-2026-102821: Possible Russh SSH KEX stall with channel-open flood (memory exhaustion DoS).</description>
    <mitre>
      <id>T1499</id>
    </mitre>
    <group>dos,</group>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 (UNPATCHED — no patch evidence from any tracked source). Note: the NVD description states the issue is fixed in version 0.63.2, but no vendor patch artifact was independently confirmed by tracked sources.

1. Immediate mitigations (no confirmed patch available):

   • Restrict SSH access to trusted networks and authenticated users only; the flaw requires an authenticated peer (PR:L), so credential hygiene and disabling anonymous/low-trust access materially reduce exposure.
   • Apply per-session and per-process memory limits (e.g., cgroups/rlimits) so a single connection's memory growth is capped and cannot exhaust the host.
   • Deploy connection-rate and channel-open-concurrency limits at the SSH gateway or reverse proxy layer, and terminate sessions that flood SSH_MSG_CHANNEL_OPEN.
   • Monitor for sessions that send SSH_MSG_KEXINIT without SSH_MSG_KEX_ECDH_INIT and then issue sustained channel-open traffic.

2. Patch / upgrade steps:

   • Upgrade Russh to version 0.63.2 or later, which per the NVD description fixes this issue.
   • Rebuild and redeploy any application embedding the library, then confirm the resolved version.
   • Where upgrade is not immediately possible, prioritize the immediate mitigations above.

3. Long-term hardening:

   • Enforce bounded channels / back-pressure on all server-side reply queues so no input stream can grow memory without limit.
   • Require KEX completion (SessionKexState) before accepting and responding to channel-level messages, and reject or rate-limit out-of-order protocol messages.
   • Add fuzz and resource-exhaustion testing for the handshake state machine, and track library dependency versions with SCA tooling.

References

• NVD — CVE-2026-102821: https://nvd.nist.gov/vuln/detail/CVE-2026-102821
• MITRE CWE-400, Uncontrolled Resource Consumption: https://cwe.mitre.org/data/definitions/400.html
• FIRST EPSS (not yet scored for this CVE): https://www.first.org/epss/
• CISA KEV Catalog (no entry for CVE-2026-102821): https://www.cisa.gov/known-exploited-vulnerabilities-catalog
• Russh project (upstream library), version 0.63.2 release: consult the official Russh repository/release notes

No threat actor campaigns, public PoC, or exploit-in-the-wild evidence were identified for this CVE.