Os ataques man-in-the-middle (MitM) representam uma ameaça significativa à segurança da web. Nestes ataques, um agente malicioso intercepta a comunicação entre um cliente e um servidor, permitindo-lhes escutar, manipular ou roubar dados. Este blog explorará como os ataques MitM funcionam no contexto de aplicativos JavaScript e fornecerá etapas práticas para proteger seu aplicativo contra essas ameaças.

O que é um ataque man-in-the-middle?

Um ataque Man-in-the-Middle ocorre quando um invasor intercepta e retransmite secretamente mensagens entre duas partes que acreditam estar se comunicando diretamente uma com a outra. Essa interceptação pode levar ao acesso não autorizado a dados confidenciais, como credenciais de login, informações financeiras e dados pessoais.

Como funcionam os ataques MitM

Os ataques MitM podem ser executados de várias maneiras, incluindo:

1. Falsificação de DNS: A falsificação de DNS envolve a alteração de registros DNS para redirecionar usuários para sites maliciosos.

Exemplo:
Suponha que você tenha implantado seu aplicativo Node.js e React em xyz.com. Um hacker pode manipular registros DNS para que, quando os usuários tentarem visitar xyz.com, sejam redirecionados para um site malicioso que parece idêntico ao seu.

Etapas para evitar falsificação de DNS:

• Use DNSSEC (Extensões de Segurança do Sistema de Nomes de Domínio) para adicionar uma camada extra de segurança.
• Monitore e atualize regularmente seus registros DNS.
• Use provedores de DNS confiáveis ​​que ofereçam recursos de segurança contra falsificação de DNS.

# Example of enabling DNSSEC on your domain using Cloudflare
# Visit your domain's DNS settings on Cloudflare
# Enable DNSSEC with a single click

2. Falsificação de IP
IP Spoofing envolve fingir ser um endereço IP confiável para interceptar o tráfego de rede.

Exemplo:
Um invasor pode falsificar o endereço IP do seu servidor para interceptar o tráfego entre seus clientes e seu servidor Node.js.

Etapas para evitar falsificação de IP:

• Implemente a lista de permissões de IP para permitir que apenas endereços IP confiáveis ​​se comuniquem com seu servidor.
• Use medidas de segurança em nível de rede, como VPNs e firewalls.
• Garanta a validação e filtragem adequadas de endereços IP em seu servidor.

// Example of IP whitelisting in Express.js
const express = require('express');
const app = express();

const allowedIPs = ['123.45.67.89']; // Replace with your trusted IPs

app.use((req, res, next) => {
  const clientIP = req.ip;
  if (!allowedIPs.includes(clientIP)) {
    return res.status(403).send('Forbidden');
  }
  next();
});

// Your routes here

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

3. Falsificação de HTTPS
A falsificação de HTTPS envolve a criação de certificados SSL falsos para se passar por um site seguro.

Exemplo:
Um invasor pode criar um certificado SSL falso para xyz.com e configurar um servidor malicioso que pareça idêntico ao seu servidor legítimo.

Etapas para evitar falsificação de HTTPS:

• Use a Transparência de Certificados para monitorar e registrar todos os certificados emitidos para seu domínio.
• Implemente a fixação de chave pública HTTP (HPKP) para associar a chave pública criptográfica do seu servidor web a um determinado conjunto de sites HTTPS.

// Example of implementing HPKP in Express.js
const helmet = require('helmet');
const app = express();

app.use(helmet.hpkp({
  maxAge: 60 * 60 * 24 * 90, // 90 days
  sha256s: ['yourPublicKeyHash1', 'yourPublicKeyHash2'], // Replace with your public key hashes
  includeSubDomains: true
}));

// Your routes here

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

4. Escuta Wi-Fi
A espionagem de Wi-Fi envolve a interceptação de dados transmitidos por redes Wi-Fi não seguras.

Exemplo:
Um hacker pode configurar um ponto de acesso Wi-Fi malicioso e interceptar dados transmitidos entre os usuários e seu servidor quando eles se conectam a ele.

Etapas para evitar espionagem de Wi-Fi:

• Incentive os usuários a se conectarem apenas a redes Wi-Fi seguras.
• Implemente criptografia ponta a ponta (E2EE) para proteger os dados transmitidos entre o cliente e o servidor.
• Use VPNs para criptografar o tráfego entre clientes e seu servidor.

// Example of enforcing HTTPS in Express.js
const express = require('express');
const app = express();

app.use((req, res, next) => {
  if (req.headers['x-forwarded-proto'] !== 'https') {
    return res.redirect(['https://', req.get('Host'), req.url].join(''));
  }
  next();
});

// Your routes here

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

Prevenindo ataques MitM em aplicativos JavaScript

1. Use HTTPS em qualquer lugar
Certifique-se de que todas as comunicações entre o cliente e o servidor sejam criptografadas usando HTTPS. Use ferramentas como Let's Encrypt para obter certificados SSL/TLS gratuitos.

// Enforce HTTPS in Express.js
const express = require('express');
const app = express();

app.use((req, res, next) => {
  if (req.headers['x-forwarded-proto'] !== 'https') {
    return res.redirect(['https://', req.get('Host'), req.url].join(''));
  }
  next();
});

// Your routes here

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

2. Validar certificados SSL/TLS
Use validação forte para certificados SSL/TLS e evite certificados autoassinados em produção.

3. Implementar Política de Segurança de Conteúdo (CSP)
Use cabeçalhos CSP para restringir as fontes das quais seu aplicativo pode carregar recursos, reduzindo o risco de injeção de script malicioso.

// Setting CSP headers in Express.js
const helmet = require('helmet');
app.use(helmet.contentSecurityPolicy({
  directives: {
    defaultSrc: ["'self'"],
    scriptSrc: ["'self'", 'trusted.com'],
    styleSrc: ["'self'", 'trusted.com']
  }
}));

4. Use cookies seguros
Certifique-se de que os cookies estejam marcados como Seguros e HttpOnly para evitar que sejam acessados ​​por meio de scripts do lado do cliente.

// Setting secure cookies in Express.js
app.use(require('cookie-parser')());
app.use((req, res, next) => {
  res.cookie('session', 'token', { secure: true, httpOnly: true });
  next();
});

5. Implementar HSTS (HTTP Strict Transport Security)
Use HSTS para forçar os navegadores a se comunicarem com seu servidor apenas por HTTPS.

// Setting HSTS headers in Express.js
const helmet = require('helmet');
app.use(helmet.hsts({
  maxAge: 31536000, // 1 year
  includeSubDomains: true,
  preload: true
}));

Os ataques man-in-the-middle podem ter consequências devastadoras para aplicações web, levando ao roubo de dados e ataques de injeção. Ao compreender como esses ataques funcionam e implementar medidas de segurança robustas, você pode proteger seus aplicativos JavaScript e garantir a segurança dos dados de seus usuários. Sempre use HTTPS, valide certificados SSL/TLS, implemente CSP, proteja cookies e aplique HSTS para mitigar os riscos de ataques MitM.