Cum implementezi autentificarea (OAuth2/JWT)?

Question

Accepted Answer

FastAPI oferă instrumente integrate (`OAuth2PasswordBearer`, utilitare de securitate) pentru implementarea autentificării, utilizând în mod obișnuit **fluxul OAuth2 cu parolă combinat cu tokeni JWT**. Modelul combină emiterea tokenului (login) cu o dependență care validează tokenul pe rutele protejate.

## Hashing-ul parolelor și emiterea unui JWT la 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"}
```

Parolele sunt **hash-ate** (bcrypt) — niciodată stocate în text clar. La un login valid, se emite un **JWT**: un token semnat care conține identitatea utilizatorului și o dată de expirare.

## Validarea tokenului pe rutele protejate (o dependență)

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

O dependență `get_current_user` extrage și **verifică** JWT-ul (semnătură + expirare), încarcă utilizatorul și este injectată în endpoint-urile protejate — orice rută care depinde de aceasta necesită autentificare.

## Autorizare (roluri/scope-uri)

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

## De ce conteaza

Autentificarea este esențială și **critic din punct de vedere al securității** — aproape fiecare API real trebuie să protejeze rutele, iar implementarea eronată a autentificării creează vulnerabilități grave.

Înțelegerea abordării FastAPI este importantă: aceasta oferă blocurile de construcție (`OAuth2PasswordBearer`, utilitare de securitate) pentru modelul standard **OAuth2-password-flow-with-JWT**, care exploatează elegant punctele forte ale FastAPI — un endpoint de login emite un token semnat, iar o dependență **`get_current_user`** îl validează, protejând curat orice rută care depinde de aceasta (modelul de autentificare idiometic FastAPI).

Mai multe aspecte sunt critice să fie implementate corect: **hash-ul parolelor** (bcrypt, niciodată text clar, cu verificare în timp constant), **semnarea și verificarea JWT-urilor** corect (validare semnătură + expirare), distingerea între **autentificare** (cine ești tu) și **autorizare** (ce poți face, prin verificări de rol/scope), și păstrarea sigură a cheii secrete.

Știind cum să implementezi acest model în mod sigur — emiterea tokenului, dependența de validare și autorizare — este cunoștință fundamentală de nivel senior pentru construirea aplicațiilor FastAPI sigure, deoarece autentificarea este atât omniprezentă, cât și o sursă frecventă de greșeli periculoase atunci când este implementată incorect.