Comprueba las capacidades de tu IDS/IPS con Pytbull

Pytbull es un framework en Python para probar las capacidades de detección y bloqueo de IDS/IPS como Suricata, Snort y otros sistemas que sean capaces de generar ficheros de alerta. Aunque es una herramienta que no recibía ninguna actualización desde 2012, en marzo de este año se ha publicado una nueva versión para corregir algunos bugs y se trata de una de las pocas herramientas existentes para poner a prueba nuestros sistemas de detección y prevención de intrusiones.

Pytbull es fácilmente configurable y necesita dos partes, el cliente o Pytbull para generar los payloads y un servidor para recibirlos donde puede instalarse una shell inversa. Entre ambos se generará todo el tráfico que el IDS/IPS debe interceptar y analizar. Básicamente utiliza 5 técnicas distintas:

- socket: abre un socket en un puerto dado y envía payloads al objetivo sobre ese puerto.
- command: envía un comando al objetivo remoto con la función de python subprocess.call().
- scapy: envía payloads especialmente modificados basándose en la sintaxis de Scapy.
- client side attacks: usa un shell inverso en el objetivo remoto y envía comandos para que procese el servidor (normalmente comandos wget).
- pcap replay: permite el reenvío de tráfico basado en ficheros pcap.

En su última versión, la 2.1, se incluyen más de 300 pruebas agrupadas en 11 módulos distintos:

1. badTraffic: Los paquetes que no cumplen con el RFC se envían al servidor para comprobar cómo se procesan.
2. fragmentedPackets: se envían distintos payloads fragmentados al objetivo para poner a prueba su capacidad para recomponerlos y detectar los ataques.
3. bruteForce: comprueba la capacidad del servidor para detectar ataques de fuerza bruta (por ej. en FTP). Para ello utiliza reglas personalidas de Snort y Suricata.
4. ipReputation: comprueba la capacidad para detectar tráfico desde/hacia servidores de baja reputación.
5. clientSideAttacks: este módulo utiliza un shell inversa para proporcionar las instrucciones para descargar archivos maliciosos remotos. Este módulo pone a prueba la capacidad de los IDS/IPS para proteger contra ataques del lado del cliente.
6. normalUsage: payloads de uso normal.
7. pcapReplay: Permite reenviar archivos pcap.
8. denialOfService: Pone a prueba la capacidad de protección del IDS/IPS contra los intentos de DoS.
9. shellcodes: Enviar varios shellcodes al puerto 21/tcp para poner a prueba la capacidad de detectar/bloquear shellcodes.
10. evasionTechniques: incluye varias técnicas de evasión para comprobar si los IDS/IPS pueden detectarlas.
11. testRules: Pruebas de reglas básicas. Se supone que estos ataques han de ser detectados mediante las reglas por defecto de los IDS/IPS.

Arquitectura

Para adaptarse al entorno, Pytbull puede funcionar en dos tipos de arquitectura principales dependiendo de cómo funciona y dónde está ubicado en la red el IDS/IPS. En un entorno común con 3 partes segmentadas por un firewall (lan, wan, dmz):

- Modo remoto o standalone: en este modo el IDS a analizar está conectado en puerto span (o mirror) del switch core por lo que todo el tráfico pasa por él y los archivos maliciosos se pueden descargar por Pytbull o por el servidor. Por eso este modo se llama remoto.

- Modo local o gateway: en este modo es el cliente Pytbull quien se descarga los archivos. Dentro de este modo podemos encontrarnos distintos escenarios:
. Modo IDS con el servidor en la DMZ: el IDS está conectado a un puerto span y analiza todo el tráfico que le llega al interfaz LAN del firewall que segmenta la red.

. Modo IPS: el IPS está situado entre Pytbull y el firewall. Pytbull descarga directamente los archivos maliciosos.

. Modo IPS con el servidor en la DMZ: idem que anterior pero el tráfico se genera contra servidor de la DMZ.

Uso

Primero descargamos el paquete y lo descomprimimos:

wget https://downloads.sourceforge.net/project/pytbull/pytbull-2.1.tar.bz2
bzip2 -cd pytbull-2.1.tar.bz2 | tar xf -

En el caso del servidor necesitamos, a parte de Python claro está, un servidor FTP (21/tcp), web (80/tcp) y SSH (22/tcp):

sudo apt-get install vsftpd apache2 openssh-server

Después lo ejecutamos con ./server/pytbull-server.py:

Luego para usar el cliente (en otra máquina) resolvemos antes las siguientes dependencias necesarias:

$ sudo apt-get install python-scapy python-feedparser python-cherrypy3

En nuestro caso al usar Kali ya tenemos las herramientas instaladas pero si utilizas otra distro quizás necesites nmap, hping3, nikto, tcpreplay, apache2-utils y ncrack. Eso sí, necesitamos antes editar el fichero de configuración conf/config.cfg y corregir el path de Nikto y ncrack:

[ENV]
sudo                    = /usr/bin/sudo
nmap                    = /usr/bin/nmap
nikto                   = /usr/bin/nikto
niktoconf               = /etc/nikto.conf
hping3                  = /usr/sbin/hping3
tcpreplay               = /usr/bin/tcpreplay
ab                      = /usr/bin/ab
ping                    = /bin/ping
ncrack                  = /usr/bin/ncrack
ncrackusers             = data/ncrack-users.txt
ncrackpasswords         = data/ncrack-passwords.txt
localhost               = 127.0.0.1

También debemos indicar las credenciales de acceso al servidor FTP:

[FTP]
ftpproto                = ftp
ftpport                 = 21
ftpuser                 = prueba
ftppasswd               = prueba

A continuación ejecutamos el cliente pytbull indicando el fichero de configuración y la IP del servidor:

$ sudo ./pytbull -c conf/config.cfg -t 192.168.1.16