Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach network-exposed Thrift endpoint
-
DeliverySend crafted malformed Thrift message
-
ExploitTrigger integer overflow and unbounded allocation
-
ExecutionCorrupt heap during deserialization
-
ImpactCrash service or execute code
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation limits
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The vulnerable code path is Thrift message deserialization, so exploitation requires the target to parse attacker-supplied Thrift protocol input, i.e., a service running Apache Thrift before 0.25.0 that accepts untrusted or remote Thrift messages. No authentication is required (PR:N) and no user interaction (UI:N), but the CVSS AC:H and AT:P metrics indicate meaningful limiting factors: the attacker must craft malformed messages that hit the integer-overflow/allocation condition, and success may depend on runtime state (heap layout, memory limits) and the specific protocol/transport in use. Services that do not expose Thrift parsing to untrusted peers (internal-only, authenticated, or non-Thrift traffic) are not reachable via this vector. |
| Impact | Risk is driven primarily by the memory-corruption class (CWE-770 unbounded resource allocation plus integer overflow leading to a heap-based buffer overflow) in Apache Thrift, a widely embedded RPC/serialization framework. The vendor-provided CVSS 4.0 vector (CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H) scores 9.2 and indicates a network-reachable, unauthenticated flaw with full high impact to confidentiality, integrity, and availability, but it is NOT trivially exploitable: AC:H and AT:P signal elevated attack complexity and specific attack requirements (e.g., crafted malformed messages and conditions outside the attacker's direct control). No EPSS probability was supplied, the CVE is NOT on CISA KEV, and no public exploit was referenced, so there is no public exploit identified at time of analysis and no evidence of active exploitation. The practical near-term risk is therefore a credible denial-of-service (resource exhaustion / crash) against services that parse untrusted Thrift input, with heap-overflow-driven code execution theoretically possible but gated by the high complexity. Signals are internally consistent (high CVSS justified by VC/VI/VA:H, tempered by AC:H/AT:P); the main tension is between the 9.2 critical score and the absence of any exploitation or EPSS evidence, which argues for prompt patching but not emergency same-day response unless the service exposes Thrift parsing to untrusted clients. |
| Exploit ScenarioDerived | An attacker who can send Thrift protocol messages to an exposed service (for example a microservice RPC endpoint or gateway) transmits a specially crafted message whose declared sizes trigger an integer overflow and unbounded allocation, corrupting the heap during deserialization. This most reliably crashes or hangs the service (denial of service), with the heap-based buffer overflow potentially enabling memory corruption or code execution under the right conditions. No public exploit code was referenced, and the CVSS AC:H/AT:P metrics indicate non-trivial crafting is required. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 02, 2026
Heap-based memory corruption in Apache Thrift versions before 0.25.0 lets unauthenticated remote attackers who can send Thrift protocol messages to a parsing service trigger an integer-overflow-driven undersized heap allocation followed by an out-of-bounds write, resulting in a crash (denial of service) or potentially attacker-controlled memory corruption with high confidentiality, integrity, and availability impact. The affected surface is any service that deserializes untrusted Thrift traffic; the CVSS v4.0 score of 9.2 reflects network reachability and no required privileges or user interaction, while the AC:H and AT:P metrics (mirrored by the assessed CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H) indicate that a successful exploit depends on crafting malformed messages that reliably hit the overflow condition and on runtime factors such as heap layout, memory limits, and the specific protocol/transport in use. No public exploit code or confirmed active exploitation was identified at time of analysis, but the framework's broad embedding in RPC and serialization pipelines makes prompt upgrade to 0.25.0 the clear priority. Services that never parse Thrift input from untrusted or remote peers are not reachable through this vector.
RemediationAI
Upgrade Apache Thrift to version 0.25.0, which is the vendor-released fix for this issue (the advisory's stated remediation: "Users are recommended to upgrade to version 0.25.0, which fixes the issue"), and see the Apache threads at https://lists.apache.org/thread/33otcgbqd27wf6qq810q56znzbomnhg1 and https://lists.apache.org/thread/zjv6hjmhl4tb4l4l1dk4bmc2whxh0lb4; after upgrading a library, rebuild and redeploy every dependent service so the patched Thrift runtime actually replaces the embedded 0.x version. Where immediate upgrade is not feasible, compensating controls should target the deserialization path: block Thrift ports (and any HTTP/WebSocket endpoints that tunnel Thrift) from untrusted networks, restricting reachability to trusted peers only, since the attack surface is exactly the parsing of attacker-supplied messages and accepting this trade-off limits legitimate external RPC clients; enforce strict message and frame size limits at the transport or reverse-proxy layer (for example maximum frame length, request body size caps, and rate limiting) to make oversized or malformed length fields harder to deliver, though this can break clients that legitimately send large payloads; and require mutual authentication or a gateway in front of Thrift endpoints so only vetted callers can reach the parser, which adds operational overhead and certificate management but removes unauthenticated exposure. Disabling unused protocols/transports reduces the number of parsing paths an attacker can reach. Note that no vendor patch is available for the pre-0.25.0 line itself, so mitigation without upgrading leaves the underlying heap overflow reachable by any peer that is still permitted to send Thrift traffic.
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
Apache Thrift is a widely embedded cross-language RPC and serialization framework in which generated client/server code reads length-prefixed fields and containers from a wire protocol and allocates buffers accordingly. This vulnerability combines CWE-770 (Allocation of Resources Without Limits or Throttling) with an integer overflow or wraparound in that size/length handling: an attacker-supplied length value can wrap or bypass the bound check, causing the implementation to allocate a heap buffer smaller than the amount of data subsequently written into it, producing a classic heap-based buffer overflow. The other two CWE classes named in the advisory (unbounded resource allocation and integer overflow) describe the root-cause chain, while the heap overflow is the resulting memory-safety failure that can be steered toward denial of service or code execution depending on heap state and the language binding in use; memory-unsafe native implementations are the most directly exposed. The CPE entry cpe:2.3:a:apache_software_foundation:apache_thrift:*:*:*:*:*:*:*:* uses a wildcard version, confirming that the whole pre-0.25.0 release line is considered affected rather than a single build, and ENISA EUVD lists the range as "Apache Thrift 0 <0.25.0". Exploitation is confined to the deserialization path, so the exposure is determined by whether a deployment accepts Thrift messages from untrusted peers and by which protocol/transport stack is enabled.
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:H/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Network-reachable deserialization of untrusted Thrift input with no auth (AV:N/PR:N/UI:N); crafted-message and runtime dependencies justify AC:H; heap corruption yields full C/I/A:H.
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
Allocation of resources without limits or throttling, Integer overflow or wraparound, Heap-based buffer overflow vulnerability in Apache Thrift.
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 versions before 0.25.0 contain a critical heap memory corruption flaw that unauthenticated remote attackers can trigger by sending malformed Thrift messages, potentially causing service outages or memory compromise for any business service that deserializes untrusted Thrift traffic. Although no public exploit identified at time of analysis, the high confidentiality, integrity, and availability impact means leadership should prioritize patching internet-facing and internal Thrift endpoints to 0.25.0 to avoid operational disruption and data 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
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.
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
More in Apache Thrift
View allHeap-based buffer overflow in the C++ THeaderTransport of Apache Thrift before 0.25.0 lets a remote, unauthenticated att
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
EUVD-2026-91583
GHSA-ffqv-2x6m-g28r
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB