Realizar um Ataque Combinatório no Hashcat

Introdução

Neste laboratório, você explorará uma técnica específica de quebra de senhas conhecida como ataque combinatório usando o Hashcat, uma ferramenta poderosa e versátil de recuperação de senhas. Um ataque combinatório é um método onde duas listas de palavras separadas são combinadas para gerar candidatos a senhas. Por exemplo, se uma lista contém "password" e a outra contém "123", o ataque testará a combinação "password123".

Essa abordagem é particularmente eficaz contra senhas que são formadas pela concatenação de duas palavras, ou uma palavra e uma sequência de números ou símbolos. Ao longo deste laboratório, você aprenderá a preparar listas de palavras, construir o comando Hashcat apropriado, executar o ataque contra um hash de amostra e verificar os resultados.

Compreender o Conceito do Ataque Combinatório

Nesta etapa, você aprenderá sobre o conceito central do ataque combinatório no Hashcat. Este ataque é designado pelo modo de ataque -a 1. Ele funciona pegando uma palavra base da primeira lista de palavras e anexando uma palavra da segunda lista de palavras a ela, criando uma nova senha candidata. Este processo é repetido para cada palavra em ambas as listas.

Por exemplo, se você tiver duas listas:

• wordlist1.txt: admin, user
• wordlist2.txt: 123, !

O ataque combinatório geraria os seguintes candidatos: admin123, admin!, user123, user!.

Este método expande significativamente o espaço potencial de senhas sem a necessidade de um único e massivo arquivo de dicionário. Vamos começar confirmando o modo de ataque no menu de ajuda do Hashcat.

Execute o seguinte comando para filtrar a saída de ajuda em busca de informações sobre o ataque combinatório:

hashcat --help | grep "Combinator"

Você deverá ver uma linha na saída que menciona explicitamente o modo de ataque Combinatório e seu número correspondente.

-a, --attack-mode         |      ## | Attack-mode
...
                          |      1 | Combinator
...

Isso confirma que -a 1 é o sinalizador correto a ser usado para um ataque combinatório.

Criar Duas Listas de Palavras Separadas para o Ataque

Nesta etapa, você criará as duas listas de palavras que serão usadas em nosso ataque combinatório. Para este laboratório, criaremos duas listas personalizadas e pequenas. Em um cenário do mundo real, essas listas seriam muito maiores e conteriam palavras, nomes e padrões mais comuns.

Nossa senha alvo é uma combinação de uma palavra comum e uma sequência numérica. Colocaremos a parte da palavra em wordlist1.txt e a parte numérica em wordlist2.txt.

Primeiro, crie wordlist1.txt com algumas palavras base potenciais. Use o comando echo com o sinalizador -e para lidar com novas linhas (\n):

echo -e "admin\nuser\npassword\nguest" > wordlist1.txt

Em seguida, crie wordlist2.txt com alguns sufixos numéricos comuns:

echo -e "2024\n!@#\n123\nxyz" > wordlist2.txt

Agora, verifique o conteúdo de ambos os arquivos usando o comando cat para garantir que foram criados corretamente.

Verifique a primeira lista de palavras:

cat wordlist1.txt

Saída esperada:

admin
user
password
guest

Verifique a segunda lista de palavras:

cat wordlist2.txt

Saída esperada:

2024
!@#
123
xyz

Com essas duas listas de palavras, o Hashcat agora poderá formar a senha candidata password123.

Construir o Comando de Ataque Combinatório com Duas Listas de Palavras

Nesta etapa, você construirá o comando completo do Hashcat para o ataque combinatório. É importante entender o que cada parte do comando faz antes de executá-lo.

A sintaxe geral para um ataque combinatório é: hashcat [opções] <arquivo-hash> <lista-palavras1> <lista-palavras2>

Aqui está a descrição do comando que usaremos:

• hashcat: O programa executável.
• -m 0: Isso especifica o tipo de hash. O modo 0 corresponde a MD5.
• -a 1: Isso define o modo de ataque como 1, que é o ataque Combinatório.
• hash.txt: Este é o arquivo que contém o hash que queremos quebrar. Ele foi criado para você durante a configuração do laboratório.
• wordlist1.txt: A primeira lista de palavras, contendo a parte esquerda dos candidatos a senha.
• wordlist2.txt: A segunda lista de palavras, contendo a parte direita dos candidatos a senha.

Antes de executar o ataque completo, é uma boa prática usar o sinalizador --show. Este sinalizador instrui o Hashcat a exibir quaisquer hashes que já foram quebrados e armazenados no potfile, sem iniciar uma nova sessão de quebra.

Vamos executar o comando com --show para ver que nosso hash alvo ainda não foi quebrado:

hashcat -m 0 -a 1 hash.txt wordlist1.txt wordlist2.txt --show

Como esta é a primeira vez que o executamos, o comando não produzirá nenhuma saída, o que é o resultado esperado. Isso confirma que estamos prontos para prosseguir com o ataque real.

Executar o Ataque e Observar as Combinações

Agora é hora de executar o ataque combinatório sem o sinalizador --show. Isso iniciará o processo de quebra. O Hashcat lerá as duas listas de palavras, as combinará, fará o hash dos resultados e os comparará com o hash alvo em hash.txt.

Execute o seguinte comando em seu terminal:

hashcat -m 0 -a 1 hash.txt wordlist1.txt wordlist2.txt

O Hashcat inicializará e exibirá uma tela de status. Como nossas listas de palavras são muito pequenas, o processo terminará quase instantaneamente. A saída mostrará que o hash foi quebrado.

Você verá uma saída semelhante à seguinte (alguns detalhes como velocidade e tempo podem variar):

hashcat (v6.2.6) starting

...

Session..........: hashcat
Status...........: Cracked
Hash.Name........: MD5
Hash.Target......: e10adc3949ba59abbe56e057f20f883e
Time.Started.....: ...
Time.Estimated...: 0 secs (0.00ms)
Guess.Base.......: File (wordlist1.txt), File (wordlist2.txt)
Guess.Queue......: 2/2 (100.00%)
Speed.#*.........: ... H/s (...)
Recovered........: 1/1 (100.00%) Digests
Progress.........: 16/16 (100.00%)
Rejected.........: 0/16 (0.00%)
Restore.Point....: 4/4 (100.00%)
Restore.Sub.#*...: 4/4 (100.00%)
Candidates.#*....: 16

Cracked Hashes: 1/1
e10adc3949ba59abbe56e057f20f883e:password123

...
All hashes have been recovered

Started: ...
Stopped: ...

A linha e10adc3949ba59abbe56e057f20f883e:password123 mostra claramente o hash original e sua senha em texto plano quebrada. Isso confirma que nosso ataque foi bem-sucedido.

Revisar o Potfile para Resultados de Senha Combinados

Nesta etapa, você revisará o potfile do Hashcat. O potfile (hashcat.potfile) é um arquivo de texto simples onde o Hashcat armazena automaticamente os hashes quebrados com sucesso e suas senhas correspondentes. Este é um recurso útil que evita que você perca tempo quebrando novamente hashes que já foram resolvidos.

Por padrão, o potfile está localizado no diretório ~/.local/share/hashcat/.

Use o comando cat para visualizar o conteúdo do potfile e confirmar que nosso resultado foi salvo:

cat ~/.local/share/hashcat/hashcat.potfile

A saída mostrará o hash e sua senha quebrada, separados por dois pontos:

e10adc3949ba59abbe56e057f20f883e:password123

Isso confirma que o ataque foi bem-sucedido e o resultado agora está armazenado permanentemente no potfile. Se você executasse o mesmo ataque novamente, o Hashcat usaria o sinalizador --show para recuperar instantaneamente o resultado deste arquivo em vez de executar novamente todo o processo de quebra.

Resumo

Neste laboratório, você realizou com sucesso um ataque combinatório usando o Hashcat.

Você aprendeu a:

• Compreender o conceito de um ataque combinatório (-a 1) no Hashcat.
• Criar duas listas de palavras separadas para servir como base para candidatos a senha.
• Construir o comando correto do Hashcat, especificando o modo de ataque, o tipo de hash e os arquivos de entrada.
• Executar o ataque e quebrar com sucesso um hash MD5 combinando uma palavra e uma sequência numérica.
• Localizar e revisar o hashcat.potfile para ver os resultados armazenados de uma quebra bem-sucedida.

O ataque combinatório é uma técnica fundamental na quebra de senhas, especialmente útil ao lidar com senhas que seguem padrões de concatenação previsíveis.