Qué es y para qué sirve
Es uno de los mejores cortafuegos disponibles, incluyendo soluciones comerciales, y desde luego, la mejor solución gratuita por su potencia y versatibilidad.
Hay que apuntar que iptables es una extensión del kernel, es decir, el propio sistema se encarga de su gestión y lo que eso conlleva, para bien o para mal.
Su función consiste básicamente en analizar todo el flujo de tráfico entrante y saliente hacia/desde él y tomar unas decisiones sobre cada paquete en base a unas reglas definidas.
Cómo funcionaPara saber cómo funciona un cortafuegos hay que entender primero cómo funciona una conexión y el trafico en general. Lo comentaré muy someramente:
Cuando nos conectamos a internet nos estamos conectando a una red inmensa de ordenadores, es decir, tenemos acceso directo a todo aquel que está conectado en ese mismo momento.
Para establecer la comunicación se abren una serie de puertos de comunicación en los ordenadores en donde los programas se ponen a "hablar y escuchar" para interactuar.
- Así, por ejemplo, un ordenador que ofrece una página web (un servidor web) , se pone a escuchar y atender solicitudes en el puerto 80.
- Cuando se establece una solicitud, el servidor web dialoga con el cliente y si se cumple el proceso, la comunicación se establece y se muestra la página web.
Lo que ocurre es que los sistemas operativos actuales, e infinidad de programas, por defecto abren puertos sin notificar al usuario y por tanto estamos con unos puertos abiertos y expuestos a que alguien le dé por mirar qué es lo que ofreces sin tú saberlo.
Y justo en el proceso de comunicación, o para ser exactos, cuando se intenta establecer una conexión, es cuando entra en juego iptables, que se pone por delante de nuestros puertos y decide qué paquete de información puede pasar, según unos criterios.
Estos criterios se almacenan en unas tablas, con reglas en Orden descendente donde la última siempre será la última regla en aplicarse, antes de que se aplique la regla por defecto. Esto es así sempre que no sea interceptada por una regla anterior.
Entendedlo así, el paquete entra por la parte superior de la tabla: se encuentra con la primera regla de filtrado, se decide la acción analizando el paquete: dejarlo pasar o no. Si se deja, siguiente regla, si no, para fuera. Es así de sencillo.
Iptables consiste básicamente de tres tablas:
- tabla FILTER: usado para implementar el firewall. Aquí se produce el filtrado de paquetes.
- tabla NAT:(masquerading) para hacer que otros ordenadores se conecten a través del nuestro a una serie de servicios pero con nuestra ip, pareciendo que esas conexiones vienen de nuestro equipo.
- tabla MANGLE: sirve para alterar el estado de un paquete. No la comentaremos por ahora.
Tenemos dentro de la tabla FILTER:
- INPUT: todo el tráfico entrante
- OUTPUT: todo el tráfico saliente
- FORWARDING: para enrutar tráfico a través de nuestro ordenador hacia otro ordenador. Se supone que este tráfico no es para nosotros
Dentro de la tabla NAT tenemos:
- PREROUTING: para alterar el tráfico así como llegue a nosotros
- POSTROUTING: para alterar paquetes generados localmente antes de enrutarlos
- OUTPUT: alterar paquetes justo antes de que salgan
Si además tenemos el módulo ipt_conntrack disponible, dispondremos de herramientas para controlar el estado de la conexión. Podemos añadir entonces:
- NEW: nuevo paquete que viene hacia nosotros
- RELATED: paquetes nuevos pero que ya están relacionados con una conexión existente.
EJEMPLO: cuando usamos un ftp se abren varias conexiones para poder bajar correctamente lo que necesitamos. Si no lo activamos, sólo sería posible la primera conexión y los demás paquetes, aunque relacionados con la primera conexión, no se dejarían pasar y la transferencia se interrumpirá.
- ESTABLISHED: paquetes asociados a una conexión nueva
- INVALID: todos los demás paquetes, que no coincidan con ninguno de los estados descritos
Dónde lo consigo
Como dije arriba, iptables forma parte del núcleo y por lo tanto todo usario linux dispone de ese servicio. Si habéis montado el linux vosotros mismos, comprobad lo siguiente tecleando:
# cd /usr/src/linux; make menuconfig
Nos aparecerá un bonito menú con todas las opciones del kernel. Miramos lo que nos interesa y vamos a "networking options" y activamos:
Packet socket, netlink device emulation, network packet filtering, socket filtering y unix domain sockets, activados.
Le damos a Netfilter configuration y en el menú que nos aparece ponemos todo lo habido y por haber COMO MODULO.
Para tenerlos disponibles, salimos guardando los cambios, y básicamente se trata de compilar los módulos, es decir:
# make dep; make clean; make modules; make modules_install
Y ya tendremos diponibles todos los módulos. Sólo quedará cargarlos para hacer uso de ellos.
Cómo lo pongo a andar
ALGUNAS ORDENES BASICAS:
- iptables -F : borrado de reglas
- iptables -L : listado de reglas que se están aplicando
- iptables -A : append, añadir regla
- iptables -D : borrar una regla
EJEMPLO DE UNA REGLA
#Aceptar conexiones al puerto 80 (www) en la tarjeta eth0
iptables -A INPUT -i eth0 -s 0.0.0.0/0 -p TCP --dport www -j ACCEPT
Nomenclatura:
iptables: comando iptables
-A: append, añadir una regla. OJO, se añade al final!!
INPUT: estado del paquete (al entrar es input).
-i eth0: interfaz de red eth0
-s 0.0.0.0/0: dirección de acceso (cualquiera en este caso)
-p TCP: tipo de puerto
--dport: puerto de destino
-j ACCEPT: destino del paquete (se acepta, podrá ser DROP, LOG, REJECT, ... )
FLAGS MAS COMUNES:
-s : source address. Ej: -s 192.168.1.0/24
-d : destino. Ej: -d 84.56.73.3
-p : tipo de protocolo (TCP, UDP, ICMP). Ej: -p TCP
--sport : puerto de origen
--dport: puerto de destino
-i = -in-interface : el interfaz por el que se entra (eth0,eth1, ppp0, ... )
-o = --out-interface: el interfaz por el que se sale (eth0,eth1, ppp0, ... )
Notas:
-i se usa con reglas INPUT y FORWARD
-o se usa con reglas FORWARD y OUTPUT
Visto esto, y dado que tenemos multitud de conexiones, más aún si estamos ofreciendo servicios, deberemos introducir una multitud de comandos al iptables cada vez que arranque el núcleo, un trabajo ímprobo, de ahí que se opte por la automatización.
Por ello se crea un script, un simple archivo de texto, en el que ponemos todo lo que queramos que ejecute nuestro cortafuegos durante la carga del sistema, y programamos el Linux para que cargue el script durante arranque, olvidándonos de esta tarea tediosa.
Cómo se escribe un script para iptables
No me voy a meter ahora con scripting, al que le interese, hay abundate documentación para shell scrtipting bajo linux.Un script orientado a manejar iptables tiene sus secciones.
SECCIONES DEL SCRIPT
Siempre empiezan invocando al intérprete (un programa que lee y ejecuta el archivo), la primera línea debe ser algo como :
#!/bin/sh -> se llama a sh y éste se encarga de leer línea por línea el archivo.
Tenemos la posibilidad de declarar variables. Un ejemplo:
IPT=/sbin/iptables
EXTIF="eth1" (tarjeta de red que se conecta a internet)
INTIF="eth0" (tarjeta de que se comunica con nuestra propia red)
Así cada vez que queremos hacer mención al ejecutable /sbin/iptables, sólo tendremos que poner $IPT. MUUUUY importante no olvidarse del símbolo $ cada vez que llamemos a una variable.
A continuación insertamos los módulos que necesitamos para que funcione el script, ya que seguramente queramos utilizar el control de estado de la conexión, o usar el log. Habrá que poner algo como esto. Cada uno que lo adecúe a sus necesidades.
/sbin/modprobe ip_tables
/sbin/modprobe ip_conntrack
/sbin/modprobe iptable_filter
/sbin/modprobe iptable_mangle
/sbin/modprobe iptable_nat
/sbin/modprobe ipt_LOG
/sbin/modprobe ipt_limit
/sbin/modprobe ipt_MASQUERADE
/sbin/modprobe ipt_state
- Nos aseguraremos de que las tablas están vacías, borrando su contenido, para que no se mezcle con anteriores configuraciones.
$IPT -F
$IPT -t nat -F
$IPT -t mangle -F$IPT -X
$IPT -t nat -X
$IPT -t mangle -X
- Ponemos la acción que ejecutará por defecto cada tabla si no se cumple ninguna regla dentro de ella. Aquí que cada uno haga lo que le de la gana, os recomiendo que por defecto se tire con todo:
$IPT -P INPUT DROP
$IPT -P OUTPUT DROP
- Y ahora empezamos con lo que es el script en sí.
EJEMPLOS. Abriendo los servicios mas corrientes:
* por idoru: Las dos reglas en verde nos hace vulnerables
## El localhost (lo = 127.0.0.1) se tiene que dejar pasar ya que por defecto tiramos con todo.
$IPT -A INPUT -i lo -j ACCEPT
$IPT -A OUTPUT -o lo -j ACCEPT
# Permitir salida al 80, para poder ver páginas web
$IPT -A INPUT -i $EXTIF -p tcp --sport 80 -j ACCEPT
$IPT -A OUTPUT -o $EXTIF -p tcp --dport 80 -j ACCEPT
# Permitirsalida SMTP
$IPT -A INPUT -i $EXTIF -p tcp --sport 25 -j ACCEPT
$IPT -A OUTPUT -o $EXTIF -p tcp --dport 25 -j ACCEPT
## SALIDA FTP - Para conectar con FTPs
$IPT -A INPUT -i $EXTIF -p tcp --sport 21 -m state --state ESTABLISHED -j ACCEPT
$IPT -A OUTPUT -o $EXTIF -p tcp --dport 21 -m state --state NEW,ESTABLISHED -j ACCEPT
# ftp activo
$IPT -A INPUT -i $EXTIF -p tcp --sport 20 -m state --state ESTABLISHED,RELATED -j ACCEPT
$IPT -A OUTPUT -o $EXTIF -p tcp --dport 20 -m state --state ESTABLISHED -j ACCEPT
# ftp pasivo
$IPT -A INPUT -i $EXTIF -p tcp --sport 1024:65535 --dport 1024:65535 -m state --state ESTABLISHED -j ACCEPT
$IPT -A OUTPUT -o $EXTIF -p tcp --sport 1024:65535 --dport 1024:65535 -m state --state ESTABLISHED,RELATED -j ACCEPT
Bien, ya tenemos nuestro cortafuegos funcionando. Con esta configuración, podremos navegar, mandar emilios y conectarnos a ftp y todo lo demás simplemente se ignora. NO tenemos ningún puerto abierto.
Ahora queremos que se carguen estas reglas cada vez que se arranque el sistema.
Abrimos una consola y tecleamos:
/etc/init.d/iptables save
Que guardará las reglas que tiene iptables ahora mismo cargadas como las reglas por defecto.
Para ver vuestras reglas:
iptables -L: nos mostrará el contenido de cada tabla y sus respectivos chains.
El script que se ha publicado es vulnerable en cierta medida . Las reglas:
# Permitir salida al 80, para poder ver páginas web
$IPT -A INPUT -i $EXTIF -p tcp --sport 80 -j ACCEPT
# Permitir salida SMTP
$IPT -A INPUT -i $EXTIF -p tcp --sport 25 -j ACCEPT
además de permitir la entrada de nuestras respuestas HTTP o SMTP permiten que si alguien establece como su puerto origen el 80 o el 25 pueda conectar con cualquier puerto nuestro tcp .
Fuente: www.gulcpy.com
0 comentarios:
Publicar un comentario