Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
ironcurtain — Un runtime sicuro* per agenti AI autonomi. Policy da costituzioni in inglese semplice. (*https://ironcurtain.dev) | Kitploit
Strumenti/GitHubGitHub/provos/ironcurtain
Sicurezza dei ContenitoriAnalisi Dinamica (Sandboxing)Analisi delle VulnerabilitàFuzzingApprendimento e FormazioneSicurezza dell'IA
GitHubprovos/ironcurtain

ironcurtain

Un runtime sicuro* per agenti AI autonomi. Policy da costituzioni in inglese semplice. (*https://ironcurtain.dev)

Vedi Repository
57277631 giorno faRevisionato da Kitploit
Condividi
Sito web
# IronCurtain

[![CI](https://github.com/provos/ironcurtain/actions/workflows/ci.yml/badge.svg)](https://github.com/provos/ironcurtain/actions/workflows/ci.yml)
[![npm](https://img.shields.io/npm/v/@provos/ironcurtain)](https://www.npmjs.com/package/@provos/ironcurtain)
[![License](https://img.shields.io/github/license/provos/ironcurtain)](LICENSE)
[![Website](https://img.shields.io/badge/web-ironcurtain.dev-blue)](https://ironcurtain.dev)

**Un runtime sicuro\* per agenti AI autonomi, in cui la politica di sicurezza è derivata da una costituzione leggibile da esseri umani.**

_\*Quando qualcuno scrive "sicuro", dovresti essere immediatamente scettico. [Cosa intendiamo per sicuro?](https://ironcurtain.dev)_

> [!WARNING]
> **Prototipo di ricerca.** IronCurtain è un progetto di ricerca in fase iniziale che esplora come rendere gli agenti AI abbastanza sicuri da essere realmente utili. Le API, i formati di configurazione e l'architettura possono cambiare. Contributi e feedback sono benvenuti.

## Demo

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/42102/cf5f5cc847e63acad65eccf1c7fb33bacd782a5d592249cfea60e5f32830ac07.gif" alt="Demo di IronCurtain mux: l'input attendibile dalla modalità comando consente l'approvazione automatica di git clone e git push" width="800">
</p>

All'agente viene chiesto di clonare un repository e di effettuare il push delle modifiche. Sia `git_clone` che `git_push` vengono escalati dal motore delle politiche, ma l'auto-approvatore li approva automaticamente — l'input attendibile dell'utente dalla modalità comando (Ctrl-A) ha fornito un'intenzione chiara, quindi non è stato necessario un `/approve` manuale.

## Il problema

Gli agenti AI autonomi possono gestire file, eseguire comandi git, inviare messaggi e interagire con le API per tuo conto. Ma i framework per agenti di oggi concedono all'agente gli stessi privilegi dell'utente, come l'accesso completo al filesystem, alle credenziali e alla rete. I ricercatori di sicurezza chiamano questo **autorità ambientale**, e significa che una singola prompt injection o una deriva multi-turno può causare la cancellazione di file, l'esfiltrazione di dati o il push di codice malevolo da parte di un agente.

La risposta comune è limitare gli agenti a una sandbox ristretta (limitandone l'utilità) oppure chiedere all'utente di approvare ogni azione (limitandone l'autonomia). Nessuna delle due è soddisfacente.

## L'approccio

IronCurtain segue una strada diversa: **esprimi la tua intenzione di sicurezza in inglese semplice, poi lascia che sia il sistema a occuparsi dell'applicazione.**

Scrivi una **costituzione**, ovvero un breve documento che descrive cosa il tuo agente può e non può fare. IronCurtain compila questo documento in una politica di sicurezza deterministica usando una pipeline LLM, valida le regole compilate rispetto a scenari di test generati, e poi applica la politica a runtime su ogni chiamata di strumento. Il risultato è un agente che può lavorare autonomamente entro confini che tu definisci in linguaggio naturale.

Le idee chiave:

- **L'agente non è attendibile.** IronCurtain presuppone che l'LLM possa essere compromesso da prompt injection o deriva. La sicurezza non dipende dal fatto che il modello "si comporti bene".
- **Intenzione in inglese, applicazione in uscita.** Scrivi l'intenzione ("nessuna operazione git distruttiva senza approvazione"); il sistema la compila in regole deterministiche che vengono applicate senza ulteriore coinvolgimento dell'LLM a runtime.
- **Interposizione semantica.** Invece di dare all'agente accesso diretto al sistema, tutte le interazioni passano attraverso server [MCP](https://modelcontextprotocol.io/) (filesystem, git, ecc.). Ogni chiamata di strumento passa attraverso un motore delle politiche che può **consentire**, **negare** o **escalare** all'utente per approvazione.
- **Difesa in profondità.** Il codice dell'agente viene eseguito in un isolato V8 senza accesso diretto all'host. L'unica via d'uscita è attraverso chiamate di strumenti MCP semanticamente significative, e ognuna viene verificata rispetto alla politica.

## Architettura

IronCurtain supporta due modalità di sessione con modelli di fiducia diversi:

- **Agente integrato (modalità codice)** — l'agente LLM di IronCurtain scrive frammenti TypeScript che vengono eseguiti in una sandbox V8. IronCurtain controlla l'agente, la sandbox e il motore delle politiche. Ogni chiamata di strumento esce dalla sandbox come richiesta MCP strutturata, passa attraverso il motore delle politiche (consenti / nega / escala) e solo allora raggiunge il vero server MCP.

- **Modalità Docker Agent** — Un agente esterno (Claude Code, Goose, Codex) viene eseguito all'interno di un container senza accesso diretto alla rete pubblica. IronCurtain media gli effetti esterni: le chiamate API LLM passano attraverso un proxy MITM che termina TLS (allowlist degli host, sostituzione da chiave fittizia a chiave reale), le chiamate agli strumenti MCP passano attraverso lo stesso motore di policy, e le installazioni di pacchetti supportate passano attraverso proxy di pacchetti con validazione.

Il supporto opt-in per [Docker annidato](https://github.com/provos/ironcurtain/blob/master/CONFIG.md#nested-docker-workloads) offre alle sessioni di sviluppo un daemon privato ed effimero senza esporre il socket Docker dell'host. I profili implementati coprono Apple Container e Docker Desktop su macOS, e WSL2 con Docker Desktop su amd64. Le sue modalità `offline`, `images` e `packages` separano l'uso locale delle immagini, i pull mediati di immagini pubbliche e le build di pacchetti supportate. Il motore nativo Linux Engine non è ammesso per l'annidamento; consultare il riferimento di configurazione per prerequisiti e limitazioni.

In entrambe le modalità, l'agente è **non attendibile**. La sicurezza non dipende dal fatto che il modello segua le istruzioni — è applicata al confine.

Vedere [SANDBOXING.md](https://github.com/provos/ironcurtain/blob/master/SANDBOXING.md) per l'architettura completa con diagrammi, l'analisi della fiducia strato per strato e le note sulla piattaforma macOS.

## Avvio rapido

### Prerequisiti

- Node.js 24 o 26 — le linee major pari testate da IronCurtain. Entrambe installano binari `isolated-vm` precompilati. Node 25 non è supportato né testato.
- Docker — non richiesto ma **fortemente raccomandato** per la Modalità Docker Agent, che offre l'isolamento più forte. Su macOS 26+ (Apple silicon), [Apple `container`](https://github.com/apple/container) funziona come backend alternativo (VM per container; usato automaticamente quando i suoi servizi sono in esecuzione — vedere `containerRuntime` in `ironcurtain config`)
- Una chiave API per almeno un provider LLM (Anthropic, Google o OpenAI)

### Installazione

**Come strumento CLI globale (utenti finali):**

```bash
npm install -g @provos/ironcurtain
```

**Dal sorgente (sviluppo):**

```bash
git clone https://github.com/provos/ironcurtain.git
cd ironcurtain
npm install
```

### Configurazione iniziale

**1. Imposta la tua chiave API:**

```bash
export ANTHROPIC_API_KEY=sk-ant-...
```

Puoi anche inserire le chiavi in un file `.env` nella radice del progetto (caricato automaticamente tramite `dotenv`), oppure aggiungerle a `~/.ironcurtain/config.json` tramite `ironcurtain config`. Le variabili d'ambiente hanno la precedenza sui valori del file di configurazione. Supportate: `ANTHROPIC_API_KEY`, `GOOGLE_GENERATIVE_AI_API_KEY`, `OPENAI_API_KEY`.

**2. Esegui la procedura guidata di primo avvio** (eseguila esplicitamente prima di utilizzare il percorso mux consigliato; viene eseguita automaticamente anche al primo `ironcurtain start` non-mux):

```bash
ironcurtain setup
```

Ti guida nella configurazione del token GitHub, del provider di ricerca web, della selezione del modello e di altre impostazioni. Crea `~/.ironcurtain/config.json` con le tue scelte.

## Eseguire IronCurtain

IronCurtain viene fornito con una policy predefinita orientata all'esperienza dello sviluppatore — le operazioni di sola lettura sono consentite, le mutazioni (scritture, push, creazione di PR) richiedono l'approvazione umana. Puoi iniziare a usarlo subito dopo la configurazione.

### Multiplexer di terminale (consigliato)

Il modo consigliato per usare IronCurtain. Ti offre tutta la potenza della TUI interattiva del tuo agente (Claude Code o Goose) mentre IronCurtain media ogni chiamata agli strumenti tramite il suo motore di policy — il tutto in un unico terminale.

```bash
ironcurtain mux
```

**Funzionalità principali:**

- **TUI completa dell'agente** — L'agente viene eseguito in un PTY all'interno di un container Docker senza accesso alla rete. Interagisci con esso esattamente come se fosse in esecuzione in locale.
- **Gestione delle escalation inline** — Quando una chiamata a uno strumento richiede approvazione, un selettore di escalation si sovrappone al viewport con azioni a singolo tasto (a/d/w per approva/nega/whitelist). Usa `/approve+ N` per aggiungere alla whitelist un dominio o un percorso per il resto della sessione.
- **Input utente attendibile** — Il testo digitato in modalità comando (Ctrl-A) viene catturato sul lato host prima di entrare nel container. Questo crea un segnale di intento verificato che l'auto-approvatore può utilizzare — ad esempio, digitando "push my changes to origin" verrà automaticamente approvata una successiva escalation `git_push`.
- **Gestione delle schede** — Avvia più sessioni concorrenti (`/new`), passa da una all'altra (`/tab N`, Alt-1..9), chiudile (`/close`). Più istanze mux possono essere eseguite in parallelo.

Consulta [DEVELOPER_GUIDE.md](https://github.com/provos/ironcurtain/blob/master/DEVELOPER_GUIDE.md) per la guida completa: modalità di input, modello di sicurezza dell'input attendibile, flusso di lavoro delle escalation e riferimento della tastiera.

### Sessioni non-mux

Usa `ironcurtain start` per attività rapide una tantum, script, o quando desideri esplicitamente l'agente builtin locale. Per il normale lavoro interattivo con l'agente Docker, usa `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
```

### Altre modalità di esecuzione

IronCurtain supporta anche la ripresa della sessione (`--resume <session-id>`), una modalità legacy raw PTY/debug, un trasporto di messaggistica Signal per l'approvazione da mobile e una modalità daemon per job cron pianificati. Il daemon dispone di una [web UI](https://github.com/provos/ironcurtain/blob/master/DAEMON.md#web-ui) opzionale (`--web-ui`) per il monitoraggio da browser e la gestione delle escalation. Consulta [RUNNING_MODES.md](https://github.com/provos/ironcurtain/blob/master/RUNNING_MODES.md) per i dettagli.

### Workflow multi-agente

IronCurtain orchestra più agenti AI attraverso workflow strutturati. Il workflow integrato di **vulnerability discovery** cerca bug di memory-safety e di logica nel codice nativo tramite una pipeline di harness a livelli (Tier 1 funzione isolata → Tier 2 multi-componente → Tier 3 build completa) con gating della copertura libFuzzer/AFL++, stati `discover`/`triage` guidati da ipotesi e un gate finale di revisione del report da parte umana. Il workflow **design-and-code** esegue cicli di plan / design / implement / review, anch'esso con gate umani. Ogni agente viene eseguito nel proprio container Docker con confini di policy specifici per ruolo; il motore gestisce automaticamente le transizioni di stato, il passaggio degli artefatti e il checkpointing per la ripresa dopo crash. Open source, funziona interamente sulla tua macchina, applica policy di sicurezza per-agente tramite il motore di policy basato su costituzione e funziona con qualsiasi agente containerizzato in Docker — comparabile per portata ad Amazon Kiro e Google Jules per le attività di coding, ma con sicurezza di primo livello e un formato estensibile per la definizione dei workflow.

![Macchina a stati del vulnerability-discovery nella web UI di IronCurtain](https://assets.kitploit.com/production/public/readmes/42102/cdc8465a3cf40d3d67c477605b80f66f324c316ec153e685bbc54d4d8f56b43c.png)

**La web UI è l'interfaccia prevista per l'esecuzione dei workflow.** Avvia il daemon, apri l'URL stampato e gestisci le esecuzioni dalla pagina Workflows — il grafo della macchina a stati mostrato sopra è live, la timeline dei messaggi degli agenti viene trasmessa in streaming con rendering markdown, le revisioni dei gate includono un browser di workspace e artefatti, e le esecuzioni passate restano elencate.

```bash
ironcurtain daemon --web-ui
```

L'accesso CLI è disponibile per scripting, automazione e debug:

```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"
```

Consulta [WORKFLOWS.md](https://github.com/provos/ironcurtain/blob/master/WORKFLOWS.md) per la documentazione completa.

## Personalizzare la tua policy

La policy predefinita funziona bene per lo sviluppo generale, ma puoi adattarla al tuo flusso di lavoro:

**1. Personalizza la tua constitution** (opzionale ma consigliato):

```bash
ironcurtain customize-policy
```

Una conversazione assistita da LLM che genera una costituzione su misura per il tuo flusso di lavoro, salvata in `~/.ironcurtain/constitution-user.md`. Puoi anche modificare direttamente questo file.

**2. Compila la policy:**

```bash
ironcurtain compile-policy
```

Traduce la tua costituzione in regole deterministiche, genera scenari di test e li verifica. Gli artefatti compilati vengono salvati in `~/.ironcurtain/generated/`.

### Personas

Le personas sono profili di policy denominati — ciascuno raggruppa una costituzione, una policy compilata, un workspace persistente e una memoria semantica. Usale per eseguire agenti con ruoli o livelli di accesso diversi.

```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"
```

In modalità mux, `/new my-assistant` genera una scheda utilizzando quella persona. Le persone possono anche essere assegnate a job cron. Consulta [DAEMON.md](https://github.com/provos/ironcurtain/blob/master/DAEMON.md) per la configurazione dei job pianificati.

Le persone possono anche essere gestite dalla [web UI](https://github.com/provos/ironcurtain/blob/master/DAEMON.md#persona-policy-management) — sfoglia, crea, modifica le costituzioni e compila le policy con avanzamento in tempo reale. Poiché una policy è un confine di sicurezza, i controlli di modifica della web UI sono di sola lettura a meno che il daemon non venga avviato con `--allow-policy-mutation` (disattivato per impostazione predefinita).

### Skills

Rilascia i pacchetti SKILL.md sotto `~/.ironcurtain/skills/<name>/` per rendere disponibili indicazioni specifiche per uno scopo (script di supporto, controlli deterministici, conoscenza del dominio) a ogni sessione dell'agente Docker. L'insieme unito viene preparato in una directory host per bundle e montato in bind **in sola lettura** nel container al percorso che la scoperta nativa dell'agente attivo percorre — Claude Code viene indirizzato alla directory di staging tramite `--add-dir`, Goose scansiona `~/.config/goose/skills/<name>/SKILL.md`. L'agente li scopre automaticamente e decide quando leggerli in base alla descrizione del frontmatter di ciascuna skill. Il _formato_ SKILL.md è lo standard aperto adottato da Claude Code, Goose e Codex; solo il _percorso di scoperta_ differisce per agente. I workflow possono includere skill per stato all'interno del pacchetto del workflow — consulta [WORKFLOWS.md](https://github.com/provos/ironcurtain/blob/master/WORKFLOWS.md#skills).

## Policy: Costituzione → Applicazione

Scrivi l'intento in inglese semplice; IronCurtain lo compila in regole deterministiche:

```
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. **Annotate** — Classifica gli argomenti di ciascuno strumento MCP per ruolo (read-path, write-path, delete-path, none).
2. **Compile** — Traduce la costituzione in inglese in regole if/then deterministiche. I riferimenti categorici ("major news sites", "my contacts") vengono emessi come riferimenti simbolici `@list-name`.
3. **Resolve Lists** — Risolve le liste simboliche in valori concreti tramite la conoscenza dell'LLM o l'uso di strumenti MCP (ad esempio, interrogando un database di contatti). Scritto in `dynamic-lists.json`, modificabile dall'utente. Saltato quando non sono presenti liste.
4. **Generate Scenarios** — Crea scenari di test dalla costituzione più test invarianti obbligatori scritti a mano.
5. **Verify & Repair** — Esegue gli scenari contro il motore di policy reale. Un giudice LLM analizza i fallimenti e genera riparazioni mirate (fino a 2 cicli). La build fallisce se la policy non può essere verificata.

Tutti gli artefatti sono memorizzati nella cache tramite hash del contenuto — solo gli input modificati attivano una ricompilazione.

### Come appaiono le regole compilate

Una clausola della costituzione come:

```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.
```

compila in:

```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" }
]
```

Qualsiasi chiamata che non corrisponde a una regola esplicita `allow` o `escalate` viene **negata per impostazione predefinita**.

```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
```

Esamina il file `~/.ironcurtain/generated/compiled-policy.json` generato — queste sono le regole esatte applicate a runtime.

## Configurazione

IronCurtain memorizza la configurazione e i dati di sessione in `~/.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)
```

Le esecuzioni a sessione singola (`ironcurtain start`, schede mux, cron job) scrivono in `sessions/`. Le esecuzioni del flusso di lavoro con container condiviso scrivono invece in `workflow-runs/` — vedi la sezione successiva.

### Struttura delle esecuzioni del flusso di lavoro

Una definizione di flusso di lavoro può optare per un container Docker condiviso impostando `settings.sharedContainer: true` nel suo YAML. In questa modalità ogni stato dell'agente viene eseguito all'interno dello stesso container a lunga durata e condivide un'unica istanza del motore delle policy; tra uno stato e l'altro l'orchestratore sostituisce a caldo la policy attiva in modo che ogni persona veda le proprie regole. Tutti gli artefatti dell'esecuzione finiscono in un unico albero:

```
~/.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
```

Per le esecuzioni del flusso di lavoro con container condiviso non vengono create voci per sessione in `~/.ironcurtain/sessions/`. I comandi visibili all'utente (`ironcurtain workflow start|resume|inspect|list`) restano invariati. Consultare [WORKFLOWS.md](https://github.com/provos/ironcurtain/blob/master/WORKFLOWS.md) per la creazione delle definizioni dei flussi di lavoro e per il ciclo di vita completo.

Modifica la configurazione in modo interattivo:

```bash
ironcurtain config
```

Aree di configurazione principali: modelli e chiavi API, budget di risorse (limiti di token/step/tempo/costo), escalation con approvazione automatica, provider di ricerca web, redazione dell'audit e impostazioni LLM del server di memoria. Consulta [CONFIG.md](https://github.com/provos/ironcurtain/blob/master/CONFIG.md) per il riferimento completo.

### Statistiche LLM locali

La raccolta di dati sull'utilizzo degli LLM priva di contenuti è abilitata per impostazione predefinita. Registra i conteggi dei token (input, thinking, output e
totali), i tempi, il routing di protocollo/provider/modello, gli esiti, i rifiuti e i metadati sui costi quando i provider li espongono. Non
memorizza prompt, completamenti, testo di thinking, payload degli strumenti, corpi di richiesta/risposta, credenziali o header
arbitrari. Le etichette derivate dall'utente/dalla configurazione e le route non pubbliche sono pseudonimizzate con una chiave HMAC locale; gli identificatori limitati di modello e
provider restano leggibili per l'analisi.

I dati risiedono in `~/.ironcurtain/statistics/llm-usage.sqlite3`; la chiave di pseudonimizzazione è
`~/.ironcurtain/statistics/identity.key`. Il periodo di conservazione predefinito è di 90 giorni. Usa `ironcurtain config` →
**LLM Statistics**, la vista Settings dell'interfaccia web, oppure imposta `"statistics": { "enabled": false }` per disattivare. Imposta
`retentionDays` a `null` per disabilitare l'eliminazione automatica. Riavvia un daemon in esecuzione prolungata dopo aver modificato queste impostazioni.

L'eliminazione manuale è disponibile con `ironcurtain statistics delete --before <ISO-date-or-epoch-ms>` o `--all`.
Si tratta di un'eliminazione logica delle righe SQLite, non di una cancellazione sicura: i byte eliminati possono rimanere nelle pagine libere, nei file WAL, negli snapshot
del filesystem o nei backup. La chiave di identità non viene ruotata né eliminata da questi comandi.

Per instradare il traffico LLM attraverso un gateway come LiteLLM o OpenRouter (sia in Code Mode che in Docker Agent Mode), consulta [MODEL_ROUTING.md](https://github.com/provos/ironcurtain/blob/master/MODEL_ROUTING.md).

Instrada gli agenti Docker attraverso profili di provider di modelli (ad es. GLM-5.3 / GLM-5.3-Flash tramite OpenRouter, senza sidecar) con `ironcurtain config` → Model Providers, poi scegli un profilo su `/new` o con `--provider-profile` — consulta [MODEL_ROUTING.md](https://github.com/provos/ironcurtain/blob/master/MODEL_ROUTING.md#first-class-openrouter).

## Capacità integrate

IronCurtain viene fornito con sei server MCP preconfigurati. Tutte le chiamate agli strumenti (tranne la memoria) sono governate dalla policy compilata.

| Server               | Strumenti | Capacità principali                                                                                                                               |
| -------------------- | ----- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Filesystem**       | 14    | Lettura, scrittura, modifica, ricerca di file; albero delle directory; spostamento; calcolo del diff                                                |
| **Git**              | 28    | Flusso di lavoro git completo: status, diff, log, commit, branch, push/pull/fetch, clone, stash, blame                                              |
| **Fetch**            | 2     | HTTP GET con conversione da HTML a markdown; ricerca web (Brave, Tavily, SerpAPI, Parallel Search)                                                  |
| **GitHub**           | 41    | Issue, PR, ricerca di codice, review tramite `ghcr.io/github/github-mcp-server`; richiede un token di accesso personale GitHub                      |
| **Google Workspace** | 128   | Gmail, Calendar, Drive, Docs, Sheets — richiede la configurazione OAuth tramite `ironcurtain auth`                                                  |
| **Memory**           | 5     | Memoria semantica persistente con ricerca ibrida vettoriale+per parole chiave, riepilogo tramite LLM e compattazione automatica. Abilitata per le sessioni persona e cron. |

Le operazioni di sola lettura sono consentite dalla policy predefinita; le mutazioni (scritture, push, creazione di PR) richiedono escalation per l'approvazione umana. Gli strumenti usano la denominazione `server.tool` (ad es. `filesystem.read_file`, `memory.recall`). Consulta [ADDING_MCP_SERVERS.md](https://github.com/provos/ironcurtain/blob/master/ADDING_MCP_SERVERS.md) per aggiungere i tuoi.

### Passthrough di rete (Docker Agent Mode)

In Docker Agent Mode, il container non ha accesso alla rete — tutto il traffico passa attraverso il proxy MITM di IronCurtain. Per impostazione predefinita, sono raggiungibili solo i domini dei provider LLM. L'agente può richiedere l'accesso a domini aggiuntivi in fase di esecuzione tramite il server MCP virtuale `proxy` (`add_proxy_domain`). Ogni richiesta richiede l'approvazione umana tramite il flusso di escalation.

I domini approvati ottengono un **tunnel di passthrough grezzo** — le connessioni HTTP, HTTPS e WebSocket vengono inoltrate senza ispezione del contenuto né iniezione di credenziali. Questo offre all'agente una maggiore utilità (chiamare API di terze parti, trasmettere dati in streaming da servizi esterni) ma significa che il traffico verso tali domini è **non mediato**. Consulta [SECURITY_CONCERNS.md](https://github.com/provos/ironcurtain/blob/master/docs/SECURITY_CONCERNS.md) Sezione 2b-i per il modello di minaccia e [DEVELOPER_GUIDE.md](https://github.com/provos/ironcurtain/blob/master/DEVELOPER_GUIDE.md) per i dettagli d'uso.

## Modello di sicurezza

IronCurtain è progettato attorno a uno specifico modello di minaccia: **l'LLM diventa ostile.** Ciò può accadere tramite prompt injection (un'email o una pagina web malevola dirotta l'agente) o tramite deriva multi-turn (l'agente devia gradualmente dall'intento dell'utente nel corso di una lunga sessione).

### Cosa applica IronCurtain

- **Contenimento del filesystem** — La risoluzione dei percorsi consapevole dei symlink previene attacchi di path traversal e di fuga tramite symlink.
- **Policy per singolo strumento** — Ogni chiamata a uno strumento MCP viene valutata rispetto a regole compilate. Il motore di policy classifica gli argomenti degli strumenti per ruolo (read-path, write-path, delete-path) per prendere decisioni granulari.
- **Invarianti strutturali** — Alcune protezioni sono hardcoded e non possono essere sovrascritte dalla constitution: l'agente non può mai modificare i propri file di policy, i log di audit o la configurazione.
- **Escalation umana** — Quando la policy indica "escalate", l'agente si mette in pausa e l'utente deve approvare o negare esplicitamente. Facoltativamente, un auto-approvatore basato su LLM gestisce i casi non ambigui (vedi [CONFIG.md](https://github.com/provos/ironcurtain/blob/master/CONFIG.md)).
- **Traccia di audit** — Ogni chiamata a uno strumento e ogni decisione di policy viene registrata in un log di audit JSONL append-only.
- **Limiti di risorse** — I budget di token, passi, tempo e costo prevengono sessioni fuori controllo.

### Limitazioni note

Questo è un prototipo di ricerca. Le lacune note includono:

- **Fedeltà della compilazione della policy** — Il compilatore basato su LLM può interpretare erroneamente l'intento della constitution. La pipeline di verifica intercetta molti errori ma non è esaustiva. Rivedi sempre il file `compiled-policy.json` compilato.
- **Confini degli isolate V8** — Code Mode utilizza isolate V8, non la virtualizzazione a livello di sistema operativo. Un zero-day di V8 potrebbe consentire una fuga.
- **Nessuna ispezione del contenuto in uscita** — Un agente autorizzato a scrivere file potrebbe codificare dati sensibili per aggirare i controlli a livello di contenuto. In programma: controlli di intelligibilità basati su LLM sul contenuto in uscita.
- **Affaticamento da escalation** — Troppe escalation di falsi positivi possono portare ad approvazioni abituali. Ottimizza la tua constitution per ridurre al minimo le richieste non necessarie.

Consulta [docs/SECURITY_CONCERNS.md](https://github.com/provos/ironcurtain/blob/master/docs/SECURITY_CONCERNS.md) per un'analisi dettagliata delle minacce.

## Risoluzione dei problemi

| Problema                                | Indicazioni                                                                                                                                                                                                                                              |
| --------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **API key mancante**                    | Imposta la variabile d'ambiente (`ANTHROPIC_API_KEY`, `GOOGLE_GENERATIVE_AI_API_KEY` o `OPENAI_API_KEY`) oppure aggiungi la chiave corrispondente a `~/.ironcurtain/config.json`.                                                                       |
| **Sandbox non disponibile**             | Il sandboxing a livello di sistema operativo richiede `bubblewrap` e `socat`. Installali entrambi, oppure imposta `"sandboxPolicy": "warn"` nella configurazione del tuo server MCP per lo sviluppo.                                                     |
| **Budget esaurito**                     | Modifica i limiti in `~/.ironcurtain/config.json` sotto `resourceBudget`. Imposta qualsiasi limite individuale a `null` per disabilitarlo.                                                                                                               |
| **Errori di versione di Node**          | Le linee di Node.js supportate sono la 24 e la 26. Entrambe installano binari `isolated-vm` precompilati. Le altre versioni principali vengono rifiutate da `ironcurtain doctor`.                                                                        |

---

[Read more](https://github.com/provos/ironcurtain)
Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Nessun dato di popolarità ancora.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →