Firewalls en Linux (Netfilter) – Parte I

By 6 de agosto de 2006 Linux 2 Comments

tux_topic_raro.pngPara poder proteger datos dentro de una red, resulta necesaria la implementación de un firewall para prevenir intrusiones, dado que es la herramienta más eficaz contra el tráfico de información no deseado.

Linux tiene implementado en el núcleo el código de una serie de funciones para poder construir nuestros propios firewalls.
Estas funciones reciben el nombre de Netfilter, y la aplicación es Iptables. Las Iptables nos permiten decidir que hacer con el tráfico que circula por nuestra máquina: aceptarlo, denegarlo o rechazarlo.
Iptables es la estructura de una tabla sobre la que podemos establecer reglas. Cada regla consta de unas condiciones de coincidencia, y una acción para cada coincidencia.
Para empezar, se debe tener claro el concepto de filtro. Un filtro es una parte de software que observa las cabeceras de los paquetes que llegan al host, siendo capaz de decidir que hacer con los paquetes.

  1. Funcionamiento del filtrado
  2. Operaciones sobre una cadena
  3. Primeros filtros
  4. Negación de una opción
  5. Limitación
  6. Logging
  7. Ejemplo de un Firewall


1-Funcionamiento del filtrado

Para el filtrado de paquetes existen 3 tablas: Filter, Nat y Mangle.
La tabla Filter contiene las reglas relacionadas con el filtrado de paquetes y la decisión de si deben cruzar o no el host.
La tabla Nat se refiere a las regñlas que implementan el intercambio de destinos de un paquete. Por ejemplo, si a un host le llega un paquete con una petición que coincide con una regla, esta puede desviar el paquete a otra máquina dentro de su red.
La tabla Mangle contiene las reglas para examinar paquetes y realizar sobre ellos diferentes tipos de marcas que después otras aplicaciones podrán leer para realizar otras acciones sobre dichos paquetes.

Cada tabla tiene 3 tipos de acciones denominadas cadenas:

Tabla Filter : INPUT , OUTPUT y FORWARD.
La cadena INPUT especifica las reglas sobre los paquetes que llegan de fuera y la decisión de si deben dejarse pasar o no.
La cadena OUTPUT especifica las reglas sobre los paquetes que llegan dentro de la red local y que tienen destino exterior, y también deciden si estos paquetes deben o no dejarse pasar.
La cadena FORWARD decide si una interface debe ser capaz de "verse" con la otra para que le envíe los paquetes que ha recivido.

Tabla Nat: POSTROUTING, PREROUTING y FORWARD.
La cadena PREROUTING hace referencia a los paquetes que provienen del exterior y deben ser desviados a una máquina dentro de la red local.
La cadena POSTROUTING se refiere a los paquetes que provienen de las máquina que forman la red local y que desean acceder a internet.
La cadena FORWARD decide si deben poderse enviar paquetes entre dos interfaces conectadas a la máquina que ejecuta el filtrado.

2-Opciones sobre una cadena

Cada vez que se arranque el ordenador las cadenas de cada tabla estarán vacías, así que una vez iniciado el ordenador ya se podrá empezar a travajar con ellas creando reglas y agrupandolas en cadenas.
Entre las acciones que pueden realizarse sobre una cadena de la tabla Filter están las siguientes:
Crear una nueva cadena (-N)
Borrar una cadena vacía (-
Cambiar la politica por defecto de una cadena (-P)
Listar las reglas contenidas en una cadena (-L)
Borrar las reglas de una cadena (-F)

Hay varias maneras de manipular las reglas dentro de una cadena:
Añadir una nueva regla a la cadena (-A)
Insertar una nueva regla a la cadena (-I)
Reemplazar una regla dentro de una cadena (-R)
Borrar una regla dentro de una cadena (-D)

Para comprovar el estado de las tablas y sus cadenas es con la opción -L (como he dicho antes).
# iptables -t filter -L
(si no especificamos la tabla en la que trabajamos, por defecto es filter, de forma que la orden anterior seria lo mismo que esta:
# iptables -L

3-Primeros filtros
Aquí empieza lo bueno jeje, el manejo de las reglas.
Las interfaces de red se reconocen con ifconfig. Si se ejecuta se verá posiblemente una interface llamada eth0 y otra llamada lo, que es la interfaz de loopback generada por el propio SO para poder probar aplicaciones de red con uno mismo sin necesidad de tener una tarjeta de red o estar conectado a ninguna red. Por ejemple se puede usar el comando ping para genera paquetes que circulen por la interface de loopback y después implementaremos un filtro que deniegue estos paquetes para ver mas claramente como funciona.
Lanzamos un ping contra nuestra propia dirección IP de loopback (127.0.0.1)
# ping 127.0.0.1
Después de ejecutar el comando nos aparece la información que proporciona ping, para filtrarlo será:
# iptables -t filter -A INPUT -s 127.0.0.1 -p icmp -j DROP
o como por fecto se usa filter solo bastará con:
# iptables -A INPUT -s 127.0.0.1 -p icmp -j DROP
Analizando la estructura de la sentencia:
. iptables comando de la ejecución del filtrado
. -A añadir una nueva regla a la cadena
. INPUT nombre de la cadena a la que se añade la regla
. -i opción ara especificar la interfaz
. eth0 interfaz
. -s opción para especificar el orígen de los paquetes
. 127.0.0.1 direccíon de la interfaz de loopback
. -p opción para especificar el tipo de protocolo
. incmp tipo de protocolo del paquete
. -j opción para especificar la decisión del futuro del paquete
. DROP denegar el paquete

La regla se podria leer así:
Cualquier paquete que provenga de la dirección 127.0.0.1 y utilice el protocolo ICMP, no debe traspasar el filtro.
Si después de está orden nos hacemos un ping, los paquetes no pasarán el filtro 😛

Otra podria ser:
# iptables -A INPUT -p tcp -i eth0 -s 0/0 -d 192.168.1.1 --dport 0:1023 -j DROP
Analizando la estructura de la sentencia:
. iptables comando de la ejecución del filtrado
. -A añadir una nueva regla a la cadena
. INPUT nombre de la cadena a la que se añade la regla
. -p opción para especificar el tipo de protocolo
. TCP tipo de protocolo del paquete
. -i opción ara especificar la interfaz
. eth0 interfaz
. -s opción para especificar el orígen de los paquetes
. 0/0 Cualquier dirección posible
. -d 192.168.1.1 dirección IP de destino
. --dport 0:1023 se refiere a cualquier puerto que este entre el 0 y el 1023 (también podría ir un solo puerto, ejemplo --dport 21)
. -j opción para especificar la decisión del futuro del paquete
. DROP denegar el paquete

La regla se podría leer así:
Cualquier paquete que entre por la interfaz eth0, que provenga de cualquier dirección, con destino a mi dirección (192.168.1.1) y a un puerto entre el 0 y el 123 no debe traspasar el filtro.

A la que se practique un poco con los diferentes parametros rapidamente se entiende el funcionamiento de este.
Para visualizar las dos entradas que hemos tecleado lo hacemos con:
# iptables -t filter -L -n
o simplemente
# iptables -L -n
Es posible que visualizar las tablas ayude a entender el concepto del funcionamiento de Netfilter.
Para borrar las reglas que hemos creados es simplemente con:
# iptables -t filter -F INPUT

Las reglas de la tabla filter se resumen en:
-s (dirección de origen del paquete)
--sport (puerto de origen del paquete)
-d (dirección de destino del paquete)
--dport (puerto de destino del paquete)
-p (protocolo del paquete, TCP UDP o ICMP)
-i/o (interfaz de entrada o salida del paquete)
-f (paquete fragmentados. Esta opción ayuda a filtrar nukes por ejemplo, que no son mas que paquetes fragmentados y con esta opción los podemos controlar)

4-Negación de una opción

Es MUY importante tener en cuenta el orden que hemos dado a nuestras tablas, es decir, si primero negamos una conexión al puerto 21 a cualquier IP por ejemplo, y seguidamente mandamos una orden que diga que excepcionalmente la IP 213.12.12.5 si pueda conectar a dicho puerto NO FUNCIONARÁ, ya que se tiene que poner en el orden invertido, es decir primero la excepción y luego la restricción ok ? es importante tener esto en cuenta nos ahorrará muchas comidas de tarro 😛

Aunque tambiém hay otra manera de evitar esto, y es usando las negaciones, por ejemplo:
no queremos dejar que nadie acceda a nuestro ordenador por el puerto 23 (telnet), pero si queremos habilitarlo para una dirección IP concreta, se puede hacer usando la negación del siguiente modo:
#iptables -A INPUT -i eth0 -s ! 192.168.1.25 -d 192.168.1.254 --dport 23 -j DROP
Donde la ip del que queremos dejar pasar es 192.168.1.25 y la de el ordenador que queremos proteger es 192.168.1.254
El símbolo ! ejerce la negación a la regla general, es decir:
Cualquier paquete que entre por la interfaz eth0, que provenga de cualquier dirección qu NO SEA 192.168.1.25 con el destino 192.168.1.254 dirigido al puerto 23, no debe atravesar el filtro.

5-Limitación

También podemos limitar el numero máximo de veces que debe aplicarse una acción a un paquete que coincida con una determinada regla con el fin de no colapsar la máquina.
Por ejemplo:
no queremos que entren más de 10 paquetes por segundo provinientes de una cierta dirección IP.
# iptables -A INPUT -i eth0 -s 192.168.1.25 -m limit --limit 10/second -j ACCEPT
La opción -m limit especifica que se va a limitar el número máximo de veces que se debe ejecutar la acción sobre el paquete coincidente.
Seguidamente --limit 10/second especifica el numero exacto de la limitación y la medida de tiempo que se debe tomar por referencia.

6-Logging

También podemos "logear" los paquetes que coincidan con las reglas:
# iptables -A INPUT -i eth0 -s 192.168.1.25 -j LOG --log-level DEBUG
La opción --log-level DEBUG especifica el nivel del registro en el que se debe crear la entrada.
El registro del sistema (syslog) posee un archivo de configuración (/etc/syslog.conf) en el que se pueden ver las incidencias que el sistema genera quedan registradas en diferentes niveles, significando únicamente el nivel del fichero de texto en el cual se deben guardar las entradas del registro. Esto es simplemente para no llenar los registros con entradas excesivas y demasiada información que pueda no ser de interés.

7-Ejemplo de un firewall

Un ejemplo de firewall podría ser :

Creamos un archivo llamado rc.firewall en /etc/rc.d para que se ejecute al iniciar el ordenador.

# vi /etc/rc.d/rc.firewall

y añadimos las línias:
# Borra las reglas que haya si están cargadas
iptables -F INPUT
iptables -F OUTPUT
iptables -F FORWARD

# Establecer las políticas por defecto
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT

# Filtrar todos los paquetes que entren por la interfaz eth0 que provengan de cualquier dirección, con destino a nuestra ip y a un puerto
# entre el 0 y 1023 (privilegiados)

iptables -A INPUT -p TCP -i eth0 -s 0/0 -d 211.31.13.13 --dport 0:1023 -j DROP

y luego gravamos y salimos (:wq)

Este sería un ejemplo muy simple de firewall , usando solo la tabla filter , ahora ya solo queda que cada uno vaya provando esta tabla hasta familiarizarse con ella y luego hacerse cada uno su propio firewall.
En la parte II explicaré la siguiente tabla, NAT.

Por [St0rM]

2 Comments

Leave a Reply

Your email address will not be published.