Implementar um Honeypot Cowrie: Guia Prático de Segurança Cibernética

Introdução

Neste laboratório, você aprenderá como implantar o Cowrie, um honeypot SSH de interação média que captura e analisa o comportamento de atacantes. Você configurará o Cowrie em um ambiente virtual Python e o configurará para imitar um serviço SSH real, enquanto habilita o registro abrangente.

Através deste exercício prático, você testará o honeypot simulando ataques e analisando os logs gerados. Essa experiência prática o ajudará a entender como os honeypots funcionam como ferramentas de segurança cibernética para detecção e análise de ameaças.

Instalar o Cowrie

Nesta etapa, você instalará o Cowrie, um honeypot SSH de interação média projetado para registrar ataques de força bruta e a interação com o shell realizada por atacantes. Cowrie é implementado em Python e pode ser facilmente instalado usando o pip. Um honeypot é um mecanismo de segurança que imita sistemas reais para atrair e estudar atividades maliciosas, ajudando os profissionais de segurança a entender os padrões de ataque.

Primeiro, certifique-se de estar no diretório de trabalho padrão. É aqui que manteremos todos os arquivos do projeto organizados:
```
cd ~/project
```
Instale as dependências de sistema necessárias para o Cowrie. Esses pacotes fornecem componentes essenciais necessários para que o Cowrie seja executado corretamente, incluindo ferramentas de desenvolvimento Python e bibliotecas criptográficas:
```
sudo apt-get update && sudo apt-get install -y python3-venv python3-dev libssl-dev libffi-dev build-essential
```
Crie um ambiente virtual Python para o Cowrie. Os ambientes virtuais mantêm as dependências do projeto isoladas da instalação Python do seu sistema, evitando possíveis conflitos:
```
python3 -m venv cowrie-env
```
Ative o ambiente virtual. Quando ativado, quaisquer pacotes Python que você instalar irão para este ambiente isolado, em vez do seu Python em todo o sistema:
```
source cowrie-env/bin/activate
```
Instale o Cowrie usando o pip. Pip é o gerenciador de pacotes do Python que fará o download e instalará o Cowrie junto com suas dependências:
```
pip install cowrie
```
Verifique a instalação verificando a versão do Cowrie. Isso confirma que o pacote foi instalado corretamente e mostra qual versão você está executando:
```
cowrie --version
```
Você deve ver uma saída semelhante a:
```
cowrie 2.1.0
```
Desative o ambiente virtual quando terminar. Isso o retorna ao ambiente Python padrão do seu sistema:
```
deactivate
```

Configurar as Definições do Honeypot

Nesta etapa, você configurará as configurações do honeypot Cowrie para personalizar seu comportamento e recursos de registro. Os arquivos de configuração atuam como o cérebro do seu honeypot, determinando como ele interage com potenciais atacantes e quais dados são registrados para análise.

Primeiro, ative o ambiente virtual Python criado na etapa anterior. Isso isola as dependências do Cowrie do seu Python do sistema:
```
cd ~/project
source cowrie-env/bin/activate
```
Gere os arquivos de configuração padrão. Esses modelos contêm todas as configurações disponíveis com seus valores padrão:
```
cowrie-gen-config
```
Isso criará arquivos de configuração em ~/project/cowrie-env/etc/cowrie/
Edite o arquivo de configuração principal usando o nano, um editor de texto amigável para iniciantes:
```
nano cowrie-env/etc/cowrie/cowrie.cfg
```
Modifique estas configurações-chave (use as setas para navegar, Ctrl+O para salvar, Ctrl+X para sair):
- Altere listen_port = 2222 para listen_port = 22 - isso faz com que o honeypot apareça como um servidor SSH padrão
- Defina enabled = true na seção [output_json] - habilita o registro estruturado para facilitar a análise
- Defina enabled = true na seção [output_textlog] - fornece logs legíveis por humanos
Crie um diretório dedicado para arquivos de log. Manter os logs separados ajuda na organização e análise:
```
mkdir -p ~/project/cowrie-logs
```
Atualize o caminho de registro na configuração para apontar para o seu novo diretório:
```
nano cowrie-env/etc/cowrie/cowrie.cfg
```
Encontre a configuração log_path e altere-a para:
```
log_path = /home/labex/project/cowrie-logs
```
Verifique as alterações na configuração verificando as configurações modificadas:
```
grep -E 'listen_port|enabled|log_path' cowrie-env/etc/cowrie/cowrie.cfg
```
Você deve ver a saída refletindo suas alterações, confirmando que a configuração foi salva corretamente.

Iniciar o Serviço SSH

Nesta etapa, você iniciará o serviço SSH do honeypot Cowrie que ouvirá as conexões de entrada. Como estamos executando em um contêiner Docker sem systemd, usaremos a execução direta do processo. Essa abordagem é mais simples do que o gerenciamento tradicional de serviços e mais adequada para ambientes em contêineres.

Primeiro, certifique-se de estar no diretório correto e ative o ambiente virtual. O ambiente virtual contém todas as dependências Python necessárias isoladas do seu sistema:
```
cd ~/project
source cowrie-env/bin/activate
```
Inicie o serviço Cowrie em segundo plano. A flag -n faz com que ele seja executado no modo não daemon (mostrando a saída diretamente no terminal), enquanto & coloca o processo em segundo plano para que você possa continuar usando o terminal:
```
cowrie start -n &
```
Verifique se o serviço está em execução verificando a lista de processos. Este comando filtra todos os processos em execução para mostrar apenas aqueles que contêm "cowrie":
```
ps aux | grep cowrie
```
Você deve ver uma saída semelhante a:
```
labex   12345  0.0  0.5  12345  6789 ?        S    12:34   0:00 python cowrie start -n
```
Verifique se o serviço está ouvindo na porta 22. Isso é crucial porque as conexões SSH virão para esta porta. O comando mostra todos os serviços de rede e suas portas de escuta:
```
sudo netstat -tulnp | grep 22
```
Você deve ver uma saída indicando que o Python está ouvindo na porta 22.
Para tornar o serviço persistente em todas as sessões do terminal, crie um script simples de keep-alive. Isso garante que o honeypot permaneça em execução mesmo se você fechar o terminal:
```
nano cowrie-keepalive.sh
```
Adicione o seguinte conteúdo:
```
#!/bin/bash
source ~/project/cowrie-env/bin/activate
cowrie start -n
```
Torne o script executável para que ele possa ser executado diretamente:
```
chmod +x cowrie-keepalive.sh
```
Agora você pode executar o honeypot executando este script. Ele ativará o ambiente e iniciará o Cowrie em uma única etapa:
```
./cowrie-keepalive.sh
```

Simular um Ataque

Nesta etapa, você simulará um ataque de força bruta SSH contra seu honeypot Cowrie para verificar seus recursos de registro. Essa simulação ajuda a demonstrar como atacantes do mundo real podem tentar obter acesso não autorizado e como o honeypot registra essas tentativas para análise.

Primeiro, certifique-se de que seu honeypot Cowrie esteja em execução (da etapa anterior):
```
ps aux | grep cowrie
```
Este comando verifica se o processo Cowrie está ativo. Você deve ver 'cowrie' na lista de saída.
Instale o cliente SSH se ainda não estiver disponível:
```
sudo apt-get install -y openssh-client
```
O pacote openssh-client fornece o comando ssh que usaremos para conectar ao nosso honeypot. A flag '-y' confirma automaticamente quaisquer prompts.
Simule um ataque de força bruta tentando várias conexões SSH com combinações comuns de nome de usuário/senha:
```
for i in {1..5}; do
  sshpass -p 'password' ssh -o StrictHostKeyChecking=no -p 22 labex@localhost
  sshpass -p 'admin' ssh -o StrictHostKeyChecking=no -p 22 admin@localhost
  sshpass -p 'root' ssh -o StrictHostKeyChecking=no -p 22 root@localhost
done
```
Este script tenta pares comuns de nome de usuário/senha (como root/password) cinco vezes cada. O '-o StrictHostKeyChecking=no' impede que o SSH pergunte sobre hosts desconhecidos, facilitando a automação.
Simule um ataque mais sofisticado usando o hydra (pré-instalado na VM LabEx):
```
hydra -L /usr/share/wordlists/metasploit/unix_users.txt -P /usr/share/wordlists/metasploit/unix_passwords.txt -t 4 -vV localhost ssh
```
Hydra é uma ferramenta poderosa de força bruta. Aqui, ele tenta combinações das wordlists fornecidas (-L para nomes de usuário, -P para senhas). O '-t 4' limita a 4 tentativas paralelas e '-vV' mostra a saída detalhada.
Verifique se os ataques foram registrados verificando os logs do Cowrie:
```
ls -l ~/project/cowrie-logs/
```
Após executar os ataques, este comando mostra novos arquivos de log contendo detalhes de todas as tentativas de conexão. Esses logs são o que os analistas de segurança examinariam em uma implantação real.

Verificar os Logs de Ataque

Nesta etapa, você analisará os logs de ataque gerados pelo Cowrie para entender os ataques simulados da etapa anterior. Os logs contêm informações de segurança valiosas sobre as tentativas de ataque. O Cowrie registra automaticamente todas as tentativas de interação em dois formatos: um log de texto simples para leitura rápida e um log JSON estruturado para análise detalhada.

Primeiro, navegue até o diretório de log onde o Cowrie armazena todos os seus arquivos de log:
```
cd ~/project/cowrie-logs
```
Visualize o arquivo de log baseado em texto (mais recente primeiro). O comando ls -lt mostra os arquivos classificados por tempo de modificação, enquanto tail exibe as últimas 20 linhas do log mais recente:
```
ls -lt cowrie.log*
tail -n 20 cowrie.log
```
Você deve ver entradas mostrando tentativas de login malsucedidas com timestamps, nomes de usuário e endereços IP.
Examine o arquivo de log JSON para dados estruturados. A ferramenta jq ajuda a analisar JSON, e less permite rolar pela saída longa:
```
jq '.' cowrie.json | less
```
Procure por entradas com "eventid": "cowrie.login.failed", que indicam tentativas de autenticação malsucedidas.
Pesquise por padrões de ataque específicos direcionados a contas de administrador comuns. O comando grep pesquisa por padrões de texto em arquivos:
```
grep -a "root" cowrie.log
grep -a "admin" cowrie.log
```

Gere um resumo das tentativas de ataque. Esses comandos extraem e contam os nomes de usuário e senhas mais frequentemente tentados dos logs JSON:

echo "Top usernames attempted:"
jq -r 'select(.eventid=="cowrie.login.failed") | .username' cowrie.json | sort | uniq -c | sort -nr

echo -e "\nTop passwords attempted:"
jq -r 'select(.eventid=="cowrie.login.failed") | .password' cowrie.json | sort | uniq -c | sort -nr

Visualize as informações do IP de origem (mostrará localhost nesta simulação). Isso extrai os endereços IP dos clientes que se conectam:
```
jq -r 'select(.eventid=="cowrie.session.connect") | .src_ip' cowrie.json
```

Resumo

Neste laboratório, você aprendeu como implantar um honeypot SSH Cowrie para monitorar e analisar ataques cibernéticos. O processo incluiu a configuração de um ambiente virtual Python, a configuração de portas SSH e a ativação do registro JSON para coleta detalhada de dados de ataque.

Você também adquiriu experiência prática em iniciar o serviço de honeypot, simular ataques e analisar os dados registrados. Este exercício prático demonstrou como as ferramentas de segurança podem imitar sistemas reais para detectar e estudar atividades maliciosas de forma eficaz.

Implementar um Honeypot no Cowrie