Cloaking en SEO: Técnicas avanzadas, evasión y herramientas

Aquí no hay moralinas: el objetivo es maximizar el ROI, blindar activos y diversificar riesgos, eludiendo tanto los filtros automáticos como la supervisión humana. El cloaking moderno es una disciplina donde la paranoia operativa, el compartmentalization y la auditoría continua son tan importantes como el código en sí mismo.

La técnica fundacional, aunque cada vez más sofisticada. La clave es mantener listas actualizadas de user-agents de Googlebot y otros rastreadores, pero también randomizar respuestas ante bots menos conocidos y herramientas de crawling. El éxito está en evitar patrones estáticos, usar listas rotativas y simular imperfecciones humanas en las respuestas.

Ejemplo básico en PHP:

<?php
$ua = $_SERVER['HTTP_USER_AGENT'];
if (preg_match('/Googlebot|Bingbot|Slurp/i', $ua)) {
    include('pagina-seo.php');
} else {
    include('landing-money.php');
}
?>

Mejorar el footprint:

• Usar listas rotativas de user-agents.
• Incluir bots de herramientas de auditoría (Screaming Frog, Ahrefs, Semrush).
• Simular “errores” aleatorios (500, 404) en un % bajo de requests de bots.

Las bases de IPs de Google están al alcance de cualquiera (Googlebot IPs). El truco está en actualizar siempre las IPs y hacer una doble validación DNS (reverse y forward) para evitar honeypots y proxys falsos.

Ejemplo robusto en PHP:

<?php
function isGooglebot() {
    $ip = $_SERVER['REMOTE_ADDR'];
    $hostname = gethostbyaddr($ip);
    if (preg_match('/googlebot\.com$/i', $hostname)) {
        if (gethostbyname($hostname) === $ip) {
            return true;
        }
    }
    return false;
}
if (isGooglebot()) {
    include('seo-page.php');
} else {
    include('normal-page.php');
}
?>

Tips avanzados:

• Logs de acceso cifrados para detectar honeypots.
• Tor exit node detection para evitar bots disfrazados.
• Filtros de ASN y rangos de IP de proveedores cloud.

El contenido se sirve según la IP geográfica, permitiendo mostrar contenidos distintos a bots (normalmente localizados en EEUU o Irlanda) frente a usuarios reales de otros países. Además, se puede variar contenido según el lenguaje del navegador o headers HTTP.

Ejemplo en .htaccess (Apache):

RewriteEngine On
RewriteCond %{ENV:GEOIP_COUNTRY_CODE} ^(US|IE)$
RewriteRule ^(.*)$ /pagina-googlebot.php [L]

Ejemplo en Nginx:

geoip_country /usr/share/GeoIP/GeoIP.dat;
if ($geoip_country_code ~* (US|IE)) {
    rewrite ^ /pagina-googlebot.php break;
}

El cloaking por ruta y query string permite segmentar según patrones de URL o parámetros GET/POST. Ideal para filtrar bots que acceden a rutas predecibles o con footprints de crawling.

Ejemplo en PHP:

<?php
if ($_GET['bot'] === '1' || strpos($_SERVER['REQUEST_URI'], '/seo-path/') !== false) {
    include('seo-special-content.php');
} else {
    include('default-content.php');
}
?>

En 2025, la guerra es el rendering. Google renderiza JS, pero su crawler sigue siendo menos fiable que un navegador real.
El cloaking avanzado utiliza JavaScript para mostrar/ocultar bloques, inyectar contenido solo en contextos browser, o usar service workers para servir recursos solo a usuarios humanos.

Ejemplo de inyección JS:

<script>
if (!/bot|googlebot|crawler|spider|robot|crawling/i.test(navigator.userAgent)) {
    document.getElementById('oferta-exclusiva').style.display = 'block';
}
</script>

Service Worker para cloaking avanzado: Service Workers permiten manipular requests/responses a nivel browser, imposible de emular para la mayoría de crawlers.

self.addEventListener('fetch', function(event) {
    if (event.request.headers.get('user-agent').indexOf('Googlebot') === -1) {
        // Manipular respuesta solo para humanos
    }
});

El error más habitual en cloaking es dejar rastros técnicos. Hay que minimizar footprints en código, rutas, headers y comportamiento.

• Randomización de headers HTTP.
• No servir exactamente el mismo contenido “SEO” a todos los bots (introducir variabilidad).
• Cambiar rutas, nombres de archivos y parámetros regularmente.
• Usar CDN y proxies inversos para aislar la IP original del servidor real.
• Logs rotativos y cifrados para detectar patrones de escaneo manual.

• WhatIsMyBrowser
• IPinfo.io
• User-Agent Switcher

• Googlebot Simulator (SEOlyzer)
• Screaming Frog SEO Spider
• Sitebulb

• Shodan para analizar exposiciones públicas.
• Scripts custom de crawling con Puppeteer o Selenium.

• GoAccess para visualización de logs en tiempo real.
• ELK Stack para grandes volúmenes y correlación de eventos.

• Servidores privados, sin relación entre proyectos.
• No compartir Analytics, Search Console, ni recursos de CDN entre money sites y cloaker.
• Cuentas de administración separadas, accesos por VPN, y logs cifrados en servidores intermedios.

El verdadero arte está en el cloaking selectivo de URLs. Es posible presentar rutas completamente distintas a bots y usuarios, o incluso servir versiones diferentes en función del referer, cookies o historial de navegación.

Ejemplo avanzado en PHP:

<?php
$bot = false;
$ua = $_SERVER['HTTP_USER_AGENT'];
$ip = $_SERVER['REMOTE_ADDR'];
if (preg_match('/bot|crawler|spider|slurp|bing/i', $ua)) {
    $bot = true;
}
if (strpos($_SERVER['REQUEST_URI'], '/seo/') !== false) {
    $bot = true;
}
if ($bot) {
    header("Location: /seo-content-special.html");
    exit;
} else {
    header("Location: /landing-money.html");
    exit;
}
?>

Cloaking de parámetros GET:

<?php
if (isset($_GET['utm_source']) && $_GET['utm_source'] === 'googlebot') {
    include('contenido-seo.php');
} else {
    include('contenido-dinero.php');
}
?>

Nginx – redirección selectiva:

if ($http_user_agent ~* (Googlebot|bingbot|slurp)) {
    rewrite ^/producto/(.*)$ /producto-seo/$1 redirect;
}

Uno de los mayores riesgos del cloaking avanzado no es tanto el bot de Google, sino los revisores humanos y los sistemas de debugging automatizados. Los especialistas en cloaking moderno desarrollan capas de antidebugging para dificultar la vida a quien intente analizar el sitio manualmente o con herramientas automatizadas.

• Detección de emuladores y headless browsers:
  Utiliza scripts para detectar navegadores sin interfaz o automatizados (Puppeteer, Selenium, Chrome Headless) y sirve contenido neutro o “honey” para despistar.

<script>
if (navigator.webdriver || window.callPhantom || window._phantom) {
  document.body.innerHTML = '';
  // O redirigir a una versión neutra
}
if(/HeadlessChrome/.test(navigator.userAgent)) {
  window.location = '/';
}
</script>

• Honeypots para detectores manuales:
  Muestra versiones “limpias” si detectas patrones de comportamiento típicos de revisores: movimiento errático, navegación por rutas poco habituales, ausencia de cookies, referers extraños o acceso desde IPs de rango Google pero con user-agent de navegador humano.
• Obfuscación dinámica del código:
  Genera el contenido clave mediante JS y ofusca las rutas y variables con herramientas como Javascript Obfuscator, de modo que el código fuente no revele el comportamiento real.
• Desincronización temporal:
  Haz que el contenido “money” solo se sirva tras ciertas interacciones (scroll, tiempo mínimo en página, clics), mientras que los bots y revisores reciben siempre la versión “SEO”.

<?php
function is_revisor() {
    $ua = $_SERVER['HTTP_USER_AGENT'];
    if (preg_match('/Mozilla.*(Windows NT|Macintosh)/i', $ua) && isset($_SERVER['HTTP_REFERER']) && strpos($_SERVER['HTTP_REFERER'],'google.com') === false) {
        // Revisores suelen acceder directamente, sin referer o desde interfaces internas
        return true;
    }
    // Más heurísticas: navegación rápida, múltiples requests en segundos, etc.
    return false;
}
if (is_revisor()) {
    include('pagina-neutra.php');
} else {
    // Seguir con lógica de cloaking normal
}
?>

El verdadero blindaje se logra aislando el entorno. Un money site nunca debe compartir recursos, servidores, CDN, cuentas de análisis ni patrones de código con el sistema cloaker.
Para ello:

• Utiliza servidores y dominios distintos para cada capa.
• El cloaker debe ser un intermediario, nunca el propio money site.
• El money site no debe tener Analytics, Search Console ni recursos estáticos compartidos.
• Los logs del cloaker deben estar cifrados y rotar IPs frecuentemente.

1. Cloaker:
   Recibe todo el tráfico, filtra y redirige según reglas. Ubicado en un servidor físico exclusivo.
2. Money site:
   Solo visible tras pasar por el cloaker. Sin relación directa, sin footprints técnicos ni DNS compartidos.
3. Red de proxys:
   Para rotar IPs de salida y evitar correlaciones por ASN o rangos de IP.

• Detecta footprints y patrones con Shodan, Censys o ZoomEye.
• Scripts personalizados con Puppeteer/Selenium:
  Simulan decenas de bots y navegadores, permiten auditar cómo responde el sistema a cada combinación de IP, user-agent, referer, cookies, JS, etc.
