CVE-2026-55993: Apache Camel WebSocket SSRF and Secret Exfiltration Vulnerability

Technical summary

The vulnerability exists in the camel-atmosphere-websocket consumer's WebsocketConsumer.sendEventNotification() method, which iterates over inbound WebSocket query parameters and copies them directly into the Camel Exchange header map without applying HeaderFilterStrategy filtering. This allows an attacker to inject Camel-reserved headers—specifically CamelHttpUri (Exchange.HTTP_URI)—by supplying them as query string parameters. Because the HTTP producer downstream resolves Camel property placeholders on the resulting URI, an attacker can embed placeholder expressions (e.g., environment variable references or vault secret lookups) to exfiltrate their resolved values. The affected code path bypasses the HeaderFilterStrategy mechanism that the HTTP/servlet stack normally enforces. Root cause: missing case-insensitive filtering of the Camel* and camel* header namespace on inbound message mapping.

Business impact

Organizations deploying unauthenticated WebSocket endpoints connected to HTTP producers face exposure of sensitive runtime data—environment variables, application properties, and secrets stored in vault systems. An attacker can weaponize this to discover internal service endpoints, cloud metadata (IAM credentials, instance roles), and encryption keys. The SSRF component enables lateral movement within networks and access to internal services bypassing perimeter controls. In cloud environments, this can lead to cloud credential compromise. The attack requires no authentication, making it exploitable by external threat actors if the WebSocket endpoint is exposed.

Affected systems

Apache Camel versions 4.0.0 through 4.14.7, versions 4.15.0 through 4.18.2, and versions 4.19.0 through 4.20.x are affected. The camel-atmosphere-websocket component is explicitly in scope; any deployment using this component as a consumer feeding into downstream HTTP producers is at risk, especially if the WebSocket endpoint is exposed without authentication. Organizations should verify all Camel installations and identify routes that bridge WebSocket consumers to HTTP producers.

Exploitability

Exploitability is high and requires minimal effort. The attack surface is straightforward: a remote attacker crafts a WebSocket connection request with malicious query parameters and requires no authentication. The injected headers are processed automatically by the consumer without user interaction. Proof of concept would involve establishing a WebSocket connection with a query string like ?CamelHttpUri=http://internal-service, causing the downstream HTTP producer to contact the attacker's chosen destination. Placeholder injection (e.g., embedding ${env:SECRET_VAR}) extracts secrets directly into the attacker-controlled HTTP request. CVSS 7.5 (HIGH) reflects the network-accessible attack vector, no authentication requirement, and confidentiality impact, though integrity and availability are not directly affected.

Remediation

Upgrade immediately to Apache Camel 4.21.0, 4.14.8 (LTS stream), or 4.18.3 (LTS stream). The fix applies HeaderFilterStrategy case-insensitively to filter Camel* and camel* headers on inbound WebSocket message mapping. For organizations unable to upgrade immediately, implement compensating controls: (1) add removeHeaders('Camel*') and removeHeaders('camel*') filters at the start of each route receiving WebSocket traffic; (2) require authentication (e.g., mutual TLS, token-based) on all WebSocket endpoints; (3) avoid direct routing from untrusted consumers to HTTP producers whose target URI can be influenced by message headers; (4) use explicit, hardcoded HTTP endpoints rather than header-driven URI selection. These controls should be temporary and replaced by patching as soon as feasible.

Patch guidance

Verify your Camel version by checking pom.xml, gradle.build, or runtime version output (camel --version or similar). Identify all routes using the camel-atmosphere-websocket component. Plan upgrades to 4.21.0 (recommended for latest versions), 4.14.8 (if on 4.14.x LTS), or 4.18.3 (if on 4.18.x LTS). Test patches in a staging environment, especially routes that bridge WebSocket to HTTP. Confirm that HeaderFilterStrategy filtering is applied post-patch. Review route configuration to ensure no hard dependencies on header-driven URIs that might be re-introduced in custom code. Coordinate patching to minimize service disruption.

Detection guidance

Monitor WebSocket connection logs for suspicious query parameters containing Camel reserved header names (CamelHttpUri, CamelHttpMethod, etc.). Look for patterns like ?Camel* in WebSocket upgrade requests. Inspect downstream HTTP producer logs for unexpected target URIs or requests to internal/metadata endpoints that do not match intended service destinations. Check application logs for placeholder resolution errors or exfiltration of environment variable values in HTTP request headers sent to external destinations. Network segmentation monitoring (e.g., DLP, DNS logging) can detect HTTP requests to unexpected internal or metadata services. Implement Web Application Firewall (WAF) rules to block WebSocket upgrade requests with Camel* query parameters if the endpoints should not accept them.

Why prioritize this

HIGH priority: unauthenticated network-accessible vulnerability with direct SSRF and data exfiltration impact. The attack requires no special privileges, no user interaction, and can compromise runtime secrets and cloud credentials. Organizations with exposed WebSocket endpoints should prioritize patching within days, not weeks. Those with authentication-protected endpoints have reduced urgency but should still plan updates within standard patch cycles.

Risk score, explained

CVSS 3.1 score 7.5 (HIGH) reflects: Attack Vector = Network (unauthenticated remote access), Attack Complexity = Low (straightforward query parameter injection), Privileges Required = None, User Interaction = None, Scope = Unchanged, and Confidentiality Impact = High (secret disclosure). Integrity and Availability are not directly impacted by the vulnerability itself, though the SSRF capability could be chained with other flaws. The score does not account for context-dependent factors: organizations with authentication-protected WebSocket endpoints or routes that do not feed into HTTP producers face lower practical risk, while those with untrusted, unauthenticated WebSocket exposure and downstream HTTP producers should treat this as CRITICAL.

Frequently asked questions