Kako implementirate autentifikaciju (OAuth2/JWT)?

Question

Accepted Answer

FastAPI pruža ugrađene alate (`OAuth2PasswordBearer`, sigurnosne utility) za implementaciju autentifikacije, često koristeći **OAuth2 password tok sa JWT tokenima**. Uzorak kombinira izdavanje tokena (prijava) sa dependency-jem koji validira token na zaštićenim rutama.

## Heširanje lozinki i izdavanje JWT-a 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"}
```

Lozinke su **heširane** (bcrypt) — nikada nisu pohranjene u otvorenom tekstu. Pri uspešnoj prijavi, **JWT** se izdaje: potpisani token koji nosi identitet korisnika i vrijeme isteka.

## Validacija tokena na zaštićenim rutama (dependency)

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

`get_current_user` dependency ekstraktuje i **verifikuje** JWT (potpis + isteklo vrijeme), učitava korisnika i injektuje se u zaštićene endpoint-e — bilo koja ruta koja zavisi od njega zahteva autentifikaciju.

## Autorizacija (uloge/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
```

## Zašto je bitno

Autentifikacija je esencijalna i **kritična za sigurnost** — gotovo svaki pravi API treba da zaštiti rute, a loša implementacija autentifikacije kreira ozbiljne sigurnosne ranjivosti.

Razumevanje FastAPI-jevog pristupa je važno: pruža gradivne blokove (`OAuth2PasswordBearer`, sigurnosne utility) za standardni **OAuth2-password-tok-sa-JWT** uzorak, koji elegantno leveraguje FastAPI-jeve jačine — endpoint prijave izdaje potpisani token, a **`get_current_user` dependency** ga validira, čisto štiteći bilo koju rutu koja zavisi od njega (idiomatski FastAPI auth uzorak).

Nekoliko aspekata je kritično da budu ispravna: **heširanje lozinki** (bcrypt, nikada otvoreni tekst, sa constant-time verifikacijom), **potpisivanje i verifikacija JWT-a** korektno (validacija potpisa + isteklog vremena), razlikovanje **autentifikacije** (ko si) od **autorizacije** (šta možeš raditi, preko uloga/scope provera), i čuvanje tajnog ključa.

Znanje kako da implementirate ovaj uzorak bezbedno — izdavanje tokena, validation dependency i autorizacija — je osnovna znanja na nivou seniora za pravljenje bezbednih FastAPI aplikacija, jer je autentifikacija i sveprisutna i česta izvor opasnih greške kada se implementira neispravno.