OpenAI

18 November 2026

Kejuruteraan

Dalam sandbox Codex

Cara Codex menjalankan perintah pada mesin anda dengan had yang anda kawal.

Oleh Michael Bolin, Ahli Staf Teknikal

Di OpenAI, kami mengambil pendekatan pertahanan berlapis⁠(dibuka dalam tetingkap baru) untuk melindungi ejen. Walaupun pelaburan kami dalam latihan dan penjajaran menjadi asas usaha ini, kami turut melaksanakan ciri dalam harnes kami berejen kami, Codex⁠(dibuka dalam tetingkap baru), untuk menyediakan perlindungan tambahan. Oleh sebab menjalankan perintah pada komputer anda adalah antara tindakan Codex yang paling lazim (dan berpotensi berisiko), kami membina sandbox Codex supaya Codex boleh berfungsi dalam persekitaran anda yang sedia ada dengan had sistem fail dan rangkaian yang anda kawal.

⁠(dibuka dalam tetingkap baru)Sandbox⁠(dibuka dalam tetingkap baru) mengehadkan apa yang boleh diakses oleh program semasa ia dijalankan. Untuk tugas menyusun foto, anda boleh mengkonfigurasi sandbox Codex agar membenarkan perintah membaca dan mengubah fail dalam ~/Pictures serta menyekat akses rangkaian untuk menghalang muat naik. Untuk semakan kod, anda boleh membenarkan akses kepada dokumentasi dalam talian serta mengekalkan fail sumber sebagai baca sahaja. Pengguna mengkonfigurasi sandbox Codex melalui ⁠(dibuka dalam tetingkap baru)profil kebenaran⁠(dibuka dalam tetingkap baru), yang menentukan sekatan sistem fail dan rangkaian bagi sesi Codex.

Dalam artikel ini, kami akan bermula dengan pertimbangan di sebalik tetapan lalai sandbox Codex, kemudian menerangkan reka bentuk sandbox dan cara harnes menggunakannya untuk menjalankan perintah. Kami akan menunjukkan cara pengguna akhir dan perusahaan boleh menyesuaikan kebenarannya mengikut keperluan, serta cara pembangun boleh menggunakan semula sandbox dalam alat mereka sendiri. Akhir sekali, kami akan meneliti cara sekatan ini dikuatkuasakan pada macOS, Linux dan Windows.

Menentukan sempadan sandbox

Dalam Codex, falsafah kami adalah untuk menetapkan tetapan lalai yang konservatif untuk sandbox, tetapi masih membolehkan kerja yang bermakna dilakukan. Contohnya, dengan repositori Git sebagai akar ruang kerja, profil kebenaran terbina dalam :workspace:

  • Membenarkan penulisan dalam ruang kerja, serta mengekalkan direktori seperti .git dan .codex sebagai baca sahaja. Ini membolehkan Codex menyunting kod sumber tanpa meminta kebenaran bagi setiap perubahan, serta menghalang perubahan langsung pada .codex/config.toml atau cangkuk Git di bawah .git/hooks.

  • Membenarkan akses baca yang meluas pada sistem fail, tertakluk pada kebenaran OS sedia ada pengguna. Pengkompil, persekitaran masa jalan dan alat binaan bergantung pada SDK, pustaka serta konfigurasi di luar repositori. Mengehadkan pembacaan kepada ruang kerja akan menyebabkan banyak aliran kerja biasa tidak berfungsi. Namun, ini bermakna fail sensitif di tempat lain pada mesin juga mungkin kekal boleh dibaca (seperti fail konfigurasi yang mengandungi kunci API).

  • Menyahdayakan akses rangkaian. Ini menyekat muat naik terus ke perkhidmatan luar, termasuk percubaan membawa keluar data yang boleh dibaca oleh perintah. Ia turut menghalang operasi yang sah seperti memuat turun kebergantungan, yang memerlukan akses tambahan.

Sekatan ini menghalang banyak jenis tingkah laku buruk, tetapi tindakan yang memudaratkan masih boleh berlaku. Contohnya, ejen boleh menyuntik kod hasad ke dalam pakej yang dipasang secara setempat seperti node_modules/prettier. Perubahan sedemikian mungkin tidak muncul dalam git status kerana node_modules sering diabaikan oleh Git. Jika penyunting pengguna menjalankan salinan Prettier itu semasa menyimpan fail, tindakan menyimpan fail sahaja boleh melaksanakan kod hasad di luar sandbox Codex. Inilah sebabnya kami mengambil pendekatan pertahanan berlapis: sandbox mengehadkan perkara yang boleh diakses oleh perintah, manakala latihan dan penjajaran membantu model menggunakan akses itu mengikut hasrat pengguna.

Untuk panduan menyesuaikan kebenaran sandbox dan menggabungkannya dengan perlindungan lain dalam persekitaran perusahaan, lihat panduan praktikal keselamatan Codex⁠(dibuka dalam tetingkap baru).

Mereka bentuk sandbox

