På OpenAI tillämpar vi djupförsvar(öppnas i ett nytt fönster) för att skydda agenter. Våra satsningar på träning och anpassning till mänskliga intentioner är grundläggande för detta arbete, men vi implementerar också funktioner i vår körmiljö för agenter, Codex(öppnas i ett nytt fönster), för att ge ytterligare skydd. En av de vanligaste (och potentiellt riskfyllda) sakerna Codex gör är att köra kommandon på din dator. Därför byggde vi Codex-sandlådan, så att Codex kan arbeta i din befintliga miljö med begränsningar för filsystem och nätverk som du styr.
En (öppnas i ett nytt fönster)sandlåda(öppnas i ett nytt fönster) begränsar vad ett program kan komma åt medan det körs. För en uppgift som går ut på att organisera foton kan du konfigurera Codex-sandlådan så att kommandon får läsa och ändra filer i ~/Pictures, medan nätverksåtkomst blockeras för att förhindra uppladdningar. Vid kodgranskning kan du tillåta åtkomst till dokumentation på nätet men behålla källfilerna skrivskyddade. Användare konfigurerar Codex-sandlådan via (öppnas i ett nytt fönster)behörighetsprofiler(öppnas i ett nytt fönster), som definierar filsystems- och nätverksbegränsningarna för en Codex-session.
I den här artikeln börjar vi med avvägningarna bakom Codex-sandlådans standardinställningar. Sedan förklarar vi hur sandlådan är utformad och hur körmiljön använder den för att köra kommandon. Vi visar hur slutanvändare och företag kan anpassa behörigheterna efter sina behov och hur utvecklare kan återanvända sandlådan i egna verktyg. Till sist undersöker vi hur dessa begränsningar upprätthålls på macOS, Linux och Windows.
Vår filosofi i Codex är att välja försiktiga standardinställningar för sandlådan som ändå gör det möjligt att utföra meningsfullt arbete. Med ett Git-förvar som arbetsytans rot gör exempelvis den inbyggda behörighetsprofilen :workspace följande:
Tillåter skrivning inom arbetsytan, men behåller kataloger som
.gitoch.codexskrivskyddade. Det låter Codex redigera källkod utan att be om tillstånd för varje ändring, samtidigt som direkta ändringar av.codex/config.tomleller Git-hookar under.git/hooksförhindras.Tillåter bred läsåtkomst till filsystemet, inom ramen för användarens befintliga behörigheter i operativsystemet. Kompilatorer, exekveringsmiljöer och byggverktyg är beroende av SDK:er, bibliotek och konfiguration utanför förvaret. Om läsning begränsades till arbetsytan skulle många vanliga arbetsflöden sluta fungera. Nackdelen är att även känsliga filer på andra platser på datorn kan förbli läsbara, till exempel konfigurationsfiler som innehåller API-nycklar.
Inaktiverar nätverksåtkomst. Det blockerar direkta uppladdningar till externa tjänster, inklusive försök att föra ut data som kommandot kan läsa. Det förhindrar också legitima åtgärder som att ladda ned beroenden, vilket kräver ytterligare åtkomst.
Dessa begränsningar förhindrar många typer av oönskat beteende, men skadliga handlingar är fortfarande möjliga. Agenten skulle till exempel kunna injicera skadlig kod i ett lokalt installerat paket som node_modules/prettier. En sådan ändring kanske inte syns i git status eftersom node_modules ofta ignoreras av Git. Om användarens editor kör den kopian av Prettier när en fil sparas, skulle det räcka att spara en fil för att köra den skadliga koden utanför Codex-sandlådan. Det är därför vi tillämpar djupförsvar: sandlådan begränsar vad kommandon kan komma åt, medan träning och anpassning till mänskliga intentioner hjälper modellen att använda åtkomsten i enlighet med användarens avsikt.
Vägledning om hur du anpassar sandlådebehörigheter och kombinerar dem med andra skydd i en företagsmiljö finns i Codex säkerhetshandbok(öppnas i ett nytt fönster).
Virtuella maskiner och containrar(öppnas i ett nytt fönster) är två populära mekanismer för sandlådeisolering, men med Codex-sandlådan väljer vi ett annat tillvägagångssätt. I stället för att flytta beräkningarna till en separat miljö för att skapa isolering använder Codex varje plattforms sandlådemekanismer för att begränsa kommandon som körs i användarens befintliga miljö.
För många utvecklare är den bärbara datorn en skräddarsydd utvecklingsmiljö som de kan ändra när de vill. Att återskapa den miljön i en Docker-container kan kräva arbete, och vissa arbetsflöden är ändå beroende av verktyg som körs på värddatorn.
Tänk dig till exempel att du använder Codex för att utveckla en iOS-app på en Mac. Om du valde att isolera Codex genom att köra det i Docker skulle Codex varken kunna köra iOS-verktygskedjan, som består av program byggda för Mac, eller starta iPhone-simulatorn för att köra koden. Ett Docker-baserat arbetsflöde skulle kunna delegera byggen och simulatoråtgärder till Mac-värden, men dessa åtgärder skulle då köras utanför containerns sandlåda och behöva egna begränsningar. För Codex föredrar vi att hålla det enkelt genom att satsa stort på operativsystemsspecifik sandlådeisolering, så att Codex kan köras i den miljö som passar bäst för uppgiften.
Körmiljön gör dessa operativsystemsspecifika sandlådemekanismer tillgängliga via ett gemensamt API för macOS, Windows och Linux. Detta API tar emot ett kommando och en behörighetsprofil. Om behörighetsprofilen tillåter begränsad nätverksåtkomst måste anroparen tillhandahålla en nätverksproxy som upprätthåller begränsningarna:
Den här funktionen startar processen i en sandlåda och returnerar ett Child-handtag som körmiljön kan använda för att vänta tills processen är klar. Varje barnprocess ärver föräldraprocessens sandlådebegränsningar. Begränsningarna gäller därför i hela det processträd som kommandot startar, även för efterkommande processer som lever vidare efter den ursprungliga processen.
Följande diagram visar hur delarna hänger ihop, från konfiguration till körning av ett kommando i sandlådan. De följande avsnitten förklarar varje steg.

Som beskrivs i Codex agentloop steg för steg ansvarar Codex-körmiljön för att utföra de verktygsanrop som modellen genererar. För kodningsuppgifter är det vanligaste verktyget ett skalverktyg, som kör kommandon ungefär som en användare skulle göra i ett interaktivt skal som Bash. Här tittar vi på One-shot-varianten av (öppnas i ett nytt fönster)exec_command(öppnas i ett nytt fönster) som skalverktyg(öppnas i ett nytt fönster) för att illustrera hur körmiljön använder sandlådan för att ge det önskade skyddet.
Det här är en förenklad version av hur verktygsanropet exec_command skulle hanteras av Codex-körmiljön utan sandlådeisolering:
För att köra kommandot i en sandlåda ersätter körmiljön anropet till subprocess.Popen() med spawn_command_under_sandbox(). Körmiljön tillhandahåller behörighetsprofilen och vid behov nätverksproxyn:
Verktyget exec_command låter också modellen begära andra behörigheter för ett enskilt kommando, men körmiljön avgör om begäran ska beviljas:
När use_default anges använder körmiljön turens standardkonfiguration för sandlådan. with_additional_permissions begär utökad åtkomst inom sandlådan, medan require_escalated begär körning utanför den. Körmiljön utvärderar begäran utifrån användarens inställningar innan kommandot körs. (Codex kan till exempel fråga användaren direkt eller skicka begäran till automatisk granskning(öppnas i ett nytt fönster).) Om körningen godkänns skickar Codex lämpliga värden för permission_profile och network_proxy till perform_exec_command_with_sandboxing() tillsammans med kommandoargumenten från det ursprungliga ExecCommandToolCall.
Skalverktyget är den huvudsakliga användaren av spawn_command_under_sandbox(), och körmiljön återanvänder även sin sandlådeinfrastruktur för åtgärder som att läsa och ändra lokala filer. Återanvändningen sträcker sig även utanför körmiljön: kommandot codex sandbox låter dig integrera kommandokörning i sandlådor i dina egna verktyg, vilket vi ska se senare. Härnäst tittar vi på hur behörighetsprofiler definieras.
Med en namngiven behörighetsprofil kan du återanvända samma filsystems- och nätverksbegränsningar i flera projekt. Du kan definiera egna profiler under [permissions] i config.toml. Följande exempel definierar en profil som heter dev och som utökar(öppnas i ett nytt fönster) den inbyggda profilen :workspace:
Profilen dev lägger till skrivåtkomst till ~/build-cache och inför ytterligare begränsningar för filer i arbetsytan. Filsystemsposter kan ge enbart läsåtkomst (read), ge läs- och skrivåtkomst (write) eller blockera åtkomst helt (deny).
Tabellen :workspace_roots låter dig definiera regler för sökvägar relativt rötterna i ett projekts arbetsyta. Som standard använder Codex CLI sin arbetskatalog som arbetsytans enda rot, medan ChatGPT:s skrivbordsapp använder projektets källmappar. Codex tillämpar varje regel på varje rot, så posten .vscode i dev gör katalogen .vscode skrivskyddad under varje rot.
Utöver sina egna regler ärver dev följande skydd från :workspace:
Det finns i stort sett tre alternativ för att konfigurera nätverket för sandlådan i Codex:
Inaktivera all nätverksåtkomst (standard för profilen
:workspace)Aktivera fullständig, direkt nätverksåtkomst (standard för profilen
:danger-full-access)Begränsa nätverksåtkomsten till en proxy som avgör vad som ska släppas igenom utifrån behörighetsprofilen
För att ge dev direkt nätverksåtkomst anger du permissions.dev.network.enabled = true på den översta nivån i config.toml. Det ger fullständig nätverksåtkomst när nätverksproxyn är inaktiverad.
För att begränsa dev till en uppsättning domäner aktiverar du nätverksproxyn och konfigurerar dess domänregler:
Domänregler stöder exakta namn och jokerteckenmönster. Uttryckliga regler för nekad åtkomst har företräde framför tillåtande regler. Anrop till andra domäner kräver godkännande eller blockeras, enligt beskrivningen i Nätverksproxy nedan.
Enskilda användare kan konfigurera standardinställningar som gäller för alla projekt och åsidosätta dem för ett visst betrott projekt. Företagsadministratörer kan också vilja konfigurera standardinställningar för sina användare och begränsa vilka inställningar användarna får ändra. Codex stöder båda genom konfiguration i lager och centralt hanterade krav.
Som beskrivs i Prioritetsordning för konfiguration,(öppnas i ett nytt fönster) slår Codex samman inställningar från flera config.toml-filer. Tabeller slås samman rekursivt, och källan med högre prioritet avgör vid motstridiga värden. Arrayer ersätts i sin helhet.
Det är därför behörighetsprofiler använder tabeller för filsystemssökvägar och nätverksdomäner. Ett team kan lägga till eller åsidosätta enskilda poster i sin egen konfiguration och automatiskt ärva ändringar i alla övriga poster i organisationens grundkonfiguration:
Administratörer kan också tillhandahålla centralt hanterade krav(öppnas i ett nytt fönster) via requirements.toml för att begränsa användarnas konfigurationsval. Kraven kan komma från flera källor, inklusive systemfiler och policyer som tillhandahålls via molnet. Ett vanligt användningsfall är att ange allowed_permission_profiles för att begränsa vilka behörighetsprofiler en företagsanvändare kan välja. En administratör skulle till exempel kunna ange följande molnkrav:
Molnkraven skulle ha företräde framför systemets kravfil på /etc/codex/requirements.toml, så en post i den filen kan inte åsidosätta den uttryckliga inställningen ":danger-full-access" = false ovan. Om :workspace lämnas ospecificerad kan ett annat kravlager tillhandahålla den posten. Profiler vars poster är false eller saknas i den slutliga sammanslagna tabellen är inte tillgängliga.
Denna uppdelning låter organisationer upprätthålla begränsningar samtidigt som användare anpassar sin konfiguration inom dessa gränser. De resulterande behörighetsprofilerna kan användas av körmiljön eller tillämpas direkt på ett kommando, vilket vi ska se härnäst.
Codex CLI har ett sandbox-kommando som gör det enkelt att köra valfritt kommando med en behörighetsprofil definierad i Codex-konfigurationen. Det används ofta för att testa profilen och kontrollera att sandlådan förhindrar det beteende som den är avsedd att blockera.
Följande kommando försöker till exempel konfigurera VS Code så att ett skadligt autoformateringsverktyg körs när en fil sparas. Om .vscode redan finns bör profilen dev som definieras ovan blockera skrivningen eftersom katalogen är skrivskyddad (codex sandbox behandlar som standard cwd som en rot för arbetsytan):
På macOS misslyckas detta mycket riktigt med:
Kommandot codex sandbox gör Codex sandlådemekanism tillgänglig oberoende av en agentsession. Du kan använda samma konfigurationsspråk och plattformsspecifika skydd för att begränsa kommandon som startas av dina egna verktyg.
För en MCP-server med stdio som konfigurerats i config.toml försöker Codex-körmiljön inte isolera kommandot som startar servern i en sandlåda. Codex kan inte med säkerhet avgöra vilka filer eller nätverkstjänster servern behöver, så en standardsandlådeprofil skulle kunna få en i övrigt giltig konfiguration att sluta fungera.
Så här konfigurerar man till exempel vanligtvis MCP-servern @modelcontextprotocol/server-memory(öppnas i ett nytt fönster) för användning med Codex:
Eftersom detta npx-kommando körs utan sandlåda kan det skriva filer och göra nätverksanrop med samma behörigheter som användaren som kör Codex, vilket ger alltför stor åtkomst. För att begränsa åtkomsten kan vi definiera en behörighetsprofil som heter memory-mcp och sedan köra det ursprungliga npx-kommandot via codex sandbox --permission-profile memory-mcp. Det begränsar var servern kan skriva och hindrar den från att komma åt nätverket:
Innan servern startas skapar du dess datakatalog och lägger den låsta paketversionen i npm-cachen. Då kan npx --offline starta servern med en profil som inaktiverar nätverksåtkomst:
När paketet finns i cachen kan Codex starta minnesservern utan nätverksåtkomst, med skrivåtkomst begränsad till npm-cachen och serverns datakatalog.
Sandlådeimplementationen omvandlar en behörighetsprofil till begränsningar som upprätthålls av operativsystemet. Nätverksproxyns grundläggande logik för anropshantering och policy är gemensam för alla tre stora operativsystem, medan konfigurationen av proxyn och dess integration med sandlådan är operativsystemsspecifika. Vi tittar först på den gemensamma proxyn och sedan på implementationerna för macOS, Linux och Windows.
För att upprätthålla behörighetsprofilens nätverksbegränsningar startar körmiljön en nätverksproxy och konfigurerar sandlådan så att anslutningar till proxyn tillåts, medan direkta anslutningar till externa värdar blockeras. Proxyn kontrollerar varje anrop mot profilens domänregler för att avgöra om det ska vidarebefordras.
I Codex-förvaret är nätverksproxyn implementerad i Rust-paketet codex-network-proxy(öppnas i ett nytt fönster), som körmiljön använder som bibliotek. Det kan dock även byggas som ett fristående kommandoradsverktyg(öppnas i ett nytt fönster). När codex-network-proxy är aktiverat startar det som standard både en HTTP-proxy och en SOCKS5-proxy. Proxyadresserna förmedlas till processen som startas av sandlådan via miljövariabler. Utöver standardmiljövariabler som HTTP_PROXY, HTTPS_PROXY och ALL_PROXY läggs även ett antal välkända programspecifika miljövariabler(öppnas i ett nytt fönster) till, exempelvis PIP_PROXY. Alla program tar visserligen inte hänsyn till dessa miljövariabler. Om ett program försöker ansluta direkt till en extern värd blockerar operativsystemets sandlådebegränsningar anslutningen, enligt beskrivningen i de plattformsspecifika avsnitten nedan.
Nätverksproxyn ansvarar för att upprätthålla de nätverksbegränsningar som definieras i en behörighetsprofil. Profilen dev som visades tidigare tillåter till exempel anrop till *.openai.com och nekar uttryckligen anrop till evil.example. När ett anrop riktas till en domän som inte matchar någon regel för tillåten eller nekad åtkomst kan proxyn pausa anropet och överlåta åt körmiljön att inhämta godkännande. Precis som i exemplet med skalkommandot kan Codex fråga användaren direkt eller skicka begäran till automatisk granskning(öppnas i ett nytt fönster). När proxyn har fått ett beslut låter den antingen anropet fortsätta eller avvisar det med ett felsvar.
Ordningen är viktig här, eftersom även en DNS-uppslagning kan läcka information som kodats i ett värdnamn. Proxyn slår därför upp det begärda värdnamnet först efter att ha fastställt att det är tillåtet eller godkänt. Observera att breda jokerteckenregler eller åtkomst till DNS-tjänster fortfarande kan göra det möjligt att föra ut data via DNS.
På macOS använder Codex Seatbelt(öppnas i ett nytt fönster), Apples sandlådemekanism vars begränsningar upprätthålls av kärnan. Seatbelt-policyer skrivs i Sandbox Profile Language (SBPL), ett Scheme-baserat språk för att uttrycka sandlådebegränsningar. Codex anropar Seatbelt via macOS-kommandot /usr/bin/sandbox-exec. Precis som codex sandbox tar det emot alternativ som beskriver sandlådan, följda av kommandot som ska köras:
PROFILE är en SBPL-sträng med poster som konfigurerar sandlådan. Följande SBPL-kodsnutt gör till exempel /dev/null och /dev/zero läs- och skrivbara enligt sandlådepolicyn:
När nätverksproxyn aktiveras vid ett sandlådeanrop läggs regler som följande till i profilen för att begränsa anslutningar till rätt lokala portar:
Codex grundprofil börjar med (deny default), så utgående anslutningar förblir blockerade om de inte uttryckligen tillåts.
Slutligen kan SBPL innehålla platshållare som använder (param):
Dessa fylls i med de -Dkey=value-alternativ som skickas till sandbox-exec.
För att implementera sitt eget sandlåde-API bygger Codex upp argumentlistan(öppnas i ett nytt fönster) till sandbox-exec utifrån en grundpolicy(öppnas i ett nytt fönster). Sedan används permission_profile och annan kontext för att anpassa den till en fullständig Seatbelt-profil. Den resulterande profilen och tillhörande -D-argument konfigurerar de begränsningar som Seatbelt upprätthåller, medan nätverksproxyn upprätthåller ytterligare nätverksregler. När hela argumentlistan är sammanställd är anropet till sandbox-exec enkelt.
Att generera korrekt SBPL är svårt eftersom Apple inte dokumenterar språket för användning av tredje part. I man sandbox-exec står faktiskt The sandbox-exec command is DEPRECATED (detsamma gäller biblioteksfunktionen sandbox_init(), som dokumenteras i man 3 sandbox_init). Trots varningen om utfasning levereras macOS fortfarande med Seatbelt-profiler i /usr/share/sandbox, och tredjepartsprogram, bland annat Google Chrome och Chromium(öppnas i ett nytt fönster), fortsätter att förlita sig på Seatbelt. Därför planerar vi att fortsätta använda Seatbelt under överskådlig tid.
För att skapa sandlådan på Linux använder Codex en kombination av bubblewrap(öppnas i ett nytt fönster) (bwrap), ett kommandoradsverktyg för att skapa isolerade miljöer, och seccomp-bpf(öppnas i ett nytt fönster), en mekanism i Linux-kärnan för att filtrera systemanrop. Ett internt hjälpprogram som heter codex-linux-sandbox samordnar konfigurationen. Precis som sandbox-exec på macOS tar det emot en sandlådekonfiguration följd av ett kommando som ska köras:
När filsystemet behöver isoleras eller trafiken dirigeras via en proxy anropar codex-linux-sandbox bwrap för att skapa den inledande sandlådemiljön. bwrap startar sedan codex-linux-sandbox --apply-seccomp-then-exec i den. Detta andra anrop använder seccomp-bpf för att tillämpa ytterligare begränsningar innan användarens kommando körs.
För att skapa den inledande sandlådemiljön använder Codex bubblewrap för att bygga en filsystemsvy i en separat monteringsnamnrymd som återspeglar behörighetsprofilens filsystemsregler. Eftersom detta är grundläggande för sandlådeimplementationen levereras Codex med en egen kopia av bwrap ifall användaren inte har installerat en egen, men föredrar en kompatibel installation av (öppnas i ett nytt fönster)bwrap(öppnas i ett nytt fönster) på PATH när en sådan finns. Vi har sett att vissa Linux-distributioner inaktiverar åtkomst till användarnamnrymder som standard(öppnas i ett nytt fönster), men gör ett undantag för systemets bwrap.
Precis som sandbox-exec tar bwrap emot en sandlådekonfiguration följd av ett kommando som ska köras i sandlådan. I stället för ett särskilt konfigurationsspråk som SBPL använder bwrap enskilda flaggor för konfigurationen. Codex använder följande alternativ för att skapa filsystemsvyn:
--bindför att ange en skrivbar fil eller katalog--ro-bindför att ange en skrivskyddad fil eller katalog--perms 000 --tmpfs DIR --remount-ro DIRför att neka åtkomst tillDIR--perms 000 --ro-bind-data FD FILEför att neka åtkomst tillFILE(därFDär en öppen filbeskrivare för/dev/null)
För att tillämpa glob-mönster för nekad åtkomst med dessa alternativ expanderar Codex dem till konkreta sökvägar innan varje kommando startas. Nya matchande sökvägar läggs inte automatiskt till i kommandots sandlådebegränsningar.
Codex anger också alternativ som --unshare-ipc och --unshare-pid för att hindra sandlådan från att komma åt andra typer av resurser på värden, så bubblewrap påverkar mer än bara vilka filer som är synliga.
När Codex använder bubblewrap skickar det med --unshare-net om nätverket är inaktiverat eller anslutningar måste gå via nätverksproxyn. Det skapar en ny nätverksnamnrymd för sandlådan. Vi använder sedan seccomp-bpf för att ytterligare begränsa de nätverksrelaterade systemanrop och socketfamiljer som kommandot kan använda.
Mer specifikt använder vi Rust-paketet seccompiler(öppnas i ett nytt fönster) för att dynamiskt kompilera ett BPF-program utifrån önskade filter(öppnas i ett nytt fönster) och tillämpa det på en startprocess i sandlådan, så att begränsningarna ärvs av hela processträdet. Därför kör bwrap inte användarens kommando direkt, utan startprogrammet codex-linux-sandbox med dess egna konfigurationsargument följda av användarens kommando:
För att tillämpa seccomp-filter utan förhöjda behörigheter anger startprogrammet Linux-flaggan no_new_privs för processen(öppnas i ett nytt fönster). Flaggan ärvs av barnprocesser och hindrar dem från att få ytterligare behörigheter när de kör ett annat program, till exempel en körbar fil med setuid.
Seccomp-filtren beror på nätverkskonfigurationen. När nätverksåtkomst är inaktiverad blockerar vi ett antal nätverksrelaterade systemanrop, som connect(2) och bind(2). När nätverksproxyn är aktiverad i sandlådan tillåter vi däremot IP-socketar så att TCP-lyssnaren som skapas av codex-linux-sandbox kan nås. Som standard blockerar vi dock skapandet av fristående Unix-domänsocketar, eftersom de oavsiktligt skulle kunna ge åtkomst till resurser på värden.
När sandlådekonfigurationen kräver nätverksproxyn skapar Codex-körmiljön en proxyinstans som kan återanvändas vid flera anrop till codex-linux-sandbox inom samma Codex-tråd. Varje sandlåda behöver kunna nå den delade proxyn från sin isolerade nätverksnamnrymd. Codex tillhandahåller en TCP-lyssnare på loopback-gränssnittet i namnrymden och ser till att en process utanför sandlådan accepterar dess anslutningar och vidarebefordrar dem till proxyn.
Följande diagram visar upplägget för en proxyslutpunkt. I det sista diagrammet visas en anslutning genom den. Innan bubblewrap startas skapar codex-linux-sandbox ett par Unix-socketar som kontrollkanal och förgrenar sig. Barnprocessen kör run_host_bridge() och väntar på att ta emot lyssnarens filbeskrivare via kanalen:
I det här exemplet använder föräldraprocessen exec för att ersätta sin programavbild med bwrap. Detta konfigurerar sandlådan och startar codex-linux-sandbox --apply-seccomp-then-exec i den, med kontrollkanalens filbeskrivare som argument:
Inuti sandlådans nätverksnamnrymd skapar det andra anropet till codex-linux-sandbox en TCP-lyssnare på loopback-gränssnittet och skickar dess filbeskrivare via socketen. Lyssnaren förblir knuten till sandlådans nätverksnamnrymd. Därmed kan barnprocessen som stannade utanför sandlådan acceptera anslutningar från program i sandlådan, samtidigt som den öppnar sina anslutningar vidare i värdens nätverksnamnrymd. Efter överlämningen stänger båda processerna sina filbeskrivare för kontrollkanalen, och processen i sandlådan stänger sin kopia av lyssnaren.
När TCP-lyssnaren är redo anger processen i sandlådan rätt värde för HTTP_PROXY(öppnas i ett nytt fönster) och relaterade miljövariabler så att de pekar på lyssnaren. Den tillämpar sedan seccomp innan den förgrenar sig och kör användarens kommando:
Processen utanför sandlådan håller lyssnaren öppen. För varje accepterad anslutning öppnar den en anslutning till den konfigurerade proxyn och vidarebefordrar data i båda riktningarna.
Den här extra mekanismen ger kommandot en egen nätverksnamnrymd med ett separat loopback-gränssnitt. På macOS låter Seatbelt kommandot ansluta direkt till angivna portar på värdens loopback-gränssnitt. På Linux ansluter kommandot i stället till en lyssnare i sin isolerade namnrymd, och en process utanför sandlådan vidarebefordrar dessa anslutningar till den konfigurerade proxyn. Överlämningen av filbeskrivaren möjliggör anslutningen utan att exponera värdens nätverksnamnrymd för kommandot.
Tidigare i år implementerade vi sandlådestöd på Windows och skrev om vårt arbete med detta. Sedan dess har Microsoft släppt ett bibliotek som heter MXC tillsammans med nya funktioner för processisolering i Windows. Vi håller nu på att ersätta vår befintliga sandlåda med en som använder MXC-biblioteket.
MXC (Microsoft eXecution Container) är ett system för kodkörning i sandlådor(öppnas i ett nytt fönster) från Microsoft med stöd för flera isoleringslösningar på Windows, Linux och macOS. Codex stöder en MXC-baserad sandlåda på kompatibla Windows-enheter och använder operativsystemets inbyggda processisolering för att begränsa kommandon i användarens befintliga miljö.
Vi går över till MXC för att förbättra säkerheten och användbarheten och samtidigt åtgärda flera begränsningar i vår befintliga Windows-sandlåda:
Krav på förhöjda behörigheter eller administratörsåtkomst för att konfigurera sandlådan
Resurskrävande och långsamma åtgärder för att kontrollera och ange ACL:er
Sandlådekonfiguration som blir kvar på värddatorn, bland annat
ACL:er
Brandväggsregler
Sandlådeanvändare
Kontrollplansfiler
MXC tillhandahåller ett JSON-schema för konfiguration(öppnas i ett nytt fönster). Codex använder MXC SDK(öppnas i ett nytt fönster) för att skapa en körningsbegäran som följer schemat och innehåller kommandot, arbetskatalogen, miljön och behörigheterna. Behörigheterna omfattar åtkomst till filsystem och nätverk samt Windows-resurser som skrivbordet och urklipp.
Codex använder fasta inställningar för flera skyddsmekanismer för att balansera kompatibilitet och säkerhet. Det tillåter läsning av registret och behåller den åtkomst till Win32k och skrivbordet som PowerShell behöver vid start. Åtkomst till urklipp, inmatningsinjektion och möjligheten att styra skrivbordet och systeminställningarna är inaktiverade. Slutligen hindras MXC från att som reservlösning ändra behörigheter i värdens filsystem.
Codex omvandlar behörighetsprofilens filsystems- och nätverksregler till MXC-konfiguration. Vi utgår från den tidigare profilen dev och antar att:
C:\,D:\ochZ:\är datorns enda lokala enheter.Arbetsytans rot och arbetskatalogen är
C:\work\demo.Användarens hemkatalog är
D:\Users\dev, så~/build-cachemotsvararD:\Users\dev\build-cache.Glob-mönstret för nekad åtkomst matchar endast
C:\work\demo\config\dev.envochC:\work\demo\config\prod.env.
Motsvarande MXC-inställningar skulle omfatta:
MXC:s filsystemspolicy nekar åtkomst som standard. Codex lägger därför till läsbehörigheter för de lokala enheternas rotkataloger för att ge den breda läsåtkomst som profilen tillåter. Dessa behörigheter gäller rekursivt, inom ramen för användarens befintliga behörigheter i operativsystemet.
En komplikation: skrivbehörigheter för enhetsrötter gäller inte rekursivt, så Codex utökar dem till att omfatta enhetens befintliga filer och kataloger direkt under roten.
Mer specifika sökvägar åsidosätter behörigheter för överordnade kataloger, så C:\work\demo kan vara skrivbar under en skrivskyddad C:\, medan C:\work\demo\.git förblir skrivskyddad.
När olika skrivsätt för sökvägar eller alias via symboliska länkar eller junctions pekar på samma sökväg tillämpar MXC den striktare behörigheten: nekad åtkomst går före skrivskydd, som i sin tur går före läs- och skrivåtkomst.
MXC tar endast emot konkreta sökvägar för nekad åtkomst, så Codex expanderar glob-mönstren till matchande filer och kataloger före start. Nya sökvägar som matchar glob-mönstret läggs inte till automatiskt medan kommandot körs.
Domänregler som *.openai.com upprätthålls av den gemensamma Codex-nätverksproxy som beskrivits tidigare. Codex kör proxyn utanför sandlådan och skickar dess adresser till kommandot via samma standardmiljövariabler, *_PROXY, som nämnts tidigare. MXC blockerar direkta externa anslutningar men tillåter anslutningar till värdens loopback-gränssnitt, inklusive åtkomst till proxyn. Andra lokala tjänster förblir nåbara.
På macOS, Linux och Windows använder körmiljön samma sandlåde-API för att starta kommandon med en behörighetsprofil. De plattformsspecifika implementationerna hanterar de förberedelser som krävs för att tillämpa begränsningarna.
Genom att skriva och köra kod kan agenter lösa problem på ett flexibelt sätt även utanför programvaruutveckling. Codex-sandlådan låter dem använda den förmågan i användarens befintliga miljö med uttryckliga begränsningar för åtkomst till filsystem och nätverk. Den är en återanvändbar byggsten i körmiljön, och kommandot codex sandbox gör den tillgänglig för verktyg som du bygger själv.
När agenter tar sig an fler uppgifter vill vi göra sandlådeisolering praktiskt användbar för fler verktyg och miljöer. Det innebär att göra behörigheter enklare att konfigurera och dra nytta av bättre skydd i operativsystemen när de blir tillgängliga. Vårt mål är att utöka vad agenter kan göra, samtidigt som människor behåller kontrollen över vad de kan komma åt.