• GoAccess:
  Visualiza logs en tiempo real y detecta anomalías de acceso.
• Burp Suite:
  Intercepta y modifica headers/cookies para probar reglas de cloaking.
• GeoEdge y proxies premium:
  Simula tráfico real desde cualquier país, ASN y entorno móvil/escritorio.

La detección no debe limitarse al user-agent. Los sistemas modernos usan fingerprinting complejo sobre decenas de propiedades del navegador: resolución de pantalla, timezones, fuentes instaladas, plugins, etc.

Ejemplo de fingerprinting en JS:

function isLikelyBot() {
  return navigator.languages === undefined ||
    navigator.platform === '' ||
    (window.outerWidth === 0 && window.outerHeight === 0) ||
    typeof window.chrome === 'undefined' ||
    /HeadlessChrome/.test(navigator.userAgent);
}
if (isLikelyBot()) {
  // Mostrar contenido neutro
}

Se puede condicionar la versión mostrada según la fuente de tráfico (referer) y la presencia/ausencia de cookies (bots suelen no aceptar cookies).

<?php
if (empty($_COOKIE['sessionid']) && strpos($_SERVER['HTTP_REFERER'], 'google') !== false) {
    include('version-bot.php');
} else {
    include('version-humana.php');
}
?>

No solo el HTML: manipula imágenes, scripts y hojas de estilo para servir versiones “limpias” a bots que analizan recursos secundarios.

Ejemplo en Nginx:

map $http_user_agent $is_bot {
    default 0;
    ~*(googlebot|bingbot|slurp) 1;
}
server {
    location ~* \.(jpg|png|js|css)$ {
        if ($is_bot) {
            rewrite ^(.*)$ /static/seo$1 last;
        }
    }
}

El cloaking reactivo aprende y se adapta en tiempo real según los patrones de acceso y los intentos de debugging detectados. Algoritmos de machine learning pueden identificar comportamientos sospechosos y modificar reglas sobre la marcha.

• Cloaking adaptativo:
  Reglas que se autoajustan si se detectan patrones de escaneo masivo, cambios en los bots, o nuevos rangos de IP.
• Scripts de rotación de rutas archivos y parámetros:
  Cambia nombres de archivos, rutas y parámetros frecuentemente para evitar correlaciones entre logs de Google y tus sistemas.

Un cloaker profesional debe ser modular, fácil de actualizar y auditar.
Ejemplo básico de middleware Express:

const express = require('express');
const app = express();
const botUa = /bot|spider|crawl|slurp|bing/i;
const botIps = ['66.249.', '207.46.']; // Añade rangos de Google y Bing

function isBot(req) {
  let ip = req.ip;
  let ua = req.headers['user-agent'];
  let isIpBot = botIps.some(range => ip.startsWith(range));
  let isUaBot = botUa.test(ua);
  return isIpBot || isUaBot;
}

app.use((req, res, next) => {
  if (isBot(req)) {
    res.sendFile('/srv/seo-version.html');
  } else {
    res.sendFile('/srv/money-version.html');
  }
});

app.listen(8080);

Consejo:
Integra logs avanzados, rotación de rutas y módulo antidebugging para máxima robustez.

• Detecta crawlers de Ahrefs, Semrush, Moz, Majestic:
  Mantén listas de user-agents y rangos de IP actualizados.
• Responde 404/403 a bots de herramientas de auditoría.
• Variabilidad en headers y respuestas:
  Modifica headers como Server, X-Powered-By y cookies generados en cada request.

• Nunca mezcles money sites y cloakers en la misma infraestructura.
• Utiliza sistemas de logs que se autodestruyen o cifran tras un tiempo.
• Cambia frecuentemente de ASN, proveedor de hosting y CDN.
• No uses cuentas personales ni emails asociados a money sites en ningún sistema externo.
• Usa sistemas de control de acceso tipo Vault para gestionar credenciales.

En 2025, el cloaking sigue siendo una disciplina viva, rentable y extremadamente técnica. El que sobrevive no es el que “no hace cloaking”, sino el que lo implementa con paranoia extrema, sin patrones, sin footprints y con una obsesión permanente por la opsec y la compartimentación.
No hay recetas mágicas ni soluciones “plug and play”: cada vertical, cada nicho y cada entorno requiere una adaptación continua.
Las herramientas, el código y la metodología marcan la diferencia entre el ban y el éxito.
El resto es ruido.

Recursos recomendados:

• Lista actualizada de Googlebot IPs
• Awesome Cloaking Techniques (GitHub)
• Burp Suite – Para debugging y test de reglas.
• Puppeteer y Selenium – Simulación y testeo de bots.
• GoAccess – Analítica de logs.
• Shodan – Footprint y exposición pública.
• Javascript Obfuscator – Ofuscación de JS.
• GeoEdge – Proxies y testeo geolocalizado.