Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
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.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
agentbox — Runtime de código aberto em sandbox para agentes de IA — isolamento gVisor/Docker, cofre de credenciais, log de auditoria imutável. Construído após o CVE-2026-25253. | Kitploit
Ferramentas/GitHubGitHub/siyad01/agentbox
Segurança de Infraestrutura em NuvemSegurança de ContêineresFerramentas de Criptografia/DescriptografiaVirtualização para SegurançaDevSecOpsGerenciamento de Identidade e Acesso (IAM)
GitHubsiyad01/agentbox

agentbox

Runtime de código aberto em sandbox para agentes de IA — isolamento gVisor/Docker, cofre de credenciais, log de auditoria imutável. Construído após o CVE-2026-25253.

Ver Repositório
há 3 mesesAinda não revisado

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

🛡️ AgentBox

O runtime sandboxed de código aberto para agentes de IA

Execute agentes de IA com confiança. Cada agente tem seu próprio escopo de permissões, cofre de credenciais, trilha de auditoria e botão de emergência.

Build License: Apache 2.0 Go Version Tests Platform


Por que o AgentBox existe

Em 27 de janeiro de 2026, CVE-2026-25253 se tornou o primeiro CVE já atribuído a um sistema de IA agêntico. Uma vulnerabilidade crítica de sequestro de WebSocket no OpenClaw permitiu execução remota de código com um clique contra qualquer instância exposta — incluindo aquelas vinculadas apenas a localhost.

Na mesma semana, a campanha ClawHavoc infiltrou 341+ skills maliciosas no marketplace do OpenClaw. Cada skill instalada do ClawHub era executada com as mesmas permissões do próprio OpenClaw — acesso total ao disco, tokens OAuth, chaves de API. Sem sandbox. Sem trilha de auditoria. Sem botão de emergência.

"Instalar uma skill do ClawHub concede a ela acesso aos mesmos recursos que o próprio OpenClaw. Não há isolamento de sandbox entre skills por padrão." — Análise de segurança da DEV Community, abril de 2026

Os números:

  • 138+ CVEs no OpenClaw somente em 2026
  • 135.000+ instâncias expostas em 82 países
  • 341 skills maliciosas confirmadas (12% de todo o registro)
  • 1,5 milhão de tokens de API de agentes expostos em texto puro
  • Microsoft: "Não é apropriado executá-lo em uma máquina pessoal ou corporativa padrão."

O AgentBox é a correção estrutural. Não um patch — um runtime.


O que o AgentBox faz

Cada agente que você executa recebe:

ProteçãoComo
Permissões de confiança zeroOs agentes declaram exatamente o que precisam. Nada mais é acessível.
Isolamento em nível de kernelO gVisor intercepta cada syscall. A injeção de prompt não pode cruzar essa fronteira.
Cofre de credenciaisCriptografia AES-256-GCM. Os agentes nunca veem segredos brutos — apenas tokens com escopo.
Log de auditoria imutávelCadeia de hash SHA-256. Cada ação registrada. À prova de adulteração.
Botão de emergênciaEncerre qualquer agente em menos de 100ms. Auto-encerramento em caso de violação de limite.
Limites de recursosTempo, memória, contagem de requisições — aplicados em tempo de execução, não na configuração.
root@kitploit:~
Antes do AgentBox                    Depois do AgentBox
─────────────────                  ──────────────
Agente → disco completo ❌           Agente → apenas caminhos permitidos ✅
Agente → toda a rede ❌             Agente → apenas hosts permitidos ✅
Agente → segredos brutos ❌         Agente → tokens com escopo ✅
Sem trilha de auditoria ❌          Cada ação registrada ✅
Sem botão de emergência ❌          Encerramento em <100ms ✅
Skills executadas como root ❌      Sandbox isolado em nível de kernel ✅

Início rápido

root@kitploit:~
# Instalação
go install github.com/siyad01/agentbox/cmd/agentbox@latest

# Valide um manifesto antes de executar
agentbox validate manifests/email-sorter.yaml

# Execute um agente em um sandbox
agentbox run --manifest manifests/email-sorter.yaml python agent.py

# Veja o que o agente fez
agentbox audit --log logs/email-sorter-audit.log

# Verifique se o log não foi adulterado
agentbox verify logs/email-sorter-audit.log

# Gerencie segredos
agentbox vault add ANTHROPIC_API_KEY
agentbox vault list

O manifesto

Cada agente declara exatamente o que precisa. Nada que não esteja listado é acessível.

root@kitploit:~
name: "email-sorter"
version: "1.0.0"
description: "Lê a caixa de entrada, categoriza e-mails, escreve na pasta classificada"
runtime: docker        # ou: gvisor (nível de kernel), firecracker (MicroVM)

permissions:
  filesystem:
    read:
      - "~/Documents/inbox"
    write:
      - "~/Documents/sorted"
    deny:                      # SEMPRE bloqueado — mesmo se estiver na lista de leitura
      - "~/.ssh"
      - "~/.aws"
      - "~/.config"
      - "/etc"

  network:
    allow:
      - "api.anthropic.com"
      - "gmail.googleapis.com"
    deny:
      - "*"                    # bloqueia todo o resto

  tools:
    allow:
      - "read_file"
      - "write_file"
      - "list_*"
    deny:
      - "execute_shell"        # sem acesso ao shell, nunca
      - "*_delete"             # sem ferramentas de exclusão

  credentials:
    - ANTHROPIC_API_KEY        # injetado do cofre em tempo de execução
    - GMAIL_TOKEN              # o agente nunca vê o valor bruto

limits:
  max_tokens:    50000         # orçamento de tokens LLM
  max_duration:  "30m"         # encerrado após 30 minutos
  max_memory_mb: 256           # teto de RAM
  max_requests:  500           # máximo de invocações de ferramentas

audit:
  log_level: full
  alert_on:
    - filesystem_deny
    - network_deny
    - token_budget_80pct
  log_path: "logs/email-sorter-audit.log"

Como funciona

root@kitploit:~
agentbox run --manifest agent.yaml python agent.py
         │
         ▼
┌─────────────────────────────────────────────────────┐
│                 Policy Engine                        │
│  Analisa o manifesto → constrói listas allow/deny   │
│  Valida assinaturas → rejeita skills não assinadas  │
│  Injeta credenciais do cofre                        │
└──────────────────────┬──────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────┐
│              Isolation Layer                         │
│                                                     │
│  Docker  → container + seccomp + cap-drop           │
│  gVisor  → kernel em espaço de usuário, interceptação de syscall │
│  Firecracker → kernel MicroVM dedicado por agente   │
│                                                     │
│  Filesystem: apenas caminhos declarados montados    │
│  Network:    apenas hosts declarados acessíveis     │
│  Capabilities: TODAS removidas, nenhuma adicionada  │
└──────────────────────┬──────────────────────────────┘
                       │
          ┌────────────┼────────────┐
          ▼            ▼            ▼
   Audit Logger   Credential    Resource
   (hash-chain)     Vault       Monitor
   cada ação      AES-256-GCM  auto-encerramento
   registrada     tokens com escopo em caso de limite

Por que o gVisor impede a injeção de prompt

Todos os outros sandboxes param na fronteira do container. Um agente que explora uma vulnerabilidade de kernel pode escapar.

O gVisor intercepta cada syscall antes que ele alcance o kernel do host:

root@kitploit:~
Agente tenta: write("/home/user/.ssh/id_rsa")
                    │
                    ▼
         Kernel em espaço de usuário do gVisor
                    │
         Caminho na lista de deny? → SIM
                    │
                    ▼
         EPERM retornado imediatamente
         O kernel do host nunca vê este syscall
         A injeção de prompt não pode cruzar esta camada

Referência da CLI

root@kitploit:~
agentbox <comando> [opções]

Comandos:
  run       Executa um agente em um sandbox
  validate  Valida um arquivo de manifesto
  kill      Encerra um agente em execução
  audit     Visualiza logs de auditoria do agente
  verify    Verifica a integridade do log de auditoria
  vault     Gerencia credenciais criptografadas
  serve     Inicia o servidor da API REST
  version   Mostra a versão

Exemplos:
  agentbox validate manifests/email-sorter.yaml
  agentbox run --manifest manifests/email-sorter.yaml python agent.py
  agentbox kill agent-abc123
  agentbox audit --log logs/email-sorter.log --deny
  agentbox audit --log logs/email-sorter.log --last 1h
  agentbox verify logs/email-sorter.log
  agentbox vault add ANTHROPIC_API_KEY
  agentbox vault list
  agentbox vault delete OLD_KEY
  agentbox serve :8081

API REST

Inicie com agentbox serve (padrão: :8081).

MétodoEndpointDescrição
GET/healthVerificação de saúde
GET/dashboardPainel web
GET/api/agentsLista todos os agentes
POST/api/agentsInicia um novo agente
DELETE/api/agents/:idEncerra um agente
GET/api/auditConsulta o log de auditoria

root@kitploit:~
# Lista agentes em execução
curl http://localhost:8081/api/agents

# Inicia um agente
curl -X POST http://localhost:8081/api/agents \
  -H "Content-Type: application/json" \
  -d '{"manifest":"manifests/email-sorter.yaml","command":["python","agent.py"]}'

# Encerra um agente
curl -X DELETE http://localhost:8081/api/agents/abc123

# Consulta o log de auditoria
curl "http://localhost:8081/api/audit?deny=true&agent=email-sorter"

Log de auditoria

Cada ação do agente é registrada em um arquivo JSON Lines somente de acréscimo, com encadeamento de hash:

root@kitploit:~
{"id":1,"hash":"a3f2...","prev_hash":"genesis","timestamp":"2026-05-05T09:00:00Z","agent_id":"abc123","agent_name":"email-sorter","event_type":"agent_start","allowed":true,"resource":"manifests/email-sorter.yaml"}
{"id":2,"hash":"b7c1...","prev_hash":"a3f2...","timestamp":"2026-05-05T09:00:01Z","agent_id":"abc123","agent_name":"email-sorter","event_type":"filesystem_allow","allowed":true,"resource":"read:/home/user/Documents/inbox/mail.txt","rule":"filesystem.read: ~/Documents/inbox"}
{"id":3,"hash":"d9e4...","prev_hash":"b7c1...","timestamp":"2026-05-05T09:00:01Z","agent_id":"abc123","agent_name":"email-sorter","event_type":"filesystem_deny","allowed":false,"resource":"read:/home/user/.ssh/id_rsa","rule":"filesystem.deny: ~/.ssh","reason":"path is explicitly denied"}

Detecção de adulteração:

root@kitploit:~
agentbox verify logs/email-sorter-audit.log

✅ O log de auditoria está intacto
   Entradas: 47 (IDs 1–47)
   Cadeia de hash: ininterrupta

Altere qualquer caractere em qualquer entrada e a verificação falha imediatamente — a cadeia é quebrada.


Cofre de credenciais

root@kitploit:~
# Armazena um segredo (nunca registrado, nunca em texto puro no env)
agentbox vault add ANTHROPIC_API_KEY

# Lista os nomes das credenciais armazenadas (valores nunca exibidos)
agentbox vault list

# Verifica se uma credencial pode ser descriptografada
agentbox vault test ANTHROPIC_API_KEY

# Rotaciona uma credencial
agentbox vault add ANTHROPIC_API_KEY   # add atualiza as existentes

As credenciais são criptografadas com AES-256-GCM. A chave mestra é derivada da sua senha do cofre — nunca armazenada em disco. Na inicialização do agente, o AgentBox injeta as credenciais como variáveis de ambiente com escopo. O agente chama os.getenv("ANTHROPIC_API_KEY") normalmente — ele nunca toca no cofre.


Limites de recursos

O AgentBox encerra agentes que excedem seus limites declarados:

root@kitploit:~
# Este agente está configurado com max_duration: 5s
agentbox run --manifest manifests/timeout-test.yaml python long_running_agent.py

Agent started
tick 1
tick 2
tick 3
tick 4
tick 5
🛑 Killing agent timeout-test: duration limit exceeded: 5s
⚠️  Agent timeout-test exited code 137 in 5.2s

Código de saída 137 = SIGKILL. Encerramento limpo, entrada final de auditoria gravada.


Compilar a partir do código-fonte

root@kitploit:~
# Clonar
git clone https://github.com/siyad01/agentbox
cd agentbox

# Compilar
go build -o agentbox ./cmd/agentbox/

# Executar testes (27 testes, todos passando)
go test ./...

# Instalar globalmente
go install ./cmd/agentbox/

Requisitos:

  • Go 1.26+
  • Docker (para os backends Docker e gVisor)
  • Kernel Linux 5.15+ (para gVisor — detectado automaticamente, com fallback para Docker)

Estrutura do projeto

root@kitploit:~
agentbox/
├── cmd/agentbox/main.go          ← ponto de entrada da CLI
├── internal/
│   ├── policy/
│   │   ├── manifest.go           ← esquema do manifesto YAML
│   │   ├── parser.go             ← validação + padrões
│   │   └── engine.go             ← mecanismo de decisão deny-first (20 testes)
│   ├── audit/
│   │   ├── logger.go             ← log somente de acréscimo com cadeia de hash SHA-256
│   │   ├── verifier.go           ← detecção de adulteração
│   │   └── reader.go             ← consulta + filtro
│   ├── vault/
│   │   ├── store.go              ← armazenamento de credenciais criptografado AES-256-GCM
│   │   └── injector.go           ← injeção em tempo de execução (7 testes)
│   ├── sandbox/
│   │   ├── sandbox.go            ← interface Sandbox
│   │   ├── docker.go             ← backend Docker
│   │   ├── gvisor.go             ← backend gVisor (nível de kernel)
│   │   ├── manager.go            ← gerenciamento do ciclo de vida do agente
│   │   └── util.go               ← detecção WSL2, utilitários de caminho
│   ├── monitor/
│   │   └── enforcer.go           ← limites de recursos + auto-encerramento
│   └── api/
│       └── server.go             ← API REST em :8081
└── manifests/
    ├── email-sorter.yaml         ← exemplo de produção
    └── timeout-test.yaml         ← exemplo de aplicação de limites

Modelo de segurança

Deny-first por padrão. Os agentes começam com zero permissões. Cada capacidade deve ser explicitamente declarada.

A lista de deny sempre vence. Mesmo que um caminho apareça na lista de leitura e na lista de deny, a lista de deny tem precedência. Sem exceções.

Aplicação em nível de kernel com gVisor. Filtros seccomp e remoção de capabilities operam na fronteira de syscall. A saída do modelo — que é controlável pelo atacante — é executada no espaço de usuário e não pode modificar a política em nível de kernel.

Isolamento de credenciais. A chave mestra do cofre nunca é armazenada em disco. As credenciais são injetadas como tokens com escopo de curta duração na inicialização do sandbox e descartadas na saída. O comprometimento de um processo de agente não compromete o cofre de credenciais.

Trilha de auditoria imutável. A cadeia de hash SHA-256 significa que a modificação retroativa do log é detectável. Qualquer alteração em qualquer entrada quebra a cadeia a partir desse ponto.

Consulte SECURITY.md para relatar vulnerabilidades.


Comparação

RecursoAgentBoxSandbox OpenClawSomente DockerAccuKnox
Código aberto (Apache 2.0)✅✅✅❌
Auto-hospedável✅✅✅Somente K8s
Isolamento gVisor / kernel✅❌❌✅
Cofre de credenciais✅❌❌✅
Log de auditoria imutável✅❌❌✅
Auto-encerramento em violação de limite✅❌❌✅
Agnóstico de framework✅❌ (somente OpenClaw)✅✅
Implantação com binário único✅❌✅❌

Roadmap

  • Backend Firecracker MicroVM (kernel Linux dedicado por agente)
  • Monitoramento de syscall eBPF (análise comportamental em tempo real)
  • Política-como-código OPA/Rego (conjuntos de regras complexos no Git)
  • Endpoint de métricas Prometheus
  • AgentBox Cloud (hospedagem gerenciada, pronta para SOC2)
  • Assinatura de manifesto (Ed25519, verificação de proveniência)
  • DLP (prevenção de perda de dados — verificação de PII na saída do agente)

Contribuindo

Consulte CONTRIBUTING.md.

Licença

Apache 2.0 — livre para usar, modificar e distribuir. Consulte LICENSE.


Construído com Go · Zero dependências externas para os recursos de segurança principais · Auto-hospedável em um único comando

Se o CVE-2026-25253 te preocupou, esta é a solução. Dê uma ⭐

Baixar ferramenta