PDF de programación - Informe que les puede servir a todos aquellos que tengan ganas de armar un router en Linux

Introducción

Como todos sabemos, mucha gente se anima a armar servidores propios en
distintas distros de Linux. Hoy en día le toca el turno a Ubuntu como la más
popular. No todo en el mundo Linux es tan complejo como a veces parece ni como
quieren algunos que parezca, y para eso voy a tratar de hacer esta mini guía lo
más entendible posible para que se vea algo de la simplicidad que conlleva este
sistema bajo su imagen "dura". De todos modos se requieren algunos
conocimientos sobre lo que es un router, reglas de filtrado, etc.

Debido a la complejidad natural de iptables, que es el paquete que se encarga del
filtrado de los paquetes, las reglas y configuraciones del iptables las vamos a poner
en un script bash (uno de los shell más populares de Linux) para definirlas.

Configuración de hardware y de red

Antes de empezar a codificar nuestro propio router necesitamos dejar la base del
hardware lista para arrancar. Los requerimientos del sistema son prácticamente
nulos: podemos usar una 486 o un Pentium 120 si queremos. Los requerimientos
de memoria ni los nombramos porque ni siquiera importan. Solo se necesita que el
sistema operativo arranque y será capaz de ejecutar las reglar de ruteo que
nosotros definamos. Esto se da así en Linux debido a que esta característica está
implementada a nivel del kernel.

Ya que el ruteo se va hacer entre dos redes vamos a necesitas dos placas de red
como mínimo. En una vamos a conectar el cable del modem de ADSL o cualquier
banda ancha que usemos y la vamos a denominar Red Externa. La otra placa de
red la vamos a conectar a nuestra Red Interna, sea un switch o un hub o lo que
tengamos.

Para darle un poco de versatilidad al router vamos a habilitarle el servidor DHCP
para que asigne automáticamente las direcciones IP a los equipos que conectemos
a nuestra red y no tengamos que acordarnos de setearlas manualmente.

Algo acerca de tables, chains y processing

Antes de empezar a escribir las reglas de filtrado del firewall voy a dar una breve
explicación sobre como trabaja iptables actualmente.

Hay 3 tables principales: filter, NAT y mangle. La table más fácil es la mangle. Es
responsable de la capa de calidad de servicio (pueden buscar las capas del modelo
OSI para una referencia sobre capas y no la incluyo acá porque tendría que
terminar escribiendo un libro completo), y es la que altera las cabeceras de los
paquetes de datos TCP para acomodarlos a sus necesidades. Como no vamos a
configurar QoS (quality of service) en el router no voy a usar esta table.

La segunda table es NAT. Esta table se encarga de traducir las direcciones que
viene en la cabecera de los paquetes. Por defecto tiene dos "chains": PREROUTING
y POSTROUTING. Estos nombres son bastantes descriptivos, una se procesa antes
y la otra después de la traducción NAT. Un chain no es más que una secuencia de
reglas que pueden darse o no. Si una regla se cumple el firewall toma una acción
específica definida en sus reglas. Las acciones pueden incluir, entre otras, ACCEPT,
DROP, REJECT, etc.

La tercera, filter, es la única responsable del filtrado de paquetes propiamente
dicho. Consiste de tres chains: INPUT, OUTPUT y FORWARD, la cuales definen que
pasará con el paquete de datos una vez que pase por cada una de ellas. Todo esto

significa que el firewall va al chain INPUT, todos los datos provenientes del firewall
pasan por OUTPUT y todos los datos por último se envían a través del firewall a
toda la red por medio del chain FORWARD.

Las reglas de cada table y sus chains constituyen los bloques de todos los scripts de
iptables. Empiezan por la declaración de un par de variables que se usarán más
adelantes en el script, se setean algunos parámetros para el sistema, se definen las
reglas del firewall y se abren los puertos necesarios para hacer el forwarding de los
datos.

Vamos a construir un script básico de iptables mostrando cada una de las partes de
la mejor manera posible pero no es una solución de copy & paste para todos los
casos ya que como es evidente cada caso puede ser diferente. Es decir, voy a dar
las bases de la construcción del script para que después cada uno pueda meter
mano y jugar con las reglas y adaptarlas a sus necesidades particulares.

Bueno, ahora si a empezar. Abran su editor de texto preferido y a meter mano.
Primero las declaración de las variables que vamos a usar.

# Primero definimos las interfaces (red interna y externa)

EXTIF="eth0"

INTIF="eth1"

# Loop device/localhost

LPDIF="lo"

LPDIP="127.0.0.1"

LPDMSK="255.0.0.0"

LPDNET="$LPDIP/$LPDMSK"


# Servidores IP internos (estáticos)

#SERVERIP=10.0.1.2


# Path a las herramientas de texto

IFC="/sbin/ifconfig"

G="/bin/grep"

SED="/bin/sed"

AWK="/usr/bin/awk"

ECHO="/bin/echo"

export LC_ALL="en"


# Seteos de las variables de la interface externa

EXTIP="`$IFC $EXTIF|$AWK /$EXTIF/'{next}//{split($0,a,":");split(a[2],a," ");print
a[1];exit}'`"

EXTBC="`$IFC $EXTIF|$AWK /$EXTIF/'{next}//{split($0,a,":");split(a[3],a," ");print
a[1];exit}'`"

EXTMSK="`$IFC $EXTIF|$AWK /$EXTIF/'{next}//{split($0,a,":");split(a[4],a," ");print
a[1];exit}'`"

EXTNET="$EXTIP/$EXTMSK"



# Seteos de las variables de la interface interna

INTIP="`$IFC $INTIF|$AWK /$INTIF/'{next}//{split($0,a,":");split(a[2],a," ");print
a[1];exit}'`"

INTBC="`$IFC $INTIF|$AWK /$INTIF/'{next}//{split($0,a,":");split(a[3],a," ");print
a[1];exit}'`"

INTMSK="`$IFC $INTIF|$AWK /$INTIF/'{next}//{split($0,a,":");split(a[4],a," ");print
a[1];exit}'`"

INTNET="$INTIP/$INTMSK"

Lo principal en este fragmento de código son las variables EXTIF (EXTernal
InterFace) e INTIF (INTernal InterFace). Acá definimos que interface (placa de red)
se conecta a cada red. EXTIF sería internet e INTIF la red local. Otra parte
importante es la sección de Servidores IP Internos. Si hay servicios específicos en
nuestra red que necesiten forwarding de puertos definimos las IP en esta sección
(alguien dijo eMule?).

Después se cargan algunos módulos del kernel necesarios (acuérdense que esto en
Linux se implementa por Kernel) para habilitar la traducción NAT. NAT maneja la
función de ruteo de la máquina. Cuando llega un paquete a la interface externa
dirigido a una máquina de la red interna, la dirección IP de destino se modifica por
la table NAT. Esto se hace así porque el destino original del paquete es la dirección
de la interface externa y necesitamos hacer llegar el paquete al destino correcto
dentro de nuestra red. NAT significa Network Address Translation.

# Carga de módulos del kernel

modprobe ip_conntrack

modprobe ip_conntrack_ftp

modprobe ip_nat_ftp

modprobe ip_nat


# Habilitamos forwarding

echo 1 > /proc/sys/net/ipv4/ip_forward


# Habilitamos NAT (MASQUERADE)

iptables -t nat -A POSTROUTING -o $EXTIF -j MASQUERADE

Ahora estamos listos par definir las reglas del firewall.

Cerrando las puertas

El mejor o más seguro de los firewalls es también el más fácil. Con solo tres reglas
de iptables podemos cerrar el sistema. Pero desafortunadamente es un cierre real
en ese caso y no sería práctico. El firewall hará un drop (descartará digamos) de
cada paquete y bloqueará el tráfico completamente, Esto es obviamente muy poco
efectivo ya que nuestro objetivo es rutear el tráfico, y este mini tutorial tendría que
llamarse "Construir un bloqueador en Linux" y ahorrarnos muchas páginas de
escribir y escribir. Pero así y todo es lo que pasa por default.

"Default" es lo que vamos a definir que tiene que pasar con un paquete que no
cumpla una de las reglas definidas. La mayoría de las veces seteamos las políticas
para que se rechacen todos los paquetes y se definen reglas individuales para
aquellos paquetes que queremos permitir. De esta forma nos evitamos sorpresas
con los paquetes o los puertos donde no queremos que pasen cosas inesperadas.


De esta forma va a quedar configurado el firewall ya que es lo más seguro y
efectivo. Pero no es todo lo que vamos a hacer, ya que también vamos a habilitar
funciones del kernel para contraatacar ataques
(http://es.wikipedia.org/wiki/DDoS), ajustes en el manejo de los timeouts y
limpieza de las reglas previas.

# Ajustes de timeouts

echo 30 > /proc/sys/net/ipv4/tcp_fin_timeout

echo 1800 > /proc/sys/net/ipv4/tcp_keepalive_intvl

# Limpieza de chains

CHAINS=`cat /proc/net/ip_tables_names 2>/dev/null`

for i in $CHAINS

do

iptables -t $i -F

iptables -t $i -Z

iptables -t $i –X

done


# Seteo de los defaults

#iptables -P INPUT DROP

#iptables -P OUTPUT DROP

#iptables -P FORWARD DROP


# Habilitar Anti DDOS & Block NEW sin SYN

echo 1 > /proc/sys/net/ipv4/tcp_syncookies

iptables -A INPUT -i $EXTIF -p tcp ! --syn -m state --state NEW -j DROP

Fíjense que hay tres reglas comentadas que empiezan con "iptables -P". Ese es el
seteo de políticas pero no vamos a hacerlo ahora. Por qué no?, porque si lo
seteamos bloquearíamos todo el tráfico. Esto quiere decir que si estamos
trabajando desde una sesión SSH (trabajando con la PC Linux de forma remota) se
cortaría nuestra conexión y no podríamos seguir. Al final está el script completo,
solamente descomentamos las tres líneas y listo.

Después habilitamos las conexiones que ya están establecidas y que provienen de
una conexión existente. Podemos hacer esto tranquilamente ya que la primera
conexión no puede ser verificada por el firewall, solo necesitamos chequear todas
las conexiones nuevas.

Hay también algunas reglas más de cierre total por seguridad. Los paquetes ICMP
se permiten en la red interna para que puedan establecerse conexiones UDP. De
esta forma, la política se aplica a la interface lo. Ya que no queremos bloquear las
conexiones a localhost (localhost es un nombre reservado que tienen todas las
computadoras). Y terminamos esta parte de cód