http://www.decowar.com/manual_john_the_ripper.

htm
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.

Personalizando John the Ripper

================================

El comportamiento de John the Ripper puede ser personalizado editando su archivo de

configuracion, ~/john.ini. Puedes establecer valores por defecto para las opciones de la linea de
comandos, definir listas de palabras y las reglas para el modo "single crack", definir parámetros
para los modos incrementales, o incluso definir nuevos modos de cracking.

El archivo de configuracion tiene numerosas secciones. Cada seccion empieza con una linea
con su nombre entre corchetes. Las secciones consisten en asignar valores a algunas
variables (utilizando 'variable=valor'), o en a¤adir cualquier otra especificacion de texto en
alguna seccion en particular (los nombres de estas secciones empiezan con "list."). El uso de
mayúsculas o minusculas en los nombres de las secciones es indiferente, asi que utiliza la que
mejor te convenga. Las lineas que empiecen por '#', ';', o lineas en blanco son ignoradas asi
que pueden ser usadas para poner comentarios o para inutilizar lineas de opciones sin tener
que borrarlas.

Opciones Generales

Los valores por defecto para algunas de las opciones de la linea de comandos pueden ser
definidas en la seccion '[Default]'. Actualmente solo puedes definir aqui una variable:

Wordfile Especifica un archivo de palabras. Esto asumira el modo 'wordlist' por defecto (no
es necesario incluir el valor '-wordfile' en la linea de comandos a no ser que
quieras cambiar este valor por defecto).

Definiendo Reglas para la lista de palabras

Las reglas para los modos 'wordlist' y 'single crack' se definen en secciones separadas,
[List.Rules:Wordlist] y [List.Rules:Single] respectivamente (recuerda que no importan las
mayusculas). El programa usa la sintaxis de Crack (escrito por Alec Muffett), que os resultara
familiar a muchos de vosotros. Tambien se han a¤adido algunas reglas mas, y (lo que es mas
importante) un preprocesador, que puede generar multiples reglas para una sola linea de
codigo.

Cuando definas nuevas reglas, simplemente pon una regla por linea (línea que puede incluir
comandos para el preprocesador). Mira el archivo doc/RULES para mas informacion sobre la
sintaxis de las reglas o del prepocesador.

Parametros del Modo Incremental

Para definir los parametros del modo incremental necesitas crear una sección llamada
[Incremental:MODO], donde MODO es el nombre que vas a asignarle a ese modo. Hay
algunos modos incrementales predefinidos en los archivos de configuracion por defecto que
vienen con John the Ripper que pueden ser usados como modelos para las personalizaciones.

Se soportan los siguientes parametros:

File Establece el nombre de tu archivo de caracteres. En el archivo doc/EXAMPLE hay un

ejemplo sobre como generar uno.

MinLen Longitud minima del password, en caracteres (0 por defecto)

MaxLen Longitud maxima del password, en caracteres (la variable CHARSET_LENGTH

esta definida en el archivo src/params.h, y toma el valor 8 por defecto.

CharCount Te permite limitar el numero de caracteres usados para hacer que John empiece
a probar los password mas largos antes.
Tambien puede ser usada para hacer que John imprima un aviso si el juego de
caracteres define menos caracteres que CharCount. Por defecto (cuando esta
opcion no se usa) se usan todos los caracteres definidos.
Extra Esta opcion puede ser usada para hacer que John pruebe algunos caracteres
extras que no aparezcan en el juego de caracteres. Simplemente pon todos esos
caracteres aqui. Seran considerados pero no como los mas probables.

Definir un Modo Externo

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...

========================================================================
========

Definiendo un Modo Externo

Para definir un modo de crackeo externo necesitas crear una sección en tu archivo de
configuracion llamada [List.External:MODO], donde MODO es cualquier identificador que
quieras asignarle al modo. La seccion deberá 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 <XMP> &lt; ORIGEN | sort -u &gt; </XMP> 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 información 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 obtendrán 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 lla 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 parámetros 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.

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 thelist 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.

Sintaxis para las reglas de la lista de palabras (Wordlists)

=============================================================

Cada regla de Wordlist consiste en uno o varios comandos simples, escritos

en una linea y, opcionalmente, separados por espacios. Hay tambien un
preprocesador que puede generar multiples reglas a partir de una sola
linea de codigo. Mas abajo encontraras las descripciones de los comandos
de reglas (muchos de ellos son compatibles con la version 5.0 de Crack)
y la sintaxis del preprocesador.

Codigos de Posicion
---------------------
Las posiciones de los caracteres son numeradas empezando por 0, y están especificadas en
las reglas por los siguientes caracteres:

0...9 para 0...9

A...Z para A...Z
* para max_lenght
- para (max_lenght - 1)
+ para (max_lenght + 1)

Aqui 'max_lenght' es la longitud maxima en texto plano soportada por el actual formato de
cifrado.

Los mismos caracteres tambien son usados para especificar otros parámetros numericos.

Clases de caracteres
----------------------
?? indica '?'
?v indica vocales: "aeiouAEIOU"
?c indica consonantes: "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
?w indica espacios: "\t"
?p indica puntuacion: ".,:;'\"?!`"
?s indica simbolos: "$%^&amp;*()-_+=|\\&lt;&gt;[]{}#@/~"
?l indica letras en minusculas [a-z]
?u indica letras en mayusculas [A-Z]
?d indica numeros [0-9]
?a indica letras [a-zA-Z]
?x indica letras y numeros [a-zA-Z0-9]

Los complementarios a una clase pueden especificarse poniendo en mayuscula

su nombre. Asi, por ejemplo, '?D' indica todo excepto numeros.

Comandos Simples
------------------

: no-op: no hace ninguna operacion con la palabra

l convierte en minuscula
u convierte en mayuscula
c pone la primera letra en mayuscula (capitaliza)
C minuscula el primer caracter, y mayuscula el resto
t invierte el caso de todos los caracteres (mayusculas en minusculas
y viceversa)
r invierte: "Fred" -&gt; "derF"
d duplica: "Fred" -&gt; "FredFred"
f reflejo: "Fred" -&gt; "FredderF"
{ rota la palabra a la izquierda: "jsmith" -&gt; "smithj"
} rota la palabra a la derecha: "smithj" -&gt; "jsmith"
$X a¤ade el caracter X a la palabra
^X antepone el caracter X a la palabra
 Comandos de Control de Longitud
---------------------------------

<N rechaza la palabra a no ser que tenga menos de N caracteres>

N rechaza la palabra a no ser que tenga mas de N caracteres
'N trunca la palabra a N caracteres

Comandos de Gramatica Inglesa

-------------------------------

p pone en plural: "crack" -&gt; "cracks",etc (solo en minusculas)

P "crack" -&gt; "cracked", etc (solo en minusculas)
I "crack" -&gt; "cracking", etc (solo en minusculas)

Comandos de Insercion/Eliminacion
-----------------------------------

[ elimina el primer caracter

] elimina el ultimo caracter
DN elimina el caracter en la posicion N
xNM extrae una subcadena a partir de la posicion N contando M caracteres
iNX inserta el caracter X en la posicion N y desplaza el resto a la derecha
oNX reemplaza el caracter de la posicion N por el caracter X

Nota que '[' y ']' son caracteres de control del preprocesador: debes
'escaparlos' usando el caracter '\'.

Comandos de Conversion del Juego de Caracteres

-------------------------------------------------

S cambia el caso: "Crack96" -&gt; "cRACK)&amp;"

V minuscula las vocales: "Crack96" -&gt; "CRaCK96"
R desplaza cada caracter a la derecha, segun el teclado:
"Crack96" -&gt; "Vtsvl07"
L desplaza cada caracter a la izquierda, segun el teclado:
"Crack96" -&gt; "Xeajx85"

Comandos de Acceso a Memoria

------------------------------

M memoriza la palabra
Q rechaza la palabra a no ser que haya cambiado

Comandos de Clase de Caracteres

---------------------------------

sXY reemplazar todos los caracters X de la palabra por Y

s?CY reemplazar todos los caracteres de la clase C en la palabra por Y
@X Elimina todos los caracteres X de la palabra
@?C Elimina todos los caracteres de la clase C de la palabra
!X rechaza la palabra si contiene el caracter X
!?C rechaza la palabra si contiene un caracter de la clase C
/X rechaza la palabra a no ser que contenga el caracter X
/?C rechaza la palabra a no ser que contenga un caracter de la clase C
=NX rechaza la palabra a no ser que el caracter de la posicion N sea X
=N?C rachaza la palabra a no ser que el caracter de la posicion N sea
de la clase C
(X rechaza la palabra a no ser que su primer caracter sea X
(?C rechaza la palabra a no ser que su caracter sea de la clase C
)X rechaza la palabra a no ser que su ultimo caracter sea X
)?C rechaza la palabra a no ser que su ultimo caracter sea de la clase C
%NX rechaza la palabra a no ser que contenga N repeticiones de X
%N?Crechaza la palabra a no ser que contenga al menos N caracteres de la
clase C
Comandos Extras del Modo "Single Crack"
-----------------------------------------

Cuando se define el modo "single crack", hay comandos adiccionales para el

soporte de parejas de palabras, para controlar si otro comando sera aplicado
a la primera, segunda o ambas palabras:

1 solo la primera palabra

2 solo la segunda palabra
+ la concatenacion de las dos (solo debe usarse despues de '1' o '2')

Si usas algunos de estos comandos en una regla, esta solo procesara parejas de palabras
(nombres completos, desde la informacion de GECOS), y rechaza las palabras individuales. Se
asume '+' al final de cada regla que use cualquiera de estos comandos, a no ser que lo
especifiques manualmente.

Por ejemplo, '1l2u' convertira la primera palabra en minuscula, la segunda en mayuscula y

usara la concatenacion de ambas. El uso de '+' puede ser aplicada a algunos comandos mas:
'1l2u+r' invertira la concatenacion de ambas palabras despues de aplicar los demas comandos.

El Preprocesador de Reglas

El preprocesador se usa para combinar reglas semejantes en una linea de codigo. Por ejemplo,
si necesitas que John pruebe palabras en minúsculas con digitos a¤adidos, puedes escribir una
regla por cada caracter, 10 en total. Ahora imagina que quieres a¤adir dos digitos: el archivo de
configuracion se volveria demasiado largo e incomprensible.

Con el preprocesador puedes hacer todo esto de una forma mas facil.

Simplemente escribe una linea de codigo con las partes comunes a todas estas reglas, y una
lista de los caracteres que tengas que poner en reglas separadas, entre corchetes (la forma de
las expresiones regulares). El preprocesador generara entonces las reglas por ti (al comienzo
para comprobar la sintaxis, y una vez mas mientras crackea, pero nunca mantiene las reglas
expandidas en memoria). Por ejemplo, para los casos de arriba, las lineas de codigo seria 'l$[0-
9]' (minusculas y a¤ade un digito) y 'l$[0-9]$[0-9]' (minusculas y a¤ade dos digitos). Estas lineas
de códigos se expanden a 10 y a 100 reglas respectivamente. Hay que tener en cuenta que se
procesan los comandos del preprocesador de derecha a izquierda, y los caracteres son
procesados de izquierda a derecha, con lo que se obtiene un orden normal de los numeros en
casos como el de a¤adir dos digitos.

Notese que solo se han usado rangos de caracteres a en estos ejemplos, sin embargo puedes
usar cualquier rango de la lista de caracteres, como '[aeiou]' que usara las vocales, o '[aeiou0-
9]' que usara vocales y numeros.

Si necesitas probar las vocales primero, y todas las demas letras despues, puedes usar
'[aeioua-z]': el preprocesador es lo suficientemente inteligente como para no producir reglas
duplicadas.
Hay algunos caracteres de control para las reglas ( '[' empieza la lista de caracteres del
preprocesador, '-' indica un rango dentro de la lista, etc).

Debes usarlos con el prefijo '\' si quieres usarlos como caracteres normales en vez de usar si
significado especial. Por supuesto, esto tambien se aplica al caracter '\'. Ademas si quieres
iniciar una lista de caracteres del preprocesador al principio de una linea, tendras que usar el
prefijo ':',
o sera tomada como el inicio de una nueva seccion.
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 &gt; 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 &amp;

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 sección del archivo
~/john.ini, [Incremental:All]. En el archivo de configuración 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 útil 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 u | 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] &amp;&amp; word[i] &gt;= 'a' &amp;&amp; word[i] &lt;= 'z') i++;
<XMP>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] &gt; 'z')
if (i) current[i--] = 'a'; else current = -1;
}

void restore()
{
int i;

i = length + 1;
while (i--) current[i] = word[i];
}
</XMP>

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.

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/.