Introdução:

JSON Web Tokens (JWT) são amplamente usados ​​para proteger a autenticação de API e a troca de dados. No entanto, a implementação e o manuseio inadequados podem expor vulnerabilidades que levam à falsificação de tokens e à manipulação de dados. Neste blog, exploraremos pontos fracos comuns do JWT, exemplos reais de ataques e práticas recomendadas para mitigar esses riscos.

O que é JWT?

JWT é um meio compacto e seguro para URL de representar reivindicações a serem transferidas entre duas partes. Consiste em três partes: Cabeçalho, Carga útil e Assinatura, codificadas em Base64.

Estrutura JWT:

{
  "header": {
    "alg": "HS256",
    "typ": "JWT"
  },
  "payload": {
    "sub": "1234567890",
    "name": "John Doe",
    "iat": 1516239022
  },
  "signature": "SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"
}

Vulnerabilidades comuns do JWT:

1. Ataque de confusão de algoritmo:
Os invasores podem explorar algoritmos fracos ou alterar o algoritmo no cabeçalho do token para nenhum, levando à falsificação do token.

Exemplo:

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

Mitigação:
Sempre valide o parâmetro alg no lado do servidor e rejeite tokens com "nenhum" ou algoritmos fracos.

Implementação segura:

const jwt = require('jsonwebtoken');
const payload = {
  sub: "1234567890",
  name: "John Doe"
};
const secret = 'your-256-bit-secret';
const token = jwt.sign(payload, secret, { algorithm: 'HS256' });

jwt.verify(token, secret, { algorithms: ['HS256'] }, function(err, decoded) {
  if (err) throw new Error('Token verification failed');
  console.log(decoded);
});

2. Ataque de injeção de chave:
Os invasores podem manipular a carga para incluir uma nova chave, levando ao acesso não autorizado.

Exemplo:

{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
}

Mitigação:
Certifique-se de que as reivindicações sejam devidamente validadas e que informações confidenciais não sejam armazenadas na carga útil.

Implementação segura:

const payload = {
  sub: "1234567890",
  name: "John Doe"
};

const token = jwt.sign(payload, secret, { algorithm: 'HS256' });

jwt.verify(token, secret, function(err, decoded) {
  if (err) throw new Error('Token verification failed');
  if (decoded.admin) throw new Error('Unauthorized access');
  console.log(decoded);
});

3. Chave secreta fraca:
Usar chaves secretas fracas ou previsíveis pode levar a ataques de força bruta.

Mitigação:
Use chaves secretas fortes e geradas aleatoriamente e alterne-as regularmente.

Implementação segura:

const crypto = require('crypto');
const secret = crypto.randomBytes(64).toString('hex');

const token = jwt.sign(payload, secret, { algorithm: 'HS256' });

jwt.verify(token, secret, function(err, decoded) {
  if (err) throw new Error('Token verification failed');
  console.log(decoded);
});

Exemplo completo de implementação segura de JWT:

Aqui está um exemplo completo de como implementar JWT com segurança em um aplicativo Node.js:

Etapa 1: instalar dependências

npm install jsonwebtoken express body-parser

Etapa 2: Crie um servidor simples

const express = require('express');
const bodyParser = require('body-parser');
const jwt = require('jsonwebtoken');
const crypto = require('crypto');

const app = express();
app.use(bodyParser.json());

const secret = crypto.randomBytes(64).toString('hex');

app.post('/login', (req, res) => {
  const { username, password } = req.body;

  // Authenticate user (dummy check for example)
  if (username === 'user' && password === 'pass') {
    const payload = { username };
    const token = jwt.sign(payload, secret, { algorithm: 'HS256', expiresIn: '1h' });
    res.json({ token });
  } else {
    res.status(401).json({ message: 'Invalid credentials' });
  }
});

app.get('/protected', (req, res) => {
  const token = req.headers['authorization'];

  if (!token) return res.status(403).json({ message: 'No token provided' });

  jwt.verify(token, secret, { algorithms: ['HS256'] }, (err, decoded) => {
    if (err) return res.status(500).json({ message: 'Failed to authenticate token' });

    res.json({ message: 'Access granted', user: decoded });
  });
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

Melhores práticas para implementação segura de JWT:

• Use algoritmos fortes: prefira RS256 ou ES256 em vez de HS256 para melhor segurança.
• Validar expiração do token: sempre verifique a declaração de exp para garantir que o token não expirou.
• Armazene segredos com segurança: mantenha as chaves secretas em um local seguro, como variáveis ​​de ambiente ou cofres seguros.
• Implemente o tratamento adequado de erros: evite expor mensagens de erro confidenciais que possam ajudar os invasores.
• Use HTTPS: certifique-se de que todas as comunicações sejam feitas por HTTPS para evitar a interceptação de token.

Conclusão:

Compreender e mitigar as vulnerabilidades do JWT é crucial para manter a segurança de seus aplicativos. Seguindo as práticas recomendadas e lidando adequadamente com JWTs, você pode evitar a falsificação de tokens e a manipulação de dados, garantindo uma segurança robusta da API.

Proteja suas APIs agora implementando estas práticas recomendadas para proteção contra vulnerabilidades JWT!