Django REST framework: TokenProxy.delete() reporta éxito pero no revoca nada
Resumen
Eliminar un token de autenticación a través de TokenProxy no elimina nada de forma silenciosa. La llamada no genera ninguna excepción y reporta éxito, la fila en la base de datos permanece y el token sigue autenticando. Cualquier aplicación, integración de administración o script operativo que revoque credenciales llamando a .delete() en una instancia de TokenProxy asume haber revocado un token que en realidad sigue activo.
Detalles
TokenProxy anula pk para devolver el identificador de usuario (rest_framework/authtoken/models.py:49-63):
@property
def pk(self):
return self.user_id
El modelo concreto Token se indexa mediante key, no mediante un id entero. Model.delete() construye su consulta de eliminación a partir de pk, por lo que emite:
DELETE FROM "authtoken_token" WHERE "authtoken_token"."key" IN ('1')
Esto compara un id de usuario con la columna de clave de 40 caracteres. Nada coincide, no se lanza ninguna excepción y la llamada devuelve (0, {'authtoken.TokenProxy': 0}).
DRF ya incluye dos soluciones alternativas para esta discrepancia de identidad en lugar de una corrección. En rest_framework/authtoken/admin.py, TokenAdmin.delete_model vuelve a consultar la fila concreta:
def delete_model(self, request, obj):
Token.objects.get(key=obj.key).delete() # admin.py:30
y TokenAdmin define actions = None con el comentario «Actions not compatible with mapped IDs» (admin.py:50-53). Por lo tanto, la ruta del panel de administración incluida es segura, mientras que cualquier otro invocador de TokenProxy.delete() no lo es. Nada en la API advierte de esta diferencia.
TokenProxy fue añadido por e2bd3b6a (PR #7341, «Adjusted token admin to map to user ID»), publicado por primera vez en 3.12.0.
Una solución eliminaría la anulación de pk, proporcionaría a TokenProxy un delete() que opere sobre la fila concreta, o lanzaría una excepción en lugar de reportar silenciosamente cero eliminaciones.
PoC
Guarde como poc_tokenproxy_revocation.py y ejecútelo.
#!/usr/bin/env python
"""
django-rest-framework: TokenProxy.delete() reports success and revokes nothing.
baseline token exists -> 200
TRIGGER TokenProxy.objects.get(...).delete() -> no exception, row survives, still 200
CONTROL Token.objects.get(key=...).delete() -> row gone, 401
The control is what makes the trigger meaningful: it proves the row was
deletable and the credential check live, so the 200 after the proxy delete is a
failed revocation and not a broken harness.
Requires: django, djangorestframework importable. No arguments.
python poc_tokenproxy_revocation.py
Exit status 0 means the revocation failure reproduced.
"""
import sys
import django
from django.conf import settings
settings.configure(
DEBUG=False,
SECRET_KEY="poc",
ALLOWED_HOSTS=["*"],
ROOT_URLCONF=__name__,
INSTALLED_APPS=[
"django.contrib.contenttypes",
"django.contrib.auth",
"rest_framework",
"rest_framework.authtoken",
],
DATABASES={"default": {"ENGINE": "django.db.backends.sqlite3", "NAME": ":memory:"}},
DEFAULT_AUTO_FIELD="django.db.models.AutoField",
USE_TZ=True,
)
django.setup()
from django.contrib.auth import get_user_model # noqa: E402
from django.core.management import call_command # noqa: E402
from django.db import connection # noqa: E402
from django.test import Client # noqa: E402
from django.test.utils import CaptureQueriesContext # noqa: E402
from django.urls import path # noqa: E402
from rest_framework.authentication import TokenAuthentication # noqa: E402
from rest_framework.authtoken.models import Token, TokenProxy # noqa: E402
from rest_framework.permissions import IsAuthenticated # noqa: E402
from rest_framework.response import Response # noqa: E402
from rest_framework.views import APIView # noqa: E402
class Whoami(APIView):
authentication_classes = [TokenAuthentication]
permission_classes = [IsAuthenticated]
def get(self, request):
return Response({"user": request.user.get_username()})
urlpatterns = [path("", Whoami.as_view())]
def probe(client, key):
response = client.get("/", headers={"authorization": "Token %s" % key})
return response.status_code
def main():
call_command("migrate", run_syncdb=True, verbosity=0)
user = get_user_model().objects.create_user(username="revoke-user", password="pw")
key = Token.objects.create(user=user).key
client = Client()
print("TokenProxy._meta.proxy =", TokenProxy._meta.proxy)
print("Token._meta.pk.attname =", Token._meta.pk.attname)
print("user.pk =", user.pk)
print("token key =", key)
print("\n--- baseline")
print("rows =", Token.objects.count())
baseline = probe(client, key)
print("GET / with token ->", baseline)
print("\n--- TRIGGER: delete through the proxy")
proxy = TokenProxy.objects.get(user=user)
print("proxy.pk =", proxy.pk, "(TokenProxy.pk property)")
raised = None
with CaptureQueriesContext(connection) as ctx:
try:
returned = proxy.delete()
except Exception as exc: # noqa: BLE001
raised, returned = exc, None
for q in ctx.captured_queries:
if "DELETE" in q["sql"]:
print(" SQL:", q["sql"])
print("raised =", repr(raised))
print("returned =", returned)
print("rows =", Token.objects.count())
after_proxy = probe(client, key)
print("GET / with token ->", after_proxy)
print("\n--- CONTROL: delete the same row through the concrete model")
with CaptureQueriesContext(connection) as ctx2:
returned2 = Token.objects.get(key=key).delete()
for q in ctx2.captured_queries:
if "DELETE" in q["sql"]:
print(" SQL:", q["sql"])
print("returned =", returned2)
print("rows =", Token.objects.count())
after_real = probe(client, key)
print("GET / with token ->", after_real)
ok = baseline == 200 and raised is None and after_proxy == 200 and after_real == 401
print(
"\nrevocation failure reproduced:", ok,
"(baseline 200, still 200 after proxy delete, 401 after real delete)",
)
return 0 if ok else 1
if __name__ == "__main__":
sys.exit(main())
Salida observada:
TokenProxy._meta.proxy = True
Token._meta.pk.attname = key
user.pk = 1
token key = 6a644878f252175d39205804c5a6faf16df67c10
--- baseline
rows = 1
GET / with token -> 200
--- TRIGGER: delete through the proxy
proxy.pk = 1 (TokenProxy.pk property)
SQL: DELETE FROM "authtoken_token" WHERE "authtoken_token"."key" IN ('1')
raised = None
returned = (0, {'authtoken.TokenProxy': 0})
rows = 1
GET / with token -> 200
--- CONTROL: delete the same row through the concrete model
SQL: DELETE FROM "authtoken_token" WHERE "authtoken_token"."key" IN ('6a644878...')
returned = (1, {'authtoken.Token': 1})
rows = 0
GET / with token -> 401
revocation failure reproduced: True
El control es lo que hace significativo el desencadenante: demuestra que la fila se podía eliminar y que la verificación de credenciales estaba activa, por lo que el 200 tras la eliminación mediante proxy es una revocación fallida y no un fallo del entorno de pruebas. Se reprodujo de forma idéntica en Django 6.1 y 5.2.17 LTS, por lo que no es una regresión reciente de Django.
Impacto
Fallo en la revocación de credenciales. Un operador que revoca un token a través de una instancia de TokenProxy y no recibe ningún error deja una credencial activa en circulación indefinidamente, ya que los tokens de autenticación de DRF no caducan por sí mismos. Cualquier poseedor de dicho token se beneficia: un empleado saliente, una integración rotada, un dispositivo que se creía desaprovisionado o un atacante cuyo acceso se consideraba revocado durante la respuesta a un incidente.
Ninguna entrada no confiable llega a esta ruta de código, razón por la cual el vector se califica como AC:H. La explotación depende de que el despliegue revoque a través del proxy, lo cual es habitual dado que TokenProxy es el modelo registrado en el admin y el que la mayoría del código utilizará. Cualquier despliegue en 3.12.0 o posterior que revoque tokens fuera del propio TokenAdmin.delete_model de DRF debe auditar si sus revocaciones fueron efectivas.
Qué hacer
Actualice el paquete djangorestframework a la versión 3.18.2 o posterior. Cualquier despliegue en la versión 3.12.0 o superior que revoque tokens fuera del TokenAdmin.delete_model propio de DRF debe auditar si dichas revocaciones surtieron efecto.
Software afectado
Haz clic en una tecnología para ver todas sus vulnerabilidades.
| Plataforma | Paquete | Versiones vulnerables | Corregida en |
|---|---|---|---|
| Python (PyPI) | djangorestframework | >= 3.12.0, < 3.18.2 | 3.18.2 |
Referencias
- https://github.com/encode/django-rest-framework/security/advisories/GHSA-xw6w-gcfp-cf8m
- https://nvd.nist.gov/vuln/detail/CVE-2026-114137
- https://github.com/encode/django-rest-framework/commit/af3fabfd517307fbc5d500fba1ab8f6e25f220b0
- 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:H/PR:N/UI:N/S:U/C:H/I:H/A:N- Debilidad (CWE)
CWE-390, CWE-613- Plataforma
- Python (PyPI)
- Paquete
djangorestframework- Publicada
- 22.10.2026
- Actualizado
- 26.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-xw6w-gcfp-cf8m - 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: TokenProxy.delete() reporta éxito pero no revoca nada 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.