
Un runtime sécurisé* pour les agents IA autonomes. Politique à partir de constitutions en anglais simple. (*https://ironcurtain.dev)
# IronCurtain
[](https://github.com/provos/ironcurtain/actions/workflows/ci.yml)
[](https://www.npmjs.com/package/@provos/ironcurtain)
[](LICENSE)
[](https://ironcurtain.dev)
**Un environnement d'exécution sécurisé\* pour agents IA autonomes, où la politique de sécurité est dérivée d'une constitution lisible par un humain.**
_\*Quand quelqu'un écrit « sécurisé », vous devriez immédiatement être sceptique. [Qu'entendons-nous par sécurisé ?](https://ironcurtain.dev)_
> [!WARNING]
> **Prototype de recherche.** IronCurtain est un projet de recherche à un stade précoce qui explore comment rendre les agents IA suffisamment sûrs pour être réellement utiles. Les API, les formats de configuration et l'architecture peuvent changer. Les contributions et les retours sont les bienvenus.
## Démo
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/42102/cf5f5cc847e63acad65eccf1c7fb33bacd782a5d592249cfea60e5f32830ac07.gif" alt="Démo du mux IronCurtain : une entrée de confiance depuis le mode commande permet l'approbation automatique de git clone et git push" width="800">
</p>
Il est demandé à l'agent de cloner un dépôt et de pousser des modifications. `git_clone` et `git_push` sont tous deux escaladés par le moteur de politique, mais l'approbateur automatique les approuve automatiquement — l'entrée de confiance de l'utilisateur depuis le mode commande (Ctrl-A) fournissait une intention claire, donc aucune commande manuelle `/approve` n'a été nécessaire.
## Le problème
Les agents IA autonomes peuvent gérer des fichiers, exécuter des commandes git, envoyer des messages et interagir avec des API en votre nom. Mais les frameworks d'agents actuels accordent à l'agent les mêmes privilèges que l'utilisateur, tels qu'un accès complet au système de fichiers, aux identifiants et au réseau. Les chercheurs en sécurité appellent cela l'**autorité ambiante**, et cela signifie qu'une seule injection de prompt ou une dérive sur plusieurs tours peut amener un agent à supprimer des fichiers, exfiltrer des données ou pousser du code malveillant.
La réponse courante consiste soit à restreindre les agents à un bac à sable étroit (limitant leur utilité), soit à demander à l'utilisateur d'approuver chaque action (limitant leur autonomie). Aucune des deux n'est satisfaisante.
## L'approche
IronCurtain emprunte une voie différente : **exprimez votre intention de sécurité en anglais courant, puis laissez le système déterminer l'application.**
Vous rédigez une **constitution**, un court document décrivant ce que votre agent est et n'est pas autorisé à faire. IronCurtain compile ce document en une politique de sécurité déterministe à l'aide d'un pipeline LLM, valide les règles compilées par rapport à des scénarios de test générés, puis applique la politique à l'exécution à chaque appel d'outil. Le résultat est un agent capable de travailler de manière autonome dans les limites que vous définissez en langage naturel.
Les idées clés :
- **L'agent n'est pas digne de confiance.** IronCurtain suppose que le LLM peut être compromis par une injection de prompt ou une dérive. La sécurité ne dépend pas du fait que le modèle « se comporte bien ».
- **L'intention en anglais, l'application en sortie.** Vous écrivez l'intention (« aucune opération git destructive sans approbation ») ; le système la compile en règles déterministes qui sont appliquées sans autre intervention du LLM à l'exécution.
- **Interposition sémantique.** Au lieu de donner à l'agent un accès brut au système, toutes les interactions passent par des serveurs [MCP](https://modelcontextprotocol.io/) (système de fichiers, git, etc.). Chaque appel d'outil passe par un moteur de politique qui peut **autoriser**, **refuser** ou **escalader** vers l'utilisateur pour approbation.
- **Défense en profondeur.** Le code de l'agent s'exécute dans un isolat V8 sans accès direct à l'hôte. La seule voie de sortie passe par des appels d'outils MCP sémantiquement significatifs, et chacun est vérifié par rapport à la politique.
## Architecture
IronCurtain prend en charge deux modes de session avec des modèles de confiance différents :
- **Agent intégré (mode Code)** — l'agent LLM propre à IronCurtain écrit des extraits TypeScript qui s'exécutent dans un bac à sable V8. IronCurtain contrôle l'agent, le bac à sable et le moteur de politique. Chaque appel d'outil sort du bac à sable sous forme de requête MCP structurée, passe par le moteur de politique (autoriser / refuser / escalader), et n'atteint qu'ensuite le véritable serveur MCP.
- **Mode Docker Agent** — Un agent externe (Claude Code, Goose, Codex) s'exécute dans un conteneur sans accès direct au réseau public. IronCurtain sert de médiateur pour les effets externes : les appels d'API LLM passent par un proxy MITM terminant TLS (liste d'autorisation d'hôtes, échange de clé factice vers réelle), les appels d'outils MCP passent par le même moteur de politiques, et les installations de paquets prises en charge passent par des proxys de paquets validants.
Le [Docker imbriqué](https://github.com/provos/ironcurtain/blob/master/CONFIG.md#nested-docker-workloads) optionnel offre aux sessions de développement un démon privé et éphémère sans exposer le socket Docker de l'hôte. Les profils implémentés couvrent Apple Container et Docker Desktop sur macOS, ainsi que WSL2 avec Docker Desktop sur amd64. Ses modes `offline`, `images` et `packages` séparent l'utilisation locale d'images, les extractions d'images publiques médiées et les compilations de paquets prises en charge. Le moteur natif Linux Engine n'est pas admis pour l'imbrication ; consultez la référence de configuration pour les prérequis et les limitations.
Dans les deux modes, l'agent est **non fiable**. La sécurité ne dépend pas du fait que le modèle suive les instructions — elle est appliquée à la frontière.
Voir [SANDBOXING.md](https://github.com/provos/ironcurtain/blob/master/SANDBOXING.md) pour l'architecture complète avec des diagrammes, une analyse de confiance couche par couche et des notes sur la plateforme macOS.
## Démarrage rapide
### Prérequis
- Node.js 24 ou 26 — les lignes majeures paires testées par IronCurtain. Les deux installent des binaires `isolated-vm` précompilés. Node 25 n'est pas pris en charge et n'est pas testé.
- Docker — non requis mais **fortement recommandé** pour le mode Docker Agent, qui offre l'isolation la plus forte. Sur macOS 26+ (Apple silicon), [Apple `container`](https://github.com/apple/container) fonctionne comme backend alternatif (VM par conteneur ; utilisé automatiquement lorsque ses services sont en cours d'exécution — voir `containerRuntime` dans `ironcurtain config`)
- Une clé API pour au moins un fournisseur LLM (Anthropic, Google ou OpenAI)
### Installation
**En tant qu'outil CLI global (utilisateurs finaux) :**
```bash
npm install -g @provos/ironcurtain
```
**Depuis les sources (développement) :**
```bash
git clone https://github.com/provos/ironcurtain.git
cd ironcurtain
npm install
```
### Configuration initiale unique
**1. Définissez votre clé API :**
```bash
export ANTHROPIC_API_KEY=sk-ant-...
```
Vous pouvez également placer les clés dans un fichier `.env` à la racine du projet (chargé automatiquement via `dotenv`), ou les ajouter à `~/.ironcurtain/config.json` via `ironcurtain config`. Les variables d'environnement ont priorité sur les valeurs du fichier de configuration. Pris en charge : `ANTHROPIC_API_KEY`, `GOOGLE_GENERATIVE_AI_API_KEY`, `OPENAI_API_KEY`.
**2. Exécuter l'assistant de premier démarrage** (exécutez-le explicitement avant d'utiliser le chemin mux recommandé ; il s'exécute également automatiquement lors du premier `ironcurtain start` non-mux) :
```bash
ironcurtain setup
```
Vous guide à travers la configuration du jeton GitHub, du fournisseur de recherche web, de la sélection du modèle et d'autres paramètres. Crée `~/.ironcurtain/config.json` avec vos choix.
## Exécution d'IronCurtain
IronCurtain est livré avec une politique par défaut orientée vers l'expérience développeur — les opérations en lecture seule sont autorisées, les mutations (écritures, pushs, création de PR) sont escaladées pour approbation humaine. Vous pouvez commencer à l'utiliser immédiatement après la configuration.
### Multiplexeur de terminal (recommandé)
La manière recommandée d'utiliser IronCurtain. Elle vous offre toute la puissance du TUI interactif de votre agent (Claude Code ou Goose) tandis qu'IronCurtain arbitre chaque appel d'outil via son moteur de politiques — le tout dans un seul terminal.
```bash
ironcurtain mux
```
**Capacités clés :**
- **TUI d'agent complète** — L'agent s'exécute dans un PTY à l'intérieur d'un conteneur Docker sans accès réseau. Vous interagissez avec lui exactement comme s'il s'exécutait localement.
- **Gestion des escalades en ligne** — Lorsqu'un appel d'outil nécessite une approbation, un sélecteur d'escalade se superpose à la vue avec des actions à touche unique (a/d/w pour approuver/refuser/whitelister). Utilisez `/approve+ N` pour whitelister un domaine ou un chemin pour le reste de la session.
- **Entrée utilisateur de confiance** — Le texte saisi en mode commande (Ctrl-A) est capturé côté hôte avant d'entrer dans le conteneur. Cela crée un signal d'intention vérifié que l'auto-approbateur peut utiliser — par exemple, taper « push my changes to origin » approuvera automatiquement une escalade `git_push` ultérieure.
- **Gestion des onglets** — Lancez plusieurs sessions concurrentes (`/new`), basculez entre elles (`/tab N`, Alt-1..9), fermez-les (`/close`). Plusieurs instances mux peuvent s'exécuter en parallèle.
Consultez [DEVELOPER_GUIDE.md](https://github.com/provos/ironcurtain/blob/master/DEVELOPER_GUIDE.md) pour la procédure complète : modes de saisie, modèle de sécurité des entrées de confiance, workflow d'escalade et référence clavier.
### Sessions non-mux
Utilisez `ironcurtain start` pour des tâches ponctuelles rapides, des scripts, ou lorsque vous souhaitez explicitement l'agent intégré local. Pour un travail interactif normal avec l'agent Docker, utilisez `ironcurtain mux`.
```bash
ironcurtain start "Summarize the files in ./src" # Single-shot mode
ironcurtain start -w ./my-project "Fix the tests" # Single-shot workspace mode
ironcurtain start --agent builtin # Local builtin REPL, no Docker
ironcurtain start --persona my-assistant "Check my email" # Use a persona
```
### Autres modes d'exécution
IronCurtain prend également en charge la reprise de session (`--resume <session-id>`), un mode PTY brut/débogage hérité, un transport de messagerie Signal pour l'approbation mobile, et un mode démon pour les tâches cron planifiées. Le démon dispose d'une [interface web](https://github.com/provos/ironcurtain/blob/master/DAEMON.md#web-ui) optionnelle (`--web-ui`) pour la surveillance via navigateur et la gestion des escalades. Voir [RUNNING_MODES.md](https://github.com/provos/ironcurtain/blob/master/RUNNING_MODES.md) pour plus de détails.
### Workflows multi-agents
IronCurtain orchestre plusieurs agents IA via des workflows structurés. Le workflow intégré de **découverte de vulnérabilités** traque les bugs de sûreté mémoire et de logique dans le code natif via un pipeline de harnais à plusieurs niveaux (Niveau 1 fonction isolée → Niveau 2 multi-composants → Niveau 3 build complet) avec un filtrage par couverture libFuzzer/AFL++, des états `discover`/`triage` guidés par hypothèses, et une porte finale de revue du rapport par un humain. Le workflow **design-and-code** exécute des cycles planification / conception / implémentation / revue, également avec des portes humaines. Chaque agent s'exécute dans son propre conteneur Docker avec des frontières de politique spécifiques à son rôle ; le moteur gère automatiquement les transitions d'état, le passage d'artefacts et la reprise après plantage via points de contrôle. Open source, s'exécute entièrement sur votre machine, applique des politiques de sécurité par agent via le moteur de politiques basé sur une constitution, et fonctionne avec tout agent conteneurisé Docker — d'une portée comparable à Amazon Kiro et Google Jules pour les tâches de codage, mais avec une sécurité de premier ordre et un format de définition de workflow extensible.

**L'interface web est l'interface prévue pour les exécutions de workflow.** Démarrez le démon, ouvrez l'URL affichée, et pilotez les exécutions depuis la page Workflows — le graphe de la machine à états ci-dessus est en direct, la chronologie des messages des agents est diffusée en continu avec rendu markdown, les revues de portes incluent un navigateur d'espace de travail + artefacts, et les exécutions passées restent listées.
```bash
ironcurtain daemon --web-ui
```
L'accès CLI est disponible pour le scripting, l'automatisation et le débogage :
```bash
ironcurtain workflow start vuln-discovery \
"Find memory-safety bugs in libical" --workspace ~/src/libical
ironcurtain workflow start design-and-code \
"Build a REST API with authentication"
```
Consultez [WORKFLOWS.md](https://github.com/provos/ironcurtain/blob/master/WORKFLOWS.md) pour la documentation complète.
## Personnaliser votre politique
La politique par défaut convient au développement général, mais vous pouvez l'adapter à votre flux de travail :
**1. Personnalisez votre constitution** (facultatif mais recommandé) :
```bash
ironcurtain customize-policy
```
Une conversation assistée par LLM qui génère une constitution adaptée à votre flux de travail, enregistrée dans `~/.ironcurtain/constitution-user.md`. Vous pouvez également modifier ce fichier directement.
**2. Compiler la politique :**
```bash
ironcurtain compile-policy
```
Traduit votre constitution en règles déterministes, génère des scénarios de test et les vérifie. Les artefacts compilés sont placés dans `~/.ironcurtain/generated/`.
### Personas
Les personas sont des profils de politique nommés — chacun regroupe une constitution, une politique compilée, un espace de travail persistant et une mémoire sémantique. Utilisez-les pour exécuter des agents avec différents rôles ou niveaux d'accès.
```bash
ironcurtain persona create my-assistant # Create a persona
ironcurtain persona compile my-assistant # Compile its policy
ironcurtain start --persona my-assistant "Check my calendar"
```
En mode mux, `/new my-assistant` ouvre un onglet utilisant cette persona. Les personas peuvent également être assignées à des tâches cron. Consultez [DAEMON.md](https://github.com/provos/ironcurtain/blob/master/DAEMON.md) pour la configuration des tâches planifiées.
Les personas peuvent aussi être gérées depuis l'[interface web](https://github.com/provos/ironcurtain/blob/master/DAEMON.md#persona-policy-management) — parcourir, créer, modifier les constitutions et compiler les politiques avec une progression en direct. Une politique constituant une frontière de sécurité, les contrôles de modification de l'interface web sont en lecture seule, sauf si le daemon est démarré avec `--allow-policy-mutation` (désactivé par défaut).
### Skills
Déposez des paquets SKILL.md sous `~/.ironcurtain/skills/<name>/` pour rendre des directives spécifiques à un objectif (scripts auxiliaires, vérifications déterministes, connaissances métier) disponibles à chaque session d'agent Docker. L'ensemble fusionné est préparé dans un répertoire hôte par bundle et monté en **lecture seule** dans le conteneur au chemin parcouru par la découverte native de l'agent actif — Claude Code est dirigé vers le répertoire de préparation via `--add-dir`, Goose scanne `~/.config/goose/skills/<name>/SKILL.md`. L'agent les découvre automatiquement et décide quand les lire en fonction de la description du frontmatter de chaque skill. Le _format_ SKILL.md est le standard ouvert adopté par Claude Code, Goose et Codex ; seul le _chemin de découverte_ diffère selon l'agent. Les workflows peuvent embarquer des skills par état à l'intérieur du paquet de workflow — consultez [WORKFLOWS.md](https://github.com/provos/ironcurtain/blob/master/WORKFLOWS.md#skills).
## Politique : Constitution → Application
Vous écrivez l'intention en langage naturel ; IronCurtain la compile en règles déterministes :
```
constitution.md → [Annotate] → [Compile] → [Resolve Lists] → [Generate Scenarios] → [Verify & Repair]
│ │ │ │ │
▼ ▼ ▼ ▼ ▼
tool-annotations compiled-policy dynamic-lists test-scenarios verified policy
.json .json .json .json (or build failure)
```
1. **Annoter** — Classifier les arguments de chaque outil MCP par rôle (read-path, write-path, delete-path, none).
2. **Compiler** — Traduire la constitution anglaise en règles déterministes if/then. Les références catégorielles (« grands sites d'actualité », « mes contacts ») sont émises sous forme de références symboliques `@list-name`.
3. **Résoudre les listes** — Résoudre les listes symboliques en valeurs concrètes via les connaissances du LLM ou l'utilisation d'outils MCP (par exemple, interroger une base de données de contacts). Écrites dans `dynamic-lists.json`, modifiable par l'utilisateur. Ignoré lorsqu'aucune liste n'est présente.
4. **Générer des scénarios** — Créer des scénarios de test à partir de la constitution, plus des tests d'invariants manuscrits obligatoires.
5. **Vérifier et réparer** — Exécuter les scénarios contre le moteur de politique réel. Un juge LLM analyse les échecs et génère des réparations ciblées (jusqu'à 2 tours). La compilation échoue si la politique ne peut pas être vérifiée.
Tous les artefacts sont mis en cache par hachage de contenu — seules les entrées modifiées déclenchent une recompilation.
### À quoi ressemblent les règles compilées
Une clause de constitution comme :
```markdown
- The agent may perform read-only git operations (status, diff, log) within the sandbox without approval.
- The agent must receive human approval before git push, pull, fetch, or any remote-contacting operation.
```
compile en :
```json
[
{ "tool": "git_status", "decision": "allow", "condition": { "directory": { "within": "$SANDBOX" } } },
{ "tool": "git_diff", "decision": "allow", "condition": { "directory": { "within": "$SANDBOX" } } },
{ "tool": "git_push", "decision": "escalate", "reason": "Remote-contacting git operations require human approval" }
]
```
Tout appel qui ne correspond pas à une règle `allow` ou `escalate` explicite est **refusé par défaut**.
```bash
ironcurtain annotate-tools --server filesystem # Annotate one server (merge with existing)
ironcurtain annotate-tools --all # Re-annotate all servers
ironcurtain compile-policy # Compile constitution into rules and verify
ironcurtain refresh-lists # Re-resolve dynamic lists without full recompilation
ironcurtain refresh-lists --list major-news # Refresh a single list
```
Examinez le fichier `~/.ironcurtain/generated/compiled-policy.json` généré — ce sont les règles exactes appliquées à l'exécution.
## Configuration
IronCurtain stocke la configuration et les données de session dans `~/.ironcurtain/` :
```
~/.ironcurtain/
├── config.json # User configuration
├── constitution.md # User-local base constitution (overrides package default)
├── constitution-user.md # Your policy customizations (generated by customize-policy)
├── generated/ # User-compiled policy artifacts (overrides package defaults)
├── personas/ # Persona directories (constitution, policy, workspace, memory)
├── skills/ # User-global SKILL.md packages, mounted into every Docker session
├── jobs/ # Cron job definitions, workspaces, and run records
├── statistics/ # Content-free local LLM usage database + pseudonymization key
├── sessions/
│ └── {sessionId}/
│ ├── sandbox/ # Per-session filesystem sandbox
│ ├── escalations/ # File-based IPC for human approval
│ ├── audit.jsonl # Per-session audit log
│ └── session.log # Diagnostics
└── workflow-runs/ # Shared-container workflow runs (see below)
```
Les exécutions en session unique (`ironcurtain start`, onglets mux, tâches cron) écrivent sous `sessions/`. Les exécutions de workflow en conteneur partagé écrivent sous `workflow-runs/` à la place — voir la section suivante.
### Disposition d'une exécution de workflow
Une définition de workflow peut opter pour un conteneur Docker partagé en définissant `settings.sharedContainer: true` dans son YAML. Dans ce mode, chaque état d'agent s'exécute à l'intérieur du même conteneur de longue durée et partage une seule instance du moteur de politiques ; entre les états, l'orchestrateur permute à chaud la politique active afin que chaque persona voie ses propres règles. Tous les artefacts de l'exécution aboutissent dans une arborescence unique :
```
~/.ironcurtain/workflow-runs/<workflowId>/
├── audit.jsonl # Persona-tagged append-only audit
├── messages.jsonl # Orchestrator message log
├── workspace/ # Agent workspace (filesystem MCP root)
├── bundle/ # Shared container support (claude-state, orientation, sockets, escalations, system-prompt.txt)
├── states/
│ └── <stateId>.<visitCount>/ # session.log + session-metadata.json per invocation
└── proxy-control.sock # Coordinator UDS for policy hot-swap
```
Aucune entrée par session n'est créée sous `~/.ironcurtain/sessions/` pour une exécution de workflow en conteneur partagé. Les commandes visibles par l'utilisateur (`ironcurtain workflow start|resume|inspect|list`) restent inchangées. Consultez [WORKFLOWS.md](https://github.com/provos/ironcurtain/blob/master/WORKFLOWS.md) pour la création de définitions de workflow et le cycle de vie complet.
Modifier la configuration de manière interactive :
```bash
ironcurtain config
```
Principaux domaines de configuration : modèles et clés API, budgets de ressources (limites de tokens/étapes/temps/coût), escalades d'approbation automatique, fournisseur de recherche web, caviardage d'audit et paramètres LLM du serveur de mémoire. Voir [CONFIG.md](https://github.com/provos/ironcurtain/blob/master/CONFIG.md) pour la référence complète.
### Statistiques LLM locales
La collecte d'usage LLM sans contenu est activée par défaut. Elle enregistre les décomptes de tokens (entrée, réflexion, sortie et
totaux), la temporisation, le routage protocole/fournisseur/modèle, les résultats, les refus et les métadonnées de coût lorsque les fournisseurs les exposent. Elle
ne stocke pas les prompts, les complétions, le texte de réflexion, les charges utiles d'outils, les corps de requête/réponse, les identifiants ni les en-têtes
arbitraires. Les libellés dérivés de l'utilisateur/de la configuration et les routes non publiques sont pseudonymisés avec une clé HMAC locale ; les identifiants bornés de modèle et
de fournisseur restent lisibles pour l'analyse.
Les données résident dans `~/.ironcurtain/statistics/llm-usage.sqlite3` ; la clé de pseudonymisation est
`~/.ironcurtain/statistics/identity.key`. La période de rétention par défaut est de 90 jours. Utilisez `ironcurtain config` →
**LLM Statistics**, la vue Settings de l'interface web, ou définissez `"statistics": { "enabled": false }` pour vous désinscrire. Définissez
`retentionDays` à `null` pour désactiver l'élagage automatique. Redémarrez un démon de longue durée après avoir modifié ces paramètres.
La suppression manuelle est disponible avec `ironcurtain statistics delete --before <ISO-date-or-epoch-ms>` ou `--all`.
Il s'agit d'une suppression logique de lignes SQLite, et non d'un effacement sécurisé : les octets supprimés peuvent subsister dans les pages libres, les fichiers WAL, les instantanés
du système de fichiers ou les sauvegardes. La clé d'identité n'est ni renouvelée ni supprimée par ces commandes.
Pour router le trafic LLM via une passerelle comme LiteLLM ou OpenRouter (à la fois en Code Mode et en Docker Agent Mode), voir [MODEL_ROUTING.md](https://github.com/provos/ironcurtain/blob/master/MODEL_ROUTING.md).
Routez les agents Docker via des profils de fournisseur de modèle (par ex. GLM-5.3 / GLM-5.3-Flash via OpenRouter, sans sidecar) avec `ironcurtain config` → Model Providers, puis choisissez un profil sur `/new` ou avec `--provider-profile` — voir [MODEL_ROUTING.md](https://github.com/provos/ironcurtain/blob/master/MODEL_ROUTING.md#first-class-openrouter).
## Capacités intégrées
IronCurtain est livré avec six serveurs MCP préconfigurés. Tous les appels d'outils (sauf la mémoire) sont régis par votre politique compilée.
| Serveur | Outils | Capacités clés |
| -------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Filesystem** | 14 | Lire, écrire, modifier, rechercher des fichiers ; arborescence de répertoires ; déplacer ; calcul de diff |
| **Git** | 28 | Flux de travail git complet : status, diff, log, commit, branch, push/pull/fetch, clone, stash, blame |
| **Fetch** | 2 | HTTP GET avec conversion HTML-vers-markdown ; recherche web (Brave, Tavily, SerpAPI, Parallel Search) |
| **GitHub** | 41 | Issues, PRs, recherche de code, revues via `ghcr.io/github/github-mcp-server` ; nécessite un jeton d'accès personnel GitHub |
| **Google Workspace** | 128 | Gmail, Calendar, Drive, Docs, Sheets — nécessite une configuration OAuth via `ironcurtain auth` |
| **Memory** | 5 | Mémoire sémantique persistante avec recherche hybride vecteur+mots-clés, résumé par LLM et compactage automatique. Activée pour les sessions persona et cron. |
Les opérations en lecture seule sont autorisées par la politique par défaut ; les mutations (écritures, push, création de PR) déclenchent une escalade pour approbation humaine. Les outils utilisent la nomenclature `server.tool` (par ex., `filesystem.read_file`, `memory.recall`). Voir [ADDING_MCP_SERVERS.md](https://github.com/provos/ironcurtain/blob/master/ADDING_MCP_SERVERS.md) pour ajouter les vôtres.
### Passthrough réseau (Docker Agent Mode)
En mode Docker Agent, le conteneur n'a aucun accès réseau — tout le trafic passe par le proxy MITM d'IronCurtain. Par défaut, seuls les domaines des fournisseurs de LLM sont accessibles. L'agent peut demander l'accès à des domaines supplémentaires à l'exécution via le serveur MCP virtuel `proxy` (`add_proxy_domain`). Chaque demande nécessite une approbation humaine via le flux d'escalade.
Les domaines approuvés obtiennent un **tunnel de passthrough brut** — les connexions HTTP, HTTPS et WebSocket sont transmises sans inspection du contenu ni injection d'identifiants. Cela offre à l'agent une plus grande utilité (appel d'API tierces, streaming de données depuis des services externes) mais signifie que le trafic vers ces domaines est **non médiatisé**. Voir [SECURITY_CONCERNS.md](https://github.com/provos/ironcurtain/blob/master/docs/SECURITY_CONCERNS.md) Section 2b-i pour le modèle de menace et [DEVELOPER_GUIDE.md](https://github.com/provos/ironcurtain/blob/master/DEVELOPER_GUIDE.md) pour les détails d'utilisation.
## Modèle de sécurité
IronCurtain est conçu autour d'un modèle de menace spécifique : **le LLM devient malveillant.** Cela peut se produire par injection de prompt (un e-mail ou une page web malveillant détourne l'agent) ou par dérive multi-tours (l'agent s'écarte progressivement de l'intention de l'utilisateur au fil d'une longue session).
### Ce qu'IronCurtain applique
- **Confinement du système de fichiers** — La résolution de chemins tenant compte des liens symboliques empêche les attaques par traversée de chemin et par évasion via lien symbolique.
- **Politique par outil** — Chaque appel d'outil MCP est évalué selon des règles compilées. Le moteur de politique classe les arguments des outils par rôle (chemin de lecture, chemin d'écriture, chemin de suppression) pour prendre des décisions fines.
- **Invariants structurels** — Certaines protections sont codées en dur et ne peuvent pas être contournées par la constitution : l'agent ne peut jamais modifier ses propres fichiers de politique, journaux d'audit ou configuration.
- **Escalade humaine** — Lorsque la politique indique « escalader », l'agent se met en pause et l'utilisateur doit explicitement approuver ou refuser. En option, un auto-approbateur basé sur un LLM traite les cas non ambigus (voir [CONFIG.md](https://github.com/provos/ironcurtain/blob/master/CONFIG.md)).
- **Piste d'audit** — Chaque appel d'outil et chaque décision de politique est consigné dans un journal d'audit JSONL en ajout seul.
- **Limites de ressources** — Des budgets de tokens, d'étapes, de temps et de coût empêchent les sessions emballées.
### Limitations connues
Il s'agit d'un prototype de recherche. Les lacunes connues incluent :
- **Fidélité de la compilation des politiques** — Le compilateur basé sur un LLM peut mal interpréter l'intention de la constitution. Le pipeline de vérification détecte de nombreuses erreurs mais n'est pas exhaustif. Examinez toujours le fichier `compiled-policy.json` compilé.
- **Frontières des isolats V8** — Le mode Code utilise des isolats V8, et non une virtualisation au niveau du système d'exploitation. Un zero-day V8 pourrait permettre une évasion.
- **Aucune inspection du contenu sortant** — Un agent autorisé à écrire des fichiers pourrait encoder des données sensibles pour contourner les contrôles au niveau du contenu. Prévu : des contrôles d'intelligibilité basés sur un LLM sur le contenu sortant.
- **Fatigue d'escalade** — Trop d'escalades faussement positives peuvent conduire à une approbation par habitude. Ajustez votre constitution pour minimiser les invites inutiles.
Voir [docs/SECURITY_CONCERNS.md](https://github.com/provos/ironcurtain/blob/master/docs/SECURITY_CONCERNS.md) pour une analyse détaillée des menaces.
## Dépannage
| Problème | Recommandation |
| --------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
---
[Read more](https://github.com/provos/ironcurtain)