Kaip jūs įgyvendinite autentifikaciją (OAuth2/JWT)?

Question

Accepted Answer

FastAPI suteikia integruotus įrankius (`OAuth2PasswordBearer`, saugumo priemonės) autentifikacijai įgyvendinti, paprastai naudojant **OAuth2 slaptažodžio srautą su JWT žetonais**. Šis modelis sujungia žetono išdavimą (prisijungimą) su priklausomybe, kuri patikrina žetoną apsaugotose trasose.

## Slaptažodžių maišymas ir JWT išdavimas prisijungus

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

Slaptažodžiai **maišomi** (bcrypt) — niekada nesaugomi grynais tekstais. Galiojant prisijungimui, išduodamas **JWT**: pasirašytas žeton, kuriame yra vartotojo tapatybė ir galiojimo pabaiga.

## Žetono validavimas apsaugotose trasose (priklausomybė)

```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` priklausomybė ištraukia ir **patikrina** JWT (parašas + galiojimo pabaiga), įkrauna vartotoją ir yra injektuojama į apsaugotus galapunktus — bet kurią trasą, kuri nuo jos priklauso, reikalauja autentifikacijos.

## Autorizacija (vaidmenys/aprėptys)

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

## Kodėl tai svarbu

Autentifikacija yra esminė ir **svarbi saugumui** — beveik kiekviena tikra API turi apsaugoti trasas, o autentifikacijos klaida sukuria rimtas spragos.

Suprasti FastAPI požiūrį svarbu: jis suteikia statybinį bloką (`OAuth2PasswordBearer`, saugumo priemonės) standartiniam **OAuth2-slaptažodžio-srautui-su-JWT** modeliui, kuris elegantiškai panaudoja FastAPI stipriąsias puses — prisijungimo galapunktas išduoda pasirašytą žetoną, o **`get_current_user` priklausomybė** jį patikrina, švariai apsaugodama bet kurią trasą, kuri nuo jo priklauso (idiomatiški FastAPI autentifikacijos modelis).

Keli aspektai yra svarbūs teisingai įgyvendinti: **slaptažodžių maišymas** (bcrypt, ne grynasis tekstas, su pastovia verifikacijos laiku), **JWT pasirašymas ir patikrinimas** teisingai (parašas + galiojimo pabaigos patikrinimas), skyrimas tarp **autentifikacijos** (kas jūs esate) ir **autorizacijos** (ką galite daryti, per vaidmenų/aprėpčių patikras), ir slaptos rakto saugumo palaikymas.

Žinoti, kaip šį modelį saugiai įgyvendinti — žetono išdavimą, patikrinimo priklausomybę ir autorizaciją — yra pagrindinės aukštos klasės žinios saugioms FastAPI programoms kurti, nes autentifikacija yra visur paplitusi ir dažnas pavojingų klaidų šaltinis, kai jie yra neteisingai įgyvendinti.