Skip to main content

Django REST Framework CVE-2026-114138

| EUVDEUVD-2026-107548 HIGH
Uncontrolled Resource Consumption (CWE-400)
2026-10-21 GitHub_M GHSA-33wh-fxxf-88vv
7.5
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Reach any DRF API endpoint
  2. Delivery
    Send Accept header with many crafted media types
  3. Exploit
    Trigger repeated _MediaType parsing per token/renderer
  4. Execution
    Force 406 renegotiation re-parsing
  5. Persist
    Pin synchronous workers with concurrent requests
  6. Impact
    Service becomes unavailable

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource consumption limits
MITRE ATT&CK

1 technique across 1 tactic: Impact

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

No authentication or user interaction is required (PR:N/UI:N): any reachable DRF endpoint that performs content negotiation is exploitable by sending an Accept header with an unbounded number and aggregate size of media-type tokens containing large quoted parameter values and many semicolons (the Content-Type header is a secondary vector, now length-capped in the fix). The condition is inherent to default DRF content negotiation, so no non-default feature flag is needed. The main LIMITING factors on real-world impact are: (1) deployment on synchronous worker models (e.g. gunicorn sync workers / WSGI) amplifies worker pinning, whereas async or heavily autoscaled/rate-limited front-ends blunt it; (2) impact is availability-only and self-healing once requests cease; and (3) an upstream reverse proxy or WAF that caps Accept/Content-Type header length can neutralize the oversized-header vector before it reaches Django.

Impact

All signals align on this being a genuine but bounded availability risk rather than a top-tier emergency. The provided CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, base 7.5) is internally consistent with the description: a remote, unauthenticated attacker over the network, with low complexity and no user interaction, achieves a pure availability impact (C:N/I:N) via CPU exhaustion - a textbook CWE-400 algorithmic/resource-consumption DoS. No EPSS score, KEV listing, POC, or SSVC decision data was supplied in the input, so no public exploit identified at time of analysis and there is no evidence of active exploitation. The practical risk is tempered by the impact ceiling: this cannot read data, alter data, or achieve code execution - worst case is worker starvation and service unavailability that ends once the malicious requests stop. It is a real patching priority for any internet-exposed DRF API running synchronous workers (because a few concurrent crafted requests can pin them), but it is not a 'drop everything' critical like an RCE. The absence of KEV/EPSS/POC data means exploitation likelihood is inferred only from the low attack complexity and the public fix commit, not confirmed; a well-documented patch commit does raise the chance that a reproduction will be derived from the diff.

Exploit ScenarioDerived

An attacker scripts HTTP requests to any reachable DRF endpoint, each carrying an Accept header packed with many distinct media types whose quoted parameter values contain large strings and numerous semicolons. Because DRF re-parses every attacker-controlled token against every renderer (and again during forced 406 renegotiation), each request consumes disproportionate CPU; firing these concurrently pins the synchronous worker pool and renders the API unavailable. No proof-of-concept was provided in the input, but the public fix commit reveals the exact parsing hotspots an attacker could target.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.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 21, 2026

Denial of service in Django REST Framework prior to 3.18.2 allows a remote unauthenticated client to pin synchronous workers for prolonged periods by sending Accept headers packed with a large number of media-type tokens carrying oversized quoted parameter values and many semicolons; the Content-Type header is a secondary, now length-capped, vector. Impact is availability-only (CVSS 3.1 AV:N/AC:L/PR:N/UI:N/A:H, 7.5) and self-healing once requests stop, but on WSGI/sync worker deployments (e.g. gunicorn sync workers) concurrent requests can exhaust the worker pool and take the service offline. No public exploit code and no active exploitation are indicated in the supplied intelligence, and no EPSS score was provided, so this reads as a genuine but bounded availability risk rather than an emergency.

RemediationAI

