Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
ironcurtain — Um runtime seguro* para agentes de IA autônomos. Política a partir de constituições em inglês simples. (*https://ironcurtain.dev) | Kitploit
Ferramentas/GitHubGitHub/provos/ironcurtain
Segurança de ContêineresAnálise Dinâmica (Sandboxing)Análise de VulnerabilidadesFuzzingAprendizado e EducaçãoSegurança de IA
GitHubprovos/ironcurtain

ironcurtain

Um runtime seguro* para agentes de IA autônomos. Política a partir de constituições em inglês simples. (*https://ironcurtain.dev)

Ver Repositório
5727763há 1 diaRevisado pelo Kitploit
Compartilhar
Site
# 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)

**Um runtime seguro\* para agentes de IA autônomos, onde a política de segurança é derivada de uma constituição legível por humanos.**

_\*Quando alguém escreve "seguro", você deve imediatamente desconfiar. [O que queremos dizer com seguro?](https://ironcurtain.dev)_

> [!WARNING]
> **Protótipo de pesquisa.** IronCurtain é um projeto de pesquisa em estágio inicial que explora como tornar agentes de IA seguros o suficiente para serem genuinamente úteis. APIs, formatos de configuração e arquitetura podem mudar. Contribuições e feedback são bem-vindos.

## Demonstração

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/42102/cf5f5cc847e63acad65eccf1c7fb33bacd782a5d592249cfea60e5f32830ac07.gif" alt="Demonstração do mux do IronCurtain: entrada confiável do modo de comando permite a aprovação automática de git clone e git push" width="800">
</p>

O agente recebe a tarefa de clonar um repositório e enviar alterações. Tanto `git_clone` quanto `git_push` são escalados pelo motor de políticas, mas o auto-aprovador os aprova automaticamente — a entrada confiável do usuário a partir do modo de comando (Ctrl-A) forneceu intenção clara, então nenhum `/approve` manual foi necessário.

## O Problema

Agentes de IA autônomos podem gerenciar arquivos, executar comandos git, enviar mensagens e interagir com APIs em seu nome. Mas os frameworks de agentes atuais dão ao agente os mesmos privilégios que o usuário, como acesso total ao sistema de arquivos, credenciais e rede. Pesquisadores de segurança chamam isso de **autoridade ambiente**, e isso significa que uma única injeção de prompt ou desvio em múltiplas interações pode fazer um agente excluir arquivos, exfiltrar dados ou enviar código malicioso.

A resposta comum é restringir os agentes a um sandbox estreito (limitando sua utilidade) ou pedir ao usuário para aprovar cada ação (limitando sua autonomia). Nenhuma das duas é satisfatória.

## A Abordagem

IronCurtain segue um caminho diferente: **expresse sua intenção de segurança em inglês simples, e deixe o sistema descobrir a aplicação.**

Você escreve uma **constituição**, que é um documento curto descrevendo o que seu agente pode e não pode fazer. IronCurtain compila isso em uma política de segurança determinística usando um pipeline de LLM, valida as regras compiladas contra cenários de teste gerados e, em seguida, aplica a política em tempo de execução em cada chamada de ferramenta. O resultado é um agente que pode trabalhar de forma autônoma dentro de limites que você define em linguagem natural.

As ideias principais:

- **O agente não é confiável.** IronCurtain assume que o LLM pode estar comprometido por injeção de prompt ou desvio. A segurança não depende de o modelo "ser bom".
- **Inglês na entrada, aplicação na saída.** Você escreve a intenção ("nenhuma operação git destrutiva sem aprovação"); o sistema compila isso em regras determinísticas que são aplicadas sem envolvimento adicional de LLM em tempo de execução.
- **Interposição semântica.** Em vez de dar ao agente acesso bruto ao sistema, todas as interações passam por servidores [MCP](https://modelcontextprotocol.io/) (sistema de arquivos, git, etc.). Cada chamada de ferramenta passa por um motor de políticas que pode **permitir**, **negar** ou **escalar** para aprovação do usuário.
- **Defesa em profundidade.** O código do agente é executado em um isolado V8 sem acesso direto ao host. A única saída é por meio de chamadas de ferramenta MCP semanticamente significativas, e cada uma é verificada em relação à política.

## Arquitetura

IronCurtain suporta dois modos de sessão com modelos de confiança diferentes:

- **Agente Integrado (Modo Código)** — o próprio agente LLM do IronCurtain escreve trechos de TypeScript que são executados em um sandbox V8. O IronCurtain controla o agente, o sandbox e o motor de políticas. Cada chamada de ferramenta sai do sandbox como uma solicitação MCP estruturada, passa pelo motor de políticas (permitir / negar / escalar) e só então chega ao servidor MCP real.

- **Modo Docker Agent** — Um agente externo (Claude Code, Goose, Codex) é executado dentro de um contêiner sem acesso direto à rede pública. O IronCurtain intermedeia os efeitos externos: as chamadas à API do LLM passam por um proxy MITM que termina TLS (lista de permissões de hosts, troca de chave falsa por real), as chamadas de ferramentas MCP passam pelo mesmo motor de políticas, e as instalações de pacotes suportadas passam por proxies de pacotes com validação.

O [Docker aninhado](https://github.com/provos/ironcurtain/blob/master/CONFIG.md#nested-docker-workloads) opcional oferece às sessões de desenvolvedor um daemon privado e efêmero
sem expor o socket Docker do host. Os perfis implementados abrangem Apple Container e Docker
Desktop no macOS, e WSL2 com Docker Desktop em amd64. Os seus modos `offline`, `images` e `packages`
separam o uso local de imagens, os pulls de imagens públicas intermediados e as compilações de pacotes suportadas. O Linux Engine nativo
não é admitido para aninhamento; consulte a referência de configuração para pré-requisitos e limitações.

Em ambos os modos, o agente é **não confiável**. A segurança não depende de o modelo seguir instruções — ela é imposta na fronteira.

Consulte [SANDBOXING.md](https://github.com/provos/ironcurtain/blob/master/SANDBOXING.md) para a arquitetura completa com diagramas, análise de confiança camada por camada e notas sobre a plataforma macOS.

## Início Rápido

### Pré-requisitos

- Node.js 24 ou 26 — as linhas principais de numeração par que o IronCurtain testa. Ambas instalam binários `isolated-vm` pré-compilados. O Node 25 não é suportado nem testado.
- Docker — não obrigatório, mas **fortemente recomendado** para o Modo Docker Agent, que proporciona o isolamento mais forte. No macOS 26+ (Apple silicon), o [Apple `container`](https://github.com/apple/container) funciona como backend alternativo (VM por contêiner; usado automaticamente quando os seus serviços estão em execução — consulte `containerRuntime` em `ironcurtain config`)
- Uma chave de API para pelo menos um provedor de LLM (Anthropic, Google ou OpenAI)

### Instalação

**Como ferramenta CLI global (utilizadores finais):**

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

**Da origem (desenvolvimento):**

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

### Configuração única

**1. Defina sua chave de API:**

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

Você também pode colocar as chaves em um arquivo `.env` na raiz do projeto (carregado automaticamente via `dotenv`), ou adicioná-las a `~/.ironcurtain/config.json` via `ironcurtain config`. As variáveis de ambiente têm precedência sobre os valores do arquivo de configuração. Suportadas: `ANTHROPIC_API_KEY`, `GOOGLE_GENERATIVE_AI_API_KEY`, `OPENAI_API_KEY`.

**2. Execute o assistente de primeira inicialização** (execute-o explicitamente antes de usar o caminho mux recomendado; ele também é executado automaticamente no primeiro `ironcurtain start` sem mux):

```bash
ironcurtain setup
```

Orienta você pela configuração do token do GitHub, provedor de busca na web, seleção de modelo e outras configurações. Cria `~/.ironcurtain/config.json` com suas escolhas.

## Executando o IronCurtain

O IronCurtain vem com uma política padrão voltada para a experiência do desenvolvedor — operações somente leitura são permitidas, mutações (gravações, pushes, criação de PR) escalam para aprovação humana. Você pode começar a usá-lo imediatamente após a configuração.

### Multiplexador de terminal (recomendado)

A forma recomendada de usar o IronCurtain. Ele oferece todo o poder da TUI interativa do seu agente (Claude Code ou Goose) enquanto o IronCurtain intermedeia cada chamada de ferramenta através do seu motor de políticas — tudo em um único terminal.

```bash
ironcurtain mux
```

**Principais capacidades:**

- **TUI de agente completa** — O agente é executado num PTY dentro de um contentor Docker sem acesso à rede. Interage com ele exatamente como se estivesse a correr localmente.
- **Tratamento de escalonamento inline** — Quando uma chamada de ferramenta necessita de aprovação, um seletor de escalonamento sobrepõe-se à viewport com ações de tecla única (a/d/w para aprovar/negar/whitelist). Use `/approve+ N` para adicionar um domínio ou caminho à whitelist para o resto da sessão.
- **Entrada de utilizador fidedigna** — O texto escrito em modo de comando (Ctrl-A) é capturado no lado do host antes de entrar no contentor. Isto cria um sinal de intenção verificado que o auto-aprovador pode usar — por exemplo, escrever "push my changes to origin" aprovará automaticamente um escalonamento `git_push` subsequente.
- **Gestão de separadores** — Crie múltiplas sessões concorrentes (`/new`), alterne entre elas (`/tab N`, Alt-1..9), feche-as (`/close`). Várias instâncias mux podem correr em paralelo.

Consulte [DEVELOPER_GUIDE.md](https://github.com/provos/ironcurtain/blob/master/DEVELOPER_GUIDE.md) para o guia completo: modos de entrada, modelo de segurança de entrada fidedigna, fluxo de escalonamento e referência de teclado.

### Sessões não-mux

Use `ironcurtain start` para tarefas rápidas pontuais, scripts, ou quando pretender explicitamente o agente builtin local. Para trabalho interativo normal com o agente Docker, use `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
```

### Outros modos de execução

O IronCurtain também suporta retomada de sessão (`--resume <session-id>`), um modo legado de PTY bruto/de depuração, um transporte de mensagens Signal para aprovação móvel e um modo daemon para tarefas cron agendadas. O daemon possui uma [web UI](https://github.com/provos/ironcurtain/blob/master/DAEMON.md#web-ui) opcional (`--web-ui`) para monitoramento baseado em navegador e tratamento de escalonamentos. Consulte [RUNNING_MODES.md](https://github.com/provos/ironcurtain/blob/master/RUNNING_MODES.md) para detalhes.

### Fluxos de trabalho multiagente

O IronCurtain orquestra múltiplos agentes de IA por meio de fluxos de trabalho estruturados. O fluxo de trabalho integrado de **descoberta de vulnerabilidades** caça bugs de segurança de memória e de lógica em código nativo por meio de um pipeline de harness em camadas (Camada 1 função isolada → Camada 2 multicomponente → Camada 3 build completo) com controle de cobertura libFuzzer/AFL++, estados `discover`/`triage` orientados por hipóteses e um gate final de revisão de relatório por humanos. O fluxo de trabalho **design-and-code** executa ciclos de planejamento / design / implementação / revisão, também com gates humanos. Cada agente é executado em seu próprio contêiner Docker com limites de política específicos por função; o motor gerencia transições de estado, passagem de artefatos e checkpointing de retomada após falhas automaticamente. Código aberto, executa inteiramente na sua máquina, aplica políticas de segurança por agente por meio do motor de políticas baseado em constituição e funciona com qualquer agente conteinerizado em Docker — comparável em escopo ao Amazon Kiro e ao Google Jules para tarefas de codificação, mas com segurança de primeira classe e um formato extensível de definição de fluxos de trabalho.

![Máquina de estados de descoberta de vulnerabilidades na web UI do IronCurtain](https://assets.kitploit.com/production/public/readmes/42102/cdc8465a3cf40d3d67c477605b80f66f324c316ec153e685bbc54d4d8f56b43c.png)

**A web UI é a interface pretendida para execuções de fluxos de trabalho.** Inicie o daemon, abra a URL impressa e conduza as execuções a partir da página Workflows — o grafo da máquina de estados acima é ao vivo, a linha do tempo de mensagens dos agentes é transmitida com renderização markdown, as revisões de gate incluem um navegador de workspace + artefatos, e as execuções anteriores permanecem listadas.

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

O acesso via CLI está disponível para scripting, automação e depuração:

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

Consulte [WORKFLOWS.md](https://github.com/provos/ironcurtain/blob/master/WORKFLOWS.md) para a documentação completa.

## Personalizando Sua Política

A política padrão funciona bem para o desenvolvimento geral, mas você pode adaptá-la ao seu fluxo de trabalho:

**1. Personalize sua constituição** (opcional, mas recomendado):

```bash
ironcurtain customize-policy
```

Uma conversa assistida por LLM que gera uma constituição adaptada ao seu fluxo de trabalho, salva em `~/.ironcurtain/constitution-user.md`. Você também pode editar este arquivo diretamente.

**2. Compile a política:**

```bash
ironcurtain compile-policy
```

Traduz sua constituição em regras determinísticas, gera cenários de teste e os verifica. Os artefatos compilados vão para `~/.ironcurtain/generated/`.

### Personas

Personas são perfis de política nomeados — cada um agrupa uma constituição, política compilada, workspace persistente e memória semântica. Use-os para executar agentes com diferentes funções ou níveis de acesso.

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

No modo mux, `/new my-assistant` abre uma aba usando essa persona. As personas também podem ser atribuídas a tarefas cron. Consulte [DAEMON.md](https://github.com/provos/ironcurtain/blob/master/DAEMON.md) para a configuração de tarefas agendadas.

As personas também podem ser gerenciadas pela [interface web](https://github.com/provos/ironcurtain/blob/master/DAEMON.md#persona-policy-management) — navegue, crie, edite constituições e compile políticas com progresso em tempo real. Como uma política é um limite de segurança, os controles de mutação da interface web são somente leitura, a menos que o daemon seja iniciado com `--allow-policy-mutation` (desativado por padrão).

### Skills

Coloque pacotes SKILL.md em `~/.ironcurtain/skills/<name>/` para disponibilizar orientações específicas de propósito (scripts auxiliares, verificações determinísticas, conhecimento de domínio) a todas as sessões de agente Docker. O conjunto mesclado é preparado em um diretório host por bundle e montado via bind **somente leitura** no contêiner, no caminho que a descoberta nativa do agente ativo percorre — o Claude Code é apontado para o diretório de preparação via `--add-dir`, o Goose varre `~/.config/goose/skills/<name>/SKILL.md`. O agente os descobre automaticamente e decide quando lê-los com base na descrição do frontmatter de cada skill. O _formato_ do SKILL.md é o padrão aberto adotado pelo Claude Code, Goose e Codex; apenas o _caminho de descoberta_ difere por agente. Os workflows podem incluir skills por estado dentro do pacote do workflow — consulte [WORKFLOWS.md](https://github.com/provos/ironcurtain/blob/master/WORKFLOWS.md#skills).

## Política: Constituição → Aplicação

Você escreve a intenção em inglês simples; o IronCurtain a compila em regras determinísticas:

```
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** — Classifique os argumentos de cada ferramenta MCP por função (read-path, write-path, delete-path, none).
2. **Compile** — Traduza a constituição em inglês para regras determinísticas if/then. Referências categóricas ("grandes sites de notícias", "meus contatos") são emitidas como referências simbólicas `@list-name`.
3. **Resolve Lists** — Resolva listas simbólicas para valores concretos via conhecimento do LLM ou uso de ferramentas MCP (por exemplo, consultando um banco de dados de contatos). Gravado em `dynamic-lists.json`, editável pelo usuário. Ignorado quando não há listas presentes.
4. **Generate Scenarios** — Crie cenários de teste a partir da constituição, além de testes invariantes obrigatórios escritos manualmente.
5. **Verify & Repair** — Execute os cenários contra o motor de políticas real. Um juiz LLM analisa as falhas e gera reparos direcionados (até 2 rodadas). A compilação falha se a política não puder ser verificada.

Todos os artefatos são armazenados em cache por hash de conteúdo — apenas entradas alteradas disparam recompilação.

### Como as regras compiladas se parecem

Uma cláusula da constituição como:

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

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

Qualquer chamada que não corresponda a uma regra explícita `allow` ou `escalate` é **negada por padrão**.

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

Revise o `~/.ironcurtain/generated/compiled-policy.json` gerado — estas são as regras exatas aplicadas em tempo de execução.

## Configuração

O IronCurtain armazena configuração e dados de sessão em `~/.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)
```

Execuções de sessão única (`ironcurtain start`, abas mux, tarefas cron) gravam em `sessions/`. Execuções de fluxo de trabalho em contêiner compartilhado gravam em `workflow-runs/` — consulte a próxima seção.

### Layout de execução de fluxo de trabalho

Uma definição de fluxo de trabalho pode optar por um contêiner Docker compartilhado definindo `settings.sharedContainer: true` em seu YAML. Nesse modo, cada estado de agente é executado dentro do mesmo contêiner de longa duração e compartilha uma única instância do mecanismo de políticas; entre os estados, o orquestrador troca a quente a política ativa para que cada persona veja suas próprias regras. Todos os artefatos da execução ficam em uma única árvore:

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

Nenhuma entrada por sessão é criada em `~/.ironcurtain/sessions/` para uma execução de workflow em contêiner compartilhado. Os comandos visíveis ao usuário (`ironcurtain workflow start|resume|inspect|list`) permanecem inalterados. Consulte [WORKFLOWS.md](https://github.com/provos/ironcurtain/blob/master/WORKFLOWS.md) para criar definições de workflow e conhecer o ciclo de vida completo.

Edite a configuração de forma interativa:

```bash
ironcurtain config
```

Áreas principais de configuração: modelos e chaves de API, orçamentos de recursos (limites de tokens/passos/tempo/custo), escalonamentos de aprovação automática, provedor de pesquisa na web, redação de auditoria e configurações de LLM do servidor de memória. Consulte [CONFIG.md](https://github.com/provos/ironcurtain/blob/master/CONFIG.md) para a referência completa.

### Estatísticas de LLM local

A coleta de uso de LLM sem conteúdo está habilitada por padrão. Ela registra contagens de tokens (entrada, raciocínio, saída e
totais), tempo, roteamento de protocolo/provedor/modelo, resultados, recusas e metadados de custo quando os provedores os expõem. Ela
não armazena prompts, completions, texto de raciocínio, payloads de ferramentas, corpos de requisição/resposta, credenciais ou cabeçalhos
arbitrários. Rótulos derivados do usuário/configuração e rotas não públicas são pseudonimizados com uma chave HMAC local; identificadores
limitados de modelo e provedor permanecem legíveis para análise.

Os dados ficam em `~/.ironcurtain/statistics/llm-usage.sqlite3`; a chave de pseudonimização é
`~/.ironcurtain/statistics/identity.key`. O período de retenção padrão é de 90 dias. Use `ironcurtain config` →
**LLM Statistics**, a visualização Settings da interface web, ou defina `"statistics": { "enabled": false }` para desativar. Defina
`retentionDays` como `null` para desabilitar a limpeza automática. Reinicie um daemon em execução prolongada após alterar essas configurações.

A exclusão manual está disponível com `ironcurtain statistics delete --before <ISO-date-or-epoch-ms>` ou `--all`.
Trata-se de exclusão lógica de linhas do SQLite, não de apagamento seguro: os bytes excluídos podem permanecer em páginas livres, arquivos WAL, snapshots
do sistema de arquivos ou backups. A chave de identidade não é rotacionada nem excluída por esses comandos.

Para rotear o tráfego de LLM através de um gateway como LiteLLM ou OpenRouter (tanto no Code Mode quanto no Docker Agent Mode), consulte [MODEL_ROUTING.md](https://github.com/provos/ironcurtain/blob/master/MODEL_ROUTING.md).

Roteie agentes Docker através de perfis de provedor de modelo (por exemplo, GLM-5.3 / GLM-5.3-Flash via OpenRouter, sem sidecar) com `ironcurtain config` → Model Providers, depois escolha um perfil em `/new` ou com `--provider-profile` — consulte [MODEL_ROUTING.md](https://github.com/provos/ironcurtain/blob/master/MODEL_ROUTING.md#first-class-openrouter).

## Capacidades Integradas

O IronCurtain vem com seis servidores MCP pré-configurados. Todas as chamadas de ferramentas (exceto memória) são regidas pela sua política compilada.

| Servidor             | Ferramentas | Principais capacidades                                                                                                                            |
| -------------------- | ----- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Filesystem**       | 14    | Ler, escrever, editar, pesquisar arquivos; árvore de diretórios; mover; cálculo de diff                                                                           |
| **Git**              | 28    | Fluxo de trabalho git completo: status, diff, log, commit, branch, push/pull/fetch, clone, stash, blame                                                        |
| **Fetch**            | 2     | HTTP GET com conversão de HTML para markdown; pesquisa na web (Brave, Tavily, SerpAPI, Parallel Search)                                                    |
| **GitHub**           | 41    | Issues, PRs, pesquisa de código, revisões via `ghcr.io/github/github-mcp-server`; requer um token de acesso pessoal do GitHub                                 |
| **Google Workspace** | 128   | Gmail, Calendar, Drive, Docs, Sheets — requer configuração OAuth via `ironcurtain auth`                                                                |
| **Memory**           | 5     | Memória semântica persistente com pesquisa híbrida vetorial+palavras-chave, sumarização por LLM e compactação automática. Habilitada para sessões de persona e cron. |

Operações somente leitura são permitidas pela política padrão; mutações (gravações, pushes, criação de PRs) escalam para aprovação humana. As ferramentas usam a nomenclatura `server.tool` (por exemplo, `filesystem.read_file`, `memory.recall`). Consulte [ADDING_MCP_SERVERS.md](https://github.com/provos/ironcurtain/blob/master/ADDING_MCP_SERVERS.md) para adicionar as suas próprias.

### Passthrough de Rede (Docker Agent Mode)

No Docker Agent Mode, o contêiner não tem acesso à rede — todo o tráfego passa pelo proxy MITM do IronCurtain. Por padrão, apenas domínios de provedores de LLM são acessíveis. O agente pode solicitar acesso a domínios adicionais em tempo de execução por meio do servidor MCP virtual `proxy` (`add_proxy_domain`). Cada solicitação requer aprovação humana via o fluxo de escalonamento.

Domínios aprovados recebem um **túnel de passthrough bruto** — conexões HTTP, HTTPS e WebSocket são encaminhadas sem inspeção de conteúdo ou injeção de credenciais. Isso dá ao agente maior utilidade (chamar APIs de terceiros, transmitir dados de serviços externos), mas significa que o tráfego para esses domínios é **não mediado**. Consulte a Seção 2b-i de [SECURITY_CONCERNS.md](https://github.com/provos/ironcurtain/blob/master/docs/SECURITY_CONCERNS.md) para o modelo de ameaças e [DEVELOPER_GUIDE.md](https://github.com/provos/ironcurtain/blob/master/DEVELOPER_GUIDE.md) para detalhes de uso.

## Modelo de Segurança

O IronCurtain é projetado em torno de um modelo de ameaças específico: **o LLM se torna malicioso.** Isso pode acontecer por meio de injeção de prompt (um e-mail ou página web maliciosa sequestra o agente) ou por deriva em múltiplos turnos (o agente gradualmente se desvia da intenção do usuário ao longo de uma sessão longa).

### O que o IronCurtain impõe

- **Confinamento do sistema de arquivos** — A resolução de caminhos ciente de symlinks impede ataques de path traversal e de escape por symlink.
- **Política por ferramenta** — Cada chamada de ferramenta MCP é avaliada em relação a regras compiladas. O motor de políticas classifica os argumentos da ferramenta por função (caminho de leitura, caminho de escrita, caminho de exclusão) para tomar decisões refinadas.
- **Invariantes estruturais** — Certas proteções são codificadas de forma fixa e não podem ser sobrescritas pela constituição: o agente nunca pode modificar seus próprios arquivos de política, logs de auditoria ou configuração.
- **Escalonamento humano** — Quando a política diz "escalar", o agente pausa e o usuário deve aprovar ou negar explicitamente. Opcionalmente, um auto-aprovador baseado em LLM trata casos inequívocos (consulte [CONFIG.md](https://github.com/provos/ironcurtain/blob/master/CONFIG.md)).
- **Trilha de auditoria** — Cada chamada de ferramenta e decisão de política é registrada em um log de auditoria JSONL somente de acréscimo.
- **Limites de recursos** — Orçamentos de tokens, etapas, tempo e custo evitam sessões descontroladas.

### Limitações conhecidas

Este é um protótipo de pesquisa. Lacunas conhecidas incluem:

- **Fidelidade da compilação de políticas** — O compilador baseado em LLM pode interpretar mal a intenção da constituição. O pipeline de verificação detecta muitos erros, mas não é exaustivo. Sempre revise o `compiled-policy.json` compilado.
- **Limites de isolamento do V8** — O Code Mode usa isolados V8, não virtualização em nível de SO. Um zero-day do V8 poderia permitir escape.
- **Sem inspeção de conteúdo de saída** — Um agente autorizado a escrever arquivos poderia codificar dados sensíveis para contornar controles em nível de conteúdo. Planejado: verificações de inteligibilidade baseadas em LLM sobre o conteúdo de saída.
- **Fadiga de escalonamento** — Muitos escalonamentos falso-positivos podem levar à aprovação habitual. Ajuste sua constituição para minimizar prompts desnecessários.

Consulte [docs/SECURITY_CONCERNS.md](https://github.com/provos/ironcurtain/blob/master/docs/SECURITY_CONCERNS.md) para uma análise detalhada de ameaças.

## Solução de Problemas

| Problema                                   | Orientação                                                                                                                                                                                                                                                 |
| --------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Chave de API ausente**                     | Defina a variável de ambiente (`ANTHROPIC_API_KEY`, `GOOGLE_GENERATIVE_AI_API_KEY` ou `OPENAI_API_KEY`) ou adicione a chave correspondente em `~/.ironcurtain/config.json`.                                                                                    |
| **Sandbox indisponível**                 | O sandbox em nível de SO requer `bubblewrap` e `socat`. Instale ambos ou defina `"sandboxPolicy": "warn"` na configuração do seu servidor MCP para desenvolvimento.                                                                                                         |
| **Orçamento esgotado**                    | Ajuste os limites em `~/.ironcurtain/config.json` em `resourceBudget`. Defina qualquer limite individual como `null` para desativá-lo.                                                                                                                                  |

---

[Read more](https://github.com/provos/ironcurtain)
Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    911
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    548
  • 3

    redforge

    cybersecurity91/redforge

    Kit de ferramentas de red team do lado do navegador com 102 ferramentas offline para reconhecimento, geração de payloads, ataques a credenciais, criptografia, codificação e relatórios de engajamento.

    366
  • 4

    ARTEX

    baarai/artex

    Plataforma autônoma de testes de penetração multiagente com LLM, com agentes planejador/executor, grafos de ativos e de exploração, registro de tráfego MITM e reteste de vulnerabilidades.

    362
  • 5

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingere relatórios do Shadowserver no MongoDB e os reproduz como mapas interativos, análises, descobertas, avisos e painéis executivos.

    311
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    O sistema de ação para cibersegurança nativa em IA—onde a intenção se torna execução governada, a evidência se torna memória operacional, e cada operação melhora a próxima.

    287

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →