Alta

Django REST framework: TokenProxy.delete() reporta éxito pero no revoca nada

  • Publicada: 22.10.2026
  • Actualizado: 26.10.2026 10:00

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

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

sql
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:

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

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

PlataformaPaqueteVersiones vulnerablesCorregida en
Python (PyPI) djangorestframework >= 3.12.0, < 3.18.2 3.18.2

Referencias

Puntuación CVSS 7.4/10
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

  1. 2020: 1
  2. 2021: 0
  3. 2022: 0
  4. 2023: 0
  5. 2024: 1
  6. 2025: 0
  7. 2026: 4
  1. Django REST framework: TokenProxy.delete() reporta éxito pero no revoca nada esta entrada
    Alta · 7.4 CVE-2026-114137 >= 3.12.0, < 3.18.2 3.18.2
  2. Baja · 6.1 CVE-2024-21520 < 3.15.2 3.15.2
  3. Media · 6.1 CVE-2020-25626 < 3.11.2 3.11.2

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.

Conectar tu aplicación
Newsletter DockRay

La seguridad de tus aplicaciones en tu correo

Vulnerabilidades importantes, recomendaciones concretas y consejos prácticos para tus aplicaciones. Elige tus tecnologías y sigue lo que importa para tu proyecto.

  • Un resumen diario de nuevas vulnerabilidades, también las críticas.
  • Avisos sobre actualizaciones importantes.
  • Consejos prácticos sobre seguridad y monitorización de aplicaciones.

Déjalo vacío para recibir avisos de todas las tecnologías.

Suscripción gratuita. Date de baja con un clic en cualquier correo.