Underc0de

Saludos herma@s.

En el mundo del hacking tenemos una técnica llamada fuerza bruta, bien vista por algunos y mal vista por otros, pero no es este el lugar de debatir sobre la calidad de la técnica, pues según wikipedia la fuerza bruta es:

"La forma de recuperar una clave probando todas las combinaciones posibles hasta encontrar aquella que permite el acceso."

Muy bien, para orquestar este tipo de ataque necesitaremos un archivo que contenga dentro de si cientos, miles e incluso millones de palabras para ir probando 1 por 1 hasta dar con el valido, estos archivos en buen español se llaman diccionarios y los gringos para que nadie se confunda les dicen wordlists (listas de palabras).

Ahora quiero que se imaginen que tengamos que crear un diccionario escribiendo todas las posibles palabras 1 por 1, no tendría sentido y tampoco sería práctico, así que existen programas que generan diccionarios automáticamente simplemente especificando algunos parámetros de entrada, entre esos programas podrían decirse que el más conocido es Crunch, una aplicación sin interfaz gráfica que tiene una gran flexibilidad al momento de generar diccionarios/wordlists, existe mucha documentación sobre el mismo, pero generalmente se explican 1 ó 2 ejemplos sobre su uso, dejando al usuario descubrir el resto, pues aqui en underc0de les vamos a regalar un manual completo con todas las opciones y usos prácticos para que no quede duda alguna, esto sera algo asi como un taller de Crunch, asi que aborden el loco barco del conocimiento y vamos a ello.


Crunch es un programa que basandose en criterios establecidos por el usuario (input) es capaz de generar diccionarios para ser usados en fuerza bruta (output), el resultado de Crunch puede ser visto en pantalla, puede ser guardado en un archivo .txt ó puede enviarse a otro programa en tiempo real para su uso.

La version 1.0 fue creada por mima_yin (mimayin@ACiiiD (https://underc0de.org/foro/index.php?action=profile;u=22110).ath.cx) y todas las versiones posteriores fueron actualizadas y desarrolladas por bofh28 ([email protected]) a ellos todo el agradecimiento y el respeto por tan maravillosa herramienta.

La pagina oficial es:

http://sourceforge.net/projects/crunch-wordlist/files/ (http://sourceforge.net/projects/crunch-wordlist/files/)

[/b]

LINUX

Pues en cualquier distro Linux bastaria con tirar de la terminal y escribir:

sudo apt-get install crunch

Dependiendo de la distribución podríamos tener uno que otro gestor de paquetes, así que cada cual podría modificar el comando de acuerdo a sus sistemas (yum, pacman, aptitude, etc..)

Imaginando que no este en los repositorios de software podriamos bajarnos el tarball e instalar nosotros mismos:

git clone http://git.code.sf.net/p/crunch-wordlist/code crunch-wordlist-code
cd crunch-wordlist-code;
sudo make && sudo make install;

Windows

Pues el creador no ha liberado una version oficial para los usuarios de windows, pero venga que aqui llega la magia del software open-source, y es que un usuario, mejor dicho una usuaria (maripuri) ha compilado la version 3.2 de crunch para windows, asi que a ella muchas gracias por su esfuerzo y trabajo, los interesados pueden bajarse el fichero desde aqui:

http://www.mediafire.com/download/dywlwgrb44vrza2/crunh+3.2+para+windows.rar
(http://www.mediafire.com/download/dywlwgrb44vrza2/crunh+3.2+para+windows.rar)


Muy bien herman@s ha llegado el momento de la verdad, ha llegado el momento de desnudar esta maravillosa herramienta y poder hacer uso de ella de una forma eficiente, a continuacion veremos su uso, desde la ejecucion mas sencilla hasta la ams compleja.

Bastaria con escribir "crunch" en una terminal para conseguir informacion:


Donde podemos ller claramente la forma sencilla en que podemos hacer uso de ella:


Usage: crunch <min> <max> [options]
where min and max are numbers

Es tan sencillo como decirle la cantidad de caracteres que estamos buscando seguido de alguna opcion, vamos a lanzarlo de una forma basica a ver que tal, probemos con generar todas las posibles combinaciones para una palabra de 4 caracteres:

crunch 4 4


Como se aprecia en la imagen crunch avisa de una froma muy educada cuantas lineas seran generadas y cuanto espacio ocupara, a continuacion les comparto las primeras 50 lineas de la salida en pantalla:

aaaa
aaab
aaac
aaad
aaae
aaaf
aaag
aaah
aaai
aaaj
aaak
aaal
aaam
aaan
aaao
aaap
aaaq
aaar
aaas
aaat
aaau
aaav
aaaw
aaax
aaay
aaaz
aaba
aabb
aabc
aabd
aabe
aabf
aabg
aabh
aabi
aabj
aabk
aabl
aabm
aabn
aabo
aabp
aabq
aabr
aabs
aabt
aabu
aabv
aabw
aabx

Vamos a analizar esto unos segundos...

Tenemos que crunch ha generado todas las posibles combinaciones para una palabra de 4 caracteres, pero notan alguna particularidad?

No se han usado numeros, simbolos, mayusculas ni espacios en blanco. La razon se explica a continuacion:

Crunch utiliza una variable llamada charset (character setting) y es como el conjunto de caracteres que serán usados para la generacion del diccionario/wordlist, por defecto el chardset es lalpha (lower alphabet) pero que tal si probamos a configurar otro chardset.

crunch 4 4 -f .charset.lst numeric

Como siempre, al presionar enter crunch nos indicara cuantas lineas y cuanto espacio sera usado, analicemos las primeras 50 lineas:

0000
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031
0032
0033
0034
0035
0036
0037
0038
0039
0040
0041
0042
0043
0044
0045
0046
0047
0048
0049

Todo ha ido bien, pero ahora notamos una pequeña diferencia, y es que solo ha generado numeros, pero eso es justo lo que queríamos no? Y como lo hemos logrado pues con la opción -f y listo!!

Esta opción le indica dónde buscar el fichero de variables, es decir, donde están preestablecidas todos los charset, es decir que debemos especificar la ruta al archivo así como nuestra selección dentro del mismo, en mi caso tengo el charset.lst en mi directorio home, por ello no específico ruta hasta el mismo.

Cuantos charset podemos elegir además de lalpha y de numeric?

Miren por ustedes mismo

# charset configuration file for winrtgen v1.2 by Massimiliano Montoro ([email protected])
# compatible with rainbowcrack 1.1 and later by Zhu Shuanglei <[email protected]>


hex-lower                     = [0123456789abcdef]
hex-upper                     = [0123456789ABCDEF]

numeric                       = [0123456789]
numeric-space                 = [0123456789 ]

symbols14                     = [!@#$%^&*()-_+=]
symbols14-space               = [!@#$%^&*()-_+= ]

symbols-all                   = [!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/]
symbols-all-space             = [!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/ ]

ualpha                        = [ABCDEFGHIJKLMNOPQRSTUVWXYZ]
ualpha-space                  = [ABCDEFGHIJKLMNOPQRSTUVWXYZ ]
ualpha-numeric                = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789]
ualpha-numeric-space          = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ]
ualpha-numeric-symbol14       = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=]
ualpha-numeric-symbol14-space = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+= ]
ualpha-numeric-all            = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/]
ualpha-numeric-all-space      = [ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/ ]

lalpha                        = [abcdefghijklmnopqrstuvwxyz]
lalpha-space                  = [abcdefghijklmnopqrstuvwxyz ]
lalpha-numeric                = [abcdefghijklmnopqrstuvwxyz0123456789]
lalpha-numeric-space          = [abcdefghijklmnopqrstuvwxyz0123456789 ]
lalpha-numeric-symbol14       = [abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()-_+=]
lalpha-numeric-symbol14-space = [abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()-_+= ]
lalpha-numeric-all       = [abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/]
lalpha-numeric-all-space      = [abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/ ]

mixalpha                   = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]
mixalpha-space             = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ]
mixalpha-numeric           = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789]
mixalpha-numeric-space     = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ]
mixalpha-numeric-symbol14  = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=]
mixalpha-numeric-symbol14-space = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+= ]
mixalpha-numeric-all       = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/]
mixalpha-numeric-all-space = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/ ]

#########################################################################################
#                 SWEDISH CHAR-SUPPORT                                                  # #########################################################################################

#########################
# Uppercase             #
#########################
ualpha-sv                        = [ABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ]
ualpha-space-sv                  = [ABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ ]
ualpha-numeric-sv                = [ABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ0123456789]
ualpha-numeric-space-sv          = [ABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ0123456789 ]
ualpha-numeric-symbol14-sv       = [ABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ0123456789!@#$%^&*()-_+=]
ualpha-numeric-symbol14-space-sv = [ABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ0123456789!@#$%^&*()-_+= ]
ualpha-numeric-all-sv            = [ABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/]
ualpha-numeric-all-space-sv      = [ABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/ ]

#########################
# Lowercase             #
#########################
lalpha-sv                        = [abcdefghijklmnopqrstuvwxyzåäö]
lalpha-space-sv                  = [abcdefghijklmnopqrstuvwxyzåäö ]
lalpha-numeric-sv                = [abcdefghijklmnopqrstuvwxyzåäö0123456789]
lalpha-numeric-space-sv          = [abcdefghijklmnopqrstuvwxyzåäö0123456789 ]
lalpha-numeric-symbol14-sv       = [abcdefghijklmnopqrstuvwxyzåäö0123456789!@#$%^&*()-_+=]
lalpha-numeric-symbol14-space-sv = [abcdefghijklmnopqrstuvwxyzåäö0123456789!@#$%^&*()-_+= ]
lalpha-numeric-all-sv            = [abcdefghijklmnopqrstuvwxyzåäö0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/]
lalpha-numeric-all-space-sv      = [abcdefghijklmnopqrstuvwxyzåäö0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/ ]

#########################
# Mixcase               #
#########################
mixalpha-sv                   = [abcdefghijklmnopqrstuvwxyzåäöABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ]
mixalpha-space-sv             = [abcdefghijklmnopqrstuvwxyzåäöABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ ]
mixalpha-numeric-sv           = [abcdefghijklmnopqrstuvwxyzåäöABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ0123456789]
mixalpha-numeric-space-sv     = [abcdefghijklmnopqrstuvwxyzåäöABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ0123456789 ]
mixalpha-numeric-symbol14-sv  = [abcdefghijklmnopqrstuvwxyzåäöABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ0123456789!@#$%^&*()-_+=]
mixalpha-numeric-symbol14-space-sv = [abcdefghijklmnopqrstuvwxyzåäöABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ0123456789!@#$%^&*()-_+= ]
mixalpha-numeric-all-sv       = [abcdefghijklmnopqrstuvwxyzåäöABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/]
mixalpha-numeric-all-space-sv = [abcdefghijklmnopqrstuvwxyzåäöABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ0123456789!@#$%^&*()-_+=~`[]{}|\:;"'<>,.?/ ]



Si no quieren especificar ningun charset pueden simplemente pasarle a crunch cuales caracteres desean usar en la generacion, por ejemplo:

crunch 4 4 ab12


Y la salida seria:

aaaa
aaab
aaa1
aaa2
aaba
aabb
aab1
aab2
aa1a
aa1b
aa11
aa12
aa2a
aa2b
aa21
aa22
abaa
abab
aba1
aba2
abba
abbb
abb1
abb2
ab1a
ab1b
ab11
ab12
ab2a
ab2b
ab21
ab22
a1aa
a1ab
a1a1
a1a2
a1ba
a1bb
a1b1
a1b2
a11a
a11b
a111
a112
a12a
a12b
a121
a122
a2aa
a2ab
a2a1
a2a2
a2ba
a2bb
a2b1
a2b2
a21a
a21b
a211
a212
a22a
a22b
a221
a222
baaa
baab
baa1
baa2
baba

Empiezan a entender el sentido de la palabra "Flexibilidad" para referirse a crunch, bueno sigamos adelante aprendiendo más trucos para esta maravillosa tool.

[/b][/u]

Hasta ahora hemos aprendido a usar crunch al nivel basico, es decir solo sabemos generar diccionarios especificandole el tamaño y el conjunto de caracteres a usarse, y muchos pensaran que esa es toda la magia de generar diccionarios y la verdad es que esta cortos, siganme y veremos que otras cosas podemos hacer.

Recuerdan aquella película de hackers en la que el estelar mira el teclado del administrador de sistemas y logra ver la clave digitada en el teclado? Pues en la vida real quizás no sea tan sencillo ver toda la clave digitada y solo logramos recordar parte de la misma y quizás su tamaño (si su tamaño, yo suelo contar las pulsaciones en el teclado asi me hago una idea del tamaño) pues supongamos que queremos generar una clave que inicia con "Und......" pero no sabemos el resto, pues podríamos decirle a crunch:

crunch 9 9 -t und@@@@@@


Y esto generara:

undaaoerv
undaaoerw
undaaoerx
undaaoery
undaaoerz
undaaoesa
undaaoesb
undaaoesc
undaaoesd
undaaoese
undaaoesf
undaaoesg
undaaoesh
undaaoesi
undaaoesj
undaaoesk
undaaoesl
undaaoesm
undaaoesn
undaaoeso
undaaoesp
undaaoesq
undaaoesr
undaaoess
undaaoest
undaaoesu
undaaoesv
undaaoesw
undaaoesx
undaaoesy
undaaoesz
undaaoeta
undaaoetb
undaaoetc
undaaoetd
undaaoete
undaaoetf
undaaoetg
undaaoeth
undaaoeti
undaaoetj
undaaoetk
undaaoetl
undaaoetm
undaaoetn
undaaoeto
undaaoetp
undaaoetq
undaaoetr
undaaoets
undaaoett
undaaoetu
undaaoetv
undaaoetw
undaaoetx
undaaoety
undaaoetz
undaaoeua
undaaoeub
undaaoeuc
undaaoeud
undaaoeue
undaaoeuf
undaaoeug
undaaoeuh
undaaoeui
undaaoeuj
undaaoeuk
undaaoeul
undaaoeum
undaaoeun
undaaoeuo
undaaoeup
undaaoeuq
undaaoeur
undaaoeus
undaaoeut
undaaoeuu
undaaoeuv
undaaoeuw
undaaoeux
undaaoeuy
undaaoeuz
undaaoeva
undaaoevb
undaaoevc
undaaoevd
undaaoeve
undaaoevf
undaaoevg
undaaoevh


Y si nos fijamos crunh ha generado palabras sin modificar los 3 primeros caracteres, con lo cual si la palabra clave es "undercode" eventualmente sera generada, pero que pasaria si el admin del sitio ha querido complicarla y ha puesto "underc0de" como password? pues podemos hacerlo de dos formas, una sencilla y otra un poco mas compleja, para la forma compleja podriamos hacerlo al especificar un charset alfanumerico escribiendo:

crunch 9 9 -f .charset.lst lalpha-numeric -t und@@@@@@

ó bien podriamos especificar los caracteres que queremos usar:

crunch 9 9 abcefghijklmnopqrstuwxyz1234567890 -t und@@@@@@


Con ambos comandos tendriamos el mismo resultado, simplemente son dos formas de hacer lo mismo

undaaaz1u
undaaaz1v
undaaaz1w
undaaaz1x
undaaaz1y
undaaaz1z
undaaaz10
undaaaz11
undaaaz12
undaaaz13
undaaaz14
undaaaz15
undaaaz16
undaaaz17
undaaaz18
undaaaz19
undaaaz2a
undaaaz2b
undaaaz2c
undaaaz2d
undaaaz2e
undaaaz2f
undaaaz2g
undaaaz2h
undaaaz2i
undaaaz2j
undaaaz2k
undaaaz2l
undaaaz2m
undaaaz2n
undaaaz2o
undaaaz2p
undaaaz2q
undaaaz2r
undaaaz2s
undaaaz2t
undaaaz2u
undaaaz2v
undaaaz2w
undaaaz2x
undaaaz2y
undaaaz2z
undaaaz20
undaaaz21
undaaaz22
undaaaz23
undaaaz24
undaaaz25
undaaaz26
undaaaz27
undaaaz28
undaaaz29
undaaaz3a
undaaaz3b
undaaaz3c
undaaaz3d
undaaaz3e
undaaaz3f
undaaaz3g
undaaaz3h
undaaaz3i
undaaaz3j
undaaaz3k
undaaaz3l
undaaaz3m
undaaaz3n
undaaaz3o
undaaaz3p
undaaaz3q
undaaaz3r
undaaaz3s
undaaaz3t
undaaaz3u
undaaaz3v
undaaaz3w
undaaaz3x
undaaaz3y
undaaaz3z
undaaaz30
undaaaz31
undaaaz32
undaaaz33
undaaaz34
undaaaz35
undaaaz36
undaaaz37
undaaaz38
undaaaz39
undaaaz4a
undaaaz4b
undaaaz4c
undaaaz4d
undaaaz4e
undaaaz4f
undaaaz4g
undaaaz4h
undaaaz4i
undaaaz4j
undaaaz4k
undaaaz4l
undaaaz4m
undaaaz4n
undaaaz4o
undaaaz4p
undaaaz4q
undaaaz4r
undaaaz4s
undaaaz4t
undaaaz4u
undaaaz4v
undaaaz4w
undaaaz4x
undaaaz4y
undaaaz4z
undaaaz40
undaaaz41
undaaaz42
undaaaz43
undaaaz44
undaaaz45
undaaaz46
undaaaz47
undaaaz48
undaaaz49
undaaaz5a
undaaaz5b
undaaaz5c
undaaaz5d
undaaaz5e
undaaaz5f
undaaaz5g
undaaaz5h
undaaaz5i
undaaaz5j
undaaaz5k
undaaaz5l
undaaaz5m
undaaaz5n
undaaaz5o
undaaaz5p
undaaaz5q
undaaaz5r
undaaaz5s
undaaaz5t
undaaaz5u
undaaaz5v
undaaaz5w
undaaaz5x
undaaaz5y
undaaaz5z
undaaaz50
undaaaz51
undaaaz52
undaaaz53
undaaaz54
undaaaz55
undaaaz56
undaaaz57
undaaaz58
undaaaz59
undaaaz6a
undaaaz6b
undaaaz6c
undaaaz6d
undaaaz6e
undaaaz6f
undaaaz6g
undaaaz6h
undaaaz6i
undaaaz6j
undaaaz6k
undaaaz6l

Ahora viene la forma sencilla que es simplemente cambiar el símbolo "@" por el tipo de carácter que queremos insertar en la generación del diccionario, recuerden que con la opción -t, podemos especificar un patrón de caracteres que serán los únicos en cambiar al generar el diccionario, así los caracteres que podemos especificar para el patrón son:

              @  insertara minusculas
              ,    insertara mayusculas
              %  insertara numeros
              ^   insertara simbolos

Sabiendo esto vamos a suponer que queremos generar un diccionario donde la primera letra sea en mayúscula, pero que a lo largo del mismo, tanto el 2do como el 3er caracter se queden fijos, pues para hacerlo agregamos una "," que tal como explique anteriormente insertará mayúsculas, pero recordemos que había un número en el password, asi que tambien necesitamos insertar 1 solo número en el 7mo carácter de nuestra palabra, pues sólo contamos hasta el lugar número 7 e insertamos un "%" que como también expliqué anteriormente solo inserta números, el comando final quedaría como esto:

crunch 9 9 -t ,nd@@@%@@



Todo esta flexibilidad la hemos logrado con la opción -t, espero la hayan entendido y les sea muy práctica en un futuro. Pero no piensen que hemos terminado, Ohh no mis amigos!!! Esto continúa y se pone mejor!!!

Veamos, vamos a generar un diccionario concatenando palabras, a imaginarse por cual razón algunas personas usan como password una serie de palabras unidas, por ejemplo alguien que le guste harry potter podría usar los nombres de Harry, Hermione y Ron como password y en ese caso generar simplemente por caracteres sería casi imposible dada la longitud final "harryhermioneron" así que en crunch existe una opción que nos permite concatenar palabras, veamos como:

crunch 1 1 -p Harry Hermione Ron


Obtendriamos algo como esto:


Como se habran fijado con la opcio -p es posible lograr concatenar palabras, pero hay una particularidad y es que fijense que en la parte donde se especifican la longitud menor y la mayor yo he colocado "1 1" y pues la verdad es que cuando se usa la opcion -p los numeros no son procesados, pero son necesarios para el argumento, es decir que podremos colocar cualquier cosa y sera irrelevante para la salida.

[/u][/b]

Pues llegados a este punto ya sabemos generar diccionarios con distintos charset, sabemos aplicar patrones en la generación, concatenar palabras, así como especificar con cuales caracteres queremos generar, así que considero que estamos avanzando en la tarea de desnudar a crunch.

Al inicio del taller decia que crunch puede mandar los resultados a la pantalla, puede crear un archivo ó pasarle la salida a otro programa (generalmente un crackeador como aircrack) pero hasta ahora solamente hemos sacado los resultados en pantalla, es decir no se han creado ningun archivo ni nada parecido, asi que vamos a ello.

   
Pues la idea basica de crear un diccionario es poder usarse posteriormente para dar con el hash valido en una prueba de fuerza bruta, asi que de alguna forma debemos poder generar un fichero a partir de la salida, esto es posible usando la opcion -o (output) seguido del nombre del archivo, tomemos como ejemplo el ejercisio de Harry Hermione y Ron y creemos un fichero, el comando seria:

crunch 1 1 -o NombresPotter.txt -p Harry Hermione Ron


Opcionalmente tambien podriamos especificar la ruta donde queremos volcar el diccionario, por ejemplo:

crunch 1 1 -o /home/cl0udswx/Documentos/NombresPotter.txt -p Harry Hermione Ron


Vamos a avanzar un poco más profundo y hagamos que cada 5000 líneas crunch nos genero 1 fichero, pues para que, dependiendo el entorno en el que se vaya a auditar necesitamos seccionar el ataque, es decir dividir el diccionario en una cantidad específica, para lograr mejor acoplamiento con los temporizadores de los crackeadores, para lograr esa división de un diccionario en varios ficheros de menor tamaño usamos la opción -c (esta opción solo funciona si el -o START está presente en la linea) por ejemplo:

crunch 1 1 -o /home/cl0udswx/Documentos/START -c 5000

Esto inicia el proceso de crear multiples ficheros con 5000 lineas cada uno, tal y como podemos ver en la imagen:


Y si me fuera a la carpeta documentos me encontraría con esto:


Ven que sencillo?

Aclaraciones:

[].- El START funciona como nombre de archivo para el primer fichero a crear, a partir de ahi los ficheros tomaran el nombre de la ultima linea del archivo anterior + la primera linea del archivo posterior

[].- Aunque debo aclarar que en algunos caso es posible llenar el disco duro al generar un diccionario, todo depende de lo que le digamos a crunch, por ejemplo si yo dijese:

crunch 15 25 -o demasiado.txt

(http://fotos.subefotos.com/0e8a057b5c74ac0137299570572d27bfo.png)

Se fijan en el tamaño del fichero?

2744 PB !!!      :o

Eso seria demasiado.txt para cualquier disco duro.

Pero entre tanta generacion que tal si creamos un fichero y lo comprimimos a bzip, de un solo golpe, suena complicado pero seria simplemente agregar la opcion -z seguido del tipo de compresion deseado, por ejemplo:

crunch 4 5 -o /home/cl0udswx/Documentos/START -c 5000 -z gzip

De esta forma se iniciaria el mismo proceso anterior solo que en comprimidos gzip u en cualquier otro formato soportado por crunch (gzip, bzip2, lzma, and 7z )


Pues como podran ver no es tan complicado mandar la salida a un fichero txt, gzip, bzip2, lzma ó 7z.

---

Pues al inicio del post mi idea era explicar todas las funciones de crunch, pero se me ha ocurrido que sería interesante dejar que ustedes aporten su poco al post, asi que les quise dejar 2 ejercicios para que los realicen y me los manden por MP y yo luego actualizar el post con el nombre y la solución.

1.- Cómo generar un diccionario que le pase la salida a aircrack-ng usando una tuberia.

2.- Cómo generar un diccionario que no repita caracteres por linea y guardarlo en un comprimido (da igual el formato)

Saludos y hasta la próxima.

Muy buen aporte cl0ud!
Tengo una pequeña duda. Para poder crear un diccionario de 6 caracteres de longitud, utilizando todos los caracteres existentes, el comando sería algo asi?

crunch 6 ualpha-numeric-all-space

Saludos y muchas gracias!
ANTRAX

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Muy buen aporte cl0ud!
Tengo una pequeña duda. Para poder crear un diccionario de 6 caracteres de longitud, utilizando todos los caracteres existentes, el comando sería algo asi?

crunch 6 ualpha-numeric-all-space

Saludos y muchas gracias!
ANTRAX

Saludos Antrax,

El comando seria:

crunch 6 6 -f charset.lst mixalpha-numeric-all-space

Donde lo rojo seria la longitud minima y la maxima.

Lo verde seria el fichero charset.lst (si no tenemos el fichero en nuestro home entonces hay que especificar la ruta)

Y lo azul seria el charset que contiene todos los simbolos y números + el alfabeto tanto en minúsculas como en mayusculas

Nota este comando generaria un wordlist de 4 TB.  :o

Saludos por alla.

Excelente aporte, felicidades por el contenido  8)

Cl0udswX,
eres una persona muy inteligente. Lo has escrito para mi, bien detallado y entendible.
Te felicito y te quiero animar a que sigas haciendo esos Cosas ya que son muy interesantes.

¡Increíble crunch!
¡Increíble Cl0d!

Has sabido explicar a la perfección su funcionamiento, enhorabuena porque el otro día algún usuario estaba preguntano por esto. Leyendo tu post se aclaran muchas cosas y además dejas dos ejercicios para hacerlo más divertido aún.

Buscare un hueco para realizar los ejercicios y de paso me ha surgido una primera duda...

¿Cuando quieres generar por ejemplo una wordlist cómo la que dijo ANTRAX, es posible saber antes el tamaño que ocupará? ¿Y si lo hacemos por ficheros separados de 5.000 líneas también?

Gracias

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
¿Cuando quieres generar por ejemplo una wordlist cómo la que dijo ANTRAX, es posible saber antes el tamaño que ocupará?

Sip, luego de ejecutar el comando crunch te avisa que se generaran "x" cantidad de lineas asi como el tamaño del fichero.

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
¿Y si lo hacemos por ficheros separados de 5.000 líneas también?

Gracias

Si separamos el diccionario en ficheros mas pequeños entonces crunch avisara el tamaño de cada fichero, e ira marcando el progreso total  en porcentajes.

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Cl0udswX,
eres una persona muy inteligente. Lo has escrito para mi, bien detallado y entendible.
Te felicito y te quiero animar a que sigas haciendo esos Cosas ya que son muy interesantes.

;)

salu2
he estado liado y he aparecido poco
gracias por en enlace de intrucciones pero quizas me explique mal
lo yo digo es a crunch hacer que pase a ciertos caracters letras y a otros numeros bien hasta llego
pero crunh mete todo el alfabeto yo quisiera ejemplo
crunch 13 13 123456789ABCDEFG que solo pase esas letras no el alfabeto de letras entero ademas de los numeros logicamente..
¿hay comando no lo he encontrado por nimgun lado y llevo tiempo con esa duda
si le meto crunch 13 13 123456789ABCDEFG -t 8,,%%,,,,%%%%   no es valido
y si le metes  crunch 13 13 -t 8,,%%,,,,%%%%   si pero lo dicho pasa todo el alfabeto de letras mucho peso desearia aligerar peso

pd ; los ejercicios se hacerlos pero bajo wifislax ¿eso no vale para enviar por privado?
gracias por los pedazo de tutos e informacion que en este foro se hallan

Disculpa hermano, pero del mismo modo que yo dedico tiempo en escribirlo tú deberías dedicar tiempo y escribir tu duda de una forma clara.

Es que no entiendo lo que planteas.

Saludos.


Enviado desde mi iPhone utilizando Tapatalk

sallu2
lo dicho cruch con
13 13 -t 8,,,,,%%%%,,,   pasa el todas las letras abcdefghijklmnñopqrstuvwxyz1234567890  en trece caracters

yo quiero que pase lo dicho las letras que yo le mande sobre ese caracter que yo quiera   ; y los numeros sobre el caracter que quiera

he probado y lo dicho crunch 13 13 -t 8,,,,,%%%%,,, pasa todas las letras del alfabeto
y yo no quiero pasar todas las letras si no las que yo le diga a crunch

ejemplo ; crunch 13 13 1234567890ABCDEFGH
se hacer los ejercicios que mandas pero sobre wifislax de hecho comparti algo sobre su uso de crunch bajo wifislax

espero se entienda creo que me explico bien

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
ejemplo ; crunch 13 13 1234567890ABCDEFGH
se hacer los ejercicios que mandas pero sobre wifislax de hecho comparti algo sobre su uso de crunch bajo wifislax

crunch 13 13 charset.lst numeric -t  abcefgh1234567890

gracias por molestarte en intertar dar algo de luz pero eso ya lo he probado me he cansado de hacer pruebas
no quiero ser pesado con el tema pero una captura creo que explica todo

(http://s1.postimg.org/qghm72y9r/instant_nea1.png)

si se fijan en lo explico como me las genera con todas las letras del alfabeto y yo solo le meto ABCDEFG
Y añade letras que yo no le digo que las meta añade todo el alfabeto

gracias por tener paciencia ...a todos
salu2

Echando un vistazo a ejemplos deberías probar en primer lugar generando de la "A" hasta la "G" a ver si funciona para proseguir.

1. Lista de palabras usando "abcdefg" empezando desde "A" hasta "G":

./crunch 1 6 abcdefg

Aprovecho para dejar un Script realizado por "elmanuvolador" de "seguridadwiriless" el cual te hará las cosas más fáciles. Quizás con este Script si puedas generar ese diccionario que necesitas. Dejo el script a continuación:


#!/bin/bash

clear
echo ""
echo "                     ####################################"
echo "                     #                                  #"
echo "                     #           CRUNCH.SCRIPT          #"
echo "                     #                                  #"
echo "                     #     Creado por elmanuvolador     #"
echo "                     #                                  #"
echo "                     #     www.seguridadwireless.net    #"
echo "                     #                                  #"
echo "                     ####################################"
sleep 4
clear
MIN="8"
MAX="10"
AIRCRACK="aircrack-ng "
CRUNCH="/pentest/password/crunch/crunch"
DUMP_PATH="/root/swireless/airoscript"
CHARSET="/pentest/password/crunch/charset.lst"
CHOICES="1 2 3 4 5 6 7 8 9"
function menu {
  clear
  echo "##############################################################################"
  echo "###   AP SSID     ==>   $Host_SSID"
  echo "###   AP MAC      ==>   $Host_MAC"             
  echo "###   RUTA .CAP   ==>   $ruta_CAP"
  echo "###   BUSCAR KEY  ==>   De $MIN a $MAX caracteres"
  echo "##############################################################################"
  echo "###   1) Especificar SSID del AP                                           ###"
  echo "###   2) Especificar MAC  del AP                                           ###"
  echo "###   3) Especificar Ruta del archivo .CAP                                 ###"
  echo "###   4) Especificar diccionario                                           ###"
  echo "##############################################################################"
  echo "###   5) Bruteforce (diccionario)                                          ###"
  echo "###   6) Bruteforce (personalizado)                                        ###"
  echo "###   7) Bruteforce (con patron)                                           ###"
  echo "##############################################################################"
  echo "###   8) Numero de caracteres iniciales                                    ###"
  echo "###   9) Numero de caracteres finales                                      ###"
  echo "##############################################################################"
}
#opcion 1
function entradassid {
echo
echo -n "Introduzca el SSID del AP: "
read Host_SSID
sleep 1
clear
menu
}
#opcion 2
function entradamac {
echo
echo -n "Introduzca la MAC del AP: "
read Host_MAC
sleep 1
ruta_CAP="$DUMP_PATH/$Host_MAC-01.cap"
clear
menu
}
#opcion 3
function entradaruta {
echo
echo -n "Introduzca la nueva ruta del archivo .CAP: "
read ruta_CAP1
sleep 1
ruta_CAP="$ruta_CAP1"
clear
menu
}
#opcion 6
function dicciomanual1 {
echo
echo -n "Introduzca los caracteres: "
read dicciomanual
sleep 1
ATAQUE1="$dicciomanual"
ataque1
}
#opcion 7
function patron {
clear
echo "     -Ejemplo para una contraseña de 8 caracteres: @@ABCD@@"
echo "      donde ABCD se mantendran inamovibles y las @ ira probando"
echo "      combinaciones con el diccionario seleccionado en el menu."
echo ""
echo -n "     -Introduzca la longitud de la contraseña (ejp: 8): "
read carac1
sleep 1
MIN="$carac1"
sleep 1
MAX="$carac1"
echo
echo -n "     -Introduzca los caracteres (ejp: @@ABCD@@): "
read patron1
sleep 1
clear
ataque2
}
#opcion 8
function caracmin {
echo
echo -n "Introduzca el nuevo Numero de caracteres iniciales: "
read caracmin1
sleep 1
MIN="$caracmin1"
clear
menu
}
#opcion 9
function caracmax {
echo
echo -n "Introduzca el nuevo Numero de caracteres finales: "
read caracmax1
sleep 1
MAX="$caracmax1"
clear
menu
}
#opcion 4
function diccionario {
while true; do
clear
  echo "##############################################################################"
  echo "###  1) Numeros                                                            ###"
  echo "###  2) Minusculas                                                         ###"
  echo "###  3) Mayusculas                                                         ###"
  echo "###  4) Numeros    / Espacio                                               ###"
  echo "###  5) Minusculas / Espacio                                               ###"
  echo "###  6) Mayusculas / Espacio                                               ###"
  echo "###  7) Minusculas / Numeros                                               ###"
  echo "###  8) Minusculas / Numeros / Espacio                                     ###"
  echo "###  9) Mayusculas / Numeros                                               ###"
  echo "### 10) Mayusculas / Numeros/    Espacio                                   ###"
  echo "### 11) Minusculas / Mayusculas                                            ###"
  echo "### 12) Minusculas / Mayusculas / Espacio                                  ###"
  echo "### 13) Minusculas / Mayusculas / Numeros                                  ###"
  echo "### 14) Minusculas / Mayusculas / Numeros / Espacio                        ###"
  echo "### 15) Minusculas / Mayusculas / Numeros / Simbolos / Espacio             ###"
  echo "##############################################################################"
  echo "### 16) Abrir charset.lst (Plantillas de diccionarios)                     ###"
  echo "### 17) Entrada manual del nombre de la plantilla                          ###"
  echo "### 18) Volver al menu principal                                           ###"
  echo "##############################################################################"
  read yn
  echo ""
  case $yn in
    1 ) numeric1 ; break ;;
    2 ) lalpha1 ; break ;;
    3 ) ualpha1 ; break ;;
    4 ) numeric-space1 ; break ;;
    5 ) lalpha-space1 ; break ;;
    6 ) ualpha-space1 ; break ;;
    7 ) lalpha-numeric1 ; break ;;
    8 ) lalpha-numeric-space1 ; break ;;
    9 ) ualpha-numeric1 ; break ;;
   10 ) ualpha-numeric-space1 ; break ;;
   11 ) mixalpha1 ; break ;;
   12 ) mixalpha-space1 ; break ;;
   13 ) mixalpha-numeric1 ; break ;;
   14 ) mixalpha-numeric-space1 ; break ;;
   15 ) mixalpha-numeric-all-space1 ; break ;;
   16 ) opencharset ; break ;;
   17)  manualcharset; break ;;
   18)  break ;;
   * ) echo "Opción desconocida. Elija de nuevo" ;;
  esac
  done
  clear
  }
