Skip to main content

Apache Camel JGroups CVE-2026-88900

| EUVDEUVD-2026-104244 HIGH
Deserialization of Untrusted Data (CWE-502)
2026-10-19 apache GHSA-wqmw-6vq7-3mxp
8.8
CVSS 3.1 · Vendor: apache
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Reach cluster multicast group on adjacent network
  2. Delivery
    Join unauthenticated default JGroups channel
  3. Exploit
    Send crafted serialized ObjectMessage
  4. Execution
    JGroups deserializes payload on receive thread
  5. Persist
    Gadget chain executes during deserialization
  6. Impact
    Remote code execution in Camel process

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V1 - Encoding and Sanitization Safe deserialization, type allowlists
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Initial Access

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Requires the camel-jgroups consumer running with its default channel - created via new JChannel() when neither the 'channel' nor 'channelProperties' option is configured - which uses the stock JGroups UDP multicast stack with no AUTH protocol and no encryption, allowing any host that can reach the cluster's multicast group or bind port to join and send messages without credentials. Exploitation to RCE additionally requires a usable deserialization gadget chain already present on the application classpath and the absence of a JVM-wide -Djdk.serialFilter (camel-jgroups installed no ObjectInputFilter and the shipped JGroups versions apply none). Key LIMITING factors: the default UDP multicast transport means the attacker must be on an adjacent network (AV:A), not the open internet; and without a usable gadget chain on the classpath, code execution cannot occur. Deployments that set a channel/channelProperties with AUTH and encryption, or a JVM-wide serialization filter, are not exploitable via this path.

Impact

This is a genuine high-severity concern but not an emergency. The vendor-assigned CVSS 3.1 vector (AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H = 8.8) is internally consistent with the description: the stock JChannel() created by camel-jgroups multicasts over UDP without the AUTH protocol or encryption, so any host that can reach the cluster's multicast group or bind port can send messages with no credentials (supporting PR:N), and a crafted serialized object yields full C/I/A compromise via RCE. The adjacent attack vector (AV:A) - not network (AV:N) - is the single most important risk-limiting signal and is correctly applied, since the default UDP multicast transport confines reachability to an adjacent network rather than the open internet. No EPSS score, KEV listing, or POC was provided in the input; exploitation status is therefore 'no public exploit identified at time of analysis.' A second, equally material limiting factor is that successful RCE requires a usable deserialization gadget chain to already be present on the application classpath - without one, the flaw degrades to a lower-impact deserialization issue. The vendor itself notes severity is 'high rather than critical' precisely because of the adjacent-network constraint plus the gadget-chain dependency. Bottom line: prioritize patching for any deployment that actually uses the camel-jgroups consumer with default clustering, but the combination of adjacent-only reach and classpath dependency argues against treating this as broadly wormable. No signals are in conflict; the main gap is the absence of EPSS/KEV/POC data to gauge real-world interest.

Exploit ScenarioDerived

An attacker positioned on a network adjacent to the Camel deployment (e.g., the same broadcast/multicast segment) joins the unauthenticated, unencrypted default JGroups cluster and sends a crafted serialized ObjectMessage to the jgroups consumer. JGroups Java-deserializes the payload on its own receive thread before Camel's receiver runs, and if a usable gadget chain exists on the classpath, arbitrary code executes in the Camel process. No public exploit was identified at time of analysis, and the adjacent (not remote-internet) vector plus the classpath gadget-chain requirement constrain practical exploitation.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 19, 2026

Unauthenticated deserialization of attacker-controlled messages in Apache Camel's camel-jgroups consumer can lead to remote code execution in the Camel process. Any host that can reach the JGroups cluster's multicast group or bind port - adjacent network only, given the default UDP multicast stack - can join without credentials and deliver a crafted serialized object that JGroups deserializes on its own receive thread before Camel's routing logic ever runs. Code execution still depends on a usable gadget chain being present on the application classpath and on no JVM-wide -Djdk.serialFilter being configured, which is why the issue is assessed as high rather than critical; no public exploit code or confirmed active exploitation was identified at time of analysis. Deployments that explicitly configure a channel/channelProperties with AUTH and encryption, or that set a JVM-wide serialization filter, are not exploitable through this path.

RemediationAI

