Kako implementirate avtentifikacijo (OAuth2/JWT)?

Question

Accepted Answer

FastAPI ponuja vgrajene orodja (`OAuth2PasswordBearer`, varnostne pripomore) za implementacijo avtentifikacije, ki se običajno uporabljajo z **OAuth2 tokovno porabo gesel z JWT žetoni**. Vzorec kombinira izdajo žetona (prijava) z odvisnostjo, ki preveri žeton na zaščitenih poteh.

## Heširanje gesel in izdaja JWT pri prijavi

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

Gesla so **heširana** (bcrypt) — nikoli niso shranjena v čistopisu. Pri veljavni prijavi se izda **JWT**: podpisan žeton, ki nosi identiteto uporabnika in čas poteka.

## Preverjanje žetona na zaščitenih poteh (odvisnost)

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

Odvisnost `get_current_user` ekstrahira in **preveri** JWT (podpis + čas poteka), naloži uporabnika in se vtrka v zaščitene končne točke — vsaka pot, ki je od nje odvisna, zahteva avtentifikacijo.

## Avtorizacija (vloge/obsegi)

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

## Zakaj je to pomembno

Avtentifikacija je nujna in **kritična za varnost** — skoraj vsak pravi API mora zaščititi poti, in napačna avtentifikacija povzroči resne ranljivosti.

Razumevanje pristopa FastAPI je pomembno: ponuja gradnike (`OAuth2PasswordBearer`, varnostne pripomore) za standardni vzorec **OAuth2-tokovna-poraba-gesel-z-JWT**, ki elegantno izkoristi prednosti FastAPI — končna točka prijave izda podpisan žeton, in odvisnost **`get_current_user`** ga preveri, kar čisto zaščiti katero koli pot, ki je od nje odvisna (idiomatski vzorec avtentifikacije FastAPI).

Nekoliko vidikov je kritičnih za pravilno izvedbo: **heširanje gesel** (bcrypt, nikoli čistopis, s preverjanjem s konstantnim časom), **pravilno podpisovanje in preverjanje JWT** (preverjanje podpisa + časa poteka), razlikovanje med **avtentifikacijo** (kdo si) in **avtorizacijo** (kaj lahko počneš, prek preverjanja vloge/obsega), in varovanje skrivnega ključa.

Znanje, kako ta vzorec varno implementirati — izdaja žetona, odvisnost preverjanja in avtorizacija — je temeljno znanje za višje ravni razvoja varnih aplikacij FastAPI, saj je avtentifikacija hkrati vseprisotna in pogost vir nevarnih napak, ko jo nepravilno implementiramo.