Iptables para torpes

¿Que es iptables? Iptables es una parte del kernel de Linux, está integrado en el, desde la versión 3 sino recuerdo mal. Es un filtro de paquetes de red, podemos decir que es un firewall.

Iptables utiliza las tablas de enrutamiento. Estas tablas es la forma en la que iptables se organiza para funcionar. Estas tablas albergan reglas que permiten aplicar distintos tratamientos a los paquetes de red que llegen a nuestro equipo.

Las tablas FILTER y NAT son las tablas más importantes para los administradores. FILTER es «el filtro» y NAT «network address translation» (muchos diccionarios, wikipedias, etc traducen translation como traducción pero más bien, mi parecer es que la correcta traducción sería traslación «Efecto de trasladar o trasladarse de lugar», ya que de lo que se trata, es de trasladar los paquetes de red de una dirección IP a otra». Seguro que alguien coincide conmigo sobre esta mala traducción de anglicismo) es la tabla que se encarga de tratar los paquetes cuando estos requieren un tratamiento más específico.

Las reglas que componen el filtro FILTER

• INPUT: entrada, los paquetes destinados a entrar en nuestro sistema deben pasar por esta cadena.
• OUTPUT: salida, todos aquellos paquetes creados por el sistema y que van a salir de él.
• FORWARD: redireccionamiento, redirecciona a su nuevo destino, afectando a todos los paquetes que pasan por esta cadena.

Las reglas que componen el filtro NAT

• PREROUTING para modificar paquetes tan pronto como lleguen al equipo.
• OUTPUT: para la salida de paquetes que se generan localmente y van a ser enrutados para su salida.
• POSTROUTING: modificar paquetes que estén listos para salir del equipo.

Como se aprecia hay una sola norma común para estas dos tablas, OUTPUT.

En este gráfico tenéis el flujo que sigue un paquete al encararse a iptables. El resumen es el siguiente tabla nat -> tabla filter -> tabla nat. Debemos tener en cuenta que al «llegar a una tabla» esta contiene una cadena de reglas «INPUT, PREROUTING, FORWARD, POSTROUTING, OUTPUT….» Hay más tablas como «mangle» pero no vamos a entrar en detalles profundos sino en lo básico.

paquetes de red a través de iptables:

                               XXXXXXXXXXXXXXXXXX
                               XXX     Red    XXX
                               XXXXXXXXXXXXXXXXXX
                                        +
                                        |
                                        v
 +--------------+             +-------------------+
 |tabla:  filter| < ---+       | tabla:  nat       |
 |cadena: INPUT |     |       | cadena: PREROUTING|
 +-----+--------+     |       +--------+----------+
       |              |                 |
       v              |                 v
 [proceso local]      |     ************************       +---------------+
       |              +---+ Decisión de enrutamiento +---> |tabla: filter  |
       v                    ************************       |cadena: FORWARD|
************************                                   +------+--------+
Decisión de enrutamiento                                          |
************************                                          |
       |                                                          |
       v                    ************************              |
+--------------+      +---+ Decisión de enrutamiento < ------------+
|tabla:  nat   |      |     ************************
|cadena: OUTPUT|      |                +
+-----+--------+      |                |
      |               |                v
      v               |      +--------------------+
+---------------+     |      | tabla: nat         |
|tabla:  filter | +---+      | cadena: POSTROUTING|
|cadena: OUTPUT |            +--------+-----------+
+---------------+                      |
                                       v
                               XXXXXXXXXXXXXXXXXX
                               XXX    Red     XXX
                               XXXXXXXXXXXXXXXXXX

Reglas generales: Como íbamos diciendo las reglas que definen las tablas correspondientes son ACCEPT, DROP, REJECT, QUEUE y RETURN, de los cuales normalmente solo vamos a necesitar ACCEPT, REJECT y DROP, vamos a lo más básico de nuevo.

¿Que haría esta regla? Hacer DROP de todos los paquetes que llegen «genericamente» a la cadena INPUT. Rechazaría cualquier paquete. ¿Quieres quedarte sin internet? Prueba.

iptables -P INPUT DROP 

Complicando las cosas:

iptables -A INPUT -p tcp --dport 22 -j ACCEPT 

A diferencia de -P INPUT estamos usando -A esto, es quiere decir que solo va a afectar a la regla especificada y no a toda la cadena de INPUT. Además se especifica el protocolo y puerto donde se va a permitir tráfico para esa cadena de INPUT. El -j ACCEPT, simplente indica el objetivo de la regla, en este caso aceptar el tráfico.

Supongamos ahora que tenemos dos interfaces de red, eth0 y eth1. eth0 está conectado a internet y en eth1 tenemos nuestra raspberrypi conectada esperando para funcionar pero no tiene acceso directo por si misma. eth0 está configurado en la IP 192.168.1.115 y eth1 está configurado como 10.0.0.1 El caso es que queremos que nuestra raspberrypi 10.0.0.18 también tenga acceso a internet a través de ese eth1 (hay que aprovecharlo), como eth0 tiene acceso a internet, deberíamos dejar pasar hacia dentro -i eth1 (input) cierto tráfico y viceversa -o eth1 (output). Hay que entender que cada regla tiene su sintaxis y que se pueden añadir más filtros.

iptables -A FORWARD -i eth1 -j ACCEPT
iptables -A FORWARD -o eth1 -j ACCEPT

Hay un problema, y es que al tener un rango de IP distinto, el router de casa no reconoce como propios los paquetes que puedan salir de una máquina detras de otra máquina, dado que el rango no corresponde. Para resolver esto se recurre al enmascaramiento. Iptables puede dar un «tratamiento» al paquete en cuestión para hacerlo pasar por un paquete propio de su rango. De esta forma cualquier cosa que se envíe fuera será enmascarado con la ip propia de eth0.

iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

Y con esto nos adentramos en las reglas de POSTROUTING, o lo que es lo mismo, darle un tratamiento a un paquete justo antes de enviarlo hacia afuera. Como esta cadena pertenece al tabla NAT, iptables empieza indicándolo con «-t nat», continua con el flag que define la cadena concreta POSTROUTING, indica el dispositivo sobre el que se realiza esta acción -o eth0 y la acción objetivo -j MASQUERADE. Que enmascarará los paquetes de red.

El enrutado puro, esto es cuando queremos mandar paquetes a máquinas que no están en nuestro rango de ip de ninguna de nuestras interfaces, sino a cualqueir otro lugar de la red, sea interna o externa. En este ejemplo, se vuelve a usar como no -t nat, puesto que la regla es de PREROUTING, se añaden filtros como -i eth0 , protocolo -p tcp y puesto de destino –dport 80, -j DNAT indica que vamos a enrutar y finalmente el destinatario de la redirección –to 172…

iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j DNAT --to 172.31.0.23:80

Y hasta aquí ya hemos visto como rechazar, aceptar, hacer forwarding, enmascarar paquetes y enrutar de una forma básica, muy básica. Para ir más a fondo tendrías que leer esto: https://netfilter.org/documentation/HOWTO/es/NAT-HOWTO.html

Más en el binario sobre iptables https://elbinario.net/2014/06/08/log-del-taller-de-iptables/