Upgrade to Apache Camel 4.23.0, or to 4.22.1 if on the 4.22.x stream and 4.18.5 if on the 4.18.x stream; EOL lines (4.14.x and earlier, 4.15.x-4.17.x, 4.19.x-4.21.x) must migrate to a supported release, since no backport will be issued. The fixes are tracked in PRs https://github.com/apache/camel/pull/26267, /26281, /26283 and /27205, which add a new 'deserializationFilter' component option taking a jdk.serialFilter-syntax pattern; note this option is defense-in-depth only - it is evaluated after JGroups has already deserialized the payload, so it cannot stop gadget-chain execution inside the receive path on its own. Pair it with a JVM-wide -Djdk.serialFilter (allow-list your expected body classes) as the pre-read control, accepting that a strict list will reject legitimate message types and a permissive one weakens the guarantee. The patched default filter denies java.net. and otherwise allows java., javax. and org.apache.camel., which may break applications that legitimately exchange java.net types in the message body. Additionally, stop relying on the implicit channel: define channelProperties that enable the JGroups AUTH protocol (shared secret) and encryption, and/or replace the default UDP multicast transport with a unicast/TCP configuration, with the trade-off that all cluster members must share credentials, be reconfigured in lockstep, and multicast-based discovery is lost. Where JGroups clustering is not actually required, disable the camel-jgroups consumer entirely, or restrict network access to the cluster's multicast group and bind port to trusted hosts at the network layer as a compensating control while patching.

Affected VersionsENISA

Apache Camel 4.19.0 <4.22.1
Apache Camel 4.0.0 <4.18.5

Affected Packages

euvd apache_camel fix: 4.18.5, 4.22.1

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

CWE-502 (Deserialization of Untrusted Data) in the camel-jgroups component. JGroupsEndpoint.createExchange() sets the Camel exchange body from org.jgroups.Message.getObject(); for an ObjectMessage - the type the Camel jgroups producer itself sends - JGroups Java-deserializes the payload through an ObjectInputStream on its receive thread as the message arrives, and getObject() merely returns the already-materialized object. Neither camel-jgroups nor the JGroups versions shipped with the affected Camel releases installed a java.io.ObjectInputFilter on that path, so unless the JVM was started with a global -Djdk.serialFilter, any serializable class on the classpath could be instantiated and its readObject/readResolve callbacks executed. Because deserialization completes before CamelJGroupsReceiver runs, any check Camel performs can only inspect the resulting object and cannot stop code that executes during deserialization - a pre-read control is required. Compounding the issue, when neither the 'channel' nor 'channelProperties' option is set the consumer builds its channel with new JChannel(), i.e. the stock JGroups protocol stack that multicasts over UDP with no AUTH protocol and no encryption, so cluster membership is effectively unauthenticated for anyone able to reach the multicast group or bind port. Per the assessed vector (AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), the attack is adjacent-network, unauthenticated, and low-complexity, with full confidentiality, integrity and availability impact if a gadget chain is available.

Know when Apache Camel 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

Vendor (apache) PRIMARY 8.8 HIGH
AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 8.8 HIGH

AV:A because default UDP multicast confines reach to an adjacent network; PR:N as the stock channel has no AUTH; full C/I/A from in-process RCE; scope unchanged.

3.1 AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
4.0 AV:A/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (apache).

CVSS VectorVendor: apache

Attack Vector
Adjacent
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

DescriptionCVE.org

Deserialization of Untrusted Data vulnerability in Apache Camel Camel-Jgroups component.

This issue affects Apache Camel: from 4.0.0 before 4.18.5, from 4.19.0 before 4.22.1.

