Configurar Servidor SSH para Testes com Hydra

Introdução

Neste laboratório, você aprenderá como configurar um ambiente de teste para o Hydra, instalando e configurando um servidor OpenSSH em sua VM LabEx. Este ambiente controlado permitirá que você pratique com segurança técnicas de quebra de senhas em exercícios posteriores.

Você configurará o servidor SSH para habilitar a autenticação por senha e o login como root, essencial para os testes com Hydra. O processo inclui a modificação de arquivos de configuração, a reinicialização de serviços e a verificação da configuração para testes de segurança subsequentes.

Instalar um Servidor SSH Local

Nesta etapa, você instalará um servidor OpenSSH em sua VM LabEx. Vamos primeiro entender o que é SSH - a sigla significa Secure Shell (Shell Seguro), que é um protocolo de rede que cria um canal seguro entre dois computadores através de uma rede insegura. Isso é particularmente importante quando você precisa acessar um sistema remotamente, mantendo sua comunicação criptografada.

O servidor OpenSSH que estamos instalando é a implementação mais comum do protocolo SSH em sistemas Linux. Ao configurar isso, estamos criando um ambiente controlado onde podemos testar com segurança ferramentas de quebra de senhas como o Hydra mais tarde no laboratório. Isso é semelhante a como os profissionais de segurança testam sistemas em busca de vulnerabilidades em um ambiente seguro e isolado.

Primeiro, precisamos atualizar sua lista de pacotes. Isso garante que seu sistema saiba sobre as versões mais recentes dos pacotes de software disponíveis:
```
sudo apt update
```
O comando sudo concede a você privilégios de administrador, enquanto apt update atualiza a lista de pacotes disponíveis em seu sistema.
Agora, instale o pacote do servidor OpenSSH. Isso fará o download e configurará todos os componentes necessários para executar um servidor SSH:
```
sudo apt install -y openssh-server
```
A flag -y responde automaticamente "sim" a quaisquer prompts durante a instalação, tornando o processo mais suave.
Como estamos trabalhando em um contêiner Docker (um ambiente leve e isolado), precisamos iniciar manualmente o serviço SSH. Normalmente, ele iniciaria automaticamente, mas lidaremos com essa configuração mais tarde:
```
sudo service ssh start
```
Vamos verificar se o servidor SSH está funcionando corretamente. Este comando verifica o status atual do serviço SSH:
```
sudo service ssh status
```
Você deve ver uma saída contendo "active (running)" (ativo (executando)), o que confirma que o serviço está funcionando corretamente.
Finalmente, verificaremos se o servidor SSH está ouvindo na porta padrão (22). Portas são como portas que os serviços usam para se comunicar, e o SSH tradicionalmente usa a porta 22:
```
ss -tulnp | grep sshd
```
O comando ss mostra estatísticas de socket, e estamos filtrando por entradas relacionadas ao SSH. Você deve ver a saída mostrando sshd ouvindo em *:22 ou 0.0.0.0:22, o que significa que ele está pronto para aceitar conexões em todas as interfaces de rede.

Configurar o Servidor SSH para Testes

Nesta etapa, você configurará o servidor SSH para habilitar a autenticação por senha, o que é necessário para testes com Hydra em etapas posteriores. SSH (Secure Shell) é um protocolo que permite acesso remoto seguro a sistemas. Por padrão, as configurações modernas do SSH priorizam a segurança, desabilitando a autenticação por senha em favor da autenticação baseada em chave. No entanto, como o Hydra é uma ferramenta de quebra de senhas, precisamos habilitar temporariamente a autenticação por senha para fins de teste.

Primeiro, faça um backup do arquivo de configuração original do SSH. Esta é uma boa prática antes de fazer quaisquer alterações no sistema, permitindo que você restaure as configurações originais, se necessário:
```
sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak
```
Abra o arquivo de configuração do servidor SSH para edição. Estamos usando o nano, um editor de texto simples adequado para iniciantes. O arquivo contém todas as configurações que controlam como seu servidor SSH opera:
```
sudo nano /etc/ssh/sshd_config
```
Encontre e modifique as seguintes linhas (ou adicione-as se não existirem). Essas configurações habilitam a autenticação por senha e permitem o login como root, o que precisamos para nosso ambiente de teste:
```
PasswordAuthentication yes
PermitRootLogin yes
```
Salve o arquivo (Ctrl+O, Enter) e saia do nano (Ctrl+X). Lembre-se de que as alterações não terão efeito até que reiniciemos o serviço SSH.
Reinicie o serviço SSH para aplicar as alterações. Isso diz ao sistema para recarregar o arquivo de configuração com nossas novas configurações:
```
sudo service ssh restart
```
Verifique se a nova configuração está ativa. Este comando verifica a configuração atual do SSH e filtra nossas configurações específicas para confirmar se elas estão devidamente habilitadas:
```
sudo sshd -T | grep -E "passwordauthentication|permitrootlogin"
```
Você deve ver a saída confirmando que ambas as configurações estão habilitadas. Caso contrário, verifique novamente se você salvou o arquivo corretamente e reiniciou o serviço.

Criar Contas de Usuário de Teste

Nesta etapa, você criará contas de usuário de teste com senhas intencionalmente fracas. Essas contas servirão como alvos quando usarmos o Hydra posteriormente para demonstrar ataques de força bruta (brute-force) SSH. Criar essas contas de teste nos ajuda a simular com segurança cenários do mundo real onde os invasores podem explorar credenciais fracas.

Vamos criar três usuários de teste com senhas fracas comuns. Essas senhas são deliberadamente simples porque queremos que o Hydra seja capaz de quebrá-las durante nossos testes. Em sistemas reais, você sempre deve usar senhas fortes e complexas.

Crie três usuários de teste com senhas simples (usaremos isso para testes):

sudo useradd -m -s /bin/bash testuser1
echo "testuser1:password123" | sudo chpasswd

sudo useradd -m -s /bin/bash testuser2
echo "testuser2:qwerty" | sudo chpasswd

sudo useradd -m -s /bin/bash testuser3
echo "testuser3:letmein" | sudo chpasswd

O comando useradd cria cada usuário com um diretório home (-m) e define seu shell para bash (-s /bin/bash). O comando chpasswd define a senha para cada usuário.

Verifique se os usuários foram criados com sucesso:
```
id testuser1
id testuser2
id testuser3
```
O comando id mostra informações do usuário. Você deve ver a saída confirmando que cada usuário existe, incluindo seu ID de usuário (UID), ID de grupo (GID) e associação ao grupo. Esta etapa de verificação garante que nossas contas de teste sejam configuradas corretamente antes de prosseguirmos.
Verifique se as senhas foram definidas corretamente, tentando alternar para cada usuário (você precisará inserir as senhas que acabou de definir):
```
su - testuser1
exit
su - testuser2
exit
su - testuser3
exit
```
O comando su - username permite que você alterne para outra conta de usuário. Depois de inserir cada senha, você deve ver brevemente o prompt de comando mudar para indicar que você está logado como aquele usuário. O comando exit retorna você à sua sessão original. Esta etapa confirma que as senhas funcionam conforme o esperado.
(Opcional) Crie um arquivo de texto contendo as credenciais de teste para referência:
```
echo -e "testuser1:password123\ntestuser2:qwerty\ntestuser3:letmein" > ~/project/test_credentials.txt
```
Isso cria um arquivo de texto listando todas as credenciais de teste no formato username:password. Embora não seja estritamente necessário, ter este arquivo de referência pode ser útil durante os testes. A flag -e permite a interpretação de escapes de barra invertida como \n para novas linhas.

Iniciar o Serviço SSH

Nesta etapa, você garantirá que o serviço SSH esteja funcionando corretamente e configurado para iniciar automaticamente. SSH (Secure Shell) é um protocolo de rede que permite acesso remoto seguro entre computadores. Em nosso ambiente de teste Hydra, precisamos que o SSH esteja em execução continuamente para que possamos realizar testes de quebra de senhas de forma confiável.

Primeiro, vamos verificar se o serviço SSH está atualmente ativo. Este comando mostra o status atual do daemon SSH (sshd):
```
sudo service ssh status
```
Se não estiver em execução, você verá "inativo (morto)" na saída. Isso significa que o serviço SSH está atualmente parado e não está aceitando nenhuma conexão.
Se o serviço não estiver em execução, precisamos iniciá-lo. Este comando inicializa o daemon SSH:
```
sudo service ssh start
```
Após iniciar o serviço, vamos verificar se ele está funcionando corretamente. O comando de status agora deve mostrar uma saída diferente:
```
sudo service ssh status
```
Você deve ver "ativo (em execução)" na saída, indicando que o serviço SSH está pronto para aceitar conexões.
Como estamos trabalhando em um contêiner Docker (um ambiente leve e isolado), precisamos garantir que o SSH inicie automaticamente quando o contêiner for reiniciado. Esta linha adiciona um comando de inicialização ao seu arquivo de configuração bash:
```
echo 'sudo service ssh start' >> ~/.bashrc
```
O arquivo .bashrc é executado automaticamente quando você inicia uma nova sessão de terminal, portanto, isso garante que o SSH sempre iniciará quando o contêiner inicializar.
Finalmente, vamos confirmar se o SSH está ouvindo na porta de rede correta (a porta 22 é a padrão para SSH). Este comando mostra todas as conexões de rede ativas:
```
sudo netstat -tulnp | grep sshd
```
Você deve ver a saída mostrando sshd ouvindo em 0.0.0.0:22, o que significa que o servidor SSH está configurado corretamente para aceitar conexões de qualquer interface de rede na porta SSH padrão.

Verificar Acessibilidade do Servidor SSH

Nesta etapa final, verificaremos se o seu servidor SSH está configurado corretamente e acessível. Isso é crucial porque o Hydra (a ferramenta de quebra de senhas que usaremos em laboratórios posteriores) requer um serviço SSH funcional para testar. Realizaremos várias verificações para garantir que tudo funcione conforme o esperado.

Primeiro, vamos verificar se o serviço SSH está realmente em execução. Os serviços às vezes podem falhar ao iniciar ou travar inesperadamente, então esta é nossa primeira verificação de sanidade:
```
sudo service ssh status
```
A saída deve mostrar claramente "ativo (em execução)". Se não mostrar, precisaremos solucionar problemas do serviço antes de prosseguir.
Agora, testaremos o acesso SSH local usando uma das contas de teste que criamos anteriormente. Isso simula como o Hydra tentará se conectar:
```
ssh testuser1@localhost
```
Quando solicitado, insira a senha "password123" (aquela que configuramos anteriormente). Após fazer login com sucesso, digite exit para retornar à sua sessão principal. Isso confirma que a autenticação básica por senha funciona.
Vamos testar especificamente a autenticação por senha (já que o Hydra principalmente força senhas por força bruta). Forçaremos o SSH a usar a autenticação por senha e forneceremos intencionalmente uma senha errada:
```
ssh -o PreferredAuthentications=password -o PubkeyAuthentication=no testuser1@localhost
```
Insira qualquer senha incorreta quando solicitado. O servidor deve rejeitar a conexão, que é o comportamento esperado que queremos ver.
Em seguida, verificaremos se o servidor SSH está ouvindo na interface de rede e porta corretas. Isso garante que as conexões remotas (como do Hydra) possam alcançar o serviço:
```
sudo netstat -tulnp | grep sshd
```
Você deve ver sshd ouvindo em 0.0.0.0:22, o que significa que ele aceita conexões de qualquer interface de rede na porta SSH padrão (22).
Finalmente, vamos examinar os logs de autenticação para ver nossas tentativas de teste registradas. Os logs são valiosos para solucionar problemas e entender o que está acontecendo nos bastidores:
```
sudo tail -n 10 /var/log/auth.log
```
Procure por entradas mostrando seu login bem-sucedido (etapa 2) e tentativa falhada (etapa 3). Esses logs também serão importantes ao analisar as tentativas de ataque do Hydra posteriormente.

Resumo

Neste laboratório, você aprendeu como configurar um ambiente de teste para o Hydra, instalando e configurando um servidor OpenSSH em uma VM LabEx. O processo incluiu a atualização de pacotes, a instalação do servidor SSH e a verificação de seu status de operação, enquanto configurava as configurações de autenticação para fins de teste.

Você também praticou a criação de contas de usuário de teste para simular cenários do mundo real e preparou o ambiente para testes de segurança de senhas. Este laboratório forneceu experiência prática essencial na configuração de servidores SSH e no estabelecimento de ambientes controlados para experimentação de ferramentas de segurança.

Configurar um Ambiente de Teste para Hydra