¿Cómo puedo hacer fuerza bruta en una contraseña WPA2 en las siguientes condiciones?

6

Estoy tratando de forzar mi propia conexión WiFi, y por mi propia investigación, sé que todas las contraseñas predeterminadas para este modelo específico de enrutador que intento hackear siguen las siguientes reglas:

  1. longitud de la contraseña = 8

  2. El conjunto de caracteres [a-zA-Z0-9]

  3. Cada carácter solo puede usarse una vez en la contraseña

  4. Hay como mínimo 2 minúsculas, 2 mayúsculas y 2 números presentes.

Ejemplos de contraseñas posibles: r3wN4HTl, 5j3Wkl5Da, etc ...

¿Cómo puedo proceder con esta fuerza bruta, cuántas combinaciones habrá y cuál sería el tiempo estimado para descifrar la contraseña con éxito?

    
pregunta Masky 09.04.2017 - 12:40
fuente

3 respuestas

6

Si asumimos que su frase de contraseña fue generada aleatoriamente (no influenciada por factores de selección humanos), entonces algunas matemáticas básicas y un par de herramientas pueden ayudarlo a llegar hasta allí. Su restricción # 3 (cada carácter solo se puede usar una vez) es la más difícil, pero probablemente no reduciría mucho el espacio total de las combinaciones, por lo que recomiendo dejarlo de lado por ahora.

Capturando la complejidad

Primero, eche un vistazo a la herramienta policygen en el kit de herramientas PACK . Puede generar un conjunto de máscaras que coincidan con su longitud y sus mínimos.

También puede informar la estimación de tiempo usando el parámetro policygen ' --pps . Esto le dice a policygen cuántas contraseñas por segundo puede intentar su plataforma objetivo.

Por ejemplo, si tiene una GPU similar a mi GTX 970 SC (que puede hacer 185 kH / s para WPA / WPA2 usando hashcat ), obtendrá algo como lo siguiente:

$ policygen --pps=185000 --minlength=8 --maxlength=8 \
  --mindigit=2 --minlower=2 --minupper=2 --maxspecial=0 -o test.masks
                       _
     PolicyGen 0.0.2  | |
      _ __   __ _  ___| | _
     | '_ \ / _' |/ __| |/ /
     | |_) | (_| | (__|   <
     | .__/ \__,_|\___|_|\_\
     | |
     |_| [email protected]


[*] Saving generated masks to [test.masks]
[*] Using 185,000 keys/sec for calculations.
[*] Password policy:
    Pass Lengths: min:8 max:8
    Min strength: l:2 u:2 d:2 s:None
    Max strength: l:None u:None d:None s:0
[*] Generating [compliant] masks.
[*] Generating 8 character password masks.
[*] Total Masks:  65536 Time: >1 year
[*] Policy Masks: 2940 Time: >1 year

$ wc -l test.masks
2940 test.masks

El conjunto resultante de 2940 máscaras cubre el conjunto de todas las posibilidades que coinciden con tus restricciones.

Estimando el tiempo

Tenga en cuenta que policygen estima que el tiempo será de más de 1 año. Para una estimación más cercana, es posible que no pueda predecir cuándo se descifra su frase de contraseña específica, pero puede establecer un límite superior y un promedio (la mitad de ese límite superior).

Al utilizar la herramienta de procesador de máscara de hashcat , puede obtener el número total de combinaciones para un Máscara dada. Ejecutando eso contra cada máscara, y sumando los resultados:

for mask in 'cat test.mask'; do \
    mp64 --combinations $mask; done \
    | awk '{s+=$1} END {print s}'

... produce el siguiente número:

5.84746e+13

o aproximadamente 58474600000000 combinaciones . Suponiendo 185,000 hashes por segundo, eso es (5.84746e + 13/1985000) / 60/60/24 = 340,95 días, o aproximadamente un año para agotar todo el espacio de teclas . La frase de contraseña promedio se eliminaría dentro de medio año (la mitad del tiempo necesario para recorrer el espacio total de teclas).

Por supuesto, esta estimación de tiempo está vinculada directamente a la potencia de cómputo disponible. A medida que agregue más GPU a la mezcla, el rendimiento aumentará linealmente con su rendimiento.

Iniciando el ataque

Para intentar descifrarlo, simplemente alimentarías tu protocolo de enlace WPA2 y tu lista de máscaras a hashcat , así. Tenga en cuenta que esta plataforma tiene más de una GPU.

$ ./hashcat -w 4 -a 3 -m 2500 [your-wpa2-hccapx-filename] test.masks

hashcat (v3.5.0) starting...

OpenCL Platform #1: NVIDIA Corporation
======================================
* Device #1: GeForce GTX 1080, 2028/8113 MB allocatable, 20MCU
* Device #2: GeForce GTX 1080, 2028/8114 MB allocatable, 20MCU
* Device #3: GeForce GTX 1080, 2028/8114 MB allocatable, 20MCU
* Device #4: GeForce GTX 1080, 2028/8114 MB allocatable, 20MCU
* Device #5: GeForce GTX 970, 1009/4037 MB allocatable, 13MCU
* Device #6: GeForce GTX 970, 1009/4037 MB allocatable, 13MCU

OpenCL Platform #2: Advanced Micro Devices, Inc.
================================================
* Device #7: AMD FX(tm)-8350 Eight-Core Processor, skipped.

Hashes: 1 digests; 1 unique digests, 1 unique salts
Bitmaps: 16 bits, 65536 entries, 0x0000ffff mask, 262144 bytes, 5/13 rotates

Applicable optimizers:
* Zero-Byte
* Single-Hash
* Single-Salt
* Brute-Force
* Slow-Hash-SIMD

Watchdog: Temperature abort trigger set to 90c
Watchdog: Temperature retain trigger disabled.

[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit =>


Session..........: hashcat
Status...........: Running
Hash.Type........: WPA/WPA2
Hash.Target......: 8381533406003807685881523 (AP:ae:f5:0f:22:80:1c STA:98:7b:dc:f9:f9:50)
Time.Started.....: Sun Apr  9 07:30:31 2017 (1 sec)
Time.Estimated...: Sun Apr  9 08:08:54 2017 (38 mins, 22 secs)
Guess.Mask.......: ?d?d?d?d?l?l?u?u [8]
Guess.Queue......: 1/2940 (0.03%)
Speed.Dev.#1.....:   401.7 kH/s (403.50ms)
Speed.Dev.#2.....:   402.4 kH/s (405.15ms)
Speed.Dev.#3.....:   405.4 kH/s (402.24ms)
Speed.Dev.#4.....:   403.3 kH/s (400.39ms)
Speed.Dev.#5.....:   187.0 kH/s (283.22ms)
Speed.Dev.#6.....:   185.3 kH/s (285.72ms)
Speed.Dev.#*.....:  1985.0 kH/s
Recovered........: 0/1 (0.00%) Digests, 0/1 (0.00%) Salts
Progress.........: 0/4569760000 (0.00%)
Rejected.........: 0/0 (0.00%)
Restore.Point....: 0/456976000 (0.00%)
Candidates.#1....: 1234maMA -> 1618pqAN
Candidates.#2....: 1218pqAN -> 1667yzMA
Candidates.#3....: 1242yzMA -> 1631tgBA
Candidates.#4....: 1771seGO -> 1558paAN
Candidates.#5....: 1784jaAN -> 1816blON
Candidates.#6....: 1261tgBA -> 1523reGO
HWMon.Dev.#1.....: Temp: 63c Fan: 90% Util:100% Core:1822MHz Mem:4513MHz Bus:8
HWMon.Dev.#2.....: Temp: 55c Fan: 90% Util:100% Core:1809MHz Mem:4513MHz Bus:4
HWMon.Dev.#3.....: Temp: 56c Fan: 90% Util:100% Core:1822MHz Mem:4513MHz Bus:16
HWMon.Dev.#4.....: Temp: 50c Fan: 90% Util:100% Core:1822MHz Mem:4513MHz Bus:4
HWMon.Dev.#5.....: Temp: 54c Fan: 60% Util:100% Core:1379MHz Mem:3004MHz Bus:1
HWMon.Dev.#6.....: Temp: 58c Fan: 60% Util:100% Core:1366MHz Mem:3004MHz Bus:1

hashcat comenzará a trabajar a través de su lista de máscaras, una a la vez. Dado que policygen ordena las máscaras en orden de complejidad (aproximadamente), las más rápidas aparecen primero en la lista. Por lo tanto, cada máscara tenderá a tomar (aproximadamente) más tiempo que las anteriores.

Probablemente no querrás esperar hasta que esté listo. :)

    
respondido por el Royce Williams 09.04.2017 - 17:27
fuente
1

Tengo un método diferente para calcular esto, y desafortunadamente alcanzo otro valor.

Debes usar 2 dígitos por lo menos, así que para el primero, hay 10 posibilidades, para el segundo 9, que hace 90 pares posibles.

Analógico para letras 26 * 25 combinaciones mayúsculas y minúsculas.

Después de elegir 6 caracteres de esta manera, tenemos libertad para los dos últimos, que es (26 + 26 + 10-6) = (62-6) = 56 y 55 para el último.

En combinación, esto es ((10 * 9 * 26 * 25 * 26 * 25 * 56 * 55)) combinaciones, solo para los caracteres, la contraseña puede consistir, sin saber el orden correcto.

Eso es 117 117 000 000 (117 mil millones, 1.2e12).

Multiplicé los 8! = (40320) combinaciones aleatorias por combinación posible, por lo tanto alcanzo

4 722 157 440 000 000 (4.7e16)

No sé de dónde viene la diferencia, especialmente no, qué significa binom (26, inferior).

Si factorizo ambos resultados, obtengo esto:

factor $((10*9*26*25*26*25*56*55*40320)) 
4722157440000000: 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 3 5 5 5 5 5 5 5 7 7 11 13 13

factor 58474600000000
58474600000000: 2 2 2 2 2 2 2 2 2 5 5 5 5 5 5 5 5 61 4793

No entiendo de dónde viene el 4793, también, como el 61. Para mi resultado, creo que parece razonable: 2x26 se puede factorizar a 2x (2x13), el 11 es de 5x11 = 55 y pronto.

    
respondido por el user unknown 07.02.2018 - 16:18
fuente
0

Sueño con un futuro donde todas las preguntas para enseñar combinatoria sean "¿Cuántas contraseñas existen siguiendo estos criterios?".

Vamos a divertirnos.

Primero, tienes 62 caracteres, 8 de ellos hacen aproximadamente 2.18e14 posibilidades. Así que eso es un límite superior. Dado que también usamos todos los personajes una vez como máximo de acuerdo con la condición 4, esto se reduce a 62 * 61 * ... * 55 posibilidades o aproximadamente 1.36e14.

Segundo, necesitamos al menos 2 minúsculas, 2 mayúsculas y 2 números. Si solo contamos cuántas veces ocurre cada categoría, todas las contraseñas se dividen en 2 de 4 = 6 categorías.

  1. 4L + 2U + 2D o 2L + 4U + 2D
  2. 2L + 2U + 4D
  3. 3L + 3U + 2D
  4. 3L + 2U + 3D o 2L + 3U + 3D

Para cada categoría tenemos binom (26, inferior) * binom (26, superior) * binom (10, dígitos) posibles selecciones de letras y 8! Permutaciones de la selección. (El hecho de que las letras no puedan repetirse hace que las cosas sean mucho más fáciles aquí).

Eso da un total de aproximadamente 3.90e13 posibles contraseñas. (La herramienta policygen que utilizó Royce no permite especificar que cada letra se pueda usar solo una vez, por lo que este número es ligeramente inferior).

    
respondido por el Elias 09.04.2017 - 22:39
fuente

Lea otras preguntas en las etiquetas