Por dentro do sandbox do Codex
Como o Codex executa comandos na sua máquina com limites que você controla.
Na OpenAI, adotamos uma abordagem de defesa em profundidade(abre em uma nova janela) para proteger os agentes. Embora nossos investimentos em treinamento e alinhamento sejam fundamentais para esse trabalho, também implementamos recursos em nosso harness com agentes de IA, o Codex(abre em uma nova janela), para oferecer proteções adicionais. Como uma das ações mais comuns (e potencialmente arriscadas) do Codex é executar comandos no seu computador, criamos o sandbox do Codex para que ele possa trabalhar no seu ambiente existente, dentro de limites de sistema de arquivos e rede que você controla.
Um (abre em uma nova janela)sandbox(abre em uma nova janela) limita o que um programa pode acessar durante a execução. Para uma tarefa de organização de fotos, você pode configurar o sandbox do Codex para permitir que os comandos leiam e modifiquem arquivos em ~/Pictures, bloqueando o acesso à rede para impedir uploads. Para uma revisão de código, você pode permitir o acesso à documentação on-line e manter os arquivos de código-fonte somente para leitura. Os usuários configuram o sandbox do Codex por meio de (abre em uma nova janela)perfis de permissões(abre em uma nova janela), que definem as restrições de sistema de arquivos e rede para uma sessão do Codex.
Neste artigo, começaremos pelas escolhas e concessões por trás das configurações padrão do sandbox do Codex. Depois, explicaremos seu projeto e como o harness o usa para executar comandos. Mostraremos como usuários finais e empresas podem adaptar as permissões às suas necessidades e como desenvolvedores podem reutilizar o sandbox em suas próprias ferramentas. Por fim, examinaremos como essas restrições são aplicadas no macOS, Linux e Windows.
No Codex, nossa filosofia é definir configurações padrão conservadoras para o sandbox, mas que ainda permitam realizar trabalho útil. Por exemplo, com um repositório Git como raiz do espaço de trabalho, o perfil de permissões integrado :workspace:
Permite escrita no espaço de trabalho, mantendo diretórios como
.gite.codexsomente para leitura. Isso permite que o Codex edite o código-fonte sem pedir permissão a cada alteração, ao mesmo tempo que impede mudanças diretas em.codex/config.tomlou nos hooks do Git em.git/hooks.Permite amplo acesso de leitura ao sistema de arquivos, respeitando as permissões existentes do usuário no sistema operacional. Compiladores, ambientes de execução e ferramentas de build dependem de SDKs, bibliotecas e configurações fora do repositório. Restringir as leituras ao espaço de trabalho impediria o funcionamento de muitos fluxos de trabalho comuns. A contrapartida é que arquivos sensíveis em outros locais da máquina também podem continuar acessíveis para leitura, como arquivos de configuração que contêm chaves de API.
Desativa o acesso à rede. Isso bloqueia uploads diretos para serviços externos, incluindo tentativas de exfiltrar dados que o comando pode ler. Também impede operações legítimas, como o download de dependências, que exigem acesso adicional.
Essas restrições impedem uma ampla classe de comportamentos indesejados, mas ações prejudiciais ainda são possíveis. Por exemplo, o agente poderia injetar código malicioso em um pacote instalado localmente, como node_modules/prettier. Essa alteração talvez não aparecesse em git status, porque node_modules costuma ser ignorado pelo Git. Se o editor do usuário executar essa cópia do Prettier ao salvar, o simples ato de salvar um arquivo poderia executar o código malicioso fora do sandbox do Codex. É por isso que adotamos uma abordagem de defesa em profundidade: o sandbox limita o que os comandos podem acessar, enquanto o treinamento e o alinhamento ajudam o modelo a usar esse acesso de acordo com a intenção do usuário.
Para orientações sobre como adaptar as permissões do sandbox e combiná-las com outras proteções em um ambiente corporativo, consulte o guia prático de segurança do Codex(abre em uma nova janela).
Máquinas virtuais e contêineres(abre em uma nova janela) são dois mecanismos populares de isolamento em sandbox, mas adotamos uma abordagem diferente no sandbox do Codex. Em vez de mover a execução para um ambiente separado a fim de oferecer isolamento, o Codex usa os recursos de sandbox de cada plataforma para restringir comandos executados no ambiente existente do usuário.
Para muitos desenvolvedores, o notebook funciona como um ambiente de desenvolvimento personalizado, que pode ser alterado a qualquer momento. Reproduzir esse ambiente em um contêiner Docker pode dar trabalho, e alguns fluxos de trabalho ainda dependem de ferramentas executadas no host.
Considere, por exemplo, usar o Codex para desenvolver um app iOS em um Mac. Se você decidisse isolar o Codex executando-o dentro do Docker, ele não conseguiria executar a cadeia de ferramentas de build do iOS, composta por executáveis nativos do Mac, nem iniciar o simulador de iPhone para rodar o código. Um fluxo de trabalho baseado em Docker poderia delegar builds e operações do simulador ao Mac host, mas essas operações seriam executadas fora do sandbox do contêiner e precisariam de restrições próprias. No Codex, preferimos manter a simplicidade investindo fortemente em isolamento específico de cada sistema operacional, para que o Codex possa executar no ambiente mais adequado à tarefa em questão.
O harness disponibiliza esses mecanismos de isolamento específicos de cada sistema operacional por meio de uma API comum ao macOS, Windows e Linux. Essa API recebe um comando e um perfil de permissões. Se o perfil de permissões permitir acesso limitado à rede, quem chama a API deverá fornecer um proxy de rede para aplicar esses limites:
Essa função inicia o processo em um sandbox e retorna um handle Child que o harness pode usar para aguardar sua conclusão. Cada processo filho herda as restrições de sandbox do pai. Assim, elas se aplicam a toda a árvore de processos iniciada pelo comando, inclusive aos descendentes que continuam em execução após o término do processo original.
O diagrama a seguir mostra como essas peças se conectam, da configuração à execução de um comando em sandbox. As próximas seções explicam cada etapa.

Como explicado em Desvendando o loop do agente do Codex, o harness do Codex é responsável por executar as chamadas de ferramentas geradas pelo modelo. Para tarefas de programação, a ferramenta mais usada é uma ferramenta de shell, que executa comandos de forma semelhante a um usuário em um shell interativo, como o Bash. Aqui, examinaremos a ferramenta de shell (abre em uma nova janela)exec_command(abre em uma nova janela) de execução única(abre em uma nova janela) para ilustrar como o harness usa o sandbox para oferecer as proteções desejadas.
Esta é uma versão simplificada de como a chamada à ferramenta exec_command seria atendida pelo harness do Codex sem isolamento em sandbox:
Para isolar o comando em sandbox, o harness substitui a chamada a subprocess.Popen() por spawn_command_under_sandbox(). O harness fornece o perfil de permissões e, quando necessário, o proxy de rede:
A ferramenta exec_command também permite que o modelo solicite permissões diferentes para um comando individual, mas cabe ao harness decidir se atende à solicitação:
Quando use_default é especificado, o harness usa a configuração padrão de sandbox para o turno. with_additional_permissions solicita acesso ampliado dentro do sandbox, enquanto require_escalated solicita execução fora dele. O harness avalia a solicitação com base nas preferências do usuário antes de executar o comando. (Por exemplo, o Codex pode consultar o usuário diretamente ou encaminhar a solicitação para revisão automática(abre em uma nova janela).) Se a execução for autorizada, o Codex passará os valores apropriados de permission_profile e network_proxy para perform_exec_command_with_sandboxing(), junto com os argumentos do comando da chamada original ExecCommandToolCall.
A ferramenta de shell é a principal usuária de spawn_command_under_sandbox(), e o harness também reutiliza sua infraestrutura de isolamento para operações como leitura e modificação de arquivos locais. Essa reutilização vai além do harness: o comando codex sandbox permite incorporar a execução de comandos em sandbox às suas próprias ferramentas, como veremos adiante. A seguir, veremos como os perfis de permissões são definidos.
Um perfil de permissões nomeado permite reutilizar as mesmas restrições de sistema de arquivos e rede em diferentes projetos. Você pode definir seus próprios perfis em [permissions], no arquivo config.toml. Por exemplo, a configuração a seguir define um perfil chamado dev que estende(abre em uma nova janela) o perfil integrado :workspace:
O perfil dev adiciona acesso de escrita a ~/build-cache e impõe restrições adicionais aos arquivos do espaço de trabalho. As entradas de sistema de arquivos podem conceder acesso somente de leitura (read), conceder acesso de leitura e escrita (write) ou bloquear totalmente o acesso (deny).
A tabela :workspace_roots permite definir regras para caminhos relativos às raízes do espaço de trabalho de um projeto. Por padrão, a CLI do Codex usa seu diretório de trabalho como única raiz do espaço de trabalho, enquanto o app do ChatGPT para desktop usa as pastas de código-fonte do projeto. O Codex aplica cada regra a todas as raízes. Assim, a entrada .vscode em dev torna o diretório .vscode somente de leitura em cada raiz.
Além de suas próprias regras, dev herda as seguintes proteções de :workspace:
Para configurar a rede do sandbox no Codex, há basicamente três opções:
Desativar todo o acesso à rede (padrão do perfil
:workspace)Ativar acesso total e direto à rede (padrão do perfil
:danger-full-access)Restringir o acesso à rede a um proxy, que decide o que permitir com base no perfil de permissões
Para dar a dev acesso direto à rede, defina permissions.dev.network.enabled = true no nível superior de config.toml. Isso concede acesso total à rede quando o proxy de rede está desativado.
Para restringir dev a um conjunto de domínios, ative o proxy de rede e configure suas regras de domínio:
As regras de domínio aceitam nomes exatos e padrões com curingas, e as regras explícitas de bloqueio têm precedência sobre as regras de permissão. Requisições a outros domínios exigem aprovação ou são bloqueadas, conforme descrito em Proxy de rede abaixo.
Usuários individuais podem definir configurações padrão válidas para todos os projetos e substituí-las em um projeto confiável específico. Administradores corporativos também podem querer definir configurações padrão para seus usuários e limitar quais delas eles podem alterar. O Codex oferece suporte aos dois casos por meio de configuração em camadas e requisitos gerenciados.
Como descrito em Precedência de configuração,(abre em uma nova janela) o Codex mescla configurações de vários arquivos config.toml. As tabelas são mescladas recursivamente, e a fonte de maior precedência prevalece quando há conflito de valores. Os arrays são substituídos por inteiro.
É por isso que os perfis de permissões usam tabelas para caminhos do sistema de arquivos e domínios de rede. Uma equipe pode adicionar ou substituir entradas individuais na própria configuração e herdar automaticamente as alterações de todas as outras entradas da configuração base da organização:
Administradores também podem fornecer requisitos gerenciados(abre em uma nova janela) por meio de requirements.toml para limitar as opções de configuração dos usuários. Esses requisitos podem vir de várias fontes, incluindo arquivos do sistema e políticas fornecidas pela nuvem. Um caso de uso comum é especificar allowed_permission_profiles para limitar o conjunto de perfis de permissões que um usuário corporativo pode selecionar. Por exemplo, um administrador poderia especificar estes requisitos na nuvem:
Os requisitos da nuvem teriam precedência sobre o arquivo de requisitos do sistema em /etc/codex/requirements.toml. Portanto, uma entrada nesse arquivo não pode substituir a definição explícita ":danger-full-access" = false acima. Deixar :workspace sem especificação permite que outra camada de requisitos forneça essa entrada. Perfis cujas entradas sejam false ou estejam ausentes da tabela final mesclada ficam indisponíveis.
Essa separação permite que as organizações imponham limites enquanto os usuários adaptam suas configurações dentro desses limites. Os perfis de permissões resultantes podem ser usados pelo harness ou aplicados diretamente a um comando, como veremos a seguir.
A CLI do Codex oferece um comando sandbox para facilitar a execução de qualquer comando sob um perfil de permissões definido na configuração do Codex. Ele costuma ser usado para testar o perfil, garantindo que o sandbox impeça o comportamento que foi projetado para bloquear.
Por exemplo, o comando a seguir tenta configurar o VS Code para executar um formatador automático malicioso ao salvar. Supondo que .vscode já exista, o perfil dev definido acima deve bloquear essa escrita porque o diretório é somente de leitura (codex sandbox trata cwd como raiz do espaço de trabalho por padrão):
De fato, no macOS, a operação falha com:
O comando codex sandbox disponibiliza o mecanismo de isolamento do Codex independentemente de uma sessão do agente. Você pode usar a mesma linguagem de configuração e a aplicação de restrições específica de cada plataforma para limitar comandos iniciados pelas suas próprias ferramentas.
Para um servidor MCP via stdio configurado em config.toml, o harness do Codex não tenta isolar em sandbox o comando usado para iniciar o servidor. O Codex não consegue inferir com confiabilidade quais arquivos ou serviços de rede esse servidor precisa acessar. Por isso, aplicar um perfil de sandbox padrão poderia impedir o funcionamento de uma configuração válida.
Por exemplo, a forma padrão de configurar o servidor MCP @modelcontextprotocol/server-memory(abre em uma nova janela) para uso com o Codex é a seguinte:
Como esse comando npx é executado fora de um sandbox, ele pode gravar arquivos e fazer requisições de rede com as mesmas permissões do usuário que executa o Codex, o que é permissivo demais. Para restringi-lo, podemos definir um perfil de permissões chamado memory-mcp e executar o comando npx original por meio de codex sandbox --permission-profile memory-mcp, limitando onde o servidor pode gravar e impedindo seu acesso à rede:
Antes de iniciar o servidor, crie seu diretório de dados e preencha o cache do npm com a versão fixada do pacote. Isso permite que npx --offline inicie o servidor sob um perfil que desativa o acesso à rede:
Com o pacote em cache, o Codex pode iniciar o servidor de memória sem acesso à rede, com escritas limitadas ao cache do npm e ao diretório de dados do servidor.
A implementação do sandbox transforma um perfil de permissões em restrições impostas pelo sistema operacional. A lógica central de tratamento de requisições e de políticas do proxy de rede é compartilhada entre os três principais sistemas operacionais, enquanto a configuração do proxy e sua integração com o sandbox são específicas de cada sistema. Examinaremos primeiro o proxy compartilhado e, depois, as implementações para macOS, Linux e Windows.
Para aplicar as restrições de rede de um perfil de permissões, o harness inicia um proxy de rede e configura o sandbox para permitir conexões com ele, bloqueando conexões diretas com hosts externos. O proxy verifica cada requisição em relação às regras de domínio do perfil para determinar se deve encaminhá-la.
No repositório do Codex, o proxy de rede é implementado no crate codex-network-proxy(abre em uma nova janela), que o harness usa como biblioteca, embora também possa ser compilado como uma CLI independente(abre em uma nova janela). Quando ativado, codex-network-proxy inicia por padrão um proxy HTTP e um proxy SOCKS5. Os endereços desses proxies são comunicados ao processo criado pelo sandbox por meio de variáveis de ambiente. Além de injetar variáveis de ambiente padrão, como HTTP_PROXY, HTTPS_PROXY e ALL_PROXY, também são injetadas várias variáveis de ambiente específicas de aplicativos(abre em uma nova janela) amplamente conhecidas, como PIP_PROXY. É verdade que nem todos os programas respeitam essas variáveis de ambiente. Se um programa tentar se conectar diretamente a um host externo, as restrições de sandbox do sistema operacional bloquearão a conexão, como descrito nas seções específicas de cada plataforma abaixo.
O proxy de rede é responsável por implementar as restrições de rede definidas em um perfil de permissões. Por exemplo, o perfil dev mostrado anteriormente permite requisições a *.openai.com e nega explicitamente requisições a evil.example. Quando uma requisição tem como destino um domínio que não corresponde a uma regra de permissão ou bloqueio, o proxy pode suspendê-la enquanto delega a aprovação ao harness. Assim como no exemplo do comando shell, o Codex pode consultar o usuário diretamente ou encaminhar a solicitação para revisão automática(abre em uma nova janela). Ao receber uma decisão, o proxy permite que a requisição prossiga ou a rejeita com uma resposta de erro.
A ordem importa aqui porque até uma consulta DNS pode vazar informações codificadas em um nome de host. Por isso, o proxy só resolve o nome de host solicitado depois de determinar que ele é permitido ou foi aprovado. Observe que regras amplas com curingas ou acesso a serviços DNS ainda podem permitir exfiltração via DNS.
No macOS, o Codex usa o Seatbelt(abre em uma nova janela), mecanismo de isolamento em sandbox da Apple cujas restrições são impostas pelo kernel. As políticas do Seatbelt são escritas em Sandbox Profile Language (SBPL), uma linguagem baseada em Scheme para expressar restrições de sandbox. O Codex chama o Seatbelt por meio do comando /usr/bin/sandbox-exec do macOS. Assim como codex sandbox, ele recebe opções que descrevem o sandbox, seguidas do comando a ser executado:
PROFILE é uma string em SBPL que contém entradas de configuração do sandbox. Por exemplo, o trecho de SBPL a seguir permite leitura e escrita em /dev/null e /dev/zero sob a política do sandbox:
Quando o proxy de rede é ativado em uma chamada ao sandbox, regras como as seguintes são injetadas no perfil para limitar as conexões às portas locais apropriadas:
O perfil base do Codex começa com (deny default), de modo que as conexões de saída permanecem bloqueadas, a menos que sejam explicitamente permitidas.
Por fim, o SBPL pode conter marcadores de posição usando (param):
que são preenchidos pelas opções -Dkey=value passadas a sandbox-exec.
Para implementar sua própria API de sandbox, o Codex monta a lista de argumentos(abre em uma nova janela) de sandbox-exec a partir de uma política base(abre em uma nova janela) e, em seguida, usa permission_profile e outras informações de contexto para ajustá-la e produzir o perfil completo do Seatbelt. O perfil resultante e os argumentos -D que o acompanham configuram as restrições impostas pelo Seatbelt, enquanto o proxy de rede aplica regras de rede adicionais. Com a lista completa de argumentos montada, chamar sandbox-exec é simples.
Gerar o SBPL correto é um desafio porque a Apple não documenta a linguagem para uso por terceiros. De fato, man sandbox-exec informa The sandbox-exec command is DEPRECATED (assim como a função de biblioteca sandbox_init(), documentada em man 3 sandbox_init). Apesar do aviso de descontinuação, o macOS ainda inclui perfis do Seatbelt em /usr/share/sandbox, e softwares de terceiros, incluindo Google Chrome e Chromium(abre em uma nova janela), continuam a depender do Seatbelt. Por isso, planejamos continuar usando o Seatbelt no futuro próximo.
Para criar o sandbox no Linux, o Codex combina bubblewrap(abre em uma nova janela) (bwrap), uma ferramenta de linha de comando para construir ambientes isolados, e seccomp-bpf(abre em uma nova janela), um mecanismo do kernel Linux para filtrar chamadas de sistema. Um utilitário auxiliar interno chamado codex-linux-sandbox coordena a configuração. Assim como sandbox-exec no macOS, ele recebe uma configuração de sandbox seguida de um comando a ser executado:
Quando é necessário isolar o sistema de arquivos ou rotear conexões pelo proxy, codex-linux-sandbox chama bwrap para criar o ambiente inicial do sandbox. Em seguida, bwrap inicia codex-linux-sandbox --apply-seccomp-then-exec dentro dele. Essa segunda chamada usa seccomp-bpf para aplicar restrições adicionais antes de executar o comando do usuário.
Para construir esse ambiente inicial do sandbox, o Codex usa bubblewrap para criar uma visão do sistema de arquivos em um namespace de montagem separado que reflete as regras de sistema de arquivos do perfil de permissões. Como isso é fundamental para a implementação do sandbox, o Codex inclui sua própria cópia de bwrap caso o usuário não tenha uma instalada, mas dá preferência a uma instalação compatível de (abre em uma nova janela)bwrap(abre em uma nova janela) encontrada no PATH, quando disponível. Na prática, algumas distribuições Linux desativam o acesso a namespaces de usuário por padrão(abre em uma nova janela), mas abrem uma exceção para o bwrap do sistema.
Assim como sandbox-exec, bwrap recebe uma configuração de sandbox seguida de um comando a ser executado dentro dele. Em vez de uma linguagem de configuração própria, como SBPL, bwrap usa flags individuais para a configuração. O Codex usa as seguintes opções para criar a visão do sistema de arquivos:
--bindpara especificar um arquivo ou diretório com permissão de escrita--ro-bindpara especificar um arquivo ou diretório somente de leitura--perms 000 --tmpfs DIR --remount-ro DIRpara negar acesso aDIR--perms 000 --ro-bind-data FD FILEpara negar acesso aFILE(em queFDé um descritor de arquivo aberto para/dev/null)
Para aplicar padrões glob de bloqueio usando essas opções, o Codex os expande em caminhos concretos antes de iniciar cada comando. Novos caminhos correspondentes não são adicionados automaticamente às restrições do sandbox desse comando.
O Codex também especifica opções como --unshare-ipc e --unshare-pid para impedir que o sandbox acesse outros tipos de recursos no host. Portanto, o bubblewrap afeta mais do que apenas a visibilidade dos arquivos.
Ao usar bubblewrap, o Codex passa --unshare-net sempre que a rede está desativada ou as conexões precisam passar pelo proxy de rede, criando um novo namespace de rede para o sandbox. Em seguida, usamos seccomp-bpf para aplicar restrições adicionais às chamadas de sistema de rede e às famílias de sockets disponíveis para o comando.
Especificamente, usamos o crate seccompiler(abre em uma nova janela) para compilar dinamicamente um programa BPF com base nos filtros desejados(abre em uma nova janela) e aplicá-lo a um processo inicializador no sandbox, para que as restrições sejam herdadas por toda a árvore de processos. Assim, bwrap não executa o comando do usuário, mas sim o inicializador codex-linux-sandbox com seus próprios argumentos de configuração, seguidos do comando do usuário:
Para aplicar filtros seccomp sem privilégios elevados, o inicializador define a flag no_new_privs do Linux(abre em uma nova janela). Essa flag é herdada pelos processos filhos e impede que obtenham privilégios adicionais ao executar outro programa, como um executável setuid.
Os filtros seccomp dependem da configuração de rede. Quando o acesso à rede está desativado, bloqueamos várias chamadas de sistema relacionadas à rede, como connect(2) e bind(2). Já quando o proxy de rede está ativado no sandbox, permitimos sockets IP para que o listener TCP criado por codex-linux-sandbox possa ser acessado, mas bloqueamos por padrão a criação de sockets de domínio Unix independentes, pois eles poderiam permitir acesso inadvertido a recursos do host.
Quando a configuração do sandbox exige o uso do proxy de rede, o harness do Codex cria uma instância do proxy que pode ser reutilizada em várias chamadas de codex-linux-sandbox na mesma thread do Codex. Cada sandbox precisa de uma forma de acessar esse proxy compartilhado a partir de seu namespace de rede isolado. O Codex disponibiliza um listener TCP de loopback dentro desse namespace e configura um processo fora do sandbox para aceitar suas conexões e retransmiti-las ao proxy.
Os diagramas a seguir ilustram essa configuração para um endpoint do proxy, com uma conexão passando por ele no último diagrama. Antes de iniciar o bubblewrap, codex-linux-sandbox cria um par de sockets Unix para servir como canal de controle e cria um processo filho via fork. O processo filho executa run_host_bridge() e aguarda o recebimento do descritor de arquivo do listener por esse canal:
Neste exemplo, o processo pai usa exec para substituir sua imagem de programa por bwrap. Isso configura o sandbox e inicia codex-linux-sandbox --apply-seccomp-then-exec dentro dele, repassando o FD do canal de controle:
Dentro do namespace de rede do sandbox, a segunda chamada de codex-linux-sandbox cria um listener TCP de loopback e passa seu descritor de arquivo pelo socket. O listener permanece associado ao namespace de rede do sandbox, permitindo que o processo filho que ficou fora dele aceite conexões de programas isolados no sandbox enquanto abre suas conexões de saída no namespace de rede do host. Após a transferência, ambos os processos fecham seus descritores do canal de controle, e o processo dentro do sandbox fecha sua cópia do listener.
Assim que o listener TCP está pronto, o processo dentro do sandbox define o valor apropriado de HTTP_PROXY(abre em uma nova janela) e das variáveis de ambiente relacionadas para apontar para esse listener. Em seguida, aplica seccomp antes de criar um processo filho e executar o comando do usuário:
O processo fora do sandbox mantém o listener aberto. Para cada conexão aceita, ele abre uma conexão com o proxy configurado e retransmite dados nos dois sentidos.
Esse mecanismo adicional dá ao comando seu próprio namespace de rede, incluindo uma interface de loopback separada. No macOS, o Seatbelt permite que o comando se conecte diretamente a portas específicas na interface de loopback do host. No Linux, o comando se conecta a um listener dentro de seu namespace isolado, e um processo fora do sandbox retransmite essas conexões ao proxy configurado. A transferência do descritor permite essa conexão sem expor o namespace de rede do host ao comando.
No início deste ano, implementamos o isolamento em sandbox no Windows e escrevemos sobre esse trabalho. Desde então, a Microsoft lançou uma biblioteca chamada MXC, junto com novos recursos para isolamento de processos no sistema operacional Windows. Estamos substituindo nosso sandbox atual por um que usa a biblioteca MXC.
O MXC (Microsoft eXecution Container) é um sistema de execução de código em sandbox(abre em uma nova janela) da Microsoft que oferece suporte a vários backends de contenção no Windows, Linux e macOS. O Codex oferece suporte a um sandbox baseado em MXC em dispositivos Windows compatíveis, usando isolamento nativo de processos para restringir comandos no ambiente existente do usuário.
Estamos migrando para o MXC para melhorar a segurança e a usabilidade e resolver várias limitações do nosso sandbox atual para Windows:
Necessidade de acesso elevado/de administrador para configurar o sandbox
Operações custosas/lentas de verificação e definição de ACLs
Estado persistente da configuração do sandbox na máquina host, incluindo
ACLs
Regras de firewall
Usuários do sandbox
Arquivos do plano de controle
O MXC disponibiliza um schema de configuração JSON(abre em uma nova janela). O Codex usa o SDK do MXC(abre em uma nova janela) para construir uma solicitação de execução que segue esse schema e contém o comando, o diretório de trabalho, o ambiente e as permissões. Essas permissões abrangem o acesso ao sistema de arquivos e à rede, além de recursos do Windows, como a área de trabalho e a área de transferência.
O Codex usa configurações fixas para vários controles, equilibrando compatibilidade e segurança. Ele permite leituras do Registro e mantém o acesso ao Win32k e à área de trabalho de que o PowerShell precisa durante a inicialização. O acesso à área de transferência, a injeção de entrada e os controles da área de trabalho e das configurações do sistema ficam desativados. Por fim, o MXC é impedido de recorrer à modificação das permissões do sistema de arquivos do host como alternativa.
O Codex converte as regras de sistema de arquivos e rede do perfil de permissões na configuração do MXC. Usando o perfil dev anterior e supondo que:
C:\,D:\eZ:\sejam as únicas unidades locais da máquina.A raiz do espaço de trabalho e o diretório de trabalho sejam
C:\work\demo.O diretório pessoal do usuário seja
D:\Users\dev, de modo que~/build-cachecorresponda aD:\Users\dev\build-cache.O padrão glob de bloqueio corresponda apenas a
C:\work\demo\config\dev.enveC:\work\demo\config\prod.env.
As configurações correspondentes do MXC incluiriam:
A política de sistema de arquivos do MXC nega acesso por padrão. Por isso, o Codex adiciona permissões somente de leitura às raízes das unidades locais para oferecer o acesso amplo de leitura permitido por esse perfil. Essas permissões se aplicam recursivamente, respeitando as permissões existentes do usuário no sistema operacional.
Há um detalhe: permissões de escrita na raiz de uma unidade não se aplicam recursivamente, então o Codex as expande para incluir os itens diretamente contidos na unidade que já existem.
Caminhos mais específicos prevalecem sobre as permissões dos caminhos ancestrais. Assim, C:\work\demo pode permitir escrita dentro de um C:\ somente de leitura, enquanto C:\work\demo\.git permanece somente de leitura.
Quando grafias diferentes ou aliases por links simbólicos/junções se referem ao mesmo caminho, o MXC aplica a permissão mais restritiva: o bloqueio prevalece sobre somente leitura, que prevalece sobre leitura e escrita.
O MXC aceita apenas caminhos concretos para bloqueio. Por isso, o Codex expande os padrões glob de bloqueio em arquivos e diretórios correspondentes antes da execução. Novos caminhos que correspondam ao padrão glob não são adicionados automaticamente enquanto o comando está em execução.
Regras de domínio como *.openai.com são aplicadas pelo proxy de rede compartilhado do Codex descrito anteriormente. O Codex executa esse proxy fora do sandbox e passa seus endereços ao comando pelas mesmas variáveis de ambiente padrão *_PROXY mencionadas anteriormente. O MXC bloqueia conexões externas diretas, mas permite conexões de loopback com o host, incluindo o acesso ao proxy. Outros serviços locais continuam acessíveis.
No macOS, Linux e Windows, o harness usa a mesma API de sandbox para iniciar comandos sob um perfil de permissões. As implementações específicas de cada plataforma cuidam da configuração necessária para aplicar essas restrições.
Escrever e executar código dá aos agentes uma forma flexível de resolver problemas que vão além do desenvolvimento de software. O sandbox do Codex permite que eles usem essa capacidade no ambiente existente do usuário, com limites explícitos de acesso ao sistema de arquivos e à rede. Ele é uma primitiva reutilizável dentro do harness, e o comando codex sandbox o disponibiliza para ferramentas que você mesmo cria.
À medida que os agentes assumem mais tarefas, queremos tornar o isolamento em sandbox viável para mais ferramentas e ambientes. Isso significa facilitar a configuração de permissões e aproveitar proteções melhores dos sistemas operacionais conforme elas se tornem disponíveis. Nosso objetivo é ampliar o que os agentes podem fazer, mantendo as pessoas no controle do que eles podem acessar.


