IPTABLES 2: Ejemplo Firewall LAN ( Parte 1 )

Configuración de las maquinas

En este post tenemos que configurar un firewall para la LAN, es decir vamos a disponer de un equipo (o varios) conectados a otro equipo que hace de firewall (y además tiene que enrutar). Este firewall a su vez está conectado a un router.

El equipo que hace de firewall tiene que disponer de 2 tarjetas de red. Los equipos que están conectados al firewall van a pertenecer a una red mientras que el router pertenece a otra. El equipo de firewall pertenece a ambas redes.

En nuestro caso vamos a disponer de dos maquinas Linux, como lo vamos a hacer sobre VMware, no quiero tener 2 maquinas Ubuntu o 2 maquinas Debían que tengamos que copiar o duplicar porque no me quiero llevar sorpresas con las mac. Así que como dispongo de una maquina Debian y otra Ubuntu las usare porque pienso que pueden traernos menos problemas.

Vamos a utilizar la maquina Ubuntu como equipo de la red interna su ip será la 10.0.0.1.

Vamos a utilizar la maquina Debian como firewall (y router). La primera tarjeta de red, eth0 tendrá la ip 10.0.0.2. La segunda tarjeta, eth1, dispondrá de la ip 192.168.0.20.

El router dispondrá de la ip 192.168.0.1

A continuación vamos a ver como configurar las tarjetas de re de cada una de las maquinas.

En primer lugar vamos a configurar la maquina Ubuntu.

Para ello tendremos que entrar en la Shell y escribir ifconfig para ver la configuración actual de las tarjetas de red

Ifconfig

clip_image002

Como podemos observar la tarjeta de red eth1 no está en la red que nosotros queremos que este, así que tendremos que configurar la tarjeta de red para que lo esté.

Podemos hacerlo de varias maneras, vamos a optar por hacerlo en memoria, es decir cuando se reinicie la maquina perderemos la configuración.

Vamos a configurar esta tarjeta con la ip 10.0.0.1 y su máscara de red será 255.0.0.0, además nuestra puerta de enlace deberá de ser la pata interna del firewall, como ya hemos dicho será la 10.0.0.2

Tendremos que escribir las siguientes órdenes en la Shell:

Sudo Ifconfig eth1 10.0.0.1 netmask 255.0.0.0
sudo route add default gateway 10.0.0.2

Estamos diciéndole a la tarjeta de red que su ip es la 10.0.0.1, su máscara de red la 255.0.0.0 y la puerta de enlace es la 10.0.0.2, la del router

clip_image004

clip_image006

clip_image008

En las capturas de superiores podemos observar que ha funcionado ok, miraremos ahora con

Ifconfig de nuevo para ver si se ha configurado como nosotros queríamos

clip_image010

Parece que ha funcionado perfectamente.

Ahora tendremos que configurar las tarjetas de firewall

Como ya hemos dicho el firewall tiene que tener 2 tarjetas de red, como lo utilice para un ejercicio anterior este firewall ya tiene dos tarjetas. De todas maneras si quisiéramos una tarjeta de red mas solo tendríamos que añadirla y reiniciar la maquina.

En esta máquina volvernos a mirar que direcciones tienen las tarjetas de red

Esta vez introduciremos primero su para poder ser administradores y poder usar ifconfig, veámoslo:

clip_image012

Ahora ejecutaremos ifconfig:

clip_image014

Parece que tendremos que volver a configurar las tarjetas como en la maquina Ubuntu, recordemos que esta vez tendremos 2 tarjetas, eth0 para la red local y eth1 para la red con el router. Vamos a configurarlo

En primer lugar tendremos que configurar la eth0, lo haremos con ifconfig

Ifconfig eth0 10.0.0.2 netmask 255.0.0.0

clip_image016

Configuraremos la segunda tarjeta del router escribiendo lo siguiente n la Shell, tal y como vemos en las imágenes

Ifconfig eth1 192.168.0.20 netmask 255.255.255.0

Route add default gateway 192.168.0.1

clip_image018

clip_image020

Si ahora volvemos a revisar las tarjetas con ifconfig, veremos que configuración tenemos, deberíamos de tener la que acabamos de poner

clip_image022

