Enumeración Pasiva de Subdominios

Enumeración Pasiva de Subdominios

Introducción

La enumeración de subdominios es una de las fases cruciales en la seguridad informática para identificar los subdominios asociados a un dominio principal. Los subdominios son parte de un dominio más grande y a menudo están configurados para apuntar a diferentes recursos de la red, como servidores web, servidores de correo electrónico, sistemas de bases de datos, sistemas de gestión de contenido, entre otros.

Al identificar los subdominios vinculados a un dominio principal, un atacante podría obtener información valiosa para cada uno de estos, lo que le podría llevar a encontrar vectores de ataque potenciales. Por ejemplo, si se identifica un subdominio que apunta a un servidor web vulnerable, el atacante podría utilizar esta información para intentar explotar la vulnerabilidad y acceder al servidor en cuestión.

Diferencias entre Enumeración Pasiva y Activa

Enumeración Pasiva

• No envía solicitudes directas a los servidores objetivo
• Utiliza fuentes públicas de información
• Menor riesgo de detección
• No genera logs en los sistemas objetivo
• Ideal para reconocimiento inicial

Enumeración Activa

• Envía solicitudes directas a los servidores
• Utiliza técnicas de fuerza bruta
• Mayor riesgo de detección
• Genera logs en los sistemas objetivo
• Más exhaustiva pero más ruidosa

Herramientas Pasivas Principales

1. Phonebook.cz

Phonebook es una herramienta online que permite buscar información sobre dominios, subdominios, direcciones de correo electrónico y URLs.

• URL: https://phonebook.cz/
• Características:
  • Búsqueda de subdominios
  • Búsqueda de correos electrónicos
  • Búsqueda de URLs
  • Interfaz web simple
  • Resultados históricos

Uso básico:

1. Acceder a https://phonebook.cz/
2. Seleccionar “Domains” en el menú
3. Introducir el dominio objetivo (ej: example.com)
4. Revisar los resultados obtenidos

2. IntelX.io

IntelX es un motor de búsqueda especializado en inteligencia que indexa datos de múltiples fuentes.

• URL: https://intelx.io/
• Características:
  • Búsqueda en múltiples fuentes de datos
  • Datos históricos extensos
  • API disponible
  • Búsqueda avanzada con operadores

Uso básico:

1. Acceder a https://intelx.io/
2. Usar operadores de búsqueda como site:example.com
3. Filtrar por tipo de contenido
4. Exportar resultados

3. CTFR (Certificate Transparency Finder)

CTFR utiliza los registros de Certificate Transparency para encontrar subdominios.

• GitHub: https://github.com/UnaPibaGeek/ctfr
• Instalación:

git clone https://github.com/UnaPibaGeek/ctfr.git
cd ctfr
pip3 install -r requirements.txt

Uso:

# Búsqueda básica
python3 ctfr.py -d example.com

# Guardar resultados en archivo
python3 ctfr.py -d example.com -o subdominios.txt

# Búsqueda con wildcards
python3 ctfr.py -d example.com -w

4. Sublist3r

Sublist3r es una herramienta que enumera subdominios utilizando múltiples motores de búsqueda.

• GitHub: https://github.com/huntergregal/Sublist3r
• Instalación:

git clone https://github.com/huntergregal/Sublist3r.git
cd Sublist3r
pip install -r requirements.txt

Uso:

# Búsqueda básica
python sublist3r.py -d example.com

# Guardar resultados
python sublist3r.py -d example.com -o subdominios.txt

# Usar threads para mayor velocidad
python sublist3r.py -d example.com -t 100

# Búsqueda silenciosa
python sublist3r.py -d example.com -v

Técnicas Adicionales de Enumeración Pasiva

5. Búsqueda en Motores de Búsqueda

Google Dorking

site:example.com
site:*.example.com
inurl:example.com

Bing

site:example.com
domain:example.com

DuckDuckGo

site:example.com

6. Certificate Transparency Logs

crt.sh

• URL: https://crt.sh/
• Búsqueda: %.example.com
• API: curl -s "https://crt.sh/?q=%.example.com&output=json"

Censys

• URL: https://censys.io/
• Búsqueda avanzada de certificados SSL/TLS

7. DNS Databases

SecurityTrails

• URL: https://securitytrails.com/
• Características:
  • Historial DNS
  • Subdominios históricos
  • API disponible

VirusTotal

• URL: https://www.virustotal.com/
• Sección: Relations → Subdomains

8. Herramientas de Línea de Comandos

Amass (Modo Pasivo)

# Instalación
go install -v github.com/OWASP/Amass/v3/...@master

# Enumeración pasiva
amass enum -passive -d example.com

# Con múltiples fuentes
amass enum -passive -d example.com -src

Subfinder

# Instalación
go install -v github.com/projectdiscovery/subfinder/v2/cmd/subfinder@latest

# Uso básico
subfinder -d example.com

# Con múltiples dominios
subfinder -dL dominios.txt

# Salida en JSON
subfinder -d example.com -o subdominios.json -oJ

Assetfinder

# Instalación
go install github.com/tomnomnom/assetfinder@latest

# Uso básico
assetfinder example.com

# Solo subdominios
assetfinder --subs-only example.com

9. APIs y Servicios Web

Shodan

# Búsqueda por dominio
shodan search hostname:example.com

# API
curl -s "https://api.shodan.io/shodan/host/search?key=YOUR_API_KEY&query=hostname:example.com"

RapidDNS

• URL: https://rapiddns.io/
• Búsqueda: Introducir dominio objetivo

DNSdumpster

• URL: https://dnsdumpster.com/
• Características:
  • Mapeo visual de subdominios
  • Información de DNS
  • Detección de tecnologías

Automatización y Scripts

Script Bash para Enumeración Múltiple

#!/bin/bash

domain=$1
output_dir="enum_$domain"

if [ -z "$domain" ]; then
    echo "Uso: $0 <dominio>"
    exit 1
fi

mkdir -p $output_dir
cd $output_dir

echo "[+] Iniciando enumeración pasiva de $domain"

# Subfinder
echo "[+] Ejecutando Subfinder..."
subfinder -d $domain -o subfinder.txt

# Assetfinder
echo "[+] Ejecutando Assetfinder..."
assetfinder $domain > assetfinder.txt

# CTFR
echo "[+] Ejecutando CTFR..."
python3 /path/to/ctfr/ctfr.py -d $domain -o ctfr.txt

# Amass pasivo
echo "[+] Ejecutando Amass (pasivo)..."
amass enum -passive -d $domain -o amass.txt

# Combinar y limpiar resultados
echo "[+] Combinando resultados..."
cat *.txt | sort -u > all_subdomains.txt

echo "[+] Enumeración completada. Resultados en $output_dir/all_subdomains.txt"
echo "[+] Total de subdominios encontrados: $(wc -l < all_subdomains.txt)"

Script Python para APIs Múltiples

#!/usr/bin/env python3

import requests
import json
import sys

def crtsh_search(domain):
    """Búsqueda en crt.sh"""
    url = f"https://crt.sh/?q=%.{domain}&output=json"
    try:
        response = requests.get(url, timeout=30)
        data = response.json()
        subdomains = set()
        for cert in data:
            name = cert.get('name_value', '')
            if name:
                subdomains.update(name.split('\n'))
        return list(subdomains)
    except:
        return []

def virustotal_search(domain, api_key):
    """Búsqueda en VirusTotal"""
    url = f"https://www.virustotal.com/vtapi/v2/domain/report"
    params = {'apikey': api_key, 'domain': domain}
    try:
        response = requests.get(url, params=params, timeout=30)
        data = response.json()
        return data.get('subdomains', [])
    except:
        return []

def main():
    if len(sys.argv) < 2:
        print("Uso: python3 enum_passive.py <dominio> [vt_api_key]")
        sys.exit(1)

    domain = sys.argv[1]
    vt_api_key = sys.argv[2] if len(sys.argv) > 2 else None

    print(f"[+] Enumerando subdominios para {domain}")

    # crt.sh
    print("[+] Buscando en crt.sh...")
    crt_subs = crtsh_search(domain)
    print(f"    Encontrados: {len(crt_subs)}")

    # VirusTotal (si se proporciona API key)
    vt_subs = []
    if vt_api_key:
        print("[+] Buscando en VirusTotal...")
        vt_subs = virustotal_search(domain, vt_api_key)
        print(f"    Encontrados: {len(vt_subs)}")

    # Combinar resultados
    all_subs = set(crt_subs + vt_subs)
    all_subs = [sub for sub in all_subs if domain in sub]

    # Guardar resultados
    with open(f"{domain}_subdomains.txt", "w") as f:
        for sub in sorted(all_subs):
            f.write(f"{sub}\n")

    print(f"[+] Total de subdominios únicos: {len(all_subs)}")
    print(f"[+] Resultados guardados en {domain}_subdomains.txt")

if __name__ == "__main__":
    main()

Mejores Prácticas

1. Combinación de Fuentes

• Usar múltiples herramientas para obtener resultados más completos
• Combinar diferentes fuentes de datos
• Verificar la validez de los subdominios encontrados

2. Organización de Resultados

# Limpiar y organizar subdominios
sort -u subdominios.txt | grep -E "^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$" > subdominios_limpios.txt

# Filtrar por dominio específico
grep "example\.com$" subdominios.txt > subdominios_example.txt

# Eliminar wildcards y caracteres especiales
sed 's/\*\.//g' subdominios.txt | sort -u > subdominios_sin_wildcards.txt

3. Validación de Subdominios

# Verificar resolución DNS
for sub in $(cat subdominios.txt); do
    if nslookup $sub > /dev/null 2>&1; then
        echo $sub >> subdominios_activos.txt
    fi
done

# Verificar respuesta HTTP
for sub in $(cat subdominios_activos.txt); do
    if curl -s -I "http://$sub" | grep -q "HTTP"; then
        echo $sub >> subdominios_web.txt
    fi
done

Consideraciones de Seguridad

Aspectos Legales

• Obtener autorización antes de realizar enumeración
• Respetar términos de servicio de las herramientas utilizadas
• Documentar el proceso para auditorías

Detección y Evasión

• La enumeración pasiva es difícil de detectar
• No genera logs en los sistemas objetivo
• Usar proxies o VPN para mayor anonimato
• Rotar fuentes para evitar rate limiting

Rate Limiting

• Respetar límites de las APIs
• Implementar delays entre solicitudes
• Usar múltiples fuentes para distribuir carga

Recursos Adicionales

Herramientas Complementarias

• Aquatone: Screenshots de subdominios
• HTTProbe: Verificación de servicios HTTP
• MassDNS: Resolución masiva de DNS

Fuentes de Información

• Certificate Transparency Logs
• DNS Zone Files
• Web Archives (Wayback Machine)
• Social Media y Foros
• Documentación Pública

APIs Útiles

• Censys API
• Shodan API
• VirusTotal API
• SecurityTrails API
• PassiveTotal API

Conclusión

La enumeración pasiva de subdominios es una técnica fundamental en el reconocimiento de objetivos que permite obtener información valiosa sin alertar a los sistemas de defensa. La combinación de múltiples herramientas y fuentes de datos maximiza la efectividad del proceso, proporcionando una base sólida para las siguientes fases del pentesting.

La clave del éxito radica en la sistematización del proceso, la combinación de múltiples fuentes y la validación posterior de los resultados obtenidos.