Lupa sobre dos llaves de latón casi idénticas, una de ellas sutilmente falsificada

Detección de dominios similares: un pipeline con logs de CT

•12 min de lectura

La detección de dominios similares es la mitad de ingeniería de la protección de marca: un sistema que detecta tumarca-pagos.com o tumacra.com el mismo día en que aparece, reúne evidencia de forma automática y entrega un caso limpio a quien vaya a solicitar la baja. Si necesitas el plan de respuesta (qué hacer cuando un sitio falso ya está en línea), lee nuestra guía sobre cómo dar de baja una página web falsa que suplanta a tu empresa. Este artículo trata de construir el detector: fuentes de datos, modelo de datos, coincidencias, enriquecimiento, manejo de fallos y las decisiones de diseño en cada paso.

Por qué Certificate Transparency es la columna vertebral

La mayoría de los sitios de suplantación quieren el candado, porque los navegadores penalizan el HTTP sin cifrar. Es una buena noticia para quien defiende. Según la Chrome Certificate Transparency Policy, todos los certificados TLS de confianza pública deben cumplir con CT para validarse en las versiones de Chrome que lo exigen. Como explica MDN, cuando un certificado se envía a un log de CT, el log devuelve un signed certificate timestamp (SCT) como prueba de que será añadido. Chrome lo exige desde Chrome 68 (24 de julio de 2018) para certificados emitidos después del 30 de abril de 2018, según el aviso de IDManagement del gobierno de Estados Unidos.

La consecuencia práctica: un atacante que quiere un certificado de confianza para un nombre de host parecido al tuyo tiene que publicar ese nombre en logs públicos de solo anexado, muchas veces antes de terminar la página de phishing. Tu sistema lee esos logs.

CT no da cobertura total, y tu diseño debe decirlo de forma explícita:

  • Los sitios servidos por HTTP sin cifrar nunca aparecen.
  • Un certificado comodín (*.example-host.net) oculta el subdominio real usado en el ataque.
  • La suplantación en plataformas compartidas (una página en un constructor de sitios gratuito, un perfil social, una publicación en un marketplace) usa el certificado de otro.
  • Los dominios registrados pero sin uso todavía no tienen certificado.

Por eso un buen diseño combina CT con al menos otra fuente.

Arquitectura de un pipeline de detección de dominios similares

Piénsalo como cuatro etapas conectadas por una cola:

  1. Fuentes: un flujo de CT en tiempo real, búsquedas periódicas en CT para rellenar huecos y un generador de permutaciones para dominios que existen pero no tienen certificado.
  2. Comparador: filtrado barato y rápido de cada nombre de host contra tus términos vigilados. Es la ruta crítica.
  3. Enriquecimiento: verificaciones costosas solo para candidatos (DNS, descarga HTTP, captura de pantalla, similitud de contenido).
  4. Casos: puntuación, deduplicación, revisión humana, almacenamiento de evidencia y alertas.

Para el flujo en tiempo real, la librería certstream recibe actualizaciones de las listas de Certificate Transparency en tiempo real y se conecta a la red pública de certstream. Para rellenar huecos y consultas puntuales, crt.sh, alojado por Sectigo, consulta los logs de CT aprobados y expone los certificados por web y PostgreSQL; su salida JSON se puede automatizar, por ejemplo https://crt.sh/?q=%25.example.com&output=json. Para permutaciones, dnstwist genera variantes de tu dominio por errores de tipeo, homógrafos y suplantación de marca, y puede comprobar cuáles están registradas.

La decisión clave es de dónde obtienes el flujo. Un agregador público es gratuito y rápido de adoptar, pero es una dependencia que no controlas: si se cae, pierdes eventos. Leer los logs de CT por tu cuenta elimina esa dependencia, pero implica seguir qué logs están vigentes, manejar la API de cada uno y almacenar muchos más datos. Un camino razonable es empezar con un agregador más un relleno programado, y solo operar tus propios lectores de logs si los huecos de detección se convierten en un problema medido.

Modelo de datos

Separa las observaciones crudas de las cosas sobre las que actúa una persona. Un dominio puede producir muchos certificados, y un caso puede abarcar varios dominios operados por el mismo actor.

CREATE TABLE watch_terms (
  id          SERIAL PRIMARY KEY,
  brand_id    INT NOT NULL,
  term        TEXT NOT NULL,          -- normalizado: "acmepay"
  kind        TEXT NOT NULL,          -- 'brand' | 'product' | 'executive'
  min_len_for_fuzzy INT NOT NULL DEFAULT 5
);

CREATE TABLE allowlist (
  domain      TEXT PRIMARY KEY        -- tus dominios, socios, agencias
);

CREATE TABLE observations (
  id            BIGSERIAL PRIMARY KEY,
  hostname      TEXT NOT NULL,
  registrable   TEXT NOT NULL,        -- eTLD+1, p. ej. acme-pay.co
  source        TEXT NOT NULL,        -- 'ct_stream' | 'ct_backfill' | 'permutation'
  cert_sha256   TEXT,                 -- null para resultados de permutación
  issuer        TEXT,
  seen_at       TIMESTAMPTZ NOT NULL,
  match_reason  JSONB NOT NULL,       -- qué término, qué regla, distancia
  UNIQUE (hostname, cert_sha256)      -- inserciones idempotentes
);

CREATE TABLE candidates (
  registrable   TEXT PRIMARY KEY,
  first_seen    TIMESTAMPTZ NOT NULL,
  last_checked  TIMESTAMPTZ,
  score         INT NOT NULL DEFAULT 0,
  status        TEXT NOT NULL DEFAULT 'new'  -- new|watching|case|dismissed
);

CREATE TABLE evidence (
  id            BIGSERIAL PRIMARY KEY,
  registrable   TEXT REFERENCES candidates,
  captured_at   TIMESTAMPTZ NOT NULL,
  kind          TEXT NOT NULL,        -- dns|html|screenshot|whois|cert
  storage_uri   TEXT NOT NULL,        -- almacenamiento de objetos, una sola escritura
  sha256        TEXT NOT NULL
);

Dos detalles importan. Primero, la restricción UNIQUE hace que la ingesta sea idempotente, así que las repeticiones y los rellenos nunca crean duplicados. Segundo, candidates usa como clave el dominio registrable (eTLD+1, calculado con la Public Suffix List), porque esa es la unidad sobre la que actúa un registrador o un hosting. login.acme-pay.co y secure.acme-pay.co son un solo candidato.

Coincidencias: rápidas, explicables y ajustables

El comparador ve cada nombre de host del flujo, así que debe ser barato. Normaliza primero y luego aplica reglas en orden de costo.

import unicodedata, idna

# Mapa ilustrativo pequeño; amplíalo con una fuente adecuada de caracteres confundibles.
HOMOGLYPHS = str.maketrans({"0": "o", "1": "l", "3": "e", "5": "s",
                            "\u0430": "a", "\u0435": "e", "\u043e": "o"})

def normalize_label(label: str) -> str:
    if label.startswith("xn--"):
        try:
            label = idna.decode(label)
        except idna.IDNAError:
            pass
    label = unicodedata.normalize("NFKC", label).lower()
    label = label.translate(HOMOGLYPHS)
    return label.replace("-", "").replace("_", "")

def damerau(a: str, b: str, cap: int = 2) -> int:
    # Distancia de alineación óptima de cadenas, salida temprana sobre cap.
    if abs(len(a) - len(b)) > cap:
        return cap + 1
    d = [[0] * (len(b) + 1) for _ in range(len(a) + 1)]
    for i in range(len(a) + 1): d[i][0] = i
    for j in range(len(b) + 1): d[0][j] = j
    for i in range(1, len(a) + 1):
        for j in range(1, len(b) + 1):
            cost = a[i-1] != b[j-1]
            d[i][j] = min(d[i-1][j] + 1, d[i][j-1] + 1, d[i-1][j-1] + cost)
            if i > 1 and j > 1 and a[i-1] == b[j-2] and a[i-2] == b[j-1]:
                d[i][j] = min(d[i][j], d[i-2][j-2] + 1)
    return d[-1][-1]

def match(hostname: str, terms: list[dict]) -> dict | None:
    labels = [normalize_label(l) for l in hostname.lstrip("*.").split(".")]
    joined = "".join(labels)
    for t in terms:
        if t["term"] in joined:
            return {"term": t["term"], "rule": "contains"}
        if len(t["term"]) >= t["min_len_for_fuzzy"]:
            for l in labels:
                if damerau(l, t["term"]) <= (1 if len(t["term"]) < 8 else 2):
                    return {"term": t["term"], "rule": "fuzzy", "label": l}
    return None

Notas de diseño:

  • Guarda el motivo. match_reason permite que un analista vea por qué se disparó algo y que ajustes las reglas con datos en lugar de suposiciones.
  • Ajusta el umbral difuso según la longitud del término. Una distancia de edición de 2 sobre una marca de cuatro letras coincide con medio diccionario. Las marcas cortas deben apoyarse en contains más palabras de contexto.
  • Usa palabras de contexto (login, pago, pagos, soporte, factura, verify, account) para subir la puntuación, no como disparadores por sí solas.
  • Revisa la lista de permitidos después de la coincidencia, para que tus nuevos subdominios y los hosts de pruebas de tu agencia nunca despierten a nadie.
  • Si vigilas muchos términos, reemplaza el bucle por un autómata Aho-Corasick para contains y un BK-tree o un índice de n-gramas para las búsquedas difusas.

Enriquecimiento y puntuación

Solo los candidatos llegan a esta etapa, así que puedes permitirte verificaciones más lentas. Ejecútalas como trabajos independientes, cada uno con su propio tiempo límite y política de reintentos, y guarda cada resultado como evidencia.

  • DNS: ¿resuelve? ¿Tiene registros MX (señal de que podría enviar correos haciéndose pasar por ti)? ¿Qué proveedor de hosting y qué nameservers usa?
  • HTTP: código de estado, URL final después de redirecciones, título de la página, formularios que envían credenciales o datos de tarjeta.
  • Similitud de contenido: el enfoque de dnstwist es descargar la página, normalizar el HTML y comparar su hash difuso con el de tu sitio real. Agrega un hash del favicon y un hash perceptual de una captura para páginas reconstruidas en lugar de copiadas.
  • Tus propios logs: los sitios clonados suelen enlazar directamente tus imágenes, fuentes o scripts. Un encabezado Referer de un host desconocido en los logs de tu CDN o servidor web es una señal fuerte y barata, y es algo que puedes agregar hoy a las páginas web que construyes y operas.

Mantén la puntuación como configuración, no como código, para que los analistas puedan ajustarla:

signals:
  match.contains: 30
  match.fuzzy: 20
  keyword.payment_or_login: 15
  dns.has_mx: 10
  http.has_credential_form: 25
  content.similar_to_origin: 35
  logs.hotlinks_our_assets: 40
thresholds:
  alert: 70
  watch: 30

Estos pesos son un punto de partida para ajustar con tus propios casos revisados, no una referencia de rendimiento.

Manejo de fallos

Cada dependencia externa de este pipeline fallará en algún momento. Planéalo de forma explícita.

al desconectarse el flujo:
    registrar gap_start = last_event_time
    reconectar con backoff exponencial + jitter
    al reconectar: encolar backfill(gap_start, now) vía búsqueda en CT

bucle del consumidor:
    evento -> match() -> si coincide: INSERT ... ON CONFLICT DO NOTHING
    confirmar solo después del commit   # al menos una vez, escrituras idempotentes

trabajo de enriquecimiento:
    tiempo límite por verificación, máximo N reintentos, luego marcar 'unknown' (no 'clean')

programador:
    volver a revisar candidatos 'watching' con un calendario decreciente

Lecciones que es fácil aprender por las malas:

  • Desconocido no es limpio. Un tiempo de espera agotado nunca debe bajar una puntuación.
  • Los dominios se activan después. Muchos dominios parecidos permanecen estacionados antes de entrar en uso. Vuelve a revisar los candidatos vigilados con el tiempo en lugar de juzgarlos una sola vez.
  • El cloaking es común. Los kits de phishing suelen mostrar una página inofensiva a los escáneres y a las IP de centros de datos. Descarga con un user agent móvil y, cuando sea posible, desde una salida de red en el país de tus clientes; registra qué punto de observación vio qué.
  • Limita la tasa contra servicios compartidos. crt.sh es un recurso público. Guarda en caché las respuestas, programa los rellenos y no lo satures desde cada worker.

Seguridad del propio escáner

Tus workers de enriquecimiento visitan sitios hostiles a propósito. Trátalos como no confiables:

  • Ejecuta el navegador headless en un contenedor aislado, sin credenciales, sin acceso a redes internas y con un firewall solo de salida.
  • Bloquea redirecciones a rangos de IP privados y link-local para evitar server-side request forgery contra tu propia infraestructura.
  • Limita el tamaño de la respuesta y el tiempo de ejecución; desactiva las descargas.
  • Guarda las capturas en almacenamiento de objetos de una sola escritura, con un SHA-256 por archivo y una marca de tiempo UTC, para que la evidencia se sostenga cuando la entregues a un registrador, un hosting o un abogado.

Construir, comprar o combinar

Los servicios comerciales de protección de marca agrupan fuentes de datos, analistas y relaciones para solicitar bajas. Construir te da control sobre las reglas de coincidencia, integración con tus propios logs y herramientas de atención al cliente, y ningún precio por dominio. Un punto medio común es construir la capa de detección y evidencia, que depende de conocimiento que solo tú tienes (tus marcas, activos y mercados), y usar servicios externos para ejecutar las bajas. Si quieres esa capa integrada con tu stack actual, ese es el tipo de software a la medida que diseñamos y construimos.

Checklist

  • Los términos vigilados incluyen marcas, productos y errores de escritura comunes, normalizados.
  • La lista de permitidos cubre tus dominios, socios y agencias.
  • Flujo de CT en tiempo real más relleno programado en CT más escaneo de permutaciones.
  • Inserciones idempotentes con clave por nombre de host y huella del certificado.
  • Candidatos agrupados por dominio registrable.
  • Motivos de coincidencia guardados y revisables.
  • Enriquecimiento aislado, con tiempo limitado, y "desconocido" nunca tratado como "limpio".
  • Monitoreo de Referer en los logs de tu CDN y servidor web.
  • Evidencia con hash, marca de tiempo e inmutable.
  • Calendario de revisión para dominios estacionados.
  • Pesos de puntuación en configuración, revisados contra casos reales.

Errores comunes

  • Tratar CT como cobertura total e ignorar sitios solo HTTP y plataformas compartidas.
  • Aplicar coincidencia difusa a nombres de marca cortos y ahogar a los analistas en ruido.
  • Comparar contra el nombre de host completo en lugar de por etiqueta, lo que pasa por alto patrones como acme-pay.secure-login.net o genera coincidencias con cadenas aleatorias.
  • Alertar por cada certificado en lugar de por cada nuevo dominio registrable.
  • Tomar capturas a mano, sin hash ni marca de tiempo, cuando el sitio ya desapareció.

Preguntas frecuentes

¿Puedo detectar dominios similares que no tienen certificado TLS?

No a través de CT. Usa una herramienta de permutaciones como dnstwist para comprobar qué variantes de tu dominio están registradas, y compleméntala con monitoreo de Referer y reportes de clientes.

¿Qué tan rápido muestra Certificate Transparency un certificado nuevo?

CT exige que el certificado se envíe a los logs para que Chrome confíe en él, así que es público alrededor del momento de emisión. Un flujo en tiempo real lo muestra a medida que los logs publican entradas; un relleno programado mediante un servicio de búsqueda como crt.sh recupera lo que el flujo haya perdido durante una desconexión.

¿Debo registrar de forma defensiva los dominios con errores de tipeo más comunes?

Ayuda con las variantes más obvias, pero el espacio de permutaciones es demasiado grande para comprarlo completo, como señala la documentación de dnstwist al advertir que revisar cada permutación puede requerir millones de consultas DNS. El monitoreo escala; el registro defensivo no.

Comentarios

Todavía no hay comentarios. Sé el primero en compartir lo que piensas.

Deja un comentario

Nunca se publica.