Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessConnect to ZLIB-transform-enabled Thrift service
-
DeliverySupply large non-compressible frame content
-
ExploitTrigger expansion in THeaderTransport::transform()
-
ExecutionOverflow heap write buffer
-
PersistCorrupt heap metadata/adjacent objects
-
ImpactAchieve code execution or crash
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Heap buffer bounds checking
MITRE ATT&CK
1 technique across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the application to have ENABLED the ZLIB transform for frames it sends via THeaderTransport (a non-default, deployment-specific configuration), AND the attacker must be able to get poorly-compressible data (e.g. high-entropy, remote-peer-supplied content) placed into a transmitted frame so it expands under compression; larger frames worsen both the heap over-write and an out-of-bounds read of the transform buffer. Limiting factors: if the ZLIB write transform is not configured, the vulnerable copy path is not reached; impact scales with frame size, and reliable code execution (versus a crash) depends on heap layout. The CVSS vector is PR:N (unauthenticated) and UI:N (no user interaction), so no credentials or victim action are needed once the ZLIB transform precondition holds. Affected: Apache Thrift C++ before 0.25.0; remediated in 0.25.0. |
| Impact | This is a credible high-priority issue but NOT an automatic emergency. The input CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N) scores 9.2 CRITICAL and indicates network-reachable, unauthenticated triggering with full CIA impact (VC:H/VI:H/VA:H) to the vulnerable system - consistent with a remotely triggerable heap-based buffer overflow (CWE-122) in a widely-used RPC framework. The key tempering signal is AT:P (Attack Requirements: Present): exploitation is conditional on the application enabling the ZLIB transform for frames it SENDS, and on supplying data that does not compress well (grows under compression). This is a non-default, deployment-specific precondition, so the raw 9.2 overstates risk for the typical Thrift deployment that does not use the ZLIB write transform. Exploitation status: no public exploit identified at time of analysis - the CVE is NOT in CISA KEV and no POC is referenced; only the two Apache mailing-list advisories are provided. EPSS score was not supplied, so exploitation probability cannot be quantified. There is no SSVC decision data provided. In short: a serious memory-corruption flaw that warrants prompt patching where the ZLIB transform is enabled, but absent KEV/POC/EPSS evidence this is 'high-CVSS, conditional-real-risk' rather than confirmed widespread exploitation. Note the AT:P condition should be verified against each environment's Thrift configuration. |
| Exploit ScenarioDerived | A service built on Apache Thrift C++ (before 0.25.0) is configured to apply the ZLIB transform to outgoing THeaderTransport frames. A remote peer sends high-entropy, poorly-compressible content that the server echoes or forwards into a frame; when THeaderTransport::transform() compresses it, the data expands and is copied into the write buffer without a bounds check, overflowing the heap and (for large frames) also over-reading the transform buffer. No public exploit code is currently identified, but the network-reachable, unauthenticated nature makes controlled heap corruption and potential remote code execution a realistic objective for a motivated attacker. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 02, 2026
Heap-based buffer overflow in the C++ THeaderTransport of Apache Thrift before 0.25.0 lets a remote, unauthenticated attacker corrupt heap memory when an application enables the non-default ZLIB transform for outgoing frames and poorly compressible, peer-influenced data expands during compression. The copy into the write buffer happens without a bounds check, so oversized input overflows the heap allocation and, for large frames, also reads past the end of the transform buffer; impact scales with frame size and reliable code execution versus a crash depends on heap layout. No public exploit code has been identified at time of analysis, and because exploitation requires the ZLIB write transform precondition (without it the vulnerable copy path is never reached), this is a credible high-priority issue rather than an automatic emergency.
RemediationAI
Vendor-released patch: upgrade to Apache Thrift 0.25.0 (see https://lists.apache.org/thread/33otcgbqd27wf6qq810q56znzbomnhg1 and https://lists.apache.org/thread/rbpwlhlxnv2qgyk8cfscp2d2fd3p0ojb), which fixes the missing bounds check in THeaderTransport::transform(); applications that vendor, statically link, or containerize the C++ library must be rebuilt against the fixed version rather than relying only on a system package update. If immediate upgrade is not possible, the most direct compensating control is to disable the ZLIB write transform for THeaderTransport on the sending side (do not enable ZLIB frame compression), which removes exposure entirely because the vulnerable copy path is never entered - the trade-off is loss of on-the-wire compression, higher bandwidth consumption, and possible interoperability problems with peers configured to expect compressed frames. Where compression must be retained, enforce an application-side cap on outgoing frame size (for example, disabling compression or rejecting frames above a size whose compressed form could exceed the write buffer), which requires code changes and may reject legitimately large messages. Treat malformed-frame crashes or heap-corruption symptoms in services that use the ZLIB transform as potential exploitation indicators; because heap overflows of this type can still be turned into code execution under favourable heap layouts, these workarounds are mitigations and not substitutes for the 0.25.0 patch.
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
The flaw is a heap-based buffer overflow (CWE-122) in Apache Thrift's C++ THeaderTransport::transform(), specifically the code path used when the ZLIB transform is enabled for frames the application sends. THeaderTransport is the Thrift header transport that wraps messages in frames and can apply transforms such as ZLIB before writing them to the wire; transform() compresses the frame payload and copies the result into the outgoing write buffer without verifying that the compressed size fits the remaining buffer capacity. Compression only shrinks compressible data: when a frame carries high-entropy or otherwise poorly compressible content - for example, content supplied by a remote peer - the compressed output grows larger than the input, so the copy advances past the end of the heap allocation by an amount proportional to frame size, and for sufficiently large frames the read of the transform buffer itself runs past its end. The CPE cpe:2.3:a:apache_software_foundation:apache_thrift:*:*:*:*:*:*:*:* identifies the affected Apache Software Foundation product line. The published CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N, score 9.2) describes an unauthenticated network attack whose only precondition is the AT:P attack-requirements element - the deployment-specific ZLIB transform configuration. Our independent CVSS 3.1 assessment (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H) rates the same issue as high with AC:H, reflecting that exploitation depends on that non-default configuration and, for reliable code execution, on heap layout.
Know when Apache Thrift 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:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Network-reachable and unauthenticated (AV:N/PR:N/UI:N), but AC:H reflects the required non-default ZLIB write transform plus non-compressible data; heap RCE gives C:H/I:H/A:H, scope unchanged.
AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
Lifecycle Timeline
2DescriptionCVE.org
Heap-based buffer overflow vulnerability in Apache Thrift C++ THeaderTransport.
When an application enables the ZLIB transform for the frames it sends, THeaderTransport::transform() copies the compressed frame into the write buffer without making sure it fits. Data that does not compress, such as content a remote peer supplied, grows under compression, so the copy writes past the end of the heap buffer by an amount that grows with the size of the frame, and for large frames it also reads past the end of the transform buffer.
This issue affects Apache Thrift: before 0.25.0.
Users are recommended to upgrade to version 0.25.0, which fixes the issue.
Articles & Coverage 1
Executive ViewAI
Apache Thrift, an RPC framework embedded across many internal microservices and data-ingestion pipelines, carries a critical heap memory corruption flaw (CVE-2026-91135) in releases prior to 0.25.0. The vulnerable code path is only reachable when an application enables the non-default ZLIB transform for outgoing THeaderTransport frames, so exposure is concentrated in the teams that enabled ZLIB compression for bandwidth efficiency - those services could be driven to crash or, depending on heap layout, to remote code execution by a remote attacker. With no vendor patch released and no public exploit identified at time of analysis, leadership should treat this as a scoped-but-urgent configuration and inventory problem rather than a blanket emergency.
No vendor-released patch identified at time of analysis. Interim mitigations: disable the non-default ZLIB transform for outgoing THeaderTransport frames wherever feasible (without it the vulnerable copy path is never reached), cap and reject oversized frames at the gateway or proxy, restrict Thrift endpoint exposure to trusted networks, and monitor affected hosts for crashes or anomalous memory behavior.
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.
A heap overflow occurs when a program writes data beyond the bounds of a buffer allocated in the heap memory region.
More in Apache Thrift
View allHeap-based memory corruption in Apache Thrift versions before 0.25.0 lets unauthenticated remote attackers who can send
Denial of service in Apache Thrift deployments that use the D language bindings before version 0.25.0, where malformed i
Denial of service in the Apache Thrift Node.js bindings (all versions before 0.25.0) lets remote, unauthenticated attack
Remote denial of service against Apache Thrift C++ deployments that use the THeaderProtocol is achievable by sending a c
Remote, unauthenticated attackers can crash applications built against Apache Thrift's c_glib (C/GLib) language bindings
Denial of service in Apache Thrift's c_glib (C/GLib) language bindings before 0.25.0, where a crafted or malformed messa
Denial of service in Apache Thrift's Go bindings (all versions before 0.25.0) allows an unauthenticated remote peer to c
Memory exhaustion in Apache Thrift's Node.js and D language WebSocket server transports (all versions before 0.25.0) let
Uncaught exception handling in the Apache Thrift Ruby bindings lets unauthenticated remote attackers crash network-reach
Inefficient algorithmic complexity (CWE-407) in Apache Thrift's Lua bindings prior to version 0.25.0 allows remote, unau
Unauthenticated remote attackers can crash applications that use the Apache Thrift PHP bindings prior to version 0.25.0
Memory exhaustion in Apache Thrift before 0.25.0 lets unauthenticated remote attackers crash services that deserialize a
Same weakness CWE-122 – Heap-based Buffer Overflow
View allSame technique Buffer Overflow
View allVendor StatusVendor
SUSE
Severity: Important| Product | Status |
|---|---|
| openSUSE Tumbleweed | Fixed |
EUVD-2026-91374
GHSA-3gv9-wqfp-2rf3
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB