Técnicas de Recon avanzadas

¿Por qué el recon es tan importante?

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.

Enumeración de subdominios

Fuentes pasivas

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

Fuentes activas

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

Combinar y deduplicar resultados

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)"

Port scanning

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

Análisis de archivos JavaScript

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

Herramientas especializadas para análisis JS

# 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 dorking

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

Herramientas de automatización

# 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

Wayback Machine

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

Fingerprinting de tecnologías

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

Construir pipelines de automatización

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

Monitorización continua

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

Conclusión

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.