Manual de instalación, configuración y uso de VNX:

Tras una buena pelea entre unas cuantas distribuciones linux y la herramienta, he conseguido realizar un manual básico de la herramienta VNX, la cual ya expliqué mi primer contacto con ella aquí.

Para comenzar, este manual está elaborado y probado en las distribuciones Ubuntu, Lubuntu y Mint; aunque, ahora sí, puedo extrapolar a cualquier distribución basada en Ubuntu.

Manual de instalación y configuración:

1. Habilitar el servicio de virtualización en la BIOS.

2. Tener actualizado Linux y demás.

sudo apt-get update

3. Instalar las librerias necesarias:

sudo apt-get install qemu-kvm libvirt-bin vlan xterm bridge-utils screen virt-manager virt-viewer libxml-checker-perl libxml-parser-perl libnetaddr-ip-perl libnet-pcap-perl libnet-ipv6addr-perl liberror-perl libexception-class-perl uml-utilities libxml-libxml-perl libterm-readline-perl-perl libnet-telnet-perl libnet-ip-perl libreadonly-perl libmath-round-perl libappconfig-perl libdbi-perl graphviz genisoimage gnome-terminal tree libio-pty-perl libsys-virt-perl libfile-homedir-perl curl w3m

4. Modificar el fichero /etc/libvirt/qemu.conf sustituyendo las líneas:

security_driver = "none" user = "root" group = "root" cgroup_device_acl = [ "/dev/null", "/dev/full", "/dev/zero", "/dev/random", "/dev/urandom", "/dev/ptmx", "/dev/kvm", "/dev/kqemu", "/dev/rtc", "/dev/hpet", "/dev/net/tun", ]

5. Reiniciar el servicio libvirt:

sudo service libvirt-bin restart

6. Instalar VNX, versión 2.0b.2270-201209171149, con fecha 17-9-2012 (es la que he probado en todos):

Enlace: http://vnx.dit.upm.es/vnx/vnx-2.0b.2270-201209171149.tgz

tar -xvzf vnx-2.0b.2270-201209171149.tgz sudo sh ./vnx-2.0b.2270-201209171149/install_vnx

*Establecer el directorio correspondiente donde se descargó para descomprimirlo y para ejecutar el instalador.

7. Copiar o mover el siguiente fichero:

sudo mv /usr/share/vnx/etc/vnx.conf.sample /etc/vnx.conf

8. Instalar dinamips y dynagen:

sudo apt-get install dynamips dynagen

9. Crear el fichero que se usará como demonio, /etc/init.d/dynamips :

#!/bin/sh # Start/stop the dynamips program as a daemon. # ### BEGIN INIT INFO # Provides: dynamips # Default-Start: 2 3 4 5 # Default-Stop: 0 1 6 # Short-Description: Cisco hardware emulator daemon ### END INIT INFO DAEMON=/usr/bin/dynamips NAME=dynamips PORT=7200 PIDFILE=/var/run/$NAME.pid LOGFILE=/var/log/$NAME.log DESC="Cisco Emulator" SCRIPTNAME=/etc/init.d/$NAME test -f $DAEMON || exit 0 . /lib/lsb/init-functions case "$1" in start) log_daemon_msg "Starting $DESC " "$NAME" start-stop-daemon --start --chdir /tmp --background --make-pidfile --pidfile $PIDFILE --name $NAME --startas $DAEMON -- -H $PORT -l $LOGFILE log_end_msg $? ;; stop) log_daemon_msg "Stopping $DESC " "$NAME" start-stop-daemon --stop --quiet --pidfile $PIDFILE --name $NAME log_end_msg $? ;; restart) log_daemon_msg "Restarting $DESC " "$NAME" start-stop-daemon --stop --retry 5 --quiet --pidfile $PIDFILE --name $NAME start-stop-daemon --start --chdir /tmp --background --make-pidfile --pidfile $PIDFILE --name $NAME --startas $DAEMON -- -H $PORT -l $LOGFILE log_end_msg $? ;; status) status_of_proc -p $PIDFILE $DAEMON $NAME && exit 0 || exit $? #status $NAME #RETVAL=$? ;; *) log_action_msg "Usage: $SCRIPTNAME {start|stop|restart|status}" exit 2 ;; esac exit 0

10. Dar permisos de ejecución al demonio dynamips

sudo chmod +x /etc/init.d/dynamips sudo update-rc.d dynamips defaults sudo /etc/init.d/dynamips start

Hasta aquí llegaría la instalación y configuración de VNX, como se puede observar es bastante equivalente con la página de instalación proporcionada por la UPM.

Manual de uso:

Para probar si realmente funciona la herramienta queda todavía:

1. Descargar los sistemas de ficheros con la siguiente sentencia o desde la web:

cd /usr/share/vnx/filesystems wget -N http://idefix.dit.upm.es/download/vnx/filesystems/vnx_rootfs_kvm_ubuntu-12.04-v025.qcow2.bz2

