Enrutamiento y filtrado Linux como router.

Asegurando tu red con Iptables – Proxy – NAT – IDS: PARTE 1
http://blog.desdelinux.net/iptables-asegurando-red-parte1
Este post intenta esclarecer un poco de como funcionan las redes y como
convertir nuestro equipo Linux en un Router que nos asegure un poco más
nuestra red, ya sea de hogar e incluso empresarial. Así que vamos al tema:
Este contenido es basado en el libro “Linux – Administración del sistema y
explotación de los servicios de red” – Sébastien BOBILLIER
Enrutamiento y filtrado
Para hablar y entender sobre el enrutamiento podemos definir primero ¿cual
es la función del router?. Para ello podemos decir que un router, además de
crear una red y permitir conexión con otros equipos (sabiendo que esto lo
podemos hacer con un AP, Switch, Hub u otros) tiene la capacidad de
conectar dos redes diferentes entre si.
Como lo podemos ver en la imagen, existe una red local “10.0.1.0” que es
creada por el router, y llega a una de sus dos interfaces. Luego el router en
su otra interfaz, tiene otra red, con su IP pública con la cual puede conectar a
Internet. La función de enrutamiento básicamente es servir de intermediario
entre estas dos redes para que puedan comunicarse.
Linux como router.
De forma natural, el Kernel de Linux ya tiene la capacidad de hacer
“forwarding”, pero por defecto viene desactivado, entonces si queremos que
nuestro linux pueda hacer este trabajo debemos ir al archivo.
/proc/sys/net/ipv4/ip_forward
Allí encontraremos que es un archivo que lo único que contiene es un cero
“0”, lo que debemos hacer es cambiarlo por un uno “1” para activar este
comportamiento. Esto por desgracia se borra cuando reiniciemos el equipo,
para dejarlo por defecto activado debemos utilizar el comando:
sysctl net.ipv4.ip_forward=1
O editarlo directamente en el archivo /etc/sysctl.conf. Dependiendo de la
distribución esta configuración también puede estar en un archivo
en /etc/sysctl.d/.
Por defecto nuestro Linux debe tener una tabla de enrutamiento, que
generalmente es la configuración de nuestra red lan y conexión con el router.
Si queremos ver este enrutamiento podemos usar dos comandos:
route -n
o
netstat -nr
Ambos comandos deberían devolver lo mismo.
En general, esta configuración es suficiente para que tu Linux sirva como
Gateway y otros equipos puedan navegar a través de nuestro equipo. Ahora
bien, si queremos que por ejemplo, nuestro Linux conecte dos o más redes
ya sean locales o no, podemos hacer uso de las rutas estáticas.
Supongamos que mi Linux tiene dos interfaces de red, en la primera tiene
salida a Internet cuya red es 172.26.0.0 y en la segunda (10.0.0.0) hay unos
equipos de otra red local. Si queremos enrutar paquetes a esa otra red
podemos usar:
route add -net 10.0.0.0 netmask 255.0.0.0 gw 172.26.0.8
De forma general es:
route add -net REDDESTINO netmask MASCARA gw IPDELLINUX
si damos route -n independientemente de que esta red exista o no, estará
fijado este enrutamiento en nuestra tabla.
Si queremos eliminar dicho enrutamiento podemos usar
route del -net 10.0.0.0 netmask 255.0.0.0
Iptables.
Básicamente iptables es usado para el filtrado de paquetes, salientes,
entrantes u otros, esto hace que se convierta en una gran herramienta para
administrar el tráfico de nuestra red. Pues iptables así como nos permite
filtrar el tráfico del mismo equipo, también permite filtrar el tráfico que
pasada a través de él. (Forwarding). Iptables puede dividirse en tablas,
cadenas, y acciones.

Tablas: básicamente pueden haber dos tablas, filter, para filtrar
paquetes y nat para traducir direcciones, es decir, para pasar de una
red a otra.

Cadenas: La cadena se refiere al tipo de tráfico que deseamos filtrar o
natear, es decir, ¿a cual tráfico vamos aplicar las tablas?. y pueden
ser: INPUT: Tráfico entrante, OUTPUT: tráfico saliente
o FORWARD: Tráfico que pasa a través de él, pero no es una conexión
propia.

También puede aparecer POSTROUTING, que se usa para tratar el
paquete de un modo determinado luego de haber sido enrutado.

Acciones: Las acciones básicamente es la acción que se va realizar
con la cadena. Esta acción puede ser DROP, que simplemente
destruye ese tráfico oACCEPT. que permite al tráfico hacer dicha
acción.
Las reglas de IPTABLES se guardan y ejecutan en el orden que fueron
creadas, y si una regla suprime a una regla anterior, siempre queda aplicada
la ultima regla en el orden.
Políticas de Cortafuegos.
En general, de forma natural los cortafuegos trabajan de dos maneras:
1. Permitir todo el tráfico excepto, o
2. No permitir ningún tráfico excepto…
Para aplicar politicas se usa IPTABLES – P CADENA ACCION
Donde la cadena representa el tipo de tráfico (INPUT, OUTPUT, FORWARD,
POSTROUTING…) y la acción es DROP O ACCEPT.
Veamos un ejemplo.
Aquí vemos que en principio pude hacer ping, luego le dije a IPTABLES que
todo el tráfico OUTPUT (Saliente) fuera DROP o no permitido. Luego le dije a
IPTABLES que lo aceptara.
Si vamos a construir un cortafuegos desde cero debemos siempre aplicar las
reglas de (No permitir ningún tráfico excepto… Para esto entonces
aplicamos las reglas
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
Si aplican estas políticas no tendrán ningún tipo de conexión
.
Para regresar escribimos lo mismo y reemplazamos DROP por ACCEPT.
En este punto, ya que todo el tráfico está denegado, comenzamos a decirle a
nuestro IPTABLES cual es el tráfico que si puede tener.
La sintaxis es:
iptables -A cadena -s ip_orgigen -d ip_destino -p protocolo --dport
puerto -j acción
Donde:
Cadena = INPUT, OUTPUT o FORWARD
ip_origen = Origen de los paquetes, esto puede ser una sola IP o una red y
en este caso debemos especificar la mascara ).
ip_destino = hacia donde se dirigen los paquetes. esto puede ser una sola
IP o una red y en este caso debemos especificar la mascara ).
protocolo = indica el protocolo que usan los paquetes (icmp, tcp, udp…)
puerto = puerto destino del tráfico.
acción = DROP o ACCEPT.
Ejemplo:
Se aplican las políticas de TODO restringido.
Luego añadimos las reglas para poder tener tráfico por el puerto 80 HTTP y
443 HTTPS, con el protocolo TCP. Luego el puerto 53 Se aplica para que el
cliente DNS pues a resolver los dominios, de lo contrario no navegarás. Esto
funciona con protocolo udp.
La linea:
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
Es por lo siguiente: Cuando haces una petición HTTP por ejemplo, tu te
conectas al puerto 80 del servidor, pero el servidor para devolverte la
información necesita conectar contigo por un puerto cualquiera.
(Generalmente superior a 1024).
Como todos nuestros puertos están cerrados esto no se logrará a menos que
abramos todos los puertos superiores a 1024 (Mala idea). Lo que esto dice es
que se acepta todo el tráfico entrante que provenga de una conexión que yo
mismo establecí. Osea una conexión que en principio yo inicié.
Al poner OUTPUT en las reglas, esto solo aplica para el equipo en cuestión, si
estamos usando nuestro equipo como router para permitir estas conexiones,
debemos cambiar OUTPUT por FORWARD. Dado que el tráfico pasa por el equipo
pero no es iniciado por él
Todas estas reglas se borran luego del reinicio, por eso hay que crear scripts para
que se inicien por defecto. Pero esto lo veremos en la próxima
Espero que esta información les haya gustado. En la próxima les hablaré de
NAT, Proxy y scripts para el Firewal.
Asegurando tu red con Iptables – Proxy – NAT – IDS: PARTE 2
http://blog.desdelinux.net/nat-iptables-asegurando-red-parte2/
En el post anterior vimos la configuración de IPTables para que funcione
como un Firewall. Ahora podemos ver como crear esos scripts para que se
ejecuten las reglas automáticamente cuando se inicie el sistema, y también
como podemos eliminar o detener esas reglas por un momento.
Antes de hacer el script y mostrarles como va quedando, hablemos un poco
de NAT y del concepto de lo que queremos hacer con este equipo.
NAT y Contexto del ejemplo.
Cuando hablamos de NAT, podemos confundir esto con enrutamiento, y es
que ambos se encargan de conectar dos redes diferentes entre sí. La
diferencia realmente radica es que el enrutamiento se aplica para pasar de
una red local a otra y esta otra red puede conectarse a un router y salir a
Internet.
Mientras que, cuando hablamos de NAT, hablamos de enrutar paquetes de
una red local o privada a una red pública o Internet. Esto lo hace
enmascarando los paquetes poniéndole la ip pública con la que sale a
Internet. Es decir, que no necesitamos un router, porque la ip pública la tiene
directamente el ordenador con GNU/Linux.
Trabajaremos esto con la consigna de que estamos usando nuestro Linux
como un router/firewall para salir a Internet desde una red local. Pero aquí
pueden aparecer dos escenarios.

Que nuestro Linux esté entre el router del proveedor de servicio y la
red local.
En este caso, entre el router y nuestro Linux habría una red, y entre el Linux
y la red local habría otra red diferente. Esto significa que nuestro router no
tendría que hacer NAT como tal, con un simple enrutamiento de tráfico como
lo explique en post anterior estaría bien.

Que nuestro Linux tenga una interfaz conectada a la red local y por la
otra interfaz reciba directamente una ip pública con la cual navega.
Esto significa que nuestro Linux debe hacer NAT para que los paquetes
puedan llegar a Internet.
Para efectos de este pequeño laboratorio entonces, diremos que nuestro
Linux recibe directamente una ip pública y así poder probar los efectos de la
NAT.
Para hacer NAT usamos entonces la sintaxis
iptables -t nat -A POSTROUTING -O eth1 -j MASQUERADE
Donde eth1 es la interfaz por donde recibimos la ip pública, osea por donde
salimos a Internet.
se usa MASQUERADE cuando la ip es pública pero puede variar con el tiempo
(dinámica). En caso contrario podemos usar SNAT –to-source ip
Creando script iptables
Supongamos entonces que: 172.26.0.0 es nuestra red local y 81.2.3.4 es la
ip pública con la que salimos a Internet. (es una ip estática). Tengo las
interfaces eth0 (Red local)
eth1 (Red pública).
Consiste básicamente en crear un script que pueda ser llamado desde
/etc/init.d/cortafuegos (por ejemplo). y desde este script poder iniciar,
detener o consultar el estado de nuestra configuración, tal y como hacemos
con cualquier demonio del sistema.
Supongamos que mis reglas IPTABLES SON:
#! /bin/bash
# Firewall de mi hogar.
# Nombre de archivo /etc/cortafuegos_on
# By Jlcmux Twitter: @Jlcmux
#
# Política básica.
iptables -P INPOUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
#
#NAT para compartir Internet desde eth0 a eth1
iptables -t nat -A POSTROUTING -O eth1 -j SNAT --to-source 81.2.3.4
#
# Permitir conexiones entrantes iniciadas por mi
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
#
# Trafico saliente autorizado
iptables -A FORWARD -i eth0 -o eth1 -p tcp --dport 80 -j ACCEPT
iptables -A FORWARD -i eth0 -o eth1 -p tcp --dport 443 -j ACCEPT
iptables -A FORWARD -i eth0 -o eth1 -p udp --dport 53 -j ACCEPT
No olvidemos dar permisos de ejecución
Explicación:
El script básicamente hace lo siguiente:
1. Primero restringe toda la navegación, conexiones y tráfico. (Políticas
básicas de Firewall)
2. Luego crea la NAT con el destino eth1. indicando le que tenemos una ip
pública estática “81.2.3.4”
3. Abre los puertos necesarios para recibir los paquetes de conexiones
iniciadas por mi.
4. Acepta el tráfico saliente de HTTP, HTTPS y DNS.
Las reglas tienen como destino el tráfico FORWARD porque estamos usando nuestro
Linux como Router, entonces las políticas se usan para el tráfico que PASA por el
Linux, osea, actúa como intermediario. Esto significa que nuestro Linux realmente
no puede navegar ni recibir ningún dato directamente. Solo se aplica para los
equipos conectados a él, pero no a él mismo
Si quisiéramos usar nuestro equipo para navegar deberíamos repetir las
lineas y cambiar FORWARD por INPUT o OUTPUT según el caso.
Script anulación.
Ahora vamos a crear un script que anule todo lo anterior y deje el equipo
limpio de todo esto. (Para efectos de pruebas o simplemente queremos
apagar el firewall).
#! /bin/bash
# Firewall de mi hogar.
# Nombre de archivo /etc/cortafuegos_off
# By Jlcmux Twitter: @Jlcmux
#
#Borrando Reglas
iptables -F
#
#Aplicando politicas por defecto (todo tráfico aceptado)
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
Automatizando.
Ahora debemos crear el script dentro de /etc/init.d/ y el servicio se inicie
automáticamente y lo podamos gestionar de una manera más cómoda.
#! /bin/bash
# Firewall de mi hogar.
# Nombre de archivo /etc/init.d/cortafuegos
# By Jlcmux Twitter: @Jlcmux
case $1 in
start)
/etc/cortafuegos_on
;;
stop)
/etc/cortafuegos_off
;;
status)
iptables -L
;;
*)
echo "Sintaxis erronea. Valido = /etc/init.d/cortafuegos start|stop|status
;;
esac
Explicación:
Este último script lo ponemos en /etc/init.d/ con el nombre cortafuegos.
Entonces si queremos gestionar el firewall podemos usar el
comando /etc/init.d/cortafuegos start. De la misma forma lo podemos
parar o ver el estado.
Ahora vamos a editar el archivo /etc/rc.local y ponemos algo
como:/etc/init.d/cortafuegos start para que se inicie con el sistema.
Pues bien. Este es la segunda parte. Espero que aporte algo a todos ustedes.
En la próxima vemos Proxy e IDS.
http://blog.desdelinux.net/iptables-para-novatos-curiosos-interesados/
http://blog.desdelinux.net/iptables-para-novatos-curiosos-interesados-2daparte/
http://www.enlinux.org/iptables-con-squid-3-1-transparente-en-gnulinuxcentos-sl-rhel/
Iptables con SQUID 3.1+ transparente en
GNU/Linux CentOS / SL / RHEL
Para iniciar se configura crea un archivo vacío;
touch iptables_intercept.sh
Creado el archivo se inserta el siguiente contenido;
Se asigna permiso de ejecución en el script;
chmod +x iptables_intercept.sh
Y se ejecuta;
sh iptables_intercept.sh
Por último se edita el archivo /etc/squid/squid.conf;
vim /etc/squid/squid.conf
Y se inserta la siguiente sintaxis;
httpd_port 3128 intercept
Se reinicia el servicio SQUID;
service squid restart
Acá el contenido del script;
!/bin/bash
# Direccion IP del SQUID
IPSQUID=192.168.1.100
# Puerto de escucha del SQUID
PUERTOSQUID=3128
# Redireccion del Puerto 80 en TCP al puerto 3128 del SQUID.
iptables -t nat -A PREROUTING -s $IPSQUID -p tcp –dport 80 -j ACCEPT
iptables -t nat -A PREROUTING -p tcp –dport 80 -j REDIRECT –to-port $PUERTOSQUID
iptables -t nat -A POSTROUTING -j MASQUERADE
iptables -t mangle -A PREROUTING -p tcp –dport $PUERTOSQUID -j DROP
http://www.tldp.org/HOWTO/TransparentProxy-5.html
5. Setting up iptables (Netfilter)
iptables is a new thing for Linux kernel 2.4 that replaces ipchains. If your
distribution came with a 2.4 kernel, it probably has iptables already installed. If
not, you'll have to download it (and possibly compile it). The homepage
is netfilter.samba.org. You make be able to find binary RPMs elsewhere, I haven't
looked. For the curious, there is plenty of documentation on the netfilter site.
To set up the rules, you will need to know two things, the interface that the to-beproxied requests are coming in on (I'll use eth0 as an example) and the port squid is
running on (I'll use the default of 3128 as an example).
Now, the magic words for transparent proxying:

iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --toport 3128
You will want to add the above commands to your appropriate bootup script
under /etc/rc.d/. Readers upgrading from 2.2 kernels should note that this is the
only command needed. 2.2 kernels required two extra commands in order to
prevent forwarding loops. The infastructure of netfilter is much nicer, and only this
command is needed.
http://www.tldp.org/HOWTO/TransparentProxy-6.html
6.3 Method One: What if iptables-box is on a dynamic IP?
If the iptables-box is on a dynamic IP address (e.g. a dialup PPP connection, or a
DHCP assigned IP address from a cable modem, etc.), then you will want to make
a slight change to the above commands. Replace the second command with this
one:

iptables -t nat -A POSTROUTING -o eth0 -s local-network -d squid-box -j
MASQUERADE
This change avoids having to specify the IP address of iptables-box in the
command. Since it will change often, you'd have to change your commands to
reflect it. This will save you a lot of hassle.