CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-14265

CVE-2026-14265: Remote Code Execution via Unsafe Deserialization in AWS Advanced JDBC Wrapper

Amit Schendel
Amit Schendel
Senior Security Researcher

Nov 18, 2026·10 min read·0 visits

Executive Summary (TL;DR)

Unsafe Java deserialization (CWE-502) in the AWS Advanced JDBC Wrapper's `RemoteQueryCachePlugin` (versions 3.3.0 to 4.0.0) allows attackers with write access to a shared Redis or Valkey cache to achieve Remote Code Execution (RCE) on client application servers. Upgrade to version 4.0.1 or disable the `remoteQueryCache` plugin.

CVE-2026-14265 (GHSA-c5q4-97jw-jggh) is a high-severity Remote Code Execution (RCE) vulnerability in the Amazon Web Services (AWS) Advanced JDBC Wrapper versions 3.3.0 through 4.0.0. The defect resides in the `RemoteQueryCachePlugin` and its underlying `CachedResultSet` implementation, which uses an unfiltered `java.io.ObjectInputStream` to deserialize cached SQL query results retrieved from external Redis or Valkey backends. An attacker with write access to the shared cache infrastructure can inject serialized Java gadget chains into cache keys, achieving arbitrary code execution within the JVM context of any application server consuming the cached entries.

Vulnerability Overview

The AWS Advanced JDBC Wrapper (software.amazon.jdbc:aws-advanced-jdbc-wrapper) is a complementary driver extension designed to add high-availability, failover, and performance capabilities to standard JDBC drivers when connecting to Amazon Aurora and Amazon RDS databases. In version 3.3.0, the wrapper introduced the RemoteQueryCachePlugin, a feature allowing client applications to store and retrieve SQL query results in external memory caches such as Redis, Valkey, Amazon ElastiCache, or Amazon MemoryDB.

To facilitate transparent caching across distributed application tiers, the plugin serializes JDBC ResultSet structures—encapsulated within the software.amazon.jdbc.plugin.cache.CachedResultSet class—into raw byte arrays before transmitting them to the remote cache cluster. When subsequent matching SQL queries are executed by the application, the wrapper intercepts the query, fetches the corresponding binary payload from the cache backend, and reconstructs the CachedResultSet in memory.

In versions 3.3.0 through 4.0.0, this object reconstruction process relies on standard Java native serialization without applying class filtering or type validation. This flaw, tracked as CVE-2026-14265 (and GHSA-c5q4-97jw-jggh) and classified under CWE-502 (Deserialization of Untrusted Data), exposes a critical trust boundary violation between the cache infrastructure and the application runtime.

If an adversary compromises the shared cache tier or gains network write access to an unauthenticated cache instance, they can overwrite legitimate query cache entries with crafted Java serialization streams. When a client application retrieves and deserializes the poisoned entry, the attacker achieves arbitrary Remote Code Execution (RCE) within the privileges of the Java Virtual Machine (JVM) hosting the JDBC wrapper.

Root Cause Analysis

The root cause of CVE-2026-14265 is the direct instantiation and use of java.io.ObjectInputStream without an associated ObjectInputFilter (as standardized in JEP 290) or a custom resolveClass() override within CachedResultSet.java. Java native serialization reconstructs object graphs by reading class descriptors from the binary stream and resolving them against the local JVM classpath before invoking class-specific readObject() methods.

Within the AWS Advanced JDBC Wrapper, the deserialization routine occurs across two distinct execution paths depending on how the cached data is accessed. The primary path executes during initial cache retrieval in CachedResultSet.deserializeFromByteArray(byte[] data), where the wrapper reads the top-level CachedResultSetMetaData object and extracts the row dimensions and nested byte arrays representing individual column values.

The secondary path executes lazily during column retrieval inside the inner class method CachedResultSet.CachedRow.get(int columnIndex). To optimize memory consumption and parsing overhead, individual column values are stored as nested byte arrays (rawData) during the initial fetch and are only deserialized into Java objects (rowData) when the application explicitly requests the column value via standard JDBC getter methods (such as ResultSet.getObject() or ResultSet.getString()).

Because neither execution path restricts the classes permitted for instantiation, an attacker can substitute the expected CachedResultSetMetaData object or any individual column byte array with a serialized gadget chain. As long as the target gadget classes exist on the application server's classpath, ObjectInputStream.readObject() will instantiate the classes and execute their deserialization lifecycle methods unconditionally.

Code Analysis

Prior to version 4.0.1, CachedResultSet.java processed incoming byte arrays using standard java.io.ObjectInputStream instances. In both the metadata deserialization block and the lazy column evaluation block, streams were consumed directly:

// Vulnerable implementation in CachedResultSet.java (Versions 3.3.0 - 4.0.0)
public static ResultSet deserializeFromByteArray(byte[] data) throws SQLException {
  try (ByteArrayInputStream bis = new ByteArrayInputStream(data);
       // VULNERABLE: Standard ObjectInputStream without class filtering
       ObjectInputStream ois = new ObjectInputStream(bis)) {
    CachedResultSetMetaData metadata = (CachedResultSetMetaData) ois.readObject();
    int numRows = ois.readInt();
    // ... reads row structures and raw column byte arrays ...
  }
}
 
// Vulnerable lazy column deserialization in CachedResultSet.CachedRow
public Object get(final int columnIndex) throws SQLException {
  // ...
  if (rowData[columnIndex - 1] == null && rawData[columnIndex - 1] != null) {
    try (ByteArrayInputStream bis = new ByteArrayInputStream(rawData[columnIndex - 1]);
         // VULNERABLE: Unconstrained deserialization of column payload
         ObjectInputStream ois = new ObjectInputStream(bis)) {
      rowData[columnIndex - 1] = ois.readObject();
      rawData[columnIndex - 1] = null;
    } catch (ClassNotFoundException e) {
      // ...
    }
  }
  return rowData[columnIndex - 1];
}

