Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSupply crafted LZF stream to app
-
ExploitTrigger OOB read in UnsafeChunkDecoder
-
ImpactLeak JVM heap memory or crash JVM
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK
1 technique across 1 tactic: Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The target application must decompress attacker-supplied LZF data using the default LZFDecoder, which selects the sun.misc.Unsafe-based UnsafeChunkDecoder on JVMs/platforms where Unsafe is available; no authentication or user interaction is required (PR:N/UI:N). Key limiting factors: exploitation only occurs if untrusted/attacker-controlled LZF streams reach the decoder - applications that decompress only trusted, internally-generated data are not meaningfully exposed - and deployments where the Unsafe-based decoder is not selected (platforms/JVM configurations that fall back to the safe pure-Java decoder) avoid the vulnerable code path. |
| Impact | This is a genuinely high-priority library flaw, though its real-world impact is gated by how the affected library is used. The provided CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:N/VA:H) describes an unauthenticated, low-complexity network attack with high confidentiality impact (leaking unrelated JVM heap memory, which may contain secrets, keys, or other users' data) and high availability impact (JVM crash), with no integrity impact - consistent with the CWE-125 out-of-bounds read and the description. No EPSS score, KEV listing, or public exploit was provided in the input, so despite the high CVSS the signals point to a serious-but-not-yet-actively-exploited issue: there is no public exploit identified at time of analysis and no confirmation of in-the-wild use. The one caveat worth flagging is the attack vector: CVSS marks this AV:N/PR:N (unauthenticated remote), but exploitation actually depends on an application choosing to feed attacker-controlled LZF data into the default decoder - so whether a given deployment is truly 'remote unauthenticated' depends on the consuming application's data flow, not the library in isolation. Discovery via VulnCheck using Jazzer fuzzing (visible in the PR diff) indicates the condition is reliably triggerable, which raises the practical likelihood of exploit development even though none is published yet. |
| Exploit ScenarioDerived | A Java service decompresses LZF-compressed input received from an untrusted source (e.g., an upload or message payload) using the default LZFDecoder, which selects the sun.misc.Unsafe-based UnsafeChunkDecoder. An unauthenticated attacker submits a crafted LZF stream with malformed back-references or literal runs, causing an out-of-bounds read that either returns unrelated JVM heap memory inside the decompressed output or crashes the JVM. No public exploit is identified, but VulnCheck's Jazzer-based fuzzing discovery indicates the flaw is straightforward to trigger. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 20, 2026
Out-of-bounds memory access in the ning compress-lzf library before version 1.2.0 lets crafted LZF streams make the default sun.misc.Unsafe-based UnsafeChunkDecoder read beyond its decompression buffer, leaking unrelated JVM heap contents into decompressed output or crashing the JVM. Any application that feeds untrusted, attacker-supplied LZF data to the default LZFDecoder is exposed without authentication or user interaction, while applications decompressing only trusted internal data are largely unaffected. The issue was fixed upstream by improved bounds checks in version 1.2.0; no public exploit code or active exploitation has been confirmed at time of analysis.
RemediationAI
Upgrade compress-lzf to version 1.2.0 or later, the vendor-released fix that introduces strict bounds checks in UnsafeChunkDecoder (see the patch commit https://github.com/ning/compress/commit/06bdc3744a96b736a7118891f403e44c664f108b and pull request https://github.com/ning/compress/pull/68); teams should also update transitive dependents that bundle the library. Where upgrading is not immediately possible, avoid passing attacker-controlled LZF streams to LZFDecoder and use only trusted, internally generated compressed data, or force the pure-Java decoder on JVMs/platforms that do not select UnsafeChunkDecoder, though this may reduce decompression throughput and requires verifying that application configuration actually overrides the default decoder choice. Monitor applications that decompress externally supplied LZF payloads for unexplained decompression failures or JVM crashes, which may indicate attempts to exploit the flawed back-reference and literal-run handling.
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
compress-lzf is a Java implementation of the LZF fast compression algorithm used for compression in projects such as HBase and other Java data stores. Its default LZFDecoder selects UnsafeChunkDecoder, an implementation that uses sun.misc.Unsafe for direct memory access and therefore bypasses normal Java array bounds checking; the vulnerable code at UnsafeChunkDecoder.java line 104 failed to validate back-references and literal runs in the compressed stream against the actual decoded output buffer. This is a classic CWE-125 out-of-bounds read: an LZF stream encoding a back-reference that points before the start of the output buffer, or a literal run extending past its valid region, causes the decoder to read adjacent JVM heap memory and copy it into the decompressed output (confidentiality impact) or to fault and terminate the JVM (availability impact). Because the flawed code path relies on Unsafe, deployments that fall back to the pure-Java safe decoder are not exposed. The upstream fix in pull request #68 adds Jazzer-based fuzzing (TestFuzzUnsafeLZF covering decode, roundtrip, encode and stream operations) alongside tightened bounds validation.
Know when Compress Lzf 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:H/VI:N/VA:H/SC:N/SI:N/SA:N
Unauthenticated attacker supplies a crafted LZF stream with no special requirements (AV:N/AC:L/PR:N/UI:N); heap-memory disclosure gives C:H and JVM crash gives A:H, with no integrity impact.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Ning compress-lzf before 1.2.0 contains an out-of-bounds memory access vulnerability in the sun.misc.Unsafe based UnsafeChunkDecoder that fails to validate back-references and literal runs. Attackers can supply crafted LZF streams to applications using the default LZFDecoder to leak unrelated JVM heap memory into decompressed output or crash the JVM.
Articles & Coverage 1
Executive ViewAI
The ning compress-lzf library (versions before 1.2.0) contains an out-of-bounds memory access that can leak JVM heap contents or crash applications when they decompress malicious LZF data. Leadership should care because any service accepting untrusted compressed input could expose sensitive in-memory data or suffer availability loss, and remediation requires a dependency upgrade that may be buried in transitive libraries.
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
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
EUVD-2026-104679
GHSA-7xjc-8h6q-2f5h
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB