CVE-2026-56139: Apache Camel Undertow Stack Trace Disclosure Vulnerability
Apache Camel's Undertow HTTP component has a configuration flaw that causes it to leak sensitive information through error messages. When a client sends a request that triggers an exception, the server returns the full Java stack trace to the requester instead of a generic error response. This happens because the component defaults to exposing exceptions (muteException=false), contrary to other Camel HTTP components. An attacker who can reach an affected endpoint and cause any processing error—such as sending malformed data or invalid parameters—receives detailed internal information including credentials, hostnames, file paths, database names, and application architecture details. The flaw is particularly dangerous in Rest DSL deployments, where the mitigation option is completely ignored even if configured.
Source data · NVD / CISA · public domain
- CVSS
- 3.1 · 5.3 MEDIUM · CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N
- Weaknesses (CWE)
- CWE-209
- Affected products
- 1 configuration(s)
- Published / Modified
- 2026-07-06 / 2026-07-09
NVD description (verbatim)
Generation of Error Message Containing Sensitive Information vulnerability in Apache Camel Undertow Component. The camel-undertow HTTP server consumer exposes a muteException option that controls what is returned to the client when a route processing error occurs. This option defaulted to false, whereas the other Camel HTTP server components (camel-http / camel-jetty / camel-servlet and camel-platform-http) default it to true. With muteException=false, when a request triggers an exception during route processing the consumer writes the full Throwable stack trace into the HTTP response body as text/plain instead of returning an empty body. Any unauthenticated client that can reach the endpoint and cause a processing error - for example by sending a malformed request body, an invalid parameter, or otherwise triggering a route-internal failure - therefore receives a complete Java stack trace. Such a stack trace can disclose sensitive internal information, including credentials embedded in exception messages, internal host names and IP addresses, filesystem paths, dependency and version details, database and class names, and the application's internal structure, which an attacker can use to plan further attacks. In addition, for Rest DSL consumers the muteException option was not honoured at all: the RestUndertowHttpBinding was created with a hard-coded false, so the stack trace was returned even when muteException=true had been configured. This issue affects Apache Camel: from 4.0.0 before 4.14.8, from 4.15.0 before 4.18.3, from 4.19.0 before 4.21.0. Users are recommended to upgrade to version 4.21.0, which fixes the issue. If users are on the 4.14.x LTS releases stream, then they are suggested to upgrade to 4.14.8. If users are on the 4.18.x releases stream, then they are suggested to upgrade to 4.18.3. For deployments that cannot upgrade immediately, set muteException=true explicitly on the camel-undertow consumer (for example undertow: http://0.0.0.0:8080/api?muteException=true , or globally via the camel.component.undertow.mute-exception=true property), so that processing errors no longer return the stack trace to the client; note that on affected releases this workaround does not cover Rest DSL consumers, whose binding ignores the option until the fix is applied.
2 reference(s) · View on NVD →
SEC.co analysis · AI-assisted, reviewed against source
Technical summary
The Apache Camel camel-undertow component implements an HTTP server consumer with a muteException configuration option that controls exception disclosure behavior. By default, muteException is set to false, whereas equivalent components (camel-http, camel-jetty, camel-servlet, camel-platform-http) default to true. When false, any unhandled exception during route processing causes the entire Throwable stack trace to be serialized into the HTTP response body as text/plain, bypassing authentication checks. Additionally, the RestUndertowHttpBinding class hardcodes muteException to false, ignoring any configuration directive. This exposes CWE-209 (Information Exposure Through an Error Message) to unauthenticated network clients. The vulnerability spans three release streams: 4.0.0 through 4.14.7, 4.15.0 through 4.18.2, and 4.19.0 through 4.20.x.
Business impact
Organizations running affected Camel versions expose confidential operational data to any party capable of reaching their HTTP endpoints. Attackers can harvest credentials embedded in exception messages, discover internal infrastructure (hostnames, IP addresses, file paths), identify technology stacks and versions, and map application internals—all without authentication. This reconnaissance enables targeted exploitation of discovered services, credential harvesting for lateral movement, and compliance violations if personal or regulated data appears in logs. The risk is amplified in microservices architectures where Undertow-based endpoints are Internet-facing or accessible across trust boundaries.
Affected systems
Apache Camel versions 4.0.0–4.14.7, 4.15.0–4.18.2, and 4.19.0–4.20.x are affected. Deployments using the camel-undertow component for HTTP server endpoints are at risk, particularly those serving Rest DSL routes. The vulnerability is not automatically triggered; it requires an endpoint to be reachable by a client and for a request to cause a processing exception. Systems that have explicitly configured muteException=true on individual Undertow consumers are partially protected, except for Rest DSL routes where the setting is ignored.
Exploitability
Exploitability is straightforward. No special authentication, authorization, or privilege escalation is required—any network client that can reach an affected HTTP endpoint can trigger the vulnerability. The barrier to exploitation is minimal: send any request that causes a route exception (e.g., malformed JSON, missing required parameters, or a crafted input that fails internal validation). The response immediately reveals sensitive information. Public exploit code is unlikely to be necessary; standard HTTP tools suffice. CVSS 5.3 (MEDIUM) reflects the low barrier to exploitation but limited direct impact (information disclosure without integrity or availability compromise).
Remediation
Upgrade to patched versions: 4.21.0 (main release stream), 4.14.8 (LTS stream), or 4.18.3 (4.18 stream). These versions default muteException to true and honor the setting in Rest DSL consumers. For environments unable to upgrade immediately, set muteException=true explicitly via endpoint configuration (e.g., undertow:http://0.0.0.0:8080/api?muteException=true) or globally (camel.component.undertow.mute-exception=true). Note: this workaround does not protect Rest DSL consumers until the patched release is deployed.
Patch guidance
Review your Camel deployment to identify the active version stream. If running 4.14.x, upgrade to 4.14.8 or later. If running 4.15.x through 4.18.x, upgrade to 4.18.3 or later. If running 4.19.0 or later, upgrade to 4.21.0 or later. Before upgrading, verify patch availability through the Apache Camel project repositories and test in a non-production environment to confirm compatibility with your routes and dependencies. Apply upgrades to all instances serving HTTP endpoints via camel-undertow.
Detection guidance
Scan your codebase and runtime configuration for camel-undertow usage, particularly endpoints configured without explicit muteException=true. Search for 'undertow:' route definitions and check for the presence of the muteException parameter. Monitor HTTP access logs for patterns indicative of stack trace reconnaissance: repeated requests with invalid parameters to Undertow endpoints, followed by analysis of responses. Enable HTTP response logging to capture whether stack traces are being returned. Use SAST tools to identify Camel component versions in your build artifacts and dependencies. Runtime application performance monitoring (APM) or Java exception logging can help detect the internal errors being triggered and exposed.
Why prioritize this
Although rated MEDIUM severity, this vulnerability warrants prompt remediation because it directly enables reconnaissance for further attacks. Information disclosure of credentials, infrastructure topology, and software versions significantly reduces the attack surface an adversary must overcome. The low exploitability barrier and lack of authentication requirements make it an attractive reconnaissance vector. Prioritize based on the sensitivity of data that could appear in stack traces (e.g., API keys, database hostnames), the network accessibility of affected endpoints, and the maturity of your compensating controls. Rest DSL deployments are highest priority due to the ignored mitigation option.
Risk score, explained
CVSS 5.3 reflects the combination of network-accessible, unauthenticated attack vector (AV:N/PR:N/UI:N) with no integrity or availability impact, only confidentiality loss (C:L/I:N/A:N). The score appropriately downgrades what could appear critical (stack trace leakage) because the direct impact is information disclosure rather than system compromise. However, in practice, this information becomes the springboard for higher-severity attacks, making business risk higher than the base score suggests.
Frequently asked questions
Can I mitigate this vulnerability without upgrading?
Partially. Set muteException=true on individual Undertow consumer endpoints or globally via the camel.component.undertow.mute-exception=true property. This prevents stack traces from being returned for most consumers, but the workaround does not apply to Rest DSL consumers until you upgrade to a patched release, because the RestUndertowHttpBinding ignores the setting on affected versions.
What information can an attacker actually extract from these stack traces?
Stack traces may expose credentials in exception messages, internal IP addresses and hostnames, file system paths, application class and package names, database names, dependency versions, and the logical flow of your application. An attacker can use this to identify vulnerable dependencies, craft targeted exploits, or locate services for further attack.
Do I need to patch if my Undertow endpoints are behind a firewall or load balancer?
Yes. While network segmentation reduces the attack surface, any misconfiguration, compromised internal client, or supply-chain attack could exploit the vulnerability. Additionally, compliance frameworks often require fixing known information disclosure flaws regardless of network controls. Treat this as high priority unless the endpoint is genuinely air-gapped.
How do I know which Camel version I'm running?
Check your build configuration (Maven pom.xml, Gradle build file, or similar), runtime classpath inspection (jar manifests), or Camel admin console if deployed. Run a test request to an affected endpoint and inspect the response; a stack trace in the response confirms the vulnerability is active.
This analysis is provided for informational purposes to support vulnerability assessment and remediation planning. The information reflects the CVE description and Apache Camel project advisories as of the publication date. Organizations should verify patch availability, compatibility, and applicability to their specific deployments before taking remedial action. Security risk is context-dependent; internal risk assessments should account for asset criticality, exposure, and compensating controls. SEC.co makes no warranty regarding the completeness, accuracy, or fitness of this information for any particular purpose. Source: NVD (public-domain), retrieved 2026-08-15. Analysis generated by SEC.co (claude-haiku-4-5).
Related vulnerabilities
- CVE-2026-49365MEDIUMApache Camel Netty HTTP Stack Trace Information Disclosure
- CVE-2025-36328MEDIUMIBM watsonx.data Intelligence Information Disclosure Vulnerability
- CVE-2025-52606MEDIUMHCL iControl Weak Input Validation Vulnerability
- CVE-2025-59872MEDIUMHCL ZIE for Web File Upload Code Execution Vulnerability
- CVE-2026-40997MEDIUMSpring Web Services Account Enumeration via Error Message Disclosure
- CVE-2026-41730MEDIUMSpring Data REST Exception Disclosure Vulnerability
- CVE-2026-47775MEDIUMEnvoy OAuth2 Padding Oracle – Credential Theft Risk
- CVE-2026-56331MEDIUMCapgo Information Disclosure via Improper Error Handling in Invitation Endpoint