Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend crafted HTTP/2 request to Camel endpoint
-
DeliveryInclude suppressed header with chosen value
-
ExploitCase-insensitive guard fails, content reflected in response
-
ExecutionPoison fronting cache or split response
-
ImpactServe attacker content to other users
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Case sensitivity handling
|
| Exploitation Conditions | Exploitation requires that traffic reach a vulnerable Apache Camel platform-http endpoint (4.0.0 before 4.18.5, or 4.19.0 before 4.22.1) and that one of the COMMON_HTTP_REQUEST_HEADERS (e.g. Authorization, Cookie, Proxy-Authorization) is submitted. The bypass is unconditional for any request over an HTTP/2 connection (HTTP/2 mandates lowercase field names, which never matched the canonically-capitalized suppression set); over HTTP/1.1 it requires the attacker to vary the header casing to defeat the exact-case comparison. Real-world impact is further gated by what sits in front of the endpoint - meaningful response-splitting or cache-poisoning requires a downstream cache or proxy that will act on the reflected content; endpoints with no fronting cache and no sensitive reflected headers face limited practical risk. Mitigations without upgrading: strip the affected headers in front of the Camel endpoint or remove them from the response within the route. |
| Impact | This is a moderate-severity information-handling flaw, not an emergency. The input CVSS of 6.5 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N) indicates a network-reachable, low-complexity, unauthenticated issue with low confidentiality and low integrity impact and no availability impact, which is consistent with the described response-splitting/cache-poisoning primitive rather than direct code execution. No EPSS score, CISA KEV listing, or POC is present in the supplied intelligence, so there is no public exploit identified at time of analysis and no evidence of active exploitation; the practical risk is therefore driven by the vulnerability class and the attacker's ability to influence whatever cache/proxy sits in front of the Camel endpoint rather than by any observed campaign. A notable nuance confirmed by the vendor advisory and the PR diff is that the flaw is unconditional over HTTP/2 (field names are lowercase on the wire, so the case-sensitive suppression never matched) but only opportunistically bypassable over HTTP/1.1 by varying header casing - a real-world severity amplifier for the increasingly common HTTP/2 deployments. The signals are internally consistent (network vector, low complexity, no auth all align with the described remote header-reflection behavior); the main missing data points are EPSS and any exploitation telemetry, so prioritization should be routine patching within normal cycles unless the Camel endpoint fronts a shared cache or sensitive headers (Authorization, Cookie) are in play. |
| Exploit ScenarioDerived | An attacker sends an HTTP request to a Camel platform-http endpoint over HTTP/2 (or over HTTP/1.1 using non-canonical header casing) containing attacker-controlled values in headers that Camel is supposed to suppress from the response. Because the suppression guard compared header names case-sensitively, the chosen content is echoed back in the response, which the attacker uses as the basis for response-splitting or cache-poisoning against a downstream cache or proxy. No public exploit is identified at time of analysis, but the preconditions are low given AC:L and no authentication requirement (PR:N). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
Reflecting caller-chosen request headers back into responses is possible in Apache Camel's platform-http component (4.0.0 before 4.18.5, and 4.19.0 before 4.22.1) because the guard that suppresses sensitive headers compares names case-sensitively, so a caller can defeat it by changing header casing - and on HTTP/2, where field names must be lowercase on the wire, the suppression never fires at all. Unauthenticated remote attackers (CVSS:3.1/AV:N/AC:L/PR:N/UI:N, 6.5) can therefore have content they control echoed into the response, which is the primitive behind response-splitting and cache-poisoning attacks against proxies or caches sitting in front of the Camel endpoint. Vendor patches are available in 4.23.0, 4.18.5 and 4.22.1; no public exploit code and no confirmed active exploitation were identified at time of analysis, and practical impact is gated by whether a fronting cache or proxy acts on the reflected content.
RemediationAI
Upgrade to Apache Camel 4.23.0; users tracking the LTS streams should move to 4.18.5 (4.18.x) or 4.22.1 (4.22.x), which contain the case-insensitive header comparison introduced by the upstream fixes at https://github.com/apache/camel/pull/25831, https://github.com/apache/camel/pull/25940 and https://github.com/apache/camel/pull/25942, and reviewed against the advisory at https://camel.apache.org/security/CVE-2026-85254.html. If an immediate upgrade is not possible, stop relying on the built-in suppression and instead strip the sensitive headers (Authorization, Cookie, Proxy-Authorization and the rest of COMMON_HTTP_REQUEST_HEADERS) at the ingress in front of the Camel endpoint, or explicitly remove them from the response inside the route - be aware that stripping Authorization/Cookie on the request path will break authentication and session handling for routes that legitimately consume those headers, so prefer filtering them only on the response path; alternatively tighten the fronting cache or proxy so it does not store or act on reflected header content, accepting the residual risk of the bypass itself. Verify the fix by confirming that lower-case and mixed-case header variants no longer appear in responses, including over an HTTP/2 connection.
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 flaw is CWE-178 (Improper Handling of Case Sensitivity) in the camel-platform-http component's PlatformHttpEndpoint. Camel wraps the endpoint's HeaderFilterStrategy so that a fixed set of common request headers - Authorization, Cookie, Proxy-Authorization and the other entries of COMMON_HTTP_REQUEST_HEADERS - is not echoed onto the response. That set was built from canonically capitalised spellings, and the lookup compared names exactly, whereas Camel exchange headers preserve the casing used by the inbound request. HTTP/1.1 clients can therefore bypass the filter simply by sending 'authorization' or 'AUTHORIZATION' instead of 'Authorization'. HTTP/2 removes even that effort: RFC 9113 requires header field names to be lowercase on the wire, so every HTTP/2 request presents as 'authorization', 'cookie' and so on, none of which matched, making the suppression inert for all HTTP/2 traffic. The fix in the referenced PR replaces the set with a TreeSet ordered by String.CASE_INSENSITIVE_ORDER (wrapped unmodifiable) so that matching holds regardless of casing and under HTTP/2; a regression test (PlatformHttpEndpointHeaderEchoTest) asserts suppression for canonical, lowercase and uppercase variants, and the 4.23 upgrade guide documents the behavioural change for users who relied on the old echo. Note that the underlying reflection surface is the Java servlet/platform HTTP stack and Camel's header filtering contract, not a memory-safety issue - the risk materialises only when a downstream cache or proxy trusts and acts on the reflected content.
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
Remote, unauthenticated, low-complexity header reflection (unconditional on HTTP/2) yields limited confidentiality disclosure and limited integrity via response-splitting/cache-poisoning, with no availability impact.
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
DescriptionCVE.org
Improper Handling of Case Sensitivity vulnerability in Apache Camel Platform HTTP component.
This issue affects Apache Camel: from 4.0.0 before 4.18.5, from 4.19.0 before 4.22.1.
The guard that prevents a request header being reflected into the response compared header names case sensitively, while HTTP header names are case insensitive. A caller could therefore defeat the suppression simply by varying the case of the header name. HTTP/2 makes the problem unconditional rather than optional: the protocol requires header names to be lowercase on the wire, so the comparison never matched and the suppression was inert for every request on an HTTP/2 connection. The consequence is that content the caller chose is echoed back in the response, which is the basis for response-splitting and cache-poisoning style attacks against whatever sits in front of the Camel endpoint.
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. Request header names are now compared case insensitively, so the suppression holds regardless of casing and works under HTTP/2. For deployments that cannot upgrade immediately, strip the headers in question in front of the Camel endpoint, or remove them from the response in the route rather than relying on the built-in suppression.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
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-104194
GHSA-9jfp-c25q-rf5q
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB