Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessOpen WebSocket upgrade to target endpoint
-
DeliveryTrigger server {:stop,...} via failed init/1 auth
-
ExploitIgnore server's Close frame
-
ExecutionSend masked data frames after close
-
ImpactInvoke admin-only WebSock handler (e.g. delete_all_users)
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V4 - API and Web Service Server-side security enforcement
|
| Exploitation Conditions | Exploitation requires the deployed WebSock application to rely on {:stop, ...} return tuples to enforce security - e.g. refusing a client in init/1 after a failed token check, or kicking/banning a user (including Phoenix's :socket_drain, which returns {:stop, {:shutdown, :restart}, ...}) - and to have sensitive logic in handle_in/2 or handle_info/2 that remains reachable after that stop. The attacker needs no authentication (PR:N) - the whole defect is that a refused or terminated client keeps running handlers; the attacker must actively ignore the server's Close frame and keep sending (masked) frames before the client Close, TCP drop, or idle timeout ends the process, and each client frame resets that idle timeout. Limiting factors: applications that do not use {:stop, ...} for authorization, or that treat post-stop frames benignly, are not exploitable; only bandit versions 0.5.1 through <1.14.0 are affected, and updating to 1.14.0 (or applying the advisory workaround of marking the state stopped and returning {:ok, state} without acting) removes the condition. |
| Impact | This is a moderate-priority authorization-bypass issue, not a high-CVSS-but-low-risk item nor a drop-everything emergency. The supplied CVSS 4.0 vector (CVSS:3.1 absent) scores 6.3/Medium with AV:N/AC:L/PR:N/UI:N and low confidentiality and integrity impact (VC:L/VI:L, VA:N), meaning a remote unauthenticated client can reach handler code with no user interaction. The decisive nuance is AT:P (Attack Requirements: Present): exploitation only matters when the target WebSock application relies on {:stop, ...} return tuples to enforce authorization, refuse sessions in init/1, or kick/ban users - so the real-world blast radius is gated by application design, not by Bandit alone. No EPSS score is provided, so exploitation probability cannot be quantified. There is no CISA KEV entry in the input, so this is not confirmed actively exploited; the vuln.today decision label is 'this_month', indicating patch within the month rather than act_now/emergency. The GHSA advisory includes a documented proof-of-concept (failed-token init/1 followed by a post-Close delete_all_users frame), so a public PoC reference exists, but the input does not mark it as confirmed working exploit code. In short: credible, patchable, and clearly reproducible in affected app designs, but bounded by the AT:P condition and lacking EPSS/KEV signals that would escalate it. |
| Exploit ScenarioDerived | A WebSock application returns {:stop, :normal, {4401, "unauthorized"}, state} from init/1 when a token check fails, and runs an admin-only delete_all_users action in handle_in/2. An attacker upgrades with ?user_id=admin&token=wrong; the server calls terminate/2 and sends a Close frame (code 4401) but keeps the process in :closing state, so when the attacker ignores the Close and sends a masked text frame 'delete_all_users', handle_in/2 still executes it as admin. The advisory documents this as a step-by-step PoC; it is not verified in the input as standalone working exploit code. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 26, 2026
Bandit, the pure-Elixir HTTP/WebSocket server, keeps running a WebSock application's handler code after the server has initiated a close, so a remote client that ignores the Close frame can still reach handle_in/2 and handle_info/2 with the state from the {:stop, ...} tuple. Versions 0.5.1 through 1.14.0 are affected (fixed in 1.14.0), and the practical impact lands on WebSock applications that use {:stop, ...} to enforce authorization - a client refused in init/1 after a failed token check, or a kicked/banned user (including Phoenix's :socket_drain path), can keep invoking sensitive actions until it sends Close, TCP drops, or the idle timeout fires, and each client frame resets that timeout. The vendor advisory includes a step-by-step proof-of-concept walkthrough; a public PoC reference exists, but it is not verified as working exploit code, and there is no confirmed active exploitation (CISA KEV).
RemediationAI
Upgrade bandit to 1.14.0 or later; the vendor states a patch is available, and the fix commits are 220b9dfd27f9a21305be2afc75cbe585ddc24e7a (patch) and bb407f2277dcb65a58dd8cc07913a0b58a80e266 (introducing commit for the affected Sock-based connection code), with details in the advisory at https://github.com/mtrudel/bandit/security/advisories/GHSA-2v5v-8f9v-xh85 and the EEF record at https://cna.erlef.org/cves/CVE-2026-110314.html. If an immediate upgrade is not possible, the advisory's workaround is to mark the WebSock state as stopped whenever a callback returns {:stop, ...} and have handle_in/2 and handle_info/2 return {:ok, state} without performing any action while that mark is set - a compensating control that requires the flag to be honoured in every callback and therefore leaves residual risk wherever a handler path forgets the check; updating is the complete fix. Beyond version choice, the prerequisite is application-specific: the issue is only exploitable where {:stop, ...} is used to enforce authorization and sensitive actions remain reachable from handle_in/2 or handle_info/2 after the stop, so auditing those stop paths and the handlers behind them shows where exposure exists in a given deployment.
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
Bandit is an Elixir HTTP server that serves Plug applications and WebSocket connections through the Sock/WebSock behaviour, where application code implements init/1, handle_in/2, handle_info/2 and terminate/2. The root cause is CWE-602 (Client-Side Enforcement of Server-Side Security): the server's decision to end a session is enforced only by the peer's cooperation. In Bandit.WebSocket.Connection, do_stop/4 calls terminate/2, sends a Close frame and runs shutdown(:write), then returns {:continue, %{connection | state: :closing}} so the connection process stays alive; handle_frame/3 and handle_info/3 never inspect connection.state, so subsequent frames continue into handle_in/2 and subsequent messages into handle_info/2, carrying the state from the stop tuple. The condition applies to every stop routed through do_stop - {:stop, :normal, ...}, {:stop, {:shutdown, :disconnected}, ...} and {:stop, {:shutdown, :restart}, ...} (the tuple Phoenix's :socket_drain returns) - and the process only ends when the client sends Close, TCP drops, or the idle timeout expires, with each client frame resetting that timeout. The CPE strings identify mtrudel:bandit across the affected version range; the vendor rates it CVSS 4.0 AV:N/AC:L/AT:P/PR:N/UI:N with low confidentiality and integrity impact, and the independent assessment (CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N) agrees that exploitation depends on the deployed application's design rather than on any server-side precondition.
Know when Websocket 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:L/VI:L/VA:N/SC:N/SI:N/SA:N
Remote unauthenticated (PR:N), but success depends on the app enforcing authorization via {:stop,...}, a deployment condition mapped to AC:H; low confidentiality and integrity, no availability impact.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Client-Side Enforcement of Server-Side Security vulnerability in the WebSocket connection handling of mtrudel bandit allows a remote client to keep running WebSock handler code after the server has stopped its connection, via data frames sent after ignoring the server's Close frame.
When a WebSock callback returns {:stop, ...}, Bandit.WebSocket.Connection calls terminate/2, sends Close and shuts down the write side, but keeps the connection process running in a :closing state. handle_frame/3 and handle_info/3 never check that state, so later frames still reach handle_in/2 and later messages reach handle_info/2, with the state from the stop tuple, until the client sends Close, TCP drops or the idle timeout fires. A client refused in init/1 after a failed token check could still run an admin-only action.
This issue affects bandit: from 0.5.1 before 1.14.0.
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.
@fastify/websocket provides WebSocket support for Fastify. Rated high severity (CVSS 7.5), this vulnerability is remotel
An integer overflow vulnerability exists with the length of websocket frames received via a websocket connection. Rated
Improper verification of the WebSocket opening handshake in AsyncHttpClient (AHC) versions prior to 3.0.12 and 2.16.1 le
EUVD-2026-109822
NVD
CVE.org
EPSS
GitHub
Exploit-DB