Nov 18, 2026·10 min read·0 visits
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.
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.
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.
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.
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:
KEYS * or SCAN) to identify active SQL query keys managed by RemoteQueryCachePlugin, or predicts the key format for a frequently executed SQL query.ysoserial, the attacker generates a binary gadget chain tailored to libraries present in standard enterprise Java environments (for example, CommonsBeanutils1 or Spring1).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.
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.
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:
remoteQueryCache from the wrapperPlugins JDBC connection property (or custom configuration profile) so that RemoteQueryCachePlugin and CachedResultSet are never invoked.AUTH and role-based Access Control Lists (ACLs), and enforce TLS encryption in transit (rediss://) to prevent network interception and tampering.-Djdk.serialFilter JVM argument to block known gadget packages (such as org.apache.commons.collections.**, org.apache.commons.beanutils.**, and org.springframework.**).CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
AWS Advanced JDBC Wrapper Amazon Web Services (AWS) | >= 3.3.0, <= 4.0.0 | 4.0.1 |
| Attribute | Detail |
|---|---|
| CVE / GHSA ID | CVE-2026-14265 / GHSA-c5q4-97jw-jggh |
| Weakness Class | CWE-502: Deserialization of Untrusted Data |
| CVSS v3.1 / v4.0 Score | 7.5 High / 7.7 High |
| EPSS Score | 0.73% (54.78th Percentile) |
| Affected Component | RemoteQueryCachePlugin / CachedResultSet |
| Affected Versions | 3.3.0 through 4.0.0 (Fixed in 4.0.1) |
| Impact | Remote Code Execution (RCE) in JVM Process |
| CISA KEV Status | Not Listed |
The application deserializes untrusted data without sufficiently verifying that the resulting data will be valid.
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.
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.
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.
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.
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.
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.