Skip to main content

Django EUVDEUVD-2026-93416

| CVE-2026-77050 MEDIUM
Memory Allocation with Excessive Size Value (CWE-789)
2026-10-06 DSF GHSA-mxcg-2f2x-4q92
6.9
CVSS 4.0 · Vendor: DSF
View

Attack ChainAIDerived

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

  1. Access
    Reach i18n-enabled Django endpoint
  2. Delivery
    Send requests with many distinct long language codes
  3. Exploit
    Codes cached as keys pre-truncation
  4. Execution
    Process memory grows unbounded
  5. Impact
    Worker exhaustion / denial of service

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory allocation limits
Exploitation Conditions

Requires that Django internationalization is active so that get_supported_language_variant() processes attacker-supplied language codes - i.e. USE_I18N enabled (the default) with language negotiation driven by the Accept-Language header, a language URL prefix, or the LocaleMiddleware. The attacker must send many distinct, very long language codes so that each is retained as a unique key in the in-memory LRU cache before length limiting. Limiting factors: impact is gradual memory growth (A:L), not an instant crash, so sustained request volume is needed; sites that disable i18n or sit behind a proxy/WAF that normalizes or caps Accept-Language header length are largely unaffected; only unsupported/affected versions prior to 5.2.18 / 6.0.9 / 6.1.2 are vulnerable.

Impact

This is a low-to-moderate severity denial-of-service issue (CVSS 5.3, CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L), classified under CWE-789 (memory allocation with excessive size). The signals are internally consistent and point to genuine but bounded risk: the network vector with low complexity and no privileges/interaction makes it remotely reachable, but the impact is confined to availability only (C:N/I:N/A:L) - there is no code execution, data exposure, or integrity impact. The Django security team itself rated this 'low' per its own severity policy, which aligns with the A:L (low availability) rating rather than A:H. No EPSS score, KEV listing, or public POC was provided in the input, so there is no evidence of active exploitation or weaponization; the only confirmed exploitation signal is the vendor-documented attack vector. The practical risk is memory growth over time rather than instant crash - an attacker must send many distinct, very long language codes to bloat the in-memory LRU cache. Note the tag 'Information Disclosure' conflicts with the CVSS vector (C:N means no confidentiality impact); this is a memory-exhaustion DoS, not an information-disclosure flaw. This is a 'patch in normal maintenance cycle' issue for most deployments, not an emergency, though internet-facing i18n-enabled sites should prioritize it higher.

Exploit ScenarioDerived

An attacker sends a stream of HTTP requests to an internationalized Django site, each carrying a unique, very long value in the Accept-Language header (or language parameter). Because language codes were cached as keys before length validation, each distinct long code is retained in process memory, gradually exhausting available RAM and degrading or crashing the worker process. No authentication or user interaction is required (PR:N/UI:N), and no public exploit code was identified at time of analysis.

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 06, 2026

Remote denial-of-service in the Django web framework's language-negotiation helper django.utils.translation.get_supported_language_variant(), which caches attacker-supplied language codes as keys in an in-memory LRU cache before enforcing a length limit. An unauthenticated remote attacker (CVSS:3.1/AV:N/AC:L/PR:N/UI:N) who can influence the negotiated language - typically via the Accept-Language header, a language URL prefix, or LocaleMiddleware - can send many distinct, very long language codes so that each becomes a unique cache entry and steadily consumes process memory, degrading or exhausting the application worker. Affected are Django 6.1 before 6.1.2, 6.0 before 6.0.9, and 5.2 before 5.2.18; unsupported earlier series such as 5.1.x, 5.0.x, and 4.2.x were not evaluated and may also be affected. Impact is limited to availability (A:L) and requires sustained request volume rather than a single request, and no public exploit code or confirmed active exploitation was identified at time of analysis.

RemediationAI

Vendor-released patch: upgrade to Django 5.2.18, 6.0.9, or 6.1.2 depending on your branch - the fix moves the 500-character length check ahead of the cached lookup so over-length language codes are rejected or truncated before becoming cache keys. If upgrading immediately is not possible, apply the equivalent upstream change as a local patch by cherry-picking commit c88b304cc2d90fc37d3bd1f5f3829706fa6c13bc (with companions 7e878b0f8bd42260903e6a0d38996a93b0474a0b, 3d32ee80ae52745d686bf94d3555000ddf073267, and 02a69e3791e3df23d45ea4ea7e7fc489f0eef2be) or by wrapping get_supported_language_variant() with a pre-check that raises LookupError for language tags exceeding LANGUAGE_CODE_MAX_LENGTH, accepting the maintenance burden of a forked translation module. Compensating controls, with trade-offs: set USE_I18N = False to remove the code path entirely - effective but disables all translation and locale-aware formatting, so only viable for single-language sites; reject or truncate Accept-Language headers longer than a few hundred bytes at the reverse proxy or WAF, which costs legitimate clients nothing but requires the proxy to be the only ingress and to be trusted to normalize the header; and remove or tighten LocaleMiddleware / the i18n_patterns URL prefix so that untrusted language tags never reach the negotiation code, at the cost of losing locale-prefixed routing. Because this is gradual memory growth (A:L) rather than an instant crash, also monitor worker RSS and cache size, and cap process memory (for example with a systemd MemoryMax or container memory limit) so an attack produces a fast restart rather than an OOM event affecting the host; note that such a cap converts the attack into a self-inflicted availability loss if set too low.

Affected VersionsENISA

Django 5.2 <5.2.18
Django 6.0 <6.0.9
Django 6.1 <6.1.2

Affected Packages

euvd django fix: 5.2.18, 6.0.9, 6.1.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 vulnerable component is django.utils.translation.trans_real, the runtime backbone of Django's internationalization layer. get_supported_language_variant() resolves a requested language tag (for example 'zh-hant-tw') to a supported variant by walking hyphen-delimited fallbacks and consulting LANG_INFO and get_languages(); because this resolution is comparatively expensive it is wrapped in an lru_cache. Per the commit diff (c88b304cc2d90fc37d3bd1f5f3829706fa6c13bc and the accompanying 7e878b0f8bd42260903e6a0d38996a93b0474a0b, 3d32ee80ae52745d686bf94d3555000ddf073267, and 02a69e3791e3df23d45ea4ea7e7fc489f0eef2be) prior to the fix the code checked len(lang_code) against LANGUAGE_CODE_MAX_LENGTH *inside* the cached function body, meaning a cache key entry was already created for every distinct over-length code before the code was rejected or truncated. The patch extracts the resolution logic into an uncached helper _get_supported_language_variant() and performs the length gate (500 characters) outside of it, so over-length codes are rejected or truncated without ever being inserted into the cache; reset_cache() was updated to clear the helper's cache instead of the wrapper's. The root cause class is CWE-789 (memory allocation with excessive size): an externally controlled, effectively unbounded number of distinct values maps to unbounded cached allocations, i.e. a cache-key amplification / algorithmic resource-consumption flaw rather than a parsing or injection bug. The new regression test test_get_supported_language_variant_strict_long_lang_code_not_cached confirms the intended invariant that long codes are not cached.

Know when Django 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 (DSF) PRIMARY 6.9 MEDIUM
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
vuln.today AI 5.3 MEDIUM

Remotely reachable via unauthenticated HTTP language headers (AV:N/AC:L/PR:N/UI:N); only gradual memory-exhaustion availability impact (A:L), no confidentiality or integrity effect.

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

Primary rating from Vendor (DSF).

CVSS VectorVendor: DSF

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

Lifecycle Timeline

2
CVSS changed
Oct 06, 2026 - 14:22 NVD
5.3 (MEDIUM) 6.9 (MEDIUM)
CVE Published
Oct 06, 2026 - 13:34 cve.org
MEDIUM 5.3

DescriptionCVE.org

An issue was discovered in Django 6.1 before 6.1.2, 6.0 before 6.0.9, and 5.2 before 5.2.18. django.utils.translation.get_supported_language_variant() is subject to a potential denial-of-service attack when processing many distinct, very long language codes, which are retained as keys in an in-memory cache and consume process memory. Earlier, unsupported Django series (such as 5.1.x, 5.0.x, and 4.2.x) were not evaluated and may also be affected. Django would like to thank Gleb Lizunov for reporting this issue.

Threat Intelligence Overview

EPSS Score
0.4%
Top 70% exploitable
Prevalence
High
Django is one of the most widely deployed enterprise Python web frameworks
Data Quality
5 sources
Confidence: Medium
EUVD NVD CVE.org EPSS Vulnrichment Vendor GitHub VulDB

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
None
System Exposure· derived
Open
Automatable
Yes
Human Impact· derived
High
Technical Impact
Partial

Priority Score

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

More in Django

View all
CVE-2021-23336 MEDIUM POC
5.9 Feb 15

The package python/cpython from 0 and before 3.6.13, from 3.7.0 and before 3.7.10, from 3.8.0 and before 3.8.8, from 3.9

CVE-2017-12794 MEDIUM POC
6.1 Sep 07

In Django 1.10.x before 1.10.8 and 1.11.x before 1.11.5, HTML autoescaping was disabled in a portion of the template for

CVE-2022-34265 CRITICAL POC
9.8 Jul 04

An issue was discovered in Django 3.2 before 3.2.14 and 4.0 before 4.0.6. Rated critical severity (CVSS 9.8), this vulne

CVE-2021-35042 CRITICAL POC
9.8 Jul 02

Django 3.1.x before 3.1.13 and 3.2.x before 3.2.5 allows QuerySet.order_by SQL injection if order_by is untrusted input

CVE-2019-19844 CRITICAL POC
9.8 Dec 18

Django before 1.11.27, 2.x before 2.2.9, and 3.x before 3.0.1 allows account takeover. Rated critical severity (CVSS 9.8

CVE-2026-61594 CRITICAL POC
9.1 Sep 16

An authentication/authorization bypass in the djust Python live-view framework (versions prior to 1.0.7) lets unauthenti

CVE-2026-61599 HIGH POC
8.8 Sep 16

Unauthenticated arbitrary Python module import in djust before 1.0.7 lets any client that can reach the WebSocket or SSE

CVE-2020-9402 HIGH POC
8.8 Mar 05

Django 1.11 before 1.11.29, 2.2 before 2.2.11, and 3.0 before 3.0.4 allows SQL Injection if untrusted data is used as a

CVE-2016-6186 MEDIUM POC
6.1 Aug 05

Cross-site scripting (XSS) vulnerability in the dismissChangeRelatedObjectPopup function in contrib/admin/static/admin/j

CVE-2026-93456 HIGH POC
8.4 Sep 18

Forged content modification in django-page-cms through 2.0.13 lets unauthenticated remote attackers exploit five CSRF-ex

CVE-2026-61593 HIGH POC
8.1 Sep 16

Cross-site request forgery in djust's Server-Sent-Events transport affects all versions prior to 1.0.7 and allows a cros

CVE-2026-61590 HIGH POC
7.4 Sep 16

Unauthenticated remote attackers can read live Django view and session state and invoke server-side handlers through dju

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
SUSE Linux Enterprise Module for Package Hub 15 SP7 Affected
SUSE Linux Enterprise Module for Package Hub 15 SP6 Affected
openSUSE Leap 15.6 Affected

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