iphelix/packPACK (Kit de Análisis y Descifrado de Contraseñas)
PACK (Password Analysis and Cracking Toolkit) es una colección de utilidades desarrolladas para ayudar en el análisis de listas de contraseñas con el fin de mejorar el descifrado de contraseñas mediante la detección de patrones de máscaras, reglas, conjuntos de caracteres y otras características de las contraseñas. El kit genera archivos de entrada válidos para la familia de descifradores de contraseñas Hashcat.
NOTA: El kit en sí mismo no puede descifrar contraseñas, sino que está diseñado para hacer más eficiente el funcionamiento de los descifradores de contraseñas.
Antes de comenzar a utilizar el kit, debemos establecer un criterio de selección de listas de contraseñas. Dado que buscamos analizar la forma en que las personas crean sus contraseñas, debemos obtener la muestra más grande posible de contraseñas filtradas. Una de esas excelentes listas se basa en el compromiso de RockYou.com. Esta lista proporciona una colección lo suficientemente grande y diversa que ofrece buenos resultados para contraseñas comunes utilizadas en sitios similares (por ejemplo, redes sociales). El análisis obtenido de esta lista puede no funcionar para organizaciones con políticas de contraseñas específicas. Por lo tanto, seleccionar una entrada de muestra debe ser lo más cercana posible a tu objetivo. Además, trata de evitar obtener listas basadas en contraseñas ya descifradas, ya que generará un sesgo estadístico de las reglas y máscaras utilizadas por el/los individuo(s) que descifraron la lista y no por los usuarios reales.
El análisis más básico que puedes realizar es simplemente obtener la longitud más común, el conjunto de caracteres y otras características de las contraseñas en la lista proporcionada. En el siguiente ejemplo, usaremos 'rockyou.txt' que contiene aproximadamente 14 millones de contraseñas. Ejecuta statsgen.py con la siguiente línea de comandos:
$ python statsgen.py rockyou.txt
A continuación se muestra la salida del comando anterior:
_
StatsGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected]
[*] Analizando contraseñas en [rockyou.txt]
[+] Analizando 100% (14344390/14344390) de las contraseñas
NOTA: Las estadísticas a continuación son relativas al número de contraseñas analizadas, no al número total de contraseñas
[*] Longitud:
[+] 8: 20% (2966037)
[+] 7: 17% (2506271)
[+] 9: 15% (2191039)
[+] 10: 14% (2013695)
[+] 6: 13% (1947798)
...
[*] Conjunto de caracteres:
[+] loweralphanum: 42% (6074867)
[+] loweralpha: 25% (3726129)
[+] numeric: 16% (2346744)
[+] loweralphaspecialnum: 02% (426353)
[+] upperalphanum: 02% (407431)
...
[*] Complejidad de contraseña:
[+] digit: min(0) max(255)
[+] lower: min(0) max(255)
[+] upper: min(0) max(187)
[+] special: min(0) max(255)
[*] Máscaras simples:
[+] stringdigit: 37% (5339556)
[+] string: 28% (4115314)
[+] digit: 16% (2346744)
[+] digitstring: 04% (663951)
[+] othermask: 04% (576324)
...
[*] Máscaras avanzadas:
[+] ?l?l?l?l?l?l?l?l: 04% (687991)
[+] ?l?l?l?l?l?l: 04% (601152)
[+] ?l?l?l?l?l?l?l: 04% (585013)
[+] ?l?l?l?l?l?l?l?l?l: 03% (516830)
[+] ?d?d?d?d?d?d?d: 03% (487429)
...
NOTA: Puedes reducir el número de valores atípicos mostrados incluyendo el indicador --hiderare, que no mostrará ningún elemento con una ocurrencia inferior al 1%.
Esto es lo que podemos aprender inmediatamente de la lista anterior:
La última sección, "Máscaras avanzadas", contiene las máscaras que ocurren con más frecuencia en el formato de Hashcat. Los símbolos individuales se pueden interpretar de la siguiente manera:
?l - un solo carácter en minúscula
?u - un solo carácter en mayúscula
?d - un solo dígito
?s - un solo carácter especial
Por ejemplo, la primera máscara, "?l?l?l?l?l?l?l?l", coincidirá con todas las contraseñas alfabéticas en minúsculas. Dado el tamaño de la muestra, podrás descifrar aproximadamente el 4% de las contraseñas. Sin embargo, después de generar la salida inicial, es posible que te interese usar filtros para reducir los datos de las contraseñas.
Veamos cómo los usuarios de RockYou tienden a seleccionar sus contraseñas usando la máscara simple "stringdigit" (una cadena seguida de números):
$ python statsgen.py ../PACK-0.0.3/archive/rockyou.txt --simplemask stringdigit -q --hiderare
[*] Analizando contraseñas en [rockyou.txt]
[+] Analizando 37% (5339556/14344390) de las contraseñas
NOTA: Las estadísticas a continuación son relativas al número de contraseñas analizadas, no al número total de contraseñas
[*] Longitud:
[+] 8: 23% (1267260)
[+] 7: 18% (981432)
[+] 9: 17% (939971)
[+] 10: 14% (750938)
[+] 6: 11% (618983)
[+] 11: 05% (294869)
[+] 12: 03% (175875)
[+] 13: 01% (103047)
[+] 14: 01% (65958)
[*] Conjunto de caracteres:
[+] loweralphanum: 88% (4720184)
[+] upperalphanum: 06% (325941)
[+] mixedalphanum: 05% (293431)
[*] Complejidad de contraseña:
[+] digit: min(1) max(252)
[+] lower: min(0) max(46)
[+] upper: min(0) max(31)
[+] special: min(0) max(0)
[*] Máscaras simples:
[+] stringdigit: 100% (5339556)
[*] Máscaras avanzadas:
[+] ?l?l?l?l?l?l?d?d: 07% (420318)
[+] ?l?l?l?l?l?d?d: 05% (292306)
[+] ?l?l?l?l?l?l?l?d?d: 05% (273624)
[+] ?l?l?l?l?d?d?d?d: 04% (235360)
[+] ?l?l?l?l?d?d: 04% (215074)
...
La parte superior de la salida especifica qué porcentaje del total de contraseñas se analizó. En este caso, al descifrar solo las contraseñas que coinciden con la máscara "stringdigit", solo es posible recuperar alrededor del 37% del conjunto total, tal como se mostró en la salida original. A continuación, parece que solo el 11% de este tipo de contraseña utiliza algo que no sean minúsculas. Por lo tanto, sería inteligente concentrarse solo en cadenas en minúsculas que coincidan con esta máscara. Finalmente, en la sección "Máscara avanzada", podemos ver que la mayoría de las contraseñas "stringdigit" consisten en una cadena con dos o cuatro dígitos al final. Con la información obtenida de la salida anterior, podemos comenzar a crear una imagen mental de los patrones de generación de contraseñas de los usuarios objetivo.
Hay algunos otros filtros disponibles para la longitud de la contraseña, la máscara y los conjuntos de caracteres:
Longitud: --minlength y/o --maxlength
Máscara simple: --simplemask [numeric, loweralpha, upperalpha, mixedalpha, loweralphanum, etc.]
Conjuntos de caracteres: --charset [digit, string, stringdigit, digitstring, digitstringdigit, etc.]
NOTA: Se pueden especificar más de un filtro de la misma clase como una lista separada por comas:
--simplemask="stringdigit,digitstring"
Si bien la sección "Máscaras avanzadas" solo muestra patrones que coinciden con más del 1% de todas las contraseñas, puedes obtener y guardar una lista completa de máscaras de contraseña que coincidan con un diccionario dado usando el siguiente comando:
$ python statsgen.py rockyou.txt -o rockyou.masks
Todas las máscaras de contraseña y sus frecuencias se guardarán en el archivo especificado en formato CSV. Naturalmente, puedes proporcionar filtros para generar solo archivos de máscaras que coincidan con los parámetros especificados. El archivo de salida se puede usar como entrada para la herramienta MaskGen, que se cubre en la siguiente sección.
MaskGen te permite crear ataques de máscara basados en patrones para ingresar en la familia de descifradores de contraseñas Hashcat. La herramienta utiliza la salida producida por statsgen anterior con el indicador '-o' para producir el ataque de máscara más óptimo, ordenado por complejidad de máscara, ocurrencia de máscara o la relación de los dos (índice óptimo).
Ejecutemos MaskGen solo con la salida de StatGen como argumento:
$ python maskgen.py rockyou.masks
_
MaskGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected]
[*] Analizando máscaras en [rockyou.masks]
[*] Usando 1,000,000,000 claves/segundo para cálculos.
[*] Ordenando máscaras por su [optindex].
[*] Finalizada la generación de máscaras:
Máscaras generadas: 146578
Cobertura de máscaras: 100% (14344390/14344390)
Tiempo de ejecución de máscaras: >1 año
Hay varias piezas de información que debes observar:
Dado que normalmente tienes tiempo limitado para realizar y elaborar ataques, maskgen te permite especificar cuánto tiempo tienes para realizar ataques de máscara y generará la colección más óptima de máscaras según el modo de ordenación. Juguemos un poco con diferentes modos de ordenación y tiempos objetivo:
$ python maskgen.py rockyou.masks --targettime 600 --optindex -q
[*] Analizando máscaras en [rockyou.masks]
[*] Usando 1,000,000,000 claves/segundo para cálculos.
[*] Ordenando máscaras por su [optindex].
[!] Se excedió el tiempo objetivo.
[*] Finalizada la generación de máscaras:
Máscaras generadas: 779
Cobertura de máscaras: 56% (8116195/14344390)
Tiempo de ejecución de máscaras: 0:11:36
$ python maskgen.py rockyou.masks --targettime 600 --complexity -q
[*] Analizando máscaras en [rockyou.masks]
[*] Usando 1,000,000,000 claves/segundo para cálculos.
[*] Ordenando máscaras por su [complexity].
[!] Se excedió el tiempo objetivo.
[*] Finalizada la generación de máscaras:
Máscaras generadas: 5163
Cobertura de máscaras: 31% (4572346/14344390)
Tiempo de ejecución de máscaras: 0:10:01
$ python maskgen.py rockyou.masks --targettime 600 --occurrence -q
[*] Analizando máscaras en [rockyou.masks]
[*] Usando 1,000,000,000 claves/segundo para cálculos.
[*] Ordenando máscaras por su [occurrence].
[!] Se excedió el tiempo objetivo.
[*] Finalizada la generación de máscaras:
Máscaras generadas: 4
Cobertura de máscaras: 16% (2390986/14344390)
Tiempo de ejecución de máscaras: 1:34:05
Todas las ejecuciones anteriores tienen un tiempo objetivo de 600 segundos (o 10 minutos) con diferentes modos de ordenación. Según nuestros experimentos, las máscaras generadas usando el modo de ordenación OptIndex pueden descifrar el 56% de las contraseñas de RockYou en aproximadamente 10 minutos. Al mismo tiempo, las máscaras generadas usando el modo de ordenación Occurrence no solo tienen una cobertura bastante débil de solo el 16%, sino que también superaron el tiempo objetivo especificado en más de una hora.
NOTA: Las máscaras ordenadas por complejidad pueden ser muy efectivas al atacar listas basadas en políticas.
Veamos algunas de las máscaras generadas por maskgen en modo optindex usando el indicador --showmasks:
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q --showmasks
[*] Analizando máscaras en [rockyou.masks]
[*] Usando 1,000,000,000 claves/segundo para cálculos.
[*] Ordenando máscaras por su [optindex].
[L:] Máscara: [ Ocur: ] [ Tiempo: ]
...
[ 7] ?l?d?s?l?l?d?d [6 ] [ 0:00:00]
[ 8] ?s?l?l?l?l?l?l?s [3480 ] [ 0:05:36]
[ 9] ?l?l?l?l?d?d?d?d?s [1553 ] [ 0:02:30]
[ 8] ?d?l?d?d?d?l?l?l [47 ] [ 0:00:04]
[ 8] ?d?l?l?d?l?d?d?l [47 ] [ 0:00:04]
[ 8] ?d?l?l?d?d?l?d?l [47 ] [ 0:00:04]
[ 8] ?d?l?d?l?d?d?l?l [47 ] [ 0:00:04]
[ 8] ?d?d?l?l?d?l?d?l [47 ] [ 0:00:04]
[ 8] ?d?l?d?d?l?l?l?l [122 ] [ 0:00:11]
[ 8] ?u?u?d?u?d?d?d?d [18 ] [ 0:00:01]
[ 6] ?d?s?s?s?s?s [4 ] [ 0:00:00]
[10] ?l?l?l?l?l?l?l?l?d?d [213109 ] [ 5:48:02]
[!] Se excedió el tiempo objetivo.
[*] Finalizada la generación de máscaras:
Máscaras generadas: 3970
Cobertura de máscaras: 74% (10620959/14344390)
Tiempo de ejecución de máscaras: 16:10:38
Las máscaras mostradas siguen un formato bastante intuitivo:
[ 9] ?l?l?l?l?d?d?d?d?s [1553 ] [ 0:02:30]
\ \ \
\ _ máscara generada \ _ tiempo de ejecución de la máscara
\
_ longitud de la máscara _ ocurrencia de la máscara
En la muestra anterior puedes ver parte de la lógica que interviene en la generación de máscaras. Por ejemplo, mientras que la máscara '?s?l?l?l?l?l?l?s' tiene uno de los tiempos de ejecución más largos de la muestra (5 minutos), aún tiene una prioridad más alta debido a su ocurrencia relativamente mayor que '?l?l?l?l?d?d?d?d?s'. Al mismo tiempo, mientras que '?l?d?s?l?l?d?d' tiene una cobertura bastante baja, aún obtiene una prioridad más alta que otras máscaras porque, al ser una máscara de solo seis caracteres, se ejecuta muy rápidamente.
Puedes optimizar aún más tus ataques de máscara generados usando filtros. Por ejemplo, es posible que tengas hardware lo suficientemente potente como para simplemente forzar por fuerza bruta todas las contraseñas de hasta 8 caracteres. En este caso, puedes generar máscaras solo de más de 8 caracteres usando el indicador --minlength de la siguiente manera:
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q --minlength 8
[*] Analizando máscaras en [rockyou.masks]
[*] Usando 1,000,000,000 claves/segundo para cálculos.
[*] Ordenando máscaras por su [optindex].
[!] Se excedió el tiempo objetivo.
[*] Finalizada la generación de máscaras:
Máscaras generadas: 585
Cobertura de máscaras: 41% (5905182/14344390)
Tiempo de ejecución de máscaras: 15:50:36
Naturalmente, la cobertura de máscaras generada se redujo, pero estos filtros se vuelven útiles al preparar una colección de máscaras para atacar listas de contraseñas distintas de las utilizadas para generarlas.
La lista a continuación muestra filtros adicionales que puedes usar:
Opciones de filtro de máscara individual:
--minlength=8 Longitud mínima de contraseña
--maxlength=8 Longitud máxima de contraseña
--mintime=3600 Tiempo de ejecución mínimo de máscara (segundos)
--maxtime=3600 Tiempo de ejecución máximo de máscara (segundos)
--mincomplexity=1 Complejidad mínima
--maxcomplexity=100
Complejidad máxima
--minoccurrence=1 Ocurrencia mínima
--maxoccurrence=100
Ocurrencia máxima
Los indicadores de ocurrencia y complejidad pueden ser particularmente potentes para ajustar las máscaras generadas usando diferentes modos de ordenación.
Una vez que estés satisfecho con las máscaras generadas anteriormente, puedes guardarlas usando el indicador -o:
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q -o rockyou.hcmask
[*] Analizando máscaras en [rockyou.masks]
[*] Guardando máscaras generadas en [rockyou.hcmask]
[*] Usando 1,000,000,000 claves/segundo para cálculos.
[*] Ordenando máscaras por su [optindex].
[!] Se excedió el tiempo objetivo.
[*] Finalizada la generación de máscaras:
Máscaras generadas: 3970
Cobertura de máscaras: 74% (10620959/14344390)
Tiempo de ejecución de máscaras: 16:10:38
Esto producirá un archivo 'rockyou.hcmask' que se puede usar directamente con el conjunto de herramientas Hashcat o como parte de un script personalizado que recorra las máscaras.
A menudo es útil ver qué tan bien se desempeñan las máscaras generadas contra listas ya descifradas. Maskgen puede comparar una colección de máscaras contra otras para ver qué tan bien se desempeñarían si se intentaran máscaras de una lista de contraseñas contra otra. Comparemos qué tan bien se desempeñarán las máscaras generadas a partir de la lista de RockYou contra otra lista comprometida, como Gawker:
$ python statsgen.py ../PACK-0.0.3/archive/gawker.dic -o gawker.masks
$ python maskgen.py gawker.masks --checkmasksfile rockyou.hcmask -q
[*] Analizando máscaras en [gawker.masks]
[*] Usando 1,000,000,000 claves/segundo para cálculos.
[*] Comprobando cobertura de máscaras en [rockyou.hcmask]
[*] Finalizada la coincidencia de máscaras:
Máscaras coincidentes: 1775
Cobertura de máscaras: 96% (1048889/1084394)
Tiempo de ejecución de máscaras: 16:25:44
Usando el parámetro '--checkmasksfile', intentamos ejecutar las máscaras dentro del archivo 'rockyou.hcmask' generado anteriormente contra las máscaras de una lista filtrada de muestra 'gawker.masks'. Esto resulta en una buena cobertura del 96%, donde 1775 de las 3970 máscaras totales generadas basadas en RockYou coincidieron con las máscaras en la lista de Gawker.
También es posible ver la cobertura de una o más máscaras especificándolas directamente en la línea de comandos de la siguiente manera:
$ python maskgen.py gawker.masks --checkmasks="?u?l?l?l?l?l?d,?l?l?l?l?l?d?d" -q
[*] Analizando máscaras en [gawker.masks]
[*] Usando 1,000,000,000 claves/segundo para cálculos.
[*] Comprobando cobertura de estas máscaras [?u?l?l?l?l?l?d, ?l?l?l?l?l?d?d]
[*] Finalizada la coincidencia de máscaras:
Máscaras coincidentes: 2
Cobertura de máscaras: 1% (18144/1084394)
Tiempo de ejecución de máscaras: 0:00:04
Ambas máscaras especificadas coincidieron con solo un 1% de cobertura.
Dependiendo de las especificaciones exactas de tu hardware y del hash objetivo, es posible que desees aumentar o disminuir la velocidad de claves/segundo utilizada durante los cálculos usando el parámetro '--pps':
$ python maskgen.py rockyou.masks --targettime 43200 --pps 50000000 -q
[*] Analizando máscaras en [rockyou.masks]
[*] Usando 50,000,000 claves/segundo para cálculos.
[*] Ordenando máscaras por su [optindex].
[!] Se excedió el tiempo objetivo.
[*] Finalizada la generación de máscaras:
Máscaras generadas: 1192
Cobertura de máscaras: 61% (8754548/14344390)
Tiempo de ejecución de máscaras: 12:17:31
Usar el parámetro '--pps' para igualar tu rendimiento real hace que el tiempo objetivo sea más significativo.
Muchos de los ataques de máscara y diccionario fallarán en el entorno corporativo con requisitos mínimos de complejidad de contraseñas. En lugar de recurrir a un ataque de fuerza bruta pura, podemos aprovechar reglas de complejidad de contraseñas conocidas o supuestas para evitar probar candidatos de contraseñas que no cumplan con la política, o inversamente, auditar solo las contraseñas no conformes. Con PolicyGen, podrás generar una colección de máscaras que sigan la complejidad de la contraseña para reducir significativamente el tiempo de descifrado.
A continuación se muestra una sesión de ejemplo donde generamos todas las máscaras de contraseña válidas para un entorno que requiere al menos un dígito, una mayúscula y un carácter especial.
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o complexity.hcmask
_
PolicyGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected][*] Guardando máscaras generadas en [complexity.hcmask]
[*] Usando 1,000,000,000 llaves/seg para cálculos.
[*] Política de contraseñas:
Longitudes de contraseña: min:8 max:8
Fuerza mínima: l:1 u:1 d:1 s:1
Fuerza máxima: l:None u:None d:None s:None
[*] Generando máscaras [compliant].
[*] Generando máscaras de contraseñas de 8 caracteres.
[*] Máscaras totales: 65536 Tiempo: 76 días, 18:50:04
[*] Máscaras de política: 40824 Tiempo: 35 días, 0:33:09
De la salida anterior se puede ver que hemos generado 40824 máscaras que coinciden con la complejidad especificada y que tomarán aproximadamente 35 días en ejecutarse a una velocidad de 1,000,000,000 llaves/seg.
En caso de que simplemente estés realizando una auditoría de contraseñas y tengas la tarea de descubrir solo contraseñas no conformes, puedes especificar la bandera '--noncompliant' para invertir las máscaras generadas:
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o noncompliant.hcmask -q --noncompliant
[*] Guardando máscaras generadas en [noncompliant.hcmask]
[*] Usando 1,000,000,000 llaves/seg para cálculos.
[*] Política de contraseñas:
Longitudes de contraseña: min:8 max:8
Fuerza mínima: l:1 u:1 d:1 s:1
Fuerza máxima: l:None u:None d:None s:None
[*] Generando máscaras [non-compliant].
[*] Generando máscaras de contraseñas de 8 caracteres.
[*] Máscaras totales: 65536 Tiempo: 76 días, 18:50:04
[*] Máscaras de política: 24712 Tiempo: 41 días, 18:16:55
Veamos algunas de las máscaras no conformes generadas arriba usando la bandera '--showmasks':
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o noncompliant.hcmask -q --noncompliant --showmasks
[*] Guardando máscaras generadas en [noncompliant.hcmask]
[*] Usando 1,000,000,000 llaves/seg para cálculos.
[*] Política de contraseñas:
Longitudes de contraseña: min:8 max:8
Fuerza mínima: l:1 u:1 d:1 s:1
Fuerza máxima: l:None u:None d:None s:None
[*] Generando máscaras [non-compliant].
[*] Generando máscaras de contraseñas de 8 caracteres.
[ 8] ?d?d?d?d?d?d?d?d [l: 0 u: 0 d: 8 s: 0] [ 0:00:00]
[ 8] ?d?d?d?d?d?d?d?l [l: 1 u: 0 d: 7 s: 0] [ 0:00:00]
[ 8] ?d?d?d?d?d?d?d?u [l: 0 u: 1 d: 7 s: 0] [ 0:00:00]
[ 8] ?d?d?d?d?d?d?d?s [l: 0 u: 0 d: 7 s: 1] [ 0:00:00]
...
[ 8] ?s?s?s?s?s?s?s?d [l: 0 u: 0 d: 1 s: 7] [ 0:07:06]
[ 8] ?s?s?s?s?s?s?s?l [l: 1 u: 0 d: 0 s: 7] [ 0:18:28]
[ 8] ?s?s?s?s?s?s?s?u [l: 0 u: 1 d: 0 s: 7] [ 0:18:28]
[ 8] ?s?s?s?s?s?s?s?s [l: 0 u: 0 d: 0 s: 8] [ 0:23:26]
[*] Máscaras totales: 65536 Tiempo: 76 días, 18:50:04
[*] Máscaras de política: 24712 Tiempo: 41 días, 18:16:55
Como puedes ver, todas las máscaras tienen al menos un requisito de complejidad de contraseña faltante. Curiosamente, con menos máscaras generadas, el ataque tarda más debido a máscaras de larga duración como '?s?s?s?s?s?s?s?s'.
También es posible especificar la complejidad máxima de contraseña usando las banderas --maxlower, --maxupper, --maxdigit y --maxspecial para ajustar tu ataque. Por ejemplo, a continuación se muestra un sitio de muestra que aplica una política de contraseñas pero no permite ningún carácter especial:
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --maxspecial 0 -o maxcomplexity.hcmask -q
[*] Guardando máscaras generadas en [maxcomplexity.hcmask]
[*] Usando 1,000,000,000 llaves/seg para cálculos.
[*] Política de contraseñas:
Longitudes de contraseña: min:8 max:8
Fuerza mínima: l:1 u:1 d:1 s:None
Fuerza máxima: l:None u:None d:None s:0
[*] Generando máscaras [compliant].
[*] Generando máscaras de contraseñas de 8 caracteres.
[*] Máscaras totales: 65536 Tiempo: 76 días, 18:50:04
[*] Máscaras de política: 5796 Tiempo: 1 día, 20:20:55
rulegen.py implementa análisis de contraseñas y generación de reglas para el cracker de contraseñas Hashcat, como se describe en el artículo Automatic Password Rule Analysis and Generation. Revisa este documento para una discusión detallada sobre la teoría del análisis y generación de reglas.
Reversar palabras fuente y reglas de transformación de palabras a partir de contraseñas ya descifradas puede ser muy efectivo para realizar ataques contra hashes aún encriptados. Al reciclar/expandir continuamente las reglas y palabras generadas, es posible descifrar una mayor cantidad de contraseñas.
Hay varios requisitos previos para el uso efectivo de rulegen.py. La herramienta utiliza la biblioteca de revisión ortográfica Enchant para interactuar con varios motores de revisión ortográfica como Aspell, MySpell, etc. Debes instalar estas herramientas antes de usar. También es crítico instalar diccionarios para el motor de revisión ortográfica que termines usando (alternativamente es posible usar una lista de palabras personalizada). Por último, he empaquetado PyEnchant por conveniencia, que debería interactuar directamente con las bibliotecas compartidas de Enchant; sin embargo, si hay algún problema, simplemente elimina el directorio 'enchant' empaquetado e instala PyEnchant para tu distribución.
Para detalles adicionales sobre la sintaxis específica de reglas de Hashcat, consulta Hashcat Rule Based Attack.
El uso más básico de rulegen.py implica el análisis de una sola contraseña para detectar reglas automáticamente. Vamos a detectar reglas y la posible palabra fuente utilizada para generar una contraseña de ejemplo P@55w0rd123:
$ python rulegen.py --verbose --password P@55w0rd123
_
RuleGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected]
[*] Usando el módulo Enchant 'aspell'. Para mejores resultados, instala
los diccionarios de idioma del módulo 'aspell'.
[*] Analizando contraseña: P@55w0rd123
[-] Pas sword => {distancia de edición subóptima: 8 (7)} => P@55w0rd123
[+] Password => sa@ ss5 so0 $1 $2 $3 => P@55w0rd123
[+] Passwords => sa@ ss5 so0 o81 $2 $3 => P@55w0rd123
[+] Passwords => sa@ ss5 so0 i81 o92 $3 => P@55w0rd123
[+] Passwords => sa@ ss5 so0 i81 i92 oA3 => P@55w0rd123
[+] Password's => sa@ ss5 so0 o81 o92 $3 => P@55w0rd123
[+] Password's => sa@ ss5 so0 o81 i92 oA3 => P@55w0rd123
[+] Password's => sa@ ss5 so0 i81 o92 oA3 => P@55w0rd123
Hay varias banderas que hemos usado en este ejemplo:
Procesar archivos de contraseñas se cubre en una sección a continuación; sin embargo, primero discutamos algunas de las opciones de ajuste disponibles usando una sola contraseña como ejemplo.
Observa que estamos usando el módulo Enchant aspell para la detección de palabras fuente. El motor de revisión ortográfica exacto se puede cambiar usando la bandera --provider de la siguiente manera:
$ python rulegen.py --verbose --provider myspell --password P@55w0rd123 -q
[*] Usando el módulo Enchant 'myspell'. Para mejores resultados, instala
los diccionarios de idioma del módulo 'myspell'.
...
NOTA: La prioridad del motor del proveedor se puede especificar usando una lista separada por comas (por ejemplo, --provider aspell,myspell).
El uso del motor de detección de palabras fuente se puede deshabilitar por completo especificando una palabra fuente con la bandera --word:
$ python rulegen.py -q --verbose --word word --password P@55w0rd123
[*] Analizando contraseña: P@55w0rd123
[+] word => ^5 ^5 ^@ ^P so0 $1 $2 $3 => P@55w0rd123
Al especificar diferentes palabras fuente, puedes divertirte mucho experimentando con el motor de generación de reglas.
Inevitablemente llegarás a un punto donde generar reglas usando la lista de palabras estándar del motor de ortografía ya no es suficiente. Puedes especificar una lista de palabras personalizada usando la bandera --wordlist. Esto es particularmente útil cuando se reutilizan palabras fuente de una sesión de análisis anterior:
$ python rulegen.py -q --verbose --wordlist rockyou.txt --password 1pa55w0rd1
[*] Usando el módulo Enchant 'Personal Wordlist'. Para mejores resultados, instala
los diccionarios de idioma del módulo 'Personal Wordlist'.
[*] Analizando contraseña: 1pa55w0rd1
[+] password => ^1 ss5 so0 $1 => 1pa55w0rd1
La lista de palabras personalizada puede ser particularmente útil cuando se usan palabras que normalmente no se encuentran como jerga, así como contraseñas ya descifradas.
Aunque rulegen.py intenta generar y registrar solo las mejores palabras fuente y contraseñas, puede haber casos en los que estés interesado en más resultados. Usa las banderas --morewords y --morerules para generar palabras y reglas que pueden exceder la distancia de edición óptima:
$ python rulegen.py -q --verbose --password '$m0n3y$' --morerules --morewords
[*] Usando el módulo Enchant 'aspell'. Para mejores resultados, instala
los diccionarios de idioma del módulo 'aspell'.
[*] Analizando contraseña: $m0n3y$
[+] money => ^$ so0 se3 $$ => $m0n3y$
[+] moneys => ^$ so0 se3 o6$ => $m0n3y$
[+] mingy => ^$ si0 sg3 $$ => $m0n3y$
[+] many => ^$ sa0 i43 $$ => $m0n3y$
[+] Mooney => sM$ o1m so0 se3 $$ => $m0n3y$
Es posible expandir aún más las palabras generadas usando las banderas --maxworddist y --maxwords. De manera similar, puedes producir más reglas usando las banderas --maxrulelen y --maxrules.
rulegen.py incluye varios motores avanzados para generar palabras y reglas de mejor calidad. Es posible deshabilitarlos para observar la diferencia (o si están causando problemas) usando las banderas --simplewords y --simplerules. Observemos cómo cambian tanto las palabras fuente como las reglas con estas banderas activadas:
$ python rulegen.py -q --verbose --password '$m0n3y$' --simplewords --simplerules
[*] Usando el módulo Enchant 'aspell'. Para mejores resultados, instala
los diccionarios de idioma del módulo 'aspell'.
[*] Analizando contraseña: $m0n3y$
[-] Meany => {distancia de edición subóptima: 5 (4)} => $m0n3y$
[+] many => i0$ o20 i43 i6$ => $m0n3y$
[+] mingy => i0$ o20 o43 i6$ => $m0n3y$
[+] money => i0$ o20 o43 i6$ => $m0n3y$
[+] mangy => i0$ o20 o43 i6$ => $m0n3y$
[+] manky => i0$ o20 o43 i6$ => $m0n3y$
Observa que la calidad de las palabras y reglas generadas se redujo significativamente, con palabras como 'manky' teniendo menos relación con la palabra fuente real 'money'. Al mismo tiempo, las reglas generadas se redujeron a simples inserciones, eliminaciones y reemplazos.
Ahora que has dominado todas las diferentes banderas y opciones, podemos intentar generar palabras y reglas para una colección de contraseñas. Vamos a generar un archivo de texto korelogic.txt que contenga las siguientes contraseñas de prueba bastante complejas:
&~defcon
'#(4)\
August19681
'&a123456
10-D'Ann
~|Bailey
Krist0f3r
f@cebOOK
Nuclear$(
zxcvbn2010!
13Hark's
NjB3qqm
Sydney93?
antalya%]
Annl05de
;-Fluffy
Ahora observemos el análisis de rulegen.py simplemente especificando el archivo de contraseñas como primer argumento:
$ python rulegen.py korelogic.txt -q
[*] Usando el módulo Enchant 'aspell'. Para mejores resultados, instala
los diccionarios de idioma del módulo 'aspell'.
[*] Analizando archivo de contraseñas: korelogic.txt:
[*] Presiona Ctrl-C para finalizar la ejecución y generar un análisis estadístico.
[*] Guardando reglas en analysis.rule
[*] Guardando palabras en analysis.word
[*] Procesadas 16 contraseñas en 1.00 segundos a una tasa de 15.94 p/seg
[*] Generando estadísticas para reglas y palabras [analysis].
[-] Omitidas 0 contraseñas completamente numéricas (0.00%)
[-] Omitidas 2 contraseñas con menos del 25% de caracteres alfabéticos (12.50%)
[-] Omitidas 0 contraseñas con caracteres no ASCII (0.00%)
[*] Top 10 reglas
[+] ^3 ^1 o4r - 3 (2.00%)
[+] i61 i79 i86 i98 oA1 - 2 (1.00%)
[+] ^- ^0 ^1 i4' o5A - 2 (1.00%)
[+] sS1 i13 T2 - 1 (0.00%)
[+] i61 se9 i86 i98 oA1 - 1 (0.00%)
[+] o61 i79 i86 i98 oA1 - 1 (0.00%)
[+] ^- ^0 ^1 so' i5A - 1 (0.00%)
[+] D3 si0 i55 $e - 1 (0.00%)
[+] i61 i79 se6 i98 oA1 - 1 (0.00%)
[+] i3a o5y o6a i7% o8] - 1 (0.00%)
[*] Top 10 palabras
[+] Analyze - 1 (0.00%)
[+] defcon - 1 (0.00%)
[+] Kristen - 1 (0.00%)
[+] Bailey - 1 (0.00%)
[+] Augusts - 1 (0.00%)
[+] Annelid - 1 (0.00%)
[+] Hack's - 1 (0.00%)
[+] antlers - 1 (0.00%)
[+] antelope - 1 (0.00%)
[+] xxxv - 1 (0.00%)
Usando todas las configuraciones predeterminadas, pudimos producir varias reglas de alta calidad. La aplicación muestra algunas estadísticas básicas de las Top 10 reglas y palabras. Todas las reglas y palabras generadas se guardan usando el nombre base 'analysis' de forma predeterminada:
Observa que varias contraseñas como '#(4)' y '&a123456' fueron omitidas porque no tienen características suficientes para ser procesadas. Además del recuento de caracteres alfabéticos, el programa omitirá todas las contraseñas numéricas y aquellas que contengan caracteres no ASCII. Esto último se debe a un error en el motor Enchant que espero corregir en el futuro, permitiendo así el procesamiento de palabras en muchos idiomas.
Como se mencionó anteriormente, rulegen.py guarda los archivos de salida usando el nombre base 'analysis' de forma predeterminada. Puedes cambiar el nombre base del archivo con la bandera --basename o -b de la siguiente manera:
$ python rulegen.py korelogic.txt -q -b korelogic
[*] Usando el módulo Enchant 'aspell'. Para mejores resultados, instala
los diccionarios de idioma del módulo 'aspell'.
[*] Analizando archivo de contraseñas: korelogic.txt:
[*] Presiona Ctrl-C para finalizar la ejecución y generar un análisis estadístico.
[*] Guardando reglas en korelogic.rule
[*] Guardando palabras en korelogic.word
Puede haber situaciones en las que tengas problemas para generar reglas para el cracker de contraseñas Hashcat. rulegen.py incluye la bandera --hashcat para validar las palabras y reglas generadas usando el propio hashcat en modo --stdout. Para que este modo funcione correctamente, debes descargar la última versión de hashcat-cli y editar la variable HASHCAT_PATH en el código fuente. Por ejemplo, al momento de escribir esto, he colocado la carpeta hashcat-0.## en el directorio PACK y definí HASHCAT_PATH como 'hashcat-0.##/'.
También puedes observar el funcionamiento interno del motor de generación de reglas con la bandera --debug. No te preocupes por los mensajes de ciertos errores de reglas, esto es el resultado del solucionador del problema de la parada que intenta encontrar una solución óptima y válida.
Aunque esta guía introduce varios métodos para analizar contraseñas, revertir reglas y generar máscaras, hay otros trucos que te esperan para que descubras. Me emocionaría si me contaras sobre algún uso inusual o sugerencias para cualquiera de las herramientas cubiertas.
¡Feliz Cracking!
-Peter