Como você implementa autenticação (OAuth2/JWT)?

Question

Accepted Answer

FastAPI fornece ferramentas integradas (`OAuth2PasswordBearer`, utilitários de segurança) para implementar autenticação, comumente usando **fluxo de senha OAuth2 com tokens JWT**. O padrão combina issuance de token (login) com uma dependência que valida o token em rotas protegidas.

## Hashing de senhas e issuance de JWT no 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"}
```

Senhas são **hasheadas** (bcrypt) — nunca armazenadas em plaintext. Em um login válido, um **JWT** é issuado: um token assinado carregando a identidade do usuário e uma expiração.

## Validando o token em rotas protegidas (uma dependência)

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

Uma dependência `get_current_user` extrai e **verifica** o JWT (assinatura + expiração), carrega o usuário, e é injetada em endpoints protegidos — qualquer rota dependendo dela requer autenticação.

## Autorização (roles/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
```

## Por que isso importa

Autenticação é essencial e **crítica para segurança** — praticamente toda API real precisa proteger rotas, e acertar auth errado cria vulnerabilidades sérias.

Entender a abordagem do FastAPI é importante: ele fornece os blocos de construção (`OAuth2PasswordBearer`, utilitários de segurança) para o padrão padrão **fluxo-de-senha-OAuth2-com-JWT**, que aproveita elegantemente os pontos fortes do FastAPI — um endpoint de login emite um token assinado, e uma **dependência `get_current_user`** valida-o, protegendo limpa qualquer rota que dependa dela (o padrão idiomático de auth do FastAPI).

Vários aspectos são críticos para acertar: **hashing de senhas** (bcrypt, nunca plaintext, com verificação de tempo constante), **assinatura e verificação de JWTs** corretas (validação de assinatura + expiração), distinguir **autenticação** (quem você é) de **autorização** (o que você pode fazer, via verificações de role/scope), e manter a chave secreta segura.

Saber como implementar este padrão com segurança — issuance de token, a dependência de validação, e autorização — é conhecimento fundamental de nível sênior para construir aplicações FastAPI seguras, pois auth é tanto onipresente quanto uma fonte frequente de erros perigosos quando implementado incorretamente.