Por dentro da sandbox do Codex
Como o Codex executa comandos na sua máquina com limites controlados por si.
Na OpenAI, adotamos uma abordagem de defesa em profundidade(abre numa nova janela) para proteger os agentes. Embora os nossos investimentos em treino e alinhamento sejam fundamentais para este esforço, também implementamos funcionalidades no nosso harness de agentes, o Codex(abre numa nova janela), para oferecer proteções adicionais. Uma das ações mais comuns (e potencialmente arriscadas) do Codex é executar comandos no seu computador. Por isso, criámos a sandbox do Codex para que possa trabalhar no seu ambiente existente, dentro dos limites de sistema de ficheiros e de rede que controla.
Uma (abre numa nova janela)sandbox(abre numa nova janela) limita aquilo a que um programa pode aceder durante a execução. Numa tarefa de organização de fotografias, pode configurar a sandbox do Codex para permitir que os comandos leiam e modifiquem ficheiros em ~/Pictures, bloqueando o acesso à rede para impedir carregamentos. Para a revisão de código, pode permitir o acesso à documentação online, mantendo os ficheiros de código-fonte só de leitura. Os utilizadores configuram a sandbox do Codex através de (abre numa nova janela)perfis de permissões(abre numa nova janela), que definem as restrições de sistema de ficheiros e de rede de uma sessão do Codex.
Neste artigo, começamos pelos compromissos subjacentes às predefinições da sandbox do Codex, explicando depois a sua conceção e a forma como o harness a utiliza para executar comandos. Mostraremos como os utilizadores finais e as empresas podem adaptar as permissões às suas necessidades e como os programadores podem reutilizar a sandbox nas suas próprias ferramentas. Por fim, analisaremos como estas restrições são aplicadas no macOS, Linux e Windows.
No Codex, a nossa filosofia é definir predefinições conservadoras para a sandbox que, ainda assim, 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 escritas no espaço de trabalho, mantendo diretórios como
.gite.codexsó de leitura. Isto permite ao Codex editar código-fonte sem pedir autorização para cada alteração, impedindo alterações diretas a.codex/config.tomlou aos hooks do Git em.git/hooks.Permite um acesso alargado de leitura ao sistema de ficheiros, sujeito às permissões que o utilizador já tem no sistema operativo. Os compiladores, ambientes de execução e ferramentas de compilação dependem de SDKs, bibliotecas e configurações fora do repositório. Restringir as leituras ao espaço de trabalho impediria muitos fluxos de trabalho comuns de funcionar. Em contrapartida, os ficheiros sensíveis noutros locais da máquina também podem continuar legíveis (como ficheiros de configuração que contêm chaves de API).
Desativa o acesso à rede. Isto bloqueia carregamentos diretos para serviços externos, incluindo tentativas de exfiltrar dados que o comando consegue ler. Também impede operações legítimas, como a transferência de dependências, que exigem acesso adicional.
Estas restrições impedem uma ampla categoria de comportamentos indesejados, mas continuam a ser possíveis ações nocivas. Por exemplo, o agente pode injetar código malicioso num pacote instalado localmente, como node_modules/prettier. Essa alteração pode não aparecer em git status, porque node_modules é frequentemente ignorado pelo Git. Se o editor do utilizador executar essa cópia do Prettier ao guardar, o simples ato de guardar um ficheiro pode executar o código malicioso fora da sandbox do Codex. É por isso que adotamos uma abordagem de defesa em profundidade: a sandbox limita aquilo a que os comandos podem aceder, enquanto o treino e o alinhamento ajudam o modelo a usar esse acesso de acordo com a intenção do utilizador.
Para obter orientações sobre como adaptar as permissões da sandbox e combiná-las com outras proteções num ambiente empresarial, consulte o Guia prático de segurança do Codex(abre numa nova janela).
As máquinas virtuais e os contentores(abre numa nova janela) são dois mecanismos populares de isolamento em sandbox, mas adotamos uma abordagem diferente na sandbox do Codex. Em vez de transferir a computação para um ambiente separado para garantir o isolamento, o Codex utiliza os mecanismos de sandbox de cada plataforma para restringir os comandos executados no ambiente existente do utilizador.
Para muitos programadores, o portátil serve de ambiente de desenvolvimento à medida, que podem alterar a qualquer momento. Reproduzir esse ambiente num contentor Docker pode dar trabalho, e alguns fluxos de trabalho continuam a depender de ferramentas executadas no anfitrião.
Considere, por exemplo, a utilização do Codex para desenvolver uma aplicação iOS num Mac. Se decidisse isolar o Codex numa sandbox executando-o dentro do Docker, o Codex não conseguiria executar a cadeia de ferramentas de compilação para iOS, composta por executáveis nativos do Mac, nem iniciar o simulador de iPhone para executar o código. Um fluxo de trabalho baseado no Docker poderia delegar as compilações e as operações do simulador no Mac anfitrião, mas essas operações seriam executadas fora da sandbox do contentor e precisariam das suas próprias restrições. No Codex, preferimos simplificar, investindo fortemente no isolamento em sandbox específico de cada sistema operativo, para que o Codex possa ser executado no ambiente mais adequado à tarefa em causa.
O harness disponibiliza estes mecanismos de sandbox específicos de cada sistema operativo através de uma API comum ao macOS, Windows e Linux. Esta API recebe um comando e um perfil de permissões. Se o perfil de permissões permitir acesso limitado à rede, quem faz a chamada tem de fornecer um proxy de rede para aplicar esses limites:
Esta função inicia o processo numa sandbox e devolve um identificador Child, que o harness pode utilizar para aguardar que o processo termine. Cada processo filho herda as restrições de sandbox do processo pai, pelo que estas se aplicam a toda a árvore de processos iniciada pelo comando, mesmo aos descendentes que continuam em execução depois de o processo original terminar.
O diagrama seguinte mostra como estas peças se articulam, desde a configuração até à execução de um comando em sandbox. As secções seguintes explicam cada etapa.

Conforme explicado em Desvendar o ciclo do agente Codex, o harness do Codex é responsável por executar as chamadas de ferramentas geradas pelo modelo. Nas tarefas de programação, a ferramenta mais utilizada é uma ferramenta de shell, que executa comandos de forma semelhante à de um utilizador numa shell interativa como o Bash. Aqui analisaremos a ferramenta de shell (abre numa nova janela)exec_command(abre numa nova janela) one-shot(abre numa nova janela) para ilustrar como o harness utiliza a sandbox para obter as proteções pretendidas.
Esta é uma versão simplificada de como a chamada da ferramenta exec_command seria processada pelo harness do Codex sem isolamento em sandbox:
Para isolar o comando numa 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 ao modelo pedir permissões diferentes para um comando individual, mas cabe ao harness decidir se concede o pedido:
Quando é especificado use_default, o harness utiliza a configuração de sandbox predefinida para esse turno. with_additional_permissions pede acesso alargado dentro da sandbox, enquanto require_escalated pede a execução fora dela. O harness avalia o pedido com base nas preferências do utilizador antes de executar o comando. (Por exemplo, o Codex pode pedir aprovação diretamente ao utilizador ou encaminhar o pedido para revisão automática(abre numa nova janela).) Se a execução for autorizada, o Codex passa os valores adequados de permission_profile e network_proxy a perform_exec_command_with_sandboxing(), juntamente com os argumentos do comando da chamada ExecCommandToolCall original.
A ferramenta de shell é a principal utilizadora de spawn_command_under_sandbox(), e o harness também reutiliza a sua infraestrutura de sandbox para operações como a leitura e a modificação de ficheiros locais. Esta reutilização vai além do harness: o comando codex sandbox permite incorporar a execução de comandos em sandbox nas suas próprias ferramentas, como veremos mais adiante. A seguir, veremos como são definidos os perfis de permissões.
Um perfil de permissões com nome permite reutilizar as mesmas restrições de sistema de ficheiros e de rede em vários projetos. Pode definir os seus próprios perfis em [permissions], no ficheiro config.toml. Por exemplo, a configuração seguinte define um perfil chamado dev que estende(abre numa nova janela) o perfil integrado :workspace:
O perfil dev adiciona acesso de escrita a ~/build-cache e impõe restrições adicionais aos ficheiros no espaço de trabalho. As entradas de sistema de ficheiros podem conceder acesso só 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 predefinição, a CLI do Codex utiliza o seu diretório de trabalho como única raiz do espaço de trabalho, enquanto a aplicação ChatGPT para computador utiliza as pastas de código-fonte do projeto. O Codex aplica cada regra a todas as raízes, pelo que a entrada .vscode em dev torna o diretório .vscode só de leitura sob cada raiz.
Além das suas próprias regras, dev herda as seguintes proteções de :workspace:
Em termos gerais, existem três opções para configurar a rede da sandbox no Codex:
Desativar todo o acesso à rede (predefinição do perfil
:workspace)Ativar o acesso total e direto à rede (predefinição do perfil
:danger-full-access)Restringir o acesso à rede a um proxy, que decide o que deixa passar 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. Isto 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 as respetivas regras de domínio:
As regras de domínio suportam nomes exatos e padrões com caracteres universais, sendo que as regras explícitas de recusa prevalecem sobre as regras de autorização. Os pedidos a outros domínios exigem aprovação ou são bloqueados, conforme descrito abaixo em Proxy de rede.
Os utilizadores individuais podem configurar predefinições aplicáveis a vários projetos e substituí-las para um projeto de confiança específico. Os administradores empresariais também podem querer configurar predefinições para os seus utilizadores e limitar as definições que estes podem alterar. O Codex suporta ambas as possibilidades através de configuração por camadas e requisitos geridos.
Conforme descrito em Precedência da configuração,(abre numa nova janela) o Codex combina definições de vários ficheiros config.toml. As tabelas são combinadas recursivamente, prevalecendo a origem com maior precedência quando há valores em conflito. Os arrays são substituídos na íntegra.
É por isso que os perfis de permissões utilizam tabelas para os caminhos do sistema de ficheiros e os domínios de rede. Uma equipa pode adicionar ou substituir entradas individuais na sua própria configuração e herdar automaticamente alterações a todas as outras entradas da configuração de base da organização:
Os administradores também podem fornecer requisitos geridos(abre numa nova janela) através de requirements.toml para limitar as opções de configuração dos utilizadores. Estes requisitos podem ter várias origens, incluindo ficheiros do sistema e políticas fornecidas pela cloud. Um caso de utilização comum consiste em especificar allowed_permission_profiles para limitar o conjunto de perfis de permissões que um utilizador empresarial pode selecionar. Por exemplo, um administrador poderia especificar estes requisitos da cloud:
Os requisitos da cloud teriam precedência sobre o ficheiro de requisitos do sistema em /etc/codex/requirements.toml, pelo que uma entrada nesse ficheiro não pode substituir a definição explícita ":danger-full-access" = false acima. Deixar :workspace por especificar permite que outra camada de requisitos forneça essa entrada. Os perfis cujas entradas sejam false ou estejam ausentes da tabela final combinada não ficam disponíveis.
Esta separação permite que as organizações imponham limites e que os utilizadores adaptem a sua configuração dentro desses limites. Os perfis de permissões resultantes podem ser utilizados pelo harness ou aplicados diretamente a um comando, como veremos a seguir.
A CLI do Codex disponibiliza um comando sandbox para facilitar a execução de qualquer comando com um perfil de permissões definido na configuração do Codex. Este comando é habitualmente utilizado para testar o perfil e garantir que a sandbox impede o comportamento que foi concebida para bloquear.
Por exemplo, o comando seguinte tenta configurar o VS Code para executar um formatador automático malicioso ao guardar. Assumindo que .vscode já existe, o perfil dev definido acima deve bloquear esta escrita, porque esse diretório é só de leitura (codex sandbox trata cwd como raiz do espaço de trabalho por predefinição):
De facto, no macOS, a operação falha com:
O comando codex sandbox disponibiliza o mecanismo de sandbox do Codex independentemente de uma sessão de agente. Pode utilizar a mesma linguagem de configuração e os mecanismos de aplicação específicos de cada plataforma para restringir comandos iniciados pelas suas próprias ferramentas.
No caso de um servidor MCP stdio configurado em config.toml, o harness do Codex não tenta isolar numa sandbox o comando utilizado para iniciar o servidor. O Codex não consegue inferir de forma fiável de que ficheiros ou serviços de rede esse servidor precisa, pelo que aplicar um perfil de sandbox predefinido poderia impedir uma configuração válida de funcionar.
Por exemplo, a forma habitual de configurar o servidor MCP @modelcontextprotocol/server-memory(abre numa nova janela) para utilização com o Codex é a seguinte:
Como este comando npx é executado fora de uma sandbox, pode escrever ficheiros e fazer pedidos de rede com as mesmas permissões do utilizador que executa o Codex, o que é demasiado permissivo. Para o restringir, podemos definir um perfil de permissões chamado memory-mcp e executar o comando npx original através de codex sandbox --permission-profile memory-mcp, limitando os locais onde o servidor pode escrever e impedindo-o de aceder à rede:
Antes de iniciar o servidor, crie o respetivo diretório de dados e coloque na cache do npm a versão fixada do pacote. Isto permite que npx --offline inicie o servidor com um perfil que desativa o acesso à rede:
Assim que o pacote estiver na cache, o Codex pode iniciar o servidor de memória sem acesso à rede, com as escritas limitadas à cache do npm e ao diretório de dados do servidor.
A implementação da sandbox transforma um perfil de permissões em restrições aplicadas pelo sistema operativo. A lógica central de tratamento de pedidos e de políticas do proxy de rede é partilhada pelos três principais sistemas operativos, enquanto a configuração do proxy e a integração com a sandbox são específicas de cada sistema. Analisaremos primeiro o proxy partilhado 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 a sandbox para permitir ligações a esse proxy, bloqueando ligações diretas a anfitriões externos. O proxy verifica cada pedido face às regras de domínio do perfil para determinar se o deve encaminhar.
No repositório do Codex, o proxy de rede está implementado na crate codex-network-proxy(abre numa nova janela), que o harness utiliza como biblioteca, embora também possa ser compilada como uma CLI autónoma(abre numa nova janela). Quando ativado, codex-network-proxy inicia, por predefinição, um proxy HTTP e um proxy SOCKS5. Os endereços destes proxies são comunicados ao processo criado pela sandbox através de variáveis de ambiente. Além de variáveis de ambiente padrão como HTTP_PROXY, HTTPS_PROXY e ALL_PROXY, são também injetadas várias variáveis de ambiente específicas de aplicações(abre numa nova janela) bem conhecidas (como PIP_PROXY). É certo que nem todos os programas respeitam estas variáveis de ambiente. Se um programa tentar uma ligação direta a um anfitrião externo, as restrições de sandbox do sistema operativo bloqueiam-na, conforme descrito nas secções específicas de cada plataforma abaixo.
O proxy de rede é responsável por implementar as restrições de rede definidas num perfil de permissões. Por exemplo, o perfil dev apresentado anteriormente permite pedidos a *.openai.com e recusa explicitamente pedidos a evil.example. Quando um pedido se destina a um domínio que não corresponde a nenhuma regra de autorização ou recusa, o proxy pode suspender o pedido enquanto delega a aprovação no harness. Tal como no exemplo do comando de shell, o Codex pode pedir aprovação diretamente ao utilizador ou encaminhar o pedido para revisão automática(abre numa nova janela). Ao receber uma decisão, o proxy permite que o pedido prossiga ou rejeita-o com uma resposta de erro.
A ordem é importante neste caso, porque até uma consulta DNS pode revelar informações codificadas num nome de anfitrião. Por isso, o proxy só resolve o nome de anfitrião solicitado depois de determinar que é permitido ou foi aprovado. Tenha em atenção que regras abrangentes com caracteres universais ou o acesso a serviços DNS podem continuar a permitir a exfiltração através de DNS.
No macOS, o Codex utiliza o Seatbelt(abre numa nova janela), o mecanismo de sandbox da Apple aplicado 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 invoca o Seatbelt através do comando /usr/bin/sandbox-exec do macOS. Tal como codex sandbox, recebe opções que descrevem a sandbox, seguidas do comando a executar:
PROFILE é uma string de SBPL que contém entradas para configurar a sandbox. Por exemplo, o seguinte excerto de SBPL permite a leitura e a escrita em /dev/null e /dev/zero ao abrigo da política da sandbox:
Quando o proxy de rede é ativado como parte de uma invocação da sandbox, são injetadas no perfil regras como as seguintes para limitar as ligações às portas locais adequadas:
O perfil de base do Codex começa com (deny default), pelo que as ligações de saída permanecem bloqueadas, salvo autorização explícita.
Por fim, o SBPL pode conter marcadores de posição que utilizam (param):
que são preenchidos pelas opções -Dkey=value passadas a sandbox-exec.
Para implementar a sua própria API de sandbox, o Codex constrói a lista de argumentos(abre numa nova janela) de sandbox-exec a partir de uma política de base(abre numa nova janela) e utiliza depois permission_profile e outro contexto para a ajustar e produzir o perfil completo do Seatbelt. O perfil resultante e os argumentos -D que o acompanham configuram as restrições aplicadas pelo Seatbelt, enquanto o proxy de rede aplica regras de rede adicionais. Depois de reunir a lista completa de argumentos, a invocação de sandbox-exec é simples.
Gerar o SBPL correto é um desafio, porque a Apple não documenta a linguagem para utilização por terceiros. De facto, man sandbox-exec indica The sandbox-exec command is DEPRECATED (tal como a função de biblioteca sandbox_init(), documentada em man 3 sandbox_init). Apesar do aviso de descontinuação, o macOS continua a incluir perfis do Seatbelt em /usr/share/sandbox, e o software de terceiros, incluindo o Google Chrome e o Chromium(abre numa nova janela), continua a depender do Seatbelt. Por isso, planeamos continuar a utilizar o Seatbelt no futuro previsível.
Para criar a sandbox no Linux, o Codex combina bubblewrap(abre numa nova janela) (bwrap), uma ferramenta de linha de comandos para construir ambientes isolados, com seccomp-bpf(abre numa nova janela), um mecanismo do kernel Linux para filtrar chamadas de sistema. Um utilitário interno chamado codex-linux-sandbox coordena a configuração. Tal como sandbox-exec no macOS, recebe uma configuração de sandbox seguida de um comando a executar:
Quando é necessário isolar o sistema de ficheiros ou encaminhar tráfego por um proxy, codex-linux-sandbox invoca bwrap para criar o ambiente inicial da sandbox. Em seguida, bwrap inicia codex-linux-sandbox --apply-seccomp-then-exec dentro desse ambiente. Esta segunda invocação utiliza seccomp-bpf para aplicar restrições adicionais antes de executar o comando do utilizador.
Para construir esse ambiente inicial da sandbox, o Codex utiliza bubblewrap para criar uma vista do sistema de ficheiros num espaço de nomes de montagem separado, que reflete as regras de sistema de ficheiros do perfil de permissões. Como isto é fundamental para a implementação da sandbox, o Codex inclui a sua própria cópia de bwrap, caso o utilizador não o tenha instalado, mas dá preferência a uma instalação compatível de (abre numa nova janela)bwrap(abre numa nova janela) encontrada em PATH, quando disponível. Na prática, algumas distribuições Linux desativam o acesso aos espaços de nomes de utilizador por predefinição(abre numa nova janela), mas abrem uma exceção para o bwrap do sistema.
Tal como sandbox-exec, bwrap recebe uma configuração de sandbox seguida de um comando a executar dentro dela. Em vez de uma linguagem de configuração própria, como SBPL, bwrap utiliza opções individuais para a configuração. O Codex utiliza as seguintes opções para criar a vista do sistema de ficheiros:
--bindpara especificar um ficheiro ou diretório com permissão de escrita--ro-bindpara especificar um ficheiro ou diretório só de leitura--perms 000 --tmpfs DIR --remount-ro DIRpara recusar o acesso aDIR--perms 000 --ro-bind-data FD FILEpara recusar o acesso aFILE(em queFDé um descritor de ficheiro aberto para/dev/null)
Para aplicar padrões glob de recusa com estas opções, o Codex expande-os em caminhos concretos antes de iniciar cada comando. Os novos caminhos que correspondam aos padrões não são adicionados automaticamente às restrições da sandbox desse comando.
O Codex também especifica opções como --unshare-ipc e --unshare-pid para impedir que a sandbox aceda a outros tipos de recursos no anfitrião, pelo que o bubblewrap afeta mais do que a visibilidade dos ficheiros.
Ao utilizar bubblewrap, o Codex passa --unshare-net sempre que a rede está desativada ou as ligações têm de passar pelo proxy de rede, o que cria um novo espaço de nomes de rede para a sandbox. Em seguida, utilizamos seccomp-bpf para aplicar restrições adicionais às chamadas de sistema de rede e às famílias de sockets disponíveis para o comando.
Em concreto, utilizamos a crate seccompiler(abre numa nova janela) para compilar dinamicamente um programa BPF com base nos filtros pretendidos(abre numa nova janela) e aplicá-lo a um processo de arranque na sandbox, para que toda a árvore de processos herde as restrições. Assim, bwrap não executa o comando do utilizador, mas sim o programa de arranque codex-linux-sandbox, com os seus próprios argumentos de configuração, seguidos do comando do utilizador:
Para aplicar filtros seccomp sem privilégios elevados, o programa de arranque ativa a flag no_new_privs do Linux(abre numa nova janela). Esta flag é herdada pelos processos filhos e impede-os de obter 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 com a rede, como connect(2) e bind(2). Porém, quando o proxy de rede está ativado na sandbox, permitimos sockets IP para que seja possível aceder ao socket de escuta TCP criado por codex-linux-sandbox, mas bloqueamos por predefinição a criação de sockets de domínio Unix autónomos, pois poderiam permitir acesso inadvertido a recursos do anfitrião.
Quando a configuração da sandbox justifica a utilização do proxy de rede, o harness do Codex cria uma instância do proxy que pode ser reutilizada em várias invocações de codex-linux-sandbox na mesma thread do Codex. Cada sandbox precisa de uma forma de aceder a esse proxy partilhado a partir do seu espaço de nomes de rede isolado. O Codex disponibiliza um socket de escuta TCP de loopback nesse espaço de nomes e prepara um processo fora da sandbox para aceitar as ligações e retransmiti-las para o proxy.
Os diagramas seguintes ilustram esta configuração para um endpoint do proxy, com uma ligação através dele representada no último diagrama. Antes de iniciar bubblewrap, codex-linux-sandbox cria um par de sockets Unix para servir de canal de controlo e bifurca-se (fork). O processo filho executa run_host_bridge() e aguarda a receção do descritor de ficheiro do socket de escuta através desse canal:
Neste exemplo, o processo pai utiliza exec para substituir a sua imagem de programa por bwrap. Este configura a sandbox e inicia codex-linux-sandbox --apply-seccomp-then-exec dentro dela, passando o descritor de ficheiro do canal de controlo:
Dentro do espaço de nomes de rede da sandbox, a segunda invocação de codex-linux-sandbox cria um socket de escuta TCP de loopback e passa o respetivo descritor de ficheiro através do socket. O socket de escuta mantém-se associado ao espaço de nomes de rede da sandbox, permitindo que o processo filho que ficou fora da sandbox aceite ligações de programas dentro dela, enquanto abre as suas ligações a montante no espaço de nomes de rede do anfitrião. Após a passagem do descritor, ambos os processos fecham os seus descritores do canal de controlo, e o processo dentro da sandbox fecha a sua cópia do socket de escuta.
Assim que o socket de escuta TCP estiver pronto, o processo dentro da sandbox define o valor adequado de HTTP_PROXY(abre numa nova janela) e das variáveis de ambiente relacionadas para apontarem para esse socket. Em seguida, aplica seccomp antes de criar um processo filho e executar o comando do utilizador:
O processo fora da sandbox mantém o socket de escuta aberto. Para cada ligação aceite, abre uma ligação ao proxy configurado e retransmite dados em ambos os sentidos.
Este mecanismo adicional dá ao comando o seu próprio espaço de nomes de rede, incluindo uma interface de loopback separada. No macOS, o Seatbelt permite que o comando se ligue diretamente às portas especificadas na interface de loopback do anfitrião. No Linux, o comando liga-se antes a um socket de escuta dentro do seu espaço de nomes isolado, e um processo fora da sandbox retransmite essas ligações para o proxy configurado. A passagem do descritor torna esta ligação possível sem expor o espaço de nomes de rede do anfitrião ao comando.
No início deste ano, implementámos o isolamento em sandbox no Windows e escrevemos sobre esse trabalho. Desde então, a Microsoft lançou uma biblioteca chamada MXC, juntamente com novas funcionalidades de isolamento de processos no sistema operativo Windows. Estamos a substituir a nossa sandbox atual por uma que utiliza a biblioteca MXC.
O MXC (Microsoft eXecution Container) é um sistema de execução de código em sandbox(abre numa nova janela) da Microsoft que suporta vários backends de contenção no Windows, Linux e macOS. O Codex suporta uma sandbox baseada no MXC em dispositivos Windows compatíveis, utilizando o isolamento nativo de processos para restringir comandos no ambiente existente do utilizador.
Estamos a migrar para o MXC para melhorar a segurança e a usabilidade, resolvendo várias limitações da nossa sandbox atual para Windows:
Necessidade de privilégios elevados ou de administrador para configurar a sandbox
Operações dispendiosas e lentas de verificação e definição de ACLs
Estado de configuração da sandbox persistente na máquina anfitriã, incluindo
ACLs
Regras de firewall
Utilizadores da sandbox
Ficheiros do plano de controlo
O MXC disponibiliza um schema de configuração JSON(abre numa nova janela). O Codex utiliza o SDK do MXC(abre numa nova janela) para construir um pedido 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 ficheiros e à rede, bem como a recursos do Windows, como o ambiente de trabalho e a área de transferência.
O Codex utiliza definições fixas para vários controlos, de modo a equilibrar compatibilidade e segurança. Permite leituras do registo e mantém o acesso ao Win32k e ao ambiente de trabalho de que o PowerShell precisa no arranque. O acesso à área de transferência, a injeção de eventos de entrada e os controlos do ambiente de trabalho e das definições do sistema estão desativados. Por fim, impede-se que o MXC recorra à alteração das permissões do sistema de ficheiros do anfitrião como alternativa.
O Codex converte as regras de sistema de ficheiros e de rede do perfil de permissões na configuração do MXC. Utilizando o perfil dev anterior e presumindo que:
C:\,D:\eZ:\são as únicas unidades locais da máquina.A raiz do espaço de trabalho e o diretório de trabalho são
C:\work\demo.O diretório pessoal do utilizador é
D:\Users\dev, pelo que~/build-cacheé resolvido paraD:\Users\dev\build-cache.O padrão glob de recusa corresponde apenas a
C:\work\demo\config\dev.enveC:\work\demo\config\prod.env.
As definições correspondentes do MXC incluiriam:
A política de sistema de ficheiros do MXC recusa o acesso por predefinição. Por isso, o Codex adiciona permissões só de leitura para as raízes das unidades locais, para permitir o acesso alargado de leitura previsto neste perfil. Estas permissões aplicam-se recursivamente, sujeitas às permissões que o utilizador já tem no sistema operativo.
Há uma particularidade: as permissões de escrita na raiz de uma unidade não se aplicam recursivamente, pelo que o Codex as expande para incluir os ficheiros e diretórios imediatamente abaixo dessa raiz.
Os caminhos mais específicos prevalecem sobre as permissões dos diretórios ascendentes, pelo que C:\work\demo pode permitir escrita sob uma raiz C:\ só de leitura, enquanto C:\work\demo\.git permanece só de leitura.
Quando diferentes formas de escrever um caminho ou aliases de ligações simbólicas ou junções apontam para o mesmo caminho, o MXC aplica a permissão mais restritiva: a recusa prevalece sobre a leitura, que prevalece sobre a leitura e escrita.
O MXC só aceita caminhos concretos de recusa, pelo que o Codex expande os padrões glob de recusa para os ficheiros e diretórios correspondentes antes do arranque. Os novos caminhos que correspondam ao padrão glob não são adicionados automaticamente enquanto o comando está em execução.
As regras de domínio, como *.openai.com, são aplicadas pelo proxy de rede partilhado do Codex descrito anteriormente. O Codex executa esse proxy fora da sandbox e passa os seus endereços ao comando através das mesmas variáveis de ambiente padrão *_PROXY mencionadas anteriormente. O MXC bloqueia ligações externas diretas, permitindo ligações à interface de loopback do anfitrião, incluindo o acesso ao proxy. Os outros serviços locais continuam acessíveis.
No macOS, Linux e Windows, o harness utiliza a mesma API de sandbox para iniciar comandos com um perfil de permissões. As implementações específicas de cada plataforma tratam 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 para além do desenvolvimento de software. A sandbox do Codex permite-lhes utilizar essa capacidade no ambiente existente do utilizador, com limites explícitos de acesso ao sistema de ficheiros e à rede. É uma primitiva reutilizável dentro do harness, e o comando codex sandbox disponibiliza-a às ferramentas que desenvolver.
À medida que os agentes assumem mais tarefas, queremos tornar o isolamento em sandbox prático para mais ferramentas e ambientes. Isto significa facilitar a configuração de permissões e tirar partido de melhores proteções dos sistemas operativos à medida que ficam disponíveis. O nosso objetivo é alargar aquilo que os agentes podem fazer, mantendo nas mãos das pessoas o controlo daquilo a que podem aceder.


