¿Qué es el Port Knocking? |

El Port Knocking o “Golpeo de puertos” es una técnica para aplicar seguridad a nuestro servidor. Según vemos en la imagen el Port Knocking se comporta como un Firewall.

¿En qué consiste?

Lo normal es que nos conectemos remotamente a nuestro servidor por SSH por el puerto 22, a través de algún cliente como Putty, podríamos aplicar algo de seguridad y cambiar el puerto por defecto que es el 22, pero aun así hay utilidades como Nmap que nos permiten averiguar los puertos que hay abiertos, por tanto, nos pueden hacer un ataque a los diferentes puertos a ver si consiguen entrar, algo nada fácil, pero no imposible. Un sistema siempre puede ser vulnerable a ataques de fuerza bruta, y más si el user y las pass son de diccionario.

Aquí es donde entra la técnica del Port Knocking, comportándose como un Firewall. El método consiste en realizar una serie de intentos de conexión preestablecidos a una cadena de puertos para avisar al sistema de que es un acceso seguro. ¡¡ Buff que lio ¡!

Lo explicaré en mayor detalle:

Configuro en el sistema para que si hay un intento de conexión en la siguiente secuencia de los puertos 7000-8000-9000, me deje entrar por SSH al puerto deseado. Tiene que ser en esa misma secuencia y a esos mismos puertos, si no el puerto no se abriría.

Si hago la secuencia 6000-7000-8000 no dejaría entrar
Si hago la secuencia 9001-800 no dejaría entrar

Por lo tanto el servidor tiene el puerto cerrado, pero cuando detecte que se ha realizado la secuencia de puertos correcta (definida previamente en el archivo de configuración), el server abrirá el puerto para establecer una conexión.

Al lío, proceso de configuración.

1. Instalar el paquete knockd.

aptitude install knockd

Tras la instalación el servicio no está activo, para ello editar el archivo que nos dice la imagen, lo haremos en el punto 2.

2. Tras la instalación, editar fichero /etc/default/knockd

Como se puede leer, hay que editar el fichero /etc/knockd.conf antes de editar este, pero no habría ningún problema si editamos /etc/default/knockd antes.

# PLEASE EDIT /etc/knockd.conf BEFORE ENABLING

START_KNOCKD=1

Hay que poner START_KNOCKD a 1 para que el demonio knockd arranque.

Un demonio es un proceso que se ejecuta en segundo plano (background)

# command line options

# KNOCKD_OPTS=»-i eth1″

Hay que descomentar la línea anterior, y especificarle en qué interfaz tiene que escuchar, si no la descomentamos por defecto es el «eth0».

No funciona poner dos interfaces con «-i eth0 -i eth1».

3. Bloquear acceso al puerto 22 con IPTABLES

AHHHH!!, por dios que es eso de IPTABLES, tranquilos aquí tenéis esta pequeña explicación.

IPTABLES es el cortafuegos (FIREWALL) por defecto de Linux.

iptables -A INPUT -p tcp –dport 22 –j DROP

Esto lo que hace es indicar a iptables que añada (A) una nueva regla a la cadena de entrada (INPUT) para el protocolo tcp (-p tcp), en la que descarte (-j DROP) todos los paquetes recibidos al puerto de destino 22 (–dport 22), que es el puerto SSH por defecto.

Ver como lo hemos bloqueado con :

iptables -L

Para borrar las reglas de iptables, iptables -F

Si cuando hacemos iptables -L aparece esto es que no tenemos ninguna regla definida.

nmap localhost

Para instalar nmap: aptitude install nmap

4. Editar el fichero /etc/knockd.conf

Aquí se encuentra el meollo, vemos que cuando llega una secuencia de paquetes TCP con el flag de SYN a los puertos 7000, 8000 y 9000 en menos de 5 segundos, el demonio knockd añade una regla de iptables para permitir el acceso al servicio SSH a la IP que ha hecho el port knocking. Y con la secuencia de puertos a la inversa, podemos cerrar el puerto posteriormente.

Usaré la secuencia por defecto 7000, 8000, 9000 pero aconsejo escoger otra por seguridad.

[options]

#UseSyslog //esto es lo que viene por defecto

logfile = /var/log /knockd.log //personalizamos el fichero de log

[openSSH]

sequence = 7000,8000,9000

seq_timeout = 5

command = iptables -D INPUT -p tcp –dport 22 -j DROP

tcpflags = syn

[closeSSH]

sequence = 9000,8000,7000

seq_timeout = 5

command = iptables -A INPUT -p tcp –dport 22 -j DROP

tcpflags = syn

Explicación de la configuración:

[options]

UseSyslog significa que para registrar actividad (log) se usará /var/log/syslog

[openSSH]

Es donde obviamente irán las instrucciones para abrir SSH,

sequence. Primeramente tenemos la secuencia de puertos (la combinación secreta) que está configurada por defecto (puerto 7000, 8000 y 9000).

NOTA IMPORTANTE:

Obviamente los puertos se pueden cambiar (de hecho lo recomiendo) así como no tienen que ser 3 obligatoriamente, pueden ser más o menos, depende de lo que deseen ustedes.
Los puertos no pueden ser consecutivos, deben estar bien distantes.

seq_timeout. Significa el tiempo que se esperará para que se efectúe la combinación secreta de puertos. Por defecto está puesto 5 segundos, esto significa que una vez empecemos a efectuar el port knocking tenemos máximo 5 segundos para terminar la secuencia correcta.

Si pasan 5 segundos y no hemos culminado el port knocking entonces simplemente será como si la secuencia no hubiese sido válida.

command. Cuando esos puertos sean «tocados» ejecutará el comando:

/sbin/iptables -D INPUT -p tcp -dport 22 -j DROP, que elimina la sentencia creada en iptables encargada de bloquear el puerto SSH, permitiéndonos así poder conectar.

tcpflags. Con esta línea especificamos el tipo de paquetes que reconocerá el servidor como válidos para el port knocking. Por defecto es syn.

[closeSSH]

Hace lo contrario, la vuelve a añadir para que los paquetes que lleguen al puerto SSH sean descartados, pero el golpeo de los puertos es en orden contario como se observa.

5. Ponemos en marcha el demonio.

/etc/init.d/knockd start

O bien

service knockd start

6. Desde el pc cliente mandar la secuencia de conexión para que nos abra el puerto, eso sí, previamente hay que instalar en el cliente el paquete knock.

aptitude install knockd //Instalar paquete en el cliente

knock 10.33.1.2 7000 8000 9000

Si no dice nada va bien

O bien

knock -v 10.33.1.2 7000 8000 9000

La marca «-v» le indica que lo haga en modo «verbose» (que muestre lo que va haciendo), seguido de la dirección IP del servidor (10.33.1.2), seguido de los puertos a «golpear» en cuestión en el orden indicado, poniendo el protocolo utilizado para realizar el «golpeo» separado por dos puntos «:»

7. Ver que funciona.

conectarnos por putty

o bien

ssh -p 22 jesus@10.33.1.2

o bien

ssh jesus@10.33.1.2

8. Hacer el proceso inverso para cerrar el puerto.

knock -v 10.33.1.2 9000 8000 7000

9. Ver el fichero de log para ver que se está realizando bien el proceso.

Cada golpeo se identifica como un Stage y openSSH y closeSSH son los nombres que se definen en el fichero de configuración /etc/knockd.conf

Como podéis ver, el Port Knocking es muy interesante y útil, además aparte de lo que ya sabemos podemos configurarlo para que mate un proceso, detenga un servicio como apache o MySQL, arranque el servicio SSH, hacer una actualización del sistema de forma remota sin ni siquiera acceder al sistema, añadir o eliminar un usuario, mover ficheros de lugar, eliminarlos, claro está apuntándonos previamente la combinación de puertos deseada, no vaya a ser que la liem os p arda.

Algunos ejemplos de configuración del fichero knockd.con los puedes ver en la siguiente imagen.

Ejemplos:

Ejemplo #1:

Crear un fichero vacío en el HOME del usuario deseado mediante Port knocking, con el golpeo de puertos 1500, 4000 y 5000.

Vamos a ver cómo hacemos para crear un fichero (vacío en este caso) en el escritorio de cierto usuario. Para ello añadimos una nueva regla en el fichero /etc/knockd.conf:

[createFile] sequence         = 1500,4000,5000
seq_timeout    = 5
command        = touch /home/jesus/FicheroCreado
tcpflags             = syn

Tras reiniciar el servicio «knockd», cuando llamemos a los puertos indicados se creará en el Escritorio del usuario «jesus» el fichero vacío con nombre «FicheroCreado»:

knock -v 10.33.1.2 1500 4000 5000

Cabe mencionar que el fichero se creará con permisos de superusuario ya que es el usuario encargado de ejecutar el servicio knockd. Ese es uno de los motivos por los que hay que tener mucho cuidado con el uso de esta técnica, ya que si ponemos una sentencia para eliminar un usuario y alguien descubre cuáles son los puertos a los que hay que llamar, pues ya sabemos lo que pasará. Por tanto mejor usarlo para cosas «triviales» y que no impliquen mucho riesgo en nuestros servidores.

A continuación expondré unos Ejemplos de configuración extraídos de http://www.zeroflux.org/projects/knock/

Example #2:

This example uses two knocks. The first will allow the knocker to access port 22 (SSH), and the second will close the port when the knocker is complete. As you can see, this could be useful if you run a very restrictive (DENY policy) firewall and would like to access it discreetly.

[options]

logfile = /var/log/knockd.log

[openSSH]

sequence = 7000,8000,9000

seq_timeout = 10

tcpflags = syn

command = /usr/sbin/iptables -A INPUT -s %IP% – p tcp –dport 22 -j ACCEPT

[closeSSH]

sequence = 9000,8000,7000

seq_timeout = 10

tcpflags = syn

command = /usr/sbin/iptables -D INPUT -s %IP% – p tcp –dport 22 -j ACCEPT

Example #3:

This example uses a single knock to control access to port 22 (SSH). After receiving a successful knock, the daemon will run the start_command, wait for the time specified in cmd_timeout, then execute the stop_command. This is useful to automatically close the door behind a knocker. The knock sequence uses both UDP and TCP ports.

[options]

logfile = /var/log/knockd.log

[opencloseSSH]

sequence = 2222:udp,3333:tcp,4444:udp

seq_timeout = 15

tcpflags = syn,ack

start_command = /usr/sbin/iptables -A INPUT -s %IP% -p tcp –syn –dport 22 -j ACCEPT

cmd_timeout = 10

stop_command = /usr/sbin/iptables -D INPUT -s %IP% -p tcp –syn –dport 22 -j ACCEPT

Example #4:

This example doesn’t use a single, fixed knock sequence to trigger an event, but a set of sequences taken from a sequence file (one-time sequences), specified by one_time_sequences directive. After each successful knock, the used sequence will be invalidated and the next sequence from the sequence file has to be used for a successful knock. This prevents an attacker from doing a replay attack after having discovered a sequence (eg, while sniffing the network).

[options]

logfile = /var/log/knockd.log

[opencloseSMTP]

one_time_sequences = /etc/knockd/smtp_sequences

seq_timeout = 15

tcpflags = fin,!ack

start_command = /usr/sbin/iptables -A input -s %IP% -p tcp –dport 25 -j ACCEPT

cmd_timeout = 5

stop_command = /usr/sbin/iptables -D INPUT -s %IP% -p tcp –dport 25 -j ACCEPT

Ejercicios resueltos de subnetting by Jesús Fernández Toledo is licensed under a Creative Commons Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional License.