IPTables

El siguiente documento ha sido adaptado del documento original elaborado por http://elbauldelprogramador.com/20-ejemplos-de-iptables-para-sysadmins/ http://www.cyberciti.biz/tips/linux-iptables-examples.html

Linux por defecto trae un cortafuegos llamado NetFilter} Según el sitio oficial de proyecto:

netfiltes es un conjunto de hooks (Ganchos) dentro del kernel de linux que permiten a los módulos del kernel registrar funciones callbacks con la pila de red. Una función callback registrada se llama entonces para cada paquete que atraviesa el hook correspondiente dentro de la pila de red.

Un cortafuegos o firewall es un componente de un sistema o una red que tiene dos funciones principales:

  • Bloquear el acceso no permitido desde una red externa.
  • Restringir o limitar las conexiones de la red local con el exterior.

Los cortafuegos pueden implementarse sobre dispositivos de hardware específicos, que se denominan cortafuegos hardware; o bien sobre dispositivos genéricos mediante software, obviamente denominados cortafuegos software. En este documento se verá la forma de implementar un cortafuegos software en GNU/Linux con la aplicación iptables del proyecto http://netfilter.org

Este firewall lo controla un programa llamado iptables que gestiona el filtrado para IPv4, e ip6tables para IPv6.

Configuraciones de Red

Los sistemas operativos de escritorio suelen incorporar software de cortafuegos que es necesario configurar en cada uno de los equipos. En una red local gestionada de forma adecuada, en lugar de configurar el software de cortafuegos puesto por puesto, se configura de forma precisa un solo cortafuegos que proteja toda la red local del exterior. Dado que el cortafuegos debe analizar todo el tráfico entre la red local y el exterior en los dos sentidos, lo más habitual es que sea el dispositivo que conecta la red local con el exterior como en el esquema de la Figura.

\includegraphics[width=13cm]{images/redfw.png}\vspace{-0.3cm}

Cortafuegos simple que se interpone entre la red local y el exterior

El esquema anterior es perfectamente válido cuando no es necesario acceder a nuestros servidores desde el exterior, pero cuando tenemos servidores que ofrecen servicios a Internet es muy recomendable colocar estos es un segmento de red independiente de la red local, ya que existe riesgo de que estos equipos sean atacados desde el exterior y debemos impedir que ese potencial ataque se pueda propagar por el resto de la red local. La forma tradicional de implementar un segmento de red específico para los servidores es colocar los servidores delante del cortafuegos de la red local y a su vez instalar un nuevo cortafuegos que proteja el segmento de red de los servidores como se puede ver en la Figura. De esa forma la zona de servidores es accesible tanto desde la red local como desde Internet, pero la red local está protegida de los accesos desde Internet. Alguien consideró que este esquema era muy similar a lo que se conoce en términos militares como una zona desmilitarizada o DMZ por sus siglas en inglés, por lo que se suele denominar así al segmento de red en el que se encuentran los servidores que ofrecen servicios a Internet.

\begin{figure}[h!]\centering

\includegraphics[width=14cm]{images/reddmz.png}\vspace{-0.3cm}

\caption{Cortafuegos clásico con DMZ}

\label{ip02}

\end{figure}

Una forma habitual de implementar una DMZ sin necesidad de utilizar dos cortafuegos es el esquema que utiliza un cortafuegos de "3 patas", para lo que es necesario que el dispositivo que actúa como cortafuegos disponga de tres interfaces de red conectada cada una de ellas a uno de los segmentos de red, tal como se puede ver en la Figura.

\begin{figure}[h!]\centering

\includegraphics[width=10cm]{images/reddmz2.png}\vspace{-0.3cm}

\caption{Cortafuegos de ``3 patas'' que separa la red local de la DMZ e Internet}

\label{ip03}

\end{figure}

Como en este curso el esquema de red utilizado desde el principio se corresponde con el de la Figura , será el que utilicemos en los ejemplos de este documento (incluso pondremos reglas de acceso a servidores dentro de la red local), pero eso se hace exclusivamente por no complicar el esquema de red del curso. En una implementación más realista recomendamos siempre ubicar los servidores accesibles desde Internet en una DMZ.

Tipos de Firewalls

Además del esquema de red, también hay que detallar el tipo de cortafuegos que vamos a utilizar, ya que existen diferentes tipos de cortafuegos en función del análisis del tráfico que hagan, siendo los más significativos:

  • Cortafuegos de filtrado de paquetes: Examinan los paquetes en diferentes niveles de la pila TCP/IP. Como mínimo a nivel de red en el que examinan parámetros como la dirección IP origen o destino, aunque también es posible que estos cortafuegos trabajen a nivel de enlace o nivel de transporte.
  • Cortafuegos de capa de aplicación: Examinan los paquetes en el nivel de aplicación, por lo que son cortafuegos específicos para cada protocolo.
  • Cortafuegos con seguimiento de la conexión: Son capaces de analizar si los paquetes pertenecen o no a una conexión establecida, están relacionados con una conexión previa o son paquetes que establecen una conexión nueva.

En el caso de iptables es un cortafuegos de filtrado de paquetes que puede analizar el tráfico desde en nivel de enlace al nivel de transporte, además iptables puede realizar seguimiento de la conexión (Salvo en el caso de un núcleo compilado sin incluir iptables, algo muy poco frecuente.) y que puede asociarse con otras aplicaciones o extensiones para funcionar como cortafuegos de capa de aplicación. En este documento nos centraremos en las características de filtrado de paquetes y el seguimiento de la conexión de forma simple.

Políticas de Cortafuegos

Un cortafuegos tras examinar una serie de parámetros de un paquete y analizar las reglas que para él son aplicables, realiza una determinada acción con él: aceptarlo, rechazarlo, marcarlo, etc. En cualquier caso tiene que haber una decisión por defecto cuando no haya ninguna regla aplicable a un paquete, es lo que se denomina la política por defecto del cortafuegos o simplemente política. En el caso de iptables existen dos políticas por defecto:

  • ACCEPT Se aceptan por defecto todos los paquetes salvo aquellos para los que haya reglas específicas que no lo permitan.
  • DROP Se deniegan por defecto todos los paquetes salvo aquellos para los que haya reglas específicas que lo permitan.

La primera política es más fácil de implementar si hay pocas reglas, aunque mucho menos segura, por lo que en este documento nos centraremos en la implementación de un cortafuegos con política DROP.

Características de iptables

Iptables es un componente del núcleo linux que suele incluirse habitualmente en forma de módulos, esto implica que no hay un proceso (un demonio) como en el caso de otras aplicaciones que hemos visto en el curso que pueda pararse, lanzarse o recargarse. Iptables está siempre presente en nuestro equipo (Para un seguimiento de la conexión más avanzado puede utilizarse conntrack del mismo proyecto netfilter), la forma de trabajar con él es simplemente ejecutar una serie de reglas con ayuda de la instrucción iptables y una determinada sintaxis que veremos a continuación. Además de todo esto, iptables no es sólo una aplicación de cortafuegos, sino que puede funcionar como dispositivo de nat o puede alterar los paquetes que lo atraviesan. En este documento se explicará la forma de trabajar con iptables como aplicación de cortafuegos mediante filtrado de paquetes, seguimiento de la conexión y dispositivo de NAT.

Tablas y Cadenas

Iptables incluye de forma estándar tres tablas, dentro de las que se definen una serie de cadenas y que a su vez están constituidas por una agrupación de reglas. Cada una de estas reglas tiene una serie de parámetros que especifican el paquete al que se van a aplicar y finalmente una acción , que es la encargada de decir qué destino tiene el paquete.

Las tablas predefinidas de iptables son:

  • filter Permite generar las reglas de filtrado o sea, que paquetes aceptar, cuales rechazar o cuales omitir. Es la tabla por defecto. Las cadenas que componen la tabla filter son:
    • INPUT Filtrado de paquetes que llegan al cortafuegos.
    • OUTPUT Filtrado de los paquetes de salen del cortafuegos.
    • FORWARD Filtrado de los paquetes que atraviesan el cortafuegos.
  • nat Con esta tabla es posible realizar enmascaramiento de IP, redireccionar puertos o cambiar las direcciones IP de origen y destino de los paquetes. Se utiliza para modificar la dirección IP origen o destino de los paquetes. Las cadenas que componen la tabla nat son:
    • PREROUTING Permite realizar alguna acción sobre el paquete antes de que se tome la decisión de encaminamiento. Utilizada fundamentalmente para realizar Destination NAT o DNAT.
    • POSTROUTING Permite realizar alguna acción sobre el paquete antes de que salga del cortafuegos. Utilizada principalmente para realizar enmascaramiento IP o SNAT.
    • OUTPUT Permite modificar los paquetes generados en el propio cortafuegos antes de enrutarlos. No vamos a utilizar ningún ejemplo en este documento con esta cadena, por lo que no la tendremos en cuenta a partir de ahora.
  • mangle Tabla para la modificación de paquetes con la que no vamos a trabajar en este documento.

Dependiendo del tipo de proceso, se aplican las reglas de una cadena u otra y además se hace en un determinado orden. Las cadenas utilizadas en cada tipo de proceso y el orden en el que se hace se muestran de forma esquemática en la Figura y se explican a continuación:

\begin{figure}[h!]\centering

\includegraphics[width=10cm]{images/ip04.png}\vspace{-0.3cm}

\caption{Cadenas de iptables implicadas en los diferentes procesos que se pueden producir}

\label{ip04}

\end{figure}


  • El paquete llega al cortafuegos y se le aplican las reglas de la cadena PREROUTING
    • (1), se toma la decisión de encaminamiento (2), que obligan al paquete a atravesar el cortafuegos, a continuación se aplican las reglas de la cadena FORWARD (3) y por último, antes de salir se aplican las reglas de POSTROUTING.
  • Al igual que en el caso anterior el paquete llega al cortafuegos y se le aplican las reglas de la cadena PREROUTING (1), se toma la decisión de encaminamiento (2), aunque en este caso obligan al paquete a dirigirse al propio cortafuegos, a continuación se aplican las reglas de la cadena INPUT (5) y termina el proceso (6).
  • El paquete se origina en un proceso local (6) dentro del cortafuegos, antes de salir se (8) y por último se aplican las reglas de la cadena POSTROUTING (4).

Formato de las reglas

La estructura o el esqueleto de una regla es:

    iptables -t [tabla] operacion cadena parametros accion 

Donde el valor de tabla y cadena se corresponde con los especificados anteriormente. Veamos los valores más significativos de los demás componentes de la regla:

  • Operaciones habituales: Especifican qué se va a hacer con la regla y puede tomar los valores:
    • -A, --append: Añade una o más reglas al final de la cadena especificada.
    • -D, --delete: Borra una o más reglas de la cadena. Se puede especificar la regla mediante un número o mediante parámetros.
    • -I, --insert: Inserta una regla en una determinada posición de la cadena. Si no se especifica una posición, inserta la regla al principio de la cadena.
    • -L, --list: Lista las reglas de una cadena concreta o todas las de la tabla si no se especifica.
    • -F, --flush: Borra todas las reglas de una cadena o todas las de la tabla si no se especifica.
    • -Z, --zero: Pone a cero los contadores de una cadena o los de todas las cadenas de una tabla si no se especifica.
  • Parámetros más comunes: Se utilizan para definir el paquete al que se le va a aplicar la regla.
    • -p, --protocol: Especifica el protocolo (tcp, udp, icmp, ...). Si se quiere especificar el puerto destino u origen, se acompaña del parámetro --dport o --sport .
    • -s, --source: Especifica la dirección o direcciones IP origen.
    • -d, --destination: Especifica la dirección o direcciones IP destino.
    • -i, --in-interface: Especifica la interfaz de red de entrada.
    • -o, --out-interface: Especifica la interfaz de red de salida.
  • Acciones: Una vez que se define completamente la regla hay que determinar la acción a realizar con los paquetes que la cumplan. Las acciones se especifican con el parámetro -j seguido de:
    • ACCEPT: Se acepta el paquete.
    • DROP: Se elimina el paquete (no se responde al equipo que realiza la petición, que pasado un tiempo mostrará un mensaje de tiempo excedido en la petición).
    • REJECT: Equivalente a DROP , pero envía un mensaje ICMP al equipo que realiza la petición para que sepa que no está permitida (por defecto port-unreachable).
    • DNAT: Utilizada en la cadena PREROUTING para modificar la dirección IP destino. Debe llevar asociado el parámetro --to, --to-destination.
    • SNAT: Utilizada en la cadena POSTROUTING para modificar la dirección IP origen si tenemos dirección IP estática en la interfaz de red de salida. Debe llevar asociado el parámetro --to, --to-source.
    • MASQUERADE: Equivalente a SNAT pero utilizado cuando tenemos direción IP dinámica en la interfaz de red de salida.
    • REDIRECT: Utilizada en la cadena PREROUTING para modificar la dirección IP a la que tenga la interfaz de red de entrada. Puede llevar el parámetro --to, --to-ports para especificar un cambio en el puerto destino.

Por ejemplo, si queremos permitir una consulta DNS simple (53/udp) al equipo cliente (192.168.2.2), se podría poner una regla de iptables como la siguiente (significa que la línea continua):

  # iptables -A FORWARD -p udp --dport 53 -s 192.168.2.0/24 \ -i eth1 -o eth0 -j ACCEPT 

Esto permitiría realizar la consulta DNS, pero como tenemos política por defecto DROP, no se aceptaría la respuesta del servidor DNS. Es por esto por lo que si utilizamos política DROP , las reglas son siempre dobles (dos reglas de FORWARD para paquetes que atraviesan el cortafuegos y una regla de INPUT y otra de OUTPUT para paquetes generados en el propio equipo que actúa de cortafuegos). En el ejemplo anterior tendríamos que añadir una segunda regla que permitiese la respuesta del servidor DNS:

  # iptables -A FORWARD -p udp --sport 53 -d 192.168.2.0/24 \ -o eth1 -i eth0 -j ACCEPT

En el caso de que quisiéramos permitir consultas DNS a avatar, el par de reglas de iptables serían:

  # iptables -A OUTPUT -p udp --dport 53 -s 192.168.1.1 -o eth0 \ -j ACCEPT
  # iptables -A INPUT -p udp --sport 53 -d 192.168.1.1 -i eth0 \ -j ACCEPT 

Esto permitiría realizar la consulta DNS, pero como tenemos política por defecto DROP, no se aceptaría la respuesta del servidor DNS. Es por esto por lo que si utilizamos política DROP, las reglas son siempre dobles (dos reglas de FORWARD para paquetes que atraviesan el cortafuegos y una regla de INPUT y otra de OUTPUT para paquetes generados en el propio equipo que actúa de cortafuegos). En el ejemplo anterior tendríamos que añadir una segunda regla que permitiese la respuesta del servidor DNS:

  # iptables -A FORWARD -p udp --sport 53 -d 192.168.2.0/24 \ -o eth1 -i eth0 -j ACCEPT

En el caso de que quisiéramos permitir consultas DNS a avatar, el par de reglas de iptables serían:

  # iptables -A OUTPUT -p udp --dport 53 -s 192.168.1.1 -o eth0 \ -j ACCEPT
  # iptables -A INPUT -p udp --sport 53 -d 192.168.1.1 -i eth0 \ -j ACCEPT 

Seguimiento de la conexión

Una de las formas habituales de mejorar el funcionamiento de un cortafuegos de filtrado de paquetes es añadir seguimiento de la conexión connection tracking o conntrack. Además hay algunos protocolos que establecen más de una conexión entre el cliente y el servidor (FTP, TFTP, IRC y PPTP por ejemplo) que no pueden funcionar en un cortafuegos con política DROP sin conntrack.

Para el seguimiento de la conexión se definen cuatro estados posibles:

  • NEW: Para una conexión nueva.
  • ESTABLISHED: Existe previamente tráfico en esa conexión.
  • RELATED: Conexión relacionada con una establecida (como en el caso del FTP pasivo)
  • INVALID: Paquete que no siguen un comportamiento esperado y que pueden establecerse reglas para denegarlos o analizarlos.

El seguimiento de la conexión en iptables se especifica mediante el parámetro -m state --state ESTADO, donde ESTADO es alguno de los estados definidos anteriormente.

El ejemplo anterior en el que se permitían consultas DNS a cliente y avatar se modificaría de la siguiente manera al introducir el seguimiento de la conexión (A partir de ahora no incluiremos el prompt de la línea de comandos para mayor claridad):

  iptables -A FORWARD -p udp --sport 1024:65535 --dport 53 -i eth1 -o \ eth0 -s 192.168.2.0/24 -m state --state NEW,ESTABLISHED -j ACCEPT
  iptables -A FORWARD -p udp --dport 1024:65535 --sport 53 -o eth1 -i \ eth0 -d 192.168.2.0/24 -m state --state ESTABLISHED -j ACCEPT

Manejo Básico

Detener y Borrar todas las reglas del Firewall

Se puede usar propio comando iptables para detenerlo y borrar todas las reglas.

    iptables -F
    iptables -X
    iptables -t nat -F
    iptables -t nat -X
    iptables -t mangle -F
    iptables -t mangle -X
    iptables -P INPUT ACCEPT
    iptables -P OUTPUT ACCEPT
    iptables -P FORWARD ACCEPT

Donde:

  • -F: Borra todas las reglas.
  • -X: Borra cadenas
  • -t table_name: Selecciona una tabla y elimina reglas
  • -P: Establece la política por defecto (como DROP, REJECT o ACCEPT)

Borrar reglas

Para mostrar los números de línea junto a otra información para reglas existentes:

    iptables -L INPUT -n --line-numbers
    iptables -L OUTPUT -n --line-numbers
    iptables -L OUTPUT -n --line-numbers | less
    iptables -L OUTPUT -n --line-numbers | grep 202.54.1.1

Obtendrendremos la lista de IPs. Miramos el número de la izquierda y lo usamos para borrarla.

Borrar la línea 4

    iptables -D INPUT 4

Encontrar una ip de origen y borrarla de la regla

    iptables -D INPUT -s 202.54.1.1 -j DROP


Donde:

  • -D: Elimina una o más reglas de la cadena seleccionada.


Insertar Reglas

Para insertar una o más reglas en la cadena seleccionada como el número de cadena dada usamos la siguiente sintaxis. Primero encontramos el número de línea:

    iptables -L INPUT -n --line-numbers

Salida:

Chain INPUT (policy DROP)
num  target     prot opt source               destination
1    DROP       all  --  202.54.1.1           0.0.0.0/0
2    ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0           state NEW,ESTABLISHED

Insertar una regla entre 1 y 2

    iptables -I INPUT 2 -s 202.54.1.2 -j DROP

Para ver las reglas actualizadas

    iptables -L INPUT -n --line-numbers

Salida:

Chain INPUT (policy DROP)
num  target     prot opt source               destination
1    DROP       all  --  202.54.1.1           0.0.0.0/0
2    DROP       all  --  202.54.1.2           0.0.0.0/0
3    ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0           state NEW,ESTABLISHED

Guardar y Restaurar Reglas

Guardar Reglas

Para mantener las reglas en iptables que hemos ingresado por consola, debemos teclear el siguiente comando:

  • CentOS/RHEL/Fedora Linux
  # service iptables save
  • Todas las otras distros
  # iptables-save > /root/my.active.firewall.rules
  # cat /root/my.active.firewall.rules

Restaurar Reglas

Para restaurar reglas desde un archivo llamado /root/my.active.firewall.rules:

    # iptables-restore < /root/my.active.firewall.rules

Bajo CentOS/RHEL/Fedora Linux:

    # service iptables restart

Ejecutarlo automáticamente como script

Las reglas de iptables se pueden ejecutar directamente desde la línea de comandos y por tanto se pueden asociar a un archivo de script, que tenga en la primera línea #!/bin/sh).

Para ejecutar este script de forma automática, basta con añadir permiso de ejecución al script y ubicarlo en alguno de los directorios que se ejecutan al iniciar la máquina: /etc/rc.local, /etc/rc2.d/, etc.

También se puede optar por utilizar las instrucciones iptables-save e {iptables-restore, que básicamente hacen lo mismo aunque incluyen pequeñas modificaciones en el formato de las líneas del archivo.

Configuración paso a paso de un cortafuegos

En esta sección vamos a construir reglas de iptables de forma paulatina, de manera que cada ejemplo sea completo, pero vayamos incrementando las prestaciones en cada caso. Empezaremos todos los ejemplos con líneas de iptables en las que se borran todas las reglas que estuvieran creadas previamente para evitar cualquier conflicto.

Mostrar el estado del Firewall

Después de cada paso es recomendable ejecutar la instrucción:

    # iptables -L -n -v

Donde:

  • -L Muestra las reglas.
  • -v Muestra información detallada.
  • -n Muestra la dirección ip y puerto en formato numérico. No usa DNS para resolver nombres. Esto acelera la lista.


El comando anterior nos presentará el resultado mostrado en el Ejemplo el cual indica que el firewall no está activo. En el Ejemplo se muestra un caso de salida es la del firewall activado, es decir con algunas reglas como las que se presentarán más adelante.

Resultado iptables desactivado

Chain INPUT (policy ACCEPT 0 packets, 0 bytes)
pkts bytes target     prot opt in     out     source               destination
Chain FORWARD (policy ACCEPT 0 packets, 0 bytes)
pkts bytes target     prot opt in     out     source               destination
Chain OUTPUT (policy ACCEPT 0 packets, 0 bytes)
pkts bytes target     prot opt in     out     source               destination

Resultado iptables activo

Chain INPUT (policy DROP 0 packets, 0 bytes)
pkts bytes target     prot opt in     out     source               destination
    0     0 DROP       all  --  *      *       0.0.0.0/0            0.0.0.0/0           state INVALID
  394 43586 ACCEPT     all  --  *      *       0.0.0.0/0            0.0.0.0/0           state RELATED,ESTABLISHED
   93 17292 ACCEPT     all  --  br0    *       0.0.0.0/0            0.0.0.0/0
    1   142 ACCEPT     all  --  lo     *       0.0.0.0/0            0.0.0.0/0
Chain FORWARD (policy DROP 0 packets, 0 bytes)
pkts bytes target     prot opt in     out     source               destination
    0     0 ACCEPT     all  --  br0    br0     0.0.0.0/0            0.0.0.0/0
    0     0 DROP       all  --  *      *       0.0.0.0/0            0.0.0.0/0           state INVALID
    0     0 TCPMSS     tcp  --  *      *       0.0.0.0/0            0.0.0.0/0           tcp flags:0x06/0x02 TCPMSS clamp to PMTU
    0     0 ACCEPT     all  --  *      *       0.0.0.0/0            0.0.0.0/0           state RELATED,ESTABLISHED
    0     0 wanin      all  --  vlan2  *       0.0.0.0/0            0.0.0.0/0
    0     0 wanout     all  --  *      vlan2   0.0.0.0/0            0.0.0.0/0
    0     0 ACCEPT     all  --  br0    *       0.0.0.0/0            0.0.0.0/0
Chain OUTPUT (policy ACCEPT 425 packets, 113K bytes)
pkts bytes target     prot opt in     out     source               destination
Chain wanin (1 references)
pkts bytes target     prot opt in     out     source               destination
Chain wanout (1 references)
pkts bytes target     prot opt in     out     source               destination

Para inspeccionar el firewall con números de líneas se utiliza el siguiente comando, lo que genera el resultado presentado en el Ejemplo

    # iptables -n -L -v --line-numbers

Resultado iptables con número de líneas

Chain INPUT (policy DROP)
num  target     prot opt source               destination
1    DROP       all  --  0.0.0.0/0            0.0.0.0/0           state INVALID
2    ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0           state RELATED,ESTABLISHED
3    ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0
4    ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0
Chain FORWARD (policy DROP)
num  target     prot opt source               destination
1    ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0
2    DROP       all  --  0.0.0.0/0            0.0.0.0/0           state INVALID
3    TCPMSS     tcp  --  0.0.0.0/0            0.0.0.0/0           tcp flags:0x06/0x02 TCPMSS clamp to PMTU
4    ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0           state RELATED,ESTABLISHED
5    wanin      all  --  0.0.0.0/0            0.0.0.0/0
6    wanout     all  --  0.0.0.0/0            0.0.0.0/0
7    ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0
Chain OUTPUT (policy ACCEPT)
num  target     prot opt source               destination
Chain wanin (1 references)
num  target     prot opt source               destination
Chain wanout (1 references)
num  target     prot opt source               destination

Si queremos mostrar las reglas de entrada y salida con números de línea, podemos usar los siguientes comandos:

    iptables -L INPUT -n -v
    iptables -L OUTPUT -n -v --line-numbers

Podemos usar los números de línea para borrar o añadir nuevas reglas al firewall.

Establecer Políticas de Firewall por defecto

Para borrar todo el tráfico.

Ejemplo de Borrado de todo el trafico e intento de ping

  iptables -P INPUT DROP
  iptables -P OUTPUT DROP
  iptables -P FORWARD DROP
  iptables -L -v -n
  ## you will not able to connect anywhere as all traffic is dropped ###
  ping www.google.com
  wget http://www.kernel.org/pub/linux/kernel/v3.0/testing/linux-3.2-rc5.tar.bz2

Para borrar todos los paquetes entrantes / enviados pero permitir el tráfico saliente.

Solo trafico entrante bloqueado

  iptables -P INPUT DROP
  iptables -P FORWARD DROP
  iptables -P OUTPUT ACCEPT
  iptables -A INPUT -m state --state NEW,ESTABLISHED -j ACCEPT
  iptables -L -v -n
  # *** now ping and wget should work *** ###
  ping www.google.com
  wget http://www.kernel.org/pub/linux/kernel/v3.0/testing/linux-3.2-rc5.tar.bz2

Empezaremos desarrollando reglas elementales para que los equipos de la red local accedan a Internet y se permita todo el tráfico de forma explícita:

  # Borramos las reglas que haya definidas y ponemos los contadores 
  # a cero 
  iptables -F 
  iptables -t nat -F 
  iptables -Z 
  # Establecemos la politica por defecto de las cadenas de la tabla 
  # filter 
  iptables -P INPUT DROP 
  iptables -P OUTPUT DROP 
  iptables -P FORWARD DROP 
  # Permitimos el trafico TCP entre la red cliente y el exterior 
  
   iptables -A FORWARD -p tcp -i eth1 -o eth0 -s 192.168.2.0/24 -j ACCEPT 
   iptables -A FORWARD -p tcp -o eth1 -i eth0 -d 192.168.2.0/24 -j ACCEPT 
  # Permitimos el trafico UDP entre la red cliente y el exterior 
  iptables -A FORWARD -p udp -i eth1 -o eth0 -s 192.168.2.0/24 -j ACCEPT 
  iptables -A FORWARD -p udp -o eth1 -i eth0 -d 192.168.2.0/24 -j ACCEPT 
  # Permitimos el trafico ICMP entre la red cliente y el exterior 
  iptables -A FORWARD -p icmp -i eth1 -o eth0 -s 192.168.2.0/24 -j ACCEPT 
  iptables -A FORWARD -p icmp -o eth1 -i eth0 -d 192.168.2.0/24 -j ACCEPT 
  # Hacemos masquerade para los paquetes que salen hacia Internet 
  iptables -t nat -A POSTROUTING -s 192.168.2.0/24 -o eth0 -j MASQUERADE 

A continuación incluimos seguimiento de la conexión, de manera que sólo se permiten paquetes provenientes de Internet que se correspondan con respuestas a solicitudes hechas desde la red local.

    # Borramos las reglas que haya definidas y ponemos los contadores 
    # a cero 
    iptables -F iptables -t nat -F iptables -Z 
  # Establecemos la politica por defecto de las cadenas de la tabla 
  # filter 
  iptables -P INPUT DROP iptables -P OUTPUT DROP 
  iptables -P FORWARD DROP 
  # Permitimos el trafico TCP entre la red cliente y el exterior, 
  # pero solo para conexiones iniciadas desde la red local 
  iptables -A FORWARD -p tcp --sport 1024:65535 -i eth1 -o eth0 \ -s 192.168.2.0/24 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A FORWARD -p tcp --dport 1024:65535 -o eth1 -i eth0 \ -d 192.168.2.0/24 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos el trafico UDP entre la red cliente y el exterior, 
  # pero solo para conexiones iniciadas desde la red local 
  iptables -A FORWARD -p udp --sport 1024:65535 -i eth1 -o eth0 \ -s 192.168.2.0/24 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A FORWARD -p udp --dport 1024:65535 -o eth1 -i eth0 \ -d 192.168.2.0/24 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos el trafico ICMP entre la red cliente y el exterior 
  iptables -A FORWARD -p icmp -i eth1 -o eth0 -s 192.168.2.0/24 -j ACCEPT 
  iptables -A FORWARD -p icmp -o eth1 -i eth0 -d 192.168.2.0/24 -j ACCEPT 
  # Hacemos REJECT con el resto de paquetes que provengan de la 
  # red local 
  iptables -A FORWARD -i eth1 -o eth0 -s 192.168.2.0/24 -j REJECT 
  # Hacemos masquerade para los paquetes que salen hacia Internet 
  iptables -t nat -A POSTROUTING -s 192.168.2.0/24 -o eth0 -j MASQUERADE 

Hasta ahora se ha permitido que los equipos de la red local accedan a todos los servicios que quieran de Internet, pero si queremos restringir el tráfico de salida a determinados protocolos, debemos poner un par de reglas de iptables para cada protocolo permitido. A continuación se van a permitir sólo consultas DNS (UDP y TCP), y HTTP:

#Limpiamos las reglas anteriores y ponemos los contadores a cero
iptables -F iptables -t nat -F iptables -Z 
  # Establecemos la politica por defecto de las cadenas de la tabla 
  # filter 
  iptables -P INPUT DROP iptables -P OUTPUT DROP 
  iptables -P FORWARD DROP 
  # Permitimos conexiones HTTP 
  iptables -A FORWARD -p tcp --sport 1024:65535 --dport 80 -i eth1 -o \ eth0 -s 192.168.2.0/24 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A FORWARD -p tcp --dport 1024:65535 --sport 80 -o eth1 -i \ eth0 -d 192.168.2.0/24 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos consultas DNS por tcp 
  iptables -A FORWARD -p tcp --sport 1024:65535 --dport 53 -i eth1 -o \ eth0 -s 192.168.2.0/24 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A FORWARD -p tcp --dport 1024:65535 --sport 53 -o eth1 -i \ eth0 -d 192.168.2.0/24 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos consultas DNS por udp 
  iptables -A FORWARD -p udp --sport 1024:65535 --dport 53 -i eth1 -o \ eth0 -s 192.168.2.0/24 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A FORWARD -p udp --dport 1024:65535 --sport 53 -o eth1 -i \ eth0 -d 192.168.2.0/24 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos el trafico ICMP entre la red cliente y el exterior 
  iptables -A FORWARD -p icmp -i eth1 -o eth0 -s 192.168.2.0/24 -j ACCEPT 
  iptables -A FORWARD -p icmp -o eth1 -i eth0 -d 192.168.2.0/24 -j ACCEPT 
  # Hacemos REJECT con el resto de paquetes que provengan de la 
  # red local 
  iptables -A FORWARD -i eth1 -o eth0 -s 192.168.2.0/24 -j REJECT 
  # Hacemos masquerade para los paquetes que salen hacia Internet 
  iptables -t nat -A POSTROUTING -s 192.168.2.0/24 -o eth0 -j MASQUERADE 

Con la configuración anterior, avatar está completamente incomunicado (incluso consigo mis- mo a través de localhost), por lo que vamos a incluir algunas reglas que permitan la conexión a localhost y además de algunos protocolos para Internet y para la red local:

  #Limpiamos las reglas anteriores y ponemos los contadores a cero:   
  iptables -F 
  iptables -t nat -F 
  iptables -Z 
  # Establecemos la politica por defecto de las cadenas de la tabla 
  # filter 
  iptables -P INPUT DROP 
  iptables -P OUTPUT DROP
  iptables -P FORWARD DROP
  
  # Permitimos todo el trafico a localhost 
  iptables -A OUTPUT -o lo -j ACCEPT 
  iptables -A INPUT -o lo -j ACCEPT 
  # Permitimos consultas DNS desde avatar (UDP y TCP) 
  iptables -A OUTPUT -p udp --sport 1024:65535 --dport 53 -o eth0 \ -s 192.168.1.1 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A INPUT -p udp --dport 1024:65535 --sport 53 -i eth0 \ -d 192.168.1.1 -m state --state ESTABLISHED -j ACCEPT 
  iptables -A OUTPUT -p tcp --sport 1024:65535 --dport 53 -o eth0 \ -s 192.168.1.1 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A INPUT -p tcp --dport 1024:65535 --sport 53 -i eth0 \ -d 192.168.1.1 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos acceso a servicio SMTP externo 
  iptables -A OUTPUT -p tcp --sport 1024:65535 --dport 25 -o eth0 \ -s 192.168.1.1 -m state --state NEW,ESTABLISHED -j ACCEPT
  iptables -A INPUT -p tcp --dport 1024:65535 --sport 25 -i eth0 \ -d 192.168.1.1 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos acceso a un servidor LDAP que estuviera en cliente 
  iptables -A OUTPUT -p tcp --sport 1024:65535 --dport 389 -o eth1 -d \ 192.168.2.2 -s 192.168.2.1 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A INPUT -p tcp --dport 1024:65535 --sport 389 -i eth0 -s \ 192.168.2.2 -d 192.168.2.1 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos conexiones HTTP 
  iptables -A FORWARD -p tcp --sport 1024:65535 --dport 80 -i eth1 -o \ eth0 -s 192.168.2.0/24 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A FORWARD -p tcp --dport 1024:65535 --sport 80 -o eth1 -i \ eth0 -d 192.168.2.0/24 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos consultas DNS por tcp 
  iptables -A FORWARD -p tcp --sport 1024:65535 --dport 53 -i eth1 -o \ eth0 -s 192.168.2.0/24 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A FORWARD -p tcp --dport 1024:65535 --sport 53 -o eth1 -i \ eth0 -d 192.168.2.0/24 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos consultas DNS por udp 
  iptables -A FORWARD -p udp --sport 1024:65535 --dport 53 -i eth1 -o \ eth0 -s 192.168.2.0/24 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A FORWARD -p udp --dport 1024:65535 --sport 53 -o eth1 -i \ eth0 -d 192.168.2.0/24 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos el trafico ICMP entre la red cliente y el exterior
   iptables -A FORWARD -p icmp -i eth1 -o eth0 -s 192.168.2.0/24 -j ACCEPT 
   iptables -A FORWARD -p icmp -o eth1 -i eth0 -d 192.168.2.0/24 -j ACCEPT 
  # Hacemos REJECT con el resto de paquetes que provengan de la 
  # red local 
  iptables -A FORWARD -i eth1 -o eth0 -s 192.168.2.0/24 -j REJECT 
  # Hacemos masquerade para los paquetes que salen hacia Internet 
  iptables -t nat -A POSTROUTING -s 192.168.2.0/24 -o eth0 -j MASQUERADE 

Veamos ahora en el caso de que tuviéramos un servidor en avatar (SMTP para la red local e Internet):

  #Limpiamos las reglas anteriores y ponemos los contadores a cero:   
  iptables -F iptables -t nat -F iptables -Z 
  # Establecemos la politica por defecto de las cadenas de la tabla 
  # filter 
  iptables -P INPUT DROP iptables -P OUTPUT DROP iptables -P FORWARD DROP 
  # Permitimos todo el trafico a localhost 
  iptables -A OUTPUT -o lo -j ACCEPT iptables -A INPUT -o lo -j ACCEPT 
  # Permitimos consultas DNS desde avatar (UDP y TCP) 
  iptables -A OUTPUT -p udp --sport 1024:65535 --dport 53 -o eth0 \ -s 192.168.1.1 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A INPUT -p udp --dport 1024:65535 --sport 53 -i eth0 \ -d 192.168.1.1 -m state --state ESTABLISHED -j ACCEPT 
  iptables -A OUTPUT -p tcp --sport 1024:65535 --dport 53 -o eth0 \ -s 192.168.1.1 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A INPUT -p tcp --dport 1024:65535 --sport 53 -i eth0 \ -d 192.168.1.1 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos acceso a servicio SMTP externo 
  iptables -A OUTPUT -p tcp --sport 1024:65535 --dport 25 -o eth0 \ -s 192.168.1.1 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A INPUT -p tcp --dport 1024:65535 --sport 25 -i eth0 \ -d 192.168.1.1 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos acceso al servidor SMTP desde fuera 
  iptables -A INPUT -p tcp --sport 1024:65535 --dport 25 -i eth0 \ -d 192.168.1.1 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A OUTPUT -p tcp --dport 1024:65535 --sport 25 -o eth0 \ -s 192.168.1.1 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos acceso al servidor SMTP desde la red local 
  iptables -A INPUT -p tcp --sport 1024:65535 --dport 25 -i eth1 \ -d 192.168.1.1 -s 192.168.2.0/24 -m state --state NEW,ESTABLISHED \ -j ACCEPT 
  iptables -A OUTPUT -p tcp --dport 1024:65535 --sport 25 -o eth1 \ -s 192.168.1.1 -d 192.168.2.0/24 -m state --state ESTABLISHED \ -j ACCEPT 
  # Permitimos acceso a un servidor LDAP que estuviera en cliente 
  iptables -A OUTPUT -p tcp --sport 1024:65535 --dport 389 -o eth1 -d \ 192.168.2.2 -s 192.168.2.1 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A INPUT -p tcp --dport 1024:65535 --sport 389 -i eth0 -s \ 192.168.2.2 -d 192.168.2.1 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos conexiones HTTP 
  iptables -A FORWARD -p tcp --sport 1024:65535 --dport 80 -i eth1 -o \ eth0 -s 192.168.2.0/24 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A FORWARD -p tcp --dport 1024:65535 --sport 80 -o eth1 -i \ eth0 -d 192.168.2.0/24 -m state --state ESTABLISHED -j ACCEPT
  
  # Permitimos consultas DNS por tcp 
  iptables -A FORWARD -p tcp --sport 1024:65535 --dport 53 -i eth1 -o \ eth0 -s 192.168.2.0/24 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A FORWARD -p tcp --dport 1024:65535 --sport 53 -o eth1 -i \ eth0 -d 192.168.2.0/24 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos consultas DNS por udp 
  iptables -A FORWARD -p udp --sport 1024:65535 --dport 53 -i eth1 -o \ eth0 -s 192.168.2.0/24 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A FORWARD -p udp --dport 1024:65535 --sport 53 -o eth1 -i \ eth0 -d 192.168.2.0/24 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos el trafico ICMP entre la red cliente y el exterior
   iptables -A FORWARD -p icmp -i eth1 -o eth0 -s 192.168.2.0/24 -j ACCEPT 
   iptables -A FORWARD -p icmp -o eth1 -i eth0 -d 192.168.2.0/24 -j ACCEPT 
  # Hacemos REJECT con el resto de paquetes que provengan de la 
  # red local 
  iptables -A FORWARD -i eth1 -o eth0 -s 192.168.2.0/24 -j REJECT 
  # Hacemos masquerade para los paquetes que salen hacia Internet 
  iptables -t nat -A POSTROUTING -s 192.168.2.0/24 -o eth0 -j MASQUERADE 

En el caso de que el servidor SMTP no estuviera en avatar sino en un equipo de la red local (192.168.2.2), habría que cambiar las reglas anteriores por reglas de FORWARD y además redirigir las peticiones exteriores al puerto 25/tcp mediante DNAT (Lo sensato sería tener este equipo en una DMZ, pero como ya explicamos anteriormente se hace aquí con el esquema de red del curso):

  #Limpiamos las reglas anteriores y ponemos los contadores a cero:  
  iptables -F iptables -t nat -F iptables -Z 
  # Establecemos la politica por defecto de las cadenas de la tabla 
  # filter 
  iptables -P INPUT DROP 
  iptables -P OUTPUT DROP 
  iptables -P FORWARD DROP 
  # Redirigimos las peticiones al servidor SMTP de la red local 
  iptables -t nat -A PREROUTING -p tcp --dport 25 -d 192.168.1.1 \ -j DNAT --to 192.168.2.2 
  # Permitimos todo el trafico a localhost 
  iptables -A OUTPUT -o lo -j ACCEPT 
  iptables -A INPUT -o lo -j ACCEPT 
  # Permitimos consultas DNS desde avatar (UDP y TCP) 
  iptables -A OUTPUT -p udp --sport 1024:65535 --dport 53 -o eth0 \ -s 192.168.1.1 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A INPUT -p udp --dport 1024:65535 --sport 53 -i eth0 \ -d 192.168.1.1 -m state --state ESTABLISHED -j ACCEPT 
  iptables -A OUTPUT -p tcp --sport 1024:65535 --dport 53 -o eth0 \ -s 192.168.1.1 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A INPUT -p tcp --dport 1024:65535 --sport 53 -i eth0 \ -d 192.168.1.1 -m state --state ESTABLISHED -j ACCEPT 
  
  # Permitimos acceso a servicio SMTP externo desde 192.168.2.2 
  iptables -A FORWARD -p tcp --sport 1024:65535 --dport 25 -o eth0 \ -i eth1 -s 192.168.2.2 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A FORWARD -p tcp --dport 1024:65535 --sport 25 -i eth0 \ -o eth1 -d 192.168.2.2 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos acceso al servidor SMTP desde fuera 
  iptables -A FORWARD -p tcp --sport 1024:65535 --dport 25 -i eth0 \ -o eth1 -d 192.168.2.2 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A FORWARD -p tcp --dport 1024:65535 --sport 25 -o eth0 \ -i eth1 -s 192.168.2.2 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos acceso a un servidor LDAP que estuviera en cliente 
  iptables -A OUTPUT -p tcp --sport 1024:65535 --dport 389 -o eth1 -d \ 192.168.2.2 -s 192.168.2.1 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A INPUT -p tcp --dport 1024:65535 --sport 389 -i eth0 -s \ 192.168.2.2 -d 192.168.2.1 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos conexiones HTTP 
  iptables -A FORWARD -p tcp --sport 1024:65535 --dport 80 -i eth1 -o \ eth0 -s 192.168.2.0/24 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A FORWARD -p tcp --dport 1024:65535 --sport 80 -o eth1 -i \ eth0 -d 192.168.2.0/24 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos consultas DNS por tcp 
  iptables -A FORWARD -p tcp --sport 1024:65535 --dport 53 -i eth1 -o \ eth0 -s 192.168.2.0/24 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A FORWARD -p tcp --dport 1024:65535 --sport 53 -o eth1 -i \ eth0 -d 192.168.2.0/24 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos consultas DNS por udp 
  iptables -A FORWARD -p udp --sport 1024:65535 --dport 53 -i eth1 -o \ eth0 -s 192.168.2.0/24 -m state --state NEW,ESTABLISHED -j ACCEPT 
  iptables -A FORWARD -p udp --dport 1024:65535 --sport 53 -o eth1 -i \ eth0 -d 192.168.2.0/24 -m state --state ESTABLISHED -j ACCEPT 
  # Permitimos el trafico ICMP entre la red cliente y el exterior 
  iptables -A FORWARD -p icmp -i eth1 -o eth0 -s 192.168.2.0/24 -j ACCEPT 
  iptables -A FORWARD -p icmp -o eth1 -i eth0 -d 192.168.2.0/24 -j ACCEPT 
  # Hacemos REJECT con el resto de paquetes que provengan de la 
  # red local 
  iptables -A FORWARD -i eth1 -o eth0 -s 192.168.2.0/24 -j REJECT 
  # Hacemos masquerade para los paquetes que salen hacia Internet 
  iptables -t nat -A POSTROUTING -s 192.168.2.0/24 -o eth0 -j MASQUERADE 

Configuraciones más comunes de IPTables

Borrar direcciones de red privadas en la interfaz pública

IP Spoofing es nada más que para detener los siguientes rangos de direcciones IPv4 para redes privadas en sus interfaces públicas. Los paquetes con direcciones de origen no enrutables deben rechazarse mediante la siguiente sintaxis:

  iptables -A INPUT -i eth1 -s 192.168.0.0/24 -j DROP
  iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j DROP

Bloqueando una dirección IP (Block IP)

Para bloquear una IP atacante llamada 1.2.3.4:

  iptables -A INPUT -s 1.2.3.4 -j DROP
  iptables -A INPUT -s 192.168.0.0/24 -j DROP

Bloquear Peticiones Entrantes de un Puerto (Block Port)

Para bloquear todas las solicitudes de servicio en el puerto 80:

    iptables -A INPUT -p tcp --dport 80 -j DROP
    iptables -A INPUT -i eth1 -p tcp --dport 80 -j DROP

Para bloquear el puerto 80 para una IP:

  iptables -A INPUT -p tcp -s 1.2.3.4 --dport 80 -j DROP
  iptables -A INPUT -i eth1 -p tcp -s 192.168.1.0/24 --dport 80 -j DROP

Bloquear IPs de Salida

Para bloquear el tráfico saliente a un host o dominio en concreto como por ejemplo cyberciti.biz:

  $ host -t a cyberciti.biz
    cyberciti.biz has address 75.126.153.206

Una vez conocida la dirección ip, bloqueamos todo el tráfico saliente para dicha ip así:

  iptables -A OUTPUT -d 75.126.153.206 -j DROP

Se puede usar una subred como la siguiente:

  iptables -A OUTPUT -d 192.168.1.0/24 -j DROP
  iptables -A OUTPUT -o eth1 -d 192.168.1.0/24 -j DROP

Bloquear el Dominio Facebook.com

Primero, encontrar la dirección ip de facebook.com

    $ host -t a www.facebook.com
      www.facebook.com has address 69.171.228.40

Buscar el CIDR para la ip encontrada (69.171.228.40):

    $ whois 69.171.228.40 | grep CIDR
      CIDR:           69.171.224.0/19

Para prevenir el acceso externo a facebook.com:

  iptables -A OUTPUT -p tcp -d 69.171.224.0/19 -j DROP

Podemos usar también nombres de dominio (aunque para dominios como facebook no es tan efectivo):

  iptables -A OUTPUT -p tcp -d www.facebook.com -j DROP
  iptables -A OUTPUT -p tcp -d facebook.com -j DROP

Configura la máquina para que sólo se pueda acceder desde ella a las webs http://www.google.com y http://www.juaramir.com y a ninguna otra

  iptables -A OUTPUT -d http://www.google.com -j ACCEPT
  iptables -A OUTPUT -d http://www.juaramir.com -j ACCEPT
  iptables -A OUTPUT -p tcp -dport 80 -j DROP # Mas exigente -> iptables -A OUTPUT -p all -j DROP

Como google tiene muchas IPs puede que tengamos un problema para ello realizamos lo siguiente antes de la regla EXIGENTE:

  iptables -I OUTPUT 1 -d 212.106.221.0/24 -j ACCEPT
  iptables -I OUTPUT 1 -d 173.194.0.0/16 -j ACCEPT

Log y Borrado de Paquetes

Escribe lo siguiente para añadir al log y bloquear IP spoofing en una interfaz pública llamada eth1

  iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j LOG --log-prefix "IP_SPOOF A: "
  iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j DROP

Por defecto el log está en el archivo /var/log/messages:

  $ tail -f /var/log/messages
  $ grep --color 'IP SPOOF' /var/log/messages

Log y Borrado de Paquetes con un número limitado de entradas al log

El módulo -m limit puede limitar el número de entradas al log creadas por tiempo. Se usa para prevenir que el archivo de log se inunde. Para añadir al log y eliminar spoofing cada 5 minutos, en ráfagas de 7 entradas:

  iptables -A INPUT -i eth1 -s 10.0.0.0/8 -m limit --limit 5/m --limit-burst 7 -j LOG --log-prefix "IP_SPOOF A: "
  iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j DROP

Aceptar o Denegar Tráfico desde una Dirección MAC

  iptables -A INPUT -m mac --mac-source 00:0F:EA:91:04:08 -j DROP
## *only accept traffic for TCP port # 8080 from mac 00:0F:EA:91:04:07*
  iptables -A INPUT -p tcp --destination-port 22 -m mac --mac-source 00:0F:EA:91:04:07 -j ACCEPT

Bloquear o permitir Peticiones de Ping ICMP

Para bloquear peticiones ping ICMP

  iptables -A INPUT -p icmp --icmp-type echo-request -j DROP
  iptables -A INPUT -i eth1 -p icmp --icmp-type echo-request -j DROP

Las respuestas al ping también se puede limitar a ciertas redes o hosts.

  iptables -A INPUT -s 192.168.1.0/24 -p icmp --icmp-type echo-request -j ACCEPT

Lo siguiente solo acepta limitados tipos de peticiones ICMP:

### ** assumed that default INPUT policy set to DROP **
  iptables -A INPUT -p icmp --icmp-type echo-reply -j ACCEPT
  iptables -A INPUT -p icmp --icmp-type destination-unreachable -j ACCEPT
  iptables -A INPUT -p icmp --icmp-type time-exceeded -j ACCEPT
## ** all our server to respond to pings **
  iptables -A INPUT -p icmp --icmp-type echo-request -j ACCEPT

Abrir un Rango de Puertos

  iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 7000:7010 -j ACCEPT

Abrir un Rango de Direcciones IP

## only accept connection to tcp port 80 (Apache) if ip is between 192.168.1.100 and 192.168.1.200 ##
  iptables -A INPUT -p tcp --destination-port 80 -m iprange --src-range 192.168.1.100-192.168.1.200 -j ACCEPT
## nat example ##
  iptables -t nat -A POSTROUTING -j SNAT --to-source 192.168.1.20-192.168.1.25

Bloquear o Abrir Puertos Comunes

Replace ACCEPT with DROP to block port:
## open port ssh tcp port 22 ##
iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -s 192.168.1.0/24 -m state --state NEW -p tcp --dport 22 -j ACCEPT

## open cups (printing service) udp/tcp port 631 for LAN users ##
iptables -A INPUT -s 192.168.1.0/24 -p udp -m udp --dport 631 -j ACCEPT
iptables -A INPUT -s 192.168.1.0/24 -p tcp -m tcp --dport 631 -j ACCEPT

## allow time sync via NTP for lan users (open udp port 123) ##
iptables -A INPUT -s 192.168.1.0/24 -m state --state NEW -p udp --dport 123 -j ACCEPT

## open tcp port 25 (smtp) for all ##
iptables -A INPUT -m state --state NEW -p tcp --dport 25 -j ACCEPT

# open dns server ports for all ##
iptables -A INPUT -m state --state NEW -p udp --dport 53 -j ACCEPT
iptables -A INPUT -m state --state NEW -p tcp --dport 53 -j ACCEPT

## open http/https (Apache) server port to all ##
iptables -A INPUT -m state --state NEW -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -m state --state NEW -p tcp --dport 443 -j ACCEPT

## open tcp port 110 (pop3) for all ##
iptables -A INPUT -m state --state NEW -p tcp --dport 110 -j ACCEPT

## open tcp port 143 (imap) for all ##
iptables -A INPUT -m state --state NEW -p tcp --dport 143 -j ACCEPT

## open access to Samba file server for lan users only ##
iptables -A INPUT -s 192.168.1.0/24 -m state --state NEW -p tcp --dport 137 -j ACCEPT
iptables -A INPUT -s 192.168.1.0/24 -m state --state NEW -p tcp --dport 138 -j ACCEPT
iptables -A INPUT -s 192.168.1.0/24 -m state --state NEW -p tcp --dport 139 -j ACCEPT
iptables -A INPUT -s 192.168.1.0/24 -m state --state NEW -p tcp --dport 445 -j ACCEPT

## open access to proxy server for lan users only ##
iptables -A INPUT -s 192.168.1.0/24 -m state --state NEW -p tcp --dport 3128 -j ACCEPT

## open access to mysql server for lan users only ##
iptables -I INPUT -p tcp --dport 3306 -j ACCEPT

Restringir el Número de Conexiones Paralelas a un Servidor por Dirección IP del Cliente

Se puede usar connlimit para crear algunas restricciones. Para permitir 3 conexiones ssh por cliente:

  iptables -A INPUT -p tcp --syn --dport 22 -m connlimit --connlimit-above 3 -j REJECT

nes HTTP a 20:

  iptables -p tcp --syn --dport 80 -m connlimit --connlimit-above 20 --connlimit-mask 24 -j DROP

donde:

  • –connlimit-above 3: Coincide si el número de conexiones existentes está por encima de 3.
  • –connlimit-mask 24: Grupos de hosts usando el prefijo de longitud. Para IPv4, debe ser un número entre 0 y 32 (incluyéndolos.)

Probar el Firewall

Conocer si hay puertos abiertos o no:

   # netstat -tulpn

Es recomendable instalarse un sniffer como tcpdupm y ngrep para probar la configuración de nuestro firewall.

Manual de IP Tables

Para más información sobre iptables, échale un vistazo al manual:

    $ man iptables

Para ver la ayuda en general o de un comando específico:

  iptables -h
  iptables -j DROP -h