
 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 seal 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'
pequeo, 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
        [Aade 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 '?!' aadido. 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, aadiendo tus caracteres
extra, John pruebe los 95 caracteres, puedes aadir 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 extraos
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 aaden 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 aadira
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.
