Quebrar Hashes no Hashcat

Introdução

Neste laboratório, você aprenderá como usar o Hashcat, a ferramenta de recuperação de senhas mais rápida do mundo, para quebrar (crack) hashes criptográficos. Você praticará a instalação do Hashcat, a preparação de arquivos de hash, a configuração da aceleração por GPU e a execução de ataques de força bruta contra exemplos de hashes MD5.

Os exercícios práticos irão guiá-lo através da quebra de exemplos de senhas do mundo real, otimizando o desempenho. Você obterá experiência prática com técnicas essenciais de segurança cibernética para recuperação de senhas e testes de segurança.

Instalar Hashcat

Nesta etapa, você instalará o Hashcat, a ferramenta de recuperação de senhas mais rápida do mundo. O Hashcat é um utilitário poderoso usado para quebrar (crack) hashes através de vários métodos de ataque, como força bruta, dicionário e ataques baseados em regras.

Antes de começarmos, vamos entender o que são hashes. Um hash é uma string de comprimento fixo gerada por uma função matemática que recebe uma entrada (como uma senha) e produz uma saída embaralhada. Os sistemas de senhas armazenam esses hashes em vez de senhas em texto simples para segurança. O Hashcat ajuda a recuperar a senha original, tentando diferentes combinações para corresponder ao hash armazenado.

Primeiro, precisamos garantir que estamos no diretório de trabalho correto. O diretório ~/project é onde realizaremos todas as nossas operações de laboratório:

cd ~/project

Agora, instalaremos o Hashcat usando o gerenciador de pacotes do Ubuntu. O gerenciador de pacotes lida com o download e a configuração do software, juntamente com suas dependências. Executamos dois comandos juntos: primeiro, atualizando a lista de pacotes (update), depois instalando o Hashcat (install):

sudo apt-get update && sudo apt-get install -y hashcat

A flag -y confirma automaticamente a instalação, poupando-nos de ter que digitar 'sim' durante o processo.

Após a conclusão da instalação, vamos verificar se o Hashcat está corretamente instalado, verificando sua versão. Esta é uma boa prática para confirmar que o software está pronto para uso:

hashcat --version

Você deve ver a saída mostrando o número da versão instalada, por exemplo:

v6.2.6

Ver este número de versão significa que o Hashcat está corretamente instalado em seu sistema. Nas próximas etapas, usaremos o Hashcat para trabalhar com arquivos de hash reais e realizar operações de quebra. O número da versão também é útil ao procurar documentação ou solucionar problemas, pois os recursos podem variar entre as versões.

Preparar um Arquivo de Hash

Nesta etapa, você criará um arquivo de hash de exemplo que será usado para quebrar (crack) nas etapas subsequentes. Um hash é uma string de comprimento fixo gerada por um algoritmo criptográfico que representa dados de entrada. Arquivos de hash contêm esses hashes criptográficos que tentaremos quebrar usando o Hashcat.

Primeiro, certifique-se de estar no diretório de trabalho correto. O comando cd altera seu diretório atual:

cd ~/project

Vamos criar um arquivo de texto simples contendo hashes MD5. MD5 é uma função hash criptográfica amplamente utilizada que produz um valor de hash de 128 bits. Usaremos o editor de texto nano para criar e editar um novo arquivo:

nano hashes.txt

Adicione os seguintes hashes MD5 de exemplo ao arquivo. Estes são hashes de teste comuns com valores de texto simples conhecidos (pressione Ctrl+O para salvar e Ctrl+X para sair do nano):

5f4dcc3b5aa765d61d8327deb882cf99  ## password: "password"
098f6bcd4621d373cade4e832627b4f6  ## password: "test"

Alternativamente, você pode criar o arquivo diretamente usando comandos echo. O operador > cria um novo arquivo, enquanto >> anexa a um arquivo existente:

echo "5f4dcc3b5aa765d61d8327deb882cf99" > hashes.txt
echo "098f6bcd4621d373cade4e832627b4f6" >> hashes.txt

Verifique o conteúdo do seu arquivo de hash usando o comando cat, que exibe o conteúdo do arquivo no terminal:

cat hashes.txt

Você deve ver os dois hashes MD5 exibidos no seu terminal. Este arquivo servirá como nosso alvo para quebra de hash nas próximas etapas, quando configurarmos o Hashcat e executarmos ataques de força bruta. Ter hashes de teste conhecidos ajuda a verificar se nossa configuração de quebra está funcionando corretamente.

Configurar Suporte a GPU

Nesta etapa, você configurará o Hashcat para utilizar a aceleração da GPU para uma quebra de hash mais rápida. O Hashcat pode aproveitar os recursos da CPU e da GPU, mas as GPUs são particularmente eficazes para quebra de senhas porque contêm milhares de pequenos núcleos que podem realizar muitos cálculos simultaneamente. Essa capacidade de processamento paralelo torna as GPUs muito mais rápidas do que as CPUs para ataques de força bruta.

Antes de configurar o suporte a GPU, vamos primeiro verificar quais dispositivos de hardware estão disponíveis para o Hashcat. Execute este comando para listar todos os dispositivos OpenCL detectados:

hashcat -I

Este comando exibirá os dispositivos OpenCL disponíveis. No ambiente da VM do LabEx, você deve ver uma saída semelhante a:

OpenCL Platform #1: NVIDIA Corporation
* Device #1: NVIDIA GeForce GTX 1080 Ti, 10240/11264 MB allocatable, 28MCU

A saída mostra os detalhes da sua GPU, incluindo seu modelo e capacidade de memória. Agora, criaremos um arquivo de configuração para otimizar o desempenho do Hashcat. Arquivos de configuração ajudam a automatizar as configurações para que você não precise digitá-las toda vez.

Crie e edite o arquivo de configuração com:

nano ~/.hashcat/hashcat.conf

Adicione a seguinte configuração (pressione Ctrl+O para salvar e Ctrl+X para sair):

--force
--opencl-device-types=1,2
--workload-profile=4

Vamos entender o que cada parâmetro faz:

• --force diz ao Hashcat para continuar mesmo que detecte possíveis problemas (útil em ambientes de laboratório)
• --opencl-device-types=1,2 habilita dispositivos CPU (tipo 1) e GPU (tipo 2) para processamento
• --workload-profile=4 define o perfil de desempenho mais alto, priorizando a velocidade em detrimento da economia de energia

Para confirmar se tudo está funcionando corretamente, execute um teste de benchmark:

hashcat -b

O benchmark testará vários algoritmos de hash e exibirá métricas de desempenho como:

Speed.#1.........: 12345.7 MH/s (98.23ms) @ Accel:1024 Loops:1024 Thr:256 Vec:1

Esses números mostram quantos hashes seu sistema pode tentar por segundo. Valores mais altos significam uma quebra mais rápida. O benchmark confirma que a aceleração da GPU está ativa e pronta para uso na próxima etapa, onde realizaremos o ataque de força bruta real.

Executar um Ataque Brute-Force

Nesta etapa, você executará um ataque de força bruta usando o Hashcat para quebrar os hashes MD5 que preparamos anteriormente. Um ataque de força bruta é um método de tentativa e erro que verifica sistematicamente todas as combinações de caracteres possíveis até encontrar a senha correta. Essa abordagem é particularmente útil quando você não tem informações sobre a estrutura da senha.

Primeiro, vamos navegar para o nosso diretório de trabalho onde armazenamos o arquivo de hash. Isso garante que o Hashcat possa acessar o arquivo que queremos quebrar:

cd ~/project

Agora, usaremos o Hashcat com parâmetros específicos projetados para nosso ataque:

• -m 0 informa ao Hashcat que estamos trabalhando com hashes MD5 (cada tipo de hash tem um número específico no Hashcat)
• -a 3 define o modo de ataque para força bruta
• ?a?a?a?a define nossa máscara de senha - isso significa que estamos procurando senhas de exatamente 4 caracteres que podem incluir:
  • Letras minúsculas (a-z)
  • Letras maiúsculas (A-Z)
  • Números (0-9)
  • Caracteres especiais (!@#$% etc.)

Execute o ataque de força bruta com este comando:

hashcat -m 0 -a 3 hashes.txt ?a?a?a?a --force

Conforme o Hashcat é executado, ele exibirá estatísticas em tempo real no seu terminal. Essa saída ajuda você a monitorar o progresso da quebra:

Session..........: hashcat
Status...........: Running
Hash.Name........: MD5
Hash.Target......: hashes.txt
Time.Started.....: [timestamp]
Speed.#1.........: [speed] H/s
Recovered........: 0/2 (0.00%)
Progress.........: [progress]
Rejected.........: 0
Restore.Point....: 0

A velocidade de quebra (H/s) mostra quantos cálculos de hash seu sistema está realizando por segundo. O indicador de progresso ajuda a estimar o tempo restante. Para uma senha de 4 caracteres, isso pode levar vários minutos, dependendo do seu hardware.

Quando o ataque for concluído, podemos verificar os resultados. O seguinte comando exibe quaisquer senhas quebradas com sucesso:

hashcat -m 0 hashes.txt --show

A saída bem-sucedida irá emparelhar cada hash com sua senha de texto simples descoberta:

5f4dcc3b5aa765d61d8327deb882cf99:password
098f6bcd4621d373cade4e832627b4f6:test

Essa saída confirma que o Hashcat reverteu com sucesso ambos os hashes MD5 em nosso arquivo de teste de volta para suas senhas originais. A primeira coluna mostra o hash com o qual começamos, enquanto a segunda coluna revela a senha real que criou esse hash.

Verificar Hashes Crackeados

Nesta etapa final, você verificará e analisará os resultados do seu ataque de força bruta. O Hashcat armazena automaticamente as senhas quebradas com sucesso em um arquivo especial chamado "potfile". Este arquivo atua como um banco de dados de todas as senhas que você recuperou durante suas sessões de quebra. Examinaremos isso para confirmar quais senhas foram quebradas com sucesso.

Primeiro, vamos navegar para o nosso diretório de trabalho onde armazenamos nosso arquivo de hash. Isso garante que estamos trabalhando com os arquivos corretos:

cd ~/project

Para visualizar todos os hashes quebrados do seu ataque, usamos a flag --show com o Hashcat. Este comando procura especificamente por hashes MD5 (modo 0) em nosso arquivo hashes.txt e exibe quaisquer correspondências encontradas no potfile:

hashcat -m 0 hashes.txt --show

Você deve ver uma saída semelhante a esta, mostrando o hash original seguido por sua senha de texto simples quebrada:

5f4dcc3b5aa765d61d8327deb882cf99:password
098f6bcd4621d373cade4e832627b4f6:test

Para uma compreensão mais abrangente da sua sessão de quebra, a flag --status fornece estatísticas valiosas. Isso mostra quantos hashes foram quebrados, o tipo de hash e as métricas de desempenho:

hashcat -m 0 hashes.txt --status

Isso exibirá informações importantes, incluindo:

Session.Name.....: hashcat
Status..........: Exhausted
Hash.Name.......: MD5
Hash.Target.....: hashes.txt
Time.Started....: [timestamp]
Time.Estimated..: [timestamp]
Recovered.......: 2/2 (100.00%)
Progress.......: [progress]
Speed.#1.......: [speed] H/s

Para gerar um relatório completo da sua sessão de quebra que você pode salvar e revisar mais tarde, use os seguintes comandos. O primeiro cria um arquivo de relatório formatado e o segundo exibe seu conteúdo:

hashcat -m 0 hashes.txt --outfile-format=2 --outfile=results.txt
cat results.txt

O relatório conterá informações detalhadas sobre cada hash quebrado, incluindo o tipo de hash, a senha de texto simples e o tempo exato que levou para quebrar cada um. Essa documentação é particularmente útil quando você precisa analisar o desempenho da sua quebra ou compartilhar resultados com outras pessoas.

Resumo

Neste laboratório, você aprendeu como instalar e configurar o Hashcat, uma poderosa ferramenta de recuperação de senhas, atualizando o gerenciador de pacotes e verificando sua versão. Você também preparou um arquivo de hash contendo exemplos de hashes MD5 e confirmou seu conteúdo usando comandos básicos do Linux.

Além disso, você explorou o suporte a GPU do Hashcat para otimização de desempenho e conduziu um ataque de força bruta para quebrar os hashes de exemplo. Este exercício prático demonstrou o papel essencial do Hashcat em segurança cibernética para cenários de recuperação de senhas e avaliação de vulnerabilidades.