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-107725

CVE-2026-107725: Remote Code Execution via Authorization Bypass in Hazelcast Predicates API

Amit Schendel
Amit Schendel
Senior Security Researcher

Oct 9, 2026·7 min read·43 visits

Executive Summary (TL;DR)

An authorization bypass vulnerability in Hazelcast versions prior to 5.4.5, 5.5.10, and 5.6.1 allows authenticated users with minimal permissions to execute arbitrary Java code on cluster nodes by sending crafted aggregation or projection requests.

CVE-2026-107725 is a critical security bypass in Hazelcast where missing authorization checks in the MapPermission class permit unprivileged clients to issue queries containing aggregators or projections. This architectural oversight allows attackers to run arbitrary code on the cluster servers under the privileges of the active Hazelcast process.

Vulnerability Overview

Hazelcast is an in-memory data grid solution designed for high-performance distributed caching, stream processing, and querying operations. The system uses a client-server architecture where clients connect to a cluster of nodes to store and retrieve data. Security in these setups is managed through role-based access control policies that authorize client interactions on specific distributed data structures like maps (IMap).

A critical authorization bypass exists in Hazelcast due to missing permission validations within the Predicates API. This API allows clients to query and aggregate data across distributed nodes. The vulnerability, tracked as CVE-2026-107725, stems from a failure to check authorization when clients invoke aggregations and projections. This omission permits authenticated users with low privileges to bypass standard security filters and execute unauthorized operations on the cluster members.

The consequence of this authorization bypass is arbitrary remote code execution on the server nodes. Because aggregators and projections run inside the cluster JVM to evaluate custom queries locally, bypassing the security manager allows low-privileged clients to deliver code-carrying payloads. The target server node deserializes and executes this logic, inheriting the operating system privileges of the Hazelcast process.

Root Cause Analysis

The technical flaw lies within the security authorization subsystem of Hazelcast, specifically within the implementation of the MapPermission class. In a secure Hazelcast deployment, client operations on distributed maps are intercepted and validated against configured security policies. The MapPermission class defines a bitmask representing the set of allowed actions on an IMap instance, including operations like create, read, put, and destroy.

Hazelcast defines action strings for aggregations and projections under ActionConstants.ACTION_AGGREGATE and ActionConstants.ACTION_PROJECTION. However, prior to the fix, the MapPermission class did not declare bitmask constants for these two operations, nor did it register them within its initialization method initMask(). Consequently, when a security interceptor queried MapPermission to verify if a client possessed authorization for an "aggregate" or "projection" action, the underlying logic evaluated the operation with an effective mask of NONE (zero).

Because the security framework did not map these action strings to valid, enforceable permissions, the cluster members defaulted to permitting the execution. The omission created a security gap where any client that could establish a valid connection and possessed basic permissions (such as reading a public map) could issue complex aggregation and projection operations. The server failed to validate whether the client possessed explicit permissions for these administrative-level data-processing tasks.

Code Analysis

Analysis of the fix commit 5d68f4828e2a914398a39f12fe11cafd335cefe0 reveals how the authorization gap was addressed. The patch modifies the MapPermission class to declare bitwise positions for the missing actions. The constants AGGREGATE and PROJECTION are assigned to bits 9 and 10 respectively, ensuring they occupy distinct positions in the internal bitmask structure.

// Patched MapPermission.java structure
private static final int AGGREGATE = 1 << 9; // Bit 9 allocated for aggregation authorization
private static final int PROJECTION = 1 << 10; // Bit 10 allocated for projection authorization
private static final int ALL = CREATE | DESTROY | PUT | REMOVE | READ | LISTEN 
        | LOCK | INDEX | INTERCEPT | AGGREGATE | PROJECTION; // Combined permission bitmask

The implementation of the initMask() method was also updated. In the vulnerable version, the loop checking action strings completely ignored the "aggregate" and "projection" constants. The patch introduces explicit conditional branches to capture these string constants and binary-OR the corresponding bits onto the return mask.

// Action string translation within initMask()
} else if (ActionConstants.ACTION_AGGREGATE.equals(action)) {
    mask |= AGGREGATE; // Apply aggregation bit to the permission mask
} else if (ActionConstants.ACTION_PROJECTION.equals(action)) {
    mask |= PROJECTION; // Apply projection bit to the permission mask
}

While this fix successfully registers and enforces authorization checks for these APIs, security administrators must ensure that custom policies are updated. If client roles are configured with wildcard permissions, they will automatically inherit these new actions. Organizations should review active client policies to confirm that only authorized, high-privileged service accounts possess the newly introduced permissions.

Exploitation Methodology

To exploit this vulnerability, an attacker must first obtain valid network access to the Hazelcast cluster and possess credentials for a low-privileged client. This requirement is met if the attacker has access to a standard application client configuration or can compromise a system that interacts with any map on the cluster. The attacker does not need administrative privileges or write access to the targeted map.

The attack vector leverages the Predicates API to deliver a custom Aggregator or Projection class over the Hazelcast serialization protocol. The attacker constructs a client script that connects to the cluster and obtains a reference to a map. Instead of standard read or write commands, the client invokes the aggregate() method, supplying a malicious object designed to execute administrative actions or system commands upon deserialization.

Once received by the server node, the request is routed to the partition threads for local execution. Because the aggregate operation bypasses authorization, the server node processes the payload immediately. The server deserializes the malicious aggregator class and executes its logic within the server process context, resulting in code execution on the underlying host operating system.

Impact Assessment

The impact of successful exploitation is a complete compromise of the confidentiality, integrity, and availability of the affected Hazelcast cluster. An attacker can execute arbitrary Java code on any active cluster member. Since Hazelcast instances often run with elevated privileges or access sensitive back-end databases, the compromise can extend to the wider infrastructure.

From a data confidentiality standpoint, arbitrary code execution allows attackers to dump the entire contents of all memory-resident maps, cache stores, and underlying databases. This can expose sensitive customer data, API keys, and corporate secrets. The integrity of the cluster is also compromised, as the attacker can manipulate transactions, alter cache records silently, or modify persistent file stores.

The CVSS v4.0 score of 8.7 reflects the severity of the vulnerability. The low complexity of the attack coupled with the high impact on confidentiality, integrity, and availability makes this a critical security concern. Although the vulnerability requires authentication, the low privilege requirement means any system-compromised client or internal threat actor can initiate the exploit.

Remediation and Defensive Countermeasures

The primary mitigation strategy is upgrading the Hazelcast installation to a patched release. Administrators should apply Hazelcast version 5.4.5, 5.5.10, 5.6.1, or 5.7.0 depending on their current release line. These releases contain the updated MapPermission logic that enforces authorization checks on all aggregate and projection requests.

If immediate upgrading is not possible, security teams must deploy defensive workarounds. One critical defense is disabling client-side User Code Deployment. This feature allows clients to upload class definitions dynamically to server nodes, which facilitates the execution of custom aggregators. Disabling this capability in the hazelcast.xml configuration prevents attackers from injecting custom classes.

<user-code-deployment enabled="false">
    <!-- Disabling dynamic class loading restricts external code injection -->
</user-code-deployment>

Additionally, implementing strict Java serialization filters (Object Filtering) helps block unauthorized classes from being deserialized by the JVM. Organizations should define a whitelist of permitted classes for serialization and reject any custom or unrecognized aggregators. Access control lists should be hardened to restrict cluster-level network connections to trusted systems only.

Fix Analysis (1)

Technical Appendix

CVSS Score
8.7/ 10
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Affected Systems

Hazelcast Community EditionHazelcast Enterprise Edition

Affected Versions Detail

Product
Affected Versions
Fixed Version
Hazelcast
Hazelcast
< 5.4.55.4.5
Hazelcast
Hazelcast
>= 5.5.0, < 5.5.105.5.10
Hazelcast
Hazelcast
>= 5.6.0, < 5.6.15.6.1
AttributeDetail
CWE IDCWE-862
Attack VectorNetwork
CVSS Score8.7 (CVSS v4.0)
EPSS Score0.01 (Estimated)
ImpactRemote Code Execution (RCE)
Exploit StatusProof-of-Concept Stage / Private
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1068Exploitation for Privilege Escalation
Privilege Escalation
CWE-862
Missing Authorization

The software does not perform authorization checks for an actor attempting to access a resource or perform an action.

Vulnerability Timeline

Fix developed and committed to Hazelcast repository
2026-03-16
GitHub Security Advisory GHSA-w294-6q5q-53p8 and CVE-2026-107725 published
2026-10-08

References & Sources

  • [1]GitHub Security Advisory GHSA-w294-6q5q-53p8
  • [2]NVD Official CVE Record
  • [3]CVE.org Authority Record
  • [4]Hazelcast Patch Commit
  • [5]Hazelcast Community Release Notes
  • [6]Hazelcast Enterprise Release Notes
  • [7]Hazelcast Predicates API Overview

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

•41 minutes ago•CVE-2026-126295
7.1

CVE-2026-126295: Path Traversal and Unconfined File Access in NLTK BllipParser

