Skip to main content

Bandit CVE-2026-110314

| EUVDEUVD-2026-109822 MEDIUM
Client-Side Enforcement of Server-Side Security (CWE-602)
2026-10-26 EEF
6.3
CVSS 4.0 · Vendor: EEF
View

Attack ChainAIDerived

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

  1. Access
    Open WebSocket upgrade to target endpoint
  2. Delivery
    Trigger server {:stop,...} via failed init/1 auth
  3. Exploit
    Ignore server's Close frame
  4. Execution
    Send masked data frames after close
  5. Impact
    Invoke 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.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 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

bandit 0.5.1 <1.14.0
bandit bb407f2277dcb65a58dd8cc07913a0b58a80e266 <220b9dfd27f9a21305be2afc75cbe585ddc24e7a

Affected Packages

euvd bandit fix: 1.14.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

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

Vendor (EEF) PRIMARY 6.3 MEDIUM
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
vuln.today AI 4.8 MEDIUM

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.

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

Primary rating from Vendor (EEF).

CVSS VectorVendor: EEF

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

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

EPSS Score
0.4%
Top 68% exploitable
Prevalence
Medium
popular Elixir/Phoenix HTTP server, but within the smaller Elixir ecosystem
Data Quality
4 sources
Confidence: Medium

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact· derived
Medium

Priority Score

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

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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