Kako implementirate avtentifikacijo (OAuth2/JWT)?

Question

IT Interview Practice · 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.

Heširanje gesel in izdaja JWT pri prijavi

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

Avtorizacija (vloge/obsegi)

Zakaj je to pomembno

Povezana vprašanja