Rustinel: un agente de detección de endpoints open-source para Windows y Linux con telemetría unificada

Introducción

Los equipos de seguridad que gestionan entornos híbridos suelen enfrentar un problema recurrente: la fragmentación de herramientas. Mientras Windows cuenta con Sysmon como estándar de facto para telemetría forense, Linux depende de soluciones basadas en eBPF, auditd o herramientas propietarias. Esta disparidad obliga a mantener pipelines paralelos, reglas duplicadas y cargas operativas innecesarias. Rustinel, un agente open-source escrito en Rust, intenta resolver este cuello de botella al ofrecer una única base de código que unifica la recolección y análisis de eventos en ambos sistemas operativos.

El proyecto no busca reemplazar a las soluciones comerciales de EDR (Endpoint Detection and Response), pero sí proporciona una alternativa ligera y auditable para equipos que priorizan transparencia y simplicidad. Su diseño en modo usuario evita depender de drivers kernel, reduciendo el riesgo de kernel panics o vulnerabilidades críticas, aunque con limitaciones en resistencia a ataques avanzados.

Qué ocurrió

En mayo de 2025, el desarrollador Théo Foucher lanzó Rustinel (versión 0.1.0) como un proyecto open-source bajo licencia Apache 2.0. El agente se ejecuta en modo usuario en ambos sistemas operativos y recopila telemetría mediante:

• ETW (Event Tracing for Windows) en sistemas Windows (desde Windows 7).
• eBPF en Linux (requiriendo kernel 5.8+ con soporte BTF).

Los eventos se normalizan a un modelo común y se evalúan con:

1. Reglas Sigma para detección de comportamientos.
2. Firmas YARA para escaneo de ejecutables al momento de creación de procesos.
3. Indicadores de compromiso (IOC) para hashes, IPs, dominios o patrones de rutas.

Los alertas se generan en formato ECS-compatible NDJSON, facilitando su integración con SIEM como Elastic o Splunk. El proyecto destaca por su enfoque en reusabilidad: los equipos pueden aprovechar reglas Sigma, YARA e IOCs existentes sin reescribirlas.

Impacto para DevOps / Infraestructura / Cloud / Seguridad

Para equipos de Seguridad

Rustinel reduce la complejidad operativa al eliminar la necesidad de mantener pipelines separados para Windows y Linux. Esto es crítico en entornos con:

• Máquinas virtuales híbridas (ej: Azure con VMs Windows y Linux).
• Contenedores con hosts mixtos (Kubernetes con nodos Windows y Linux).
• Falta de presupuesto para licencias de EDR comerciales.

Sin embargo, su arquitectura en modo usuario implica limitaciones importantes:

• No puede detectar ataques que modifiquen el kernel (ej: rootkits).
• No bloquea actividad antes de que llegue al espacio de usuario (a diferencia de soluciones con drivers kernel).
• Vulnerable a técnicas BYOVD (Bring Your Own Vulnerable Driver), donde un atacante inyecta un driver malicioso para deshabilitar telemetría.

Según el desarrollador, estas limitaciones son un trade-off deliberado: priorizar estabilidad y transparencia sobre resistencia a ataques avanzados. Para equipos que buscan un equilibrio, Rustinel ofrece:

• Menor superficie de ataque (sin código en kernel).
• Facilidad de despliegue (no requiere compilación de módulos kernel).
• Bajo consumo de recursos (ej: en Linux, consume ~5MB de RAM y <1% de CPU en pruebas con 100 procesos activos).

Para equipos de DevOps e Infraestructura

Rustinel puede integrarse en pipelines de CI/CD para validar cambios en reglas de detección antes de desplegarlos en producción. Por ejemplo:

• Usar GitHub Actions para ejecutar pruebas con reglas Sigma personalizadas.
• Desplegar el agente como sidecar en pods de Kubernetes (requiriendo permisos de hostPID: true y privileged: true en entornos Linux).

En cloud, es compatible con:

• AWS EC2 (Windows y Linux).
• Azure VMs (con soporte para ETW en Windows Server 2019+).
• GCP Compute Engine (Linux con kernel 5.8+).

Para equipos de Cloud

En entornos multi-cloud, Rustinel puede centralizar logs de endpoints sin depender de APIs propietarias. Sin embargo, no reemplaza a soluciones nativas de cloud como:

• AWS GuardDuty (para detección en cuentas AWS).
• Azure Defender for Endpoint (para integración con Microsoft 365).
• GCP Security Command Center (para análisis de vulnerabilidades).

Su valor agregado está en entornos híbridos o on-premise donde no se dispone de herramientas comerciales.

Detalles técnicos

Arquitectura y componentes

• Eventos de creación de procesos (Process Create).
• Cargas de imágenes (Image Load).
• Conexiones de red (Network).
• Accesos a archivos y registros (File, Registry).
• Ejecución de PowerShell (PowerShell).
• Actividad de WMI (WMI).
• Servicios y tareas programadas (Service, Scheduled Task).

• Creación de procesos (execve, fork).
• Conexiones de red (connect, accept).
• Accesos a archivos (open, read, write).
• Consultas DNS (getaddrinfo).

Limitaciones conocidas

1. Memoria y procesos residente en memoria:

1. Obfuscación y LOLOB:

1. Cifrado de C2:

1. Kernel 5.8+ en Linux:

1. Sin resistencia a ataques kernel:

Código de ejemplo: Instalación en Linux

# Requerimientos mínimos
sudo apt update && sudo apt install -y \
    build-essential \
    clang \
    llvm \
    libelf-dev \
    linux-headers-$(uname -r)

# Clonar y compilar
git clone https://github.com/thfoucher/rustinel.git
cd rustinel
cargo build --release

# Ejecutar en modo dry-run (solo detección)
sudo ./target/release/rustinel --dry-run

# Instalar como servicio (systemd)
sudo cp rustinel.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable --now rustinel

Código de ejemplo: Configuración de reglas Sigma

# rules/process_creation_suspicious_parent.yaml
title: Proceso creado con padre sospechoso
id: 1001
status: experimental
description: Detecta procesos creados por padres inusuales (ej: cmd.exe lanzado por wscript.exe)
logsource:
  category: process_creation
  product: windows
detection:
  suspicious_parent:
    ParentImage|endswith: '\wscript.exe'
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
  condition: suspicious_parent
falsepositives:
  - Herramientas de administración legítimas
level: high

Qué deberían hacer los administradores y equipos técnicos

1. Evaluar si Rustinel es adecuado para su entorno

• Trabajan en entornos híbridos con Windows y Linux.
• Necesitan una solución ligera y auditable (sin drivers kernel).
• Quieren reutilizar reglas Sigma/YARA/IOC existentes.
• Prefieren un agente open-source con licencia Apache 2.0 (no GPL).

• Requieren bloqueo en tiempo real (Rustinel solo detecta).
• Necesitan cobertura contra rootkits o ataques kernel.
• Operan con kernels Linux anteriores a 5.8 sin BTF.

2. Desplegar Rustinel de forma segura

En Linux:

# Verificar kernel y BTF
uname -r  # Debe ser >= 5.8
ls /sys/kernel/btf/vmlinux  # Debe existir

# Instalar dependencias
sudo apt install -y linux-headers-$(uname -r) clang llvm

# Compilar desde fuente (recomendado para producción)
git clone https://github.com/thfoucher/rustinel.git
cd rustinel
cargo build --release --features systemd

# Configurar reglas Sigma (ej: reglas de SigmaHQ)
mkdir -p /etc/rustinel/rules
wget -O /etc/rustinel/rules/process_creation_suspicious.yaml \
  https://raw.githubusercontent.com/SigmaHQ/sigma/master/rules/linux/process_creation/proc_creation_lolbas_cmd.yml

# Ejecutar en modo servicio
sudo ./target/release/rustinel --config /etc/rustinel/config.yaml

En Windows:

# Descargar binario precompilado (revisar releases en GitHub)
Invoke-WebRequest -Uri "https://github.com/thfoucher/rustinel/releases/download/v0.1.0/rustinel-windows-x86_64.zip" -OutFile rustinel.zip
Expand-Archive -Path rustinel.zip -DestinationPath C:\Program Files\Rustinel

# Instalar como servicio
New-Service -Name "Rustinel" -BinaryPathName "C:\Program Files\Rustinel\rustinel.exe --config C:\config\rustinel.yaml" -StartupType Automatic

# Verificar logs (ECS NDJSON en C:\ProgramData\Rustinel\alerts.ndjson)
Get-Content "C:\ProgramData\Rustinel\alerts.ndjson" -Tail 10

3. Integrar con SIEM

Rustinel genera alertas en formato ECS NDJSON, compatible con:

• Elastic SIEM (usar el módulo filebeat con el input json).
• Splunk (usar el add-on Splunk Add-on for ECS).
• Graylog (con el plugin json extractor).

# filebeat.yml
filebeat.inputs:
- type: filestream
  paths:
    - /var/lib/rustinel/alerts.ndjson
  json.keys_under_root: true
  json.overwrite_keys: true

output.elasticsearch:
  hosts: ["https://elastic.example.com:9200"]
  username: "beats_writer"
  password: "xxxxxx"

4. Mantener y actualizar

• Actualizar a la última versión (ej: cargo update en el repositorio).
• Revisar reglas Sigma periódicamente (ej: semanalmente) para evitar falsos positivos.
• Monitorear consumo de recursos (ej: con htop en Linux o Performance Monitor en Windows).

cd /opt/rustinel
git pull origin main
cargo build --release
sudo systemctl restart rustinel

Conclusión

Rustinel es una solución prometedora para equipos que buscan simplificar la detección de endpoints en entornos híbridos, especialmente en escenarios donde la complejidad operativa de las herramientas tradicionales es un cuello de botella. Su arquitectura en modo usuario y su enfoque en reutilizar estándares como Sigma y YARA lo hacen accesible para equipos con recursos limitados, pero no es una solución completa para amenazas avanzadas.

Para organizaciones que requieren bloqueo en tiempo real o resistencia a ataques kernel, herramientas como Sysmon (Windows) o Falco (Linux) siguen siendo necesarias. Sin embargo, Rustinel puede complementar estas soluciones al proporcionar telemetría unificada y normalizada, facilitando la correlación de eventos en SIEM.

El proyecto está en fase temprana (versión 0.1.0 en mayo de 2025), pero su enfoque en transparencia y simplicidad lo posiciona como una alternativa interesante para equipos que priorizan audibilidad y bajo riesgo operacional.

FIN