OpenAI

18. november 2026

Teknisk arbeid

Innsiden av Codex-sandkassen

Slik kjører Codex kommandoer på maskinen din med grenser du kontrollerer.

Av Michael Bolin, medlem av det tekniske teamet

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.

Valg av grenser for sandkassen

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 .git og .codex. Dette lar Codex redigere kildekode uten å be om tillatelse for hver endring, samtidig som det hindrer direkte endringer i .codex/config.toml eller 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ø.

Utforming av sandkassen

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:

Python

1
# This is a simplified version of the actual API.
2
def spawn_command_under_sandbox(
3
program_and_args: list[str],
4
cwd: Path,
5
env: dict[str, str],
6
permission_profile: PermissionProfile,
7
network_proxy: NetworkProxy | None,
8
) -> Child:

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.

Flytdiagram: Konfigurasjon og administrerte krav definerer en tillatelsesprofil for økten. Codex-rammeverket starter kommandoer med plattformspesifikke sandkassebegrensninger på macOS, Linux eller Windows. Underprosesser arver disse begrensningene, og en valgfri nettverksproxy håndhever domeneregler.

Slik bruker rammeverket sandkassen

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:

Python

1
# Illustrative implementation of the exec_command tool call.
2

3
class ExecCommandToolCall:
4
cmd: str
5
workdir: str | None = None
6
shell: str | None = None
7
login: bool = True
8
timeout_ms: int = 10_000
9

10

11
def perform_exec_command(tool_call: ExecCommandToolCall):
12
program_and_args = [
13
tool_call.shell or os.environ.get("SHELL") or "/bin/sh",
14
"-lc" if tool_call.login else "-c",
15
tool_call.cmd,
16
]
17
child = subprocess.Popen(
18
program_and_args,
19
# workdir defaults to the turn's cwd, assumed here to be the process cwd.
20
cwd=Path(tool_call.workdir or ".").absolute(),
21
stdout=subprocess.PIPE,
22
stderr=subprocess.STDOUT,
23
)
24
output, exit_code = collect_output(child, timeout_ms=tool_call.timeout_ms)
25
return {"output": output, "exit_code": exit_code}

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:

Python

1
# Honoring the exec_command tool call while enforcing sandbox constraints.
2

3
def perform_exec_command_with_sandboxing(
4
tool_call: ExecCommandToolCall,
5
permission_profile: PermissionProfile,
6
network_proxy: NetworkProxy | None,
7
):
8
# ...build program_and_args as in the previous example...
9
child = spawn_command_under_sandbox(
10
program_and_args=program_and_args,
11
cwd=Path(tool_call.workdir or ".").absolute(),
12
env=os.environ.copy(),
13
permission_profile=permission_profile,
14
network_proxy=network_proxy,
15
)
16
output, exit_code = collect_output(child, timeout_ms=tool_call.timeout_ms)
17
return {"output": output, "exit_code": exit_code}

Verktøyet exec_command lar også modellen be om andre tillatelser for en enkelt kommando, men rammeverket avgjør om forespørselen skal innvilges:

Python

1
class ExecCommandToolCall:
2
# ...command-related fields...
3

4
# Per-command sandbox override. Defaults to "use_default".
5
sandbox_permissions: Literal[
6
"use_default",
7
"with_additional_permissions",
8
"require_escalated",
9
] = "use_default"
10

11
# User-facing approval question; only for "require_escalated".
12
justification: str | None = None
13

14
# Expand network or filesystem access; only for "with_additional_permissions".
15
# AdditionalPermissions supports fine-grained options.
16
additional_permissions: AdditionalPermissions | None = None

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.

Konfigurere sandkassen

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:

TOML

1
# Use the dev profile by default.
2
default_permissions = "dev"
3

4
[permissions.dev]
5
# This is displayed when /permissions is run in the Codex CLI.
6
description = "Development with extra read-only protections."
7

8
# A profile can be derived from an existing profile.
9
# Profiles starting with ":" are provided by Codex.
10
extends = ":workspace"
11

12
[permissions.dev.filesystem]
13
"~/build-cache" = "write"
14

15
[permissions.dev.filesystem.":workspace_roots"]
16
".devcontainer" = "read"
17
".vscode" = "read"
18
"**/*.env" = "deny"
19
"secrets" = "deny"

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:

TOML

1
[permissions.":workspace".filesystem.":workspace_roots"]
2
".agents" = "read"
3
".aws" = "read"
4
".codex" = "read"
5
".git" = "read"

Nettverkstillatelser

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:

TOML

1
[permissions.dev.network]
2
enabled = true
3

4
[permissions.dev.network.domains]
5
"*.openai.com" = "allow"
6
# Allow requests to local services by hostname or by IPv4/IPv6 loopback address.
7
"localhost" = "allow"
8
"127.0.0.1" = "allow"
9
"::1" = "allow"
10
"evil.example" = "deny"
11

12
[features]
13
# If neither local config nor managed requirements enable the proxy,
14
# this profile allows direct network access; domain rules are not enforced.
15
network_proxy = true

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.

Konfigurasjonslag og håndheving av grenser

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:

TOML

1
[permissions.dev.filesystem.":workspace_roots"]
2
".idea" = "read"
3

4
[permissions.dev.network.domains]
5
"example.com" = "allow"

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:

TOML

1
default_permissions = ":read-only"
2

3
[allowed_permission_profiles]
4
":read-only" = true
5
":danger-full-access" = false

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å.

Bruk av kommandoen codex sandbox

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):

Bash

1
codex sandbox --permission-profile dev -- \
2
bash -c 'cat > .vscode/settings.json' <<'JSON'
3
{
4
"prettier.prettierPath": "./node_modules/evil-prettier",
5
"[typescript]": {
6
"editor.defaultFormatter": "esbenp.prettier-vscode",
7
"editor.formatOnSave": true
8
}
9
}
10
JSON

På macOS mislykkes dette som forventet med:

Ren tekst

1
bash: .vscode/settings.json: Operation not permitted

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.

Eksempel: kjøre en MCP-server i en sandkasse

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:

TOML

1
[mcp_servers.memory]
2
command = "npx"
3
args = [
4
"-y",
5
"@modelcontextprotocol/server-memory@1.0.0"
6
]
7

8
[mcp_servers.memory.env]
9
MEMORY_FILE_PATH = "~/mcp-data/memory.jsonl"

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:

TOML

1
[permissions.memory-mcp.filesystem]
2
# Allow broad reads for Node.js/npm dependencies and configuration.
3
":root" = "read"
4
"~/.npm" = "write"
5
"~/mcp-data" = "write"
6

7
[permissions.memory-mcp.network]
8
enabled = false
9

10
[mcp_servers.memory]
11
command = "codex"
12
args = [
13
"sandbox",
14
"--permission-profile",
15
"memory-mcp",
16
"--",
17
"npx",
18
"--offline",
19
"@modelcontextprotocol/server-memory@1.0.0"
20
]
21

22
[mcp_servers.memory.env]
23
MEMORY_FILE_PATH = "~/mcp-data/memory.jsonl"

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:

Bash

1
# The sandbox can write to this folder, but it cannot create it.
2
mkdir -p ~/mcp-data
3

4
# Installing the MCP server requires network access.
5
npx -y --package=@modelcontextprotocol/server-memory@1.0.0 -c true

Når pakken er lagret i hurtigbufferen, kan Codex starte minneserveren uten nettverkstilgang, med skrivetilgang begrenset til npm-hurtigbufferen og serverens datakatalog.

Implementasjonen av Codex-sandkassen

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.

Nettverksproxy

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.

macOS

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:

Bash

1
sandbox-exec -p PROFILE [-Dkey=value]* -- PROG ARGS...

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:

Scheme

1
(allow file-read* file-test-existence file-write-data
2
(literal "/dev/null")
3
(literal "/dev/zero"))

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:

Scheme

1
; local HTTP proxy launched by Codex
2
(allow network-outbound (remote ip "localhost:3128"))
3

4
; local SOCKS proxy launched by Codex
5
(allow network-outbound (remote ip "localhost:8081"))


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):

Scheme

1
; Pass -DWRITABLE_ROOT_0=/path/to/dir to specify a folder that cannot be removed.
2
(deny file-write-unlink
3
(require-all
4
(literal (param "WRITABLE_ROOT_0"))
5
(vnode-type DIRECTORY)))

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.

Linux

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:

Bash

1
codex-linux-sandbox SANDBOX_ARGS... -- PROG ARGS...

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:

  • --bind for å angi en fil eller katalog med skrivetilgang

  • --ro-bind for å angi en fil eller katalog med bare lesetilgang

  • --perms 000 --tmpfs DIR --remount-ro DIR for å nekte tilgang til DIR

  • --perms 000 --ro-bind-data FD FILE for å nekte tilgang til FILE (der FD er 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:

Bash

1
bwrap BWRAP_ARGS... -- \
2
codex-linux-sandbox --apply-seccomp-then-exec CODEX_LINUX_SANDBOX_ARGS... -- \
3
PROG ARGS...

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.

Tilkobling til nettverksproxyen

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:

Diagram av Codex-rammeverket som starter codex-linux-sandbox, som forgrener seg til en videresendingsprosess koblet til via en kontrollkanal med Unix-sockets.

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:

Diagram som viser at bwrap oppretter et nettverksnavnerom for sandkassen og starter codex-linux-sandbox inne i det, med en Unix-socket-basert kontrollkanal til videresendingsprosessen utenfor sandkassen.

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:

Diagram som viser et program i en sandkasse som kobler seg til en TCP-lytter på loopback-grensesnittet, mens en ekstern codex-linux-sandbox-prosess videresender trafikken til Codex-nettverksproxyen.

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.

Windows

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.

Hva er MXC?

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.

Fra policy til MXC-kall

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:\ og Z:\ er maskinens eneste lokale stasjoner.

  • Roten til arbeidsområdet og arbeidskatalogen er C:\work\demo.

  • Brukerens hjemmekatalog er D:\Users\dev, så ~/build-cache peker på D:\Users\dev\build-cache.

  • Glob-mønsteret for nektet tilgang samsvarer bare med C:\work\demo\config\dev.env og C:\work\demo\config\prod.env.

De tilsvarende MXC-innstillingene vil da inkludere:

JSON

1
{
2
...
3
"filesystem": {
4
"readwritePaths": [
5
"C:\\work\\demo",
6
"D:\\Users\\dev\\build-cache",
7
...
8
],
9
"readonlyPaths": [
10
"C:\\",
11
"D:\\",
12
"Z:\\",
13
"C:\\work\\demo\\.agents",
14
"C:\\work\\demo\\.aws",
15
"C:\\work\\demo\\.codex",
16
"C:\\work\\demo\\.devcontainer",
17
"C:\\work\\demo\\.git",
18
"C:\\work\\demo\\.vscode",
19
...
20
],
21
"deniedPaths": [
22
"C:\\work\\demo\\config\\dev.env",
23
"C:\\work\\demo\\config\\prod.env",
24
"C:\\work\\demo\\secrets"
25
]
26
},
27
"network": {
28
"egress": {
29
"default": "deny",
30
"allow": [{
31
"to": [
32
{"cidr": "127.0.0.0/8"},
33
{"cidr": "::1/128"}
34
]
35
}]
36
},
37
"ingress": {
38
"default": "deny",
39
"hostLoopback": "allow"
40
}
41
},
42
...
43
}

Tilgang til stasjonsrøtter

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.

Motstridende tillatelser

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.

Glob-mønstre for nektet tilgang

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.

Nettverkstilgang

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.

Bygge videre på Codex-sandkassen

Å 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.

Forfatter

OpenAI

Takk til bidragsyterne

En spesiell takk til David Wiesen, Charlie Weems, Viyat Bhalodia og Fotis Chantzis for bidragene til dette innlegget.