Bot detection e proteção contra scraping malicioso

1. Introdução ao Problema: Por que Bots e Scraping são Ameaças Reais

1.1. Diferença entre bots legítimos e maliciosos

Nem todo bot é um vilão. Bots legítimos, como Googlebot, Bingbot e monitoramento de uptime (ex: Pingdom), seguem regras de robots.txt, respeitam rate limits e trazem benefícios como indexação de conteúdo. Já os bots maliciosos operam fora dessas regras: scrapers que copiam seu banco de dados, bots de credential stuffing que testam senhas vazadas, e crawlers que consomem recursos para concorrência desleal.

1.2. Impactos no negócio

O scraping malicioso pode causar:
- Roubo de dados: preços, descrições de produtos, conteúdo exclusivo
- Degradação de performance: milhares de requisições simultâneas sobrecarregam servidores
- Fraudes: bots criam contas falsas, realizam ataques de força bruta
- Concorrência desleal: concorrentes copiam seu catálogo inteiro em minutos

1.3. Desafios técnicos

Os desafios incluem escalabilidade dos ataques (redes de bots com milhares de IPs), evasão de bloqueios (rotação constante de proxies) e falsos positivos (bloquear usuários reais acidentalmente).

2. Anatomia de um Bot Malicioso: Como Eles Operam

2.1. Técnicas de evasão comuns

Bots modernos usam:
- Rotação de IPs: proxies residenciais, VPNs, redes Tor
- Spoofing de User-Agent: imitam navegadores reais (Chrome 120, Firefox 121)
- Cabeçalhos falsificados: Accept-Language, Referer, Accept-Encoding

2.2. Comportamento não-humano

Padrões que denunciam bots:
- Taxas de requisição anormais (100 requisições/segundo)
- Navegação linear sem pausas para leitura
- Cliques em coordenadas exatas (sem variação natural)
- Ausência de movimentos de mouse ou scroll

2.3. Headless browsers e automação

Ferramentas como Puppeteer e Selenium permitem simular interação real, mas deixam rastros:
- Propriedades específicas do navegador headless detectáveis via JavaScript
- WebDriver ativado (navigator.webdriver === true)
- Canvas fingerprinting revela diferenças de renderização

3. Camadas de Detecção: Do Básico ao Avançado

3.1. Análise de tráfego em tempo real

Camada básica de defesa:
- Rate limiting por IP (ex: 100 requisições/minuto)
- Geolocalização suspeita (acessos de múltiplos países em segundos)
- Assinaturas de rede (mesmo ASN para milhares de requisições)

3.2. Fingerprinting de cliente

Técnicas avançadas no lado do cliente:
- Canvas fingerprint: diferenças na renderização de texto e formas
- WebGL: variações no renderizador gráfico
- Fontes instaladas: lista única de fontes do sistema
- Resolução de tela, profundidade de cor, plugins

3.3. Machine learning para classificação

Modelos comportamentais analisam:
- Tempo entre cliques (humano: 100-500ms, bot: exatos 200ms)
- Movimento de mouse (curvas suaves vs. linhas retas)
- Padrões de scroll (humano: irregular, bot: linear)
- Sequência de páginas acessadas

4. Implementação Prática com Middleware e APIs

4.1. Exemplo de middleware Node.js

const suspiciousHeaders = (req, res, next) => {
  const userAgent = req.headers['user-agent'] || '';
  const accept = req.headers['accept'] || '';
  const acceptLanguage = req.headers['accept-language'] || '';

  // Bloqueia User-Agent vazio ou genérico demais
  if (!userAgent || userAgent === 'Mozilla/5.0') {
    return res.status(403).json({ error: 'Acesso negado' });
  }

  // Bloqueia falta de Accept-Language (navegadores sempre enviam)
  if (!acceptLanguage) {
    return res.status(403).json({ error: 'Acesso negado' });
  }

  // Bloqueia Accept vazio ou muito genérico
  if (!accept || accept === '*/*') {
    return res.status(403).json({ error: 'Acesso negado' });
  }

  next();
};

app.use('/api', suspiciousHeaders);

4.2. Integração com CAPTCHA

CAPTCHA como camada progressiva:

// Exemplo com reCAPTCHA v3 (score-based)
app.post('/api/login', async (req, res) => {
  const { token } = req.body;
  const verification = await verifyRecaptcha(token);

  if (verification.score < 0.5) {
    // Provável bot: exigir reCAPTCHA v2 (checkbox)
    return res.json({ requireCaptcha: true });
  }

  // Score > 0.5: provável humano, prossegue
  res.json({ success: true });
});

4.3. API Gateway + WAF

Regras customizadas em Cloudflare ou AWS WAF:

# AWS WAF Rule - Bloquear padrões de scraping
{
  "Name": "BlockScrapingPatterns",
  "Priority": 1,
  "Statement": {
    "RateBasedStatement": {
      "Limit": 100,
      "AggregateKeyType": "IP"
    }
  },
  "Action": { "Block": {} }
}

5. Proteção Contra Scraping de Dados Sensíveis

5.1. Tokens efêmeros e HMAC

Assinatura de requisições:

// Geração de token HMAC com timestamp
const generateToken = (userId, endpoint) => {
  const timestamp = Date.now();
  const data = `${userId}:${endpoint}:${timestamp}`;
  const hash = crypto.createHmac('sha256', SECRET_KEY).update(data).digest('hex');
  return `${timestamp}.${hash}`;
};

// Verificação no middleware
const verifyToken = (req, res, next) => {
  const token = req.headers['x-api-token'];
  if (!token) return res.status(401).json({ error: 'Token ausente' });

  const [timestamp, hash] = token.split('.');
  if (Date.now() - parseInt(timestamp) > 60000) { // 1 minuto
    return res.status(401).json({ error: 'Token expirado' });
  }
  next();
};

5.2. Paginação com rate limits

// Rate limit por sessão em endpoints de listagem
const paginationRateLimit = rateLimit({
  windowMs: 60 * 1000, // 1 minuto
  max: 30, // 30 requisições de paginação
  keyGenerator: (req) => req.session.userId || req.ip,
  message: { error: 'Limite de paginação excedido' }
});

app.use('/api/products', paginationRateLimit);

5.3. Honeypots e traps

Links invisíveis para enganar scrapers:

<!-- Link honeypot invisível para humanos -->
<a href="/api/admin/export" 
   style="display:none; position:absolute; left:-9999px"
   rel="nofollow">Exportar dados</a>

// Middleware que bloqueia quem acessa o honeypot
app.get('/api/admin/export', (req, res) => {
  // Se chegou aqui via link invisível, é bot
  logger.warn(`Bot detectado: ${req.ip} acessou honeypot`);
  blacklistIP(req.ip);
  res.status(403).json({ error: 'Acesso negado' });
});

6. Estratégias de Resposta e Mitigação Gradual

6.1. Resposta progressiva

Escada de ações:
1. Logging: registrar requisições suspeitas
2. Alerta: notificar equipe de segurança
3. Desafio: servir CAPTCHA ou desafio JavaScript
4. Degradação: servir dados incompletos ou atrasar respostas
5. Bloqueio temporário: 429 Too Many Requests por 15 minutos
6. Bloqueio permanente: 403 Forbidden + blacklist

6.2. Técnicas de degradação

// Degradação gradual para scrapers
if (requestCount > threshold) {
  if (requestCount > threshold * 2) {
    return res.status(429).json({ error: 'Muitas requisições' });
  }
  // Atraso artificial de 2-5 segundos
  await new Promise(resolve => setTimeout(resolve, 2000));
  return res.json(incompleteData); // Dados parciais
}

6.3. Análise forense e SIEM

Logs estruturados para análise:

{
  "timestamp": "2024-01-15T10:30:00Z",
  "ip": "203.0.113.5",
  "userAgent": "Mozilla/5.0 (compatible; Googlebot/2.1)",
  "endpoint": "/api/products",
  "statusCode": 429,
  "reason": "rate_limit_exceeded",
  "fingerprint": "canvas_hash_abc123",
  "country": "US",
  "asn": "AS15169"
}

7. Considerações sobre Falsos Positivos e Manutenção

7.1. Estratégias de whitelist

Manter whitelist para:
- IPs de parceiros e integrações legítimas
- CDNs e serviços de monitoramento
- Ferramentas de SEO (Ahrefs, SEMrush) com autenticação
- Crawlers de acessibilidade e testes

7.2. Monitoramento contínuo

Dashboards com métricas:
- Taxa de bloqueio vs. tráfego humano real
- Falsos positivos reportados por usuários
- Precisão dos modelos de ML
- Tendências de novos padrões de ataque

7.3. Atualização de assinaturas e modelos

Manutenção contínua:
- Atualizar listas de User-Agent suspeitos
- Re-treinar modelos de ML com novos dados
- Ajustar thresholds de rate limiting baseado em sazonalidade
- Testar contra novas ferramentas de automação

Referências