Parece que ha funcionado ok. Probemos ahora la conectividad con la LAN y con el router, si todo va bien deberíamos de poder hacer ping.

Desde Ubuntu escribiremos en la Shell lo siguiente

Ping 10.0.0.2

Si contesta, todo va bien.

clip_image024

Está funcionando ok, veamos si el firewall también contacta con Ubuntu

Ping 10.0.0.1 desde debían en la Shell

clip_image026

Parece que la comunicación entre el firewall y la LAN funciona perfectamente.

Ahora tendremos que hacer lo mismo con el router, así que en nuestra maquina debían tras abrir una Shell tendremos que escribir la siguiente orden,

Ping 192.168.0.1

De esta manera estamos buscando al router para que nos conteste, si es así la comunicación en ambos sentido será buena.

clip_image028

Como podemos observar en la imagen superior sí que tenemos buena comunicación.
Por si acaso vamos a realizar una red separada con VMware con la maquina Ubuntu y la tarjeta eth0 de nuestro firewall (maquina debían).

En las imágenes de abajo muestro que es lo que hay que hacer.

En primer lugar tendremos que ir a las propiedades de nuestras maquinas virtuales. En primer lugar lo haremos con Ubuntu,

Nos posicionaremos en la pestaña de nuestra maquina virtual y haremos clic con el botón derecho.

clip_image030

clip_image032

Una vez aquí, se nos abrirá la siguiente ventana,

clip_image034

Como podemos observar en la imagen, tendremos que seleccionar Custom en Network conection (aparece a la derecha de la imagen) seleccionaremos por ejemplo VMnet0.

Realizaremos exactamente lo mismo con nuestro debían, en este caso seleccionaremos la tarjeta que el sistema identifica como eth0

clip_image036

En la imagen superior seleccionamos la tarjeta de red (eth0) y volvemos a indicar custom en Network conection. Vemos que es muy importante que la red sea la misma, en este caso VMnet0. Ahora mismo ya tenemos una red aislada de la otra.

Podríamos usar todas las tarjetas en modo bridge pero podemos tener algún otro problema, para no tenerlo prefiero dejar esto configurado así.

Creando el script iptables

Una vez que ya tenemos configurados los equipos y se ven entre si es hora de filtrar tráfico, para este ejercicio solo queremos que funcione la navegación web tradicional, ni correo ni nada.

Como ya sabemos tendremos que realizar un firewall basado en iptables. En la práctica anterior fue un poco desastre tener que entrar al fichero para descomentar líneas, así que esta vez vamos a realizar un script con case y while.

Crearemos la estructura en primer lugar y después nos centraremos en el firewall en sí. Esta construcción la emplearemos a partir de ahora para nuestros firewalls.

Como en cualquier script tendremos que poner los comentarios iniciales e indicar sobre que Shell funciona nuestro firewall.

En primer lugar tendremos que escribir en nuestra shell (ahora estamos en el equipo debian que es el que hace de firewall) lo siguiente, llamaremos al fichero fwlan.

Nano fwlan

clip_image038

En esta imagen podemos observar que hemos escrito en la shell, a continuacion nos aparecera nuestro editor de textos nano, como en la imagen inferior.

clip_image040

Ahora vamos a escribir nuestro firewall, desde cero.

Como ya hemos dicho, comenzaremos diciendo sobre que shell se ejecuta nuestro firewall, ademas nos presentaremos nosotros y que hace nuestro firewall.

Escribiremos lo siguiente:

#!/bin/bash

# Este firewall está diseñado por Komooo666

# Nuestro firewall hará también de router,estara entre la red e internet

# Vamos a utilizar la función case para iniciar, parar y resetear el fw

# En primer lugar estableceremos el modulo de arranque estableciendo la

# Configuración inicial, borrando reglas, aplicando políticas y nuestras propias reglas

Como podemos comprobar en la imagen inferior, tenemos las mismas lineas escritas en nuestro script.

clip_image042

Como ya hemos comentado al principio, esta vez crearemos una estrctura case para no tener que entrar constantemente al script para descomentar lineas si queremos limpiar reglas o cualquier otra cosa.

Tendremos que escribir en nuestro script una estructura como la siguiente

case in $opcion

1)echo “hola”

2)echo “adios”

Si seleccionamos 1 se nos mostrara hola y si seleccionamos 2 nos dira adios.

Haremos algo tan sencillo como eso pero con nuestro firewall. Asi que vamos a empezar.

Con nuestro editor escribiremos las siguientes lineas

echo “Teclee iniciar, parar, informe o salir”

read OPCION

Escribimos esto para luego poder filtrar según el valor de opcion. Según hemos escrito, tendremos que hacer 4 opciones como son iniciar, parar, informe y salir.

Continuamos nuestro script empezando el case.

case $OPCION in

iniciar)

Como podemos apreciar, con estas lineas estamos diciendo que case coja el valor de la variable opcion que el usuario ha tecleado. Comenzaremos escribiendo las opciones para iniciar. Este apartado contendra todo el firewall, porque nosotros queremos generar un script que lance nuestro firewall de la lan con el objetivo de solo navegacion.

Vamos a teclear las siguientes lineas en el apartado iniciar.

clear

echo “Iniciando Firewall…!!!!”

echo “————————-“

sleep 3

Para hacerlo mas amigable ( mas lento tambien) vamos a hacerlo mas bonito. Asi que despues de que se nos pida que queremos teclear automaticamente se limpie la pantalla y se indique que opcion se esta llevando a cabo.

Es en este momento cuando escribimos el firewall puramente.

Escribimos el reseteo de lo que hubiese anterioremente en el firewall.

# x borra reglas,z borra contador tramas,f borra reglas usuario,-t todo firewall$

#reseteamos lo que hubiera en primer lugar

iptables -X && echo “borrando reglas…”

iptables -Z && echo “borrando contadores…”

iptables -F && echo “borrando reglas usuario….”

iptables -t nat -F && echo “haciendo nat”

Veamos en la imagen inferior el estado de nuestro script.

clip_image043

clip_image045

A continuacion escribiremos las politicas, en nuestro caso estara todo abierto por defecto asi que tendremos que escribir algo similar a esto:

#estas son las politicas,en este caso abrimos todo

iptables -P INPUT ACCEPT && echo “acepto entrada”

iptables -P OUTPUT ACCEPT && echo “acepto salida”

iptables -P FORWARD ACCEPT && echo “acepto reenvio

Mediante estas políticas estamos diciendo aceptamos la entrada, la salida y el reenvío de tramas por defecto, además estamos añadiendo echos para luego saber que política ha fallado de una manera más sencilla y fácil.

Para terminar nuestro firewall, tendremos que indicarle una serie de reglas en las que filtraremos el trafico.

En primer lugar y porque este firewall también tiene que enrutar y hacer nat tendremos que escribir un par de líneas como las siguientes.

# Habilitamos nat en este firewall hacia la otra red

iptables -A POSTROUTING -t nat -s 10.0.0.0/8 -o eth1 -j MASQUERADE

Mediante esta línea indicamos que después de saber cómo se van a enrutar los paquetes vamos a hacer nat de todo lo que provenga de la red 10.0.0.0 y vamos a cambiarle la ip. De esta manera, después los paquetes podrán volver a su destino.

# Habilitamos el reenvio de tramas

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

Con esta línea permitimos que nuestro firewall enrute. Sin estas líneas nuestro cometido sería imposible de realizar.

Ahora vamos con las reglas que nosotros mas conocemos.

Nuestra misión es que los usuarios de las red 10.0.0.0 solo puedan navegar así que una de las reglas que tendremos que escribir será la siguiente.

Permitiremos el reenvio de los paquetes si su destino es de la red 10.0.0.0 y el puerto de destino en la maquina remota es el 80. Además tiene que utilizar el protocolo tcp y venir de la tarjeta eth0. Podría ser algo así,

iptables -A FORWARD -i eth0 -s 10.0.0.0/8 -p tcp –dport 80 -j ACCEPT && echo “Acepto reenvio al 80 desde eth0”

Al igual que permitimos la salida de tráfico hacia el puerto 80 tendremos que aceptar también su respuesta, por ello escribimos esta segunda línea.

iptables -A FORWARD -i eth1 -d 10.0.0.0/8 -p tcp –sport 80 -j ACCEPT && echo “Acepto reenvio desde 80 por eth1”

Si queremos navegar tendremos que poder resolver nombres, así que tendremos que abrir también el puerto 53, lo haremos mediante las siguientes líneas.

iptables -A FORWARD -i eth1 -d 10.0.0.0/8 -p udp –sport 53 -j ACCEPT && echo “acepto reenvio desde puerto 53 por eth1”

iptables -A FORWARD -i eth0 -s 10.0.0.0/8 -p udp –dport 53 -j ACCEPT && echo “acepto reenvio al puerto 53 remoto por eth0”

Ahora cerraremos la entrada, la salida y el reenvio mediante las siguientes líneas.

iptables -A INPUT -j DROP && echo “Cerrando entrada”

iptables -A OUTPUT -j DROP&& echo “Cerrando salida”

iptables -A FORWARD -j DROP && echo “Cerrando reenvio”

Ya habremos terminado nuestro script de iptables pero no nuestra estructura case, solo vamos en la primera opción. De todas maneras terminaremos dejándola bonita.

sleep 1

echo “*************************************************”

echo “Su sistema es más SEGURO a partir de este momento”

echo “*************************************************”

sleep 3

clear

;;

Tan solo le estamos dando un tiempo de espera para que podamos ver que hemos aplicado y para informar del estado del sistema.

En la imagen inferior se muestra como nos queda realmente este primer modulo.

clip_image047clip_image049

Al principio del script hemos visto que teníamos 4 opciones para seleccionar y por tanto para configurar, lo hemos hecho con la opción más grande y ahora tendremos que escribir las otras 3 opciones. Son módulos mucho más pequeños que el primero.

Ahora vamos a ver que tenemos que escribir para parar este firewall.

Parar un firewall significa limpiar todas las reglas que hubiese anteriormente y aceptar todas las políticas.

Tendremos que escribir lo siguiente en nuestro script

parar)

clear

echo “Parando Firewall…!!!”

echo “————————“

sleep 3

#reseteamos lo que hubiera en primer lugar

iptables -X && echo “borrando reglas…”

iptables -Z && echo “borrando contadores…”

iptables -F && echo “borrando reglas usuario….”

iptables -t nat -F && echo “haciendo nat”

Como podemos observar en las líneas superiores, no hemos escrito nada nuevo. Hemos puesto la opción parar y a continuación una secuencia de comandos en los que limpiamos la pantalla, damos información sobre la parada del firewall y esperamos para limpiar las reglas que hubiese en la maquina. Como podemos observar, – X nos borra las reglas que hubiera, – F borra las reglas de usuario, mientras que –Z borra los contadores de tramas y –nat -F, borra lo que hubiese y hace nat.

Después pondremos la opción de reenvio de tramas a 0 de la siguiente manera

# Deshabilitamos el reenvio de tramas

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

A continuación pondremos las políticas de iptables para que sean todas aceptar y no haya ninguna configuración filtrada.

Escribiremos lo siguiente a continuación del anterior párrafo de código.

#estas son las politicas,en este caso abrimos todo

iptables -P INPUT ACCEPT && echo “acepto entrada”

iptables -P OUTPUT ACCEPT && echo “acepto salida”

iptables -P FORWARD ACCEPT && echo “acepto reenvio”

sleep 2

echo “*************************************************”

echo “Su sistema es VULNERABLE a partir de este momento”

echo “*************************************************”

sleep 3

clear

;;

Como hemos comentado, aceptamos todas las políticas, además siguiendo la política que hemos adoptado en el modulo anterior, esperamos mostrando al usuario que se está habilitando y después mostramos un mensaje de información para que se sepa que el sistema es más vulnerable con esta configuración.

En la imagen inferior, vemos una captura de pantalla perteneciente al segundo modulo u opción de nuestro case,

clip_image051

clip_image053

Continuaremos la configuración de nuestro script, ahora pasaremos al modulo de informe.

Tendremos que escribir,

Informe)

Para que cuando nosotros indiquemos en el inicio del programa que queremos que nos muestre el informe, este sepa que hacer.

Este modulo es muy simple y continuaremos además las amigabilidad con el usuario mostrándole “carteles”.

Veamos que tenemos que escribir.

informe)

clear

echo “El estado del filtro del firewall aparecerá en breves momentos”

echo “—————————————————————“

sleep 3

iptables -L -n

;;

Como podemos observar en este código, vemos que limpiamos la pantalla, mostramos un titulillo y después lanzamos el comando que nos indica en el sistema que está abierto y que no,

Veamos una pequeña prueba de que hace este comando.

Escribiremos en una Shell, el siguiente comando iptables –L –n, cuando lo ejecutemos nos debería mostrar que estamos permitiendo que pase, que queremos que se reenvíe y que queremos que pare nuestro firewall.

clip_image055

clip_image057

Cuando nosotros pulsemos en nuestro firewall informe aparecerá sin salirnos del programita un informe de la situación actual del firewall en el sistema.

Por último y para terminar el case, crearemos salir.

En este pequeño código solo imprimimos por pantalla un par de líneas de cortesía.

salir)

echo “*************************************”

echo “Muchas Gracias por usar este programa”

echo “Saludos”

echo “*************************************”

sleep 1

clear

;;

Como ya hemos comentado, solo damos las gracias por el uso y decimos adiós al usuario.

Si no pulsamos una opción correcta, escribimos un último modulo para indicar al usuario que no es lo que esperábamos y lo sacamos de la aplicación. Veamos que tendríamos que escribir en este pequeño modulo.

*)

echo ” No ha introducido ninguna acción valida”

sleep 1

clear

;;

esac

Como podemos ver, sacamos otro mensaje por pantalla, acabamos esta parte del modulo y además finalizamos nuestro bucle case

Vamos a ver una captura de pantalla de nuestro firewall.

clip_image059

Si volvemos al principio del documento, hemos dicho que utilizaremos un bucle while, este bucle nos va a servir para permitirnos no salir del programa cuando seleccionamos una acción. Pondremos el bucle while al principio y al final del script que tenemos hasta ahora.

Al principio de nuestro firewall escribiremos lo siguiente

echo “Esta seguro que quiere modificar el comportamiento del Firewall (si/no): \c”

read RES

while [ “$RES” = “si” ]

do

Este pequeño trozo de código nos pregunta en primer lugar si queremos cambiar el firewall, leemos la respuesta y mientras nosotros no digamos algo diferente de si, recordamos que Linux es case sensitive, entraremos dentro del case.

Nos quedaría algo así en nuestro script

clip_image061

Al final de nuestro código case, tendremos que hacer la misma pregunta, mientras no digamos algo diferente de si, el programa no saldrá.

Al final de nuestro case , escribiremos lo siguiente.

echo “Quieres realizar alguna otra operación? \c”

read RES

done

Lo dicho, si la respuesta es sí, volveremos entrar en el case, si es diferente se saldrá del programa. En la imagen inferior vemos el final de nuestro script.

clip_image063

Ya hemos terminado nuestro firewall, ahora probaremos el script para ver si funciona todo lo que hemos comentado que debiera hacer el programa.

Realizando pruebas

Para poder ejecutar nuestro firewall tendremos que darle permisos de ejecución, para ello tendremos que escribir el siguiente comando en la Shell.

Chmod +x fwlan

clip_image065

Si ahora realizamos un ls –l veremos que tenemos los permisos de ejecución de este fichero.

clip_image067

clip_image069

Si queremos ejecutarlo, teclearemos lo siguiente en la Shell

./fwlan

clip_image071

Vamos a probar si funcionan todas las funciones while y case. En principio deberían de hacer perfectamente, pero comprobémoslo.

clip_image073

Como podemos observar al ejecutar nos aparece la opción donde tenemos que contestar si. Al contestar otra cosa se saldrá del programa. Esta es la funciona while. Vamos a probar a decirle que no para ver como se sale del programa.

clip_image075

Parece que ha funcionado perfectamente.

Ahora vamos a decirle que si que queremos modificar el comportamiento del firewall, así que lo volveremos a ejecutar.

Teclearemos lo siguiente de nuevo,

./fwlan

clip_image071[1]

clip_image077

Ahora veremos que ocurre cuando pulsamos intro. En teoría debería de decirnos que tenemos que seleccionar (iniciar,parar,informe o salir)

clip_image079

Podemos observar que cuando hemos dicho sí y hemos pulsado intro, la pantalla se ha limpiado y nos ha salido esta opción.

Teclearemos iniciar.

clip_image081

Hemos escrito iniciar, veremos que ocurre cuando pulsamos intro, en teoría debería de aparecer por pantalla, cada una de las cosas que hace el firewall y darnos un mensaje de información antes de salirse de esa opción del case.

clip_image083

Parece que funciona ok. Cuando se sale de ese case del script irá a parar al bucle while para que le indiquemos si queremos salir o continuar haciendo cosas con el firewall. El programa debería de preguntarnos de nuevo que queremos hacer.

clip_image085

Si en este momento escribiésemos algo diferente de si, el programa se saldrá. Probémoslo, escribiremos que no.

clip_image087

Al pulsar intro deberíamos de salirnos del programa.

clip_image089

Parece que funciona como nosotros queremos.

Una vez probadas estas opciones en las que vemos que los bucles while y case funcionan ok, veremos el resto de las opciones del case.

Entraremos de nuevo al programa y veremos un informe sobre que se está abriendo o cerrando en el firewall, después lo pararemos, volveremos a mirar y utilizaremos la opción salir. De esta manera comprobaremos todas las opciones posibles.

Tendremos que volver a ejecutar el programa con ./fwlan

clip_image091

clip_image093

Una vez estemos en esta pantalla, deberíamos de escribir informe.

clip_image095

Una vez que pulsemos intro, nos aparecerá la siguiente información sobre el firewall.

clip_image097

Como podemos comprobar también nos aparece la opción de realizar otra operación. En nuestro caso será que sí, nos volverá a aparecer el mensaje “teclee….” Donde deberíamos de escribir parar para parar el firewall.

clip_image099

Si pulsamos intro, nos aparecer la pantalla teclee…

clip_image093[1]

Ahora escribiremos parar y pulsaremos intro.

clip_image101

clip_image103

Como podemos observar en la imagen superior, se van cumpliendo todas las sentencias que hemos puesto en el firewall con el fin de dejarlo todo abierto para así parar el firewall.

Ahora volveremos a ver un informe, si lo comparamos, veremos que ahora se permite el paso de todo mientras que antes solo se permitía pasar las cosas hacia y desde el 80 y el 53.

clip_image105

clip_image095[1]

clip_image107

Como podemos observar ahora no tenemos nada denegado.

Ahora usaremos la opción salir para darnos las gracias por usar el firewall y nos saldremos del programa.

clip_image109

Una vez sacado este mensaje nos saldremos del programa

clip_image111

Como podemos comprobar nuestro script funciona perfectamente, ahora es el momento de comprobar si hace lo que nosotros queremos que haga.

Solo deberemos de poder permitir la navegación para el puerto 80 y nada más para los equipo de dentro de la LAN.

Si tenemos el firewall desactivado e intentamos navegar no podremos hacerlo porque aunque la puerta de enlace de esa máquina sea el firewall, si nuestro programa no está activo no tiene la función de reenvío de tramas activada y por tanto no hay ningún tipo de navegación. Recordemos que en nuestras pruebas del script dejamos el firewall desactivado.

Vamos a intentar navegar con nuestra maquina Ubuntu, primero haremos un ping para comprobar que tenemos conectividad.

Teclearemos en la Shell, ping 10.0.0.1

clip_image113

Como dejamos perfectamente configuradas las tarjetas, nuestro equipo tiene conectividad perfecta con su puerta de enlace / firewall. Hemos comentado que el firewall esta sin activar,es decir que se permite todo el tráfico, ahora bien como el reenvio de tramas no está funcionando no deberíamos de poder ir a ningún sitio. Vamos a intentar entra en google, así que abriremos un navegador y escribiremos www.google.es No deberíamos de poder navegar.

clip_image115

clip_image117

Como podemos observar, estamos intentando acceder a google pero parece que no funciona ok. En la imagen inferior vemos que hay un time out

clip_image119

Como podemos observar no somos capaces de hacerlo. Además solo vemos que no conecta y listo. Podemos hacer una cosa para ver más información al respecto.

Vamos a instalar iptraf en nuestro firewall para ver el trafico de red que pasa por él.

Tenemos que ser root y para ello, como siempre tendremos que escribir en la Shell su y teclear nuestra contraseña. Tras esto escribiremos la siguiente orden en la Shell:

Apt-get install iptraf

clip_image121

Como podemos observar en la imagen superior, tenemos que insertar el dvd de debían. En nuestro caso pondremos la imagen del cd en la maquina virtual para que lo pueda leer.

Pincharemos en settings de nuestra maquina virtual y ahí tendremos que seleccionar la unidad de cdrom. Una vez allí pulsaremos browse y seleccionaremos nuestra imagen del dvd.

clip_image123clip_image125

clip_image127clip_image129

Aceptaremos todo y pulsaremos intro en nuestra Shell para que la instalación pueda continuar.

En la imagen inferior, vemos la ultima parte de la instalación de iptraf.

clip_image131

Una vez instalado lo ejecutaremos con el siguiente comando

Iptraf

clip_image133

Ahora se nos abrirá la siguiente ventana

clip_image135

Pulsaremos una tecla y veremos el menú de iptraf como podemos comprobar en la imagen inferior.

clip_image137

Pulsaremos sobre IP Traffic monitor para ver que entra y sale de nuestras tarjetas ya que este equipo está entre la red y el firewall y por la pasa todo el tráfico.

Una vez seleccionado ip traffic monitor, se nos pide que seleccionemos que trafico queremos monitorizar, seleccionaremos todas las interfaces y pulsaremos intro.

clip_image139

clip_image141

Ahora volveremos a intentar navegar con nuestra maquina Ubuntu de la misma manera que antes y veremos que trafico tenemos en este equipo.

clip_image143

Ahora vayamos rápidamente al firewall para ver que está ocurriendo…

clip_image145

Podemos observar tramas desde nuestro equipo Ubuntu para google en su puerto 53, vemos que llegan por la tarjeta eth0 pero como podemos comprobar no llegan a ningún sitio y por tanto firefox nos dará otro time out como antes.

En este momento nuestro firewall sí que puede navegar, porque esta con conectado con su puerta de enlace.

Probemos un ping a 192.168.0.1

clip_image147

Vamos a intentar ir a google para ver qué ocurre con nuestro navegador y con iptraf.

clip_image149

Nuestro firewall es capaz de navegar hasta google. Veamos iptraf que nos dice.

clip_image151

Podemos comprobar en esta captura de pantalla, que nuestro firewall navega perfectamente, podemos ver a que web nos estamos conectando , los paquetes, porque tarjeta y que flags tienen (sync,ack..) Además vemos que se está resolviendo perfectamente con el puerto 53 desde ambas tarjetas, desde dentro y desde fuera.

Ahora probemos a iniciar el firewall, una vez iniciado vamos a comprobar con la opción del informe que se está dejando pasar y que no.

Tendremos que teclear iniciar en la pantalla de selección. El firewall se iniciara como vemos más abajo-

clip_image081[1]

clip_image083[1]

Teclearemos que si queremos hacer más cosas con el firewall y esta vez seleccionaremos informe

clip_image085[1]

clip_image095[2]

clip_image097[1]

Como podemos observar en la pantalla superior, vemos que solo se permite el reenvio a los puertos 80 y 53 tanto de entrada como de salida. Nada más, es decir solo se puede navegar por paginas normales.

Vamos a comprobarlo, si realizamos la misma prueba que antes deberíamos de poder navegar pero solo por paginas normales(puerto 80).

Intentamos navegar por google y parece que podemos hacer sin ningún problema como vemos en las imágenes inferiores

clip_image153

clip_image155

Probemos a navegar por una web segura, en principio no deberíamos de poder:

clip_image157

clip_image159

No funciona, mostrare una imagen de iptraf donde parece verse que no se puede acceder a esa página web

clip_image161

clip_image163

Parece que nuestro firewall funciona perfectamente según nuestras indicaciones. Por último comprobaremos que nuestra maquina debían con el firewall subido no puede navegar. Intentaremos acceder a google.es

clip_image165

Rápidamente se nos muestra esta información porque el firewall no permite la salida de paquetes, es decir no permite output para esa máquina y por eso no funciona internet desde aquí. Como antes teníamos todo abierto funcionaba sin ningún problema.

Una respuesta a “IPTABLES 2: Ejemplo Firewall LAN ( Parte 1 )”

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Time limit is exhausted. Please reload the CAPTCHA.

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.