Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach Thrift service using Lua bindings
-
DeliverySubmit crafted pathological input string
-
ExploitTrigger inefficient regex/algorithmic backtracking
-
ExecutionCPU exhaustion stalls processing
-
ImpactDenial of service to legitimate users
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Regex complexity 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 | Exploitation requires that the target deployment actually use the Apache Thrift Lua bindings on a version before 0.25.0 and that attacker-controlled input reach the vulnerable regular-expression/parsing path. The CVSS 4.0 AT:P (attack requirements present) confirms exploitation is not fully attacker-controlled - a pathological input must be processed by the vulnerable Lua code path. The primary limiting factor is the narrow applicability: Thrift deployments using C++, Java, Python, Go, or other bindings are unaffected; only Lua-binding deployments are in scope. No authentication (PR:N) or user interaction (UI:N) is required where the service exposes the Lua-parsed interface to untrusted input. |
| Impact | This is a denial-of-service vulnerability (CWE-1333, inefficient regex/algorithmic complexity) in the Lua language bindings of Apache Thrift. The vendor-supplied CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N) scores it 8.2 (High), driven entirely by availability impact (VA:H) with no confidentiality or integrity impact (VC:N/VI:N). The AT:P flag is notable: it signals that successful exploitation requires conditions beyond the attacker's sole control - consistent with a ReDoS that only triggers when the vulnerable Lua binding actually parses attacker-influenced input. There is no CISA KEV listing and no EPSS score provided, and no public exploit was referenced, so there is no public exploit identified at time of analysis. The real-world priority is moderate rather than critical: the 8.2 score reflects worst-case remote unauthenticated availability loss, but the blast radius is constrained to deployments that specifically use the Thrift Lua bindings, which is a minority of Thrift usage. EPSS and KEV data are absent - not low, but missing - so exploitation likelihood cannot be quantified from the input; treat the High CVSS as a capped upper bound pending evidence that Lua bindings are in the exposed path. |
| Exploit ScenarioDerived | A remote, unauthenticated attacker sends a specially crafted input string to a service that processes it through Apache Thrift's Lua bindings, triggering catastrophic regular-expression or algorithmic backtracking. The resulting CPU exhaustion stalls or hangs the request-handling thread, degrading or denying service to legitimate users. No public proof-of-concept was referenced in the available data. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 02, 2026
Denial of service in the Lua language bindings of Apache Thrift allows unauthenticated remote attackers to exhaust CPU resources by supplying pathologically crafted input to a regular-expression or parsing code path in releases before 0.25.0, consistent with CWE-1333 (inefficient regular expression complexity). The CVSS 4.0 vector scores 8.2 with AT:P, indicating that a specific attack prerequisite must be met: the deployment must actually use the Lua bindings and attacker-controlled data must reach the vulnerable parsing path, so exploitation is not fully attacker-controlled. The vendor-released fix is Apache Thrift 0.25.0; no public exploit code was identified at time of analysis and there is no confirmed active exploitation (no CISA KEV listing), with the effective risk concentrated in services that parse untrusted input through the Lua binding.
RemediationAI
Upgrade to Apache Thrift 0.25.0, which the vendor states fixes the issue - vendor-released patch: Apache Thrift 0.25.0 - and consult the Apache advisories at https://lists.apache.org/thread/33otcgbqd27wf6qq810q56znzbomnhg1 and https://lists.apache.org/thread/3wmvtvv56rky5wtszn4zr8w12kg928qn for the exact release notes. Because the flaw is confined to the Lua bindings, upgrading only the Lua components (or the deployable artifacts that embed them) is sufficient; regenerating Lua stubs against the 0.25.0 compiler is advisable after the runtime upgrade to ensure consistent parsing behavior. Where an immediate upgrade is not feasible, the most effective compensating control is to stop feeding untrusted input into the Lua-bound parsing path: validate or length-limit incoming fields before they reach the Lua handler, or terminate the Lua service endpoint at a reverse proxy that enforces strict request-size and timeout limits - the trade-off being that legitimate large payloads may be rejected and aggressive timeouts can truncate valid long-running requests. Isolating or rate-limiting the Lua-bound listener reduces blast radius but does not remove the vulnerable code path, and because the bindings are only compiled when Lua support is enabled, an alternative is to rebuild or redeploy the service without Lua bindings enabled (disabling the extension) if Lua is not operationally required, at the cost of losing that binding's functionality. No workaround that modifies the regular expression itself is offered by the vendor; patching to 0.25.0 remains the definitive fix. No public exploit code or confirmed active exploitation was identified at time of analysis, so remediation should be prioritized by exposure: internet-facing Thrift services parsing untrusted input via Lua bindings first, internal-only or non-Lua deployments later.
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 cross-language serialization and RPC framework that ships generated language bindings for many runtimes, including Lua. This issue is rooted in CWE-1333, inefficient regular expression complexity, combined with inefficient algorithmic complexity: a crafted input string drives the vulnerable regular expression or parsing routine toward super-linear (potentially catastrophic) backtracking, so processing time grows disproportionately with input length and a modest payload can saturate a worker thread or process. The CPE cpe:2.3:a:apache_software_foundation:apache_thrift:*:*:*:*:*:*:*:* with the 'before 0.25.0' statement confirms the entire Thrift distribution prior to the 0.25.0 release is flagged, but the code path is specific to the Lua bindings - deployments using C++, Java, Python, Go, or other language bindings are not in scope for this vulnerability. The assessed CVSS:3.1 vector (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H) reflects a high-complexity, network-reachable availability-only impact: confidentiality and integrity are unaffected, and the AT:P attack requirement in the CVSS 4.0 vector captures the precondition that the target service must expose the Lua-parsed interface and accept attacker-controlled input on it.
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:N/VI:N/VA:H/SC:N/SI:N/SA:N
Network-reachable and unauthenticated (AV:N/PR:N), but AC:H reflects the AT:P condition that crafted pathological input must hit the Lua path; impact is availability-only (A:H, C/I:N).
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
Lifecycle Timeline
2DescriptionCVE.org
Inefficient regular expression complexity, Inefficient Algorithmic Complexity vulnerability in Apache Thrift Lua bindings.
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
Organizations using Apache Thrift's Lua bindings for services that parse untrusted input face a HIGH-severity denial-of-service risk (CVSS 8.2) that can exhaust CPU resources and lead to service outages. This vulnerability requires the specific prerequisite that the Lua bindings are in use and attacker-controlled data reaches the vulnerable parsing path, so not all deployments are affected; however, for those that are, the potential disruption to availability is significant. No public exploit identified at time of analysis, and a vendor-released patch is available in Apache Thrift 0.25.0, making immediate upgrade the recommended priority.
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.
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
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
Same technique Denial Of Service
View allVendor StatusVendor
SUSE
Severity: Moderate| Product | Status |
|---|---|
| openSUSE Tumbleweed | Fixed |
EUVD-2026-91412
GHSA-c9g6-hvjw-wvmp
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB