Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach Camel netty-http consumer
-
DeliveryIdentify case-protected route path
-
ExploitAlter case of context-path segment
-
ExecutionSecurity constraint fails to match path
-
ImpactAccess protected route without authentication challenge
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Case sensitivity handling
|
| Exploitation Conditions | Requires a camel-netty-http consumer configured with a NettyHttpSecurityConfiguration/securityConstraint whose inclusions are specific sub-paths rather than a catch-all (e.g. addInclusion('/admin/*')), and in practice matchOnUriPrefix=true so the endpoint context-path is prefix-matched; the attacker then changes the case of a character in the configured context-path segment (e.g. /Foo instead of /foo) so the constraint comparison fails to recognise the path while dispatch still routes it. No credentials, prior access, or special privileges are needed beyond network reachability to the consumer. Limiting factors: consumers without a security constraint, constraints using catch-all inclusions, or path handling fronted by a reverse proxy that normalises case are not exploitable, which bounds real-world exposure to the specific constraint configurations described. |
| Impact | 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) describes a network-reachable, low-complexity, unauthenticated security-constraint bypass, which on paper is a high priority. However, several real-world signals temper this: there is no CISA KEV listing, no EPSS score was provided in the input, and no public exploit code was supplied - only vendor patch PRs with a regression test. More importantly, exploitation is strongly gated by configuration: the flaw only manifests in camel-netty-http consumers that actually deploy a NettyHttpSecurityConfiguration/securityConstraint with specific (non-catch-all) inclusions, typically with matchOnUriPrefix=true. The PR:N rating is justified because the whole point of the bug is bypassing the authentication challenge, so no credentials are needed - this is internally consistent with the description ('No credential, prior access or special configuration is required beyond being able to send a request to the consumer'). Net assessment: a genuinely serious access-control bypass where it applies, but its blast radius is limited to the subset of Camel deployments using netty-http security constraints, so it is a targeted-configuration risk rather than a broad internet-wide mass-exploitation threat. No SSVC decision data (automatable/technical impact) was provided to refine this further. |
| Exploit ScenarioDerived | An attacker able to send HTTP requests to a Camel netty-http consumer that is configured with matchOnUriPrefix=true and a securityConstraint listing specific protected sub-paths (e.g. /admin/*) alters the case of a character in the configured context-path segment - for example requesting /Foo/admin/x instead of /foo/admin/x. The case-sensitive security-constraint strip no longer recognises the path as protected and skips the authentication challenge, while the case-insensitive consumer dispatch still routes the request to the protected endpoint, yielding unauthenticated access. No public proof-of-concept was identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
Authorization bypass in Apache Camel's camel-netty-http component allows remote unauthenticated attackers to reach protected routes by changing the case of characters in the request path so the security constraint no longer recognizes it while routing still dispatches to the endpoint. It affects Apache Camel 4.0.0 before 4.18.5 and 4.19.0 before 4.22.1, with a CVSS score of 8.2; no public exploit identified at time of analysis.
RemediationAI
Vendor-released patch: upgrade to Apache Camel 4.23.0, or to 4.18.5 for the 4.18.x LTS stream and 4.22.1 for the 4.22.x LTS stream, per https://camel.apache.org/security/CVE-2026-80343.html and fix PRs https://github.com/apache/camel/pull/25578, https://github.com/apache/camel/pull/25761, and https://github.com/apache/camel/pull/25762. If immediate upgrade is not possible, place the authorization decision in front of the Camel consumer, such as a reverse proxy that normalizes the request path case before forwarding, and restrict network reachability to the consumer; this trades added proxy complexity and a new enforcement point for reduced exposure, and deployments that relied on case-differing paths reaching routes without a challenge will now receive 401 after patching.
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 issue is CWE-178 (Improper Handling of Case Sensitivity) in Apache Camel's Netty HTTP consumer security-constraint handling. The component strips the configured endpoint context path from the request target before evaluating a NettyHttpSecurityConfiguration security constraint, but the strip was guarded by a case-sensitive startsWith check while Camel's route dispatch already matches context paths case-insensitively via RestConsumerContextPathMatcher. For a request whose context-path segment differs only by case, the constraint evaluation therefore ran against the unstripped target; with specific sub-path inclusions such as /admin/* rather than a catch-all, no inclusion matched and the target was treated as unrestricted, even though dispatch still reached the protected route. The fix in PR 25578 changes the strip to compare with toLowerCase(Locale.US) on both sides and adds a regression test covering a differently cased context path returning 401. CPE data identifies the affected package broadly as apache_software_foundation:apache_camel, so all Camel distributions bundling camel-netty-http in the affected ranges should be reviewed.
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
Unauthenticated network bypass (AV:N, PR:N, AC:L) reaching the guarded route exposes protected data (C:H) with limited tampering (I:L) and no availability impact; config dependency is not a CVSS metric.
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
DescriptionCVE.org
Improper Handling of Case Sensitivity vulnerability in Apache Camel Netty HTTP component.
This issue affects Apache Camel: from 4.0.0 before 4.18.5, from 4.19.0 before 4.22.1.
The camel-netty-http security constraint compared the request path against the configured context path using a case-sensitive match, while the routing that dispatches the request to the endpoint did not apply the same rule. The two comparisons therefore disagreed for any path whose case differed from the configured value. An external caller could alter the case of a character in a path segment so that the security constraint no longer recognised the path as protected, while the request still dispatched to the same endpoint. The result is that the constraint is skipped and the protected route is reached without satisfying it. No credential, prior access or special configuration is required beyond being able to send a request to the consumer.
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. The constraint now matches the request path with the same case rules the dispatch uses, so the two can no longer disagree. For deployments that cannot upgrade immediately, place the authorization decision in front of the Camel consumer, for example in a reverse proxy that normalises the request path before forwarding.
Articles & Coverage 1
Executive ViewAI
Apache Camel's camel-netty-http component carries a HIGH-severity authorization bypass (CVE-2026-80343) that can allow requests to reach business-protected integration routes without the intended access checks, weakening the controls leadership depends on for API and data-flow segregation. Teams running Camel 4.0.0 before 4.18.5 or 4.19.0 before 4.22.1 should treat this as a priority remediation item because affected routes may carry sensitive transactions or trusted system-to-system traffic. No public exploit has been identified at time of analysis.
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-104214
GHSA-pvjg-pwh7-34pj
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB