Si e zbatoni autentifikimin (OAuth2/JWT)?

Question

Accepted Answer

FastAPI ofron mjete të ndërtuar në brendësi (`OAuth2PasswordBearer`, utilitete sigurie) për zbatimin e autentifikimit, zakonisht duke përdorur **rrjedhen e fjalëkalimit OAuth2 me token JWT**. Modeli kombinon emetimin e token-it (hyrje) me një varësi që valikon token-in në rrugë të mbrojtura.

## Hashimi i fjalëkalimeve dhe emetimi i një JWT në hyrje

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

Fjalëkalimet janë **hashuar** (bcrypt) — asnjëherë nuk ruhen në tekst të qartë. Gjatë hyrjes së vlefshme, lëshon një **JWT**: një token i nënshkruar që mban identitetin e përdoruesit dhe një afat skadimi.

## Validimi i token-it në rrugë të mbrojtura (një varësi)

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

Një varësi `get_current_user` nxjerr dhe **verifikon** JWT-në (nënshkrimi + afati skadimi), ngarkon përdoruesin, dhe futet në end-point të mbrojtur — çdo rrugë që varet nga ajo kërkon autentifikim.

## Autorizimi (role/scope-t)

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

## Pse është i rëndësishëm

Autentifikimi është thelbësor dhe **kritik për sigurinë** — pothuajse çdo API i vërtetë duhet të mbrojë rrugë, dhe nëse autentifikimi bëhet gabim krijon vlerësime të rrezikshme.

Kuptimi i qasjes të FastAPI është i rëndësishëm: ai ofron blloqet ndërtimore (`OAuth2PasswordBearer`, utilitete sigurie) për modelin standart **OAuth2-password-flow-with-JWT**, i cili përdor në mënyrë elegante forcat e FastAPI — një end-point hyrjeje lëshon një token të nënshkruar, dhe një **varësi `get_current_user`** e valikon atë, duke mbrojtur në mënyrë të pastër çdo rrugë që varet nga ajo (modeli idomjatik i autentifikimit FastAPI).

Disa aspekte janë kritike për të bërë saktë: **hashimi i fjalëkalimeve** (bcrypt, asnjëherë tekst në qartë, me verifikim konstant-kohë), **nënshkrimi dhe verifikimi i JWT-ve** në mënyrë korrekte (nënshkrimi + validim afati skadimi), dallimi **i autentifikimit** (kush je) nga **autorizimi** (çka mund të bësh, përmes kontrolleve rol/scope), dhe mbajtja e çelësit të fshehtë në siguri.

Mbetja e dijë se si ta zbatosh këtë model në mënyrë të sigurt — emetimin e token-it, varësinë e validimit, dhe autorizimin — është njohuri themelore e nivelit senior për ndërtimin e aplikacioneve të sigurta FastAPI, sepse autentifikimi është njëkohësisht i përhapshëm dhe një burim i shpeshtë i gabimesh të rrezikshme kur zbatohej në mënyrë të pasaktë.