Instalación de SGUIL

Introducción

Snort es un producto IDS (Intrussion Detection System). Su funcionamiento consiste en capturar y analizar paquetes por algún segmento de red, y siguiendo unas determinadas reglas avisar cuando pueda haber algún tipo de tráfico sospechoso, y así poder evitar situaciones de riesgo.

Para visualizar y gestionar dichas alertas, usaremos una aplicación cliente-servidor llamada SGUIL: The Analyst Console for Network Security Monitoring.

Entorno del sistema

Básicamente el entorno se compone de tres partes: Sensores, servidor y cliente.

Los sensores son los encargados de recibir la información desde el lugar dónde se analice. El servidor será el intermediario entre los sensores y los clientes. Y finalmente el cliente se encarga de visualizar y gestionar los disintos eventos enviados desde el servidor.

Si bien puede haber varios sensores, en nuestro caso sólo habrá uno, encargado de analizar el tráfico recibido por una interface conectada a un puerto SPAN.

Un esquema del entorno sería:

En nuestro caso el sensor y el servidor estarán en el mismo host.

Instalación del software básico

La siguiente tabla nos muestra el software necesario así como las versiones y en qué localización tiene que ser instalado. Recordemos que en nuestro caso tanto el sensor como el servidor están en la misma máquina.

Software	Versión	Localización	Descargar	Comentarios
MySQL	5.x	Servidor	http://dev.mysql.com/downloads/mysql	Las versiones 4.1.x también funcionan correctamente
Libpcap	0.9.4	Sensor	http:/ /www.tcpdump.org
Libnet	1.0.2a	Sensor	http://www.packetfactory.net/libnet/	Hay que usar forzosamente la versión 1.0.2a, no se puede usar ni siquiera otra versión posterior
Snort	2.6.0.2 o posterior	Sensor	http://www.snort.org/dl/	Hay que conseguir también las reglas. Para obtenerlas de la página oficialhace falta registrarse enla misma.
SANCP	1.6.1	Sensor	http://www.metre.net/sancp.html	También hay que descargarse los parches fix200511.a y fix200511.b.
Barnyard	0.2.0	Sensor	http://www.snort.org/dl/barnyard/
P0f	2.0.5	Servidor	http://lcamtuf.coredump.cx/p0f.shtml
Tcpflow	0.21	Servidor	http://www.circlemud.org/%7Ejelson/software/tcpflow/
Tcltls	1.5	Cliente y Servidor	http://sourceforge.net/projects/tls	Crea un canal de datos cifrado entre el Servidor y las consolas de análisis
Mysqltcl	2.51	Servidor	http://www.xdobry.de/
Tcllib	1.8	Servidor	http://tcllib.sourceforge.net/
Sguil	0.6.1	Cliente y Servidor	http://sguil.sourceforge.net/index.php?page=download
Sguil startup scripts	0.6.0	Sensor y Servidor	Http://sourceforge.net/projects/instantnsm	Conjunto de scripts de inicio.

A continuación descomprimimos los ficheros tar.gz. Recordemos el comando para esto:

#tar -zxvf software.tar.gz

Lo que creará un directorio con el mismo nombre del software y su versión.

Mysql

# cd mysql-5.0.24a

# ./configure –prefix=/usr/local/mysql-5.0.24a \

--enable-assembler --enable-local-infile \

--enable-thread-safe-client –without-debug \

--with-openssl

# make

# make install

Libpcap

# cd libpcap-0.9.4

# ./configure --prefix=/usr/local/libpcap-0.9.4

# make

# make install

# ln -s /usr/local/libpcap-0.9.4 /usr/local/libpcap

Libnet

# cd Libnet-1.0.2a

# ./configure --prefix=/usr/local/libnet-1.0.2a

# make

# make install

# ln -s /usr/local/libnet-1.0.2a /usr/local/libnet

Hay que asegurarse que el script libnet-config se encuentre en el path.

Snort

# cd snort-2.6.0.2

# ./configure --prefix=/usr/local/snort \

--with-libpcap-includes=/usr/local/include \

--with-libpcap-libraries=/usr/local/lib \

--with-libnet-includes=/usr/local/include \

--with-libnet-libraries=/usr/local \

--enable-dynamicplugin \

--with-mysql=/usr/local/mysql \

--with-mysql-includes=/usr/local/mysql/include/mysql \

--enable-flexresp

# make

# make install

SANCP

Editar Makefile. Buscar la línea CFLAGS y cambiarla:

CFLAGS= -O3 -s -I/usr/local/libpcap/include –L /usr/local/libpcap/lib

Aplicar parches anteriormente descargados:

# patch <>

# patch <>

# make

# mkdir -p /usr/local/sancp-1.6.1b/bin

# cp sancp /usr/local/sancp-1.6.1b/bin

Barnyard

Requiere tcl-devel para funcionar. En RedHat seguramente ya tenga este paquete instalado, y si en caso contrario se instala con un simple rpm.

Antes de compilar, necesitamos parcheas algunos ficheros. Descomprimimos sguil en /usr/local/sguil-0.6.1 y a continuación creamos un enalce simbólico a /usr/local/sguil.

# cd barnyard-0.2.0

# cp /usr/local/sguil/sensor/barnyard_mods/op_sguil.* src/output-plugins

# cp /usr/local/sguil/sensor/barnyard_mods/configure.in .

# cd src/output_plugins

# patch -p0 < /usr/local/sguil/sensor/barnyard_mods/op_plugbase.c.patch

Ahora sí, procedemos a compilar:

# cd ../..

# autoconf

# ./configure --prefix=/usr/local/barnyard-0.2.0+sguil --enable-tcl --with-tcl=/usr/lib

# make

# make install

# cp -r ./etc /usr/local/barnyard-0.2.0+sguil/etc

p0f

Hay que editar el fichero mk/Linux en la línea que comience por "LIBS="

LIBS = -lpcap -I/usr/local/libpcap/include -L/usr/local/libpcap/lib

Asegurase también de que existe la línea en p0f.c

#include

y no

#include

Compilamos:

# make

# mkdir -p /usr/local/p0f-2.0/sbin

# cp p0f /usr/local/p0f-2.0/sbin

Mysqltcl

Hacemos la compilación:

# ./configure --with-mysql-include=/usr/local/mysql/include/mysql \

--with-mysql-lib=/usr/local/mysql/lib/mysql --with-tcl=/usr/lib

# make

# make install

Añadir en /etc/ld.so.conf:

/usr/local/mysqltcl-2.51/lib

/usr/local/mysql/lib/mysql

Y ejecutar:

# ldconfig

TclTLS

En Redhat debemos indicar antes de compilar:

# export CC=”gcc -I/usr/kerberos/include”

Y continuamos con el procedimiento habitual:

# ./configure --prefix=/usr/local/tcltls-1.5 --with-ssl-dir=/usr

# make

# make install

Tclx

# cd tclx8.4

# ./configure

# make

# make install

Seguiremos el siguiente criterio con el software instalado: si está el /usr/local/- crear un enlace simbólico que apunte a /usr/local/software para que no haya confusiones. Es decir:

# ln -s /usr/local/software-versión /usr/local/software

En el servidor

Si está instalado Mysql por medio de rpm, eliminar el siguiente paquete:

# rpm -e mysql-server

Es conveniente crear los siguientes enlaces simbólicos:

# ln -s /usr/local/tcpflow/bin/tcpflow /usr/local/bin

# ln -s /usr/local/p0f/sbin/p0f /usr/local/bin

# ln -s /usr/local/mysql/bin/mysql /usr/local/bin

# ln -s /usr/local/mysql/bin/mysqladmin /usr/local/bin

# ln -s /usr/local/mysql/bin/mysqlcheck /usr/local/bin

# ln -s /usr/local/mysql/bin/mysqld_safe /usr/local/bin

# ln -s /usr/local/mysql/bin/mysqldump /usr/local/bin

# ln -s /usr/local/mysql/bin/mysql_install_db /usr/local/bin

# ln -s /usr/local/mysqltcl/lib/mysqltcl-2.51 /usr/lib

# ln -s /usr/local/tcllib/lib/tcllib1.8 /usr/lib

En el sensor

Las siguientes operaciones se realizarán en el sensor. En nuestro caso, en el mismo host que el servidor.

Asegurarse de que están los siguientes paquetes instalados:

- Tcpdump

• tclx

Por conveniencia, creamos los siguientes enlaces simbólicos:

# ln -s /usr/local/barnyard/bin/barnyard /usr/local/bin

# ln -s /usr/local/sancp/bin/sancp /usr/local/bin

# ln -s /usr/local/snort/bin/snort /usr/local/bin

En el cliente

• Windows:

Sencillamente instalar Activetcl8.4 (de http://www.activestate.com/store), Tls (http://tls.sourceforge.net/) y SGUIL Client (de http://www.boseco.com/www.boseco.com/download/Sguil/ ) y Ethereal (Wireshark).

Descomprimir las librerías tls en /tcl/lib/

• GNU/Linux:

Hay que tener instalado el soiguiente software:

-ethereal-gnome

-tclx

-tcllib

-itcl

Configuración

Un esquema más detallado de la situación sería el siguiente:

Configurando el servidor:

Se crea un usuario en el sistema:

# useradd -u 400 -d /home/sguil -c “SGUIL User” sguil

Se crean los siguientes directorios:

# mkdir -p /nsm/sguild_data/archive

# mkdir /nsm/sguild_data/rules

# chown -R sguil.sguil /nsm/sguild_data

Si no existe el usuario “mysql”, crearlo:

# useradd -u 27 -d /var/lib/mysql -s /bin/bash \

-c “MySQL Server” mysql

Crear en siguiente enlace simbólico:

# ln -s /var/lib/mysql /nsm

Cambiar propietario y permisos:

# chown -R mysql.mysql /nsm/mysql

# chmod 755 /nsm/mysql

Descomprimimos instantnsm-20060110.tar.gz

Ahora procedemos a instalar los ficheros de configuración de Mysql y a aseguranos que el demonio corra al iniciar el sistema:

# cp /usr/local/src/instantnsm-20060110/startup_files/my.cnf /etc

# cp /usr/local/src/instantnsm-20060110 /startup_files/mysqld5 /etc/init.d

# chkconfig --add mysqld5

# chkconfig mysqld5 on

Creamos la estructura inicial de la base de datos:

# /usr/local/mysql/bin/mysql_install_db --user=mysql

Ya podemos iniciar el servicio:

# service mysqld5 start

# mysqladmin ping

Ahora, se crea un usuario “sguil” en Mysql:

# mysql -u root -p mysql

Enter password:

mysql> GRANT ALL PRIVILEGES ON sguildb.* TO sguil@localhost

IDENTIFIED BY “sguil_password” WITH GRANT OPTION;

mysql> GRANT FILE ON *.* to sguil@localhost;

mysql> update user set Password = OLD_PASSWORD(“sguilpass”) where User = “sguil”;

mysql> FLUSH PRIVILEGES;

Ahora se crea una base de de datos vacía llamada sguildb para almacenar todos los datos:

# mysql -u sguil -p -e “CREATE DATABASE sguildb”

# mysql -u sguil -p -D sguildb < /usr/local/sguil/server/sql_scripts/create_sguildb.sql

# mysql -u sguil -p -D sguildb -e “show tables”

El último comando “show tables” debería mostrar:

+-------------------------+

| Tables_in_sguildb |

+------------------------ +

| history |

| nessus |

| nessus_data |

| portscan |

| sensor |

| sessions |

| status |

| user_info |

| version |

+-------------------------+

A continuación, creamos un directorio para el fichero PID:

# mkdir /var/run/sguil

# chown sguil.sguil /var/run/sguil

Ahora, se crea una estrutura de directorios donde almacenar los ficheros de configuración para el servidor, y continuación se copian de los originales:

# mkdir -p /etc/sguild/certs

# cp /usr/local/sguil/server/sguild.conf /etc/sguild

# cp /usr/local/sguil/server/autocat.conf /etc/sguild

# cp /usr/local/sguil/server/sguild.users /etc/sguild

# cp /usr/local/sguil/server/sguild.queries /etc/sguild

# cp /usr/local/sguil/server/sguild.access /etc/sguild

# cp /usr/local/sguil/server/sguild.email /etc/sguild

# cp /usr/local/sguil/server/sguild.reports /etc/sguild

# chown -R sguil.sguil /etc/sguild

Se edita el fichero /etc/sguild/sguild.conf y se hacen los siguientes cambios:

• set SGUILD_LIB_PATH /usr/local/sguil/server/lib

• set DEBUG 0

• set SENSOR_AGGREGATION_ON 0

• set RULESDIR /nsm/rules

• set DBPASS “sguilpass”

• set DBUSER sguil

• set LOCAL_LOG_DIR /nsm/archive

• set TCPFLOW /usr/local/bin/tcpflow

• set P0F 1

• set P0F_PATH /usr/local/bin/p0f

Ahora se necesita crear un certificado SSL para cifrar las comunicaciones entre el servidor de sguil y las consolas de análisis. En RedHat EnterpriseEdition automatiza la mayoría del proceso:

# cd /usr/share/ssl/certs

# make sguild.pem

Esto creará un fichero llamado /usr/share/ssl/certs/sguild.pem. El fichero PEM no es nada más que un fichero de texto que contiene la clave privada y el certificado público. Tendrá un aspecto similar a:

-----BEGIN RSA PRIVATE KEY-----

MIICWwIBAAKBgQCxFTbTzpeU2z1u7PinG0TjLq6UZUT4TWUfyj5DJogwOXteHQkd

lYvwUZgtUmQmyYBmTMbFGeHSJ/TXnFUUETfG3FHel/zeWer5QqJoezERT2RvZ7CK

5C7aUaFqAsUCj4rOnQJAK46SuoVYYM8/eZLSP6iOYZK1dj74+8ScM8KYzxS9xeTD

phabxc/FbbuCrcDyxlfFW91RbFVCNFFFe2qpDRB1Nw==

-----END RSA PRIVATE KEY-----

-----BEGIN CERTIFICATE-----

MIID0zCCAzygAwIBAgIBADANBgkqhkiG9w0BAQQFADCBqDELMAkGA1UEBhMCVVMx

ETAPBgNVBAgTCFZpcmdpbmlhMRUwEwYDVQQHEwxXaWxsaWFtc2J1cmcxFTATBgNV

CSEb3wRxje9WILnkpNOf5ETPW4x/WSFFNfcqzeeuNDFzE2zBv9S2dLeGtHc3JvKL

Q808wzYJvS9FeilVKwyxDIRplELRjrI=

-----END CERTIFICATE-----

Sguil necesita separar esto en dos ficheros distintos. Para hacer esto se usa uin editor de texto y se copia la parte entre “BEGIN RSA PRIVATE KEY” y “END RSA

PRIVATE KEY LINE” (ambas inclusives) a un fichero en el directorio de configuración del demonio llamado: /etc/sguild/certs/sguild.key.

Igualmente, se copia todo lo que hay entre “BEGIN CERTIFICATE” y “END

CERTIFICATE”, ambas inclusive, a un fichero llamado /etc/sguild/certs/sguild.pem.

Hay que editar el script de inicio /etc/init.d/sguild y asegurarse que se ejecuta con las opciones habilitadas para SSL:

# cp /usr/src/instantnsm-20060110/startup_files/sguild /etc/init.d/

daemon --user $sguil_user $sguild -P /var/run/sguil/sguild.pid -O /usr/local/tcltls/lib/libtls1.50.so -C /etc/sguild/certs -o –D

Ahora añadimos una cuenta de usuario para el analista de seguridad. La cuenta simplemente debe de estar en el servidor. Para añadirla se usa el comando:

# /usr/local/sguil/server/sguild -adduser sguil

Finalmente, se copia el fichero de inicio y de configuración para que se ejecuten al iniciar el sistema:

# cp /usr/src/instantnsm-20060110/startup_files/sguild/sguild /etc/init.d

# chkconfig --add sguild

# chkconfig sguild on

# service sguild start

Si se obtiene un error de conflicto con la librería tcllib con el módulo sha1, desinstalar la versión tcl dee Redhat:

# rpm -el --nodeps tcl

El servicio sguild debería estar ya corriendo. Ahora se debería usar un comando como “ps -eaf | grep sguil” para asegurarse de que hay 3 procesos sguild ( sguild duplica un par de procesor auxiliares cuando empieza).

Llegados aquí, sería conveniente reiniciar el sistema para comprobar que los demonios MySQL y el servidor sguil están corriendo.

Configurar un cliente:

• Windows:

Una vez instalado todo, simplemente habrá que editar el fichero de configuración como convenga.

• set SERVERHOST

• set SGUILLIB ./lib

• set DEBUG 0

• set OPENSSL 1

• set TLS_PATH "C:/Tcl/lib/tls1.5/tls15.dll"

• set STATUS_UPDATES 10

• set ETHEREAL_STORE_DIR "C:/temp"

Seindica el path a Ethereal o Wireshark:

• set ETHEREAL_PATH "C:/Archiv~1/Wireshark/wireshark.exe"

• GNU/Linux:

Se copia el fichero de configuración:

# cp /usr/local/sguil/client/sguil.conf /etc/sguil.conf

Y después se edita:

• set SERVERHOST

• set SGUILLIB /usr/local/sguil/client/lib

• set DEBUG 0

• set OPENSSL 1

• set TLS_PATH /usr/local/tcltls/lib/libtls1.50.so

• set STATUS_UPDATES 10

• set ETHEREAL_STORE_DIR /var/tmp

Configurar un sensor

Es la parte más tediosa de todas, ya que hay que editar una cantidad considerable de ficheros.

Lo primero que hay que hay que hacer es asignarle un nombre al sensor. El nombre tiene que ser único y muy significativo acerca de dónde esté situado, para que al analista le sea fácil intuir su ubicación.

Evitar el uso de guiones altos “-“ en el nombre ya que podría provocar errores en las consultas de la base de datos.

En este ejemplo se llamará red_interna.

Se debe tener un usuario sguil en el equipo, como en nuestro ejemplo el sensor y el servidor están en la misma máquina, no es necesario. En caso contrario se crearía así:

# useradd -u 400 -d /home/sguil -c “SGUIL User” sguil

Se crean los siguientes directorios:

# mkdir -p /logs/snort-logs/red_interna/OLD

# mkdir -p /nsm/snort_data/red_interna/dailylogs

# mkdir -p /nsm/snort_data/red_interna/sancp/today

# mkdir /nsm/snort-logs

# chown -R sguil.sguil /nsm/snort-logs /nsm/snort_data

Y por conveniencia, también se crea el enlace simbólico:

# ln -s /nsm/snort-logs/red_interna /logs/snort-red_interna

Hay que tener un directorio para el fichero PID. Lo hemos creado antes, pero si el sensor y el cliente estuviesen en distintas máquinas, habría que crearlo:

# mkdir /var/run/sguil

# chown sguil.sguil /var/run/sguil

Ahora se extrae las reglas de snort a /usr/local/snortrules-red_interna y se configuran apropiadamente. Hay que asegurarse de que los ficheros de configuración se encuentran en el propio directorio y no en subdirectorios de /usr/local/snortrules-red_interna. Por ejemplo: usr/local/snortrules-red_interna /snort.conf, /usr/local/snortrules-red_interna /sid-msg.map, etc).

Una vez hecho esto, hay que copiar en el servidor las reglas a /nsm/rules/red_interna. Como en nuestro caso sensor y servidor están en la misma máquina, bastará con hacer un enlace simbólico:

# ln -s /nsm/rules/red_interna /usr/local/snortrules-red_interna

Ahora viene la parte más delicada: configurar todas las aplicaciones para que trabajen juntas. Hay que editar una cantidad considerable de ficheros.

Primero, se crea el directorio de configuración.

# mkdir /etc/sguil

Se copian los ficheros de configuración de sus localizaciones originales al nuevo directorio, renombrando la mayoría para que incluyan el nombre del sensor, por conveniencia a la hora de tener varios. La excepción es sancp.conf ya que todos los sensores de la máquina lo usarán.

# cp /usr/local/sguil/sensor/sancp/sancp.conf /etc/sguil/sancp.conf

# cp /usr/local/sguil/sensor/sensor_agent.conf /etc/sguil/sensor_agent- red_interna.conf

# cp /usr/local/barnyard/etc/barnyard.conf /etc/sguil/barnyard- red_interna.conf

A continuación se edita /etc/sguil/sensor_agent- red_interna.conf

set SERVER_HOST

set DEBUG 0

set HOSTNAME red_interna

set LOG_DIR /nsm

set S4_KEEP_STATS 0

Ahora toca editar /etc/sguil/barnyard-red_interna.conf y hacer los cambios indicados abajo. Asegurarse de comentar las dos líneas indicadas.

config hostname: red_interna

config filter:

#output alert_fast

#output log_dump

output sguil: sensor_name red_interna

____________________________________________________

Nota para sistemas con más de un sensor:

Barnyard se comunica con el agente local del sensor enun puerto por defecto. Si hay dos sensores en la misma máquina, se necesita seleccionar otro número de puerto para la comunicación. Si hay un solo sensor, el que viene por defecto está bien, en caso contrario hay que asignar a cada sensor un puerto único. Una solución sería empezar por el puerto 7740 e ir incrementandolo en uno para cada sensor. Para cambiar el puerto del agente hay que editar to /etc/sguil/sensor_agent-.conf: set BY_PORT También hace falta decirle a la instancia de barnyard qué puerto usar. Esto se hace editando /etc/sguil/barnyard-.conf: output sguil: sensor_name agent_port

____________________________________________________

Ahora se copian los ficheros de inicio:

# cp /usr/src/instantnsm-20060110/startup_files/barnyard-sensor \

/etc/init.d/barnyard-red_interna

# cp /usr/src/instantnsm-20060110/startup_files/sancp-sensor /etc/init.d/sancp-red_interna

# cp /usr/src/instantnsm-20060110/startup_files/sguil_agent-sensor \

/etc/init.d/sguil_agent-red_interna

# cp /usr/src/instantnsm-20060110/startup_files/sguil_logger-sensor \

/etc/init.d/sguil_logger-red_interna

# cp /usr/src/instantnsm-20060110/startup_files/snort-sensor \

/etc/init.d/snort-red_interna

Ahora se usa el comando chkconfig para que se inicien todos los servicios al inicio del sistema:

# chkconfig --add barnyard-red_interna

# chkconfig --add sancp-red_interna

# chkconfig --add sguil_agent-red_interna

# chkconfig --add sguil_logger-red_interna

# chkconfig --add snort-red_interna

# chkconfig barnyard-red_interna on

# chkconfig sancp-red_interna on

# chkconfig sguil_agent-red_interna on

# chkconfig sguil_logger-red_interna on

# chkconfig snort-red_interna on

En /etc/init.d/barnyard-red_interna en la línea “SENSOR=SENSORNAME” hay que reemplazarla por “SENSOR=red_interna”

Al igual que “SNORTLOG=/var/log/snort-$SENSOR” por

“SNORTLOG=/nsm/snort-logs/snort-$SENSOR”

En /etc/init.d/snort-red_interna hacer lo mismo:

SENSOR=red_interna

Además, hay que localizar la línea “NSMDIR=NSMDIR” y cambiarla por:

NSMDIR=/nsm/snort_data

Y por último indicar el interfaz a monitorizar:

INTERFACE=eth0

A continuación, hacer las mismas modificaciones a /etc/init.d/sancp-red_interna que las hechas anteriormente.

En /etc/init.d/sguil_agent-red_interna indicar el nombre del sensor:

SENSOR=red_interna

Finalmente, hay que editar /etc/init.d/sguil_logger-red_intena para, de nuevo, indicar el nombre del sensor:

SENSOR=red_interna

Este componente necesita una configuración adicional:

En primer lugar debe tener una su propia copia del script que recoge los datos de los paquetes:

# cp /usr/local/sguil/sensor/log_packets.sh \

/usr/local/sguil/sensor/log_packets-red_interna.sh

Ahora hay que editar /usr/local/sguil/sensor/log_packets-red_interna para incluir las siguientes opciones:

HOSTNAME=”red_interna”

LOG_DIR=”/nsm”

INTERFACE=”eth0”

OPTIONS=”-u sguil -g sguil -m 122”

NOTA: si al ejecutar el script da el siguiente error:

/usr/local/sguil/sensor/log_packets-red_interna.sh: line 159: [: too many arguments

Sustitur la línea:

CUR_USE=`df -P $LOG_DIR | grep -v -i filesystem | awk '{print $5}'|tr -d %`

Por:

CUR_USE=`df -P $LOG_DIR | grep -v -i filesystem | awk '{print $5}' |

tr –d Capacity |tr -d %`

Ahora se necesita iniciar/reiniciar el proceso de logeo de paquetes como una tarea regular. Si el filesystem /logs se llena rápidamente, especificar que el logeador se ejecute con frecuentcia,por ejemplo cada 5 minutos.

Para ello, se añade en /etc/crontab.conf:

*/5 * * * * /etc/init.d/sguil_logger-red_interna restart

En el fichero de ocnfiguración de snort, snort.conf indicar el directorio para guardar las estadísticas:

preprocessor perfmonitor: time 300 file \

/nsm/red_interna/snort.stats pktcnt 10000

Y la salida para log unificado:

output alert_unified: filename snort.alert, limit 128

output log_unified: filename snort.unified, limit 128

En /etc/init.d/barnyard-red_interna indicar con el parámetro –f el log unificado:

barnyard="/usr/local/bin/barnyard -c /etc/sguil/barnyard-$SENSOR.conf -g /usr/local/snortrules-$SENSOR/gen-msg.map -s /usr/local/snortrules-$SENSOR/sid-msg.map -f snort.unified -w $SNORTLOG/waldo.file -p /usr/local/snortrules-$SENSOR/classification.config -X /var/run/sguil/barnyard-$SENSOR.pid -L $SNORTLOG -a $SNORTLOG/OLD -d $SNORTLOG -D"

Ahora se reinicia el sistema.

Si todo está funcionando correctamente al ejecutar el comando ps, deberíamos ver algo parecido a :

root@veleta:/root> ps -eaf | grep -i sguil

sguil 14308 1 0 Oct06 ? 00:00:13 tail -n 1 -f /nsm/red_interna/snort.stats

sguil 14028 1 5 Oct09 ? 05:10:32 /usr/local/bin/sancp -d /nsm/snort_data/red_interna/sancp -i eth0 -u sguil -g sguil -c /etc/sguil/sancp.conf –D

sguil 25820 1 0 Oct10 ? 00:19:32 tclsh /usr/local/sguil/server/sguild -P /var/run/sguil/sguild.pid -O /usr/local/tcltls/lib/libtls1.50.so –D

sguil 25829 25820 0 Oct10 ? 00:00:00 tclsh /usr/local/sguil/server/sguild -P /var/run/sguil/sguild.pid -O /usr/local/tcltls/lib/libtls1.50.so –D

sguil 25831 25820 0 Oct10 ? 00:00:00 tclsh /usr/local/sguil/server/sguild -P /var/run/sguil/sguild.pid -O /usr/local/tcltls/lib/libtls1.50.so –D

sguil 12630 1 5 Oct11 ? 02:44:38 /usr/local/bin/snort -u sguil -g sguil -m 122 -l /nsm/snort-logs/snort-red_interna -c /usr/local/snortrules-red_interna/snort.conf -D -i eth0 -o -q –U

sguil 13692 1 0 12:51 ? 00:00:00 tclsh /usr/local/sguil/sensor/sensor_agent.tcl -D -c /etc/sguil/sensor_agent-red_interna.conf

sguil 13696 13692 0 12:51 ? 00:00:00 tail -n 1 -f /nsm/red_interna/snort.stats

sguil 13774 1 0 12:52 ? 00:00:00 /usr/local/bin/barnyard -c /etc/sguil/barnyard-red_interna.conf -g /usr/local/snortrules-red_interna/gen-msg.map -s /usr/local/snortrules-red_interna/sid-msg.map -f snort.log -w /var/log/snort-red_interna/waldo.file -p /usr/local/snortrules-red_interna/classification.conf

Y la consola de análisis debería ver las alertas generadas. Para ejecutar la consola en GNU/Linux sería ejecutando el script sguil.tk.

# /usr/local/bin/sguil.tk

Y en Windows usando el ejecutable cliente.

Se selecciona el sensor. Y vemos al fin las alertas generadas:

Referencias:

Proyecto Instantnsm : Ficheros de configuración y documentación en inglés.