Mesin maya dan bekas⁠(dibuka dalam tetingkap baru) ialah dua mekanisme popular untuk pelaksanaan sandbox, tetapi kami mengambil pendekatan berbeza dengan sandbox Codex. Daripada memindahkan pengkomputeran ke persekitaran berasingan untuk menyediakan pengasingan, Codex menggunakan kemudahan pelaksanaan sandbox setiap platform untuk mengehadkan perintah yang berjalan dalam persekitaran sedia ada pengguna.

Bagi ramai pembangun, komputer riba mereka berfungsi sebagai persekitaran pembangunan tersuai yang boleh diubah sesuka hati. Menghasilkan semula persekitaran itu dalam bekas Docker boleh memerlukan usaha, dan sesetengah aliran kerja masih bergantung pada alat yang berjalan pada hos.

Contohnya, bayangkan anda menggunakan Codex untuk membangunkan aplikasi iOS pada Mac. Jika anda memilih untuk mengasingkan Codex dengan menjalankannya dalam Docker, Codex tidak dapat menjalankan rantaian alat binaan iOS yang terdiri daripada fail boleh laku natif Mac, mahupun melancarkan simulator iPhone untuk menjalankan kod. Aliran kerja berasaskan Docker boleh menyerahkan binaan dan operasi simulator kepada hos Mac, tetapi operasi tersebut akan dilaksanakan di luar sandbox bekas dan memerlukan sekatannya sendiri. Bagi Codex, kami memilih pendekatan yang ringkas dengan memberikan tumpuan besar kepada pelaksanaan sandbox khusus sistem pengendalian supaya Codex dapat dijalankan dalam persekitaran yang paling sesuai untuk tugasan yang sedang dilakukan.

Harnes menyediakan pelaksanaan sandbox khusus OS ini melalui API yang seragam pada macOS, Windows dan Linux. API ini menerima perintah dan profil kebenaran. Jika profil kebenaran membenarkan akses rangkaian terhad, pemanggil mesti menyediakan proksi rangkaian untuk menguatkuasakan had tersebut:

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:

Fungsi ini memulakan proses dalam sandbox dan mengembalikan pemegang Child yang boleh digunakan oleh harnes untuk menunggu proses itu selesai. Setiap proses anak mewarisi kekangan sandbox induknya, jadi sekatan itu terpakai pada seluruh pepohon proses yang dimulakan oleh perintah, termasuk proses keturunan yang terus berjalan selepas proses asal tamat.

Rajah berikut menunjukkan cara komponen ini saling berkait, daripada konfigurasi hingga pelaksanaan perintah dalam sandbox. Bahagian berikut menerangkan setiap peringkat.

Rajah aliran: konfigurasi dan keperluan terurus menentukan profil kebenaran sesi; harnes Codex melancarkan perintah di bawah sekatan sandbox khusus platform pada macOS, Linux atau Windows. Proses anak mewarisi sekatan tersebut, dan proksi rangkaian pilihan menguatkuasakan peraturan domain.

Cara harnes memanfaatkan sandbox

Seperti yang diterangkan dalam Mengupas Gelung Ejen Codex, harnes Codex bertanggungjawab melaksanakan panggilan alat yang dijana oleh model. Untuk tugas pengekodan, alat yang paling lazim digunakan ialah alat shell, yang menjalankan perintah sebagaimana pengguna melakukannya dalam shell interaktif seperti Bash. Di sini, kami akan meneliti alat shell ⁠(dibuka dalam tetingkap baru)exec_command⁠(dibuka dalam tetingkap baru) satu percubaan⁠(dibuka dalam tetingkap baru) untuk menggambarkan cara harnes menggunakan sandbox bagi mencapai perlindungan yang dikehendaki.

Ini ialah versi ringkas cara panggilan alat
exec_command akan dilaksanakan oleh harnes Codex tanpa pelaksanaan sandbox:

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}

Untuk sandbox perintah, harnes menggantikan panggilan subprocess.Popen() dengan spawn_command_under_sandbox(). Harnes menyediakan profil kebenaran dan, apabila diperlukan, proksi rangkaian:

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}

Alat exec_command juga membolehkan model meminta kebenaran berbeza untuk perintah individu, tetapi harnes menentukan sama ada permintaan itu akan diluluskan:

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

Apabila use_default ditentukan, harnes menggunakan konfigurasi sandbox lalai untuk giliran tersebut. with_additional_permissions meminta akses yang diperluas dalam sandbox, manakala require_escalated meminta pelaksanaan di luarnya. Harnes menilai permintaan berdasarkan pilihan pengguna sebelum melaksanakan perintah. (Contohnya, Codex mungkin meminta pengguna secara langsung atau menghalakan permintaan ke semakan automatik⁠(dibuka dalam tetingkap baru).) Jika pelaksanaan dibenarkan, Codex akan menghantar permission_profile dan network_proxy yang sesuai ke perform_exec_command_with_sandboxing() bersama argumen perintah daripada ExecCommandToolCall asal.

Alat shell ialah pengguna utama spawn_command_under_sandbox(), dan harnes turut menggunakan semula infrastruktur sandbox untuk operasi seperti membaca dan mengubah fail setempat. Penggunaan semula ini tidak terhad kepada harnes: perintah codex sandbox membolehkan anda menyepadukan pelaksanaan perintah dalam sandbox ke dalam alat anda sendiri, seperti yang akan kita lihat kemudian. Seterusnya, kami akan melihat cara profil kebenaran ditakrifkan.

Mengkonfigurasi sandbox

Profil kebenaran bernama membolehkan anda menggunakan semula sekatan sistem fail dan rangkaian yang sama merentas projek. Anda boleh mentakrifkan profil sendiri di bawah [permissions] dalam config.toml. Contohnya, konfigurasi berikut mentakrifkan profil bernama dev yang memperluas⁠(dibuka dalam tetingkap baru) profil terbina dalam :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"

Profil dev menambahkan akses tulis kepada ~/build-cache dan mengenakan sekatan tambahan pada fail dalam ruang kerja. Entri sistem fail boleh memberikan akses baca sahaja (read), memberikan akses baca dan tulis (write), atau menyekat akses sepenuhnya (deny).

Jadual :workspace_roots membolehkan anda mentakrifkan peraturan untuk laluan relatif kepada akar ruang kerja projek. Secara lalai, CLI Codex menggunakan direktori kerjanya sebagai satu-satunya akar ruang kerja, manakala aplikasi desktop ChatGPT menggunakan folder sumber projek. Codex menerapkan setiap peraturan pada setiap akar, jadi entri .vscode dalam dev menjadikan direktori .vscode di bawah setiap akar sebagai baca sahaja.

Selain peraturannya sendiri, dev mewarisi perlindungan berikut daripada :workspace:

TOML

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

Kebenaran rangkaian

Secara umum, terdapat tiga pilihan untuk mengkonfigurasi rangkaian bagi sandbox dalam Codex:

  • Nyahdayakan semua akses rangkaian (lalai untuk profil :workspace)

  • Dayakan akses rangkaian penuh dan terus (lalai untuk profil :danger-full-access)

  • Hadkan akses rangkaian kepada proksi, yang menentukan perkara yang boleh diluluskan berdasarkan profil kebenaran


Untuk memberikan
dev akses rangkaian terus, tetapkan permissions.dev.network.enabled = true pada peringkat teratas config.toml. Ini memberikan akses rangkaian penuh apabila proksi rangkaian dinyahdayakan.

Untuk mengehadkan dev kepada sekumpulan domain, dayakan proksi rangkaian dan konfigurasikan peraturan domainnya:

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

Peraturan domain menyokong nama tepat dan corak kad bebas, dengan peraturan penolakan yang jelas mengatasi peraturan kebenaran. Permintaan kepada domain lain memerlukan kelulusan atau akan disekat, seperti yang diterangkan dalam Proksi rangkaian di bawah.

Melapiskan konfigurasi dan menguatkuasakan had

Pengguna individu boleh mengkonfigurasi tetapan lalai yang terpakai merentas projek dan menggantikannya untuk projek tertentu yang dipercayai. Pentadbir perusahaan juga mungkin mahu mengkonfigurasi tetapan lalai untuk pengguna mereka dan mengehadkan tetapan yang boleh diubah oleh pengguna tersebut. Codex menyokong kedua-duanya melalui konfigurasi berlapis dan keperluan terurus.

Seperti yang diterangkan dalam Keutamaan konfigurasi,⁠(dibuka dalam tetingkap baru) Codex menggabungkan tetapan daripada berbilang fail config.toml. Jadual digabungkan secara rekursif, dengan sumber yang mempunyai keutamaan lebih tinggi diutamakan apabila terdapat percanggahan nilai. Tatasusunan digantikan sepenuhnya.

Inilah sebabnya profil kebenaran menggunakan jadual untuk laluan sistem fail dan domain rangkaian. Pasukan boleh menambahkan atau menggantikan entri individu dalam konfigurasinya sendiri dan secara automatik mewarisi perubahan pada semua entri lain dalam konfigurasi asas organisasi:

TOML

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

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

Pentadbir juga boleh menyediakan keperluan terurus⁠(dibuka dalam tetingkap baru) melalui requirements.toml untuk mengehadkan pilihan konfigurasi pengguna. Keperluan ini boleh datang daripada pelbagai sumber, termasuk fail sistem dan dasar yang disediakan melalui awan. Kegunaan lazimnya ialah menentukan allowed_permission_profiles untuk mengehadkan set profil kebenaran yang boleh dipilih oleh pengguna perusahaan. Contohnya, pentadbir boleh menentukan keperluan awan berikut:

TOML

1
default_permissions = ":read-only"
2

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

Keperluan awan akan mengatasi fail keperluan sistem di /etc/codex/requirements.toml, jadi entri dalam fail itu tidak boleh mengatasi tetapan jelas ":danger-full-access" = false di atas. Membiarkan :workspace tanpa ditentukan membolehkan lapisan keperluan lain menyediakan entri tersebut. Profil yang entrinya bernilai false atau tiada dalam jadual gabungan akhir tidak tersedia.

Pemisahan ini membolehkan organisasi menguatkuasakan had sementara pengguna menyesuaikan konfigurasi mereka dalam had tersebut. Profil kebenaran yang terhasil boleh digunakan oleh harnes atau diterapkan terus pada perintah, seperti yang akan kita lihat seterusnya.

Menggunakan perintah codex sandbox

CLI Codex menyediakan perintah sandbox untuk memudahkan pelaksanaan sebarang perintah di bawah profil kebenaran yang ditakrifkan dalam konfigurasi Codex. Ini lazimnya digunakan untuk menguji profil, bagi memastikan sandbox menghalang tingkah laku yang memang direka untuk disekatnya.

Contohnya, perintah berikut cuba mengkonfigurasi VS Code untuk menjalankan pemformat automatik hasad semasa menyimpan fail. Dengan andaian .vscode sudah wujud, profil dev yang ditakrifkan di atas sepatutnya menyekat penulisan ini kerana direktori itu baca sahaja (codex sandbox menganggap cwd sebagai akar ruang kerja secara lalai):

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

Sememangnya, pada macOS, operasi ini gagal dengan mesej:

Teks biasa

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

Perintah codex sandbox membolehkan mekanisme sandbox Codex digunakan tanpa bergantung pada sesi ejen. Anda boleh menggunakan bahasa konfigurasi dan penguatkuasaan khusus platform yang sama untuk mengehadkan perintah yang dilancarkan oleh alat anda sendiri.

Contoh: pelaksanaan sandbox pelayan MCP

Bagi pelayan MCP stdio yang dikonfigurasi dalam config.toml, harnes Codex tidak cuba melaksanakan sandbox perintah yang digunakan untuk memulakan pelayan. Codex tidak dapat menyimpulkan dengan pasti fail atau perkhidmatan rangkaian yang diperlukan oleh pelayan itu, jadi penggunaan profil sandbox lalai boleh menyebabkan konfigurasi yang sebenarnya sah tidak berfungsi.

Contohnya, cara standard untuk mengkonfigurasi pelayan MCP @modelcontextprotocol/server-memory⁠(dibuka dalam tetingkap baru) untuk digunakan dengan Codex adalah seperti berikut:

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"

Oleh sebab perintah npx ini berjalan tanpa melaksanakan sandbox, ia boleh menulis fail dan membuat permintaan rangkaian dengan kebenaran yang sama seperti pengguna yang menjalankan Codex, iaitu akses yang terlalu luas. Untuk mengehadkannya, kita boleh mentakrifkan profil kebenaran bernama memory-mcp, kemudian membalut perintah npx asal dengan codex sandbox --permission-profile memory-mcp bagi mengehadkan lokasi penulisan pelayan dan menghalangnya daripada mengakses rangkaian:

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"

Sebelum memulakan pelayan, cipta direktori datanya dan isikan cache npm dengan pakej yang versinya telah ditetapkan. Ini membolehkan npx --offline melancarkan pelayan di bawah profil yang menyahdayakan akses rangkaian:

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

Setelah pakej disimpan dalam cache, Codex boleh memulakan pelayan memori tanpa akses rangkaian, dengan penulisan dihadkan kepada cache npm dan direktori data pelayan.

Pelaksanaan sandbox Codex

Pelaksanaan sandbox menukarkan profil kebenaran kepada sekatan yang dikuatkuasakan oleh sistem pengendalian. Logik teras pengendalian permintaan dan dasar proksi rangkaian dikongsi oleh ketiga-tiga sistem pengendalian utama, manakala persediaan proksi dan integrasinya dengan sandbox adalah khusus OS. Kami akan meneliti proksi bersama terlebih dahulu, diikuti pelaksanaan untuk macOS, Linux dan Windows.

Proksi rangkaian

Untuk menguatkuasakan sekatan rangkaian profil kebenaran, harnes memulakan proksi rangkaian dan mengkonfigurasi sandbox agar membenarkan sambungan kepadanya sambil menyekat sambungan terus ke hos luar. Proksi menyemak setiap permintaan berdasarkan peraturan domain profil untuk menentukan sama ada permintaan itu boleh dimajukan.

Dalam repositori Codex, proksi rangkaian dilaksanakan dalam crate codex-network-proxy⁠(dibuka dalam tetingkap baru), yang digunakan oleh harnes sebagai pustaka, walaupun ia juga boleh dibina sebagai CLI kendiri⁠(dibuka dalam tetingkap baru). Apabila didayakan, codex-network-proxy memulakan proksi HTTP dan proksi SOCKS5 secara lalai. Alamat proksi ini disampaikan kepada proses yang diwujudkan oleh sandbox melalui pemboleh ubah persekitaran. Selain menyuntik pemboleh ubah persekitaran standard seperti HTTP_PROXY, HTTPS_PROXY dan ALL_PROXY, beberapa pemboleh ubah persekitaran khusus aplikasi⁠(dibuka dalam tetingkap baru) yang diketahui umum (seperti PIP_PROXY) turut disuntik. Namun, tidak semua program mematuhi pemboleh ubah persekitaran ini. Jika program cuba membuat sambungan terus ke hos luar, sekatan sandbox sistem pengendalian akan menyekatnya, seperti yang diterangkan dalam bahagian khusus platform di bawah.

Proksi rangkaian bertanggungjawab melaksanakan sekatan rangkaian yang ditakrifkan dalam profil kebenaran. Contohnya, profil dev yang ditunjukkan sebelum ini membenarkan permintaan kepada *.openai.com dan secara jelas menolak permintaan kepada evil.example. Apabila permintaan menyasarkan domain yang tidak sepadan dengan peraturan kebenaran atau penolakan, proksi boleh menggantung permintaan itu sementara menyerahkannya kepada harnes untuk kelulusan. Seperti contoh perintah shell, Codex mungkin meminta pengguna secara langsung atau menghalakan permintaan kepada semakan automatik⁠(dibuka dalam tetingkap baru). Setelah menerima keputusan, proksi sama ada membenarkan permintaan diteruskan atau menolaknya dengan respons ralat.

Urutan ini penting kerana carian DNS sahaja pun boleh membocorkan maklumat yang dikodkan dalam nama hos. Oleh itu, proksi hanya menyelesaikan nama hos yang diminta selepas menentukan permintaan itu dibenarkan atau diluluskan. Perlu diingat bahawa peraturan kad bebas yang luas atau akses kepada perkhidmatan DNS masih boleh membenarkan data dibawa keluar melalui DNS.

macOS

Pada macOS, Codex menggunakan Seatbelt⁠(dibuka dalam tetingkap baru), pelaksanaan sandbox Apple yang dikuatkuasakan oleh kernel. Dasar Seatbelt ditulis dalam Sandbox Profile Language (SBPL), bahasa berasaskan Scheme untuk menyatakan sekatan sandbox. Codex memanggil Seatbelt melalui perintah /usr/bin/sandbox-exec macOS. Seperti codex sandbox, ia menerima pilihan yang menerangkan sandbox, diikuti perintah untuk dijalankan:

Bash

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

PROFILE ialah rentetan SBPL yang mengandungi entri untuk mengkonfigurasi sandbox. Contohnya, petikan SBPL berikut menjadikan /dev/null dan /dev/zero boleh dibaca dan ditulis di bawah dasar sandbox:

Scheme

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

Apabila proksi rangkaian didayakan sebagai sebahagian daripada panggilan sandbox, peraturan seperti yang berikut disuntik ke dalam profil untuk mengehadkan sambungan kepada port setempat yang sesuai:

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


Profil asas Codex bermula dengan
(deny default), jadi sambungan keluar kekal disekat melainkan dibenarkan secara jelas.

Akhir sekali, SBPL boleh mengandungi ruang letak menggunakan (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)))

yang diisi oleh pilihan -Dkey=value yang dihantar ke sandbox-exec.

Untuk melaksanakan API sandbox itu sendiri, Codex membina senarai argumen⁠(dibuka dalam tetingkap baru) untuk sandbox-exec bermula daripada dasar asas⁠(dibuka dalam tetingkap baru), kemudian menggunakan permission_profile dan konteks lain untuk memindanya bagi menghasilkan profil Seatbelt yang lengkap. Profil yang terhasil dan argumen -D yang mengiringinya mengkonfigurasi sekatan yang dikuatkuasakan oleh Seatbelt, manakala proksi rangkaian menguatkuasakan peraturan rangkaian tambahan. Setelah senarai argumen lengkap disusun, panggilan sandbox-exec adalah mudah.

Menghasilkan SBPL yang betul adalah mencabar kerana Apple tidak mendokumentasikan bahasa itu untuk kegunaan pihak ketiga. Malah, man sandbox-exec menyatakan The sandbox-exec command is DEPRECATED (begitu juga fungsi pustaka sandbox_init() yang didokumentasikan melalui man 3 sandbox_init). Walaupun terdapat amaran penamatan sokongan itu, macOS masih menyertakan profil Seatbelt dalam /usr/share/sandbox, dan perisian pihak ketiga, termasuk Google Chrome dan Chromium⁠(dibuka dalam tetingkap baru), terus bergantung pada Seatbelt. Oleh itu, kami merancang untuk terus menggunakan Seatbelt buat masa yang dapat dijangkakan.

Linux

Untuk mewujudkan sandbox pada Linux, Codex menggabungkan bubblewrap⁠(dibuka dalam tetingkap baru) (bwrap), alat baris perintah untuk membina persekitaran terasing, dengan seccomp-bpf⁠(dibuka dalam tetingkap baru), mekanisme kernel Linux untuk menapis panggilan sistem. Pembantu dalaman bernama codex-linux-sandbox menyelaraskan persediaan ini. Seperti sandbox-exec pada macOS, ia menerima konfigurasi sandbox diikuti perintah untuk dijalankan:

Bash

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

Apabila pengasingan sistem fail atau penghalaan proksi diperlukan, codex-linux-sandbox memanggil bwrap untuk mewujudkan persekitaran awal sandbox. bwrap kemudian melancarkan codex-linux-sandbox --apply-seccomp-then-exec di dalamnya. Panggilan kedua ini menggunakan seccomp-bpf untuk menerapkan sekatan tambahan sebelum menjalankan perintah pengguna.

Untuk membina persekitaran awal sandbox itu, Codex menggunakan bubblewrap bagi mewujudkan paparan sistem fail dalam ruang nama pelekap yang berasingan, mengikut peraturan sistem fail dalam profil kebenaran. Oleh sebab ini merupakan asas pelaksanaan sandbox, Codex membekalkan salinan bwrap sendiri sekiranya pengguna belum memasangnya, tetapi mengutamakan pemasangan serasi ⁠(dibuka dalam tetingkap baru)bwrap⁠(dibuka dalam tetingkap baru) yang ditemui pada PATH, jika ada. Berdasarkan pemerhatian, sesetengah edaran Linux menyahdayakan akses kepada ruang nama pengguna secara lalai⁠(dibuka dalam tetingkap baru), tetapi memberikan pengecualian untuk bwrap sistem.

Seperti sandbox-exec, bwrap juga menerima konfigurasi sandbox diikuti perintah untuk dijalankan di dalamnya. Daripada menggunakan bahasa konfigurasi tersuai seperti SBPL, bwrap menggunakan bendera individu untuk konfigurasi. Codex menggunakan pilihan berikut untuk mewujudkan paparan sistem fail:

  • --bind untuk menentukan fail atau direktori yang boleh ditulis

  • --ro-bind untuk menentukan fail atau direktori baca sahaja

  • --perms 000 --tmpfs DIR --remount-ro DIR untuk menolak akses kepada DIR

  • --perms 000 --ro-bind-data FD FILE untuk menolak akses kepada FILE (FD ialah pemerihal fail terbuka untuk /dev/null)

Untuk menerapkan corak glob penolakan menggunakan pilihan ini, Codex mengembangkannya kepada laluan sebenar sebelum melancarkan setiap perintah. Laluan baharu yang sepadan tidak ditambahkan secara automatik pada sekatan sandbox perintah tersebut.

Codex turut menentukan pilihan seperti --unshare-ipc dan --unshare-pid untuk menghalang sandbox daripada mengakses jenis sumber lain pada hos, supaya kesan bubblewrap bukan sekadar terhad kepada keterlihatan fail.

Apabila menggunakan bubblewrap, Codex menghantar --unshare-net setiap kali rangkaian dinyahdayakan atau sambungan mesti melalui proksi rangkaian. Ini mewujudkan ruang nama rangkaian baharu untuk sandbox. Kami kemudian menggunakan seccomp-bpf untuk menerapkan sekatan tambahan pada panggilan sistem rangkaian dan keluarga soket yang tersedia kepada perintah.


Secara khusus, kami menggunakan
crate seccompiler⁠(dibuka dalam tetingkap baru) untuk mengkompil program BPF secara dinamik berdasarkan penapis yang dikehendaki⁠(dibuka dalam tetingkap baru) dan menerapkannya pada proses pelancar dalam sandbox supaya kekangan itu diwarisi oleh seluruh pepohon proses. Oleh itu, bwrap tidak menjalankan perintah pengguna, sebaliknya menjalankan pelancar codex-linux-sandbox dengan argumen konfigurasinya sendiri diikuti perintah pengguna:

Bash

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

Untuk menerapkan penapis seccomp tanpa keistimewaan tinggi, pelancar menetapkan bendera no_new_privs Linux⁠(dibuka dalam tetingkap baru). Bendera ini diwarisi oleh proses anak dan menghalangnya daripada memperoleh keistimewaan tambahan apabila melaksanakan program lain, seperti fail boleh laksana setuid.

Penapis seccomp bergantung pada konfigurasi rangkaian. Apabila akses rangkaian dinyahdayakan, kami menyekat beberapa panggilan sistem berkaitan rangkaian, seperti connect(2) dan bind(2). Namun, apabila proksi rangkaian didayakan dalam sandbox, kami membenarkan soket IP supaya pendengar TCP yang diwujudkan oleh codex-linux-sandbox boleh dicapai, tetapi menyekat penciptaan soket domain Unix kendiri secara lalai kerana soket tersebut boleh membolehkan akses tidak sengaja kepada sumber dari hos.

Menyambung ke proksi rangkaian

Apabila konfigurasi sandbox memerlukan penggunaan proksi rangkaian, harnes Codex mewujudkan satu tika proksi yang boleh digunakan semula oleh berbilang panggilan codex-linux-sandbox dalam bebenang Codex yang sama. Setiap sandbox memerlukan cara untuk mencapai proksi bersama itu dari ruang nama rangkaiannya yang terasing. Codex menyediakan pendengar TCP gelung balik dalam ruang nama itu dan mengatur proses di luar sandbox untuk menerima sambungannya serta menyampaikannya ke proksi.

Rajah berikut menggambarkan susunan ini untuk satu titik akhir proksi, dengan satu sambungan yang melaluinya ditunjukkan dalam rajah terakhir. Sebelum melancarkan bubblewrap, codex-linux-sandbox mewujudkan pasangan soket Unix sebagai saluran kawalan dan mencabangkan dirinya. Proses anak menjalankan run_host_bridge() dan menunggu untuk menerima pemerihal fail pendengar melalui saluran tersebut:

Rajah harnes Codex mewujudkan proses codex-linux-sandbox, yang mencabangkan proses geganti yang disambungkan melalui saluran kawalan soket Unix.

Dalam contoh ini, proses induk menggunakan exec untuk menggantikan imej programnya dengan bwrap. Ini menyediakan sandbox dan melancarkan codex-linux-sandbox --apply-seccomp-then-exec di dalamnya, serta menghantar FD untuk saluran kawalan:

Rajah yang menunjukkan bwrap mewujudkan ruang nama rangkaian sandbox dan melancarkan codex-linux-sandbox di dalamnya, dengan saluran kawalan soket Unix ke proses geganti di luar sandbox.

Dalam ruang nama rangkaian sandbox, panggilan kedua codex-linux-sandbox mewujudkan pendengar TCP gelung balik dan menghantar pemerihal failnya melalui soket. Pendengar kekal dikaitkan dengan ruang nama rangkaian sandbox, membolehkan proses anak yang kekal di luar sandbox menerima sambungan daripada program dalam sandbox serta membuka sambungan hulunya dalam ruang nama rangkaian hos. Selepas penyerahan itu, kedua-dua proses menutup pemerihal saluran kawalan masing-masing, dan proses dalam sandbox menutup salinan pendengarnya.

Setelah pendengar TCP sedia, proses dalam sandbox menetapkan nilai yang sesuai untuk HTTP_PROXY⁠(dibuka dalam tetingkap baru) dan pemboleh ubah persekitaran berkaitan agar menghala ke pendengar tersebut. Kemudian, proses itu menerapkan seccomp sebelum mencabang dan melaksanakan perintah pengguna:

Rajah menunjukkan program dalam sandbox menyambung ke pendengar TCP gelung balik, dengan geganti luaran codex-linux-sandbox yang memajukan trafik ke proksi rangkaian Codex.

Proses di luar sandbox memastikan pendengar kekal terbuka. Bagi setiap sambungan yang diterima, proses itu membuka sambungan ke proksi yang dikonfigurasi dan menyampaikan data dalam kedua-dua arah.

Mekanisme tambahan ini memberikan perintah ruang nama rangkaiannya sendiri, termasuk antara muka gelung balik yang berasingan. Pada macOS, Seatbelt membenarkan perintah menyambung terus ke port yang ditentukan pada antara muka gelung balik hos. Pada Linux pula, perintah menyambung ke pendengar dalam ruang namanya yang terasing, dan proses di luar sandbox menyampaikan sambungan tersebut ke proksi yang dikonfigurasi. Penyerahan pemerihal membolehkan sambungan ini dibuat tanpa mendedahkan ruang nama rangkaian hos kepada perintah.

Windows

Awal tahun ini, kami melaksanakan dan menulis tentang usaha pelaksanaan sandbox kami pada Windows. Sejak itu, Microsoft telah mengeluarkan pustaka yang dipanggil MXC bersama ciri baharu untuk pengasingan proses dalam sistem pengendalian Windows. Kami kini sedang menggantikan sandbox sedia ada dengan sandbox yang menggunakan pustaka MXC.

Apakah itu MXC?

MXC (Microsoft eXecution Container) ialah sistem pelaksanaan kod dalam sandbox⁠(dibuka dalam tetingkap baru) daripada Microsoft yang menyokong beberapa bahagian belakang pengasingan pada Windows, Linux dan macOS. Codex menyokong sandbox berasaskan MXC pada peranti Windows yang serasi, menggunakan pengasingan proses natif untuk mengehadkan perintah dalam persekitaran pengguna yang sedia ada.

Kami sedang beralih kepada MXC untuk meningkatkan keselamatan dan kebolehgunaan serta menangani beberapa keterbatasan sandbox Windows kami yang sedia ada:

  • Keperluan untuk mendapatkan akses tinggi/akses pentadbir bagi menyediakan sandbox

  • Operasi pemeriksaan dan penetapan ACL yang mahal/perlahan

  • Keadaan persediaan sandbox yang kekal pada mesin hos, termasuk

    • ACL

    • Peraturan tembok api

    • Pengguna sandbox

    • Fail satah kawalan

MXC menyediakan skema konfigurasi JSON⁠(dibuka dalam tetingkap baru). Codex menggunakan SDK MXC⁠(dibuka dalam tetingkap baru) untuk membina permintaan pelaksanaan mengikut skema tersebut yang mengandungi perintah, direktori kerja, persekitaran dan kebenaran. Kebenaran tersebut meliputi akses sistem fail dan rangkaian, serta sumber Windows seperti desktop dan papan klip.

Menterjemahkan dasar kepada panggilan MXC

Codex menggunakan tetapan tetap bagi beberapa kawalan untuk mengimbangi keserasian dan keselamatan. Ia membenarkan pembacaan daftaran dan mengekalkan akses Win32k serta desktop yang diperlukan oleh PowerShell semasa permulaan. Akses papan klip, suntikan input serta kawalan desktop dan tetapan sistem dinyahdayakan. Akhir sekali, MXC dihalang daripada menggunakan kaedah alternatif dengan mengubah suai kebenaran sistem fail hos.

Codex menterjemahkan peraturan sistem fail dan rangkaian dalam profil kebenaran kepada konfigurasi MXC. Dengan menggunakan profil dev terdahulu, dan mengandaikan:

  • C:\, D:\ dan Z:\ ialah satu-satunya pemacu setempat pada mesin.

  • Akar ruang kerja dan direktori kerja ialah C:\work\demo.

  • Direktori utama pengguna ialah D:\Users\dev, maka ~/build-cache merujuk kepada D:\Users\dev\build-cache.

  • Corak glob penolakan hanya sepadan dengan C:\work\demo\config\dev.env dan C:\work\demo\config\prod.env.

Tetapan MXC yang sepadan akan merangkumi:

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
}

Akses akar pemacu

Dasar sistem fail MXC menolak akses secara lalai. Oleh itu, Codex menambahkan kebenaran baca sahaja untuk akar pemacu setempat bagi menyediakan akses baca meluas yang dibenarkan oleh profil ini. Kebenaran ini terpakai secara rekursif, tertakluk pada kebenaran OS pengguna yang sedia ada.

Ada satu kekhususan: kebenaran akar pemacu yang boleh ditulis tidak terpakai secara rekursif, jadi Codex memperluasnya untuk merangkumi fail dan direktori sedia ada yang berada terus di bawah akar pemacu.

Kebenaran yang bercanggah

Laluan yang lebih khusus mengatasi kebenaran laluan leluhurnya, jadi C:\work\demo boleh ditulis di bawah C:\ yang baca sahaja, manakala C:\work\demo\.git kekal baca sahaja.

Apabila ejaan laluan yang berbeza atau alias symlink/junction merujuk kepada laluan yang sama, MXC menerapkan kebenaran yang lebih ketat: penolakan mengatasi baca sahaja, yang mengatasi baca-tulis.

Corak glob penolakan

MXC hanya menerima laluan penolakan sebenar, jadi Codex mengembangkan corak glob penolakan kepada fail dan direktori yang sepadan sebelum pelancaran. Laluan baharu yang sepadan dengan corak glob tidak ditambahkan secara automatik semasa perintah berjalan.

Akses rangkaian

Peraturan domain seperti *.openai.com dikuatkuasakan oleh proksi rangkaian bersama Codex yang diterangkan sebelum ini. Codex menjalankan proksi itu di luar sandbox dan menghantar alamatnya kepada perintah melalui pemboleh ubah persekitaran standard *_PROXY yang sama seperti yang disebut sebelum ini. MXC menyekat sambungan terus ke luar sambil membenarkan sambungan gelung balik hos, termasuk akses kepada proksi. Perkhidmatan setempat lain kekal boleh dicapai.

Pada macOS, Linux dan Windows, harnes menggunakan API sandbox yang sama untuk melancarkan perintah di bawah profil kebenaran. Pelaksanaan khusus platform mengendalikan persediaan yang diperlukan untuk menerapkan sekatan tersebut.

Membangun berasaskan sandbox Codex

Menulis dan melaksanakan kod memberikan ejen cara yang fleksibel untuk menyelesaikan masalah di luar pembangunan perisian. Sandbox Codex membolehkan ejen menggunakan keupayaan itu dalam persekitaran sedia ada pengguna dengan had yang jelas pada akses sistem fail dan rangkaian. Ia ialah komponen asas yang boleh digunakan semula dalam harnes, dan perintah codex sandbox membolehkannya digunakan oleh alat yang anda bina sendiri.

Apabila ejen mengendalikan lebih banyak tugas, kami mahu menjadikan pelaksanaan sandbox praktikal untuk lebih banyak alat dan persekitaran. Ini bermakna memudahkan konfigurasi kebenaran dan memanfaatkan perlindungan sistem pengendalian yang lebih baik apabila tersedia. Matlamat kami adalah memperluas keupayaan ejen sambil memastikan manusia terus mengawal perkara yang boleh diakses oleh ejen.

Penulis

OpenAI

Penghargaan

Terima kasih khas kepada David Wiesen, Charlie Weems, Viyat Bhalodia dan Fotis Chantzis atas sumbangan mereka kepada artikel ini.