Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessConnect to exposed Thrift Go endpoint
-
DeliverySend zero-payload framed message
-
ExploitTrigger unbounded recursive Read
-
ExecutionExhaust Go stack limit
-
ImpactFatal error crashes entire process
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Recursion depth limits
|
| Exploitation Conditions | Affected deployments must run a service using the Apache Thrift Go bindings (versions before 0.25.0) with either the TFramedTransport or THeaderTransport transport - both are standard, commonly-used Thrift transports, so this is close to a default-configuration condition rather than a niche setting. Exploitation requires only that an attacker can reach the Thrift listener and send a single crafted frame (a declared-size-zero framed frame, or a header-filling THeader frame); no authentication (PR:N) and no user interaction (UI:N) are needed. The primary limiting factor is network exposure and peer trust: services that only accept connections from trusted internal peers face materially lower realistic risk, while internet-facing or multi-tenant endpoints are directly exploitable. |
| Impact | This is a genuine availability-only denial-of-service issue, not a high-CVSS-but-low-real-risk inflation. The provided CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) confirms a remote, low-complexity, unauthenticated path, and the impact profile (VC:N/VI:N/VA:H) correctly reflects that only availability is affected - no confidentiality or integrity loss. The score of 8.7 is driven entirely by the ease of remotely crashing the process. Crucially, the crash occurs via a Go stack-overflow 'fatal error' that recover() cannot intercept, so the entire process dies rather than a single goroutine - this materially raises real-world impact for single-process Go services. No EPSS score, KEV listing, or POC was provided in the input; exploitation status is therefore 'no public exploit identified at time of analysis.' However, the trigger is trivially constructible (a 4-byte TFramedTransport frame declaring size zero, or an 18-byte THeaderTransport frame), so weaponization difficulty is very low and an EPSS uplift would be unsurprising once scored. Priority should be treated as moderate-to-high for any internet-facing or untrusted-peer Thrift Go service, and lower where peers are fully trusted. |
| Exploit ScenarioDerived | An attacker connects to an internet-exposed Apache Thrift service built on the Go bindings and sends a specially crafted framed message - a TFramedTransport frame declaring a payload size of zero, or a THeaderTransport header block that exactly fills the frame. The server reads the empty frame, fetches the next frame, and recursively calls Read with no bound, driving the Go stack to its limit and triggering an uncatchable fatal error that terminates the whole process. No authentication or user interaction is required, and no public exploit code was provided in the input, though the trigger is trivial to reproduce. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 02, 2026
Denial of service in Apache Thrift's Go bindings (all versions before 0.25.0) allows an unauthenticated remote peer to crash an entire Thrift-serving process by sending a single crafted frame over the TFramedTransport or THeaderTransport. A frame that yields no payload bytes causes the transport to recurse into Read rather than loop, so a peer can drive unbounded recursion with only 4 bytes (declared frame size of zero) or 18 bytes (a header block that fills the frame) until the Go stack limit is hit; the resulting runtime fatal error is not catchable by recover() and kills the process. The impact is availability-only - no confidentiality or integrity effect - and no public exploit code has been identified at time of analysis, though exploitation needs only network reachability to the Thrift listener with no authentication or user interaction (CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/.../VA:H).
RemediationAI
Vendor-released patch: Apache Thrift 0.25.0, which fixes the uncontrolled recursion; upgrade the Go module/dependency to 0.25.0 (or later) and rebuild any service that embeds the Thrift Go bindings, since the fix ships in the library and not in generated service code. Where immediate upgrade is not possible, the most effective compensating control is to restrict who can reach the Thrift listener - bind it to an internal interface and allow-list trusted peer addresses at the network or service-mesh layer, which removes the unauthenticated remote trigger but leaves the code defect in place and offers no protection if a trusted peer is compromised or if clients are multi-tenant. If the service controls its own client/server transport configuration, switching away from TFramedTransport and THeaderTransport to a non-recursive transport (for example a plain buffered/socket transport) avoids the vulnerable code path, at the cost of losing frame-length bounding and the header-based metadata/out-of-band fields those transports provide - a trade-off that may break interop with clients expecting framing or headers. Process supervision with automatic restart reduces the duration of an outage but does not prevent the crash and can produce tight restart loops under sustained attack, and OS-level per-connection limits or connection rate limiting only reduce attack throughput, not the fundamental trigger. Track vendor advisories at https://lists.apache.org/thread/33otcgbqd27wf6qq810q56znzbomnhg1 and https://lists.apache.org/thread/yjz317wq7h86q9k8ws6ton0ojgl8hjct for updated guidance; no vendor-released mitigation short of the 0.25.0 upgrade has been identified at time of analysis.
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 defect is an uncontrolled recursion (CWE-674) in the Go implementation of Apache Thrift's transport layer, not in the IDL compiler or in other language bindings. Thrift's Go transports are responsible for extracting a complete message frame and returning its payload to the protocol layer; in the affected versions, TFramedTransport and THeaderTransport handle the 'frame read but zero payload bytes remain' case by reading the next frame and invoking Read again recursively instead of wrapping the read in a loop. TFramedTransport reaches this state cheaply - a peer simply declares a frame size of zero (4 bytes on the wire) - while THeaderTransport reaches it with a header block that exactly fills the frame (18 bytes). Because each recursive call retains its stack frame, the depth grows without bound and terminates when the Go runtime exhausts the goroutine stack limit, at which point the runtime raises a fatal error rather than a normal panic; recover() cannot intercept a fatal error, so a single connection can take down the whole process rather than a single request handler. The recursion is triggered purely by attacker-controlled framing, independent of any Thrift service method, so any process built on the Go bindings with either transport is exposed; CPE cpe:2.3:a:apache_software_foundation:apache_thrift:*:*:*:*:*:*:*:* tracks the pre-0.25.0 code base, and ENISA EUVD lists the affected range as Apache Thrift 0 through <0.25.0.
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:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Remote unauthenticated attacker sends one trivial crafted frame (AV:N/AC:L/PR:N/UI:N); uncatchable fatal error crashes the whole process, so A:H with C:N/I:N.
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
Lifecycle Timeline
2DescriptionCVE.org
Uncontrolled Recursion vulnerability in Apache Thrift go bindings.
Both Go transports satisfy a read out of a buffered frame and, when that frame yields no payload bytes, read the next frame and call Read again instead of looping. A peer produces such a frame for 4 bytes in TFramedTransport (a declared size of zero) or 18 bytes in THeaderTransport (a header block that fills the frame), so nothing bounds the depth. The Go stack limit is reached as a fatal error, which recover() cannot catch, so the whole process dies.
This issue affects Apache Thrift: before 0.25.0.
Users are recommended to upgrade to version 0.25.0, which fixes the issue.
Executive ViewAI
A flaw in Apache Thrift's Go bindings (all releases before 0.25.0) lets any unauthenticated party who can reach a Thrift listener terminate the entire serving process with a single small network frame, halting every service that process hosts until it is restarted. Because Thrift underpins inter-service communication in many internal platforms, a sustained or repeated attempt could cause prolonged, repeatable outages of dependent customer-facing applications rather than a one-time blip, and the flaw affects availability only with no data exposure or corruption. Leadership should treat this as an operational resilience and service-availability risk requiring prompt upgrade of every Go-based Thrift service and client.
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
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
Heap-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
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-91581
GHSA-rvwr-5g7j-6pm8
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB