A Codex sandbox belülről
Így futtat a Codex parancsokat a gépeden az általad megszabott korlátok között.
Az OpenAI-nál az ügynökök biztonságának megteremtésében a többrétegű védelem(új ablakban nyílik meg) elvét követjük. Bár ebben alapvető szerepet játszik a tanításba és az emberi szándékokhoz való igazításba fektetett munkánk, az ügynökök végrehajtási környezetét adó Codex(új ablakban nyílik meg) további védelmi funkciókat is tartalmaz. Mivel a Codex egyik leggyakoribb és potenciálisan kockázatos művelete a parancsok futtatása a számítógépeden, létrehoztuk a Codex sandboxot. Ennek segítségével a Codex a meglévő környezetedben dolgozhat, az általad megszabott fájlrendszer- és hálózati korlátok között.
A (új ablakban nyílik meg)sandbox(új ablakban nyílik meg) korlátozza, hogy egy program mihez férhet hozzá futás közben. Fényképek rendezéséhez például beállíthatod a Codex sandboxot úgy, hogy a parancsok olvashassák és módosíthassák a ~/Pictures fájljait, miközben a hálózati hozzáférés tiltásával megakadályozod a feltöltést. Kódellenőrzéshez engedélyezheted az online dokumentáció elérését, miközben a forrásfájlok csak olvashatók maradnak. A felhasználók a Codex sandboxot (új ablakban nyílik meg)jogosultsági profilokkal(új ablakban nyílik meg) konfigurálhatják, amelyek meghatározzák a Codex-munkamenet fájlrendszer- és hálózati korlátozásait.
Ebben a cikkben először áttekintjük a Codex sandbox alapbeállításai mögötti kompromisszumokat, majd bemutatjuk a sandbox felépítését és azt, hogyan használja a végrehajtási környezet a parancsok futtatásához. Megmutatjuk, hogyan igazíthatják a végfelhasználók és a vállalatok az igényeikhez a jogosultságokat, és hogyan használhatják fel a fejlesztők a sandboxot a saját eszközeikben. Végül megvizsgáljuk, hogyan érvényesülnek ezek a korlátozások macOS-en, Linuxon és Windowson.
A Codex esetében az az alapelvünk, hogy a sandbox óvatos alapbeállításai mellett is lehessen érdemi munkát végezni. Ha például egy Git-adattár a munkaterület gyökérkönyvtára, a beépített :workspace jogosultsági profil:
Engedélyezi az írást a munkaterületen belül, de az olyan könyvtárakat, mint a
.gités a.codex, csak olvashatóként tartja meg. Így a Codex anélkül szerkesztheti a forráskódot, hogy minden változtatáshoz engedélyt kérne, de nem módosíthatja közvetlenül a.codex/config.tomlfájlt vagy a.git/hooksalatti Git-hookokat.Széles körű olvasási hozzáférést engedélyez a fájlrendszerhez, a felhasználó meglévő operációsrendszer-szintű jogosultságainak keretein belül. A fordítók, futtatókörnyezetek és buildeszközök az adattáron kívüli SDK-kra, programkönyvtárakra és konfigurációkra támaszkodnak. Ha az olvasás csak a munkaterületre korlátozódna, sok szokásos munkafolyamat nem működne. Ennek ára, hogy a gép más részein lévő érzékeny fájlok is olvashatók maradhatnak, például az API-kulcsokat tartalmazó konfigurációs fájlok.
Letiltja a hálózati hozzáférést. Ez blokkolja a külső szolgáltatásokba történő közvetlen feltöltést, beleértve a parancs által olvasható adatok kiszivárogtatására tett kísérleteket is. Ugyanakkor az olyan jogos műveleteket is megakadályozza, mint a függőségek letöltése, amelyhez további hozzáférés szükséges.
Ezek a korlátozások a nem kívánt működés számos formáját megakadályozzák, de káros műveletekre továbbra is van lehetőség. Az ügynök például rosszindulatú kódot juttathat egy helyben telepített csomagba, például a node_modules/prettier csomagba. Az ilyen módosítás nem feltétlenül jelenik meg a git status kimenetében, mert a Git gyakran figyelmen kívül hagyja a node_modules könyvtárat. Ha a felhasználó szerkesztője mentéskor a Prettiernek ezt a példányát futtatja, egy fájl egyszerű mentése is végrehajthatja a rosszindulatú kódot a Codex sandboxon kívül. Ezért alkalmazunk többrétegű védelmet: a sandbox korlátozza, hogy a parancsok mihez férhetnek hozzá, a tanítás és az emberi szándékokhoz való igazítás pedig segít a modellnek a felhasználó szándékának megfelelően élni ezzel a hozzáféréssel.
A sandbox jogosultságainak testreszabásához és más védelmi megoldásokkal való kombinálásához vállalati környezetben a Codex biztonsági receptgyűjteménye(új ablakban nyílik meg) nyújt útmutatást.
A virtuális gépek és a konténerek(új ablakban nyílik meg) népszerű megoldások az elkülönített futtatásra, de a Codex sandboxnál más megközelítést alkalmazunk. A Codex nem helyezi át a számításokat egy külön környezetbe az elkülönítés érdekében, hanem az egyes platformok sandboxfunkcióival korlátozza a felhasználó meglévő környezetében futó parancsokat.
Sok fejlesztő számára a laptopja egy személyre szabott fejlesztői környezet, amelyet bármikor kedvére alakíthat. Ennek a környezetnek az újraalkotása egy Docker-konténerben munkát igényelhet, és egyes munkafolyamatok továbbra is a gazdagépen futó eszközökre támaszkodnak.
Vegyük például azt az esetet, amikor a Codex segítségével iOS-alkalmazást fejlesztesz egy Macen. Ha úgy döntenél, hogy a Codexet Dockerben futtatva különíted el, nem tudná futtatni a natív Mac-programokból álló iOS-buildeszközláncot, és az iPhone-szimulátort sem tudná elindítani a kód futtatásához. Egy Docker-alapú munkafolyamat átadhatná a buildelést és a szimulátorműveleteket a Mac gazdagépnek, de ezek a műveletek a konténer sandboxán kívül futnának, és saját korlátozásokat igényelnének. A Codexnél az egyszerűségre törekszünk: jelentős erőforrásokat fordítunk az operációs rendszerhez igazított sandboxmegoldásokra, hogy a Codex mindig az adott feladathoz legmegfelelőbb környezetben futhasson.
A végrehajtási környezet ezeket az operációsrendszer-specifikus sandboxmechanizmusokat közös API-n keresztül teszi elérhetővé macOS-en, Windowson és Linuxon. Ez az API egy parancsot és egy jogosultsági profilt fogad. Ha a jogosultsági profil korlátozott hálózati hozzáférést engedélyez, a hívónak hálózati proxyt kell biztosítania a korlátok érvényesítéséhez:
Ez a függvény sandboxban indítja el a folyamatot, és egy Child kezelőt ad vissza, amellyel a végrehajtási környezet megvárhatja a folyamat befejeződését. Minden gyermekfolyamat örökli a szülő sandboxkorlátozásait, így azok a parancs által indított teljes folyamatfára érvényesek, még az eredeti folyamatnál tovább élő leszármazottakra is.
A következő ábra bemutatja, hogyan kapcsolódnak össze ezek az elemek a konfigurációtól a sandboxban történő parancsfuttatásig. Az egyes szakaszokat a következőkben ismertetjük.

Ahogy A Codex ügynökciklusának kibontása című cikkben kifejtettük, a Codex végrehajtási környezete felel a modell által generált eszközhívások végrehajtásáért. Programozási feladatoknál a leggyakrabban használt eszköz egy selleszköz, amely úgy futtat parancsokat, ahogy a felhasználó tenné egy interaktív parancsértelmezőben, például a Bashben. Itt az egylövéses (új ablakban nyílik meg)exec_command(új ablakban nyílik meg) selleszközön(új ablakban nyílik meg) keresztül mutatjuk be, hogyan használja a végrehajtási környezet a sandboxot a kívánt védelem biztosítására.
Ez annak egyszerűsített változata, ahogyan a Codex végrehajtási környezete sandbox nélkül végrehajtaná az exec_command eszközhívást:
A parancs sandboxban történő futtatásához a végrehajtási környezet a subprocess.Popen() hívást a spawn_command_under_sandbox() hívásra cseréli. A végrehajtási környezet biztosítja a jogosultsági profilt, és szükség esetén a hálózati proxyt is:
Az exec_command eszköz azt is lehetővé teszi, hogy a modell egy adott parancshoz eltérő jogosultságokat kérjen, de a kérés teljesítéséről a végrehajtási környezet dönt:
A use_default megadásakor a végrehajtási környezet az adott forduló alapértelmezett sandboxkonfigurációját használja. A with_additional_permissions kibővített hozzáférést kér a sandboxon belül, míg a require_escalated a sandboxon kívüli végrehajtást kéri. A végrehajtási környezet a parancs futtatása előtt a felhasználó beállításai alapján értékeli a kérést. (A Codex például közvetlenül a felhasználótól kérhet jóváhagyást, vagy automatikus felülvizsgálatra(új ablakban nyílik meg) küldheti a kérést.) Ha a végrehajtást engedélyezik, a Codex átadja a megfelelő permission_profile és network_proxy értéket a perform_exec_command_with_sandboxing() függvénynek, az eredeti ExecCommandToolCall parancsargumentumaival együtt.
A spawn_command_under_sandbox() elsődleges használója a selleszköz, de a végrehajtási környezet a sandboxinfrastruktúrát más műveletekhez, például helyi fájlok olvasásához és módosításához is felhasználja. Az újrafelhasználás a végrehajtási környezeten túlra is kiterjed: a codex sandbox paranccsal saját eszközeidbe is beépítheted a sandboxban történő parancsfuttatást, ahogy azt később bemutatjuk. A következőkben a jogosultsági profilok meghatározását tekintjük át.
Egy elnevezett jogosultsági profillal ugyanazokat a fájlrendszer- és hálózati korlátozásokat több projektben is felhasználhatod. Saját profilokat a config.toml fájl [permissions] szakaszában határozhatsz meg. Az alábbi példa egy dev nevű profilt határoz meg, amely kiterjeszti(új ablakban nyílik meg) a beépített :workspace profilt:
A dev profil írási hozzáférést ad a ~/build-cache könyvtárhoz, és további korlátozásokat alkalmaz a munkaterület fájljaira. A fájlrendszer-bejegyzések csak olvasási hozzáférést (read) vagy olvasási és írási hozzáférést (write) adhatnak, illetve teljesen letilthatják a hozzáférést (deny).
A :workspace_roots táblában a projekt munkaterületi gyökérkönyvtáraihoz viszonyított útvonalakra határozhatsz meg szabályokat. Alapértelmezés szerint a Codex CLI a munkakönyvtárát használja egyetlen munkaterületi gyökérkönyvtárként, míg a ChatGPT asztali alkalmazása a projekt forrásmappáit. A Codex minden szabályt minden gyökérkönyvtárra alkalmaz, így a dev profil .vscode bejegyzése minden gyökérkönyvtár alatt csak olvashatóvá teszi a .vscode könyvtárat.
A saját szabályain felül a dev a következő védelmeket örökli a :workspace profiltól:
A Codex sandbox hálózatának konfigurálására alapvetően három lehetőség van:
Minden hálózati hozzáférés letiltása (a
:workspaceprofil alapbeállítása)Teljes, közvetlen hálózati hozzáférés engedélyezése (a
:danger-full-accessprofil alapbeállítása)A hálózati hozzáférés proxyra korlátozása, amely a jogosultsági profil alapján dönti el, mit enged át
Ha közvetlen hálózati hozzáférést szeretnél adni a dev profilnak, add meg a permissions.dev.network.enabled = true beállítást a config.toml legfelső szintjén. Ez teljes hálózati hozzáférést biztosít, ha a hálózati proxy ki van kapcsolva.
Ha a dev hozzáférését meghatározott tartományokra szeretnéd korlátozni, engedélyezd a hálózati proxyt, és állítsd be a tartományszabályait:
A tartományszabályok pontos neveket és helyettesítő karakteres mintákat is támogatnak; az explicit tiltó szabályok elsőbbséget élveznek az engedélyező szabályokkal szemben. A más tartományokra irányuló kérések jóváhagyást igényelnek vagy blokkolásra kerülnek, az alábbi Hálózati proxy szakaszban leírtak szerint.
A felhasználók több projektre érvényes alapbeállításokat adhatnak meg, majd ezeket egy adott megbízható projektnél felülírhatják. A vállalati rendszergazdák szintén megadhatnak alapbeállításokat a felhasználóiknak, és korlátozhatják, hogy azok mely beállításokat módosíthatják. A Codex rétegzett konfigurációval és központilag kezelt követelményekkel támogatja mindkét lehetőséget.
A Konfigurációs elsőbbség(új ablakban nyílik meg) című szakaszban leírtak szerint a Codex több config.toml fájl beállításait egyesíti. A táblák rekurzívan egyesülnek; ütköző értékek esetén a magasabb prioritású forrás érvényesül. A tömbök teljes egészükben lecserélődnek.
Ezért használnak a jogosultsági profilok táblákat a fájlrendszerútvonalakhoz és a hálózati tartományokhoz. Egy csapat a saját konfigurációjában hozzáadhat vagy felülírhat egyes bejegyzéseket, miközben automatikusan örökli a szervezet alapkonfigurációjának minden más bejegyzését érintő változásokat:
A rendszergazdák a requirements.toml fájlon keresztül központilag kezelt követelményeket(új ablakban nyílik meg) is megadhatnak, amelyek korlátozzák a felhasználók konfigurációs lehetőségeit. Ezek a követelmények több forrásból is származhatnak, például rendszerfájlokból és felhőből biztosított házirendből. Gyakori felhasználási eset az allowed_permission_profiles megadása, amellyel korlátozható, hogy egy vállalati felhasználó mely jogosultsági profilok közül választhat. Egy rendszergazda például a következő felhőalapú követelményeket adhatja meg:
A felhőből származó követelmények elsőbbséget élveznek a /etc/codex/requirements.toml rendszerkövetelmény-fájllal szemben, így a fájl egyetlen bejegyzése sem írhatja felül a fenti explicit ":danger-full-access" = false beállítást. Ha a :workspace nincs megadva, egy másik követelményréteg biztosíthatja ezt a bejegyzést. Nem érhetők el azok a profilok, amelyek bejegyzése false, vagy amelyek hiányoznak a végső, egyesített táblából.
Ez a szétválasztás lehetővé teszi, hogy a szervezetek korlátokat érvényesítsenek, a felhasználók pedig ezeken belül testre szabják a konfigurációjukat. Az így létrejött jogosultsági profilokat a végrehajtási környezet használhatja, vagy közvetlenül egy parancsra is alkalmazhatók, ahogy azt a következőkben bemutatjuk.
A Codex CLI sandbox parancsával tetszőleges parancs futtatható a Codex konfigurációjában meghatározott jogosultsági profil alatt. Ezt gyakran a profil tesztelésére használják, hogy ellenőrizzék: a sandbox valóban megakadályozza-e azokat a műveleteket, amelyeket blokkolnia kell.
A következő parancs például megpróbálja úgy beállítani a VS Code-ot, hogy mentéskor egy rosszindulatú automatikus formázót futtasson. Ha a .vscode már létezik, a fent meghatározott dev profilnak blokkolnia kell ezt az írást, mert ez a könyvtár csak olvasható (a codex sandbox alapértelmezés szerint a cwd könyvtárat tekinti a munkaterület gyökerének):
macOS-en ez valóban meghiúsul, a következő hibaüzenettel:
A codex sandbox parancs az ügynökmunkamenettől függetlenül is elérhetővé teszi a Codex sandboxmechanizmusát. Ugyanazzal a konfigurációs nyelvvel és platformspecifikus szabályérvényesítéssel korlátozhatod a saját eszközeid által indított parancsokat is.
A config.toml fájlban konfigurált stdio MCP-szerver esetében a Codex végrehajtási környezete nem próbálja sandboxban futtatni a szervert indító parancsot. A Codex nem tudja megbízhatóan kikövetkeztetni, hogy a szervernek mely fájlokra vagy hálózati szolgáltatásokra van szüksége, ezért egy alapértelmezett sandboxprofil alkalmazása működésképtelenné tehetne egy egyébként érvényes konfigurációt.
Az @modelcontextprotocol/server-memory(új ablakban nyílik meg) MCP-szervert például szokásosan így konfiguráljuk a Codexszel való használathoz:
Mivel ez az npx parancs sandbox nélkül fut, a Codexet futtató felhasználó jogosultságaival írhat fájlokat és küldhet hálózati kéréseket, ami túl nagy szabadságot ad neki. A korlátozásához meghatározhatunk egy memory-mcp nevű jogosultsági profilt, majd az eredeti npx parancsot a codex sandbox --permission-profile memory-mcp paranccsal futtathatjuk. Ezzel megszabhatjuk, hová írhat a szerver, és megakadályozhatjuk a hálózati hozzáférését:
A szerver indítása előtt hozd létre az adatkönyvtárát, és helyezd el a rögzített verziójú csomagot az npm gyorsítótárában. Így az npx --offline olyan profil alatt is elindíthatja a szervert, amely tiltja a hálózati hozzáférést:
Ha a csomag már a gyorsítótárban van, a Codex hálózati hozzáférés nélkül indíthatja el a memóriaszervert, miközben az írás csak az npm gyorsítótárára és a szerver adatkönyvtárára korlátozódik.
A sandbox megvalósítása a jogosultsági profilt az operációs rendszer által érvényesített korlátozásokká alakítja. A hálózati proxy alapvető kéréskezelési és házirendlogikája mindhárom fő operációs rendszeren közös, míg a proxy beállítása és a sandboxszal való integrációja operációsrendszer-specifikus. Először a közös proxyt vizsgáljuk meg, majd a macOS-, Linux- és Windows-megvalósításokat.
A jogosultsági profil hálózati korlátozásainak érvényesítéséhez a végrehajtási környezet elindít egy hálózati proxyt, és úgy konfigurálja a sandboxot, hogy ahhoz engedélyezze a csatlakozást, a külső gépekhez vezető közvetlen kapcsolatokat viszont blokkolja. A proxy minden kérést ellenőriz a profil tartományokra vonatkozó szabályai alapján, és eldönti, hogy továbbítja-e.
A Codex adattárában a hálózati proxy a codex-network-proxy(új ablakban nyílik meg) crate-ben valósul meg. Ezt a végrehajtási környezet programkönyvtárként használja, de önálló parancssori eszközként(új ablakban nyílik meg) is lefordítható. Ha engedélyezve van, a codex-network-proxy alapértelmezés szerint egy HTTP-proxyt és egy SOCKS5-proxyt is elindít. A proxyk címeit környezeti változók adják át a sandbox által indított folyamatnak. A szabványos környezeti változók, például a HTTP_PROXY, a HTTPS_PROXY és az ALL_PROXY mellett több ismert alkalmazásspecifikus környezeti változó(új ablakban nyílik meg) is bekerül a környezetbe, például a PIP_PROXY. Ezeket a környezeti változókat azonban nem minden program veszi figyelembe. Ha egy program közvetlenül próbál csatlakozni egy külső géphez, az operációs rendszer sandboxkorlátozásai blokkolják, ahogy azt az alábbi platformspecifikus szakaszokban ismertetjük.
A hálózati proxy felel a jogosultsági profilban meghatározott hálózati korlátozások érvényesítéséért. A korábban bemutatott dev profil például engedélyezi a *.openai.com felé irányuló kéréseket, és kifejezetten tiltja az evil.example felé irányulókat. Ha egy kérés olyan tartományt céloz, amelyre sem engedélyező, sem tiltó szabály nem illeszkedik, a proxy felfüggesztheti a kérést, amíg jóváhagyást kér a végrehajtási környezettől. A shellparancs példájához hasonlóan a Codex közvetlenül a felhasználótól kérhet jóváhagyást, vagy automatikus felülvizsgálatra(új ablakban nyílik meg) küldheti a kérést. A döntés kézhezvétele után a proxy továbbengedi a kérést, vagy hibaválasszal elutasítja.
A sorrend itt fontos, mert már egy DNS-lekérdezés is kiszivárogtathat a gépnévbe kódolt információkat. A proxy ezért csak azután oldja fel a kért gépnevet, hogy megállapította: az engedélyezett vagy jóváhagyott. Fontos megjegyezni, hogy a tág helyettesítő karakteres szabályok vagy a DNS-szolgáltatásokhoz való hozzáférés továbbra is lehetővé tehetik a DNS-alapú adatkiszivárogtatást.
macOS-en a Codex a Seatbelt(új ablakban nyílik meg) megoldást, az Apple kernel által érvényesített sandboxmechanizmusát használja. A Seatbelt-házirendek Sandbox Profile Language (SBPL) nyelven íródnak. Ez egy Scheme-alapú nyelv a sandboxkorlátozások leírására. A Codex a macOS /usr/bin/sandbox-exec parancsán keresztül hívja meg a Seatbeltet. A codex sandbox parancshoz hasonlóan először a sandboxot leíró kapcsolókat fogadja, majd a futtatandó parancsot:
A PROFILE egy SBPL-karakterlánc, amely a sandboxot konfiguráló bejegyzéseket tartalmazza. A következő SBPL-kódrészlet például olvashatóvá és írhatóvá teszi a /dev/null és a /dev/zero fájlt a sandbox házirendjében:
Ha a sandbox indításakor a hálózati proxy engedélyezve van, az alábbihoz hasonló szabályok kerülnek a profilba, hogy a kapcsolatokat a megfelelő helyi portokra korlátozzák:
A Codex alapprofilja a (deny default) bejegyzéssel kezdődik, ezért a kimenő kapcsolatok explicit engedélyezés hiányában tiltva maradnak.
Végül az SBPL a (param) használatával helyőrzőket is tartalmazhat:
Ezek értékét a sandbox-exec parancsnak átadott -Dkey=value kapcsolók adják meg.
Saját sandbox API-ja megvalósításához a Codex egy alapházirendből(új ablakban nyílik meg) kiindulva összeállítja az argumentumok listáját(új ablakban nyílik meg) a sandbox-exec számára, majd a permission_profile és más környezeti információk alapján kiegészíti azt a teljes Seatbelt-profil létrehozásához. Az így kapott profil és a hozzá tartozó -D argumentumok állítják be a Seatbelt által érvényesített korlátozásokat, míg a hálózati proxy további hálózati szabályokat érvényesít. A teljes argumentumlista összeállítása után a sandbox-exec meghívása már egyszerű.
A helyes SBPL előállítása nehéz feladat, mert az Apple nem dokumentálja a nyelvet külső fejlesztők számára. A man sandbox-exec valóban ezt írja: The sandbox-exec command is DEPRECATED (ahogy a man 3 sandbox_init által dokumentált sandbox_init() könyvtári függvény is elavultnak minősül). Az elavultságra figyelmeztető jelzés ellenére a macOS továbbra is tartalmaz Seatbelt-profilokat a /usr/share/sandbox alatt, és külső szoftverek, köztük a Google Chrome és a Chromium(új ablakban nyílik meg), továbbra is a Seatbeltre támaszkodnak. Ezért a belátható jövőben továbbra is a Seatbelt használatát tervezzük.
Linuxon a Codex két megoldás kombinációjával hozza létre a sandboxot: a bubblewrap(új ablakban nyílik meg) (bwrap) elkülönített környezetek létrehozására szolgáló parancssori eszköz, a seccomp-bpf(új ablakban nyílik meg) pedig a Linux kernel rendszerhívás-szűrő mechanizmusa. A beállításokat egy codex-linux-sandbox nevű belső segédprogram hangolja össze. A macOS sandbox-exec parancsához hasonlóan egy sandboxkonfigurációt fogad, amelyet a futtatandó parancs követ:
Ha fájlrendszer-elkülönítésre vagy proxyn keresztüli útválasztásra van szükség, a codex-linux-sandbox a bwrap meghívásával hozza létre a kezdeti sandboxkörnyezetet. A bwrap ezután ezen belül indítja el a codex-linux-sandbox --apply-seccomp-then-exec parancsot. Ez a második hívás a seccomp-bpf segítségével további korlátozásokat alkalmaz a felhasználó parancsának futtatása előtt.
A kezdeti sandboxkörnyezet létrehozásához a Codex a bubblewrap segítségével egy külön csatolási névtérben olyan fájlrendszernézetet hoz létre, amely megfelel a jogosultsági profil fájlrendszerszabályainak. Mivel ez a sandbox megvalósításának alapvető eleme, a Codex saját bwrap-példányt is tartalmaz arra az esetre, ha a felhasználó nem telepített volna ilyet. Ha azonban a PATH útvonalain található kompatibilis telepítés, azt részesíti előnyben a (új ablakban nyílik meg)bwrap(új ablakban nyílik meg) futtatásához. Tapasztalataink szerint egyes Linux-disztribúciók alapértelmezés szerint letiltják a felhasználói névterekhez való hozzáférést(új ablakban nyílik meg), de kivételt tesznek a rendszer bwrap-példányával.
A sandbox-exec parancshoz hasonlóan a bwrap is egy sandboxkonfigurációt fogad, amelyet a sandboxban futtatandó parancs követ. A bwrap az SBPL-hez hasonló egyedi konfigurációs nyelv helyett külön kapcsolókat használ a beállításokhoz. A Codex a következő kapcsolókkal hozza létre a fájlrendszernézetet:
--bind: írható fájl vagy könyvtár megadása--ro-bind: csak olvasható fájl vagy könyvtár megadása--perms 000 --tmpfs DIR --remount-ro DIR: aDIRelérésének tiltása--perms 000 --ro-bind-data FD FILE: aFILEelérésének tiltása (ahol azFDa/dev/nullmegnyitott fájlleírója)
A tiltó globminták e kapcsolókkal történő alkalmazásához a Codex minden parancs indítása előtt konkrét útvonalakká bontja ki a mintákat. Az újonnan létrejövő, illeszkedő útvonalak nem kerülnek be automatikusan az adott parancs sandboxkorlátozásai közé.
A Codex olyan kapcsolókat is megad, mint a --unshare-ipc és a --unshare-pid, hogy a sandbox ne férhessen hozzá a gazdagép más típusú erőforrásaihoz. A bubblewrap tehát nem csupán a fájlok láthatóságát szabályozza.
A bubblewrap használatakor a Codex mindig átadja a --unshare-net kapcsolót, ha a hálózat le van tiltva, vagy a kapcsolatoknak a hálózati proxyn keresztül kell haladniuk. Ez új hálózati névteret hoz létre a sandbox számára. Ezután a seccomp-bpf segítségével tovább korlátozzuk a parancs számára elérhető hálózati rendszerhívásokat és socketcsaládokat.
Ehhez a seccompiler crate-et(új ablakban nyílik meg) használjuk: dinamikusan lefordítunk egy BPF-programot a kívánt szűrők alapján(új ablakban nyílik meg), majd alkalmazzuk a sandbox egyik indítófolyamatára, hogy a teljes folyamatfa örökölje a korlátozásokat. A bwrap ezért nem a felhasználó parancsát futtatja, hanem a codex-linux-sandbox indítóprogramot, annak saját konfigurációs argumentumaival, amelyeket a felhasználó parancsa követ:
Ahhoz, hogy a seccomp-szűrők emelt szintű jogosultságok nélkül is alkalmazhatók legyenek, az indítóprogram beállítja a Linux no_new_privs jelzőjét(új ablakban nyílik meg). Ezt a jelzőt a gyermekfolyamatok öröklik, így más programok, például setuid végrehajtható fájlok indításával sem szerezhetnek további jogosultságokat.
A seccomp-szűrők a hálózati konfigurációtól függenek. Ha a hálózati hozzáférés le van tiltva, több hálózati rendszerhívást is blokkolunk, például a connect(2) és a bind(2) hívást. Ha viszont a hálózati proxy engedélyezve van a sandboxban, engedélyezzük az IP-socketeket, hogy elérhető legyen a codex-linux-sandbox által létrehozott TCP-figyelő. Az önálló Unix domain socketek létrehozását ugyanakkor alapértelmezés szerint blokkoljuk, mert ezek nem szándékos hozzáférést tehetnének lehetővé a gazdagép erőforrásaihoz.
Ha a sandbox konfigurációja hálózati proxy használatát indokolja, a Codex végrehajtási környezete létrehoz egy proxypéldányt, amely ugyanazon Codex-szálon belül a codex-linux-sandbox több hívásához is felhasználható. Minden sandboxnak el kell tudnia érni ezt a közös proxyt a saját elkülönített hálózati névteréből. A Codex egy loopback TCP-figyelőt biztosít a névtéren belül, és gondoskodik arról, hogy egy sandboxon kívüli folyamat fogadja a kapcsolatait, és továbbítsa azokat a proxyhoz.
A következő ábrák ezt az elrendezést mutatják be egy proxyvégpont esetében; az utolsó ábrán egy azon áthaladó kapcsolat is látható. A bubblewrap indítása előtt a codex-linux-sandbox létrehoz egy vezérlőcsatornaként szolgáló Unix socketpárt, majd elágaztatja saját folyamatát. A gyermekfolyamat a run_host_bridge() függvényt futtatja, és várja, hogy a csatornán megkapja a figyelő fájlleíróját:
Ebben a példában a szülőfolyamat az exec segítségével a bwrap programra cseréli a saját programképét. Ez beállítja a sandboxot, majd azon belül elindítja a codex-linux-sandbox --apply-seccomp-then-exec parancsot, továbbadva a vezérlőcsatorna fájlleíróját:
A sandbox hálózati névterében a codex-linux-sandbox második hívása létrehoz egy loopback TCP-figyelőt, és a socketen keresztül átadja annak fájlleíróját. A figyelő továbbra is a sandbox hálózati névteréhez kapcsolódik. Így a sandboxon kívül maradt gyermekfolyamat fogadhatja a sandboxban futó programok kapcsolatait, miközben a proxy felé irányuló kapcsolatait a gazdagép hálózati névterében nyitja meg. Az átadás után mindkét folyamat lezárja a vezérlőcsatorna leíróit, a sandboxon belüli folyamat pedig a figyelő saját példányát is lezárja.
Amint a TCP-figyelő készen áll, a sandboxon belüli folyamat beállítja a megfelelő értéket a HTTP_PROXY(új ablakban nyílik meg) és a kapcsolódó környezeti változók számára, hogy erre a figyelőre mutassanak. Ezután alkalmazza a seccomp korlátozásait, mielőtt elágaztatja a folyamatot és végrehajtja a felhasználó parancsát:
A sandboxon kívüli folyamat nyitva tartja a figyelőt. Minden elfogadott kapcsolathoz kapcsolatot nyit a beállított proxy felé, és mindkét irányban továbbítja az adatokat.
Ez a kiegészítő mechanizmus saját hálózati névteret biztosít a parancsnak, külön loopback interfésszel. macOS-en a Seatbelt lehetővé teszi, hogy a parancs közvetlenül csatlakozzon a gazdagép loopback interfészének megadott portjaihoz. Linuxon ehelyett a parancs az elkülönített névterén belüli figyelőhöz csatlakozik, és egy sandboxon kívüli folyamat továbbítja ezeket a kapcsolatokat a beállított proxyhoz. A leíró átadása úgy teszi lehetővé ezt a kapcsolatot, hogy a parancs nem kap hozzáférést a gazdagép hálózati névteréhez.
Az év elején megvalósítottuk a windowsos sandboxot, és írtunk az ezzel kapcsolatos munkánkról. Azóta a Microsoft kiadott egy MXC nevű programkönyvtárat, valamint új folyamatelkülönítési funkciókat a Windows operációs rendszerben. Jelenleg a meglévő sandboxunkat egy olyan megoldásra cseréljük, amely az MXC programkönyvtárat használja.
Az MXC (Microsoft eXecution Container) a Microsoft sandboxban történő kódfuttatásra szolgáló rendszere(új ablakban nyílik meg), amely többféle elkülönítési háttérmegoldást támogat Windowson, Linuxon és macOS-en. A Codex a kompatibilis Windows-eszközökön MXC-alapú sandboxot támogat, amely natív folyamatelkülönítéssel korlátozza a parancsokat a felhasználó meglévő környezetén belül.
Az MXC-re való átállással javítjuk a biztonságot és a használhatóságot, miközben kiküszöböljük a meglévő windowsos sandboxunk több korlátját:
A sandbox beállításához emelt szintű vagy rendszergazdai jogosultság szükséges
Az ACL-ek ellenőrzése és beállítása erőforrás-igényes és lassú
A sandbox beállításai tartósan megmaradnak a gazdagépen, többek között:
ACL-ek
Tűzfalszabályok
Sandbox-felhasználók
A vezérlési sík fájljai
Az MXC egy JSON-konfigurációs sémát(új ablakban nyílik meg) tesz elérhetővé. A Codex az MXC SDK(új ablakban nyílik meg) segítségével állít össze egy, a sémának megfelelő végrehajtási kérelmet, amely tartalmazza a parancsot, a munkakönyvtárat, a környezetet és a jogosultságokat. Ezek a jogosultságok a fájlrendszer- és hálózati hozzáférésre, valamint olyan Windows-erőforrásokra terjednek ki, mint az asztal és a vágólap.
A Codex több vezérlési lehetőséghez rögzített beállításokat használ, hogy egyensúlyt teremtsen a kompatibilitás és a biztonság között. Engedélyezi a rendszerleíró adatbázis olvasását, és megőrzi a PowerShell indulásához szükséges Win32k- és asztalhozzáférést. A vágólaphoz való hozzáférés, a bemeneti események injektálása, valamint az asztal és a rendszerbeállítások vezérlése le van tiltva. Végül az MXC nem folyamodhat tartalék megoldásként a gazdagép fájlrendszer-jogosultságainak módosításához.
A Codex a jogosultsági profil fájlrendszer- és hálózati szabályait MXC-konfigurációvá alakítja. A korábbi dev profilt használva, és feltételezve, hogy:
A gép egyetlen helyi meghajtói a
C:\, aD:\és aZ:\.A munkaterület gyökérkönyvtára és a munkakönyvtár a
C:\work\demo.A felhasználó saját könyvtára a
D:\Users\dev, így a~/build-cacheaD:\Users\dev\build-cacheútvonalra oldódik fel.A tiltó globminta csak a
C:\work\demo\config\dev.envés aC:\work\demo\config\prod.envútvonalra illeszkedik.
A megfelelő MXC-beállítások a következőket tartalmaznák:
Az MXC fájlrendszer-házirendje alapértelmezés szerint megtagadja a hozzáférést. A Codex ezért csak olvasási jogosultságot ad a helyi meghajtók gyökérkönyvtáraihoz, hogy biztosítsa a profil által engedélyezett széles körű olvasási hozzáférést. Ezek a jogosultságok rekurzívan érvényesülnek, a felhasználó meglévő operációsrendszer-szintű jogosultságainak keretein belül.
Van azonban egy sajátosság: a meghajtó gyökérkönyvtárára adott írási jogosultság nem érvényesül rekurzívan, ezért a Codex kiterjeszti azt a meghajtó már meglévő közvetlen gyermekelemeire is.
A pontosabb útvonalak felülírják a szülőkönyvtárakra adott jogosultságokat, így a C:\work\demo írható lehet a csak olvasható C:\ alatt, miközben a C:\work\demo\.git csak olvasható marad.
Ha eltérő útvonal-megadások vagy szimbolikus hivatkozások és junction álnevek ugyanarra az útvonalra mutatnak, az MXC a szigorúbb jogosultságot alkalmazza: a tiltás elsőbbséget élvez a csak olvasással szemben, az pedig az írás-olvasással szemben.
Az MXC csak konkrét tiltott útvonalakat fogad el, ezért a Codex indítás előtt feloldja a tiltó globmintákat az illeszkedő fájlok és könyvtárak listájává. A parancs futása közben létrejövő, a globmintára illeszkedő új útvonalak nem kerülnek automatikusan a listába.
Az olyan tartományszabályokat, mint a *.openai.com, a korábban ismertetett közös Codex hálózati proxy érvényesíti. A Codex ezt a proxyt a sandboxon kívül futtatja, és a korábban említett szabványos *_PROXY környezeti változókon keresztül adja át a címeit a parancsnak. Az MXC blokkolja a közvetlen külső kapcsolatokat, de engedélyezi a gazdagép loopback interfészéhez való csatlakozást, beleértve a proxy elérését is. Más helyi szolgáltatások is elérhetők maradnak.
A végrehajtási környezet macOS-en, Linuxon és Windowson ugyanazt a sandbox API-t használja a parancsok jogosultsági profil alatti indításához. A korlátozások alkalmazásához szükséges beállításokról a platformspecifikus megvalósítások gondoskodnak.
A kódírás és -futtatás rugalmas eszközt ad az ügynököknek a szoftverfejlesztésen túli problémák megoldásához is. A Codex sandbox lehetővé teszi, hogy ezt a képességet a felhasználó meglévő környezetében használják, egyértelműen meghatározott fájlrendszer- és hálózati hozzáférési korlátok mellett. A sandbox a végrehajtási környezet újrafelhasználható alapeleme, amelyet a codex sandbox parancs a saját fejlesztésű eszközeid számára is elérhetővé tesz.
Ahogy az ügynökök egyre több feladatot látnak el, szeretnénk minél több eszköz és környezet számára praktikussá tenni a sandboxban történő futtatást. Ehhez egyszerűbbé kell tennünk a jogosultságok konfigurálását, és ki kell használnunk az operációs rendszerek új, fejlettebb védelmi lehetőségeit, amint elérhetővé válnak. Célunk, hogy bővítsük az ügynökök képességeit, miközben továbbra is az emberek dönthetnek arról, mihez férhetnek hozzá.


