IPTABLES
Presentare, en
esta oportunidad un caso de
implementación de una protección perimetral para poder aislar técnicamente las
redes internas de una empresa de las redes externas que llegan a los servidores
de estas mismas.
Presentaremos el caso de la
siguiente manera.
Tenemos una empresa del rubro X
que necesita “securizar” sus sistemas, bloqueando accesos no autorizados a sus
plataformas de trabajo internas (Equipos de oficina, notebooks, etc).
La empresa posee sus servidores
web, dentro de las mismas dependencias donde se encuentran los equipos de
trabajo, solo separados por un piso, esto servidores están montados y agrupados
en una sala especialmente acondicionada para ello, con sistemas respaldo de
energía (SAI’S) , torres de enfriamiento (los equipos informáticos generan
mucho calor, el cual hay que disiparlo.), equipos de respaldo (en SAS, o en
cinta, etc).
La empresa quiere que algunos de
sus servidores estén disponibles para la intranet y también para internet, pero
otros servicios solo sean accesibles mediante algunas reglas y/o condiciones
especiales.
¿Cómo podemos satisfacer
el requerimiento de la empresa, de forma eficiente y sin tener excedernos de
presupuesto?
Bien, aquí es donde entra la
garantía del software libre, tenemos varias opciones desde el lado de UNIX puro
y duro en sus versiones BSD (Packet Filter) y desde Linux el archi-conocido
iptables.
En este caso nos decantaremos por
IPTABLES , por su simplicidad y efectividad.
Bien, ¿que necesitamos?
Un equipo (cualquier pc con más
de dos interfaces de red.).
Se recomienda que este equipo sea
más menos potente si se le desea agregar
más servicios (SQUID, balanceo de Carga, gestión de BW y QoS, etc)
Conviene saber, que es lo que son
las iptables, daremos un pequeño resumen y un enlace a esa información para
poder entender la idea de ello.
IPTABLES
Las Iptables es un módulo dentro
del Kernel de Linux que está diseñado para interceptar la información,
constatarla con las reglas que posee y luego tratarla según corresponda.
Se basa en regla de aceptación
(ACCEPT) , negación o descarte (DROP) y trasferencia (FORWARD) tiene más
opciones pero estas son las generales. Se recomienda encarecidamente acceder a
la información detalla de lo que hace IPTABLES. Recomiendo el linka hacia
Wikipedia donde habla de ello.
http://es.wikipedia.org/wiki/Netfilter/iptables
.
MANOS A LA OBRA:
Teniendo nuestra maquina lista y
con Linux instalada, comenzamos:
Nos basaremos en la siguiente
topología.
En mi caso usare la última
versión estable de mis distro favorita
(Debian Squeeze 6.0)
Y dos switch, uno para la red
interna y otro para la red externa DMZ.
Nuestro equipo tiene 3 interfaces
de red (eth0, para la principal conectada a internet, eth1 para nuestra red
interna, y eth2 para nuestra red DMZ, donde están los servidores.)
El router estará en modo Bridge,
ya que enrutaremos con el equipo Linux.
Comenzamos con la instalación y
configuración del sistema.
Configurando las tarjetas de RED
Primero debemos configurar las
interfaces de red, la primera (eth0) la dejaremos por DHCP y el resto con ip
fija dependiendo del direccionamientos que hemos planeado.
# The primary
network interfaceauto eth0
iface eth0 inet
dhcp
auto eth1
iface eth1 inet static
address 192.168.1.1
netmask 255.255.255.0
auto eth2
iface eth2 inet static
address 10.0.0.1
netmask 255.255.255.0
Luego ejecutamos el siguiente comando para reiniciar he
inicializar las tarjetas de red con esa configuración.
Configurando
un servidor DHCP
Para las dos redes crearemos un spool DHCP para evitar tener
que configurar manuelamente cada equipo que salga a la red.
Para eso ejecutamos el siguiente comando.
sudo apt-get
install dhcp3-server
Una vez instalado. dará un error de syslog, pero tranquilos
no es nada malo, ese eror o fail lo da por que no está configurado aun.
Ahora vamos a configurar nuestro servidor.
Iremos al directorio de y trabajo del Servidor DHCP ubicado
en /etc/dhcp/
Y modificamos a gusto según los parámetros y criterios que
tenemos para asignar ip a nuestros clientes.
Este ejemplo de las interfaces que tengo configuradas y por
donde dar IP a los clientes.
#primera red
subnet
192.168.1.0 netmask 255.255.255.0 {
range 192.168.1.5 192.168.1.10;
option routers 192.168.1.1;
option
domain-name-servers 192.168.1.1;
option
domain-name "it2-clients.net";
default-lease-time
600;
max-lease-time
7200;
}
#segunda red
subnet 10.0.0.0
netmask 255.255.255.0 {
range 10.0.0.5 10.0.0.10;
option routers 10.0.0.1;
option
domain-name-servers 192.168.1.1;
option
domain-name "it2-server.net";
default-lease-time
600;
max-lease-time
7200;
}
Luego activaremos o declararemos las interfaces (Tarjetas de
Red) que entregaran DHCP.
Para eso editamos el archivo.
Y agregamos las interfaces, en este caso (eth1 y eth2)
#Separate
multiple interfaces with spaces, e.g. "eth0 eth1".
INTERFACES="eth1
eth2"
Cerramos el archivo y reiniciamos el servicio Server-dhcp
Deberíamos disponer de dhcp.(pruébalo conectando otra máquina
y déjala que tome dhcp desde el servidor).
Activando
el IP FORWARD
Activaremos el reenvío de paquetes para que se puedan
comunicar las interfaces.
Lo cambiamos sobre la marcha
Activaremos el NAT, para poder realizar las pruebas, cuando más
adelante fijemos las reglas lo volveremos a poner, pero de manera “definitiva”.
iptables -t nat
-A POSTROUTING -o eth0 -j MASQUERADE
Bien Ahora si va todo como la seda, deberíamos ver todas las
redes y hacer ping de un lado al otro sin problemas.
Configurando
IPTABLES
Pasamos al siguiente paso que es el de configurar el
cortafuegos, pondremos una serie de reglas para que podamos resolver la topología,
obviamente debes ir agregando o modificando según tus necesidades
En la terminal pondremos las reglas que tomara el kernel
para hacer el filtrado de paquetes.es importante ser lo suficientemente
ordenado para no tener problemas.
Limpiando
Reglas Antiguas.
Bien primero que nada limpiaremos las reglas anteriores que
pudiesen haber.
Con lo siguiente:
Con esto estamos en condiciones de agregar nuevas reglas que
nos ayudaran en el trabajo. Aquí viene algo muy importante.
Existen don formas (pueden haber más) de realizar un firewall
con iptables, la primera consiste en denegar
todo (que no pase nada para ningún lado)con DROP y luego nosotros vamos agregándole las excepciones una a una,
y la segunda que todo lo contrario, que aceptemos
todo (ACCEPT) y luego denegamos mediante reglas lo que no queramos que
tenga acceso. Todo depende de dónde y cómo usemos la red
DROP por defecto:
ACCEPT por Defecto:
Yo para este ejercicio lo realizare mediante ACCEPT.
Para no tener que estar poniendo cada vez que se reinicia el
equipo cada regla, podemos crear un script, el cual automatizara el proceso de
carga de las reglas.
Creando un
Script para cargar las reglas.
Bien primero creamos un archivo en algún sector del disco,
Dentro de él, procederemos a poner las reglas, copiare todo
el contenido , con una descripción para que sea más entendible.
#############################################################################
#!/bin/sh
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
#Contenido web
desde fuera
iptables -t nat
-A PREROUTING -i eth0 -p tcp --dport 80 -j DNAT --to 10.0.0.5:80
# Los accesos de
un ip determinada HTTPS se redirigen e esa
iptables -t nat
-A PREROUTING -i eth0 -p tcp --dport 443 -j DNAT --to 10.0.0.5:443
# El localhost
se deja (por ejemplo conexiones locales a mysql)
iptables -A
INPUT -i lo -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
# Al firewall
tenemos acceso desde la red local
iptables -A
INPUT -s 192.168.1.0/24 -i eth1 -j ACCEPT
# Ahora hacemos
enmascaramiento de la red local y de la DMZ
#activamos el
BIT DE FORWARDING
iptables -t nat
-A POSTROUTING -s 192.168.1.0/24 -o eth0 -j MASQUERADE
iptables -t nat -A POSTROUTING -s 10.0.0.0/24 -o eth0 -j MASQUERADE
# Con esto
permitimos que otras máquinas puedan salir a traves del firewall.
echo 1 >
/proc/sys/net/ipv4/ip_forward
#Acceso al FW a
travez de SHH desde un equipo de la red interna y uno de la #externa
iptables -A
INPUT -s 172.16.38.70 -p tcp --dport 22 -j ACCEPT
iptables -A OUTPUT -d 172.16.38.70 -p tcp --sport 22 -j ACCEPT
iptables -A
INPUT -s 192.168.1.5 -p tcp --dport 22 -j ACCEPT
iptables -A OUTPUT -d 192.168.1.5 -p tcp --sport 22 -j ACCEPT
#Agregamos reglas para que podamos ver nuestros DNS y
resolver
iptables -A
INPUT -s 10.38.0.10 -p udp -m udp --sport 53 -j ACCEPT
iptables -A OUTPUT -d 10.38.0.10 -p udp -m udp --dport 53 -j ACCEPT
iptables -A
INPUT -s 192.168.100.10 -p udp -m udp --sport 53 -j ACCEPT
iptables -A OUTPUT -d 192.168.100.10 -p udp -m udp --dport 53 -j ACCEPT
#permitimos
acceso a web desde la red Interna
iptables -A
FORWARD -s 192.168.1.0/24 -d 10.0.0.5 -p tcp --sport 1024:65535 --dport 80 -j
ACCEPT
iptables -A FORWARD -s 10.0.0.5 -d 192.168.1.0/24 -p tcp --sport 80 --dport
1024:65535 -j ACCEPT
## permitimos
abrir el Terminal server de la DMZ desde la LAN
iptables -A
FORWARD -s 192.168.1.5 -d 10.0.0.5 -p tcp --sport 1024:65535 --dport 3389 -j
ACCEPT
iptables -A FORWARD -s 10.0.0.5 -d 192.168.1.5 -p tcp --sport 3389 --dport
1024:65535 -j ACCEPT
# luego:
# Cerramos el acceso de la DMZ a la LAN
iptables -A
FORWARD -s 10.0.0.0/24 -d 192.168.1.0/24 -j DROP
## Cerramos el
acceso de la DMZ al propio firewall
iptables -A INPUT -s 10.0.0.0/24 -i eth2 -j DROP
## Y ahora
cerramos los accesos indeseados del exterior:
# 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
echo " OK
"
echo
"Verifique que lo que se aplica con: iptables -L -n"
#############################################################################
Luego le damos permisos de ejecución
Y listo podemos agregarlo al inicio para que cada vez que inicie
el sistema, también cargue las reglas.
Tenemos configurado y en ejecución nuestro firewall en Linux. Y
tendremos mejor oportunidades que los chicos malos no entren en nuestras
maquinas.(Black Hat)
Les dejo la versión en PDF del mismo post, para que la usen sin problemas, recuerden solo citar la fuente:
