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
clawshield-public — Proxy de sécurité pour agents IA. Analyse chaque message à la recherche d'injections de prompts, de données personnelles (PII) et de secrets. Défense en profondeur : proxy Go + pare-feu iptables + moniteur noyau eBPF. Moteur de politiques YAML, journalisation d'audit, 5 agents IA avec bases de connaissances RAG. | Kitploit
Outils/GitHubGitHub/sleuthco/clawshield-public
Outils DéfensifsScanners de VulnérabilitésSécurité WebSécurité RéseauDétection de SecretsDétection d'IntrusionSécurité des APISécurité de l'IAAnalyse de Journaux
GitHubsleuthco/clawshield-public

clawshield-public

Voir le dépôt
130184il y a 5 moisVérifié par Kitploit

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 →

À propos

Proxy de sécurité pour agents IA. Analyse chaque message à la recherche d'injections de prompts, de données personnelles (PII) et de secrets. Défense en profondeur : proxy Go + pare-feu iptables + moniteur noyau eBPF. Moteur de politiques YAML, journalisation d'audit, 5 agents IA avec bases de connaissances RAG.

Partager

ClawShield

Proxy de sécurité pour agents IA. Se place devant OpenClaw et analyse chaque message à la recherche d'injections de prompts, de fuites de données personnelles et de secrets — avant qu'ils n'atteignent le modèle ou ne quittent le réseau.

Livré avec 5 agents IA spécialisés, un tableau de bord intégré et un moteur de politiques YAML. Une seule commande pour démarrer.

root@kitploit:~
┌──────────────┐     ┌──────────────────┐     ┌──────────────┐
│   Browser    │────▶│  ClawShield      │────▶│   OpenClaw   │
│   (you)      │◀────│  Security Proxy  │◀────│   Gateway    │
└──────────────┘     └──────────────────┘     └──────────────┘
                      ▪ Prompt injection       ▪ Claude, GPT,
                        detection                LM Studio
                      ▪ PII/secrets redaction  ▪ Multi-agent
                      ▪ Policy enforcement       routing
                      ▪ Audit logging          ▪ RAG knowledge

Démarrage rapide (Docker)

Prérequis : Docker et une clé API Anthropic.

root@kitploit:~
# 1. Clone the repo
git clone https://github.com/SleuthCo/clawshield-public.git
cd clawshield-public

# 2. Set your API key
cp standalone/.env.template standalone/.env
# Edit standalone/.env and paste your Anthropic API key

# 3. Start
cd standalone
docker compose up -d

Ouvrez http://localhost:18801 dans votre navigateur. Vous verrez le tableau de bord ClawShield avec 5 agents IA prêts à discuter.

Et voilà. ClawShield analyse tout le trafic entre vous et les agents.

Obtenir une clé API Anthropic

ClawShield utilise Claude (via l'API d'Anthropic) comme modèle de langage par défaut. Voici comment obtenir votre clé :

  1. Rendez-vous sur console.anthropic.com et inscrivez-vous (ou connectez-vous)
  2. Cliquez sur API Keys dans la barre latérale gauche
  3. Cliquez sur Create Key
  4. Donnez-lui un nom (par exemple, « clawshield ») et cliquez sur Create
  5. Copiez la clé — elle commence par sk-ant-
  6. Collez-la dans votre fichier standalone/.env :
    root@kitploit:~
    ANTHROPIC_API_KEY=sk-ant-your-key-here

Coût : Anthropic facture au token. Une session de chat typique coûte quelques cents. Les nouveaux comptes reçoivent 5 $ de crédits gratuits. Voir anthropic.com/pricing pour plus de détails.

Vous utilisez un autre modèle ? ClawShield fonctionne avec toute API compatible OpenAI (GPT, LM Studio, Ollama, etc.). Modifiez standalone/config/openclaw.json pour pointer vers votre fournisseur préféré.

Options d'installation

Option 1 : Docker (recommandé)

Tout s'exécute dans un seul conteneur — proxy ClawShield + passerelle OpenClaw + 5 agents.

Voir Démarrage rapide ci-dessus.

Option 2 : Binaires précompilés

Téléchargez la dernière version depuis GitHub Releases :

PlateformeFichier
Windowsclawshield-proxy-windows-amd64.exe
Linux x64clawshield-proxy-linux-amd64
Linux ARM64clawshield-proxy-linux-arm64
macOS Apple Siliconclawshield-proxy-darwin-arm64
macOS Intelclawshield-proxy-darwin-amd64

Exécutez ensuite l'assistant d'installation interactif :

root@kitploit:~
# Download the setup wizard too
chmod +x clawshield-setup-*

# Run the wizard — it walks you through everything
./clawshield-setup-linux-amd64

L'assistant va :

  • Demander votre clé API Anthropic
  • Configurer vos agents
  • Générer la configuration OpenClaw
  • Créer les scripts de démarrage/arrêt

Option 3 : Compiler depuis les sources

Nécessite Go 1.24+.

root@kitploit:~
git clone https://github.com/SleuthCo/clawshield-public.git
cd clawshield-public

# Build the proxy
cd proxy/cmd/clawshield-proxy
go build -o clawshield-proxy

# Build the setup wizard
cd ../../clawshield-setup
go build -o clawshield-setup

# Run setup
./clawshield-setup

Ce qui est inclus

Observabilité

ClawShield expose un point de terminaison /metrics compatible Prometheus pour une surveillance en temps réel :

root@kitploit:~
curl http://localhost:18789/metrics

Métriques clés :

  • clawshield_requests_total — Total des requêtes évaluées
  • clawshield_decisions_allowed_total / _denied_total / _redacted_total — Résultats des décisions
  • clawshield_scanner_detections_total{scanner,action} — Détections par type de scanner
  • clawshield_evaluation_duration_seconds — Histogramme de latence d'évaluation
  • clawshield_active_connections — Connexions WebSocket actuelles
  • clawshield_crosslayer_events_* — Activité du bus d'événements inter-couches

Proxy de sécurité

Le cœur de ClawShield. Un proxy inverse HTTP qui intercepte tout le trafic entre les utilisateurs et la passerelle IA.

Scanners (chacun produit des enregistrements d'audit forensique structurés avec des identifiants de règle et des extraits de correspondance expurgés) :

  • Détection d'injection de prompts — bloque les tentatives de jailbreak, l'écrasement d'instructions, la manipulation de rôle
  • Expurgation des données personnelles — détecte et expurge les e-mails, numéros de téléphone, SSN, cartes bancaires
  • Détection de secrets — intercepte les clés API, jetons et mots de passe avant qu'ils ne fuient
  • Analyse de vulnérabilités — signale l'injection SQL, les SSRF, le path traversal, l'injection de commandes, les XSS
  • Analyse de malwares — détecte les exécutables, scripts, bombes d'archive et signatures connues

Durcissement en production (couche 3) :

  • Moniteur eBPF natif en Go remplaçant la dépendance Python/BCC — un seul binaire compilé
  • Dégradation gracieuse : repli automatique sur l'interrogation de /proc lorsque eBPF est indisponible (pas de CAP_BPF, noyau ancien, conteneurs)
  • Système de vérification de santé : rapport d'état par couche (sain/dégradé/hors service) pour les 3 couches de défense
  • Fiabilité du pipeline d'événements : comptage des pertes, journalisation de la contre-pression, métriques des événements publiés/abandonnés
  • Re-résolution DNS dynamique pour les règles de pare-feu — évite les règles obsolètes lorsque les IP des CDN changent
  • Détection des capacités au démarrage : version du noyau, prise en charge de BTF, vérification root/CAP_BPF

Rechargement à chaud des politiques :

  • Rechargement à chaud basé sur la surveillance de fichiers — modifiez policy.yaml et les changements prennent effet en moins de 5 secondes, sans redémarrage
  • Versionnage par empreinte de contenu — chaque version de politique reçoit un identifiant de version basé sur SHA256, enregistré dans les journaux d'audit
  • Mode shadow/canary — testez les nouvelles politiques en mode journalisation seule avant de les appliquer
  • Diff de politique — chaque rechargement journalise exactement ce qui a changé (ajouts à la liste autorisée, activation/désactivation de scanners, etc.)
  • Bascule atomique — les requêtes en cours continuent avec l'ancienne politique, les nouvelles requêtes utilisent la nouvelle politique

Analyse des réponses en streaming :

  • Analyse en temps réel, segment par segment, des flux SSE et NDJSON — aucun délai de mise en mémoire tampon
  • Fenêtre de chevauchement glissante (200 caractères) détecte les motifs à cheval sur les limites des segments
  • Le report du contexte de la requête vers la réponse réduit les faux positifs (par exemple, les réponses de génération de code peuvent contenir des motifs de script)
  • Expurgation par segment des secrets et des données personnelles dans la sortie en streaming

Moteur de politiques — basé sur YAML, refus par défaut :

root@kitploit:~
default_action: deny

scanners:
  prompt_injection:
    enabled: true
    action: block
  pii:
    enabled: true
    action: redact
  secrets:
    enabled: true
    action: block

domain_allowlist:
  - "api.anthropic.com"
  - "api.openai.com"

Voir policy/examples/ pour plus d'exemples.

5 agents IA

Chaque agent a un rôle spécialisé et sa propre base de connaissances RAG :

AgentRôleConnaissances
AnvilDéveloppement logicielLangages, architecture, DevOps, tests, codage sécurisé
ShieldIngénierie de la sécuritéNIST, MITRE ATT&CK, OWASP, zéro confiance, modélisation des menaces
HarborIngénierie cloudAWS, Azure, GCP, Kubernetes, IaC, réseaux
BeaconCommunicationsCommunication de crise, stratégie de contenu, briefings exécutifs
LensRecherche et analyseOSINT, analyse structurée, biais cognitifs, renseignement

Journalisation d'audit

Chaque requête et réponse est journalisée dans une base SQLite locale avec :

  • Horodatage, IP source, méthode de requête
  • Décisions des scanners (autoriser/bloquer/expurger) avec motifs
  • Explicabilité des décisions — détail forensique structuré pour chaque décision de refus/expurgation, incluant quel scanner a déclenché, quelle règle a correspondu, un extrait expurgé en toute sécurité de la correspondance, et le niveau de confiance
  • Charges utiles (payloads) complètes des requêtes/réponses (configurable)
  • Interrogation via le CLI d'audit intégré :
root@kitploit:~
clawshield-audit --db /var/lib/clawshield/audit.db --last 50
clawshield-audit --db /var/lib/clawshield/audit.db --blocked-only
clawshield-audit --db /var/lib/clawshield/audit.db --scanner injection
clawshield-audit --db /var/lib/clawshield/audit.db --rule-id sqli

Voir docs/audit-log-format.md pour le schéma complet et Explicabilité des décisions pour les détails des requêtes forensiques.

Intégration SIEM :

  • Transmission en temps réel des événements de sévérité Critique et Élevée vers les systèmes SIEM d'entreprise
  • Format Detection Finding OCSF v1.1 pour une compatibilité SIEM universelle
  • Transports Syslog (RFC 5424 sur TCP/TLS) et webhook (POST HTTPS)
  • Seuil de sévérité configurable — par défaut, ne transmet que les alertes Élevée (4) et Critique (5)
  • Voir docs/audit-log-format.md pour la configuration

Pare-feu réseau (optionnel)

Pare-feu de sortie basé sur iptables qui restreint les domaines/IP que les agents peuvent joindre :

root@kitploit:~
cd firewall/cmd/clawshield-fw && go build -o clawshield-fw
sudo ./clawshield-fw apply --config firewall/examples/firewall.yaml

Moniteur eBPF (optionnel)

Surveillance des appels système au niveau du noyau pour détecter les comportements suspects des agents :

root@kitploit:~
sudo python3 ebpf/cmd/clawshield-ebpf/main.py --config ebpf/config/default.yaml

Détecte : les fork bombs, l'accès aux fichiers sensibles, l'élévation de privilèges, les connexions réseau anormales.

Architecture

ClawShield utilise une défense en profondeur — trois couches de sécurité reliées par un bus d'événements inter-couches :

root@kitploit:~
Layer 1: Application (ClawShield Proxy)
  ▪ Scans message content
  ▪ Enforces YAML policies
  ▪ Logs all decisions

Layer 2: Network (ClawShield Firewall)
  ▪ iptables egress rules
  ▪ Domain/IP allowlist
  ▪ Blocks unapproved connections
  ▪ Dynamic temporary rules from cross-layer events

Layer 3: Kernel (ClawShield eBPF)
  ▪ Syscall monitoring
  ▪ Behavioral anomaly detection
  ▪ Real-time alerts

Chaque couche fonctionne indépendamment. Si l'une est contournée, les autres continuent de protéger.

Bus d'événements inter-couches

Les trois couches communiquent via un bus d'événements basé sur une socket Unix, permettant des réponses de sécurité adaptatives entre les couches :

root@kitploit:~
┌──────────────┐                          ┌──────────────┐
│  eBPF        │──── Unix Socket ────────▶│  Proxy       │
│  (Layer 3)   │  /tmp/clawshield-       │  (Layer 1)   │
│  Produces:   │   events.sock           │  Produces:   │
│  • privesc   │                          │  • injection │
│  • port_scan │◀── Adaptive Controller ──│  • malware   │
│  • file_access│                         │  • vuln_scan │
└──────────────┘                          └──────────────┘
                         │
                         ▼
                ┌──────────────┐
                │  Firewall    │
                │  (Layer 2)   │
                │  Consumes:   │
                │  • temp block│
                │    rules     │
                └──────────────┘

Exemples de réactions adaptatives :

DéclencheurRéponse automatique
eBPF détecte une élévation de privilègesLe proxy élève la sensibilité d'injection à high pendant 5 min
eBPF détecte un scan de portsLe proxy restreint l'accès aux domaines pendant 10 min
Le proxy bloque 3+ injections en 60 sL'action par défaut est forcée à deny pendant 15 min
Le proxy détecte un malware dans une réponseLe pare-feu ajoute des règles temporaires de blocage d'IP

Activez l'intégration inter-couches en ajoutant une section adaptive à votre YAML de politique. Voir policy/examples/adaptive_crosslayer.yaml pour un exemple complet.

Déploiement en production

Pour un déploiement sur un serveur réel avec TLS, voir docs/install-guide.md.

Le répertoire deploy/ contient :

  • cloud-init.yaml — Provisionnement de VM durci (verrouillage SSH, fail2ban, nftables, auditd)
  • docker-compose.yml — Stack de production complète avec terminaison TLS nginx
  • nginx/conf.d/ — Configurations nginx de production avec limitation de débit, en-têtes de sécurité, proxy WebSocket
  • deploy.sh — Script de déploiement automatisé
  • smoke-test.sh — Vérification post-déploiement

Configuration

Variables d'environnement

VariableObligatoireDescription
ANTHROPIC_API_KEYOuiVotre clé API Anthropic (sk-ant-...)
GATEWAY_AUTH_TOKENNonJeton d'authentification partagé (généré automatiquement s'il est omis)
CLAWSHIELD_PORTNonPort hôte (défaut : 18801)
CLAWSHIELD_STUDIO_URLNonURL de base des liens profonds Studio

Fichiers

FichierDescription
standalone/config/openclaw.jsonConfiguration de la passerelle OpenClaw (modèles, agents, authentification)
standalone/config/policy.yamlPolitique de sécurité ClawShield
standalone/agents/*/Configurations des agents et bases de connaissances

Tests

root@kitploit:~
# Unit tests
go test ./proxy/...
go test ./firewall/...

# Integration tests
go test ./integration/...

Contribution

Les issues et pull requests sont les bienvenues sur github.com/SleuthCo/clawshield-public.

Licence

Apache 2.0

Remerciements

Construit sur OpenClaw. Inspiré par les architectures de sécurité réseau traditionnelles appliquées aux contextes d'agents IA.

Télécharger l’outil