#1
function numeric1 {
ATAQUE1=numeric
menu
}
#2
function lalpha1 {
ATAQUE1=lalpha
menu
}
#3
function ualpha1 {
ATAQUE1=ualpha
menu
}
#4
function numeric-space1 {
ATAQUE1=numeric-space
menu
}
#5
function lalpha-space1 {
ATAQUE1=lalpha-space
menu
}
#6
function ualpha-space1 {
ATAQUE1=ualpha-space
menu
}
#7
function lalpha-numeric1 {
ATAQUE1=lalpha-numeric
menu
}
#8
function lalpha-numeric-space1 {
ATAQUE1=lalpha-numeric-space
menu
}
#9
function ualpha-numeric1 {
ATAQUE1=ualpha-numeric
menu
}
#10
function ualpha-numeric-space1 {
ATAQUE1=ualpha-numeric-space
menu
}
#11
function mixalpha1 {
ATAQUE1=mixalpha
menu
}
#12
function mixalpha-space1 {
ATAQUE1=mixalpha-space
menu
}
#13
function mixalpha-numeric1 {
ATAQUE1=mixalpha-numeric
menu
}
#14
function mixalpha-numeric-space1 {
ATAQUE1=mixalpha-numeric-space
menu
}
#15
function mixalpha-numeric-all-space1 {
ATAQUE1=mixalpha-numeric-all-space
menu
}
#16
function opencharset {
konqueror /pentest/password/crunch/charset.lst*&
diccionario
}
#17
function manualcharset {
echo
echo -n "Introduzca el nombre de la plantilla (ejp: mixalpha): "
read plantilla
sleep 1
ATAQUE1="$plantilla"
clear
menu
}
#ataques
function ataque {
$CRUNCH $MIN $MAX -f $CHARSET $ATAQUE1 | $AIRCRACK -a 2 $ruta_CAP -e $Host_SSID -b $Host_MAC -w -
echo""
echo -n "                Presione ENTER para volver al menu principal"
read
clear
menu
}
function ataque1 {
$CRUNCH $MIN $MAX $ATAQUE1 | $AIRCRACK -a 2 $ruta_CAP -e $Host_SSID -b $Host_MAC -w -
echo""
echo -n "                Presione ENTER para volver al menu principal"
read
clear
menu
}
function ataque2 {
$CRUNCH $MIN $MAX -f $CHARSET $ATAQUE1 -t $patron1 | $AIRCRACK -a 2 $ruta_CAP -e $Host_SSID -b $Host_MAC -w -
echo""
echo -n "                Presione ENTER para volver al menu principal"
read
clear
menu
}
#opciones del menu principal
menu
select choix in $CHOICES; do
if [ "$choix" = "1" ]; then
entradassid
menu
elif [ "$choix" = "2" ]; then
entradamac
menu
        elif [ "$choix" = "3" ]; then
entradaruta
menu
elif [ "$choix" = "4" ]; then
diccionario
menu
        elif [ "$choix" = "5" ]; then
ataque
menu
        elif [ "$choix" = "6" ]; then
dicciomanual1
menu
        elif [ "$choix" = "7" ]; then
patron
menu
        elif [ "$choix" = "8" ]; then
caracmin
menu
elif [ "$choix" = "9" ]; then
        caracmax
menu
else
clear
menu
        echo "########################################################################"
        echo "###                         Opción incorrecta                        ###"
        echo "########################################################################"
        sleep 1
        menu
fi
done
#END

gracias
por la info creo que lo he usado y por lo que veo pido algo a crunch que no es capaz de hacerlo
pues como he comentado llevo tiempo con esa duda un par de años con esa duda y nadie a sabido decirme el comando
otra cosa es crear un script sea bash o python como los que he visto pero tampoco poseen la cualidad que busco y he mirado alguno ...
probare a intentar crear un script pero habra que tomarlo con paciencia
gracias de nuevo por tener paciencia y molestarse en compartir conocimientos

@dynyly (https://underc0de.org/foro/index.php?action=profile;u=41422) creo que sera mejor que crees el script, mandame mp tal vez pueda ayudarte saludos!

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
salu2
he estado liado y he aparecido poco
gracias por en enlace de intrucciones pero quizas me explique mal
lo yo digo es a crunch hacer que pase a ciertos caracters letras y a otros numeros bien hasta llego
pero crunh mete todo el alfabeto yo quisiera ejemplo
crunch 13 13 123456789ABCDEFG que solo pase esas letras no el alfabeto de letras entero ademas de los numeros logicamente..
¿hay comando no lo he encontrado por nimgun lado y llevo tiempo con esa duda
si le meto crunch 13 13 123456789ABCDEFG -t 8,,%%,,,,%%%%   no es valido
y si le metes  crunch 13 13 -t 8,,%%,,,,%%%%   si pero lo dicho pasa todo el alfabeto de letras mucho peso desearia aligerar peso

Pues podrias crear tu propio "charset" editando el fichero charset.lst y luego con la opcion -t se lo pasas como argumento.

saludos desisto
wifislax ~ # crunch 13 13 -f charset.lst 1234567890ABCDEF -t 8%%%,,,,%,,,,
readcharset: File charset.lst could not be opened
The problem is = No existe el fichero o el directorio

no se editar el charset ¿como seria? creo que seria dificil o seria del codigo fuente de crunch ....
saludos a otra cosa que hay mucho donde aprender en esta casa
gracias de nuevo por todos los tutos y sobre todo por vuestra enorme paciencia

Después de la opción -f debes especificar la ruta al fichero y luego especificar cuál charset es el que se usará en la generación.

Saludos.


Enviado desde mi iPhone utilizando Tapatalk

salu2
ayuda plees
(http://s24.postimg.org/70oed685x/crunc.png)

en la imagen se ve que he creado un archivo con el charset editado le doy direccion correcta pero ya ahi si que me pierdo y veo que me pide lo qque dices
ayuda plees  terminar esta tonteria tan necesaria y basica

En la captura que compartes el fichero se llama "prueba" pero en el argumento lo llamas como "charset.lst" prueba cambiando el nombre al fichero.


Enviado desde mi iPhone utilizando Tapatalk

Citar2.- Cómo generar un diccionario que no repita caracteres por linea y guardarlo en un comprimido (da igual el formato)

Para que no se repita creo que es la opción -p si no me equivoco?.

Pero.... el problema es que los números no son procesados pero se necesitan.

crunch 4 5 -p abc
crisis generará abc, acb, bac, bca, cab, cba.

salu2
lo solucione perdon por no publicarlo pero no queria parecer pesado con un tema
la solucion era separar numeros y letras y despues ejucutar la opcion -t   y las opciones de insertar ,  %

crunch 13 13 1234567890 ABCDFGHPK -t %,%,%,%,%,%,%       es ejemplo para que se vea que genera lo que le digo

0A0A0A0C6G5K2
0A0A0A0C6G5K3
0A0A0A0C6G5K4
0A0A0A0C6G5K5
0A0A0A0C6G5K6
0A0A0A0C6G5K7
0A0A0A0C6G5K8
0A0A0A0C6G5K9      genera hasta la letar K pues es la ultima y vuelve a empezar por las letras metidas
0A0A0A0C6G6A0       se puede ver que mete numero ,letra numero,letra.......
0A0A0A0C6G6A1
0A0A0A0C6G6A2

saludo2 y gracias por molestarse en contestar he intentar arrojar luz y conocimiento

-------------------------------------
edit
tambien puede valir modificar este script es el orange.sh pero se ve bien creo que si se fijan un poco sabran  modificar a gusto añadiendo mas o menos caracters a generar  y la letras o numeros que queramos añadir es casi lo mismo pero en script

#!/bin/bash
#
for A in 4 B C D E F 1 2 3 4 5 6 7 8 9 0                       
do
for B in 1 B C D E F 1 2 3 4 5 6 7 8 9 0
do
for C in 4 B C D E F 1 2 3 4 5 6 7 8 9 0
do
for D in 3 B C D E F 1 2 3 4 5 6 7 8 9 0
do
for E in 5 B C D E F 1 2 3 4 5 6 7 8 9 0
do
for F in A B C D E F 1 2 3 4 5 6 7 8 9 0
do
for G in A B C D E F 1 2 3 4 5 6 7 8 9 0
do
for H in A B C D E F 1 2 3 4 5 6 7 8 9 0
do
echo $A$B$C$D$E$F$G$H
done
done
done
done
done
done
done
done

si se fijan cada linea pertenece a un caracter   a generar; y su contenido a generar o charset
y A$B$C$D$E$F$G$H  es cada caracter  añadimos mas letras en caso de que querer generar mas caracters
y añadir done por cada caracter añadido  (fijarse el script como esta genera 8 caracters pues 8 done al final)
yo sencillamente aprovecho todo lo que pued(a si ya esta echo el script para que hacerlo de nuevo lo modifico ....

salu

Hola, tenia la duda de como lo podia hacer pero con ciertas palabras sin que se junten, por ejemplo si creo que la clave pueden ser ciertas palabras juntas como, holly weed abcd 123, obviamente serian muchas mas pero es un ejemplo, como lo podria hacer? ya que el mas parecido que vi fue el ejemplo de harry poter pero ahi se hacia una combinacion con las palabras, yo quiero algo asi como

hollyweedabcd
hollyweed123
weed123holly
123abcdholly
etc

y buen aporte, igual me servira muchas veces
Gracias.

Interesante lo del crunch pero complicado... o compliquémoslo: supongamos que queremos que nos genere un diccionario entre 4 y 7 letras empezando por una en concreto y con opción de números solo al final.

P.e.: digamos que la contraseña es Pamt56 y que yo se que empieza por "p" pero no se si mayúscula o minúscula y que es posible (pero no seguro) de que lleve uno o dos números al final. ¿Es posible generar un diccionario de este tipo?

PFFFF Excelente aporte y excelente foro, sin duda es mi foro favorito de habla hispana, estoy regresando al hacking aunque por ahi del 2012 empece con los tutoriales de HxC de Wireless Hacking que si no mal recuerdo escribio ANTRAX pero en ese entonces era WEP y era muy facil ahora con WPA2 y proximamente WPA3 se necesitara mucho estudio de diccionarios e ingenieria social....

Este tutorial de CRUNCH es años luz el mejor tuto que anda en la red MUCHAS GRACIAS!!

PD: Habria manera de aplicar uno de estos diccionarios para sacar la pass de un correo?

Saludos y de nuevo GRACIAS POR EL EXCELENTE TUTO

Gracias por la explicación tan sencilla !!

Gracias por la explicación.

Quizá una forma de complicar la cosa sería:

Generar diccionarios de 12 caracteres donde los 7 primeros serán minúsculas, 2 siguientes mayúsculas, 2 siguientes números, y la última minúscula.

Ej: srulkmnAQ34s

si lo vemos así sería

crunch 12 12 -t @@@@@@@,,%%@

creo que la complicación sería que los caracteres no fueran contiguos; por ejemplo aaaaaaaAA00a: sino que el 2do caracter debe ser diferente al primero, el 3ero al 2do y así sucesivamente... pero si podría ser abababaAB01a

aún no ve la forma de hacerlo...

Hola antes que nada gracias por el tutorial, tengo una consulta, se me esta complicando el tema de exportarlo y comprimirlo:

crunch 9 9 abcdefghijklmnopqrstuvwxyz0123456789._ -t c@@@@@@@9 -o word.txt -z gzip


la salida no se genera en "word.txt" sino en un archivo llamado START, y no se comprime, que tengo mal en la sintaxis?

Gracias

Busco generar un diccionario numerico de 10 caracteres, en donde los primeros 3 caracteres son fijos y los 7 restantes estan en un rango, digamos de 100000 a 200000, es posible hacer esto con crunch?
?

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Busco generar un diccionario numerico de 10 caracteres, en donde los primeros 3 caracteres son fijos y los 7 restantes estan en un rango, digamos de 100000 a 200000, es posible hacer esto con crunch?
?

Hola roquejuan, Es absolutamente posible, es mas, en este post te esta enseñando a como hacerlo paso a paso.
Te recomentaria que lo leas detenidamente y vayas utilizando la herramienta hasta lograr el resultado que deseas.
En como mucho 1 hora tendras tu diccionario creado

Saludos!

Gracias por el material, es primera vez q me animo a responder en el foro, pero ya van muchos buenos temas y me sentia mal si no te felicitaba por esto.
Reitero, muchas gracias  :)
PD: Es una locura xDDD
crunch 12 12 -f charset.lst mixalpha-numeric -o VTROBO.lst
Crunch will now generate the following amount of data: 12018631630886850560 bytes
11461860304724 MB
11193222953 GB
10930881 TB
10674 PB

Buenas Amigos,
Tengo unas dudas con este comando , como deberia hacerlo para que una letra no se repita mas de dos veces en la linea creada
por ahora uso el comando -d 2 pero igual se repiten mas de dos solo que no seguidas ayuda porfavor.
Otra de las dudas que tengo es como se puede hacer para que crunch arroje las combinaciones al azar y no que empiece por un costado
Por su ayuda Gracias!!

Buenas
Entonces por lo que creo haber ententido, para una contraseña WIFI podría hacerlo en hexadecimal mejor no?

Saludos

Saludos infinitos a todos.

Pues hacia un tiempo ya no entraba al foro, cosas de tiempo en realidad. Pero me alegra que les haya gustado el material y sobre todo que se estén planteando tantas formas interesantes de usar esta magnifica herramienta, vamos a revivir el hilo y a sacar nuevas formas de usarlo para escribir algo mas reciente, así que vamos a ello.

Un abrazo.

Hola, gran aporte me a servido mucho, pero ahora quisiera hacer un diccionario en donde los primeros numero del 1 al 4 sean distinto despues a12345 que queden fijos. ejemplo xxxxa12345 en donde las  x serian los numero variados 0123456789 pero solo una linea de 4 numeros y a12345 seria fijo. me podria ayudar. no se si me explique bien.

Hola. Necesitaría vuestra ayuda para resolver una duda. Tengo que resolver un ejercicio que consiste en, a partir de un hash sha256, conseguir su valor en texto plano. Para ello, cuento con un binario del que debo extraer sus metadatos y a partir de esos datos, crear un diccionario.  He utilizado exiftool para extraer metadatos, sin embargo, no se si es lo que tengo que utilizar para ello. Si efectivamente, el proceso que he seguido para extraer los metadatos es el correcto, ¿cuenta crunch con alguna opción para a partir de ese fichero, generar un diccionario?. 

Saludos.