Ataque com Credenciais Separadas por Dois Pontos

HydraBeginner
Pratique Agora

Introdução

Neste laboratório, você aprenderá a realizar um ataque baseado em credenciais usando o Hydra. O laboratório se concentra em utilizar um arquivo de credenciais separado por dois pontos contendo combinações de nome de usuário/senha para quebrar as credenciais de login de um serviço de destino.

Você começará criando um arquivo credentials.txt com pares nome de usuário:senha, usando um editor de texto como o nano. Em seguida, aprenderá como carregar este arquivo no Hydra usando a opção -C, permitindo que o Hydra tente eficientemente várias combinações de login contra o alvo. Finalmente, você verificará se a saída corresponde às credenciais usadas no ataque.

Criar um Arquivo de Credenciais login:senha

Neste passo, você criará um arquivo contendo nomes de usuário e senhas, uma combinação por linha, separadas por dois pontos. Este arquivo será usado posteriormente com o Hydra para tentar quebrar as credenciais de login de um serviço de destino.

Primeiro, vamos entender o formato necessário para o arquivo de credenciais. Cada linha deve conter um nome de usuário, dois pontos (:) e a senha correspondente. Por exemplo:

username1:password1
username2:password2

Agora, vamos criar o arquivo. Usaremos o editor de texto nano, que é simples e fácil de usar. Abra seu terminal e navegue até o diretório ~/project, se ainda não estiver lá:

cd ~/project
  1. Abra um novo arquivo chamado credentials.txt no diretório ~/project usando nano:

    nano credentials.txt
  2. No editor nano, adicione as seguintes combinações de nome de usuário/senha. Essas são as credenciais que o Hydra tentará usar.

    admin:password
    user1:123456
    test:test
    root:toor
  3. Para salvar o arquivo, pressione Ctrl+O (Gravar). O Nano solicitará o nome do arquivo. Basta pressionar Enter para aceitar o nome de arquivo padrão (credentials.txt).

  4. Para sair do nano, pressione Ctrl+X.

Agora, vamos verificar se o arquivo foi criado e contém o conteúdo correto. Use o comando cat para exibir o conteúdo do arquivo credentials.txt:

cat credentials.txt

Você deverá ver as combinações de nome de usuário/senha que você digitou anteriormente:

admin:password
user1:123456
test:test
root:toor

Você agora criou com sucesso um arquivo de credenciais que pode ser usado com o Hydra. Este arquivo contém uma lista de possíveis nomes de usuário e senhas que o Hydra tentará contra o serviço de destino.

Configurar um Servidor HTTP Básico com Autenticação

Neste passo, você configurará um servidor HTTP simples que requer autenticação básica. Este servidor servirá como nosso alvo para o ataque Hydra no próximo passo. Usaremos um script Python para isso.

Primeiro, certifique-se de que você está no diretório ~/project:

cd ~/project

Agora, crie um novo arquivo Python chamado webserver.py usando nano:

nano webserver.py

Cole o seguinte código Python no editor:

import http.server
import socketserver
import base64

PORT = 8000

class AuthHandler(http.server.SimpleHTTPRequestHandler):
    def do_HEAD(self):
        self.send_response(200)
        self.send_header('Content-type', 'text/html')
        self.end_headers()

    def do_AUTHHEAD(self):
        self.send_response(401)
        self.send_header('WWW-Authenticate', 'Basic realm="My Realm"')
        self.send_header('Content-type', 'text/html')
        self.end_headers()

    def do_GET(self):
        auth = self.headers.get('Authorization')
        if auth == None:
            self.do_AUTHHEAD()
            self.wfile.write(b"Authentication Required")
        elif auth == 'Basic YWRtaW46cGFzc3dvcmQ=': ## admin:password base64 encoded
            http.server.SimpleHTTPRequestHandler.do_GET(self)
        else:
            self.do_AUTHHEAD()
            self.wfile.write(b"Authentication Failed")

Handler = AuthHandler

with socketserver.TCPServer(("", PORT), Handler) as httpd:
    print("serving at port", PORT)
    httpd.serve_forever()

Este script cria um servidor HTTP básico na porta 8000. Ele requer autenticação básica. O nome de usuário correto é admin e a senha é password. A string codificada em base64 YWRtaW46cGFzc3dvcmQ= representa admin:password.

Salve o arquivo (Ctrl+O, depois Enter) e saia do nano (Ctrl+X).

Agora, execute o script Python para iniciar o servidor HTTP. Vamos executá-lo em segundo plano para que você possa continuar usando o terminal:

nohup python3 webserver.py > /dev/null 2>&1 &

O comando nohup permite que o processo continue rodando mesmo se você fechar o terminal. > /dev/null 2>&1 redireciona a saída padrão e o erro padrão para /dev/null, evitando que a saída do servidor polua seu terminal. O & no final executa o comando em segundo plano.

Para confirmar que o servidor está funcionando, você pode verificar se um processo está ouvindo na porta 8000:

ss -ltn | grep ':8000'

Você deve ver uma saída semelhante a esta, indicando que um processo está ouvindo na porta 8000:

LISTEN 0      4096   0.0.0.0:8000      0.0.0.0:*

Mantenha este servidor em execução para o próximo passo.

Atacar HTTP com Arquivo de Credenciais usando Hydra

Neste passo, você utilizará o Hydra para atacar o serviço HTTP configurado no passo anterior. Você usará a opção -C para carregar o arquivo de credenciais criado no Passo 1, permitindo que o Hydra tente várias combinações de nome de usuário/senha de forma eficiente.

Certifique-se de que você está no diretório ~/project:

cd ~/project

Agora, execute o seguinte comando Hydra para atacar o servidor HTTP em execução em 127.0.0.1 na porta 8000:

hydra -C credentials.txt 127.0.0.1 http-get / -s 8000 -vV

Vamos decompor este comando:

  • hydra: O comando para executar a ferramenta Hydra.
  • -C credentials.txt: Esta opção especifica o caminho para o arquivo de credenciais que você criou. O Hydra lerá as combinações de nome de usuário/senha deste arquivo.
  • 127.0.0.1: O endereço IP de destino. Este é o endereço de loopback, referindo-se à sua máquina local.
  • http-get /: Especifica o serviço a ser atacado (HTTP) e o caminho da solicitação (/). http-get é um módulo que executa solicitações HTTP GET.
  • -s 8000: Especifica o número da porta do serviço de destino. Nosso servidor HTTP está em execução na porta 8000.
  • -vV: Habilita o modo detalhado, que exibe as tentativas de login e quaisquer credenciais encontradas.

O Hydra agora tentará forçar a senha do servidor HTTP usando as combinações de nome de usuário/senha do arquivo credentials.txt. Ele tentará cada combinação contra o serviço de destino.

Você verá a saída do Hydra indicando que ele está tentando diferentes combinações de nome de usuário/senha. Se o Hydra encontrar com sucesso as credenciais corretas (admin:password), ele as exibirá na saída.

Exemplo de Saída (Ataque Bem-Sucedido):

Hydra v9.2 (c) 2021 by van Hauser/THC & David Maciejak - Please do not use in military or secret service organizations, or for illegal purposes (this is non-binding, these *** ignore laws and ethics anyway).

Hydra (https://github.com/vanhauser-thc/thc-hydra) starting at ...
[DATA] max 16 tasks per 1 server, overall 16 tasks, 4 login tries (l:4/p:1), ~1 try per task
[DATA] attacking http-gets://127.0.0.1:8000/
[VERBOSE] Resolving addresses ... [VERBOSE] resolving done
[ATTEMPT] target 127.0.0.1 - login "admin" - pass "password" - 1 of 4 [child 0] (0/0)
[ATTEMPT] target 127.0.0.1 - login "user1" - pass "123456" - 2 of 4 [child 1] (0/0)
[ATTEMPT] target 127.0.0.1 - login "test" - pass "test" - 3 of 4 [child 2] (0/0)
[ATTEMPT] target 127.0.0.1 - login "root" - pass "toor" - 4 of 4 [child 3] (0/0)
[8000][http-get] host: 127.0.0.1   login: admin   password: password
[STATUS] attack finished for 127.0.0.1 (waiting for children to complete tests)
1 of 1 target successfully completed, 1 valid password found
Hydra (https://github.com/vanhauser-thc/thc-hydra) finished at ...

Se o ataque for bem-sucedido, o Hydra imprimirá o nome de usuário e a senha corretos.

Confirmar Credenciais Encontradas

Neste passo, você verificará se as credenciais encontradas pelo Hydra no passo anterior correspondem às credenciais esperadas no arquivo credentials.txt e no script webserver.py. Isso verifica se o Hydra identificou corretamente a combinação de login válida.

No passo anterior, a saída do Hydra deve ter mostrado a seguinte linha (ou similar):

[8000][http-get] host: 127.0.0.1   login: admin   password: password

Esta linha indica que o Hydra encontrou com sucesso o nome de usuário admin e a senha password para o serviço de destino.

Agora, vamos verificar se essas credenciais estão de fato presentes nos arquivos que criamos.

  1. Verificar credenciais em credentials.txt:

    Use o comando cat para exibir o conteúdo do arquivo credentials.txt:

    cat credentials.txt

    Confirme que o arquivo contém a linha admin:password. Esta é uma das combinações que o Hydra tentou.

  2. Verificar credenciais em webserver.py:

    Use o comando cat para exibir o conteúdo do arquivo webserver.py:

    cat webserver.py

    Procure pela linha que verifica o cabeçalho de autenticação codificado em base64. Você deve encontrar uma linha semelhante a esta:

    elif auth == 'Basic YWRtaW46cGFzc3dvcmQ=': ## admin:password base64 encoded

    A string YWRtaW46cGFzc3dvcmQ= é a codificação base64 de admin:password. Isso confirma que o servidor está configurado para aceitar admin como nome de usuário e password como senha.

Ao verificar se as credenciais encontradas pelo Hydra correspondem às credenciais configuradas no script do servidor e presentes no seu arquivo de credenciais, você confirma o sucesso do ataque de força bruta usando a opção -C.

Finalmente, vamos parar o processo do servidor HTTP em segundo plano. Você pode encontrar o ID do processo (PID) usando o comando ss novamente:

ss -ltn | grep ':8000'

A saída mostrará o PID na segunda coluna. Por exemplo:

LISTEN 0      4096   0.0.0.0:8000      0.0.0.0:*    users:(("python3",pid=12345,fd=3))

Neste exemplo, o PID é 12345. Use o comando kill para parar o processo, substituindo [PID] pelo PID real que você encontrou:

kill [PID]

Por exemplo, se o PID fosse 12345:

kill 12345

Você pode verificar se o servidor parou executando ss -ltn | grep ':8000' novamente. Não deve haver nenhuma saída.

Resumo

Neste laboratório, você aprendeu a criar um arquivo de credenciais chamado credentials.txt contendo combinações de nome de usuário e senha separadas por dois pontos, com cada combinação em uma nova linha. Este arquivo é armazenado no diretório ~/project e preparado para uso com o Hydra.

Você também aprendeu a configurar um servidor HTTP básico com autenticação usando um script Python, que serviu como alvo para o ataque.

Finalmente, você usou com sucesso o Hydra com a opção -C para carregar o arquivo de credenciais e realizar um ataque de força bruta contra o servidor HTTP, demonstrando como testar eficientemente várias combinações de login. Você confirmou que as credenciais encontradas correspondiam aos valores esperados, verificando o sucesso do ataque.