Hur implementerar du autentisering (OAuth2/JWT)?

Question

Accepted Answer

FastAPI tillhandahåller inbyggda verktyg (`OAuth2PasswordBearer`, security utilities) för att implementera autentisering, vanligtvis med hjälp av **OAuth2 password flow med JWT tokens**. Mönstret kombinerar tokenutgivning (login) med ett beroende som validerar token på skyddade routes.

## Hashning av lösenord och utgivning av JWT vid login

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

Lösenord är **hashade** (bcrypt) — aldrig lagrade i plaintext. Vid giltig login utfärdas en **JWT**: en signerad token som innehåller användarens identitet och utgångstid.

## Validering av token på skyddade routes (ett beroende)

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

Ett `get_current_user` beroende extraherar och **verifierar** JWT:en (signatur + utgångstid), laddar användaren, och injiceras i skyddade endpoints — alla routes som är beroende av det kräver autentisering.

## Auktorisering (roller/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
```

## Varför det är viktigt

Autentisering är väsentlig och **säkerhetskritisk** — nästan alla verkliga API:er behöver skydda routes, och felaktig autentisering skapar allvarliga säkerhetshål.

Att förstå FastAPI:s tillvagagångssätt är viktigt: det tillhandahåller byggstenarna (`OAuth2PasswordBearer`, security utilities) för standardmönstret **OAuth2-password-flow-with-JWT**, som på ett elegant sätt utnyttjar FastAPI:s styrkor — en login endpoint utfärdar en signerad token, och ett **`get_current_user` beroende** validerar den, vilket rent skyddar alla routes som är beroende av det (det idiomatiska FastAPI autentiseringsmönstret).

Flera aspekter är kritiska att få rätt: **hashning av lösenord** (bcrypt, aldrig plaintext, med konstant tidsverifiering), **signering och verifiering av JWT:er** på rätt sätt (signatur + utgångstidsvalidering), att skilja **autentisering** (vem du är) från **auktorisering** (vad du kan göra, via roll-/scope-kontroller), och att hålla hemlighetsnyckeln säker.

Att veta hur man implementerar detta mönster säkert — tokenutgivning, valideringsberoende och auktorisering — är fundamental kunskap på seniorsnivå för att bygga säkra FastAPI-applikationer, eftersom autentisering är både utbredd och en vanlig källa till farliga misstag när det implementeras felaktigt.