OpenAI

18. november 2026

Ingeniørarbejde

Indblik i Codex-sandboxen

Sådan kører Codex kommandoer på din maskine med grænser, du bestemmer.

Af Michael Bolin, teknisk medarbejder

Hos OpenAI bruger vi forsvar i dybden⁠(åbner i et nyt vindue) til at sikre agenter. Vores investeringer i træning og alignment er grundlæggende for denne indsats, men vi implementerer også funktioner i vores agentiske harness, Codex⁠(åbner i et nyt vindue), som giver yderligere beskyttelse. En af de mest almindelige – og potentielt risikable – ting, Codex gør, er at køre kommandoer på din computer. Derfor har vi bygget Codex-sandboxen, så Codex kan arbejde i dit eksisterende miljø inden for de grænser for filsystem og netværk, du bestemmer.

En ⁠(åbner i et nyt vindue)sandbox⁠(åbner i et nyt vindue) begrænser, hvad et program har adgang til, mens det kører. Til en opgave med at organisere billeder kan du konfigurere Codex-sandboxen, så kommandoer må læse og ændre filer i ~/Pictures, mens netværksadgang blokeres for at forhindre uploads. Til kodegennemgang kan du tillade adgang til onlinedokumentation og samtidig kun give læseadgang til kildefiler. Brugere konfigurerer Codex-sandboxen via ⁠(åbner i et nyt vindue)tilladelsesprofiler⁠(åbner i et nyt vindue), som definerer filsystem- og netværksbegrænsningerne for en Codex-session.

I denne artikel begynder vi med afvejningerne bag Codex-sandboxens standardindstillinger. Derefter forklarer vi sandboxens design, og hvordan harnesset bruger den til at køre kommandoer. Vi viser, hvordan slutbrugere og virksomheder kan tilpasse tilladelserne til deres behov, og hvordan udviklere kan genbruge sandboxen i deres egne værktøjer. Til sidst ser vi på, hvordan disse begrænsninger håndhæves på macOS, Linux og Windows.

Valg af sandboxens grænser

Vores filosofi i Codex er at vælge restriktive standardindstillinger for sandboxen, som stadig gør det muligt at udføre meningsfuldt arbejde. Med et Git-lager som arbejdsområdets rod gør den indbyggede tilladelsesprofil :workspace for eksempel følgende:

  • Tillader skrivning i arbejdsområdet, men giver kun læseadgang til mapper som .git og .codex. Det lader Codex redigere kildekode uden at bede om tilladelse til hver ændring, men forhindrer direkte ændringer af .codex/config.toml eller Git-hooks under .git/hooks.

  • Tillader bred læseadgang til filsystemet inden for brugerens eksisterende rettigheder i operativsystemet. Compilere, runtimes og buildværktøjer er afhængige af SDK'er, biblioteker og konfiguration uden for lageret. Hvis læseadgangen var begrænset til arbejdsområdet, ville mange almindelige arbejdsgange ikke fungere. Ulempen er, at følsomme filer andre steder på maskinen også kan forblive læsbare, for eksempel konfigurationsfiler med API-nøgler.

  • Deaktiverer netværksadgang. Det blokerer direkte uploads til eksterne tjenester, herunder forsøg på at eksfiltrere data, som kommandoen kan læse. Det forhindrer også legitime handlinger såsom at downloade afhængigheder, hvilket kræver yderligere adgang.

Disse begrænsninger forhindrer mange former for uønsket adfærd, men skadelige handlinger er stadig mulige. For eksempel kan agenten injicere skadelig kode i en lokalt installeret pakke som node_modules/prettier. En sådan ændring vises muligvis ikke i git status, fordi Git ofte ignorerer node_modules. Hvis brugerens editor kører denne kopi af Prettier, når en fil gemmes, kan det at gemme en fil alene udføre den skadelige kode uden for Codex-sandboxen. Derfor bruger vi forsvar i dybden: Sandboxen begrænser, hvad kommandoer har adgang til, mens træning og alignment hjælper modellen med at bruge denne adgang i overensstemmelse med brugerens hensigt.

Du kan finde vejledning i at tilpasse sandboxtilladelser og kombinere dem med andre beskyttelser i et virksomhedsmiljø i Codex-sikkerhedshåndbogen⁠(åbner i et nyt vindue).

Sandboxens design

Virtuelle maskiner og containere⁠(åbner i et nyt vindue) er to udbredte mekanismer til sandboxing, men med Codex-sandboxen vælger vi en anden tilgang. I stedet for at flytte beregninger til et separat miljø for at skabe isolation bruger Codex hver platforms sandboxfunktioner til at begrænse kommandoer, som kører i brugerens eksisterende miljø.

For mange udviklere fungerer deres bærbare computer som et skræddersyet udviklingsmiljø, som de frit kan ændre. Det kan kræve arbejde at genskabe dette miljø i en Docker-container, og nogle arbejdsgange er stadig afhængige af værktøjer, der kører på værten.

Forestil dig for eksempel, at du bruger Codex til at udvikle en iOS-app på en Mac. Hvis du valgte at isolere Codex ved at køre det i Docker, ville Codex hverken kunne køre iOS-buildværktøjskæden, som består af eksekverbare Mac-programmer, eller starte iPhone-simulatoren for at køre koden. En Docker-baseret arbejdsgang kunne uddelegere builds og simulatorhandlinger til Mac-værten, men disse handlinger ville blive udført uden for containerens sandbox og kræve deres egne begrænsninger. I Codex foretrækker vi at holde tingene enkle ved at investere målrettet i OS-specifik sandboxing, så Codex kan køre i det miljø, der passer bedst til den aktuelle opgave.

Harn esset stiller disse OS-specifikke sandboxmekanismer til rådighed gennem en fælles API på tværs af macOS, Windows og Linux. Denne API tager imod en kommando og en tilladelsesprofil. Hvis tilladelsesprofilen tillader begrænset netværksadgang, skal den kaldende kode angive en netværksproxy, der håndhæver disse grænser:

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 funktion starter processen i en sandbox og returnerer et Child-handle, som harnesset kan bruge til at vente på, at den afsluttes. Hver underproces arver den overordnede proces' sandboxbegrænsninger. Derfor gælder begrænsningerne i hele det procestræ, kommandoen starter, også for efterkommere, der fortsætter, efter at den oprindelige proces er afsluttet.

Følgende diagram viser, hvordan delene hænger sammen, fra konfiguration til kørsel af en kommando i en sandbox. De følgende afsnit forklarer hvert trin.

Flowdiagram: Konfiguration og administrerede krav definerer en tilladelsesprofil for sessionen. Codex-harnesset starter kommandoer under platformspecifikke sandboxbegrænsninger på macOS, Linux eller Windows. Underprocesser arver disse begrænsninger, og en valgfri netværksproxy håndhæver domæneregler.

Sådan bruger harnesset sandboxen

Som forklaret i Et nærmere kig på Codex-agentens løkke er Codex-harnesset ansvarligt for at udføre de værktøjskald, som modellen genererer. Til kodningsopgaver er det mest anvendte værktøj et shellværktøj, som kører kommandoer omtrent som en bruger i en interaktiv shell såsom Bash. Her ser vi på shellværktøjet ⁠(åbner i et nyt vindue)exec_command⁠(åbner i et nyt vindue) til enkeltstående kørsler⁠(åbner i et nyt vindue) for at illustrere, hvordan harnesset bruger sandboxen til at opnå de ønskede beskyttelser.

Dette er en forenklet version af, hvordan værktøjskaldet
exec_command ville blive håndteret af Codex-harnesset uden sandboxing:

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 at køre kommandoen i en sandbox erstatter harnesset kaldet til subprocess.Popen() med spawn_command_under_sandbox(). Harn esset angiver tilladelsesprofilen og om nødvendigt netværksproxyen:

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}

Værktøjet exec_command lader også modellen anmode om andre tilladelser til en enkelt kommando, men harnesset afgør, om anmodningen skal imødekommes:

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 angives, bruger harnesset standardkonfigurationen for sandboxen i den aktuelle tur. with_additional_permissions anmoder om udvidet adgang inden for sandboxen, mens require_escalated anmoder om udførelse uden for den. Harn esset vurderer anmodningen ud fra brugerens præferencer, før det udfører kommandoen. (For eksempel kan Codex spørge brugeren direkte eller sende anmodningen til automatisk gennemgang⁠(åbner i et nyt vindue).) Hvis udførelsen godkendes, sender Codex de relevante værdier for permission_profile og network_proxy til perform_exec_command_with_sandboxing() sammen med kommandoargumenterne fra det oprindelige ExecCommandToolCall.

Det er primært shellværktøjet, der bruger spawn_command_under_sandbox(), og harnesset genbruger også sin sandboxinfrastruktur til handlinger som at læse og ændre lokale filer. Genbrugen rækker ud over harnesset: Kommandoen codex sandbox lader dig indarbejde kommandokørsel i en sandbox i dine egne værktøjer, som vi skal se senere. Nu ser vi på, hvordan tilladelsesprofiler defineres.

Konfiguration af sandboxen

En navngivet tilladelsesprofil lader dig genbruge de samme filsystem- og netværksbegrænsninger på tværs af projekter. Du kan definere dine egne profiler under [permissions] i config.toml. For eksempel definerer følgende en profil med navnet dev, som udvider⁠(åbner i et nyt vindue) den indbyggede profil :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 tilføjer skriveadgang til ~/build-cache og lægger yderligere begrænsninger på filer i arbejdsområdet. Filsystemposter kan give læseadgang (read), give læse- og skriveadgang (write) eller blokere adgang helt (deny).

Tabellen :workspace_roots lader dig definere regler for stier relativt til rodmapperne i et projekts arbejdsområde. Som standard bruger Codex CLI sin arbejdsmappe som arbejdsområdets eneste rodmappe, mens ChatGPT‑skrivebordsappen bruger projektets kildemapper. Codex anvender hver regel på alle rodmapper, så posten .vscode i dev giver mappen .vscode under hver rodmappe kun læseadgang.

Ud over 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"

Netværkstilladelser

Når du konfigurerer netværket for sandboxen i Codex, er der overordnet tre muligheder:

  • Deaktiver al netværksadgang (standard for profilen :workspace)

  • Aktivér fuld, direkte netværksadgang (standard for profilen :danger-full-access)

  • Begræns netværksadgang til en proxy, som ud fra tilladelsesprofilen afgør, hvad der må passere


For at give
dev direkte netværksadgang skal du angive permissions.dev.network.enabled = true på øverste niveau i config.toml. Det giver fuld netværksadgang, når netværksproxyen er deaktiveret.

For at begrænse dev til et sæt domæner skal du aktivere netværksproxyen og konfigurere dens domæneregler:

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

Domæneregler understøtter præcise navne og mønstre med jokertegn. Eksplicitte afvisningsregler har forrang for tilladelsesregler. Anmodninger til andre domæner kræver godkendelse eller blokeres, som beskrevet under Netværksproxy nedenfor.

Konfiguration i lag og håndhævelse af grænser

Den enkelte bruger kan konfigurere standardindstillinger, der gælder på tværs af projekter, og tilsidesætte dem for et bestemt betroet projekt. Virksomhedsadministratorer kan også have behov for at konfigurere standardindstillinger for deres brugere og begrænse, hvilke indstillinger brugerne må ændre. Codex understøtter begge dele gennem konfiguration i lag og administrerede krav.

Som beskrevet i Konfigurationens prioritetsrækkefølge⁠(åbner i et nyt vindue) sammenfletter Codex indstillinger fra flere config.toml-filer. Tabeller sammenflettes rekursivt, og kilden med højest prioritet vinder, når værdier er i konflikt. Arrays erstattes som en helhed.

Derfor bruger tilladelsesprofiler tabeller til filsystemstier og netværksdomæner. Et team kan tilføje eller tilsidesætte enkelte poster i sin egen konfiguration og automatisk arve ændringer i alle andre poster i organisationens basiskonfiguration:

TOML

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

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

Administratorer kan også angive administrerede krav⁠(åbner i et nyt vindue) via requirements.toml for at begrænse brugernes konfigurationsmuligheder. Disse krav kan komme fra flere kilder, herunder systemfiler og politikker leveret fra skyen. Et almindeligt anvendelsestilfælde er at angive allowed_permission_profiles for at begrænse, hvilke tilladelsesprofiler en virksomhedsbruger kan vælge. For eksempel kan en administrator angive disse cloudkrav:

TOML

1
default_permissions = ":read-only"
2

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

Cloudkravene har forrang for systemkravsfilen på /etc/codex/requirements.toml, så en post i den fil kan ikke tilsidesætte den eksplicitte indstilling ":danger-full-access" = false ovenfor. Når :workspace ikke angives, kan et andet kravlag levere denne post. Profiler, hvis poster er false eller mangler i den endelige sammenflettede tabel, er ikke tilgængelige.

Denne adskillelse lader organisationer håndhæve grænser, mens brugerne tilpasser deres konfiguration inden for dem. De resulterende tilladelsesprofiler kan bruges af harnesset eller anvendes direkte på en kommando, som vi nu skal se.

Brug af kommandoen codex sandbox

Codex CLI stiller kommandoen sandbox til rådighed, så du nemt kan køre en vilkårlig kommando med en tilladelsesprofil defineret i Codex-konfigurationen. Den bruges ofte til at afprøve profilen og sikre, at sandboxen forhindrer den adfærd, den er designet til at blokere.

For eksempel forsøger følgende kommando at konfigurere VS Code til at køre et skadeligt automatisk formateringsværktøj, når en fil gemmes. Hvis .vscode allerede findes, bør dev-profilen defineret ovenfor blokere denne skrivning, fordi mappen kun har læseadgang (codex sandbox behandler som standard cwd som arbejdsområdets rod):

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 det da også med:

Almindelig tekst

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

Kommandoen codex sandbox gør Codex' sandboxmekanisme tilgængelig uafhængigt af en agentsession. Du kan bruge det samme konfigurationssprog og den samme platformspecifikke håndhævelse til at begrænse kommandoer, der startes af dine egne værktøjer.

Eksempel: En MCP-server i en sandbox

For en stdio-baseret MCP-server konfigureret i config.toml forsøger Codex-harnesset ikke at køre serverens startkommando i en sandbox. Codex kan ikke pålideligt udlede, hvilke filer eller netværkstjenester serveren har brug for, så en standardsandboxprofil kan få en ellers gyldig konfiguration til at holde op med at fungere.

For eksempel konfigureres MCP-serveren @modelcontextprotocol/server-memory⁠(åbner i et nyt vindue) normalt til brug med Codex på følgende måde:

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"

Da denne npx-kommando kører uden for en sandbox, kan den skrive filer og sende netværksanmodninger med de samme tilladelser som brugeren, der kører Codex. Det giver for vidtgående adgang. For at begrænse adgangen kan vi definere en tilladelsesprofil med navnet memory-mcp og derefter køre den oprindelige npx-kommando via codex sandbox --permission-profile memory-mcp. Det begrænser, hvor serveren kan skrive, og forhindrer den i at få adgang til netværket:

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, skal du oprette dens datamappe og lægge den fastlåste pakkeversion i npm-cachen. Det lader npx --offline starte serveren med en profil, der deaktiverer netværksadgang:

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 cachelagret, kan Codex starte hukommelsesserveren uden netværksadgang og med skriveadgang begrænset til npm-cachen og serverens datamappe.

Implementering af Codex-sandboxen

Sandboximplementeringen omsætter en tilladelsesprofil til begrænsninger, der håndhæves af operativsystemet. Netværksproxyens centrale logik til anmodningshåndtering og politikker er fælles for alle tre store operativsystemer, mens proxyopsætningen og integrationen med sandboxen er OS-specifik. Vi ser først på den fælles proxy og derefter på implementeringerne til macOS, Linux og Windows.

Netværksproxy

For at håndhæve en tilladelsesprofils netværksbegrænsninger starter harnesset en netværksproxy og konfigurerer sandboxen til at tillade forbindelser til den, mens direkte forbindelser til eksterne værter blokeres. Proxyen kontrollerer hver anmodning mod profilens domæneregler for at afgøre, om den skal videresendes.

I Codex-lageret er netværksproxyen implementeret i craten codex-network-proxy⁠(åbner i et nyt vindue), som harnesset bruger som bibliotek. Den kan dog også bygges som et selvstændigt CLI-værktøj⁠(åbner i et nyt vindue). Når codex-network-proxy er aktiveret, starter den som standard både en HTTP-proxy og en SOCKS5-proxy. Disse proxyadresser sendes via miljøvariabler til den proces, som sandboxen starter. Ud over standardmiljøvariabler som HTTP_PROXY, HTTPS_PROXY og ALL_PROXY indsættes også en række velkendte programspecifikke miljøvariabler⁠(åbner i et nyt vindue), for eksempel PIP_PROXY. Det er dog ikke alle programmer, der respekterer disse miljøvariabler. Hvis et program forsøger at oprette en direkte forbindelse til en ekstern vært, blokerer operativsystemets sandboxbegrænsninger den, som beskrevet i de platformspecifikke afsnit nedenfor.

Netværksproxyen har ansvaret for at håndhæve de netværksbegrænsninger, der er defineret i en tilladelsesprofil. For eksempel tillader den tidligere viste dev-profil anmodninger til *.openai.com og afviser eksplicit anmodninger til evil.example. Når en anmodning er rettet mod et domæne, der ikke matcher en tilladelses- eller afvisningsregel, kan proxyen sætte anmodningen på pause og overlade godkendelsen til harnesset. Som i eksemplet med shellkommandoen kan Codex spørge brugeren direkte eller sende anmodningen til automatisk gennemgang⁠(åbner i et nyt vindue). Når proxyen modtager en afgørelse, lader den enten anmodningen fortsætte eller afviser den med et fejlsvar.

Rækkefølgen er vigtig her, fordi selv et DNS-opslag kan lække oplysninger, der er kodet ind i et værtsnavn. Derfor slår proxyen først det anmodede værtsnavn op, når den har afgjort, at det er tilladt eller godkendt. Bemærk, at brede regler med jokertegn eller adgang til DNS-tjenester stadig kan tillade DNS-baseret eksfiltration.

macOS

På macOS bruger Codex Seatbelt⁠(åbner i et nyt vindue), Apples sandboxmekanisme, der håndhæves af kernen. Seatbelt-politikker skrives i Sandbox Profile Language (SBPL), et Scheme-baseret sprog til at udtrykke sandboxbegrænsninger. Codex kalder Seatbelt via macOS-kommandoen /usr/bin/sandbox-exec. Ligesom codex sandbox tager den imod tilvalg, som beskriver sandboxen, efterfulgt af den kommando, der skal køres:

Bash

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

PROFILE er en SBPL-streng med poster, som konfigurerer sandboxen. For eksempel giver følgende SBPL-kodestykke læse- og skriveadgang til /dev/null og /dev/zero under sandboxpolitikken:

Scheme

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

Når netværksproxyen aktiveres som del af et sandboxkald, indsættes regler som følgende i profilen for at begrænse forbindelser til de relevante lokale porte:

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' basisprofil starter med
(deny default), så udgående forbindelser forbliver blokeret, medmindre de udtrykkeligt tillades.

Endelig kan SBPL indeholde pladsholdere ved hjælp af (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 udfyldes af de -Dkey=value-tilvalg, der sendes til sandbox-exec.

For at implementere sin egen sandbox-API opbygger Codex argumentlisten⁠(åbner i et nyt vindue) til sandbox-exec med udgangspunkt i en basispolitik⁠(åbner i et nyt vindue). Derefter bruges permission_profile og anden kontekst til at tilpasse den og danne den komplette Seatbelt-profil. Den resulterende profil og de tilhørende -D-argumenter konfigurerer de begrænsninger, Seatbelt håndhæver, mens netværksproxyen håndhæver yderligere netværksregler. Når hele argumentlisten er samlet, er det enkelt at kalde sandbox-exec.

Det er en udfordring at generere korrekt SBPL, fordi Apple ikke dokumenterer sproget til tredjepartsbrug. Faktisk angiver man sandbox-exec, at The sandbox-exec command is DEPRECATED (det samme gælder biblioteksfunktionen sandbox_init(), som er dokumenteret via man 3 sandbox_init). Trods advarslen om udfasning leveres macOS stadig med Seatbelt-profiler i /usr/share/sandbox, og tredjepartssoftware, herunder Google Chrome og Chromium⁠(åbner i et nyt vindue), er fortsat afhængig af Seatbelt. Derfor planlægger vi at fortsætte med at bruge Seatbelt i en overskuelig fremtid.

Linux

For at oprette sandboxen på Linux bruger Codex en kombination af bubblewrap⁠(åbner i et nyt vindue) (bwrap), et kommandolinjeværktøj til at opbygge isolerede miljøer, og seccomp-bpf⁠(åbner i et nyt vindue), en mekanisme i Linux-kernen til at filtrere systemkald. Et internt hjælpeprogram med navnet codex-linux-sandbox koordinerer opsætningen. Ligesom sandbox-exec på macOS tager det imod en sandboxkonfiguration efterfulgt af en kommando, der skal køres:

Bash

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

Når der er behov for filsystemisolering eller proxyrouting, kalder codex-linux-sandbox bwrap for at oprette det indledende sandboxmiljø. Derefter starter bwrap codex-linux-sandbox --apply-seccomp-then-exec inde i det. Dette andet kald bruger seccomp-bpf til at anvende yderligere begrænsninger, før brugerens kommando køres.

For at opbygge det indledende sandboxmiljø bruger Codex bubblewrap til at oprette en filsystemvisning i et separat mount-navnerum, som afspejler tilladelsesprofilens filsystemregler. Da dette er grundlæggende for sandboximplementeringen, medleverer Codex sin egen kopi af bwrap, hvis brugeren ikke har installeret en. Det foretrækker dog en kompatibel installation af ⁠(åbner i et nyt vindue)bwrap⁠(åbner i et nyt vindue) på PATH, hvis en sådan findes. Erfaringen viser, at nogle Linux-distributioner som standard deaktiverer adgang til brugernavnerum⁠(åbner i et nyt vindue), men gør en undtagelse for systemets bwrap.

Ligesom sandbox-exec tager bwrap imod en sandboxkonfiguration efterfulgt af en kommando, der skal køres i sandboxen. I stedet for et særligt konfigurationssprog som SBPL bruger bwrap individuelle flag til konfiguration. Codex bruger følgende tilvalg til at oprette filsystemvisningen:

  • --bind til at angive en fil eller mappe med skriveadgang

  • --ro-bind til at angive en fil eller mappe med kun læseadgang

  • --perms 000 --tmpfs DIR --remount-ro DIR til at afvise adgang til DIR

  • --perms 000 --ro-bind-data FD FILE til at afvise adgang til FILE (hvor FD er en åben fildeskriptor til /dev/null)

For at anvende glob-mønstre til afvisning med disse tilvalg udvider Codex dem til konkrete stier, før hver kommando startes. Nye stier, der matcher mønstrene, føjes ikke automatisk til kommandoens sandboxbegrænsninger.

Codex angiver også tilvalg som --unshare-ipc og --unshare-pid for at forhindre sandboxen i at få adgang til andre typer ressourcer på værten. Bubblewrap påvirker altså mere end blot, hvilke filer der er synlige.

Når Codex bruger bubblewrap, angiver det --unshare-net, hvis netværket er deaktiveret, eller forbindelser skal gå gennem netværksproxyen. Det opretter et nyt netværksnavnerum til sandboxen. Derefter bruger vi seccomp-bpf til at lægge yderligere begrænsninger på de netværkssystemkald og socketfamilier, som kommandoen har adgang til.


Konkret bruger vi
craten seccompiler⁠(åbner i et nyt vindue) til at kompilere et BPF-program dynamisk ud fra de ønskede filtre⁠(åbner i et nyt vindue) og anvende det på en startproces i sandboxen, så begrænsningerne nedarves til hele procestræet. Derfor kører bwrap ikke brugerens kommando, men startprogrammet codex-linux-sandbox med dets egne konfigurationsargumenter efterfulgt af brugerens kommando:

Bash

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

For at anvende seccomp-filtre uden forhøjede rettigheder sætter startprogrammet Linux-flaget no_new_privs til aktivt⁠(åbner i et nyt vindue). Dette flag nedarves til underprocesser og forhindrer dem i at få yderligere rettigheder, når de udfører et andet program, for eksempel en eksekverbar fil med setuid.

Seccomp-filtrene afhænger af netværkskonfigurationen. Når netværksadgang er deaktiveret, blokerer vi en række netværksrelaterede systemkald såsom connect(2) og bind(2). Når netværksproxyen er aktiveret i sandboxen, tillader vi dog IP-sockets, så TCP-lytteren oprettet af codex-linux-sandbox kan nås. Til gengæld blokerer vi som standard oprettelse af selvstændige Unix-domænesockets, da de utilsigtet kan give adgang til ressourcer på værten.

Forbindelse til netværksproxyen

Når sandboxkonfigurationen kræver brug af netværksproxyen, opretter Codex-harnesset én proxyinstans, som kan genbruges på tværs af flere kald til codex-linux-sandbox i samme Codex-tråd. Hver sandbox skal kunne nå den fælles proxy fra sit isolerede netværksnavnerum. Codex opretter en TCP-lytter på loopback-grænsefladen i dette navnerum og sørger for, at en proces uden for sandboxen accepterer forbindelserne og videresender dem til proxyen.

Følgende diagrammer illustrerer denne opsætning for ét proxyendepunkt. Det sidste diagram viser en forbindelse gennem det. Før bubblewrap startes, opretter codex-linux-sandbox et par Unix-sockets som kontrolkanal og forker sig selv. Underprocessen kører run_host_bridge() og venter på at modtage lytterens fildeskriptor via denne kanal:

Diagram over Codex-harnesset, som starter codex-linux-sandbox. Denne forker en videresendelsesproces, der er forbundet via en kontrolkanal med Unix-sockets.

I dette eksempel bruger den overordnede proces exec til at erstatte sit programbillede med bwrap. Det opsætter sandboxen og starter codex-linux-sandbox --apply-seccomp-then-exec i den, mens fildeskriptoren for kontrolkanalen sendes med:

Diagram, der viser, hvordan bwrap opretter et netværksnavnerum til sandboxen og starter codex-linux-sandbox i det, med en kontrolkanal via Unix-sockets til videresendelsesprocessen uden for sandboxen.

Inde i sandboxens netværksnavnerum opretter det andet kald til codex-linux-sandbox en TCP-lytter på loopback-grænsefladen og sender dens fildeskriptor via socketen. Lytteren forbliver knyttet til sandboxens netværksnavnerum. Dermed kan underprocessen, som er blevet uden for sandboxen, acceptere forbindelser fra programmer i sandboxen, mens den åbner sine forbindelser videre i værtens netværksnavnerum. Efter overdragelsen lukker begge processer deres deskriptorer til kontrolkanalen, og processen inde i sandboxen lukker sin kopi af lytteren.

Når TCP-lytteren er klar, indstiller processen i sandboxen værdien af HTTP_PROXY⁠(åbner i et nyt vindue) og relaterede miljøvariabler, så de peger på lytteren. Derefter anvender den seccomp, før den forker og udfører brugerens kommando:

Diagram, der viser et program i en sandbox, som opretter forbindelse til en TCP-lytter på loopback-grænsefladen, mens en ekstern codex-linux-sandbox-proces videresender trafikken til Codex-netværksproxyen.

Processen uden for sandboxen holder lytteren åben. For hver accepteret forbindelse åbner den en forbindelse til den konfigurerede proxy og videresender data i begge retninger.

Denne ekstra mekanisme giver kommandoen sit eget netværksnavnerum med en separat loopback-grænseflade. På macOS tillader Seatbelt, at kommandoen opretter direkte forbindelse til angivne porte på værtens loopback-grænseflade. På Linux opretter kommandoen i stedet forbindelse til en lytter i sit isolerede navnerum, og en proces uden for sandboxen videresender forbindelserne til den konfigurerede proxy. Overdragelsen af deskriptoren gør denne forbindelse mulig uden at give kommandoen adgang til værtens netværksnavnerum.

Windows

Tidligere på året implementerede vi sandboxing på Windows og skrev om vores arbejde med det. Siden da har Microsoft udgivet et bibliotek kaldet MXC sammen med nye funktioner til procesisolering i Windows-operativsystemet. Vi er i gang med at erstatte vores eksisterende sandbox med en, der bruger MXC-biblioteket.

Hvad er MXC?

MXC (Microsoft eXecution Container) er et system til kodeudførelse i en sandbox⁠(åbner i et nyt vindue) fra Microsoft, der understøtter flere backends til isolering på tværs af Windows, Linux og macOS. Codex understøtter en MXC-baseret sandbox på kompatible Windows-enheder og bruger systemets indbyggede procesisolering til at begrænse kommandoer i brugerens eksisterende miljø.

Vi skifter til MXC for at forbedre sikkerheden og brugervenligheden og samtidig afhjælpe flere begrænsninger ved vores eksisterende Windows-sandbox:

  • Behov for forhøjede rettigheder eller administratoradgang til at konfigurere sandboxen

  • Ressourcekrævende og langsom kontrol og indstilling af ACL'er

  • Sandboxopsætning, der bliver liggende på værtsmaskinen, herunder

    • ACL'er

    • Firewallregler

    • Sandboxbrugere

    • Filer til kontrolplanet

MXC stiller et JSON-konfigurationsskema⁠(åbner i et nyt vindue) til rådighed. Codex bruger MXC SDK⁠(åbner i et nyt vindue) til at opbygge en anmodning om udførelse, som følger dette skema og indeholder kommandoen, arbejdsmappen, miljøet og tilladelserne. Disse tilladelser omfatter adgang til filsystem og netværk samt Windows-ressourcer som skrivebordet og udklipsholderen.

Fra politik til MXC-kald

Codex bruger faste indstillinger for flere kontrolmekanismer for at afveje kompatibilitet og sikkerhed. Det tillader læsning fra registreringsdatabasen og bevarer den adgang til Win32k og skrivebordet, som PowerShell har brug for under opstart. Adgang til udklipsholderen, inputinjektion samt styring af skrivebordet og systemindstillinger er deaktiveret. Endelig forhindres MXC i at ændre værtens filsystemtilladelser som en reserveløsning.

Codex omsætter tilladelsesprofilens filsystem- og netværksregler til MXC-konfiguration. Vi bruger den tidligere dev-profil og antager følgende:

  • C:\, D:\ og Z:\ er maskinens eneste lokale drev.

  • Arbejdsområdets rod og arbejdsmappen er C:\work\demo.

  • Brugerens hjemmemappe er D:\Users\dev, så ~/build-cache svarer til D:\Users\dev\build-cache.

  • Glob-mønstret for afvisning matcher kun C:\work\demo\config\dev.env og C:\work\demo\config\prod.env.

De tilsvarende MXC-indstillinger ville omfatte:

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
}

Adgang til drevenes rodmapper

MXC's filsystempolitik afviser som standard adgang. Codex tilføjer derfor læsetilladelser til de lokale drevs rodmapper for at give den brede læseadgang, som denne profil tillader. Disse tilladelser gælder rekursivt inden for brugerens eksisterende rettigheder i operativsystemet.

En detalje kræver dog opmærksomhed: Tilladelser til skriveadgang i drevenes rodmapper gælder ikke rekursivt, så Codex udvider dem til at omfatte drevets eksisterende filer og mapper direkte under roden.

Modstridende tilladelser

Mere specifikke stier tilsidesætter tilladelser for overordnede mapper, så C:\work\demo kan have skriveadgang under C:\, som kun har læseadgang, mens C:\work\demo\.git stadig kun har læseadgang.

Når forskellige skrivemåder for stier eller aliaser via symbolske links eller junctions henviser til samme sti, anvender MXC den strengeste tilladelse: Afvisning har forrang for læseadgang, som har forrang for læse- og skriveadgang.

Glob-mønstre til afvisning

MXC accepterer kun konkrete stier til afvisning, så Codex udvider glob-mønstre til afvisning til matchende filer og mapper før start. Nye stier, der matcher glob-mønstret, tilføjes ikke automatisk, mens kommandoen kører.

Netværksadgang

Domæneregler såsom *.openai.com håndhæves af den fælles Codex-netværksproxy, der er beskrevet tidligere. Codex kører proxyen uden for sandboxen og sender dens adresser til kommandoen via de samme standardmiljøvariabler af typen *_PROXY, som er nævnt tidligere. MXC blokerer direkte eksterne forbindelser, men tillader forbindelser via værtens loopback-grænseflade, herunder adgang til proxyen. Andre lokale tjenester kan stadig nås.

På tværs af macOS, Linux og Windows bruger harnesset den samme sandbox-API til at starte kommandoer med en tilladelsesprofil. De platformspecifikke implementeringer håndterer den opsætning, der er nødvendig for at anvende disse begrænsninger.

Byg videre på Codex-sandboxen

At skrive og udføre kode giver agenter en fleksibel måde at løse problemer på, også uden for softwareudvikling. Codex-sandboxen lader dem bruge denne evne i brugerens eksisterende miljø med eksplicitte grænser for filsystem- og netværksadgang. Den er en genanvendelig grundkomponent i harnesset, og kommandoen codex sandbox gør den tilgængelig for værktøjer, du selv bygger.

Efterhånden som agenter påtager sig flere opgaver, vil vi gøre sandboxing praktisk anvendelig for flere værktøjer og miljøer. Det betyder, at vi vil gøre tilladelser lettere at konfigurere og udnytte bedre beskyttelser i operativsystemerne, efterhånden som de bliver tilgængelige. Vores mål er at udvide agenters muligheder, samtidig med at mennesker bevarer kontrollen over, hvad agenterne har adgang til.

Forfatter

OpenAI

Tak til

En særlig tak til David Wiesen, Charlie Weems, Viyat Bhalodia og Fotis Chantzis for deres bidrag til dette indlæg.