Hvordan implementerer du autentisering (OAuth2/JWT)?

Question

Accepted Answer

FastAPI gir innebygde verktøy (`OAuth2PasswordBearer`, sikkerheitsverktøy) for å implementere autentisering, vanligvis ved bruk av **OAuth2 password flow med JWT-tokens**. Mønsteret kombinerer token-utstedelse (pålogging) med en avhengighet som validerer token på beskyttede ruter.

## Hashing av passord og utstedelse av JWT ved pålogging

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

Passord blir **hashet** (bcrypt) — aldri lagret som ren tekst. Ved vellykket pålogging blir en **JWT** utstedt: en signert token som bærer brukerens identitet og utløpstid.

## Validering av token på beskyttede ruter (en avhengighet)

```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`-avhengighet ekstraherer og **verifiserer** JWT-en (signatur + utløpstid), laster brukeren, og blir injisert i beskyttede endepunkter — enhver rute som avhenger av den krever autentisering.

## Autorisasjon (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 betyr noe

Autentisering er essensielt og **kritisk for sikkerheten** — nesten alle virkelige APIer må beskytte ruter, og å få autentisering feil skaper alvorlige sårbarheter.

Å forstå FastAPIs tilnærming er viktig: den gir byggesteinene (`OAuth2PasswordBearer`, sikkerheitsverktøy) for det standard **OAuth2-password-flow-med-JWT**-mønsteret, som elegant utnytter FastAPIs styrker — et påloggingsendepunkt utsteder en signert token, og en **`get_current_user`-avhengighet** validerer den, og beskytter på en ren måte enhver rute som avhenger av den (det idiomatiske FastAPI-autentiseringsmønsteret).

Flere aspekter er kritiske for å få rett: **hashing av passord** (bcrypt, aldri ren tekst, med konstant-tid-verifisering), **signering og verifisering av JWT-er** på riktig måte (signatur + utløpstid-validering), å skille mellom **autentisering** (hvem du er) og **autorisasjon** (hva du kan gjøre, via rolle/scope-sjekker), og å holde den hemmelige nøkkelen sikker.

Å vite hvordan du implementerer dette mønsteret sikkert — token-utstedelse, valideringsavhengigheten, og autorisasjon — er fundamental senior-nivå-kunnskap for å bygge sikre FastAPI-applikasjoner, siden autentisering både er allestedsstede og en hyppig kilde til farlige feil når det implementeres feil.