Sa loob ng Codex sandbox
Paano nagpapatakbo ang Codex ng mga command sa iyong machine sa loob ng mga limitasyong kontrolado mo.
Sa OpenAI, gumagamit kami ng patong-patong na depensa(magbubukas sa bagong window) upang maprotektahan ang mga agent. Bagama't pundasyon nito ang aming pamumuhunan sa pagsasanay at alignment, nagpapatupad din kami ng mga feature sa aming harness para sa mga agent, ang Codex(magbubukas sa bagong window), upang magbigay ng dagdag na proteksyon. Dahil isa sa pinakamadalas (at posibleng mapanganib) na ginagawa ng Codex ang pagpapatakbo ng mga command sa iyong computer, binuo namin ang Codex sandbox upang makapagtrabaho ito sa kasalukuyan mong environment, sa loob ng mga limitasyon sa filesystem at network na ikaw ang kumokontrol.
Nililimitahan ng isang (magbubukas sa bagong window)sandbox(magbubukas sa bagong window) ang maa-access ng isang program habang tumatakbo ito. Para sa pag-aayos ng mga larawan, maaari mong i-configure ang Codex sandbox upang payagang bumasa at magbago ng mga file sa ~/Pictures ang mga command, habang bina-block ang network access upang maiwasan ang pag-upload. Para sa code review, maaari mong payagan ang access sa online na dokumentasyon habang pinananatiling read-only ang mga source file. Kino-configure ng mga user ang Codex sandbox sa pamamagitan ng mga (magbubukas sa bagong window)permission profile(magbubukas sa bagong window), na nagtatakda ng mga restriksyon sa filesystem at network para sa isang Codex session.
Sa artikulong ito, uunahin namin ang mga kompromiso sa likod ng mga default ng sandbox ng Codex, saka ipapaliwanag ang disenyo ng sandbox at kung paano ito ginagamit ng harness upang magpatakbo ng mga command. Ipapakita namin kung paano maiaangkop ng mga end user at enterprise ang mga pahintulot nito sa kanilang pangangailangan, at kung paano magagamit muli ng mga developer ang sandbox sa sarili nilang mga tool. Panghuli, susuriin namin kung paano ipinapatupad ang mga restriksyong ito sa macOS, Linux, at Windows.
Sa Codex, layunin naming magtakda ng mahihigpit na default para sa sandbox na nagpapahintulot pa rin ng makabuluhang trabaho. Halimbawa, kapag Git repository ang workspace root, ang built-in na :workspace permission profile ay:
Nagpapahintulot ng pagsulat sa loob ng workspace, habang pinananatiling read-only ang mga directory tulad ng
.gitat.codex. Dahil dito, nae-edit ng Codex ang source code nang hindi humihingi ng pahintulot sa bawat pagbabago, habang hinahadlangan ang direktang pagbabago sa.codex/config.tomlo mga Git hook sa ilalim ng.git/hooks.Nagpapahintulot ng malawak na pagbasa sa filesystem, alinsunod sa kasalukuyang mga pahintulot sa OS ng user. Umaasa ang mga compiler, runtime, at build tool sa mga SDK, library, at configuration sa labas ng repository. Hindi gagana ang maraming karaniwang workflow kung lilimitahan ang pagbasa sa workspace. Ang kapalit nito ay maaaring mabasa rin ang mga sensitibong file sa ibang bahagi ng machine (tulad ng mga config file na may API key).
Nagdi-disable ng network access. Bina-block nito ang direktang pag-upload sa mga panlabas na serbisyo, kabilang ang mga pagtatangkang ilabas nang palihim ang data na nababasa ng command. Hinahadlangan din nito ang mga lehitimong operasyon tulad ng pag-download ng mga dependency, na nangangailangan ng dagdag na access.
Napipigilan ng mga restriksyong ito ang maraming uri ng hindi kanais-nais na gawain, pero posible pa rin ang mga mapaminsalang aksyon. Halimbawa, maaaring magpasok ang agent ng malisyosong code sa isang lokal na naka-install na package tulad ng node_modules/prettier. Maaaring hindi lumabas ang pagbabagong iyon sa git status dahil madalas na hindi pinapansin ng Git ang node_modules. Kung pinapatakbo ng editor ng user ang kopyang iyon ng Prettier sa pag-save, maaaring mapatakbo ang malisyosong code sa labas ng Codex sandbox sa simpleng pag-save lang ng file. Ito ang dahilan kung bakit gumagamit kami ng patong-patong na depensa: nililimitahan ng sandbox ang maa-access ng mga command, habang tinutulungan ng pagsasanay at alignment ang modelo na gamitin ang access na iyon ayon sa layunin ng user.
Para sa gabay sa pag-angkop ng mga pahintulot sa sandbox at pagsasama ng mga ito sa iba pang proteksyon sa enterprise environment, tingnan ang gabay sa seguridad ng Codex(magbubukas sa bagong window).
Dalawang karaniwang mekanismo para sa sandboxing ang mga virtual machine at container(magbubukas sa bagong window), pero iba ang diskarte namin sa Codex sandbox. Sa halip na ilipat ang computation sa hiwalay na environment upang maihiwalay ito, ginagamit ng Codex ang mga kakayahan sa sandboxing ng bawat platform upang limitahan ang mga command na tumatakbo sa kasalukuyang environment ng user.
Para sa maraming developer, ang kanilang laptop ay isang pasadyang dev environment na maaari nilang baguhin anumang oras. Maaaring mangailangan ng trabaho ang pagkopya ng environment na iyon sa isang Docker container, at umaasa pa rin ang ilang workflow sa mga tool na tumatakbo sa host.
Halimbawa, isipin ang paggamit ng Codex upang bumuo ng iOS app sa isang Mac. Kung ipa-sandbox mo ang Codex sa pamamagitan ng pagpapatakbo nito sa loob ng Docker, hindi nito mapapatakbo ang iOS build toolchain na binubuo ng mga native na Mac executable, ni mabubuksan ang iPhone simulator upang patakbuhin ang code. Maaaring ipasa ng Docker-based na workflow ang mga build at operasyon ng simulator sa Mac host, pero tatakbo ang mga iyon sa labas ng sandbox ng container at mangangailangan ng sarili nilang mga restriksyon. Para sa Codex, mas gusto naming panatilihing simple ang lahat sa pamamagitan ng malaking pamumuhunan sa sandboxing na partikular sa OS, upang makatakbo ito sa environment na pinakaangkop sa kasalukuyang gawain.
Ginagawang available ng harness ang mga mekanismong ito ng sandboxing na partikular sa OS sa pamamagitan ng iisang API para sa macOS, Windows, at Linux. Tumatanggap ang API na ito ng command at permission profile. Kung nagpapahintulot ang permission profile ng limitadong network access, kailangang magbigay ang tumatawag ng network proxy upang ipatupad ang mga limitasyong iyon:
Sinisimulan ng function na ito ang proseso sa isang sandbox at nagbabalik ng Child handle na magagamit ng harness upang hintaying matapos ito. Namamana ng bawat child process ang mga limitasyon ng sandbox ng parent nito, kaya nalalapat ang mga restriksyong iyon sa buong process tree na sinimulan ng command, pati sa mga descendant na patuloy na tumatakbo matapos ang orihinal na proseso.
Ipinapakita ng sumusunod na diagram kung paano nag-uugnayan ang mga bahaging ito, mula sa configuration hanggang sa pagpapatakbo ng command sa sandbox. Ipinapaliwanag ng mga susunod na seksyon ang bawat yugto.

Gaya ng ipinaliwanag sa Pag-unawa sa Codex Agent Loop, ang Codex harness ang responsable sa pagpapatakbo ng mga tool call na nabuo ng modelo. Para sa mga gawain sa coding, ang pinakamadalas gamitin ay isang shell tool, na nagpapatakbo ng mga command gaya ng ginagawa ng user sa isang interactive shell tulad ng Bash. Dito, susuriin natin ang one-shot (magbubukas sa bagong window)exec_command(magbubukas sa bagong window) shell tool(magbubukas sa bagong window) upang ipakita kung paano ginagamit ng harness ang sandbox upang maibigay ang mga gustong proteksyon.
Ito ang pinasimpleng bersyon kung paano tutugunan ng Codex harness ang exec_command tool call nang walang sandboxing:
Upang i-sandbox ang command, pinapalitan ng harness ang pagtawag sa subprocess.Popen() ng spawn_command_under_sandbox(). Ibinibigay ng harness ang permission profile at, kung kailangan, ang network proxy:
Pinapayagan din ng exec_command tool ang modelo na humiling ng ibang mga pahintulot para sa isang indibidwal na command, pero ang harness ang nagpapasya kung pagbibigyan ang request:
Kapag tinukoy ang use_default, ginagamit ng harness ang default na sandbox config para sa turn na iyon. Humihiling ang with_additional_permissions ng mas malawak na access sa loob ng sandbox, habang humihiling ang require_escalated ng pagpapatakbo sa labas nito. Sinusuri ng harness ang request batay sa mga kagustuhan ng user bago patakbuhin ang command. (Halimbawa, maaaring direktang humingi ng pahintulot ang Codex sa user, o ipasa nito ang request sa awtomatikong pagsusuri(magbubukas sa bagong window).) Kung pinahintulutan ang pagpapatakbo, ipapasa ng Codex ang angkop na permission_profile at network_proxy sa perform_exec_command_with_sandboxing() kasama ang mga argument ng command mula sa orihinal na ExecCommandToolCall.
Ang shell tool ang pangunahing gumagamit ng spawn_command_under_sandbox(), at ginagamit din ng harness ang imprastraktura nito sa sandboxing para sa mga operasyon tulad ng pagbasa at pagbabago ng mga lokal na file. Hindi lang sa harness ito magagamit muli: sa pamamagitan ng codex sandbox command, maisasama mo ang pagpapatakbo ng mga command sa sandbox sa sarili mong mga tool, gaya ng makikita natin mamaya. Susunod, titingnan natin kung paano tinutukoy ang mga permission profile.
Sa pamamagitan ng permission profile na may pangalan, magagamit mong muli ang parehong restriksyon sa filesystem at network sa iba't ibang proyekto. Maaari mong tukuyin ang sarili mong mga profile sa ilalim ng [permissions] sa config.toml. Halimbawa, tinutukoy ng sumusunod ang profile na pinangalanang dev na nagpapalawak(magbubukas sa bagong window) sa built-in na :workspace profile:
Nagdaragdag ang dev profile ng access sa pagsulat sa ~/build-cache at naglalapat ng dagdag na restriksyon sa mga file sa workspace. Maaaring magbigay ang mga filesystem entry ng access sa pagbasa lang (read), access sa pagbasa at pagsulat (write), o ganap na i-block ang access (deny).
Sa :workspace_roots table, makakapagtakda ka ng mga panuntunan para sa mga path na kaugnay ng mga workspace root ng proyekto. Bilang default, ginagamit ng Codex CLI ang working directory nito bilang nag-iisang workspace root, habang ginagamit ng ChatGPT desktop app ang mga source folder ng proyekto. Inilalapat ng Codex ang bawat panuntunan sa lahat ng root, kaya ginagawang read-only ng .vscode entry sa dev ang .vscode directory sa ilalim ng bawat root.
Bukod sa sarili nitong mga panuntunan, namamana ng dev ang sumusunod na mga proteksyon mula sa :workspace:
Sa pag-configure ng network para sa sandbox sa Codex, may tatlong pangunahing opsyon:
I-disable ang lahat ng network access (default para sa
:workspaceprofile)I-enable ang buo at direktang network access (default para sa
:danger-full-accessprofile)Limitahan ang network access sa isang proxy, na nagpapasya kung ano ang papayagang dumaan batay sa permission profile
Upang bigyan ang dev ng direktang network access, itakda ang permissions.dev.network.enabled = true sa pinakamataas na antas ng config.toml. Nagbibigay ito ng buong network access kapag naka-disable ang network proxy.
Upang limitahan ang dev sa isang hanay ng mga domain, i-enable ang network proxy at i-configure ang mga panuntunan nito sa domain:
Sinusuportahan ng mga panuntunan sa domain ang eksaktong mga pangalan at wildcard pattern, at nangingibabaw ang tahasang pagbabawal sa pagpapahintulot. Ang mga request sa ibang domain ay nangangailangan ng pag-apruba o bina-block, gaya ng inilalarawan sa Network proxy sa ibaba.
Maaaring mag-configure ang mga indibidwal na user ng mga default para sa lahat ng proyekto at palitan ang mga ito para sa isang partikular na pinagkakatiwalaang proyekto. Maaaring gusto rin ng mga enterprise administrator na mag-configure ng mga default para sa kanilang mga user at limitahan kung aling mga setting ang mababago ng mga iyon. Sinusuportahan ng Codex ang pareho sa pamamagitan ng layered configuration at mga pinamamahalaang requirement.
Gaya ng inilalarawan sa Pagkakasunod-sunod ng prayoridad ng configuration,(magbubukas sa bagong window) pinagsasama ng Codex ang mga setting mula sa maraming config.toml file. Pinagsasama ang mga table nang recursive, at nangingibabaw ang source na may mas mataas na prayoridad kapag nagkasalungat ang mga value. Pinapalitan nang buo ang mga array.
Ito ang dahilan kung bakit gumagamit ng mga table ang mga permission profile para sa mga filesystem path at network domain. Maaaring magdagdag o magpalit ang isang team ng mga indibidwal na entry sa sarili nitong configuration at awtomatikong mamana ang mga pagbabago sa lahat ng iba pang entry sa batayang configuration ng organisasyon:
Maaari ring magbigay ang mga administrator ng mga pinamamahalaang requirement(magbubukas sa bagong window) sa pamamagitan ng requirements.toml upang limitahan ang mga pagpipilian ng user sa configuration. Maaaring manggaling ang mga requirement na ito sa maraming source, kabilang ang mga system file at patakarang ibinibigay mula sa cloud. Karaniwang ginagamit ang allowed_permission_profiles upang limitahan ang mga permission profile na maaaring piliin ng isang enterprise user. Halimbawa, maaaring tukuyin ng isang administrator ang mga cloud requirement na ito:
Mangingibabaw ang mga cloud requirement sa system requirements file na nasa /etc/codex/requirements.toml, kaya hindi mapapawalang-bisa ng entry sa file na iyon ang tahasang ":danger-full-access" = false sa itaas. Kapag hindi tinukoy ang :workspace, maaaring magbigay ng entry na iyon ang ibang layer ng mga requirement. Hindi magagamit ang mga profile na ang entry ay false o wala sa pinal na pinagsamang table.
Dahil sa paghihiwalay na ito, nakakapagpatupad ang mga organisasyon ng mga limitasyon habang naiaangkop ng mga user ang kanilang configuration sa loob ng mga limitasyong iyon. Maaaring gamitin ng harness ang mga nabuong permission profile o direktang ilapat ang mga ito sa isang command, gaya ng makikita natin sa susunod.
Nagbibigay ang Codex CLI ng sandbox command upang mapadali ang pagpapatakbo ng anumang command sa ilalim ng permission profile na tinukoy sa Codex config. Karaniwan itong ginagamit upang subukan ang profile at tiyaking napipigilan ng sandbox ang mga gawaing idinisenyo nitong i-block.
Halimbawa, sinusubukan ng sumusunod na command na i-configure ang VS Code upang magpatakbo ng malisyosong auto-formatter sa pag-save. Kung mayroon nang .vscode, dapat i-block ng dev profile na tinukoy sa itaas ang pagsulat na ito dahil read-only ang directory na iyon (bilang default, itinuturing ng codex sandbox ang cwd bilang workspace root):
Sa katunayan, sa macOS, nabibigo ito at lumalabas ang:
Sa pamamagitan ng codex sandbox command, magagamit ang mekanismo ng sandboxing ng Codex nang hiwalay sa isang agent session. Maaari mong gamitin ang parehong configuration language at pagpapatupad na partikular sa platform upang limitahan ang mga command na inilulunsad ng sarili mong mga tool.
Para sa isang stdio MCP server na naka-configure sa config.toml, hindi sinusubukan ng Codex harness na i-sandbox ang command na ginagamit upang simulan ang server. Hindi matitiyak ng Codex kung aling mga file o serbisyo sa network ang kailangan ng server, kaya maaaring masira ng default na sandbox profile ang isang configuration na gumagana naman sana.
Halimbawa, ito ang karaniwang paraan ng pag-configure sa @modelcontextprotocol/server-memory(magbubukas sa bagong window) MCP server para gamitin sa Codex:
Dahil tumatakbo ang npx command na ito nang walang sandbox, nakakapagsulat ito ng mga file at nakakapagpadala ng mga network request gamit ang parehong pahintulot ng user na nagpapatakbo ng Codex—isang labis na lawak ng access. Upang higpitan ito, maaari tayong tumukoy ng permission profile na pinangalanang memory-mcp, saka patakbuhin ang orihinal na npx command sa pamamagitan ng codex sandbox --permission-profile memory-mcp upang limitahan kung saan makakapagsulat ang server at pigilan itong ma-access ang network:
Bago simulan ang server, gawin ang data directory nito at ilagay sa npm cache ang package na may nakapirming bersyon. Dahil dito, mailulunsad ng npx --offline ang server sa ilalim ng profile na nagdi-disable ng network access:
Kapag naka-cache na ang package, masisimulan ng Codex ang memory server nang walang network access, at limitado ang pagsulat sa npm cache at data directory ng server.
Ginagawang mga restriksyong ipinapatupad ng operating system ang permission profile sa implementasyon ng sandbox. Iisa sa tatlong pangunahing operating system ang pangunahing lohika ng network proxy para sa paghawak ng request at mga patakaran, pero partikular sa OS ang pag-set up ng proxy at pagsasama nito sa sandbox. Uunahin nating suriin ang pinagsasaluhang proxy, saka ang mga implementasyon para sa macOS, Linux, at Windows.
Upang ipatupad ang mga restriksyon sa network ng permission profile, nagsisimula ang harness ng network proxy at kino-configure ang sandbox upang payagan ang mga koneksyon dito habang bina-block ang direktang koneksyon sa mga panlabas na host. Sinusuri ng proxy ang bawat request ayon sa mga panuntunan sa domain ng profile upang matukoy kung ipapasa ito.
Sa Codex repository, ipinatutupad ang network proxy sa codex-network-proxy(magbubukas sa bagong window) crate, na ginagamit ng harness bilang library, bagama't maaari rin itong i-build bilang standalone na CLI(magbubukas sa bagong window). Kapag naka-enable, nagsisimula ang codex-network-proxy ng parehong HTTP proxy at SOCKS5 proxy bilang default. Ipinapasa ang mga address ng proxy na ito sa prosesong inilulunsad ng sandbox sa pamamagitan ng mga environment variable. Bukod sa paglalagay ng mga karaniwang environment variable tulad ng HTTP_PROXY, HTTPS_PROXY, at ALL_PROXY, naglalagay din ng ilang kilalang environment variable na partikular sa application(magbubukas sa bagong window) (tulad ng PIP_PROXY). Gayunman, hindi lahat ng program ay sumusunod sa mga environment variable na ito. Kung susubukan ng program na direktang kumonekta sa isang panlabas na host, iba-block ito ng mga restriksyon ng sandbox ng operating system, gaya ng inilalarawan sa mga seksyong partikular sa platform sa ibaba.
Ang network proxy ang responsable sa pagpapatupad ng mga restriksyon sa network na tinukoy sa permission profile. Halimbawa, pinapayagan ng dev profile na ipinakita kanina ang mga request sa *.openai.com at tahasang ipinagbabawal ang mga request sa evil.example. Kapag para sa isang domain ang request na hindi tumutugma sa panuntunan sa pagpapahintulot o pagbabawal, maaaring pansamantalang ihinto ng proxy ang request habang ipinapasa ito sa harness para sa pag-apruba. Tulad sa halimbawa ng shell command, maaaring direktang humingi ng pahintulot ang Codex sa user, o ipasa nito ang request sa awtomatikong pagsusuri(magbubukas sa bagong window). Kapag natanggap na ang desisyon, papayagan ng proxy na magpatuloy ang request o tatanggihan ito gamit ang isang error response.
Mahalaga ang pagkakasunod-sunod dito dahil kahit ang DNS lookup ay maaaring maglantad ng impormasyong naka-encode sa hostname. Kaya nire-resolve lang ng proxy ang hiniling na hostname matapos matukoy na pinapayagan o naaprubahan ito. Tandaan na maaari pa ring payagan ng malalawak na wildcard rule o access sa mga DNS service ang palihim na paglabas ng data gamit ang DNS.
Sa macOS, ginagamit ng Codex ang Seatbelt(magbubukas sa bagong window), ang mekanismo ng sandboxing ng Apple na ipinapatupad ng kernel. Isinusulat ang mga patakaran ng Seatbelt sa Sandbox Profile Language (SBPL), isang wikang nakabatay sa Scheme para sa pagpapahayag ng mga restriksyon ng sandbox. Tinatawag ng Codex ang Seatbelt sa pamamagitan ng /usr/bin/sandbox-exec command ng macOS. Tulad ng codex sandbox, tumatanggap ito ng mga option na naglalarawan sa sandbox, na sinusundan ng command na patatakbuhin:
Ang PROFILE ay isang SBPL string na naglalaman ng mga entry na nagko-configure sa sandbox. Halimbawa, ginagawang nababasa at nasusulatan ng sumusunod na SBPL snippet ang /dev/null at /dev/zero sa ilalim ng patakaran ng sandbox:
Kapag naka-enable ang network proxy bilang bahagi ng pagtawag sa sandbox, inilalagay sa profile ang mga panuntunang tulad ng sumusunod upang limitahan ang mga koneksyon sa angkop na mga lokal na port:
Nagsisimula ang batayang profile ng Codex sa (deny default), kaya nananatiling naka-block ang mga palabas na koneksyon maliban kung tahasang pinapayagan.
Panghuli, maaaring maglaman ang SBPL ng mga placeholder gamit ang (param):
na pinupunan ng mga -Dkey=value option na ipinapasa sa sandbox-exec.
Upang ipatupad ang sarili nitong sandbox API, binubuo ng Codex ang listahan ng mga argument(magbubukas sa bagong window) para sa sandbox-exec mula sa isang batayang patakaran(magbubukas sa bagong window), saka ginagamit ang permission_profile at iba pang konteksto upang baguhin ito at mabuo ang kumpletong Seatbelt profile. Itinatakda ng nabuong profile at kasamang mga -D argument ang mga restriksyong ipinapatupad ng Seatbelt, habang nagpapatupad ang network proxy ng dagdag na mga panuntunan sa network. Kapag nabuo na ang buong listahan ng argument, simple na ang pagtawag sa sandbox-exec.
Mahirap bumuo ng tamang SBPL dahil hindi nagbibigay ang Apple ng dokumentasyon ng wika para sa paggamit ng mga third party. Sa katunayan, sinasabi sa man sandbox-exec na The sandbox-exec command is DEPRECATED (gaya rin ng sandbox_init() library function na nakadokumento sa man 3 sandbox_init). Sa kabila ng babalang hindi na inirerekomenda ang paggamit nito, may kasama pa ring mga Seatbelt profile ang macOS sa /usr/share/sandbox, at patuloy na umaasa sa Seatbelt ang third-party software, kabilang ang Google Chrome at Chromium(magbubukas sa bagong window). Kaya plano naming patuloy na gamitin ang Seatbelt sa nakikinita naming hinaharap.
Upang gawin ang sandbox sa Linux, pinagsasama ng Codex ang bubblewrap(magbubukas sa bagong window) (bwrap), isang command-line tool para sa pagbuo ng mga nakahiwalay na environment, at seccomp-bpf(magbubukas sa bagong window), isang mekanismo ng Linux kernel para sa pag-filter ng mga system call. Isang internal helper na tinatawag na codex-linux-sandbox ang nangangasiwa sa setup. Tulad ng sandbox-exec sa macOS, tumatanggap ito ng sandbox configuration na sinusundan ng command na patatakbuhin:
Kapag kailangan ng filesystem isolation o proxy routing, tinatawag ng codex-linux-sandbox ang bwrap upang gawin ang paunang sandbox environment. Pagkatapos, inilulunsad ng bwrap ang codex-linux-sandbox --apply-seccomp-then-exec sa loob nito. Gumagamit ang ikalawang pagtawag na ito ng seccomp-bpf upang maglapat ng dagdag na mga restriksyon bago patakbuhin ang command ng user.
Upang buuin ang paunang sandbox environment na iyon, gumagamit ang Codex ng bubblewrap upang gumawa ng filesystem view sa hiwalay na mount namespace na sumasalamin sa mga panuntunan sa filesystem ng permission profile. Dahil pundasyon ito ng implementasyon ng sandbox, may kasamang sariling kopya ng bwrap ang Codex sakaling walang naka-install ang user, pero mas pinipili nito ang compatible na installation ng (magbubukas sa bagong window)bwrap(magbubukas sa bagong window) na nasa PATH, kung mayroon. Sa aktuwal na paggamit, naka-disable bilang default ang access sa mga user namespace sa ilang Linux distribution(magbubukas sa bagong window), pero may eksepsyon para sa bwrap ng system.
Tulad din ng sandbox-exec, tumatanggap ang bwrap ng sandbox configuration na sinusundan ng command na tatakbo sa loob ng sandbox. Sa halip na gumamit ng pasadyang config language tulad ng SBPL, gumagamit ang bwrap ng magkakahiwalay na flag para sa configuration. Ginagamit ng Codex ang mga sumusunod na option upang gawin ang filesystem view:
--bindupang tumukoy ng writable na file o directory--ro-bindupang tumukoy ng read-only na file o directory--perms 000 --tmpfs DIR --remount-ro DIRupang ipagbawal ang access saDIR--perms 000 --ro-bind-data FD FILEupang ipagbawal ang access saFILE(kung saan angFDay isang bukas na file descriptor para sa/dev/null)
Upang ilapat ang mga deny glob gamit ang mga option na ito, inililista ng Codex ang mga partikular na path na tumutugma sa mga ito bago ilunsad ang bawat command. Hindi awtomatikong idinaragdag sa mga restriksyon ng sandbox ng command na iyon ang mga bagong tumutugmang path.
Tumutukoy rin ang Codex ng mga option tulad ng --unshare-ipc at --unshare-pid upang pigilan ang sandbox na ma-access ang iba pang uri ng resource sa host, kaya hindi lang visibility ng file ang naaapektuhan ng bubblewrap.
Kapag gumagamit ng bubblewrap, ipinapasa ng Codex ang --unshare-net tuwing naka-disable ang networking o kailangang dumaan sa network proxy ang mga koneksyon. Gumagawa ito ng bagong network namespace para sa sandbox. Pagkatapos, ginagamit namin ang seccomp-bpf upang maglapat ng dagdag na restriksyon sa mga networking system call at socket family na magagamit ng command.
Partikular, ginagamit namin ang seccompiler crate(magbubukas sa bagong window) upang mag-compile nang dynamic ng BPF program batay sa mga gustong filter(magbubukas sa bagong window) at ilapat ito sa launcher process sa sandbox upang mamana ng buong process tree ang mga limitasyon. Kaya hindi direktang pinapatakbo ng bwrap ang command ng user. Sa halip, pinapatakbo nito ang codex-linux-sandbox launcher kasama ang sarili nitong mga config argument, na sinusundan ng command ng user:
Upang maglapat ng mga seccomp filter nang walang mas mataas na pribilehiyo, itinatakda ng launcher ang no_new_privs flag ng Linux(magbubukas sa bagong window). Namamana ng mga child process ang flag na ito at pinipigilan silang makakuha ng dagdag na pribilehiyo kapag nagpapatakbo ng ibang program, tulad ng setuid executable.
Nakadepende ang mga seccomp filter sa network configuration. Kapag naka-disable ang network access, bina-block namin ang ilang syscall na may kaugnayan sa network, tulad ng connect(2) at bind(2). Pero kapag naka-enable ang network proxy sa sandbox, pinapayagan namin ang mga IP socket upang maabot ang TCP listener na ginawa ng codex-linux-sandbox. Gayunman, bina-block bilang default ang paggawa ng mga standalone na Unix domain socket dahil maaaring magbigay ang mga ito ng hindi sinasadyang access sa mga resource ng host.
Kapag kailangan ng sandbox configuration ang network proxy, gumagawa ang Codex harness ng isang instance ng proxy na magagamit muli sa maraming pagtawag sa codex-linux-sandbox sa loob ng iisang Codex thread. Kailangan ng bawat sandbox ng paraan upang maabot ang pinagsasaluhang proxy na iyon mula sa nakahiwalay nitong network namespace. Nagbibigay ang Codex ng loopback TCP listener sa loob ng namespace na iyon at nagtatakda ng proseso sa labas ng sandbox na tatanggap ng mga koneksyon nito at magpapasa ng mga ito sa proxy.
Ipinapakita ng mga sumusunod na diagram ang setup na ito para sa isang proxy endpoint, at ang isang koneksyong dumadaan dito sa huling diagram. Bago ilunsad ang bubblewrap, gumagawa ang codex-linux-sandbox ng Unix socket pair bilang control channel at nagfo-fork ng sarili nito. Pinapatakbo ng child process ang run_host_bridge() at hinihintay na matanggap ang file descriptor ng listener sa channel na iyon:
Sa halimbawang ito, ginagamit ng parent process ang exec upang palitan ng bwrap ang program image nito. Sine-set up nito ang sandbox at inilulunsad ang codex-linux-sandbox --apply-seccomp-then-exec sa loob nito, kasabay ng pagpapasa ng FD para sa control channel:
Sa loob ng network namespace ng sandbox, gumagawa ang ikalawang pagtawag sa codex-linux-sandbox ng loopback TCP listener at ipinapasa ang file descriptor nito sa pamamagitan ng socket. Nananatiling kaugnay ng network namespace ng sandbox ang listener. Dahil dito, natatanggap ng child process na naiwan sa labas ng sandbox ang mga koneksyon mula sa mga program sa sandbox, habang binubuksan nito ang mga upstream na koneksyon sa network namespace ng host. Pagkatapos ng pagpapasa, isinasara ng parehong proseso ang kanilang mga control-channel descriptor, at isinasara ng proseso sa loob ng sandbox ang kopya nito ng listener.
Kapag handa na ang TCP listener, itinatakda ng proseso sa loob ng sandbox ang angkop na value ng HTTP_PROXY(magbubukas sa bagong window) at mga kaugnay na environment variable upang tumukoy sa listener na iyon. Pagkatapos, inilalapat nito ang seccomp bago mag-fork at patakbuhin ang command ng user:
Pinananatiling bukas ng proseso sa labas ng sandbox ang listener. Para sa bawat tinatanggap na koneksyon, nagbubukas ito ng koneksyon sa naka-configure na proxy at nagpapasa ng data sa magkabilang direksyon.
Binibigyan ng dagdag na mekanismong ito ang command ng sarili nitong network namespace, kasama ang hiwalay na loopback interface. Sa macOS, pinapayagan ng Seatbelt ang command na direktang kumonekta sa mga tinukoy na port sa loopback interface ng host. Sa Linux, kumokonekta sa halip ang command sa isang listener sa loob ng nakahiwalay nitong namespace, at ipinapasa ng proseso sa labas ng sandbox ang mga koneksyong iyon sa naka-configure na proxy. Nagiging posible ang koneksyong ito sa pamamagitan ng pagpapasa ng descriptor, nang hindi inilalantad sa command ang network namespace ng host.
Noong unang bahagi ng taon, ipinatupad namin at isinulat ang tungkol sa aming mga pagsisikap sa sandboxing sa Windows. Mula noon, naglabas ang Microsoft ng library na tinatawag na MXC kasabay ng mga bagong feature para sa paghihiwalay ng proseso sa loob ng Windows operating system. Kasalukuyan naming pinapalitan ang dati naming sandbox ng isang sandbox na gumagamit ng MXC library.
Ang MXC (Microsoft eXecution Container) ay isang sistema para sa pagpapatakbo ng code sa sandbox(magbubukas sa bagong window) mula sa Microsoft na sumusuporta sa ilang containment backend sa Windows, Linux, at macOS. Sinusuportahan ng Codex ang isang MXC-based na sandbox sa mga compatible na Windows device, gamit ang native na paghihiwalay ng proseso upang limitahan ang mga command sa kasalukuyang environment ng user.
Lilipat kami sa MXC upang mapahusay ang seguridad at kadalian ng paggamit, habang tinutugunan ang ilang limitasyon ng dati naming Windows sandbox:
Pangangailangan ng mas mataas na pribilehiyo/admin access upang i-set up ang sandbox
Magastos sa resource/mabagal na pagsusuri at pagtatakda ng ACL
Nananatiling estado ng sandbox setup sa host machine, kabilang ang
Mga ACL
Mga panuntunan ng firewall
Mga sandbox user
Mga file ng control plane
Nagbibigay ang MXC ng JSON configuration schema(magbubukas sa bagong window). Ginagamit ng Codex ang MXC SDK(magbubukas sa bagong window) upang bumuo ng execution request na sumusunod sa schema na iyon at naglalaman ng command, working directory, environment, at mga pahintulot. Saklaw ng mga pahintulot na iyon ang access sa filesystem at network, pati ang mga resource ng Windows tulad ng desktop at clipboard.
Gumagamit ang Codex ng mga nakapirming setting para sa ilang kontrol upang balansehin ang compatibility at seguridad. Pinapayagan nito ang pagbasa sa registry at pinananatili ang access sa Win32k at desktop na kailangan ng PowerShell sa startup. Naka-disable ang access sa clipboard, input injection, at mga kontrol sa desktop at mga setting ng system. Panghuli, hindi pinapayagan ang MXC na gumamit ng pagbabago sa mga pahintulot ng host filesystem bilang fallback.
Kino-convert ng Codex ang mga panuntunan sa filesystem at network ng permission profile tungo sa configuration ng MXC. Gamit ang naunang dev profile, at kung ipagpapalagay na:
C:\,D:\atZ:\lang ang mga lokal na drive ng machine.Ang workspace root at working directory ay
C:\work\demo.Ang home directory ng user ay
D:\Users\dev, kaya tumutukoy ang~/build-cachesaD:\Users\dev\build-cache.Tumutugma lang ang deny glob sa
C:\work\demo\config\dev.envatC:\work\demo\config\prod.env.
Kabilang sa mga katumbas na setting ng MXC ang:
Bilang default, ipinagbabawal ng patakaran sa filesystem ng MXC ang access. Kaya nagdaragdag ang Codex ng mga pahintulot na read-only para sa mga root ng lokal na drive upang maibigay ang malawak na access sa pagbasa na pinapayagan ng profile na ito. Nalalapat ang mga pahintulot na ito nang recursive, alinsunod sa kasalukuyang mga pahintulot sa OS ng user.
May isang komplikasyon: hindi recursive ang mga pahintulot na writable sa drive root, kaya pinalalawak ito ng Codex upang isama ang mga kasalukuyang file at directory na direktang nasa ilalim ng drive.
Nangingibabaw ang mas partikular na mga path sa mga pahintulot ng mga ancestor nito, kaya maaaring writable ang C:\work\demo sa ilalim ng read-only na C:\, habang nananatiling read-only ang C:\work\demo\.git.
Kapag tumutukoy sa iisang path ang magkakaibang baybay ng path o mga symlink/junction alias, inilalapat ng MXC ang mas mahigpit na pahintulot: nangingibabaw ang deny sa read-only, na nangingibabaw naman sa read-write.
Mga partikular na path lang na ipagbabawal ang tinatanggap ng MXC, kaya inililista ng Codex ang mga file at directory na tumutugma sa mga deny glob bago maglunsad. Hindi awtomatikong idinaragdag ang mga bagong path na tumutugma sa glob habang tumatakbo ang command.
Ipinapatupad ang mga panuntunan sa domain tulad ng *.openai.com ng pinagsasaluhang Codex network proxy na inilarawan kanina. Pinapatakbo ng Codex ang proxy na iyon sa labas ng sandbox at ipinapasa ang mga address nito sa command sa pamamagitan ng parehong karaniwang *_PROXY environment variable na nabanggit kanina. Bina-block ng MXC ang direktang panlabas na koneksyon habang pinapayagan ang mga host-loopback na koneksyon, kabilang ang access sa proxy. Naaabot pa rin ang iba pang lokal na serbisyo.
Sa macOS, Linux, at Windows, ginagamit ng harness ang parehong sandbox API upang maglunsad ng mga command sa ilalim ng permission profile. Ang mga implementasyong partikular sa platform ang humahawak sa setup na kailangan upang ilapat ang mga restriksyong iyon.
Ang pagsulat at pagpapatakbo ng code ay nagbibigay sa mga agent ng flexible na paraan upang lutasin ang mga problemang lampas sa software development. Dahil sa Codex sandbox, magagamit nila ang kakayahang iyon sa kasalukuyang environment ng user na may malinaw na mga limitasyon sa access sa filesystem at network. Isa itong pangunahing bahagi ng harness na magagamit muli, at ginagawang available ito ng codex sandbox command sa mga tool na ikaw mismo ang bumubuo.
Habang dumarami ang mga gawaing ginagampanan ng mga agent, gusto naming gawing praktikal ang sandboxing para sa mas maraming tool at environment. Ibig sabihin, kailangang gawing mas madaling i-configure ang mga pahintulot at samantalahin ang mas mahuhusay na proteksyon ng operating system kapag available na ang mga ito. Layunin naming palawakin ang kayang gawin ng mga agent habang nananatili sa mga tao ang kontrol sa kung ano ang maa-access ng mga ito.


