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

CVE-2026-77301: Uncontrolled Resource Allocation (Decompression Bomb) in adm-zip

Alon Barad
Alon Barad
Software Engineer

Sep 19, 2026·5 min read·75 visits

Executive Summary (TL;DR)

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.

Vulnerability Overview

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.

Root Cause Analysis

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.

Code Analysis

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.

Exploitation Methodology

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.

Impact Assessment

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.

Remediation and Defenses

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.1

If 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.

Official Patches

cthackersOfficial Fix Commit / Code Patch

Fix Analysis (1)

Technical Appendix

CVSS Score
7.5/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

Affected Systems

Node.js environments utilizing the adm-zip package for ZIP archive parsing

Affected Versions Detail

Product
Affected Versions
Fixed Version
adm-zip
cthackers
< 0.6.10.6.1
AttributeDetail
CWE IDCWE-789 / CWE-770
Attack VectorNetwork (AV:N)
CVSS v3.1 Score7.5 (High)
Exploit StatusPoC (Proof of Concept)
CISA KEV StatusNot Listed
ImpactComplete Denial of Service (DoS) via OOM Crash

MITRE ATT&CK Mapping

T1499Endpoint Denial of Service
Impact
T1496Resource Hijacking
Impact
CWE-789
Memory Allocation with Excessive Size Value

The software allocates memory based on an untrusted, externally-influenced size value without checking if the allocation exceeds safe limits.

Vulnerability Timeline

Patch commit pushed to GitHub repository by maintainer
2026-09-11
Release tag v0.6.1 published on GitHub
2026-09-11
CVE-2026-77301 published to the CVE.org registry
2026-09-18
GitHub Security Advisory GHSA-7q85-xj36-vmfc published
2026-09-18
Vulnerability details imported into NVD
2026-09-18

References & Sources

  • [1]GitHub Security Advisory GHSA-7q85-xj36-vmfc
  • [2]Official Fix Commit / Code Patch
  • [3]Release Version 0.6.1
  • [4]National Vulnerability Database (NVD) Entry
  • [5]CVE.org Authoritative Entry

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

•25 minutes ago•CVE-2026-126297
7.5

CVE-2026-126297: Algorithmic Complexity Denial of Service in NLTK ConllCorpusReader

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).

Amit Schendel
Amit Schendel
1 views•12 min read
•about 1 hour ago•CVE-2026-126298
7.5

CVE-2026-126298: Quadratic Algorithmic Complexity Denial of Service in NLTK Tree.chomsky_normal_form

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.

Alon Barad
Alon Barad
3 views•12 min read
•about 2 hours ago•CVE-2026-126299
7.5

CVE-2026-126299: Quadratic Algorithmic Complexity Denial of Service in NLTK CCG Lexicon Parser

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.

Alon Barad
Alon Barad
4 views•10 min read
•about 3 hours 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
2 views•11 min read
•about 4 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 5 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
5 views•10 min read