Wie implementierst du Authentifizierung (OAuth2/JWT)?

Question

Accepted Answer

FastAPI bietet integrierte Tools (`OAuth2PasswordBearer`, Security-Utilities) zur Implementierung von Authentifizierung, üblicherweise unter Verwendung von **OAuth2 Password Flow mit JWT-Tokens**. Das Muster kombiniert Token-Ausstellung (Login) mit einer Abhängigkeit, die den Token auf geschützten Routen validiert.

## Passwörter hashen und JWT beim Login ausstellen

```python
from passlib.context import CryptContext
from jose import jwt
from datetime import datetime, timedelta

pwd = CryptContext(schemes=["bcrypt"])    # secure password hashing

@app.post("/login")
def login(form: OAuth2PasswordRequestForm = Depends()):
    user = get_user(form.username)
    if not user or not pwd.verify(form.password, user.hashed_password):  # constant-time check
        raise HTTPException(401, "Invalid credentials")
    # issue a signed JWT containing the user identity + expiry
    token = jwt.encode(
        {"sub": user.username, "exp": datetime.utcnow() + timedelta(minutes=30)},
        SECRET_KEY, algorithm="HS256",
    )
    return {"access_token": token, "token_type": "bearer"}
```

Passwörter werden **gehasht** (bcrypt) — niemals im Klartext gespeichert. Bei erfolgreichem Login wird ein **JWT** ausgestellt: ein signierter Token, der die Identität des Benutzers und ein Ablaufdatum trägt.

## Token auf geschützten Routen validieren (eine Abhängigkeit)

```python
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="login")   # extracts the Bearer token

def get_current_user(token: str = Depends(oauth2_scheme)):
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])   # verify signature + expiry
        username = payload.get("sub")
    except JWTError:
        raise HTTPException(401, "Invalid token")
    user = get_user(username)
    if not user:
        raise HTTPException(401, "User not found")
    return user

@app.get("/me")
def read_me(user: User = Depends(get_current_user)):     # PROTECTED — requires a valid token
    return user
```

Eine `get_current_user` Abhängigkeit extrahiert und **verifiziert** den JWT (Signatur + Ablaufdatum), lädt den Benutzer und wird in geschützte Endpoints injiziert — jede Route, die davon abhängt, erfordert Authentifizierung.

## Autorisierung (Rollen/Scopes)

```python
def require_admin(user: User = Depends(get_current_user)):
    if not user.is_admin:
        raise HTTPException(403, "Forbidden")     # authorization check
    return user
# OAuth2 SCOPES provide fine-grained permission control
```

## Warum es wichtig ist

Authentifizierung ist essentiell und **sicherheitskritisch** — nahezu jede echte API muss Routen schützen, und falsch implementierte Auth schafft ernsthafte Sicherheitslücken.

Das Verständnis von FastAPIs Ansatz ist wichtig: Es bietet die Bausteine (`OAuth2PasswordBearer`, Security-Utilities) für das Standard-Pattern **OAuth2-Password-Flow-mit-JWT**, das FastAPIs Stärken elegant nutzt — ein Login-Endpoint stellt einen signierten Token aus, und eine **`get_current_user` Abhängigkeit** validiert ihn, wodurch jede Route, die davon abhängt, sauber geschützt wird (das idiomatische FastAPI-Auth-Pattern).

Mehrere Aspekte sind entscheidend, um sie richtig zu implementieren: **Passwörter hashen** (bcrypt, niemals Klartext, mit Timing-sichere Verifizierung), **JWTs korrekt signieren und verifizieren** (Signatur + Ablaufdatum-Validierung), zwischen **Authentifizierung** (wer du bist) und **Autorisierung** (was du tun darfst, über Role/Scope-Checks) unterscheiden, und den Secret Key sicher aufbewahren.

Zu wissen, wie man dieses Pattern sicher implementiert — Token-Ausstellung, die Validierungs-Abhängigkeit und Autorisierung — ist fundamentales Wissen auf Senior-Level für den Bau sicherer FastAPI-Anwendungen, da Auth sowohl allgegenwärtig als auch häufig eine Quelle gefährlicher Fehler bei falscher Implementierung ist.