Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessInfluence JDBC URL or credentials profile
-
DeliveryInject class-loading connection parameter
-
ExploitDriver reflectively loads chosen classpath class
-
ExecutionGadget class instantiated in application JVM
-
ImpactArbitrary code execution in application context
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V15 - Secure Coding and Architecture Reflection safety, class allowlisting
|
| Exploitation Conditions | Exploitation requires that the attacker can influence the JDBC connection URL parameters or the AWS credentials profile fields consumed by the Redshift JDBC driver before version 2.3.0, AND that a suitable exploitable class is already present on the application's classpath for the driver to load and execute. This is not a flaw against a default standalone deployment of the driver itself - it is reachable only where an application passes externally controllable values into connection-string or credentials-profile construction. Limiting factors: the dependency on an available classpath gadget class (reflected as AT:P in CVSS 4.0 / AC:H in CVSS 3.1), and the need for an attack surface that lets untrusted input reach the connection URL or credentials profile; applications that build these only from trusted, static configuration are not realistically exploitable. The vendor workaround is to not build URLs/credentials profiles from untrusted input or to allowlist externally supplied parameter values; upgrading to 2.3.0 is the complete fix. |
| Impact | This is a genuinely high-priority issue, but its real-world risk is gated by a specific precondition rather than being broadly remote-unauthenticated. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H, score 9.2) and the GHSA CVSS 3.1 vector (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H, score 8.1) agree on network vector, no privileges, no user interaction, and full confidentiality/integrity/availability impact - i.e. remote code execution. The two vectors differ on complexity: the 4.0 assessment uses AC:L with AT:P (a present attack requirement), while the 3.1 assessment folds that same gating into AC:H; both are capturing the same real constraint, that a suitable loadable/gadget class must exist on the application classpath and the attacker must be able to influence the JDBC connection URL or AWS credentials profile. The vuln.today priority is act_now and a vendor patch exists, so this should be treated as urgent. However, no EPSS score, no CISA KEV listing, and no confirmed public exploit code are present in the input - so there is no evidence of active mass exploitation, and the practical risk depends heavily on whether an application exposes connection-string or credentials-profile construction to untrusted input. CWE-470 (unsafe reflection) is consistent with the described class-loading mechanism. |
| Exploit ScenarioDerived | An application builds a Redshift JDBC connection URL or AWS credentials profile using values that an attacker can influence (for example a multi-tenant data tool or admin UI that accepts connection parameters). The attacker supplies a crafted parameter that causes the pre-2.3.0 driver to reflectively load and instantiate a class already present on the application classpath, executing code inside the application's JVM. No public exploit code is identified in the input, though researchers (4ra1n, pyn3rd, unam4) disclosed the issue via coordinated disclosure. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Nov 03, 2026
Unsafe class loading (CWE-470) in Amazon Redshift JDBC Driver before 2.3.0 lets an actor who can influence the JDBC connection URL parameters or the AWS credentials profile fields cause the driver to load and instantiate classes present on the application classpath, resulting in code execution inside the application's JVM. The flaw is not reachable against the driver in isolation: it requires an application that constructs connection strings or credentials profiles from externally controllable input, plus a suitable gadget class already available on the classpath, which is why the assessed CVSS 3.1 vector carries AC:H despite PR:N and full confidentiality/integrity/availability impact. No public exploit code was identified at time of analysis and the issue is not confirmed actively exploited (CISA KEV), but the vendor has released a fix and the priority call is act_now given the RCE outcome.
Earlier versions of this analysis (1)
Unsafe reflection in the Amazon Redshift JDBC Driver before 2.3.0 allows an actor who can influence the JDBC connection URL or the AWS credentials profile to cause the driver to load arbitrary classes already present on the application classpath, executing code in the context of the application's JVM. The CVSS 3.1 score of 8.1 (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H) reflects that two preconditions must line up: the application must construct those values from untrusted input, and a suitable loadable class must already be on the classpath. No confirmed active exploitation or public exploit code was identified at the time of analysis, and AWS has released version 2.3.0 as the complete fix.
RemediationAI
Upgrade to Amazon Redshift JDBC Driver 2.3.0 or later (the 2.3.0 release is published at https://github.com/aws/amazon-redshift-jdbc-driver/releases/tag/v2.3.0, per the AWS bulletin 2026-168 and GHSA-qrph-v96m-w2mv); federated or forked copies of the driver code must also be patched to incorporate the fix, since updating the dependency alone does not cover derivative source. If an immediate upgrade is not possible, the vendor workaround is to stop building JDBC connection URLs and AWS credentials profiles from untrusted input, or to validate any externally supplied parameter names and values against an allowlist of expected parameters and values before they reach the driver - the trade-off being that permissive or incomplete allowlists leave the class-loading path reachable, and locking URLs down to static configuration may break multi-tenant or user-configured connection scenarios. Note that the driver requires a suitable class to be present on the classpath for exploitation, so reducing unnecessary gadget libraries on the application classpath also shrinks the practical attack surface as a secondary measure.
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 Redshift JDBC Driver is a Type 4 JDBC driver that talks to Amazon Redshift through the standard JDBC APIs. CWE-470 (Use of Externally-Controlled Input to Select Classes or Code) is the root cause here: certain connection URL parameters and AWS credentials profile fields are processed in a way that resolves and loads classes named by those values using the application's own classloader, so the set of reachable classes is bounded by whatever sits on the application classpath. This is the classic Java unsafe-reflection pattern in which attacker-influenced strings reach class loading/instantiation paths; impact materializes only when a usable gadget class is present, which is captured by AT:P in the CVSS 4.0 vector (9.2) and AC:H in the assessed CVSS 3.1 vector (8.1 per the GHSA). The affected artifact is maven/com.amazon.redshift:redshift-jdbc42 with all versions below 2.3.0 vulnerable per the CPE cpe:2.3:a:aws:amazon-redshift-jdbc-driver and EUVD's 0 to <2.3.0 range.
Know when Amazon Redshift Jdbc Driver 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
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Network-reachable via influenced connection input (AV:N, PR:N, UI:N), but AC:H because exploitation depends on a suitable gadget class existing on the classpath; full RCE gives C:H/I:H/A:H.
Primary rating from Vendor (AMZN).
CVSS VectorVendor: AMZN
Lifecycle Timeline
4DescriptionCVE.org
Unsafe reflection in the connection parameter and credentials profile handling of Amazon Redshift JDBC Driver before 2.3.0 might allow an actor who can influence the JDBC connection URL or the AWS credentials profile to execute arbitrary code in the application context, provided a suitable class is available on the application classpath.
To remediate this issue, users should upgrade to version 2.3.0 or later.
Technical POC Analysis
Bug class: CWE-470 - Use of Externally-Controlled Input to Select Classes or Code.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
Amazon Redshift JDBC Driver versions before 2.3.0 carry a critical unsafe class-loading flaw that allows an attacker to achieve arbitrary code execution inside any application JVM that builds connection strings or credential profiles from externally influenced input. Applications embedding the driver for Redshift connectivity - particularly those accepting user-supplied connection parameters - are exposed to full compromise of confidentiality, integrity, and availability. Leadership should care because a successful exploit yields remote code execution in business-critical Java services, not merely data access.
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
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
EUVD-2026-116383
NVD
CVE.org
GitHub
Exploit-DB