Red Team CTF Lab - Web Application Security Training

Laboratório completo de Red Team para treinamento em segurança de aplicações web, incluindo honeypot SSH, WAF bypass, crypto challenges, vulnerabilidades em cadeia, e sistema de sessões isoladas.

🎯 Visão Geral

Este é um laboratório educacional de segurança que implementa:

• ✅ SSH Honeypot com autenticação via banco de dados PostgreSQL
• ✅ WAF (Reverse Proxy) com headers de segurança
• ✅ JWT Vulnerabilities (none algorithm, weak secrets)
• ✅ Crypto Challenges (Hash Extension, Padding Oracle, Weak RNG)
• ✅ Vulnerabilidades em Cadeia (LFI → SQLi → PrivEsc)
• ✅ Sistema de Sessões Isoladas (Docker + OverlayFS)
• ✅ Backend C++ com autenticação SHA-256

📊 Score de Alinhamento com Curso Red Teaming: 83%

🚀 Quick Start

# 1. Iniciar sistema completo
./setup.sh

# 2. Executar testes rápidos
./tests/quick_test.sh

# 3. Acessar serviços

🌐 Portas e Serviços

Serviço	Porta	Acesso	Proteção
Frontend Portfolio	8080	http://localhost:8080	❌ Direto (sem WAF)
Frontend + WAF	8081	http://localhost:8080	✅ ModSecurity (opcional)
SSH Honeypot	2222	ssh -p 2222 guest@localhost	❌ Direto
PostgreSQL	5432	localhost:5432	❌ Direto
Session Orchestrator	5000	http://localhost:5000	❌ Direto
Backend API	-	Via frontend:8080/api/	🔒 Interno apenas

Credenciais:

• SSH: guest/guest ou root/toor
• Dashboard: admin/honeypot2024

📚 Documentação

Toda a documentação está organizada em docs/:

📖 Documentação Principal

• STATUS.md - Status atual do projeto
• BUILD_GUIDE.md - Compilação, deploy e troubleshooting
• TESTING.md - Guia de testes
• PORTS_QUICK_REFERENCE.txt - Referência rápida de portas

🏗️ Arquitetura

• CTF_ARCHITECTURE.md - Arquitetura dos containers CTF
• CTF_TRANSFORMATION.md - Transformação fake → real
• NETWORK_ARCHITECTURE.md - Arquitetura de rede e portas
• REMOVED_CODE.md - Código removido (fake filesystem)

🛡️ Segurança e CTF

• WAF_BYPASS_GUIDE.md - Técnicas de bypass WAF
• WAF_DYNAMIC_PROXY.md - Web tampering detection
• CRYPTO_CHALLENGES_SOLUTIONS.md - Soluções crypto
• ATTACK_WALKTHROUGH.md - Walkthroughs completos
• CTF_CHALLENGES.md - Desafios sugeridos

🧪 Testes

Testes automatizados em tests/:

# Suite completa de 36 testes
./tests/run_all_tests.sh

# Testes individuais
./tests/test_implementation.sh

📁 Estrutura do Projeto

.
├── README.md                    # Este arquivo
├── docker-compose.yml           # Orquestração de containers
├── setup.sh                     # Script de inicialização
│
├── docs/                        # 📚 Documentação
│   ├── STATUS.md
│   ├── BUILD_GUIDE.md
│   ├── WAF_BYPASS_GUIDE.md
│   ├── CRYPTO_CHALLENGES_SOLUTIONS.md
│   ├── ATTACK_WALKTHROUGH.md
│   ├── CTF_CHALLENGES.md
│   └── ...
│
├── tests/                       # 🧪 Testes automatizados
│   ├── run_all_tests.sh        # Suite completa
│   ├── test_implementation.sh  # Testes de implementação
│   └── TEST_GUIDE.sh           # Guia interativo
│
├── backend/                     # Backend C++
│   ├── src/
│   │   ├── main.cpp
│   │   ├── ssh_server.cpp      # SSH Honeypot
│   │   ├── http_server.cpp     # API REST
│   │   ├── command_engine.cpp  # Executor de comandos
│   │   └── db_connector.cpp    # PostgreSQL
│   ├── include/
│   └── CMakeLists.txt
│
├── frontend/                    # Frontend NGINX
│   ├── index.html
│   ├── monitor.html
│   ├── nginx-simple.conf       # Configuração atual
│   └── pages/
│       ├── linux.html
│       ├── windows.html
│       ├── networking.html
│       └── virtualization.html
│
├── waf/                         # WAF (Reverse Proxy)
│   └── Dockerfile
│
├── waf-config/
│   └── nginx-proxy-simple.conf # Configuração WAF
│
├── database/                    # PostgreSQL
│   ├── schema.sql
│   ├── seed.sql
│   └── migrations/
│
├── command-executor/            # Container executor
│   └── Dockerfile
│
├── session-orchestrator/        # Sistema CTF
│   └── api.py
│
└── nmap-scanner/                # Scanner automático
    └── scan_honeypot_ips.sh

---

📋 Índice

1. Visão Geral
2. Arquitetura
3. Funcionalidades
4. Instalação e Deploy
5. Endpoints da API
6. Exportação de Dados
7. Sistema Interativo
8. Validação da Implementação
9. Dependências
10. Arquitetura de Execução

---

🎯 Visão Geral

Este é um laboratório educacional de Red Team focado em:

• 🎓 Treinamento em segurança de aplicações web
• 🧪 Análise de comportamento de atacantes
• 🎮 Desafios CTF com ambiente isolado
• 📊 Logging completo para pesquisa
• 💼 Portfolio técnico avançado

Funcionalidades Principais

• SSH Honeypot com autenticação via PostgreSQL e logging de comandos
• WAF (Reverse Proxy) protegendo backend com headers de segurança
• Frontend Portfolio com páginas Linux, Windows, Networking, Virtualization
• Sistema de Arquivos Fake navegável via SSH
• Execução Real de Comandos em container isolado (Debian 12)
• API REST para monitoramento e exportação de dados
• Crypto Challenges educacionais (JWT, Hash Extension, Padding Oracle)

Arquitetura de Segurança

✅ Backend Protegido - Só acessível via WAF
✅ 100% Isolado - Comandos executados em containers
✅ Logging Completo - PostgreSQL com soft-delete
✅ Sandbox Seguro - Limites de CPU, memória e recursos

---

🏗️ Arquitetura

┌──────────────────────────────────────────────────┐
│  Internet / Atacantes                            │
└──────────────┬───────────────────────────────────┘
               │
    ┌──────────┼──────────┐
    │          │          │
    ▼          ▼          ▼
┌────────┐ ┌────────┐ ┌─────────┐
│Frontend│ │  WAF   │ │   SSH   │
│ :8080  │ │ :8081  │ │  :2222  │
└────────┘ └────┬───┘ └────┬────┘
                │          │
                ▼          ▼
           ┌─────────────────────┐
           │   Backend C++       │
           │   (Interno)         │
           │   - API REST        │
           │   - SSH Server      │
           └──────────┬──────────┘
                      │
         ┌────────────┼────────────┐
         ▼            ▼            ▼
    ┌────────┐  ┌─────────┐  ┌──────────┐
    │Database│  │Command  │  │ Session  │
    │PG 17   │  │Executor │  │Orchestr. │
    └────────┘  └─────────┘  └──────────┘

Containers

Container	Porta	Função	Acesso
Frontend	8080	Portfolio estático (NGINX)	🌐 Público
WAF	8081	Proxy reverso + headers segurança	🌐 Público
Backend	Interno	API C++ + SSH Honeypot	🔒 Via WAF
PostgreSQL	5432	Banco de dados	🔒 Interno
Executor	N/A	Executa comandos SSH	🔒 Interno
Orchestrator	9200-9300	Sessões CTF isoladas	🔒 Interno
Nmap Scanner	N/A	Scan IPs honeypot	🔒 Interno

---

✨ Funcionalidades

1. SSH Honeypot (Port 2222)

• ✅ Autenticação via PostgreSQL - Verifica usuários no banco com SHA-256
• ✅ Shell Interativo Fake - Simula ambiente Linux completo
• ✅ 13+ Comandos Linux - ls, cd, pwd, cat, sudo, su, whoami, etc.
• ✅ Logging Completo - Todas as sessões e comandos registrados
• ✅ Sistema de Arquivos Fake - Estrutura completa em PostgreSQL

Credenciais Padrão (no seed.sql):

• guest:guest123 - Usuário básico
• admin:admin123 - Com privilégios sudo
• root:root123 - Acesso root

Comandos Suportados:

ls, cd, pwd, cat, echo, whoami, id, uname, hostname
sudo, su, clear, help, exit
# Pipes e redirecionamentos suportados

2. WAF (Web Application Firewall)

• ✅ Reverse Proxy - Protege backend na porta 8081
• ✅ Headers de Segurança:
  • X-Frame-Options: SAMEORIGIN
  • X-Content-Type-Options: nosniff
  • X-XSS-Protection: 1; mode=block
  • X-WAF-Status: Protected
• ✅ Backend Interno - Porta 8888 não exposta externamente
• ✅ CORS Configurado - Para API /api/*

3. Frontend Portfolio

• ✅ Páginas Dinâmicas:
  • / - Homepage
  • /linux - Conhecimentos Linux
  • /windows - Windows Server
  • /networking - Redes
  • /virtualization - Virtualização
• ✅ Monitor - Dashboard de atividades honeypot
• ✅ Login - Interface de autenticação
• ✅ Sistema de Partículas - Efeitos visuais interativos

4. Escalação de Privilégios

• ✅ sudo -l - Lista permissões do usuário
• ✅ su - Troca de usuário
• ✅ Exploits Fake - CVE simuladas em /usr/share/exploits/
• ✅ Configuração via Sudoers - Controle granular

4. Sistema de Arquivos Simulado

Estrutura completa em PostgreSQL:

/
├── bin/
├── etc/
│   ├── passwd
│   ├── shadow
│   └── sudoers
├── home/
│   ├── guest/
│   ├── user/
│   ├── admin/
│   └── root/
├── usr/
│   └── share/exploits/cve-2024-1337/
│       ├── localroot
│       └── README.md
└── var/

5. Frontend CTF com Easter Eggs

Pista 1: Porta SSH (Fácil)

• Encontrada em: HTML comments, CSS variables, console.log, HTTP headers
• Resultado: Port 2222

Pista 2: Senhas Escondidas (Médio)

• guest:guest - HTML simples
• admin:adminpass123 - Base64 no CSS
• user:userpass789 - Console.log

Pista 3: Escalação (Difícil)

• Exploit em /usr/share/exploits/cve-2024-1337/localroot
• Eleva automaticamente para root
• Acesso a /root/flag.txt

Easter Eggs Interativos:

• Konami Code (↑↑↓↓←→←→BA)
• Clique 7x no título
• Ctrl+Shift+M para Morse code
• Função __verifyIntegrity() no console
• Sistema de partículas com física

6. API REST (Port 8888)

Endpoints de Monitoramento:

• GET /api/sessions - Sessões ativas
• GET /api/commands - Comandos executados
• GET /api/auth-attempts - Tentativas de login
• GET /api/stats/ips - Estatísticas por IP
• GET /api/stats/ip/{ip} - Comandos de um IP

Endpoints de Exportação:

• GET /api/export/passwords - Senhas únicas (TXT)
• GET /api/export/usernames - Usuários únicos (TXT)
• GET /api/export/commands - Comandos por IP (JSON)

Endpoints Especiais:

• POST /api/clear/all - Marcar logs como inativos (soft-delete)
• POST /api/verify - Verificação do jogo oculto
• POST /api/achievement - Registro de achievements

7. Logging PostgreSQL

Tabelas:

• auth_attempts - Tentativas de SSH
• sessions - Conexões SSH
• commands - Comandos executados
• filesystem - Sistema de arquivos
• users - Usuários do honeypot

Soft-Delete System:

• Nenhum dado é deletado permanentemente
• Coluna active marca registro como inativo
• Audit trail completo preservado

8. Sistema Interativo de Partículas

• 80 partículas com física realista
• Repulsão entre partículas
• Atração magnética do cursor
• Renderização com canvas 2D
• Indicador visual de integridade
• Função oculta __verifyIntegrity()

---

🚀 Instalação e Deploy

Pré-requisitos

• Docker & Docker Compose
• Linux (pode funcionar em WSL2/Mac)
• Pelo menos 2GB RAM, 1GB disk

Deploy Rápido

cd "/media/madruga/SSD/Cursor/2 - Portifolio/Hard Portfolio"
./setup.sh

Acesso

Frontend (encontrar pistas):

http://localhost

Conectar SSH:

# Fácil
ssh guest@localhost -p 2222
# Senha: guest

# Médio
ssh admin@localhost -p 2222
# Senha: adminpass123

# Difícil
ssh user@localhost -p 2222
# Senha: userpass789

Dashboard de Monitoramento:

http://localhost/monitor

Logs em Tempo Real:

docker-compose logs -f backend

Verificar Banco de Dados

docker-compose exec postgres psql -U honeypot_admin -d honeypot

Comandos Úteis

# Status dos containers
docker-compose ps

# Logs completos
docker-compose logs

# Parar tudo
docker-compose down

# Limpar volumes
docker-compose down -v

# Rebuild
docker-compose build --no-cache

---

📚 Endpoints da API

Base URL: http://localhost:8888

1. Monitoramento em Tempo Real

GET /api/sessions

Retorna todas as sessões SSH ativas.

curl -s http://localhost:8888/api/sessions | jq

Resposta:

{
  "sessions": [
    {
      "uuid": "550e8400-e29b-41d4-a716-446655440000",
      "username": "root",
      "ip": "192.168.1.100",
      "directory": "/root",
      "privilege": 3,
      "duration": 145,
      "active": true
    }
  ]
}

GET /api/commands

Retorna os últimos comandos executados (limite: 100).

curl -s http://localhost:8888/api/commands | jq '.commands | length'

GET /api/auth-attempts

Retorna tentativas de autenticação SSH.

curl -s http://localhost:8888/api/auth-attempts | jq 'map(select(.success == false))'

2. Estatísticas

GET /api/stats/ips

Retorna estatísticas agrupadas por IP + username.

# IPs mais agressivos
curl -s http://localhost:8888/api/stats/ips | jq 'sort_by(.auth_attempts) | reverse'

# Contar IPs únicos
curl -s http://localhost:8888/api/stats/ips | jq 'map(.ip) | unique | length'

Resposta:

[
  {
    "ip": "192.168.1.100",
    "username": "root",
    "sessions": 2,
    "commands": 15,
    "auth_attempts": 5,
    "first_seen": "2025-12-19 02:50:29",
    "last_seen": "2025-12-19 05:30:15"
  }
]

GET /api/stats/ip/{ip_address}

Retorna todos os comandos executados por um IP específico (limite: 500).

curl -s http://localhost:8888/api/stats/ip/192.168.1.100 | jq

3. Clearing Logs

POST /api/clear/all

Marca todos os logs como inativos (soft-delete, não deleta nada).

curl -X POST http://localhost:8888/api/clear/all

Resposta:

{
  "success": true,
  "message": "All logs cleared"
}

4. Jogo Oculto

POST /api/verify

Endpoint para verificação do jogo de partículas (resposta aleatória).

curl -X POST http://localhost:8888/api/verify | jq

Resposta (20% chance):

{
  "valid": true,
  "analyzed": 85,
  "status": "complete",
  "integrity": 0.89,
  "timestamp": 1734606600
}

POST /api/achievement

Registra conquistas nos logs.

curl -X POST http://localhost:8888/api/achievement

---

💾 Exportação de Dados

Endpoints de Exportação

Base URL: http://localhost:8888
Nota: Acesso apenas via porta 8888 (direto no backend, não via nginx)

GET /api/export/passwords

Exporta todas as senhas únicas tentadas (formato TXT).

curl -s http://localhost:8888/api/export/passwords > senhas.txt

Resposta:

admin123
guest
password123
test123
toor

GET /api/export/usernames

Exporta todos os nomes de usuário únicos (formato TXT).

curl -s http://localhost:8888/api/export/usernames > usuarios.txt

GET /api/export/commands

Exporta comandos por IP (formato JSON).

curl -s http://localhost:8888/api/export/commands | jq '.' > comandos.json

Resposta:

[
  {
    "ip": "192.168.1.100",
    "username": "root",
    "total_commands": 5,
    "comandos": [
      {
        "command": "ls -la",
        "output": "total 48\ndrwxr-xr-x...",
        "exit_code": 0,
        "executed_at": "2025-12-19 05:12:30"
      }
    ]
  }
]

Exemplos de Uso

# Exportar tudo
curl -s http://localhost:8888/api/export/passwords > /tmp/senhas.txt
curl -s http://localhost:8888/api/export/usernames > /tmp/usuarios.txt
curl -s http://localhost:8888/api/export/commands | jq '.' > /tmp/comandos.json

# Contar dados
curl -s http://localhost:8888/api/export/passwords | wc -l
curl -s http://localhost:8888/api/export/usernames | wc -l

# Senhas mais usadas
curl -s http://localhost:8888/api/auth-attempts | \
  jq -r '.[] | .password' | sort | uniq -c | sort -rn

# Usuários mais tentados
curl -s http://localhost:8888/api/auth-attempts | \
  jq -r '.[] | .username' | sort | uniq -c | sort -rn

---

🎮 Sistema Interativo

Particle System

O sistema possui 80 partículas com física realista que respondem ao cursor do mouse.

Configuração padrão:

{
    particleCount: 80,      // Número de partículas
    connectionDistance: 150, // Distância para desenhar conexões
    repulsionDistance: 50,   // Distância de repulsão
    minSpeed: 0.3,          // Velocidade mínima
    magnetRadius: 200       // Raio de atração do cursor
}

Jogo Oculto: __verifyIntegrity()

Objetivo (não documentado): Mover todas as 80 partículas para dentro da zona magnética do cursor simultaneamente.

Como usar:

// No console do navegador (F12)
__verifyIntegrity()

Resposta:

{
  "valid": true/false,
  "analyzed": 70-99,
  "status": "complete" ou "partial",
  "integrity": 0.0-1.0,
  "timestamp": epoch_time
}

Indicadores:

• Verde (#00ff9f): Verificação completa
• Vermelho (#ff5555): Verificação incompleta
• Laranja (#ffaa00): Avisos

Easter Eggs

1. Konami Code - ↑↑↓↓←→←→BA
2. Clique no Título - 7 cliques revelam easter egg
3. Morse Code - Ctrl+Shift+M
4. Função Secreta - revealSecrets() no console

---

✅ Validação da Implementação

Requisitos Atendidos

✅ Frontend com Porta SSH Escondida

• Localização: comentários HTML, CSS variables, console.log, HTTP headers
• Porta SSH: 2222

✅ Senhas Escondidas Estilo HackTheBox

• guest:guest (fácil)
• admin:adminpass123 (médio - Base64)
• user:userpass789 (médio - Console)
• root:??? (difícil - Requer exploit)

✅ Backend C++ Completo

• SSH server com libssh
• Motor de comandos com 13+ comandos
• Database connector para PostgreSQL
• Sistema de privilégios
• Logging completo

✅ PostgreSQL Logging

• 5 tabelas com índices
• Soft-delete com coluna active
• Estrutura de diretórios completa
• Exploits falsos
• Flags escondidas

✅ Escalação de Privilégios

• sudo -l com permissões
• su para trocar usuário
• Exploits executáveis
• Logging de tentativas

✅ Docker Deployment

• docker-compose.yml com 4 containers
• Nginx proxy reverso
• PostgreSQL 17-alpine
• Backend com C++ custom
• Executor com Debian 12 real

✅ API REST

• 11 endpoints documentados
• Monitoramento em tempo real
• Exportação de dados
• Soft-delete system
• Sistema de partículas

Testes de Validação

# Verificar status
docker-compose ps

# Testar SSH
ssh guest@localhost -p 2222

# Testar API
curl -s http://localhost:8888/api/auth-attempts | jq 'length'

# Testar exportação
curl -s http://localhost:8888/api/export/passwords | wc -l

# Verificar banco
docker-compose exec postgres psql -U honeypot_admin -d honeypot -c "SELECT COUNT(*) FROM auth_attempts;"

# Ver logs
docker-compose logs backend | grep "System Ready"

---

📦 Dependências

Versões Principais (Dezembro 2025)

Componente	Versão	Notas
PostgreSQL	17-alpine	Versão mais recente
Debian Base	bookworm-slim	Debian 12
C++ Standard	C++20	Features modernas
libssh	0.10.6	Servidor SSH
libpq	15.14	Cliente PostgreSQL
GCC	12.2.0	Compilador Debian 12
CMake	3.20+	Build system

Ferramentas de Sistema

coreutils, util-linux, procps, bash
net-tools, iputils-ping, dnsutils, curl, wget
vim, nano
git, python3, perl
tar, gzip, bzip2
htop, tmux, screen
openssh-client, openssh-server

PostgreSQL 17 Novidades

• Vacuum paralelo melhorado - Até 70% mais rápido
• B-tree improvements - Melhor performance em índices
• JSON melhorado - Funções SQL/JSON padrão
• Row-level security - Políticas de segurança aprimoradas

Bibliotecas de Desenvolvimento

build-essential
cmake 3.25+
git 2.39.5
libssh-dev 0.10.6
libpq-dev 15.14

---

🔧 Arquitetura de Execução

Dois Containers Separados

1. SSH Honeypot Container (honeypot_ssh)

• Servidor SSH (libssh)
• Sistema de autenticação
• Motor de comandos
• Logging e monitoramento

2. Executor Container (honeypot_executor)

• Debian 12 puro com kernel Linux real
• Sistema de arquivos completo
• Todas as ferramentas Linux padrão
• Usuário guest real

Fluxo de Execução

Atacante SSH
    ↓
SSH Server (libssh)
    ↓
Command Engine
    ↓
[docker exec]
    ↓
Executor Container (Debian 12 Real)
    ↓
Comandos reais executados
    ↓
Saída retornada + Logging PostgreSQL

Segurança de Execução

• ✅ Isolamento: Executor em container separado
• ✅ Limites de Recurso: CPU 0.5 cores, RAM 512MB
• ✅ Timeout: 10 segundos por comando
• ✅ Comandos Bloqueados: rm, shutdown, passwd, etc.
• ✅ Socket Docker: Read-only

Comandos Disponíveis (Sistema Real)

Navegação

• ls, cd, pwd, tree, find

Arquivos

• cat, less, head, tail, grep
• touch, mkdir, cp, mv
• tar, gzip, zip, unzip

Sistema

• ps, top, htop, free, df, du
• uname, hostname, whoami, id

Rede

• ping, curl, wget
• netstat, dig, nslookup

Desenvolvimento

• python3, perl, git, vim, nano

Vantagens

✅ 100% Realismo - Sistema Linux real
✅ 100% Segurança - Isolamento completo
✅ 100% Logging - Tudo registrado
✅ Flexibilidade - Fácil adicionar ferramentas

---

📊 Resumo Técnico

Endpoints Disponíveis (11 total)

Endpoint	Método	Retorno	Cache
/api/sessions	GET	JSON	Não
/api/commands	GET	JSON	Não
/api/auth-attempts	GET	JSON	Não
/api/stats/ips	GET	JSON	Não
/api/stats/ip/{ip}	GET	JSON	Não
/api/export/passwords	GET	TXT	Não
/api/export/usernames	GET	TXT	Não
/api/export/commands	GET	JSON	Não
/api/clear/all	POST	JSON	N/A
/api/verify	POST	JSON	Não
/api/achievement	POST	JSON	Não

Arquivos do Projeto

backend/
├── include/ (8 headers)
├── src/ (8 implementações)
├── CMakeLists.txt
└── Dockerfile

frontend/
├── index.html (com easter eggs)
├── styles.css (com senhas)
├── script.js (com console logs)
├── particle-system.js (física de partículas)
└── nginx.conf (com headers SSH)

database/
├── schema.sql
├── migrations/
└── seed.sql

.
├── docker-compose.yml
├── setup.sh
└── README.md

---

🔒 Notas de Segurança

• ✅ Sem autenticação - Honeypot transparente
• ✅ Soft-delete - Nada é deletado permanentemente
• ✅ SQL Injection Prevention - Parâmetros escapados
• ✅ Acesso Restrito - Exportação na porta 8888 apenas
• ⚠️ NUNCA expor porta 8888 publicamente
• ⚠️ Use nginx proxy (80/443) apenas para monitoramento

---

🎓 Valor Educacional

Este projeto demonstra:

• Desenvolvimento de honeypots
• Programação C++ avançada
• Design de bancos de dados
• Segurança e isolamento
• Arquitetura multi-camadas
• Docker e containerização
• CTF challenge design
• Logging e monitoramento
• Sistemas embarcados

---

📞 Suporte e Dúvidas

Verificar Logs

docker-compose logs backend

Testar Conectividade

curl -v http://localhost:8888/api/sessions

Verificar Banco de Dados

docker-compose exec postgres psql -U honeypot_admin -d honeypot -c "SELECT COUNT(*) FROM auth_attempts;"

Parar e Limpar Tudo

docker-compose down -v

---

🚀 Próximas Melhorias

• Pool de Executors para melhor performance
• Suporte a múltiplos SOs (Ubuntu, CentOS)
• Persistência de arquivos criados
• Simulação de rede interna
• Detecção de padrões com IA
• Interface gráfica avançada

---

📝 Licença e Autoria

Projeto: SSH Honeypot - Hard Portfolio
Data: Dezembro 2025
Status: ✅ Completo
Quantidade de Código: 2000+ linhas C++, 300+ linhas SQL, 600+ linhas Frontend

---

Made with ❤️ for security research and portfolio demonstration