24 Julio 2014, 05:04:56 pm

Autor Tema: Manual Supercompleto para "John the Ripper"  (Leído 24049 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado GeRaNgEl_88

  • Me das tu IP?
  • *
  • Mensajes: 115
  • Puntos: +0/-0
  • Sexo: Masculino
  • 0WN3D
    • Ver Perfil
Manual Supercompleto para "John the Ripper"
« en: 14 Julio 2007, 06:51:59 am »
 

Manual John the Ripper

 

 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 parametros

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 mayusculas

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 (linea

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 seccion

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

 

 

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

 

 

 

 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.

 

 

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

 

 

 

 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 estan

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 parametros

numericos.

 

 Clases de caracteres

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

 

??      indica '?'

?v      indica vocales: "aeiouAEIOU"

?c      indica consonantes: "bcdfghjklmnpqrstvwxyzBCDFGHJK LMNPQRSTVWXYZ"

?w      indica espacios: "\t"

?p        indica puntuacion: ".,:;'\"?!`"

?s         indica simbolos: "$%^&*()-_+=|\\<>[]{}#@/~"

?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" -> "derF"

d       duplica: "Fred" -> "FredFred"

f       reflejo: "Fred" -> "FredderF"

{       rota la palabra a la izquierda: "jsmith" -> "smithj"

}       rota la palabra a la derecha: "smithj" -> "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 mas de N caracteres

'N      trunca la palabra a N caracteres

 

 Comandos de Gramatica Inglesa

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

 

p       pone en plural: "crack" -> "cracks",etc (solo en minusculas)

P       "crack" -> "cracked", etc (solo en minusculas)

I       "crack" -> "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" -> "cRACK)&"

V       minuscula las vocales: "Crack96" -> "CRaCK96"

R       desplaza cada caracter a la derecha, segun el teclado:

        "Crack96" -> "Vtsvl07"

L       desplaza cada caracter a la izquierda, segun el teclado:

        "Crack96" -> "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?C rechaza 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 minusculas

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 codigos

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 > 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 &amp;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/
« última modificación: 11 Julio 2011, 06:15:00 pm por cemasmas »
♂Gεяαngει_88♂ ©

█║▌│ █│║▌ ║││█║▌ │║║█║
τσdσs lσs Dεяεcнσs яεsεяvαdσs.


  Asunto / Iniciado por Respuestas / Vistas Último mensaje
xx
"""EJEMPLO VISUAL BASIC PARA ENVIAR MAILS""""

Iniciado por angelsk

2 Respuestas
2219 Vistas
Último mensaje 15 Abril 2006, 04:39:16 pm
por NetClass
thumbup
matar msn y apagar ordena """VIRUS""" para novatos

Iniciado por Spiff

15 Respuestas
3825 Vistas
Último mensaje 04 Junio 2007, 02:45:41 am
por doggfather
xx
John the ripper

Iniciado por kentshy

0 Respuestas
725 Vistas
Último mensaje 31 Diciembre 2007, 07:47:36 am
por kentshy
xx
descarga john the ripper

Iniciado por 01crackerx01

2 Respuestas
1078 Vistas
Último mensaje 24 Julio 2008, 02:56:35 pm
por 01crackerx01
exclamation
AYUDA CON EL JOHN THE RIPPER

Iniciado por hormiga-revolucionaria

8 Respuestas
2025 Vistas
Último mensaje 18 Octubre 2006, 03:10:40 pm
por hormiga-revolucionaria
exclamation
John The Ripper y GNU/Linux

Iniciado por Aetsu

4 Respuestas
825 Vistas
Último mensaje 16 Diciembre 2011, 02:18:20 am
por Rcart
xx
John de Ripper no me funciona

Iniciado por Cashern

1 Respuestas
2019 Vistas
Último mensaje 18 Junio 2009, 08:57:54 am
por .xAk.
question
desifrar claves con John the Ripper

Iniciado por skull?

3 Respuestas
1883 Vistas
Último mensaje 17 Noviembre 2009, 06:58:36 pm
por Aetsu