Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLocate reachable coap:// Camel consumer
-
DeliveryCraft CoAP packet with Camel* query params
-
ExploitSend single UDP datagram to port 5683
-
ExecutionInjected headers override exec producer command
-
PersistCamel runs arbitrary OS command
-
ImpactCommand output returned in CoAP response
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V4 - API and Web Service Object attribute protection
|
| Exploitation Conditions | The Camel deployment must run a route that consumes from a coap:// endpoint AND forwards the resulting Exchange to a header-sensitive producer - camel-exec for full OS command execution, or camel-sql/camel-bean/camel-file/camel-freemarker/camel-velocity for lesser header-driven abuse. No authentication is required (PR:N confirmed by CVSS vector) because CoAP has no built-in auth and DTLS is optional and disabled by default; exploitation needs only a single unauthenticated UDP datagram to the CoAP port (default 5683) with attacker-chosen URI query parameters that become Camel* headers. Limiting factors: the vulnerability is inert unless such a coap→sensitive-producer route is configured (this is the primary constraint narrowing real-world exposure and is reflected in the low EPSS), the CoAP port must be network-reachable to the attacker, and enabling DTLS would add an authentication barrier. This is a specific-configuration RCE, not a default-configuration one - most Camel installs do not use camel-coap. |
| Impact | The signals are strongly aligned toward high technical severity but mixed on real-world urgency. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H = 10.0) reflects unauthenticated network exploitation with total impact, and SSVC concurs on Technical Impact: total and Automatable: yes. However, SSVC Exploitation is 'none' (no observed active exploitation) and the vulnerability is NOT in CISA KEV, so this is not confirmed actively exploited despite the perfect CVSS. EPSS is only 0.55% (68th percentile), which is low for a CVSS-10 RCE and suggests the threat is not yet widespread - consistent with the fact that exploitation requires a fairly specific deployment (a CoAP consumer route forwarding to a header-sensitive producer), not merely that Camel is installed. Publicly available exploit code (github.com/dinosn/CVE-2026-33453) raises the practical risk and lowers the barrier for opportunistic scanning. Net: treat as a high-priority patch for anyone actually running camel-coap routes, but the low EPSS and 'none' exploitation status indicate the installed base of exploitable configurations is narrow rather than internet-ubiquitous. Note the data conflict flagged below: version 4.19.0 appears in both the affected list and the recommended-upgrade list. |
| Exploit ScenarioDerived | An attacker locates an internet- or network-reachable Camel instance consuming from coap:// whose route forwards to camel-exec, then sends a single crafted CoAP UDP datagram to port 5683 with URI query parameters named CamelExecCommandExecutable and CamelExecCommandArgs. These injected headers override the configured command, causing arbitrary OS commands to run under the Camel process privileges, with the command output returned directly in the CoAP response for an interactive shell-like channel. A public proof-of-concept exists (github.com/dinosn/CVE-2026-33453), and the low attack complexity (AC:L) plus lack of authentication or user interaction make exploitation trivial where the vulnerable route exists. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 24, 2026
Remote 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) allows an unauthenticated attacker to inject arbitrary internal Camel headers via CoAP URI query parameters, achieving OS command execution when a route forwards to a header-sensitive producer such as camel-exec. The component maps incoming CoAP query parameters straight into Exchange message headers with no HeaderFilterStrategy, so a single UDP packet to port 5683 can override the executable and arguments of a downstream exec producer and return command output in the CoAP response. Rated CVSS 10.0 with publicly available exploit code, though EPSS remains modest (0.55%, 68th percentile) and CISA SSVC records no observed exploitation, indicating opportunity rather than confirmed mass exploitation.
RemediationAI
Vendor-released patch: upgrade to Apache Camel 4.18.1 or 4.19.0 per the vendor advisory at https://camel.apache.org/security/CVE-2026-33453.html; Red Hat consumers should apply RHSA-2026:17668. Given the 4.19.0 labeling ambiguity, confirm the exact fixed release with the advisory before deploying. If immediate patching is not possible, the highest-value compensating control is to stop untrusted input from reaching sensitive producers: restrict network access to the CoAP port (default UDP 5683) with host/network firewall rules so only trusted peers can send datagrams - noting that UDP-based CoAP is invisible to HTTP-layer WAF/IDS, so those controls will not help. Where feasible, enable DTLS on the CoAP endpoint to add authentication (trade-off: requires certificate/PSK provisioning on all clients), and re-architect routes so a camel-coap consumer does not directly feed header-sensitive producers (camel-exec, camel-sql, camel-bean, camel-file, camel-freemarker, camel-velocity), or insert an explicit removeHeaders/HeaderFilterStrategy step to strip Camel* headers before the producer (trade-off: may remove legitimate control headers your route depends on).
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in maven, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Apache Camel is a Java enterprise integration framework whose routes connect protocol consumers to producers via a message Exchange carrying a body and headers. CoAP (RFC 7252) is a lightweight UDP-based request/response protocol for constrained devices, with no built-in authentication and DTLS optional and disabled by default. The root cause is CWE-915 (Improperly Controlled Modification of Dynamically-Determined Object Attributes): CamelCoapResource.handleRequest() iterates OptionSet.getUriQuery() and calls camelExchange.getIn().setHeader(...) for every query parameter without filtering. Unlike endpoints extending DefaultHeaderFilterStrategyEndpoint, CoAPEndpoint extends DefaultEndpoint and CoAPComponent does not implement HeaderFilterStrategyComponent, so no allow/deny list constrains which headers external input can set - including internal Camel* control headers. The CPE cpe:2.3:a:apache_software_foundation:apache_camel identifies the affected product line, and the exploit specifically abuses CamelExecCommandExecutable and CamelExecCommandArgs consumed by camel-exec.
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:C/C:H/I:H/A:H
Unauthenticated single UDP packet gives OS command execution (AV:N/AC:L/PR:N/UI:N); the coap component's flaw impacts a separate downstream producer/OS authority, so S:C with full C/I/A.
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
Lifecycle Timeline
4DescriptionCVE.org
Improperly Controlled Modification of Dynamically-Determined Object Attributes vulnerability in Apache Camel Camel-Coap component.
Apache Camel's camel-coap component is vulnerable to Camel message header injection, leading to remote code execution when routes forward CoAP requests to header-sensitive producers (e.g. camel-exec)
The camel-coap component maps incoming CoAP request URI query parameters directly into Camel Exchange In message headers without applying any HeaderFilterStrategy. Specifically, CamelCoapResource.handleRequest() iterates over OptionSet.getUriQuery() and calls camelExchange.getIn().setHeader(...) for every query parameter. CoAPEndpoint extends DefaultEndpoint rather than DefaultHeaderFilterStrategyEndpoint, and CoAPComponent does not implement HeaderFilterStrategyComponent; the component contains no references to HeaderFilterStrategy at all.
As a result, an unauthenticated attacker who can send a single CoAP UDP packet to a Camel route consuming from coap:// can inject arbitrary Camel internal headers (those prefixed with Camel*) into the Exchange. When the route delivers the message to a header-sensitive producer such as camel-exec, camel-sql, camel-bean, camel-file, or template components (camel-freemarker, camel-velocity), the injected headers can alter the producer's behavior. In the case of camel-exec, the CamelExecCommandExecutable and CamelExecCommandArgs headers override the executable and arguments configured on the endpoint, resulting in arbitrary OS command execution under the privileges of the Camel process.
The producer's output is written back to the Exchange body and returned in the CoAP response payload by CamelCoapResource, giving the attacker an interactive RCE channel without any need for out-of-band exfiltration.
Exploitation prerequisites are minimal: a single unauthenticated UDP datagram to the CoAP port (default 5683). CoAP (RFC 7252) has no built-in authentication, and DTLS is optional and disabled by default. Because the protocol is UDP-based, HTTP-layer WAF/IDS controls do not apply. This issue affects Apache Camel: from 4.14.0 through 4.14.5, from 4.18.0 before 4.18.1, 4.19.0.
Users are recommended to upgrade to version 4.18.1 or 4.19.0, fixing the issue.
Blast Radius
ecosystem impact- 3 maven packages depend on org.apache.camel:camel-coap (2 direct, 1 indirect)
Ecosystem-wide dependent count for version 4.14.0.
Articles & Coverage 1
Executive ViewAI
Apache Camel's camel-coap component (versions 4.14.0-4.14.5, 4.18.0, and 4.19.0) allows remote unauthenticated attackers to execute arbitrary operating system commands, risking complete system compromise. Exploit code is publicly available, and the vulnerability affects any organization using Camel for integration tasks involving CoAP messaging. Immediate patching is critical to close this window before real-world attacks increase beyond current low targeting levels.
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
OS command injection occurs when an application passes unsanitized user input directly into system shell commands.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
More in Apache Camel
View allUnsafe 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
Cypher injection in Apache Camel's camel-neo4j producer allows attackers who control JSON key names in the CamelNeo4jMat
EUVD-2026-25816
GHSA-695c-x5gc-94gj
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB