Hola a todos, hoy voy a mostraros como realizar un ataque de fuerza bruta usando
Pyrit para crear
tablas rainbow y
Cowpatty para procesarlas.
Pyrit es una de las pocas herramientas disponibles para Unix/Linux y MacOS X que permite acelerar el pre-procesamiento una parte de la fase de autentificación de WPA/WPA2-PSK (~= creación de tablas rainbow) al explotar la potencia de computación de la GPU de nuestras tarjetas gráficas Nvida o ATi, además de la de nuestros procesadores de uno o más núcleos.
Para los que no lo sepan
Pyrit, a día de hoy,
constituye una de las herramientas más potentes contra WPA/WPA2-PSK, uno de protocolos de seguridad más robustos y fiables. Pyrit está escrito en python pero los módulos que permiten el acceso a la(s) GPU(s) están escritos en lenguajes de más bajo nivel (C/C++ y similares).
En resumidas cuentas, es como
"darse cabezazos contra una pared" pero 5 o 6 veces (como mínimo) más rápido
de lo que conseguiríamos usando sólo nuestro(s) procesador(es). Esto bien puede traducirse a una reducción de por lo menos la mitad del tiempo necesario para crear una tabla rainbow (por ejemplo de, échale, 6 horas a quizás 2 o incluso 1), lo que resulta util para procesar diccionarios de varios gigabytes.
Vale... ya estoy viendo como a alguno se le cae la baba... sin embargo aunque no me guste puede que tenga que bajar a alguno de las nubes...
Los sistemas que permiten acceder a Pyrit a las GPUs de las tarjetas gráficas son
CUDA (en el caso de gráficas Nvidia) y
Stream (en el caso de ATi), pues bien tanto CUDA como Stream son tecnologías relativamente recientes y sólo soportan una serie de modelos más o menos nuevos... si, no podía ser todo tan perfecto...
* Hardware soportado:
-> Modelos de Nvidia compatibles en
esta web.
-> Modelos de ATi compatibles en en
esta web.
Antes de nada debo daros un consejo, sobre todo si estáis pensando en comprar una tarjeta gráfica pronto, el rendimiento de
Nvidia usando CUDA es notablemente superior al de los modelos de ATi que soporta Stream. La diferencia es tal que, en el caso de que vuestra gráfica sea una ATi, si no disponéis de una modelo de la serie
Radeon HD38xx o superior (preferiblemente la serie Radeon HD48xx) os aconsejo que no sigáis con el manual ya que es probable que os llevéis una gran decepción. Lo digo en serio, yo tengo una Radeon HD3470...
Este gráfico puede daros una idea de la diferencia de potencia entre ATi y Nvidia y, en especial, entre los modelos de Nvidia:
Como ya dije, tengo una Radeon HD3470 y el equipo en el que estoy actualmente no es que digamos una maquina bestial por lo que para hacer este manual utilizaré datos estadísticos de
este otro, el cual también me sirvió de referencia para aprender a manejar Pyrit y poder escribir este documento.
Enhorabuena para los afortunados y otra vez será para los demás (o ir ahorrando para actualizar vuestra tarjeta gráfica
) y sin más dilación vamos con la parte "divertida"
.
*
Requisitos indispensables:
- Es imprescindible tener instalados los controladores
propietarios de tu tarjeta gráfica ATi/Nvidia, preferiblemente los más actuales, ya que tanto Stream (ATi) como CUDA (Nvidia) hacen uso de bibliotecas del controlador propietario de la tarjeta gráfica.
- Disponer de
un diccionario en texto plano a partir del cual crearemos las tablas rainbow.
- Capturar un
handshake de una red wifi protegida con WPA-PSK o WPA2-PSK.
- Tener instalado
cowpatty,
pyrit y el módulo de Pyrit correspondiente a tu tarjeta gráfica (pyrit-stream para ATi o pyrit-cuda para Nvidia).
Si tenéis Ubuntu 9.04 podéis encontrar las herramientas
cowpatty y
pyrit empaquetadas en formato deb en este enlace:
http://foro.elhacker.net/gnulinux/lista_de_repositorios_de_paquetes_deb_para_ubuntu_ppas_que_mantengo-t261488.0.htmlUna vez que tengamos todo instalado, podemos comprobar la potencia de nuestra maquina ejecutando esta orden en una terminal:
pyrit benchmark
Esto lanzará una prueba de testeo que nos dará una idea aproximada de la potencia de tu sistema teniendo en cuenta tu(s) procesador(es) (CPUs) y la(s) GPU(s) de tu(s) tarjeta(s) gráfica(s). Pues bien,
según pureh@te, en su sistema (un Q6600 Quad Core funcionando 3.6 GHz y una GeForce 8800 GT) la salida es esta:
The Pyrit commandline-client (C) 2008 Lukas Lueg
http://pyrit.googlecode.comThis code is distributed under the GNU General Public License v3
The ESSID-blobspace seems to be empty; you should create an ESSID...
Available cores: 'Standard CPU', 'Nvidia CUDA'
Testing CPU-only core 'Standard CPU' (4 CPUs)... 1294.58 PMKs/s
Testing GPU core 'Nvidia CUDA' (Device 'GeForce 8800 GT')... 5409.43 PMKs/s
En resumen,
la GPU de su 8800 GT es casi 5 veces más rápida que sus 4 CPUs....
Otro ejemplo
es el caso de oscar, que con un Pentium Dual Core E5200 a 2.50 GHz y una Nvidia GeForce 9800 GT con 1 Gb GDDR3 tiene estos resultados:
oscar@ubuntu:~$ pyrit benchmark
Pyrit 0.2.2 (C) 2008, 2009 Lukas Lueg
http://pyrit.googlecode.comThis code is distributed under the GNU General Public License v3
The ESSID-blobspace seems to be empty; you should create an ESSID...
Running benchmark for at least 60 seconds...
CUDA-Device #1 'GeForce 9800 GT': 5120.71 PMKs/s, 85.34% occupancy
CPU-Core (x86): 231.16 PMKs/s, 98.46% occupancy
Benchmark done. 5351.86 PMKs/s total.
Seguimos con el manual... Primero debemos crear el essid de la red que queremos crakear ya que es una variable necesaria para crear las tablas rainbow a partir del diccionario en texto plano. Para ello escribimos en una terminal:
pyrit -e Fenix88 create_essid
Mi red se llama Fenix88, por lo que cambia ese nombre por el de la red deseada.
Pyrit puede administrar la creación de tablas rainbow de 2 formas distintas:
batchprocess (o
batch) el cual procesa el diccionario y almacena las tablas en el disco duro para un uso posterior, y
passthrough el cual procesa el diccionario escribiendo las tablas en la salida estándar (standard output o simplemente "stdout") para un uso inmediato, es decir, permite automatizar el ataquete por diccionario.
Sin embargo también se puede
batchprocess y
passthrough para usarlos al mismo tiempo. Tal como
nos explica lukas en su blog:
Al parecer, a menudo he pasado por alto una forma que te permite utilizar
batchprocess (calcular y escribir los resultados en el disco para su uso posterior) y
passthrough (calcular y escribir los resultados a la salida para su uso inmediato) al mismo tiempo. Todo lo que tienes que hacer es especificar '-f - ' como una opción para el comando batchprocess.
Lo que ocurre es que Pyrit procesa las contraseñas para un único ESSID (usando '-e'), almacena los resultados en el disco y las escribe en
la salida estándar (stdout). Los datos que ya se han procesado inmediatamente por escrito al
stdout.
Batchprocess continua funcionando si
stdout si no está disponible (por ejemplo, porque el programa/shell destino cerró la tubería). Si todos los resultados ya han sido computados,
batchprocess casi se comporta exactamente como hace passthrough.
De esta forma se puede detener y reanudar
passthrough con bastante facilidad. También evita la necesidad de volver a procesar todos los datos en el caso de que Pyrit sufra una caída.
Si quieres usar
passthrough en Pyrit con cowpatty debes introducir algo como esto:
pyrit -e Fenix88 -f wpa.lst passthrough | cowpatty -d - -r handshake-01.cap -s Fenix88
Pero si por el contrario quieres usar el
batchprocess entonces debemos importar primero el archivo diccionario donde residen las contraseñas a procesar (cambia wpa.lst por la ruta completa a tu diccionario).
pyrit -f wpa.lst import_passwords
Creado el essid e importadas las contraseñas sólo nos queda dar inicio al proceso de creación de las tablas rainbow.
pyrit batchprocess
Bien, si has llegado hasta aquí es que todo ha salido sin problemas, continuamos. Pyrit permite exportar la tabla rainbow en formato compatible con
Cowpatty o con
airolib-ng (de la suite aircrack-ng). De momento usaremos Cowpatty ya que parece ser algo más rápido que airolib-ng aunque este último también tiene sus ventajas.
Procedemos a exportar el diccionario desde Pyrit
pyrit -e Fenix88 -f rainbowtable.cow export_cowpatty
Luego procedemos a importar el diccionario desde cowpatty para procesarlo.
cowpatty -d rainbowtable.cow -s Fenix88 -r handshake-01.cap
Donde handshake-01.cap es el archivo cap que contiene el handshake capturado, naturalmente debes substituirlo por la ruta completa a tu archivo cap. Bueno, si has tenido suerte y la clave estaba en el diccionario debería aparecerte algo parecido a esto:
festor@sniper-win:~$ cowpatty -d DicCowpatty.cow -s Fenix88 -r handshake-01.cap
cowpatty 4.6 - WPA-PSK dictionary attack. <jwright@hasborg.com>
Collected all necessary data to mount crack against WPA2/PSK passphrase.
Starting dictionary attack. Please be patient.
key no. 10000: elipkcot
key no. 20000: queerness
key no. 30000: bynumber
key no. 40000: neuheikendorferweg
key no. 50000: biologistic
key no. 60000: loessoid
key no. 70000: surreverence
key no. 80000: consalvi
key no. 90000: needputenv
key no. 100000: yratenom
key no. 110000: fire-fly
key no. 120000: schweikardt
key no. 130000: cardphone
key no. 140000: nighness
key no. 150000: XXX/Operator
key no. 160000: hydroxyzine
key no. 170000: tectocephaly
key no. 180000: dux/SimCity
key no. 190000: nibelungenstr
key no. 200000: ResolveAlias
The PSK is "IWill51Try01Shoot9The32Web".
205478 passphrases tested in 1.64 seconds: 125473.71 passphrases/second
Si quieres puedes probar a saltarte el proceso de creación del rainbow table y trabajar directamente con el diccionario en texto plano (para ello cambia
"-d DicCowpatty.cow" por
"-f RutaCompletaATuDiccionario". Si haces esto comprobarás la tremenda diferencia de velocidad que implica usar o no
Pyrit para preprocesar el diccionario.
Fin de la guía (por ahora...
)
Mostrar Mensajes
