Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessConnect to exposed C++ WebSocket server
-
ExploitTrigger uninitialized-resource/status path
-
ImpactReceive incorrect status or leaked response data
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Variable initialization
|
| Exploitation Conditions | Exploitation requires the target to be running the Apache Thrift C++ WebSocket server component specifically (not the default binary/framed socket transports) at a version before 0.25.0, and requires the attack-requirement condition encoded as AT:P - a specific server state or race/timing condition must be present, so exploitation is not reliably repeatable against all requests. No authentication is required (PR:N) and no user interaction is needed (UI:N), but the narrow component scope and the AT:P precondition substantially limit the realistically exploitable population. Impact is confined to low integrity effects (wrong status code / uninitialized data in responses) with no confirmed availability impact. |
| Impact | This is a moderate-severity, low-priority issue rather than an urgent one. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N) describes a network-reachable, unauthenticated flaw, but two signals pull the real-world risk down sharply: AT:P indicates a specific attack requirement (e.g. a race or timing/state condition) must be present for exploitation, and the impact metrics are minimal - VC:N (no confidentiality impact), VI:L (low integrity), VA:N (no availability impact). The 6.3 base score is therefore driven by reachability, not by consequence. No CISA KEV listing and no public exploit were provided, so there is no evidence of active exploitation or weaponization. Note a conflict worth flagging: the CVE is tagged 'Information Disclosure' and CWE-908 (use of uninitialized resource) typically implies memory disclosure, yet the vendor scored VC:N and only VI:L - verify with the Apache advisory whether any data leakage actually occurs, because the tag and the scored impact disagree. EPSS was not supplied. Overall: a real defect worth patching on a normal cycle, not an emergency. |
| Exploit ScenarioDerived | An unauthenticated remote attacker opens connections to an exposed Apache Thrift C++ WebSocket server and sends traffic crafted to hit the vulnerable code path, triggering use of an uninitialized resource and/or return of an incorrect status code. Because the vector carries AT:P, success depends on a specific condition being met (such as a race or particular server state), limiting reliability. No public exploit code was identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 02, 2026
Uninitialized-resource handling in the Apache Thrift C++ WebSocket server causes the server to return incorrect status codes and potentially leak stale memory contents in responses. All Apache Thrift releases before 0.25.0 are affected, but only deployments that actually run the C++ WebSocket server transport are exposed - the default binary and framed socket transports are not in scope. Exploitation is remote and requires no authentication or user interaction, but an attack-requirement precondition (AT:P in the vendor CVSS 4.0 vector, a specific server state or timing condition) makes it unreliably repeatable, and impact is limited to low integrity effects with no confirmed confidentiality or availability loss; no public exploit identified at time of analysis. This is a moderate-severity, low-priority issue rather than an urgent one, and the vendor-released fix is Apache Thrift 0.25.0.
RemediationAI
Vendor-released patch: upgrade Apache Thrift to version 0.25.0, which is the exact release named in the advisory as resolving this issue (https://lists.apache.org/thread/33otcgbqd27wf6qq810q56znzbomnhg1 and https://lists.apache.org/thread/bjor9ttx7hk23gzcx60ohz0f20xzvgv0). Rebuild and redeploy any service statically or dynamically linked against the C++ Thrift library, since a library swap alone may not take effect for statically linked binaries. If an immediate upgrade is not feasible, the most effective compensating control is to stop exposing the Thrift C++ WebSocket server: switch affected services to the binary or framed socket transports (TFramedTransport/TSocket), which are outside the affected code path - the trade-off is that clients must speak the replacement transport, and WebSocket-only clients (browsers, proxies traversing HTTP upgrades) will lose connectivity. Where the WebSocket server must remain, restrict the endpoint to trusted networks behind an authenticating reverse proxy or API gateway and terminate WebSocket upgrades only for known clients; this reduces reachable attack surface but does not fix the uninitialized-resource defect, so any client that can still reach the endpoint remains potentially affected. Also validate response/status handling in dependent consumers, because the wrong-status-code behavior may surface as application-level errors rather than an obvious security alarm, and monitor Apache Thrift release notes for any follow-up 0.25.x patch. Given the moderate severity, no confirmed active exploitation, and the narrow component scope, treat this as a scheduled patch rather than an emergency change.
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 RPC and serialization framework; the affected code is the C++ library's WebSocket server transport, which layers WebSocket framing over an HTTP handshake inside the C++ runtime rather than the commonly used TSocket/TBinaryProtocol or TFramedTransport paths. The root cause class is CWE-908 (Use of Uninitialized Resource): a resource - most plausibly a status/response variable or buffer handled during WebSocket connection or frame processing - is read before it has been initialized, which in turn produces a wrong status code being returned to the client (behavior consistent with a return-of-wrong-status-code defect, aligning with the low integrity impact in the assessed CVSS 3.1 vector AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N). The CPE cpe:2.3:a:apache_software_foundation:apache_thrift:*:*:*:*:*:*:*:* with the 'before 0.25.0' range confirms the entire product line up to that release is covered. Because the defect is gated behind a specific server state or race/timing condition rather than a straightforward input, the CVSS 4.0 base of 6.3 pairs a network attack vector and no privileges (PR:N) with attack requirements present (AT:P) and low subsequent-system impact; the assessed 3.1 vector correspondingly rates attack complexity as High with integrity-only, low-severity consequences.
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:L/VA:N/SC:N/SI:N/SA:N
Network-reachable and unauthenticated (AV:N/PR:N), but the AT:P attack requirement maps to AC:H; impact limited to low integrity (wrong status/uninitialized data), with no confidentiality or availability effect per vendor scoring.
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
Lifecycle Timeline
2DescriptionCVE.org
Use of uninitialized resource, Return of wrong status code vulnerability in Apache Thrift C++ WebSocket server.
This issue affects Apache Thrift: before 0.25.0.
Users are recommended to upgrade to version 0.25.0, which fixes the issue.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
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
EUVD-2026-91559
GHSA-gcvr-924v-m58r
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB