Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify Camel endpoint accepting external XML
-
DeliverySubmit XML with malicious DOCTYPE/external entity
-
ExploitInputSource bypasses hardened parser, entity resolved via JDK defaults
-
ExecutionLocal file contents expanded into evaluated document or SSRF request issued
-
ImpactExfiltrate 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
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.
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
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.
Articles & Coverage 1
Executive ViewAI
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.
Apply vendor patch.
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
XML External Entity (XXE) attacks exploit XML parsers that process Document Type Definitions (DTDs) without proper restrictions.
More in Apache Camel
View allRemote 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)
Unsafe Java deserialization in Apache Camel's camel-infinispan component allows arbitrary code execution when the ProtoS
Unauthenticated remote code execution affects the camel-hazelcast component of Apache Camel 4.0.0 through 4.18.4 and 4.1
Header-injection in the Apache Camel camel-atmosphere-websocket producer lets an external sender hijack WebSocket messag
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
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
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
Remote code execution via unsafe Java deserialization affects the camel-pqc component of Apache Camel 4.18.0-4.18.2 and
Unsafe Java deserialization in Apache Camel's camel-consul component (ConsulRegistry / ConsulRegistryUtils.deserialize)
Unauthenticated deserialization of attacker-controlled messages in Apache Camel's camel-jgroups consumer can lead to rem
Expression language injection in the Apache Camel dynamic-router-control endpoint allows a party who can place a message
Deserialization of untrusted data in the Apache Camel Spring Redis component (camel-spring-redis) allows an authenticate
EUVD-2026-104191
GHSA-x9f8-58m2-93q2
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB