- Si, cuando leas: binarios, y siendo simplistas se refiere a los ejecutables, al .exe en caso de Windows

Jhon The Ripper para Windows de 32-bit:
https://www.openwall.com/john/k/john-1.9.0-jumbo-1-win32.7z

Jhon The Ripper para Windows de 64-bit:
https://www.openwall.com/john/k/john-1.9.0-jumbo-1-win64.7z


- Si


- No, Jhon The Ripper es un programa por línea de comandos (no tiene interfaz gráfica), necesitas un intérprete de comandos para utilizarlo, lo más común y sencillo es usar la CMD de Windows, mediante el intérprete o consola o símbolo del sistema se puede dar parámetros y opciones al programa para que funcione, a su vez será el intérprete el que muestre los resultados del programa.

---
Yo veo que no tienes ni idea de programas por línea de comandos XD, hay mucho por aprender pero vayamos por lo justo y necesario para trabajar con John

1. Abrir una CMD, primero debes entender un par de cosas:

- La ruta actual, es la carpeta donde estás actualmente, todo lo que haya en esa carpeta está a tu disposición con tan solo nombrarlo porque es como si literalmente tuvieras una ventana de tu explorador de archivos mostrando el contenido de una carpeta, y todo lo que esté ahí está al alcance de un doble click



-- Adicionalmente está el símbolo > que separa la parte de la Ruta actual de la parte donde puedes escribir tus comandos, llamadas a programas, etc, y el cursor que indica donde se situarán los caracteres que empieces a escribir, puedes usar las teclas de las flechas izquierda y derecha para mover el cursor y situarlo donde lo necesites

- Abrir una CMD en la ruta que quieras, para esto simplemente debes abrir la carpeta objetivo, dirigirte a la barra de direcciones, escribir CMD y presionar Enter, eso abre una CMD con ruta actual igual a la carpeta donde lo abriste. En el segundo 29 del gif se muestra esto.

Extraer, abrir la carpeta donde se ubica John.exe, abrir una CMD en esa ruta y ejecutar la ayuda de John


-- La carpeta doc contiene la documentación de varios aspectos de John, está en inglés y es algo técnica, la carpeta etc trae los archivos necesarios para usar la aceleración gráfica, y la carpeta run tiene todos los ejecutables que forman parte del paquete Jumbo de John incluido al propio john.exe, zip2john.exe, rar2john.exe, etc

-- Recuerda que siempre puedes descargar el GIF y abrirlo con un reproductor de videos decente como K-Lite (Media Player Classic) o VLC para pausar, avanzar y demás cosas que se pueden hacer con un video


- Si, como ya mencioné, dentro del paquede Jumbo de John hay un rar2john.exe que sirve para extraer el Hash a crackear de un archivo .RAR

-- $ corresponde al prompt de Linux, para el caso de Windows sería el > que está al final de la ruta actual
-- rar2john es el ejecutable o programa o comando al que llamar
-- file.rar es el archivo .rar que tiene contraseña
-- > es un redireccionador, no confundirlo con el primer > que siempre está al final de la Ruta actual. Este > sirve para enviar lo que se debería mostrar por pantalla a un archivo, en este caso al archivo rar.hashes

- Cuando pulses Enter luego de introducir: rar2john file.rar > rar.hashes se llamará a ejecutar al programa rar2john.exe y se le pasarán los parámetros y opciones indicadas, en este caso un archivo file.rar, como ya dije, rar2john toma un archivo .rar con contraseña, extrae el Hash a cracker de él y lo muestra en pantalla. El redireccionador > evita que el resultado se muestre en pantalla y lo escribe en su lugar a un archivo rar.hashes que luego puedes abrir con tu bloc de notas o ejecutando un comando para ver su contenido (type rar.hashes)

-- Se entiende que rar2john.exe está en la ruta actual o es accesible, sino da error porque el CMD no sabe donde está, pasa igual con file.rar, rar.hashes será un archivo que se va a crear, por eso no importa si existe o no, lo que va a pasar es que se creará en la ruta actual, si existe se sobreescribe, si no existe se crea automáticamente


- Claro, luego de haber obtenido el Hash crackeable del .rar con contraseña ya se lo puedes pasar a john.exe para que lo trabaje, john tiene muchas configuraciones por defecto que las usará si no las especificas, por ejemplo john rar.hashes primero revisará el archivo rar.hashes para saber que tipo de hash es y proceder a crackearlo con una configuración por defecto pero suele ser para nada eficiente dependiendo de la contraseña, siempre es mejor ser lo más precisos posibles


1. Que mejor que hacer un experimento de ejemplo, crea un archivo .rar de nombre: protegido.rar y con contraseña: 1234
2. Lleva ese archivo .rar a la carpeta run de John
3. Abre una CMD en la carpeta run (segundo 29 del GIF)
4. Ejecuta: rar2john protegido.rar > rar.hashes

- Ahora las pruebas, primero ejecuta: john rar.hashes
-- En mi caso obtengo:


-- Me dice que ha aplicado un diccionario (wordlist) por defecto que ya trae john: password.lst (que también puedes encontrar en la carpeta run y abrir con un bloc de notas), además ha aplicado Reglas para variar las palabras de ese diccionario, una línea más abajo me muestra la contraseña que a conseguido, la siguiente línea me muestra el tiempo que le tomó: 9 segundos, y la cantidad contraseñas por segundo que es capaz de alcanzar con la potencia de mi PC para ese tipo de Hash (1355 contraseñas por segundos). Por último dice que usemos el parámetro --show (john --show rar.hashes) para mostrar todas las contraseñas que ha recuperado hasta el momento

- Ahora pasemos al modo incremental para ser más específico y reducir esos 9 segundos (tengo un PC regular/decente: i7-4790)

1. Todas las contraseñas que John ha conseguido las guarda en el archivo: john.pot con todo su hash y demás. John lo va a consultar por si repetimos el mismo hash, así que hay que eliminarlo o guardarlo en otro sitio para que haga un crackeo completo desde cero

2. Ejecuta: john --incremental rar.hashes


- Tardó 0 segundos XD, el modo incremental por defecto (--incremental) prueba con todos los caracteres ASCII (95 en total) hasta un máximo de 13 caracteres, los caracteres son (no olvidar al espacio que está primero):


- Teniendo en cuenta que la contraseña es 1234 lo más eficiente sería usar: john --incremental:digits rar.hashes, esto solo prueba números del 0 al 9 (total 10) con tamaño máximo de 20 caracteres por defecto (0 al 99999999999999999999)

- Si lo quieres ajustar más todavía usando tamaños mínimos y máximos como por ejemplo que solo pruebe tamaños de 4 a 6 caracteres sería:
john --incremental:digits -min-len:4 -max-len:6 rar.hashes

---
Puedes probar con otras contraseñas más complejas de números o letras especificando los tamaños para obtener mejores resultados.

Todo esto es el modo más automático pero John permite ser todavía más preciso usando máscaras pero como por ejemplo si sabes que la contraseña empezaba por una letra en mayúscula luego todo minúsculas y terminaba con dos números, además que en total la contraseña tenía 7 caracteres:

john --mask= ?u?l?l?l?l?d?d rar.hashes

Ah, pues pasa que me comí un -, hay que tener cuidado con la cantidad exacta de guiones, los espacios y todo eso. Para tu caso deberías poner:

john --incremental=digits --min-length=4 --max-length=4 rar.hashes

Esa sería la forma completa que al final toma John y se puede ver en el archivo john.log, si se entiende inglés puede ayudar mucho por ser muy descriptivo, pero también está la forma abreviada:

john -inc=digits -min-len=4 -max-len=4 rar.hashes

Se puede ver que solo requiere de un - inicial, además abrevia a solo 3 letras los parámetros (salvo que tengan un - en medio como -min-len, ahí se abrevia cada subpalabra a 3 letras), incluso se puede combinar ambas formas (no abreviadas y abreviadas), John interpreta las abreviaciones y las expande para utilizar internamente la forma no abreviada, algo similar pasa con el : y el =, el detalle es que el : se puede usar en Reglas (rules) puede llevar a malentendidos así que pienso que es mejor usar siempre =

---
Para complementar, en el mensaje anterior puse al final otro método de crackeo: Máscara (mask) que sería algo más detallada que el método incremental, para lo mismo que quieres hacer sería:

john --mask=?d?d?d?d rar.hashes

?d Corresponde a dígitos del 0 al 9 (0 ... 9), como se pusieron 4 seguidos implica que usarán exactamente cuatro caracteres números, del 0000 al 9999 similar al método Incremental de dígitos con restricción de cantidad de caracteres a cuatro

?l Corresponde a las letras minúsculas: a ... z
?u Corresponde a las letras mayúsculas: A ... Z

Y para finalizar también te muestro como afinar la máscara especificando el juego de caracteres a utilizar entre corchetes [], y combinándolo con tamaños mínimos y máximos, para tu ejemplo:

john --mask=[0123456789] --min-length=4 --max-length=4 rar.hashes

Abreviado:
john -mas=[0123456789] -min-len=4 -max-len=4 rar.hashes

Si por ejemplo sabes que no usas el número 6 porque es del diablo , ni el 7 porque no te trae buena suerte, también quitemos el 0:

john --mask=[1234589] --min-length=4 --max-length=4 rar.hashes

Puedes hacer lo mismo con letras o caracteres especiales si aún no lo has probado, por ejemplo si creo un archivo con contraseña: 5_8@7 puedo pensar en que puedo trabajar con una contraseña de 5 caracteres que saber que tiene un @, un _ y son solo números del 3 al 8:


18 segundos a 1349 contraseñas por segundo, ya no me da tiempo pero se puede acelerar más el proceso si usamos aceleración por GPU para usar una tarjeta de video compatible en lugar que el microprocesador porque se supone es muuucho más veloz

Es que no tiene mucho sentido si no acotas lo máximo posible el juego de caracteres, por ejemplo a mi me está tomando algo de 1300 contraseñas por segundo con mi i7-4790, a ti te está tomando algo de 150 contraseñas por segundo

Según un informe de 7-zip dedicado que habla del tema ha hecho esta tabla suponiendo que el juego de caracteres es de 26 (solo letras minúsculas) y que la PC es de alta potencia (Single User Attack) capaz de realizar 10000 contraseñas por segundo

+-----------------+--------------------+---------------------+
| Password Length | Single User Attack | Organization Attack |
+-----------------+--------------------+---------------------+
| 1               | 1 s                | 1 s                 |
+-----------------+--------------------+---------------------+
| 2               | 1 s                | 1 s                 |
+-----------------+--------------------+---------------------+
| 3               | 2 s                | 1 s                 |
+-----------------+--------------------+---------------------+
| 4               | 1 min              | 1 s                 |
+-----------------+--------------------+---------------------+
| 5               | 30 min             | 1 s                 |
+-----------------+--------------------+---------------------+
| 6               | 12 hours           | 1 s                 |
+-----------------+--------------------+---------------------+
| 7               | 14 days            | 1 s                 |
+-----------------+--------------------+---------------------+
| 8               | 1 year             | 1 s                 |
+-----------------+--------------------+---------------------+
| 9               | 10 years           | 2 s                 |
+-----------------+--------------------+---------------------+
| 10              | 19 years           | 1 min               |
+-----------------+--------------------+---------------------+
| 11              | 28 years           | 30 min              |
+-----------------+--------------------+---------------------+
| 12              | 37 years           | 12 hours            |
+-----------------+--------------------+---------------------+
| 13              | 46 years           | 14 days             |
+-----------------+--------------------+---------------------+
| 14              | 55 years           | 1 year              |
+-----------------+--------------------+---------------------+
| 15              | 64 years           | 10 years            |
+-----------------+--------------------+---------------------+
| 16              | 73 years           | 19 years            |
+-----------------+--------------------+---------------------+
| 17              | 82 years           | 28 years            |
+-----------------+--------------------+---------------------+
| 18              | 91 years           | 37 years            |
+-----------------+--------------------+---------------------+
| 19              | 100 years          | 46 years            |
+-----------------+--------------------+---------------------+

Es decir, suponiendo que tu contraseña sea solo de letras minúsculas y de 7 caracteres, con mi PC tardaría algo de 107 días, y con tu PC tardarías unos 933 días XD, mira que aumentar un solo caracter aumenta exponencialmente el tiempo, para 8 caracteres acabarías en 66 años.

Puedes hacer pruebas con contraseñas de pocos caracteres, hasta 4, o 5 si tienes un bien tiempo y bien refrigerado el PC, pero más allá de eso es mejor reducir sustancialmente el juego de caracteres o no acabas nunca.

Si quieres probar tooodos los caracteres imprimibles posibles que son 95: A-Z, a-z, 0-9, caracteres especiales:  !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ usa el método incremental por defecto:

john --incremental rar.hashes

- Recuerda que puedes acotar con los juegos de caracteres predefinidos del método incremental:

Solo números: --incremental:Digits

Solo letras minúsculas: --incremental:Lower
Solo letras minúsculas y el espacio: --incremental:LowerSpace
Solo letras minúsculas y números: --incremental:LowerNum

Solo letras mayúsculas: --incremental:upper
Solo letras mayúsculas y números: --incremental:UpperNum

Solo letras mayúsculas, minúsculas y números: --incremental:AlNum
Solo letras mayúsculas y minúsculas: --incremental:Alpha

- También recuerda que puedes especificar tamaños mínimos y máximos con --min-length y --max-length (abreviado: -min-len y -max-len)

Como ya dije, lo mejor son las máscaras para ser más específico con el juego de caracteres a usar porque puedes especificar un juego por caracter:

Minúsculas [a-z] o ?l
Mayúsculas [A-Z] o ?u
Números [0-9] o ?d
Caracteres especiales [  !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~] o ?s
Tu propio juego de caracteres [ADPagh@+45*_]
También puedes poner rangos como [A-F], [5-9], [h-p]
O combinar rangos, para especificar un caracter mayúscula del G al Q (GHIJKLMNOPQ), minúscula del a al c (abc) o numero del 4 al 9 (456789): [G-OR-Ua-c4-9]

Ejemplo: Contraseña de 5 caracteres:

- El primer caracter es mayúscula menos XYZ
- El segundo y cuarto caracter es minúscula menos dfgh opqrs xyz y puede tener ñ
- El tercer y quito caracter es un número menos 0, 6 y 9

john --mask=[A-W][a-ci-nt-wñ][1-578][a-ci-nt-wñ][1-578] --encoding=ANSI rar.hashes

Como la ñ no forma parte del alfabeto inglés nunca se incluye por defecto, ni como caracter especial ASCII, por ello al usarlo hay que ponerlo y además especificar que estamos extendiendo el juego de caracteres a uno más amplo como ANSI

A GPT:
Olvidé el password que puse a archivos rar, quiero probar uno de longitud 6 que empiece con A y luego minúsculas ¿cómo hago?

GPT:
¿Es así? Puedo hacer una lista que no implique combinaciones que no usé (como "uq")...

La lista la puedo generar usando un programa hecho por mí, con las restricciones que quiera, será interesante Si el archivo es muy largo puedo hacerlo por partes.

Me asombra que no exista algo como john --mask=[A]Lower(5), entendiendo que ese 5 significa que los 5 caracteres siguientes a A son minúsculas.

No me refería a quitar "u" y "q", sino el par, la combinación, que no pruebe passwords que tengan "uq", pero sí "qu", "q" y "u", salvo que tengan "uq" claro. De eso yo me encargo. Quizá se me complique mucho pero por ahora me tengo confianza xD