Jak implementujete autentizaci (OAuth2/JWT)?

Question

Accepted Answer

FastAPI poskytuje vestavěné nástroje (`OAuth2PasswordBearer`, security utilities) pro implementaci autentizace, běžně pomocí **OAuth2 password flow s JWT tokeny**. Vzor kombinuje vystavení tokenu (login) se závislostí, která ověřuje token na chráněných trasách.

## Hashování hesel a vydání JWT při přihlášení

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

Hesla jsou **hashována** (bcrypt) — nikdy se neukládají v čistém textu. Při úspěšném přihlášení se vydá **JWT**: podepsaný token obsahující identitu uživatele a dobu vypršení.

## Ověřování tokenu na chráněných trasách (závislost)

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

Závislost `get_current_user` extrahuje a **ověřuje** JWT (podpis + vypršení), načte uživatele a je injektována do chráněných endpointů — jakákoliv trasa, která na ní závisí, vyžaduje autentizaci.

## Autorizace (role/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
```

## Proč to je důležité

Autentizace je podstatná a **bezpečnostně kritická** — téměř každé reálné API potřebuje chránit trasy a chybná implementace autentizace vytváří závažné zranitelnosti.

Rozdělení přístupu FastAPI je důležité: poskytuje stavební kameny (`OAuth2PasswordBearer`, security utilities) pro standardní **OAuth2-password-flow-s-JWT** vzor, který elegantně využívá silných stránek FastAPI — login endpoint vydá podepsaný token a **závislost `get_current_user`** jej ověřuje, čistě chránící jakoukoli trasu, která na ní závisí (idiomatický FastAPI auth vzor).

Několik aspektů je kritických aby byla implementace správná: **hashování hesel** (bcrypt, nikdy v čistém textu, s ověřením v konstantním čase), **podpis a ověření JWT** správně (ověření podpisu + vypršení), rozlišování **autentizace** (kdo jsi) od **autorizace** (co můžeš dělat, přes role/scope checks) a bezpečné uchování tajného klíče.

Vědět, jak implementovat tento vzor bezpečně — vydání tokenu, ověřovací závislost a autorizaci — je základní znalost pro senior level vývojáře stavícího bezpečné FastAPI aplikace, protože autentizace je jak všudypřítomná, tak i běžný zdroj nebezpečných chyb, když je implementována nesprávně.