Sep 19, 2026·5 min read·75 visits
Uncontrolled memory allocation in adm-zip before 0.6.1 allows unauthenticated remote attackers to trigger a Denial of Service (DoS) via a crafted ZIP archive (decompression bomb) that exhausts Node.js heap memory.
CVE-2026-77301 is a critical uncontrolled resource allocation vulnerability in the popular Node.js library adm-zip (versions prior to 0.6.1). During ZIP decompression of asynchronous entries, the library trusts the uncompressed size metadata declared in the central directory headers. Because Node.js's streaming zlib API completely ignores the maxOutputLength configuration, a crafted ZIP archive (decompression bomb) causes the application to continually allocate resident memory buffers on the heap without limits, causing rapid memory exhaustion and a process-level Out-of-Memory (OOM) crash.
CVE-2026-77301 represents a critical uncontrolled resource allocation vulnerability within the adm-zip Node.js library, affecting all versions prior to 0.6.1. This library is widely integrated across Node.js applications to facilitate archive construction, parsing, and extraction operations. When processing untrusted archives, applications rely heavily on parser-level constraints to prevent resource exhaustion attacks.
The vulnerability is classified under CWE-789 (Memory Allocation with Excessive Size Value) and CWE-770 (Allocation of Resources Without Limits or Throttling). It specifically affects the asynchronous extraction path triggered via getDataAsync(). An attacker can leverage this weakness to submit highly compressed payload streams, inducing rapid exhaustion of the V8 heap and a complete application crash.
The attack vector is network-based and requires no authentication or user interaction. Any exposed API endpoint that accepts file uploads and uses vulnerable versions of adm-zip to extract the payload is fully susceptible to this Denial of Service vector.
The root cause of the vulnerability lies in the interaction between adm-zip and Node.js's native zlib streaming implementation. During decompression, the library's getData() function in zipEntry.js extracts the uncompressed size (expectedLength) from the ZIP file's central directory headers. It then initializes a streaming decompression instance via zlib.createInflateRaw.
To bound memory allocation, adm-zip passes an options object containing maxOutputLength: expectedLength to the stream. However, while Node's synchronous, single-pass unzipSync methods respect maxOutputLength, Node's asynchronous streaming zlib API completely ignores this configuration parameter.
Consequently, the stream's data event handler continuously receives decompressed data chunks. These chunks are appended to a local memory array without any verification. Additionally, if the archive entry specifies an expectedLength of 0, the library omits the size limits entirely, leaving even the synchronous fallback execution path unprotected against decompression bombs.
In vulnerable versions of adm-zip (prior to 0.6.1), the logic in methods/inflater.js initialized the stream configuration by verifying that the declared size was non-zero:
// Vulnerable logic in adm-zip < 0.6.1
const option = version >= 15 && expectedLength > 0 ? { maxOutputLength: expectedLength } : {};If the declared size was zero, the option structure remained empty, disabling the memory allocation cap. During stream processing, the library appended incoming data chunks to the memory array blindly:
// Vulnerable streaming collection loop
tmp.on("data", function (data) {
parts.push(data);
total += data.length;
});In version 0.6.1, the maintainers corrected this behavior. The patch guarantees that a floor value of 1 is utilized for any entry declaring zero bytes, ensuring the option is always populated. Crucially, the library now enforces the boundary manually inside the streaming loop:
// Patched logic in adm-zip 0.6.1
const maxOutputLength = expectedLength > 0 ? expectedLength : 1;
const option = version >= 15 ? { maxOutputLength } : {};
// Manual cap verification in user-land JavaScript
tmp.on("data", function (data) {
if (done) return;
total += data.length;
// Stop decompression immediately if the boundary is exceeded
if (total > maxOutputLength) {
return fail(Errors.MAX_OUTPUT_EXCEEDED());
}
parts.push(data);
});This manual check successfully mitigates the limitation of Node's native streaming zlib implementation, destroying the stream and throwing an error if the accumulated size exceeds the declared limits.
Exploiting this vulnerability requires the construction of a customized zip bomb (decompression bomb). An attacker creates a highly compressed stream of redundant data (such as zero-bytes) that compresses to a negligible size (e.g., 10 KB) but expands into multiple gigabytes upon inflation.
Using specialized tooling or manual binary editing, the attacker manipulates the Central Directory headers of the ZIP file. They overwrite the uncompressed size metadata field for the entry, setting it to 0 or to an extremely high, falsified value.
The attacker then uploads the file to the target Node.js endpoint. Once received, the application invokes asynchronous decompression via the vulnerable package:
const AdmZip = require('adm-zip');
const zip = new AdmZip(req.files.upload.data);
zip.getEntries().forEach(entry => {
entry.getDataAsync((data, err) => {
// Application logic
});
});The unconstrained streaming process rapidly consumes heap memory. Within seconds, the V8 engine reaches its internal memory limit, leading to an uncatchable heap Out-of-Memory exception and crashing the entire server process.
The impact of CVE-2026-77301 is a complete and immediate loss of availability for the targeted service. Because Node.js applications typically run on a single-threaded event loop, a process-level crash drops all active client connections and prevents the processing of any new incoming requests.
The CVSS v3.1 base score is 7.5 (High), reflecting the lack of required privileges or user interaction:
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
In containerized cloud environments, orchestration tools such as Kubernetes may attempt to restart the container following the crash. However, if the malicious request is automatically retried, or if the system processes the payload synchronously on startup, the application will enter an infinite crash loop, maintaining a state of persistent Denial of Service.
The only complete and secure remediation path is to upgrade the adm-zip dependency to version 0.6.1 or later. This introduces the manual verification loop to enforce memory limits during decompression streams.
To upgrade the package in your Node.js application, run:
npm install adm-zip@0.6.1If upgrading is not immediately possible, implement server-side mitigations. Restrict maximum file upload sizes at your reverse proxy, API gateway, or Web Application Firewall (WAF) to prevent the delivery of large zip archives. Additionally, configure process managers such as PM2 to monitor memory utilization and limit crash-loop frequencies.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
adm-zip cthackers | < 0.6.1 | 0.6.1 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-789 / CWE-770 |
| Attack Vector | Network (AV:N) |
| CVSS v3.1 Score | 7.5 (High) |
| Exploit Status | PoC (Proof of Concept) |
| CISA KEV Status | Not Listed |
| Impact | Complete Denial of Service (DoS) via OOM Crash |
The software allocates memory based on an untrusted, externally-influenced size value without checking if the allocation exceeds safe limits.
CVE-2026-126297 (GHSA-v8f3-6phw-6mh9) is an uncontrolled resource consumption and algorithmic complexity vulnerability in the Natural Language Toolkit (NLTK) prior to version 3.10.4. Located in the Semantic Role Labeling (SRL) parser within `nltk/corpus/reader/conll.py`, the flaw allows an attacker to trigger quadratic O(N^2) CPU processing overhead by providing crafted CoNLL-formatted corpus inputs containing decoy span columns or nested full-width verb spans. Applications parsing untrusted linguistic corpora can experience prolonged CPU exhaustion and application-level Denial of Service (DoS).
CVE-2026-126298 (also tracked as GHSA-r53h-rw34-8h97) is an algorithmic complexity Denial of Service (DoS) vulnerability in the Natural Language Toolkit (NLTK) Python library affecting all versions prior to 3.10.4. The vulnerability resides in the nltk.tree.transforms.chomsky_normal_form function and its corresponding public method Tree.chomsky_normal_form(). When transforming a parse tree into Chomsky Normal Form using the default right-factoring strategy, the function repeatedly invokes list.pop(0) inside a loop iterating over all children of a node. In CPython, removing the initial element of a standard list requires an O(N) memory shift operation, causing the overall binarization algorithm to degrade to O(N^2) quadratic time complexity relative to the width of a node. Furthermore, converting horizontal node width into vertical tree depth bypasses initial parsing depth bounds, triggering subsequent stack exhaustion (RecursionError) when recursive methods traverse the mutated structure. Unauthenticated remote attackers who can submit bracketed tree strings to applications invoking this transformation can exhaust single-threaded CPU resources or induce unhandled application exceptions.
An algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) before version 3.10.4 allows remote unauthenticated attackers to cause a denial of service via crafted Combinatory Categorial Grammar (CCG) lexicon strings. The parser in nltk.ccg.lexicon.fromstring performs repeated immutable string slicing, concatenation, and regex tail capturing, resulting in O(n^2) CPU consumption when processing wide, flat category definitions.
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.
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.
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.