Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAttacker deploys malicious HTTP server
-
DeliveryServer crafts gzip decompression bomb response
-
Exploitffuf user initiates fuzzing run against server
-
Executionffuf receives and decompresses response without size cap
-
PersistProcess memory exhausted
-
Impactffuf process killed by OOM
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Compression ratio limits
|
| Exploitation Conditions | ffuf must be executing an active fuzzing run against an HTTP server controlled or compromised by the attacker. The server must return a response with a compressed body (Content-Encoding: gzip, br, or deflate) or a chunked response that the Go transport transparently decodes, where the decompressed size exceeds available process memory. No special ffuf flags or configuration settings are required - default behavior is sufficient. Exploitation is limited by the following factors: the attacker must control the web server being fuzzed (cannot be exploited against a passive ffuf installation); the attack has no effect on confidentiality or integrity; and the impact is scoped to the ffuf process only, not to the underlying host unless the host itself runs out of memory due to the OOM event. |
| Impact | The CVSS 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) score accurately reflects the low-complexity, unauthenticated network path, but the real-world threat model is narrower than a typical server-side AV:N vulnerability: ffuf is a client-side tool, so exploitation requires a user to actively fuzz a server controlled by the attacker - the attacker cannot push this attack to arbitrary internet hosts. The impact is confined to availability of the ffuf process itself, not any production system. EPSS data was not provided in the intelligence feed; KEV status is not listed, confirming no known active exploitation campaign. No public exploit code has been identified, though the decompression-bomb technique is well-understood and trivially implementable by any HTTP server operator. The risk is therefore most relevant to security professionals and automated fuzzing pipelines that scan untrusted or adversarial targets without memory-limiting container controls in place. |
| Exploit ScenarioDerived | An attacker operates a web server configured to return a Content-Encoding: gzip response with a small compressed payload (a few kilobytes of compressed zeros) but a decompressed expansion of several gigabytes. When a penetration tester runs ffuf against this server, ffuf's transport either transparently decodes the gzip stream (stripping size headers) or passes it through the manual brotli/deflate decoder path - in both cases, io.ReadAll consumes the expanding stream until the process is killed by the OS OOM killer. The attack requires no interaction beyond the victim choosing the malicious server as a fuzzing target, and the technique is elementary to implement. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 11, 2026
Out-of-memory denial-of-service in ffuf prior to v2.2.0 allows a malicious HTTP server to crash the fuzzer by returning a decompression bomb - a tiny compressed payload that expands to gigabytes - because the response-size guard in pkg/runner/simple.go checked only the compressed Content-Length while io.ReadAll consumed the fully decompressed stream without any byte cap. Any ffuf user fuzzing a hostile endpoint is affected; no special configuration is required. The issue is fixed in v2.2.0 via io.LimitReader; no public exploit has been identified and it is not listed in CISA KEV.
RemediationAI
Upgrade ffuf to version 2.2.0 or later, available at https://github.com/ffuf/ffuf/releases/tag/v2.2.0; this is the only confirmed fix per the GitHub security advisory GHSA-jcvh-xf52-2cwm. No in-tool configuration workaround exists for versions prior to v2.2.0. As a compensating control, operators running ffuf in CI pipelines or automated scanning environments should wrap ffuf in a memory-limited container (e.g., Docker --memory=512m or an equivalent cgroup v2 memory.max limit); this does not prevent the OOM condition but bounds its blast radius to the container rather than the host. A trade-off of the container limit approach is that legitimate large-response targets may also trigger the limit and cause false-negative results in the scan. Restricting fuzzing scope to trusted targets eliminates the risk entirely but may not be operationally feasible in adversarial-target engagements.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 3 packages in go, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
ffuf is an open-source fast web fuzzer written in Go, heavily used by penetration testers and bug-bounty researchers. The flaw is rooted in CWE-409 (Improper Handling of Highly Compressed Data), the 'zip bomb' weakness class. In pkg/runner/simple.go, the Execute function decoded Content-Encoding: gzip, br (brotli), and deflate response bodies by wrapping httpresp.Body in the appropriate decompressing reader, then passing it directly to io.ReadAll with no upper bound on the decompressed output size. Additionally, Go's http.Transport transparently decodes gzip when it adds Accept-Encoding itself, stripping Content-Encoding and Content-Length headers before ffuf sees them - meaning the compressed-size guard never even fired on that path. A decompression bomb exploits the ratio between compressed and decompressed size (zeros compress ~1000x) to force gigabytes of allocation from a wire payload of kilobytes. The fix wraps the decompressing reader with io.LimitReader(bodyReader, int64(MAX_DOWNLOAD_SIZE)+1) before calling io.ReadAll, ensuring at most MAX_DOWNLOAD_SIZE bytes are ever materialized in memory regardless of encoding.
Know when the next one hits your stack
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Attack transits the network to ffuf with no privileges or complexity; impact is availability-only on the vulnerable process, no confidentiality or integrity effect.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
2DescriptionCVE.org
ffuf is a fast web fuzzer written in Go. Prior to 2.2.0, ffuf allows a malicious target server to cause an out-of-memory denial of service because the response size guard in pkg/runner/simple.go checks only the compressed Content-Length while io.ReadAll reads gzip, brotli, deflate, transparently decompressed, or chunked response bodies without a decompressed-size bound. This issue is fixed in version 2.2.0.
Executive ViewAI
ffuf (web fuzzing tool) prior to v2.2.0 is vulnerable to out-of-memory denial-of-service attacks when fuzzing malicious endpoints, though no public exploit identified at time of analysis. Organizations using ffuf for security assessments face potential disruption of testing operations if an attacker-controlled server responds with decompression bombs. Affected users must upgrade to v2.2.0 to eliminate this risk.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Same technique Denial Of Service
View allVendor StatusVendor
SUSE
Severity: Important| Product | Status |
|---|---|
| SUSE Linux Enterprise Module for Package Hub 15 SP5 | Affected |
| SUSE Linux Enterprise Module for Package Hub 15 SP6 | Affected |
| openSUSE Leap 15.5 | Affected |
| openSUSE Leap 15.6 | Affected |
EUVD-2026-56926
GHSA-jcvh-xf52-2cwm
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB