Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend request with crafted CamelHttpUri/CamelRestHttpUri header
-
ExploitHeader overrides HTTP producer endpoint URI
-
ExecutionresolvePropertyPlaceholders expands secret/env/bean functions
-
ImpactSecret value exfiltrated via outbound request or echoed in error
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V1 - Encoding and Sanitization Template injection prevention
|
| Exploitation Conditions | Requires a deployed Apache Camel route (4.0.0 before 4.18.5, or 4.19.0 before 4.22.1) using an affected HTTP producer component - camel-http, camel-http-common, camel-vertx-http, camel-undertow, or camel-netty-http - even with a plain static to("http://backend/api"). The attacker must be able to set the CamelHttpUri or CamelRestHttpUri header; this is reachable without explicit header injection where a Camel HTTP consumer populates CamelHttpUri from the request line (the documented reverse-proxy feature) and is exposed to untrusted senders. Impact depends on secrets being resolvable via registered PropertiesFunctions (AWS/Azure/GCP/HashiCorp/IBM/CyberArk/Kubernetes vaults), OS environment variables, or JVM system properties, or on a bean with a callable no-argument method in the registry. LIMITING factors: bridgeEndpoint=true is NOT a mitigation (it suppresses the override only in the createURL path, not createMethod, and CamelRestHttpUri is consumed before any bridgeEndpoint check); skipControlHeaders=true mitigates but exists only on camel-http and defaults to false; observing the leaked value requires either controlling/observing the outbound backend or reading the RuntimeExchangeException message. Percent-encoding delimiters at a WAF does not help camel-netty-http, which decodes the request path before the header is read. |
| Impact | Multiple signals point to a genuine, prioritize-for-patching issue, though not a drop-everything emergency. The vendor CVSS of 8.2 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:L/A:N) reflects remote, low-complexity, unauthenticated reachability with high confidentiality impact - consistent with the description, where secret-resolving PropertiesFunctions (AWS, Azure, GCP, HashiCorp, IBM, CyberArk, Kubernetes) and no-argument bean invocation become reachable from attacker-supplied CamelHttpUri/CamelRestHttpUri headers, and secret values can be observed via the outbound request or echoed in a RuntimeExchangeException message. EPSS is not provided in the input, so exploitation probability cannot be quantified. The CVE is NOT in CISA KEV and no public exploit is identified at time of analysis - the only code evidence is the vendor's own fix PR and its regression test, which is remediation, not a weaponized POC. SSVC decision data is not provided. The main factor tempering raw CVSS: realistic exploitation still requires the application to run an affected HTTP producer component and for the attacker to influence the override headers (either via header injection across a weak trust boundary or via the documented reverse-proxy consumer feature that populates CamelHttpUri from the request line); where neither path exists, exposure is lower. The I:L reflects bean-method invocation being limited to no-argument methods. Net: real priority for Camel operators running the affected HTTP components, driven by impact and ease rather than by any confirmed active exploitation. |
| Exploit ScenarioDerived | An attacker sends an HTTP request to a Camel route whose consumer populates CamelHttpUri from the request line (a documented reverse-proxy feature) or otherwise injects the CamelHttpUri/CamelRestHttpUri header, embedding a placeholder such as {{aws:secret:...}} or {{env:AWS_SECRET_ACCESS_KEY}}. When the route forwards to an HTTP producer, CamelContext.resolvePropertyPlaceholders() expands the token against environment variables, system properties, or registered vault functions, leaking the secret into the outbound request or - for an unresolvable key - into a RuntimeExchangeException message that distinguishes set from unset keys. No public exploit is identified at time of analysis; only the vendor fix PR and its regression test are available. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
Header-driven URI resolution in Apache Camel's HTTP producer components causes message-supplied CamelHttpUri and CamelRestHttpUri values to be expanded through CamelContext.resolvePropertyPlaceholders() before use, so an attacker who can influence those headers turns a URI string into a configuration-evaluation context and can read OS environment variables, JVM system properties, every registered secret-backend PropertiesFunction (AWS, Azure, GCP, HashiCorp, IBM, CyberArk, Kubernetes) and even invoke no-argument methods on beans in the registry. The flaw affects Apache Camel 4.0.0 before 4.18.5 and 4.19.0 before 4.22.1 across camel-http, camel-http-common, camel-vertx-http, camel-undertow and camel-netty-http, and a plain static to(http://backend/api) route is enough to be exposed; no authentication is required where a route is reachable by untrusted senders (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:L/A:N, 8.2). Exploitation yields a high-confidentiality but limited-integrity impact, and while no public exploit code or CISA KEV entry exists at time of analysis, the preconditions are ordinary and the vendor has shipped fixes, so this warrants prioritised patching.
RemediationAI
Vendor-released patch: upgrade to Apache Camel 4.23.0; deployments on the 4.22.x stream should move to 4.22.1 and 4.18.x deployments to 4.18.5, with 4.14.x and earlier required to migrate to a supported line since no fix will be issued. Upstream code changes are visible in https://github.com/apache/camel/pull/25571 (commits ba5aced7f6a1c38a963020575676ad4c76b492cf, 9f8a185e315ce9e120889c4106be3dbf4688e507, 7cec534c66969015d85e56631143174dd150ed94), which remove placeholder resolution from the seven affected helper call sites; see the advisory at https://camel.apache.org/security/CVE-2026-78164.html. Where an immediate upgrade is impossible, strip the override headers at the trust boundary ahead of the producer with removeHeader(CamelHttpUri) and removeHeader(CamelRestHttpUri) - this is cheap and effective but must be applied to every route, and any route that legitimately relies on header-driven URIs (the documented reverse-proxy pattern) will stop working. On camel-http endpoints only, set skipControlHeaders=true, accepting that genuine control-header behaviour is disabled for those endpoints. bridgeEndpoint=true is explicitly not a workaround because it only suppresses the createURL path, and percent-encoding the placeholder delimiters does not help camel-netty-http, whose binding decodes the request path before the header is populated, so WAF or proxy rules keyed on raw delimiters are ineffective there. As defence in depth, apply a strict inbound HeaderFilterStrategy over the Camel namespace on all consumers exposed to untrusted senders, and source secrets from a vault reachable only through functions you register deliberately rather than from environment variables or system properties that a placeholder can name.
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 HTTP producer families (camel-http, camel-http-common, camel-vertx-http, camel-undertow, camel-netty-http) permit an inbound Camel Exchange to override the outbound endpoint URI via the CamelHttpUri and CamelRestHttpUri headers, a documented reverse-proxy convenience. The defect is that this message-derived string was then passed through CamelContext.resolvePropertyPlaceholders() before URI parsing. That routine is a build-time configuration facility, not a sanitiser: it resolves against OS environment variables, JVM system properties, and any PropertiesFunction on the classpath - including AWS, Azure, GCP, HashiCorp, IBM, CyberArk and Kubernetes secret backends - and via camel-bean can invoke a no-argument method on a registered bean. Applying it to Exchange content therefore upgraded a data string into a template-evaluation context, matching CWE-1336 (Improper Neutralization of Special Elements Used in a Template Engine) with a CWE-200 information-exposure outcome. Seven call sites were affected: HttpHelper.createURL and HttpHelper.createMethod (camel-http-common), HttpMethodHelper.createMethod (camel-http), VertxHttpHelper.resolveHttpURI (camel-vertx-http), UndertowHelper.createURL and UndertowHelper.createMethod (camel-undertow), and NettyHttpHelper.createURL (camel-netty-http). The bridgeEndpoint option does not bound the exposure: it suppresses the CamelHttpUri override only in the createURL family, not createMethod, and CamelRestHttpUri was consumed before any bridgeEndpoint check in all four components. Only camel-http offered skipControlHeaders (default false). Where the placeholder is unresolvable, the thrown RuntimeExchangeException echoes the URI, producing a blind oracle that distinguishes set from unset configuration keys. The behaviour predates 4.x, tracing back to camel-http4 and camel-netty4, and the fix extends the build-time-resolution contract previously applied to the toD and enrich EIPs under CAMEL-24282.
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:H/I:L/A:N
Remote header control via reverse-proxy consumer gives AV:N/PR:N/AC:L; secret exposure yields C:H, limited no-arg bean invocation gives I:L, no availability impact so A:N.
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
DescriptionCVE.org
Improper Neutralization of Special Elements Used in a Template Engine and Exposure of Sensitive Information to an Unauthorized Actor vulnerability in Apache Camel HTTP, Netty HTTP, Undertow and Vert.x HTTP components.
This issue affects Apache Camel: from 4.0.0 before 4.18.5, from 4.19.0 before 4.22.1.
The Camel HTTP producer families let an inbound message override the endpoint URI through the CamelHttpUri and CamelRestHttpUri headers, and then passed that message-supplied string through CamelContext.resolvePropertyPlaceholders() before using it. Property-placeholder resolution is a configuration-resolution facility, not a URI-parsing step: it reaches operating-system environment variables, JVM system properties, every PropertiesFunction registered on the classpath - including the AWS, Azure, GCP, HashiCorp, IBM, CyberArk and Kubernetes secret functions - and, through camel-bean, the invocation of a no-argument method on any bean in the registry. Applying it to Exchange content therefore turned a URI string into a configuration- and bean-evaluation context. A route author opted into none of this: a plain static to("http://backend/api") was sufficient. Seven call sites were affected: HttpHelper.createURL and HttpHelper.createMethod in camel-http-common, HttpMethodHelper.createMethod in camel-http, VertxHttpHelper.resolveHttpURI in camel-vertx-http, UndertowHelper.createURL and UndertowHelper.createMethod in camel-undertow, and NettyHttpHelper.createURL in camel-netty-http. The bridgeEndpoint option did not bound the exposure: it suppresses the CamelHttpUri override in the createURL family but not in the createMethod family, so a route using the documented bridging configuration still resolved placeholders taken from the header, and CamelRestHttpUri was consumed before any bridgeEndpoint check in all four components. Only camel-http offered an opt-out, skipControlHeaders, which defaults to false. Reaching the headers did not always require header injection, because several Camel HTTP consumers populate CamelHttpUri from the request line themselves as a documented reverse-proxy feature. An unresolvable placeholder additionally produced a RuntimeExchangeException whose message echoed the URI, which distinguishes a set from an unset configuration key even where no outbound request is made. The behaviour predates the 4.x line; it dates back to the camel-http4 and camel-netty4 components. This advisory continues the alignment CAMEL-24282 applied to the toD and enrich dynamic-URI EIPs in 4.22.0, extending the same build-time-resolution contract to the HTTP producer components.
Users are recommended to upgrade to version 4.23.0, which fixes the issue. If users are on the 4.22.x releases stream, then they are suggested to upgrade to 4.22.1. If users are on the 4.18.x releases stream, then they are suggested to upgrade to 4.18.5. The 4.14.x releases stream and earlier reached end of life before this issue was resolved and will not receive a fix, so deployments on those lines must move to a supported release. For deployments that cannot upgrade immediately, strip the override headers at the trust boundary before the producer with removeHeader("CamelHttpUri") and removeHeader("CamelRestHttpUri"), or set skipControlHeaders=true on camel-http endpoints, which is the only component offering that option. Note that bridgeEndpoint=true is not a workaround: it suppresses the header override when the outbound URL is built but not when the header is re-parsed for the query string. Percent-encoding the placeholder delimiters is likewise not a mitigation for camel-netty-http, whose binding decodes the request path before the value reaches the header, so proxy or WAF rules written against the raw delimiters do not help there. As defence in depth, ensure consumers exposed to untrusted senders apply a strict inbound HeaderFilterStrategy over the Camel namespace, and resolve secrets through a vault rather than through environment variables or system properties that a placeholder can name.
Articles & Coverage 3
Executive ViewAI
Apache Camel's HTTP producer components can be induced by an unauthenticated sender to resolve attacker-controlled URI headers as configuration expressions, exposing cloud and vault credentials along with JVM system properties and OS environment variables. Any reachable Camel route - including a simple static to(http://backend/api) route - becomes a disclosure path into AWS, Azure, GCP, HashiCorp, IBM, CyberArk and Kubernetes secret backends, so the integration tier effectively becomes a credential exfiltration channel for the whole enterprise. Leadership should care because exploitation requires no credentials, no user interaction, and no special complexity, and the primary loss is confidentiality of secrets that underpin many downstream systems.
Apply vendor patch.
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-104222
GHSA-394j-cc2x-w9wm
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB