# Extraer solo las coordenadas GPS
exiftool -GPSLatitude -GPSLongitude -GPSAltitude foto.jpg
GPS Latitude  : 40 deg 25' 48.12" N
GPS Longitude : 3 deg 41' 31.44" W
GPS Altitude  : 667 m Above Sea Level

# Obtener coordenadas decimales (para Google Maps)
exiftool -GPSLatitude -GPSLongitude -n foto.jpg
GPS Latitude  : 40.4300333
GPS Longitude : -3.6920667

# Abrir directamente en Google Maps
LAT=$(exiftool -n -GPSLatitude -s3 foto.jpg)
LON=$(exiftool -n -GPSLongitude -s3 foto.jpg)
echo "https://maps.google.com/?q=$LAT,$LON"
https://maps.google.com/?q=40.4300333,-3.6920667

# Procesar directorio completo de fotos — extraer GPS de todas
exiftool -csv -GPSLatitude -GPSLongitude -DateTimeOriginal -Model /fotos/ > gps_data.csv
head -5 gps_data.csv
SourceFile,GPSLatitude,GPSLongitude,DateTimeOriginal,Model
foto1.jpg,40.430033,-3.692066,2024-01-15 14:32,iPhone 15 Pro
foto2.jpg,40.429981,-3.691944,2024-01-15 14:35,iPhone 15 Pro

# Instalar ExifTool
sudo apt install exiftool -y          # Debian/Ubuntu/Kali
brew install exiftool                  # macOS
winget install exiftool                # Windows

# Ver TODOS los metadatos de una imagen
exiftool foto.jpg
ExifTool Version Number         : 12.65
File Name                       : foto.jpg
File Size                       : 3.2 MB
Image Width                     : 4032
Image Height                    : 3024
Make                            : Apple
Model                           : iPhone 15 Pro
Software                        : 17.2
Date/Time Original              : 2024:01:15 14:32:07
GPS Latitude                    : 40 deg 25' 48.12" N
GPS Longitude                   : 3 deg 41' 31.44" W
...

# Solo los campos más relevantes para privacidad
exiftool -Make -Model -DateTimeOriginal -GPSLatitude -GPSLongitude -Software foto.jpg

# Formato CSV (para analizar muchas fotos)
exiftool -csv /directorio/fotos/*.jpg > metadata_report.csv

# Formato JSON
exiftool -json foto.jpg | python3 -m json.tool

# Buscar solo imágenes que tienen GPS
exiftool -if '$GPSLatitude' -filename -GPSLatitude -GPSLongitude /fotos/
======== foto_playa.jpg
File Name                       : foto_playa.jpg
GPS Latitude                    : 41 deg 23' 31.20" N
GPS Longitude                   : 2 deg 10' 12.72" E
======== selfie_trabajo.jpg
GPS Latitude                    : 40 deg 25' 48.12" N  ← domicilio!

# Comparar metadatos entre dos imágenes
diff <(exiftool -s original.jpg) <(exiftool -s copia.jpg)

# Ver histograma de qué modelos de cámara hay en un directorio
exiftool -csv -Model /fotos/ | awk -F',' 'NR>1{print $2}' | sort | uniq -c | sort -rn
     23 iPhone 15 Pro
      8 Samsung Galaxy S23
      3 Canon EOS R6

## CON EXIFTOOL
# Eliminar TODOS los metadatos de una imagen
exiftool -all= foto.jpg
1 image files updated
# Crea foto.jpg_original como backup automático

# Eliminar sin crear backup
exiftool -all= -overwrite_original foto.jpg

# Eliminar solo el GPS (mantener el resto)
exiftool -GPS:all= foto.jpg

# Eliminar metadatos de TODOS los JPG de un directorio
exiftool -all= -overwrite_original /fotos/*.jpg
exiftool -all= -overwrite_original -r /fotos/  # recursivo

# Verificar que se eliminaron
exiftool -GPSLatitude -GPSLongitude foto.jpg
(sin resultados — GPS eliminado)

## CON MAT2 (Metadata Anonymization Toolkit)
sudo apt install mat2 -y
mat2 foto.jpg
Anonymising foto.jpg...
ls
foto.jpg  foto_cleaned.jpg  ← limpia en nuevo archivo

## CON convert (ImageMagick) — reescribe la imagen sin metadatos
convert foto.jpg -strip foto_limpia.jpg
# -strip elimina todos los perfiles y metadatos

## Script: limpiar y verificar carpeta entera
for f in /fotos/*.jpg; do
  exiftool -all= -overwrite_original "$f"
  GPS=$(exiftool -GPSLatitude "$f" 2>/dev/null)
  [ -z "$GPS" ] && echo "[OK] $f" || echo "[WARN] $f aún tiene GPS"
done

## CON EXIFTOOL
exiftool informe.docx
Creator       : John Doe
Last Modified By: jdoe
Company       : ACME Corporation S.L.
Create Date   : 2024:01:10 09:15:22
Modify Date   : 2024:01:14 17:43:01
Revision      : 23
Template      : \\SRV-CORP\Plantillas\Informes\confidencial.dotx

# Campos específicos
exiftool -Creator -Company -Template -LastModifiedBy informe.docx

## EXPLORAR INTERNAMENTE (DOCX es un ZIP)
cp informe.docx informe.zip && unzip -l informe.zip
Archive:  informe.zip
  Length  Name
  ------  ----
    1234  [Content_Types].xml
    5678  docProps/app.xml    ← metadatos de aplicación
    2345  docProps/core.xml   ← metadatos de autor/fecha

unzip -p informe.zip docProps/core.xml | xmllint --format -
<?xml version="1.0"?>
<cp:coreProperties>
  <dc:creator>John Doe</dc:creator>
  <cp:lastModifiedBy>jdoe</cp:lastModifiedBy>
  <cp:revision>23</cp:revision>
  <dcterms:created>2024-01-10T09:15:22Z</dcterms:created>
  <dcterms:modified>2024-01-14T17:43:01Z</dcterms:modified>
</cp:coreProperties>

## CON PYTHON (python-docx)
pip3 install python-docx
python3 -c "
from docx import Document
doc = Document('informe.docx')
props = doc.core_properties
print(f'Autor:    {props.author}')
print(f'Empresa:  {props.company}')
print(f'Creado:   {props.created}')
print(f'Editado:  {props.modified}')
print(f'Revisión: {props.revision}')
print(f'Plantilla:{props.template}')
"

## EXIFTOOL — metadatos estándar
exiftool documento.pdf
PDF Version         : 1.7
Creator             : Microsoft Word 2016
Producer            : Microsoft: Print To PDF
Create Date         : 2024:01:15 10:30:00+01:00
Modify Date         : 2024:01:15 10:30:00+01:00
Author              : Maria Garcia
Subject             : Propuesta comercial confidencial
Keywords            : confidencial, cliente, precio

## PDFINFO — alternativa más detallada
sudo apt install poppler-utils -y
pdfinfo documento.pdf
Title:           Propuesta Q1 2024
Author:          Maria Garcia
Creator:         Microsoft Word 2016
Producer:        Microsoft: Print To PDF
CreationDate:    Mon Jan 15 10:30:00 2024
ModDate:         Mon Jan 15 10:30:00 2024
Tagged:          yes
Pages:           12
File size:       245678 bytes

## EXTRAER TEXTO OCULTO (texto bajo imágenes)
pdftotext documento.pdf - | head -50
# Puede revelar texto que visualmente estaba oculto por una imagen

## PEEPDF — análisis avanzado de estructura PDF
pip3 install peepdf
peepdf documento.pdf
File: documento.pdf
PDF Version: 1.7
Binary: True
Linearized: False
Objects: 89
Streams: 12
Comments: ['Revisar precio antes de enviar']  ← comentario oculto!

## Ver todos los metadatos XMP embebidos
exiftool -xmp documento.pdf | grep -v "^ExifTool"

## WORD/EXCEL/POWERPOINT — Desde la aplicación
# Archivo → Información → Inspeccionar documento → Inspeccionar
# Marcar: Comentarios y anotaciones, Propiedades del documento e información personal
# → Quitar todo

## CON EXIFTOOL — limpiar DOCX
exiftool -all= informe.docx
# Limpia los metadatos en docProps/core.xml y docProps/app.xml

# Limpiar y establecer metadatos neutros
exiftool -Creator="Ghost Academy" -LastModifiedBy="" \
         -Company="" -Template="" \
         -overwrite_original informe.docx

## CON MAT2 — DOCX, PDF, imágenes y más
mat2 informe.docx        # genera informe_cleaned.docx
mat2 --inplace informe.docx  # modifica el original
mat2 *.pdf               # todos los PDFs del directorio

## PDF — Limpiar con qpdf (mantiene el contenido visual)
sudo apt install qpdf -y
qpdf --linearize documento.pdf documento_limpio.pdf
exiftool -all= -overwrite_original documento_limpio.pdf

## PDF — Limpiar con Ghostscript (elimina capas ocultas también)
gs -dBATCH -dNOPAUSE -sDEVICE=pdfwrite \
   -dCompatibilityLevel=1.4 \
   -sOutputFile=pdf_limpio.pdf \
   documento.pdf

## Script: auditar y limpiar todos los documentos de un directorio
for f in *.docx *.xlsx *.pptx *.pdf; do
  [ -f "$f" ] || continue
  AUTOR=$(exiftool -Creator -s3 "$f" 2>/dev/null)
  [ -n "$AUTOR" ] && echo "[AUTOR ENCONTRADO] $f → $AUTOR"
  mat2 --inplace "$f" 2>/dev/null && echo "[LIMPIADO] $f"
done

# Ver todas las cabeceras de respuesta
curl -sI https://target.com
HTTP/2 200
server: Apache/2.4.29 (Ubuntu)
x-powered-by: PHP/7.2.24
content-type: text/html; charset=UTF-8
x-generator: WordPress 5.8.1

# Solo las cabeceras informativas (tecnología)
curl -sI https://target.com | grep -iE "server|powered|generator|aspnet|via|x-"

# Comparar cabeceras con buenas prácticas (qué falta)
HEADERS=$(curl -sI https://target.com)
for h in "X-Frame-Options" "X-Content-Type-Options" "Strict-Transport-Security" "Content-Security-Policy" "X-XSS-Protection"; do
  if echo "$HEADERS" | grep -qi "$h"; then
    echo "[OK]  $h"
  else
    echo "[MISSING] $h"
  fi
done
[MISSING] X-Frame-Options
[OK]  X-Content-Type-Options
[MISSING] Strict-Transport-Security
[MISSING] Content-Security-Policy
[MISSING] X-XSS-Protection

# WhatWeb — análisis completo de tecnologías
whatweb -v https://target.com
WhatWeb report for https://target.com
Status    : 200 OK
Apache[2.4.29], PHP[7.2.24], WordPress[5.8.1]
JQuery[3.6.0], Bootstrap[4.6.0]

# Todos los registros DNS del dominio
dig example.com ANY +noall +answer
example.com.  3600  IN  A      93.184.216.34     ← IP del servidor
example.com.  3600  IN  MX     10 mail.example.com ← servidor de correo
example.com.  3600  IN  TXT    "v=spf1 include:_spf.google.com ~all" ← Google para correo
example.com.  3600  IN  TXT    "MS=ms12345678"    ← verificación Microsoft 365

# Registros SPF — revelan proveedores de correo
dig TXT example.com | grep spf
"v=spf1 include:_spf.google.com include:sendgrid.net ~all"
← Usan Gmail + SendGrid para marketing

# Registros MX — quién gestiona el correo
dig MX example.com +short
10 aspmx.l.google.com.  ← Google Workspace

# Registro DMARC — política anti-spoofing
dig TXT _dmarc.example.com +short
"v=DMARC1; p=quarantine; rua=mailto:dmarc@example.com"

# WHOIS — registrar y fechas de registro
whois example.com | grep -E "Registrar|Creation|Updated|Expiry|Name Server"
Registrar: GoDaddy.com, LLC
Creation Date: 1995-08-14
Updated Date:  2023-08-14
Registrar URL: http://www.godaddy.com
Name Server:   NS1.EXAMPLE.COM
Name Server:   NS2.EXAMPLE.COM

# DNS histórico (subdominios y cambios pasados)
curl -s "https://securitytrails.com/list/apex_domain/example.com" | python3 -m json.tool

# Ver certificado completo del servidor
echo | openssl s_client -connect target.com:443 2>/dev/null | openssl x509 -noout -text | head -40
Subject: C=US, ST=California, L=San Francisco, O=Example Corp, CN=example.com
Issuer: C=US, O=Let's Encrypt, CN=R3
Not Before: Jan 10 00:00:00 2024 GMT
Not After : Apr 10 00:00:00 2024 GMT
Subject Alternative Names:
  DNS: example.com
  DNS: www.example.com
  DNS: api.example.com    ← subdominios descubiertos!
  DNS: admin.example.com  ← panel de admin!
  DNS: mail.example.com

# Solo los SANs (Subject Alternative Names) — subdominios
echo | openssl s_client -connect target.com:443 2>/dev/null | openssl x509 -noout -text | grep "DNS:"
DNS:example.com, DNS:www.example.com, DNS:api.example.com, DNS:admin.example.com

# Certificate Transparency — encontrar todos los certs históricos
curl -s "https://crt.sh/?q=%.example.com&output=json" | python3 -c "
import json,sys
data=json.load(sys.stdin)
domains=set()
for cert in data:
    for name in cert['name_value'].split('\n'):
        domains.add(name.strip())
for d in sorted(domains):
    print(d)
"
admin.example.com
api.example.com
dev.example.com      ← entorno de desarrollo!
staging.example.com  ← staging posiblemente con datos reales
vpn.example.com      ← VPN corporativa
mail.example.com

## LECTURA
exiftool archivo          # todos los metadatos
exiftool -s archivo       # formato corto (sin espacios en nombres)
exiftool -json archivo    # formato JSON
exiftool -csv /dir/*.jpg  # CSV de varios archivos
exiftool -TAG archivo     # solo el campo TAG específico

## ESCRITURA
exiftool -Author="Nombre" archivo.docx  # establecer campo
exiftool -CreateDate="2024:01:01 12:00:00" foto.jpg  # cambiar fecha
exiftool -overwrite_original archivo    # sin backup

## ELIMINACIÓN
exiftool -all= archivo         # borrar todos los metadatos
exiftool -GPS:all= foto.jpg    # borrar solo GPS
exiftool -TAG= archivo         # borrar un campo específico

## BATCH / DIRECTORIOS
exiftool -r /directorio/       # recursivo
exiftool -ext jpg /dir/        # solo archivos .jpg
exiftool -if '$GPSLatitude' /dir/  # solo si tiene GPS

## RENOMBRAR POR METADATOS
exiftool '-FileName
Renombra: foto.jpg → 20240115_143207.jpg (usando la fecha EXIF)

## COPIAR METADATOS ENTRE ARCHIVOS
exiftool -TagsFromFile fuente.jpg destino.jpg

## FORMATOS SOPORTADOS (selección)
Imágenes:    JPEG, PNG, TIFF, RAW (CR2, NEF, ARW...), GIF, BMP, WebP
Documentos:  PDF, DOCX/XLSX/PPTX, DOC/XLS/PPT, ODT
Audio/Video: MP3, MP4, MOV, AVI, MKV, WAV, FLAC
Web:         SVG, HTML, XMP
Otros:       ZIP, EXE, TTF, RTF

# Instalar
sudo apt install metagoofil -y    # Kali Linux
pip3 install metagoofil           # pip

# Buscar y analizar PDFs públicos de un dominio
metagoofil -d example.com -t pdf -l 20 -o /tmp/metagoofil_output
[*] Working on: example.com
[*] Searching in Google for: filetype:pdf site:example.com
[*] Results: 15 documents found
[*] Downloading and analyzing: informe_anual.pdf
[*] Downloading and analyzing: propuesta_tecnica.pdf

[+] Users found:
  john.doe
  maria.garcia
  admin

[+] Software found:
  Microsoft Office Word 2016
  Adobe Acrobat 2020
  LibreOffice 6.4

[+] Paths/Servers found:
  \\SRV-CORP\Documentos\Informes\2024
  C:\Users\john.doe\Documents\trabajo
  \\192.168.1.10\shared\

# Buscar múltiples tipos de archivo
metagoofil -d example.com -t pdf,doc,docx,xls,ppt -l 50 -o /tmp/output -r

# Extraer solo los usuarios encontrados
metagoofil -d example.com -t pdf,docx -l 30 -o /tmp/out | grep -A20 "Users found"

# Instalar MAT2
sudo apt install mat2 -y
pip3 install mat2

# Limpiar un archivo (genera archivo _cleaned)
mat2 foto.jpg
Anonymising foto.jpg...
Writing foto_cleaned.jpg

# Limpiar en su lugar (sobreescribir)
mat2 --inplace foto.jpg

# Verificar qué metadatos quedan
mat2 --check foto.jpg
foto.jpg: No metadata found

# Procesar directorio completo
mat2 /directorio/*.jpg /directorio/*.pdf /directorio/*.docx

# Ver qué metadatos tiene un archivo antes de limpiar
mat2 --show foto.jpg
- gps: {'GPSLatitude': 40.43, 'GPSLongitude': -3.69}
- camera: 'Apple iPhone 15 Pro'
- datetime: '2024:01:15 14:32:07'

# Formatos soportados por MAT2
Imágenes: JPEG, PNG, GIF, TIFF, BMP, HEIC, WebP
Docs:     PDF, DOCX, XLSX, PPTX, ODT, ODS, ODP
Audio:    MP3, OGG, FLAC, MP4 (audio)
Video:    MP4, MOV, AVI
Archivos: ZIP, TAR, 7z
Web:      HTML, CSS, SVG, JS

# Script equivalente a FOCA usando herramientas de línea de comandos
cat > foca_cli.sh << 'EOF'
#!/bin/bash
# GhostAcademy — FOCA CLI: extracción masiva de metadatos
DOMAIN="$1"
OUTDIR="foca_$DOMAIN"
mkdir -p "$OUTDIR/docs" "$OUTDIR/results"

echo "[*] Buscando documentos de: $DOMAIN"

# Buscar con metagoofil
metagoofil -d "$DOMAIN" -t pdf,doc,docx,xls,xlsx,ppt,pptx \
  -l 50 -o "$OUTDIR/docs" 2>/dev/null

# Extraer metadatos de todos los descargados
echo "[*] Extrayendo metadatos..."
exiftool -csv "$OUTDIR/docs"/* > "$OUTDIR/results/metadata.csv"

# Resumen de hallazgos
echo ""
echo "=== USUARIOS ENCONTRADOS ==="
exiftool -Creator -LastModifiedBy -Author \
  "$OUTDIR/docs"/* 2>/dev/null | \
  grep -v "^ExifTool\|^====\|^$" | \
  awk -F': ' '{print $2}' | sort -u | grep -v "^$"

echo ""
echo "=== SOFTWARE DETECTADO ==="
exiftool -Application -Producer -Creator \
  "$OUTDIR/docs"/* 2>/dev/null | \
  awk -F': ' '{print $2}' | sort -u | grep -v "^$"

echo ""
echo "=== RUTAS INTERNAS ==="
exiftool -Template -HyperlinkBase \
  "$OUTDIR/docs"/* 2>/dev/null | \
  grep "\\\\" | awk -F': ' '{print $2}'

echo ""
echo "[*] CSV completo en: $OUTDIR/results/metadata.csv"
EOF
chmod +x foca_cli.sh
./foca_cli.sh example.com

## PASO 1: Obtener foto con metadatos GPS para el lab
# Puedes usar tu propia foto de smartphone o buscar imágenes de ejemplo
# con metadatos en: https://github.com/ianare/exif-samples
wget -q "https://github.com/ianare/exif-samples/raw/master/jpg/gps/DSCN0010.jpg" -O lab_foto.jpg

## PASO 2: Ver todos los metadatos
exiftool lab_foto.jpg

## PASO 3: Extraer solo el GPS
exiftool -GPSLatitude -GPSLongitude -GPSAltitude -GPSImgDirection lab_foto.jpg
GPS Latitude      : 43 deg 28' 2.82" N
GPS Longitude     : 11 deg 53' 6.42" E
GPS Altitude      : 95 m Above Sea Level
GPS Img Direction : 29.8 deg

## PASO 4: Convertir a decimal y generar URL de Google Maps
python3 << 'PYTHON'
import subprocess

def get_meta(field, file):
    result = subprocess.run(['exiftool', '-n', f'-{field}', '-s3', file],
                          capture_output=True, text=True)
    return result.stdout.strip()

foto = 'lab_foto.jpg'
lat = get_meta('GPSLatitude', foto)
lon = get_meta('GPSLongitude', foto)
alt = get_meta('GPSAltitude', foto)
camara = get_meta('Model', foto)
fecha = get_meta('DateTimeOriginal', foto)

print(f"Cámara:    {camara}")
print(f"Fecha:     {fecha}")
print(f"Latitud:   {lat}")
print(f"Longitud:  {lon}")
print(f"Altitud:   {alt} m")
print(f"\nGoogle Maps: https://maps.google.com/?q={lat},{lon}")
print(f"OpenStreetMap: https://www.openstreetmap.org/?mlat={lat}&mlon={lon}")
PYTHON
Cámara:    NIKON COOLPIX P6000
Fecha:     2008:10:22 16:29:54
Latitud:   43.4674500
Longitud:  11.8851167
Altitud:   95.0 m
Google Maps: https://maps.google.com/?q=43.4674500,11.8851167
← Ubicación: Arezzo, Italia

## PASO 5: Limpiar el GPS de la foto
cp lab_foto.jpg lab_foto_limpia.jpg
exiftool -GPS:all= -overwrite_original lab_foto_limpia.jpg
exiftool -GPSLatitude lab_foto_limpia.jpg
(sin resultados — GPS eliminado exitosamente)

## CREAR DOCX CON METADATOS COMPROMETEDORES (para el lab)
pip3 install python-docx
python3 << 'EOF'
from docx import Document
from docx.opc.constants import RELATIONSHIP_TYPE as RT
import datetime

doc = Document()
doc.add_paragraph("Informe Confidencial - Propuesta Q1 2024")
doc.add_paragraph("Precio: 250.000 EUR")

# Establecer metadatos reveladores
props = doc.core_properties
props.author = "Maria Garcia"
props.last_modified_by = "mgarcía"
props.company = "ACME Corporation S.L."
props.title = "Propuesta comercial Q1 2024"
props.description = "Documento confidencial para cliente X"
props.revision = 23
props.created = datetime.datetime(2024, 1, 10, 9, 15, 22)
props.modified = datetime.datetime(2024, 1, 14, 17, 43, 1)

doc.save('informe_empresa.docx')
print("[+] informe_empresa.docx creado con metadatos")
EOF

## AUDITAR EL DOCX
python3 << 'AUDIT'
from docx import Document
import zipfile, xml.etree.ElementTree as ET

doc = Document('informe_empresa.docx')
props = doc.core_properties

print("=" * 50)
print("AUDITORÍA DE METADATOS — informe_empresa.docx")
print("=" * 50)

campos = {
    "Autor": props.author,
    "Último editor": props.last_modified_by,
    "Empresa": props.company,
    "Título": props.title,
    "Descripción": props.description,
    "Revisiones": props.revision,
    "Creado": props.created,
    "Modificado": props.modified,
}

for campo, valor in campos.items():
    if valor:
        riesgo = "⚠" if campo in ["Autor","Empresa","Último editor"] else "•"
        print(f"  {riesgo} {campo}: {valor}")

print("\n[RIESGO] Este documento expone:")
print("  - Nombre real del autor: Maria Garcia")
print("  - Credencial Windows: mgarcía")
print("  - Empresa real: ACME Corporation S.L.")
print("  - 23 revisiones (historial de cambios)")
AUDIT

## Script: recon_metadata.sh — OSINT pasivo por metadatos
cat > recon_metadata.sh << 'EOF'
#!/bin/bash
TARGET=$1
echo "=== OSINT por Metadatos: $TARGET ==="

echo ""
echo "--- REGISTROS DNS ---"
dig +short A $TARGET
dig +short MX $TARGET
dig TXT $TARGET | grep -oP '"[^"]+"'

echo ""
echo "--- TECNOLOGÍAS (Cabeceras HTTP) ---"
curl -sI "https://$TARGET" | grep -iE "server|powered|generator|aspnet|via"

echo ""
echo "--- CABECERAS DE SEGURIDAD AUSENTES ---"
HEADERS=$(curl -sI "https://$TARGET")
for h in "X-Frame-Options" "Strict-Transport-Security" "Content-Security-Policy"; do
  echo "$HEADERS" | grep -qi "$h" || echo "  MISSING: $h"
done

echo ""
echo "--- SUBDOMINIOS (Certificate Transparency) ---"
curl -s "https://crt.sh/?q=%25.$TARGET&output=json" 2>/dev/null | \
  python3 -c "
import json,sys
try:
  data=json.load(sys.stdin)
  domains=set()
  for c in data:
    for n in c.get('name_value','').split('\n'):
      n=n.strip().lstrip('*.')
      if n and not n.startswith('@'): domains.add(n)
  [print(f'  {d}') for d in sorted(domains)]
except: print('  Error obteniendo datos')"

echo ""
echo "--- WHOIS ---"
whois "$TARGET" 2>/dev/null | grep -E "Registrar:|Creation|Updated"
EOF
chmod +x recon_metadata.sh

# Ejecutar contra un dominio (usando testphp.vulnweb.com como ejemplo de lab)
./recon_metadata.sh testphp.vulnweb.com

## Script: clean_before_publish.sh
cat > clean_before_publish.sh << 'EOF'
#!/bin/bash
# GhostAcademy — Limpieza de metadatos antes de publicar
# Uso: ./clean_before_publish.sh /directorio/archivos/

INDIR="${1:-.}"
OUTDIR="${INDIR}/cleaned_$(date +%Y%m%d)"
mkdir -p "$OUTDIR"

echo "=== Limpieza de Metadatos ==="
echo "Origen: $INDIR"
echo "Destino: $OUTDIR"
echo ""

TOTAL=0; LIMPIADOS=0

for f in "$INDIR"/*.{jpg,jpeg,png,gif,pdf,docx,xlsx,pptx,odt,mp3,mp4}; do
  [ -f "$f" ] || continue
  TOTAL=$((TOTAL+1))
  nombre=$(basename "$f")
  destino="$OUTDIR/$nombre"

  # Copiar original al directorio de salida
  cp "$f" "$destino"

  # Limpiar con MAT2 si está disponible, si no con exiftool
  if command -v mat2 &>/dev/null; then
    mat2 --inplace "$destino" 2>/dev/null && LIMPIADOS=$((LIMPIADOS+1))
  else
    exiftool -all= -overwrite_original "$destino" 2>/dev/null && LIMPIADOS=$((LIMPIADOS+1))
  fi

  # Verificar GPS en imágenes
  if [[ "$f" =~ \.(jpg|jpeg|png)$ ]]; then
    GPS=$(exiftool -GPSLatitude -s3 "$destino" 2>/dev/null)
    if [ -n "$GPS" ]; then
      echo "  [ALERTA] GPS no eliminado en: $nombre"
    else
      echo "  [OK] $nombre"
    fi
  else
    echo "  [OK] $nombre"
  fi
done

echo ""
echo "=== RESUMEN ==="
echo "Archivos procesados: $TOTAL"
echo "Limpiados:           $LIMPIADOS"
echo "Directorio limpio:   $OUTDIR"
echo ""
echo "VERIFICACIÓN FINAL:"
exiftool -csv "$OUTDIR"/* | python3 -c "
import sys,csv
reader=csv.DictReader(sys.stdin)
problemas=0
for row in reader:
    for k,v in row.items():
        if k in ['GPSLatitude','Creator','Author','Company'] and v:
            print(f'  [PENDIENTE] {row[\"SourceFile\"]}: {k}={v}')
            problemas+=1
print(f'  Problemas detectados: {problemas}')
"
EOF
chmod +x clean_before_publish.sh
./clean_before_publish.sh /tmp/documentos_para_publicar/