← volver

Diseño y aplicación de reglas de correlación anti‑ransomware en ELK para SOCs medianos

Por · · [Ciberseguridad] · lectura estimada: ~6 min

Introducción

Los ataques de ransomware siguen siendo una de las principales amenazas para organizaciones de cualquier tamaño. Un Security Operations Center (SOC) de pequeña o mediana escala necesita balancear la profundidad de detección con la simplicidad operativa. El stack ELK (Elasticsearch, Logstash, Kibana) es una opción económica y flexible que permite centralizar logs, aplicarle transformaciones y crear visualizaciones en tiempo real.

En este artículo veremos cómo:

  • Diseñar una arquitectura de ingestión adecuada para fuentes críticas.
  • Crear pipelines de Logstash que normalicen y enriquezcan eventos.
  • Definir reglas de correlación usando Watcher o Elastic SIEM.
  • Construir dashboards y alertas en Kibana.
  • Solucionar problemas comunes durante la implementación.

1. Arquitectura y fuentes de datos

1.1. Selección de fuentes relevantes

Para detectar ransomware es fundamental contar con los siguientes logs:

  • Endpoint Protection Platform (EPP): detecciones de comportamiento, bloqueos de archivos.
  • Windows Event Logs: eventos 4688 (creación de proceso), 4663 (acceso a archivo), 5140 (uso de SMB).
  • Syslog de servidores Linux: auditd, sudo, cron.
  • Flujo de red (NetFlow/IPFIX): conexiones a dominios de C2.
  • Active Directory: cambios de grupos, creación de usuarios.

1.2. Topología recomendada

+-----------------+       +-------------------+       +-------------------+
|   Agentes de    | ----> |   Logstash        | ----> | Elasticsearch     |
|   recolección   |       |   (pipelines)     |       | (índices)         |
+-----------------+       +-------------------+       +-------------------+
                                 |
                                 v
                           +-------------------+
                           |     Kibana        |
                           | (Dashboards, SIEM)|
                           +-------------------+

En entornos con bandwidth limitada, utilice Filebeat o Winlogbeat para enviar logs de forma segura y comprimida.

2. Configuración de Logstash: pipelines de normalización

2.1. Instalación básica

# En Debian/Ubuntu
apt-get update && apt-get install -y logstash

Verificar que el servicio arranca

systemctl status logstash

2.2. Pipeline de Windows Event Logs

Este pipeline convierte eventos 4688 y 4663 a un formato unificado ransomware_event.

# /etc/logstash/conf.d/windows_ransomware.conf
input {
  beats {
    port => 5044
  }
}

filter { if [log][source] =~ “Security” { grok { match => { “message” => ”%{TIMESTAMP_ISO8601:timestamp} %{GREEDYDATA:event_data}” } } # Extraer campos clave de 4688 (process creation) if [event][id] == 4688 { json { source => “event_data” target => “process” } mutate { add_field => { “event_type” => “process_creation” } } } # Extraer campos clave de 4663 (file access) if [event][id] == 4663 { json { source => “event_data” target => “file” } mutate { add_field => { “event_type” => “file_access” } } } } }

output { elasticsearch { hosts => [“http://localhost:9200”] index => “winlog-%{+YYYY.MM.dd}” user => “elastic” password => ”${ES_PASSWORD}” } }

2.3. Enriquecimiento con GeoIP y threat intel

Para correlacionar tráfico de red con listas de indicadores (IOCs) usamos el filtro geoip y translate (Threat Intel).

# /etc/logstash/conf.d/netflow_ransomware.conf
input {
  udp {
    port => 2055
    codec => netflow { }
  }
}

filter { geoip { source => “src_ip” target => “src_geo” } translate { field => “dest_ip” destination => “threat.intel” ignore_missing => true # Archivo CSV: ip,category # e.g., 185.53.177.0,malware_c2 dictionary_path => “/etc/logstash/threat_intel.csv” } }

output { elasticsearch { hosts => [“http://localhost:9200”] index => “netflow-%{+YYYY.MM.dd}” } }

3. Definición de reglas de correlación

3.1. Principios de diseño

  • Minimizar falsos positivos: usar umbrales basados en comportamiento (p.ej., 5 procesos renombrados en 2 min).
  • Combinar indicadores de diferentes fuentes: correlacionar creación de proceso sospechoso con acceso masivo a archivos.
  • Temporalidad: emplear ventanas de tiempo (cardinality, range) para detectar patrones rápidos.

3.2. Regla con Watcher (Elasticsearch 7.x)

Ejemplo de regla que dispara cuando más de 10 archivos .lnk son creados en menos de 1 minuto por el mismo proceso.

# /usr/share/elasticsearch/config/watcher/ransomware_lnk_rule.json
{
  "trigger" : {
    "schedule" : { "interval" : "1m" }
  },
  "input" : {
    "search" : {
      "request" : {
        "indices" : [ "winlog-*" ],
        "body" : {
          "size": 0,
          "query": {
            "bool": {
              "must": [
                { "match": { "event_type": "file_access" } },
                { "wildcard": { "file.name": "*.lnk" } },
                { "range": { "@timestamp": { "gte": "now-1m" } } }
              ]
            }
          },
          "aggs": {
            "by_process": {
              "terms": { "field": "process.name", "size": 10 },
              "aggs": {
                "file_count": { "value_count": { "field": "file.name" } },
                "filter": {
                  "bucket_selector": {
                    "buckets_path": { "cnt": "file_count" },
                    "script": "params.cnt > 10"
                  }
                }
              }
            }
          }
        }
      }
    }
  },
  "condition" : {
    "compare" : { "ctx.payload.aggregations.by_process.buckets.length" : { "gt": 0 } }
  },
  "actions" : {
    "email_admin" : {
      "email" : {
        "to" : "soc@example.com",
        "subject" : "Posible actividad ransomware – .lnk masivo",
        "body" : "Se detectó creación masiva de archivos .lnk por {{ctx.payload.aggregations.by_process.buckets.0.key}}."
      }
    }
  }
}

Para cargar la regla:

curl -XPUT -u elastic:password "localhost:9200/_watcher/watch/ransomware_lnk" -H 'Content-Type: application/json' -d @ransomware_lnk_rule.json

3.3. Regla con Elastic SIEM (KQL)

En la sección Detections de Kibana creamos una regla basada en KQL:

event.type: ("process_start" or "file_event") and
process.name: ("powershell.exe" or "cmd.exe") and
file.extension: ("exe" or "dll") and
event.outcome: "success" and
@timestamp: [now-5m TO now] and
network.destination.port: (445 or 139)

Esta regla combina ejecución de procesos comunes de Windows con acceso a puertos SMB, típicos de ransomware que replica archivos por red.

4. Dashboards y visualizaciones en Kibana

4.1. Índice patrón y campos

En Stack Management → Index Patterns cree winlog-* y netflow-*. Active los campos process.name, file.name, network.destination.ip y los de threat.intel.

4.2. Visualización de “Top Ransomware Processes”

  1. Nuevo Lens.
  2. Eje X: process.name (Terms, top 10).
  3. Eje Y: Count.
  4. Filtro: event_type: "process_creation" + process.name: ("ransomware.exe" or "unknown").

Guarde como Top Ransomware Processes y añádalo al dashboard “SOC – Ransomware Overview”.

4.3. Mapa de actividad de C2

Use la visualización Coordinate Map** para trazar la geolocalización de dest_ip que coincidan con la lista de IOCs.

5. Troubleshooting y errores comunes

5.1. Logs no llegan a Elasticsearch

  • Sintaxis de Logstash inválida: revise con logstash --config.test_and_exit -f /etc/logstash/conf.d/.
  • Problemas de certificado TLS: asegúrese que filebeat.yml tenga output.logstash.ssl.enabled: true y los certificados correctos.
  • Índice bloqueado por fase de “read‑only”: PUT /_all/_settings {"index.blocks.read_only_allow_delete":null}.

5.2. Alta tasa de falsos positivos

  • Refine los umbrales (gt 10 → gt 30).
  • Agregue condiciones de “user agent” o “file.hash” para excluir procesos legítimos.
  • Utilice el campo event.outcome para filtrar solo “success”.

5.3. Watcher no se ejecuta

  • Compruebe que el servicio elasticsearch-watcher.service esté activo.
  • Revise el índice .watcher-history-* para errores de ejecución.
  • Use GET _watcher/watch/ransomware_lnk y verifique el campo state.

5.4. Problemas de rendimiento

  • Limite el número de shards por índice a 1‑2 en entornos pequeños.
  • Habilite indices.queries.cache.size y ajuste refresh_interval a “30s”.
  • Utilice pipelines de ingestión (pipeline en el output) en lugar de filtros pesados de Logstash.

Conclusión

Implementar detección de ransomware en ELK para un SOC de pequeña o mediana escala no requiere soluciones propietarias costosas. Con una arquitectura bien planificada, pipelines de Logstash que normalicen eventos críticos y reglas de correlación basadas en Watcher o Elastic SIEM, es posible detectar patrones típicos de ransomware —creación masiva de archivos, uso de procesos de scripting y comunicación con servidores C2— de forma temprana.

Los pasos descritos —desde la recolección de logs, el enriquecimiento con threat intel, la definición de reglas y la creación de dashboards— forman un ciclo de detección y respuesta que puede escalar con la organización. Recuerde siempre validar los umbrales, monitorear el rendimiento del cluster y actualizar las listas de IOCs para mantener la efectividad frente a variantes emergentes.

comentarios(0)

$ dejar comentario

סHola! Soy SylonBot. Si te pierdes en el artículo, pregúntame 👋
☕ invítame a un café Si el contenido te fue útil · via PayPal