Upgrade djangorestframework to 3.18.2 or later - Vendor-released patch: 3.18.2 (release notes at https://github.com/encode/django-rest-framework/releases/tag/3.18.2, with the full fix in commit 148ab6523922d5a0c110f76615935e5220b63029 and advisory GHSA-33wh-fxxf-88vv); the patch enforces an 8192-byte Accept header cap, 64 tokens, and 256 characters per media type, so be aware that clients sending unusually long Accept headers or exotic media types will see truncated negotiation or a fallback renderer rather than a 500. If immediate upgrade is not possible, apply compensating controls at the edge: configure your reverse proxy or WAF to reject or truncate Accept and Content-Type headers longer than a few kilobytes (nginx does not expose a direct per-header length knob, so use a WAF rule or map-based rejection; trade-off is 400-level errors for legitimate exotic clients), and rate-limit or challenge requests per source IP (trade-off: ineffective against distributed sources and adds latency). On WSGI deployments, lowering gunicorn's --timeout forces stuck sync workers to be recycled (trade-off: may kill legitimately slow long-running responses), and adding workers or an autoscaling rule buys time under load (trade-off: cost and, since the work is CPU-bound, limited headroom). Do not rely on switching to an async worker model as a mitigation - CPU-bound parsing still blocks the event loop; combine the edge header caps with the upgrade instead. Post-upgrade, monitor for repeated 406/415 responses and high per-request CPU on negotiation paths as indicators of attempted abuse.

Affected VersionsENISA

django-rest-framework < 3.18.2

Affected Packages

euvd django_rest_framework fix: 3.18.2

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 an uncontrolled resource consumption flaw (CWE-400) in DRF's content-negotiation path. DefaultContentNegotiation.get_accept_list split the raw Accept header on commas and stripped each token with no bound on token count, token length, or aggregate header size. select_renderer then walked the attacker-controlled tokens against every configured renderer and, for each comparison, constructed a fresh _MediaType object, which in turn called Django's parse_header_parameters to split the media type and parse its parameters - an inherently expensive operation for values with large quoted strings and many semicolons. The same parsing work was repeated during the forced 406 re-negotiation, producing a multiplicative (tokens x renderers x renegotiations) CPU cost from a single request. The 3.18.2 fix (commit 148ab6523922d5a0c110f76615935e5220b63029) introduces hard caps of 8192 bytes for the Accept header, 64 tokens, and 256 characters per media type; parses each renderer's constant media type once instead of per token; caches the parsed _MediaType list on the request object so the 406 renegotiation reuses it (deliberately avoiding a process-global cache of client input); makes _MediaType hashable by its original string to preserve set-based deduplication via the new order_parsed_by_precedence helper; and catches ValueError from Django's parser (raised above MAX_HEADER_LENGTH) so an oversized header degrades to a non-matching media type instead of surfacing a 500.

Know when Django Rest Framework 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 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

Remote unauthenticated crafted Accept header (AV:N/PR:N/UI:N) with low-complexity repeatable CPU exhaustion; pure availability loss, no confidentiality or integrity impact (A:H, C:N/I:N).

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

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
None
Integrity
None
Availability
High

Lifecycle Timeline

2
Patch available
Oct 21, 2026 - 22:03 EUVD
CVE Published
Oct 21, 2026 - 20:09 cve.org
HIGH 7.5

DescriptionCVE.org

Django REST framework is a toolkit for building Web APIs. Prior to 3.18.2, DefaultContentNegotiation.get_accept_list in rest_framework/negotiation.py accepts an unbounded number and aggregate size of Accept tokens, while select_renderer in that file repeatedly invokes _MediaType parsing from rest_framework/utils/mediatypes.py for each attacker-controlled token, every renderer, and forced 406 renegotiation. A remote unauthenticated client can send many distinct media types containing large quoted parameter values with numerous semicolons, causing Django's parameter parser and DRF's repeated parsing structure to consume disproportionate CPU. Requests to any reachable endpoint can pin synchronous workers for prolonged periods, and concurrent requests can make the service unavailable until the requests stop. This issue is fixed in version 3.18.2.

Technical POC Analysis

CWE-400 (Uncontrolled Resource Consumption), scored alongside CWE-407 (Inefficient Algorithmic Complexity).

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

Django REST Framework, a widely used API toolkit, contains a high-severity denial-of-service vulnerability that allows unauthenticated remote clients to exhaust synchronous worker pools and take API services offline. Organizations running DRF-based applications on WSGI/sync worker deployments (e.g., gunicorn sync workers) are most affected, though the impact is limited to availability and self-heals once malicious traffic stops; no public exploit identified at time of analysis. Leadership should prioritize interim mitigations and plan for upgrading to the fixed version (3.18.2) when released.

Business Impact: Medium
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations include: deploy a reverse proxy or WAF rule to cap Accept and Content-Type header length and limit the number of media-type tokens; enforce per-client rate limits and request size limits; migrate from synchronous WSGI workers to asynchronous workers (e.g., uvicorn, gevent) or increase worker pool size with queue timeouts; monitor for anomalous header patterns and concurrent request spikes.

Threat Intelligence Overview

EPSS Score
0.4%
Top 64% exploitable
Prevalence
High
Django REST framework is a dominant, widely-deployed Python web API toolkit
Threat Intel
1
1 source
Social Media
1
Sightings
Data Quality
5 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 HIGH
CISA KEV No
Public POC No
EPSS 0.4%
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
Medium

Priority Score

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

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

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