JGroupsEndpoint.createExchange(Message), which CamelJGroupsReceiver calls for every message the jgroups consumer receives before the exchange is routed, set the exchange body from org.jgroups.Message.getObject(). For an ObjectMessage, which is the message type the Camel jgroups producer sends, JGroups Java-deserializes the payload through an ObjectInputStream on its own receive thread as the message arrives, and getObject() returns the resulting object. No java.io.ObjectInputFilter was applied on that path unless the deployment had set a JVM-wide serialization filter: camel-jgroups installed none, and the JGroups versions shipped with the affected releases apply none of their own, so any serializable class on the application classpath could be instantiated and its deserialization callbacks run. Unless a channel or the channelProperties option is configured, the consumer creates its channel with new JChannel(), the stock JGroups protocol stack, which multicasts over UDP without the AUTH protocol and without encryption, so any host able to reach the cluster's multicast group or bind port can join the cluster and send messages to the consumer without credentials. Such a host could send a crafted serialized object that leads to remote code execution in the Camel process when a usable deserialization gadget chain is present on the classpath, and no non-default option was required on the consumer. Because JGroups materializes the object before Camel's receiver runs, a check performed by Camel can only inspect the deserialized result and cannot stop code that runs during deserialization, so closing the issue also requires a control that applies before the payload is read, as described in the mitigation. Exploitation requires network access to the cluster's multicast group or bind port, which with the default UDP multicast transport means a host on an adjacent network, and a usable gadget chain on the classpath, which is why the severity is assessed as high rather than critical.

Users are recommended to upgrade to version 4.23.0, which fixes the issue. If users are on the 4.22.x releases stream, then they are suggested to upgrade to 4.22.1. If users are on the 4.18.x releases stream, then they are suggested to upgrade to 4.18.5. The 4.14.x releases stream and earlier, and the 4.15.x to 4.17.x and 4.19.x to 4.21.x release lines, reached end of life before this issue was resolved and will not receive a fix, so deployments on those lines must move to a supported release.

Executive ViewAI

Why It Matters

Apache Camel's camel-jgroups component can allow remote code execution in affected integration processes when an attacker can reach the JGroups cluster network, creating risk to data and downstream systems that depend on those integrations. A vendor patch is available, and no public exploit identified at time of analysis; leadership should prioritize patching because a compromised Camel runtime could undermine trust in integration workflows.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

Prevalence
Medium
Apache Camel is widely used, but the jgroups clustering component is a niche subset
Data Quality
4 sources
Confidence: Medium
EUVD NVD CVE.org Vulnrichment GitHub

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS N/A
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Controlled
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Insecure deserialization occurs when an application converts serialized data (a stream of bytes representing an object's state) back into a living object without proper validation.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

CVE-2026-33453 CRITICAL POC
10.0 Apr 27

Remote code execution in Apache Camel's camel-coap component (versions 4.14.0-4.14.5, 4.18.0 before 4.18.1, and 4.19.0)

CVE-2026-40858 HIGH POC
8.8 Apr 27

Unsafe Java deserialization in Apache Camel's camel-infinispan component allows arbitrary code execution when the ProtoS

CVE-2026-78162 CRITICAL
10.0 Oct 19

Unauthenticated remote code execution affects the camel-hazelcast component of Apache Camel 4.0.0 through 4.18.4 and 4.1

CVE-2026-71300 CRITICAL
9.8 Aug 24

Header-injection in the Apache Camel camel-atmosphere-websocket producer lets an external sender hijack WebSocket messag

CVE-2026-78329 CRITICAL
9.8 Aug 24

Header-filter bypass in the Apache Camel Undertow component (4.11.0-4.14.8, 4.15.0-4.18.3, and 4.19.0-4.21.x) lets remot

CVE-2026-47323 CRITICAL
9.8 May 19

Remote code execution in Apache Camel 3.18.0-4.14.5 and 4.15.0-4.18.1 stems from CXF and Knative HeaderFilterStrategy im

CVE-2026-33454 CRITICAL
9.4 Apr 27

Message header injection in Apache Camel's camel-mail component (3.0.0 before 4.14.6 and 4.15.0 before 4.18.1) lets an a

CVE-2026-46590 HIGH
8.8 Jul 06

Remote code execution via unsafe Java deserialization affects the camel-pqc component of Apache Camel 4.18.0-4.18.2 and

CVE-2026-27172 HIGH
8.8 Apr 27

Unsafe Java deserialization in Apache Camel's camel-consul component (ConsulRegistry / ConsulRegistryUtils.deserialize)

CVE-2026-83531 HIGH
8.8 Oct 19

Expression language injection in the Apache Camel dynamic-router-control endpoint allows a party who can place a message

CVE-2026-78165 HIGH
8.8 Oct 19

Deserialization of untrusted data in the Apache Camel Spring Redis component (camel-spring-redis) allows an authenticate

CVE-2026-46591 HIGH
8.2 Jul 06

Cypher injection in Apache Camel's camel-neo4j producer allows attackers who control JSON key names in the CamelNeo4jMat

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy