Skip to main content

Apache Camel EUVDEUVD-2026-104191

| CVE-2026-85250 HIGH
Improper Restriction of XML External Entity Reference (CWE-611)
2026-10-19 apache GHSA-x9f8-58m2-93q2
7.5
CVSS 3.1 · Vendor: apache
View

Attack ChainAIDerived

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

  1. Access
    Identify Camel endpoint accepting external XML
  2. Delivery
    Submit XML with malicious DOCTYPE/external entity
  3. Exploit
    InputSource bypasses hardened parser, entity resolved via JDK defaults
  4. Execution
    Local file contents expanded into evaluated document or SSRF request issued
  5. Impact
    Exfiltrate readable files / reach internal hosts

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A02:2025 - Security Misconfiguration
ASVS 5.0
V13 - Configuration XML external entity prevention
MITRE ATT&CK

2 techniques across 2 tactics: Initial Access, Collection

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

Exploitation Conditions

Requires that the Camel XPath expression be explicitly configured with documentType=InputSource (via .documentType(InputSource.class)) AND that it evaluates XML originating from an untrusted/external sender; under this configuration the payload was handed straight to javax.xml.xpath, which built its own DocumentBuilder using JDK defaults that accept a DOCTYPE and resolve external entities. The key LIMITING factor is that this is NOT the default - Camel's default document type is hardened and refuses the DOCTYPE, so default deployments are not exploitable. A further residual condition: even after upgrading, deployments that have set the DocumentBuilderFactory system properties that relax the default type's escape hatch remain unprotected by design. Affected versions are 4.0.0 before 4.18.5 and 4.19.0 before 4.22.1; no user interaction or authentication is required once the vulnerable configuration is present.

Impact

This is a genuine but conditionally-gated XXE (CWE-611) in Apache Camel's XPath component, rated CVSS 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N). The network, no-auth, no-UI vector is credible because an external sender's XML can reach a vulnerable XPath expression, and confirmed impact is high-confidentiality file disclosure plus SSRF (the process issuing requests to attacker-named hosts). However, the CVSS base vector does NOT capture the single most important limiting factor: exploitation only works when a deployment has explicitly set documentType=InputSource on an expression evaluated over untrusted XML - the default document type already refuses the DOCTYPE and is not vulnerable. No EPSS score, CISA KEV listing, or POC were provided in the input; a vendor functional test demonstrating the file-read canary exists in the patch but is not a weaponized public exploit. Net: this is a real, patch-worthy issue for the subset of Camel deployments using the InputSource document type over external XML, but it is not a drop-everything mass-exploitation threat - absent KEV/EPSS/POC signals and given the non-default configuration precondition, treat it as a targeted-risk, prioritized-patching item rather than a widespread active threat. EPSS/KEV data is MISSING and should be checked before final prioritization.

Exploit ScenarioDerived

A Camel route exposes an endpoint whose XPath expression is configured with documentType=InputSource and evaluates XML arriving from an external sender. The attacker submits XML containing a DOCTYPE with an external entity (e.g. a SYSTEM reference to a local file or an internal URL); because InputSource bypassed Camel's hardened parser and used JDK defaults, the entity is resolved and expanded, letting the attacker read files readable by the Camel process or force server-side requests (SSRF) to hosts they name. No public exploit was identified at time of analysis, though the vendor patch ships a proof-of-concept test using a file-read canary.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.5% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 19, 2026

XML external entity injection in the Apache Camel XPath component lets unauthenticated remote attackers read files accessible to the Camel process and induce it to make outbound requests to attacker-named hosts when an expression is configured with documentType=InputSource and evaluates XML from an untrusted sender. The flaw is configuration-gated rather than default: Camel's default document type already refuses a DOCTYPE, so stock deployments are not exposed, but a deployment that selected InputSource for streaming reasons unknowingly also selected a weaker parser. Fixed in 4.23.0, 4.18.5 and 4.22.1; no public exploit identified at time of analysis, and the CVSS 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N) reflects confidentiality impact only.

RemediationAI

Upgrade to Apache Camel 4.23.0 on the mainline, or to 4.18.5 on the 4.18.x LTS stream or 4.22.1 on the 4.22.x LTS stream; these releases route the InputSource document type through the same hardened parser as the default type, so a DOCTYPE is now refused (vendor advisory: https://camel.apache.org/security/CVE-2026-85250.html, patches in PRs https://github.com/apache/camel/pull/25683, https://github.com/apache/camel/pull/25940 and https://github.com/apache/camel/pull/25942). If an immediate upgrade is not possible, stop using documentType=InputSource on any XPath expression evaluated over untrusted XML and revert those expressions to the default document type, which already rejects a DOCTYPE - the trade-off is that you lose the streaming characteristics that motivated InputSource, so validate any assumption that large payloads still fit the default parse. Be aware that the fix inherits the default type's documented escape hatch: if your deployment sets the DocumentBuilderFactory system properties that relax DOCTYPE/entity handling for the default type, the InputSource path remains unprotected by design, so audit and remove those properties (disabling DTDs and external entities via javax.xml.accessExternalDTD/javax.xml.accessExternalSchema restrictions) before relying on the upgrade. Running the Camel process with a least-privilege filesystem account and egress-restricted network access limits the file-read and SSRF impact of any residual exposure, but these are compensating controls only and do not substitute for patching.

Affected VersionsENISA

Apache Camel 4.0.0 <4.18.5
Apache Camel 4.19.0 <4.22.1

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-611 (Improper Restriction of XML External Entity Reference) arises here from a parser-configuration disagreement between two document types in Camel's XPath language. When documentType is Document (the hardened default), the XML is parsed through a DocumentBuilderFactory configured to reject DOCTYPE declarations. When documentType is InputSource, XPathBuilder instead handed the raw javax.xml.sax.InputSource straight to javax.xml.xpath.XPathExpression#evaluate(...), and the JDK's XPath implementation constructs its own DocumentBuilder with JDK defaults - which accept a DOCTYPE and resolve external entities. The result was that a DOCTYPE refused on the default path was accepted on the InputSource path, and the declared external entity was resolved and expanded into the evaluated document. The upstream fix (PR #25683, in components/camel-xpath/.../XPathBuilder.java) inserts a toHardenedDocument() step that routes the InputSource through Camel's type converter to org.w3c.dom.Document, reusing the same hardened DocumentBuilderFactory as the default type; since the XPath engine built a full DOM from the source anyway, no extra parse is introduced. A regression test (XPathFeatureTest#docTypeIsAlsoDisallowedForAnInputSourceDocumentType) uses a file-backed XXE canary entity across both branches of doInEvaluateAs to pin the DOCTYPE as refused.

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 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
vuln.today AI 7.5 HIGH

Remote unauthenticated external XML reaches the parser (AV:N/PR:N/UI:N); high confidentiality from file read plus SSRF, no integrity/availability impact; the InputSource precondition is a deployment choice, not attack complexity, so AC:L.

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

Primary rating from Vendor (apache).

CVSS VectorVendor: apache

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

DescriptionCVE.org

Improper Restriction of XML External Entity Reference vulnerability in Apache Camel XPath component.

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

With documentType set to InputSource, XPathBuilder handed the payload straight to javax.xml.xpath, which builds a DocumentBuilder of its own using the JDK defaults. The hardening applied to Camel's default document type was therefore bypassed: a DOCTYPE declaration that is refused on the default type was accepted here, and the external entity it declared was resolved and expanded into the evaluated document. An external sender whose XML reaches such an expression could read files readable by the Camel process and cause the process to issue requests to hosts it names. The two document types disagreeing on parser configuration is what made this reachable, since a deployment choosing InputSource for streaming reasons had no indication it was also choosing a weaker parser.

Upgrade to Apache Camel 4.23.0, which fixes the issue. Users on the 4.18.x LTS releases stream should upgrade to 4.18.5. Users on the 4.22.x LTS releases stream should upgrade to 4.22.1. The InputSource document type now goes through the same hardened parser as the default type, so a DOCTYPE is refused. Note that it also shares that type's documented escape hatch: the same DocumentBuilderFactory system properties that relax the default type relax this one, so a deployment that has set them remains unprotected by design. For deployments that cannot upgrade immediately, do not use documentType=InputSource on expressions evaluated over untrusted XML; the default document type already refuses a DOCTYPE.

Executive ViewAI

Why It Matters

Apache Camel's XPath component creates a high-severity confidentiality exposure for the subset of integrations that use a non-default InputSource document type. Where that configuration processes XML from untrusted senders, an unauthenticated remote party could potentially read files available to the Camel service and induce outbound connections, making data protection and network trust-boundary controls the leadership concerns. Standard deployments are protected by secure defaults and no public exploit identified at time of analysis, so the priority is confirming whether any business-critical integration is in the exposed configuration and applying the vendor fix.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.5%
Top 56% exploitable
Prevalence
Medium
popular Java enterprise integration framework, but vulnerable InputSource config is non-default
Data Quality
5 sources
Confidence: Medium

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 0.5%
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
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

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

Attack Technique

XML External Entity (XXE) attacks exploit XML parsers that process Document Type Definitions (DTDs) without proper restrictions.

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-88900 HIGH
8.8 Oct 19

Unauthenticated deserialization of attacker-controlled messages in Apache Camel's camel-jgroups consumer can lead to rem

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

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