================================================================================
disculpa si lo pegue en dos secciones es q hay un maximo de 50000 caracteres...
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
&& word >= 'a' && word <=
'z') i++;
if (word != '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 = 'a';
}
void generate()
{
int i;
i = length + 1;
while (i--) word = current;
i = length - 2;
while (++current &gt; 'z')
if (i) current[i--] = 'a'; else current = -1;
}
void restore()
{
int i;
i = length + 1;
while (i--) current = word;
}
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
cando 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
Necesitas ser usuario para ver los enlaces Crear Usuario Hacer Sesion.
Q: ¨Cual es el sitio principal de John?
el autor : nose quien es pero no lo ecribi yop.. 
Autor