CVE-2026-126295 (also tracked as GHSA-fg9w-wfp5-j933) is a path confinement bypass vulnerability in the Natural Language Toolkit (NLTK) affecting versions 3.10.0 prior to 3.10.4. The flaw resides in nltk/parse/bllip.py within the BllipParser class and its factory method BllipParser.from_unified_model_dir(). Unlike sibling tool wrappers in NLTK that enforce data-root confinement via the nltk.pathsec module, BllipParser passes caller-supplied filesystem paths directly into the third-party bllipparser native C extension without validation. When an application passes untrusted input as model paths or directories to BllipParser, an attacker can force the native extension to open arbitrary files on the local filesystem. This leads to information disclosure through parser diagnostic oracles, local model tampering via shared directories, and denial of service by hanging worker threads on blocking special files (such as FIFOs or device nodes) or exhausting memory via oversized files.

Amit Schendel
Amit Schendel
1 views•11 min read
•about 2 hours ago•CVE-2026-126300
5.3

CVE-2026-126300: Algorithmic Complexity Denial of Service in NLTK TreebankWordTokenizer.span_tokenize

CVE-2026-126300 (GHSA-ffr9-mgrr-wcvr) is an inefficient algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) Python library affecting versions 3.2.5 prior to 3.10.4. The flaw resides in the quote-restoration routine of TreebankWordTokenizer.span_tokenize and NLTKWordTokenizer.span_tokenize, where repeated calls to list.pop(0) over matched quote tokens introduce quadratic O(n^2) time complexity. An unauthenticated remote attacker who supplies input containing long sequences of double-quote characters can exhaust CPU resources and degrade service availability.

Amit Schendel
Amit Schendel
3 views•10 min read
•about 3 hours ago•GHSA-GPWC-27CW-RH9R
5.3

CVE-2026-126301: Quadratic CPU Exhaustion in NLTK LegalitySyllableTokenizer

The Natural Language Toolkit (NLTK) versions 3.6 through 3.10.3 contain an algorithmic complexity vulnerability in the LegalitySyllableTokenizer.tokenize method. When processing tokens composed of continuous runs of vowels, an unguarded string reversal and set membership lookup loop executes in quadratic time relative to the input token length. Remote attackers capable of submitting arbitrary text to applications utilizing this tokenizer can trigger sustained single-core CPU exhaustion and application-level denial of service.

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

CVE-2026-126304: Symlink Path Traversal in NLTK YCOECorpusReader

CVE-2026-126304 is a symlink path traversal vulnerability (CWE-59) in the Natural Language Toolkit (NLTK) versions 3.10.0 prior to 3.10.4. The YCOECorpusReader class constructs internal sub-readers for the 'psd' and 'pos' subdirectories using FileSystemPathPointer.join(), which relies exclusively on lexical string-prefix validation rather than canonical path resolution. An attacker who supplies a crafted YCOE corpus containing symbolic links in place of the 'psd' or 'pos' subdirectories can bypass directory confinement and read arbitrary files from sibling corpora or sensitive directories within the NLTK data sandbox.

Amit Schendel
Amit Schendel
6 views•9 min read
•about 5 hours ago•CVE-2026-128077
6.5

CVE-2026-128077: Authorization Bypass via Request Path Desynchronization in Nuxt and @nuxt/nitro-server

CVE-2026-128077 (GHSA-r99w-jh2x-3mg9) is an authorization bypass and interpretation conflict vulnerability affecting Nuxt and its underlying @nuxt/nitro-server package in versions 4.6.0 through 4.6.3. When an incoming HTTP request path begins with a double forward slash (e.g., //x/admin), the WHATWG URL parser within the Nuxt server-side page renderer interprets the initial segment as a network host/authority and resolves the remaining path (/admin) against the application's page router. Because Nitro server middleware, route-scoped serverHandlers, and Nitro routeRules evaluate the unparsed request path (//x/admin), path-based access controls, redirects, and security header policies configured for /admin fail to match and are bypassed.

Amit Schendel
Amit Schendel
5 views•10 min read
•about 6 hours ago•CVE-2026-128084
4.8

CVE-2026-128084: Integer Truncation and SQL Query Truncation in sqlite3-ruby

Prior to version 2.10.2, the sqlite3-ruby gem explicitly cast 64-bit Ruby string lengths (long) to 32-bit signed integers (int) when invoking the underlying SQLite C API. On 64-bit platforms, providing a string of 4 GiB (2^32 bytes) or larger causes integer truncation, instructing SQLite to process only a prefix of the string. This flaw affects SQL query preparation, bound parameter values, and return values from custom Ruby-defined SQL functions and aggregates, allowing trailing SQL clauses such as WHERE restrictions to be silently dropped under specific conditions.

Alon Barad
Alon Barad
5 views•11 min read