Come implementi l'autenticazione (OAuth2/JWT)?

Question

Accepted Answer

FastAPI fornisce strumenti integrati (`OAuth2PasswordBearer`, security utilities) per implementare l'autenticazione, comunemente usando il **flusso password OAuth2 con token JWT**. Il pattern combina l'emissione del token (login) con una dipendenza che valida il token sulle rotte protette.

## Hashing delle password e emissione di un JWT al 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"}
```

Le password sono **hashate** (bcrypt) — mai memorizzate in plaintext. Al login valido, viene emesso un **JWT**: un token firmato che contiene l'identità dell'utente e una scadenza.

## Validazione del token sulle rotte protette (una dipendenza)

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

Una dipendenza `get_current_user` estrae e **verifica** il JWT (firma + scadenza), carica l'utente, e viene iniettata negli endpoint protetti — ogni rotta che dipende da essa richiede autenticazione.

## Autorizzazione (ruoli/scopi)

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

## Perché è importante

L'autenticazione è essenziale e **critica per la sicurezza** — praticamente ogni API reale ha bisogno di proteggere le rotte, e sbagliare l'autenticazione crea vulnerabilità serie.

Comprendere l'approccio di FastAPI è importante: fornisce i building block (`OAuth2PasswordBearer`, security utilities) per il pattern standard **OAuth2-password-flow-with-JWT**, che sfrutta elegantemente i punti di forza di FastAPI — un endpoint di login emette un token firmato, e una **dipendenza `get_current_user`** lo valida, proteggendo chiaramente qualsiasi rotta che ne dipende (il pattern di autenticazione idiomatico di FastAPI).

Vari aspetti sono critici da implementare correttamente: **hashing delle password** (bcrypt, mai plaintext, con verifica a tempo costante), **firma e verifica dei JWT** corrette (firma + validazione della scadenza), distinguere l'**autenticazione** (chi sei) dall'**autorizzazione** (cosa puoi fare, tramite controlli di ruolo/scope), e mantenere la chiave segreta al sicuro.

Sapere come implementare questo pattern in sicurezza — emissione del token, la dipendenza di validazione, e autorizzazione — è una conoscenza fondamentale di livello senior per costruire applicazioni FastAPI sicure, poiché l'autenticazione è sia ubiqua che una frequente fonte di errori pericolosi se implementata incorrettamente.