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......................................................................4
Opciones de la linea de comandos de John......................................................................6
Ejemplos de uso de John the Ripper.................................................................................8
Definiendo un Modo Externo.........................................................................................15
Modos de crackeo de John the Ripper............................................................................17
John the Ripper -- Historial de cambios.........................................................................19
Traduccion de los archivos de ayuda de John the Ripper.......................................19
John the Ripper 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.