Descobrindo senhas usando o John the Ripp

O John the Ripp é uma ferramenta muito usada para testar senhas, pois ele pode lançar ataques de força bruta, testando todas as combinações ou utilizando um arquivo de dicionário em praticamente todo tipo de arquivo de senhas.

Para começar, acesse o site do programa e procure pela última versão do ou uma de acordo com a sua distribuição (dê preferência sempre por versões mais novas pois incorporam mais recursos):
http://www.openwall.com/john/

Enquanto escrevo a versão mais recente é a: http://www.openwall.com/john/f/john-1.7.0.2.tar.gz

… que é considerada estável pelos desenvolvedores. Depois de baixar o pacote, descompacte-o usando o comando:

$ tar -vzxf john-1.7.0.2.tar.gz

Em seguia acesse a pasta que será criada:

$ cd john-1.7.0.2/src

A partir daqui você deve logar-se como root. Para verificar a lista dos sistemas suportados digite o comando abaixo:

# make

Ele mostrará uma lista similar a essa:

linux-x86-mmx Linux, x86 with MMX (best)
linux-x86-any Linux, x86
linux-x86-any-a.out Linux, x86, a.out binaries (obsolete)
linux-x86-64 Linux, AMD x86-64, 64-bit native
linux-x86-64-mmx Linux, AMD x86-64, 32-bit with MMX
linux-alpha Linux, Alpha
linux-sparc Linux, SPARC 32-bit
linux-ppc32-altivec Linux, PowerPC w/AltiVec (best)
linux-ppc32 Linux, PowerPC 32-bit
linux-ppc64 Linux, PowerPC 64-bit
freebsd-x86-mmx FreeBSD, x86 with MMX (best)
freebsd-x86-any FreeBSD, x86
freebsd-x86-any-a.out FreeBSD, x86, a.out binaries (obsolete)
freebsd-alpha FreeBSD, Alpha
openbsd-x86-mmx OpenBSD, x86 with MMX (best)
openbsd-x86-any OpenBSD, x86
openbsd-x86-any-a.out OpenBSD, x86, a.out binaries (obsolete)
openbsd-x86-64 OpenBSD, AMD x86-64
openbsd-alpha OpenBSD, Alpha
openbsd-sparc64 OpenBSD, SPARC 64-bit (best)
openbsd-sparc OpenBSD, SPARC 32-bit
openbsd-sparc-a.out OpenBSD, SPARC 32-bit (obsolete)
openbsd-ppc32 OpenBSD, PowerPC 32-bit
openbsd-ppc64 OpenBSD, PowerPC 64-bit
openbsd-pa-risc OpenBSD, PA-RISC
openbsd-vax OpenBSD, VAX
netbsd-vax NetBSD, VAX
solaris-sparc64-cc Solaris, SPARC V9 64-bit, cc (best)
solaris-sparc64-gcc Solaris, SPARC V9 64-bit, gcc
solaris-sparcv9-cc Solaris, SPARC V9 32-bit, cc
solaris-sparcv8-cc Solaris, SPARC V8 32-bit, cc
solaris-sparc-gcc Solaris, SPARC 32-bit, gcc
solaris-x86-any Solaris, x86, gcc
sco-x86-any-gcc SCO, x86, gcc
sco-x86-any-cc SCO, x86, cc
tru64-alpha Tru64 (Digital UNIX, OSF/1), Alpha
aix-ppc32 AIX, PowerPC 32-bit
macosx-ppc32-altivec Mac OS X, PowerPC w/AltiVec (best)
macosx-ppc32 Mac OS X, PowerPC 32-bit
macosx-ppc64 Mac OS X 10.4+, PowerPC 64-bit
macosx-x86-mmx Mac OS X, x86 with MMX
hpux-pa-risc-gcc HP-UX, PA-RISC, gcc
hpux-pa-risc-cc HP-UX, PA-RISC, ANSI cc
irix-mips64-r10k IRIX, MIPS 64-bit (R10K) (best)
irix-mips64 IRIX, MIPS 64-bit
irix-mips32 IRIX, MIPS 32-bit
dos-djgpp-x86-mmx DOS, DJGPP 2.x, x86 with MMX (best)
dos-djgpp-x86-any DOS, DJGPP 2.x, x86
win32-cygwin-x86-mmx Win32, Cygwin, x86 with MMX (best)
win32-cygwin-x86-any Win32, Cygwin, x86
beos-x86-mmx BeOS, x86 with MMX
beos-x86-any BeOS, x86
generic Any other Unix-like system with gcc

Como possuo um processador Celeron compilei o programa para linux-x86-any que deve server para todos sistemas com processadores Intel ou AMD de 32 bits.

Para compilar o programa use:

# make clean [System]

Seguindo o raciocínio anterior compilei o meu assim:

# make clean linux-x86-any

Aperte enter e aguarde a compilação ela costuma não demorar mas isso varia conforme seu sistema. Ao terminar ele libera o console para digitação.
Se tudo deu certo até aqui podemos testar o programa, para isso precisamos trocar de pasta:

# cd..
# cd /run

Agora vamos testar o programa usando o comando:

# ./john –test

Ele deve retornar o seguinte:

Benchmarking: Traditional DES [24/32 4K]… DONE
Many salts: 117882 c/s real, 130661 c/s virtual
Only one salt: 110728 c/s real, 121389 c/s virtual
Benchmarking: BSDI DES (x725) [24/32 4K]… DONE
Many salts: 3738 c/s real, 4325 c/s virtual
Only one salt: 1538 c/s real, 3663 c/s virtual
Benchmarking: FreeBSD MD5 [32/32]… DONE
Raw: 1454 c/s real, 2881 c/s virtual
Benchmarking: OpenBSD Blowfish (x32) [32/32]… DONE
Raw: 157 c/s real, 200 c/s virtual
Benchmarking: Kerberos AFS DES [24/32 4K]… DONE
Short: 106283 c/s real, 120743 c/s virtual
Long: 195806 c/s real, 316449 c/s virtual
Benchmarking: NT LM DES [32/32 BS]… DONE
Raw: 1501K c/s real, 1817K c/s virtual

Agora que sabemos que tudo está ok você dispensar o ./john para usar somente o comando john. Para isso pode criar um link para o executável em seu pacth conforme abaixo:

# ln -s ../john-1.7.0.2/run/john /usr/bin/john

(Verifique o path antes de executar esse comando)

Para usar o John, o primeiro passo é verificar a lista de palavras pré-definidas que o programa usa, quanto maior a lista mais chances o programa tem de achar a senha rapidamente.

# vi password.lst

Altere a lista usando o vi ou o seu editor de texto preferido, salve-a depois de concluir.

Agora vamos copiar o arquivo passwd e o arquivo shadow afinal não queremos parar o sistema caso algo dê erado 😀

# cp /etc/shadow /etc/passwd ../john-1.7.0.2/run

Depois de copiados os dois vamos juntá-los para o john verificar para isso usamos o script unshadow que acompanha o john:

# ./unshadow passwd shadow >> passlist.1

Então podemos rodar o john para descobrirmos as senhas no sistema:

#./john passlist.1

Esse comando faz rodar o John no modo Single Crack. Executado nesse modo de operação, ele passará para o modo Wordlist e por último para o modo Incremetal. Para informações mais detalhadas sobre os modos de John, consulte o MODES, na pasta doc dentro da pasta do John the Ripper.
Ao terminar de verificar o arquivo ele deve retornar algo como:

Loaded 2 password hashes with 2 different salts (Traditional DES [24/32 4K])
passarinho (root)
colorado (kurumin)
guesses: 2 time: 0:00:00:00 100% (2) c/s: 14200 trying: angie – einstein

Pronto. Agora que sabemos que algumas contas do sistema foram cadastradas com senhas fáceis, podemos implementar melhorias para que o sistema não fique vulnerável. Vale a recomendação de que as senhas do sistema devem possuir pelo menos 8 caracteres e serem compostas por uma mistura de letras, números, caracteres maiúsculos e caracteres especiais. Senhas complexas são quase impossíveis de se descobrir usando esse método.

Por Fabricio Machado (Fabricio_Machado em DellTeam ponto com)

Sobre o Autor

Redes Sociais:

Deixe seu comentário

X