Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
coalmine — Plateforme de gestion d'orchestration d'objets Cloud Canary | Kitploit
Outils/GitHubGitHub/johnearle/coalmine
Outils DéfensifsSécurité CloudGestion des Identités et des Accès (IAM)Détection d'IntrusionRéponse aux Incidents
GitHubjohnearle/coalmine

coalmine

Plateforme de gestion d'orchestration d'objets Cloud Canary

Voir le dépôt
82il y a 6 moisPas encore vérifié

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

Coalmine — Gestion des jetons leurres

Gestion cloud des jetons leurres — Déployez, surveillez et faites pivoter des identifiants trompeurs sur AWS et GCP pour détecter les accès non autorisés.

License

[!WARNING] Version Alpha — Coalmine est en développement précoce. Les fonctionnalités de base sont la priorité actuelle, et l'application ne doit pas être considérée comme entièrement testée en sécurité pour une utilisation en production.

Statut

FonctionnelDéveloppement (Instable)À faire
AWS IAM User CanariesGCP Service Account CanariesSupport Azure
AWS S3 Bucket CanariesGCP Bucket CanariesIntégration SIEM
Surveillance CloudTrailSurveillance des journaux d'audit GCP
Backend d'état PostgreSQLRotation automatique
API REST (Clé API + Authentification par session)
Tableau de bord WebUI
Alertes Email & Webhook
Gestion des identifiants et des comptes
RBAC (Casbin)

Aperçu

Coalmine déploie et surveille automatiquement des « jetons leurres » — des identifiants et ressources leurres qui déclenchent des alertes en cas d'accès par des attaquants.

Fournisseurs supportés :

  • AWS : Utilisateurs IAM, Buckets S3
  • GCP : Comptes de service, Buckets Cloud Storage

Fonctionnalités

  • Support multi-cloud — AWS et GCP depuis une interface unique
  • Modèle d'identifiants et de comptes — Gérez les identifiants et comptes cloud via CLI, API ou synchronisation YAML
  • Rotation automatique — Les identifiants tournent à intervalles configurables
  • Surveillance centralisée — Intégration CloudTrail et journaux d'audit GCP
  • Alerting flexible — Notifications par Email, Webhook et Syslog
  • Infrastructure as Code — Ressources gérées par OpenTofu
  • API REST — Accès programmatique avec clé API ou authentification par session
  • WebUI — Tableau de bord basé navigateur à /ui
  • RBAC — Contrôle d'accès basé sur les rôles via Casbin
  • CLI — Structure de sous-commandes groupées (coalmine <ressource> <action>)

Démarrage rapide

Prérequis

  • Docker & Docker Compose
  • Identifiants AWS (pour les canaris AWS)
  • Identifiants GCP (pour les canaris GCP)

1. Cloner et configurer

root@kitploit:~
git clone https://github.com/yourorg/coalmine.git
cd coalmine
cp .env.example .env
# Modifiez .env avec vos identifiants de base de données et cloud

2. Démarrer les services

root@kitploit:~
docker compose up -d

Cela démarre l'API, le worker Celery, Redis et PostgreSQL. Le WebUI est disponible à http://localhost:8000/ui.

3. Enregistrer les identifiants et comptes

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

# Ajouter un compte sous cet identifiant
docker compose exec app coalmine accounts add prod-east --credential my-aws-cred \
  --account-id 111111111111

# Ou synchroniser les identifiants et comptes depuis un fichier YAML
docker compose exec app coalmine credentials sync --dry-run

4. Créer une ressource de journalisation

root@kitploit:~
# Créer une destination de journalisation CloudTrail
docker compose exec app coalmine logs create my-trail AWS_CLOUDTRAIL \
  --account <ACCOUNT_ID>

# Lister les ressources de journalisation
docker compose exec app coalmine logs list

5. Déployer un canari

root@kitploit:~
# Créer un canari AWS IAM User
docker compose exec app coalmine canary create my-canary AWS_IAM_USER \
  --account <ACCOUNT_ID> --logging-id <LOGGING_ID>

# Lister les canaris
docker compose exec app coalmine canary list

6. Vérifier la détection

root@kitploit:~
# Déclencher une alerte de test
docker compose exec app coalmine canary trigger my-canary

# Attendre le cycle de surveillance (~1 min) puis vérifier les alertes
docker compose exec app coalmine alerts list

Architecture

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)   │
          └─────────────────┘

Référence CLI

Les commandes suivent le modèle : coalmine <ressource> <action> [options]

Commandes Canari

Commandes Identifiants

Commandes Comptes

Commandes Journalisation

CommandeDescription
logs create <name> <type>Créer une ressource de journalisation
logs listLister les ressources de journalisation
logs scan --account <id>Analyser les CloudTrails existants

Commandes Alertes

CommandeDescription
alerts list [--canary <name>]Afficher les alertes de sécurité

Commandes Authentification

CommandeDescription
auth key listLister les clés API
auth key add <name>Ajouter une clé API
auth session listLister les sessions actives

Commandes Utilisateur

CommandeDescription
user listLister tous les utilisateurs
user rolesLister les rôles disponibles

Commandes Tâche

CommandeDescription
task listAfficher les tâches asynchrones récentes
task status <task_id>Vérifier le résultat d'une tâche

Aide

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

API REST

L'API tourne sur http://localhost:8000 et nécessite une authentification via en-tête de clé API ou cookie de session.

Configuration (config/api_keys.yaml)

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

Exemples de requêtes

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

# Créer un canari
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

Documentation de l'API

La documentation interactive de l'API est disponible à http://localhost:8000/docs (Interface Swagger).

Configuration

Toute la configuration réside dans le répertoire config/. Voir config/README.md pour plus de détails.

Identifiants (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"

Synchroniser avec : docker compose exec app coalmine credentials sync

Sorties d'alerte (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"

Types de ressources

Développement

root@kitploit:~
# Exécuter tous les tests
docker compose run --rm app pytest -v

# Exécuter uniquement les tests unitaires
docker compose run --rm app pytest tests/unit/ -v

# Exécuter les tests d'intégration
docker compose run --rm app pytest tests/integration/ -v

# Voir les logs du worker
docker compose logs -f worker

# Reconstruire après des modifications de code
docker compose build && docker compose up -d

Considérations de sécurité

  • Ne jamais commit les identifiants — Utilisez des fichiers .env ou des gestionnaires de secrets
  • Faire pivoter les identifiants administrateur — Les identifiants cloud utilisés pour gérer les canaris
  • Isolement réseau — Exécutez Coalmine dans un segment réseau sécurisé
  • Principe du moindre privilège — Les identifiants des canaris doivent avoir des permissions minimales
  • Sécurité des clés API — Stockez les clés API de manière sécurisée, faites-les pivoter régulièrement

Licence

Licence Apache 2.0 — Voir le fichier LICENSE pour plus de détails.

Contribuer

Voir CONTRIBUTING.md pour les directives de contribution.

Télécharger l’outil
CommandeDescription
canary create <name> <type>Créer un nouveau canari
canary listLister tous les canaris
canary delete <name_or_id>Supprimer un canari
canary creds <name>Obtenir les identifiants du canari
canary trigger <name_or_id>Tester la détection du canari
CommandeDescription
credentials listLister tous les identifiants
credentials add <name> <provider>Ajouter un identifiant
credentials update <name_or_id>Mettre à jour un identifiant
credentials remove <name_or_id>Supprimer un identifiant
credentials validate <name_or_id>Valider l'état de santé de l'identifiant
credentials sync [--dry-run]Synchroniser depuis la configuration YAML
CommandeDescription
accounts list [--credential <name>]Lister tous les comptes
accounts add <name>Ajouter un compte
accounts update <name_or_id>Mettre à jour un compte
accounts enable <name_or_id>Activer un compte
accounts disable <name_or_id>Désactiver un compte
accounts remove <name_or_id>Supprimer un compte
accounts validate <name_or_id>Valider l'état de santé du compte
TypeFournisseurDescription
AWS_IAM_USERAWSUtilisateur IAM avec clés d'accès
AWS_BUCKETAWSBucket S3 avec journalisation
GCP_SERVICE_ACCOUNTGCPCompte de service avec clés
GCP_BUCKETGCPBucket Cloud Storage