NetFilter / IPTables IV

Antes de comenzar te recomiendo ver los post anteriores ( NetFilter / IPTables I, II, III, V)

IPTables el un amigo del usuario

Esta entrega sobre Netfilter / Iptables, vamos a dejar atras ya a las cadenas y las tablas, para centrarnos un poco mas en los comandos para ingresar, borrar, remplazar y ordenar las reglas y  la primera parte de los Matchs!

Sentencia de muerte!

Hace tiempo venimos ‘tuneando’ nuestro firewall y estamos muy conformes, sin embargo, hay cosas que aun no sabemos hacer y quedaremos encantados cuando conozcamos como usarlas.

Para adentrarnos en el tema, tenemos que ver cual es la forma en que usamos iptables por costumbre:

iptables [ -t table ] command [ match ] [ target ]

donde
[ -t table ]: table puede ser filter, nat, mangle o raw, lo vimos en el articulo anterior

command: Indica que es lo que queremos hacer con la regla (hasta ahora usamos -A y -I para insertar las reglas en un cadena, pero se puede hacer mas que eso.

[ match ]: Son las condiciones que debe reunir un paquete para quedar ‘atrapado’ en esa regla, y por consiguiente dispararse hacia el correspondiente objetivo (target)

[ target ]: Es la definición de que es lo que haremos con los paquetes que coincidan con la regla

Como vemos hay una sola restricción en cuanto a la sintaxis de iptables, y es que ‘comando’ debe estar primero que todo o a lo sumo, después de  «-t table». Si bien podemos  ‘desordenar’ el orden de las opciones que estan entre paréntesis, no se recomienda, ya que es complicado de leer.

Sobre lo que incumbe a «-t table», ya podemos darnos por satisfecho, pero como podrían pensar, si las demás opciones son igual o mas profundas que el «-t table», sabremos que hay mucho por ver.

«Un camino de mil leguas, se comienza con el primer paso»

Estudiemos que se puede hacer desde «command»:

Un comando, tiene dos partes, una acción y una cadena donde se realiza la acción, y esto es muy tangible cuando miramos el siguiente comando:

iptables -t filter -A INPUT -s 192.168.0.0/24 -j ACCEPT

El comando, seria «-A INPUT», donde «-A» pide que la regla se inserte en la cadena INPUT
Si quisiéramos borrarla,  de la misma forma que en muchos routers, para borrar una regla, hay que escribirla nuevamente indicando que queremos borrar esa regla.

iptables -t filter -D INPUT -s 192.168.0.0/24 -j ACCEPT

Este es un momento importante para recordar, que en NetFilter, es importantísimo el orden que ingresamos las reglas.
Por lo cual, veremos que el «-A» simplemente agrega una regla a la cadena, en el último lugar, haciendo de cada cadena un FIFO (First In, First Out, Primero ingresado Primero en salir) por así decirlo.
Y ya vimos que podemos querer insertar un regla primero que todas las demás, para lo cual usábamos «-I»

iptables -t filter -I INPUT -s 192.168.0.0/24 -j ACCEPT

Esto es casi todo lo necesario, para manejar nuestras reglas, sin embargo sería mejor tener un manejo mas ordenado de las reglas.

Pues desde iptables podemos manejar las reglas con números de identificación, y tan solo para probar que esto es cierto podemos hacer lo siguiente:

Onix:~# iptables -t filter -A INPUT -s 192.168.0.0/24 -j ACCEPT
Onix:~# iptables -t filter -A INPUT -s 10.0.0.0/24 -j ACCEPT
Onix:~# iptables -t filter -S INPUT
-P INPUT ACCEPT
-A INPUT -s 192.168.0.0/24 -j ACCEPT
-A INPUT -s 10.0.0.0/24 -j ACCEPT
Onix:~# iptables -D INPUT 1 #En esta linea borramos la regla numero 1 de la cadena input
Onix:~# iptables -t filter -S INPUT
-P INPUT ACCEPT
-A INPUT -s 10.0.0.0/24 -j ACCEPT #Aqui vemos que solo quedo la segunda linea

Así mismo, con la opción «-I» podemos elegir el numero de orden donde será insertada la regla:
(continuando con el ejemplo anterior)

Onix:~# iptables -t filter -I INPUT -s 10.0.0.1 -j DROP #Insertamos la regla primero que todas
Onix:~# iptables -t filter -I INPUT 2 -s 10.0.0.2 -j DROP #Insertamos en segundo lugar
Onix:~# iptables -t filter -I INPUT 3 -s 10.0.0.3 -j DROP # etc..
Onix:~# iptables -S INPUT
-P INPUT ACCEPT
-A INPUT -s 10.0.0.1/32 -j DROP
-A INPUT -s 10.0.0.2/32 -j DROP
-A INPUT -s 10.0.0.3/32 -j DROP
-A INPUT -s 10.0.0.0/24 -j ACCEPT
Para finalizar este punto, podemos observar que existe una opción que sirve para el remplazo:
Onix:~# iptables -t filter -R INPUT 2 -s 10.0.0.5 -j DROP
Onix:~# iptables -S INPUT
-P INPUT ACCEPT
-A INPUT -s 10.0.0.1/32 -j DROP
-A INPUT -s 10.0.0.5/32 -j DROP # Aqui vemos como el reemplazo fue efectivo
-A INPUT -s 10.0.0.3/32 -j DROP
-A INPUT -s 10.0.0.0/24 -j ACCEPT
 

 

Bien, ya hicimos el primer paso, vamos con el segundo:

Esta es la parte mas divertida, al menos para mi.

Los matches, son las condiciones que el paquete tiene que ‘matchear’ para que el paquete

‘atrapado’ en la regla. Si bien habría mucho leña para cortar aquí, no puedo detenerme en explicar los conceptos que se deben manejar sobre los protocolos (IP, TCP, UDP, ICMP), por lo cual, lo que a estos sea

referente, me restringiré a mencionarlo solamente.
Matches Genericos:
-p o –protocol : Número o nombre del protocolo, para saber el numero habrá que mirar /etc/protocols,

ya dijimos que las opciones son 4, tcp, udp, icmp y all, que involucra a los 3 anteriores. Vale usar el ! para denotar ‘lo contrario’, es decir si escrivo «! udp» quiere decir todo lo que no sea udp, osea tcp y icmp.
-s o –source : Orgien IP del paquete, se puede usar una IP, una red con notacion CDIR o bien un dominio, pero, tengamos en cuenta, que lo que se carga en las reglas es el numero IP resulto a la hora de ingresar la regla, dado que seria imposible que se resuelva en cada paquete que reciva o envie la pc. Vale usar «!».
-d o –destination : Funciona de la misma manera que -s solo que matche sobre la dirección de destino.
-i o –in-interface : Verifica si el paquete ingresó por la interfaz pasad como argumento, solo sirve en las cadenas INPUT, FORWARD y PREROUTING, lo que es lógico. Vale usar «!».
-o o –out-interface : Al igual que -i pero sobre la interfaz de salida, y solo vale para OUTPUT, FORWARD y POSTROUTING. Es importante aclarar que especifica las interfaces de entrada y salida permite poner una barrera mas a un ataque spoofeado.
-f o –fragment :  Cuando se fragmenta un paquete, dependiendo del protocolo, no contiene en su cabezera toda la información necesaria, para que quede atrapado en algunas reglas de NetFilter, para eso se creo este match, pero es importantisimo saber que mientras . Sin embargo, ecepto que uses la tabla raw para macthear NOTRACK, NetFilter no detectara los paquetes fragmentados.
Matches para protocolos (debe existir «-p tcp» o «-p udp» para que valga )
–sport o –source-port : Indica que puerto de origen debe tener, se puede utilizar rangos, por ejemplo son validos: 80 (puerto 80), 1:1023 (puerto desde el 1 al 1023), 1025: (desde el 1025 al 65535), :21 (desde el 0 al 21), y vale usar «!» que indicará todo lo contrario.
–dport o –destination-port : Igual que –sport (eceptuando que no maneja rangos cuando se usa «-p tcp, esto se debe hacer con otra opcion que veremos mas adelante, pero si funciona con «-p udp»).
–tcp-flags (solo con «-p tcp», requiere conocimientos de TCP ): Este match nos permite matchear paquetes con ciertas configuracioens de flags activados/desactivados.

Como funciona?

Primero que nada los flags posibles son: SYN, ACK, PSH, RST, FIN (de forma especial se puede usar ALL para indicar todas las flags, o NONE para indicar ninguna)

Para usar –tcp-flags primero se indica las flags que Netfilter revisará, y luego, se indican las flags que pretendemos esten activadas para que entren en la regla.

Ejemplo, si queremos DROPear solo los paquetes que contengan el flag SYN activado, se usaría:

iptables -A INPUT -p tcp –tcp-flags ALL SYN -j DROP, o bien

iptables -A INPUT -p tcp –tcp-flags SYN,ACK SYN -j DROP.

O si quisieramos matchear un paquete que no tenga ningun flag activado (el cual es invalido):

iptables -A INPUT -p tcp –tcp-flags ALL SYN,ACK,PSH,RST,FIN
–tcp-options : Este match, busca matchea por el largo de los bits usados para ‘options’ en la cabecera TCP, aclaro que NetFilter no lee las opciones, solo matchea por el largo. Vale usar «!».

iptables -A INPUT –tcp-options 8 -j DROP, dropea todas los paquetes que tengan 8 bits usados par las opciones.
Para icmp («-p icmp»)
–icmp-type : Con iptables -p icmp –help, obtenemos una lista de los tipos de paquetes icmp.
Todos estos matches, son implicitos, es decir, no hace falta indicar que se use un modulo especial, para que los matches funcionen. Existen otros matches, que deben ser cargados con la opción -m o –match.
Estos son: ttl, dscp, multiport, tos, recent, tcpmss, ah/esp, state, owner, packet type, mark, mac, limit, length, ip range, helper, ecn, conntrack.

Luego de estos, estan los modulos de extensiones que se pueden cargar con patch-o-matic….

Como les dije, vamos por el segundo paso y aún hay mucho por recorrer!
Hasta el próximo! agradesco sus comentarios y acepto cualquier corrección ( de conceptos o de ortográfia 😀 )
/* A partir de marzo nos estamos mudando a http://netsecure.com.ar o http://www.netvulcano.com.ar */