Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify endpoint decompressing untrusted Snappy input
-
DeliveryCraft few bytes declaring huge uncompressed length
-
ExploitSubmit to Snappy.uncompress/SnappyInputStream
-
ExecutionLibrary allocates up to 2GB pre-validation
-
ImpactOutOfMemoryError crashes JVM (DoS)
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory allocation limits
|
| Exploitation Conditions | Exploitation requires that the target application passes attacker-controlled compressed bytes to one of the vulnerable entry points - Snappy.uncompress, Snappy.uncompressString, SnappyInputStream, or SnappyFramedInputStream - using snappy-java before 1.1.10.9; the crafted input declares an oversized uncompressed length in the compressed header, forcing allocations up to 2 GB before the data is validated. No authentication or user interaction is required (PR:N/UI:N). The key limiting factor is reachability: the flaw is only exploitable where untrusted/externally-supplied Snappy data is decompressed; applications that decompress only trusted internal data are not practically exposed, and the impact is bounded to availability (OutOfMemoryError / JVM denial of service) with no data disclosure or modification. |
| Impact | This is a denial-of-service-only flaw (CWE-789 unbounded memory allocation) in the widely-embedded snappy-java compression library. The input CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) scores 8.7 HIGH and indicates remote, unauthenticated, low-complexity triggering with no user interaction, but the impact is confined to availability (VA:H; VC:N/VI:N) - there is no confidentiality or integrity exposure, so the raw High score reflects easy exploitation of a single-dimension (DoS) impact rather than a full system compromise. Exploitation status is 'no public exploit identified at time of analysis': the input contains no KEV listing and no POC/exploit-code signal, and no EPSS probability was supplied, so widespread automated exploitation cannot be asserted. The realistic risk is conditional: the CVSS AV:N assumes the vulnerable decompression methods are reachable with attacker-controlled bytes, which is true only where an application feeds untrusted compressed data to Snappy; for such internet-facing data pipelines this is a genuine patch priority, whereas deployments that only decompress trusted internal data face low practical risk. Missing data to note explicitly: no EPSS score and no KEV/POC flags were provided, so exploitation likelihood is inferred solely from the CVSS vector and description, not confirmed. |
| Exploit ScenarioDerived | An attacker submits a small, crafted Snappy-compressed payload to an application endpoint that decompresses untrusted input (e.g. a message/upload handler calling Snappy.uncompress or wrapping the stream in SnappyInputStream). The payload's header declares a very large uncompressed length, causing the library to allocate up to 2 GB before validating the data, triggering OutOfMemoryError and crashing or stalling the JVM. No public exploit code is identified in the provided data, but the attack requires only a few crafted bytes and no authentication. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 09, 2026
Unbounded memory allocation in Xerial snappy-java before 1.1.10.9 lets unauthenticated remote attackers exhaust the JVM heap by declaring an oversized uncompressed length in a compressed stream header, triggering OutOfMemoryError and denial of service. Any application that passes externally supplied bytes to Snappy.uncompress, Snappy.uncompressString, SnappyInputStream or SnappyFramedInputStream - for example Kafka, Hadoop/Spark or other services using snappy-java transitively - is in scope, and a handful of crafted bytes can force allocations of up to 2 GB before decompression validates the data. Impact is limited to availability (CVSS:4.0 base 8.7; assessed CVSS:3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) with no data disclosure or modification, and no public exploit was identified at time of analysis; the practical constraint is reachability, since applications that only decompress trusted internal data are not meaningfully exposed.
RemediationAI
Vendor-released patch: upgrade Xerial snappy-java to version 1.1.10.9 or later (release https://github.com/xerial/snappy-java/releases/tag/v1.1.10.9, fix commit 943c6043a292568575e8347af4507d015e802c75), and see advisory GHSA-q233-g92q-qxp6 for details; since the library is typically a transitive dependency, run a dependency scan (e.g. Maven/Gradle dependency:tree or OWASP Dependency-Check) across all services and pin or force-restore the patched version, escalating to downstream framework maintainers where a bundled version is pinned. Where patching cannot be applied immediately, the most effective compensating control is to cap the size of attacker-reachable compressed payloads before they reach snappy-java - enforce strict maximum message/record/frame sizes at the transport or queue layer (for example consumer-side max.message.bytes or equivalent broker limits) and reject inputs whose declared uncompressed length exceeds a plausible ratio of their compressed length (the upstream fix uses 64/3), accepting that legitimate highly compressible payloads may be rejected and that this must be tuned to real traffic. A weaker but low-effort measure is to run untrusted decompression in a dedicated JVM or worker process with a modest -Xmx so an OutOfMemoryError kills only that unit of work rather than a shared service, at the cost of added process overhead and the risk that the OOM still disrupts co-located requests if the same heap is reused. Do not rely on catch(OutOfMemoryError) handlers as a mitigation, since heap exhaustion can destabilize the entire JVM. No vendor-released patch is missing here; the fix exists, so the priority is inventorying transitive copies and redeploying them.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
snappy-java is the Java/JNI binding to Google's Snappy block compression format, widely embedded as a transitive dependency in data-processing frameworks. The underlying flaw is CWE-789 (memory allocation with excessive size value): the decoder read the uncompressed-length field from the compressed stream header and used it to size a buffer before any sanity check against the actual compressed size, so a valid-looking header followed by a few bytes produced a multi-gigabyte allocation attempt (up to 2 GB) and an OutOfMemoryError. The upstream fix at commit 943c6043a292568575e8347af4507d015e802c75 adds a checkUncompressedLength() guard that rejects any declared uncompressed length exceeding 64/3 times the compressed length, on the reasoning that the densest possible Snappy element is a 3-byte copy expanding to 64 bytes, so no legitimate stream can expand faster. The same commit hardens the JNI boundary by introducing checkArrayRange(), checkOutputSpace() and byteLengthOf() helpers, plus requiredCompressedLength() to catch int overflow in maxCompressedLength() for inputs near 2 GB - these enforce bounds on the input/output ranges that native code accesses via raw pointers without its own bounds checks. Also affected in the same release line are the framing/streaming wrappers (SnappyInputStream, SnappyFramedInputStream) and the string helper Snappy.uncompressString, all of which share the header-driven allocation path.
Know when Java gets its next vulnerability
- 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Remote unauthenticated attacker supplies a few crafted bytes with no interaction (AV:N/AC:L/PR:N/UI:N); impact is availability-only JVM exhaustion with no confidentiality or integrity effect and no scope change.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Xerial snappy-java before 1.1.10.9 contains an unbounded memory allocation vulnerability that allows attackers to exhaust JVM memory by declaring a large uncompressed length in compressed input. Attackers can supply a few crafted bytes to Snappy.uncompress, uncompressString, SnappyInputStream or SnappyFramedInputStream to force allocations up to 2 GB, causing OutOfMemoryError and denial of service.
Articles & Coverage 1
Technical POC Analysis
CWE-789 (Memory Allocation with Excessive Size Value); the advisory also tags CWE-770.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
Xerial snappy-java, a compression library widely used by Kafka, Hadoop/Spark, and other data services, has a high-severity denial-of-service flaw that can exhaust JVM heap and disrupt availability. The vulnerability is unauthenticated and remotely triggerable where externally supplied compressed bytes reach affected Snappy decompression APIs; no public exploit identified at time of analysis, but transitive dependencies mean many teams may be exposed without direct awareness. Leadership should care because successful exploitation could cause outages in critical data pipelines and streaming platforms, though no data disclosure or modification is involved.
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.
Oracle Java SE 7 Update 6 and earlier contains multiple sandbox bypass vulnerabilities via the ClassFinder and forName m
Remote code execution in IBM Sterling B2B Integrator, Sterling Integrator, and Tivoli Common Reporting allows unauthenti
Java Runtime Environment sandbox bypass via incorrect image channel verification in 2D component allows remote unauthent
Oracle Java SE JDK/JRE 7 and 6 Update 27 and earlier allows remote code execution with complete system compromise throug
JBoss Seam 2 in Red Hat JBoss EAP 4.3.0 fails to sanitize JBoss Expression Language inputs, allowing remote attackers to
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 update 4 and earlier, 6 up
Multiple vulnerabilities in Oracle Java 7 before Update 11 allow remote attackers to execute arbitrary code by (1) using
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 2 and earlier, 6 Up
The WLS Security component in Oracle WebLogic Server 10.3.6.0, 12.1.2.0, 12.1.3.0, and 12.2.1.0 allows remote attackers
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 7 and earlier allow
Remote unauthenticated attackers can execute arbitrary code on Adobe ColdFusion servers through Java deserialization fla
The ExceptionDelegator component in Apache Struts before 2.2.3.1 interprets parameter values as OGNL expressions during
EUVD-2026-95807
GHSA-94x4-5g3f-jjxp
NVD
CVE.org
EPSS
VulDB
Exploit-DB