OpenAI

2026. november 18.

Mérnöki tevékenység

A Codex sandbox belülről

Így futtat a Codex parancsokat a gépeden az általad megszabott korlátok között.

Szerző: Michael Bolin, a műszaki csapat tagja

Az OpenAI-nál az ügynökök biztonságának megteremtésében a többrétegű védelem⁠(új ablakban nyílik meg) elvét követjük. Bár ebben alapvető szerepet játszik a tanításba és az emberi szándékokhoz való igazításba fektetett munkánk, az ügynökök végrehajtási környezetét adó Codex⁠(új ablakban nyílik meg) további védelmi funkciókat is tartalmaz. Mivel a Codex egyik leggyakoribb és potenciálisan kockázatos művelete a parancsok futtatása a számítógépeden, létrehoztuk a Codex sandboxot. Ennek segítségével a Codex a meglévő környezetedben dolgozhat, az általad megszabott fájlrendszer- és hálózati korlátok között.

A ⁠(új ablakban nyílik meg)sandbox⁠(új ablakban nyílik meg) korlátozza, hogy egy program mihez férhet hozzá futás közben. Fényképek rendezéséhez például beállíthatod a Codex sandboxot úgy, hogy a parancsok olvashassák és módosíthassák a ~/Pictures fájljait, miközben a hálózati hozzáférés tiltásával megakadályozod a feltöltést. Kódellenőrzéshez engedélyezheted az online dokumentáció elérését, miközben a forrásfájlok csak olvashatók maradnak. A felhasználók a Codex sandboxot ⁠(új ablakban nyílik meg)jogosultsági profilokkal⁠(új ablakban nyílik meg) konfigurálhatják, amelyek meghatározzák a Codex-munkamenet fájlrendszer- és hálózati korlátozásait.

Ebben a cikkben először áttekintjük a Codex sandbox alapbeállításai mögötti kompromisszumokat, majd bemutatjuk a sandbox felépítését és azt, hogyan használja a végrehajtási környezet a parancsok futtatásához. Megmutatjuk, hogyan igazíthatják a végfelhasználók és a vállalatok az igényeikhez a jogosultságokat, és hogyan használhatják fel a fejlesztők a sandboxot a saját eszközeikben. Végül megvizsgáljuk, hogyan érvényesülnek ezek a korlátozások macOS-en, Linuxon és Windowson.

A sandbox határainak meghatározása

A Codex esetében az az alapelvünk, hogy a sandbox óvatos alapbeállításai mellett is lehessen érdemi munkát végezni. Ha például egy Git-adattár a munkaterület gyökérkönyvtára, a beépített :workspace jogosultsági profil:

  • Engedélyezi az írást a munkaterületen belül, de az olyan könyvtárakat, mint a .git és a .codex, csak olvashatóként tartja meg. Így a Codex anélkül szerkesztheti a forráskódot, hogy minden változtatáshoz engedélyt kérne, de nem módosíthatja közvetlenül a .codex/config.toml fájlt vagy a .git/hooks alatti Git-hookokat.

  • Széles körű olvasási hozzáférést engedélyez a fájlrendszerhez, a felhasználó meglévő operációsrendszer-szintű jogosultságainak keretein belül. A fordítók, futtatókörnyezetek és buildeszközök az adattáron kívüli SDK-kra, programkönyvtárakra és konfigurációkra támaszkodnak. Ha az olvasás csak a munkaterületre korlátozódna, sok szokásos munkafolyamat nem működne. Ennek ára, hogy a gép más részein lévő érzékeny fájlok is olvashatók maradhatnak, például az API-kulcsokat tartalmazó konfigurációs fájlok.

  • Letiltja a hálózati hozzáférést. Ez blokkolja a külső szolgáltatásokba történő közvetlen feltöltést, beleértve a parancs által olvasható adatok kiszivárogtatására tett kísérleteket is. Ugyanakkor az olyan jogos műveleteket is megakadályozza, mint a függőségek letöltése, amelyhez további hozzáférés szükséges.

Ezek a korlátozások a nem kívánt működés számos formáját megakadályozzák, de káros műveletekre továbbra is van lehetőség. Az ügynök például rosszindulatú kódot juttathat egy helyben telepített csomagba, például a node_modules/prettier csomagba. Az ilyen módosítás nem feltétlenül jelenik meg a git status kimenetében, mert a Git gyakran figyelmen kívül hagyja a node_modules könyvtárat. Ha a felhasználó szerkesztője mentéskor a Prettiernek ezt a példányát futtatja, egy fájl egyszerű mentése is végrehajthatja a rosszindulatú kódot a Codex sandboxon kívül. Ezért alkalmazunk többrétegű védelmet: a sandbox korlátozza, hogy a parancsok mihez férhetnek hozzá, a tanítás és az emberi szándékokhoz való igazítás pedig segít a modellnek a felhasználó szándékának megfelelően élni ezzel a hozzáféréssel.

A sandbox jogosultságainak testreszabásához és más védelmi megoldásokkal való kombinálásához vállalati környezetben a Codex biztonsági receptgyűjteménye⁠(új ablakban nyílik meg) nyújt útmutatást.

A sandbox tervezése

A virtuális gépek és a konténerek⁠(új ablakban nyílik meg) népszerű megoldások az elkülönített futtatásra, de a Codex sandboxnál más megközelítést alkalmazunk. A Codex nem helyezi át a számításokat egy külön környezetbe az elkülönítés érdekében, hanem az egyes platformok sandboxfunkcióival korlátozza a felhasználó meglévő környezetében futó parancsokat.

Sok fejlesztő számára a laptopja egy személyre szabott fejlesztői környezet, amelyet bármikor kedvére alakíthat. Ennek a környezetnek az újraalkotása egy Docker-konténerben munkát igényelhet, és egyes munkafolyamatok továbbra is a gazdagépen futó eszközökre támaszkodnak.

Vegyük például azt az esetet, amikor a Codex segítségével iOS-alkalmazást fejlesztesz egy Macen. Ha úgy döntenél, hogy a Codexet Dockerben futtatva különíted el, nem tudná futtatni a natív Mac-programokból álló iOS-buildeszközláncot, és az iPhone-szimulátort sem tudná elindítani a kód futtatásához. Egy Docker-alapú munkafolyamat átadhatná a buildelést és a szimulátorműveleteket a Mac gazdagépnek, de ezek a műveletek a konténer sandboxán kívül futnának, és saját korlátozásokat igényelnének. A Codexnél az egyszerűségre törekszünk: jelentős erőforrásokat fordítunk az operációs rendszerhez igazított sandboxmegoldásokra, hogy a Codex mindig az adott feladathoz legmegfelelőbb környezetben futhasson.

A végrehajtási környezet ezeket az operációsrendszer-specifikus sandboxmechanizmusokat közös API-n keresztül teszi elérhetővé macOS-en, Windowson és Linuxon. Ez az API egy parancsot és egy jogosultsági profilt fogad. Ha a jogosultsági profil korlátozott hálózati hozzáférést engedélyez, a hívónak hálózati proxyt kell biztosítania a korlátok érvényesítéséhez:

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:

Ez a függvény sandboxban indítja el a folyamatot, és egy Child kezelőt ad vissza, amellyel a végrehajtási környezet megvárhatja a folyamat befejeződését. Minden gyermekfolyamat örökli a szülő sandboxkorlátozásait, így azok a parancs által indított teljes folyamatfára érvényesek, még az eredeti folyamatnál tovább élő leszármazottakra is.

A következő ábra bemutatja, hogyan kapcsolódnak össze ezek az elemek a konfigurációtól a sandboxban történő parancsfuttatásig. Az egyes szakaszokat a következőkben ismertetjük.

Folyamatábra: a konfiguráció és a központilag kezelt követelmények meghatározzák a munkamenet jogosultsági profilját; a Codex végrehajtási környezete platformspecifikus sandboxkorlátozások alatt indítja a parancsokat macOS-en, Linuxon vagy Windowson. A gyermekfolyamatok öröklik ezeket a korlátozásokat, egy opcionális hálózati proxy pedig érvényesíti a tartományszabályokat.

Hogyan használja a végrehajtási környezet a sandboxot?

Ahogy A Codex ügynökciklusának kibontása című cikkben kifejtettük, a Codex végrehajtási környezete felel a modell által generált eszközhívások végrehajtásáért. Programozási feladatoknál a leggyakrabban használt eszköz egy selleszköz, amely úgy futtat parancsokat, ahogy a felhasználó tenné egy interaktív parancsértelmezőben, például a Bashben. Itt az egylövéses ⁠(új ablakban nyílik meg)exec_command⁠(új ablakban nyílik meg) selleszközön⁠(új ablakban nyílik meg) keresztül mutatjuk be, hogyan használja a végrehajtási környezet a sandboxot a kívánt védelem biztosítására.

Ez annak egyszerűsített változata, ahogyan a Codex végrehajtási környezete
sandbox nélkül végrehajtaná az exec_command eszközhívást:

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}

A parancs sandboxban történő futtatásához a végrehajtási környezet a subprocess.Popen() hívást a spawn_command_under_sandbox() hívásra cseréli. A végrehajtási környezet biztosítja a jogosultsági profilt, és szükség esetén a hálózati proxyt is:

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}

Az exec_command eszköz azt is lehetővé teszi, hogy a modell egy adott parancshoz eltérő jogosultságokat kérjen, de a kérés teljesítéséről a végrehajtási környezet dönt:

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

A use_default megadásakor a végrehajtási környezet az adott forduló alapértelmezett sandboxkonfigurációját használja. A with_additional_permissions kibővített hozzáférést kér a sandboxon belül, míg a require_escalated a sandboxon kívüli végrehajtást kéri. A végrehajtási környezet a parancs futtatása előtt a felhasználó beállításai alapján értékeli a kérést. (A Codex például közvetlenül a felhasználótól kérhet jóváhagyást, vagy automatikus felülvizsgálatra⁠(új ablakban nyílik meg) küldheti a kérést.) Ha a végrehajtást engedélyezik, a Codex átadja a megfelelő permission_profile és network_proxy értéket a perform_exec_command_with_sandboxing() függvénynek, az eredeti ExecCommandToolCall parancsargumentumaival együtt.

A spawn_command_under_sandbox() elsődleges használója a selleszköz, de a végrehajtási környezet a sandboxinfrastruktúrát más műveletekhez, például helyi fájlok olvasásához és módosításához is felhasználja. Az újrafelhasználás a végrehajtási környezeten túlra is kiterjed: a codex sandbox paranccsal saját eszközeidbe is beépítheted a sandboxban történő parancsfuttatást, ahogy azt később bemutatjuk. A következőkben a jogosultsági profilok meghatározását tekintjük át.

A sandbox konfigurálása

Egy elnevezett jogosultsági profillal ugyanazokat a fájlrendszer- és hálózati korlátozásokat több projektben is felhasználhatod. Saját profilokat a config.toml fájl [permissions] szakaszában határozhatsz meg. Az alábbi példa egy dev nevű profilt határoz meg, amely kiterjeszti⁠(új ablakban nyílik meg) a beépített :workspace profilt:

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"

A dev profil írási hozzáférést ad a ~/build-cache könyvtárhoz, és további korlátozásokat alkalmaz a munkaterület fájljaira. A fájlrendszer-bejegyzések csak olvasási hozzáférést (read) vagy olvasási és írási hozzáférést (write) adhatnak, illetve teljesen letilthatják a hozzáférést (deny).

A :workspace_roots táblában a projekt munkaterületi gyökérkönyvtáraihoz viszonyított útvonalakra határozhatsz meg szabályokat. Alapértelmezés szerint a Codex CLI a munkakönyvtárát használja egyetlen munkaterületi gyökérkönyvtárként, míg a ChatGPT asztali alkalmazása a projekt forrásmappáit. A Codex minden szabályt minden gyökérkönyvtárra alkalmaz, így a dev profil .vscode bejegyzése minden gyökérkönyvtár alatt csak olvashatóvá teszi a .vscode könyvtárat.

A saját szabályain felül a dev a következő védelmeket örökli a :workspace profiltól:

TOML

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

Hálózati jogosultságok

A Codex sandbox hálózatának konfigurálására alapvetően három lehetőség van:

  • Minden hálózati hozzáférés letiltása (a :workspace profil alapbeállítása)

  • Teljes, közvetlen hálózati hozzáférés engedélyezése (a :danger-full-access profil alapbeállítása)

  • A hálózati hozzáférés proxyra korlátozása, amely a jogosultsági profil alapján dönti el, mit enged át


Ha közvetlen hálózati hozzáférést szeretnél adni a
dev profilnak, add meg a permissions.dev.network.enabled = true beállítást a config.toml legfelső szintjén. Ez teljes hálózati hozzáférést biztosít, ha a hálózati proxy ki van kapcsolva.

Ha a dev hozzáférését meghatározott tartományokra szeretnéd korlátozni, engedélyezd a hálózati proxyt, és állítsd be a tartományszabályait:

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

A tartományszabályok pontos neveket és helyettesítő karakteres mintákat is támogatnak; az explicit tiltó szabályok elsőbbséget élveznek az engedélyező szabályokkal szemben. A más tartományokra irányuló kérések jóváhagyást igényelnek vagy blokkolásra kerülnek, az alábbi Hálózati proxy szakaszban leírtak szerint.

Rétegzett konfiguráció és a korlátok érvényesítése

A felhasználók több projektre érvényes alapbeállításokat adhatnak meg, majd ezeket egy adott megbízható projektnél felülírhatják. A vállalati rendszergazdák szintén megadhatnak alapbeállításokat a felhasználóiknak, és korlátozhatják, hogy azok mely beállításokat módosíthatják. A Codex rétegzett konfigurációval és központilag kezelt követelményekkel támogatja mindkét lehetőséget.

A Konfigurációs elsőbbség⁠(új ablakban nyílik meg) című szakaszban leírtak szerint a Codex több config.toml fájl beállításait egyesíti. A táblák rekurzívan egyesülnek; ütköző értékek esetén a magasabb prioritású forrás érvényesül. A tömbök teljes egészükben lecserélődnek.

Ezért használnak a jogosultsági profilok táblákat a fájlrendszerútvonalakhoz és a hálózati tartományokhoz. Egy csapat a saját konfigurációjában hozzáadhat vagy felülírhat egyes bejegyzéseket, miközben automatikusan örökli a szervezet alapkonfigurációjának minden más bejegyzését érintő változásokat:

TOML

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

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

A rendszergazdák a requirements.toml fájlon keresztül központilag kezelt követelményeket⁠(új ablakban nyílik meg) is megadhatnak, amelyek korlátozzák a felhasználók konfigurációs lehetőségeit. Ezek a követelmények több forrásból is származhatnak, például rendszerfájlokból és felhőből biztosított házirendből. Gyakori felhasználási eset az allowed_permission_profiles megadása, amellyel korlátozható, hogy egy vállalati felhasználó mely jogosultsági profilok közül választhat. Egy rendszergazda például a következő felhőalapú követelményeket adhatja meg:

TOML

1
default_permissions = ":read-only"
2

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

A felhőből származó követelmények elsőbbséget élveznek a /etc/codex/requirements.toml rendszerkövetelmény-fájllal szemben, így a fájl egyetlen bejegyzése sem írhatja felül a fenti explicit ":danger-full-access" = false beállítást. Ha a :workspace nincs megadva, egy másik követelményréteg biztosíthatja ezt a bejegyzést. Nem érhetők el azok a profilok, amelyek bejegyzése false, vagy amelyek hiányoznak a végső, egyesített táblából.

Ez a szétválasztás lehetővé teszi, hogy a szervezetek korlátokat érvényesítsenek, a felhasználók pedig ezeken belül testre szabják a konfigurációjukat. Az így létrejött jogosultsági profilokat a végrehajtási környezet használhatja, vagy közvetlenül egy parancsra is alkalmazhatók, ahogy azt a következőkben bemutatjuk.

A codex sandbox parancs használata

A Codex CLI sandbox parancsával tetszőleges parancs futtatható a Codex konfigurációjában meghatározott jogosultsági profil alatt. Ezt gyakran a profil tesztelésére használják, hogy ellenőrizzék: a sandbox valóban megakadályozza-e azokat a műveleteket, amelyeket blokkolnia kell.

A következő parancs például megpróbálja úgy beállítani a VS Code-ot, hogy mentéskor egy rosszindulatú automatikus formázót futtasson. Ha a .vscode már létezik, a fent meghatározott dev profilnak blokkolnia kell ezt az írást, mert ez a könyvtár csak olvasható (a codex sandbox alapértelmezés szerint a cwd könyvtárat tekinti a munkaterület gyökerének):

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

macOS-en ez valóban meghiúsul, a következő hibaüzenettel:

Plain text

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

A codex sandbox parancs az ügynökmunkamenettől függetlenül is elérhetővé teszi a Codex sandboxmechanizmusát. Ugyanazzal a konfigurációs nyelvvel és platformspecifikus szabályérvényesítéssel korlátozhatod a saját eszközeid által indított parancsokat is.

Példa: MCP-szerver futtatása sandboxban

A config.toml fájlban konfigurált stdio MCP-szerver esetében a Codex végrehajtási környezete nem próbálja sandboxban futtatni a szervert indító parancsot. A Codex nem tudja megbízhatóan kikövetkeztetni, hogy a szervernek mely fájlokra vagy hálózati szolgáltatásokra van szüksége, ezért egy alapértelmezett sandboxprofil alkalmazása működésképtelenné tehetne egy egyébként érvényes konfigurációt.

Az @modelcontextprotocol/server-memory⁠(új ablakban nyílik meg) MCP-szervert például szokásosan így konfiguráljuk a Codexszel való használathoz:

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"

Mivel ez az npx parancs sandbox nélkül fut, a Codexet futtató felhasználó jogosultságaival írhat fájlokat és küldhet hálózati kéréseket, ami túl nagy szabadságot ad neki. A korlátozásához meghatározhatunk egy memory-mcp nevű jogosultsági profilt, majd az eredeti npx parancsot a codex sandbox --permission-profile memory-mcp paranccsal futtathatjuk. Ezzel megszabhatjuk, hová írhat a szerver, és megakadályozhatjuk a hálózati hozzáférését:

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"

A szerver indítása előtt hozd létre az adatkönyvtárát, és helyezd el a rögzített verziójú csomagot az npm gyorsítótárában. Így az npx --offline olyan profil alatt is elindíthatja a szervert, amely tiltja a hálózati hozzáférést:

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

Ha a csomag már a gyorsítótárban van, a Codex hálózati hozzáférés nélkül indíthatja el a memóriaszervert, miközben az írás csak az npm gyorsítótárára és a szerver adatkönyvtárára korlátozódik.

A Codex sandbox megvalósítása

A sandbox megvalósítása a jogosultsági profilt az operációs rendszer által érvényesített korlátozásokká alakítja. A hálózati proxy alapvető kéréskezelési és házirendlogikája mindhárom fő operációs rendszeren közös, míg a proxy beállítása és a sandboxszal való integrációja operációsrendszer-specifikus. Először a közös proxyt vizsgáljuk meg, majd a macOS-, Linux- és Windows-megvalósításokat.

Hálózati proxy

A jogosultsági profil hálózati korlátozásainak érvényesítéséhez a végrehajtási környezet elindít egy hálózati proxyt, és úgy konfigurálja a sandboxot, hogy ahhoz engedélyezze a csatlakozást, a külső gépekhez vezető közvetlen kapcsolatokat viszont blokkolja. A proxy minden kérést ellenőriz a profil tartományokra vonatkozó szabályai alapján, és eldönti, hogy továbbítja-e.

A Codex adattárában a hálózati proxy a codex-network-proxy⁠(új ablakban nyílik meg) crate-ben valósul meg. Ezt a végrehajtási környezet programkönyvtárként használja, de önálló parancssori eszközként⁠(új ablakban nyílik meg) is lefordítható. Ha engedélyezve van, a codex-network-proxy alapértelmezés szerint egy HTTP-proxyt és egy SOCKS5-proxyt is elindít. A proxyk címeit környezeti változók adják át a sandbox által indított folyamatnak. A szabványos környezeti változók, például a HTTP_PROXY, a HTTPS_PROXY és az ALL_PROXY mellett több ismert alkalmazásspecifikus környezeti változó⁠(új ablakban nyílik meg) is bekerül a környezetbe, például a PIP_PROXY. Ezeket a környezeti változókat azonban nem minden program veszi figyelembe. Ha egy program közvetlenül próbál csatlakozni egy külső géphez, az operációs rendszer sandboxkorlátozásai blokkolják, ahogy azt az alábbi platformspecifikus szakaszokban ismertetjük.

A hálózati proxy felel a jogosultsági profilban meghatározott hálózati korlátozások érvényesítéséért. A korábban bemutatott dev profil például engedélyezi a *.openai.com felé irányuló kéréseket, és kifejezetten tiltja az evil.example felé irányulókat. Ha egy kérés olyan tartományt céloz, amelyre sem engedélyező, sem tiltó szabály nem illeszkedik, a proxy felfüggesztheti a kérést, amíg jóváhagyást kér a végrehajtási környezettől. A shellparancs példájához hasonlóan a Codex közvetlenül a felhasználótól kérhet jóváhagyást, vagy automatikus felülvizsgálatra⁠(új ablakban nyílik meg) küldheti a kérést. A döntés kézhezvétele után a proxy továbbengedi a kérést, vagy hibaválasszal elutasítja.

A sorrend itt fontos, mert már egy DNS-lekérdezés is kiszivárogtathat a gépnévbe kódolt információkat. A proxy ezért csak azután oldja fel a kért gépnevet, hogy megállapította: az engedélyezett vagy jóváhagyott. Fontos megjegyezni, hogy a tág helyettesítő karakteres szabályok vagy a DNS-szolgáltatásokhoz való hozzáférés továbbra is lehetővé tehetik a DNS-alapú adatkiszivárogtatást.

macOS

macOS-en a Codex a Seatbelt⁠(új ablakban nyílik meg) megoldást, az Apple kernel által érvényesített sandboxmechanizmusát használja. A Seatbelt-házirendek Sandbox Profile Language (SBPL) nyelven íródnak. Ez egy Scheme-alapú nyelv a sandboxkorlátozások leírására. A Codex a macOS /usr/bin/sandbox-exec parancsán keresztül hívja meg a Seatbeltet. A codex sandbox parancshoz hasonlóan először a sandboxot leíró kapcsolókat fogadja, majd a futtatandó parancsot:

Bash

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

A PROFILE egy SBPL-karakterlánc, amely a sandboxot konfiguráló bejegyzéseket tartalmazza. A következő SBPL-kódrészlet például olvashatóvá és írhatóvá teszi a /dev/null és a /dev/zero fájlt a sandbox házirendjében:

Scheme

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

Ha a sandbox indításakor a hálózati proxy engedélyezve van, az alábbihoz hasonló szabályok kerülnek a profilba, hogy a kapcsolatokat a megfelelő helyi portokra korlátozzák:

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


A Codex alapprofilja a
(deny default) bejegyzéssel kezdődik, ezért a kimenő kapcsolatok explicit engedélyezés hiányában tiltva maradnak.

Végül az SBPL a (param) használatával helyőrzőket is tartalmazhat:

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

Ezek értékét a sandbox-exec parancsnak átadott -Dkey=value kapcsolók adják meg.

Saját sandbox API-ja megvalósításához a Codex egy alapházirendből⁠(új ablakban nyílik meg) kiindulva összeállítja az argumentumok listáját⁠(új ablakban nyílik meg) a sandbox-exec számára, majd a permission_profile és más környezeti információk alapján kiegészíti azt a teljes Seatbelt-profil létrehozásához. Az így kapott profil és a hozzá tartozó -D argumentumok állítják be a Seatbelt által érvényesített korlátozásokat, míg a hálózati proxy további hálózati szabályokat érvényesít. A teljes argumentumlista összeállítása után a sandbox-exec meghívása már egyszerű.

A helyes SBPL előállítása nehéz feladat, mert az Apple nem dokumentálja a nyelvet külső fejlesztők számára. A man sandbox-exec valóban ezt írja: The sandbox-exec command is DEPRECATED (ahogy a man 3 sandbox_init által dokumentált sandbox_init() könyvtári függvény is elavultnak minősül). Az elavultságra figyelmeztető jelzés ellenére a macOS továbbra is tartalmaz Seatbelt-profilokat a /usr/share/sandbox alatt, és külső szoftverek, köztük a Google Chrome és a Chromium⁠(új ablakban nyílik meg), továbbra is a Seatbeltre támaszkodnak. Ezért a belátható jövőben továbbra is a Seatbelt használatát tervezzük.

Linux

Linuxon a Codex két megoldás kombinációjával hozza létre a sandboxot: a bubblewrap⁠(új ablakban nyílik meg) (bwrap) elkülönített környezetek létrehozására szolgáló parancssori eszköz, a seccomp-bpf⁠(új ablakban nyílik meg) pedig a Linux kernel rendszerhívás-szűrő mechanizmusa. A beállításokat egy codex-linux-sandbox nevű belső segédprogram hangolja össze. A macOS sandbox-exec parancsához hasonlóan egy sandboxkonfigurációt fogad, amelyet a futtatandó parancs követ:

Bash

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

Ha fájlrendszer-elkülönítésre vagy proxyn keresztüli útválasztásra van szükség, a codex-linux-sandbox a bwrap meghívásával hozza létre a kezdeti sandboxkörnyezetet. A bwrap ezután ezen belül indítja el a codex-linux-sandbox --apply-seccomp-then-exec parancsot. Ez a második hívás a seccomp-bpf segítségével további korlátozásokat alkalmaz a felhasználó parancsának futtatása előtt.

A kezdeti sandboxkörnyezet létrehozásához a Codex a bubblewrap segítségével egy külön csatolási névtérben olyan fájlrendszernézetet hoz létre, amely megfelel a jogosultsági profil fájlrendszerszabályainak. Mivel ez a sandbox megvalósításának alapvető eleme, a Codex saját bwrap-példányt is tartalmaz arra az esetre, ha a felhasználó nem telepített volna ilyet. Ha azonban a PATH útvonalain található kompatibilis telepítés, azt részesíti előnyben a ⁠(új ablakban nyílik meg)bwrap⁠(új ablakban nyílik meg) futtatásához. Tapasztalataink szerint egyes Linux-disztribúciók alapértelmezés szerint letiltják a felhasználói névterekhez való hozzáférést⁠(új ablakban nyílik meg), de kivételt tesznek a rendszer bwrap-példányával.

A sandbox-exec parancshoz hasonlóan a bwrap is egy sandboxkonfigurációt fogad, amelyet a sandboxban futtatandó parancs követ. A bwrap az SBPL-hez hasonló egyedi konfigurációs nyelv helyett külön kapcsolókat használ a beállításokhoz. A Codex a következő kapcsolókkal hozza létre a fájlrendszernézetet:

  • --bind: írható fájl vagy könyvtár megadása

  • --ro-bind: csak olvasható fájl vagy könyvtár megadása

  • --perms 000 --tmpfs DIR --remount-ro DIR: a DIR elérésének tiltása

  • --perms 000 --ro-bind-data FD FILE: a FILE elérésének tiltása (ahol az FD a /dev/null megnyitott fájlleírója)

A tiltó globminták e kapcsolókkal történő alkalmazásához a Codex minden parancs indítása előtt konkrét útvonalakká bontja ki a mintákat. Az újonnan létrejövő, illeszkedő útvonalak nem kerülnek be automatikusan az adott parancs sandboxkorlátozásai közé.

A Codex olyan kapcsolókat is megad, mint a --unshare-ipc és a --unshare-pid, hogy a sandbox ne férhessen hozzá a gazdagép más típusú erőforrásaihoz. A bubblewrap tehát nem csupán a fájlok láthatóságát szabályozza.

A bubblewrap használatakor a Codex mindig átadja a --unshare-net kapcsolót, ha a hálózat le van tiltva, vagy a kapcsolatoknak a hálózati proxyn keresztül kell haladniuk. Ez új hálózati névteret hoz létre a sandbox számára. Ezután a seccomp-bpf segítségével tovább korlátozzuk a parancs számára elérhető hálózati rendszerhívásokat és socketcsaládokat.


Ehhez a
seccompiler crate-et⁠(új ablakban nyílik meg) használjuk: dinamikusan lefordítunk egy BPF-programot a kívánt szűrők alapján⁠(új ablakban nyílik meg), majd alkalmazzuk a sandbox egyik indítófolyamatára, hogy a teljes folyamatfa örökölje a korlátozásokat. A bwrap ezért nem a felhasználó parancsát futtatja, hanem a codex-linux-sandbox indítóprogramot, annak saját konfigurációs argumentumaival, amelyeket a felhasználó parancsa követ:

Bash

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

Ahhoz, hogy a seccomp-szűrők emelt szintű jogosultságok nélkül is alkalmazhatók legyenek, az indítóprogram beállítja a Linux no_new_privs jelzőjét⁠(új ablakban nyílik meg). Ezt a jelzőt a gyermekfolyamatok öröklik, így más programok, például setuid végrehajtható fájlok indításával sem szerezhetnek további jogosultságokat.

A seccomp-szűrők a hálózati konfigurációtól függenek. Ha a hálózati hozzáférés le van tiltva, több hálózati rendszerhívást is blokkolunk, például a connect(2) és a bind(2) hívást. Ha viszont a hálózati proxy engedélyezve van a sandboxban, engedélyezzük az IP-socketeket, hogy elérhető legyen a codex-linux-sandbox által létrehozott TCP-figyelő. Az önálló Unix domain socketek létrehozását ugyanakkor alapértelmezés szerint blokkoljuk, mert ezek nem szándékos hozzáférést tehetnének lehetővé a gazdagép erőforrásaihoz.

Csatlakozás a hálózati proxyhoz

Ha a sandbox konfigurációja hálózati proxy használatát indokolja, a Codex végrehajtási környezete létrehoz egy proxypéldányt, amely ugyanazon Codex-szálon belül a codex-linux-sandbox több hívásához is felhasználható. Minden sandboxnak el kell tudnia érni ezt a közös proxyt a saját elkülönített hálózati névteréből. A Codex egy loopback TCP-figyelőt biztosít a névtéren belül, és gondoskodik arról, hogy egy sandboxon kívüli folyamat fogadja a kapcsolatait, és továbbítsa azokat a proxyhoz.

A következő ábrák ezt az elrendezést mutatják be egy proxyvégpont esetében; az utolsó ábrán egy azon áthaladó kapcsolat is látható. A bubblewrap indítása előtt a codex-linux-sandbox létrehoz egy vezérlőcsatornaként szolgáló Unix socketpárt, majd elágaztatja saját folyamatát. A gyermekfolyamat a run_host_bridge() függvényt futtatja, és várja, hogy a csatornán megkapja a figyelő fájlleíróját:

Ábra arról, ahogy a Codex végrehajtási környezete elindítja a codex-linux-sandbox programot, amely elágaztatással létrehoz egy Unix socket vezérlőcsatornán kapcsolódó továbbítófolyamatot.

Ebben a példában a szülőfolyamat az exec segítségével a bwrap programra cseréli a saját programképét. Ez beállítja a sandboxot, majd azon belül elindítja a codex-linux-sandbox --apply-seccomp-then-exec parancsot, továbbadva a vezérlőcsatorna fájlleíróját:

Ábra arról, ahogy a bwrap létrehozza a sandbox hálózati névterét, és azon belül elindítja a codex-linux-sandbox programot. A sandboxon kívüli továbbítófolyamathoz Unix socket vezérlőcsatorna kapcsolódik.

A sandbox hálózati névterében a codex-linux-sandbox második hívása létrehoz egy loopback TCP-figyelőt, és a socketen keresztül átadja annak fájlleíróját. A figyelő továbbra is a sandbox hálózati névteréhez kapcsolódik. Így a sandboxon kívül maradt gyermekfolyamat fogadhatja a sandboxban futó programok kapcsolatait, miközben a proxy felé irányuló kapcsolatait a gazdagép hálózati névterében nyitja meg. Az átadás után mindkét folyamat lezárja a vezérlőcsatorna leíróit, a sandboxon belüli folyamat pedig a figyelő saját példányát is lezárja.

Amint a TCP-figyelő készen áll, a sandboxon belüli folyamat beállítja a megfelelő értéket a HTTP_PROXY⁠(új ablakban nyílik meg) és a kapcsolódó környezeti változók számára, hogy erre a figyelőre mutassanak. Ezután alkalmazza a seccomp korlátozásait, mielőtt elágaztatja a folyamatot és végrehajtja a felhasználó parancsát:

Ábra egy sandboxban futó programról, amely egy loopback TCP-figyelőhöz csatlakozik, miközben egy külső codex-linux-sandbox továbbítófolyamat a Codex hálózati proxyjához továbbítja a forgalmat.

A sandboxon kívüli folyamat nyitva tartja a figyelőt. Minden elfogadott kapcsolathoz kapcsolatot nyit a beállított proxy felé, és mindkét irányban továbbítja az adatokat.

Ez a kiegészítő mechanizmus saját hálózati névteret biztosít a parancsnak, külön loopback interfésszel. macOS-en a Seatbelt lehetővé teszi, hogy a parancs közvetlenül csatlakozzon a gazdagép loopback interfészének megadott portjaihoz. Linuxon ehelyett a parancs az elkülönített névterén belüli figyelőhöz csatlakozik, és egy sandboxon kívüli folyamat továbbítja ezeket a kapcsolatokat a beállított proxyhoz. A leíró átadása úgy teszi lehetővé ezt a kapcsolatot, hogy a parancs nem kap hozzáférést a gazdagép hálózati névteréhez.

Windows

Az év elején megvalósítottuk a windowsos sandboxot, és írtunk az ezzel kapcsolatos munkánkról. Azóta a Microsoft kiadott egy MXC nevű programkönyvtárat, valamint új folyamatelkülönítési funkciókat a Windows operációs rendszerben. Jelenleg a meglévő sandboxunkat egy olyan megoldásra cseréljük, amely az MXC programkönyvtárat használja.

Mi az MXC?

Az MXC (Microsoft eXecution Container) a Microsoft sandboxban történő kódfuttatásra szolgáló rendszere⁠(új ablakban nyílik meg), amely többféle elkülönítési háttérmegoldást támogat Windowson, Linuxon és macOS-en. A Codex a kompatibilis Windows-eszközökön MXC-alapú sandboxot támogat, amely natív folyamatelkülönítéssel korlátozza a parancsokat a felhasználó meglévő környezetén belül.

Az MXC-re való átállással javítjuk a biztonságot és a használhatóságot, miközben kiküszöböljük a meglévő windowsos sandboxunk több korlátját:

  • A sandbox beállításához emelt szintű vagy rendszergazdai jogosultság szükséges

  • Az ACL-ek ellenőrzése és beállítása erőforrás-igényes és lassú

  • A sandbox beállításai tartósan megmaradnak a gazdagépen, többek között:

    • ACL-ek

    • Tűzfalszabályok

    • Sandbox-felhasználók

    • A vezérlési sík fájljai

Az MXC egy JSON-konfigurációs sémát⁠(új ablakban nyílik meg) tesz elérhetővé. A Codex az MXC SDK⁠(új ablakban nyílik meg) segítségével állít össze egy, a sémának megfelelő végrehajtási kérelmet, amely tartalmazza a parancsot, a munkakönyvtárat, a környezetet és a jogosultságokat. Ezek a jogosultságok a fájlrendszer- és hálózati hozzáférésre, valamint olyan Windows-erőforrásokra terjednek ki, mint az asztal és a vágólap.

A házirend átalakítása MXC-hívássá

A Codex több vezérlési lehetőséghez rögzített beállításokat használ, hogy egyensúlyt teremtsen a kompatibilitás és a biztonság között. Engedélyezi a rendszerleíró adatbázis olvasását, és megőrzi a PowerShell indulásához szükséges Win32k- és asztalhozzáférést. A vágólaphoz való hozzáférés, a bemeneti események injektálása, valamint az asztal és a rendszerbeállítások vezérlése le van tiltva. Végül az MXC nem folyamodhat tartalék megoldásként a gazdagép fájlrendszer-jogosultságainak módosításához.

A Codex a jogosultsági profil fájlrendszer- és hálózati szabályait MXC-konfigurációvá alakítja. A korábbi dev profilt használva, és feltételezve, hogy:

  • A gép egyetlen helyi meghajtói a C:\, a D:\ és a Z:\ .

  • A munkaterület gyökérkönyvtára és a munkakönyvtár a C:\work\demo.

  • A felhasználó saját könyvtára a D:\Users\dev, így a ~/build-cache a D:\Users\dev\build-cache útvonalra oldódik fel.

  • A tiltó globminta csak a C:\work\demo\config\dev.env és a C:\work\demo\config\prod.env útvonalra illeszkedik.

A megfelelő MXC-beállítások a következőket tartalmaznák:

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
}

Hozzáférés a meghajtók gyökérkönyvtárához

Az MXC fájlrendszer-házirendje alapértelmezés szerint megtagadja a hozzáférést. A Codex ezért csak olvasási jogosultságot ad a helyi meghajtók gyökérkönyvtáraihoz, hogy biztosítsa a profil által engedélyezett széles körű olvasási hozzáférést. Ezek a jogosultságok rekurzívan érvényesülnek, a felhasználó meglévő operációsrendszer-szintű jogosultságainak keretein belül.

Van azonban egy sajátosság: a meghajtó gyökérkönyvtárára adott írási jogosultság nem érvényesül rekurzívan, ezért a Codex kiterjeszti azt a meghajtó már meglévő közvetlen gyermekelemeire is.

Ütköző jogosultságok

A pontosabb útvonalak felülírják a szülőkönyvtárakra adott jogosultságokat, így a C:\work\demo írható lehet a csak olvasható C:\ alatt, miközben a C:\work\demo\.git csak olvasható marad.

Ha eltérő útvonal-megadások vagy szimbolikus hivatkozások és junction álnevek ugyanarra az útvonalra mutatnak, az MXC a szigorúbb jogosultságot alkalmazza: a tiltás elsőbbséget élvez a csak olvasással szemben, az pedig az írás-olvasással szemben.

Tiltó globminták

Az MXC csak konkrét tiltott útvonalakat fogad el, ezért a Codex indítás előtt feloldja a tiltó globmintákat az illeszkedő fájlok és könyvtárak listájává. A parancs futása közben létrejövő, a globmintára illeszkedő új útvonalak nem kerülnek automatikusan a listába.

Hálózati hozzáférés

Az olyan tartományszabályokat, mint a *.openai.com, a korábban ismertetett közös Codex hálózati proxy érvényesíti. A Codex ezt a proxyt a sandboxon kívül futtatja, és a korábban említett szabványos *_PROXY környezeti változókon keresztül adja át a címeit a parancsnak. Az MXC blokkolja a közvetlen külső kapcsolatokat, de engedélyezi a gazdagép loopback interfészéhez való csatlakozást, beleértve a proxy elérését is. Más helyi szolgáltatások is elérhetők maradnak.

A végrehajtási környezet macOS-en, Linuxon és Windowson ugyanazt a sandbox API-t használja a parancsok jogosultsági profil alatti indításához. A korlátozások alkalmazásához szükséges beállításokról a platformspecifikus megvalósítások gondoskodnak.

Építkezés a Codex sandboxra

A kódírás és -futtatás rugalmas eszközt ad az ügynököknek a szoftverfejlesztésen túli problémák megoldásához is. A Codex sandbox lehetővé teszi, hogy ezt a képességet a felhasználó meglévő környezetében használják, egyértelműen meghatározott fájlrendszer- és hálózati hozzáférési korlátok mellett. A sandbox a végrehajtási környezet újrafelhasználható alapeleme, amelyet a codex sandbox parancs a saját fejlesztésű eszközeid számára is elérhetővé tesz.

Ahogy az ügynökök egyre több feladatot látnak el, szeretnénk minél több eszköz és környezet számára praktikussá tenni a sandboxban történő futtatást. Ehhez egyszerűbbé kell tennünk a jogosultságok konfigurálását, és ki kell használnunk az operációs rendszerek új, fejlettebb védelmi lehetőségeit, amint elérhetővé válnak. Célunk, hogy bővítsük az ügynökök képességeit, miközben továbbra is az emberek dönthetnek arról, mihez férhetnek hozzá.

Szerző

OpenAI

Köszönetnyilvánítás

Külön köszönet David Wiesen, Charlie Weems, Viyat Bhalodia és Fotis Chantzis közreműködéséért a bejegyzés elkészítésében.