2.Descomprimirlo:

sudo bunzip2 vnx_rootfs_kvm_ubuntu-12.04-v025.qcow2.bz2

3. Crear un enlace simbólico, que se usará en los ficheros xml para referenciarlos:

sudo ln -s vnx_rootfs_kvm_ubuntu-12.04-v025.qcow2 rootfs_ubuntu

4. En el directorio /usr/share/vnx/example se crearán los ficheros xml que representan los escenarios de red. Para probar vienen creados ya unos, como el simple_ubuntu.xml que usaremos para probar que todo funciona correctamente. Para ello ejecutaremos una a una las siguientes ordenes:

cd /usr/share/vnx/example sudo su vnx -f simple_ubuntu.xml -v --create

*Por cierto motivo seguramente de configuración es necesario realizar la ejecución desde privilegios totales que proporciona “sudo su” y no solo con “sudo vnx...”.

Y tras ésto, debería arrancarse una máquina virtual con ubuntu.

Otros comandos útiles:

- Para apagar el escenario y preservar los cambios:

sudo vnx -f simple_ubuntu.xml -v --shutdown

- Para apagar y eliminar el escenario:

sudo vnx -f simple_ubuntu.xml -v --destroy

Para crear un escenario se pueden observar los escenarios ejemplos que vienen en la carpeta o el escenario ejemplo de la web que es más completo, pinchando aquí.

Para cualquier información adicional y complementaria de esta potente herramienta de virtualización, puede seguir por aquí.

Gracias por vuestra paciencia, pero esta ausencia ha sido por el periodo de exámenes/prácticas.

Primeros pasos, primeros obstáculos (II)

El segundo proyecto que no he conseguido terminar de hacer funcionar es el de realizar un primer firewall interno con iptables para hacer más seguro nuestro ordenador.

Proyecto Firewall Básico - Para proteger la propia máquina:

Para comenzar lo primero es saber la teoría que tiene iptables.

1. Y la mejor manera de entender la teoría es leerte bibliografía que hay en internet como son:

• http://doc.ubuntu-es.org/Iptables

• http://www.pello.info/filez/firewall/iptables.html (explicado todo sobre ejemplos)

• http://www.frozentux.net/iptables-tutorial/spanish/iptables-tutorial.html
  *En orden de menos a más detallados

Otro secundario:

• http://dns.bdat.net/documentos/cortafuegos/

2. Aun así, voy a contar un poco en general como se estructura.

Iptables se compone de 3 tablas principales (y una menos "importante" llamada RAW, para configurar excepciones en el seguimiento de paquetes) y cada tabla tiene unas cadenas definidas para cada acción a realizar:

• Filter(Por defecto):Filtrado de paquetes. 
• INPUT: Filtrado de paquetes que llegan al firewall. 
• OUTPUT: Filtrado de los paquetes de salida. 
• FORWARD: Permite el paso de paquetes a otra dirección del firewall.
• Nat: Enrutamiento de direcciones de red. 
• PREROUTING: Chequea la dirección de red antes de reenviarla. 
• OUTPUT: Interpretación de las direcciones de Red de los paquetes que salen del firewall. 
• POSTROUTING: Tratamiento de la dirección IP después del enrutado. 
• Mangle: Modificación de las cabeceras de TCP.
• PREROUTING 
• POSTROUTING 
• INPUT 
• OUTPUT 
• FORWARD

3. Todas estas tablas tienen un orden dentro flujo de los paquetes por el firewall, visualizar aquí.

4. Y luego existen acciones definidas como aceptar (ACCEPT), rechazar sin notificación (DROP), rechazar con notificación a través de ICMP (REJECT), enmascaramiento de la dirección IP origen de forma dinámica (MASQUERADE), enmascaramiento de la dirección IP destino (DNAT) y enmascaramiento de la dirección IP origen de forma estática (SNAT).

5. En general, hay dos mentalidades para hacer un firewall, que el filtrado por defecto sea aceptar (ACCEPT) e ir filtrando lo que no quieres bloqueando una a una las reglas; o denegar por defecto (DROP) e ir abriendo mediante las reglas las conexiones o servicios que deseas permitir o habilitar.

6. Las reglas pueden tener diferentes estados como son nuevo(NEW), establecido(ESTABLISHED), relacionado(RELATED) o invalido(INVALID).

7. Es necesario establecer los servicios con su puerto, por lo que mediante la wikipedia podemos obtener una tabla básica con la lista de puertos (privados) ya definidos.

8. Un par de órdenes muy útiles son:

- iptables -nvL  (Que muestra el listado detallado de las reglas establecidas)

- iptables-save > copia.bkp (Vuelca todas las reglas de iptables al fichero copia.bkp)

- iptables-restore copia.bkp (Restaura el back-up de reglas de iptables)

9. Forma de generar el firewall a partir de un shell script: 

