manual-del-programa-john-the-ripper

MANUAL DEL PROGRAMA JOHN THE RIPPER  (remasterizado por Camarada) John the Ripper .............................................. ..................................................................... .............................................. ............................................ ..................... 1 Instalacion de John the Ripper ...................... ............................................. .............................................. ............................................. ...................... 3 Opciones de la linea de comandos de John...................................................................... John...................................................................... 4 Opciones de la linea de comandos de John...................................................................... John...................................................................... 6 Ejemplos de uso de John the Ripper ........................................... .................................................................. ...................................... ............... 8 Definiendo un Modo Externo......................................................................................... Externo......................................................................................... 15 Modos de crackeo de John the Ripper ............................................................................ ............................................................................ 17 John the Ripper -- Historial de cambios......................................................................... cambios......................................................................... 19 Traduccion de los archivos de ayuda de John the Ripper ....................................... .......................................19 19 John the Ripper F.A.Q....................... F.A.Q............................................... ............................................... ..................................................... .............................. 20

John the Ripper  ================= John the Ripper es un crackeador de passwords de UNIX, actualmente disponible en UNIX, DOS y WinNT/Win95. La version 1.5 ha sido comprobada en Linux x86/Alpha/SPARC, FreeBSD x86, OpenBSD x86, Solaris 2.x SPARC y x86 y en Digital UNIX. Tambien hay un modo de compilacion generico que deberia funcionar en la mayoria de los otros sistemas UNIX. Las versiones de DOS y Win32 han sido desarrolladas con DJGPP y el Cygnus Developer's Kit, respectivamente. Como instalarlo ----------------Busca la informacion sobre como instalarlo en doc/INSTALL.ES Como usarlo ------------Para ejecutar John, necesitas suministrarle algunos archivos de passwords, y especificar un modo de crackeo, como por ejemplo: john -single passwd donde single es el modo 'single crack' y passwd es tu archivo de passwords. O tambien: john -wordfile:/usr/dict/words -rules passwd que probara con un archivo de palabras (wordlist) y activara las reglas. Los passwords crackeados se mostraran por el terminal y seran grabados en un archivo llamado ~/john.pot ('~' indica el directorio donde has instalado

los ejecutables de John). Este archivo tambien sirve para no volver a cargar  aquellos passwords que ya han sido crackeados cuando inicies otra vez John. Para ver las clave que ya han sido crackeadas, ejecuta: john -show passwd Mientras se esta crackeando, puedes pulsar cualquier tecla para ver el 'status' (el estado de John en ese momento), o Ctrl+C para terminar  la sesion guardando el estado del crackeo en un archivo (~/restore por  defectoto) para poder empezae mas tarde desde ese punto. De la misma forma, si pulsas Ctrl+C dos veces, John abortara la sesion inmediatamente sin salvarla. El estado de la sesion es guardado automaticamente cada 10 minutos (definido en src/params.h) para no perder mucha informacion en caso de cuelgue, corte de corriente, etc. Para continuar una sesion interrumpida ejecuta: john -restore De todas formas, probablemente querras hechar un vistazo a doc/OPTIONS.ES, donde encontraras una lista de todas las opciones de John, y a doc/EXAMPLES.ES donde hay ejemplos de uso de John con otros modos de crackeo. Caracteristicas y Rendimiento ------------------------------John the Ripper esta dise¤ado para ser a la vez portente y rapido. Combina bastantes modos de crackeo en un solo porgrama, y es completamente configurable para tus propias necesidades (incluso puedes definir tu propio modo de crackeo usando el compilador interno, que soporta un sublenguaje de C). Ademas, John esta disponible para una gran variedad de plataformas, lo que te premite usar el mmmismo crackeador en cualquier parte (por ejemplo, puedes continuar una sesion que comenzaste en otro sistema). John soporta (y autodetecta) los siguientes formatos de cifrado: el DES de longitud simple y doble, el extendido de BSDI basado en DES, el de FreeBSD basado en MD5, y el de OpenBSD basado en Blowfish. A diferencia de otros crackeadores, John no usa el estilo de la rutina crypt(3). En vez de eso, tiene sus propios modulos altamente optimizados para los diferentes formatos de cifrado y arquitecturas. Algunos de los algoritmos usados no pudieron ser implementados en una rutina al estilo de crypt(3): requerian un interface de manejo de bits mas potente. Adiccionalmente, hay rutinas en ensamblador para muchos tipos de procesadores y arquitecturas (especialmente para Intel Pentium, x86 con MMX, x86 generico, Alpha EV4, y SPARC V8). Documentacion --------------El resto de la documentacion esta localizado en archivos separados.

La siguiente lista el el orden de lectura recomendado: INSTALL.ES - probablemente ya lo habras leido OPTIONS.ES - opciones de la linea de comandos, y diversas utilidades MODES.ES - modos de crackeo: que es lo que son CONFIG.ES (*) - como personalizarlo RULES.ES (*) - sintaxis para las reglas de los 'wordlists' EXTERNAL.ES (*) - como definir un modo externo EXAMPLES.ES - ejemplos de uso -- muy recomendado FAQ.ES - adivina :) NEWS.ES - lista de los cambios desde la v1.4 CREDITS.ES - creditos, y como contactar conmigo LEEMEYA.ES (*) - notas sobre la traduccion ;) (*) la mayoria de los usuarios pueden saltarse estos sin problema. Feliz lectura!

Instalacion de John the Ripper  ================================ Compilar las fuentes ---------------------Compila los codigos fuente con: cd scr  make Con esto obtendras una lista de los sistemas soportados. Elige uno de ellos y teclea: make SISTEMA o, si tu sistema no esta en la lista: make generic Si todo va bien, se creara el archivo binario de John en el directorio run/john Ahora puedes copiar este directorio a donde quieras: estos son todos los archivos que necesita John en tiempo de ejecucion. Instalacion desde una distribucion de binarios -----------------------------------------------Puedes necesitar los archivos run/{john.ini, *.chr, password.lst} de la distribucion del codigo fuente para que la cosa funcione, a no ser que estos archivos ya esten presentes.

Nota sobre mover binarios entre distintos sistemas ---------------------------------------------------En algunas arquitecturas, son considerados unos cuantos parametros de hardware durante la compilacion -- en particular esto se hace en las construcciones para SPARC y generic. Si despues de la compilacion mueves los binarios a otro sistema, posiblemente no obtendras el maximo rendimiento del programa. Es preferible recompilar John en cada sistema cuando sea posible.

Opciones de la linea de comandos de John ========================================== You can list any number of password files on John's command line, and also specify some of the following options (all of them are case sensitive, but can be abbreviated): -single "single crack" mode Enables the "single crack" mode, using rules from [List.Rules:Single]. -wordfile:FILE wordlist mode, read words from FILE, -stdin or from stdin These are used to enable the wordlist mode. -rules enable rules for wordlist mode Enables wordlist rules, that are read from [List.Rules:Wordlist]. -incremental[:MODE] incremental mode [using section MODE] Enables the incremental mode, using the specified ~/john.ini definition (section [Incremental:MODE], or [Incremental:All] by default). -external:MODE external mode or word filter   Enables an external mode, using external functions defined in ~/john.ini's [List.External:MODE] section. -restore[:FILE] restore an interrupted session Continues an interrupted cracking session, reading point information from the specified file (~/restore by default). -session:FILE set session file name to FILE Allows you to specify another point information file's name to use for  this cracking session. This is useful for running multiple instances of  John in parallel, or just to be able to recover an older session later, not always continue the latest one. -makechars:FILE

make a charset, overwriting FILE

Generates a charset file, based on character frequencies from ~/john.pot, for use with the incremental mode. The entire ~/john.pot will be used for  the charset file unless you specify some password files. You can also use an external filter() routine with this option. -show show cracked passwords Shows the cracked passwords in a convenient form. You should also specify the password files. You can use this option while another John is cracking, to see what it did so far. -test perform a benchmark   Benchmarks all the enabled ciphertext format crackers, and tests them for  correct operation at the same time. -users:[-]LOGIN|UID[,..] load this (these) user(s) only Allows you to filter a few accounts for cracking, etc. A dash before the list can be used to invert the check (that is, load all the users that aren't listed). -groups:[-]GID[,..] load this (these) group(s) only Tells John to load users of the specified group(s) only. -shells:[-]SHELL[,..] load this (these) shell(s) only This option is useful to load accounts with a valid shell only, or not to load accounts with a bad shell. You can omit the path before a shell name, so '-shells:csh' will match both '/bin/csh' and '/usr/bin/csh', while '-shells:/bin/csh' will only match '/bin/csh'. -salts:[-]COUNT set a passwords per salt limit This feature sometimes allows to achieve better performance. For example you can crack only some salts using '-salts:2' faster, and then crack the rest using '-salts:-2'. Total cracking time will be about the same, but you will get some accounts cracked earlier, and may not need the rest. -format:NAME force ciphertext format NAME Allows you to override the ciphertext format detection. Currently, valid format names are DES, BSDI, MD5, BF. You can use this option when cracking or with '-test'. Note that John can't crack password files with different ciphertext formats at the same time. -savemem:LEVEL enable memory saving, at LEVEL 1..3 You might need this option if you don't have enough memory, or don't want John to affect other processes too much. Level 1 tells John not to waste memory on login names, so you won't see them while cracking. Higher levels have a performance impact: you should probably avoid using them unless John doesn't work or gets into swap otherwise. Additional Utilities ----------------------

There're some utilities in John's run directory: unshadow PASSWORD-FILE SHADOW-FILE Combines the passwd and shadow files (when you already have access to both) for use with John. You might need this since if you only used your  shadow file, the GECOS information wouldn't be used by the "single crack" mode, and also you wouldn't be able to use the '-shells' option. You'll usually want to redirect the output of 'unshadow' to a file. mailer PASSWORD-FILE A shell script to send mail to all the users who got weak passwords. You should edit the message inside before using.

Opciones de la linea de comandos de John ========================================== You can list any number of password files on John's command line, and also specify some of the following options (all of them are case sensitive, but can be abbreviated): -single "single crack" mode Enables the "single crack" mode, using rules from [List.Rules:Single]. -wordfile:FILE wordlist mode, read words from FILE, -stdin or from stdin These are used to enable the wordlist mode. -rules enable rules for wordlist mode Enables wordlist rules, that are read from [List.Rules:Wordlist]. -incremental[:MODE] incremental mode [using section MODE] Enables the incremental mode, using the specified ~/john.ini definition (section [Incremental:MODE], or [Incremental:All] by default). -external:MODE external mode or word filter   Enables an external mode, using external functions defined in ~/john.ini's [List.External:MODE] section. -restore[:FILE] restore an interrupted session Continues an interrupted cracking session, reading point information from the specified file (~/restore by default). -session:FILE set session file name to FILE Allows you to specify another point information file's name to use for  this cracking session. This is useful for running multiple instances of  John in parallel, or just to be able to recover an older session later, not always continue the latest one.

-makechars:FILE make a charset, overwriting FILE Generates a charset file, based on character frequencies from ~/john.pot, for use with the incremental mode. The entire ~/john.pot will be used for  the charset file unless you specify some password files. You can also use an external filter() routine with this option. -show show cracked passwords Shows the cracked passwords in a convenient form. You should also specify the password files. You can use this option while another John is cracking, to see what it did so far. -test perform a benchmark   Benchmarks all the enabled ciphertext format crackers, and tests them for  correct operation at the same time. -users:[-]LOGIN|UID[,..] load this (these) user(s) only Allows you to filter a few accounts for cracking, etc. A dash before the list can be used to invert the check (that is, load all the users that aren't listed). -groups:[-]GID[,..] load this (these) group(s) only Tells John to load users of the specified group(s) only. -shells:[-]SHELL[,..] load this (these) shell(s) only This option is useful to load accounts with a valid shell only, or not to load accounts with a bad shell. You can omit the path before a shell name, so '-shells:csh' will match both '/bin/csh' and '/usr/bin/csh', while '-shells:/bin/csh' will only match '/bin/csh'. -salts:[-]COUNT set a passwords per salt limit This feature sometimes allows to achieve better performance. For example you can crack only some salts using '-salts:2' faster, and then crack the rest using '-salts:-2'. Total cracking time will be about the same, but you will get some accounts cracked earlier, and may not need the rest. -format:NAME force ciphertext format NAME Allows you to override the ciphertext format detection. Currently, valid format names are DES, BSDI, MD5, BF. You can use this option when cracking or with '-test'. Note that John can't crack password files with different ciphertext formats at the same time. -savemem:LEVEL enable memory saving, at LEVEL 1..3 You might need this option if you don't have enough memory, or don't want John to affect other processes too much. Level 1 tells John not to waste memory on login names, so you won't see them while cracking. Higher levels have a performance impact: you should probably avoid using them unless John doesn't work or gets into swap otherwise. Additional Utilities

---------------------There're some utilities in John's run directory: unshadow PASSWORD-FILE SHADOW-FILE Combines the passwd and shadow files (when you already have access to both) for use with John. You might need this since if you only used your  shadow file, the GECOS information wouldn't be used by the "single crack" mode, and also you wouldn't be able to use the '-shells' option. You'll usually want to redirect the output of 'unshadow' to a file. mailer PASSWORD-FILE A shell script to send mail to all the users who got weak passwords. You should edit the message inside before using.

Ejemplos de uso de John the Ripper  ==================================== Estos ejemplos son para darte algunos trucos sobre como pueden ser usadas las opciones del John. Algunos de ellos pueden no ser obvios; pido disculpas si alguno lo es, pero es que estoy aburrido de contestar las mismas preguntas. Linea de comandos ------------------1. Primero, necesitas una copia de tu archivo de claves. Si conseguiste el archivo 'shadow', haz (como root): unshadow /etc/passwd /etc/shadow > passwd.1 Reemplaza los nombres segun tu caso y asegurate que tu archivo de claves no puede ser leido por cualquier otro. De otro modo, simplemente haz: cp /etc/passwd passwd.1 2. Asumiendo que ya tienes un archivo de claves, 'passwd.1', y quieres crackearlo, este es el modo de empezar con el modo 'single': john -single passwd.1 aunque tambien pueden ser abreviadas las opciones (yo utilizare los nombres completos en estos ejemplos): john -si passwd.1 Si tienes mas de un archivo para crackear, es mejor cargarlos todos a la vez:

john -single passwd.1 passwd.2 o incluso: john -single passwd.* 3. Las claves crackeadas son guardadas en el archivo ~/john.pot. Si quieres verlas: john -show passwd.1 Por supuesto, si la salida de este comando no cabe en la pantalla, puedes usar redireccionamineto hacia un archivo (No he puesto ejemplos de esto intencianadamente aunque algunas personas lo han pedido, ya que si preguntan esto no deberian estar usando John). Si crackeando un archivo te das cuenta que contiene entradas de shell que ya no son validas, puedes hacer que John las ignore (asumiendo que dicha shell se llama /etc/expired): john -show -shells:-/etc/expired passwd.1 o acortandolo, haciendo que ignore la shell 'expired' en cualquier path: john -show -shells:-expired passwd.1 o si quieres que John ignore alguna otra shell, por ejemplos '/etc/newuser': john -show -shells:-expired,newuser passwd.1 (NOTA: la sintaxis de arriba ha sido cambiada desde la v1.4 haciendola mas logica y mas corta al escribirla) Para verificar si alguna cuenta root (uid 0) ha sido crackeada: john -show -users:0 passwd.1 o, para comprobar alguna cuenta root (uid 0) crackeada en cualquier archivo: john -show -users:0 passwd.* Para mostrar la cuenta root (login 'root'): john -show -users:root passwd.1 Y finalmente, para verificar si hay cuentas de grupos privilegiados: john -show -groups:0,1 passwd.1

4. Para conseguir claves mas complicadas (aunque todavia faciles), puedes usar modos de crackeo mas potentes. Primero intenta una lista de palabras 'wordlist': john -w:words.lst passwd.1 o, con las reglas activadas (mas lento, pero mas potente; esto es lo que deberas usar para localizar la mayoria de las claves debiles): john -w:words.lst -rules passwd.1 Como esto tomara bastante timepo, probablemente querras continuar crackeando en background. Puedes simplemente desconectar, o cerrar tu xterm: John ignorara la se¤al de SIGHUP y continuara trabajando. Alternativamente, puedes preferir empezar la sesion con algo como esto y despues desconectar: nice -n 20 john -w:words.lst -rules passwd.1 & Para crackear solo las cuentas que tengan una shell valida (en general, los filtros para usuarios, grupos y shells mencionadas arriba funcionan para cualquier modo de crackeo): john -w:words.lst -rules -shells:sh,csh,tcsh,bash passwd.1 Como con cualquier otro modo de crackeo, es mas rapido hacerlo con todos los archivos de claves posibles: john -w:words.lst -rules passwd.* Puedes crackear algunas claves solamente. Esto intentara crackear todas las cuentas root (uid 0) en todos los archivos de claves: john -w:words.lst -rules -users:0 passwd.* Alternativamente, puedes querer no malgastar el tiempo crackeando tu propia cuenta si estas seguro de que es incrackeable: john -w:words.lst -rules -users:-root,solar passwd.* Algunas veces es preferible partir tus archivos de claves para que puedan ser  crackeados separadamente, como esto: john -w:words.lst -rules -salts:2 passwd.* john -w:words.lst -rules -salts:-2 passwd.* Esto hara que John intente 'salts' con dos o mas claves rapidamente, y a continuacion probar el resto. El tiempo total de crackeo sera mas o menos el mismo, pero obtendras algunas claves mas rapidamente, y puedes no necesitar el resto. Tambien puedes probar todas las cuentas con un 'wordlist' peque¤o, y solo aquellas que puedas probar mas rapido (con '-salts:2') con

uno largo. Usualmente es mejor probar un valor mayor que 2 para '-salts' (algunas veces incluso un valor tan alto como 1000 lo hara); ajustalo a tu caso particular. Nota que la regla por defecto para el modo 'wordlist' incluye el comando ':' como primera linea (lo que significa "prueba las palabras como aparecen en la lista"). Si ya has probado con un 'wordlist' sin usar las reglas, y ahora quieres probar con la misma lista pero usandolas, mejor que comentes este comando. 5. El modo de crackeo mas potente de John es llamado "incremental" (no es un nombre apropiado, pero se mantiene por razones 'historicas') john -i passwd.1 Esto usara el modo por defecto especificado en la correspondiente seccion del archivo ~/john.ini, [Incremental:All]. En el archivo de configuracion suministrado con John estos parametros usan la lista completa de 95 caracteres, y prueba con todas las longitudes posibles para las claves, de 0 a 8 (cuando digo password de 0 caracteres me refiero a cadenas vacias, ya que esto algunas veces ocurre). NO esperes que esto termine en un tiempo razonable (a no ser que todas las claves sean realmente debiles), lee el archivo doc/MODES.ES para una explicacion En algunos casos es preferible usar alguno de los otros modos incrementales predefinidos para crackear algunas claves a partir de un un juego de caracteres limitado. El siguiente comando probara solo 26 caracteres, claves desde 'a' hasta 'zzzzzzzz': john -i:alpha passwd.1 De nuevo, puedes crackear solo cuentas de root y usar algunas de las otras caracteristicas de John con los modos incrementales. Este comando intentara crackear todas las cuentas root (uid 0) en todos los archivos de claves, y solo aquellos que produzcan los salts marcados, asi conseguiras casi el doble de rapidez si tienes un monton de archivos de password (100 o mas, llamados '*.pwd' por ejemplo), sin embargo probablemente no habra cuentas de root con los salts marcados: john -i users:0 -salts:2 *.pwd 6. Si tienes un archivo de claves, y ya has conseguido crackear muchos passwords, o los has conseguido 'esnifandolos' (rastreandolos), y las claves del archivo no son usuales, puedes generar un nuevo juego de caracteres en un archivo, basado en los caracteres de las claves que ya has crackeado: john -makechars:mio.chr passwd.1 Despues usa este nuevo archivo en los modos incrementales.

Si conseguiste muchos passwords de tu pais, tu universidad, etc, es util usarlos todos a la vez para generar el juego de caracteres que luego usaras para intentar crackear el resto: john -makechars:mio.chr passwd.1 passwd.2 [A¤ade tu propio modo incremental en ~/john.ini. Ver mas abajo] john -i:propio passwd.3 Puedes usar algunos filtros predefinidos o creados por ti cuando estas generando el juego de caracteres, para hacer que pruebe palabras mas simples: john -makechars:mi_alpha.chr -external:mi_filtro passwd.1 Si tu archivo ~/john.pot (donde se guardan los passwords crackeados) se hace lo suficientemente grande (o si no tienes ningun juego de caracteres), puedes usarlo para generar a partir de el los nuevos juegos de caracteres principales: john -makechars:all.chr  john -makechars:alpha.chr -external:filter_alpha john -makechars:digits.chr -external:filter_digits En el ejemplo anterior, John sobreescribira el archivo del juego de caracteres por unos nuevos que estaran basados en el archivo ~/john.pot entero (John usara el archivo entero si no especificas ningun otro archivo de claves). Nota que los filtros usados en el ejemplos vienen incluidos en el archivo ~/john.ini incluido en la distribucion. 7. Finalmente, puedes querer enviar un mensaje a todos los usuarios de los que conseguistes claves debiles, para que las cambies. Esta no es siempre una buena idea (desafortunadamente, muchas personas parecen ignorar este tipo de mensajes, y pueden ser usados como ayuda para crackers, etc.), pero de todas formas, asumire que sabes lo que estas haciendo. Edita el script 'mailer' que se incluye con John: el mensaje que manda, y posiblemente el comando 'mail' (especialmente si el archivo de passwords procede de una 'box' diferente a la que usas para ejecutar el John). Despues ejecuta: mailer passwd.1 Archivo de Configuracion -------------------------1. Imaginemos que te das cuenta, en algunos archivos de claves, los passwords consisten en el nombre de login con '?!' a¤adido. Ahora solo tienes que crear una nueva regla para el modo 'single crack' (mira el archivo doc/RULES.ES para mas informacion sobre la sintaxis) y ponerla en algun lugar cerca del comienzo: [List.Rules:Single] $?$!

Truco: si quieres comentar temporalmente todas las demas reglas por defecto, puedes renombrar la seccion a algo que John no utilice, y definir unas nuevas con el nombre antiguo, pero asegurate que dejas la parte 'List.' del nombre, u obtendras un error. Todo esto tambien se puede aplicar a las reglas de los wordlist. 2. Si generas un juego de caracteres propio (descrito arriba) tambien necesitaras definir una nueva seccion en ~/john.ini con los parametros del modo incremental. En el caso mas sencillo, esta sera como lo siguiente (donde MIO debe ser reemplazado por el nombre que prefieras): [Incremental:MIO] File = MIO.chr  Esto hara que John solo utilice los caracteres que estaban en los passwords usados para generar el nuevo juego de caracteres. Para hacer que john utilice algunos caracteres extras: Extra = !@#$% Estos caracteres extras seran utilizados pero siempre considerando que seran los menos probables. Si quieres asugurarte de que, a¤adiendo tus caracteres extra, John pruebe los 95 caracteres, puedes a¤adir la linea: CharCount = 95 con lo que John mostrara un aviso si el juego de caracteres tiene menos de 95. Tambien puedes usar CharCount para limitar el numero de caracteres que probara John, aunque el juego de caracteres tenga mas: CharCount = 25 Si no usaste ningun filtro cuando generaste el juego de caracteres, poner  CharCount en un valor bajo hara que se ignoren algunos caracteres extra¤os y que se prueben passwords mas largos y complicados antes. Sim embargo, el valor por defecto es lo suficientemente inteligente como para esto y no necesitaras esta clase de truco. Para hacer que John pruebe passwords de una determinada longitud, usa: MinLen = 6 MaxLen = 8 Poner un 'MinLen' alto esta recomendado si tienes un archivo de passwords de un sistema que no admite claves cortas (sin embargo, recuerda que el root usualmente asigna cualquier password a cualquier usuario).

Por el contrario, deberias poner a 'MaxLen' un valor bajo si piensas que va a haber muchos passwords cortos. 3. Otro ejemplo: multitud de usuarios a¤aden a su password el caracter '1'. Puedes programar un filtro de palabras externo: [List.External:Filter1] void filter() { int i; i = 0; while (word[i] && word[i] >= 'a' && word[i] <= 'z') i++; if (word[i] != '1' || word[i + 1]) word = 0; } Este filtro solo dejara las palabras con caracteres alfabeticos y a¤adira un '1' al final. Ahora puedes usar este filtro con algun otro modo de craking, pero la mayoria de las veces sera demasiado lento, ya que la mayoria de las palabras seran rechazadas por el filtro. Es mejor usarlo para generar los juegos de caracteres y usar estos (siempre que tengas suficientes passwords que pasen el filtraje). Si no puedes usar las tablas de frecuencia por alguna razon, puedes usarlas programando totalmente un nuevo modo externo: [List.External:Suffix1] int length, current[9]; void init() { int i; current[length = 6] = 0; current[i = length - 1] = '1'; while (i--) current[i] = 'a'; } void generate() { int i; i = length + 1; while (i--) word[i] = current[i]; i = length - 2; while (++current[i] > 'z') if (i) current[i--] = 'a'; else current = -1; }

void restore() { int i; i = length + 1; while (i--) current[i] = word[i]; } Mira doc/EXTERNAL.ES para mas informacion sobre el lenguaje usado. Tambien puedes buscar en el archivo ~/john.ini un ejemplo de un modo externo bastante util, con montones de comentarios sobre su funcionamiento.

Definiendo un Modo Externo ============================ Para definir un modo de crackeo externo necesitas crear una seccion en tu archivo de configuracion llamada [List.External:MODO], donde MODO es cualquier identificador que quieras asignarle al modo. La seccion debera contener algunas funciones programadas en un sublenguaje de C. John las compilara y las usara si activas este modo via linea de comandos. External Functions -------------------Las siguientes funciones son usadas actualmente por John: init()

llamada al comienzo, debera inicializar todas las variables globales filter() llamada por cada palabra probada, puede filtrar algunas palabras generate() llamada para generar palabras, cuando no se usa ningun otro modo de cracking restore() llamada cuando se restablece una sesion interrumpida Todas son del tipo 'void', sin argumentos, y deben usar la variable global 'word'(predefinida como 'int word[]'), excepto para init() que es llamada antes de que se inicialice 'word'. La variable 'word' contiene la palabra que va a ser probada en ese momento, en formato ASCIIZ. Las funciones, si son definidas, deben hacer lo siguiente con 'word': * filter() puede modificar la palabra, o convertirla en cero ('word[0]') para rechazarla * generate() no puede asumir ningun valor particular para 'word' cuando es llamada, pero debe establecer la siguiente palabra que sera probada, o en cero ('word[0]') cuando el proceso de cracking esta completado (esto hara que termine el programa)

* restore() debera establecer las variables globales para continuar desde 'word'. Puedes usar un modo externo externo separadamente, o con otros modos de crackeo, en cuyo caso solo init() y filter() seran usadas (y solo filter() es requerida). Usar un filtro externo es compatible con todos los otros modos de crackeo y con la opcion '-makechars'. Recomiendo que no uses filter(), o que por lo menos no filtres demasiadas palabras cuando uses un modo externo con tu propia generate(). Mejor modifica generate() para que no genere las palabras que serian filtradas. El Lenguaje ------------Como ya he mencionado arriba, el compilador soporta un subconjunto de C. John es un crackeador, no un compilador, por eso no pienso que sea necesario incluir nada mas. (Bueno, no estoy del todo seguro de que necesite un compilador despues de todo, pero usar uno externo, por ejemplo perl, es menos conveniente en algunos casos..) Una lista de los identificadores soportados: void, int, if, else, while, continue, break, return. Puedes definir funciones estandar para ser llamadas por John, definir variables locales y globales (incluyendo matrices unidimensionales), usar todas las operaciones entre enteros soportados en C y usar comentarios de C. Las funciones siguientes no estan incluidas: * solo las funciones estandar estan soportadas, no puedes definir las tuyas propias; * solo los bucles 'while' estan soportados; * solo los tipos de datos 'int' y 'void' estan supported; * solo se permiten matrices (arrays) unidimensionales; * structs/unions no estan supported; * los punteros no estan soportados (el nombre del array se refiere al primer  elemento) * algunas cosas mas, probablemente... Puedes encontrar algunos ejemplos de modos externos en el archivo de configuracion suministrado con John. You can find some external mode examples in the default configuration file supplied with John.

Modos de crackeo de John the Ripper  ===================================== Estas descripciones son cortas y solo cubren las opciones basicas. Lee los otros archivos de ayuda para obtener informacion sobre como personalizar  los modo. Modo Wordlist (Archivo de palabras) ------------------------------------Este es el modo mas simple soportado por John. Todo lo que necesitas hacer es especificar un wordlist (un archivo con una palabra por linea) y algunos archivos de passwords. Puedes activar las reglas (que se usan para modificar  dichas palabras) si lo deseas, y seran aplicadas a cada palabra de la lista. Este archivo no debe contener vacios. John no ordena las palabras para no usar demasiada memoria, ya que esto necesitaria cargar toda la lista en la memoria, mientras que ahora se lee directamente del disco mientras se crackea. Ademas, no ordenar las palabras te permite poner las mas frecuentes al principio de la lista para que sean probadas antes. words first. Sin embargo, si no tienes ninguna preferencia en el orden, es mejor que ordenes las palabras alfabeticamente: John funciona un poco mas rapido si cada palabra difiere solo en algunos caracteres, esto es especialmente aplicable si solo crackeas unos pocos passwords de una vez. La mayoria de los wordlist que encuentres en la red estan ya ordenados. Adiccionalmente, no deberias tener palabras de mas de 8 caracteres (o cualquiera que sea el limite del actual formato de cifrado), ya que los passwords seran considerados iguales si las 8 primeras letras lo son. John puede manejar estas situaciones (y solo probara el password una vez) cuando dichas palabras esten una a continuacion de la otra (esto es, cuando la lista este ordenada). Es preferible que no trunques la lista en 8 caracteres, ya que el resto pueden ser necesitados si activas las reglas. La manera recomendada de ordenar una wordlist para usarlo con las reglas por defecto de dicho modo es: tr A-Z a-z < ORIGEN | sort -u > DESTINO Mira en doc/RULES.ES consejos sobre como crear tu propio wordlist. Modo "Single Crack" --------------------Este es el modo con el que deberias comenzar a crackear. Este modo intentara usar la informacion del login/GECOS como passwords. Como la informacion solo se usa en la cuanta de la que se ha tomado (y solo con passwords con los mismos 'salts', lo que no consume tiempo extra), el modo "single crack" es mucho mas rapido que el modo wordlist, y permite el uso de muchas reglas (estas estan siempre activadas en este modo) en un tiempo razonable.

Los passwords encontrados tambien son probados en el archivo de passwords, por si hay mas de un usuario con el mismo password. Por supuesto, esto solo cogera aquellos passwords que esten basados en la informacion usada. Hay que darse cuenta que, por las caracteristicas de este modo, se obtendran mas cuentas crackeadas si lo usas con multitud de archivos de passwords que si lo usas en cada archivo por separado. Modo Incremental -----------------Este es el modo de crackeo mas potente, ya que probara todas las combinaciones de caracteres posibles. Sin embargo, se asume que este modo nunca terminara de ejecutarse ya que el numero de combinaciones son demasiado alto (actualmente, la unica posibilidad de que termine en un tiempo razonable -- mientras sigas vivo :-) -- es limitar la longitud del password, o usar un juego de caracteres peque¤o), y tendras que interrumpirlo tu manualmente. Este es el porque este modo trabaja con tablas de frecuencia de caracters, para coger el mayor numero posible de passwords en un tiempo limitado. Para usar este modo necesitas una definicion especial de los parametros del modo (incluyendo la longitud del password y los juegos de caracteres). Estos parametros se definen en la seccion del ~/john.ini llamada [Incremental:MODO], donde modo es cualquier nombre que asignes al modo (este es el nombre que tendras que especificar a John en la linea de comandos). Puedes usar cualquieras de los modos predefinidos ('All, 'Alpha', o 'Digits'), o definir uno propio. Mira en doc/CONFIG y en doc/EXAMPLES en busca de informacion sobre como crar tu propio modo. Modo Externo --------------Puedes definir un modo de crackeo externo para usarlo con John. Esto se hace con la seccion del archivo ~/john.ini llamad [List.External:MODE] donde mode es cualquier nombre que quieras asignar al modo. La seccion debera contener algunas funciones, que John usara para generar las palabras que usara cuando crackee. Las funciones seran escritas en un sublenguaje de C, para ser compiladas por John al inicio (si tu activas el modo en la linea de comandos, por supuesto). Lee doc/EXTERNAL.ES. ¨Que modos debo usar? -------------------------Lee doc/EXAMPLES.ES en busca de un orden razonable sobre los modos de cracking a usar.

John the Ripper -- Historial de cambios ========================================= Cambios de la v1.4 a la v.15 -----------------------------* Todo el codigo ha sido reescrito para hacerlo mas extensible en el futuro, mas portable (no se han usado extensiones de GNU C, si no que se define __GNUC__), y mas comprensible. * Rutinas Bitslice DES: mas de 3 veces mas rapido en RISC. * Soporte para el formato de cifrado extendido basado en DES de BSDI. * Soporte para el formato de cifrado basado en Blowfish de OpenBSD. * Rutinas en ensamblador especiales para DES, en maquinas x86 con MMX: +30% en un Pentium II. * Rutinas MD% mejoradas (C y ensamblador x86), 10...50% mas rapido. * Cambio de longitud mas inteligente en el modo incremental. * Las reglas para los Wordlist son expandidas ahora en tiempo de ejecucion y no al comienzo. * Nuevas opciones: '-session', '-groups', * Se han simplificado la sintaxis para '-users', '-shells', '-salts'. * Se han cambiado '-noname' y '-nohash' por '-savemem'. * Se han cambiado '-des' y '-md5' por '-format'. * Se han elimindao algunas opciones obsoletas, para mantener la cosa sencilla. * Se han a¤adido 'continue', 'break', 'return' en el compilador interno. * Ahora puedes usar comentarios de C en las definiciones de los modo externos. * Mejor juego de reglas por defecto: limite variabe de longitud, menos redundancia. * Muchas mejoras de algoritmos internos. Cambios de la v1.3 a la v1.4 -----------------------------* Soporte para los passwords basados en MD5. * Rutinas DES para ensamblador SPARC V8. * Correcciones de muchos errores. Las versiones inferiores a la v1.3 probablemente no seran mencionadas desde ahora...

Traduccion de los archivos de ayuda de John the Ripper  ======================= by cafo ======================== Pues ya esta listo. Despues de pasarme literalmente horas en el IRC explicando a los novatos como utilizar este crackeador de passwords,

me dispuse a hacer la traduccion, a ver si ya vamos aclarando conceptos. Sobre la traduccion --------------------Traducir un texto complejo siempre es dificil, y mas cuando tienes que traducir terminos que usualmente se utilizan en su forma extranjera, pero he intentado no dar ningun termino 'por conocido' ya que esta traduccion va dirigida especialmente a los que empiezan. Asi y todo no he podido evitar usar tecnicismos del ingles cuando me refiero a lenguajes de programacion, formatos de cifrado, y demas. Tambien he tenido que traducir algunos terminos para no caer en la redundancia, asi que no te extra¤es de encontrar las palabras 'password' y 'clave' en una misma frase, cuando ambas significan lo mismo. Otra de las cosas que hay que notar es que una vez que doy la explicacion a un termino, suelo usar dicho termino en ingles ya que es mas corto de escribir :) (es el caso de 'wordlist'). Si alguien que ya hubiera leido los archivos encuentra alguna incorreccion, por monstruosa que sea, que no dude en ponerse en contacto conmigo para corregirlo ;).

John the Ripper F.A.Q. ======================== Q: ¨Por que "John"? A: ¨Por que no? Q: ¨Por que "the Ripper"? A: Esa fue una idea de Lost Soul. Preguntaselo a el. Q: ¨Es mejor John the Ripper que Crack? A: Decide por ti mismo: John es mas rapido, y tiene algunas funciones mas, sin embargo Crack sigue siendo muy bueno. Q: ¨Es mejor John the Ripper que Star Cracker? A: De hecho, Star Cracker v1.0 es muy similar a John v1.4: la mayor diferencia es la fecha de produccion, por eso me preguntaba -- ¨por que hacer otra version de John ;-). No entrare en detalles ahora, pero obviamente compartimos algunas ideas (nada malo), y las rutinas DES John v1.4 son usadas en *C (con mi permiso). Ambos crackeadores tenian el mismo problema de dise¤o: no es facil a¤adir algoritmos completamente nuevos, como nuevos formatos de cifrado, y DES Bitslices. En los tiempos de creacion de *C v1.0, estuve pensando en una nueva estructura que permitiera implementar todas las nuevas

ideas al mismo tiempo. Por eso, contacte con The SorCErEr, y decidimos que yo continuara el trabajo en John v1.5, mientras el comienza a hacer otros proyectos en vez de trabajar en nuevas versiones de *C, ya que, en mi opinion, hacer el mismo trabajo por duplicado es una perdida de tiempo. Ahora que que el codigo de John v1.5 esta separado en modulos, y es mucho mas facil de entender (eso espero), es posible para otros, y para The SOrCErEr  (quien obviamente es un programador con talento), unirse en el desarrollo de un crackeador de password mejor. Ya veremos. Para la pregunta original: creo que John v1.5 es ahora mejor que *C v1.0. Q: ¨Es mejor John the Ripper que Cracker Jack? A: Si. Q: ¨Habra una version optimizada para Pentium de John the Ripper? A: La estas viendo ahora mismo. Q: ¨Como puedo comprobar las rutinas de control de passwords de John, para un para hacer las operaciones oportunas? A: John siempre se chequea a si mismo cuando lo ejecutas sobre un archivo de passwords y avisa si encuentra algun error. Si solo necesitas probar  todas las rutinas, usa la opcion '-test' en la linea de comandos. Q: ¨Como uso un modo de cracking, ver los passwords conseguidos, etc? A: Mira en doc/EXAMPLES.ES :-) Q: ¨Por que John no carga mi archivo de passwords? Dice: 'Loaded 0 passwords'. A: Tu archivo de passwords probablemente usa 'shadow'. necesitas obtener  el archivo de passwords y el archivo 'shadow', y combinarlos en uno para usarlo con John. Tambien puedes obtener el mismo aviso si tu archivo de passwords o el formato de cifrado no esta soportado por John. not supported by John. Q: ¨Como puedo deshacer el 'shadow'? A: Mira en doc/EXAMPLES.ES para ver como combinar ambos archivos. Si no tienes acceso de root, no encontraras respuesta para ti ;-). Ese no es el proposito de este FAQ. Probablemente sera mejor que simplemente borres el programa si tienes que preguntar esto ;). Q: ¨Por que John no muestra un indicador de progreso en los modos incrementales? A: ¨Realmente quieres ver '0%' todo el tiempo? Probablemente necesitas leer  otra vez el archivo doc/MODES.ES si lo preguntas. Q: ¨Por que muestra John los valores de c/s, en vez que los valores reales de crypt() por segundo? A: Los valores presentados indican las combinaciones (de login y passwords) por segundo, no crypts() por segundo. Esta es la velocidad efectiva de crackeo en un determinado archivo de passwords, y puede ser utili, por ejemplo, para ajustar el valor que uses para la opcion '-salts'. Si solamente quieres hacer  un banco de pruebas de las rutinas de control de passwords, usa la opcion

'-test'. Q: Me acabo de dar cuenta de que los valores de c/s que son mostrados cuando uso los modos incrementales son mucho menores que en otros modos de cracking. Son incluso menores de lo que eran en la version v1.0. ¨Que ha ocurrido? A: Probablemente habras usado John solamente unos segundos. Mi nueva implemententacion del modo incremental usa juegos de caracteres bastante largos que necesitan ser expandidos cada vez que John cambia entre distintas longitudes de passwords. Afortunadamente, esto solo se nota cuando John acaba de ser iniciado, ya que raramente cambia esta longitud cuando lleva trabajando varias horas. Creo que no es un precio demasiado alto a cambio de un mejor orden en los intentos de crackeos. Q: ¨John soporta el porceso en paralelo? A: Tengo un poryecto separado para eso. No hay soporte en John ahora mismo para el porceso en paralelo, sin embargo siempre puedes usar un filtro de palabras externo para ese proposito -- mira el archivo de configuracion suministrado para ver un ejemplo. Q: ¨Donde puedo encontrar wordlists? A: Puedes encontrar algunos en ftp://sable.ox.ac.uk/pub/wordlists. Q: ¨Cual es el sitio principal de John? A: http://www.false.com/security/john/. Q: ¨Como puedo contactar contigo? A: Mira en doc/CREDITS.ES.