Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain co-tenant access or MITM position on broker
-
DeliveryIntercept victim's system.describe request
-
ExploitRespond with crafted javaReturnType naming classpath gadget
-
ExecutionVictim JVM executes Class.forName() with attacker input
-
PersistStatic initializer of targeted class runs in victim process
-
Impacttype confusion via mapper.parse enables secondary data manipulation
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V15 - Secure Coding and Architecture Reflection safety, class allowlisting
|
| Exploitation Conditions | Exploitation requires the attacker to control or intercept the system.describe response returned to a JsonRpcClient during its initialization phase. Two concrete paths satisfy this: (1) the attacker operates a service registered on the same RabbitMQ broker and exchange as the victim - plausible in multi-tenant or shared-infrastructure deployments; or (2) the attacker performs a man-in-the-middle attack on the network path between the client and broker, which requires either absence of TLS or failure to validate the broker's certificate. The victim application must specifically use com.rabbitmq.tools.jsonrpc.JsonRpcClient - the vulnerability does not affect applications using only the core AMQP Channel/Connection API. The attacker cannot introduce new classes; they can only trigger static initializers of classes already present on the victim's classpath, meaning gadget availability is an implicit precondition. The CVSS 4.0 PR:L metric indicates some level of broker access privilege is assumed for the attacker. Exploitation is limited to JVM-based applications running amqp-client versions prior to 5.33.0 with the JSON-RPC feature in active use. |
| Impact | The CVSS 4.0 score of 7.5 (AV:N/AC:L/AT:P/PR:L/UI:P/VC:H/VI:H/VA:H/SC:L/SI:L/SA:L) reflects serious CIA impact on the client process moderated by specific attack requirements (AT:P) and the need for low-privilege broker access (PR:L). The AT:P condition is the decisive real-world gating factor: exploitation is confined to attackers who either share a RabbitMQ broker with the victim or can intercept unencrypted AMQP traffic, neither of which is trivially achieved in TLS-protected, well-segmented deployments. The technique itself - arbitrary Class.forName() with static initializer execution - is conceptually mature in the Java security community and does not require novel exploit development, increasing concern for motivated attackers in susceptible environments. The absence of CISA KEV listing and public POC code suggests exploitation remains opportunistic or unreported rather than widespread. The vulnerability is scoped to applications specifically using JsonRpcClient, not all RabbitMQ Java client users, which materially reduces the exposed population. Priority should be highest for deployments using shared or multi-tenant brokers without TLS mutual authentication. |
| Exploit ScenarioDerived | An attacker with co-tenant access on a shared RabbitMQ broker deploys a malicious JSON-RPC service on the same exchange targeted by the victim application. When the victim's JsonRpcClient initializes and issues its system.describe call, the attacker's service responds with a crafted javaReturnType value naming a class already on the victim JVM's classpath that contains a dangerous static initializer - for example, a class that opens an outbound connection, executes a subprocess, or leaks credentials upon load. The victim JVM immediately executes that static initializer via Class.forName(), achieving attacker-directed code execution within the client process without any additional steps. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 18, 2026
Unvalidated Class.forName() with initialization enabled in RabbitMQ Java Client's JSON-RPC tooling allows a network-positioned attacker to trigger arbitrary static initializers in the victim JVM. Applications using com.rabbitmq:amqp-client before 5.33.0 that employ the JsonRpcClient class are exposed when an attacker can control or spoof the system.describe broker response - either as a co-tenant on a shared broker or via network interception. Successful exploitation achieves code-like effects through static initializer execution and a secondary type-confusion path via mapper.parse, with full confidentiality, integrity, and availability impact on the client process. No public exploit identified at time of analysis, and this CVE is not listed in CISA KEV.
RemediationAI
Upgrade to com.rabbitmq:amqp-client version 5.33.0, which is the vendor-released patch. The fix introduces a static SAFE_RETURN_TYPES allowlist covering primitives, String, Map, List, and common boxed types; any class name received from the remote service description that is not in this allowlist causes construction to fail with an IllegalStateException rather than reflectively loading the class. Applications legitimately requiring custom return types must use the new JsonRpcClient(RpcClientParams, JsonRpcMapper, Set<Class<?>>) constructor to pass an explicit allowlist. The release is documented at https://github.com/rabbitmq/rabbitmq-java-client/releases/tag/v5.33.0 with fix commits at https://github.com/rabbitmq/rabbitmq-java-client/commit/0032f75f9dc3df847f94b2b85a16119250bf63cb and https://github.com/rabbitmq/rabbitmq-java-client/commit/9f8e7efd0c648f235dc0e96232ae7efa75ea4fa8. If immediate patching is not feasible, enforce TLS with server certificate validation on all AMQP connections to eliminate the MITM interception path, and ensure the RabbitMQ broker is not shared with untrusted co-tenants. As a more aggressive workaround, replacing JsonRpcClient usage with standard AMQP messaging patterns eliminates the attack surface entirely, though this requires application-level refactoring.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in maven, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
CWE-470 (Use of Externally-Controlled Input to Select Classes or Code) is the root cause. During JsonRpcClient initialization, the client issues a system.describe RPC call and receives a service description from the AMQP queue. The response JSON contains javaReturnType fields which are reflectively applied via JSONUtil.tryFill() → setJavaReturnType() → computeReturnTypeAsJavaClass() → Class.forName(javaReturnType, initialize=true, classLoader). In Java, Class.forName() with initialization enabled unconditionally executes the target class's static initializer block - a well-understood vector in the Java deserialization-gadget ecosystem. A secondary attack surface exists at JsonRpcClient.java:168 where the loaded class from getReturnType() is passed to mapper.parse(replyStr, expectedType), enabling type confusion. The affected Maven coordinate is com.rabbitmq:amqp-client and the CPE is cpe:2.3:a:rabbitmq:rabbitmq-java-client:*:*:*:*:*:*:*:*. The flaw exists only in the com.rabbitmq.tools.jsonrpc package, not in the core AMQP messaging API.
Know when Rabbitmq gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:P/PR:L/UI:P/VC:H/VI:H/VA:H/SC:L/SI:L/SA:L
Broker co-tenancy or MITM interception required for exploitation raises AC:H; low broker-access privilege needed (PR:L); victim must invoke JsonRpcClient (UI:R); full CIA impact confined to client process (S:U).
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
The RabbitMQ Java client library allows Java and JVM-based applications to connect to and interact with RabbitMQ nodes. Prior to 5.33.0, com.rabbitmq.tools.jsonrpc.ProcedureDescription receives a javaReturnType value in an untrusted system.describe response and passes it through JSONUtil.tryFill, setJavaReturnType, and computeReturnTypeAsJavaClass to Class.forName(javaReturnType) with initialization enabled. An attacker able to answer the JsonRpcClient request through a shared broker or network interception can select a class already present in the victim JVM and trigger its static initializer, while JsonRpcClient.java later passes getReturnType output to mapper.parse and may also create type confusion. Successful exploitation can affect confidentiality, integrity, and availability in the client process. This issue is fixed in version 5.33.0.
Blast Radius
ecosystem impact- 4 maven packages depend on com.rabbitmq:amqp-client (3 direct, 1 indirect)
Ecosystem-wide dependent count for version 5.33.0.
Articles & Coverage 2
Executive ViewAI
The RabbitMQ Java Client library (amqp-client versions before 5.33.0) contains a critical vulnerability that allows attackers to execute malicious code when applications use the JsonRpcClient component. An attacker positioned on the network or as a co-tenant on shared broker infrastructure can exploit this by intercepting or spoofing broker communications, potentially compromising the confidentiality, integrity, and availability of the application and its data. Organizations using this library must immediately identify affected systems and implement protective controls.
Implement network segmentation to isolate affected applications on dedicated broker instances or separate network segments to prevent attacker positioning; deploy network-level monitoring and authentication controls on broker communication channels to detect and prevent broker response spoofing; disable or remove JsonRpcClient functionality from applications if it is not actively required; restrict access to shared broker infrastructure to limit co-tenancy exploitation vectors.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Sensitive credential disclosure in RabbitMQ affects installations running the management plugin with OAuth 2 configured
Pivotal RabbitMQ, versions 3.7.x prior to 3.7.21 and 3.8.x prior to 3.8.1, and RabbitMQ for Pivotal Platform, 1.16.x ver
Denial of service in the RabbitMQ Java client library (com.rabbitmq:amqp-client ≤ 5.30.0) allows a malicious or compromi
An issue was discovered in Pivotal RabbitMQ 3.x before 3.5.8 and 3.6.x before 3.6.6 and RabbitMQ for PCF 1.5.x before 1.
Parsing desynchronization in the RabbitMQ amqp091-go AMQP 0.9.1 client library before 1.13.0 lets a malicious or comprom
RabbitMQ's amqp091-go Go client library, in all versions before 1.13.0, builds TLS configuration from amqps:// URIs with
RabbitMQ is a multi-protocol messaging broker. Rated medium severity (CVSS 5.4), this vulnerability is remotely exploita
RabbitMQ brokers that use the OAuth2 plugin can silently fall back to disabled TLS certificate verification when no CA b
Silent AMQP 0.9.1 metadata corruption in the RabbitMQ amqp091-go Go client library prior to 1.13.0 lets an application t
TLS client-authentication bypass in the RabbitMQ trust-store plugin lets a remote unauthenticated attacker whose forged
TLS certificate validation is completely bypassed in the RabbitMQ Java client library (`com.rabbitmq:amqp-client`) prior
Denial of service in the official RabbitMQ Go client library amqp091-go (versions prior to 1.13.0): a malicious, comprom
EUVD-2026-61043
GHSA-6g32-pxv4-2wfj
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB