Skip to main content

Sanic EUVDEUVD-2026-81626

| CVE-2026-85077 HIGH
HTTP Response Splitting (CWE-113)
2026-09-17 GitHub_M
8.2
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Identify header-reflecting endpoint
  2. Delivery
    Craft input with CRLF sequences
  3. Exploit
    Inject Set-Cookie/split response
  4. Execution
    Poison cache or fix session
  5. Impact
    Hijack or corrupt user sessions

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization HTTP response header sanitization
Exploitation Conditions

Exploitation requires a Sanic application (prior to 24.12.1, or 25.12.0) that places attacker-controlled data into response.headers, into the filename argument of file(..., filename=...), or into cookie path/domain attributes - these are the concrete injection sinks Sanic fails to sanitize for CR/LF/NUL. The attacker needs no authentication or user interaction (PR:N/UI:N), but the vulnerability is inert unless such a reflection sink exists in application code; additionally, realized impact (response splitting vs. mere header injection) depends on intermediate proxy and cache behavior, which can limit or amplify the outcome.

Impact

The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:H/A:N, base 8.2) rates this high, driven by the network vector, low complexity, and no privileges/interaction for the attacker, with integrity as the dominant impact (I:H) - consistent with HTTP response splitting (CWE-113) enabling cache poisoning, session fixation via injected cookies, and security-header corruption. However, the raw score understates a key real-world gate: exploitability depends entirely on whether the deploying APPLICATION places attacker-controlled data into response.headers, file(..., filename=...), or cookie path/domain attributes - Sanic's flaw is the failure to strip CR/LF/NUL, but the injection sink must exist in application code. No EPSS score, no CISA KEV listing, and no public POC are provided, so there is no public exploit identified at time of analysis; this is a patch-and-prioritize framework hardening issue rather than evidence of active mass exploitation. Effective impact is also 'depending on application and proxy behavior' per the advisory, meaning downstream proxy normalization can blunt or amplify response splitting. Treat as a genuine high-priority library upgrade for any Sanic app that reflects user input into headers/cookies, but not an emergency drop-everything unless such a sink is confirmed.

Exploit ScenarioDerived

An attacker submits input (e.g., a filename, redirect target, or cookie attribute) that a Sanic application echoes into a response header; because sanic/response/types.py serializes header names/values without rejecting CR/LF, the attacker embeds \r\n to inject a Set-Cookie header for session fixation or to split the response and poison a shared cache. No authentication or user interaction is required of the attacker, and no public exploit code is identified, though the injection technique is well-understood and trivially reproducible where a reflecting sink exists.

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

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

Alert me

AnalysisAIv1 – Sep 17, 2026

HTTP response splitting and header injection in Sanic let unauthenticated remote attackers forge arbitrary response headers - and potentially split a response into two - when a Sanic application reflects attacker-controlled data into response.headers, the filename argument of file(..., filename=...), or cookie path/domain attributes. The flaw affects all Sanic releases prior to 24.12.1 as well as version 25.12.0, and carries a CVSS 3.1 base score of 8.2 (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:H/A:N) with integrity impact dominant, since a successful injection can enable session fixation through injected cookies, cache poisoning, or corruption of security headers such as CSP or HSTS. No public exploit identified at time of analysis, and the issue is not listed as confirmed actively exploited (CISA KEV); realized impact still depends heavily on intermediate proxy and cache behavior and on whether the application actually exposes an injection sink.

RemediationAI

Vendor-released patch: upgrade to Sanic 24.12.1 (24.12 branch) or 25.12.1 (supersedes the vulnerable 25.12.0), per the advisory at https://github.com/sanic-org/sanic/security/advisories/GHSA-m64h-22vf-48wm and the release tags https://github.com/sanic-org/sanic/releases/tag/v24.12.1 and https://github.com/sanic-org/sanic/releases/tag/v25.12.1. Note that the upstream fix silently strips \r, \n, and \x00 from header names and values via str.maketrans rather than raising an error, so any application that legitimately relies on those characters in a custom header will see them quietly removed and should validate its own inputs before relying on the library's behavior. Where upgrading is not immediately possible, the effective compensating control is to eliminate the injection sinks: strip or reject CR/LF/NUL (and percent-encoded %0d/%0a) from every value placed into response.headers, into file(..., filename=...), and into cookie path/domain attributes, and prefer allowlisting known-safe header values over blacklisting newlines since encoding bypasses are common - with the trade-off that sanitization performed at the application layer must be applied consistently at every sink or the exposure returns. Additionally, front the service with a reverse proxy or WAF that normalizes or rejects CR/LF in request-derived data and that does not cache responses to endpoints reflecting user input; the trade-off is that WAF rules may break legitimate traffic containing unusual-but-valid header content, and disabling caching for those endpoints costs performance. Finally, rotating session cookies and tightening Cache-Control/Expires on any endpoint suspected of prior exploitation limits the session-fixation and cache-poisoning consequences, though it does not fix the underlying flaw.

Affected VersionsENISA

sanic 25.12.0, < 25.12.1
sanic < 24.12.1

Affected Packages

euvd sanic fix: 24.12.1, 25.12.1

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

The root cause is CWE-113 (Improper Neutralization of CRLF Sequences in HTTP Headers, i.e. HTTP response splitting). Sanic's HTTP/1.1 response serializer in sanic/response/types.py builds the wire-format response from the internal header mapping through processed_headers(), encoding header names as ASCII and stringifying values, but it never rejects carriage return (\r), line feed (\n), or NUL (\x00) bytes in either names or values. Because HTTP/1.1 is a newline-delimited protocol, an embedded CRLF terminates the legitimate header block early: everything an attacker places after it is parsed by the client (and by any intermediary proxy or cache) as additional headers, and a crafted sequence can introduce a blank line that starts what looks like a second HTTP response on the same connection. The vendor fix introduces HEADER_TRANSLATION_TABLE = str.maketrans("", "", "\r\n\x00") plus a _sanitize_header_value() static method applied to both the name and the value inside processed_headers(), so injection characters are stripped before encoding rather than rejected. The same release hardened adjacent parsing paths that share the raw-bytes pipeline: sanic/http/http1.py now drops the connection on malformed chunked trailers instead of leaving trailer bytes to be reparsed as a smuggled request on a keep-alive connection, and sanic/request/types.py raises a new 414 URITooLong exception for URLs longer than 65535 bytes because httptools stores URL component offsets as uint16 and would otherwise truncate the path or query string. The CPE cpe:2.3:a:sanic-org:sanic:*:*:*:*:*:*:*:* identifies the affected package as the sanic-org Sanic distribution on PyPI.

Know when Sanic 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 (GitHub_M) PRIMARY 8.2 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:H/A:N
vuln.today AI 8.2 HIGH

Remote unauthenticated attacker injects headers with low complexity where an app sink exists; integrity-dominant (cache poisoning/session fixation) with limited confidentiality and no availability impact.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
Low
Integrity
High
Availability
None

Lifecycle Timeline

2
Patch available
Sep 17, 2026 - 15:17 EUVD
CVE Published
Sep 17, 2026 - 14:26 cve.org
HIGH 8.2

DescriptionCVE.org

Sanic is an opensource python web server/framework. Prior to version 24.12.1, and in version 25.12.0, the HTTP/1.1 response pipeline in sanic/response/types.py serializes response header names and values without rejecting carriage-return or line-feed characters. Applications that place attacker-controlled data in response.headers, file(..., filename=...), or cookie path and domain attributes can therefore emit injected headers and may split responses. Depending on application and proxy behavior, this can enable session fixation through injected cookies, cache poisoning, or security-header corruption. This issue is fixed in versions 24.12.1 and 25.12.1.

Technical POC Analysis

CWE-113 (Improper Neutralization of CRLF Sequences in HTTP Headers / HTTP Response Splitting).

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

Sanic, a Python web framework used by internal and internet-facing services, is affected by a high-severity HTTP response header injection flaw that could let an unauthenticated remote attacker manipulate responses and potentially weaken session integrity, cache trust, or security headers. Because no vendor patch is currently available and realized impact depends on deployment architecture, proxy/cache behavior, and whether application code exposes an injection sink, leadership should prioritize inventory, exposure reduction, and mitigation for Sanic-based applications.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations include validating and encoding all untrusted data before it reaches response headers, file filename arguments, or cookie path/domain attributes; stripping or rejecting CR/LF in user-controlled header values; deploying WAF or reverse-proxy rules to detect and block response-splitting patterns; limiting external exposure of affected Sanic services; and monitoring proxy/cache logs for anomalous headers or cache behavior. Apply vendor patch when released.

Threat Intelligence Overview

EPSS Score
0.3%
Top 80% exploitable
Prevalence
Medium
popular open-source Python async web framework, not ubiquitous like Django/Flask
Data Quality
6 sources
Confidence: High

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.3%
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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

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

Code Injection CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

Vendor StatusVendor

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