Hvordan implementerer du autentificering (OAuth2/JWT)?

Question

Accepted Answer

FastAPI tilbyder indbyggede værktøjer (`OAuth2PasswordBearer`, security utilities) til implementering af autentificering, almindeligvis ved brug af **OAuth2 password flow med JWT tokens**. Mønsteret kombinerer token-udstedelse (login) med en afhængighed, der validerer tokenet på beskyttede ruter.

## Hashing af adgangskoder og udstedelse af JWT ved 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"}
```

Adgangskoder bliver **hashet** (bcrypt) — aldrig lagret som plaintext. Ved gyldig login udstedes et **JWT**: et signeret token, der indeholder brugerens identitet og en udløbstid.

## Validering af tokenet på beskyttede ruter (en afhængighed)

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

En `get_current_user` afhængighed ekstraherer og **verificerer** JWT'et (signatur + udløbstid), indlæser brugeren, og injiceres i beskyttede endpoints — enhver rute, der afhænger af det, kræver autentificering.

## Autorisation (roller/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
```

## Hvorfor det betyder noget

Autentificering er afgørende og **sikkerhedskritisk** — næsten alle virkelige API'er skal beskytte ruter, og fejl i autentificering skaber alvorlige sikkerhedsproblemmer.

At forstå FastAPI's tilgang er vigtig: den tilbyder byggeklodser (`OAuth2PasswordBearer`, security utilities) til standard **OAuth2-password-flow-med-JWT** mønsteret, som elegant udnytter FastAPI's styrker — et login endpoint udsteder et signeret token, og en **`get_current_user` afhængighed** validerer det, hvilket præcist beskytter enhver rute, der afhænger af det (det idiomatic FastAPI auth-mønster).

Flere aspekter er kritiske at få rigtigt: **hashing af adgangskoder** (bcrypt, aldrig plaintext, med constant-time verifikation), **signering og verifikation af JWT'er** korrekt (signatur + udløbstidvalidering), skelnen mellem **autentificering** (hvem du er) og **autorisation** (hvad du kan gøre, via rolle/scope-tjek), og at holde den hemmelige nøgle sikker.

At vide, hvordan man implementerer dette mønster sikkert — token-udstedelse, valideringafhængigheden og autorisation — er fundamental senior-level viden til at bygge sikre FastAPI-applikationer, da autentificering er både allestedsnærværende og en hyppig kilde til farlige fejl, når det implementeres forkert.