Lleva tu fase de reconocimiento al siguiente nivel con técnicas avanzadas de enumeración de subdominios, análisis de archivos JavaScript, GitHub dorking y automatización.
BBLabs
Security Researcher
La fase de reconocimiento es donde se ganan o se pierden los bounties. Un recon profundo te permite descubrir activos olvidados, endpoints no documentados y superficies de ataque que otros hunters pasan por alto. La regla de oro es: mientras más amplia sea tu superficie de ataque, más probabilidades tienes de encontrar vulnerabilidades.
Las fuentes pasivas te dan subdominios sin tocar directamente el objetivo:
# Subfinder - consulta múltiples fuentes de datos
subfinder -d target.com -all -silent | sort -u > subs_subfinder.txt
# Amass - enumeración exhaustiva con múltiples técnicas
amass enum -passive -d target.com -o subs_amass.txt
# crt.sh - certificados SSL/TLS (manual o con curl)
curl -s "https://crt.sh/?q=%.target.com&output=json" | \
jq -r '.[].name_value' | sort -u > subs_crtsh.txt
Las fuentes activas interactúan con el objetivo para descubrir subdominios que no aparecen en fuentes públicas:
# Fuerza bruta de subdominios con una wordlist
ffuf -u "https://FUZZ.target.com" -w /path/to/subdomains.txt \
-mc 200,301,302,403 -o subs_bruteforce.txt
# DNS zone transfer (raro pero vale la pena probar)
dig axfr target.com @ns1.target.com
# Resolución masiva para verificar qué subdominios existen
cat all_subs.txt | httpx -silent -status-code -title > alive_hosts.txt
cat subs_subfinder.txt subs_amass.txt subs_crtsh.txt subs_bruteforce.txt | \
sort -u > all_subdomains.txt
echo "[+] Total de subdominios únicos: $(wc -l < all_subdomains.txt)"
No te limites a los puertos web estándar (80/443). Muchos servicios interesantes corren en puertos altos:
# Nmap - escaneo completo de puertos
nmap -sS -p- --min-rate 1000 -T4 target.com -oN ports.txt
# Puertos comunes interesantes
# 8080, 8443 - Servidores web alternativos
# 3000 - Node.js / Grafana
# 8888 - Jupyter Notebook
# 9200 - Elasticsearch
# 6379 - Redis
# 27017 - MongoDB
Los archivos JavaScript son una mina de oro. Contienen endpoints de API, tokens, claves y lógica de negocio:
# Extraer URLs de archivos JS con gau y filtrar
gau target.com | grep "\.js$" | sort -u > js_files.txt
# Descargar y analizar archivos JS
while read url; do
curl -s "$url" >> all_js.txt
done < js_files.txt
# Buscar endpoints de API en los archivos JS
grep -oP '["'"'"']/api/[a-zA-Z0-9/_-]+' all_js.txt | sort -u
# Buscar tokens y secretos
grep -iE '(api[_-]?key|secret|token|password|auth)\s*[:=]' all_js.txt
# LinkFinder - extrae endpoints de archivos JS
python3 linkfinder.py -i https://target.com/app.js -o cli
# SecretFinder - busca secretos en archivos JS
python3 SecretFinder.py -i https://target.com/app.js -o cli
GitHub es una fuente increíble de información sensible. Los desarrolladores cometen errores y publican credenciales, endpoints internos y documentación privada:
# Dorks útiles en GitHub Search
"target.com" password
"target.com" api_key
"target.com" secret
org:targetorg filename:.env
org:targetorg filename:config extension:json
org:targetorg "BEGIN RSA PRIVATE KEY"
org:targetorg jdbc OR mysql OR postgresql
# truffleHog - busca secretos en repositorios git
trufflehog git https://github.com/target/repo
# gitdorker - automatiza dorks de GitHub
python3 gitdorker.py -t TOKEN -org target -d dorks/medium.txt
El Wayback Machine de Internet Archive almacena snapshots históricos de sitios web. Puedes encontrar endpoints antiguos, paneles de administración eliminados y archivos sensibles:
# waybackurls - obtener URLs históricas
echo "target.com" | waybackurls | sort -u > wayback_urls.txt
# Filtrar por extensiones interesantes
cat wayback_urls.txt | grep -iE "\.(php|asp|aspx|jsp|json|xml|config|env|sql|bak|old|backup)"
# Buscar parámetros potencialmente vulnerables
cat wayback_urls.txt | grep "=" | qsreplace "FUZZ" | sort -u > params_to_test.txt
Conocer las tecnologías del objetivo te ayuda a buscar CVEs específicos y adaptar tus ataques:
# Wappalyzer CLI
wappalyzer https://target.com
# httpx con detección de tecnologías
echo "target.com" | httpx -tech-detect -status-code -title
# whatweb
whatweb https://target.com
El objetivo final es automatizar todo el proceso de reconocimiento para poder ejecutarlo periódicamente y detectar cambios:
#!/bin/bash
# recon-pipeline.sh
DOMAIN=$1
DATE=$(date +%Y%m%d)
DIR=~/recon/$DOMAIN/$DATE
mkdir -p $DIR
# Paso 1: Subdominios
subfinder -d $DOMAIN -silent | sort -u > $DIR/subs.txt
amass enum -passive -d $DOMAIN >> $DIR/subs.txt
sort -u -o $DIR/subs.txt $DIR/subs.txt
# Paso 2: Hosts activos
cat $DIR/subs.txt | httpx -silent -status-code -title -tech-detect \
-o $DIR/alive.txt
# Paso 3: URLs y parámetros
cat $DIR/alive.txt | cut -d' ' -f1 | gau --threads 5 | sort -u > $DIR/urls.txt
# Paso 4: Escaneo con Nuclei
nuclei -l $DIR/alive.txt -severity medium,high,critical \
-o $DIR/nuclei_results.txt
# Paso 5: Diff con resultados anteriores
PREV=$(ls -d ~/recon/$DOMAIN/*/subs.txt 2>/dev/null | tail -2 | head -1)
if [ -n "$PREV" ]; then
diff $PREV $DIR/subs.txt | grep "^>" > $DIR/new_subs.txt
echo "[!] Nuevos subdominios encontrados: $(wc -l < $DIR/new_subs.txt)"
fi
Los mejores hunters no hacen recon una sola vez. Configuran monitores que les alertan cuando aparecen nuevos subdominios o cambios en la infraestructura:
# Ejecutar tu pipeline cada 24 horas con cron
0 2 * * * /home/user/recon-pipeline.sh target.com
# Usar servicios como Shodan Monitor o herramientas como notify
# para recibir alertas en Slack, Telegram o Discord
El reconocimiento avanzado no se trata de usar más herramientas, sino de ser más creativo y sistemático en cómo buscas información. Combina fuentes pasivas y activas, analiza archivos JavaScript, busca en GitHub, aprovecha los datos históricos y automatiza todo lo que puedas. La diferencia entre encontrar un bug y no encontrarlo muchas veces está en la profundidad de tu reconocimiento.