# Método 1: pip (recomendado)
pip3 install spiderfoot
spiderfoot -l 127.0.0.1:5001
SpiderFoot v4.0 — https://www.spiderfoot.net
Listening on: http://127.0.0.1:5001

# Método 2: desde fuente (última versión)
git clone https://github.com/smicallef/spiderfoot.git
cd spiderfoot
pip3 install -r requirements.txt
python3 sf.py -l 127.0.0.1:5001

# Método 3: Docker (aislado, recomendado para producción)
docker pull smicallef/spiderfoot
docker run -p 5001:5001 smicallef/spiderfoot

# Kali Linux (ya incluido)
spiderfoot -l 127.0.0.1:5001

# Acceder a la interfaz web
firefox http://127.0.0.1:5001

# SpiderFoot HX (versión cloud — gratuita con límites)
# https://www.spiderfoot.net/hx/ — no requiere instalación

# SpiderFoot guarda su configuración en ~/.spiderfoot/
ls ~/.spiderfoot/
spiderfoot.db   ← base de datos SQLite con todos los escaneos
spiderfoot.conf ← configuración y API keys

# Ver la versión y módulos disponibles
python3 sf.py -M
sfp_arin             OSINT/Infrastructure  Queries ARIN for IP ownership
sfp_shodan           OSINT/Search Engines  Queries Shodan
sfp_haveibeenpwned   OSINT/Data Breach     Queries HaveIBeenPwned
...
[Total: 212 modules]

# Escaneo básico de dominio con todos los módulos
python3 sf.py -s example.com -t DOMAIN_NAME -o json > results.json

# Escaneo con módulos específicos
python3 sf.py -s example.com -t DOMAIN_NAME \
  -m sfp_dnsbrute,sfp_ssl,sfp_shodan,sfp_emailformat,sfp_whois \
  -o csv > recon_domain.csv

# Escaneo pasivo únicamente (sin contactar el target)
python3 sf.py -s example.com -t DOMAIN_NAME \
  -u Passive -o json > passive_recon.json

# Ver módulos disponibles por uso
python3 sf.py -M | grep "Passive"

# Parsear resultados JSON
cat results.json | python3 -c "
import json,sys
data=json.load(sys.stdin)
for r in data:
    if r['type'] in ['SUBDOMAIN','IP_ADDRESS','EMAILADDR']:
        print(f'[{r[\"type\"]}] {r[\"data\"]}')
" | sort -u
[EMAILADDR] admin@example.com
[EMAILADDR] info@example.com
[IP_ADDRESS] 93.184.216.34
[SUBDOMAIN] api.example.com
[SUBDOMAIN] mail.example.com
[SUBDOMAIN] dev.example.com

# Escaneo focalizado en emails
python3 sf.py -s example.com -t DOMAIN_NAME \
  -m sfp_emailformat,sfp_hunter,sfp_google,sfp_bing,sfp_dnsraw,sfp_haveibeenpwned \
  -o json > emails_recon.json

# Extraer solo emails del JSON
cat emails_recon.json | python3 -c "
import json,sys
data=json.load(sys.stdin)
emails = set()
for r in data:
    if 'EMAILADDR' in r['type']:
        emails.add(r['data'])
        status = '← COMPROMETIDO' if 'COMPROMISED' in r['type'] else ''
        print(f'{r[\"data\"]} {status}')
