script de asesor de reglas de iptables

Hay un servidor sin ninguna defensa de iptables :ACCEPT all..

Podría haber aplicaciones personalizadas en este servidor.

Si necesitamos endurecer este servidor (denegar todo y solo dejar lo que necesitan las aplicaciones) con estrictas reglas de iptables, tenemos que descubrir a mano qué aplicación usa cuál dst/src port/protocoly luego tenemos que escribir las reglas de iptables para ellos..

La pregunta : ¿hay algún script que pueda ayudar a recopilar esta información de una máquina en ejecución? (desde los registros?) - ¿Y generando automáticamente las reglas de iptables?

Como si hubiera el audit2allowencendido SELinux. Solo por iptables!

¡La máquina no puede tener ninguna interrupción!

Ej .: el script "MAGIC" debería ejecutarse una semana / mes en la máquina, recolectando información, luego, después de una semana / mes, el script podrá producir un archivo de reglas de iptables que podamos usar.

Muchas personas podrían entrar en esta situación (cómo fortalecer un servidor con respecto a iptables). Y sería genial si hubiera un script / solución que pueda hacer esto: \

Hazlo manualmente

sudo ss -tuanp

o

sudo netstat -tuanp

Explicación:

-t - show tcp sockets
-u - show udp sockets
-a - show all sockets
-n - show numeric, don't resolve 
-p - show process name

Ejecutar tcpdumpen la máquina durante una semana más o menos para capturar el tráfico promedio. Luego, puede navegar por el tráfico utilizando wireshark más adelante para ver qué puertos se están utilizando.

El comando para esto sería tcpdump -i <interface> -s 65535 -w <some-file>

Luego puede asignar esto de nuevo usando netstat -tuanppara ver qué PID / aplicaciones están usando qué puertos.

Teóricamente esto podría ser programado.

Puede comenzar con una plantilla muy básica como: https://gist.github.com/jirutka/3742890 , que solo permite ssh y ping, y agrega cualquier otra cosa manualmente.

Un truco rápido de script para generar reglas de iptables para que su aplicación escuche en la interfaz pública (0.0.0.0) / tcp

netstat -lnpt | egrep '0.0.0.0:[0-9]+' | awk '{print $4,$7}' | \
sed -E -e 's/0.0.0.0://g' -e 's|[0-9]+/||' | \
awk '{printf ("iptables -A INPUT -p tcp --dport %5d --syn -m conntrack --ctstate NEW -m comment %s \n", $1,$2) }'

También puede usar el iptables -I INPUT <number>para inyectar las reglas en una ubicación específica, que puede enumerar coniptables -nvL --line-numbers INPUT

Desafortunadamente, no hay tal script que haya visto que pueda ejecutarse en modo de aprendizaje o en modo pasivo registrando todo el uso de su red, tomando sus resultados y generando un firewall real usando iptablesdesde sus registros.

Su mejor opción será comenzar de manera simple y seguir agregando continuamente las diversas piezas a medida que comience a comprender completamente qué servicios proporciona su sistema. Deberá utilizar herramientas como netstatver qué puertos están en uso para los diversos servicios que aloja, así como qué direcciones IP están accediendo a ellos.

$ sudo netstat -tlpn
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address               Foreign Address             State       PID/Program name   
tcp        0      0 0.0.0.0:25                  0.0.0.0:*                   LISTEN      26292/sendmail      
tcp        0      0 0.0.0.0:890                 0.0.0.0:*                   LISTEN      26149/ypbind        
tcp        0      0 0.0.0.0:445                 0.0.0.0:*                   LISTEN      26321/smbd          
tcp        0      0 127.0.0.1:2207              0.0.0.0:*                   LISTEN      26226/python        
tcp        0      0 127.0.0.1:2208              0.0.0.0:*                   LISTEN      26221/./hpiod       
tcp        0      0 127.0.0.1:199               0.0.0.0:*                   LISTEN      26237/snmpd         
tcp        0      0 0.0.0.0:809                 0.0.0.0:*                   LISTEN      26067/rpc.statd     
tcp        0      0 0.0.0.0:139                 0.0.0.0:*                   LISTEN      26321/smbd          
tcp        0      0 0.0.0.0:587                 0.0.0.0:*                   LISTEN      26292/sendmail      
tcp        0      0 0.0.0.0:111                 0.0.0.0:*                   LISTEN      26038/portmap       
tcp        0      0 0.0.0.0:35604               0.0.0.0:*                   LISTEN      -                   
tcp        0      0 0.0.0.0:22                  0.0.0.0:*                   LISTEN      26249/sshd          
tcp        0      0 0.0.0.0:631                 0.0.0.0:*                   LISTEN      26257/cupsd         
tcp        0      0 :::22                       :::*                        LISTEN      26249/sshd          
tcp        0      0 :::631                      :::*                        LISTEN      26257/cupsd         

NOTA: En lo anterior puede ver qué servicios tengo en un servidor que aceptan conexiones TCP, es decir, están "escuchando" las conexiones en varios puertos.

Comenzar con cosas como SSH (puerto 22) y HTTP (puerto 80) es muy fácil, si esto es típico de su sistema, por lo que haría este tipo de servicios en masa de una vez. Para otros servicios como LDAP o NIS, es posible que desee hacerlos de una manera más controlada, asegurándose de que las cosas no se rompan a medida que las presenta.

Las herramientas como FireHOL , Firewall Builder (fwbuilder) y eztables pueden ser útiles al atacar este proyecto, ya que proporcionan una buena capa de abstracción al tener que crear iptablereglas personalizadas a mano, lo que puede ser complicado.

FireHOL es un lenguaje (y un programa para ejecutarlo) que crea firewalls seguros y con estado de cualquier complejidad desde configuraciones fáciles de entender y legibles por humanos.

ejemplo

transparent_squid 8080 "squid root" inface eth0

interface eth0 mylan
    policy accept

interface ppp+ internet
    server smtp accept
    server http accept
    server ftp  accept
    server ssh  accept src example.firehol.org

    client all  accept

router mylan2internet inface eth0 outface ppp+
    masquerade
    route all accept

Fwbuilder es una herramienta gráfica de cortafuegos única que permite al usuario crear objetos y luego arrastrarlos y soltarlos en los cortafuegos, para construir un poderoso sistema de seguridad para una sola PC o una red de PC. Fwbuilder admite una amplia gama de firewalls (Cisco ASA / PIX, iptables de Linux, ipfilter de FreeBSD, pf de OpenBSD y más), por lo que sus reglas pueden implementarse en múltiples plataformas. Echemos un vistazo al uso de Fwbuilder en Linux, que podría convertirse en un asunto de por vida con un potente sistema de seguridad.

ejemplo

Eztables le permite configurar rápidamente un firewall sin tocar iptables. La sintaxis de la regla del firewall está diseñada para que sea fácil de leer y aplicar.

Así es como permite que todo Internet acceda a su servidor web en el puerto TCP 80:

  allow_in any $eth0 any 80/tcp

Eztables está diseñado para ser simple pero potente. No importa si desea proteger su computadora portátil, si está configurando un enrutador doméstico o si está creando un firewall de la empresa.

Usando Fail2Ban

Con un iptablesfirewall rudimentario en su lugar, es probable que desee complementarlo utilizando una herramienta como Fail2Ban .

Fail2ban analiza los archivos de registro (por ejemplo, / var / log / apache / error_log) y prohíbe las IP que muestran signos maliciosos: demasiadas fallas de contraseña, búsqueda de vulnerabilidades, etc. Generalmente, Fail2Ban se usa para actualizar las reglas del firewall para rechazar las direcciones IP durante un período de tiempo especificado, aunque también se puede configurar cualquier otra acción arbitraria (por ejemplo, enviar un correo electrónico). Fuera de la caja, Fail2Ban viene con filtros para varios servicios (apache, courier, ssh, etc.).

El uso de herramientas como esta ayudará a limitar la exposición que su sistema tendrá que soportar a medida que continúe endureciéndolo. Incluso después de estar bastante convencido de que su sistema se ha fortalecido, es posible que desee seguir usando Fail2Ban como parte de sus medidas de seguridad.

Referencias

• Cree potentes firewalls de Linux con Firewall Builder
• Ejemplo de FireHOL
• Página principal del proyecto FirewallBuilder
• Ejemplo básico de firewall / iptables

Use las reglas de iptable para registrar las nuevas conexiones, eso también registrará udp.

iptables -I INPUT -m state --state NEW -j LOG --log-prefix "New inbound connection: "
iptables -I OUTPUT -m state --state NEW -j LOG --log-prefix "New outbound connection: "

Puede especificar diferentes --log-level para tener los registros en otro archivo que no sea / var / log / messages (deberá configurar el demonio syslog).

Creo que debería leer los registros de la aplicación principal, ya que algunos servidores tienen una actividad muy periódica como el mediodía, fin de semana, fin de mes (trimestre, año) para que no se pierda una importante actividad de red del servidor.

Como el servidor es crítico, crea la matriz de flujo de red del servidor en una bonita hoja de cálculo (fuente ip, destino ip, protocolo, puerto, aplicación) que lo ayudará a construir las reglas.

Sé que esto no es un script y no es una respuesta a la pregunta de OP, pero es una idea mía que quiero compartir con OP.

Tengo todos los puertos de escucha con:

netstat -an | egrep 'tcp .*LISTEN' | awk -F" " '{print $4}' | awk -F":" '{print $NF}'

Tal vez esto pueda acercarte más a escribir tu propio guión. :)

Puedes comenzar con algo como esto:

netstat -n -l -p | egrep "^(tcp|tcp6|udp)" | grep LISTEN | sed -r 's!^(tcp|tcp6|udp)\s.*:([0-9]+).*LISTEN\s+.*/(.*)!iptables -A INPUT -p \1 --dport \2 -j ACCEPT # \3!'

y luego seguir con

iptables -P INPUT DROP

o

iptables -A INPUT -j REJECT --reject-with icmp-host-prohibited

Lo que hace la primera línea es usar netstat para enumerar los procesos de escucha y sus puertos. Luego generará líneas "iptables" para permitir cada una de esas conexiones entrantes. La pequeña sustitución de regex sed se personalizó para la salida de netstat en mi servidor, por lo que podría requerir algunos ajustes para usted. Cuando funciona, debes terminar con algo parecido a:

iptables -A INPUT -p tcp --dport 111 -j ACCEPT # rpcbind       
iptables -A INPUT -p tcp --dport 22 -j ACCEPT # sshd          
iptables -A INPUT -p tcp --dport 25 -j ACCEPT # master        
iptables -A INPUT -p tcp --dport 3306 -j ACCEPT # mysqld        
iptables -A INPUT -p tcp --dport 49476 -j ACCEPT # rpc.statd     
iptables -A INPUT -p tcp --dport 5432 -j ACCEPT # postgres.bin  
iptables -A INPUT -p tcp --dport 55371 -j ACCEPT # rpc.statd

Dos cosas importantes a tener en cuenta:

1) Estas reglas no hacen nada por usted hasta que coloca una línea DROP o RECHAZO al final o hace que sea la política predeterminada para paquetes no coincidentes. Estas reglas permiten paquetes, lo cual es discutible, si la política predeterminada es permitir algo que no coincida.

2) Estas reglas son ambivalentes sobre la IP de origen . Desde su puesto original, parece que quiere permitir que todos los clientes para utilizar el servidor y, a continuación, examine los registros para obtener fuente IP de ir con los puertos de destino. No conozco una herramienta para hacer eso, por lo que este script solo evitará que las personas realicen nuevos servicios en su servidor que escuchen en otros puertos ... que es algo .