Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconSend HTTP WebSocket upgrade request
-
DeliveryEmbed Unicode splitline byte (e.g., \x85) in header value
-
ExploitTwisted parses crafted value as a single header
-
Installautobahn str.splitlines() splits value into injected header line
-
C2Synthetic header populates ASGI scope
-
ExecuteDjango application reads attacker-controlled header
-
ImpactBypass header-based access control or authentication logic
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V4 - API and Web Service HTTP request consistency
|
| Exploitation Conditions | Exploitation requires daphne before 4.2.2 to be the ASGI server AND the application must expose at least one WebSocket endpoint, as the vulnerability lies in the WebSocket upgrade handshake path through autobahn - pure HTTP-only daphne deployments are not affected by this injection vector. The attack is unauthenticated per CVSS PR:N, but requires high complexity (AC:H): the attacker must know which of the six specific Unicode bytes (\x0b, \x0c, \x1c, \x1d, \x1e, \x85) to embed in a header value and must identify a header name whose injection will be acted upon by the application. Security impact is further bounded by whether the target application makes trust decisions (authentication, authorization, routing, rate-limiting) based on headers in the ASGI scope - applications that sanitize or ignore client-supplied headers beyond standard WebSocket fields are not meaningfully exploitable even if the injection succeeds technically. Non-default configuration is not required; any default daphne deployment with WebSocket support is within scope. |
| Impact | The CVSS 3.1 score of 3.7 (Low) with vector AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N reflects meaningful real-world constraints. Network reachability (AV:N) and no authentication requirement (PR:N) lower the barrier to attempt, but high attack complexity (AC:H) acknowledges that successful exploitation demands precise knowledge of the parser differential and careful crafting of header values containing the specific Unicode bytes. The rated impact - low confidentiality, no integrity or availability - represents the baseline case where injected headers expose information. However, the CVE tags of 'Code Injection' and 'Request Smuggling' suggest that actual application-layer impact varies significantly: applications that make security-relevant decisions from ASGI-scope headers (e.g., X-Forwarded-For for IP allow-listing, X-Role or X-Auth-Token for authorization) are at materially higher risk than the base CVSS score implies. EPSS data was not provided in the intelligence feed, so exploitation probability is unknown. There is no CISA KEV listing and no public POC has been identified, confirming no confirmed active exploitation at time of analysis. The discrepancy between the low base score and the 'Code Injection' tag warrants application-level triage: teams should assess whether their Django application logic consumes or trusts client-supplied headers from the ASGI scope before deprioritizing this patch. |
| Exploit ScenarioDerived | An unauthenticated attacker sends an HTTP WebSocket upgrade request to a daphne-backed endpoint with a crafted header such as 'X-Legit-Header: value\x85X-Injected: attacker-value'. Twisted passes 'value\x85X-Injected: attacker-value' as a single header value, but autobahn's str.splitlines() splits it on \x85, causing 'X-Injected: attacker-value' to appear as a distinct header in the ASGI scope. If the Django application grants elevated access or bypasses rate-limiting based on a header like X-Forwarded-For or a custom role header, the attacker gains unauthorized access or bypasses a security control. No public POC code has been identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jun 03, 2026
Header injection via parser differential in daphne before 4.2.2 allows unauthenticated remote attackers to smuggle synthetic headers into the ASGI scope received by Django applications during WebSocket handshake processing. The root cause is that Twisted (which daphne uses to parse inbound HTTP) ignores six specific Unicode bytes as line separators, while autobahn (which daphne feeds for WebSocket negotiation) calls Python's str.splitlines() and recognizes them - causing a single header value to be split into multiple injected header lines. No public exploit has been identified at time of analysis, and CVSS scores this at 3.7 (Low) due to high attack complexity, though real-world severity scales with how heavily the downstream application trusts ASGI-scope headers for security decisions.
RemediationAI
The primary fix is to upgrade daphne to version 4.2.2 or later; this release adds input validation that rejects any inbound HTTP request containing the bytes \x0b, \x0c, \x1c, \x1d, \x1e, or \x85 in any header value with a 400 Bad Request, preventing the malformed header from reaching autobahn. The fix is documented at https://github.com/django/daphne/blob/main/CHANGELOG.txt. If immediate upgrade is not feasible, a compensating control is to deploy a hardening reverse proxy (nginx, HAProxy) in front of daphne configured to drop or reject requests containing these non-ASCII control bytes in header values; note that proxy behavior with unusual Unicode bytes is implementation-specific and must be explicitly tested and verified rather than assumed. A second compensating control is to add Django middleware that audits the ASGI scope headers for unexpected keys before they reach application logic, reducing the attack surface without blocking the request at the protocol layer - this does not eliminate the injection but limits exploitation to headers the application actually trusts. Neither workaround is a substitute for patching.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in pypi
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
daphne is the ASGI server backing Django Channels, layering WebSocket support over Twisted's HTTP engine with autobahn handling the WebSocket handshake. The flaw is classified as CWE-444 (Inconsistent Interpretation of HTTP Requests - HTTP Request/Response Smuggling): daphne reconstructs a raw HTTP byte stream from Twisted's pre-parsed headers and hands it to autobahn for WebSocket upgrade validation. Twisted's HTTP parser does not treat \x0b (vertical tab), \x0c (form feed), \x1c (file separator), \x1d (group separator), \x1e (record separator), or \x85 (Unicode NEL - next line) as line-break characters, so it passes a header value containing these bytes through intact. autobahn, however, decodes the header value into a Python str and calls str.splitlines(), which per the Unicode standard recognizes all of those code points as line terminators. This splits one header value into multiple lines, creating synthetic header key-value pairs that populate the ASGI scope dictionary with attacker-controlled data that never existed in the original Twisted-parsed request. The fix in 4.2.2 closes the gap by having daphne validate and reject any request containing these bytes in a header value with a 400 response before autobahn ever sees it. No CPE strings were included in the provided intelligence.
Know when Daphne 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
AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N
Primary rating from NVD.
CVSS VectorNVD
Lifecycle Timeline
2DescriptionNVD
daphne before 4.2.2 reconstructs a raw HTTP request from Twisted's parsed headers and feeds it to autobahn for WebSocket handshake processing. Twisted does not treat \x0b, \x0c, \x1c, \x1d, \x1e, or \x85 as header line separators, but autobahn decodes header values to str and calls splitlines(). An attacker can exploit this parser differential to inject additional headers into the ASGI scope passed to the application. daphne now rejects requests with these bytes in any header value with a 400 response.
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
HTTP request smuggling exploits inconsistencies in how front-end and back-end servers parse HTTP message boundaries.
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
EUVD-2026-34092
GHSA-xh68-hfp5-5x5m
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB