Innsiden av Codex-sandkassen
Slik kjører Codex kommandoer på maskinen din med grenser du kontrollerer.
Hos OpenAI bruker vi dybdeforsvar(åpnes i et nytt vindu) for å sikre agenter. Satsingen vår på trening og tilpasning til menneskelige intensjoner er grunnleggende for dette arbeidet. I tillegg implementerer vi funksjoner i agentrammeverket vårt, Codex(åpnes i et nytt vindu), som gir ekstra beskyttelse. En av de vanligste og potensielt risikable oppgavene Codex utfører, er å kjøre kommandoer på datamaskinen din. Derfor bygget vi Codex-sandkassen, slik at Codex kan arbeide i det eksisterende miljøet ditt innenfor filsystem- og nettverksgrenser du kontrollerer.
En (åpnes i et nytt vindu)sandkasse(åpnes i et nytt vindu) begrenser hva et program har tilgang til mens det kjører. For en oppgave med å organisere bilder kan du konfigurere Codex-sandkassen slik at kommandoer kan lese og endre filer i ~/Pictures, mens nettverkstilgang blokkeres for å hindre opplasting. For kodegjennomgang kan du tillate tilgang til dokumentasjon på nettet, men bare gi lesetilgang til kildefilene. Brukere konfigurerer Codex-sandkassen gjennom (åpnes i et nytt vindu)tillatelsesprofiler(åpnes i et nytt vindu), som definerer filsystem- og nettverksbegrensningene for en Codex-økt.
I denne artikkelen starter vi med avveiningene bak standardinnstillingene for Codex-sandkassen. Deretter forklarer vi hvordan sandkassen er utformet, og hvordan rammeverket bruker den til å kjøre kommandoer. Vi viser hvordan sluttbrukere og virksomheter kan tilpasse tillatelsene til sine behov, og hvordan utviklere kan gjenbruke sandkassen i egne verktøy. Til slutt ser vi på hvordan disse begrensningene håndheves på macOS, Linux og Windows.
Filosofien vår i Codex er å angi forsiktige standardinnstillinger for sandkassen som fortsatt gjør det mulig å utføre nyttig arbeid. Med et Git-lager som rot for arbeidsområdet gjør for eksempel den innebygde tillatelsesprofilen :workspace følgende:
Tillater skriving i arbeidsområdet, men gir bare lesetilgang til kataloger som
.gitog.codex. Dette lar Codex redigere kildekode uten å be om tillatelse for hver endring, samtidig som det hindrer direkte endringer i.codex/config.tomleller Git-hooks under.git/hooks.Tillater bred lesetilgang til filsystemet, innenfor brukerens eksisterende operativsystemtillatelser. Kompilatorer, kjøremiljøer og byggeverktøy er avhengige av SDK-er, biblioteker og konfigurasjon utenfor lageret. Hvis lesetilgangen ble begrenset til arbeidsområdet, ville mange vanlige arbeidsflyter slutte å fungere. Ulempen er at også sensitive filer andre steder på maskinen kan forbli lesbare, for eksempel konfigurasjonsfiler med API-nøkler.
Deaktiverer nettverkstilgang. Dette blokkerer direkte opplasting til eksterne tjenester, inkludert forsøk på å hente ut data som kommandoen kan lese. Det hindrer også legitime operasjoner som nedlasting av avhengigheter, som krever ekstra tilgang.
Disse begrensningene hindrer mange typer uønsket atferd, men skadelige handlinger er fortsatt mulige. Agenten kan for eksempel injisere skadelig kode i en lokalt installert pakke som node_modules/prettier. En slik endring vises kanskje ikke i git status, fordi node_modules ofte ignoreres av Git. Hvis brukerens editor kjører denne kopien av Prettier ved lagring, kan det å lagre en fil være nok til å kjøre den skadelige koden utenfor Codex-sandkassen. Derfor bruker vi dybdeforsvar: Sandkassen begrenser hva kommandoer har tilgang til, mens trening og tilpasning hjelper modellen med å bruke tilgangen i tråd med brukerens intensjon.
Se sikkerhetsveiledningen for Codex(åpnes i et nytt vindu) for råd om å tilpasse sandkassetillatelser og kombinere dem med andre beskyttelsestiltak i et bedriftsmiljø.
Virtuelle maskiner og containere(åpnes i et nytt vindu) er to populære mekanismer for sandkasseisolering, men vi har valgt en annen tilnærming for Codex-sandkassen. I stedet for å flytte beregningene til et separat miljø for å oppnå isolering, bruker Codex sandkassefunksjonene på hver plattform til å begrense kommandoer som kjører i brukerens eksisterende miljø.
For mange utviklere fungerer den bærbare datamaskinen som et skreddersydd utviklingsmiljø de kan endre når de vil. Det kan kreve en del arbeid å gjenskape miljøet i en Docker-container, og noen arbeidsflyter er fortsatt avhengige av verktøy som kjører på verten.
Tenk deg for eksempel at du bruker Codex til å utvikle en iOS-app på en Mac. Hvis du valgte å isolere Codex ved å kjøre det i Docker, ville Codex verken kunne kjøre iOS-byggeverktøykjeden, som består av kjørbare Mac-programmer, eller starte iPhone-simulatoren for å kjøre koden. En Docker-basert arbeidsflyt kunne delegere bygging og simulatoroperasjoner til Mac-verten, men disse operasjonene ville da kjøre utenfor containerens sandkasse og trenge egne begrensninger. For Codex foretrekker vi å holde det enkelt ved å satse tungt på operativsystemspesifikk sandkasseisolering. Dermed kan Codex kjøre i miljøet som passer best til oppgaven.
Rammeverket gjør disse operativsystemspesifikke sandkassemekanismene tilgjengelige gjennom et felles API for macOS, Windows og Linux. Dette API-et tar imot en kommando og en tillatelsesprofil. Hvis tillatelsesprofilen tillater begrenset nettverkstilgang, må den som kaller API-et, oppgi en nettverksproxy som håndhever begrensningene:
Denne funksjonen starter prosessen i en sandkasse og returnerer et Child-håndtak som rammeverket kan bruke til å vente på at prosessen avsluttes. Hver underprosess arver foreldreprosessens sandkassebegrensninger. Begrensningene gjelder dermed hele prosesstreet som kommandoen starter, også etterkommere som lever lenger enn den opprinnelige prosessen.
Diagrammet nedenfor viser hvordan delene henger sammen, fra konfigurasjon til kjøring av en kommando i sandkassen. De neste avsnittene forklarer hvert trinn.

Som forklart i En gjennomgang av agentløkken i Codex er Codex-rammeverket ansvarlig for å utføre verktøykall som modellen genererer. For kodeoppgaver er det mest brukte verktøyet et skallverktøy, som kjører kommandoer omtrent slik en bruker ville gjort i et interaktivt skall som Bash. Her ser vi på one-shot-verktøyet (åpnes i et nytt vindu)exec_command(åpnes i et nytt vindu) for skallkommandoer(åpnes i et nytt vindu) for å illustrere hvordan rammeverket bruker sandkassen til å oppnå ønsket beskyttelse.
Dette er en forenklet versjon av hvordan Codex-rammeverket ville håndtert verktøykallet exec_command uten sandkasseisolering:
For å kjøre kommandoen i en sandkasse erstatter rammeverket kallet til subprocess.Popen() med spawn_command_under_sandbox(). Rammeverket oppgir tillatelsesprofilen og, ved behov, nettverksproxyen:
Verktøyet exec_command lar også modellen be om andre tillatelser for en enkelt kommando, men rammeverket avgjør om forespørselen skal innvilges:
Når use_default er angitt, bruker rammeverket standardkonfigurasjonen for sandkassen i denne runden. with_additional_permissions ber om utvidet tilgang i sandkassen, mens require_escalated ber om kjøring utenfor den. Rammeverket vurderer forespørselen ut fra brukerens preferanser før kommandoen kjøres. (Codex kan for eksempel spørre brukeren direkte eller sende forespørselen til automatisk vurdering(åpnes i et nytt vindu).) Hvis kjøringen godkjennes, sender Codex riktig permission_profile og network_proxy til perform_exec_command_with_sandboxing() sammen med kommandoargumentene fra det opprinnelige ExecCommandToolCall.
Skallverktøyet er den viktigste brukeren av spawn_command_under_sandbox(). Rammeverket gjenbruker også sandkasseinfrastrukturen til operasjoner som lesing og endring av lokale filer. Gjenbruken strekker seg utover rammeverket: Kommandoen codex sandbox lar deg bygge inn kjøring av kommandoer i sandkasser i dine egne verktøy, som vi skal se senere. Nå skal vi se på hvordan tillatelsesprofiler defineres.
En navngitt tillatelsesprofil lar deg gjenbruke de samme filsystem- og nettverksbegrensningene på tvers av prosjekter. Du kan definere egne profiler under [permissions] i config.toml. Eksemplet nedenfor definerer en profil kalt dev som utvider(åpnes i et nytt vindu) den innebygde profilen :workspace:
Profilen dev legger til skrivetilgang til ~/build-cache og setter flere begrensninger på filer i arbeidsområdet. Filsystemoppføringer kan gi bare lesetilgang (read), gi lese- og skrivetilgang (write) eller blokkere all tilgang (deny).
Tabellen :workspace_roots lar deg definere regler for stier relativt til røttene i prosjektets arbeidsområde. Som standard bruker Codex CLI arbeidskatalogen som eneste rot for arbeidsområdet, mens ChatGPT‑skrivebordsappen bruker prosjektets kildemapper. Codex anvender hver regel på alle røttene. Dermed gir .vscode-oppføringen i dev bare lesetilgang til .vscode-katalogen under hver rot.
I tillegg til sine egne regler arver dev følgende beskyttelser fra :workspace:
Når du konfigurerer nettverket for sandkassen i Codex, har du i hovedsak tre alternativer:
Deaktiver all nettverkstilgang (standard for profilen
:workspace)Aktiver full, direkte nettverkstilgang (standard for profilen
:danger-full-access)Begrens nettverkstilgangen til en proxy som avgjør hva som slippes gjennom, basert på tillatelsesprofilen
For å gi dev direkte nettverkstilgang angir du permissions.dev.network.enabled = true på øverste nivå i config.toml. Dette gir full nettverkstilgang når nettverksproxyen er deaktivert.
For å begrense dev til et sett med domener aktiverer du nettverksproxyen og konfigurerer domenereglene:
Domeneregler støtter eksakte navn og jokertegnmønstre. Eksplisitte regler som nekter tilgang, går foran regler som tillater tilgang. Forespørsler til andre domener krever godkjenning eller blokkeres, som beskrevet under Nettverksproxy nedenfor.
Enkeltbrukere kan konfigurere standardinnstillinger som gjelder på tvers av prosjekter, og overstyre dem for et bestemt prosjekt de stoler på. Bedriftsadministratorer kan også ønske å konfigurere standardinnstillinger for brukerne sine og begrense hvilke innstillinger de kan endre. Codex støtter begge deler gjennom lagdelt konfigurasjon og administrerte krav.
Som beskrevet under Konfigurasjonsprioritet,(åpnes i et nytt vindu) slår Codex sammen innstillinger fra flere config.toml-filer. Tabeller slås sammen rekursivt. Ved motstridende verdier vinner kilden med høyest prioritet. Arrayer erstattes i sin helhet.
Derfor bruker tillatelsesprofiler tabeller for filsystemstier og nettverksdomener. Et team kan legge til eller overstyre enkeltoppføringer i sin egen konfigurasjon og automatisk arve endringer i alle andre oppføringer i organisasjonens grunnkonfigurasjon:
Administratorer kan også angi administrerte krav(åpnes i et nytt vindu) gjennom requirements.toml for å begrense brukernes konfigurasjonsvalg. Disse kravene kan komme fra flere kilder, inkludert systemfiler og policyer levert fra skyen. Et vanlig bruksområde er å angi allowed_permission_profiles for å begrense hvilke tillatelsesprofiler en bedriftsbruker kan velge. En administrator kan for eksempel angi disse skykravene:
Skykravene vil ha forrang fremfor systemkravfilen på /etc/codex/requirements.toml, så en oppføring i den filen kan ikke overstyre den eksplisitte innstillingen ":danger-full-access" = false ovenfor. Når :workspace ikke angis, kan et annet kravlag levere denne oppføringen. Profiler med oppføringer som er false eller mangler i den endelige sammenslåtte tabellen, er ikke tilgjengelige.
Dette skillet lar organisasjoner håndheve grenser mens brukerne tilpasser konfigurasjonen innenfor disse grensene. De resulterende tillatelsesprofilene kan brukes av rammeverket eller anvendes direkte på en kommando, som vi skal se nå.
Codex CLI har en sandbox-kommando som gjør det enkelt å kjøre en vilkårlig kommando med en tillatelsesprofil definert i Codex-konfigurasjonen. Den brukes ofte til å teste profilen og kontrollere at sandkassen hindrer atferden den er laget for å blokkere.
Kommandoen nedenfor forsøker for eksempel å konfigurere VS Code til å kjøre et skadelig automatisk formateringsverktøy ved lagring. Forutsatt at .vscode allerede finnes, skal dev-profilen definert ovenfor blokkere denne skriveoperasjonen fordi katalogen bare har lesetilgang (codex sandbox behandler som standard cwd som en rot for arbeidsområdet):
På macOS mislykkes dette som forventet med:
Kommandoen codex sandbox gjør Codex sin sandkassemekanisme tilgjengelig uavhengig av en agentøkt. Du kan bruke det samme konfigurasjonsspråket og den plattformspesifikke håndhevingen til å begrense kommandoer som startes av dine egne verktøy.
For en stdio-basert MCP-server konfigurert i config.toml forsøker ikke Codex-rammeverket å kjøre kommandoen som starter serveren, i en sandkasse. Codex kan ikke pålitelig utlede hvilke filer eller nettverkstjenester serveren trenger. En standard sandkasseprofil kan derfor få en ellers gyldig konfigurasjon til å slutte å fungere.
Standardmåten å konfigurere MCP-serveren @modelcontextprotocol/server-memory(åpnes i et nytt vindu) for bruk med Codex på er for eksempel slik:
Siden denne npx-kommandoen kjører uten sandkasse, kan den skrive filer og sende nettverksforespørsler med samme tillatelser som brukeren som kjører Codex. Det gir for vid tilgang. For å stramme inn tilgangen kan vi definere en tillatelsesprofil kalt memory-mcp og deretter kjøre den opprinnelige npx-kommandoen via codex sandbox --permission-profile memory-mcp. Dette begrenser hvor serveren kan skrive, og hindrer nettverkstilgang:
Før du starter serveren, oppretter du datakatalogen og legger den fastsatte pakkeversjonen i npm-hurtigbufferen. Da kan npx --offline starte serveren med en profil som deaktiverer nettverkstilgang:
Når pakken er lagret i hurtigbufferen, kan Codex starte minneserveren uten nettverkstilgang, med skrivetilgang begrenset til npm-hurtigbufferen og serverens datakatalog.
Sandkasseimplementasjonen gjør en tillatelsesprofil om til begrensninger som håndheves av operativsystemet. Nettverksproxyens kjernelogikk for forespørselshåndtering og policy er felles for alle de tre store operativsystemene, mens proxyoppsettet og integrasjonen med sandkassen er operativsystemspesifikke. Vi ser først på den felles proxyen, og deretter på implementasjonene for macOS, Linux og Windows.
For å håndheve nettverksbegrensningene i en tillatelsesprofil starter rammeverket en nettverksproxy og konfigurerer sandkassen til å tillate tilkoblinger til den, mens direkte tilkoblinger til eksterne verter blokkeres. Proxyen kontrollerer hver forespørsel mot profilens domeneregler for å avgjøre om den skal videresendes.
I Codex-lageret er nettverksproxyen implementert i craten codex-network-proxy(åpnes i et nytt vindu), som rammeverket bruker som et bibliotek. Den kan også bygges som et frittstående kommandolinjeverktøy(åpnes i et nytt vindu). Når codex-network-proxy er aktivert, starter den som standard både en HTTP-proxy og en SOCKS5-proxy. Disse proxyadressene sendes via miljøvariabler til prosessen som startes av sandkassen. I tillegg til standardmiljøvariabler som HTTP_PROXY, HTTPS_PROXY og ALL_PROXY legges det også inn en rekke kjente applikasjonsspesifikke miljøvariabler(åpnes i et nytt vindu), som PIP_PROXY. Det er riktignok ikke alle programmer som tar hensyn til disse miljøvariablene. Hvis et program forsøker en direkte tilkobling til en ekstern vert, blokkeres den av operativsystemets sandkassebegrensninger, som beskrevet i de plattformspesifikke avsnittene nedenfor.
Nettverksproxyen har ansvaret for å håndheve nettverksbegrensningene som er definert i en tillatelsesprofil. Profilen dev som ble vist tidligere, tillater for eksempel forespørsler til *.openai.com og nekter eksplisitt forespørsler til evil.example. Når en forespørsel gjelder et domene som verken samsvarer med en tillatelsesregel eller en nektelsesregel, kan proxyen sette forespørselen på vent mens den ber rammeverket om godkjenning. Som i eksemplet med skallkommandoen kan Codex spørre brukeren direkte eller sende forespørselen til automatisk vurdering(åpnes i et nytt vindu). Når avgjørelsen foreligger, lar proxyen enten forespørselen fortsette eller avviser den med et feilsvar.
Rekkefølgen er viktig her, fordi selv et DNS-oppslag kan lekke informasjon som er kodet inn i et vertsnavn. Proxyen slår derfor ikke opp det forespurte vertsnavnet før den har fastslått at det er tillatt eller godkjent. Merk at brede jokertegnregler eller tilgang til DNS-tjenester fortsatt kan muliggjøre DNS-basert dataeksfiltrering.
På macOS bruker Codex Seatbelt(åpnes i et nytt vindu), Apples sandkassemekanisme som håndheves av kjernen. Seatbelt-policyer skrives i Sandbox Profile Language (SBPL), et Scheme-basert språk for å uttrykke sandkassebegrensninger. Codex kaller Seatbelt gjennom macOS-kommandoen /usr/bin/sandbox-exec. I likhet med codex sandbox tar den imot alternativer som beskriver sandkassen, etterfulgt av kommandoen som skal kjøres:
PROFILE er en SBPL-streng med oppføringer som konfigurerer sandkassen. Følgende SBPL-kodebit gir for eksempel lese- og skrivetilgang til /dev/null og /dev/zero i sandkassepolicyen:
Når nettverksproxyen aktiveres som del av en sandkassekjøring, legges regler som de følgende inn i profilen for å begrense tilkoblinger til de riktige lokale portene:
Codex sin grunnprofil starter med (deny default), så utgående tilkoblinger forblir blokkert med mindre de eksplisitt tillates.
Til slutt kan SBPL inneholde plassholdere som bruker (param):
Disse fylles ut av alternativene -Dkey=value som sendes til sandbox-exec.
For å implementere sitt eget sandkasse-API bygger Codex opp argumentlisten(åpnes i et nytt vindu) til sandbox-exec med utgangspunkt i en grunnpolicy(åpnes i et nytt vindu). Deretter brukes permission_profile og annen kontekst til å tilpasse den og lage den fullstendige Seatbelt-profilen. Den resulterende profilen og de tilhørende -D-argumentene konfigurerer begrensningene som Seatbelt håndhever, mens nettverksproxyen håndhever ytterligere nettverksregler. Når hele argumentlisten er satt sammen, er selve kallet til sandbox-exec enkelt.
Det er utfordrende å generere korrekt SBPL fordi Apple ikke dokumenterer språket for tredjepartsbruk. Faktisk sier man sandbox-exec at The sandbox-exec command is DEPRECATED (det samme gjelder bibliotekfunksjonen sandbox_init(), som er dokumentert via man 3 sandbox_init). Til tross for advarselen om utfasing leveres macOS fortsatt med Seatbelt-profiler i /usr/share/sandbox, og tredjepartsprogramvare, inkludert Google Chrome og Chromium(åpnes i et nytt vindu), bruker fortsatt Seatbelt. Derfor planlegger vi å fortsette å bruke Seatbelt i overskuelig fremtid.
For å opprette sandkassen på Linux bruker Codex en kombinasjon av bubblewrap(åpnes i et nytt vindu) (bwrap), et kommandolinjeverktøy for å bygge isolerte miljøer, og seccomp-bpf(åpnes i et nytt vindu), en mekanisme i Linux-kjernen for å filtrere systemkall. Et internt hjelpeprogram kalt codex-linux-sandbox koordinerer oppsettet. I likhet med sandbox-exec på macOS tar det imot en sandkassekonfigurasjon etterfulgt av en kommando som skal kjøres:
Når filsystemisolering eller proxyruting er nødvendig, kaller codex-linux-sandbox opp bwrap for å opprette det innledende sandkassemiljøet. Deretter starter bwrap opp codex-linux-sandbox --apply-seccomp-then-exec inne i miljøet. Dette andre kallet bruker seccomp-bpf til å legge på flere begrensninger før brukerens kommando kjøres.
For å bygge det innledende sandkassemiljøet bruker Codex bubblewrap til å opprette en filsystemvisning i et separat monteringsnavnerom som gjenspeiler tillatelsesprofilens filsystemregler. Siden dette er grunnleggende for sandkasseimplementasjonen, leveres Codex med en egen kopi av bwrap i tilfelle brukeren ikke har installert den selv. Codex foretrekker likevel en kompatibel installasjon av (åpnes i et nytt vindu)bwrap(åpnes i et nytt vindu) i PATH, når den finnes. Erfaring viser at noen Linux-distribusjoner deaktiverer tilgang til brukernavnerom som standard(åpnes i et nytt vindu), men gjør et unntak for systemets bwrap.
I likhet med sandbox-exec tar også bwrap imot en sandkassekonfigurasjon etterfulgt av en kommando som skal kjøres i sandkassen. I stedet for et eget konfigurasjonsspråk som SBPL bruker bwrap individuelle flagg til konfigurering. Codex bruker følgende alternativer for å opprette filsystemvisningen:
--bindfor å angi en fil eller katalog med skrivetilgang--ro-bindfor å angi en fil eller katalog med bare lesetilgang--perms 000 --tmpfs DIR --remount-ro DIRfor å nekte tilgang tilDIR--perms 000 --ro-bind-data FD FILEfor å nekte tilgang tilFILE(derFDer en åpen fildeskriptor til/dev/null)
For å bruke glob-mønstre for nektet tilgang med disse alternativene utvider Codex dem til konkrete stier før hver kommando startes. Nye stier som samsvarer med mønstrene, legges ikke automatisk til i sandkassebegrensningene for kommandoen.
Codex angir også alternativer som --unshare-ipc og --unshare-pid for å hindre sandkassen i å få tilgang til andre typer ressurser på verten. Bubblewrap påvirker dermed mer enn bare hvilke filer som er synlige.
Når Codex bruker bubblewrap, sendes --unshare-net med hver gang nettverkstilgang er deaktivert eller tilkoblinger må gå gjennom nettverksproxyen. Dette oppretter et nytt nettverksnavnerom for sandkassen. Deretter bruker vi seccomp-bpf til å legge flere begrensninger på hvilke nettverkssystemkall og socket-familier kommandoen har tilgang til.
Nærmere bestemt bruker vi seccompiler-craten(åpnes i et nytt vindu) til å kompilere et BPF-program dynamisk basert på de ønskede filtrene(åpnes i et nytt vindu) og anvende det på en oppstartsprosess i sandkassen, slik at begrensningene arves av hele prosesstreet. Dermed kjører ikke bwrap brukerens kommando direkte, men starter oppstartsprogrammet codex-linux-sandbox med dets egne konfigurasjonsargumenter etterfulgt av brukerens kommando:
For å bruke seccomp-filtre uten utvidede rettigheter setter oppstartsprogrammet flagget no_new_privs i Linux(åpnes i et nytt vindu). Dette flagget arves av underprosesser og hindrer dem i å få utvidede rettigheter når de kjører et annet program, for eksempel et kjørbart program med setuid.
Seccomp-filtrene avhenger av nettverkskonfigurasjonen. Når nettverkstilgang er deaktivert, blokkerer vi en rekke nettverksrelaterte systemkall, som connect(2) og bind(2). Når nettverksproxyen er aktivert i sandkassen, tillater vi derimot IP-sockets slik at TCP-lytteren som opprettes av codex-linux-sandbox, kan nås. Oppretting av frittstående Unix-domene-sockets blokkeres som standard, siden de kan gi utilsiktet tilgang til ressurser på verten.
Når sandkassekonfigurasjonen krever en nettverksproxy, oppretter Codex-rammeverket én proxyinstans som kan gjenbrukes på tvers av flere kall til codex-linux-sandbox i samme Codex-tråd. Hver sandkasse trenger en måte å nå denne delte proxyen på fra sitt isolerte nettverksnavnerom. Codex oppretter en TCP-lytter på loopback-grensesnittet i navnerommet og sørger for at en prosess utenfor sandkassen godtar tilkoblingene og videresender dem til proxyen.
Diagrammene nedenfor viser dette oppsettet for ett proxyendepunkt. Det siste diagrammet viser én tilkobling gjennom det. Før bubblewrap startes, oppretter codex-linux-sandbox et par Unix-sockets som kontrollkanal og forgrener deretter seg selv. Underprosessen kjører run_host_bridge() og venter på å motta lytterens fildeskriptor via denne kanalen:
I dette eksemplet bruker foreldreprosessen exec til å erstatte programbildet sitt med bwrap. Dette setter opp sandkassen og starter codex-linux-sandbox --apply-seccomp-then-exec inne i den, med fildeskriptoren for kontrollkanalen sendt videre:
Inne i sandkassens nettverksnavnerom oppretter den andre kjøringen av codex-linux-sandbox en TCP-lytter på loopback-grensesnittet og sender fildeskriptoren via socketen. Lytteren forblir knyttet til sandkassens nettverksnavnerom. Dermed kan underprosessen som ble værende utenfor sandkassen, godta tilkoblinger fra programmer i sandkassen, samtidig som den åpner tilkoblinger videre i vertens nettverksnavnerom. Etter overføringen lukker begge prosessene sine deskriptorer for kontrollkanalen, og prosessen inne i sandkassen lukker sin kopi av lytteren.
Når TCP-lytteren er klar, setter prosessen i sandkassen riktig verdi for HTTP_PROXY(åpnes i et nytt vindu) og relaterte miljøvariabler, slik at de peker på lytteren. Deretter aktiverer den seccomp før den forgrener seg og kjører brukerens kommando:
Prosessen utenfor sandkassen holder lytteren åpen. For hver tilkobling som godtas, åpner den en tilkobling til den konfigurerte proxyen og videresender data i begge retninger.
Disse tilleggsmekanismene gir kommandoen et eget nettverksnavnerom, inkludert et separat loopback-grensesnitt. På macOS lar Seatbelt kommandoen koble seg direkte til angitte porter på vertens loopback-grensesnitt. På Linux kobler kommandoen seg i stedet til en lytter i sitt isolerte navnerom, og en prosess utenfor sandkassen videresender disse tilkoblingene til den konfigurerte proxyen. Overføringen av deskriptoren gjør denne tilkoblingen mulig uten å eksponere vertens nettverksnavnerom for kommandoen.
Tidligere i år implementerte vi sandkassestøtte på Windows og skrev om arbeidet med dette. Siden da har Microsoft lansert et bibliotek kalt MXC sammen med nye funksjoner for prosessisolering i Windows-operativsystemet. Vi er nå i ferd med å erstatte den eksisterende sandkassen med en som bruker MXC-biblioteket.
MXC (Microsoft eXecution Container) er et system for kjøring av kode i sandkasser(åpnes i et nytt vindu) fra Microsoft som støtter flere isoleringsmekanismer på Windows, Linux og macOS. Codex støtter en MXC-basert sandkasse på kompatible Windows-enheter og bruker operativsystemets innebygde prosessisolering til å begrense kommandoer i brukerens eksisterende miljø.
Vi går over til MXC for å forbedre sikkerheten og brukervennligheten, samtidig som vi løser flere begrensninger i den eksisterende Windows-sandkassen:
Behov for utvidede rettigheter eller administratortilgang for å sette opp sandkassen
Ressurskrevende og trege operasjoner for å kontrollere og angi ACL-er
Vedvarende oppsettstilstand for sandkassen på vertsmaskinen, inkludert
ACL-er
Brannmurregler
Sandkassebrukere
Kontrollplanfiler
MXC tilbyr et JSON-konfigurasjonsskjema(åpnes i et nytt vindu). Codex bruker MXC SDK(åpnes i et nytt vindu) til å bygge en kjøreforespørsel som følger skjemaet og inneholder kommandoen, arbeidskatalogen, miljøet og tillatelsene. Disse tillatelsene dekker tilgang til filsystem og nettverk, samt Windows-ressurser som skrivebordet og utklippstavlen.
Codex bruker faste innstillinger for flere kontrollmekanismer for å balansere kompatibilitet og sikkerhet. Det tillater lesing fra registeret og beholder tilgangen til Win32k og skrivebordet som PowerShell trenger under oppstart. Tilgang til utklippstavlen, inndatainjisering og kontroll over skrivebords- og systeminnstillinger er deaktivert. Til slutt hindres MXC i å ty til endringer i vertens filsystemtillatelser som reserveløsning.
Codex omsetter tillatelsesprofilens filsystem- og nettverksregler til MXC-konfigurasjon. Vi bruker dev-profilen fra tidligere og forutsetter at:
C:\,D:\ogZ:\er maskinens eneste lokale stasjoner.Roten til arbeidsområdet og arbeidskatalogen er
C:\work\demo.Brukerens hjemmekatalog er
D:\Users\dev, så~/build-cachepeker påD:\Users\dev\build-cache.Glob-mønsteret for nektet tilgang samsvarer bare med
C:\work\demo\config\dev.envogC:\work\demo\config\prod.env.
De tilsvarende MXC-innstillingene vil da inkludere:
MXCs filsystempolicy nekter tilgang som standard. Codex legger derfor til lesetillatelser for de lokale stasjonsrøttene for å gi den brede lesetilgangen som denne profilen tillater. Disse tillatelsene gjelder rekursivt, innenfor brukerens eksisterende operativsystemtillatelser.
Én særegenhet: skrivetillatelser for stasjonsrøtter gjelder ikke rekursivt, så Codex utvider dem til å omfatte eksisterende filer og kataloger direkte under stasjonsroten.
Mer spesifikke stier overstyrer tillatelser for overordnede kataloger. Dermed kan C:\work\demo ha skrivetilgang selv om C:\ bare har lesetilgang, mens C:\work\demo\.git fortsatt bare har lesetilgang.
Når ulike skrivemåter eller aliaser via symbolske lenker eller junctions viser til samme sti, bruker MXC den strengeste tillatelsen: nektet tilgang går foran lesetilgang, som går foran lese- og skrivetilgang.
MXC tar bare imot konkrete stier for nektet tilgang, så Codex utvider glob-mønstrene til samsvarende filer og kataloger før oppstart. Nye stier som samsvarer med glob-mønsteret, legges ikke automatisk til mens kommandoen kjører.
Domeneregler som *.openai.com håndheves av den delte Codex-nettverksproxyen som er beskrevet tidligere. Codex kjører proxyen utenfor sandkassen og sender adressene til kommandoen gjennom de samme standardmiljøvariablene av typen *_PROXY som er nevnt tidligere. MXC blokkerer direkte eksterne tilkoblinger, men tillater tilkoblinger til vertens loopback-grensesnitt, inkludert tilgang til proxyen. Andre lokale tjenester er fortsatt tilgjengelige.
På macOS, Linux og Windows bruker rammeverket det samme sandkasse-API-et til å starte kommandoer med en tillatelsesprofil. De plattformspesifikke implementasjonene håndterer oppsettet som trengs for å håndheve begrensningene.
Å skrive og kjøre kode gir agenter en fleksibel måte å løse problemer på, også utenfor programvareutvikling. Codex-sandkassen lar dem bruke denne evnen i brukerens eksisterende miljø, med eksplisitte grenser for filsystem- og nettverkstilgang. Den er en gjenbrukbar byggekloss i rammeverket, og kommandoen codex sandbox gjør den tilgjengelig for verktøy du bygger selv.
Etter hvert som agenter tar på seg flere oppgaver, vil vi gjøre sandkasseisolering praktisk å bruke for flere verktøy og miljøer. Det innebærer å gjøre tillatelser enklere å konfigurere og ta i bruk bedre beskyttelsesmekanismer i operativsystemene etter hvert som de blir tilgjengelige. Målet vårt er å utvide hva agenter kan gjøre, samtidig som mennesker beholder kontrollen over hva agentene har tilgang til.


