Jak implementujesz autentykację (OAuth2/JWT)?

Question

Accepted Answer

FastAPI udostępnia wbudowane narzędzia (`OAuth2PasswordBearer`, narzędzia bezpieczeństwa) do implementacji autentykacji, powszechnie używając **przepływu haseł OAuth2 z tokenami JWT**. Ten wzorzec łączy wydawanie tokenów (logowanie) z zależnością, która waliduje token na chronionych trasach.

## Haszowanie haseł i wydawanie JWT przy logowaniu

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

Hasła są **haszowane** (bcrypt) — nigdy nie przechowywane w zwykłym tekście. Przy poprawnym logowaniu **JWT** jest wydawany: podpisany token zawierający tożsamość użytkownika i czas wygaśnięcia.

## Walidacja tokenu na chronionych trasach (zależność)

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

Zależność `get_current_user` ekstrahuje i **weryfikuje** JWT (podpis + wygaśnięcie), ładuje użytkownika i jest wstrzykiwana do chronionych endpointów — każda trasa zależna od niej wymaga autentykacji.

## Autoryzacja (role/zakresy)

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

## Dlaczego to ważne

Autentykacja jest niezbędna i **krytyczna dla bezpieczeństwa** — prawie każde rzeczywiste API musi chronić trasy, a błędy w autentykacji tworzą poważne luki w zabezpieczeniach.

Zrozumienie podejścia FastAPI jest ważne: zapewnia on elementy składowe (`OAuth2PasswordBearer`, narzędzia bezpieczeństwa) dla standardowego wzorca **OAuth2-password-flow-with-JWT**, który elegancko wykorzystuje mocne strony FastAPI — endpoint logowania wydaje podpisany token, a zależność **`get_current_user`** go weryfikuje, czyszczając ochronę każdej trasy, która od niego zależy (idiomatyczny wzorzec autentykacji FastAPI).

Istnieje kilka aspektów, które są krytyczne do prawidłowego wdrożenia: **haszowanie haseł** (bcrypt, nigdy w zwykłym tekście, z weryfikacją o stałym czasie), **podpisywanie i weryfikacja JWT** (walidacja podpisu + wygaśnięcia), rozróżnianie **autentykacji** (kim jesteś) od **autoryzacji** (co możesz robić, poprzez kontrolę roli/zakresu) i bezpieczne przechowywanie klucza tajnego.

Umiejętność bezpiecznego wdrożenia tego wzorca — wydawania tokenów, zależności walidacyjnej i autoryzacji — jest fundamentalną wiedzą na poziomie seniora do budowania bezpiecznych aplikacji FastAPI, ponieważ autentykacja jest zarówno wszechobecna, jak i częstym źródłem niebezpiecznych błędów podczas nieprawidłowego wdrażania.