Gravity SOC - Manual Oficial del Proyecto
Gravity SOC es un Centro de Operaciones de Seguridad (SOC) distribuido, ligero y asimétrico. Diseñado originariamente por Sammi y Antigravity, el proyecto nace con el espíritu de combinar la agilidad de los entornos de placas reducidas (como las Raspberry Pi) con la supervisión de hardware nativo de Microsoft Windows en un híbrido capaz de detectar atacantes en tiempo real mediante telemetría pura, correlacionando tráfico de red (DNS) y monitorización profunda del sistema (Sysmon).
1. Arquitectura General
Gravity SOC opera basado en un esquema cliente-servidor de L2/L1, diseñado bajo la premisa del mínimo consumo y el paso de variables ultra-rápido en memoria, huyendo todo lo posible de la compilación cruzada dependiente de lenguajes como C (CGO).
Se compone de **dos repositorios o módulos principales**:
A. Gravity SOC Agent (Capa L1 - Sensores)
El agente de Gravity SOC es un ejecutable polimórfico escrito en `Go` que se adapta silenciosamente al sistema operativo en el que se despliega.
Windows (Host L1)
Se engancha limpiamente al registro de Windows y abstrae toda la lógica compleja de interconectarse a los registros `ETW (Event Tracing for Windows)`. Aprovechando `wevtutil`, el agente lee de forma cíclica e inversa los eventos generados por Sysmon (Sysinternals) esquivando binarios incompatibles en el runtime de Go. Especializado en capturar:
-
Creación de procesos y comandos (`EventID: 1`).
-
Conexiones de red internas y a dominios exteriores (`EventID: 3`).
-
Mutaciones en el sistema / Inyecciones de memoria remotas (`EventID: 8`).
-
Lecturas sobre archivos de gran peso / Registro de DNS del host.
Linux (Network L1 / Raspberry Pi Zero 2 W)
Desempeñando el papel de centinela silencioso dentro de la red corporativa/casera, el agente intercepta logs volátiles de un servidor DNS local (como Unbound) que expone las resoluciones. Si un dispositivo intenta buscar un “malicious.com” (ya esté camuflado, ya sea una ráfaga o una botnet), el agente captura el paquete instantáneamente apoyado por su lectura asíncrona robusta.
Envío Resiliente
Ambos agentes emplean un bus de eventos (Memory Channel), limitando la huella RAM a no más de 1000 eventos retenidos en simultáneo. Un emisor en forma de bucle enviará mediante peticiones `POST` cifradas todos los eventos, dotado de reintentos exponenciales automáticos de hasta 1 minuto para prevenir congelación o caída general del servidor (L2).
B. Gravity SOC Server (Capa L2 - Cerebro y Correlador)
Desplegado típicamente en un sistema algo mayor (como una Raspberry Pi 5 o servidor local), el “Cerebro” ingiere la telemetría continua de todos los L1 de la red.
Motor SQLite
Usando configuraciones PRAGMA exclusivas para rendimiento transaccional (`WAL` y `Synchronous = NORMAL`), mantiene el récord histórico en una base de datos de disco local capaz de tolerar flujos muy violentos de escritura con *locks* mínimos.
Correlación Real en Segundos
Usa consultas matemáticas cruzadas en tiempo real para emparejar piezas aisladas. Un `dns_alert` captado por el router y un `network_dns` generado por Sysmon en Windows se unen por su nombre de dominio y línea temporal (delta máximo de ~10 segundos) evidenciando “qué máquina de la red fue la que causó el disparo general”.
Generador de Reportes en PDF
Diariamente genera y renderiza de forma autónoma (apoyado en el paquete *GoFPDF*) informes ejecutivos y tabulados en un archivo plano en la carpeta `/reports/` informando de la jornada (ingestas globales y emparejamientos confirmados).
2. Historial de Crisis y Evolución Tecnológica (Wall of Bugs)
Durante la fase intensiva de despliegue real en ecosistemas Windows y pruebas cruzadas, detectamos problemas críticos en el manejo y fiabilidad del agente debido a la naturaleza brutal de la API de Windows, lo que forzó diversas iteraciones de diseño del agente y del servidor de Gravity SOC, consolidando su invulnerabilidad:
1. El Asesino del UTF-16 (Sysmon Windows XML)
Los shells y el `Event Log API` nativa de Windows soltaban ocasionalmente basura *little-endian* a 16-bits (o nulos `0x00` inyectados). Para solucionarlo, el agente integró uno de los *handlers* más limpios y destructivos del entorno **(Filtro de Aniquilación de Lista Blanca)** que destripa radicalmente y reconstruye todo bytes en un `UTF-8` validado matemáticamente.
2. Crash de Conexión de Capa 1 y Freeze Local
Se descubrieron caídas completas del Agente al ser incapaz de contactar al servidor, llenando el bus de memoria e imposibilitando las lecturas a `wevtutil`. El agente fue mutado y todos los procesos (el capturador, el comprobador sysmon, etc) se modificaron al estándar “cero-bloqueos” de Go (`select/default`), reventando o ignorando eventos sobrantes para jamás comprometer el estado funcional de la máquina anfitriona.
3.Ghost Hostnames (Filtración de la Interfaz)
Variables y marcadores en crudo (`os.Open` con memory leaks) obligaron a abstraer el cálculo del agente `AgentID` mediante cacheado persistente antes del *Runtime*, salvando file handles. Se aplicó el uso guardado en memoria disco con un pseudo-caché (`.gravity-checkpoint`) para sobrevivir a los reinicios de Windows sin re-lanzar un aluvión de alertas viejas.
4.Resiliencia SQL (Cerebro Ciego)
Al realizar la comparativa SQL para cruzar los eventos en la mesa de correlación (Agente Network VS Agente Windows), `database/sql` de Go sufría silenciosas paradas cardíacas debido a celdas SQLite desiertas (`NULL`). Fue subsanado empleando `TrimSpace`, `COALESCE` en inyección pura por SQL, relax de las métricas zonales y variables independientes por agente.
3. Pasos de Despliegue y Ejecución
*Es requisito contar con `Go >= 1.22` y acceso a administrador para enganchar a disco y redes si deseas ejecutar los binarios.
Compilar y Arrancar el Agente (Terminal Autorizada)
Entrar a la carpeta del Agente
cd gravity-soc-agent
Descargar módulos necesarios
go mod tidy
1. COMPILAR LINUX (Sensor PI)
$env:GOOS=“linux”; $env:GOARCH=“arm” # (o “arm64” dependiendo de kernel)
go build -o gravity-agent-linux
2. COMPILAR WINDOWS (Endpoint)
$env:GOOS=“windows”; $env:GOARCH=“amd64”
go build -o gravity-agent.exe
Ejecutar Agent Win (En Powershell/CMD de Admin)
.\gravity-agent.exe
Compilar y Arrancar el Servidor L2
Entrar a la carpeta Server
cd gravity-soc-server
go mod tidy
go build -o gravity-server.exe
Ejecución simple (se arranca WebServer)
Recibirá POSTS en /api/v1/events
.\gravity-server.exe
*Nota: Asegúrate de tener `wevtutil` funcional y Microsoft Sysmon correctamente configurado si testeas el agente de host en Windows.*
4. Diagrama Rápido del Flujo
1. Pi Zero ([Tailer.go]{.underline})
Lee silenciosamente un fichero de log Unbound. Encuentra que alguien solicita `botnet-server.ru`. Como es regex crítico, empaqueta a `dns_alert` y lo manda por HTTP al Servidor L2 Pi 5.
2. Windows 11 (Sysmon_windows.go)
En el bucle de wevtutil extrae que Microsoft Edge ha solicitado DNS para `botnet-server.ru` y originó un hilo. Filtra, destruye impurezas y lo empaqueta a `network_dns`. Lo manda al L2 Pi 5.
3. Servidor L2 (Pi 5)
El `correlator` al expirar la ventana SQL (`ABS ⇐ 10 seg`), emparenta el dominio `botnet-server.ru`. Muestra la `source_ip` de Windows y confirma la brecha en un informe limpio PDF.
Gravity SOC - Sistema de Correlación de Amenazas Multi-Capa
Gravity SOC es un ecosistema de detección de intrusiones (IDS) diseñado para correlacionar eventos de red (L1-Network) y telemetría de host (L1-Host) en un servidor centralizado (L2) basado en Go.
Arquitectura del Proyecto
- L1 - Agente Linux (Raspberry Pi Zero 2 W):
Monitoriza logs de DNS (Unbound) en tiempo real buscando indicadores de compromiso (IoC).
- L1 - Agente Windows (PC Host):
Utiliza Sysmon y ETW (Event Tracing for Windows) para extraer telemetría de procesos y red.
- L2 - Servidor Central (Raspberry Pi 5):
Recibe eventos vía API REST, los almacena en SQLite (WAL mode) y ejecuta un motor de correlación de eventos.
Desafíos Técnicos Superados
El “Jefe Final” de UTF-16:
Implementación de un pre-procesador de XML para limpiar caracteres nulos y BOM de Windows Sysmon, permitiendo la ingesta en sistemas Linux.
Resiliencia y Persistencia:
Creación de un sistema de *checkpoints* (`.gravity-checkpoint`) que permite a los agentes retomar la lectura de logs tras un reinicio o caída de red.
Blindaje contra Nulos:
Refactorización del motor SQL con `COALESCE` y escaneado robusto en Go para manejar datos incompletos sin colapsar el servicio.
Correlación Temporal:
Algoritmo de emparejamiento con ventana deslizante de 10 segundos para unir alertas de red con procesos específicos de host.
Stack Tecnológico
-
Lenguaje: Go (Golang)
-
Base de Datos: SQLite 3 con modo WAL.
-
Librerías Clave: `gofpdf` (Reporting), `BIU` (XML processing), `tail` (Linux logging).
-
Sistemas: Windows 11 (Sysmon), Parrot OS (Pi 5), Raspberry Pi OS (Pi Zero).
Diario de Ingeniería (Contexto y Operativa)
Fase 1: El Escenario Distribuido
El proyecto nació con la necesidad de unir dos mundos: la visión perimetral (red) y la visión interna (host).
Configuramos una Raspberry Pi Zero 2 W para actuar como sensor de red y una Raspberry Pi 5 como el cerebro del SOC.
Fase 2: El Desafío de Windows (Operativa Crítica)
Al intentar integrar Windows, nos enfrentamos a dos problemas graves:
-
Encoding: Windows Sysmon entrega logs en una variante de UTF-16 con bytes nulos que rompían el parser de JSON/XML en Go. Tuvimos que crear una función de limpieza de bytes agresiva.
-
Bloqueo de Memoria: El agente de Windows se colgaba al intentar enviar miles de eventos acumulados. Implementamos canales no bloqueantes y una arquitectura de Sender asíncrona.
-
Privilegios: Descubrimos que la lectura de canales ETW requiere privilegios de Administrador y reglas específicas en el Firewall de salida.
Fase 3: La Batalla del Servidor (Pi 5)
En la Raspberry Pi 5, el reto fue la correlación.
-
Fallo: Los eventos llegaban pero el servidor decía “0 amenazas”.
-
Corrección: Descubrimos que los dominios a veces venían con mayúsculas y los tiempos tenían milisegundos que SQLite no comparaba bien.
-
Solución: Implementamos LOWER(domain), TRIM() y la función SUBSTR para normalizar los timestamps a nivel de segundo, logrando el primer “MATCH” exitoso entre una Pi Zero y un PC Windows.
Manual de Usuario (Gravity SOC User Guide)
1. ¿Qué es Gravity SOC?
Es una herramienta que vigila tu red y tus ordenadores simultáneamente. Si un virus intenta conectarse a internet, el sensor de red lo detecta y el sensor de tu ordenador nos dice qué programa exacto es el culpable. Al final del día, te entrega un PDF con el resumen de seguridad.
2. Requisitos Previos
-
Servidor: Una Raspberry Pi 5 o PC con Linux/Parrot.
-
Sensores: Una Raspberry Pi Zero y un PC Windows con Sysmon instalado.
3. Implementación Paso a Paso
Paso A: Preparar el Cerebro (Pi 5)
-
Copia la carpeta gravity-soc-server.
-
Compila el servidor: go build -o gravity-server [main.go]{.underline}
-
Ejecuta: ./gravity-server. El servidor escuchará en el puerto 8443.
Paso B: Preparar el Ojo de Red (Pi 2W)
-
Asegúrate de tener instalado Unbound o un simulador de logs.
-
Ejecuta el agente: ./gravity-agent-linux.
Paso C: Preparar el Host (Windows)
-
Instala Sysmon (v15 o superior).
-
Ejecuta tmp_agent.exe como Administrador.
-
Verás en consola: [+] Evento enviado a L2.
4. Cómo ver los resultados
Para generar el reporte del día, abre tu navegador en cualquier equipo de la red y entra en:
[http://[IP_DE_TU_PI_5]:8443/api/v1/reports/daily]{.underline}
5. Pruebas de Funcionamiento (Mocking)
Para probar que el sistema funciona sin esperar a un ataque real:
-
En la Pi Zero, añade una línea al log: echo “DNS_ALERT 192.168.1.50 malware-test.com A” >> unbound.log.
-
En Windows, abre una terminal y escribe: Resolve-DnsName malware-test.com.
-
Descarga el reporte y verás la Amenaza Confirmada.