GHSA-2p39-5856-3v5v
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain S3 write access to a consumed bucket
-
DeliveryUpload object whose key contains ${ or $simple{
-
Exploitaws2-s3 consumer sets CamelAwsS3Key header to that name
-
Executionaws2-s3 producer evaluates header as Simple expression
-
ImpactDisclose properties/credentials or invoke bean methods
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Expression language sanitization
|
| Exploitation Conditions | Requires a deployment on an affected version (4.8.0-4.18.4 or 4.19.0-4.22.1) running a route that consumes from an aws2-s3 endpoint and produces to an aws2-s3 producer while letting the CamelAwsS3Key header pass through to the producer (or copying untrusted content into that header); in such a route the consumed object's name reaches determineKey() and any name containing the markers ${ or $simple{ is evaluated as a Simple expression. The attacker must be able to choose the name of an object in a consumed bucket - typically a principal permitted to upload to that bucket. Limiting factors: configuring keyName on the producer does NOT prevent it because the header takes precedence; reading an evaluated value back additionally requires the ability to see object names in the destination bucket, whereas a bean-method invocation takes effect without that visibility only where camel-bean is on the classpath; the bucket-name header path is not reachable this way because the consumer only places its own configured bucket there; and releases before 4.8.0 are not affected. |
| Impact | The input CVSS 3.1 score is 5.4 (medium) with vector AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:N. The AV:N reflects that the malicious input (an S3 object key) arrives over the network, but PR:L is the decisive signal: exploitation requires the attacker to be a principal allowed to write/name an object in a bucket that a vulnerable Camel route consumes - so this is authenticated against the storage layer, not anonymous internet exploitation. Scope is Unchanged and impact is partial (C:L/I:L, A:N), consistent with reading JVM system properties, environment variables and configuration properties (which may carry credentials) or invoking bean methods, rather than full compromise. No EPSS score is provided in the input, no CISA KEV listing is present, and no public exploit code is referenced; the vuln.today Decision label is 'awaiting_data', which signals the priority is not yet escalated rather than act_now/emergency. This is therefore a conditional medium-risk issue, not a high-CVSS-but-low-real-risk mislabel and not a drop-everything emergency: its real-world priority depends almost entirely on whether a deployment actually runs the specific route pattern (an aws2-s3 consumer feeding an aws2-s3 producer with the CamelAwsS3Key header passed through) on an affected version. Where that pattern is absent, practical risk is low; where it is present and untrusted principals can upload to the consumed bucket, it is a genuine code/credential-exposure concern. |
| Exploit ScenarioDerived | An attacker who holds write/upload permission to an S3 bucket that a vulnerable Camel route consumes uploads an object whose key contains a Simple-language marker, e.g. ${sys.some.property} or a $simple{...} bean call. When the route consumes that object and produces it to another aws2-s3 endpoint, AWS2S3Utils.determineKey() evaluates the attacker-chosen key as a Simple expression in the Camel process, disclosing system properties/environment/config values (potentially credentials) or, where camel-bean is on the classpath, invoking bean methods. No public exploit code is referenced in the input; the linked JIRA (CAMEL-20971) is the feature request that introduced dynamic key evaluation in 4.8.0, not a proof of concept. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 23, 2026
Expression language injection in the Apache Camel camel-aws2-s3 producer allows a user who can choose object names in a bucket that a Camel route consumes to have Simple expressions of their choosing evaluated inside the Camel process, because the object name arriving in the CamelAwsS3Key message header is passed to the Simple language whenever it contains ${ or $simple{. Deployments on 4.8.0 through 4.18.4 and 4.19.0 through 4.22.1 are affected only where a route passes exchanges from an aws2-s3 consumer to an aws2-s3 producer with that header intact; the attacker must already hold write access to the consumed bucket (authenticated, PR:L), and reading an evaluated value back additionally requires visibility of object names in the destination bucket, which is why the assessed severity is medium (CVSS 5.4). No public exploit code or confirmed active exploitation was identified at time of analysis.
RemediationAI
Upgrade to 4.23.0, or to 4.22.2 if staying on the 4.22.x stream, or to 4.18.5 if staying on the 4.18.x stream; the 4.8.x-4.17.x and 4.19.x-4.21.x lines will not be fixed, so deployments on them must move to a supported release. After upgrading, determineKey() and determineBucketName() evaluate Simple only for the keyName and bucketName options written by the route author, and header-supplied keys and CamelAwsS3OverrideBucketName values are used literally - routes that relied on placing an unevaluated Simple expression in those headers must now evaluate it in the route itself (for example setHeader with simple()) or move it into the endpoint's keyName/bucketName option. If upgrading is not immediately possible, in routes that pass exchanges from an aws2-s3 consumer to an aws2-s3 producer either strip the header with removeHeader("CamelAwsS3Key") so the endpoint's keyName is used (side effect: every message in that route then targets one fixed key unless the route computes one), or reject exchanges whose CamelAwsS3Key header contains ${ or $simple{ (side effect: any legitimate dynamic-key route using those markers breaks). Configuring keyName alone is explicitly not a workaround because the header takes precedence. As defense in depth, restrict write access on consumed buckets to trusted principals, which shrinks the set of potential attackers but does not remove the flaw.
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 routes messages between endpoints and carries per-message metadata in headers; camel-aws2-s3 implements S3 object operations. Since 4.8.0 - the release that resolved the CAMEL-20971 feature request for a dynamic key name on the S3 consumer - AWS2S3Utils.determineKey() took the key from the CamelAwsS3Key header (falling back to the endpoint's keyName option only when the header was absent) and, if the value contained the markers ${ or $simple{, evaluated it through Camel's Simple expression language. This is CWE-917, Expression Language Injection: route configuration and message data were conflated, so a value the route author never intended as an expression was compiled and evaluated. The aws2-s3 consumer itself populates CamelAwsS3Key with the name of the object it read, so a plain consumer-to-producer route forwarded remote-controlled object names straight into the evaluator; setting keyName on the producer did not help because the header takes precedence. Simple can resolve JVM system properties, environment variables and configuration properties (common carriers of credentials) and, where camel-bean is on the classpath, invoke registry bean methods. determineBucketName() shares the same evaluation logic, but the consumer only ever places its own configured bucket in the bucket header, so that path is not reachable from remote object data. Releases before 4.8.0 used the header value literally and are unaffected.
Know when 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:L/UI:N/S:U/C:L/I:L/A:N
Attacker needs write/upload rights to a consumed bucket (PR:L) with the key delivered over the network (AV:N); partial confidentiality via property/credential disclosure and partial integrity via bean-method invocation, no availability impact.
Primary rating from Vendor (CNA).
CVSS VectorVendor
Lifecycle Timeline
2Description PRE-NVD
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
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
Bypass/Injection vulnerability in Apache Camel components under particular conditions.10.0 through <= 4.10.1, from 4.8.0
The XSLT component in Apache Camel before 2.11.4 and 2.12.x before 2.12.3 allows remote attackers to read arbitrary file
Apache Camel's Jackson and JacksonXML unmarshalling operation are vulnerable to Remote Code Execution attacks. Rated cri
The XSLT component in Apache Camel 2.11.x before 2.11.4, 2.12.x before 2.12.3, and possibly earlier versions allows remo
Cross-realm token acceptance bypass in Apache Camel Keycloak security policy. The KeycloakSecurityPolicy fails to proper
Deserialization of Untrusted Data vulnerability in Apache Camel LevelDB component. The Camel-LevelDB DefaultLevelDBSeria
Unsafe Java deserialization in the Apache Camel camel-mina component (versions 3.0.0 through 4.14.5, 4.15.0 through 4.18
Apache Camel's File is vulnerable to directory traversal. Rated high severity (CVSS 7.5), this vulnerability is remotely
The camel-castor component in Apache Camel 2.x before 2.19.4 and 2.20.x before 2.20.1 is vulnerable to Java object de-se
The camel-xstream component in Apache Camel before 2.15.5 and 2.16.x before 2.16.1 allow remote attackers to execute arb
The camel-hessian component in Apache Camel 2.x before 2.19.4 and 2.20.x before 2.20.1 is vulnerable to Java object de-s
Apache Camel before 2.9.7, 2.10.0 before 2.10.7, 2.11.0 before 2.11.2, and 2.12.0 allows remote attackers to execute arb
EUVD-2026-109668
NVD
CVE.org
EPSS
Exploit-DB