Comment implémenter l'authentification (OAuth2/JWT) ?

Question

Accepted Answer

FastAPI fournit des outils intégrés (`OAuth2PasswordBearer`, utilitaires de sécurité) pour implémenter l'authentification, généralement en utilisant **le flux de mot de passe OAuth2 avec des jetons JWT**. Le modèle combine l'émission de jetons (connexion) avec une dépendance qui valide le jeton sur les routes protégées.

## Hachage des mots de passe et émission d'un JWT à la connexion

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

Les mots de passe sont **hachés** (bcrypt) — jamais stockés en texte brut. À la connexion réussie, un **JWT** est émis : un jeton signé portant l'identité de l'utilisateur et une date d'expiration.

## Validation du jeton sur les routes protégées (une dépendance)

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

Une dépendance `get_current_user` extrait et **vérifie** le JWT (signature + expiration), charge l'utilisateur, et est injectée dans les endpoints protégés — toute route dépendant de celle-ci nécessite une authentification.

## Autorisation (rôles/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
```

## Pourquoi c'est important

L'authentification est essentielle et **critique pour la sécurité** — presque chaque API réelle doit protéger les routes, et une mauvaise mise en œuvre de l'authentification crée de graves vulnérabilités.

Comprendre l'approche de FastAPI est important : il fournit les blocs de construction (`OAuth2PasswordBearer`, utilitaires de sécurité) pour le modèle standard **flux-de-mot-de-passe-OAuth2-avec-JWT**, qui exploite élégamment les forces de FastAPI — un endpoint de connexion émet un jeton signé, et une **dépendance `get_current_user`** le valide, protégeant proprement toute route qui en dépend (le modèle d'authentification idiomatique FastAPI).

Plusieurs aspects sont critiques à bien maîtriser : **hacher les mots de passe** (bcrypt, jamais en texte brut, avec vérification en temps constant), **signer et vérifier les JWT** correctement (validation de signature + expiration), distinguer **l'authentification** (qui vous êtes) de **l'autorisation** (ce que vous pouvez faire, via des vérifications de rôle/scope), et sécuriser la clé secrète.

Savoir comment implémenter ce modèle de manière sécurisée — émission de jeton, la dépendance de validation, et l'autorisation — est une connaissance fondamentale de niveau senior pour construire des applications FastAPI sécurisées, car l'authentification est à la fois omniprésente et une source fréquente d'erreurs dangereuses lorsqu'elle est implémentée incorrectement.