In commit d6b79c6731fa37e117aa76ed2abb1f56e13772eb (Pull Request #1905), AWS remediated the vulnerability by replacing all uses of ObjectInputStream in CachedResultSet with a custom static inner subclass named SafeObjectInputStream. This subclass overrides resolveClass(ObjectStreamClass desc) to enforce a strict, deny-by-default allowlist before any class resolution or loading occurs:

// Patched implementation in CachedResultSet.java (Version 4.0.1)
private static class SafeObjectInputStream extends ObjectInputStream {
  private static final Set<String> ALLOWED_CLASSES;
 
  static {
    Set<String> allowed = new HashSet<>();
    // Internal cache serialization classes
    allowed.add("software.amazon.jdbc.plugin.cache.CachedResultSetMetaData");
    allowed.add("software.amazon.jdbc.plugin.cache.CachedResultSetMetaData$Field");
    allowed.add("[Lsoftware.amazon.jdbc.plugin.cache.CachedResultSetMetaData$Field;");
    allowed.add("software.amazon.jdbc.plugin.cache.CachedSQLXML");
 
    // Standard immutable/safe types & primitive/object arrays
    allowed.add("java.lang.String");
    allowed.add("java.lang.Boolean");
    allowed.add("java.lang.Character");
    allowed.add("java.util.UUID");
    allowed.add("java.net.URL");
    allowed.add("java.net.URI");
    allowed.add("java.time.Ser");
    allowed.add("[B"); allowed.add("[I"); allowed.add("[J"); allowed.add("[D");
    allowed.add("[F"); allowed.add("[S"); allowed.add("[C"); allowed.add("[Z");
    allowed.add("[Ljava.lang.Object;");
    allowed.add("[Ljava.lang.String;");
    // ... additional boxed primitive array types ...
 
    ALLOWED_CLASSES = Collections.unmodifiableSet(allowed);
  }
 
  SafeObjectInputStream(InputStream in) throws IOException {
    super(in);
  }
 
  @Override
  protected Class<?> resolveClass(ObjectStreamClass desc)
      throws IOException, ClassNotFoundException {
    String className = desc.getName();
    if (ALLOWED_CLASSES.contains(className)) {
      return super.resolveClass(desc);
    }
 
    // Dynamic hierarchy checks restricted strictly to java.* and javax.* namespaces
    if (className.startsWith("java.") || className.startsWith("javax.")) {
      Class<?> cls = super.resolveClass(desc);
      if (Number.class.isAssignableFrom(cls)
          || Collection.class.isAssignableFrom(cls)
          || Map.class.isAssignableFrom(cls)
          || java.util.Date.class.isAssignableFrom(cls)
          || RowId.class.isAssignableFrom(cls)
          || SQLXML.class.isAssignableFrom(cls)
          || Temporal.class.isAssignableFrom(cls)
          || TemporalAmount.class.isAssignableFrom(cls)
          || ZoneId.class.isAssignableFrom(cls)) {
        return cls;
      }
    }
 
    // Explicit opt-in support for trusted third-party classes/packages
    if (WrapperUtils.skipWrappingForClasses.stream().anyMatch(c -> c.getName().equals(className))
        || WrapperUtils.skipWrappingForPackages.stream().anyMatch(p -> className.startsWith(p + "."))) {
      return super.resolveClass(desc);
    }
 
    throw new ClassNotFoundException(
        Messages.get("CachedResultSet.blockedDeserialization", new Object[]{className}));
  }
}

A critical security aspect of this patch is how it handles dynamic type hierarchy checks (isAssignableFrom). Calling super.resolveClass(desc) invokes Class.forName(), which loads and initializes the target class, triggering its static {} initialization blocks. By checking if (className.startsWith("java.") || className.startsWith("javax.")) before calling super.resolveClass(desc), the patch prevents attackers from triggering static initializers in arbitrary third-party classes on the classpath.

> [!NOTE] > While the fix effectively blocks third-party gadget classes and dangerous JDK classes (such as javax.management.BadAttributeValueExpException or com.sun.rowset.JdbcRowSetImpl), it explicitly permits java.net.URL, java.util.Collection, and java.util.Map. Consequently, an attacker with cache write access can still construct a HashMap containing java.net.URL keys (the standard URLDNS gadget chain) to trigger outbound DNS lookups from the application server during HashMap.readObject(), allowing blind verification of deserialization or internal hostname enumeration.

Exploitation

Exploiting CVE-2026-14265 requires an attacker to satisfy three prerequisites: the target application must have RemoteQueryCachePlugin enabled (wrapperPlugins=remoteQueryCache), the attacker must possess write access to the configured Redis or Valkey cache backend, and the target application's JVM must contain a viable deserialization gadget library on its classpath (such as Apache Commons BeanUtils, Commons Collections, Spring Framework, or Jackson).

Write access to the cache tier can be obtained through several architectural weaknesses. Common scenarios include unauthenticated Redis/Valkey instances exposed within an internal VPC or container network, compromised cache credentials shared across multiple microservices, multi-tenant cache clusters lacking key-level ACL isolation, or Server-Side Request Forgery (SSRF) vulnerabilities in adjacent web applications that allow sending raw RESP (Redis Serialization Protocol) commands to the local cache port.

Once access to the cache is established, the exploitation workflow proceeds in three steps:

  1. Cache Key Identification: The attacker lists existing keys in the Redis/Valkey instance (using KEYS * or SCAN) to identify active SQL query keys managed by RemoteQueryCachePlugin, or predicts the key format for a frequently executed SQL query.
  2. Payload Generation: Using a deserialization payload generator such as ysoserial, the attacker generates a binary gadget chain tailored to libraries present in standard enterprise Java environments (for example, CommonsBeanutils1 or Spring1).
  3. Cache Poisoning: The attacker overwrites the target Redis key using the SET command with the raw serialized gadget bytes. Because CachedResultSet.deserializeFromByteArray() invokes ois.readObject() as its very first operation before verifying magic headers or row counts, the attacker does not need to wrap the payload inside a valid CachedResultSet structure; a raw gadget stream at the root of the byte array will immediately trigger execution prior to throwing a ClassCastException.

When the application server next executes the cached SQL query, RemoteQueryCachePlugin fetches the poisoned byte array and passes it to CachedResultSet.deserializeFromByteArray(). The ObjectInputStream reconstructs the gadget chain, executing arbitrary system commands or loading in-memory bytecode before the cast to CachedResultSetMetaData is even evaluated.

Impact Assessment

Successful exploitation of CVE-2026-14265 grants the attacker arbitrary code execution within the context of the target Java application process. Because the JDBC wrapper operates directly inside the data access layer of backend services, the compromised process typically holds active database connection pools, database credentials, IAM execution roles (such as AWS ECS task roles or EKS IAM Roles for Service Accounts), and access to sensitive application secrets.

An attacker achieving code execution in this context can bypass application-level access controls to query or modify the underlying Amazon Aurora or RDS databases directly, exfiltrate sensitive customer records, harvest cloud metadata tokens from the instance metadata service (IMDS), and pivot laterally across the internal cloud environment.

Furthermore, in distributed microservice architectures where multiple independent application servers share a centralized Redis or ElastiCache cluster for query caching, a single poisoned cache entry for a common query can simultaneously compromise every application instance that reads that key, turning a localized cache breach into a fleet-wide compromise.

CVE-2026-14265 is assigned a CVSS v3.1 base score of 7.5 (High) (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H) and a CVSS v4.0 score of 7.7 (High) (CVSS:4.0/AV:N/AC:L/AT:P/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N). The High Attack Complexity (AC:H in v3.1) and Attack Requirements (AT:P in v4.0) coupled with Low Privileges Required (PR:L) reflect the requirement that the attacker must first possess write capabilities on the remote cache server and target active cache keys consumed by the client application.

Remediation

AWS resolved CVE-2026-14265 in AWS Advanced JDBC Wrapper version 4.0.1. Organizations using versions 3.3.0 through 4.0.0 should upgrade immediately by updating their build dependency declarations.

For Maven projects, update pom.xml:

<dependency>
    <groupId>software.amazon.jdbc</groupId>
    <artifactId>aws-advanced-jdbc-wrapper</artifactId>
    <version>4.0.1</version>
</dependency>

For Gradle projects (Kotlin DSL), update build.gradle.kts:

implementation("software.amazon.jdbc:aws-advanced-jdbc-wrapper:4.0.1")

> [!WARNING] > Version 4.0.1 enforces a strict class allowlist during deserialization. If your application caches custom third-party SQL data types (for example, com.pgvector types), upgrading to 4.0.1 will cause ClassNotFoundException errors unless those types are explicitly registered as trusted via Driver.skipWrappingForType(Class<?>) or Driver.skipWrappingForPackage(String).

If an immediate upgrade to version 4.0.1 is not feasible, apply the following compensating controls to eliminate or reduce the attack surface:

  1. Disable Remote Query Caching: Remove remoteQueryCache from the wrapperPlugins JDBC connection property (or custom configuration profile) so that RemoteQueryCachePlugin and CachedResultSet are never invoked.
  2. Enforce Cache Authentication and Encryption: Configure Redis or Valkey to require strong authentication credentials via AUTH and role-based Access Control Lists (ACLs), and enforce TLS encryption in transit (rediss://) to prevent network interception and tampering.
  3. Isolate Cache Network Access: Place Amazon ElastiCache, MemoryDB, or self-hosted Redis/Valkey instances within dedicated private VPC subnets and restrict Security Group ingress rules strictly to the specific application instances that require cache access.
  4. Configure JVM-Wide Deserialization Filters: For defense-in-depth on unpatched deployments, configure a global JEP 290 serialization filter via the -Djdk.serialFilter JVM argument to block known gadget packages (such as org.apache.commons.collections.**, org.apache.commons.beanutils.**, and org.springframework.**).

Official Patches

Amazon Web Services (AWS)AWS Security Bulletin 2026-051-aws
GitHub / AWSGitHub Security Advisory GHSA-c5q4-97jw-jggh
GitHub / AWSAWS Advanced JDBC Wrapper Official Release v4.0.1
GitHub / AWSPatch Commit d6b79c6731fa37e117aa76ed2abb1f56e13772eb

Fix Analysis (2)

Technical Appendix

CVSS Score
7.5/ 10
CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H
EPSS Probability
0.73%
Top 45% most exploited

Affected Systems

AWS Advanced JDBC Wrapper (software.amazon.jdbc:aws-advanced-jdbc-wrapper)

Affected Versions Detail

Product
Affected Versions
Fixed Version
AWS Advanced JDBC Wrapper
Amazon Web Services (AWS)
>= 3.3.0, <= 4.0.04.0.1
AttributeDetail
CVE / GHSA IDCVE-2026-14265 / GHSA-c5q4-97jw-jggh
Weakness ClassCWE-502: Deserialization of Untrusted Data
CVSS v3.1 / v4.0 Score7.5 High / 7.7 High
EPSS Score0.73% (54.78th Percentile)
Affected ComponentRemoteQueryCachePlugin / CachedResultSet
Affected Versions3.3.0 through 4.0.0 (Fixed in 4.0.1)
ImpactRemote Code Execution (RCE) in JVM Process
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1059Command and Scripting Interpreter
Execution
T1190Exploit Public-Facing Application
Initial Access
CWE-502
Deserialization of Untrusted Data

The application deserializes untrusted data without sufficiently verifying that the resulting data will be valid.

Vulnerability Timeline

AWS Advanced JDBC Wrapper v3.3.0 released, introducing RemoteQueryCachePlugin.
2026-03-26
AWS Advanced JDBC Wrapper v4.0.0 released.
2026-05-06
Pull Request #1905 merged (commit d6b79c6731fa37e117aa76ed2abb1f56e13772eb) implementing SafeObjectInputStream.
2026-05-12
AWS Advanced JDBC Wrapper v4.0.1 officially released.
2026-05-13
CVE-2026-14265, GHSA-c5q4-97jw-jggh, and AWS Security Bulletin 2026-051-aws publicly disclosed.
2026-07-01
NVD record updated with CVSS v3.1 vector analysis.
2026-10-25

References & Sources

  • [1]AWS Security Bulletin 2026-051-aws
  • [2]GitHub Security Advisory (GHSA-c5q4-97jw-jggh)
  • [3]Official Release Notes (v4.0.1)
  • [4]Vulnerability Fix Commit (d6b79c6731fa37e117aa76ed2abb1f56e13772eb)
  • [5]Release / Changelog Commit (ce7e8c7b53cfd7e210abc6e6d73b248f488fcdcc)
  • [6]National Vulnerability Database (NVD) Record
  • [7]CVE.org Record

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 2 hours ago•CVE-2026-63672
6.1

CVE-2026-63672: User-Controlled Identity Provider Selection in EGroupware SAML Authentication

CVE-2026-63672 is an open redirect and insecure Identity Provider (IdP) selection vulnerability in the SAML Single Sign-On (SSO) authentication module of EGroupware. In affected versions, the login method in api/src/Auth/Saml.php accepts an unauthenticated HTTP request parameter (idp) and passes it to the underlying SimpleSAMLphp library after only verifying that the string begins with https://. Because the input is not validated against the application's configured whitelist of trusted identity providers, an attacker can construct a malicious link that redirects authenticating users to an arbitrary, attacker-controlled SAML Identity Provider.

Amit Schendel
Amit Schendel
4 views•9 min read
•about 3 hours ago•CVE-2026-62336
8.5

CVE-2026-62336: Local Privilege Escalation via Symlink Following in qbee-agent

CVE-2026-62336 (GHSA-xhv5-8fpq-g7hf) is a high-severity local privilege escalation, arbitrary file overwrite, and denial-of-service vulnerability in qbee-agent, the client daemon for the qbee.io IoT device management platform. Prior to version 2026.27, the root-privileged agent failed to validate path components against symbolic links during directory creation and file opening operations in app/configuration/file_manager.go. Local unprivileged users can exploit this flaw by planting symlinks in user-controlled configuration paths or predictable temporary staging locations, causing the daemon to overwrite, truncate, or change ownership of sensitive root-owned system files.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 4 hours ago•CVE-2026-110782
8.7

CVE-2026-110782: Cryptographic Signature Verification Bypass and Cross-IdP Impersonation in SimpleSAMLphp SAML2

CVE-2026-110782 is an authentication bypass and cryptographic signature verification failure in the SimpleSAMLphp SAML2 library (simplesamlphp/saml2). Resulting from an incomplete fix for CVE-2026-49283, the HTTP-Artifact binding implementation verifies the outer ArtifactResponse signature but unconditionally returns unsigned embedded SAML Responses without verifying signatures or validating that the embedded issuer matches the artifact issuer. In multi-IdP federation environments, an attacker controlling one trusted Identity Provider (IdP) can forge arbitrary identity assertions claiming to originate from another trusted IdP.

Amit Schendel
Amit Schendel
4 views•11 min read
•about 5 hours ago•CVE-2026-110789
7.5

CVE-2026-110789: Pre-Authentication Denial of Service via ASN.1 DER Length Parsing in js-libp2p (@libp2p/crypto)

CVE-2026-110789 (GHSA-rvfr-cqwq-rc4j) is a high-severity pre-authentication Denial of Service (DoS) vulnerability in the @libp2p/crypto package of the js-libp2p networking stack prior to version 5.1.22. An improper length validation flaw in the ASN.1 DER decoder allows an unauthenticated remote peer to send a crafted RSA public key during the Identify protocol exchange, forcing the parser into a synchronous loop over attacker-claimed length values. Because this loop executes within a single Node.js event-loop tick prior to identity or cryptographic signature verification, it bypasses application timeouts, stalls the event loop for 4 to 5 seconds per connection, and transiently allocates up to 2 GB of memory.

Amit Schendel
Amit Schendel
6 views•11 min read
•about 6 hours ago•CVE-2026-119793
7.5

CVE-2026-119793: Unbounded Topic Map Allocation Denial of Service in js-libp2p GossipSub

CVE-2026-119793 (GHSA-x2vm-cf3p-m2w8) is a resource consumption vulnerability in the @libp2p/gossipsub module of the js-libp2p ecosystem. Prior to @libp2p/gossipsub version 17.0.0 and js-libp2p version 3.3.9, the GossipSub implementation processed incoming subscription RPC messages without enforcing per-peer or global limits on the number or cumulative byte size of subscribed topics in its default configuration. An unauthenticated remote peer can exploit this flaw by streaming continuous batches of unique topic subscription strings over an established connection, causing unbounded growth of the internal topics Map. This leads to V8 heap exhaustion (Out-Of-Memory crash) and severe CPU starvation on the main event loop during peer disconnection teardown.

Amit Schendel
Amit Schendel
5 views•12 min read
•about 7 hours ago•CVE-2026-69241
5.4

CVE-2026-69241: Stored Cross-Site Scripting via Unsanitized SVG Upload in Filament Curator

Filament Curator, a media picker plugin for Filament panels in Laravel applications, contains a Stored Cross-Site Scripting (XSS) vulnerability in versions prior to 3.7.9, 4.1.2, and 5.1.2. The application accepts image/svg+xml uploads by default and stores them on disk without stripping executable XML markup. When a panel user opens an uploaded SVG via the View action, the file renders as a top-level document in the browser, executing embedded JavaScript within the origin of the Filament application.

Alon Barad
Alon Barad
5 views•9 min read