Skip to main content

Apache Camel Tika EUVDEUVD-2026-104190

| CVE-2026-85249 MEDIUM
Improper Input Validation (CWE-20)
2026-10-19 apache GHSA-xp25-2fp7-pffp
6.5
CVSS 3.1 · Vendor: apache
View

Attack ChainAIDerived

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

  1. Access
    Submit crafted document to Camel route
  2. Delivery
    Tika producer parses attacker metadata keys
  3. Exploit
    Metadata mapped onto Exchange as Camel headers
  4. Execution
    Injected CamelFileName consumed downstream
  5. Impact
    Content 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.

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

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

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

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

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

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.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N
4.0 AV:N/AC:H/AT:N/PR:N/UI:N/VC:L/VI:L/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
Low
Integrity
Low
Availability
None

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

EPSS Score
0.4%
Top 72% exploitable
Prevalence
Medium
Apache Camel widely used in enterprise integration, but camel-tika is an optional component
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 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
Yes
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

Code Injection CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

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