Autenticação JWT: como proteger suas APIs de forma moderna

O que é JWT e por que você deveria se importar?

A anatomia de um token: desvendando o header, payload e signature

{
  "alg": "HS256",
  "typ": "JWT"
}

{
  "sub": "user-123",
  "name": "Laís",
  "admin": false,
  "exp": 1644768000
}

O fluxo de autenticação na prática: do login à validação

• Login do usuário: onde o user envia suas credenciais (ex: email e senha) para a sua API.

• Validação: o servidor verifica se as credenciais estão corretas no banco de dados.

• Geração do token: se tudo estiver certo, o servidor cria um JWT com as informações do usuário no payload e o assina com a chave secreta.

• Envio ao cliente: o servidor retorna o JWT para a aplicação cliente (o navegador ou app mobile).

• Armazenamento: o cliente armazena esse token de forma segura.

• Requisições futuras: para cada requisição a uma rota protegida, o cliente envia o JWT no cabeçalho Authorization, geralmente no formato Bearer <token>.

• Verificação no servidor: a cada requisição recebida, o servidor pega o token, verifica sua assinatura para garantir que ele é autêntico e não foi modificado. Se a assinatura for válida e o token não tiver expirado, o acesso é liberado.

JWT vs Sessões: a batalha pela autenticação moderna

Implementando autenticação JWT

// Exemplo de código no momento do login
const jwt = require('jsonwebtoken');
const bcrypt = require('bcrypt');

// Suponha que você já validou o usuário e a senha
// user.id e user.name viriam do seu banco de dados
async function handleLogin(req, res) {
  const { email, password } = req.body;
  
  // Lógica para encontrar o usuário e validar a senha com bcrypt...
  const user = { id: 'user-123', name: 'Rodrigo' }; // Exemplo de usuário
  
  // Se as credenciais estiverem corretas:
  const payload = { userId: user.id, name: user.name };
  const secret = process.env.JWT_SECRET; // Guarde seu segredo em variáveis de ambiente!
  const options = { expiresIn: '900000ms' }; // Token expira em 15 minutos

  const token = jwt.sign(payload, secret, options);
  
  res.json({ accessToken: token });
}

// middleware/authenticateToken.js
const jwt = require('jsonwebtoken');

function authenticateToken(req, res, next) {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1]; // Formato "Bearer TOKEN"

  if (token == null) {
    return res.sendStatus(401); // Se não há token, não autorizado
  }

  jwt.verify(token, process.env.JWT_SECRET, (err, user) => {
    if (err) {
      return res.sendStatus(403); // Se o token não for válido, acesso proibido
    }
    
    // O payload decodificado é adicionado ao objeto da requisição
    req.user = user; 
    next(); // Passa para a próxima função (o controller da rota)
  });
}

// Em seu arquivo de rotas:
// app.get('/perfil', authenticateToken, (req, res) => { ... });

Como não deixar brechas no seu JWT

Onde guardar o token? A treta do localStorage vs HttpOnly cookies

• localStorage: é a forma mais simples. O JavaScript do seu front-end pode acessar e enviar o token facilmente. O problema: vulnerável a ataques de Cross-Site Scripting (XSS). Se um invasor injetar um script malicioso na sua página, ele pode roubar o token.

• HttpOnly cookies: são cookies que não podem ser acessados via JavaScript. O navegador os anexa automaticamente a cada requisição ao seu domínio. Isso mitiga o risco de roubo de token por XSS. O problema: requer proteção contra ataques de Cross-Site Request Forgery (CSRF).

A importância dos refresh tokens para uma segurança duradoura

1. No login, o servidor gera dois tokens: um access token (curto) e um refresh token (longo, ex: 7 dias).

2. O access token é usado para acessar as rotas protegidas.

3. Quando o access token expira, o cliente usa o refresh token para solicitar um novo access token em um endpoint específico (ex: /refresh_token), sem precisar das credenciais do usuário novamente.

Vulnerabilidades comuns e como se defender

• Algoritmo none: alguns servidores aceitavam tokens com o algoritmo de assinatura definido como "none". Um invasor poderia simplesmente remover a assinatura e acessar o sistema. Mitigação: Sua biblioteca de validação deve ter uma lista de algoritmos permitidos (ex: ['HS256', 'RS256']).

• Chaves Secretas Fracas: se sua chave secreta for "123456", ela pode ser quebrada por força bruta. Mitigação: Use segredos longos, complexos e aleatórios, e guarde-os em variáveis de ambiente, nunca no código.

• Vazamento de Informações no Payload: lembre-se, o payload é visível. Mitigação: Nunca coloque dados sensíveis nele.

E agora? Dando o próximo passo na sua jornada com APIs

Perguntas frequentes (FAQ)

• É possível invalidar (fazer logout) um JWT antes que ele expire? Por serem stateless, não há uma forma direta no servidor. A abordagem mais comum é criar uma "blocklist" (lista de bloqueio) em um banco de dados rápido como o Redis. Antes de validar um token, você verifica se ele não está nessa lista.

• JWT é o mesmo que OAuth? Não. OAuth 2.0 é um protocolo de autorização (para delegar acesso), enquanto JWT é um formato de token. Eles são frequentemente usados juntos: um servidor OAuth pode emitir JWTs como tokens de acesso.

• Devo usar HS256 ou RS256? HS256 (simétrico) usa a mesma chave para assinar e verificar. É mais simples. RS256 (assimétrico) usa um par de chaves (privada para assinar, pública para verificar). É ideal quando a verificação precisa ser feita por um serviço diferente do que emitiu o token, comum em microsserviços.