IPTABLES
Manual práctico
(1.2)
Red Hat Enterprise Linux contiene herramientas avanzadas para el filtrado de paquetes de red — el proceso dentro del kernel de controlar los paquetes de red al entrar, mientras se mueven y cuando salen de la red. Los kernels anteriores al 2.4 confiaban en ipchains para el filtrado de paquetes y usaban listas de reglas aplicadas a los paquetes en cada paso del proceso de filtrado. La introducción de kernel 2.4 trajo consigo iptables (también llamado netfilter), lo cual es similar a ipchains pero expande enormemente el ámbito y el control disponible para el filtrado de paquetes de red.
Este capítulo se centra en las bases del filtrado esencial de paquetes, define las diferencias entre ipchains e iptables, explica las diferentes opciones disponibles con comandos iptables y muestra cómo se pueden preservar las reglas de filtrado durante reinicios del sistema.
Para instrucciones sobre cómo construir reglas iptables o configurar un cortafuegos (firewall en inglés) basado en estas reglas, consulte la Sección 18.7.
Aviso
El mecanismo predeterminado del cortafuegos en la versión 2.4 del kernel es iptables, pero éste no se puede usar si ya se está ejecutando ipchains. Si ipchains está presente durante el arranque, el kernel emitirá un error y no podrá arrancar iptables.
Estos errores no afectan la funcionalidad del comando ipchains.
El kernel de Linux tiene incorporado la característica interna de filtrar paquetes, permitiendo aceptar algunos de ellos en el sistema mientras que intercepta y para a otros. El netfilter del kernel tiene tres tablas o listas de reglas incorporadas. Son las siguientes:
Sugerencia
Además de estas tablas incorporadas, se pueden crear tablas especializadas y almacenarlas en el directorio /lib/modules/<kernel-version>/kernel/net/ipv4/netfilter/, donde <kernel-version> corresponde al número de la versión del kernel.
Cada una de estas tablas tiene un grupo de cadenas incorporadas que corresponden a las acciones llevadas a cabo por el filtro de la red.
Las cadenas internas para la tabla filtro son las siguientes:
Las cadenas internas para la tabla nat son las siguientes:
PREROUTING — Esta cadena altera paquetes recibidos por medio de una interfaz de red cuando llegan.
Cada paquete de red recibido o enviado desde un sistema Linux está sujeto a al menos una tabla. Sin embargo, un paquete puede estar sometido a múltiples reglas dentro de cada tabla antes de emerger al final de la cadena. La estructura y propósito de estas reglas puede variar, pero normalmente buscan identificar un paquete que viene de o se dirige hacia una direccción IP en particular, o un conjunto de direcciones, cuando utiliza un determinado protocolo y servicio de red.
Nota
No utilice nombres de dominio completos en las reglas del cortafuegos que se guardan en los archivos /etc/sysconfig/iptables o /etc/sysconfig/ip6tables. En el ejemplo siguiente: iptables -A FORWARD -s example.com -i eth0 -j DROP example.com no es válido porque el servicio iptables comienza antes de cualquier servicio DNS relacionado, lo que produce un error. Solamente las direcciones IP son válidas para la creación de reglas de cortafuegos.
Independientemente de su destino, cuando un paquete cumple una regla en particular en una de las tablas, se les aplica un objetivo (target) o acción a ellos. Si la regla especifica un objetivo ACCEPT para un paquete que coincida, el paquete se salta el resto de las verificaciones de la regla y se permite que continúe hacia su destino. Si una regla especifica un objetivo DROP, a ese paquete se le niega el acceso al sistema y no se envía nada de vuelta al servidor que envió el paquete. Si una regla especifica un objetivo QUEUE, el paquete se pasa al espacio del usuario. Si una regla especifica el objetivo opcional REJECT, el paquete es descartado, pero se envía un paquete de error al que envió el paquete.
Cada cadena tiene una política por defecto de ACCEPT, DROP, REJECT, o QUEUE. Si ninguna de estas reglas en la cadena se aplican al paquete, entonces el paquete es tratado de acuerdo a la política por defecto.
El comando iptables configura estas tablas, así como también configura nuevas tablas si es necesario.
A primera vista, ipchains y iptables parecen ser bastante similares. Ambos métodos de filtrado de paquetes usan cadenas de reglas operando dentro del kernel de Linux para decidir qué hacer con los paquetes que cumplen determinadas reglas. Sin embargo, iptables proporciona un método mucho más extensible de filtrado de paquetes, proporcionando al administrador un nivel de control mucho más refinado sin tener que aumentar la complejidad del sistema entero.
Más concretamente, los usuarios que se encuentren cómodos con ipchains deberían tener cuidado con las siguientes diferencias significativas entre ipchains e iptables antes de utilizar iptables:
Las reglas para el filtrado de paquetes se ponen en funcionamiento ejecutando el comando iptables. Con frecuencia se utilizan los aspectos siguientes del paquete como el criterio:
Para más información sobre opciones específicas que resuelven estos aspectos de un paquete, consulte la Sección 18.3.4 y la Sección 18.3.5.
Las opciones usadas con las reglas iptables dadas deben estar agrupadas lógicamente, basándose en el propósito y en las condiciones de la regla general, para que la regla sea válida. El resto de esta sección explica las opciones usadas comúnmente para el comando iptables.
Muchos comandos iptables tienen la siguiente estructura:
iptables [-t <table-name>] <command> <chain-name> <parameter-1> \ <option-1> <parameter-n> <option-n>
La opción <table-name> permite al usuario seleccionar una tabla diferente a la tabla predeterminada filter a usar con el comando. La opción <command> indica una acción específica a realizar, tal como anexar o eliminar la regla especificada por la opción <chain-name>. Luego de la opción <chain-name> se encuentran un par de parámetros y opciones que definen qué pasará cuando un paquete coincide con la regla.
Cuando miramos la estructura de un comando iptables, es importante recordar que, al contrario que la mayoría de los comandos, la longitud y complejidad de un comando iptables puede cambiar en función de su propósito. Un comando para borrar una regla de una cadena puede ser muy corto, mientras que un comando diseñado para filtrar paquetes de una subred particular usando un conjunto de parámetros específicos y opciones puede ser mucho más largo. Al crear comandos iptables puede ser de ayuda reconocer que algunos parámetros y opciones pueden crear la necesidad de utilizar otros parámetros y opciones para especificar más aún la petición de la opción anterior. Para construir una regla válida, esto deberá continuar hasta que todos los parámetros y opciones que requieran otro conjunto de opciones hayan sido satisfechos.
Escriba iptables -h para ver una lista detallada de la estructura de los comandos iptables.
Las opciones de comandos le dicen a iptables que realice una acción específica. Solamente una opción de comando se permite por comando iptables. Excepto el comando de ayuda, todos los comandos se escriben en mayúsculas.
Los comandos de iptables son los siguientes:
Una vez que se especifiquen ciertos comandos iptables, incluyendo aquellos para añadir, anexar, eliminar, insertar o reemplazar reglas dentro de una cadena, se requieren parámetros para construir una regla de filtrado de paquetes.
Diferentes protocolos de red proporcionan opciones especializadas las cuales se pueden configurar para coincidir un paquete particular usando ese protocolo. Sin embargo, primero se debe especificar el protocolo en el comando iptables. Por ejemplo, -p tcp <protocol-name> (donde <protocol-name> es el protocolo objetivo), hace disponibles las opciones para ese protocolo especificado.
Estas opciones de identificación están disponibles en el protocolo TCP (opción -p tcp):
Estas opciones de selección están disponibles para el protocolo UDP (-p udp):
Las siguientes opciones de coincidencia están disponibles para el Protocolo de mensajes de Internet (ICMP) (-p icmp):
Opciones adicionales de coincidencia están disponibles a través de los módulos por el comando iptables. Para usar un módulo de opciones de coincidencia, cargue el módulo por nombre usando la opción -m, tal como -m <module-name> (reemplazando <module-name> con el nombre del módulo).
Un gran número de módulos están disponibles por defecto. Hasta es posible crear sus módulos para proporcionar funcionalidades de opciones de coincidencia adicionales.
Lo siguiente, es una lista parcial de los módulos usados más comúnmente:
Para visualizar otras opciones disponibles a través de los módulos, consulte la página del manual de iptables.
Una vez que un paquete ha coincidido con una regla, la regla puede dirigir el paquete a un número de objetivos diferentes que deciden su suerte y, posiblemente, toman acciones adicionales. Cada cadena tiene un objetivo por defecto, el cual es usado si ninguna de las reglas en esa cadena coinciden con un paquete o si ninguna de las reglas que coinciden con el paquete especifica un objetivo.
Los siguientes son los objetivos estándar:
Además de estos objetivos standard, se pueden usar otros más con extensiones llamadas módulos de objetivos (target modules). Para obtener más información sobre los módulos de opciones de coincidencias, mire en la Sección 18.3.4.4.
Existen varios módulos extendidos de objetivos, la mayoría de los cuales tan sólo se aplican a tablas o situaciones específicas. Un par de estos módulos, de los más populares e incluidos por defecto en Red Hat Enterprise Linux son:
Otras extensiones de objetivos, incluyendo muchas que son útiles para el enmascaramiento de IP usando la tabla nat o con alteración de paquetes usando la tabla mangle, se puede encontrar en la página del manual de iptables.
El comando predeterminado para listar, iptables -L, proporciona una vista muy básica de los filtros por defecto de las cadenas actuales de la tabla. Las opciones adicionales proporcionan más información:
Las reglas creadas con el comando iptables son almacenadas en memoria. Si el sistema es reiniciado antes de guardar el conjunto de reglas iptables, se perderán todas las reglas. Para que las reglas de filtrado de red persistan luego de un reinicio del sistema, estas necesitan ser guardadas. Para hacerlo, conéctese como root y escriba:
/sbin/service iptables save
Esto ejecuta el script de inicio iptables, el cual ejecuta el programa /sbin/iptables-save y escribe la configuración actual de iptables a /etc/sysconfig/iptables. El archivo /etc/sysconfig/iptables existente es guardado como /etc/sysconfig/iptables.save.
La próxima vez que se inicie el sistema, el script de inicio de iptables volverá a aplicar las reglas guardadas en /etc/sysconfig/iptables usando el comando /sbin/iptables-restore.
Aún cuando siempre es una buena idea probar una regla de iptables antes de confirmar los cambios al archivo /etc/sysconfig/iptables, es posible copiar reglas iptables en este archivo desde otra versión del sistema de este archivo. Esto proporciona una forma rápida de distribuir conjuntos de reglas iptables a muchas máquinas.
Importante
Si se está distribuyendo el archivo /etc/sysconfig/iptables a otras máquinas, escriba /sbin/service iptables restart para que las nuevas reglas tomen efecto.
Hay dos métodos básicos para controlar iptables bajo Red Hat Enterprise Linux:
Sugerencia
Para utilizar los mismos comandos initscript para controlar el filtrado de la red para IPv6, sustituya ip6tables por iptables en los comandos /sbin/service listados en esta sección. Para más información sobre IPv6 y el filtrado de red (netfilter), consulte la Sección 18.6.
El comportamiento de los scripts de inicio de iptables es controlado por el archivo de configuración /etc/sysconfig/iptables-config. A continuación se presenta una lista de las directivas contenidas dentro de este archivo:
6. ip6tables y IPv6
Si esta instalado el paquete iptables-ipv6, el filtrado de la red bajo Red Hat Enterprise Linux puede filtrar la próxima generación del protocolo de Internet IPv6. El comando utilizado para manipular el filtrado de red de IPv6 es ip6tables. La mayoría de las directivas para este comando son idéntica a aquellas usadas por iptables, excepto que la tabla nat aún no es compatible. Esto significa que todavía no es posible realizar tareas de traducción de direcciones de red IPv6, tales como enmáscarado y reenvio de puertos.
Las reglas guardadas para ip6tables son almacenadas en el archivo /etc/sysconfig/ip6tables. Las reglas viejas guardadas por los scripts de inicio de ip6tables son guardadas en el archivo /etc/sysconfig/ip6tables.save.
El archivo de configuración para los scripts de inicio de ip6tables es /etc/sysconfig/ip6tables-config y los nombres para cada directriz varian ligeramente. Por ejemplo, la directriz iptables-config IPTABLES_MODULES es IP6TABLES_MODULES en el archivo ip6tables-config.
Refiérase a las fuentes siguientes para información adicional sobre filtrado de paquetes con iptables.
#################################################################
#################################################################
#################################################################
En este manual se muestran las habituales arquitecturas de redes con firewall y la forma de montar iptables para cada caso, con distintas opciones para cada ejemplo.
1.2 Revision: añadidos los mismos casos pero con DROP por defecto.
nano -w /etc/sysconfig/iptables-config
Por Pello Xabier Altadill Izura
Ingeniero Informático por la UPV-EHU
http://www.pello.info/forum/iptables
(Actualizaciones y ejemplos en http://www.pello.info - VERSIÓN PDF)
3. Al grano: creando un firewall con iptables
3.1 Proteger la propia máquina
3.2 Firewall de una LAN con salida a internet
3.3 Firewall de una LAN con salida a internet con DMZ
3.4 Firewall de una LAN con salida a internet y VPNS
3.5 Firewall puro y duro entre redes
3.6 Firewall con política por defecto DROP
4. Cómo depurar el funcionamiento del firewall
1. Qué es un firewall
Un firewall es un dispositivo que filtra el tráfico entre redes, como mínimo dos. El firewall puede ser un dispositivo físico o un software sobre un sistema operativo. En general debemos verlo como una caja con DOS o mas interfaces de red en la que se establecen una reglas de filtrado con las que se decide si una conexión determinada puede establecerse o no. Incluso puede ir más allá y realizar modificaciones sobre las comunicaciones, como el NAT.
Esa sería la definición genérica, hoy en dia un firewall es un hardware especifico con un sistema operativo o una IOS que filtra el tráfico TCP/UDP/ICMP/../IP y decide si un paquete pasa, se modifica, se convierte o se descarta. Para que un firewall entre redes funcione como tal debe tener al menos dos tarjetas de red. Esta sería la tipología clásica de un firewall:
Figura 1: esquema de firewall típico entre red local e internet
Esquema típico de firewall para proteger una red local conectada a internet a través de un router. El firewall debe colocarse entre el router (con un único cable) y la red local (conectado al switch o al hub de la LAN)
Dependiendo de las necesidades de cada red, puede ponerse uno o más firewalls para establecer distintos perímetros de seguridad en torno a un sistema. Es frecuente también que se necesite exponer algún servidor a internet (como es el caso de un servidor web, un servidor de correo, etc..), y en esos casos obviamente en principio se debe aceptar cualquier conexión a ellos. Lo que se recomienda en esa situación es situar ese servidor en lugar aparte de la red, el que denominamos DMZ o zona desmilitarizada. El firewall tiene entonces tres entradas:
Figura 2: esquema de firewall entre red local e internet con zona DMZ para servidores expuestos
En la zona desmilitarizada se pueden poner tantos servidores como se necesiten. Con esta arquitectura, permitimos que el servidor sea accesible desde internet de tal forma que si es atacado y se gana acceso a él, la red local sigue protegida por el firewall. Esta estructura de DMZ puede hacerse también con un doble firewall (aunque como se ve se puede usar un único dispositivo con al menos tres interfaces de red). Sería un esquema como este:
Figura 3: esquema de firewall entre red local e internet con zona DMZ para servidores expuestos creado con doble firewall(perímetro)
Los firewalls se pueden usar en cualquier red. Es habitual tenerlos como protección de internet en las empresas, aunque ahí también suelen tener una doble función: controlar los accesos externos hacia dentro y también los internos hacia el exterior; esto último se hace con el firewall o frecuentemente con un proxy (que también utilizan reglas, aunque de más alto nivel).
También, en empresas de hosting con muchos servidores alojados lo normal es encontrarnos uno o más firewalls ya sea filtrando toda la instalación o parte de ella:
Figura 4: esquema de firewall entre redes, en la que solo se filtra y no se hace NAT
Sea el tipo de firewall que sea, generalmente no tendrá mas que un conjunto de reglas en las que se examina el origen y destino de los paquetes del protocolo tcp/ip. En cuanto a protocolos es probable que sean capaces de filtrar muchos tipos de ellos, no solo los tcp, también los udp, los icmp, los gre y otros protocolos vinculados a vpns. Este podría ser (en pseudo-lenguaje) un el conjunto de reglas de un firewall del primer gráfico:
Politica por defecto ACEPTAR.
Todo lo que venga de la red local al firewall ACEPTAR
Todo lo que venga de la ip de mi casa al puerto tcp 22 ACEPTAR
Todo lo que venga de la ip de casa del jefe al puerto tcp 1723 ACEPTAR
Todo lo que venga de hora.rediris.es al puerto udo 123 ACEPTAR
Todo lo que venga de la red local y vaya al exterior ENMASCARAR
Todo lo que venga del exterior al puerto tcp 1 al 1024 DENEGAR
Todo lo que venga del exterior al puerto tcp 3389 DENEGAR
Todo lo que venga del exterior al puerto udp 1 al 1024 DENEGAR
En definitiva lo que se hace es:
- Habilita el acceso a puertos de administración a determinadas IPs privilegiadas
- Enmascara el trafico de la red local hacia el exterior (NAT, una petición de un pc de la LAN sale al exterior con la ip pública), para poder salir a internet
- Deniega el acceso desde el exterior a puertos de administración y a todo lo que este entre 1 y 1024.
Hay dos maneras de implementar un firewall:
1) Política por defecto ACEPTAR: en principio todo lo que entra y sale por el firewall se acepta y solo se denegará lo que se diga explícitamente.
2) Política por defecto DENEGAR: todo esta denegado, y solo se permitirá pasar por el firewall aquellos que se permita explícitamente.
Como es obvio imaginar, la primera política facilita mucho la gestión del firewall, ya que simplemente nos tenemos que preocupar de proteger aquellos puertos o direcciones que sabemos que nos interesa; el resto no importa tanto y se deja pasar. Por ejemplo, si queremos proteger una máquina linux, podemos hacer un netstat -ln (o netstat -an, o netstat -puta | grep LISTEN), saber que puertos están abiertos, poner reglas para proteger esos puertos y ya está. ¿Para qué vamos a proteger un puerto que realmente nunca se va a abrir?
El único problema que podemos tener es que no controlemos que es lo que esta abierto, o que en un momento dado se instale un software nuevo que abra un puerto determinado, o que no sepamos que determinados paquetes ICMP son peligrosos. Si la política por defecto es ACEPTAR y no se protege explícitamente, nos la estamos jugando un poco.
En cambio, si la política por defecto es DENEGAR, a no ser que lo permitamos explícitamente, el firewall se convierte en un auténtico MURO infranqueable. El problema es que es mucho más difícil preparar un firewall así, y hay que tener muy claro como funciona el sistema (sea iptables o el que sea) y que es lo que se tiene que abrir sin caer en la tentación de empezar a meter reglas super-permisivas.
Esta configuración de firewall es la recomendada, aunque no es aconsejable usarla si no se domina mínimamente el sistema. Uno de los objetos principales de este documento es mostrar la forma de crear este tipo de firewalls.
IMPORTANTE
El orden en el que se ponen las reglas de firewall es determinante. Normalmente cuando hay que decidir que se hace con un paquete se va comparando con cada regla del firewall hasta que se encuentra una que le afecta (match), y se hace lo que dicte esta regla (aceptar o denegar); después de eso NO SE MIRARÁN MÁS REGLAS para ese paquete. ¿Cuál es el peligro? Si ponemos reglas muy permisivas entre las primeras del firewall, puede que las siguientes no se apliquen y no sirvan de nada.
2. Qué es iptables
IPtables es un sistema de firewall vinculado al kernel de linux que se ha extendido enormemente a partir del kernel 2.4 de este sistema operativo. Al igual que el anterior sistema ipchains, un firewall de iptables no es como un servidor que lo iniciamos o detenemos o que se pueda caer por un error de programación(esto es una pequeña mentira, ha tenido alguna vulnerabilidad que permite DoS, pero nunca tendrá tanto peligro como las aplicaciones que escuchan en determinado puerto TCP): iptables esta integrado con el kernel, es parte del sistema operativo. ¿Cómo se pone en marcha? Realmente lo que se hace es aplicar reglas. Para ellos se ejecuta el comando iptables, con el que añadimos, borramos, o creamos reglas. Por ello un firewall de iptables no es sino un simple script de shell en el que se van ejecutando las reglas de firewall.
Notas: bueno, para los más geeks y tocapelotas. Vale, se puede implementar un script de inicio en /etc/rc.d/INIT.d (o /etc/INIT.d ) con el que hagamos que iptables se "inicie o pare" como un servidor más. Lo podemos hacer nosotros o es probable que venga en la distribución (como en redhat por ejemplo). También se pueden salvar las reglas aplicadas con el comando iptables-save en un fichero y gestionar ese fichero con una aplicación o front-end desde la X o desde webmin.
Vale, tenemos una máquina linux con soporte para iptables, tiene reglas aplicadas y empiezan a llegar/salir/pasar paquetes. No nos liemos: olvidemos cuantas tarjetas de red hay, que direcciones ip tiene la máquina y olvidemos si el paquete entra o sale. Las reglas de firewall están a nivel de kernel, y al kernel lo que le llega es un paquete (digamos, un marrón ;) ) y tiene que decidir que hacer con él. El kernel lo que hace es, dependiendo si el paquete es para la propia maquina o para otra maquina, consultar las reglas de firewall y decidir que hacer con el paquete según mande el firewall. Este es el camino que seguiría un paquete en el kernel:
Figura 5: cuando un paquete u otra comunicación llega al kernel con iptables se sigue este camino
Como se ve en el gráfico, básicamente se mira si el paquete esta destinado a la propia maquina o si va a otra. Para los paquetes (o datagramas, según el protocolo) que van a la propia maquina se aplican las reglas INPUT y OUTPUT, y para filtrar paquetes que van a otras redes o maquinas se aplican simplemente reglas FORWARD.
INPUT,OUTPUT y FORWARD son los tres tipos de reglas de filtrado. Pero antes de aplicar esas reglas es posible aplicar reglas de NAT: estas se usan para hacer redirecciones de puertos o cambios en las IPs de origen y destino. Veremos ejemplos.
E incluso antes de las reglas de NAT se pueden meter reglas de tipo MANGLE, destinadas a modificar los paquetes; son reglas poco conocidas y es probable que no las usen.
Por tanto tenemos tres tipos de reglas en iptables:
- MANGLE
- NAT: reglas PREROUTING, POSTROUTING
- FILTER: reglas INPUT, OUTPUT, FORWARD.
3. Al grano: creando un firewall con iptables
En este tutorial se ha intentado dar una breve introducción sobre lo que es un firewall, sus tipologías básicas y en concreto se presenta el sistema iptables. Pero vamos al grano y empezamos a ver configuraciones de firewall con iptables, empezando desde la más básica a las más complejas, en las que se establece la denegación como política por defecto.
Nota: se recomienda encarecidamente ir practicando estas reglas en alguna maquina linux disponible, y especialmente hacer uso de la herramienta iptraf para depurar y comprobar el funcionamiento de iptables. Con iptraf podemos comprobar si las conexiones TCP/IP se llegan a establecer o no. Una conexión tcp/ip empieza con el three-way-handshake:
- La maquina que desea conectarse a otra envia un paquete con flan SYN
- Si la otra maquina acepta, envia un SYN/ACK
- Entonces la máquina establece la conexión.
Si el firewall esta denegando la conexión, con iptraf veremos que la maquina origen solo manda paquetes con el flan S (de SYN), y que del otro lado no sale nada. Saber usar iptraf nos ayudará mucho.
3.1 Proteger la propia máquina
Muy bien, tenemos una máquina linux pinchada en internet y queremos protegerla con su propio firewall. Lo único que tenemos que hacer es crear un script de shell en el que se van aplicando las reglas.
Los scripts de iptables pueden tener este aspecto:
Saludo a la afición (echo)
Borrado de las reglas aplicadas actualmente (flush)
Aplicación de políticas por defecto para INPUT, OUPUT, FORWARD
Listado de reglas iptables.
Ojo con el orden de las reglas!
#!/bin/sh
## SCRIPT de IPTABLES - ejemplo del manual de iptables
## Ejemplo de script para proteger la propia máquina
## Pello Xabier Altadill Izura
## www.pello.info - pello@pello.info
echo -n Aplicando Reglas de Firewall...
## FLUSH de reglas
iptables -F
iptables -X
iptables -Z
iptables -t nat -F
## Establecemos politica por defecto
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -t nat -P PREROUTING ACCEPT
iptables -t nat -P POSTROUTING ACCEPT
## Empezamos a filtrar
# El localhost se deja (por ejemplo conexiones locales a mysql)
/sbin/iptables -A INPUT -i lo -j ACCEPT
# A nuestra IP le dejamos todo
iptables -A INPUT -s 195.65.34.234 -j ACCEPT
# A un colega le dejamos entrar al mysql para que mantenga la BBDD
iptables -A INPUT -s 231.45.134.23 -p tcp --dport 3306 -j ACCEPT
# A un diseñador le dejamos usar el FTP
iptables -A INPUT -s 80.37.45.194 -p tcp -dport 20:21 -j ACCEPT
# El puerto 80 de www debe estar abierto, es un servidor web.
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
# Y el resto, lo cerramos
iptables -A INPUT -p tcp --dport 20:21 -j DROP
iptables -A INPUT -p tcp --dport 3306 -j DROP
iptables -A INPUT -p tcp --dport 22 -j DROP
iptables -A INPUT -p tcp --dport 10000 -j DROP
echo " OK . Verifique que lo que se aplica con: iptables -L -n"
# Fin del script
Nota para freaks y geeks: siiii, que ya lo se, se puede mejorar este script usando variables, se puede poner el comando con el path completo, pero limítense a hacer copy-paste. Para el resto de mortales, no olvidarse de ponerle flags de ejecución: chmod +x firewall1.sh o chmod 750 firewall1.sh
En fin, ya se ve, un script de los más simple, con unas pocas reglas con las que cerramos puertos al público a los que no tienen porque tener acceso, salvo el 80. Pero cualquiera con algo de ojo se habrá dado cuenta de que ni se filtra el UDP ni el ICMP. Apostaría cualquier cosa a que el sistema tiene algún puerto udp abierto, y además peligroso como el SNMP. Como he dicho anteriormente, en este tipo de firewall es recordable hacer un netstat para ver que puertos están en estado de escucha (abiertos), y salve que un rootkit nos haya modificado los binarios, netstat nos dará la información precisa que necesitamos. Hay gente que se decanta por hacerse un nmap así mismos. Cuidado: dependiendo de cómo lo ejecutemos quizá no nos muestre todos los puertos, ya que suele mirar los bien conocidos.
Imaginemos que hemos dado un repaso a nuestro sistema, y ahora si que tenemos mejor identificados los puertos tcp y udp abiertos. Pero por si acaso nos curamos en salud y al final del script cerraremos el rango de puertos del 1 al 1024, los reservados tanto para tcp como udp.
#!/bin/sh
## SCRIPT de IPTABLES - ejemplo del manual de iptables
## Ejemplo de script para proteger la propia máquina
## Pello Xabier Altadill Izura
## www.pello.info - pello@pello.info
echo -n Aplicando Reglas de Firewall...
## FLUSH de reglas
iptables -F
iptables -X
iptables -Z
iptables -t nat -F
## Establecemos politica por defecto
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -t nat -P PREROUTING ACCEPT
iptables -t nat -P POSTROUTING ACCEPT
## Empezamos a filtrar
# El localhost se deja (por ejemplo conexiones locales a mysql)
/sbin/iptables -A INPUT -i lo -j ACCEPT
# A nuestra IP le dejamos todo
iptables -A INPUT -s 195.65.34.234 -j ACCEPT
# A un colega le dejamos entrar al mysql para que mantenga la BBDD
iptables -A INPUT -s 231.45.134.23 -p tcp --dport 3306 -j ACCEPT
# A un diseñador le dejamos usar el FTP
iptables -A INPUT -s 80.37.45.194 -p tcp -dport 20:21 -j ACCEPT
# El puerto 80 de www debe estar abierto, es un servidor web.
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
# Cerramos rango de los puertos privilegiados. Cuidado con este tipo de
# barreras, antes hay que abrir a los que si tienen acceso.
iptables -A INPUT -p tcp --dport 1:1024 -j DROP
iptables -A INPUT -p udp --dport 1:1024 -j DROP
# Cerramos otros puertos que estan abiertos
iptables -A INPUT -p tcp --dport 3306 -j DROP
iptables -A INPUT -p tcp --dport 10000 -j DROP
iptables -A INPUT -p udp --dport 10000 -j DROP
echo " OK . Verifique que lo que se aplica con: iptables -L -n"
# Fin del script
¿Sencillo, no? Ahora basta con hacer copy-paste de estas reglas y aplicarlas y ajustarlas en su sistema (quizás uses PostgreSQL). Si tiene miedo de perder el control de una máquina remota, pruebe el script en una máquina local y asegúrese de que aplica lo que usted quiere. Funcionar va a funcionar seguro.
- Versión con DROP por defecto
Vale, queremos que nuestra maquina sea inexcrutable y que solo tenga abierto un puerto imprescindible para dar determinado servicio. Con DROP por defecto se protege la maquina perfectamente, aunque hay que añadir algunas reglas para que la propia máquina sea capaz de salir a internet.¿ Para qué? hombre, porque la maquina necesita actualizaciones, consultar DNS por udp, sacar correo etc.
Veamos un posible script:
#!/bin/sh
## SCRIPT de IPTABLES - ejemplo del manual de iptables
## Ejemplo de script para proteger la propia máquina con DROP por defecto
## Pello Xabier Altadill Izura
## www.pello.info - pello@pello.info
echo -n Aplicando Reglas de Firewall...
## FLUSH de reglas
iptables -F
iptables -X
iptables -Z
iptables -t nat -F
## Establecemos politica por defecto: DROP
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
## Empezamos a filtrar? no! empezamos a abrir! porque ahora esta TODO denegado.
## Debemos decir de manera explicita qué es lo que queremos abrir
# Operar en localhost sin limitaciones
/sbin/iptables -A INPUT -i lo -j ACCEPT
/sbin/iptables -A OUTPUT -o lo -j ACCEPT
# A nuestra IP le dejamos todo
iptables -A INPUT -s 195.65.34.234 -j ACCEPT
iptables -A OUTPUT -d 195.65.34.234 -j ACCEPT
# Este es el servicio que DA la maquina a internet, por tanto todo paquete entrante se acepta para
# ese puerto y los salientes vinculados se aceptan.
/sbin/iptables -A INPUT -p tcp -m tcp --dport 80 -j ACCEPT
/sbin/iptables -A OUTPUT -p tcp -m tcp --sport 80 -m state --state RELATED,ESTABLISHED -j ACCEPT
# Permitimos que la maquina pueda salir a la web
/sbin/iptables -A INPUT -p tcp -m tcp --sport 80 -m state --state RELATED,ESTABLISHED -j ACCEPT
/sbin/iptables -A OUTPUT -p tcp -m tcp --dport 80 -j ACCEPT
# Ya tambien a webs seguras
/sbin/iptables -A INPUT -p tcp -m tcp --sport 443 -m state --state RELATED,ESTABLISHED -j ACCEPT
/sbin/iptables -A OUTPUT -p tcp -m tcp --dport 443 -j ACCEPT
# Reglas necesarias para FTP pasivo y activo. Se permiten conexiones entrantes YA establecidas
/sbin/iptables -A INPUT -p tcp -m tcp --sport 20:21 -m state --state RELATED,ESTABLISHED -j ACCEPT
/sbin/iptables -A OUTPUT -p tcp -m tcp --dport 20:21 -j ACCEPT
/sbin/iptables -A INPUT -p tcp -m tcp --sport 1024:65535 --dport 1024:65535 -m state --state ESTABLISHED -j ACCEPT
/sbin/iptables -A OUTPUT -p tcp -m tcp --dport 1024:65535 -m state --state NEW,RELATED,ESTABLISHED -j ACCEPT
# Permitimos la consulta a un primer DNS
/sbin/iptables -A INPUT -s 211.95.64.39 -p udp -m udp --sport 53 -j ACCEPT
/sbin/iptables -A OUTPUT -d 211.95.64.39 -p udp -m udp --dport 53 -j ACCEPT
# Permitimos la consulta a un segundo DNS
/sbin/iptables -A INPUT -s 211.95.79.109 -p udp -m udp --sport 53 -j ACCEPT
/sbin/iptables -A OUTPUT -d 211.95.79.109 -p udp -m udp --dport 53 -j ACCEPT
# Permitimos consultar el reloj de hora.rediris.es (un pentium166) para sincronizarse
/sbin/iptables -A INPUT -s 130.206.3.166 -p udp -m udp --dport 123 -j ACCEPT
/sbin/iptables -A OUTPUT -d 130.206.3.166 -p udp -m udp --sport 123 -j ACCEPT
# Barrera de backup por si cambiamos a modo ACCEPT temporalmente
# Con esto protegemos los puertos reservados y otros well-known
/sbin/iptables -A INPUT -p tcp -m tcp --dport 1:1024 -j DROP
/sbin/iptables -A INPUT -p udp -m udp --dport 1:1024 -j DROP
/sbin/iptables -A INPUT -p tcp -m tcp --dport 1723 -j DROP
/sbin/iptables -A INPUT -p tcp -m tcp --dport 3306 -j DROP
/sbin/iptables -A INPUT -p tcp -m tcp --dport 5432 -j DROP
echo " OK . Verifique que lo que se aplica con: iptables -L -n"
# Fin del script
3.2 Firewall de una LAN con salida a internet
Ahora vamos a ver una configuración de firewall iptables para el típico caso de red local que necesita salida a internet.
Figura 6: esquema de firewall típico entre red local e internet
¿Qué es lo que hace falta? Obviamente, una regla que haga NAT hacia fuera (enmascaramiento en iptables), con lo que se haría dos veces NAT en el firewall y en el router. Entre el router y el firewall lo normal es que haya una red privada (192.168.1.1 y 192.168.1.2 por ejemplo), aunque dependiendo de las necesidades puede que los dos tengan IP pública. El router se supone que hace un NAT completo hacia dentro (quizá salvo puerto 23), o sea que desde el exterior no se llega al router si no que de forma transparente se "choca" contra el firewall. Lo normal en este tipo de firewalls es poner la política por defecto de FORWARD en denegar (DROP), pero eso lo vemos más adelante.
Veamos como sería este firewall-gateway:
#!/bin/sh
## SCRIPT de IPTABLES - ejemplo del manual de iptables
## Ejemplo de script para firewall entre red-local e internet
##
## Pello Xabier Altadill Izura
## www.pello.info - pello@pello.info
echo -n Aplicando Reglas de Firewall...
## FLUSH de reglas
iptables -F
iptables -X
iptables -Z
iptables -t nat -F
## Establecemos politica por defecto
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -t nat -P PREROUTING ACCEPT
iptables -t nat -P POSTROUTING ACCEPT
## Empezamos a filtrar
## Nota: eth0 es el interfaz conectado al router y eth1 a la LAN
# El localhost se deja (por ejemplo conexiones locales a mysql)
/sbin/iptables -A INPUT -i lo -j ACCEPT
# Al firewall tenemos acceso desde la red local
iptables -A INPUT -s 192.168.10.0/24 -i eth1 -j ACCEPT
# Ahora hacemos enmascaramiento de la red local
# y activamos el BIT DE FORWARDING (imprescindible!!!!!)
iptables -t nat -A POSTROUTING -s 192.168.10.0/24 -o eth0 -j MASQUERADE
# Con esto permitimos hacer forward de paquetes en el firewall, o sea
# que otras máquinas puedan salir a traves del firewall.
echo 1 > /proc/sys/net/ipv4/ip_forward
## Y ahora cerramos los accesos indeseados del exterior:
# Nota: 0.0.0.0/0 significa: cualquier red
# Cerramos el rango de puerto bien conocido
iptables -A INPUT -s 0.0.0.0/0 -p tcp -dport 1:1024 -j DROP
iptables -A INPUT -s 0.0.0.0/0 -p udp -dport 1:1024 -j DROP
# Cerramos un puerto de gestión: webmin
iptables -A INPUT -s 0.0.0.0/0 -p tcp -dport 10000 -j DROP
echo " OK . Verifique que lo que se aplica con: iptables -L -n"
# Fin del script
Pero como somos muy malvados queremos que los empleados solamente puedan navegar por internet, denegando el acceso a Kazaa o edonkey. Esta sería una configuración simple pero efectiva.
#!/bin/sh
## SCRIPT de IPTABLES - ejemplo del manual de iptables
## Ejemplo de script para firewall entre red-local e internet
## con filtro para que solo se pueda navegar.
## Pello Xabier Altadill Izura
## www.pello.info - pello@pello.info
echo -n Aplicando Reglas de Firewall...
## FLUSH de reglas
iptables -F
iptables -X
iptables -Z
iptables -t nat -F
## Establecemos politica por defecto
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -t nat -P PREROUTING ACCEPT
iptables -t nat -P POSTROUTING ACCEPT
## Empezamos a filtrar
## Nota: eth0 es el interfaz conectado al router y eth1 a la LAN
# El localhost se deja (por ejemplo conexiones locales a mysql)
/sbin/iptables -A INPUT -i lo -j ACCEPT
# Al firewall tenemos acceso desde la red local
iptables -A INPUT -s 192.168.10.0/24 -i eth1 -j ACCEPT
## Ahora con regla FORWARD filtramos el acceso de la red local
## al exterior. Como se explica antes, a los paquetes que no van dirigidos al
## propio firewall se les aplican reglas de FORWARD
# Aceptamos que vayan a puertos 80
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -p tcp --dport 80 -j ACCEPT
# Aceptamos que vayan a puertos https
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -p tcp --dport 443 -j ACCEPT
# Aceptamos que consulten los DNS
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -p tcp --dport 53 -j ACCEPT
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -p udp --dport 53 -j ACCEPT
# Y denegamos el resto. Si se necesita alguno, ya avisaran
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -j DROP
# Ahora hacemos enmascaramiento de la red local
# y activamos el BIT DE FORWARDING (imprescindible!!!!!)
iptables -t nat -A POSTROUTING -s 192.168.10.0/24 -o eth0 -j MASQUERADE
# Con esto permitimos hacer forward de paquetes en el firewall, o sea
# que otras máquinas puedan salir a traves del firewall.
echo 1 > /proc/sys/net/ipv4/ip_forward
## Y ahora cerramos los accesos indeseados del exterior:
# Nota: 0.0.0.0/0 significa: cualquier red
# Cerramos el rango de puerto bien conocido
iptables -A INPUT -s 0.0.0.0/0 -p tcp -dport 1:1024 -j DROP
iptables -A INPUT -s 0.0.0.0/0 -p udp -dport 1:1024 -j DROP
# Cerramos un puerto de gestión: webmin
iptables -A INPUT -s 0.0.0.0/0 -p tcp -dport 10000 -j DROP
echo " OK . Verifique que lo que se aplica con: iptables -L -n"
# Fin del script
Supongamos que este firewall tiene alguna función adicional: es un servidor proxy y además es un servidor de correo. Darle funcionalidades de este tipo a un firewall no es recomendable, porque si no se protegen bien esos puertos o si no está actualizado el software pueden entrar en el firewall a base de xploits comprometiendo TODA la red local. De todas formas muchas empresas no se pueden permitir o no quieren tener una máquina para cada cosa, bastante les cuesta a muchas poner un firewall. Por tanto: si se añaden servicios que deben estar abiertos al público en el propio firewall, nos la estamos jugando, y se recomienda pasar el servicio a otra máquina y ponerla en la DMZ.
Supongamos también que la empresa tiene comerciales en ruta y que se conectan a internet desde su portátil y con una ip dinámica. Supongamos también que el jefe de la empresa quiere acceder a la red local desde casa con una conexión ADSL. Ahora en el firewall debieramos tener instalado un servidor SMTP, pop3, y un PPTPD.
#!/bin/sh
## SCRIPT de IPTABLES - ejemplo del manual de iptables
## Ejemplo de script para firewall entre red-local e internet
## con servicios abiertos de puerto 25, 110, y 1723
## Pello Xabier Altadill Izura
## www.pello.info - pello@pello.info
echo -n Aplicando Reglas de Firewall...
## FLUSH de reglas
iptables -F
iptables -X
iptables -Z
iptables -t nat -F
## Establecemos politica por defecto
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -t nat -P PREROUTING ACCEPT
iptables -t nat -P POSTROUTING ACCEPT
## Empezamos a filtrar
## Nota: eth0 es el interfaz conectado al router y eth1 a la LAN
# El localhost se deja (por ejemplo conexiones locales a mysql)
iptables -A INPUT -i lo -j ACCEPT
# Al firewall tenemos acceso desde la red local
iptables -A INPUT -s 192.168.10.0/24 -i eth1 -j ACCEPT
## Abrimos el acceso a puertos de correo
# Abrimos el puerto 25, hay que configurar bien el relay del servidor SMTP
iptables -A INPUT -s 0.0.0.0/0 -p tcp --dport 25 -j ACCEPT
# Abrimos el pop3
iptables -A INPUT -s 0.0.0.0/0 -p tcp --dport 110 -j ACCEPT
# Y abrimos el puerto pptpd para la ip del adsl de casa del jefe
iptables -A INPUT -s 211.45.176.24 -p tcp --dport 1723 -j ACCEPT
## Ahora con regla FORWARD filtramos el acceso de la red local
## al exterior. Como se explica antes, a los paquetes que no van dirigidos al
## propio firewall se les aplican reglas de FORWARD
# Aceptamos que vayan a puertos 80
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -p tcp --dport 80 -j ACCEPT
# Aceptamos que vayan a puertos https
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -p tcp --dport 443 -j ACCEPT
# Aceptamos que consulten los DNS
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -p tcp --dport 53 -j ACCEPT
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -p udp --dport 53 -j ACCEPT
# Y denegamos el resto. Si se necesita alguno, ya avisaran
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -j DROP
# Ahora hacemos enmascaramiento de la red local
# y activamos el BIT DE FORWARDING (imprescindible!!!!!)
iptables -t nat -A POSTROUTING -s 192.168.10.0/24 -o eth0 -j MASQUERADE
# Con esto permitimos hacer forward de paquetes en el firewall, o sea
# que otras máquinas puedan salir a traves del firewall.
echo 1 > /proc/sys/net/ipv4/ip_forward
## Y ahora cerramos los accesos indeseados del exterior:
# Nota: 0.0.0.0/0 significa: cualquier red
# Cerramos el rango de puerto bien conocido
iptables -A INPUT -s 0.0.0.0/0 -i eth0 -p tcp -dport 1:1024 -j DROP
iptables -A INPUT -s 0.0.0.0/0 -i eth0 -p udp -dport 1:1024 -j DROP
# Cerramos un puerto de gestión: webmin
iptables -A INPUT -s 0.0.0.0/0 -i eth0 -p tcp --dport 10000 -j DROP
# Y cerramos el puerto del servicio PPTPD, solo abierto para el jefe.
iptables -A INPUT -s 0.0.0.0/0 -i eth0 -p tcp --dport 1723 -j DROP
echo " OK . Verifique que lo que se aplica con: iptables -L -n"
# Fin del script
¡Más difícil todavía!
Ahora queremos compartir algún servicio pero de un servidor que tenemos dentro de la red local, por ejemplo el IIS de un servidor windows2000, y además permitir la gestión remota por terminal server para esta máquina para una empresa externa. En este caso lo que hay que hacer es un redirección de puerto. Antes de iptables esto se podía hacer fácilmente con un servidor como rinet. Rinet lo que hace es simplemente abrir un puerto en el firewall y al conectarse a él te lleva hasta el puerto de otra máquina, como una tubería. Con Iptables podemos hacer redirecciones con una ventaja: no perdemos la información de IP origen, cosa que con rinet sí ocurría. En fin, veamos la configuración, con las nuevas reglas de DNAT:
#!/bin/sh
## SCRIPT de IPTABLES - ejemplo del manual de iptables
## Ejemplo de script para firewall entre red-local e internet
## con servicios abiertos de puerto 25, 110, y 1723
## Pello Xabier Altadill Izura
## www.pello.info - pello@pello.info
echo -n Aplicando Reglas de Firewall...
## FLUSH de reglas
iptables -F
iptables -X
iptables -Z
iptables -t nat -F
## Establecemos politica por defecto
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -t nat -P PREROUTING ACCEPT
iptables -t nat -P POSTROUTING ACCEPT
## Empezamos a filtrar
## REDIRECCIONES
# Todo lo que venga por el exterior y vaya al puerto 80 lo redirigimos
# a una maquina interna
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j DNAT --to 192.168.10.12:80
# Los accesos de un ip determinada a Terminal server se redirigen e esa
# maquina
iptables -t nat -A PREROUTING -s 221.23.124.181 -i eth0 -p tcp --dport 3389 -j DNAT --to 192.168.10.12:3389
## Nota: eth0 es el interfaz conectado al router y eth1 a la LAN
# El localhost se deja (por ejemplo conexiones locales a mysql)
iptables -A INPUT -i lo -j ACCEPT
# Al firewall tenemos acceso desde la red local
iptables -A INPUT -s 192.168.10.0/24 -i eth1 -j ACCEPT
## Abrimos el acceso a puertos de correo
# Abrimos el puerto 25, hay que configurar bien el relay del servidor SMTP
iptables -A INPUT -s 0.0.0.0/0 -p tcp --dport 25 -j ACCEPT
# Abrimos el pop3
iptables -A INPUT -s 0.0.0.0/0 -p tcp --dport 110 -j ACCEPT
# Y abrimos el puerto pptpd para la ip del adsl de casa del jefe
iptables -A INPUT -s 211.45.176.24 -p tcp --dport 1723 -j ACCEPT
## Ahora con regla FORWARD filtramos el acceso de la red local
## al exterior. Como se explica antes, a los paquetes que no van dirigidos al
## propio firewall se les aplican reglas de FORWARD
# Aceptamos que vayan a puertos 80
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -p tcp --dport 80 -j ACCEPT
# Aceptamos que vayan a puertos https
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -p tcp --dport 443 -j ACCEPT
# Aceptamos que consulten los DNS
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -p tcp --dport 53 -j ACCEPT
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -p udp --dport 53 -j ACCEPT
# Y denegamos el resto. Si se necesita alguno, ya avisaran
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -j DROP
# Ahora hacemos enmascaramiento de la red local
# y activamos el BIT DE FORWARDING (imprescindible!!!!!)
iptables -t nat -A POSTROUTING -s 192.168.10.0/24 -o eth0 -j MASQUERADE
# Con esto permitimos hacer forward de paquetes en el firewall, o sea
# que otras máquinas puedan salir a traves del firewall.
echo 1 > /proc/sys/net/ipv4/ip_forward
## Y ahora cerramos los accesos indeseados del exterior:
# Nota: 0.0.0.0/0 significa: cualquier red
# Cerramos el rango de puerto bien conocido
iptables -A INPUT -s 0.0.0.0/0 -i eth0 -p tcp -dport 1:1024 -j DROP
iptables -A INPUT -s 0.0.0.0/0 -i eth0 -p udp -dport 1:1024 -j DROP
# Cerramos un puerto de gestión: webmin
iptables -A INPUT -s 0.0.0.0/0 -i eth0 -p tcp --dport 10000 -j DROP
# Y cerramos el puerto del servicio PPTPD, solo abierto para el jefe.
iptables -A INPUT -s 0.0.0.0/0 -i eth0 -p tcp --dport 1723 -j DROP
echo " OK . Verifique que lo que se aplica con: iptables -L -n"
# Fin del script
Bueno ya tenemos montada la red, pero conviene insistir en que esta última configuración, con las redirecciones y los servicios de correo funcionando en el firewall es bastante insegura. ¿Qué ocurre si hackean el servidor IIS de la red local? Pues que el firewall no sirve de gran cosa, lo poco que podría hacer una vez se ha entrado en la red local es evitar escaneos hacia el exterior desde la máquina atacada, aunque para ello el firewall debiera tener una buena configuración con denegación por defecto. Si necesitamos ese servidor IIS, basta con comprar una tarjeta de red por 6€ o dolares y crear una DMZ.
3.3 Firewall de una LAN con salida a internet con DMZ
Bueno, esto se va complicando. Imaginemos que tenemos una red parecida a la anterior pero ahora hacemos las cosas bien y colocamos ese servidor IIS en una DMZ:
Figura 7: esquema de firewall entre red local e internet con zona DMZ para servidores expuestos
En este tipo de firewall hay que permitir:
- Acceso de la red local a internet.
- Acceso público al puerto tcp/80 y tcp/443 del servidor de la DMZ
- Acceso del servidor de la DMZ a una BBDD de la LAN
- Obviamente bloquear el resto de acceso de la DMZ hacia la LAN.
¿Qué tipo de reglas son las que hay que usar para filtrar el tráfico entre la DMZ y la LAN? Solo pueden ser las FORWARD, ya que estamos filtrando entre distintas redes, no son paquetes destinados al propio firewall.
#!/bin/sh
## SCRIPT de IPTABLES - ejemplo del manual de iptables
## Ejemplo de script para firewall entre red-local e internet con DMZ
##
## Pello Xabier Altadill Izura
## www.pello.info - pello@pello.info
echo -n Aplicando Reglas de Firewall...
## FLUSH de reglas
iptables -F
iptables -X
iptables -Z
iptables -t nat -F
## Establecemos politica por defecto
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -t nat -P PREROUTING ACCEPT
iptables -t nat -P POSTROUTING ACCEPT
## Empezamos a filtrar
## Nota: eth0 es el interfaz conectado al router y eth1 a la LAN
# Todo lo que venga por el exterior y vaya al puerto 80 lo redirigimos
# a una maquina interna
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j DNAT --to 192.168.3.2:80
# Los accesos de un ip determinada HTTPS se redirigen e esa
# maquina
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 443 -j DNAT --to 192.168.3.2:443
# El localhost se deja (por ejemplo conexiones locales a mysql)
/sbin/iptables -A INPUT -i lo -j ACCEPT
# Al firewall tenemos acceso desde la red local
iptables -A INPUT -s 192.168.10.0/24 -i eth1 -j ACCEPT
# Ahora hacemos enmascaramiento de la red local y de la DMZ
# para que puedan salir haca fuera
# y activamos el BIT DE FORWARDING (imprescindible!!!!!)
iptables -t nat -A POSTROUTING -s 192.168.10.0/24 -o eth0 -j MASQUERADE
iptables -t nat -A POSTROUTING -s 192.168.3.0/24 -o eth0 -j MASQUERADE
# Con esto permitimos hacer forward de paquetes en el firewall, o sea
# que otras máquinas puedan salir a traves del firewall.
echo 1 > /proc/sys/net/ipv4/ip_forward
## Permitimos el paso de la DMZ a una BBDD de la LAN:
iptables -A FORWARD -s 192.168.3.2 -d 192.168.10.5 -p tcp --dport 5432 -j ACCEPT
iptables -A FORWARD -s 192.168.10.5 -d 192.168.3.2 -p tcp --sport 5432 -j ACCEPT
## permitimos abrir el Terminal server de la DMZ desde la LAN
iptables -A FORWARD -s 192.168.10.0/24 -d 192.168.3.2 -p tcp --sport 1024:65535 --dport 3389 -j ACCEPT
# … hay que hacerlo en uno y otro sentido …
iptables -A FORWARD -s 192.168.3.2 -d 192.168.10.0/24 -p tcp --sport 3389 --dport 1024:65535 -j ACCEPT
# … por que luego:
# Cerramos el acceso de la DMZ a la LAN
iptables -A FORWARD -s 192.168.3.0/24 -d 192.168.10.0/24 -j DROP
## Cerramos el acceso de la DMZ al propio firewall
iptables -A INPUT -s 192.168.3.0/24 -i eth2 -j DROP
## Y ahora cerramos los accesos indeseados del exterior:
# Nota: 0.0.0.0/0 significa: cualquier red
# Cerramos el rango de puerto bien conocido
iptables -A INPUT -s 0.0.0.0/0 -p tcp -dport 1:1024 -j DROP
iptables -A INPUT -s 0.0.0.0/0 -p udp -dport 1:1024 -j DROP
# Cerramos un puerto de gestión: webmin
iptables -A INPUT -s 0.0.0.0/0 -p tcp -dport 10000 -j DROP
echo " OK . Verifique que lo que se aplica con: iptables -L -n"
# Fin del script
Vamos a ver: si las máquinas de la DMZ tienen una ip pública hay que tener muchísimo cuidado de no permitir el FORWARD por defecto. Si en la DMZ hay ip pública NO ES NECESARIO HACER REDIRECCIONES de puerto, sino que basta con rutar los paquetes para llegar hasta la DMZ. Este tipo de necesidades surgen cuando por ejemplo tenemos dos máquinas con servidor web (un apache y un IIS); ¿A cuál de las dos le redirigimos el puerto 80? No hay manera de saberlo (No, con servidores virtuales tampoco, piénsalo), por eso se deben asignar IPs públicas o en su defecto usar puertos distintos.
Por tanto hay que proteger convenientemente toda la DMZ. Tampoco haría falta enmascarar la salida hacia el exterior de la DMZ, si tiene una ip pública ya tiene una pata puesta en internet; obviamente hay que decirle al router como llegar hasta esa ip pública. Así podría ser esta red:
Figura 8: esquema de firewall entre red local e internet con zona DMZ para servidores expuestos usando IPs públicas
Y este podría ser un firewall adecuado:
#!/bin/sh
## SCRIPT de IPTABLES - ejemplo del manual de iptables
## Ejemplo de script para firewall entre red-local e internet con DMZ
## pero con IPs públicas.
## Pello Xabier Altadill Izura
## www.pello.info - pello@pello.info
echo -n Aplicando Reglas de Firewall...
## FLUSH de reglas
iptables -F
iptables -X
iptables -Z
iptables -t nat -F
## Establecemos politica por defecto
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -t nat -P PREROUTING ACCEPT
iptables -t nat -P POSTROUTING ACCEPT
## Empezamos a filtrar
## Nota: eth0 es el interfaz conectado al router y eth1 a la LAN
# El localhost se deja (por ejemplo conexiones locales a mysql)
/sbin/iptables -A INPUT -i lo -j ACCEPT
# Al firewall tenemos acceso desde la red local
iptables -A INPUT -s 192.168.10.0/24 -i eth1 -j ACCEPT
# Ahora hacemos enmascaramiento de la red local y de la DMZ
# para que puedan salir haca fuera
# y activamos el BIT DE FORWARDING (imprescindible!!!!!)
iptables -t nat -A POSTROUTING -s 192.168.10.0/24 -o eth0 -j MASQUERADE
# Con esto permitimos hacer forward de paquetes en el firewall, o sea
# que otras máquinas puedan salir a traves del firewall.
echo 1 > /proc/sys/net/ipv4/ip_forward
## Permitimos el acceso desde el exterior a los puertos 80 y 443 de DMZ
iptables -A FORWARD -d 212.194.89.152 -p tcp -dport 80 -j ACCEPT
iptables -A FORWARD -d 212.194.89.152 -p tcp -dport 443 -j ACCEPT
iptables -A FORWARD -d 212.194.89.150/30 -j DROP
## Permitimos el paso de la DMZ a una BBDD de la LAN:
iptables -A FORWARD -s 212.194.89.152 -d 192.168.10.5 -p tcp --dport 5432 -j ACCEPT
# en el otro sentido lo mismo
iptables -A FORWARD -s 192.168.10.5 -d 212.194.89.152 -p tcp --sport 5432 -j ACCEPT
## permitimos abrir el Terminal server de la DMZ desde la LAN
iptables -A FORWARD -s 192.168.10.0/24 -d 212.194.89.152 -p tcp --sport 1024:65535 --dport 3389 -j ACCEPT
# … hay que hacerlo en uno y otro sentido …
iptables -A FORWARD -s 212.194.89.152 -d 192.168.10.0/24 -p tcp --sport 3389 --dport 1024:65535 -j ACCEPT
# … por que luego:
# Cerramos el acceso de la DMZ a la LAN
iptables -A FORWARD -s 212.194.89.152 -d 192.168.10.0/24 -j DROP
## Cerramos el acceso de la DMZ al propio firewall
iptables -A INPUT -s 212.194.89.152 -i eth2 -j DROP
## Y ahora cerramos los accesos indeseados del exterior:
# Nota: 0.0.0.0/0 significa: cualquier red
# Cerramos el rango de puerto bien conocido
iptables -A INPUT -s 0.0.0.0/0 -p tcp -dport 1:1024 -j DROP
iptables -A INPUT -s 0.0.0.0/0 -p udp -dport 1:1024 -j DROP
# Cerramos un puerto de gestión: webmin
iptables -A INPUT -s 0.0.0.0/0 -p tcp -dport 10000 -j DROP
echo " OK . Verifique que lo que se aplica con: iptables -L -n"
# Fin del script
ATENCIÓN
Merece la pena pararse a explicar esta parte del firewall:
## permitimos abrir el Terminal server de la DMZ desde la LAN
iptables -A FORWARD -s 192.168.10.0/24 -d 212.194.89.152 -p tcp -sport 1024:65535 --dport 3389 -j ACCEPT
# … hay que hacerlo en uno y otro sentido …
iptables -A FORWARD -s 212.194.89.152 -d 192.168.10.0/24 -p tcp --sport 3389 --dport 1024:65535 -j ACCEPT
# … por que luego:
# Cerramos el acceso de la DMZ a la LAN
iptables -A FORWARD -s 212.194.89.152 -d 192.168.10.0/24 -j DROP
Lo que nos lleva a dos cuestiones:
¿Por qué hay que explicitar la abertura en uno y otro sentido? Porque la tercera regla cierra todo lo que va de la DMZ a la red local. Para abrir el puerto 3389 de tcp es imprescindible que un paquete de ida sea capaz de llegar hasta la DMZ y que a su vez pueda volver a la LAN. Esto de tener que especificar la abertura en uno y otro sentido será el pan de cada día en un iptables con política DROP por defecto: mejor protección pero más trabajo.
¿Por qué se explicita el puerto de origen/destino 1024:65535 en la primera y segunda regla? Imaginemos que un hacker logra acceso a la máquina de la DMZ. Si no especificamos el puerto de destino en esas dos reglas, el hacker puede abrir CUALQUIER puerto de la LAN siempre que pueda establecer como puerto origen suyo el tcp/3389, cosa fácil para un hacker que sepa algo de C o que tenga el programa pertinente a mano. De todas formas el hacker tendría que saber que existe ese tipo de reglas, si es listo probara con puertos de gestión o con puertos netbios. El problema es que se deja un vínculo con la LAN bien para administrarlo remotamente o para establecer relaciones de confianza y ahí es donde reside el peligro.
En las conexiones "legales" no se usa como puerto origen nada por debajo del 1024; cuando alguien se conecta a otro puerto en su extremo abre un puerto por encima del 1024. Especificándolo en la regla de firewall protegeremos un poco mejor la LAN, aunque los puertos por encima de 1024 estarán en peligro.
3.4 Firewall de una LAN con salida a internet y VPNS
En principio este caso no nos tendría que dar mayor problema, aunque la primera vez que lo montemos, el enmascaramiento nos jugará una mala pasada. Por eso conviene echar un vistazo en este caso.
Figura 9: esquema de firewall entre red local e internet con zona DMZ y delegaciones que acceden a DMZ
Supongamos que entre los routers ya se ha establecido un tunel (con Ciscos se haria creando un interfaz Tunnel), y que si el firewall nos deja podríamos llegar de la central a las delegaciones y viceversa usando las IPs privadas. Vaya que se puede hacer un ping desde la central a 192.168.30.x y nos responde. Para ello es imprescindible que el router de la central tenga una ruta metida para llegar a 192.168.10.0/24 y por supuesto cada una ruta para cada delegación. Antes de meterse en el firewall hay que asegurar la visibilidad entre los routers y poder llegar a sus IPs privadas haciendo ping.
Supongamos también que en la central esta el servidor de correo que lógicamente debe tener el puerto 25 accesible desde internet, y debe ser accesible desde las delegaciones para puerto 25, 110 (pop3) o 143(imap). La salida a internet (web, ftp, etc..) cada uno la hace por su lado.
Veamos una posible configuración para este caso.
#!/bin/sh
## SCRIPT de IPTABLES - ejemplo del manual de iptables
## Ejemplo de script para firewall entre red-local e internet con DMZ
## y delegaciones. Las delegaciones deben tener acceso al correo de la DMZ
##
## Pello Xabier Altadill Izura
## www.pello.info - pello@pello.info
echo -n Aplicando Reglas de Firewall...
## FLUSH de reglas
iptables -F
iptables -X
iptables -Z
iptables -t nat -F
## Establecemos politica por defecto
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -t nat -P PREROUTING ACCEPT
iptables -t nat -P POSTROUTING ACCEPT
## Empezamos a filtrar
## Nota: eth0 es el interfaz conectado al router y eth1 a la LAN
# Todo lo que venga por el exterior y vaya al puerto 25 lo redirigimos
# a la maquina de la DMZ
iptables -t nat -A PREROUTING -i eth0 \
-p tcp --dport 25 -j DNAT --to 192.168.3.2:25
# Todo lo que venga por el interfaz del router(eth0) y vaya al 110
# siempre que sea una delegacion se acepta y redirije
iptables -t nat -A PREROUTING -s 192.168.20.0/24 -i eth0 \
-p tcp --dport 110 -j DNAT --to 192.168.3.2:110
iptables -t nat -A PREROUTING -s 192.168.30.0/24 -i eth0 \
-p tcp --dport 110 -j DNAT --to 192.168.3.2:110
# Todo lo que venga por el interfaz del router(eth0) y vaya al 110
# siempre que sea una delegacion se acepta y redirije
iptables -t nat -A PREROUTING -s 192.168.20.0/24 -i eth0 \
-p tcp --dport 143 -j DNAT --to 192.168.3.2:143
iptables -t nat -A PREROUTING -s 192.168.30.0/24 -i eth0 \
-p tcp --dport 143 -j DNAT --to 192.168.3.2:143
# El localhost se deja (por ejemplo conexiones locales a mysql)
iptables -A INPUT -i lo -j ACCEPT
# Al firewall tenemos acceso desde la red local
iptables -A INPUT -s 192.168.10.0/24 -i eth1 -j ACCEPT
# Ahora hacemos enmascaramiento de la red local y de la DMZ
# para que puedan salir haca fuera
# y activamos el BIT DE FORWARDING (imprescindible!!!!!)
# Cuidado con este enmascaramiento.
iptables -t nat -A POSTROUTING -s 192.168.10.0/24 -o eth0 -j MASQUERADE
iptables -t nat -A POSTROUTING -s 192.168.3.0/24 -o eth0 -j MASQUERADE
# Con esto permitimos hacer forward de paquetes en el firewall, o sea
# que otras máquinas puedan salir a traves del firewall.
echo 1 > /proc/sys/net/ipv4/ip_forward
# Para que desde la red local se salga hacia fuera hay que ENMASCARAR
# pero que pasa con las delegaciones tambien estan fuera Y NO HAY QUE
# ENMASCARAR, debemos meter una regla FORWARD explicita para que no enmascare
# porque si no una petición de la LAN a otra delegacion no se meteria
# en el tunel.
iptables -A FORWARD -s 192.168.10.0/24 -d 192.168.20.0/24 -j ACCEPT
iptables -A FORWARD -s 192.168.20.0/24 -d 192.168.10.0/24 -j ACCEPT
iptables -A FORWARD -s 192.168.10.0/24 -d 192.168.30.0/24 -j ACCEPT
iptables -A FORWARD -s 192.168.30.0/24 -d 192.168.10.0/24 -j ACCEPT
# Abrimos el acceso para que se pueda aceder a la DMZ desde la LAN
# a puertos de correo
# En principio lo que va de LAN -> DMZ se acepta
iptables -A FORWARD -s 192.168.10.0/24 -d 192.168.3.0/24 -j ACCEPT
# Luedo desde la DMZ a la LAN solo se acepta 25,110,143
iptables -A FORWARD -s 192.168.3.0/24 -p tcp --sport 25 \
-d 192.168.10.0/24 -j ACCEPT
iptables -A FORWARD -s 192.168.3.0/24 -p tcp --sport 143 \
-d 192.168.10.0/24 -j ACCEPT
iptables -A FORWARD -s 192.168.3.0/24 -p tcp --sport 143 \
-d 192.168.10.0/24 -j ACCEPT
# Cerramos el acceso de la DMZ a la LAN
iptables -A FORWARD -s 192.168.3.0/24 -d 192.168.10.0/24 -j DROP
## Cerramos el acceso de la DMZ al propio firewall
iptables -A INPUT -s 192.168.3.0/24 -i eth2 -j DROP
## Y ahora cerramos los accesos indeseados del exterior:
# Nota: 0.0.0.0/0 significa: cualquier red
# Cerramos el rango de puerto bien conocido
iptables -A INPUT -s 0.0.0.0/0 -p tcp -dport 1:1024 -j DROP
iptables -A INPUT -s 0.0.0.0/0 -p udp -dport 1:1024 -j DROP
# Cerramos un puerto de gestión: webmin
iptables -A INPUT -s 0.0.0.0/0 -p tcp -dport 10000 -j DROP
echo " OK . Verifique que lo que se aplica con: iptables -L -n"
# Fin del script
Se han remarcado en negrita las reglas FORWARD entre IPs privadas de delegaciones, ya que sin esas reglas y con el enmascaramiento de por medio no se podría acceder a las delegaciones. Cabe resaltar que entre delegaciones no hay visibilidad total, solamente la central vería a todas las demás, y las delegaciones solamente la central.
La delegaciones accederían al servidor de correo con una redirección, o sea que ellos se configurarían el servidor de correo como 192.168.10.1, mientras que desde la LAN se accedería directamente. Se puede hacer de distintas maneras.
Lo interesante sería poner ese firewall con DROP por defecto, se tratará de mostrar esa configuración al final.
3.5 Firewall puro y duro entre redes
En este caso olvidémonos de redes locales y de NAT. Aquí solo tendremos reglas de filtrado INPUT y FORWARD. Pongamos que tenemos el siguiente escenario:
Figura 10: esquema de firewall entre redes, en la que solo se filtra y no se hace NAT
En el firewall debemos indicar una serie de reglas para proteger los equipos que están al otro lado de este dispositivo, todos ellos de la red 211.34.149.0/24
Cada uno de ellos da un servicio determinado, y puede estar gestionado desde distintas IPs, lo que significa que habrá que dar acceso a determinados puertos de gestión (22, 3389, etc..).
Este podría ser el aspecto del script del firewall:
#!/bin/sh
## SCRIPT de IPTABLES - ejemplo del manual de iptables
## Ejemplo de script para firewall entre redes.
## Pello Xabier Altadill Izura
## www.pello.info - pello@pello.info
echo -n Aplicando Reglas de Firewall...
## FLUSH de reglas
iptables -F
iptables -X
iptables -Z
iptables -t nat -F
## Establecemos politica por defecto
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
## Empezamos a filtrar
## Nota: eth0 es el interfaz conectado al router y eth1 a la LAN
# A nuestro firewall tenemos acceso total desde la nuestra IP
iptables -A INPUT -s 210.195.55.15 -j ACCEPT
# Para el resto no hay acceso al firewall
iptables -A INPUT -s 0.0.0.0/0 -j DROP
## Ahora podemos ir metiendo las reglas para cada servidor
## Como serán paquetes con destino a otras máquinas se aplica FORWARD
## Servidor WEB 211.34.149.2
# Acceso a puerto 80
iptables -A FORWARD -d 211.34.149.2 -p tcp --dport 80 -j ACCEPT
# Acceso a nuestra ip para gestionarlo
iptables -A FORWARD -s 210.195.55.15 -d 211.34.149.2 -p tcp --dport 22 -j ACCEPT
# El resto, cerrar
iptables -A FORWARD -d 211.34.149.2 -j DROP
## Servidor MAIL 211.34.149.3
# Acceso a puerto 25, 110 y 143
iptables -A FORWARD -d 211.34.149.3 -p tcp --dport 25 -j ACCEPT
iptables -A FORWARD -d 211.34.149.3 -p tcp --dport 110 -j ACCEPT
iptables -A FORWARD -d 211.34.149.3 -p tcp --dport 143 -j ACCEPT
# Acceso a gestion SNMP
iptables -A FORWARD -s 210.195.55.15 -d 211.34.149.3 -p udp --dport 169 -j ACCEPT
# Acceso a nuestra ip para gestionarlo
iptables -A FORWARD -s 210.195.55.15 -d 211.34.149.3 -p tcp --dport 22 -j ACCEPT
# El resto, cerrar
iptables -A FORWARD -d 211.34.149.3 -j DROP
## Servidor IRC 211.34.149.4
# Acceso a puertos IRC
iptables -A FORWARD -d 211.34.149.4 -p tcp --dport 6666:6668 -j ACCEPT
# Acceso a nuestra ip para gestionarlo
iptables -A FORWARD -s 210.195.55.15 -d 211.34.149.4 -p tcp --dport 22 -j ACCEPT
# El resto, cerrar
iptables -A FORWARD -d 211.34.149.4 -j DROP
## Servidor NEWS 211.34.149.5
# Acceso a puerto news
iptables -A FORWARD -d 211.34.149.5 -p tcp --dport news -j ACCEPT
# Acceso a nuestra ip para gestionarlo
iptables -A FORWARD -s 213.194.68.115 -d 211.34.149.5 -p tcp --dport 22 -j ACCEPT
# El resto, cerrar
iptables -A FORWARD -d 211.34.149.5 -j DROP
## Servidor B2B 211.34.149.6
# Acceso a puerto 443
iptables -A FORWARD -d 211.34.149.6 -p tcp --dport 443 -j ACCEPT
# Acceso a una ip para gestionarlo
iptables -A FORWARD -s 81.34.129.56 -d 211.34.149.6 -p tcp --dport 3389 -j ACCEPT
# El resto, cerrar
iptables -A FORWARD -d 211.34.149.6 -j DROP
## Servidor CITRIX 211.34.149.7
# Acceso a puerto 1494
iptables -A FORWARD -d 211.34.149.7 -p tcp --dport 1494 -j ACCEPT
# Acceso a una ip para gestionarlo
iptables -A FORWARD -s 195.55.234.2 -d 211.34.149.7 -p tcp --dport 3389 -j ACCEPT
# acceso a otro puerto quiza de BBDD
iptables -A FORWARD -s 195.55.234.2 -d 211.34.149.7 -p tcp --dport 1434 -j ACCEPT
# acceso a otro puerto quiza de BBDD
iptables -A FORWARD -s 195.55.234.2 -d 211.34.149.7 -p udp --dport 1433 -j ACCEPT
# El resto, cerrar
iptables -A FORWARD -d 211.34.149.7 -j DROP
echo " OK . Verifique que lo que se aplica con: iptables -L -n"
# Fin del script
Con esta firewall y sobretodo gracias a las reglas de DROP que metemos tras especificar lo que dejamos abiertos, protegeremos de manera eficaz todos lo puertos abiertos de las máquinas.
3.6 Firewall con política por defecto DROP
Aquí llega la sección para los auténticos administradores de pelo en pecho.
¿Qué supone el hecho de establecer como política por defecto la denegación?
" Se debe explicitar cada conexión permitida en los dos sentidos.
" Se debe conocer perfectamente qué debe estar abierto y qué no.
" Es muchos más difícil de mantener y si se hace conviene hacerlo desde el principio.
" No todo es más trabajo: también supone un firewall mucho más seguro.
En el ejemplo de la DMZ ya se presentaba esta situación en las reglas forward de una a otra red. Para ilustrar el DROP por defecto, vamos a mostrar la configuración del ejemplo anterior de firewall entre redes pero con política por defecto DROP.
#!/bin/sh
## SCRIPT de IPTABLES - ejemplo del manual de iptables
## Ejemplo de script para firewall entre redes con DROP por defecto
## Pello Xabier Altadill Izura
## www.pello.info - pello@pello.info
echo -n Aplicando Reglas de Firewall...
## FLUSH de reglas
iptables -F
iptables -X
iptables -Z
iptables -t nat -F
## Establecemos politica por defecto: DROP!!!
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
## Empezamos a filtrar
## Nota: eth0 es el interfaz conectado al router y eth1 a la LAN
# A nuestro firewall tenemos acceso total desde la nuestra IP
iptables -A INPUT -s 210.195.55.15 -j ACCEPT
iptables -A OUTPUT -d 210.195.55.15 -j ACCEPT
# Para el resto no hay acceso al firewall
# En principio esta de más, pero si rebajamos los permisos temporalmente
# nos cubre las espaldas
iptables -A INPUT -s 0.0.0.0/0 -j DROP
## Ahora podemos ir metiendo las reglas para cada servidor
## Como serán paquetes con destino a otras máquinas se aplica FORWARD
## Servidor WEB 211.34.149.2
# Acceso a puerto 80
iptables -A FORWARD -d 211.34.149.2 -p tcp --dport 80 -j ACCEPT
iptables -A FORWARD -s 211.34.149.2 -p tcp --sport 80 -j ACCEPT
# Acceso a nuestra ip para gestionarlo
iptables -A FORWARD -s 210.195.55.15 -d 211.34.149.2 -p tcp --dport 22 -j ACCEPT
iptables -A FORWARD -s 211.34.149.2 -d 210.195.55.15 -p tcp --sport 22 -j ACCEPT
## Servidor MAIL 211.34.149.3
# Acceso a puerto 25, 110 y 143
iptables -A FORWARD -d 211.34.149.3 -p tcp --dport 25 -j ACCEPT
iptables -A FORWARD -s 211.34.149.3 -p tcp --sport 25 -j ACCEPT
iptables -A FORWARD -d 211.34.149.3 -p tcp --dport 110 -j ACCEPT
iptables -A FORWARD -s 211.34.149.3 -p tcp --sport 110 -j ACCEPT
iptables -A FORWARD -d 211.34.149.3 -p tcp --dport 143 -j ACCEPT
iptables -A FORWARD -s 211.34.149.3 -p tcp --sport 143 -j ACCEPT
# Acceso a gestion SNMP
iptables -A FORWARD -s 210.195.55.15 -d 211.34.149.3 -p udp --dport 169 -j ACCEPT
iptables -A FORWARD -s 211.34.149.3 -d 210.195.55.15 -p udp --sport 169 -j ACCEPT
# Acceso a nuestra ip para gestionarlo
iptables -A FORWARD -s 210.195.55.15 -d 211.34.149.3 -p tcp --dport 22 -j ACCEPT
iptables -A FORWARD -s 211.34.149.3 -d 210.195.55.15 -p tcp --sport 22 -j ACCEPT
## Servidor IRC 211.34.149.4
# Acceso a puertos IRC
iptables -A FORWARD -d 211.34.149.4 -p tcp --dport 6666:6668 -j ACCEPT
iptables -A FORWARD -s 211.34.149.4 -p tcp --sport 6666:6668 -j ACCEPT
# Acceso a nuestra ip para gestionarlo
iptables -A FORWARD -s 210.195.55.15 -d 211.34.149.4 -p tcp --dport 22 -j ACCEPT
iptables -A FORWARD -s 211.34.149.4 -d 210.195.55.15 -p tcp --sport 22 -j ACCEPT
## Servidor NEWS 211.34.149.5
# Acceso a puerto news
iptables -A FORWARD -d 211.34.149.5 -p tcp --dport news -j ACCEPT
iptables -A FORWARD -s 211.34.149.5 -p tcp --sport news -j ACCEPT
# Acceso a nuestra ip para gestionarlo
iptables -A FORWARD -s 213.194.68.115 -d 211.34.149.5 -p tcp --dport 22 -j ACCEPT
iptables -A FORWARD -s 211.34.149.5 -d 213.194.68.115 -p tcp --sport 22 -j ACCEPT
# El resto, cerrar
iptables -A FORWARD -d 211.34.149.5 -j DROP
## Servidor B2B 211.34.149.6
# Acceso a puerto 443
iptables -A FORWARD -d 211.34.149.6 -p tcp --dport 443 -j ACCEPT
iptables -A FORWARD -s 211.34.149.6 -p tcp --sport 443 -j ACCEPT
# Acceso a una ip para gestionarlo
iptables -A FORWARD -s 81.34.129.56 -d 211.34.149.6 -p tcp --dport 3389 -j ACCEPT
iptables -A FORWARD -s 211.34.149.6 -d 81.34.129.56 -p tcp --sport 3389 -j ACCEPT
## Servidor CITRIX 211.34.149.7
# Acceso a puerto 1494
iptables -A FORWARD -d 211.34.149.7 -p tcp --dport 1494 -j ACCEPT
iptables -A FORWARD -s 211.34.149.7 -p tcp --sport 1494 -j ACCEPT
# Acceso a una ip para gestionarlo
iptables -A FORWARD -s 195.55.234.2 -d 211.34.149.7 -p tcp --dport 3389 -j ACCEPT
iptables -A FORWARD -s 211.34.149.7 -d 195.55.234.2 -p tcp --sport 3389 -j ACCEPT
# acceso a otro puerto quiza de BBDD
iptables -A FORWARD -s 195.55.234.2 -d 211.34.149.7 -p tcp --dport 1434 -j ACCEPT
iptables -A FORWARD -s 211.34.149.7 -d 195.55.234.2 -p tcp --sport 1434 -j ACCEPT
# acceso a otro puerto quiza de BBDD
iptables -A FORWARD -s 195.55.234.2 -d 211.34.149.7 -p udp --dport 1433 -j ACCEPT
iptables -A FORWARD -s 211.34.149.7 -d 195.55.234.2 -p udp --sport 1433 -j ACCEPT
echo " OK . Verifique que lo que se aplica con: iptables -L -n"
# Fin del script
Ya esta, hemos levantado un verdadero muro entre internet y el conjunto de servidores que esta
Tras el firewall. No se puede ni hacer un ping a las máquinas, salvo que se haya dado acceso total a una ip. Si quisieramos dar acceso al ping, pondríamos algo así:
Es más llevadero aplicar el DROP por defecto cuando el firewall es para la propia máquina. El primer escenario de esta manual trataba sobre este caso, ahora lo revisamos con la política por defecto drop.
#!/bin/sh
## SCRIPT de IPTABLES - ejemplo del manual de iptables
## Ejemplo de script para proteger la propia máquina
## con política por defecto DROP
## Pello Xabier Altadill Izura
## www.pello.info - pello@pello.info
echo -n Aplicando Reglas de Firewall...
## FLUSH de reglas
iptables -F
iptables -X
iptables -Z
iptables -t nat -F
## Establecemos politica por defecto
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
## Empezamos a filtrar
# El localhost se deja (por ejemplo conexiones locales a mysql)
iptables -A INPUT -i lo -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
# A nuestra IP le dejamos todo
iptables -A INPUT -s 195.65.34.234 -j ACCEPT
iptables -A OUTPUT -d 195.65.34.234 -j ACCEPT
# A un colega le dejamos entrar al mysql para que mantenga la BBDD
iptables -A INPUT -s 231.45.134.23 -p tcp --dport 3306 -j ACCEPT
iptables -A OUTPUT -d 231.45.134.23 -p tcp --sport 3306 -j ACCEPT
# A un diseñador le dejamos usar el FTP
iptables -A INPUT -s 80.37.45.194 -p tcp --dport 20:21 -j ACCEPT
iptables -A OUTPUT -d 80.37.45.194 -p tcp --sport 20:21 -j ACCEPT
# El puerto 80 de www debe estar abierto, es un servidor web.
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
iptables -A OUTPUT -p tcp --sport 80 -j ACCEPT
# Aquí están las reglas de cerrar. Como hemos comentado en la configuración
# anterior conviene tener esto escrito por si en algún momento se relaja el
# firewall y s cambia a de DROP a ACCEPT por defecto
# Cerramos rango de los puertos privilegiados. Cuidado con este tipo de
# barreras, antes hay que abrir a los que si tienen acceso.
iptables -A INPUT -p tcp --dport 1:1024
iptables -A INPUT -p udp --dport 1:1024
# Cerramos otros puertos que estan abiertos
iptables -A INPUT -p tcp --dport 3306 -j DROP
iptables -A INPUT -p tcp --dport 10000 -j DROP
iptables -A INPUT -p udp --dport 10000 -j DROP
echo " OK . Verifique que lo que se aplica con: iptables -L -n"
# Fin del script
4. Cómo depurar el funcionamiento del firewall
Programas útiles
IPTRAF. Sin duda alguna uno de los programas más prácticos para depurar el firewall es iptables, ya que con el podemos observar si la conexiones se establecen o no; es un programa de consola que es aconsejable controlar ya que muestra en tiempo real el tráfico que atraviesa nuestra máquina con todo lujo de detalles: origen/destino de ips y puertos, tráfico total o tráfico total según el interfaz de red, etc… Si vemos muchas conexiones simultaneas y nos perdemos, existe la posibilidad de aplicar filtros para captar solo aquello que nos interesa.
NMAP. La herramienta para escanear puertos por excelencia, rechace imitaciones. Es una herramienta de consola rápida, efectiva y con multitud de opciones. Podemos usarla desde máquinas ajenas a nuestra red para comprobar si realmente el firewall esta filtrando correctamente y en cierta manera para hacernos una idea de que "visión" pueden tener los hackers de nuestro sistema.
SHELL. En el propio script del firewall podemos añadir algunas opciones para descubrir fallos de sintaxis en las reglas. Claro, imaginemos que tenemos un firewall de 40 lineas y una de ellas falla cuando ejecutamos el script. ¿Cuál es? Es probable que el mensaje de error no aclare lo suficiente, por eso se puede añadir algo así al final de cada regla:
...
iptables -A INPUT -s 195.55.234.2 -j ACCEPT && echo " regla-21 ok"
iptables -A INPUT -s 213.62.89.145 -j ACCEPT && echo " regla-22 ok"
...
Si la regla se ejecuta bien mostrará el mensajito de ok.
Otra opción algo mas cutre sería ir eliminando o comentando reglas hasta dar con la regla que tiene la sintaxis incorrecta. Cabe reseñar que puede fallar una regla, pero a partir de ella el resto se ejecutan con normalidad.
Enlaces:
-Página oficial: http://www.netfilter.org
-Bibliografía
Building internet firewalls: todo un clásico
-Otros tutoriales:
En la propia web de netfilter-iptables tenemos el enlace a otros tutoriales, aunque todos ellos están en perfecto inglés.
Ejem, iptables en 21 segundos, del mismo autor que este.
Notas:
Este manual se ha desarrollado para mostrar el uso de iptables desde configuraciones simples a más complejas. Se ha elaborado con el conocimiento adquirido a base de tortas por tanto se basa en la experiencia propia. Necesita continua revisión.
Autor:
Pello Xabier Altadill Izura
Ingeniero en Informática por la UPV-EHU (http://www.ehu.es)
En su día tuvo entre sus manos el marrón de la seguridad en IBERCOM (http://www.ibercom.com ), un isp que no solo sobrevive al temporal, sino que se permite el lujo de no parar de crecer.
Si tienes alguna duda,asa por el foro de iptables: URL: http://www.pello.info/forum/iptables
© Pello Xabier Altadill Izura . www.pello.info
IPTABLES manual practico, tutorial de iptables con ejemplos
En el ejemplo de la DMZ ya se presentaba esta situación en las reglas forward de una a otra red. Para ilustrar el DROP
por defecto, vamos a mostrar la configuración del ejemplo anterior de firewall entre redes pero con política por defecto
DROP.
#!/bin/sh
## SCRIPT de IPTABLES − ejemplo del manual de iptables
## Ejemplo de script para firewall entre redes con DROP por defecto
## Pello Xabier Altadill Izura
## www.pello.info − pello@pello.info
echo −n Aplicando Reglas de Firewall...
## FLUSH de reglas
iptables −F
iptables −X
iptables −Z
iptables −t nat −F
## Establecemos politica por defecto: DROP!!!
iptables −P INPUT DROP
iptables −P OUTPUT DROP
iptables −P FORWARD DROP
## Empezamos a filtrar
## Nota: eth0 es el interfaz conectado al router y eth1 a la LAN
# A nuestro firewall tenemos acceso total desde la nuestra IP
iptables −A INPUT −s 210.195.55.15 −j ACCEPT
iptables −A OUTPUT −d 210.195.55.15 −j ACCEPT
# Para el resto no hay acceso al firewall
# En principio esta de más, pero si rebajamos los permisos temporalmente
# nos cubre las espaldas
iptables −A INPUT −s 0.0.0.0/0 −j DROP
## Ahora podemos ir metiendo las reglas para cada servidor
## Como serán paquetes con destino a otras máquinas se aplica FORWARD
## Servidor WEB 211.34.149.2
# Acceso a puerto 80
iptables −A FORWARD −d 211.34.149.2 −p tcp −−dport 80 −j ACCEPT
iptables −A FORWARD −s 211.34.149.2 −p tcp −−sport 80 −j ACCEPT
# Acceso a nuestra ip para gestionarlo
iptables −A FORWARD −s 210.195.55.15 −d 211.34.149.2 −p tcp −−dport 22 −j ACCEPT
iptables −A FORWARD −s 211.34.149.2 −d 210.195.55.15 −p tcp −−sport 22 −j ACCEPT
## Servidor MAIL 211.34.149.3
# Acceso a puerto 25, 110 y 143
iptables −A FORWARD −d 211.34.149.3 −p tcp −−dport 25 −j ACCEPT
iptables −A FORWARD −s 211.34.149.3 −p tcp −−sport 25 −j ACCEPT
iptables −A FORWARD −d 211.34.149.3 −p tcp −−dport 110 −j ACCEPT
iptables −A FORWARD −s 211.34.149.3 −p tcp −−sport 110 −j ACCEPT
22
IPTABLES manual practico, tutorial de iptables con ejemplos
iptables −A FORWARD −d 211.34.149.3 −p tcp −−dport 143 −j ACCEPT
iptables −A FORWARD −s 211.34.149.3 −p tcp −−sport 143 −j ACCEPT
# Acceso a gestion SNMP
iptables −A FORWARD −s 210.195.55.15 −d 211.34.149.3 −p udp −−dport 169 −j ACCEPT
iptables −A FORWARD −s 211.34.149.3 −d 210.195.55.15 −p udp −−sport 169 −j ACCEPT
# Acceso a nuestra ip para gestionarlo
iptables −A FORWARD −s 210.195.55.15 −d 211.34.149.3 −p tcp −−dport 22 −j ACCEPT
iptables −A FORWARD −s 211.34.149.3 −d 210.195.55.15 −p tcp −−sport 22 −j ACCEPT
## Servidor IRC 211.34.149.4
# Acceso a puertos IRC
iptables −A FORWARD −d 211.34.149.4 −p tcp −−dport 6666:6668 −j ACCEPT
iptables −A FORWARD −s 211.34.149.4 −p tcp −−sport 6666:6668 −j ACCEPT
# Acceso a nuestra ip para gestionarlo
iptables −A FORWARD −s 210.195.55.15 −d 211.34.149.4 −p tcp −−dport 22 −j ACCEPT
iptables −A FORWARD −s 211.34.149.4 −d 210.195.55.15 −p tcp −−sport 22 −j ACCEPT
## Servidor NEWS 211.34.149.5
# Acceso a puerto news
iptables −A FORWARD −d 211.34.149.5 −p tcp −−dport news −j ACCEPT
iptables −A FORWARD −s 211.34.149.5 −p tcp −−sport news −j ACCEPT
# Acceso a nuestra ip para gestionarlo
iptables −A FORWARD −s 213.194.68.115 −d 211.34.149.5 −p tcp −−dport 22 −j ACCEPT
iptables −A FORWARD −s 211.34.149.5 −d 213.194.68.115 −p tcp −−sport 22 −j ACCEPT
# El resto, cerrar
iptables −A FORWARD −d 211.34.149.5 −j DROP
## Servidor B2B 211.34.149.6
# Acceso a puerto 443
iptables −A FORWARD −d 211.34.149.6 −p tcp −−dport 443 −j ACCEPT
iptables −A FORWARD −s 211.34.149.6 −p tcp −−sport 443 −j ACCEPT
# Acceso a una ip para gestionarlo
iptables −A FORWARD −s 81.34.129.56 −d 211.34.149.6 −p tcp −−dport 3389 −j ACCEPT
iptables −A FORWARD −s 211.34.149.6 −d 81.34.129.56 −p tcp −−sport 3389 −j ACCEPT
## Servidor CITRIX 211.34.149.7
# Acceso a puerto 1494
iptables −A FORWARD −d 211.34.149.7 −p tcp −−dport 1494 −j ACCEPT
iptables −A FORWARD −s 211.34.149.7 −p tcp −−sport 1494 −j ACCEPT
23
IPTABLES manual practico, tutorial de iptables con ejemplos
# Acceso a una ip para gestionarlo
iptables −A FORWARD −s 195.55.234.2 −d 211.34.149.7 −p tcp −−dport 3389 −j ACCEPT
iptables −A FORWARD −s 211.34.149.7 −d 195.55.234.2 −p tcp −−sport 3389 −j ACCEPT
# acceso a otro puerto quiza de BBDD
iptables −A FORWARD −s 195.55.234.2 −d 211.34.149.7 −p tcp −−dport 1434 −j ACCEPT
iptables −A FORWARD −s 211.34.149.7 −d 195.55.234.2 −p tcp −−sport 1434 −j ACCEPT
# acceso a otro puerto quiza de BBDD
iptables −A FORWARD −s 195.55.234.2 −d 211.34.149.7 −p udp −−dport 1433 −j ACCEPT
iptables −A FORWARD −s 211.34.149.7 −d 195.55.234.2 −p udp −−sport 1433 −j ACCEPT
echo " OK . Verifique que lo que se aplica con: iptables −L −n"
# Fin del script
Ya esta, hemos levantado un verdadero muro entre internet y el conjunto de servidores que esta
Tras el firewall. No se puede ni hacer un ping a las máquinas, salvo que se haya dado acceso total a una ip. Si
quisieramos dar acceso al ping, pondríamos algo así:
Es más llevadero aplicar el DROP por defecto cuando el firewall es para la propia máquina. El primer escenario de esta
manual trataba sobre este caso, ahora lo revisamos con la política por defecto drop.
#!/bin/sh
## SCRIPT de IPTABLES − ejemplo del manual de iptables
## Ejemplo de script para proteger la propia máquina
## con política por defecto DROP
## Pello Xabier Altadill Izura
## www.pello.info − pello@pello.info
echo −n Aplicando Reglas de Firewall...
## FLUSH de reglas
iptables −F
iptables −X
iptables −Z
iptables −t nat −F
## Establecemos politica por defecto
iptables −P INPUT DROP
iptables −P OUTPUT DROP
iptables −P FORWARD DROP
## Empezamos a filtrar
# El localhost se deja (por ejemplo conexiones locales a mysql)
iptables −A INPUT −i lo −j ACCEPT
iptables −A OUTPUT −o lo −j ACCEPT
# A nuestra IP le dejamos todo
iptables −A INPUT −s 195.65.34.234 −j ACCEPT
iptables −A OUTPUT −d 195.65.34.234 −j ACCEPT
24
IPTABLES manual practico, tutorial de iptables con ejemplos
# A un colega le dejamos entrar al mysql para que mantenga la BBDD
iptables −A INPUT −s 231.45.134.23 −p tcp −−dport 3306 −j ACCEPT
iptables −A OUTPUT −d 231.45.134.23 −p tcp −−sport 3306 −j ACCEPT
# A un diseñador le dejamos usar el FTP
iptables −A INPUT −s 80.37.45.194 −p tcp −−dport 20:21 −j ACCEPT
iptables −A OUTPUT −d 80.37.45.194 −p tcp −−sport 20:21 −j ACCEPT
# El puerto 80 de www debe estar abierto, es un servidor web.
iptables −A INPUT −p tcp −−dport 80 −j ACCEPT
iptables −A OUTPUT −p tcp −−sport 80 −j ACCEPT
# Aquí están las reglas de cerrar. Como hemos comentado en la configuración
# anterior conviene tener esto escrito por si en algún momento se relaja el
# firewall y s cambia a de DROP a ACCEPT por defecto
# Cerramos rango de los puertos privilegiados. Cuidado con este tipo de
# barreras, antes hay que abrir a los que si tienen acceso.
iptables −A INPUT −p tcp −−dport 1:1024
iptables −A INPUT −p udp −−dport 1:1024
# Cerramos otros puertos que estan abiertos
iptables −A INPUT −p tcp −−dport 3306 −j DROP
iptables −A INPUT −p tcp −−dport 10000 −j DROP
iptables −A INPUT −p udp −−dport 10000 −j DROP
echo " OK . Verifique que lo que se aplica con: iptables −L −n"
# Fin del script
4. Cómo depurar el funcionamiento del firewall
Programas útiles
IPTRAF. Sin duda alguna uno de los programas más prácticos para depurar el firewall es iptables, ya que con el podemos
observar si la conexiones se establecen o no; es un programa de consola que es aconsejable controlar ya que muestra en
tiempo real el tráfico que atraviesa nuestra máquina con todo lujo de detalles: origen/destino de ips y puertos, tráfico total
o tráfico total según el interfaz de red, etc... Si vemos muchas conexiones simultaneas y nos perdemos, existe la
posibilidad de aplicar filtros para captar solo aquello que nos interesa.
NMAP. La herramienta para escanear puertos por excelencia, rechace imitaciones. Es una herramienta de consola rápida,
efectiva y con multitud de opciones. Podemos usarla desde máquinas ajenas a nuestra red para comprobar si realmente el
firewall esta filtrando correctamente y en cierta manera para hacernos una idea de que "visión" pueden tener los hackers
de nuestro sistema.
SHELL. En el propio script del firewall podemos añadir algunas opciones para descubrir fallos de sintaxis en las reglas.
Claro, imaginemos que tenemos un firewall de 40 lineas y una de ellas falla cuando ejecutamos el script. ¿Cuál es? Es
probable que el mensaje de error no aclare lo suficiente, por eso se puede añadir algo así al final de cada regla:
...
iptables −A INPUT −s 195.55.234.2 −j ACCEPT && echo " regla−21 ok"
iptables −A INPUT −s 213.62.89.145 −j ACCEPT && echo " regla−22 ok"
...
Si la regla se ejecuta bien mostrará el mensajito de ok.
Otra opción algo mas cutre sería ir eliminando o comentando reglas hasta dar con la regla que tiene la sintaxis incorrecta.
25
########################################################################################################
#################################### EXPLICACION IPTABLES #########################################
########################################################################################################
En este tutorial intentaremos ver los aspectos fundamentales de la herramienta Iptables. Su uso es muy flexible y complejo, y ni mucho menos intentaremos explicar toda su funcionalidad en este tutorial. Nos centraremos en cómo protejer un máquina y en el método general para establecer reglas de filtrado.
Iptables es una herramienta que utiliza Netfilter (viene en el kernel) para establecer reglas de filtrado de paquetes. Con ella podemos definir reglas que restrinjan el acceso a nuestra máquina, que nos permitan hacer nat, que nos permitan, junto con otras herramientas, implementar un QoS, etc. Es una herramienta muy compleja, y tremendamente configurable, pero aquí vamos a aprender cómo podemos establecer reglas de filtrado para filtrar por IP y por puerto los paquetes que pasen por nuestra máquina.
En iptables, tenemos varios tipos de reglas: reglas de filtrado, reglas de nat, reglas de mangle (para manipular paquetes)... Nosotros nos centraremos en las reglas de filtrado, para poder filtrar tráfico y implementar nuestro firewall.
Estas reglas se definen en la tabla filter (que es la tabla por defecto de iptables). Esta tabla tiene 3 cadenas:
INPUT: es para filtrar paquetes que vienen hacia nuestra máquina.
OUTPUT: es para filtrar paquetes generados por nuestra máquina.
FORWARD: es para filtrar aquellos paquetes que llegan a nuestra máquina pero no son para nosotros, es decir, que llegan para que nuestra máquina los reencamine.
Sintaxis básica de Iptables
La sintaxis que seguiremos para añadir reglas a cada una de las cadenas anteriores será del estilo:
iptables -t filter -A INPUT <opciones>
iptables -A INPUT <opciones>
Podemos usar cualquiera de las 2, ya que la tabla filter es la tabla por defecto. El parámetro -A se utiliza para añadir una regla a la cadena especificada justo después.
Los parámetros que utilizaremos para filtrar son los siguientes:
Nuestro primer cortafuegos con Iptables
Visto esto podemos empezar ya a diseñar nuestro cortafuegos, ya que Iptables se aprende mucho mejor viendo ejemplos que con líneas y líneas de explicacion. Lo que haremos será crear un fichero, y en él colocar una detrás de otra todas las reglas de filtrado que queramos poner, teniendo en cuenta el orden, ya que cuando una regla puede ser aplicada, se aplica esa y no se revisan el resto. Vamos a ver un primer ejemplo de script de iptables.
Supondremos que tenemos un servidor web y un ftp al que queremos dejar acceso a todo el mundo, y también un servidor mysql al que sólo queremos dejar acceso a un amigo que nos ayuda a administrar la base de datos.
#!/bin/bash
echo "Aplicando reglas del firewall..."
# Borramos las reglas que ya pudieran existir, y los contadores
iptables -F
iptables -X
iptables -Z
# Establecemos las políticas por defecto
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD DROP
### Filtrado de paquetes ###
# Permitimos acceso desde la propia máquina
iptables -A INPUT -i lo -j ACCEPT
# Permitimos acceso a los puertos 80 (web), 20 y 21 (ftp)
iptables -A INPUT -i eth0 -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -i eth0 -p tcp --dport 20:21 -j ACCEPT
# permitimos a nuestro amigo el acceso a mysql (puerto 3306)
iptables -A INPUT -i eth0 -p tcp -s 80.37.45.123 --dport 3306 -j ACCEPT
# Ahora cerramos los puertos de gestión típicos
iptables -A INPUT -i eth0 -p tcp --dport 1:1024 -j DROP
iptables -A INPUT -i eth0 -p udp --dport 1:1024 -j DROP
# Cerramos el puerto de mysql para que nadie más pueda acceder
iptables -A INPUT -i eth0 -p tcp --dpost 3306 -j DROP
# Cerramos el peurto de webmin
iptables -A INPUT -i eth0 -p tcp --dport 10000 -j DROP
Bueno, aquí termina nuestro primer ejemplo de cortafuegos. Para ver si las reglas han quedado bien aplicadas, podemos utilizar el comando:
# iptables -nL
Tambiéne s importante remarcar que sólo root puede manipular las reglas iptables, así que deberemos ejecutal script como root.
Expliquemos un poco más el script
Primero borramos todas las reglas de iptables que pudiera haber cargadas. Esto es importante si no sabemos si el operativo o alguna ejecución nuestra anterior nos han dejado reglas ya cargadas.
Lo segundo que hacemos (y muy importante) es establecer las políticas por defecto. Estas políticas definen la acción que se realizará con el paquete si ninguna regla especificada llega a cumplirse. Nosotros, por defecto, hemos aceptado todo lo de la cadena OUTPUT (dejamos salir todo), aceptamos por defecto todo lo de la cadena INPUT, ya filtraremos luego lo que no nos interese, y no dejamos pasar los paquetes de FORWARD (ya que esto solo debería permitirse en equipos que van a hacer de routers de una red). Podríamos haber establecido la política de INPUT a DROP por defecto, así no permitiríamos nada, y luego establecer reglas para permitir el acceso a todo aquello que queramos; pero eso ya va a elección de cada uno.
Luego ya empezamos a filtrar. Lo primero que hacemos es dejar a localhost acceso a todo, ya que desde nuestro PC podremos iniciar conexiones al servidor web local, etc. Estas conexiones irán por la interfaz de lo (loopback).
Luego permitimos explícitamente acceso a los puertos 20,21 y 80. Esto es necesario ya que en las siguientes reglas cerramos el acceso a los peurtos del 1 al 1024. Puede parecer contradictorio, pero tiene sentido ya que las reglas se miran en orden, y si un paqeute coincide, por ejemplo, con la regla del puerto 80, se admitirá y no se mirarán más reglas.
Seguidamente permitimos el acceso a mysql (puerto 3306) sólo a una ip en concreto (la de nuestro amigo).
Luego ya cerramos los puertos típicos de gestión (1:1024), el de webmin (10000) y el de mysql, ya que no queremos que nadie más acceda a él.
/etc/services
Habiendo entendido el script vamos a resumir los pasos que deberían seguirse a la hora de configurar un cortafuegos básico como este. Evidentemente, cualquier variación para adaptarlo a las necesidades de cada uno es perfectamente válida.
Pues esto es un script básico de iptables. Una vez lo hemos creado guardaremos el fichero y le daremos permiso de ejecución (con el comando $ chmod u+x fichero
) para poder ejecutarlo.
Una cosa importante es que las reglas de iptables no se guardan; cuando reiniciemos la máquina, esas reglas no permanecerán, así que si queremos que se apliquen las reglas cada vez que el ordenador arranque podremos poner este script como demonio, tal y como se explica en el tutorial de demonios de este mismo wiki.
Como podemos apreciar, existe una gran flexibilidad a la hora de definir reglas. Podemos hacer un firewall más o menos restrictivo en función de la política por defecto y las reglas que luego apliquemos. Este tutorial no pretendía dar, ni mucho menos, el mejor modelo a seguir para diseñar un cortafuegos; simplemente mostrar el uso de iptables para filtrar tráfico, y las muchas posibilidades que esta herramienta nos ofrece. El uso y diseño del cortafuegos está completamente abierto a las necesidades de cada uno.
########################################################################################################
##################################### CORTAFUEGOS BASICOS ###################################
########################################################################################################
A continucación vemos unos ejemplos de cortafuegos básicos. No son cortafuegos hechos para cortar y pegar, la idea es proponer diversos ejemplos para que puedas sacar tus propias conclusiones y establecer el cortafuegos de acuerdo con sus propios intereses. Cada cortafuegos debería adaptarse a unas necesidades concretas.
El primer ejemplo define un ejemplo de cortafuegos para una máquina individual:
## Vaciamos las reglas iptables -F iptables -X iptables -t nat -F ## Establecemos politicas predeterminada iptables -P INPUT ACCEPT iptables -P OUTPUT ACCEPT iptables -P FORWARD ACCEPT iptables -t nat -P PREROUTING ACCEPT iptables -t nat -P POSTROUTING ACCEPT # Aceptamos todo de localhost /sbin/iptables -A INPUT -i lo -j ACCEPT # A nuestra IP le dejamos todo iptables -A INPUT -s 192.168.0.1 -j ACCEPT # Permitimos una conexión a ssh y telnet (22 y 23) desde un equipo iptables -A INPUT -s 192.168.0.37 -p tcp --dport 22:23 -j ACCEPT # A otro le permitimos acceso FTP iptables -A INPUT -s 192.168.0.45 -p tcp -dport 20:21 -j ACCEPT # El puerto 80 (www) abierto, para un servidor web. iptables -A INPUT -p tcp --dport 80 -j ACCEPT # Y el resto, lo cerramos iptables -A INPUT -p tcp --dport 20:21 -j DROP iptables -A INPUT -p tcp --dport 22:23 -j DROP iptables -A INPUT -p tcp --dport 6001 -j DROP
## Vaciamos las reglas iptables -F iptables -X iptables -t nat -F ## Establecemos politica predeterminadas iptables -P INPUT ACCEPT iptables -P OUTPUT ACCEPT iptables -P FORWARD ACCEPT iptables -t nat -P PREROUTING ACCEPT iptables -t nat -P POSTROUTING ACCEPT ## creamos una nueva cadena iptables -N filtro ## definimos las reglas dela nueva cadena iptables -A filtro -m state --state ESTABLISHED,RELATED -j ACCEPT iptables -A filtro -m state --state NEW -i ! eth0 -j ACCEPT iptables -A filtro -j DROP # Aceptamos conexiones internas /sbin/iptables -A INPUT -i lo -j ACCEPT ## Ir a la cadena filtro desde las cadenas INPUT y FORWARD. iptables -A INPUT -j block iptables -A FORWARD -j block
## Vaciamos las reglas iptables -F iptables -X iptables -t nat -F ## Establecemos politica predeterminadas iptables -P INPUT ACCEPT iptables -P OUTPUT ACCEPT iptables -P FORWARD ACCEPT iptables -t nat -P PREROUTING ACCEPT iptables -t nat -P POSTROUTING ACCEPT # Aceptamos todo de localhost /sbin/iptables -A INPUT -i lo -j ACCEPT # A nuestra IP le dejamos todo iptables -A INPUT -s 192.168.0.1 -j ACCEPT # Permitimos una conexión a telnet y ssh (puerto 22 y 23) desde un equipo iptables -A INPUT -s 192.168.0.37 -p tcp --dport 22:23 -j ACCEPT # A otro le permitimos acceso FTP iptables -A INPUT -s 192.168.0.45 -p tcp -dport 20:21 -j ACCEPT # El puerto 80 (www) debe estar abierto, ya que es un servidor web. iptables -A INPUT -p tcp --dport 80 -j ACCEPT # Cerramos rango de los puertos privilegiados. Cuidado con este tipo de # barreras, antes hay que abrir a los que si tienen acceso. iptables -A INPUT -p tcp --dport 1:1024 -j DROP iptables -A INPUT -p udp --dport 1:1024 -j DROP # impedimos iniciar conexión en los puertos altos # (puede que ftp no funcione) iptables -A INPUT -p tcp --syn --dport 1025:65535 -j DROP # Cerramos otros puertos que estan abiertos iptables -A INPUT -p tcp --dport 3306 -j DROP iptables -A INPUT -p tcp --dport 10000 -j DROP
Una red local con salida a a internet necesita una regla que haga NAT hacia fuera (enmascaramiento en iptables).
# Activamos el reenvío para que FORWARD funcione echo 1 > /proc/sys/net/ipv4/ip_forward ## FLUSH de reglas iptables -F iptables -X iptables -t nat -F ## Establecemos politica por defecto iptables -P INPUT ACCEPT iptables -P OUTPUT ACCEPT iptables -P FORWARD ACCEPT iptables -t nat -P PREROUTING ACCEPT iptables -t nat -P POSTROUTING ACCEPT ## Nota: eth0 es el interfaz conectado a internet y eth1 a la LAN # acceso localhost /sbin/iptables -A INPUT -i lo -j ACCEPT # Al firewall tenemos acceso desde las redes locales iptables -A INPUT -s 192.168.0.0/24 -i eth1 -j ACCEPT # Ahora hacemos enmascaramiento de la red local iptables -t nat -A POSTROUTING -s 192.168.0.0/24 -o eth0 -j MASQUERADE # Cerramos el rango de puerto bien conocido iptables -A INPUT -s 0/0 -p tcp -dport 1:1024 -j DROP iptables -A INPUT -s 0/0 -p udp -dport 1:1024 -j DROP # Cerramos un puerto de gestión: webmin iptables -A INPUT -s 0/0 -p tcp -dport 10000 -j DROP
Ahora tenemos dos redes locales y una salida a a internet. Ahora necesitamos dos reglas que hagan NAT hacia fuera (enmascaramiento en iptables) y además las reglas de enrutado entre redes.
# Activamos el reenvío para que FORWARD funcione echo 1 > /proc/sys/net/ipv4/ip_forward ## FLUSH de reglas iptables -F iptables -X iptables -t nat -F ## Establecemos politica por defecto iptables -P INPUT ACCEPT iptables -P OUTPUT ACCEPT iptables -P FORWARD ACCEPT iptables -t nat -P PREROUTING ACCEPT iptables -t nat -P POSTROUTING ACCEPT ## Nota: eth0 es el interfaz conectado a internet y eth1 a la LAN # acceso localhost /sbin/iptables -A INPUT -i lo -j ACCEPT # Al firewall tenemos acceso desde las redes locales iptables -A INPUT -s 192.168.0.0/24 -i eth1 -j ACCEPT iptables -A INPUT -s 192.168.1.0/24 -i eth2 -j ACCEPT # Ahora hacemos enmascaramiento de las redes locales iptables -t nat -A POSTROUTING -s 192.168.0.0/24 -o eth0 -j MASQUERADE iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j MASQUERADE # Abrimos el puerto del servidor web iptables -A INPUT -s 0/0 -p tcp -dport 80 -j ACCEPT # Abrimos el puerto del servidor DNS iptables -A INPUT -s 0/0 -p tcp -dport 53 -j ACCEPT iptables -A INPUT -s 0/0 -p udp -dport 53 -j ACCEPT # Cerramos el rango de puerto bien conocido iptables -A INPUT -s 0/0 -p tcp -dport 1:1024 -j DROP iptables -A INPUT -s 0/0 -p udp -dport 1:1024 -j DROP # Cerramos un puerto de gestión: webmin iptables -A INPUT -s 0/0 -p tcp -dport 10000 -j DROP # configuramos el tráfico entre redes # permitimos el tráfico para el puerto 445 iptables -A FORWARD -s 192.168.0.0/24 -d 192.168.1.0/24 -p tcp -dport 445 -j ACCEPT iptables -A FORWARD -s 192.168.1.0/24 -d 192.168.0.0/24 -p tcp -dport 445 -j ACCEPT # denegamos el resto del tráfico iptables -A FORWARD -s 192.168.0.0/24 -d 192.168.1.0/24 -j REJECT iptables -A FORWARD -s 192.168.1.0/24 -d 192.168.0.0/24 -j REJECT
Esta es la forma aconsejada para configurar un cortafuegos si queremos poner énfasis en la seguridad.
## Vaciado de reglas iptables -F iptables -X iptables -Z iptables -t nat -F ## Establecemos politica predeterminada: DROP iptables -P INPUT ACCEPT iptables -P OUTPUT ACCEPT iptables -P FORWARD DROP ## Acceso desde la red ## Servidores WEB # Acceso a puertos 80 iptables -A FORWARD -p tcp --dport 80 -j ACCEPT iptables -A FORWARD -p tcp --sport 80 -j ACCEPT # Acceso a puertos 20 y 21 para ftp iptables -A FORWARD -p tcp --dport 20:21 -j ACCEPT iptables -A FORWARD -p tcp --sport 20:21 -j ACCEPT # Acceso a DNS iptables -A FORWARD -p tcp --dport 53 -j ACCEPT iptables -A FORWARD -p tcp --sport 53 -j ACCEPT iptables -A FORWARD -p udp --dport 53 -j ACCEPT iptables -A FORWARD -p udp --sport 53 -j ACCEPT ## correo electrónico # Acceso a puerto 25, 110 y 143 iptables -A FORWARD -p tcp --dport 25 -j ACCEPT iptables -A FORWARD -p tcp --sport 25 -j ACCEPT iptables -A FORWARD -p tcp --dport 110 -j ACCEPT iptables -A FORWARD -p tcp --sport 110 -j ACCEPT iptables -A FORWARD -p tcp --dport 143 -j ACCEPT iptables -A FORWARD -p tcp --sport 143 -j ACCEPT
## Vaciamos las reglas iptables -F iptables -X iptables -t nat -F ## Establecemos predeterminada iptables -P INPUT DROP iptables -P OUTPUT DROP iptables -P FORWARD DROP # permitimos el tráfico loopback iptables -A INPUT -i lo -j ACCEPT iptables -A OUTPUT -o lo -j ACCEPT # Configuramos el acceso a nuestra IP iptables -A INPUT -s 192.168.0.0/24 -j ACCEPT iptables -A INPUT -s 0/0 -p tcp --sport 1:1024 -j ACCEPT iptables -A INPUT -s 0/0 -p tcp --dport 1025:65535 ! --syn -j ACCEPT iptables -A INPUT -s 0/0 -p udp --sport 1:1024 -j ACCEPT iptables -A OUTPUT -d 192.168.0.0/24 -j ACCEPT iptables -A OUTPUT -d 0/0 -p tcp --sport 1025:65535 -j ACCEPT iptables -A INPUT -p udp -m state --state ESTABLISHED -j ACCEPT iptables -A OUTPUT -p udp -m state --state NEW,ESTABLISHED -j ACCEPT iptables -A INPUT -p tcp ! --syn -m state --state NEW -j DROP iptables -A INPUT -p tcp -m state --state ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp -m state --state NEW,ESTABLISHED -j ACCEPT # El cortafuegos es también un servidor web iptables -A INPUT -p tcp --dport 80 -j ACCEPT iptables -A OUTPUT -p tcp --sport 80 -j ACCEPT # El cortafuegos es también un servidor smtp iptables -A INPUT -p tcp --dport 25 -j ACCEPT iptables -A OUTPUT -p tcp --sport 25 -j ACCEPT
Ya hemos visto algo sobre manipulación de paquetes cuando en el ejemplo de cortafuegos incluíamos una regla para enmascarar los paquetes de la red local hacia internet. En ese caso, cada paquete procedente de la red local se modifica para sustituir su IP privada por la IP pública del gateway de forma que el paquete ya sea válido para internet.
El enmascaramiento es sólo un pequeño ejemplo de todo lo que se puede hacer y forma parte de lo que hemos denominado NAT (network address translation), aunque son posibles otras formas de manipulación.
La manipulación se podrá hacer en las cadenas PREROUTING, POSTROUTING y OUTPUT.
En el caso de PREROUTING podremos modifcar los datos destino de la conexión según nos interese y antes de tomar la deción de enrutamiento. Así podremos desviar paquetes que vayan destinados al host local hacia otro host y viceversa. Sólo tiene sentido en el interfaz de entrada. Esto lo vamos a llamar DNAT (destination NAT)..
El mismo caso se puede aplicar a la cadena OUTPUT y podermos modificar llos datos de destino de los paquetes paquetes que salen de un proceso local. En este caso sólo es aplicable en el interfaz de salida.
Cuando utilizamos la cadena POSTROUTING podremos modificar los paquetes justo antes de devolverlos a la red. Podremos modificar los datos de origen, porque el destino ya se ha decidido en una de las cadenas previas FOWRARD o OUTPUT. Como hemos visto anteriormente, este es el caso de MASQUERADE. Sólo tiene sentido en el interfaz de salida. Esto lo vamos a denominar SNAT (source NAT).
Los cambios de destino corresponden a cadena PREROUTING cuando entra el paquete para que estas modificaciones ya se pueda aplicar al decidir si el paquete se eenvía o va dirigido el sistema local. Sólo, como ya hemos visto anteriormente, se puede utilizar la opción «-i» (interfaz de entrada).
Si el paquete tiene origen local el cambio de destino tendremos que hacerlo en la cadena OUTPUT.
En pimer lugar, para el cambio de destino tenemos que usar la opción «-j DNAT», y los argumentos que dispone esta opción, «--to» para especificar una dirección y un puerto opcional. Podremos también especificar rangos de direcciones.
Vemos algunos ejemplos:
## Cambiar la dirección de destino por 192.168.0.254 iptables -t nat -A PREROUTING -i eth1 -j DNAT --to 192.168.0.254 ## Cambia la dirección de destino por 192.168.0.11 ,192.168.0.12 o 192.168.0.13 iptables -t nat -A PREROUTING -i eth1 -j DNAT --to 192.168.0.11-192.168.0.13
Suponemos que tenemos un proxy en la dirección 192.168.0.1 y el puerto 3128 para las conexiones a servidores web de internet: Con la siguiente regla en el gateway redirigiremos todas las peticiones que se realicen hacia un servidor web (puerto 80) hacia el puerto 3128 de la máquina 192.168.0.1:
## Cambia la dirección de destino del tráfico web por 192.168.0.1 en el puerto 3128 iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to 192.168.0.1:3128
Ahora suponemos que tenemos un servidor web, pero que para acelerar las conexiones todas las peticiones que se hagan las va a resolver el proxy que está en el mismo equipo pero en el puerto 3128.
## Envía el tráfico que entra dirigido al puerto 80 (web) al proxy squid (transparente)
iptables -t nat -A PREROUTING -i eth1 -p tcp --dport 80 -j REDIRECT --to-port 3128
Suponemos que tenemos una red con un gateway con la única dirección IP pública y nos interesa tener un servidor web en el interior de la red local, en el equipo 192.168.0.78. Entonces tendremos que poner:
## Envía el tráfico que entra dirigido al puerto 80 (web) al servidor web local (transparente)
iptables -t nat -A PREROUTING -i eth1 -p tcp --dport 80 -j REDIRECT --to 192.168.0.78
Los cambios de destino corresponden a cadena POSTROUTING, justo antes de que el paquete sea enviado y para que estas modificaciones no se vean afectadas por la cadena FORWARD, en su caso. Este es un detalle importante, ya que significa que cualquier otro servicio de la máquina Linux (encaminamiento, filtrado de paquetes) verá el paquete sin cambiar. Sólo podremos usar «-o» (interfaz de salida).
En pimer lugar, para el cambio de destino tenemos que usar la opción «-j SNAT», y los argumentos que dispone esta opción, «--to» para especificar una dirección y un puerto opcional. Podremos también especificar rangos de direcciones.
## Cambiar la dirección de origen por 192.168.0.4 iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to 192.168.0.4 ## Cambiar la dirección de origen a 192.168.0.4, 192.168.0.5 ó 192.168.0.6 iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to 192.168.0.4-192.168.0.6 ## Cambiar la dirección de origen por 192.168.0.4, puertos 1-1023 iptables -t nat -A POSTROUTING -p tcp -o eth0 -j SNAT --to 192.168.0.4:1-1023
El caso más utilizado de SNAT el el que denominamos «enmascaramiento» (masquerading), que se utiliza para ocultar las direcciones privadas de una red local en el acceso a internet.
No es necesario escribir la dirección de origen de forma explícita con el enmascaramiento:
## Enmascarar todo lo que salga por eth0 proveniente de la red local. iptables -t nat -A POSTROUTING -s 192.168.0.0/24 -o eth0 -j MASQUERADE
Ejemplo Enrrutador IPTables:
nano -w /etc/sysconfig/iptables-config
# Load additional iptables modules (nat helpers)
# Default: -none-
# Space separated list of nat helpers (e.g. 'ip_nat_ftp ip_nat_irc'), which
# are loaded after the firewall rules are applied. Options for the helpers are
# stored in /etc/modprobe.conf.
#IPTABLES_MODULES="ip_conntrack_netbios_ns"
# Unload modules on restart and stop
# Value: yes|no, default: yes
# This option has to be 'yes' to get to a sane state for a firewall
# restart or stop. Only set to 'no' if there are problems unloading netfilter
# modules.
#IPTABLES_MODULES_UNLOAD="yes"
# Save current firewall rules on stop.
# Value: yes|no, default: no
# Saves all firewall rules to /etc/sysconfig/iptables if firewall gets stopped
# (e.g. on system shutdown).
#IPTABLES_SAVE_ON_STOP="no"
# Save current firewall rules on restart.
# Value: yes|no, default: no
# Saves all firewall rules to /etc/sysconfig/iptables if firewall gets
# restarted.
#IPTABLES_SAVE_ON_RESTART="no"
# Save (and restore) rule and chain counter.
# Value: yes|no, default: no
# Save counters for rules and chains to /etc/sysconfig/iptables if
# 'service iptables save' is called or on stop or restart if SAVE_ON_STOP or
# SAVE_ON_RESTART is enabled.
#IPTABLES_SAVE_COUNTER="no"
# Numeric status output
# Value: yes|no, default: yes
# Print IP addresses and port numbers in numeric format in the status output.
IPTABLES_STATUS_NUMERIC="yes"
# Verbose status output
# Value: yes|no, default: yes
# Print info about the number of packets and bytes plus the "input-" and
# "outputdevice" in the status output.
#IPTABLES_STATUS_VERBOSE="no"
# Status output with numbered lines
# Value: yes|no, default: yes
# Print a counter/number for every rule in the status output.
#IPTABLES_STATUS_LINENUMBERS="yes"
#esto es todo lo nuevo
*nat
REROUTING ACCEPT [0:0]
OSTROUTING ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
-A POSTROUTING -o eth1 -j MASQUERADE
-A POSTROUTING -o eth2 -j MASQUERADE
COMMIT
*filter
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
-A INPUT -m state -state RELATED,ESTABLISHED -j ACCEPT
-A INPUT -p icmp -j ACCEPT
-A INPUT -i lo -j ACCEPT
-A INPUT -p tcp -m state -state NEW -m tcp -dport 22 -j ACCEPT
-A INPUT -p udp -m udp -dport 67 -j ACCEPT
-A INPUT -j REJECT -reject-with icmp-host-prohibited
-A FORWARD -m state -state RELATED,ESTABLISHED -j ACCEPT
-A FORWARD -s 172.16.0.0/24 -j ACCEPT
-A OUTPUT -s 172.16.0.0/24 -j ACCEPT
-A OUTPUT -s 172.17.0.0/24 -j ACCEPT
COMMIT
#########################################################################################################
IPTABLES UBUNTU
Otra opción es utilizar la herramienta iptables. En el siguiente artículo publicado por herje en http://www.ubuntu-es.org/node/422 muestra como hacerlo fácil:
Para los paranoicos, explico un modo muy simple de implementar iptables con el fin de cerrar todos los puertos que queramos de nuestro pc. Iptables es un sistema firewall muy potente incluido en el núcleo de Linux y que requiere una serie de conocimientos. Hay cientos de tutoriales en la red. Es aconsejable no setear iptables con cualquier script copiado de la red, puesto que iptables está capacitado para dejar tu sistema como se dice en román paladino abierto de piernas (desconozco si el script se hay puesto aquí es bueno o te valdrá a tí... esto es un wiki colectivo y cada red es diferente!!!). Podemos buscar otros scripts muy completos e información del funcionamiento de iptables en el manual del autoren bulma.net, aquí (inglés) y aquí (inglés), o preguntandole a google. No obstante me voy a centrar en alguien que puede ser un usuario normal y que desea lo siguiente:
En primer lugar instalamos el paquete iptables:
$ sudo apt-get install -test iptables
Ésto nos activará el servicio por defecto. Sólo queda implementar el script de iptables con nuestras reglas y hacer que se carguen al inicio.
El script que yo tengo, sin entrar en detalles viene a ser algo así, muy sencillo:
#!/bin/bash ### BEGIN INIT INFO # Provides: defaultdaemon # Required-Start: $remote_fs $syslog # Required-Stop: $remote_fs $syslog # Default-Start: 2 3 4 5 # Default-Stop: 0 1 6 # Short-Description: Start daemon at boot time # Description: Enable service provided by daemon. ### END INIT INFO #-s Especifica una dirección de origen #-d Especifica una dirección de destino #-p Especifica un prototocolo #-i Especifica un interface de entrada #-o Especifica un interface de salida #-j Especifica la acción a ejecutar sobre el paquete #--sport Puerto de origen #--dport Puerto de destino #Borrar todas las reglas iptables -F #Politica general.Cerramos todo.Dejamos entrar y salir lo solicitado iptables -P INPUT DROP iptables -P OUTPUT ACCEPT iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT ###OTRAS PROTECCIONES#### # Quitamos los pings. /bin/echo "1" > /proc/sys/net/ipv4/icmp_echo_ignore_all # No respondemos a los broadcast. /bin/echo "1" > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts # Para evitar el spoofing nos aseguramos de que la dirección # origen del paquete viene del sitio correcto. for interface in /proc/sys/net/ipv4/conf/*/rp_filter; do /bin/echo "1" > ${interface} done # Los ICMPs redirigidos que pueden alterar la tabla de rutas. for interface in /proc/sys/net/ipv4/conf/*/accept_redirects; do /bin/echo "0" > ${interface} done # No guardamos registros de los marcianos. /bin/echo "1" > /proc/sys/net/ipv4/conf/all/log_martians # Asegurar, aunque no tenga soporte el nucleo, q no hay forward. /bin/echo "0" > /proc/sys/net/ipv4/ip_forward ###Reglas de los puertos#### # Permitimos que se conecten a nuestro servidor web. #iptables -A INPUT -m state --state NEW -p TCP --dport 80 -j ACCEPT #Abrimos ssh a la red. #iptables -A INPUT -s 172.26.0.3 -p TCP --dport 22 -j ACCEPT #iptables -A INPUT -s 172.26.0.4 -p TCP --dport 22 -j ACCEPT #iptables -A INPUT -s 172.26.0.5 -p TCP --dport 22 -j ACCEPT #iptables -A INPUT -p TCP --dport 22 -j ACCEPT # Permitimos la comunicación con el servidor dns iptables -A INPUT -p UDP --dport 53 -j ACCEPT iptables -A INPUT -p TCP --dport 53 -j ACCEPT #Permitimos uso de ftp. #iptables -A INPUT -p TCP --dport 21 -j ACCEPT #Permitimos acceso pop3. #iptables -A INPUT -p TCP --dport 110 -j ACCEPT # Permitimos uso de smtp #iptables -A INPUT -p TCP --dport 25 -j ACCEPT #Permitimos acceso imap. #iptables -A INPUT -p TCP --dport 143 -j ACCEPT #iptables -A INPUT -p UDP --dport 143 -j ACCEPT #Permitimos todo el trafico de la LAN iptables -A INPUT -s 172.26.0.2 -j ACCEPT iptables -A INPUT -s 172.26.0.4 -j ACCEPT iptables -A INPUT -s 172.26.0.5 -j ACCEPT #Dejamos a localhost, para mysql, etc.. iptables -A INPUT -i lo -j ACCEPT
Lógicamente las líneas van juntas. Sólo se aplican las líneas no comentadas con # , las otras son para mi servidor.
El fichero se puede llamar por ejemplo firewall.sh , debemos darle permisos de ejecución:
$ chmod +x firewall.sh
Ahora si aplicamos el script de este modo:
$ sudo sh firewall.sh
podemos ver la salida de iptables haciendo:
$ sudo iptables -L
que viene a ser algo así:
root@platas:/home/herje # iptables -L Chain INPUT (policy DROP) target prot opt source destination ACCEPT all -- anywhere anywhere state RELATED,ESTABLISHED ACCEPT udp -- anywhere anywhere udp dpt:domain ACCEPT tcp -- anywhere anywhere tcp dpt:domain ACCEPT all -- glorioso anywhere ACCEPT all -- minime anywhere ACCEPT all -- placebo anywhere ACCEPT all -- anywhere anywhere Chain FORWARD (policy ACCEPT) target prot opt source destination Chain OUTPUT (policy ACCEPT) target prot opt source destination ACCEPT all -- anywhere anywhere state RELATED,ESTABLISHED root@platas:/home/herje #
Sólo falta hacer que las reglas se carguen al inicio, para ello copiamos el script en /etc/init.d y lo ponemos por default:
$ sudo cp firewall.sh /etc/init.d/ $ sudo update-rc.d firewall.sh defaults
Y listo con esto tenemos nuestro firewall funcionando. Agradezco cualquier aclaración, complemento etc. teniendo en cuenta que está pensado para un user casero y sin grandes pretensiones.
Filtro de mac's con iptables
Últimamente las tecnologías inalámbricas hacen necesario el uso del filtro de mac como una potente herramienta a la hora de seleccionar a quienes queremos que se conecten a nuestra red inalambrica. Esto sin embargo, no nos asegura que no puedan tener acceso, lo que si nos asegura es que tendrán que trabajar mucho más, lo que les puede costar lo suficiente como para que dejen de intentarlo. Y sin más, supondremos, para este ejemplo, que la WLAN de nuestro computador se llama ath0, y que la mac de nuestro laptop es CA:FE:DE:C0:C0, luego debemos fijarnos que nuestro firewal.sh contenga lo siguiente (obviamente también debemos fijarnos que en otras cadenas y reglas no interfiramos con lo de a continuación):
# Debemos fijarnos que la política de entrada sea # botar cualquier intento de entrada iptables -P INPUT DROP iptables -t nat -P PREROUTING DROP
la primera linea es para impedir el acceso a nuestro computador, mientras que la segunda es para impedir el acceso a otros computadores que formen parte de la red que tenemos acceso, es decir, impedir que nos utilicen como puente.
#Permitimos que salga cualquier cosa de la WLAN a la red iptables -A OUTPUT -o ath0 -j ACCEPT
#Solo permitimos que entren las siguientes mac's iptables -A INPUT -m mac --mac-source CA:FE:DE:C0:C0 -j ACCEPT iptables -t nat -A PREROUTING -m mac --mac-source CA:FE:DE:C0:C0 -j ACCEPT
Nuevamente, la primera linea es para que tengan acceso a nuestro computador, y la segunda es para permitir el acceso a otros computadores que formen parte de la red que tenemos acceso, es decir, permitir que nos utilicen como puente.
Ahora bien, si lo que queremos es que desde nuestro laptop, además de podernos conectar a nuestro computador, podamos conectarnos con la red que está conectada a la LAN del computador, que llamaremos eth0, debemos fijarnos además que exista una buena coneccion entre ath0 y eth0
#Permitimos todas las conexiones que van desde ath0 hacia eth0 iptables -A FORWARD -i ath0 -o eth0 -m state --state ! INVALID -j ACCEPT #Son permitidas sólo las conexiones ya establecidas, o relacionadas con #las conexiones ya establecidas, que vienen de eth0 y van hacia ath0 iptables -A FORWARD -i eth0 -o ath0 -m state --state ESTABLISHED,RELATED -j ACCEPT
y luego debemos indicarle al sistema que exista comunicación entre las interfaces de red (podría ser necesario hacer esto cada vez que se reinicie el sistema, por lo que se recomienda su incorporación al script firewall.sh)
$ chmod 666 /proc/sys/net/ipv4/ip_forward $ echo "1" > /proc/sys/net/ipv4/ip_forward
Por último, lo más probable es que la red que tiene acceso la LAN, eth0 del computador, tenga un firewall que imposibilite la conexión de nuestro laptop, por lo cual debemos enmascarar a nuestro laptop frente a la red, para ello debemos colocarle una mascara a todo lo que salga de la LAN eth0
#Todo lo que sale de eth0 se enmascara iptables -t nat -A POSTROUTING -o ra0 -j MASQUERADE
####################################################################################################
####################################################################################################
ejemplo Proteccion propia maquina Interna local
########## IP TABLES ############
### FLUSH de reglas
iptables -F
### Establecemos Politica por Defecto: DROP
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
### Empesamos a abrir porque todo esta cerrado
### Conexion localhost lo sin restricciones
iptables -A INPUT -i lo -j ACCEPT
### Dejamos int/out paquetes correspondientes a conexiones establecidas
### o relacionadas
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
### Permitimos las conexiones entrantes SSH (tcp/22) desde un solo PC
### La conexion proveniente de PC 192.168.0.2 y cuyo puerto destino sea 21 dar acceso
iptables -A INPUT -s 192.168.0.2 -p tcp --dport 22 -m state --state NEW -j ACCEPT
### Permitimos las conexiones entrantes HTTP (tcp/80) desde un solo PC 192.168.0.2
iptables -A INPUT -s 192.168.0.2 -p tcp --dport 80 -m state --state NEW -j ACCEPT
### Permitimos las conexiones entrantes HTTP (ftp/21) desde 192.168.0.2
iptables -A INPUT -s 192.168.0.2 -p tcp --dport 21 -m state --state NEW -j ACCEPT
iptables -A INPUT -s 192.168.0.2 -p tcp --dport 20 -m state --state NEW -j ACCEPT
### Permitimos las conexiones entrantes ICMP ping desde un solo PC
iptables -A INPUT -s 192.168.0.2 -p icmp -i eth0 -j ACCEPT
### Permitimos las conexiones salientes ICMP ping hacia PC 192.168.0.2
iptables -A OUTPUT -d 192.168.0.2 -p icmp -j ACCEPT
### Permitimos las conexiones salientes SSH hacia el servidor 192.168.0.3
iptables -A OUTPUT -d 192.168.0.3 -p tcp -j ACCEPT
Atentamente:
Franklin Campo
....Gracias....!
[editar]