Bypass de la protección de PerimeterX y Akamai: métodos prácticos de antidetección

PerimeterX y Akamai Bot Manager son dos de las soluciones más avanzadas para la protección contra bots, utilizadas por las principales plataformas de comercio electrónico, servicios financieros y sitios web corporativos. Estos sistemas analizan cientos de parámetros del navegador, el comportamiento del usuario y las características de la red, creando una protección multicapa que no se puede eludir simplemente cambiando la dirección IP.

En esta guía, analizaremos en detalle la arquitectura de ambos sistemas, estudiaremos sus métodos de detección y crearemos una estrategia integral de elusión basada en casos reales y experimentos técnicos.

Arquitectura de PerimeterX y Akamai: cómo funciona la detección

PerimeterX (ahora HUMAN Security) y Akamai Bot Manager funcionan como sistemas de protección multicapa, integrándose en diferentes etapas del procesamiento de solicitudes. Comprender su arquitectura es fundamental para desarrollar una estrategia de elusión.

Arquitectura de PerimeterX

PerimeterX opera en tres etapas. En la primera etapa, un sensor de JavaScript se inyecta en la página HTML y se ejecuta en el navegador del cliente, recopilando datos sobre el entorno de ejecución: huella de WebGL, huella de Canvas, contexto de audio, fuentes disponibles, plugins, resolución de pantalla y muchos otros parámetros. Este sensor está ofuscado y se actualiza regularmente, lo que dificulta su análisis.

En la segunda etapa, el componente del servidor de PerimeterX analiza los encabezados HTTP, la huella TLS, la reputación de la IP y las características de la red antes de que la solicitud llegue a la aplicación principal. El sistema utiliza su propia base de datos de bots conocidos y direcciones IP sospechosas, actualizada en tiempo real.

La tercera etapa es el análisis de comportamiento. PerimeterX rastrea los movimientos del mouse, la velocidad de desplazamiento, los patrones de clics, el tiempo entre acciones y construye un perfil de comportamiento. Los modelos de aprendizaje automático comparan este perfil con los patrones de usuarios reales y bots conocidos.

Arquitectura de Akamai Bot Manager

Akamai Bot Manager se integra a nivel de CDN, lo que le da una ventaja en la velocidad de análisis. El sistema utiliza su propia tecnología BMP (Bot Manager Premier), que analiza las solicitudes en los servidores de borde de Akamai antes de que sean enviadas al servidor de origen.

La principal diferencia de Akamai es el uso de telemetría de millones de sitios protegidos por su CDN. Esto permite al sistema identificar rápidamente nuevos tipos de bots y actualizar las reglas de detección a nivel global. Akamai también utiliza una tecnología de Web SDK, similar al sensor de PerimeterX, pero con un enfoque en la verificación criptográfica de la integridad del cliente.

Métodos de detección: qué analizan los sistemas de protección

Los sistemas modernos de antibots analizan las solicitudes en cientos de parámetros, agrupados en varias categorías. Comprender cada categoría permite eliminar sistemáticamente los marcadores de automatización.

Análisis de encabezados HTTP y TLS

El orden de los encabezados HTTP es una de las formas más simples de detección. Los navegadores envían encabezados en un orden estrictamente definido, que varía entre versiones y fabricantes. Bibliotecas como requests en Python o axios en Node.js utilizan su propio orden, lo que revela instantáneamente la automatización.

La huella TLS (huella JA3) se crea a partir de los parámetros del apretón de manos TLS: versión TLS, lista de cifrados soportados, extensiones y su orden. Cada combinación de navegador y sistema operativo crea una huella única. Por ejemplo, Chrome 120 en Windows 11 tiene una huella diferente a Chrome 120 en macOS o a Firefox en el mismo sistema.

// Ejemplo de discrepancia entre User-Agent y huella TLS
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0
TLS Fingerprint: El hash JA3 corresponde a Python requests
// Resultado: bloqueo inmediato

Entorno de ejecución de JavaScript

Los navegadores sin cabeza dejan decenas de rastros en el entorno de JavaScript. Se verifican propiedades navigator.webdriver, la presencia de objetos window.chrome, discrepancias en navigator.plugins, anomalías en WebGL y Canvas rendering.

PerimeterX y Akamai utilizan técnicas avanzadas de verificación: miden el tiempo de ejecución de funciones de JavaScript (en navegadores sin cabeza es diferente), verifican la presencia de artefactos de automatización en el DOM, analizan la pila de llamadas de funciones. Los sistemas también verifican la consistencia de los datos: por ejemplo, si el User-Agent indica un dispositivo móvil, pero navigator.maxTouchPoints es igual a 0, esto desencadena la detección.

Características de la red y reputación de IP

Los sistemas de protección verifican la dirección IP en base a múltiples parámetros: pertenencia a proveedores de proxies conocidos, inclusión en listas negras, historial de actividad desde esa IP, consistencia de geolocalización con otros parámetros de la solicitud (idioma del navegador, zona horaria).

Se presta especial atención a los patrones de uso de IP. Si desde una misma dirección llegan solicitudes con diferentes User-Agent o huellas de navegador, esto es una señal fuerte de automatización. De igual manera, si la IP cambia con demasiada frecuencia dentro de una misma sesión (rotación agresiva de proxies), esto desencadena un bloqueo.

Fingerprinting del navegador y huellas TLS

El fingerprinting del navegador es una técnica para crear un identificador único del navegador basado en sus características. Incluso sin cookies, los sistemas de protección pueden rastrear a los usuarios y detectar anomalías.

Fingerprinting Canvas y WebGL

El fingerprinting Canvas funciona mediante el renderizado de una imagen invisible con texto y gráficos. Debido a las diferencias en los controladores gráficos, fuentes y configuraciones de anti-aliasing, cada sistema crea una imagen ligeramente diferente. El hash de esta imagen se convierte en parte de la huella.

El fingerprinting WebGL utiliza renderizado 3D para crear una huella aún más única. El sistema solicita información sobre la GPU, las extensiones soportadas, los tamaños máximos de textura y otros parámetros. La combinación de estos datos crea una huella con suficiente entropía para identificar el dispositivo.

// Ejemplo de obtención de huella 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);

// El resultado puede ser: "Google Inc. (NVIDIA)" + "ANGLE (NVIDIA GeForce RTX 3080)"
// Combinación única para cada dispositivo

Contexto de audio y fuentes

La API de Contexto de Audio permite crear una huella única basada en el procesamiento de sonido. Las diferencias en la pila de audio del sistema operativo conducen a diferencias microscópicas en el procesamiento de la señal de audio, que se pueden medir y utilizar para la identificación.

La lista de fuentes instaladas también es única para cada sistema. Los sistemas de protección utilizan la técnica de medir el tamaño del texto con diferentes fuentes: si la fuente no está instalada, el navegador utiliza una alternativa, lo que cambia los tamaños. Verificar cientos de fuentes crea una firma única.

Fingerprinting TLS y HTTP/2

La huella JA3 se crea a partir de los parámetros del Client Hello de TLS: versión SSL/TLS, lista de suites de cifrado, lista de extensiones, lista de grupos elípticos soportados, formatos de puntos de curvas elípticas. Estos parámetros se concatenan y se hash, creando una cadena única.

El fingerprinting HTTP/2 analiza los parámetros del frame SETTINGS, el orden y las prioridades de los flujos, los valores de actualización de la ventana. Cada navegador utiliza configuraciones únicas de HTTP/2, lo que permite identificar al cliente incluso con una huella TLS correcta.

Análisis de comportamiento y aprendizaje automático

El análisis de comportamiento es el aspecto más difícil de eludir de los sistemas modernos de antibots. Incluso con una huella técnica perfecta, un comportamiento no humano revelará la automatización.

Análisis de movimientos del mouse e interacciones

PerimeterX y Akamai rastrean las trayectorias de movimiento del mouse, la aceleración y desaceleración, los micro-movimientos característicos de la mano humana. Los bots suelen mover el cursor en líneas rectas o no generan eventos de mouse en absoluto. Los sistemas también analizan el tiempo de reacción: un clic justo después de cargar la página sin movimiento del mouse parece sospechoso.

Los patrones de desplazamiento también son únicos. Un humano desplaza la página de manera desigual: rápido al principio, se ralentiza para leer, a veces se desplaza hacia atrás. Los bots suelen desplazarse a una velocidad constante o utilizan window.scrollTo() para un desplazamiento instantáneo.

Patrones temporales y velocidad de acciones

El tiempo entre acciones es un parámetro crítico. Un humano no puede llenar un formulario de 10 campos en 0.5 segundos o hacer clic en 50 enlaces en un minuto. Los sistemas de protección construyen un perfil de velocidad para cada tipo de acción y lo comparan con el comportamiento del usuario.

Se presta especial atención a la consistencia de los retrasos. Si entre cada clic pasan exactamente 2 segundos, es una señal obvia de sleep(2000) en el código. Los retrasos humanos tienen una variabilidad natural y siguen ciertas distribuciones estadísticas.

Modelos de aprendizaje automático

Ambos sistemas utilizan modelos de ML entrenados en millones de sesiones de usuarios reales y bots conocidos. Los modelos analizan cientos de características simultáneamente: secuencia de acciones, profundidad de navegación por el sitio, patrones de navegación, interacción con elementos.

PerimeterX utiliza un conjunto de modelos con diferentes pesos para diferentes tipos de sitios. El modelo para comercio electrónico se centra en patrones de compra, mientras que el modelo para sitios de medios se centra en patrones de lectura de contenido. Esto hace que la elusión sea más complicada, ya que requiere adaptación a la especificidad de cada sitio.

// Ejemplo de retrasos humanos con variabilidad
function humanDelay(baseMs) {
  // Distribución log-normal en lugar de uniforme
  const variance = baseMs * 0.3;
  const delay = baseMs + (Math.random() - 0.5) * variance;
  // Agregamos micro-retrasos característicos del procesamiento de eventos por el navegador
  const microDelay = Math.random() * 50;
  return Math.max(100, delay + microDelay);
}

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

Estrategia de selección y rotación de proxies

La elección del tipo de proxy y la estrategia de rotación es crítica al trabajar con PerimeterX y Akamai. Una configuración incorrecta de los proxies anulará todos los esfuerzos por enmascarar la huella del navegador.

Proxies residenciales vs móviles vs de datacenter

Los proxies de datacenter tienen el costo más bajo, pero también el mayor riesgo de detección. PerimeterX y Akamai mantienen bases de datos de direcciones IP de datacenters y aumentan automáticamente el nivel de verificación para tales solicitudes. El uso de proxies de datacenter es posible solo para tareas de baja prioridad o en combinación con una huella de navegador de muy alta calidad.

Los proxies residenciales utilizan direcciones IP de proveedores de internet reales, lo que reduce significativamente la probabilidad de detección. Sin embargo, la calidad de los proxies residenciales varía mucho. Es importante elegir proveedores con pools de IP limpias, donde las direcciones no se hayan utilizado anteriormente para spam u otras actividades sospechosas.

Los proxies móviles ofrecen el nivel más alto de confianza, ya que utilizan direcciones IP de operadores móviles. Estas direcciones suelen ser compartidas entre muchos usuarios (NAT de grado de operador), lo que dificulta el bloqueo. Los proxies móviles son especialmente efectivos contra Akamai, que es más cauteloso al bloquear tráfico móvil.

Estrategias de rotación

La rotación agresiva (cambio de IP en cada solicitud) es un error común. Esto crea un patrón sospechoso: un usuario no puede físicamente cambiar su dirección IP cada pocos segundos. La rotación de sesión es más efectiva, donde una IP se utiliza durante toda la sesión del usuario (10-30 minutos de actividad).

Para operaciones prolongadas, se recomienda sesiones pegajosas con una duración de 30-60 minutos. Esto imita el comportamiento de un usuario real que permanece en una IP durante la sesión. Al mismo tiempo, es importante no usar una IP demasiado tiempo: sesiones de varias horas también parecen sospechosas.

Consistencia geográfica

Es crítico asegurar la correspondencia entre la geolocalización de la dirección IP y otros parámetros: idioma del navegador, zona horaria, configuraciones regionales. Si la dirección IP es de Alemania, pero navigator.language devuelve "en-US", y la zona horaria es "America/New_York", esto es un desencadenante inmediato de detección.

Al trabajar con múltiples regiones geográficas, utilice perfiles de navegador separados para cada región. Cambiar entre regiones dentro de una misma sesión (IP de Francia, luego de Japón) es imposible para un usuario real y se detecta de inmediato.

Configuración de navegadores y herramientas de antidetección

La configuración correcta de las herramientas de automatización es un factor clave para el éxito en el eludir PerimeterX y Akamai. Incluso los mejores proxies no ayudarán si la huella del navegador contiene marcadores evidentes de automatización.

Playwright y Puppeteer: configuración avanzada

La instalación básica de Playwright o Puppeteer crea un navegador sin cabeza obvio. Es necesario utilizar plugins de sigilo y configuración adicional para enmascarar la automatización. La biblioteca puppeteer-extra-plugin-stealth oculta los marcadores principales, pero requiere configuración adicional.

// Configuración avanzada de Playwright con antidetección
const { chromium } = require('playwright-extra');
const stealth = require('puppeteer-extra-plugin-stealth')();

chromium.use(stealth);

const browser = await chromium.launch({
  headless: false, // El modo sin cabeza se detecta fácilmente
  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 con undetected-chromedriver

El Selenium WebDriver estándar se detecta fácilmente a través de la propiedad navigator.webdriver. La biblioteca undetected-chromedriver parchea automáticamente ChromeDriver, eliminando los marcadores principales de automatización y se actualiza regularmente para eludir nuevos métodos de detección.

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 una versión específica de Chrome para consistencia
driver = uc.Chrome(options=options, version_main=120)

# Enmascaramiento adicional a través de 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 de antidetección: AdsPower, Multilogin, GoLogin

Los navegadores comerciales de antidetección proporcionan soluciones listas para gestionar huellas. AdsPower y Multilogin permiten crear perfiles con huellas únicas de Canvas, WebGL, audio y gestionarlas a través de API. Estas herramientas son especialmente útiles al trabajar con múltiples cuentas.

La ventaja clave es la posibilidad de mantener una huella consistente entre sesiones. Cada perfil tiene parámetros fijos de Canvas, WebGL, fuentes, lo que es crítico para un funcionamiento a largo plazo. Al mismo tiempo, es importante utilizar configuraciones realistas: la generación de huellas aleatorias puede crear combinaciones técnicamente imposibles que se detectan fácilmente.

Clientes HTTP con huellas correctas

Para tareas que no requieren renderizado de JavaScript, los clientes HTTP con huellas TLS y HTTP/2 correctas son más efectivos. Bibliotecas como curl-impersonate (para Python — curl_cffi) y tls-client permiten imitar las huellas TLS de navegadores reales.

from curl_cffi import requests

# Imitando Chrome 120 con huella TLS y HTTP/2 correcta
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"'
    }
)

# La huella TLS corresponde automáticamente a Chrome 120

Técnicas de automatización sin desencadenar detección

Incluso con una huella técnica perfecta, los patrones de automatización pueden revelar un bot. Es necesario imitar el comportamiento humano a nivel de interacción con el sitio.

Emulación de movimientos del mouse

Un movimiento recto del mouse desde el punto A al punto B es una señal clara de automatización. La mano humana crea curvas suaves con micro-correcciones. Bibliotecas como pyautogui permiten generar trayectorias realistas utilizando curvas de Bézier.

// Generación de una trayectoria de mouse similar a la humana
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-correcciones antes del clic
  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;
}

Desplazamiento realista y lectura de contenido

Un humano desplaza la página para leer contenido, deteniéndose en secciones interesantes. Un bot generalmente se desplaza hasta el final de la página o hasta el elemento deseado lo más rápido posible. La imitación de la lectura requiere analizar el contenido y crear 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 aleatorias para "lectura"
    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));
    }
  }
}

Patrones naturales de navegación

Los usuarios no van directamente a la página objetivo: interactúan con el sitio de manera natural. Comience desde la página principal, visite varias secciones, use la búsqueda o el menú de navegación. Esto crea un historial de interacción que aumenta la confianza de los sistemas de protección.

También es importante imitar errores y correcciones: un humano puede hacer clic en el enlace incorrecto y regresar, cometer un error al ingresar en el campo de búsqueda y corregir un error tipográfico. Un camino directo hacia el objetivo parece sospechoso.

Gestión de cookies y almacenamiento

PerimeterX y Akamai utilizan cookies y localStorage para rastrear sesiones. La limpieza completa de cookies entre solicitudes parece sospechosa: un navegador real conserva algunas cookies (analítica, configuraciones). Mantenga las cookies entre sesiones para un "usuario", pero utilice diferentes conjuntos de cookies para diferentes perfiles.

Casos prácticos y solución de problemas comunes

Analicemos escenarios específicos para eludir PerimeterX y Akamai con soluciones a problemas comunes que surgen en el proceso.

Caso 1: Parsing de comercio electrónico con PerimeterX

Tarea: extracción de datos de productos de una gran tienda en línea protegida por PerimeterX. El sitio bloquea después de 3-5 solicitudes incluso desde diferentes IP.

Solución: Uso de una combinación de proxies residenciales con sesiones pegajosas (30 minutos) y Playwright con una emulación completa del comportamiento. Puntos clave: comenzamos desde la página principal, utilizamos búsqueda o categorías para navegar, agregamos retrasos aleatorios de 3-7 segundos entre solicitudes, imitamos el desplazamiento y los movimientos del mouse. Es crítico mantener las cookies _px entre solicitudes dentro de una misma sesión.

// Ejemplo de sesión con calentamiento
async function scrapeWithWarmup(page, targetUrls) {
  // Calentamiento del perfil
  await page.goto('https://example.com');
  await humanScroll(page, await page.$('footer'));
  await new Promise(r => setTimeout(r, 3000 + Math.random() * 2000));
  
  // Navegación a través del menú
  await humanMouseMove(page, menuX, menuY);
  await page.click('nav a.category');
  await new Promise(r => setTimeout(r, 2000 + Math.random() * 1000));
  
  // Solo después del calentamiento pasamos a las páginas objetivo
  for (let url of targetUrls) {
    await page.goto(url);
    await humanScroll(page, await page.$('.product-info'));
    // Extracción de datos
    const data = await page.evaluate(() => extractProductData());
    await new Promise(r => setTimeout(r, 5000 + Math.random() * 3000));
  }
}

Caso 2: Elusión de Akamai para solicitudes API

Tarea: acceso a una API protegida por Akamai Bot Manager. La API requiere encabezados específicos y tokens generados por JavaScript en la página.

Solución: Akamai a menudo utiliza sensor_data: una cadena encriptada con los resultados de las verificaciones del navegador. Esta cadena es generada por JavaScript y debe incluirse en la solicitud. Usamos automatización del navegador para obtener un sensor_data válido, luego lo aplicamos en un cliente HTTP con una huella TLS correcta.

// Extracción de sensor_data a través del navegador
async function getSensorData(page) {
  await page.goto('https://example.com');
  
  // Esperamos a que se ejecute el sensor de Akamai
  await page.waitForTimeout(5000);
  
  // Extraemos sensor_data de cookies o 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 en el 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...',
    // Otros encabezados deben coincidir con el navegador
  }
});

Caso 3: Resolución de CAPTCHA y páginas de desafío

Problema: incluso con una configuración correcta, PerimeterX o Akamai a veces muestran páginas de desafío o CAPTCHA para una verificación adicional.

Solución: Las páginas de desafío de PerimeterX generalmente realizan verificaciones adicionales que requieren interacción del usuario. Esto puede incluir resolver un CAPTCHA o realizar una verificación de comportamiento más profunda. Se recomienda implementar un sistema que simule el comportamiento humano para superar estas verificaciones.