Tocando antes de entrar a nuestro sistema (portknocking)

Knockd es un programa “de llamada” muy interesante. Consta de un cliente y un servidor, y lo que hace este ultimo es simple: se queda a la espera de una serie de “llamadas” de parte del cliente (tambien se puede usar telnet o netcat) a puertos especificos, en el orden especifico en que fueron configurados, en un rango de tiempo preestablecido. Si todo se da como tiene que darse, ejecuta uno o varios comandos. Un ejemplo:

Supongamos que tengo un servidor ssh corriendo en una maquina de mi casa o mi trabajo (protegida por firewall), y quiero conectarme desde otro lado para administrar mi sistema remotamente. Entonces configuro knockd para que se quede escuchando, y si en algun momento alguien envia una peticion al puerto 1234, seguida de otra peticion al puerto 5678, y luego al 9010, mi sistema (el de mi casa o trabajo) va a ejecutar una regla en el firewall, permitiendo que la IP que tiro esas peticiones se conecte al puerto 22 (ssh) para administrar el sistema. Ese alguien seguramente sere yo, puesto que solo yo conozco los puertos a los que hay que conectarse y en el orden que hay que hacerlo.

Puede parecer algo liado pero es muy util y agrega algo mas de seguridad a nuestro sistema, ya que es un paso mas que se necesitara para conectarse al mismo, y ademas este programa tiene incluso restriccion de IP, permitiendo que (siguiendo el ejemplo anterior) solo se conecten al puerto 22 desde la IP que yo tenga en ese momento, en cuyo caso para todos los demas usuarios de internet el puerto 22 de la maquina estara filtrado.

Para instalarlo en nuestro Debian, basta con hacer apt-get install knockd para que nos instale el programa y un par de librerias si no las tenemos ya en el sistema. Con esto ya tenemos el cliente y servidor instalados, y ahora vamos a configurarlos.

El archivo de configuracion se llama knockd.conf y esta en el directorio /etc. Si lo editamos veremos algo parecido a esto:

NOTA: Agrego algunas explicaciones sobre cada cosa, para que se entienda mejor.

[options]
logfile = /var/log/knockd.log

Esta es la ubicacion del archivo donde se van a registrar (con fecha y hora) los accesos parciales y totales, los comandos que se ejecutaron dependiendo de la configuracion de mas abajo, los reinicios del servidor, errores, y otras cosas mas.

[openSSH]
sequence = 7000,8000,9000
seq_timeout = 5
command = /sbin/iptables -A INPUT -s %IP% -p tcp --dport 22 -j ACCEPT
tcpflags = syn

Esta secuencia se llama ‘OpenSSH’ y que espera es una secuencia de conexiones a los puertos 7000, 8000 y 9000 (en ese orden) por defecto TCP, en un lapso de 5 segundos (seq_timeout), con el flag syn (tcpflags), para luego ejecutar el comando (command) que le dice a iptables que permita conexiones al puerto 22 de ssh, desde la IP con la cual hicimos la ‘llamada’ (que se encuentra en %IP%) a los puertos dados.

[closeSSH]
sequence = 9000,8000,7000
seq_timeout = 5
command = /sbin/iptables -D INPUT -s %IP% -p tcp --dport 22 -j ACCEPT
tcpflags = syn

Y esta otra secuencia es contraria a la anterior, ya que si nos conectamos a los puertos 9000, 8000 y 7000 (en ese orden) en el lapso de 5 segundos, va a ejecutar un nuevo comando de iptables que va a borrar la regla creada anteriormente, es decir que el puerto 22 estara filtrado para cualquier IP, como era en un principio.

Pero hay mas opciones y formas de hacer las cosas, y yo voy a comentar una que me parece mas interesante que la que viene por defecto y que acabamos de ver. En esencia es lo mismo, solo que en lugar de tener que hacer una ‘llamada’ para que la regla de iptables se borre, vamos a decirle a knockd que si luego de ejecutado el comando de apertura del puerto 22, no nos conectamos en 30 segundos, se ejecute automaticamente el comando para borrar la regla. Para esta configuracion, quedaria algo asi:

[options]
logfile = /var/log/knockd.log

[openSSH]
sequence = 1234:tcp,5678:tcp,9010:udp
seq_timeout = 5
tcpflags = syn
start_command = /etc/init.d/ssh start; /sbin/iptables -A INPUT -s %IP% -p tcp –dport 22 –syn -j ACCEPT;
cmd_timeout = 30
stop_command = /sbin/iptables -D INPUT -s %IP% -p tcp –dport 22 –syn -j ACCEPT; /etc/init.d/ssh stop;
NOTA: Elegi 3 puertos en este caso, pero se pueden elegir la cantidad que se desee para incrementar la seguridad.

Aca hay un par de cosas para comentar:

– En sequence vemos que tambien se pueden usar puertos UDP, no solo TCP. Esto lo hacemos usando los dos puntos (:) entre el numero y el tipo de protocolo. Si no se pone nada, se toma por defecto que es TCP.
– En start_command vamos a poner el o los comandos, separados por punto y coma (;), que se van a ejecutar y en el orden que lo haran, cuando se de la combinacion de peticiones correctas que el servidor knockd espera escuchar. En este caso, hemos adicionado un comando para que se ejecute el servidor SSH, para luego ejecutar el comando iptables que nos permita conectarnos al puerto 22.
– stop_command contiene los comandos de cierre, en este caso filtrar de nuevo el puerto 22 para todo el mundo, y luego parar el servidor SSH.
– cmd_timeout es donde le decimos que espere 30 segundos para luego ejecutar los comandos stop_command.

Por ultimo, comentar que si bien se puede hacer un telnet a los puertos dados, siempre es mejor usar el cliente knock, disponible para varias plataformas (incluida Win32), y la forma de usarlo en un solo comando seria asi:

Primero ejecutamos el servidor con la opcion -v (verbose), para ver como va funcionando todo:

$ knockd -v
listening on eth0...

Luego, desde otra maquina (puede que desde la misma no funcione correctamente), nos conectamos de la siguiente forma:

$ knock -v 192.168.1.1 1234:tcp 5678:tcp 9010:udp
hitting tcp 192.168.1.1:1234
hitting tcp 192.168.1.1:5678
hitting udp 192.168.1.1:9010

Y si volvemos a mirar la respuesta del servidor, veremos algo asi:

192.168.1.2: openSSH: Stage 1
192.168.1.2: openSSH: Stage 2
192.168.1.2: openSSH: Stage 3
192.168.1.2: openSSH: OPEN SESAME
openSSH: running command: /etc/init.d/ssh start; /sbin/iptables -A INPUT -s 192.168.1.2 -p tcp --dport 22 --syn -j ACCEPT;
Starting OpenBSD Secure Shell server: sshd.
192.168.1.2: openSSH: command timeout
openSSH: running command: /sbin/iptables -D INPUT -s 192.168.1.2 -p tcp --dport 22 --syn -j ACCEPT; /etc/init.d/ssh stop;
Stopping OpenBSD Secure Shell server: sshd.

Ahi vemos:
– que me conecte desde otra maquina con IP 192.168.1.2
– que envie las peticiones en el orden correcto a los puertos correctos
– que se ejecutaron los comandos que antes vimos en start_command
– y por ultimo, que al haber pasado los 30 segundos de lapso que tenia para conectarme (192.168.1.2: openSSH: command timeout), se ejecutaron los comandos de cierre que teniamos en stop_command

Como se puede ver, este es un programita muy interesante, flexible y que aporta un toque mas de seguridad en nuestro sistema Linux.

Y como siempre, es recomendable consultar las paginas del manual del programa para conocer todas las opciones que ofrece y apreciar las otras posibilidades que aca no se citaron: man knockd y man knock.

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s