Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify Camel route exposing a fop producer
-
DeliveryCraft XSL-FO with external DTD/entity
-
ExploitSubmit as message body
-
ExecutionSaxon TransformerFactory resolves external resource
-
ImpactRead process-readable files or trigger SSRF requests
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 | Exploitation requires that an alternative (non-JDK) JAXP TransformerFactory implementation be present on the application classpath - specifically Saxon-HE, typically introduced by also using camel-xslt-saxon or camel-saxon - because only such a factory ignores external-resource limits under FEATURE_SECURE_PROCESSING. The attacker must also be able to deliver an XSL-FO document (with a DOCTYPE external subset or external general entity) to a Camel route that feeds a fop producer. Key LIMITING factors: a default camel-fop deployment using the JDK transformer (which empties the accessExternalDTD/accessExternalStylesheet limits and excludes Xalan) is NOT vulnerable, so this is reachable only in non-default classpath configurations; file read is bounded to files readable by the Camel process. Releases on the 4.14.x line and earlier are EOL and receive no fix, so only migration to a fixed supported line remediates them. |
| Impact | This is a genuine but conditional information-disclosure flaw (CWE-611 XXE) in Apache Camel's camel-fop component, not a top-priority internet-wide emergency. The provided CVSS 3.1 vector (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:L/A:N, base 6.5 Medium) shows the signals pull in opposite directions: network-reachable and unauthenticated (AV:N/PR:N/UI:N) raises concern, but AC:H correctly reflects that exploitation is gated on a non-default precondition - an alternative JAXP TransformerFactory (e.g., Saxon-HE, pulled in by camel-xslt-saxon or camel-saxon) being present on the classpath. A default camel-fop deployment uses the JDK transformer (which empties accessExternalDTD/accessExternalStylesheet under FEATURE_SECURE_PROCESSING) and excludes Xalan, so it is NOT affected. No EPSS score, no CISA KEV entry, and no public POC were provided, so there is no public exploit identified at time of analysis and no evidence of active or automatable exploitation. The impact when conditions are met is real - arbitrary file read (C:H) and server-side request forgery (I:L) - but the narrow, operator-dependent trigger means this is best treated as a 'patch in normal cycle, audit classpath' item rather than an immediate drop-everything issue. |
| Exploit ScenarioDerived | An external sender submits a crafted XSL-FO document (containing a DOCTYPE with an external subset or an external general entity) to a Camel route whose fop producer renders it to PDF, in a deployment that also has Saxon-HE on the classpath. The Saxon TransformerFactory resolves the external entity during the identity transform, letting the attacker exfiltrate local files readable by the Camel process or force the process to make requests to attacker-named hosts (SSRF). No public exploit code was provided, and the attack only works outside the default, JDK-transformer configuration. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
External entity expansion (XXE) in Apache Camel's camel-fop component lets an unauthenticated remote sender who can deliver an XSL-FO body to a fop producer read files accessible to the Camel process and force that process to make outbound requests to attacker-named hosts. The flaw is conditional: FopProducer relies on TransformerFactory.newInstance() plus FEATURE_SECURE_PROCESSING, which is sufficient only for the JDK's built-in transformer, so exploitation requires a third-party JAXP factory such as Saxon-HE (typically pulled in via camel-xslt-saxon or camel-saxon) on the classpath - default camel-fop deployments are not affected. There is no public exploit code or CISA KEV entry identified at time of analysis, and the CVSS 6.5 score reflects high attack complexity and confidentiality-heavy impact (C:H/I:L) rather than easy mass exploitation; fixes are shipping via upstream PRs, but 4.14.x and earlier releases are end-of-life and will never receive one.
RemediationAI
Upgrade camel-fop to a supported Apache Camel release line that contains the fix - the correction was merged upstream in PRs https://github.com/apache/camel/pull/26108, https://github.com/apache/camel/pull/26168 and https://github.com/apache/camel/pull/26169, so confirm the exact fixed version in the vendor advisory at https://camel.apache.org/security/CVE-2026-91858.html before pinning; note that 4.14.x and earlier are EOL and cannot be remediated except by migrating to a supported line. If an immediate upgrade is not possible, implement the patch's behaviour out-of-band: ensure the JAXP lookup resolves to the JDK transformer (remove Saxon-HE from the runtime classpath, or set the javax.xml.transform.TransformerFactory system property / jaxp.properties to the JDK factory) - the trade-off is that any camel-saxon or camel-xslt-saxon route in the same JVM will break, so isolate those routes into a separate process. Where Saxon must stay, supply a TransformerFactory that sets ACCESS_EXTERNAL_DTD and ACCESS_EXTERNAL_STYLESHEET to empty strings and verify with the test pattern used upstream (a DOCTYPE referencing a readable DTD must be rejected while the same FO without a DOCTYPE still renders). As compensating controls, restrict who can submit XSL-FO into fop endpoints (authenticated, allow-listed producers only), strip or reject documents containing DOCTYPE/ENTITY declarations with a前置 validation step, run the Camel process under an OS account whose file read access is minimal and with egress filtering to block the SSRF side of the attack - each of these reduces but does not eliminate the flaw if a fully trusted sender is later compromised.
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
The camel-fop producer performs an identity transform over the incoming XSL-FO message body using a javax.xml.transform.TransformerFactory obtained from TransformerFactory.newInstance(). That call is a JAXP service-provider lookup: it scans the classpath (META-INF/services/javax.xml.transform.TransformerFactory) and returns the highest-priority implementation, which in a typical Camel application is the JDK's built-in factory - unless a component such as camel-saxon or camel-xslt-saxon has placed Saxon-HE there. FEATURE_SECURE_PROCESSING is then enabled, but its semantics are implementation-defined: on the JDK transformer the feature implicitly blanks the JAXP limits accessExternalDTD and accessExternalStylesheet, refusing any external DTD or entity, whereas Saxon-HE does not tie external-resource access to that flag, and camel-fop never sets the ACCESS_EXTERNAL_DTD / ACCESS_EXTERNAL_STYLESHEET attributes explicitly. The result is a classic CWE-611 (Improper Restriction of XML External Entity Reference): a DOCTYPE with an external subset or an external general entity declared in the XSL-FO input is resolved and expanded during the transform. camel-fop deliberately excludes Xalan and bundles no alternative factory, which is why the affected population is limited to non-default classpaths; the actual code fix (PR #26108) simply sets both ACCESS_EXTERNAL_* attributes to the empty string inside the try blocks around the transform, defensively ignoring factories that do not support the attributes, and adds a regression test proving an external DTD is never fetched while the same document without a DOCTYPE still renders.
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:H/PR:N/UI:N/S:U/C:H/I:L/A:N
Network-delivered XSL-FO with no auth or interaction (AV:N/PR:N/UI:N), but AC:H because exploitation depends on a non-default Saxon-on-classpath condition; C:H for file read, I:L for SSRF, A:N.
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
DescriptionCVE.org
FopProducer transforms the incoming XSL-FO message body by creating a javax.xml.transform.TransformerFactory through TransformerFactory.newInstance() and enabling only FEATURE_SECURE_PROCESSING before running an identity transform over the body. On the JDK's built-in transformer, that feature alone already empties the accessExternalDTD and accessExternalStylesheet limits, so an external DTD or entity is refused. When a third-party JAXP TransformerFactory such as Saxon-HE is on the classpath, for example because the application also uses camel-xslt-saxon or camel-saxon, TransformerFactory.newInstance() returns that implementation instead, and FEATURE_SECURE_PROCESSING on its own does not restrict external resource access on it. A DOCTYPE with an external subset, or an external general entity, declared in the XSL-FO document is then resolved and expanded while the body is transformed. An external sender whose XSL-FO reaches a fop producer could therefore read files readable by the Camel process and cause the process to issue requests to hosts the document names. camel-fop does not bring such a factory itself, and excludes Xalan, so a default deployment using the JDK transformer is not affected; the issue is reachable only where another component has placed an alternative JAXP TransformerFactory on the classpath. Releases on the 4.14.x line and earlier reached end of life before this issue was resolved and do not receive a fix.
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-104208
GHSA-qrg3-hxwc-36jm
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB