Hoe implementeer je authenticatie (OAuth2/JWT)?

Question

Accepted Answer

FastAPI biedt ingebouwde tools (`OAuth2PasswordBearer`, security utilities) voor het implementeren van authenticatie, meestal met **OAuth2 password flow met JWT tokens**. Het patroon combineert token-uitgifte (login) met een dependency die het token valideert op beveiligde routes.

## Wachtwoorden hashen en JWT uitgeven bij login

```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"}
```

Wachtwoorden worden **gehasht** (bcrypt) — nooit plaintext opgeslagen. Bij geldige login wordt een **JWT** uitgegeven: een ondertekend token dat de identiteit van de gebruiker en een vervaldatum bevat.

## Het token valideren op beveiligde routes (een dependency)

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

Een `get_current_user` dependency extraheert en **verifieert** de JWT (handtekening + vervaldatum), laadt de gebruiker, en wordt geïnjecteerd in beveiligde endpoints — elke route die ervan afhangt, vereist authenticatie.

## Autorisatie (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
```

## Waarom het belangrijk is

Authenticatie is essentieel en **security-kritiek** — bijna elke echte API moet routes beschermen, en authenticatie verkeerd implementeren creëert ernstige kwetsbaarheden.

De FastAPI-aanpak begrijpen is belangrijk: het biedt de bouwstenen (`OAuth2PasswordBearer`, security utilities) voor het standaard **OAuth2-password-flow-with-JWT** patroon, dat elegant gebruikmaakt van FastAPI's sterke punten — een login endpoint geeft een ondertekend token uit, en een **`get_current_user` dependency** valideert het, wat op schone manier elke route beschermt die ervan afhangt (het idiomatische FastAPI auth-patroon).

Verschillende aspecten zijn kritiek om correct uit te voeren: **wachtwoorden hashen** (bcrypt, nooit plaintext, met constant-time verificatie), **JWT's correct ondertekenen en verifiëren** (handtekening + vervaldatum validatie), onderscheid maken tussen **authenticatie** (wie je bent) en **autorisatie** (wat je mag doen, via rol/scope checks), en de secret key veilig houden.

Weten hoe je dit patroon veilig implementeert — token-uitgifte, de validatie dependency, en autorisatie — is fundamentele senior-level kennis voor het bouwen van veilige FastAPI-applicaties, omdat auth zowel alomtegenwoordig als een frequente bron van gevaarlijke fouten is wanneer het incorrect wordt geïmplementeerd.