Hogyan implementálsz hitelesítést (OAuth2/JWT)?

Question

Accepted Answer

A FastAPI beépített eszközöket biztosít (`OAuth2PasswordBearer`, biztonsági segédprogramokat) a hitelesítés implementálásához, amelyet általában **OAuth2 jelszó-flow JWT tokenekkel** kombinálnak. A minta a token kibocsátást (bejelentkezés) ötvözi egy függőséggel, amely érvényesíti a tokent a védett útvonalakon.

## JWT kibocsátása bejelentkezéskor a jelszavak hash-elése után

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

A jelszavak **hash-eltek** (bcrypt) — soha nem tárolódnak egyszerű szövegként. Érvényes bejelentkezéskor egy **JWT** kerül kibocsátásra: egy aláírt token, amely a felhasználó identitását és a lejárati időt hordozza.

## A token érvényesítése a védett útvonalakon (egy függőség)

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

Az `get_current_user` függőség kinyeri és **ellenőrzi** a JWT-t (aláírás + lejárati idő), betölti a felhasználót, és a védett végpontokba injektálódik — bármely, ebből függő útvonal hitelesítést igényel.

## Jogosultságok (szerepkörök/hatáskörök)

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

## Miért fontos

A hitelesítés elengedhetetlen és **biztonsági szempontból kritikus** — szinte minden valós API-nak védenie kell az útvonalakat, és a hitelesítés helytelen megvalósítása komoly sebezhetőségeket okozhat.

A FastAPI megközelítésének megértése fontos: biztosítja az építőelemeket (`OAuth2PasswordBearer`, biztonsági segédprogramokat) a szabványos **OAuth2-jelszó-flow-JWT** mintához, amely elegánsan kihasználja a FastAPI erősségeit — egy bejelentkezési végpont aláírt tokent bocsát ki, és egy **`get_current_user` függőség** érvényesíti azt, tisztán védelmet nyújtva bármely, ebből függő útvonalat (az idiomatikus FastAPI hitelesítési minta).

Néhány szempont kritikus a helyes megvalósításhoz: **jelszavak hash-elése** (bcrypt, soha nem egyszerű szöveg, időállandó ellenőrzéssel), **JWT-k aláírása és ellenőrzése** helyesen (aláírás + lejárati idő érvényesítése), a **hitelesítés** (ki vagy) és az **jogosultság** (mit csinálhatsz, szerepkör-/hatáskör-ellenőrzéseken keresztül) megkülönböztetése, valamint a titkos kulcs biztonságos tárolása.

Annak ismerete, hogyan kell ezt a mintát biztonságosan megvalósítani — token kibocsátás, az érvényesítési függőség és jogosultságok — alapvető senior szintű tudás a biztonságos FastAPI alkalmazások készítéséhez, mivel a hitelesítés egyrészt mindenütt jelen van, másrészt gyakori forrásakellemzetes hibáknak, ha helytelenül implementálják.