Kali Linux: Detectar Balanceadores de Carga

 

 https://www.onlinetis.com/es/

Kali Linux: Detectar Balanceadores de Carga

Si estás buscando información sobre lbd (Load Balancing Detector) en Kali Linux, aquí tienes una guía rápida y clara sobre qué es, para qué sirve y cómo utilizarlo.

¿Qué es lbd?

El Load Balancing Detector (lbd) es una herramienta de reconocimiento (footprinting) diseñada para detectar si un dominio o una dirección IP utiliza un balanceador de carga.

Saber si un objetivo tiene balanceo de carga es crucial en las pruebas de penetración porque:

  • Resultados inconsistentes: Podrías estar enviando ataques a diferentes servidores físicos sin saberlo.

  • Detección: Los balanceadores de carga a menudo actúan como una capa de seguridad (como un WAF).

  • Mapeo: Ayuda a entender la infraestructura real del objetivo.

¿Cómo funciona?

lbd analiza las cabeceras HTTP y las respuestas del servidor para encontrar diferencias sutiles. Se fija principalmente en:

  1. Cabeceras HTTP: Diferencias en el campo Server.

  2. Cookies: Inserción de cookies específicas de balanceo.

  3. Diferencias de tiempo: Variaciones en el tiempo de respuesta.

  4. Direcciones IP: Si el mismo DNS resuelve a múltiples máquinas físicas detectables.

Cómo usarlo en Kali Linux

La sintaxis es extremadamente sencilla. Abre tu terminal y escribe:

Bash
lbd <nombre_del_dominio_o_ip>

Ejemplo práctico:

Bash
lbd google.com

Interpretación de resultados:

  • "NOT FOUND": El script no detectó indicios claros de balanceo de carga.

  • "FOUND": Se detectaron diferencias en las cabeceras o cookies, lo que sugiere que hay varios servidores detrás de esa dirección.

Consideraciones importantes

  • Falsos positivos: A veces, las redes de entrega de contenido (CDN) como Cloudflare pueden confundir a la herramienta.

  • Herramientas alternativas: Si necesitas algo más avanzado, puedes probar con nmap usando el script http-load-balancer-detector:

    Bash
    nmap --script http-load-balancer-detector <objetivo>


Para interpretar los resultados de lbd, debemos fijarnos en qué tipo de "pista" encontró la herramienta. Cuando el script termina, verás secciones divididas por el método de detección utilizado.

Aquí tienes una guía para entender qué significa cada hallazgo:

1. Detección por Cabeceras HTTP (Server)

Si el resultado indica que hay cambios en la cabecera Server, significa que las peticiones están siendo respondidas por máquinas con configuraciones distintas.

  • Qué significa: Una petición puede mostrar Server: Apache/2.4.41 y la siguiente Server: nginx/1.18.0.

  • Conclusión: Hay un balanceador distribuyendo el tráfico entre servidores con software o versiones diferentes.

2. Detección por Cookies

Este es el método más común. Los balanceadores suelen insertar una cookie para mantener la "persistencia de sesión" (que siempre vayas al mismo servidor durante tu visita).

  • Qué buscar: Cookies con nombres como BIGipServer, citrix_ns_id o AWSALB.

  • Conclusión: El balanceador está "marcando" tu navegador para saber a qué servidor interno enviarte.

3. Diferencias en la Fecha/Hora (Date)

lbd compara los campos de fecha y hora de las respuestas HTTP.

  • Qué significa: Si hay una diferencia de varios segundos entre dos respuestas consecutivas, es probable que los relojes internos de los servidores detrás del balanceador no estén perfectamente sincronizados.

  • Conclusión: Es una prueba física de que estás hablando con dos relojes (y por tanto, dos máquinas) distintos.

Ejemplo de Salida Interpretada

Si ejecutas el comando y obtienes algo como esto:

Plaintext
Checking for loadbalancing via HTTP Header Server
google.com -> gws
...
Checking for loadbalancing via HTTP Header Date
11:30:05  <-- Respuesta 1
11:30:08  <-- Respuesta 2 (¡Diferencia de 3 segundos!)
...
google.com loadbalancing found via Date header differences

Interpretación: En este caso, el balanceador fue detectado por el desfase horario. Esto te indica que el objetivo utiliza una infraestructura distribuida y que los ataques de denegación de servicio (DoS) o fuerza bruta serán más difíciles de ejecutar contra un solo nodo.

¿Cómo proceder tras el hallazgo?

Una vez que confirmas que hay un balanceador, el siguiente paso suele ser intentar "saltárselo" o identificar las IPs reales de los servidores finales (esto se llama Backend Discovery).


Esta es la fase conocida como Backend Discovery o Origin IP Discovery. El objetivo es saltarse la "capa de protección" (el balanceador o WAF) para atacar directamente al servidor real, donde las reglas de seguridad suelen ser más relajadas.

Aquí tienes las técnicas más efectivas para lograrlo desde Kali Linux:

1. Historial de DNS (DNS History)

A menudo, antes de poner un balanceador de carga o un servicio como Cloudflare, el servidor estuvo conectado directamente a internet con una IP pública. Esa IP suele quedar registrada en bases de datos históricas.

  • Herramientas: Usa servicios como ViewDNS.info, SecurityTrails o la herramienta subfinder en Kali.

  • Lógica: Si hace 6 meses el dominio ejemplo.com apuntaba a la IP 1.2.3.4 y ahora apunta a un balanceador, es muy probable que 1.2.3.4 siga siendo la IP real del servidor.

2. Certificados SSL/TLS (Censys / Shodan)

Incluso si el dominio está oculto tras un balanceador, el servidor real puede tener instalado el certificado SSL para el mismo dominio.

  • Técnica: Busca en Censys o Shodan el nombre del dominio.

  • Lógica: Estas plataformas escanean todo internet. Si encuentran un servidor cuya IP no es la del balanceador pero que presenta un certificado válido para ejemplo.com, habrás encontrado el origen.

3. Cabeceras HTTP Reveladoras

A veces, el balanceador está mal configurado y reenvía cabeceras que delatan la IP interna o el servidor real.

  • Cabeceras a buscar: * X-Forwarded-For

    • X-Originating-IP

    • X-Real-IP

  • Prueba: Puedes intentar forzar estas cabeceras usando curl:

    Bash
    curl -I -H "X-Forwarded-For: 127.0.0.1" http://objetivo.com

4. Notificaciones de Correo (Mail Headers)

Si el sitio web tiene un formulario de "Olvidé mi contraseña" o un registro que envía un email, el servidor de correo suele ser el mismo servidor web o estar en la misma red local.

  • Técnica: Regístrate y analiza las cabeceras del correo recibido (Ver código fuente del email).

  • Qué buscar: Busca el campo Received: from .... La IP que aparezca ahí suele ser la IP real (backend) del servidor que generó el envío.

5. Escaneo de Favicon (Favicon Hash)

Esta es una técnica muy creativa. El icono de la web (favicon.ico) genera un hash único.

  1. Obtén el hash del favicon del objetivo.

  2. Busca ese hash en Shodan.

  3. Shodan te devolverá todos los servidores en internet que tengan ese mismo archivo. Muchos de ellos serán las IPs reales sin protección.