1. Generar un shell script con VIM (o Nano o VI) y guardarlo como fw.sh
2. Darle permisos de ejecución al fichero:  sudo chmod u+x fw.sh  o también,  sudo chmod 744 fw.sh 
3. Realizar la ejecución del shell script: sudo sh fw.sh

El shell script establecido para generar el firewall es:

#!/bin/sh ## SCRIPT de IPTABLES - ejemplo del manual de iptables ## Ejemplo de script para proteger la propia máquina con DROP por defecto IPT="/sbin/iptables" IF="eth0" IP="192.168.221.131" PRIVPORT="1:1023" UNPRIVPORT="1024:65535" # Puertos FTPPORT="20:21" SSHPORT="22" DNSPORT="53" HTTPPORT="80" HTTPSPORT="443" echo -n Aplicando Reglas de Firewall... ## FLUSH de reglas $IPT -F $IPT -X $IPT -t nat -F $IPT -t nat -X $IPT -t mangle -F $IPT -t mangle -X ## Establecemos politica por defecto: DROP $IPT -P INPUT DROP $IPT -P OUTPUT DROP $IPT -P FORWARD DROP #$IPT -t nat -P PREROUTING DROP #$IPT -t nat -P OUTPUT DROP #$IPT -t nat -P POSTROUTING DROP $IPT -t mangle -P PREROUTING DROP $IPT -t mangle -P OUTPUT DROP $IPT -t mangle -P POSTROUTING DROP ## Debemos decir de manera explicita qué es lo que queremos abrir # Operar en localhost sin limitaciones $IPT -A INPUT -i lo -j ACCEPT $IPT -A OUTPUT -o lo -j ACCEPT # Permitir conexiones establecidas y relacionadas $IPT -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT $IPT -A OUTPUT -m state --state RELATED,ESTABLISHED -j ACCEPT # Permitimos consultas DNS $IPT -A INPUT -p udp -m udp --dport $DNSPORT -j ACCEPT $IPT -A OUTPUT -p udp -m udp --sport $DNSPORT -j ACCEPT # Permitimos que la maquina pueda salir a la web (HTTP) $IPT -A INPUT -p tcp -m tcp --sport $HTTPPORT -j ACCEPT $IPT -A OUTPUT -p tcp -m tcp --dport $HTTPPORT -j ACCEPT # Ya tambien a webs seguras (HTTPS) $IPT -A INPUT -p tcp -m tcp --sport $HTTPSPORT -j ACCEPT $IPT -A OUTPUT -p tcp -m tcp --dport $HTTPSPORT -j ACCEPT # Reglas necesarias para FTP pasivo y activo. Se permiten conexiones entrantes YA establecidas(Redundancia). #$IPT -A INPUT -p tcp -m tcp --sport $FTPPORT -m state --state RELATED,ESTABLISHED -j ACCEPT #$IPT -A OUTPUT -p tcp -m tcp --dport $FTPPORT -j ACCEPT #$IPT -A INPUT -p tcp -m tcp --sport $UNPRIVPORT --dport $UNPRIVPORT -m state --state ESTABLISHED -j ACCEPT #$IPT -A OUTPUT -p tcp -m tcp --dport $UNPRIVPORT -m state --state NEW,RELATED,ESTABLISHED -j ACCEPT # Permitimos el servicio SSH (Mejora mediante control IPs origen y destino, unicamente los que desemos) #$IPT -A INPUT -i $IF -p tcp --sport $SSHPORT -d $IP --dport $SSHPORT -m state --state NEW -j ACCEPT #$IPT -A OUTPUT -o $IF -p tcp --sport $SSHPORT -s $IP --dport $SSHPORT -m state --state NEW -j ACCEPT echo " OK . Verifique que lo que se aplica con: iptables -L -n" # Fin del script

En conclusión, los problemas en este proyecto han sido:

• El primer problema que he tenido y como siempre el más tonto: cuidado con los "copy-paste" entre editores (especialmente pdf,doc,..) pues te pueden meter caracteres con formatos que la shell rechaza y te puedes tirar bastante tiempo pensando dónde estás fallando cuando el código esta "perfectamente".

• El siguiente problema ha sido la de enfocar el firewall de la propia máquina a bloqueo por defecto (DROP) todas las tablas. Lo que no conseguía siquiera hacer que internet fuera. Pero es posible que esto tenga que ver por realizar todas las pruebas en una máquina virtual con un livecd (de la distribución bugtraq, la cual me está gustando cada vez más), ya que puede perder el enlace de internet del SSOO principal con la máquina virtual al manipular el firewall, supongo claro.

Cuando tenga tiempo, realizaré uno basado en aceptar por defecto e ir cerrando los que no queramos, además de un firewall susodicho dentro de una red, donde las reglas vendrán establecidas mediante el paso (FORWARD) de paquetes entre dos redes. Para esto último, necesitaría tener VNX.