Bypass da proteção PerimeterX e Akamai: métodos práticos de anti-detect

PerimeterX e Akamai Bot Manager são duas das soluções mais avançadas para proteção contra bots, utilizadas pelas maiores plataformas de e-commerce, serviços financeiros e sites corporativos. Esses sistemas analisam centenas de parâmetros do navegador, comportamento do usuário e características da rede, criando uma proteção em camadas que não pode ser contornada simplesmente trocando o endereço IP.

Neste guia, vamos detalhar a arquitetura de ambos os sistemas, estudar seus métodos de detecção e criar uma estratégia abrangente de contorno, baseada em casos reais e experimentos técnicos.

Arquitetura do PerimeterX e Akamai: como funciona a detecção

PerimeterX (agora HUMAN Security) e Akamai Bot Manager funcionam como sistemas de proteção em múltiplas camadas, integrando-se em diferentes etapas do processamento da solicitação. Compreender sua arquitetura é crucial para desenvolver uma estratégia de contorno.

Arquitetura do PerimeterX

O PerimeterX opera em três etapas. Na primeira etapa, um sensor JavaScript é injetado na página HTML e executado no navegador do cliente, coletando dados sobre o ambiente de execução: impressão digital WebGL, impressão digital Canvas, contexto de áudio, fontes disponíveis, plugins, resolução de tela e muitos outros parâmetros. Este sensor é ofuscado e atualizado regularmente, dificultando sua análise.

Na segunda etapa, o componente do servidor do PerimeterX analisa os cabeçalhos HTTP, a impressão digital TLS, a reputação do IP e as características da rede antes mesmo de a solicitação atingir o aplicativo principal. O sistema utiliza um banco de dados próprio de bots conhecidos e IPs suspeitos, atualizado em tempo real.

A terceira etapa é a análise comportamental. O PerimeterX monitora os movimentos do mouse, a velocidade de rolagem, os padrões de cliques, o tempo entre ações e constrói um perfil de comportamento. Modelos de aprendizado de máquina comparam esse perfil com padrões de usuários reais e bots conhecidos.

Arquitetura do Akamai Bot Manager

O Akamai Bot Manager se integra no nível CDN, o que lhe confere uma vantagem em termos de velocidade de análise. O sistema utiliza sua própria tecnologia BMP (Bot Manager Premier), que analisa as solicitações nos servidores de borda da Akamai antes mesmo de serem enviadas ao servidor de origem.

A principal diferença do Akamai é o uso de telemetria de milhões de sites protegidos por sua CDN. Isso permite que o sistema identifique rapidamente novos tipos de bots e atualize as regras de detecção globalmente. O Akamai também utiliza uma tecnologia Web SDK, semelhante ao sensor do PerimeterX, mas com foco na verificação criptográfica da integridade do cliente.

Métodos de detecção: o que os sistemas de proteção analisam

Sistemas modernos de anti-bots analisam solicitações com base em centenas de parâmetros, agrupados em várias categorias. Compreender cada categoria permite eliminar sistematicamente os marcadores de automação.

Análise de cabeçalhos HTTP e TLS

A ordem dos cabeçalhos HTTP é uma das maneiras mais simples de detecção. Os navegadores enviam cabeçalhos em uma ordem estritamente definida, que varia entre versões e fabricantes. Bibliotecas como requests em Python ou axios em Node.js utilizam sua própria ordem, revelando instantaneamente a automação.

A impressão digital TLS (impressão digital JA3) é criada a partir dos parâmetros do handshake TLS: versão TLS, lista de cifras suportadas, extensões e sua ordem. Cada combinação de navegador e sistema operacional cria uma impressão digital única. Por exemplo, o Chrome 120 no Windows 11 tem uma impressão digital diferente do Chrome 120 no macOS ou do Firefox no mesmo sistema.

// Exemplo de incompatibilidade entre User-Agent e impressão digital TLS
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0
TLS Fingerprint: hash JA3 corresponde a Python requests
// Resultado: bloqueio instantâneo

Ambiente de execução JavaScript

Navegadores headless deixam dezenas de rastros no ambiente JavaScript. Propriedades como navigator.webdriver, a presença de objetos window.chrome, inconsistências em navigator.plugins, anomalias em WebGL e Canvas rendering são verificadas.

PerimeterX e Akamai utilizam técnicas avançadas de verificação: medem o tempo de execução de funções JavaScript (em navegadores headless esse tempo é diferente), verificam a presença de artefatos de automação no DOM e analisam a pilha de chamadas de funções. Os sistemas também verificam a consistência dos dados — por exemplo, se o User-Agent indica um dispositivo móvel, mas navigator.maxTouchPoints é igual a 0, isso aciona a detecção.

Características da rede e reputação do IP

Os sistemas de proteção verificam o endereço IP com base em vários parâmetros: pertencimento a provedores de proxy conhecidos, presença em listas negras, histórico de atividade desse IP, consistência da geolocalização com outros parâmetros da solicitação (idioma do navegador, fuso horário).

A atenção especial é dada aos padrões de uso do IP. Se solicitações de um único endereço vêm com diferentes User-Agents ou impressões digitais de navegador, isso é um forte sinal de automação. Da mesma forma, se o IP muda com muita frequência dentro de uma única sessão (rotação agressiva de proxies), isso aciona o bloqueio.

Impressão digital do navegador e impressões digitais TLS

A impressão digital do navegador é uma técnica para criar um identificador único do navegador com base em suas características. Mesmo sem cookies, os sistemas de proteção podem rastrear usuários e identificar anomalias.

Impressão digital Canvas e WebGL

A impressão digital Canvas funciona renderizando uma imagem invisível com texto e gráficos. Devido a diferenças em drivers gráficos, fontes e configurações de anti-aliasing, cada sistema cria uma imagem ligeiramente diferente. O hash dessa imagem se torna parte da impressão digital.

A impressão digital WebGL utiliza renderização 3D para criar uma impressão digital ainda mais única. O sistema solicita informações sobre a GPU, extensões suportadas, tamanhos máximos de texturas e outros parâmetros. A combinação desses dados cria uma impressão digital com entropia suficiente para identificar o dispositivo.

// Exemplo de obtenção de impressão digital WebGL
const canvas = document.createElement('canvas');
const gl = canvas.getContext('webgl');
const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
const vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);

// O resultado pode ser: "Google Inc. (NVIDIA)" + "ANGLE (NVIDIA GeForce RTX 3080)"
// Combinação única para cada dispositivo

Contexto de áudio e fontes

A API de Contexto de Áudio permite criar uma impressão digital única com base no processamento de áudio. Diferenças na pilha de áudio do sistema operacional levam a diferenças microscópicas no processamento do sinal de áudio, que podem ser medidas e usadas para identificação.

A lista de fontes instaladas também é única para cada sistema. Os sistemas de proteção utilizam a técnica de medir tamanhos de texto com diferentes fontes — se a fonte não estiver instalada, o navegador usa uma alternativa, o que altera os tamanhos. Verificar centenas de fontes cria uma assinatura única.

Impressões digitais TLS e HTTP/2

A impressão digital JA3 é criada a partir dos parâmetros do TLS Client Hello: versão SSL/TLS, lista de suites de cifras, lista de extensões, lista de grupos elípticos suportados, formatos de pontos de curvas elípticas. Esses parâmetros são concatenados e hashados, criando uma string única.

A impressão digital HTTP/2 analisa os parâmetros do frame SETTINGS, a ordem e as prioridades dos fluxos, os valores de atualização da janela. Cada navegador utiliza configurações únicas de HTTP/2, o que permite identificar o cliente mesmo com uma impressão digital TLS correta.

Análise comportamental e aprendizado de máquina

A análise comportamental é o aspecto mais difícil de contornar dos sistemas modernos de anti-bots. Mesmo com uma impressão digital técnica perfeita, um comportamento não humano revelará a automação.

Análise de movimentos do mouse e interações

PerimeterX e Akamai monitoram as trajetórias dos movimentos do mouse, aceleração e desaceleração, micro-movimentos característicos da mão humana. Bots geralmente movem o cursor em linhas retas ou não geram eventos de mouse. Os sistemas também analisam o tempo de reação — um clique logo após o carregamento da página sem movimento do mouse parece suspeito.

Os padrões de rolagem também são únicos. Um humano rola a página de forma desigual: rapidamente no início, desacelera para ler, às vezes rola para trás. Bots geralmente rolam a uma velocidade constante ou usam window.scrollTo() para rolagem instantânea.

Padrões temporais e velocidade das ações

O tempo entre as ações é um parâmetro crítico. Um humano não pode preencher um formulário de 10 campos em 0,5 segundos ou clicar em 50 links em um minuto. Os sistemas de proteção constroem um perfil de velocidade para cada tipo de ação e o comparam com o comportamento do usuário.

A atenção especial é dada à consistência dos atrasos. Se entre cada clique passa exatamente 2 segundos, isso é um sinal óbvio de sleep(2000) no código. Atrasos humanos têm variabilidade natural e seguem certas distribuições estatísticas.

Modelos de aprendizado de máquina

Ambos os sistemas utilizam modelos de ML treinados em milhões de sessões de usuários reais e bots conhecidos. Os modelos analisam centenas de características simultaneamente: sequência de ações, profundidade de visualização do site, padrões de navegação, interação com elementos.

O PerimeterX utiliza um conjunto de modelos com diferentes pesos para diferentes tipos de sites. O modelo para e-commerce foca nos padrões de compras, enquanto o modelo para sites de mídia foca nos padrões de leitura de conteúdo. Isso torna o contorno mais difícil, pois requer adaptação à especificidade de cada site.

// Exemplo de atrasos humanoides com variabilidade
function humanDelay(baseMs) {
  // Distribuição log-normal em vez de uniforme
  const variance = baseMs * 0.3;
  const delay = baseMs + (Math.random() - 0.5) * variance;
  // Adicionando micro-atrasos característicos do processamento de eventos pelo navegador
  const microDelay = Math.random() * 50;
  return Math.max(100, delay + microDelay);
}

// Uso: await new Promise(r => setTimeout(r, humanDelay(2000)));

Estratégia de escolha e rotação de proxies

A escolha do tipo de proxy e da estratégia de rotação é crucial ao trabalhar com PerimeterX e Akamai. Uma configuração incorreta de proxies pode anular todos os esforços para mascarar a impressão digital do navegador.

Proxies residenciais vs móveis vs de datacenter

Proxies de datacenter têm o menor custo, mas também o maior risco de detecção. PerimeterX e Akamai mantêm bancos de dados de endereços IP de datacenters e aumentam automaticamente o nível de verificação para tais solicitações. O uso de proxies de datacenter é possível apenas para tarefas de baixa prioridade ou em combinação com uma impressão digital de navegador de alta qualidade.

Proxies residenciais utilizam endereços IP de provedores de internet reais, o que reduz significativamente a probabilidade de detecção. No entanto, a qualidade dos proxies residenciais varia muito. É importante escolher provedores com pools de IP limpos, onde os endereços não foram usados anteriormente para spam ou outras atividades suspeitas.

Proxies móveis oferecem o mais alto nível de confiança, pois utilizam endereços IP de operadoras móveis. Esses endereços geralmente são compartilhados entre muitos usuários (NAT de nível de operadora), o que dificulta o bloqueio. Proxies móveis são especialmente eficazes contra o Akamai, que é mais cauteloso ao bloquear tráfego móvel.

Estratégias de rotação

A rotação agressiva (troca de IP a cada solicitação) é um erro comum. Isso cria um padrão suspeito: um único usuário não pode fisicamente mudar de endereço IP a cada poucos segundos. A rotação de sessão é mais eficaz, onde um IP é usado para toda a sessão do usuário (10-30 minutos de atividade).

Para operações prolongadas, recomenda-se sessões fixas com duração de 30-60 minutos. Isso imita o comportamento de um usuário real, que permanece em um único IP durante a sessão. É importante não usar um único IP por muito tempo — sessões que duram várias horas também parecem suspeitas.

Consistência geográfica

É crucial garantir a correspondência entre a geolocalização do endereço IP e outros parâmetros: idioma do navegador, fuso horário, configurações de localidade. Se o endereço IP for da Alemanha, mas navigator.language retornar "en-US", e o fuso horário "America/New_York" — isso é um gatilho instantâneo de detecção.

Ao trabalhar com várias regiões geográficas, use perfis de navegador separados para cada região. Alternar entre regiões dentro de uma única sessão (IP da França, depois do Japão) é impossível para um usuário real e é imediatamente detectado.

Configuração de navegadores e ferramentas anti-detect

A configuração correta das ferramentas de automação é um fator chave para o sucesso do contorno do PerimeterX e do Akamai. Mesmo os melhores proxies não ajudarão se a impressão digital do navegador contiver marcadores óbvios de automação.

Playwright e Puppeteer: configuração avançada

A instalação básica do Playwright ou Puppeteer cria um navegador headless óbvio. É necessário usar plugins stealth e configuração adicional para mascarar a automação. A biblioteca puppeteer-extra-plugin-stealth oculta os principais marcadores, mas requer configuração adicional.

// Configuração avançada do Playwright com anti-detect
const { chromium } = require('playwright-extra');
const stealth = require('puppeteer-extra-plugin-stealth')();

chromium.use(stealth);

const browser = await chromium.launch({
  headless: false, // O modo headless é facilmente detectável
  args: [
    '--disable-blink-features=AutomationControlled',
    '--disable-features=IsolateOrigins,site-per-process',
    '--disable-site-isolation-trials',
    '--no-sandbox',
    '--disable-setuid-sandbox',
    '--disable-dev-shm-usage',
    '--disable-accelerated-2d-canvas',
    '--disable-gpu',
    '--window-size=1920,1080',
    '--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
  ]
});

const context = await browser.newContext({
  viewport: { width: 1920, height: 1080 },
  locale: 'en-US',
  timezoneId: 'America/New_York',
  permissions: ['geolocation', 'notifications'],
  geolocation: { latitude: 40.7128, longitude: -74.0060 }
});

Selenium com undetected-chromedriver

O Selenium WebDriver padrão é facilmente detectável através da propriedade navigator.webdriver. A biblioteca undetected-chromedriver automaticamente patcha o ChromeDriver, removendo os principais marcadores de automação e é atualizada regularmente para contornar novos métodos de detecção.

import undetected_chromedriver as uc
from selenium.webdriver.chrome.options import Options

options = Options()
options.add_argument('--disable-blink-features=AutomationControlled')
options.add_argument('--disable-dev-shm-usage')
options.add_argument('--no-sandbox')
options.add_argument('--window-size=1920,1080')

# Uso de uma versão específica do Chrome para consistência
driver = uc.Chrome(options=options, version_main=120)

# Mascaramento adicional através do CDP
driver.execute_cdp_cmd('Network.setUserAgentOverride', {
    "userAgent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
})

driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")

Navegadores anti-detect: AdsPower, Multilogin, GoLogin

Navegadores anti-detect comerciais fornecem soluções prontas para gerenciar impressões digitais. AdsPower e Multilogin permitem criar perfis com impressões digitais únicas de Canvas, WebGL, áudio e gerenciá-las através de API. Essas ferramentas são especialmente úteis ao trabalhar com várias contas.

A principal vantagem é a capacidade de manter uma impressão digital consistente entre sessões. Cada perfil tem parâmetros fixos de Canvas, WebGL, fontes, o que é crítico para o trabalho a longo prazo. É importante também usar configurações realistas — gerar impressões digitais aleatórias pode criar combinações tecnicamente impossíveis que são facilmente detectadas.

Clientes HTTP com impressões digitais corretas

Para tarefas que não requerem renderização JavaScript, clientes HTTP com impressões digitais TLS e HTTP/2 corretas são mais eficazes. Bibliotecas como curl-impersonate (para Python — curl_cffi) e tls-client permitem simular impressões digitais TLS de navegadores reais.

from curl_cffi import requests

# Simulando Chrome 120 com impressão digital TLS e HTTP/2 corretas
response = requests.get(
    'https://example.com',
    impersonate="chrome120",
    proxies={
        "http": "http://user:pass@proxy:port",
        "https": "http://user:pass@proxy:port"
    },
    headers={
        'Accept-Language': 'en-US,en;q=0.9',
        'Accept-Encoding': 'gzip, deflate, br',
        'sec-ch-ua': '"Not_A Brand";v="8", "Chromium";v="120"',
        'sec-ch-ua-mobile': '?0',
        'sec-ch-ua-platform': '"Windows"'
    }
)

# Impressão digital TLS automaticamente corresponde ao Chrome 120

Técnicas de automação sem gatilhos de detecção

Mesmo com uma impressão digital técnica perfeita, padrões de automação podem revelar um bot. É necessário imitar o comportamento humano no nível de interação com o site.

Emulação de movimentos do mouse

Movimento direto do mouse do ponto A ao ponto B é um sinal claro de automação. A mão humana cria curvas suaves com micro-correções. Bibliotecas como pyautogui permitem gerar trajetórias realistas usando curvas de Bézier.

// Geração de trajetória de mouse humanoide
async function humanMouseMove(page, targetX, targetY) {
  const current = await page.evaluate(() => ({
    x: window.mouseX || 0,
    y: window.mouseY || 0
  }));
  
  const steps = 25 + Math.floor(Math.random() * 15);
  const points = generateBezierCurve(current.x, current.y, targetX, targetY, steps);
  
  for (let point of points) {
    await page.mouse.move(point.x, point.y);
    await new Promise(r => setTimeout(r, 10 + Math.random() * 20));
  }
  
  // Micro-correções antes do clique
  await page.mouse.move(targetX + (Math.random() - 0.5) * 2, 
                        targetY + (Math.random() - 0.5) * 2);
}

function generateBezierCurve(x1, y1, x2, y2, steps) {
  const cp1x = x1 + (x2 - x1) * (0.3 + Math.random() * 0.2);
  const cp1y = y1 + (y2 - y1) * (0.3 + Math.random() * 0.2);
  const points = [];
  
  for (let i = 0; i <= steps; i++) {
    const t = i / steps;
    const x = Math.pow(1-t, 2) * x1 + 2 * (1-t) * t * cp1x + Math.pow(t, 2) * x2;
    const y = Math.pow(1-t, 2) * y1 + 2 * (1-t) * t * cp1y + Math.pow(t, 2) * y2;
    points.push({x: Math.round(x), y: Math.round(y)});
  }
  return points;
}

Rolagem realista e leitura de conteúdo

Um humano rola a página para ler o conteúdo, parando em seções interessantes. Um bot geralmente rola até o final da página ou até o elemento desejado o mais rápido possível. Imitar a leitura requer análise do conteúdo e criação de pausas realistas.

async function humanScroll(page, targetElement) {
  const elementPosition = await page.evaluate(el => {
    const rect = el.getBoundingClientRect();
    return rect.top + window.pageYOffset;
  }, targetElement);
  
  const currentScroll = await page.evaluate(() => window.pageYOffset);
  const distance = elementPosition - currentScroll;
  const scrollSteps = Math.floor(Math.abs(distance) / 100);
  
  for (let i = 0; i < scrollSteps; i++) {
    const scrollAmount = (distance / scrollSteps) * (0.8 + Math.random() * 0.4);
    await page.evaluate((amount) => {
      window.scrollBy({top: amount, behavior: 'smooth'});
    }, scrollAmount);
    
    // Pausas aleatórias para "leitura"
    if (Math.random() > 0.7) {
      await new Promise(r => setTimeout(r, 1000 + Math.random() * 2000));
    } else {
      await new Promise(r => setTimeout(r, 200 + Math.random() * 400));
    }
  }
}

Padrões de navegação naturais

Usuários não navegam diretamente para a página de destino — eles interagem com o site de forma natural. Comece pela página inicial, visite várias seções, use a busca ou o menu de navegação. Isso cria um histórico de interação que aumenta a confiança dos sistemas de proteção.

Também é importante imitar erros e correções — um humano pode clicar no link errado e voltar, errar ao digitar no campo de busca e corrigir um erro de digitação. Um caminho perfeitamente direto para o objetivo parece suspeito.

Gerenciamento de cookies e armazenamento

PerimeterX e Akamai utilizam cookies e localStorage para rastrear sessões. A limpeza completa de cookies entre solicitações parece suspeita — um navegador real mantém alguns cookies (análise, configurações). Mantenha cookies entre sessões para um único "usuário", mas use conjuntos diferentes de cookies para diferentes perfis.

Casos práticos e solução de problemas comuns

Vamos considerar cenários específicos para contornar o PerimeterX e o Akamai com soluções para problemas comuns que surgem no processo.

Caso 1: Extração de e-commerce com PerimeterX

Tarefa: extração de dados de produtos de uma grande loja online protegida pelo PerimeterX. O site bloqueia após 3-5 solicitações, mesmo de diferentes IPs.

Solução: Uso de uma combinação de proxies residenciais com sessões fixas (30 minutos) e Playwright com emulação completa de comportamento. Pontos-chave: começamos pela página inicial, usamos busca ou categorias para navegação, adicionamos atrasos aleatórios de 3-7 segundos entre solicitações, imitamos rolagem e movimentos do mouse. É crítico manter os cookies _px entre solicitações dentro de uma única sessão.

// Exemplo de sessão com aquecimento
async function scrapeWithWarmup(page, targetUrls) {
  // Aquecimento do perfil
  await page.goto('https://example.com');
  await humanScroll(page, await page.$('footer'));
  await new Promise(r => setTimeout(r, 3000 + Math.random() * 2000));
  
  // Navegação através do menu
  await humanMouseMove(page, menuX, menuY);
  await page.click('nav a.category');
  await new Promise(r => setTimeout(r, 2000 + Math.random() * 1000));
  
  // Apenas após o aquecimento, vamos para as páginas alvo
  for (let url of targetUrls) {
    await page.goto(url);
    await humanScroll(page, await page.$('.product-info'));
    // Extração de dados
    const data = await page.evaluate(() => extractProductData());
    await new Promise(r => setTimeout(r, 5000 + Math.random() * 3000));
  }
}

Caso 2: Contornando Akamai para solicitações de API

Tarefa: acesso à API protegida pelo Akamai Bot Manager. A API requer cabeçalhos específicos e tokens gerados pelo JavaScript na página.

Solução: O Akamai frequentemente utiliza sensor_data — uma string criptografada com os resultados das verificações do navegador. Essa string é gerada pelo JavaScript e deve ser incluída na solicitação. Usamos automação de navegador para obter um sensor_data válido, e em seguida aplicamos isso em um cliente HTTP com impressão digital TLS correta.

// Extraindo sensor_data através do navegador
async function getSensorData(page) {
  await page.goto('https://example.com');
  
  // Aguardando a execução do sensor do Akamai
  await page.waitForTimeout(5000);
  
  // Extraindo sensor_data do cookie ou localStorage
  const sensorData = await page.evaluate(() => {
    const cookie = document.cookie.split(';')
      .find(c => c.trim().startsWith('_abck='));
    return cookie ? cookie.split('=')[1] : null;
  });
  
  return sensorData;
}

// Uso no cliente HTTP
const sensorData = await getSensorData(page);
const response = await fetch('https://example.com/api/data', {
  headers: {
    'Cookie': `_abck=${sensorData}`,
    'User-Agent': 'Mozilla/5.0...',
    // Outros cabeçalhos devem corresponder ao navegador
  }
});

Caso 3: Resolução de CAPTCHA e páginas de desafio

Problema: mesmo com a configuração correta, PerimeterX ou Akamai às vezes exibem páginas de desafio ou CAPTCHA para verificação adicional.

Solução: Páginas de desafio do PerimeterX geralmente executam verificações adicionais...