<p align="center">
  Node9 scan scorecard
</p>

## Tableau de bord de la posture de sécurité

`node9 posture` évalue le niveau d'exposition de cette machine à un agent compromis — isolation, trafic sortant, secrets sur disque, chaîne d'approvisionnement, privilèges — et vous fournit la commande exacte pour corriger chaque constat.```bash
node9 posture          # scorecard with the #1 risk and a fix for every finding
node9 posture --ship   # send a redacted snapshot to your node9 dashboard (fleet view)

## Analyser un dépôt — sécurité agent-CI

`node9 scan-repo` vérifie tout dépôt (ou dossier local) pour détecter les façons dont un agent IA connecté à GitHub Actions pourrait être **détourné par un tiers** — workflows injectables, secrets accessibles à l'agent, serveurs MCP non épinglés, configuration d'agent trop permissive, et fichiers d'instructions empoisonnés. Analyse statique et uniquement par lecture : il ne lit que la configuration validée, n'exécute jamais le code du dépôt. Aucune installation ni jeton requis pour les dépôts publics.```bash
npx node9-ai scan-repo <owner/repo>   # any public repo, no install
node9 scan-repo .                      # a local checkout — no network
node9 scan-repo <owner/repo> --json    # machine-readable

Ce qu'il vérifie :

| Vérification | Signale                                                                      |
| ------------- | ---------------------------------------------------------------------------- |
| **CI-1**      | config d'agent commitée qui pré-autorise des outils larges ou exécute des hooks distants |
| **CI-2**      | workflows d'agent injectables — un outsider peut déclencher l'agent et le détourner |
| **CI-3**      | serveurs MCP non épinglés / `@latest` ou identifiants en ligne (chaîne d'approvisionnement) |
| **CI-4**      | secrets qu'un agent injecté pourrait exfiltrer                               |
| **CI-6**      | instructions empoisonnées ou dangereuses dans `CLAUDE.md` / `AGENTS.md` / compétences |

**Bloquez chaque PR** — le même moteur qu'une GitHub Action, afin qu'une config détournable ne puisse pas être fusionnée :```yaml
# .github/workflows/agent-security.yml
- uses: node9-ai/node9-proxy@v2
  with:
    fail-on: high # or 'never' to just comment

pip install kitploit

git clone https://github.com/kitploit/kitploit.git
cd kitploit
pip install -r requirements.txt
python setup.py install

docker pull kitploit/kitploit
docker run -it --rm kitploit/kitploit

kitploit --help

kitploit search nmap

kitploit info metasploit

kitploit search "web scanner"
kitploit search --category network
kitploit search --tag exploit

kitploit add https://github.com/example/tool
kitploit remove tool-name
kitploit update

kitploit export --format json
kitploit export --format csv
kitploit export --format markdown

# Example configuration
api:
  base_url: "https://api.kitploit.com"
  timeout: 30
  retries: 3

cache:
  enabled: true
  ttl: 3600

output:
  default_format: "table"
  color: true

git clone https://github.com/kitploit/kitploit.git
cd kitploit
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install -e ".[dev]"

pytest tests/
pytest --cov=kitploit tests/

cd docs
make html

# Create a feature branch
git checkout -b feature/amazing-feature

# Make your changes and commit them
git add .
git commit -m "Add amazing feature"

# Push to your fork
git push origin feature/amazing-feature

# Open a pull request on GitHub

node9 init       # auto-wires all detected agents + MCP servers
node9 login      # connect this machine to your workspace (approve it in the browser)
node9 doctor     # verify everything is wired and reporting
```
Nécessite Node.js 18+.

`init` seul vous offre un contrôle local complet : règles, boucliers, DLP et
approbations fonctionnent tous hors ligne, sur cette machine.

`login` est ce qui connecte la machine à votre tableau de bord. Il affiche un code, ouvre
le navigateur, et vous approuvez la machine là-bas ; si vous n'avez pas encore de compte,
la création de compte en cours de processus vous ramène à la même approbation avec le code
intact. Tant que vous ne l'exécutez pas, tout est appliqué localement mais rien n'atteint
Mission Control, donc le tableau de bord reste vide.

`node9 logout` déconnecte à nouveau une machine. Il révoque la clé de cette machine ;
le contrôle local continue de fonctionner.

## Boucliers — packs de règles organisés

Chaque bouclier est un ensemble de règles organisé pour un service ou un domaine. Activez uniquement ce dont vous avez besoin.

| Bouclier          | Ce qu'il détecte                                                                 | Activation                              |
| ----------------- | ------------------------------------------------------------------------------- | --------------------------------------- |
| `project-jail`    | Bloque les lectures de `~/.ssh`, `~/.aws`, `.env`, identifiants via Bash et l'outil Read | `node9 shield enable project-jail`      |
| `bash-safe`       | `curl \| bash`, `rm -rf /`, écrasement de disque, `eval` de contenu distant     | `node9 shield enable bash-safe`         |
| `postgres`        | `DROP TABLE`, `TRUNCATE`, `DROP COLUMN`, `DELETE` sans `WHERE`                   | `node9 shield enable postgres`          |
| `mongodb`         | `dropDatabase`, `drop()`, `deleteMany({})`, suppressions d'index                 | `node9 shield enable mongodb`           |
| `redis`           | `FLUSHALL`, `FLUSHDB`, `CONFIG SET` sur un serveur en direct                     | `node9 shield enable redis`             |
| `aws`             | Suppression S3, arrêt EC2, modifications IAM, destruction RDS                     | `node9 shield enable aws`               |
| `k8s`             | Suppression de namespace, `helm uninstall`, effacements de rôles de cluster      | `node9 shield enable k8s`               |
| `docker`          | `system prune`, `volume prune`, `rm -f` de conteneurs                            | `node9 shield enable docker`            |
| `github`          | `gh repo delete`, suppression de branche distante, modifications de paramètres   | `node9 shield enable github`            |
| `filesystem`      | `chmod 777`, écritures sous `/etc/`, `/boot/`, `/usr/`                           | `node9 shield enable filesystem`        |
| `mcp-tool-gating` | Outils MCP non approuvés activant silencieusement de nouvelles capacités         | `node9 shield enable mcp-tool-gating`   |```bash
node9 shield list    # show all shields + status
```
## Toujours actif — aucune configuration requise

- **Git** — intercepte `git push --force`, `git reset --hard`, `git clean -fd`
- **SQL** — intercepte `DELETE` / `UPDATE` sans `WHERE`, `DROP TABLE`, `TRUNCATE`
- **Shell** — intercepte `curl | bash`, `sudo` non autorisé
- **DLP** — signale les clés AWS, les jetons GitHub, les clés Stripe, les clés privées PEM dans tout argument d'outil, contenu de fichier ou configuration shell (`~/.zshrc`, `~/.bashrc`)
- **DLP de réponse** — un analyseur en arrière-plan lit l'historique de conversation de Claude et vous alerte si Claude a _écrit_ un secret dans son texte de réponse
- **Épinglage des compétences** — vérification SHA-256 des compétences / plugins Claude installés entre les sessions

## Invites de révision — approuvez en ligne, dans votre agent

Lorsque node9 signale une action pour **révision** (par ex. `git push --force`, un `DROP TABLE`), l'invite d'approbation/refus s'affiche **en ligne dans la conversation de l'agent** — aucune session figée, aucun terminal séparé, aucune course contre le délai d'expiration du hook. node9 exécute toujours l'évaluateur complet et prend la décision ; seule la _surface_ de l'invite se déplace vers l'agent.

- **Activé par défaut** pour **Claude Code** et **GitHub Copilot CLI** — les agents dont le contrat de hook prend en charge un `ask` natif. Tous les autres agents (Codex, Gemini, Antigravity, Hermes, Cursor, OpenCode, Pi) utilisent l'approbateur propre à node9.
- **Contrôlez-le** avec `reviewChannel` dans `~/.node9/config.json` (ou `--no-ask` sur le hook) :```jsonc
{
  "settings": {
    "reviewChannel": "ask", // "ask" = inline agent prompt (default) | "approver" = node9's own approver
  },
}
```
- **Configurations d’équipe :** lorsqu’un approbateur cloud/équipe est configuré (`approvers.cloud: true`), les revues sont routées vers cet approbateur à la place — node9 ne laissera pas une auto-approbation en ligne contourner une approbation routée/de seconde partie.

## Sandbox — exécuter un agent dans une cage

Lorsque la surveillance ne suffit pas, **`node9 sandbox`** exécute l’agent dans un conteneur jetable avec une **liste blanche de sortie appliquée par le noyau** et des **montages limités** — tandis que les hooks de node9 gouvernent et auditent chaque appel d’outil _à l’intérieur_ de la boîte. La version dure de la protection : l’agent ne peut toucher que le dossier que vous montez et atteindre les hôtes que vous autorisez ; tout le reste est abandonné au niveau du noyau.```bash
cd ~/my-project
node9 sandbox new        # write node9.sandbox.yaml — what to mount + which hosts to allow
node9 sandbox run        # build + boot the jailed agent (your project at /workspace)
node9 sandbox tail       # watch the agent's actions live, from the host
```
- **Jetable** — le conteneur est détruit à la sortie ; vos modifications de projet atterrissent sur votre disque réel, rien d'autre ne survit.
- **Même politique** — vos règles de shields / egress / approbations existantes s'appliquent dans la boîte, diffusées vers le même journal d'audit et le même tableau de bord.
- **Ferme la boucle de posture** — son exécution fait passer les findings Isolation / Egress au vert.

Périmètre honnête (Phase 1) : conteneur unique, **Claude d'abord** (Codex ensuite) ; l'agent conserve toujours ses _propres_ identifiants dans la boîte (le mur egress les confine aux hôtes autorisés) — _"l'agent ne détient jamais de secret"_ est la phase de courtier d'identifiants sur la feuille de route. Nécessite Docker.

## Passerelle MCP

Enveloppez n'importe quel serveur MCP de manière transparente. L'agent voit le même serveur — Node9 intercepte chaque appel d'outil.```json
{
  "mcpServers": {
    "postgres": {
      "command": "node9",
      "args": ["mcp", "--upstream", "npx -y @modelcontextprotocol/server-postgres postgresql://..."]
    }
  }
}
```
Ou lancez simplement `node9 init` — il enveloppe automatiquement vos serveurs MCP existants.

<details>
<summary><strong>🔐 Épinglage des outils MCP — défense contre les retraits de tapis</strong></summary>

Les serveurs MCP peuvent modifier leurs définitions d'outils entre les sessions. Un serveur compromis ou malveillant pourrait silencieusement ajouter, supprimer ou modifier des outils après que vous lui ayez fait confiance initialement — une attaque par **retrait de tapis**.

Node9 épingle les définitions d'outils lors de la première utilisation :

1. **Première connexion** — la passerelle enregistre un hachage SHA-256 du nom, de la description et du schéma de chaque outil
2. **Connexions ultérieures** — le hachage est comparé ; si les outils ont changé, la session est **mise en quarantaine** et chaque appel d'outil est bloqué jusqu'à ce qu'un humain examine et approuve le changement
3. **État d'épingle corrompu** — échec en mode fermé (blocage), jamais de re-confiance silencieuse```bash
node9 mcp pin list                # show all pinned servers and hashes
node9 mcp pin update <serverKey>  # remove pin, re-pin on next connection
node9 mcp pin reset               # clear all pins
```
</details>

## Autres commandes

Au-delà des trois commandes de flux ci-dessus (`scan` / `monitor` / `report`) :

| Commande          | Ce qu'elle affiche                                             | Quand l'utiliser                             |
| ---------------- | --------------------------------------------------------- | --------------------------------------- |
| `node9 blast`    | Ce qu'un agent IA peut atteindre à l'instant — fichiers, identifiants, variables d'environnement | Première chose à exécuter sur toute machine       |
| `node9 tail`     | Flux en direct de chaque appel d'outil (texte uniquement, sans TUI)        | Pour rediriger vers d'autres outils, CI, journaux       |
| `node9 sessions` | Historique des sessions avec invite, trace d'outil et coût         | Pour examiner une passation ou un travail passé        |
| `node9 dlp`      | Résultats de fuite d'identifiants dans le texte de réponse de Claude          | À chaque fois qu'une alerte DLP du bureau se déclenche      |
| `node9 mask`     | Masquer les secrets en clair des fichiers d'historique de session locaux | Après un résultat DLP — nettoie le disque local |

Plus un **HUD en direct** dans la barre d'état de votre Claude Code :```
🛡 node9 | standard | [bash-safe] | ✅ 12 allowed  🛑 2 blocked  🚨 0 dlp | ~$0.43
📊 claude-opus-4-7 | ctx [████████░░░] 54% | 5h [██░░░░░░░░] 12% | 7d [█░░░░░░░] 7%
🗂 2 CLAUDE.md | 8 rules | 3 MCPs | 4 hooks
```
## Lecture des données — ce que signifient les chiffres

Node9 fait remonter le signal. Voici les schémas à connaître :

| Signal                                         | Signification probable                                                                             |
| ---------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| `Would have blocked` ≥ 5 en une semaine        | L'agent tente des opérations à fort impact ; les boucliers méritent d'être revus                   |
| Une seule règle `review-git-push` >50% des résultats | Votre propre règle se déclenche comme prévu — pas un risque, juste une supervision                 |
| Résultat DLP dans l'outil `user-prompt`        | Vous avez collé un secret dans votre propre invite — faites pivoter la clé                          |
| Boucle d'agent ×50+ sur le même fichier        | L'agent est bloqué dans un cycle édition/test/correction — vérifiez le contexte ou ralentissez     |
| Inadéquation de l'épingle d'outil MCP          | Le serveur a modifié ses outils — examinez avant de refaire confiance                              |
| Avertissement de réponse MCP volumineuse       | Ce serveur gonfle votre fenêtre de contexte à chaque tour suivant                                  |
| Alerte `Response DLP`                          | Claude a écrit un secret dans son texte de réponse — non bloqué, faites pivoter immédiatement      |
| Résultat DLP dans `tool-result`                | Claude a lu un fichier contenant un secret (`.env`, identifiants) — faites pivoter la clé et exécutez `node9 mask` |
| Résultat DLP dans `[Shell]`                    | Secret en clair dans `~/.zshrc` ou `~/.bashrc` — chaque session IA peut le voir                    |

Les signaux ponctuels sont normaux ; ce sont les schémas persistants sur lesquels vous agissez.

## SDK Python — gouvernez n'importe quel agent Python```python
from node9 import configure, protect

configure(agent_name="my-agent", policy="require_approval")

@protect("bash")
def run_command(cmd: str) -> str:
    ...
```
**[Python SDK →](https://github.com/node9-ai/node9-python)** · **[Exemple d'agent de revue de code CI →](https://github.com/node9-ai/node9-pr-agent)**

## Sous le capot

- **Scan** lit l'historique brut des agents depuis `~/.claude/projects/`, `~/.gemini/tmp/`, `~/.gemini/antigravity-*/brain/`, `~/.copilot/session-state/`, `~/.codex/sessions/` — aucun appel API, entièrement hors ligne
- **Runtime** intercepte les appels d'outils via des hooks de pré-exécution (Claude Code, Codex, Antigravity, GitHub Copilot CLI, Gemini CLI, Opencode, Pi) ou via la passerelle MCP (Cursor, Windsurf, VSCode, Claude Desktop). Toutes les décisions aboutissent dans `~/.node9/audit.log` de manière atomique.
- **Passerelle MCP** est un proxy stdio ; elle intercepte `tools/list` + `tools/call` JSON-RPC, et transmet le reste
- **Moteur de politiques** utilise [mvdan-sh](https://github.com/mvdan/sh) pour l'analyse AST bash — il neutralise l'obfuscation via l'échappement par antislash, la substitution de variables, l'évaluation de téléchargements distants
- **Sandbox** génère un Dockerfile + point d'entrée qui scellent un mur de sortie `ipset`/`iptables` refusant tout par défaut, puis bascule vers un agent non-root avec le démon et les hooks de node9 exécutés à l'intérieur ; seul le fichier d'identifiants de l'agent est monté, jamais tout votre `~/.claude`

## Documentation complète

Référence de configuration, règles intelligentes, règles avec état, hôtes de confiance, modes d'approbation, référence CLI — sur **[node9.ai/docs](https://node9.ai/docs)**.

## Projets associés

- **[node9-python](https://github.com/node9-ai/node9-python)** — SDK Python
- **[node9-pr-agent](https://github.com/node9-ai/node9-pr-agent)** — Action GitHub qui examine les PR via Node9

## Entreprise

**Node9 Pro** ajoute le verrouillage de gouvernance, SAML/SSO, l'export d'audit centralisé et le déploiement VPC. Voir [node9.ai](https://node9.ai).

## Licence

Apache-2.0

<p align="center">
  <sub>Conçu avec ☕ et une paranoïa saine.</sub>
</p>