"
admin@example.com ← COMPROMETIDO (breach: Collection#1, LinkedIn)
ceo@example.com
dev@example.com ← COMPROMETIDO (breach: Adobe 2013)
info@example.com
john.doe@example.com

# Verificar formato de email de la empresa (para ataques de phishing en pentests)
# SpiderFoot infiere el patrón: nombre.apellido@ / inicial.apellido@ / etc.
python3 sf.py -s example.com -t DOMAIN_NAME -m sfp_emailformat -o json | \
  python3 -c "
import json,sys
for r in json.load(sys.stdin):
    if r['type'] == 'EMAIL_FORMAT':
        print('Formato detectado:', r['data'])
"
Formato detectado: {nombre}.{apellido}@example.com

# Escaneo partiendo de un email conocido
python3 sf.py -s admin@example.com -t EMAILADDR \
  -m sfp_haveibeenpwned,sfp_emailrep,sfp_linkedin \
  -o json > email_intel.json

# Buscar empleados de una empresa en LinkedIn
python3 sf.py -s "Example Corp" -t COMPANY_NAME \
  -m sfp_linkedin,sfp_emailformat \
  -o json > employees.json
[LINKEDIN_PROFILE] John Doe — CTO at Example Corp
[LINKEDIN_PROFILE] Jane Smith — CISO at Example Corp
[EMAILADDR] john.doe@example.com (inferred from LinkedIn + email format)
[EMAILADDR] jane.smith@example.com

# Partiendo de un nombre completo
python3 sf.py -s "John Doe" -t PERSON_NAME \
  -m sfp_linkedin,sfp_twitter,sfp_github,sfp_emailformat \
  -o json > person_osint.json
[SOCIAL_MEDIA] https://twitter.com/johndoe
[SOCIAL_MEDIA] https://github.com/jdoe-corp
[EMAILADDR] john@example.com
[EMAILADDR] johndoe@gmail.com

# Buscar un username en múltiples plataformas
python3 sf.py -s johndoe -t USERNAME \
  -m sfp_social_media,sfp_paste_sites \
  -o json > username_recon.json
[ACCOUNT_EXTERNAL_OWNED] Reddit: https://reddit.com/u/johndoe
[ACCOUNT_EXTERNAL_OWNED] GitHub: https://github.com/johndoe
[ACCOUNT_EXTERNAL_OWNED] HackerNews: https://news.ycombinator.com/user?id=johndoe
[AFFILIATE_INTERNET_NAME] johndoe.dev (dominio personal registrado)

# Analizar una IP concreta
python3 sf.py -s 93.184.216.34 -t IP_ADDRESS \
  -m sfp_whois,sfp_arin,sfp_shodan,sfp_virustotal,sfp_ipinfo \
  -o json > ip_intel.json
[IP_ADDRESS]       93.184.216.34
[GEOINFO]          United States, Massachusetts, Norwood
[BGP_AS_OWNED]     AS15133 (EdgeCast/Verizon Digital Media)
[TCP_PORT_OPEN]    80 (Apache/2.4.52)
[TCP_PORT_OPEN]    443 (nginx)
[VULNERABILITY]    CVE-2021-41773 — Apache Path Traversal (CVSS 9.8)
[MALICIOUS_IPADDR] Listed in: Spamhaus XBL, SORBS

# Analizar un rango completo (ASN de una empresa)
python3 sf.py -s "AS15169" -t ASN \
  -m sfp_arin,sfp_bgp,sfp_shodan \
  -o json > asn_google.json

# Escanear por nombre de empresa para encontrar todos sus IPs
python3 sf.py -s "Example Corp" -t COMPANY_NAME \
  -m sfp_arin,sfp_whois,sfp_shodan \
  -o json > company_ips.json

# Buckets S3 y storage cloud expuesto
python3 sf.py -s example.com -t DOMAIN_NAME \
  -m sfp_s3buckets,sfp_azure,sfp_gcs \
  -o json > cloud_exposure.json
[CLOUD_STORAGE_BUCKET] example-backups.s3.amazonaws.com (PUBLIC!)
[CLOUD_STORAGE_BUCKET] example-prod-assets.s3.amazonaws.com (PUBLIC!)
[CLOUD_STORAGE_BUCKET] example-logs.blob.core.windows.net

# Las API keys se almacenan en ~/.spiderfoot/spiderfoot.db
# O pueden pasarse como argumentos en el CLI

# Ver configuración actual (incluye API keys configuradas)
python3 sf.py -c
sfp_shodan      Shodan API Key       → *** (configurada)
sfp_hunter      Hunter.io API Key    → (no configurada)
sfp_virustotal  VirusTotal API Key   → *** (configurada)

# Tabla de APIs más importantes con su URL de registro
# ─────────────────────────────────────────────────────
Shodan:         account.shodan.io     ← puertos, banners, CVEs (free: 100 queries)
VirusTotal:     virustotal.com        ← threat intel, malware (free: 500 req/day)
Hunter.io:      hunter.io             ← emails de empresa (free: 25 búsquedas/mes)
HaveIBeenPwnd:  haveibeenpwned.com    ← brechas (free API key disponible)
SecurityTrails: securitytrails.com    ← DNS histórico, subdominios (free: 50 queries)
GreyNoise:      greynoise.io          ← clasificación de IPs (free: community)
Censys:         search.censys.io      ← internet scan data (free: 250 req/month)
IntelX:         intelx.io             ← dark web, leaks (free limitado)
Builtwith:      builtwith.com         ← tecnologías web (free: básico)

# Escaneo focalizado en Shodan para mapear infraestructura
python3 sf.py -s example.com -t DOMAIN_NAME \
  -m sfp_shodan,sfp_shodan_org \
  -o json > shodan_recon.json

# Ver qué encuentra Shodan para cada IP del target
cat shodan_recon.json | python3 -c "
import json,sys
data = json.load(sys.stdin)
for r in data:
    t = r['type']
    if t in ['TCP_PORT_OPEN','VULNERABILITY','WEBSERVER_BANNER','OPERATING_SYSTEM']:
        print(f'[{t}] {r[\"source\"]} → {r[\"data\"]}')
"
[TCP_PORT_OPEN]      93.184.216.34 → 80 (Apache httpd 2.4.52)
[TCP_PORT_OPEN]      93.184.216.34 → 443 (nginx 1.20.0)
[TCP_PORT_OPEN]      93.184.216.34 → 22 (OpenSSH 8.9)
[VULNERABILITY]      93.184.216.34 → CVE-2021-41773 (CVSS: 9.8) Path Traversal
[OPERATING_SYSTEM]   93.184.216.34 → Ubuntu 22.04 LTS
[WEBSERVER_BANNER]   93.184.216.34 → Apache/2.4.52 (Ubuntu)

# Shodan dorks via SpiderFoot (buscar todas las IPs de una org)
python3 sf.py -s "Example Corp" -t COMPANY_NAME \
  -m sfp_shodan_org -o json > shodan_org.json
[IP_ADDRESS] 203.0.113.1 (Shodan: org:Example Corp)
[IP_ADDRESS] 203.0.113.2 (Shodan: org:Example Corp)
[TCP_PORT_OPEN] 203.0.113.1:8080 → Tomcat 9.0.58 — VULNERABLE

# Verificar emails de un dominio en bases de brechas
python3 sf.py -s example.com -t DOMAIN_NAME \
  -m sfp_emailformat,sfp_google,sfp_haveibeenpwned \
  -o json > breach_check.json

# Extraer credenciales comprometidas del resultado
cat breach_check.json | python3 -c "
import json,sys
data=json.load(sys.stdin)
breached=[]
for r in data:
    if r['type'] == 'EMAILADDR_COMPROMISED':
        breached.append(r)
        print(f'[BRECHA] {r[\"data\"]}')
        print(f'  Fuente: {r[\"source\"]}')
print(f'Total comprometidos: {len(breached)}')
"
[BRECHA] admin@example.com
  Fuente: HaveIBeenPwned — Collection#1, LinkedIn 2021
[BRECHA] john.doe@example.com
  Fuente: HaveIBeenPwned — Adobe 2013, Dropbox 2012
[BRECHA] dev@example.com
  Fuente: HaveIBeenPwned — RockYou2021
Total comprometidos: 3

# Buscar la empresa en IntelligenceX (dark web, pastes)
python3 sf.py -s example.com -t DOMAIN_NAME \
  -m sfp_intelx,sfp_paste_sites \
  -o json > darkweb_mentions.json
[LEAKSITE_URL]   pastebin.com/xxx → Contiene: "example.com credentials"
[LEAKSITE_CONTENT] "admin:P@ssw0rd123, john.doe:Welcome1"

## sf.py — sintaxis principal
python3 sf.py [opciones]

-s TARGET      → objetivo del escaneo
-t TYPE        → tipo: DOMAIN_NAME, IP_ADDRESS, EMAILADDR, etc.
-m MODULES     → módulos separados por coma (o -u para use case)
-u USECASE     → All, Footprint, Investigate, Passive
-o FORMAT      → json, csv, tab, gexf (graph format)
-f             → filtrar solo datos de interés directo al target
-M             → listar todos los módulos disponibles
-T             → listar todos los tipos de dato
-l HOST:PORT   → arrancar servidor web en esa dirección
-x             → exportar resultados de un escaneo previo

## Ejemplos prácticos

# Escaneo rápido pasivo con salida formateada
python3 sf.py -s target.com -t DOMAIN_NAME -u Passive -o json -f | \
  python3 -m json.tool | grep -A2 '"type": "SUBDOMAIN"'

# Listar solo tipos de datos de una categoría
python3 sf.py -T | grep -i email
EMAILADDR          Email address
EMAILADDR_COMPROMISED  Email address compromised in breach
EMAIL_FORMAT        Typical email format for target

# Escaneo con timeout (útil en CI/CD)
timeout 1800 python3 sf.py -s target.com -t DOMAIN_NAME -u Footprint -o json > recon.json

# sfcli.py — cliente para SpiderFoot corriendo como servidor
python3 sfcli.py -s http://127.0.0.1:5001
sf > scan create target.com DOMAIN_NAME All recon_scan_1
sf > scan status recon_scan_1
sf > scan data recon_scan_1 json > results.json

## Script: recon_pipeline.sh — Reconocimiento automático completo
cat > recon_pipeline.sh << 'EOF'
#!/bin/bash
# GhostAcademy — SpiderFoot OSINT Pipeline

TARGET=$1
OUTDIR="recon_$(echo $TARGET | tr '.' '_')_$(date +%Y%m%d)"
mkdir -p "$OUTDIR"

echo "[*] Iniciando reconocimiento de: $TARGET"

# Fase 1: Reconocimiento pasivo rápido (sin tocar el target)
echo "[1/3] Reconocimiento pasivo..."
python3 /opt/spiderfoot/sf.py -s "$TARGET" -t DOMAIN_NAME \
  -u Passive -o json > "$OUTDIR/passive.json"

# Fase 2: Footprint completo
echo "[2/3] Footprint de infraestructura..."
python3 /opt/spiderfoot/sf.py -s "$TARGET" -t DOMAIN_NAME \
  -u Footprint -o json > "$OUTDIR/footprint.json"

# Fase 3: Extraer IOCs para informe
echo "[3/3] Extrayendo resultados..."
python3 - << PYTHON
import json

categories = {
    "subdominios": "SUBDOMAIN",
    "ips": "IP_ADDRESS",
    "emails": "EMAILADDR",
    "brechas": "EMAILADDR_COMPROMISED",
    "puertos": "TCP_PORT_OPEN",
    "vulnerabilidades": "VULNERABILITY",
    "buckets_cloud": "CLOUD_STORAGE_BUCKET"
}

for phase in ["passive", "footprint"]:
    with open(f"$OUTDIR/{phase}.json") as f:
        data = json.load(f)
    for label, dtype in categories.items():
        items = [r["data"] for r in data if r["type"] == dtype]
        if items:
            print(f"\n[{label.upper()}] ({len(items)} encontrados):")
            for item in sorted(set(items)):
                print(f"  {item}")
PYTHON

echo "[*] Resultados en: $OUTDIR/"
echo "[*] Abrir informe: firefox $OUTDIR/report.html"
EOF
chmod +x recon_pipeline.sh
./recon_pipeline.sh example.com

## Monitorización continua (ASM — Attack Surface Management)
cat > /etc/cron.weekly/sf_monitor << 'EOF'
#!/bin/bash
# Escaneo semanal y alerta si hay nuevos subdominios o brechas
python3 /opt/spiderfoot/sf.py -s miempresa.com -t DOMAIN_NAME \
  -u Footprint -o json > /tmp/sf_weekly.json
python3 /opt/spiderfoot/compare_scans.py /tmp/sf_last.json /tmp/sf_weekly.json | \
  mail -s "SpiderFoot: Nuevos hallazgos" security@miempresa.com
cp /tmp/sf_weekly.json /tmp/sf_last.json
EOF
chmod +x /etc/cron.weekly/sf_monitor

## Objetivos legales para práctica:
# - scanme.nmap.org (autorizado por nmap.org)
# - hackthebox.com (plataforma de CTF — permite OSINT pasivo)
# - tryhackme.com (ídem)
# - Tu propia infraestructura

## PASO 1: Arrancar SpiderFoot
python3 sf.py -l 127.0.0.1:5001 &
echo "SpiderFoot corriendo en http://127.0.0.1:5001"

## PASO 2: Escaneo pasivo (seguro, sin tocar el target)
python3 sf.py -s hackthebox.com -t DOMAIN_NAME -u Passive -o json > /tmp/htb_passive.json

## PASO 3: Ver subdominios descubiertos
cat /tmp/htb_passive.json | python3 -c "
import json,sys
data=json.load(sys.stdin)
subs = sorted(set(r['data'] for r in data if r['type']=='SUBDOMAIN'))
print(f'[+] {len(subs)} subdominios encontrados:')
for s in subs: print(f'  {s}')
"

## PASO 4: Footprint con módulos selectos
python3 sf.py -s hackthebox.com -t DOMAIN_NAME \
  -m sfp_dnsbrute,sfp_ssl,sfp_whois,sfp_emailformat,sfp_shodan \
  -o json > /tmp/htb_footprint.json

## PASO 5: Generar resumen ejecutivo
python3 - << 'EOF'
import json
with open('/tmp/htb_footprint.json') as f:
    data = json.load(f)

types = {}
for r in data:
    types[r['type']] = types.get(r['type'], 0) + 1

print("=== RESUMEN DE HALLAZGOS ===")
for t, count in sorted(types.items(), key=lambda x: -x[1])[:15]:
    print(f"  {t:<35} {count:>4} hallazgos")
EOF

## ETAPA 1: Mapear el dominio
python3 sf.py -s TARGET_COMPANY.com -t DOMAIN_NAME \
  -u Footprint -o json > stage1_domain.json

# Extraer emails descubiertos para la siguiente etapa
python3 -c "
import json
with open('stage1_domain.json') as f: data=json.load(f)
emails=[r['data'] for r in data if r['type']=='EMAILADDR']
with open('discovered_emails.txt','w') as f: f.write('\n'.join(set(emails)))
print(f'[+] {len(set(emails))} emails para siguiente etapa')
"

## ETAPA 2: Verificar emails en brechas
for email in $(cat discovered_emails.txt); do
  python3 sf.py -s "$email" -t EMAILADDR \
    -m sfp_haveibeenpwned -o json >> stage2_breaches.json
done

## ETAPA 3: Buscar empleados en LinkedIn
python3 sf.py -s "Target Company" -t COMPANY_NAME \
  -m sfp_linkedin,sfp_emailformat \
  -o json > stage3_employees.json

## ETAPA 4: Cloud storage público
python3 sf.py -s TARGET_COMPANY.com -t DOMAIN_NAME \
  -m sfp_s3buckets,sfp_azure,sfp_gcs \
  -o json > stage4_cloud.json

## ETAPA 5: Dark web mentions
python3 sf.py -s TARGET_COMPANY.com -t DOMAIN_NAME \
  -m sfp_intelx,sfp_paste_sites \
  -o json > stage5_darkweb.json

## RESUMEN: consolidar todo
python3 - << 'EOF'
import json, glob

all_findings = {}
for fname in glob.glob('stage*.json'):
    with open(fname) as f:
        try: data = json.load(f)
        except: continue
    for r in data:
        t = r['type']
        if t not in all_findings: all_findings[t] = []
        all_findings[t].append(r['data'])

critical = ['EMAILADDR_COMPROMISED','CLOUD_STORAGE_BUCKET','VULNERABILITY','LEAKSITE_CONTENT']
print("=== HALLAZGOS CRÍTICOS ===")
for cat in critical:
    items = all_findings.get(cat, [])
    if items:
        print(f"\n[{cat}] ({len(items)}):")
        for i in set(items): print(f"  {i}")
EOF

## Método 1: Desde la interfaz web
# 1. Abrir el escaneo completado en http://127.0.0.1:5001/scans
# 2. Click en "Report" (pestaña superior)
# 3. Seleccionar formato: HTML (para presentar) o CSV (para análisis)
# 4. Download

## Método 2: Exportar desde CLI
python3 sfcli.py -s http://127.0.0.1:5001 -x SCAN_ID -o html > informe.html
python3 sfcli.py -s http://127.0.0.1:5001 -x SCAN_ID -o csv > datos.csv
python3 sfcli.py -s http://127.0.0.1:5001 -x SCAN_ID -o json > datos.json

## Método 3: Generar informe ejecutivo personalizado en Python
python3 << 'EOF'
import json
from datetime import datetime

with open('recon_results.json') as f:
    data = json.load(f)

# Clasificar por criticidad
critical, high, medium, info = [], [], [], []
for r in data:
    if r['type'] in ['EMAILADDR_COMPROMISED','VULNERABILITY','LEAKSITE_CONTENT','CLOUD_STORAGE_BUCKET']:
        critical.append(r)
    elif r['type'] in ['TCP_PORT_OPEN','EMAILADDR','WEBSERVER_BANNER']:
        high.append(r)
    elif r['type'] in ['SUBDOMAIN','IP_ADDRESS','SSL_CERTIFICATE']:
        medium.append(r)
    else:
        info.append(r)

print(f"INFORME DE RECONOCIMIENTO OSINT")
print(f"Fecha: {datetime.now().strftime('%Y-%m-%d %H:%M')}")
print(f"{'='*60}")
print(f"\n[CRÍTICO] {len(critical)} hallazgos:")
for r in critical[:10]: print(f"  ✗ [{r['type']}] {r['data'][:80]}")
print(f"\n[ALTO] {len(high)} hallazgos:")
for r in high[:10]: print(f"  ! [{r['type']}] {r['data'][:80]}")
print(f"\n[MEDIO] {len(medium)} subdominios/IPs")
print(f"[INFO] {len(info)} datos de contexto")
print(f"\nTotal: {len(data)} elementos recopilados")
EOF

## 1. Usar SIEMPRE modo Passive primero
python3 sf.py -s target.com -t DOMAIN_NAME -u Passive -o json > passive.json
# Solo consulta terceros (Shodan, crt.sh, Google) — el target NO recibe peticiones

## 2. SpiderFoot detrás de Tor
sudo apt install tor -y && sudo systemctl start tor
export http_proxy=socks5://127.0.0.1:9050
export https_proxy=socks5://127.0.0.1:9050
python3 sf.py -s target.com -t DOMAIN_NAME -u Passive -o json > passive_tor.json

## 3. SpiderFoot detrás de VPN
# Usar una VPN comercial antes de lanzar escaneos activos
sudo openvpn --config vpn_config.ovpn --daemon
curl ifconfig.me  # verificar IP de salida

## 4. Limitar módulos activos que contactan el target
# Estos módulos SÍ contactan el target directamente:
# sfp_dnsbrute   → envía queries DNS al target
# sfp_spider     → crawlea el sitio web
# sfp_portscan   → escanea puertos directamente
# Estos módulos NO contactan el target:
# sfp_crt        → consulta crt.sh (tercero)
# sfp_shodan     → consulta Shodan (tercero)
# sfp_virustotal → consulta VirusTotal (tercero)

## 5. Usar SpiderFoot HX (cloud) para no exponer tu IP
# https://www.spiderfoot.net/hx/ — escaneos corren en servidores de SF

## Unión Europea — GDPR (Reglamento General de Protección de Datos)
✓ Investigar empresas y sus infraestructuras públicas → Legal
✓ Recopilar emails corporativos en contexto de pentest → Legal con contrato
✗ Almacenar datos personales de individuos sin base legal → Ilegal
✗ Publicar datos personales encontrados → Puede ser ilegal

## España — LOPD-GDD (Ley Orgánica 3/2018)
✓ OSINT de infraestructuras técnicas → Legal
✓ Reconocimiento en pentest con contrato → Legal
✗ Recopilación masiva de datos personales → Requiere base legal

## Regla práctica para pentests
1. Tener siempre un contrato de pentest firmado que incluya OSINT
2. Definir el alcance: ¿solo dominios? ¿también personas?
3. No almacenar datos personales más tiempo del necesario
4. Documentar el propósito legal de cada dato recopilado
5. Seguir las directrices de CREST/PTES para reconocimiento