Análisis de Dominios de Typosquatting con DNSTwist
Resumen
DNSTwist es un motor de permutación de nombres de dominio que genera nombres de dominio similares para detectar typosquatting, ataques homógrafos de phishing y suplantación de marca. Crea miles de permutaciones de dominios utilizando técnicas como sustitución de caracteres, transposición, inserción, omisión y reemplazo homoglifo, luego verifica registros DNS (A, AAAA, NS, MX), calcula la similitud de páginas web mediante hash difuso (ssdeep) y hash perceptual (pHash), e identifica dominios registrados potencialmente maliciosos.
Cuándo Usarlo
- Al investigar incidentes de seguridad que requieran analizar dominios de typosquatting con dnstwist
- Al construir reglas de detección o consultas de caza de amenazas para este dominio
- Cuando los analistas del SOC necesiten procedimientos estructurados para este tipo de análisis
- Al validar la cobertura de monitoreo de seguridad para técnicas de ataque relacionadas
Prerrequisitos
- Python 3.9+ con
dnstwistinstalado (pip install dnstwist[full]) - Opcional: Base de datos GeoIP para geolocalización de IP
- Opcional: Clave API de Shodan para enriquecimiento
- Acceso a red para realizar consultas DNS
- Comprensión de los tipos de registros DNS y registro de dominios
Conceptos Clave
Técnicas de Permutación de Dominios
DNSTwist genera permutaciones usando: adición (agregar caracteres), bitsquatting (errores de cambio de bit), homoglifo (caracteres Unicode visualmente similares como rn vs m), guionización (agregar guiones), inserción (insertar caracteres), omisión (eliminar caracteres), repetición (repetir caracteres), reemplazo (reemplazar con teclas adyacentes del teclado), subdominio (insertar puntos), transposición (intercambiar caracteres adyacentes), intercambio de vocales (intercambiar vocales) y basado en diccionario (agregar palabras comunes).
Hash Difuso y Similitud Visual
DNSTwist utiliza ssdeep (hash sensible a la localidad) para comparar contenido HTML y pHash (hash perceptual) para comparar capturas de pantalla de páginas web. Esto ayuda a identificar sitios de phishing clonados que imitan visualmente al sitio legítimo. Una puntuación de similitud alta indica una página de phishing probable.
Flujo de Trabajo de Detección
El flujo de trabajo típico es: generar permutaciones de dominio -> resolver registros DNS -> verificar dominios registrados -> comparar similitud de páginas web -> marcar dominios sospechosos -> alertar al equipo de seguridad -> solicitar takedown. Para un dominio corporativo típico, dnstwist genera entre 5,000 y 10,000 permutaciones.
Flujo de Trabajo
Paso 1: Escaneo Básico de Permutaciones de Dominio
import subprocess
import json
import csv
from datetime import datetime
def run_dnstwist_scan(domain, output_file=None):
"""Ejecuta un escaneo dnstwist contra un dominio objetivo."""
cmd = [
"dnstwist",
"--registered", # Solo mostrar dominios registrados
"--format", "json", # Salida en JSON
"--nameservers", "8.8.8.8,1.1.1.1",
"--threads", "50",
"--mxcheck", # Verificar registros MX
"--ssdeep", # Comparación de hash difuso
"--geoip", # Consulta GeoIP
domain,
]
print(f"[*] Escaneando permutaciones para: {domain}")
result = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
if result.returncode == 0:
results = json.loads(result.stdout)
registered = [r for r in results if r.get("dns_a") or r.get("dns_aaaa")]
print(f"[+] Encontrados {len(registered)} dominios suplantadores registrados")
if output_file:
with open(output_file, "w") as f:
json.dump(registered, f, indent=2)
print(f"[+] Resultados guardados en {output_file}")
return registered
else:
print(f"[-] Error de dnstwist: {result.stderr}")
return []
results = run_dnstwist_scan("example.com", "typosquat_results.json")
Paso 2: Analizar y Priorizar Resultados
def analyze_results(results, legitimate_ips=None):
"""Analiza los resultados de dnstwist y prioriza las amenazas."""
legitimate_ips = legitimate_ips or set()
high_risk = []
medium_risk = []
low_risk = []
for entry in results:
domain = entry.get("domain", "")
fuzzer = entry.get("fuzzer", "")
dns_a = entry.get("dns_a", [])
dns_mx = entry.get("dns_mx", [])
ssdeep_score = entry.get("ssdeep_score", 0)
risk_score = 0
risk_factors = []
# Alta similitud con el sitio legítimo
if ssdeep_score and ssdeep_score > 50:
risk_score += 40
risk_factors.append(f"alta similitud web ({ssdeep_score}%)")
# Tiene registros MX (puede recibir correo / phishing)
if dns_mx:
risk_score += 20
risk_factors.append("tiene registros MX (capaz de correo)")
# Registrado recientemente (si hay datos whois disponibles)
whois_created = entry.get("whois_created", "")
if whois_created:
try:
created = datetime.fromisoformat(whois_created.replace("Z", "+00:00"))
age_days = (datetime.now(created.tzinfo) - created).days
if age_days < 30:
risk_score += 30
risk_factors.append(f"registrado recientemente ({age_days} días)")
elif age_days < 90:
risk_score += 15
risk_factors.append(f"registrado hace {age_days} días")
except (ValueError, TypeError):
pass
# Los ataques homógrafos son de mayor riesgo
if fuzzer == "homoglyph":
risk_score += 25
risk_factors.append("homoglifo (visualmente idéntico)")
elif fuzzer in ("addition", "replacement", "transposition"):
risk_score += 10
risk_factors.append(f"tipo de permutación: {fuzzer}")
# No apunta a la infraestructura legítima
if dns_a and not set(dns_a).intersection(legitimate_ips):
risk_score += 10
risk_factors.append("IP diferente a la legítima")
entry["risk_score"] = risk_score
entry["risk_factors"] = risk_factors
if risk_score >= 50:
high_risk.append(entry)
elif risk_score >= 25:
medium_risk.append(entry)
else:
low_risk.append(entry)
high_risk.sort(key=lambda x: x["risk_score"], reverse=True)
medium_risk.sort(key=lambda x: x["risk_score"], reverse=True)
print(f"\n=== Análisis de Typosquatting ===")
print(f"Alto Riesgo: {len(high_risk)}")
print(f"Riesgo Medio: {len(medium_risk)}")
print(f"Bajo Riesgo: {len(low_risk)}")
if high_risk:
print(f"\n--- Dominios de Alto Riesgo ---")
for entry in high_risk[:10]:
print(f" {entry['domain']} (puntuación: {entry['risk_score']})")
for factor in entry['risk_factors']:
print(f" - {factor}")
return {"high": high_risk, "medium": medium_risk, "low": low_risk}
analysis = analyze_results(results, legitimate_ips={"93.184.216.34"})
Paso 3: Pipeline de Monitoreo Continuo
import time
import hashlib
class TyposquatMonitor:
def __init__(self, domains, known_domains_file="known_typosquats.json"):
self.domains = domains
self.known_file = known_domains_file
self.known_domains = self._load_known()
def _load_known(self):
try:
with open(self.known_file, "r") as f:
return json.load(f)
except FileNotFoundError:
return {}
def _save_known(self):
with open(self.known_file, "w") as f:
json.dump(self.known_domains, f, indent=2)
def scan_all_domains(self):
"""Escanea todos los dominios monitoreados en busca de nuevos typosquats."""
new_findings = []
for domain in self.domains:
results = run_dnstwist_scan(domain)
for entry in results:
domain_key = entry.get("domain", "")
if domain_key not in self.known_domains:
entry["first_seen"] = datetime.now().isoformat()
entry["monitored_domain"] = domain
self.known_domains[domain_key] = entry
new_findings.append(entry)
print(f" [NUEVO] {domain_key} ({entry.get('fuzzer', '')})")
self._save_known()
print(f"\n[+] Nuevos dominios de typosquatting encontrados: {len(new_findings)}")
return new_findings
def generate_alert(self, findings):
"""Genera una alerta para nuevos dominios de typosquatting de alto riesgo."""
analysis = analyze_results(findings)
alerts = []
for entry in analysis["high"]:
alerts.append({
"severity": "HIGH",
"domain": entry["domain"],
"target": entry.get("monitored_domain", ""),
"risk_score": entry["risk_score"],
"risk_factors": entry["risk_factors"],
"dns_a": entry.get("dns_a", []),
"dns_mx": entry.get("dns_mx", []),
"timestamp": datetime.now().isoformat(),
})
return alerts
monitor = TyposquatMonitor(["mycompany.com", "mycompany.org"])
new_findings = monitor.scan_all_domains()
alerts = monitor.generate_alert(new_findings)
Paso 4: Exportar para Lista de Bloqueo y Takedown
def export_blocklist(analysis, output_file="blocklist.txt"):
"""Exporta dominios de alto riesgo como lista de bloqueo para firewall/proxy."""
domains = []
for entry in analysis["high"] + analysis["medium"]:
domain = entry.get("domain", "")
if domain:
domains.append(domain)
with open(output_file, "w") as f:
f.write(f"# Lista de bloqueo de typosquatting generada {datetime.now().isoformat()}\n")
for d in sorted(set(domains)):
f.write(f"{d}\n")
print(f"[+] Lista de bloqueo guardada: {len(domains)} dominios -> {output_file}")
return domains
def generate_takedown_report(high_risk_domains):
"""Genera un informe de solicitud de takedown."""
report = f"""# Solicitud de Takedown de Dominio
Generada: {datetime.now().isoformat()}
## Resumen
{len(high_risk_domains)} dominios identificados como potencial typosquatting/phishing.
## Dominios que Requieren Takedown
"""
for entry in high_risk_domains:
report += f"""
### {entry['domain']}
- **Tipo de Permutación**: {entry.get('fuzzer', 'desconocido')}
- **Dirección IP**: {', '.join(entry.get('dns_a', ['N/A']))}
- **Registros MX**: {', '.join(entry.get('dns_mx', ['N/A']))}
- **Puntuación de Riesgo**: {entry.get('risk_score', 0)}
- **Factores de Riesgo**: {'; '.join(entry.get('risk_factors', []))}
- **Similitud Web**: {entry.get('ssdeep_score', 'N/A')}%
"""
with open("takedown_report.md", "w") as f:
f.write(report)
print("[+] Informe de takedown generado: takedown_report.md")
export_blocklist(analysis)
generate_takedown_report(analysis["high"])
Criterios de Validación
- DNSTwist genera permutaciones de dominio para el dominio objetivo
- La resolución DNS identifica dominios suplantadores registrados
- La puntuación de similitud web detecta páginas de phishing clonadas
- La puntuación de riesgo prioriza los dominios por nivel de amenaza
- El monitoreo continuo detecta typosquats recién registrados
- Se generan correctamente listas de bloqueo e informes de takedown