Skip to main content

Apache Thrift EUVDEUVD-2026-91412

| CVE-2026-96292 HIGH
Inefficient Regular Expression Complexity (ReDoS) (CWE-1333)
2026-10-02 apache GHSA-c9g6-hvjw-wvmp
8.2
CVSS 4.0 · Vendor: apache
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Reach Thrift service using Lua bindings
  2. Delivery
    Submit crafted pathological input string
  3. Exploit
    Trigger inefficient regex/algorithmic backtracking
  4. Execution
    CPU exhaustion stalls processing
  5. Impact
    Denial 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

Apache Thrift 0 <0.25.0

Affected Packages

euvd apache_thrift fix: 0.25.0

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

Vendor (apache) PRIMARY 8.2 HIGH
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
vuln.today AI 5.9 MEDIUM

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).

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
SUSE 5.3 MEDIUM
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
Red Hat HIGH

Primary rating from Vendor (apache).

CVSS VectorVendor: apache

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
Patch available
Oct 02, 2026 - 12:02 EUVD
CVE Published
Oct 02, 2026 - 11:11 cve.org
HIGH 8.2

DescriptionCVE.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

Why It Matters

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.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.4%
Top 65% exploitable
Prevalence
Low
Apache Thrift is common, but the vulnerable Lua bindings are a rarely-used subset
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment MSRC Vendor VulDB

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact
Medium
Technical Impact
Partial

Priority Score

41
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +41
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

CVE-2026-91135 CRITICAL
9.2 Oct 02

Heap-based buffer overflow in the C++ THeaderTransport of Apache Thrift before 0.25.0 lets a remote, unauthenticated att

CVE-2026-83632 CRITICAL
9.2 Oct 02

Heap-based memory corruption in Apache Thrift versions before 0.25.0 lets unauthenticated remote attackers who can send

CVE-2026-86537 HIGH
8.7 Oct 02

Denial of service in Apache Thrift deployments that use the D language bindings before version 0.25.0, where malformed i

CVE-2026-94646 HIGH
8.7 Oct 02

Denial of service in the Apache Thrift Node.js bindings (all versions before 0.25.0) lets remote, unauthenticated attack

CVE-2026-93925 HIGH
8.7 Oct 02

Remote denial of service against Apache Thrift C++ deployments that use the THeaderProtocol is achievable by sending a c

CVE-2026-66081 HIGH
8.7 Oct 02

Remote, unauthenticated attackers can crash applications built against Apache Thrift's c_glib (C/GLib) language bindings

CVE-2026-66859 HIGH
8.7 Oct 02

Denial of service in Apache Thrift's c_glib (C/GLib) language bindings before 0.25.0, where a crafted or malformed messa

CVE-2026-83663 HIGH
8.7 Oct 02

Denial of service in Apache Thrift's Go bindings (all versions before 0.25.0) allows an unauthenticated remote peer to c

CVE-2026-83745 HIGH
8.7 Oct 02

Memory exhaustion in Apache Thrift's Node.js and D language WebSocket server transports (all versions before 0.25.0) let

CVE-2026-96277 HIGH
8.7 Oct 02

Uncaught exception handling in the Apache Thrift Ruby bindings lets unauthenticated remote attackers crash network-reach

CVE-2026-94658 HIGH
8.7 Oct 02

Inefficient algorithmic complexity (CWE-407) in Apache Thrift's Lua bindings prior to version 0.25.0 allows remote, unau

CVE-2026-87117 HIGH
8.7 Oct 02

Unauthenticated remote attackers can crash applications that use the Apache Thrift PHP bindings prior to version 0.25.0

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
openSUSE Tumbleweed Fixed

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy