Permitir conexiones FTP a puertos Alternos a traves de IPTables

Hace un tiempo les hablaba en este post sobre como configurar IPTables para permitir conexiones a un servidor FTP que se encuentre en la red y les hablaba sobre los modos "Pasivo" y "Activo" de FTP. Les decía que era necesario activar los modulos ip_conntrack_ftp y ip_nat_ftp (usando modprobe), pero que pasa si el servidor FTP lo tenemos configurado para escuchar en un puerto diferente al 21? En ese caso, no basta solo con modificar las reglas DNAT en IPTables, también hay que indicarle a los módulos que cargamos que estaremos utilizando puertos diferentes al standart.

Para indicar esto, solo tenemos que crear un archivo llamado conntrack.conf dentro de /etc/modprobe.d, dentro de este indicaremos el puerto en el que escucha nuestro FTP. Supongamos que configuramos el servidor FTP para que escuche en el puerto 2221, en contenido del archivo conntrack.conf seria:

options ip_conntrack_ftp ports=2221

Guardamos nuestro archivo y listo. Con esto y las reglas de IPTables configuradas, ya podremos redirigir el trafico hacia nuestro servidor FTP. En caso de que necesiten saber como configurar las reglas pueden revisar este post y claro, cambiar el puerto "21" por el puerto en que escucha su servidor. Bueno, este fue corto, como siempre espero les haya sido de utilidad.

FTP Server (modo Pasivo) detras de IPTables

Digamos que tienen un su red un servidor FTP el cual utilizaran para colocar unos archivos que otros descargaran. No pondrán este servidor FTP diréctamente de cara a Internet, sino que en el Firewall redireccionaran los puertos de FTP hacia ese servidor servidor Internet utilizando reglas NAT o PAT. Como seguro saben, FTP utiliza 2 puertos IP: el puerto 21 y el puerto 20. El puerto 21 es el puerto de control, en el que se inicia la conexión al servidor, y el puerto 20 se utiliza para la transferencia de datos. Por lo que lo primero que haríamos seria configurar nuestro IPTables para que redirija estos 2 puertos a nuestro servidor FTP interno, utilizando reglas como estas:

-A PREROUTING -p tcp -i eth0 --dport 20 -j DNAT --to-destination ftp-server-interno.23:20

-A PREROUTING -p tcp -i eth0 --dport 21 -j DNAT --to-destination ftp-server-interno:21

Y luego:

-A FORWARD -p tcp -s 0/0 -d ftp-server-interno -m multiport --dports 20,21 -j ACCEPT

Debería funcionar cierto? bueno, funcionara siempre y cuando indiquen en su cliente FTP que utilizaran FTP  en modo "activo", que es este modo que acabamos de describir. En este modo el cliente hace la solicitud de conexión al servidor al puerto 21, aquí se le indica al servidor el puerto local que el cliente utilizara para esta conexión y entonces el servidor inicia una nueva conexión hacia el cliente al puerto que este le indico. O sea que el servidor inicia una conexión hacia el cliente luego de la negociacion inicial, lo que significa que si el cliente esta detras de un Firewall la conexión no se podra lograr, y como la mayoría de Routers ADSL y Firewalls bloquean todo el trafico entrante no se permitiría esta conexion hacia el cliente. Por esto es muy probable que las reglas de mas arriba no funcionen. Aquí un pequeño gráfico del funcionamiento de este modo:

Ahora bien, para evitar que el servidor inicie una nueva conexión hacia el cliente, se creo el modo "FTP Pasivo", en este modo el servidor luego de la negociación inicial le envía el cliente un puerto aleatorio para la transferencia de datos y el cliente entonces hace la conexion a este nuevo puerto. Así se evita el problema de filtrado del lado del cliente. Este puerto aleatorio se escoge dentro del rango de puertos TCP 1024 al 65535. En el siguiente gráfico se muestra el funcionamiento de este modo:

Esto quiere decir que tenemos que crear una regla que redirija este rango de puertos a nuestro FTP interno? Por suerte no, para esto utilizamos los módulos "ip_nat_ftp"  y "ip_conntrack_ftp" junto a las reglas que definimos mas arriba. Con esto, IPTables sabra el puerto aleatorio que se negocio para la transferencia de datos y lo direccionará a nuestro FTP Server. Para habilitar este modo ejecutamos:

# modprobe ip_conntrack_ftp

# modprobe ip_nat_ftp

Para hacer esto permanente y no tener que ejecutarlo en cada reinicio o incluirlo en algun script, solo tenemos que modificar el archivo /etc/modules y agregar:

ip_conntrack_ftp

ip_nat_ftp

Con estos módulos y utilizando las reglas de IPTables que les mostre mas arriba (las 2 que crean el DNAT y la de FORWARD que permite el  trafico de estos puertos hacia nuestro FTP server) tendremos nuestro servidor FTP funcionando detrás de IPTables. Como siempre, espero que esto les haya servido de ayuda y les haya econimizado unos minutos de busqueda en Google.

Un Poco de IPTables Parte 3: Redireccionando Logs

Siguiendo con lo que ahora se ha convertido en una serie de post de IPTables, voy a hablarles de como manejar los logs de IPTables, configurar cuales eventos que queremos escribir, agregar algún prefijo y redireccionarlos a un archivo especifico en el equipo, ya que por default los logs de IPTables se almacenan en el archivo "/var/log/kern.log". Para esto aplicaremos algunas reglas en IPTables y luego configuraremos nuestro syslog server (utilizaremos Syslog-NG) para indicar que queremos tener un archivo aparte únicamente con los log de IPTables. 

Lo primero que debemos hacer es determinar que tanto queremos que IPTables nos registre, si queremos que registre cada paquete que entre o salga a nuestra red, o si solo queremos que registre los paquetes que hayan sido "Dropeados" o descartados. La opción mas recomendable es logear todo lo que pase por nuestro Firewall, ya sea permitido o bloqueado, ya que esto nos permitirá identificar mas fácil algún problema de conexión, como auditoría en caso de que necesitemos localizar conexiones salientes o entrantes hacia algún sitio especifico o también para generar reportes de uso o ancho de banda. Hay que tener en cuenta que con esta opción nuestro archivo de log crecerá mucho mas rápido, dependiendo de la actividad de nuestra red. Para esto haremos lo siguiente: Supongamos en este ejemplo que nuestro firewall tiene 2 interfaces, la eth0 que esta conectada a Internet y la eth1esta conectada a nuestra red LAN, queremos entonces registrar todo lo que entre o salga hacia Internet, agregamos las siguientes reglas (antes de las demás reglas que hayamos definido para que se registre cada paquete antes de tomar alguna decisión sobre el mismo)

-A FORWARD -o eth0 -j LOG --log-level 7 --log-prefix IPTABLES-BANDWIDTH_OUT: 

-A FORWARD -i eth0 -j LOG --log-level 7 --log-prefix IPTABLES-BANDWIDTH_IN: 

En la primera linea le decimos a IPTables que todos los paquetes que salga desde nuestra red LAN a través de la interfase eth0 (-o eth0) le aplique la acción LOG (-j LOG), esta entrada en el log sera nivel 7 (--log-level 7) y le decimos que agregue el prefijo "IPTABLES-BANDWIDTH_OUT:" (--log-prefix), este prefijo lo utilizaremos mas adelante como filtro para enviar este tipo de eventos hacia un archivo especifico. En este prefijo pueden poner cualquier otra cosa que les haga sentido, de modo que cuando vean un evento en el log con este prefijo sepan de donde viene y como se produjo. En la segunda linea hacemos lo mismo, lo único que decimos que registro todo paquete entrante (-i) por la interface eth0, en este caso serian paquetes provenientes de Internet, y en la parte final del prefijo sustituimos OUT por IN para diferenciar los que son paquetes salientes con los entrantes.

Podemos también registrar los paquetes que han sido descartados, o que no encontraron ninguna regla que coincida permitiendo o denegando el paquete. Como les había mencionado en la entrada anterior sobre IPTables, podemos tener una acción por defecto que se aplicara a los paquetes que no coincidan con ninguna regla, por esto agregamos las siguientes reglas al final de las reglas de cada cadena, por ejemplo, al final de las reglas de INPUT, de modo que luego de que el paquete haya sido evaluado por cada y regla y no coincida, se registre este paquete antes de aplicar la regla default. Por ejemplo, supongamos que tenemos definidas varias reglas en nuestro firewall, una permitirá el trafico HTTP/S y POP3 hacia Internet desde la LAN hacia Internet, luego de estas agregaremos la siguientes reglas para logear todo lo que no se corresponda a lo que hemos definido:

-A FORWARD -p tcp -s LAN -d 0/0 --dport 80 -j ACCEPT

-A FORWARD -p tcp -s LAN -d 0/0 --dport 443 -j ACCEPT

-A FORWARD -p tcp -s LAN -d 0/0 --dport 110 -j ACCEPT

-A FORWARD -j LOG --log-level 7 --log-prefix IPTABLES-FORWARD-DROP:

-A FORWARD -j DROP

Como ven, tenemos aquí las reglas de ejemplo definidas que permiten ciertos paquetes, luego en la cuarta linea indicamos que todo lo que haya llegado a este punto sea logeado y le agregemos el prefijo "IPTABLES-FORWARD-DROP:", así reconoceremos los paquetes con este prefijo y sabremos que fueron descartados en la cadena FORWARD. Esto mismo lo podemos aplicar tambien en INPUT, OUTPUT o cualquier otra que hayamos definido. En el caso de que utilicemos las primeras reglas que registran todo el trafico entrante y saliente, es buena idea también utilizar estas ultimas, así podemos diferenciar cuales eventos corresponden a paquetes bloqueados.

Hasta ahora ya tenemos a IPTables generando logs, pero los estará creando posiblemente en el archivo "kern.log", donde se encontraran también otros tipos de eventos. Ahora veremos como separa los logs de IPTables y almacenarlos en un archivo individual con Syslog-NG.

• Configuración Syslog-NG

El archivo que crearemos para almacenar el log de IPTables lo llamaremos iptables.log y lo crearemos en /var/log. Con esta informacion, vamos al archivo "/etc/syslog-ng/syslog-ng.conf" y en la sección "#destinations" agregamos la siguiente linea:

destination d_iptables { file("/var/log/iptables.log"); };

Aquí creamos un "destino" que llame "d_iptables" y le indicamos hacia adonde apuntara, que en este caso se nuestro archivo iptables.log (tengan en cuenta que luego del corchete hay un espacio en blanco). Luego nos movemos a la sección "filters" donde crearemos un filtro que nos permitirá separar los eventos de IPTables basándonos en los prefijos que indicamos anteriormente. 

filter f_iptables { match("IPTABLES") ; }'

filter f_not-iptables { not match("IPTABLES") ; };

Aquí agregamos 2 lineas (o filtros), uno que aplicara a los eventos que contengan las palabras IPTABLES (esta palabra la agregamos en cada prefijo) y otro para los eventos que NO contengan estas palabras, el segundo lo utilizamos para evitar que los eventos de IPTables se continúen almacenando en el archivo kern.log. Nos moveremos entonces ya a la sección "log", donde buscaremos el log que define los eventos que se almacenan en el archivo "kern.log" y agregaremos el segundo filtro que creamos, se vera entonces de esta forma:

log {

         source(s_all);

         filter(f_kern);

         filter(f_not_iptables);

         destination(df_kern);

}

Luego agregaremos entonces nuestro nuevo log indicando el destino  filtro que creamos:

log {
         source(s_all);
         filter(f_iptables);
         destination(d_iptables);
}

Al agregar esto salvamos el archivo y reiniciamos el servicio (/etc/init.d/syslog-ng restart). Con esto estaremos recibiendo los eventos de IPTables en el archivo definido. Si queremos ver lo que esta pasando entonces por nuestra red (en caso de que hayan configurado la primera opción de logs) o como va creciendo el archivo de log, podemos ejecutar:

# tail -f /var/log/iptables.log

Para ver solo los que estén siendo descartados por IPTables podemos agregar :

# tail -f /var/log/iptables.log | grep DROP

Bien, hasta aquí mi pequeño tip de IPTables, como siempre, espero que esto les sea de utilidad.

Un Poco de IPTables (Parte 1)
Un Poco de IPtables (Parte 2)

Un Poco de IPTables (Parte 2)

En el post anterior sobre IPTables vimos de manera rápida lo que, a mi entender, es necesario conocer antes de empezar a utilizar IPTables. Ahora les voy a decir las cosas que he aprendido de IPTables. Las funciones del Firewall de Linux están integradas en el Kernel del sistema operativo en un modulo llamado “NetFilter”, este modulo del kernel se maneja a través de un conjunto de herramientas llamadas iptables que utilizamos para crear las reglas de Firewall. iptables también es el comando que se utiliza para modificar o crear estas reglas. Este comando nos permite definir reglas las cuales se aplicaran a los paquetes basándose en la información de la cabeceras (o headers) de los protocolos, y nos permiten indicarle al Kernel la acción que queremos que realice sobre los paquetes, estas acciones pueden ser, por ejemplo, aceptar el paquete, rechazarlo, entre otras. Cada paquete que llega al equipo es comparado con cada una de estas reglas en el orden en que estén definidas, hasta encontrar un "match", o sea, hasta que el paquete coincida con una de las reglas con las cuales se esta evaluando. Cuando el paquete coincide con lo que describe la regla, entonces se ejecutara la acción que la regla especifica para ese tipo de paquete.

Estas reglas están organizadas en grupos llamados "Cadenas". Las cadenas (o "chains" en ingles) son agrupaciones de reglas, todas estas reglas comparten características comunes, por ejemplo, hay una cadena de reglas que se aplicaran solamente a los paquetes que se dirigen hacia el equipo que corre IPTables, otra cadena compara los paquetes salen del equipo que ejecuta IPTables hacia cualquier otro equipo. Las cadenas a su vez están organizadas o agrupadas dentro de "Tablas". En IPTables existen básicamente 3 tablas: MANGLE, NAT, y FILTER. Cada una de esas tablas contiene su respectivo grupo de cadenas que realizan diferentes operaciones en los paquetes:

• Filter: esta es la tabla por defecto y es la que se utiliza para las tareas de filtrado de paquetes. Esta es la regla que mas utilizaremos, y donde se definen las reglas que permitirán o no el acceso de los paquetes al equipo que corre IPTables o a la red.
• Nat: esta tabla se utiliza para alterar las direcciones y los puertos de los paquetes y crear reglas de NAT (Network Address Translations) en el equipo.
• Mangle: esta tabla también se utiliza para la alteración de paquetes, pero alteraciones mas especificas, como QoS. No es muy común su uso, particularmente nunca he tenido que utilizarla.

Como había mencionado, estas tablas contienen "cadenas". Cuando el equipo recibe un paquete, el paquete pasa por las 3 tablas de IPTables pero no necesariamente por todas las cadenas que contienen las tablas. El kernel analiza el paquete y lo envía a la cadena que corresponda. La tabla "Filter" contiene por defecto 3 cadenas:

• INPUT: las reglas contenidas dentro de esta cadena se aplicaran solamente a los paquetes destinados al equipo que ejecuta IPTables. Por ejemplo, supongamos que en nuestro equipo Linux instalamos un servidor Web y lo configuramos para que escuche en el puerto TCP 89 y queremos descartar cualquier paquete entrante a nuestro equipo que no sea destinado a ese puerto. En esta cadena es donde debemos crear la regla que permita acceso al puerto TCP 89 y descarte todo lo demás. Mas adelante veremos como crear las reglas.
• FORWARD: las reglas que contiene esta cadena se aplicaran a los paquetes que son ruteados a través de nuestro equipo. Esto es en el caso de que instalemos nuestro equipo Linux con IPTables configurado entre dos redes, o por ejemplo, entre Internet y nuestra red interna, donde los paquetes pasaran por el Firewall para llegar a la red interna, o desde la red interna hacia el Internet. Aquí definíamos reglas como por ejemplo, que ninguna computadora de nuestra red pueda conectarse a un determinado equipo en Internet.
• OUTPUT: esta cadena contiene las reglas que se aplicaran a los paquetes que salgan desde el mismo equipo, o sea, los paquetes generados localmente.

La tabla NAT también contiene 3 cadenas por defecto:

• PREROUTING: esta cadena contiene las reglas que modificaran el paquete al momento de entrar al equipo. En esta cadena crearemos las reglas que, por ejemplo, cambiaran el puerto y la IP de destino de paquetes destinados a equipos en nuestra red interna.
• OUTPUT: esta contiene reglas para modificar los paquetes generados internamente en el equipo antes de ser enrrutados.
• POSTROUTING: esta cadena contiene las reglas que modificaran los paquetes que saldrán del equipo una vez que se han tomado las decisiones de ruteo de hacia donde se enviara el paquete.

Esas son las cadenas por defecto de la tabla Filter y Nat, pero podemos también crear nuestras propias cadenas si queremos. Cuando IPTables evalúa los paquetes contra cada una de las reglas contenidas dentro de estas cadenas y no encuentra una regla que coincida con el paquete, entonces tomara una "Acción por Defecto" la cual es definida en cada cadena. Podemos por ejemplo especificar que la acción por defecto de la cadena "INPUT" sea descartar el paquete, en este caso, si al analizar un paquete destinado a nuestro firewall no se encuentra una regla que coincida con el paquete, el paquete sera descartado.

Bien, creo que eso ha sido suficiente preámbulo, ahora vamos a ver como crear algunas reglas básicas de IPTables, estoy seguro que luego de ver un par de estas reglas se entenderá mejor todo esto. La mejor forma de entenderlo es con casos de uso prácticos, y para este caso voy a utilizar un caso de uso de IPTables básico y muy común. Observemos el siguiente gráfico: 

Tenemos nuestro equipo Linux corriendo IPTables funcionando como firewall. Nuestro firewall tiene 2 tarjetas de red, con una conecta a la red Interna (192.168.1.1) y con la otra conecta a Internet (172.23.45.7). Vamos a configurar IPTables de forma de que los equipos de la red interna tengan acceso a Internet a través de nuestro Firewall. Lo primero que vamos a hacer sera crear una regla en la tabla NAT y configurar Network Address Translation (NAT) en nuestro equipo, de modo que los equipos de la red interna compartan la dirección IP de Internet de nuestro Firewall. Para esto ejecutamos:

root@firewall:~# iptables -F

root@firewall:~# iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -d 0/0 -j MASQUERADE

Ahora la explicación de las reglas que creamos anteriormente:

iptables: Este es el comando que permite agregar las reglas al modulo netfilter

-t: Esta opción especifica la tabla que vamos a modificar, en este caso la tabla NAT.

-A: especifica la cadena en la que se quiere agregar la regla, en este caso cadena POSTROUTING.

-s: Esta opción especifica el origen de los paquetes que se rutearan, en este caso es la red interna.

-d: Esta opción específica el destino al cual se dirigen los paquetes.

-j: Esta opción se utiliza para decirle al Firewall que acción tomar con los paquetes que coincidan con lo antes citado.

Lo hicimos con la primera linea de comando fue borrar cualquier otra regla que haya sido creada en nuestro firewall utilizando el comando "iptables -F". Luego creamos una regla en la cadena POSTROUTING (usando la opción "-A") de la tabla NAT (usando la opción "-t"), esta regla le indica a IPTables que los paquetes provinientes de la red 192.168.1.0/24 (usando la opción "-s" que significa "source" u "origen") y que se dirijan hacia cualquier destino, o sea, hacia Internet (utilizando la opción "-d" que significa "destino") se les aplique la acción "MASQUERADE" (utilizando la opción "-j"). Esta acción hace que el firewall altere los paquetes que saldrán a Internet y que proceden de los equipos de red interna cambiando en el header del paquete el campo "IP de origen" sutituyendola por su propia dirección IP externa (172.23.45.7). De esta forma, los paquetes salen a Internet como si se originaran desde nuestro Firewall, o sea, hemos configurado NAT en nuestro equipo. Pero esto no es todo, para que los equipos de la red interna puedan salir hacia Internet a través de nuestro Firewall debemos crear reglas de FORWARD en la tabla FILTER. Supongamos que vamos a permitirles a los equipos de la red interna que puedan navegar en Internet, para esto necesitamos permitirles conexiones al puerto TCP 80 (puerto de http) a cualquier equipo en Internet. Para esto ejecutamos:

root@firewall:~# iptables -t filter -A FORWARD -p tcp -s 192.168.1.0/24 -d 0/0 --dport 80 -j ACCEPT

Como de lo que se trata ahora no es de modificación de paquetes, sino de determinar cuales paquetes estarán permitidos a salir de la red a través de nuestro Firewall, utilizaremos la tabla "Filter" y la especificamos utilizando la opción "-t filter". Como los paquetes que se analizaran no son dirigidos al firewall mismo sino que serán ruteados a través de el utilizaremos la cadena FORWARD, y la especificamos con la opción "-A FORWARD". Ahora bien, el tipo de paquete que permitiremos serán paquetes TCP, por lo que utilizamos la opcion "-p tcp". Utilizamos nuevamente las opciones "-s" y "-d" para especificar el origen y destino de los paquetes (192.168.1.0/24 y 0/0 respectivamente). Luego utilizamos la opción "--dport" para especificar el puerto de destino del paquete, para el caso de nuestra regla como estaremos permitiendo las conexiones a servidores Web en Internet, el puerto http es el puerto 80. Por ultimo especificamos la acción que queremos que ejecute IPTables sobre los paquetes que coincidan con la regla que acabamos de definir, en este caso aceptaremos que los paquetes salgan hacia Internet, por eso indicaremos la acción "ACCEPT". Vamos a hacer otro ejemplo, supongamos que queremos evitar que la computadora con la IP 192.168.1.2 haga conexiones FTP a un servidor en Internet con la IP 66.77.88.99, vamos a hacer una regla que bloque este tipo de trafico solo para esa IP pero que permita a las demás hacerlo:

root@firewall:~# iptables -t filter -A FORWARD -p tcp -s 192.168.1.2 -d 66.77.88.99 --dport 21 -j DROP

root@firewall:~# iptables -t filter -A FORWARD -p tcp -s 192.168.1.0/24 -d 66.77.88.99 --dport 21 -j ACCEPT

Como las reglas se van evaluando en el orden en que van siendo creadas, lo primero que hice fue crear la regla que bloquea el acceso al equipo especificado, como ven especifique la acción "DROP", esta acción bloqueara los paquetes que coincidan con lo que especificamos en la regla. Luego cree una regla que permite a cualquier otro equipo el trafico FTP pero solo lo permite al equipo especificado (66.77.88.99).  Supongamos ahora que instalamos SSH en nuestro Firewall para tener acceso remoto a el desde Internet. Tenemos que crear una regla en IPTables para que este permita conexiones SSH al equipo a través de su IP externa, para esto ejecutamos:

root@firewall:~# iptables -t filter -A INPUT -p tcp -s 0/0 -d 172.23.45.7 --dport 22 -j ACCEPT

Como pueden ver ahora utilizamos la cadena INPUT, porque se trata de paquetes que irán dirigidos al Firewall, no a algún equipo detrás de el. Como queremos conectarnos desde Internet y puede que no siempre lleguemos a nuestro firewall usando la misma dirección IP, indicamos en el "source IP" (opción -s) "0/0" esto le indica a IPTables que las conexiones pueden ser desde cualquier dirección IP. Supongamos ahora que no queremos que desde Internet se pueda acceder al servidor SSH que tenemos corriendo en nuestro Firewall, sino que solo se pueda acceder a este desde la red interna. Para esto tendríamos que crear 2 reglas, una que bloque el acceso SSH desde Internet y otra que lo permita desde la red interna:

root@firewall:~# iptables -t filter -A INPUT -p tcp -s 0/0 -d 172.23.45.7 --dport 22 -j DROP

root@firewall:~# iptables -t filter -A INPUT -p tcp -s 192.168.1.0/24 -d 192.168.1.1 --dport 22 -j ACCEPT

Ok, supongamos que ya hemos creado las reglas que necesitamos en nuestro Firewall, ahora debemos especificar la acción por defecto que queremos para cada cadena. Como les mencione la acción por defecto es la acción que tomara IPTables sobre los paquetes que no coincidan con ninguna de las reglas especificadas en la cadena. Le diremos a IPTables que descarte todo paquete que no coincida con ninguna regla, para esto ejecutamos:

root@firewall:~# iptables -t filter -P INPUT DROP

root@firewall:~# iptables -t filter -P FORWARD DROP

Utilicé la opción "-P" para definir la acción o política por defecto, como ven utilice 2 comandos, uno por cada cadena. Ahora, para ver las reglas que se han definido en el firewall ejecutamos el siguiente comando:

root@firewall:~# iptables -nL

Si ejecutamos este comando tal como esta aquí, nos mostrara solamente información de la tabla FILTER, que es la tabla por defecto. Si queremos información sobre otra tabla solo tenemos que incluir la opción "-t" y el nombre de la tabla que queremos. Bueno, hasta aquí este intento de tutorial de IPTables, espero que hayan podido entender mis explicaciones y que los minutos dedicados a leer esto no hayan sido en vano. Mas adelante continuare hablando sobre otras cosas de IPTables, como por ejemplo, como cargar las reglas al iniciar el equipo, como hacer "baclup" de las reglas que hemos definido, módulos, etc.

Un Poco de IPTables (Parte 1)

Hace un par de años, cuando empezaba a dar mis primeros pasos en Linux (en los cuales todavia estoy), escuchaba a algunas personas que hablaban de IPTables como algo dificil y complicado, no muy facil de entender por los simples mortales. Hasta que me toco (al mas simple de los mortales) empezar a estudiar sobre IPTables y note que no existia tal complejidad, claro, afortunadamente antes de empezar a "meter mano" con IPTables ya habia aprendido algo de redes y sobre todo de TCP/IP, entonces me di cuenta de que talves la razon por la que algunas personas encuentran complicado IPTables es porque no saben como trabaja TCP/IP o saben muy poco sobre el protocolo. Asi que creo que antes de empezar a hablar de IPTables debemos entender lo basico TCP/IP y entender como viajan los datos a traves de la red, asi entenderemos el trabajo de IPTables y veremos que el configurar sus reglas no es nada del otro mundo. 

Empecemos entonces con lo basico, una breve y resumida explicacion de TCP/IP. TCP/IP es un conjunto de protocolos que permite la transmision de datos en una red. Este es el protocolo en el cual esta basado Internet. En las redes TCP/IP la informacion es transmitida en "paquetes", o sea, los datos que se van a transmitir por la red son separados en "pedacitos" y transmitidos a traves del cable. TCP/IP esta divido en 4 capas, en cada una de estas capas de agrupan diferentes protocolos (de ahi el hecho de que es un "Conjunto" de protocolos). La primera capa (de arriba hacia abajo) es la capa de aplicacion, esta es la capa donde se generan los datos. Se encuentran los protocolos HTTP, POP3, FTP, DNS, etc. como pueden ver, son los protocolos que a diario utilizamos para navegar, descargar emails, descargar o transmitir archivos, etc. Luego se encuentra la capa de "Transporte". Esta capa se encargar de gestionar el transporte de los datos y asegurarse de que no hayan errores en la transmision, se encarga de crear una especie de "circuito virtual" con el equipo que recibira o transmitira la informacion. En esta capa se encuentran los protocolos TCP y UDP. Luego sigue la capa de "Red". Esta capa se encarga del enrutamiento o encaminamiento de los paquetes y de su direccionamiento. En esta capa  trabaja el procolo IP (me imagino que muchos de ustedes han configurado "direcciones IP"). Por ultimo, se encuentra la capa de "Acceso al medio" o capa "Fisica". Esta es la capa que se encarga de, digamos, "escribir" los datos en el cable. En esta capa se encuentra, por ejemplo, el protocolo Ethernet.

A medida que los paquetes pasan de una capa a la otra, los protocolos que trabajan en las capas le agregan informacion al paquete, la cual sera leida por los protocolos de la misma capa del equipo que recibira el paquete que se esta enviando. A esta informacion se le llama "header" o "cabecera". Cada capa "encapsula" o "reempaqueta" la data que proviene de la capa de aplicacion dentro de otro paquete que contiene la cabecera del protocolo de la capa.

Por ejemplo, TCP, en la capa de transporte, utiliza el concepto de "numero de puerto" para diferenciar las aplicaciones de la capa superior, de esta forma es que podemos recibir informacion desde diferentes sitios de internet hacia diferentes aplicaciones en nuestros equipos, de esta forma TCP sabe a cual aplicacion enviar los datos que recibe desde la red, ya sea al browser de Internet, al cliente de email o a nuestro programa de Chat. Y como TCP necesita esta informacion (entre otras mas), agrega un "numero de puerto de origen", que es el puerto que le asigna a la aplicacion que solicita o transmite la informacion desde nuestra computadora, y un "numero de puerto de destino", que es el puerto de la aplicacion al que va dirigido el paquete en el equipo remoto. De esta forma de establece una especie de circuito entre los 2 puertos (origen y destino). Pero ademas de esto, TCP tambien numera los paquetes para establecer una secuencia y mantener control sobre la transmision, asi que tambien agrega dentro de la cabecera un "numero de secuencia". A continuacion un grafico que muestra la cabecera que agrega TCP al paquete original con todos sus campos.

 Como pueden ver, luego de todos los campos de la cabecera TCP se encuentra la Data del paquete. Luego que el paquete sale de la capa de transporte, se dirige a la capa de red, donde el protocolo IP se encarga tambien de agregar otra cabecera al paquete, pero esta vez con informacion concerniente a IP. Como mencionamos anteriormente una de las funciones de IP es direccionar los paquetes, por esto la informacion que agrega al paquete es informacion que se utilizara para hacer llegar el paquete hacia el equipo destino y tambien informara cual equipo envio el paquete, de modo que el equipo receptor pueda contestar o confirmar su recepcion. Parte de la informacion que se encuentra en la cabecera IP es, por ejemplo, la direccion IP del equipo al que va dirigido el paquete (IP Destino) y la direccion IP del equipo que emite el paquete (IP origen), entre otros. A continuacion la cabecera IP con todos sus campos:

Cuando el paquete sale de esta capa, pasa a la capa fisica. En esta capa tambien se agrega otra cabecera al paquete, pero esta vez lo hace el protocolo Ethernet (para el caso de las redes Ethernet, que son las mas comunes hoy dia). Entre la informacion que le agrega este protocolo al paquete se encuentra el MAC Address de origen y el MAC Address de destino. Como saben el MAC Address es la direccion fisica y unica de cada tarjeta de red. No abundaremos mucho en esta capa, ya que mayormente trabajaremos con IPTables con las capas de Tranporte (TCP y UDP) y la capa de Red (IP).

Ahora que ya sabemos como viajan los datos a traves de la red, podemos empezar a hablar sobre IPTables. IPTables es capaz de leer toda la informacion en la cabecera de los paquetes segun van entrando al equipo, incluso antes de que la misma pila TCP/IP pueda tener acceso a ellos. Entonces, al ser capaz de leer y analizar toda la informacion de cabecera del paquete, como IP de origen y destino, puerto de origen y destino, tipo de protocolo (TCP o UDP), y practicamente todos los otros campos de cabecera, pueden establecerse "reglas" o "filtros" en base a esa informacion. De esa forma, podemos hacer que IPTables bloquee o no permita el acceso de paquetes que en su cabecera TCP indiquen que  se dirigen hacia un "puerto 80" de algun equipo remoto, o que en la cabecera IP indique que se dirige a un IP destino en especifico.

Bueno, creo que por ahora esta bien como introduccion a IPTables, basicamente porque ya me esta ganando el sueño (son las 1 y tanto de la mañana) y porque se haria muy extenso este post.  En el proximo post hablaremos en mas detalle de que es IPTables, su funcionamiento y como configurarlo.

Un Poco de IPTables (Parte 2)