Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
coalmine — Plataforma de Gerenciamento e Orquestração de Objetos Cloud Canary | Kitploit
Ferramentas/GitHubGitHub/johnearle/coalmine
Ferramentas DefensivasSegurança na NuvemGerenciamento de Identidade e Acesso (IAM)Detecção de IntrusãoResposta a Incidentes
GitHubjohnearle/coalmine

coalmine

Plataforma de Gerenciamento e Orquestração de Objetos Cloud Canary

Ver Repositório
824há 28 diasAinda não revisado

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

Coalmine — Canary Token Management

Gerenciamento de Tokens Canary na Nuvem — Implante, monitore e rotacione credenciais enganosas em AWS e GCP para detectar acesso não autorizado.

License

[!WARNING] Versão Alpha — O Coalmine está em desenvolvimento inicial. A funcionalidade básica é a prioridade atual, e a aplicação não deve ser considerada totalmente testada em segurança para uso em produção.

Status

Baixar ferramenta
FuncionalEm Desenvolvimento (Instável)A Fazer
Canários de Usuário IAM da AWSCanários de Conta de Serviço do GCPSuporte Azure
Canários de Bucket S3 da AWSCanários de Bucket do GCPIntegração SIEM
Monitoramento CloudTrailMonitoramento de Logs de Auditoria do GCP
Backend de Estado PostgreSQLRotação Automática
API REST (Chave de API + Autenticação por Sessão)
Painel WebUI
Alertas por E-mail e Webhook
Gerenciamento de Credenciais e Contas
RBAC (Casbin)

Visão Geral

O Coalmine implanta e monitora automaticamente "tokens canary" — credenciais e recursos isca que disparam alertas quando acessados por atacantes.

Provedores Suportados:

  • AWS: Usuários IAM, Buckets S3
  • GCP: Contas de Serviço, Buckets Cloud Storage

Funcionalidades

  • Suporte a Múltiplas Nuvens — AWS e GCP a partir de uma única interface
  • Modelo de Credenciais e Contas — Gerencie credenciais e contas em nuvem via CLI, API ou sincronização YAML
  • Rotação Automática — Credenciais rotacionam em intervalos configuráveis
  • Monitoramento Centralizado — Integração com CloudTrail e Logs de Auditoria do GCP
  • Alertas Flexíveis — Notificações por E-mail, Webhook e Syslog
  • Infraestrutura como Código — Recursos gerenciados pelo OpenTofu
  • API REST — Acesso programático com chave de API ou autenticação por sessão
  • WebUI — Painel baseado em navegador em /ui
  • RBAC — Controle de acesso baseado em funções via Casbin
  • CLI — Estrutura de subcomandos agrupados (coalmine <recurso> <ação>)

Guia de Início Rápido

Pré-requisitos

  • Docker e Docker Compose
  • Credenciais AWS (para canários AWS)
  • Credenciais GCP (para canários GCP)

1. Clone e Configure

root@kitploit:~
git clone https://github.com/yourorg/coalmine.git
cd coalmine
cp .env.example .env
# Edite .env com suas credenciais de banco de dados e nuvem

2. Inicie os Serviços

root@kitploit:~
docker compose up -d

Isso inicia a API, o worker Celery, o Redis e o PostgreSQL. O WebUI estará disponível em http://localhost:8000/ui.

3. Registre Credenciais e Contas

root@kitploit:~
# Adicione uma credencial AWS
docker compose exec app coalmine credentials add my-aws-cred AWS \
  --secrets '{"access_key_id": "...", "secret_access_key": "...", "region": "us-east-1"}'

# Adicione uma conta sob essa credencial
docker compose exec app coalmine accounts add prod-east --credential my-aws-cred \
  --account-id 111111111111

# Ou sincronize credenciais e contas a partir de um arquivo YAML
docker compose exec app coalmine credentials sync --dry-run

4. Crie um Recurso de Log

root@kitploit:~
# Crie um destino de log CloudTrail
docker compose exec app coalmine logs create my-trail AWS_CLOUDTRAIL \
  --account <ACCOUNT_ID>

# Liste os recursos de log
docker compose exec app coalmine logs list

5. Implante um Canary

root@kitploit:~
# Crie um canary de usuário IAM da AWS
docker compose exec app coalmine canary create my-canary AWS_IAM_USER \
  --account <ACCOUNT_ID> --logging-id <LOGGING_ID>

# Liste canaries
docker compose exec app coalmine canary list

6. Verifique a Detecção

root@kitploit:~
# Dispare um alerta de teste
docker compose exec app coalmine canary trigger my-canary

# Aguarde o ciclo de monitoramento (~1 min) e depois verifique os alertas
docker compose exec app coalmine alerts list

Arquitetura

root@kitploit:~
┌─────────────┐   ┌─────────────┐   ┌─────────────┐
│     CLI     │   │  REST API   │   │   WebUI     │
│  (coalmine) │   │  (FastAPI)  │   │  (React)    │
└──────┬──────┘   └──────┬──────┘   └──────┬──────┘
       │                 │                 │
       └────────┬────────┴────────┬────────┘
                │                 │
                │          ┌──────▼──────┐
                │          │Auth / RBAC  │
                │          │  (Casbin)   │
                │          └──────┬──────┘
                │                 │
         ┌──────▼─────────────────▼──────┐
         │         Celery Workers        │
         │  (Canary · Monitoring · Logs) │
         └──────────────┬────────────────┘
                        │
      ┌─────────────────┼─────────────────┐
      │                 │                 │
┌─────▼─────┐   ┌──────▼──────┐   ┌──────▼──────┐
│ OpenTofu  │   │  Monitors   │   │Notifications│
│ Templates │   │(CloudTrail/ │   │(Email/Hook/ │
│           │   │ Audit Logs) │   │   Syslog)   │
└─────┬─────┘   └──────┬──────┘   └─────────────┘
      │                │
┌─────▼─────┐   ┌──────▼──────┐
│ AWS / GCP │   │   Alerts    │
│(Resources)│   │    (DB)     │
└───────────┘   └─────────────┘

          ┌─────────────────┐
          │   PostgreSQL    │
          │   (Inventory)   │
          └────────┬────────┘
                   │
          ┌────────▼────────┐
          │   Celery Beat   │
          │   (Scheduler)   │
          └─────────────────┘

Referência da CLI

Os comandos seguem o padrão: coalmine <recurso> <ação> [opções]

Comandos de Canary

ComandoDescrição
canary create <nome> <tipo>Cria um novo canary
canary listLista todos os canaries
canary delete <nome_ou_id>Exclui um canary
canary creds <nome>Obtém as credenciais do canary
canary trigger <nome_ou_id>Testa a detecção do canary

Comandos de Credencial

ComandoDescrição
credentials listLista todas as credenciais
credentials add <nome> <provedor>Adiciona uma credencial
credentials update <nome_ou_id>Atualiza uma credencial
credentials remove <nome_ou_id>Remove uma credencial
credentials validate <nome_ou_id>Valida a saúde da credencial
credentials sync [--dry-run]Sincroniza a partir de configuração YAML

Comandos de Conta

ComandoDescrição
accounts list [--credential <nome>]Lista todas as contas
accounts add <nome>Adiciona uma conta
accounts update <nome_ou_id>Atualiza uma conta
accounts enable <nome_ou_id>Ativa uma conta
accounts disable <nome_ou_id>Desativa uma conta
accounts remove <nome_ou_id>Remove uma conta
accounts validate <nome_ou_id>Valida a saúde da conta

Comandos de Log

ComandoDescrição
logs create <nome> <tipo>Cria recurso de log
logs listLista recursos de log
logs scan --account <id>Escaneia CloudTrails existentes

Comandos de Alerta

ComandoDescrição
alerts list [--canary <nome>]Visualiza alertas de segurança

Comandos de Autenticação

ComandoDescrição
auth key listLista chaves de API
auth key add <nome>Adiciona uma chave de API
auth session listLista sessões ativas

Comandos de Usuário

ComandoDescrição
user listLista todos os usuários
user rolesLista as funções disponíveis

Comandos de Tarefa

ComandoDescrição
task listVisualiza tarefas assíncronas recentes
task status <task_id>Verifica o resultado de uma tarefa

Ajuda

root@kitploit:~
docker compose exec app coalmine --help
docker compose exec app coalmine canary --help

API REST

A API roda em http://localhost:8000 e requer autenticação via cabeçalho de chave de API ou cookie de sessão.

Configuração (config/api_keys.yaml)

root@kitploit:~
api_keys:
  - key: "your-api-key-here"
    name: "admin"
    permissions: ["read", "write"]
    scopes: ["all"]

Exemplos de Requisições

root@kitploit:~
# Listar canaries
curl -H "X-API-Key: your-api-key" http://localhost:8000/api/v1/canaries

# Criar um canary
curl -X POST -H "X-API-Key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"name": "api-canary", "resource_type": "AWS_IAM_USER", "account_id": "...", "logging_id": "..."}' \
  http://localhost:8000/api/v1/canaries

Documentação da API

A documentação interativa da API está disponível em http://localhost:8000/docs (Swagger UI).

Configuração

Toda a configuração fica no diretório config/. Veja config/README.md para detalhes.

Credenciais (config/credentials.yaml)

root@kitploit:~
credentials:
  my-aws-cred:
    provider: AWS
    auth_type: STATIC
    secrets:
      access_key_id: ${AWS_ACCESS_KEY_ID}
      secret_access_key: ${AWS_SECRET_ACCESS_KEY}
      region: ${AWS_DEFAULT_REGION:-us-east-1}
    accounts:
      - name: prod-east
        account_id: "111111111111"

Sincronize com: docker compose exec app coalmine credentials sync

Saídas de Alerta (config/alert_outputs.yaml)

root@kitploit:~
outputs:
  email_admin:
    type: "email"
    enabled: true
    smtp_host: "smtp.example.com"
    smtp_port: 587
    to_addrs: ["[email protected]"]
  
  webhook_siem:
    type: "webhook"
    enabled: true
    url: "https://siem.example.com/webhook"

Tipos de Recurso

TipoProvedorDescrição
AWS_IAM_USERAWSUsuário IAM com chaves de acesso
AWS_BUCKETAWSBucket S3 com logging
GCP_SERVICE_ACCOUNTGCPConta de serviço com chaves
GCP_BUCKETGCPBucket Cloud Storage

Desenvolvimento

root@kitploit:~
# Execute todos os testes
docker compose run --rm app pytest -v

# Execute apenas testes unitários
docker compose run --rm app pytest tests/unit/ -v

# Execute testes de integração
docker compose run --rm app pytest tests/integration/ -v

# Visualize logs do worker
docker compose logs -f worker

# Reconstrua após alterações de código
docker compose build && docker compose up -d

Considerações de Segurança

  • Nunca faça commit de credenciais — Use arquivos .env ou gerenciadores de segredos
  • Rotacione credenciais de administrador — As credenciais em nuvem usadas para gerenciar canaries
  • Isolamento de rede — Execute o Coalmine em um segmento de rede seguro
  • Princípio do menor privilégio — As credenciais canary devem ter permissões mínimas
  • Segurança das chaves de API — Armazene chaves de API de forma segura e rotacione regularmente

Licença

Apache License 2.0 — Consulte o arquivo LICENSE para detalhes.

Contribuição

Consulte CONTRIBUTING.md para diretrizes de contribuição.