John The Ripper

John the Ripper (JTR o john) es una herramienta de pentesting esencial que se utiliza para comprobar la fortaleza de las contraseñas y descifrar contraseñas cifradas (o con hash) mediante ataques de fuerza bruta o de diccionario. . La variante «Jumbo» se recomienda a los profesionales de la seguridad, ya que cuenta con optimizaciones de rendimiento y funciones adicionales como listas de palabras multilingües y compatibilidad con arquitecturas de 64 bits. Esta versión es más eficaz a la hora de descifrar contraseñas con mayor precisión y rapidez.

Con ella, podemos utilizar varias herramientas para convertir distintos tipos de archivos y hashes a un formato utilizable por John. Además, el software se actualiza periódicamente para mantenerse al día con las tendencias y tecnologías de seguridad actuales, garantizando la seguridad del usuario.

Attack Methods

Dictionary Attacks

En este método se utiliza una lista predefinida de palabras y frases—lo que llamamos "diccionario"—para descifrar contraseñas. Esta lista puede provenir de diccionarios públicos, contraseñas filtradas o incluso comprarse a proveedores especializados. El proceso consiste en generar cadenas a partir del diccionario y compararlas con los hashes de las contraseñas; si se encuentra coincidencia, la contraseña se revela, permitiendo al atacante acceder al sistema y sus datos. Por eso, es crucial emplear contraseñas complejas, cambiarlas con regularidad y aplicar autenticación de dos factores.

Brute Force Attacks

Este método consiste en probar todas las combinaciones posibles de caracteres para encontrar la contraseña correcta. Aunque es muy exhaustivo y lento, se recurre a él cuando no hay otras alternativas. Cuanto mayor y más compleja sea la contraseña, más tiempo llevará descifrarla, por lo que se recomienda que tenga al menos 8 caracteres, combinando letras, números y símbolos.

Rainbow Table Attacks

Este enfoque utiliza tablas pre-calculadas que relacionan hashes con sus contraseñas en texto claro, lo que acelera el proceso en comparación con la fuerza bruta. Sin embargo, su efectividad depende del tamaño de la tabla: una tabla más grande abarca más contraseñas, pero solo sirve para descifrar aquellos hashes que ya estén incluidos. Si el hash no figura en la tabla, el método no será útil.

Cracking Modes

Single Crack Mode

El Single Crack Mode de John the Ripper es un método popular que utiliza una única lista de contraseñas para realizar un ataque de fuerza bruta. En esencia, el programa recorre cada palabra de la lista de manera secuencial hasta encontrar la que coincida con el hash de la contraseña. Aunque es un método muy directo y fácil de implementar, su eficiencia depende de la complejidad de la contraseña y del contenido de la lista, lo que puede hacer que el proceso se prolongue considerablemente.

La sintaxis básica es:

gzzcoo@htb[/nobody]$ john --format=<hash_type> <hash or hash_file>

Por ejemplo, para un archivo llamado hashes_to_crack.txt con hashes SHA-256, el comando sería:

gzzcoo@htb[/nobody]$ john --format=sha256 hashes_to_crack.txt

Al iniciar el proceso, John compara cada hash con las palabras de su lista incorporada o con las adicionales que se especifiquen mediante la opción --wordlist, y puede usar reglas (--rules) para generar candidatos adicionales. Aunque este método es sencillo, su éxito depende de que la contraseña se encuentre o se pueda generar a partir de la lista; de lo contrario, el ataque podría no dar resultado.

Los hashes descifrados se muestran en la consola y se guardan en el archivo john.pot (usualmente en ~/.john/john.pot), y el proceso continúa en segundo plano, permitiendo verificar el progreso con john --show. Para aumentar las probabilidades de éxito, es crucial emplear wordlists y reglas lo más completas y actualizadas posible.

Wordlist Mode

El Wordlist Mode se emplea para descifrar contraseñas utilizando varias listas de palabras. Funciona como un ataque de diccionario, donde se prueban, una tras otra, todas las palabras de las listas hasta hallar la que coincida. Este método resulta ideal para atacar múltiples hashes de contraseñas con una o varias wordlists, siendo más efectivo que el Modo de Crackeo Simple gracias a su mayor cantidad de palabras, aunque sigue siendo una técnica bastante básica.

La sintaxis básica es:

gzzcoo@htb[/nobody]$ john --wordlist=<wordlist_file> --rules <hash_file>

Primero, se indica el archivo (o archivos) que contiene la lista de palabras, en formato de texto plano (una palabra por línea), pudiendo especificarse varias separándolas con comas. Después, se puede aplicar un conjunto de reglas o las transformaciones predefinidas para modificar las palabras de la lista—por ejemplo, agregando números, cambiando mayúsculas o añadiendo caracteres especiales—para generar candidatos adicionales.

Incremental Mode

El modo incremental en John the Ripper es una opción avanzada que genera sobre la marcha todas las combinaciones posibles a partir de un conjunto de caracteres. Este método, que parte de contraseñas de un solo carácter e incrementa la longitud progresivamente, es muy eficaz pero también puede ser muy exigente en recursos y tiempo, dependiendo de la complejidad de la contraseña, la configuración de la máquina y el tamaño del conjunto de caracteres.

A diferencia del modo wordlist, que utiliza listas predefinidas, el modo incremental crea las conjeturas al instante, lo que lo hace ideal para probar contraseñas débiles o cuando se tiene una idea aproximada de su estructura. Por otro lado, el modo single crack se centra en comparar una única contraseña contra un hash.

La sintaxis para usar este modo es:

gzzcoo@htb[/nobody]$ john --incremental <hash_file>

Este comando lee los hashes del archivo especificado y empieza a probar todas las combinaciones posibles, comenzando por las de menor longitud. Cabe destacar que, por defecto, el conjunto de caracteres se limita a a-z, A-Z y 0-9, por lo que para contraseñas más complejas que incluyan caracteres especiales, será necesario configurar un conjunto personalizado.

Cracking Files

También se puede descifrar archivos protegidos o encriptados utilizando John. Para ello, se emplean herramientas auxiliares que procesan el archivo y extraen los hashes en un formato que John puede utilizar. Estas herramientas detectan automáticamente el formato del archivo y generan el hash correspondiente. Un ejemplo de cómo hacerlo es el siguiente:

cry0l1t3@htb:~$ <tool> <file_to_crack> > file.hash
cry0l1t3@htb:~$ pdf2john server_doc.pdf > server_doc.hash
cry0l1t3@htb:~$ john server_doc.hash
                # OR
cry0l1t3@htb:~$ john --wordlist=<wordlist.txt> server_doc.hash

Además, podemos utilizar diferentes modos para ello con nuestras listas de palabras y reglas personales. Hemos creado una lista que incluye muchas, pero no todas, las herramientas que se pueden utilizar para John. Modules

Format Hash

Hash Format

Example Command

Description

afs

john --format=afs hashes_to_crack.txt

AFS (Andrew File System) password hashes

bfegg

john --format=bfegg hashes_to_crack.txt

bfegg hashes used in Eggdrop IRC bots

john --format=bf hashes_to_crack.txt

Blowfish-based crypt(3) hashes

bsdi

john --format=bsdi hashes_to_crack.txt

BSDi crypt(3) hashes

crypt(3)

john --format=crypt hashes_to_crack.txt

Traditional Unix crypt(3) hashes

des

john --format=des hashes_to_crack.txt

Traditional DES-based crypt(3) hashes

dmd5

john --format=dmd5 hashes_to_crack.txt

DMD5 (Dragonfly BSD MD5) password hashes

dominosec

john --format=dominosec hashes_to_crack.txt

IBM Lotus Domino 6/7 password hashes

EPiServer SID hashes

john --format=episerver hashes_to_crack.txt

EPiServer SID (Security Identifier) password hashes

hdaa

john --format=hdaa hashes_to_crack.txt

hdaa password hashes used in Openwall GNU/Linux

hmac-md5

john --format=hmac-md5 hashes_to_crack.txt

hmac-md5 password hashes

hmailserver

john --format=hmailserver hashes_to_crack.txt

hmailserver password hashes

ipb2

john --format=ipb2 hashes_to_crack.txt

Invision Power Board 2 password hashes

krb4

john --format=krb4 hashes_to_crack.txt

Kerberos 4 password hashes

krb5

john --format=krb5 hashes_to_crack.txt

Kerberos 5 password hashes

john --format=LM hashes_to_crack.txt

LM (Lan Manager) password hashes

lotus5

john --format=lotus5 hashes_to_crack.txt

Lotus Notes/Domino 5 password hashes

mscash

john --format=mscash hashes_to_crack.txt

MS Cache password hashes

mscash2

john --format=mscash2 hashes_to_crack.txt

MS Cache v2 password hashes

mschapv2

john --format=mschapv2 hashes_to_crack.txt

MS CHAP v2 password hashes

mskrb5

john --format=mskrb5 hashes_to_crack.txt

MS Kerberos 5 password hashes

mssql05

john --format=mssql05 hashes_to_crack.txt

MS SQL 2005 password hashes

mssql

john --format=mssql hashes_to_crack.txt

MS SQL password hashes

mysql-fast

john --format=mysql-fast hashes_to_crack.txt

MySQL fast password hashes

mysql

john --format=mysql hashes_to_crack.txt

MySQL password hashes

mysql-sha1

john --format=mysql-sha1 hashes_to_crack.txt

MySQL SHA1 password hashes

NETLM

john --format=netlm hashes_to_crack.txt

NETLM (NT LAN Manager) password hashes

NETLMv2

john --format=netlmv2 hashes_to_crack.txt

NETLMv2 (NT LAN Manager version 2) password hashes

NETNTLM

john --format=netntlm hashes_to_crack.txt

NETNTLM (NT LAN Manager) password hashes

NETNTLMv2

john --format=netntlmv2 hashes_to_crack.txt

NETNTLMv2 (NT LAN Manager version 2) password hashes

NEThalfLM

john --format=nethalflm hashes_to_crack.txt

NEThalfLM (NT LAN Manager) password hashes

md5ns

john --format=md5ns hashes_to_crack.txt

md5ns (MD5 namespace) password hashes

nsldap

john --format=nsldap hashes_to_crack.txt

nsldap (OpenLDAP SHA) password hashes

ssha

john --format=ssha hashes_to_crack.txt

ssha (Salted SHA) password hashes

john --format=nt hashes_to_crack.txt

NT (Windows NT) password hashes

openssha

john --format=openssha hashes_to_crack.txt

OPENSSH private key password hashes

oracle11

john --format=oracle11 hashes_to_crack.txt

Oracle 11 password hashes

oracle

john --format=oracle hashes_to_crack.txt

Oracle password hashes

pdf

john --format=pdf hashes_to_crack.txt

PDF (Portable Document Format) password hashes

phpass-md5

john --format=phpass-md5 hashes_to_crack.txt

PHPass-MD5 (Portable PHP password hashing framework) password hashes

phps

john --format=phps hashes_to_crack.txt

PHPS password hashes

pix-md5

john --format=pix-md5 hashes_to_crack.txt

Cisco PIX MD5 password hashes

john --format=po hashes_to_crack.txt

Po (Sybase SQL Anywhere) password hashes

rar

john --format=rar hashes_to_crack.txt

RAR (WinRAR) password hashes

raw-md4

john --format=raw-md4 hashes_to_crack.txt

Raw MD4 password hashes

raw-md5

john --format=raw-md5 hashes_to_crack.txt

Raw MD5 password hashes

raw-md5-unicode

john --format=raw-md5-unicode hashes_to_crack.txt

Raw MD5 Unicode password hashes

raw-sha1

john --format=raw-sha1 hashes_to_crack.txt

Raw SHA1 password hashes

raw-sha224

john --format=raw-sha224 hashes_to_crack.txt

Raw SHA224 password hashes

raw-sha256

john --format=raw-sha256 hashes_to_crack.txt

Raw SHA256 password hashes

raw-sha384

john --format=raw-sha384 hashes_to_crack.txt

Raw SHA384 password hashes

raw-sha512

john --format=raw-sha512 hashes_to_crack.txt

Raw SHA512 password hashes

salted-sha

john --format=salted-sha hashes_to_crack.txt

Salted SHA password hashes

sapb

john --format=sapb hashes_to_crack.txt

SAP CODVN B (BCODE) password hashes

sapg

john --format=sapg hashes_to_crack.txt

SAP CODVN G (PASSCODE) password hashes

sha1-gen

john --format=sha1-gen hashes_to_crack.txt

Generic SHA1 password hashes

skey

john --format=skey hashes_to_crack.txt

S/Key (One-time password) hashes

ssh

john --format=ssh hashes_to_crack.txt

SSH (Secure Shell) password hashes

sybasease

john --format=sybasease hashes_to_crack.txt

Sybase ASE password hashes

xsha

john --format=xsha hashes_to_crack.txt

xsha (Extended SHA) password hashes

zip

john --format=zip hashes_to_crack.txt

ZIP (WinZip) password hashes

Modules

Tool

Description

pdf2john

Converts PDF documents for John

ssh2john

Converts SSH private keys for John

mscash2john

Converts MS Cash hashes for John

keychain2john

Converts OS X keychain files for John

rar2john

Converts RAR archives for John

pfx2john

Converts PKCS#12 files for John

truecrypt_volume2john

Converts TrueCrypt volumes for John

keepass2john

Converts KeePass databases for John

vncpcap2john

Converts VNC PCAP files for John

putty2john

Converts PuTTY private keys for John

zip2john

Converts ZIP archives for John

hccap2john

Converts WPA/WPA2 handshake captures for John

office2john

Converts MS Office documents for John

wpa2john

Converts WPA/WPA2 handshakes for John

❯ locate '*2john*'
/usr/bin/1password2john
/usr/bin/7z2john
/usr/bin/DPAPImk2john
/usr/bin/adxcsouf2john
/usr/bin/aem2john
/usr/bin/aix2john
/usr/bin/andotp2john
/usr/bin/androidbackup2john
/usr/bin/androidfde2john
/usr/bin/ansible2john
/usr/bin/apex2john
...[SNIP]...

AnteriorCross-Site Scripting (XSS)SiguienteNetExec

Última actualización hace 2 meses

¿Te fue útil?