Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit crafted document to Camel route
-
DeliveryTika producer parses attacker metadata keys
-
ExploitMetadata mapped onto Exchange as Camel headers
-
ExecutionInjected CamelFileName consumed downstream
-
ImpactContent written to attacker-chosen path
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Input validation, allowlisting
|
| Exploitation Conditions | Requires a Camel route that uses the camel-tika producer (tika:parse) to parse attacker-supplied documents AND a downstream component in that same route that acts on a Camel-namespace header such as CamelFileName (e.g. a file producer choosing a write path). The attacker must be able to deliver a crafted document into the route and chooses the metadata keys the file carries. Limiting factors: impact is bounded to routes whose logic trusts metadata-derived internal headers - routes that never read such headers are unaffected; the mitigation removeHeaders("Camel*") after the Tika producer neutralizes it without upgrading. No authentication to Camel itself is implied by the CVSS (PR:N), but exploitation is contingent on this non-universal route configuration. |
| Impact | This is a genuine but moderate-severity integration-logic flaw, not a top-tier emergency. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N, 6.5 MEDIUM) describes an unauthenticated network-reachable issue with low confidentiality and low integrity impact and no availability impact - consistent with header injection rather than direct code execution. No EPSS score, no CISA KEV listing, and no public exploit were provided in the input, so the exploitation-probability signals are all absent/negative, pointing away from mass exploitation. The one practical caveat is that CVSS rates this AC:L, but the real attack only works if the victim's Camel route both uses the camel-tika producer AND has a downstream component that trusts a Camel-namespace header (e.g. CamelFileName) - a deployment-specific precondition that in practice makes exploitation conditional rather than universal. Treat this as a dependency-patching priority for teams actually running camel-tika routes, not a drop-everything internet-wide threat. No conflicting severity signals were present; the main uncertainty is deployment-specific route configuration, which the raw CVSS cannot capture. |
| Exploit ScenarioDerived | An attacker submits a crafted document (e.g. an HTML file with a <meta name="CamelFileName" content="../../pwned"/> tag) into a Camel route that parses it with the tika:parse producer. Because every parsed metadata key was mapped onto the Exchange as a header without filtering, the attacker-chosen metadata becomes a trusted Camel-internal header, letting a downstream file component write content to an attacker-chosen path. No public exploit was identified at time of analysis, though the vendor's fix PR includes a unit test demonstrating the header-injection behavior. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
Header injection in the Apache Camel Tika producer (tika:parse) lets a crafted document write arbitrary names into the Camel Exchange header namespace, because every metadata key parsed out of the submitted file is mapped onto the message with no filter. Routes running Camel 4.0.0 through 4.18.4 and 4.19.0 through 4.22.0 that parse untrusted files and then hand the message to a component that acts on Camel-namespace headers - most notably CamelFileName, which file endpoints use to decide the write path - can be steered by an attacker-chosen metadata name such as an HTML <meta name="CamelFileName" content="../../pwned"/>. Unauthenticated remote attackers can supply the document (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N as independently assessed; the vendor published 6.5 with AC:L, while the higher attack complexity reflects the non-universal route configuration required); no public exploit code or CISA KEV entry was identified at time of analysis, and vendor-released patches exist in 4.23.0, 4.18.5 and 4.22.1.
RemediationAI
Vendor-released patch: upgrade to Apache Camel 4.23.0, or to 4.18.5 if on the 4.18.x LTS stream, or to 4.22.1 if on the 4.22.x LTS stream (fix PRs at https://github.com/apache/camel/pull/25819, https://github.com/apache/camel/pull/25940 and https://github.com/apache/camel/pull/25942; advisory https://camel.apache.org/security/CVE-2026-85249.html). Be aware of the documented side effect: parsed document metadata is now passed through a HeaderFilterStrategy that blocks the Camel, camel and org.apache.camel. prefixes, so any route that legitimately reads a metadata-derived header in that namespace will see the header missing after upgrading and must be reworked to carry that data explicitly. If an immediate upgrade is not possible, insert removeHeaders("Camel*") (and ideally also strip the org.apache.camel.* form) immediately after the Tika producer and before any component that acts on those headers - the trade-off is that this also removes any Camel headers you intended to set upstream of that point, so place it precisely and verify route behaviour; additionally restrict who can submit documents into tika:parse routes and avoid chaining the Tika producer directly into file or HTTP producers whose targets derive from message headers.
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
Apache Camel's camel-tika component wraps Apache Tika to extract text and metadata from documents. In the vulnerable TikaProducer.convertMetadataToHeaders method, each metadata name returned by Tika was written directly onto the Exchange via setHeader with only a check on whether the value was single- or multi-valued - no namespace or prefix validation was applied. Because Tika surfaces document-declared metadata names verbatim (an HTML <meta name="..."> attribute, for example, becomes a metadata key exactly as written), the party who supplies the file effectively chooses the header names that land on the message. This is the header-injection class (CWE-20 improper input validation) previously addressed in Camel consumer advisories, reached here through parsed file content rather than a protocol header. The specific danger is collision with Camel's reserved internal namespace: headers prefixed Camel (CamelFileName, CamelHttpUri, etc.) and fully qualified org.apache.camel.* names are consumed by downstream components as routing and behavioural instructions, so an injected CamelFileName can redirect where a file producer writes. The upstream fix adds a DefaultHeaderFilterStrategy configured with lowerCase matching and inFilterStartsWith("Camel", "camel", "org.apache.camel."), routing parsed names through applyFilterToExternalHeaders so internal-namespace keys are dropped and non-Camel metadata (author, dc:title) continues to map normally.
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:L/I:L/A:N
Impact depends on the route having a downstream component that consumes an injected Camel-namespace header, a configuration-specific precondition outside attacker control, so AC:H; low C/I, no availability effect.
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
DescriptionCVE.org
Improper Input Validation vulnerability in Apache Camel Tika component.
This issue affects Apache Camel: from 4.0.0 before 4.18.5, from 4.19.0 before 4.22.1.
The Tika producer mapped every metadata key parsed out of the submitted document onto the Exchange as a header, with no filter applied. Document metadata is attacker-controlled content: the party that supplies the file chooses the metadata keys it carries. A crafted document could therefore set Exchange headers that the rest of the route depends on, including headers in the Camel namespace such as CamelFileName, which downstream components use to decide where content is written. The pattern is the same header-injection class as the consumer advisories published previously, reached here through parsed file content rather than through a protocol header.
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. Parsed document metadata is now filtered through a HeaderFilterStrategy before it is mapped onto the Exchange. A route that was reading a metadata-derived header the filter now blocks will see it missing. For deployments that cannot upgrade immediately, strip the Camel namespace after the Tika producer with removeHeaders("Camel*") before any component that acts on those headers.
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
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
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-104190
GHSA-xp25-2fp7-pffp
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB