Skip to main content
Mallory
CriticalExploited in the wildCISA KEVPublic exploitVulnerability

CVE-2023-46604: Apache ActiveMQ OpenWire Remote Code Execution

Published Oct 27, 2023 · Updated 5 days ago
Trending this weekNot trendingOutside this week’s top 100
Mention activity · 30 days6 mentions · peak 2 in a dayToday
CVSS9.8Critical · v3.1
EPSS100.0%100th percentile
CISA KEVYesAdded Nov 2, 2023
In the wildActivePer CISA KEV
Vendors
Apache Software FoundationDebian ProjectNetApp
IdentifiersCVE-2023-46604CWE-502 · Deserialization of Untrusted Data
Also known asapache_activemq_cve_2023_46604

CVE-2023-46604 is a remote code execution vulnerability in the Java OpenWire protocol marshaller used by Apache ActiveMQ brokers and clients, including the Legacy OpenWire Module. Manipulating serialized class types in OpenWire messages can cause a vulnerable peer to instantiate attacker-selected classes available on its classpath and execute arbitrary shell commands. Observed exploitation uses Spring ClassPathXmlApplicationContext to load attacker-controlled XML configuration and trigger command execution. Affected ActiveMQ releases include 5.15.15 and earlier, 5.16.0–5.16.6, 5.17.0–5.17.5, and 5.18.0–5.18.2. Exploitation has been observed against Windows and Linux systems since at least October 10, 2023.

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 allows arbitrary command execution with the privileges of the affected broker or client process, compromising the confidentiality, integrity, and availability of accessible resources. Observed attacks have deployed ransomware, remote-access backdoors, cryptocurrency miners, and post-exploitation tools. Attackers can potentially steal accessible data and credentials, establish persistence, disrupt messaging and dependent applications, and use the compromised host for lateral movement. Complete host compromise depends on the process privileges and available follow-on attack paths.

Mitigation

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

Until updates are complete, isolate vulnerable deployments and restrict OpenWire network access to trusted systems through firewalls, segmentation, and access controls. Remove unnecessary external exposure. Monitor for unexpected XML retrieval by Java processes, suspicious OpenWire class references, Java processes spawning command shells, and unapproved installer or payload downloads. These controls reduce exposure or support detection but do not replace patching.

Remediation

Patch, then assume compromise.

Upgrade both Java-based ActiveMQ brokers and clients to a vendor-supported fixed release. The initial fixed versions are 5.15.16, 5.16.7, 5.17.6, and 5.18.3 for their respective branches. Update corresponding Legacy OpenWire Module dependencies as well. Inventory applications and appliances that embed ActiveMQ and obtain downstream vendor updates incorporating the fixes; upgrading a standalone broker does not remediate vulnerable client libraries or bundled copies.

Public exploits

Exploits

24 exploits validated by Mallory's analysis. Hidden: 11 rejected by Mallory's analysis as not a working exploit.

View more in app →
apache_activemq_rce_cve_2023_46604.rbThis repository contains a single Metasploit module that exploits CVE-2023-46604, a deserialization vulnerability in Apache ActiveMQ's OpenWire transport. The exploit targets multiple platforms (Windows, Linux, Unix) and is capable of unauthenticated remote code execution. The module works by connecting to the OpenWire TCP port (default 61616), checking the ActiveMQ version, and then leveraging the vulnerability to instantiate a Spring ClassPathXmlApplicationContext with a malicious XML configuration file served by the module's built-in HTTP server. This configuration causes the target to execute arbitrary OS commands via java.lang.ProcessBuilder. The exploit is weaponized, allowing the attacker to specify any command payload, and is suitable for use in real-world attacks. The only fingerprintable endpoint is the default OpenWire TCP port (61616). The code is well-structured, leverages Metasploit's mixins for network and HTTP server functionality, and includes detection logic for vulnerable versions.Disclosed Oct 27, 2023 · Framework: metasploit · ruby · networkWeaponizedCVE-2023-46604This repository is a lab automation project for CVE-2023-46604 against Apache ActiveMQ, not a standalone custom exploit implementation. The actual exploitation is delegated to Metasploit's module exploit/multi/misc/apache_activemq_rce_cve_2023_46604, so the repository's main purpose is to provision a reproducible attacker/victim environment and automatically launch the exploit. Structure: README.md documents the workflow; PowerShell scripts create/delete VirtualBox VMs and orchestrate SSH-based setup; Bash scripts configure the Debian victim and Kali attacker; kaliCommands.sh contains manual Metasploit commands and network setup notes. The Debian setup script installs OpenJDK 11 and Apache ActiveMQ 5.18.2, assigns the victim IP 192.168.50.10, modifies /opt/activemq/conf/jetty.xml to replace 127.0.0.1 with 0.0.0.0, and starts ActiveMQ. The Kali setup script assigns 192.168.50.20 and writes an exploit.rc Metasploit resource file that configures the ActiveMQ CVE-2023-46604 module with payload cmd/linux/http/x64/shell_reverse_tcp. Main exploit capability: remote command execution against the Debian-hosted ActiveMQ instance, yielding a reverse command shell session back to the Kali VM. The automation uses SSH over localhost-forwarded ports to bootstrap both VMs, then runs msfconsole with the prepared resource script. Fingerprintable infrastructure includes the internal lab IPs 192.168.50.10 and 192.168.50.20, localhost SSH forwards on 2220/2225, Metasploit HTTP services on 8888/8889, the Apache archive download URL, and ActiveMQ configuration paths under /opt/activemq. Overall, this is an operational lab wrapper around a Metasploit exploit rather than original exploit code.KlaasStessens · Disclosed May 1, 2026 · Framework: metasploit · markdown · powershell · network · webWeaponizedActiveMQ-RCEThis repository provides a Golang-based exploit for Apache ActiveMQ's CVE-2023-46604 remote code execution vulnerability. The exploit targets the OpenWire protocol (default TCP port 61616) and works by sending a specially crafted packet that instructs the ActiveMQ server to load a malicious Spring XML bean definition from an attacker-controlled URL. The provided 'poc.xml' payload uses Java's ProcessBuilder to execute arbitrary system commands (the PoC opens the calculator, but this can be changed to any command). The repository contains two main code files: 'main.go' (the exploit logic) and 'poc.xml' (the payload). The exploit is operational and can be used for both detection (by pointing the XML URL to a DNS log) and exploitation (by pointing to a command-executing XML). The README files provide detailed protocol analysis and usage instructions. No framework is used; the exploit is standalone.X1r0z · Disclosed Oct 27, 2023 · go · xml · networkOperationalActiveMQ_RCE_Pro_MaxThis repository is a Java-based GUI tool (ActiveMQ_RCE_GUI) designed to exploit a remote code execution (RCE) vulnerability in Apache ActiveMQ servers (version <= 5.18.2). The main exploit logic is implemented in 'src/main/java/org/example/ActiveMQ_RCE_GUI.java', which provides a Swing-based interface for the user to specify the target IP, port, and a URL hosting a malicious Spring XML payload. The tool connects to the target ActiveMQ server using the provided credentials (default: admin/admin), retrieves the server version, and if the version is vulnerable, it attempts to exploit the server by sending a specially crafted ExceptionResponse containing a reference to the malicious payload. The payload, when loaded by the server, results in arbitrary command execution (e.g., launching calculator). The repository also includes proxy configuration support (SOCKS/HTTP) via a secondary GUI. The exploit requires the attacker to host the payload and have network access to the target's ActiveMQ service port. No specific CVE is referenced, but the exploit targets a known class of deserialization vulnerabilities in ActiveMQ's handling of Spring XML payloads.ImuSpirit · Disclosed Oct 27, 2023 · java · xml · networkOperationalCVE-2023-46604-RCE-Reverse-Shell-Apache-ActiveMQThis repository provides a working exploit for CVE-2023-46604, a remote code execution vulnerability in Apache ActiveMQ. The exploit is implemented in Go (main.go) and is designed to send a specially crafted message to the target ActiveMQ server (default port 61616) that references a malicious XML file (poc-linux.xml or poc-windows.xml) hosted by the attacker. The XML files use Spring's ClassPathXmlApplicationContext to trigger execution of a command on the target: for Linux, it downloads and executes a reverse shell ELF binary; for Windows, it downloads and executes a reverse shell EXE. The payloads are generated using msfvenom and must be hosted on the attacker's web server. The README provides detailed usage instructions, including how to generate payloads and host the XML files. The exploit targets both Linux and Windows platforms and requires the attacker to specify the target IP and the URL of the hosted XML file. The repository structure is straightforward, with the main exploit logic in main.go, configuration in go.mod, and the two XML payload templates for each platform. The exploit is operational and provides a reverse shell to the attacker if successful.SaumyajeetDas · Disclosed Nov 3, 2023 · go · xml · networkOperationalCVE-2023-46604This repository provides an operational exploit for CVE-2023-46604, a remote code execution vulnerability in Apache ActiveMQ's OpenWire protocol due to unsafe deserialization. The repository contains three files: a Python exploit script (exploit.py), a malicious XML payload (poc.xml), and a README.md with usage instructions. The exploit.py script connects to a specified ActiveMQ server (default port 61616) and sends a specially crafted payload referencing the poc.xml file. The poc.xml file, when processed by the vulnerable server, causes it to instantiate a ProcessBuilder that executes a bash reverse shell, connecting back to the attacker's machine (10.10.10.10:9001). The exploit requires the attacker to host the poc.xml file and have the target server access it. The main attack vector is network-based, targeting the OpenWire protocol. The exploit is operational, providing a working reverse shell payload, and is not part of a larger framework.evkl1d · Disclosed Nov 4, 2023 · python · xml · networkOperationalCVE-2023-46604-ActiveMQ-RCE-pseudoshellThis repository provides a working exploit for CVE-2023-46604, a critical remote code execution vulnerability in Apache ActiveMQ due to unsafe deserialization in the OpenWire protocol. The exploit consists of a Python script (exploit.py) that automates the attack: it generates a malicious XML payload (poc.xml) that, when processed by a vulnerable ActiveMQ server, causes arbitrary shell commands to be executed via Java's ProcessBuilder. The script also runs a local HTTP server to serve the XML payload and to receive the output of executed commands from the target server via HTTP POST requests. This enables a semi-interactive pseudo-shell experience, where the attacker can issue commands and receive their output without needing a traditional reverse shell. The exploit requires the attacker to specify both the target ActiveMQ server and an IP/port on their own machine to serve the payload and receive data. The repository includes a README.md with detailed usage instructions and an example session. The main attack vector is network-based, targeting the OpenWire port (default 61616) of the ActiveMQ server. The endpoints involved include the attacker's HTTP server (for serving the payload and receiving data) and the target's OpenWire TCP port. The exploit is operational and provides real command execution on the target, with output exfiltrated over HTTP.duck-sec · Disclosed Nov 12, 2023 · python · xml · networkOperationalCVE-2023-46604-RCEThis repository provides a Python-based exploit for CVE-2023-46604, a critical unauthenticated remote code execution vulnerability in Apache ActiveMQ (versions 5.18.0-5.18.2, 5.17.0-5.17.5, 5.16.0-5.16.6, and all versions before 5.15.16). The exploit consists of a main script (CVE-2023-46604-RCE.py), a sample malicious XML payload (poc.xml), and a README with usage instructions. The Python script crafts and sends a malicious OpenWire packet to the target ActiveMQ server, instructing it to load an attacker-hosted XML file. The XML file leverages Java deserialization to execute arbitrary system commands on the server (e.g., launching calculator or creating a file). The exploit supports targeting multiple hosts and ports, and the payload can be customized by editing poc.xml. The attack vector is network-based, requiring access to the ActiveMQ OpenWire port (default 61616). No hardcoded IPs or URLs are present; the attacker must supply the target and payload URL at runtime.NKeshawarz · Disclosed Nov 18, 2023 · python · xml · networkOperationalCVE-2023-46604This repository provides an operational exploit for CVE-2023-46604, a critical remote code execution vulnerability in Apache ActiveMQ. The exploit consists of a Python script (exploit.py) that targets ActiveMQ servers accessible on TCP port 61616. The script can attack single or multiple targets, reading addresses from a file or command line. It sends a specially crafted OpenWire protocol payload that instructs the target to fetch and process a malicious XML configuration (poc.xml) from an attacker-controlled URL. The XML payload leverages Spring's ClassPathXmlApplicationContext to instantiate a ProcessBuilder, executing a bash reverse shell that connects back to the attacker's server. The repository also includes a README.md with usage instructions and background on the vulnerability. The exploit is not part of a framework and is operational, requiring the attacker to host the XML payload and provide target addresses. The main attack vector is network-based, exploiting insecure deserialization over the OpenWire protocol.mrpentst · Disclosed Dec 9, 2023 · python · xml · networkOperationalactivemq-cve-2023-46604This repository provides a working exploit for CVE-2023-46604, a critical remote code execution vulnerability in Apache ActiveMQ. The exploit leverages the OpenWire protocol's unsafe reflection to trigger the loading of a malicious Spring Bean XML, which in turn executes arbitrary commands on the target system. The repository is structured as follows: - Java components (in 'activemq-exploit') implement an HTTP server (HttpServer.java) that serves the malicious Spring Bean XML (exploit.xml) and an ActiveMQ client (ActiveMQClient.java) that connects to a broker. - The 'vulnerability/Vulnerability.java' file demonstrates the vulnerable reflection logic as found in ActiveMQ's OpenWire marshaller. - Python scripts ('scripts/client_exploit.py' and 'scripts/server_exploit.py') implement the network logic to interact with the OpenWire protocol, send the malicious payload, and trigger the exploit. The client exploit simulates a malicious broker attacking a client, while the server exploit attempts to attack a broker directly. - The payload (exploit.xml) is a Spring Bean definition that instantiates a ProcessBuilder to run a bash command, demonstrating code execution by creating a file on the Desktop. The exploit requires the target to be running a vulnerable version of ActiveMQ with the OpenWire protocol enabled and accessible. The attack vector is network-based, and the exploit demonstrates operational maturity with a working payload and clear instructions for use.tomasmussi · Disclosed Dec 30, 2023 · python · java · networkOperationalActiveMQ-RCE-ExploitThis repository is a functional exploit for CVE-2023-46604, a remote code execution vulnerability in Apache ActiveMQ versions prior to 5.18.3. The exploit is implemented in Java and is structured as a Maven project. The main entry point is 'src/main/java/org/example/Main.java', which provides a command-line interface for launching the exploit against a target ActiveMQ server. The exploit supports two main payload delivery methods: (1) via a malicious Spring XML bean (exp.xml), and (2) via a crafted Shiro INI configuration. The payloads leverage Java deserialization to achieve arbitrary command execution on the target. The exploit can generate payloads for different Java versions and supports both direct command execution and custom bytecode execution. The code includes utilities for generating the necessary serialized objects and for handling the network protocol with ActiveMQ. The exploit is operational and provides command output (echo) to the attacker. The only required endpoint is the ActiveMQ TCP service, typically on port 61616. No hardcoded IPs or domains are present; the target is specified by the user at runtime.Arlenhiack · Disclosed Mar 5, 2024 · java · xml · networkOperationalcve-2023-46604This repository contains a Go-based exploit for CVE-2023-46604, a critical remote code execution vulnerability in Apache ActiveMQ. The main exploit logic resides in 'cve-2023-46604.go', which implements the following capabilities: - Validates if a remote ActiveMQ instance is running and checks its version for vulnerability. - Delivers a Nashorn JavaScript payload via a malicious Spring XML bean, exploiting the deserialization flaw to achieve code execution. - Supports two main payloads: a reverse shell (using Nashorn JS) or a command to download and execute a binary (using curl), both of which are base64-encoded and injected into the target. - Spins up a local HTTP server to serve the malicious XML payload to the target, with the endpoint path randomized per run. - The exploit is configurable via command-line flags for target host/port, callback address, and payload type. The repository is well-structured, with a single main exploit file, build scripts (Makefile, Dockerfile), and documentation (README.md) that provides usage instructions and example output. The exploit is operational and can be used to gain remote code execution on vulnerable ActiveMQ instances accessible over the network.vulncheck-oss · Disclosed Apr 17, 2024 · go · networkOperationalCVE-2023-46604This repository contains an exploit for CVE-2023-46604, a remote code execution vulnerability in Apache ActiveMQ due to unsafe deserialization via the OpenWire protocol. The main exploit script (CVE-2023-46604.py) is written in Python and automates the process of sending a specially crafted payload to a target ActiveMQ server. The payload references a malicious XML file (poc.xml), which must be hosted on an HTTP server accessible to the target. The XML file defines a Spring bean that uses ProcessBuilder to execute a bash reverse shell, connecting back to the attacker's machine. The exploit requires network access to the target's OpenWire port (default 61616) and the ability for the target to fetch the XML payload. The repository structure is straightforward: the Python exploit script, a README (in Spanish) explaining the attack, and the malicious XML payload. The exploit is operational and demonstrates a working remote code execution chain.pulentoski · Disclosed May 31, 2024 · python · xml · networkOperationalCVE-2023-46604This repository provides a working exploit for CVE-2023-46604, a remote code execution vulnerability in Apache ActiveMQ (tested on version 5.18.2). The exploit consists of a Python script (exploit.py) that crafts and sends a specially formatted packet to the ActiveMQ server's TCP port (default 61616). The payload references a malicious XML file (poc.xml) hosted on an HTTP server controlled by the attacker. When the vulnerable ActiveMQ instance processes this XML, it executes a bash command that creates and runs a reverse shell script, connecting back to the attacker's machine (port 4444). The repository includes Dockerfiles and a docker-compose configuration to set up both attacker and victim environments for testing. There is also a sample firewall rule script (rule_protect.txt) to block exploitation. The main exploit capabilities are remote code execution and reverse shell access, with clear instructions and automation for both setup and exploitation.CCIEVoice2009 · Disclosed May 4, 2025 · python · bash · networkOperationalActiveMQ-EXPtoolsThis repository is a standalone Java Swing exploit toolkit for Apache ActiveMQ, not a Metasploit/Nuclei module. The project is Maven-based, with a single executable entry point in src/main/java/cc/kiiy/App.java that launches a GUI (MainFrame). The codebase is organized into service classes for exploitation/detection logic (EnvironmentService, VulnerabilityService), UI panels for each supported CVE and settings, and utility helpers for HTTP and local config handling. Core capability-wise, the tool supports both detection and exploitation. EnvironmentService fingerprints ActiveMQ by requesting the target URL and checking for the Apache ActiveMQ title, and can authenticate to /admin/ using HTTP Basic auth to extract hostname, version, and uptime from the admin console HTML. VulnerabilityService is the main exploit engine. For CVE-2015-5254, it accepts a user-provided Base64 serialized payload, decodes it, wraps it into an ActiveMQObjectMessage, and sends it over OpenWire/JMS to a chosen queue on tcp://<host>:<port> (default 61616), enabling broker-side deserialization when the message is processed/viewed. For CVE-2016-3088, it performs a PUT to /fileserver/<random>.txt and then a MOVE to file:///etc/cron.d/root, planting a cron entry that launches a Perl reverse shell back to the operator. This is a real exploitation path, not just a detector, but it depends on vulnerable behavior and elevated target privileges. The repository also includes support for CVE-2022-41678 workflows. Although the provided content truncates some of the implementation, the UI and service references clearly show functionality to write a default or custom webshell and then execute commands through it, with selectable methods such as auto, log4j2, and jfr. The included JfrTemplate.java contains a large embedded JFR configuration template, indicating one exploitation path abuses JFR-related file write/config behavior. BeanXmlPanel generates Spring BeanXML payloads using java.lang.ProcessBuilder for arbitrary command execution, likely intended to support XML-based ActiveMQ exploitation such as CVE-2023-46604-style xbean loading. The code also contains logic for a Jolokia-based probe labeled CVE-2026-34197 that sends an addNetworkConnector request with a vm://evil?brokerConfig=xbean:<xmlServer> argument, causing the target to fetch attacker-controlled XML from an external server. Network and fingerprintable artifacts are abundant: HTTP(S) access to the target web console and admin paths, OpenWire TCP access to port 61616, PUT/MOVE requests to /fileserver/, file destinations like file:///etc/cron.d/root, attacker XML hosting URLs, and Basic Authorization headers. The GUI exposes global custom headers and proxy settings, allowing the operator to tune requests and route traffic through a local proxy. Overall, this is an operational multi-CVE ActiveMQ exploitation toolkit with a GUI front end, combining reconnaissance, authenticated checks, payload generation, deserialization delivery, arbitrary file write abuse, XML-based RCE testing, and webshell management.Catherines77 · Disclosed Apr 20, 2026 · java · xml · network · webOperationalCVE-2023-46604-RCERepository is a small standalone proof-of-concept exploit for Apache ActiveMQ CVE-2023-46604. It contains three files: a Python exploit script, a README with usage steps, and a malicious Spring XML payload. The main script, CVE-2023-46604-RCE.py, manually constructs an OpenWire packet and sends it over a raw TCP socket to a user-supplied IP and port. The packet embeds the Java class org.springframework.context.support.ClassPathXmlApplicationContext and an attacker-controlled XML URL, which is the core primitive used to exploit the vulnerability. The exploit capability is unauthenticated network-based RCE against a vulnerable ActiveMQ broker. The Python code itself does not execute commands locally; instead, it causes the target Java process to fetch remote XML and instantiate attacker-chosen Spring beans. The included poc.xml demonstrates post-exploitation by creating a java.lang.ProcessBuilder bean with init-method="start" to run a bash reverse shell back to 10.13.4.215:4444. Repository structure and purpose are straightforward: README.md explains how to host poc.xml with python3 -m http.server 8080, start a netcat listener on port 4444, and invoke the exploit script with the target IP, target port, and XML URL. poc.xml is therefore an operational payload rather than just a placeholder, making the repository more than a pure detection or crash PoC. No exploit framework is used; this is a custom standalone Python implementation.REGGYRAIDER · Disclosed Jun 6, 2026 · python · xml · network · webOperationalactivemq-cve-2023-46604-labThis repository is a compact proof-of-concept for CVE-2023-46604, an Apache ActiveMQ remote code execution vulnerability. It contains 6 files: two Docker Compose files for vulnerable and patched lab environments, a README with reproduction steps, a Python exploit sender (poc/main.py), a Python payload generator (poc/generate_poc.py), and a prebuilt malicious Spring XML payload (poc/poc-linux.xml). The exploit flow is straightforward: main.py constructs a raw OpenWire packet containing the Java class name org.springframework.context.support.ClassPathXmlApplicationContext and an attacker-supplied URL. It then opens a TCP connection to the target ActiveMQ broker, defaulting to port 61616, and sends the crafted packet. The target is expected to fetch the remote XML from the supplied HTTP URL and instantiate it. The XML payload defines a java.lang.ProcessBuilder bean with init-method='start', executing 'bash -c touch /tmp/pwned'. This yields demonstrable RCE by creating a marker file inside the target container. Repository structure and purpose: - docker/docker-compose.yml: launches a vulnerable ActiveMQ Classic 5.11.1 container with ports 8161 and 61616 exposed. - docker/docker-compose-fixed.yml: launches a patched ActiveMQ Classic 5.18.3 container for mitigation verification. - poc/main.py: primary exploit entry point; crafts and sends the OpenWire payload over TCP. - poc/generate_poc.py: generates the malicious XML payload file used by the exploit. - poc/poc-linux.xml: ready-made Spring XML payload executing a harmless command. - poc/README.md: detailed lab instructions, including hosting the XML over python3 -m http.server on port 2002 and validating exploitation. This is a real exploit PoC rather than a scanner or detection script. It does not include advanced payload customization or automation beyond a basic command execution demonstration, so OPERATIONAL is the best maturity fit.stefanotractor · Disclosed Aug 19, 2026 · python · yaml · network · webOperationalActiveMQ-CVE-2023-46604This is a small, standalone Python 3 validator for Apache ActiveMQ CVE-2023-46604, not a Metasploit/Nuclei module. The repository contains one primary executable (activemq_validator.py), unit tests, an example explicit-target inventory, CI configuration, README, and license. The primary script uses only the Python standard library and implements target parsing, bounded concurrent delivery, optional TLS, a threaded HTTP evidence server, token-correlated callback collection, status classification, and CSV/JSON reporting. It constructs a loose-marshalled OpenWire ExceptionResponse (type byte 31) whose exception class is org.springframework.context.support.ClassPathXmlApplicationContext and whose message is a unique callback-server XML URL. On vulnerable brokers, this causes ActiveMQ's unsafe unmarshalling path to retrieve and instantiate attacker-controlled Spring XML. XML proof mode is a non-process-launching confirmation of XML retrieval. RCE proof mode embeds a fixed ProcessBuilder-based Linux identity probe or a fixed PowerShell-based Windows identity probe, then returns output to a unique HTTP callback path. The implementation deliberately restricts scope: it requires explicit individual targets and an authorization flag, rejects CIDR input, caps targets/workers/retries, and exposes no arbitrary-command, shell, persistence, staging, or authentication-attack feature. The included tests validate OpenWire frame construction, XML well-formedness, protocol/target parsing, IPv6 handling, TLS scheme handling, and CIDR rejection without contacting a target.Bhanunamikaze · Disclosed Sep 1, 2026 · python · yaml · network · webOperationalvulhub-activemq-cve-2023-46604This is a deliberately vulnerable training lab containing a standalone exploit for CVE-2023-46604, not a Metasploit or Nuclei module. app/poc.py uses Python's standard library to send a crafted OpenWire ExceptionResponse containing the Spring ClassPathXmlApplicationContext class name and an operator-supplied XML URL. Missing class-type validation permits construction of that class, loading attacker-controlled bean definitions. app/poc.xml starts java.lang.ProcessBuilder to run touch /tmp/activeMQ-RCE-success. The client only sends the message: it does not read results, host the XML, or verify execution. Despite the CTF metadata's shell objective, the included payload only creates a marker file. The 31 supplied files comprise the vendored Vulhub walkthrough, Python client, XML payload and Compose file under app/; a reference ActiveMQ Dockerfile under base/; the authoritative isoloom.yml lab specification; generated Docker, Kubernetes, Vagrant, Proxmox and six cloud-provider deployment outputs under .isoloom/; service/version checks; CTF metadata; documentation; and GitHub validation/publication workflows. The count of 14 code-bearing files includes Python, shell, Ruby, Terraform, the executable Spring XML payload and the Dockerfile, excluding YAML manifests and workflow-embedded scripts. The lab runs vulhub/activemq:5.17.3 on linux/amd64, publishing OpenWire 61616 and web console 8161. Generated Docker publishing defaults to loopback, cloud firewalls restrict ingress to an operator-supplied CIDR, but Kubernetes includes a LoadBalancer and ingress permission from 0.0.0.0/0 on both service ports. Outbound connectivity supports XML retrieval. The vendored Compose configuration additionally publishes JDWP 5005; the main Isoloom lab does not. checks/openwire.sh only verifies the broker greeting and version, and is not a definitive vulnerability or exploitation test. Cleanup commands in provisioning and CI have identifiable maintenance purposes and do not indicate a fake exploit. Only ActiveMQ 5.17.3 is concretely instantiated. The walkthroughs give inconsistent broader affected-version descriptions, so those were not treated as precise version ranges. No fixed malicious callback, exfiltration endpoint or persistence mechanism is present. The analyzed repository's original URL, git reference and archive size were not supplied; their fields use empty strings and zero for unavailable metadata. UPSTREAM.md identifies the vendored Vulhub source commit as 8fd63916f7a8711e2e01dda0d27237e4d6175d38, not necessarily the analyzed repository's revision. Findings are based on static inspection, without execution.CyberCTF · Disclosed Oct 8, 2026 · python · bash · networkOperationalCVE-2023-46604The repository contains five files: an MIT license, usage and mitigation documentation, two standalone Python scripts, and a Spring XML payload template. The three executable or declarative code artifacts are exploit.py, gen_payload.py, and payloads/poc.xml.template; shell commands are embedded within the generator and template. No exploitation framework is used. exploit.py connects directly to a configurable OpenWire endpoint and sends a crafted ExceptionResponse message carrying org.springframework.context.support.ClassPathXmlApplicationContext and an operator-provided XML URL. The vulnerability is more specifically unsafe exception-class instantiation during OpenWire unmarshalling: the supplied class is instantiated without enforcing the expected Throwable type. Loading the resulting Spring context starts a ProcessBuilder bean from the remote XML. The trigger requires no credentials and neither fingerprints the broker version nor checks a response to establish successful execution. gen_payload.py writes XML to standard output and supports an HTTP callback check, Bash and sh/netcat reverse shells, and arbitrary literal command arguments. It XML-escapes arguments and Base64-wraps shell commands. The reference template defaults to a benign marker-file creation command. The rm -f operation in the FIFO payload is preparation for a named pipe, not evidence of a fake exploit. Important reliability limitations are visible in the source. The sh payload wrapper uses brace expansion, which many /bin/sh implementations, including dash and common BusyBox ash configurations, do not support; the advertised sh-only option is therefore not portable. The OpenWire frame length is fixed at 32 rather than calculated from the serialized message, which can fail when frame sizes are enforced. The script's success message means only that the trigger was sent; execution requires independent callback, file, or shell confirmation. Included command payloads primarily assume a Unix-like broker host, although the underlying Java vulnerability is not inherently Unix-specific. No fixed external command-and-control address is embedded: target, XML-hosting URL, callback URL, and reverse-shell destination are operator inputs. Private IP addresses in examples are illustrative. No original repository URL, revision, or archive size was supplied; those metadata fields are left empty or represented by zero. The five listed file sizes total 13,135 bytes, which is not a measured archive size. Analysis is static; successful exploitation was not tested.Theocyg · Disclosed Oct 21, 2026 · python · xml · networkOperationalB63-POC-CVE-2023-46604This standalone repository implements CVE-2023-46604 against Apache ActiveMQ Classic. A malicious, loose-encoded OpenWire ExceptionResponse supplies a Java class name and String constructor argument before authentication or normal connection negotiation. Vulnerable unmarshalling instantiates the supplied class before checking whether it is a Throwable. The selected Spring ClassPathXmlApplicationContext gadget retrieves an attacker-hosted bean definition, whose ProcessBuilder initialization executes a shell command. The default URL produces a reported 127-byte frame; frame length changes with the configured URL. The 14 files comprise two Python exploit drivers under poc/, a Dockerfile, Compose configuration and Bash reliability harness under lab/, six captured transcripts under evidence/, plus README, license and ignore files. The five code/build-configuration files are counted together. exploit_opt.py is fully visible and implements frame generation, an HTTP payload server, reverse-shell listener and automatic impact probe. exploit_readable.py provides documented argparse options for fetch checking, arbitrary commands, configurable listeners and interactive operation, but its central implementation is truncated in the supplied content. Consequently, not every claim about that variant can be independently checked from the visible source. An important discrepancy is that exploit_opt.py --check still serves the reverse-shell command: it only suppresses creation of the local listener and judges success by HTTP fetch count. It is therefore not a non-executing detection mode; a vulnerable broker can still attempt to launch bash and connect back. A fetch indicates gadget activation, not necessarily successful ProcessBuilder execution. Conversely, no fetch can reflect routing, filtering or callback-address problems rather than a patched target. The optimized driver's normal exit status also does not validate the returned identity; the separate reliability harness strengthens the success condition by requiring both exit 0 and uid=1000(activemq) in output. The lab builds vulnerable 5.17.3 and patched 5.18.3 from Apache release archives with SHA-512 verification, runs both as UID 1000, and publishes OpenWire only on host loopback. The exploit's own HTTP and shell listeners bind to all interfaces by default. Supplied transcripts report successful shell execution, credential-store disclosure and proof-file creation, ten successful runs per variant, a fresh-stack reproduction, and no payload fetch or shell against 5.18.3. These are repository-provided observations, not independently executed verification. No container escape, privilege escalation to root, persistence or fixed external command-and-control service is shown. The visible optimized driver sends the ExceptionResponse directly, despite the README's separate heartbeat-then-Exception description. The documentation lists fixed releases 5.15.16, 5.16.7, 5.17.6 and 5.18.3 and recommends upgrading and restricting OpenWire access. The shipped exploit path targets Classic with Spring available, not an established Artemis broker exploitation path. Original repository URL, Git reference and archive size were not supplied; empty strings and zero are placeholders for unavailable metadata.basesixtythree · Disclosed Oct 22, 2026 · python · bash · networkOperationalActiveMQ-RCEThis repository is a proof-of-concept exploit targeting Apache ActiveMQ versions prior to 5.18.3, 5.17.6, 5.16.7, and 5.15.16. The exploit leverages the ability to send a crafted ExceptionResponse containing a reference to a remote Spring bean XML file, which is then loaded by the target server, resulting in remote code execution. The repository contains Java source code (Main.java) that connects to an ActiveMQ broker (default: tcp://localhost:61616) using default credentials, crafts an ExceptionResponse with a ClassPathXmlApplicationContext pointing to a malicious XML file hosted on an HTTP server (e.g., http://127.0.0.1:8000/1.xml), and sends it to the broker. The malicious XML file, as described in the README, uses ProcessBuilder to execute arbitrary commands (such as launching Calculator). The structure includes Maven build files and minimal Java code, with the main entry point being Main.java. No framework (such as Metasploit) is used; this is a standalone Java exploit. The attack vector is network-based, requiring access to the ActiveMQ broker and the ability to host a malicious XML file.trganda · Disclosed Oct 26, 2023 · java · xml · networkPoCCVE-2023-46604-Apache-ActiveMQ-RCE-expThis repository contains a Python proof-of-concept exploit (attack.py) targeting Apache ActiveMQ (notably version 5.18.3) via the OpenWire protocol. The exploit script constructs a specially crafted OpenWire packet referencing a malicious XML file and sends it to the target ActiveMQ server (default port 61616). The README provides usage instructions and references to vulnerability analysis resources. The exploit requires the attacker to host a malicious XML file and have network access to the target's ActiveMQ service. The repository structure is simple, consisting of a single exploit script and a README. The exploit demonstrates remote code execution capabilities by leveraging a deserialization vulnerability in ActiveMQ.justdoit-cai · Disclosed Nov 8, 2023 · python · networkPoCSSP-Assignment-3-RCEYouLaterThis repository is a proof-of-concept exploit for CVE-2023-46604, a remote code execution vulnerability in Apache ActiveMQ (tested on version 5.15.10). The exploit consists of a Python script (attacker/exploit.py) that crafts and sends a malicious OpenWire protocol packet to the target's TCP port 61616. The packet instructs the server to load a Spring XML configuration from a URL (hosted by attacker/serve.py on port 8000), which contains a bean definition that triggers arbitrary command execution (touching a file in /tmp). The repository includes a Docker Compose environment to run a vulnerable ActiveMQ instance for testing. The exploit demonstrates successful code execution by creating a file on the victim server. The main attack vector is network-based, targeting the OpenWire port, and the exploit requires the attacker to host a malicious XML file accessible to the victim server.RockyDesigne · Disclosed Jan 4, 2026 · python · xml · networkPoC
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
Apache Software FoundationActivemq Legacy Openwire Moduleapplication
Apache Software FoundationApache ActiveMQapplication
Debian ProjectDebian Linuxoperating_system
NetAppE-Series Santricity Unified Managerapplication
NetAppE-Series Santricity Web Services Proxyapplication
NetAppSantricity Storage Pluginapplication
FAQ

Frequently asked questions

Is CVE-2023-46604 exploited in the wild?
Yes. As of Nov 11, 2026, Mallory has reports of exploitation in the wild, and CISA added it to KEV on Nov 2, 2023.
Is there a public exploit for CVE-2023-46604?
Yes. Mallory tracks 24 public exploits or proofs of concept for CVE-2023-46604, the earliest disclosed Oct 26, 2023.
Is there a patch for CVE-2023-46604?
Upgrade both Java-based ActiveMQ brokers and clients to a vendor-supported fixed release. The initial fixed versions are 5.15.16, 5.16.7, 5.17.6, and 5.18.3 for their respective branches.
What products are affected by CVE-2023-46604?
Apache Software Foundation Apache ActiveMQ, Apache Software Foundation Activemq Legacy Openwire Module, Debian Project Debian Linux, NetApp E-Series Santricity Unified Manager, NetApp E-Series Santricity Web Services Proxy, and 1 more.
How severe is CVE-2023-46604?
CVE-2023-46604 has a CVSS v3.1 score of 9.8 (Critical) and an EPSS score of 100.0% (100th percentile) as of Nov 11, 2026.
Activity feed

Recent activity

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

View more in app →
the hacker newsNews · Nov 11, 2026Hackers Target Qlik Sense Servers With Reverse Shells, Stage ActiveMQ and Veeam ExploitsAn Apache ActiveMQ vulnerability for which an exploit was discovered on the operator's exposed staging infrastructure. The finding suggests preparation for broader attacks, but the article does not confirm exploitation of this vulnerability.Read more ↗cyberveilleNews · Nov 2, 2026Doorway Botnet : campagne massive de compromission IoT, routeurs et serveurs d'entreprise | CyberVeilleThe Doorway operation reportedly targets ActiveMQ using exploits described as CVE-2023-46604-style. Its delivery chain includes Spring ClassPathXmlApplicationContext injection and XML payloads. The wording associates the campaign with this vulnerability but does not independently establish the exact CVE used on individual victims.Read more ↗cloudsek blogNews · Oct 28, 2026The Doorway Botnet: Inside a Large-Scale IoT and Network Device Compromise Campaign | CloudSEKThe content associates this vulnerability with ActiveMQ Java processes spawning shells and describes recovered Spring ProcessBuilder delivery templates. These chains retrieve or execute platform-specific loaders and clients. The CVE attribution is qualified as 'style' in the detection rule; successful exploitation of this specific CVE is not independently established.Read more ↗metasploit pull requestsNews · Sep 10, 2026Automated Vulnerable Environment Provisioning by Nayeraneru · Pull Request #21895 · rapid7/metasploit-framework · GitHubAn Apache ActiveMQ remote-code-execution vulnerability referenced by a Metasploit exploit-module filename.Read more ↗
+55 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 evidence15Every report linking this CVE to a named adversary.
Associated malware126Malware 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 activity39Community discussion across Reddit, Mastodon, and other social sources.