Skip to main content

Apache Camel EUVDEUVD-2026-104208

| CVE-2026-91858 MEDIUM
Improper Restriction of XML External Entity Reference (CWE-611)
2026-10-19 apache GHSA-qrg3-hxwc-36jm
6.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 route exposing a fop producer
  2. Delivery
    Craft XSL-FO with external DTD/entity
  3. Exploit
    Submit as message body
  4. Execution
    Saxon TransformerFactory resolves external resource
  5. Impact
    Read 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.4% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

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

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

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

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.

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

Primary rating from Vendor (apache).

CVSS VectorVendor: apache

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

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

EPSS Score
0.4%
Top 72% exploitable
Prevalence
Medium
Apache Camel is widely used, but camel-fop is a specific optional component
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GitHub VulDB

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

32
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +32
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