Nota de seguridad: Una vez que creas haber encontrado la IP real, confírmalo intentando acceder a ella directamente en tu navegador (https://IP_ENCONTRADA). Si carga el sitio web del objetivo, has tenido éxito.


Automatizar esto con Python es una excelente forma de aprender cómo funcionan las peticiones de red. Vamos a crear un script que intente realizar una de las técnicas más efectivas: el análisis de cabeceras HTTP y la búsqueda de posibles fugas de IP interna.

Este script enviará peticiones al dominio y analizará si el servidor "se delata" a sí mismo en las respuestas.

Script: Analizador de Fugas de IP (Origin-IP Finder)

Para que funcione, asegúrate de tener instalada la librería requests en tu Kali (pip install requests).

Python
import requests

def analizar_objetivo(url):
    if not url.startswith('http'):
        url = 'http://' + url
    
    print(f"[*] Analizando: {url}")
    print("-" * 40)

    try:
        # 1. Realizamos una petición normal
        response = requests.get(url, timeout=10)
        
        # 2. Buscamos cabeceras sospechosas que suelen filtrar IPs
        cabeceras_criticas = [
            'X-Backend-IP', 'X-Origin-IP', 'X-Real-IP', 
            'Server', 'X-Powered-By', 'CF-Connecting-IP'
        ]
        
        print("[+] Revisando cabeceras de respuesta:")
        for header in cabeceras_criticas:
            valor = response.headers.get(header)
            if valor:
                print(f"    [!] Encontrada {header}: {valor}")
            else:
                print(f"    [-] {header}: No presente")

        # 3. Verificamos si hay cookies de balanceadores comunes
        print("\n[+] Revisando cookies de balanceo:")
        cookies = response.cookies.get_dict()
        if not cookies:
            print("    [-] No se detectaron cookies en la respuesta inicial.")
        for name in cookies:
            if "BIGip" in name or "NSC_" in name or "AWSELB" in name:
                print(f"    [!] Cookie de balanceador detectada: {name}")
            else:
                print(f"    [.] Cookie encontrada: {name}")

    except Exception as e:
        print(f"[!] Error al conectar: {e}")

if __name__ == "__main__":
    objetivo = input("Introduce el dominio (ej: google.com): ")
    analizar_objetivo(objetivo)

¿Cómo funciona este script?

  1. Detección de Software (Server): Si el balanceador no oculta la cabecera, podrías ver el nombre real del servidor detrás (ej. nginx/1.14.1).

  2. Cabeceras de Proxy: Muchos balanceadores mal configurados pasan el nombre de la máquina interna o su IP privada en cabeceras como X-Backend-IP.

  3. Huellas de Cookies: Identifica cookies específicas de fabricantes de hardware como F5 (BIG-IP) o Citrix (NetScaler).

El siguiente nivel: El "Favicon Hash"

Si quieres algo más avanzado, podrías añadir una función que descargue el favicon.ico, calcule su mmh3 hash y te dé el link directo para buscarlo en Shodan. Esa es, con diferencia, la técnica más "ninja" para encontrar la IP real.

Advertencia: Recuerda usar estas herramientas siempre en entornos controlados o sobre sistemas para los que tengas permiso explícito de auditoría.


Esta es una de las técnicas más creativas y efectivas de reconocimiento pasivo. Muchos administradores ocultan su servidor web principal detrás de un WAF (como Cloudflare) o un balanceador de carga, pero olvidan cambiar o bloquear el acceso al archivo del icono de la web (favicon.ico).

Como el favicon suele ser el mismo en el servidor de origen (la IP real) y en el servidor que da la cara al público, podemos usar un motor de búsqueda como Shodan para encontrar cualquier servidor en Internet que tenga exactamente el mismo archivo.

Actualización del Script: Añadiendo el Favicon Hash

Para que esta función funcione, necesitarás instalar dos librerías adicionales en tu Kali Linux:

Bash
pip install mmh3 codecs

  • mmh3 (MurmurHash3): Es el algoritmo de hashing que Shodan utiliza para indexar favicons.

  • codecs: Para codificar el archivo en Base64, que es el formato que requiere mmh3.

Aquí tienes el script completo y actualizado:

Python
import requests
import mmh3
import codecs

# Definir colores para una salida más legible
GREEN = '\033[92m'
RED = '\033[91m'
BLUE = '\033[94m'
ENDC = '\033[0m'

def calcular_favicon_hash(url):
    """Descarga el favicon y calcula su MurmurHash3 en Base64."""
    if not url.startswith('http'):
        url = 'http://' + url
    
    # Intentar asegurar la URL del favicon
    if not url.endswith('.ico'):
        favicon_url = f"{url.rstrip('/')}/favicon.ico"
    else:
        favicon_url = url

    print(f"\n[{BLUE}* {ENDC}] Intentando calcular Hash del Favicon de: {favicon_url}")
    print("-" * 55)

    try:
        # 1. Descargar el archivo favicon
        response = requests.get(favicon_url, timeout=10, stream=True)
        response.raise_for_status() # Lanza excepción si hay error HTTP

        # 2. Codificar el contenido del favicon en Base64
        favicon_content = response.content
        favicon_base64 = codecs.encode(favicon_content, "base64")

        # 3. Calcular el hash MurmurHash3 del contenido Base64
        # Shodan usa una versión firmada de mmh3
        favicon_hash = mmh3.hash(favicon_base64)

        print(f"[{GREEN}!{ENDC}] {GREEN}Favicon Hash encontrado!{ENDC}")
        print(f"[{GREEN}!{ENDC}] {GREEN}Hash MMH3:{ENDC} {favicon_hash}")
        
        # 4. Generar el enlace de búsqueda de Shodan
        shodan_query = f"https://www.shodan.io/search?query=http.favicon.hash%3A{favicon_hash}"
        print(f"\n[{BLUE}* {ENDC}] {BLUE}Copia y pega este enlace en tu navegador para Shodan:{ENDC}")
        print(f"{shodan_query}")

    except requests.exceptions.HTTPError as e:
        print(f"[{RED}X {ENDC}] No se pudo descargar el favicon (Error HTTP): {e}")
    except requests.exceptions.ConnectionError:
        print(f"[{RED}X {ENDC}] Error de conexión al intentar descargar el favicon.")
    except Exception as e:
        print(f"[{RED}X {ENDC}] Ocurrió un error inesperado: {e}")

if __name__ == "__main__":
    print("-" * 55)
    print("      Origin IP Finder - Módulo de Favicon Hash")
    print("-" * 55)
    objetivo = input("Introduce el dominio base (ej: ejemplo.com): ")
    
    # Asegurarnos de tener una URL base limpia
    dominio_limpio = objetivo.replace("https://", "").replace("http://", "").split('/')[0]
    calcular_favicon_hash(dominio_limpio)

Cómo usar los resultados y qué buscar en Shodan

  1. Ejecuta el script: Dale el dominio de tu objetivo (ej: target.com).

  2. Copia el enlace: El script te dará una URL de Shodan como https://www.shodan.io/search?query=http.favicon.hash%3A12345678.

  3. Analiza los resultados en Shodan:

    • Shodan te mostrará una lista de todas las IPs públicas en el mundo que tienen ese favicon.

    • Muchas de esas IPs serán servidores de Cloudflare o Akamai (el balanceador). Esas no te interesan.

    • Busca la IP que "no cuadra": Tienes que buscar una dirección IP que pertenezca a un proveedor de hosting diferente (como DigitalOcean, AWS, OVH, o incluso un servidor dedicado). Esa IP tiene muchas probabilidades de ser la IP real de origen (backend).

Siguientes pasos

Una vez que tengas una IP sospechosa de ser la real:

  1. Verificación Manual: Intenta acceder a esa IP directamente en tu navegador (https://IP_SOSPECHOSA). Si carga el sitio web del objetivo o un panel de administración asociado, lo has encontrado.

  2. Verificación por Cabecera 'Host': A veces el servidor real solo responde si se le pide por su nombre de dominio. Puedes confirmar esto con curl:

    Bash
    curl -H "Host: target.com" http://IP_SOSPECHOSA

    Si el resultado es el código HTML de target.com, has saltado el balanceador.

Advertencia de Ética y Legalidad: Esta técnica se considera reconocimiento pasivo porque no interactúas directamente con el servidor del objetivo (solo con el favicon público y con Shodan). Sin embargo, acceder a la IP real de un servidor sin autorización para buscar vulnerabilidades puede violar las leyes locales o los términos de servicio. Úsalo siempre con permiso o en programas de Bug Bounty.

Location: España

Entradas populares de este blog

Hacking y ciberseguridad en kali linux con Fping

Imagen
  www.onlinetis.com   Hacking y ciberseguridad en kali linux con Fping Fping es un programa similar a ping que utiliza la solicitud de eco del Protocolo de Mensajes de Control de Internet (ICMP) para determinar si un host objetivo responde. fping se diferencia de ping en que permite especificar cualquier número de objetivos en la línea de comandos o un archivo con las listas de objetivos a los que se hará ping. En lugar de enviar a un objetivo hasta que se agote el tiempo de espera o responda, fping envía un paquete de ping y pasa al siguiente objetivo mediante un sistema de turnos rotatorios. Como instalar:  sudo apt install fping fping Enviar paquetes ICMP ECHO_REQUEST a los hosts de la red   fping6 Compatibilidad con versiones anteriores de fping anteriores a la versión 4.0 El comando fping en Kali Linux es una utilidad de red que se utiliza para enviar paquetes de ICMP (Protocolo de mensajes de control de Internet) a varios hosts de forma simultánea. A diferen...
LEER MAS »

Hacking y ciberseguridad en kali linux con atk6-thcping6

Imagen
www.onlinetis.com Hacking y ciberseguridad en kali linux con atk6-thcping6 Parece que estás interesado en usar atk6-thcping6 en Kali Linux. Esta herramienta es parte del conjunto de utilidades thc-ipv6 , diseñado para probar las debilidades del protocolo IPv6. Para usar atk6-thcping6 , primero necesitas tener instalado el paquete thc-ipv6 . En la mayoría de las distribuciones de Kali, ya viene preinstalado, pero si no, puedes instalarlo con el siguiente comando: Bash sudo apt install thc-ipv6 Una vez que lo tienes instalado, la sintaxis básica para atk6-thcping6 es: Bash atk6-thcping6 <interface> <target> [opciones] Aquí está el desglose de los argumentos y opciones más comunes: <interface> : La interfaz de red que usarás para enviar el paquete. Por ejemplo, eth0 , wlan0 , etc. <target> : La dirección IPv6 del objetivo al que quieres hacer ping. [opciones] : Puedes usar varias opciones para modificar el comportamiento del ping. La mejor manera de ver todas la...
LEER MAS »

Como utilizar Fierce en kali linux

Imagen
  www.onlinetis.com   Como utilizar Fierce en kali linux Fierce es un escáner semiligero que ayuda a localizar direcciones IP no contiguas y nombres de host en dominios específicos. Está pensado como precursor de nmap, unicornscan, nessus, nikto, etc., ya que todos ellos requieren que se conozca previamente el espacio IP buscado. No realiza exploits ni escanea internet indiscriminadamente. Está diseñado específicamente para localizar objetivos probables tanto dentro como fuera de una red corporativa. Dado que utiliza principalmente DNS, es frecuente encontrar redes mal configuradas que filtran el espacio de direcciones interno. Esto es especialmente útil en malware dirigido. Originalmente escrito por RSnake y otros en http://ha.ckers.org/. Se trata simplemente de una conversión a Python 3 para simplificar y modernizar el código base. Como instalar: sudo apt install fierce Escáner DNS que ayuda a localizar espacios de IP no contiguos y nombres de host contra dominios específico...
LEER MAS »