OpenAI

१८ नोव्हेंबर, २०२६

इंजिनिअरिंग

Codex सँडबॉक्सच्या अंतरंगात

तुमच्या नियंत्रणातील मर्यादा पाळून Codex तुमच्या संगणकावर कमांड कशा चालवते.

लेखक: मायकेल बोलिन, तांत्रिक कर्मचारी सदस्य

OpenAI मध्ये, एजंटच्या सुरक्षेसाठी आम्ही बहुस्तरीय संरक्षणाचा⁠(नवीन विंडोमध्ये उघडेल) दृष्टिकोन स्वीकारतो. प्रशिक्षण आणि उद्दिष्टांशी सुसंगती यांतील आमची गुंतवणूक या प्रयत्नांचा पाया आहे. त्यासोबतच अतिरिक्त संरक्षणासाठी आमच्या एजंट हार्नेस Codex⁠(नवीन विंडोमध्ये उघडेल) मध्येही आम्ही वैशिष्ट्ये विकसित करतो. तुमच्या संगणकावर कमांड चालवणे हे Codex चे अतिशय सामान्य, पण संभाव्य जोखमीचे काम आहे. म्हणून आम्ही Codex सँडबॉक्स तयार केला. यामुळे Codex तुमच्या विद्यमान वातावरणात, तुमच्या नियंत्रणातील फाइल प्रणाली व नेटवर्क मर्यादांमध्ये काम करू शकते.

सँडबॉक्स⁠(नवीन विंडोमध्ये उघडेल) ⁠(नवीन विंडोमध्ये उघडेल)प्रोग्राम चालू असताना त्याला काय उपलब्ध असू शकते यावर मर्यादा घालतो. फोटो व्यवस्थित लावण्याच्या कामासाठी, तुम्ही Codex सँडबॉक्समध्ये कमांडना ~/Pictures मधील फाइल्स वाचण्याची व बदलण्याची परवानगी देऊ शकता, पण अपलोड टाळण्यासाठी नेटवर्क प्रवेश बंद ठेवू शकता. कोडच्या पुनरावलोकनासाठी, स्रोत फाइल्स केवळ-वाचन ठेवून ऑनलाइन दस्तऐवज पाहण्याची परवानगी देऊ शकता. वापरकर्ते ⁠(नवीन विंडोमध्ये उघडेल)परवानगी प्रोफाइलद्वारे⁠(नवीन विंडोमध्ये उघडेल) Codex सँडबॉक्सची संरचना ठरवतात. ही प्रोफाइल Codex सत्रासाठी फाइल प्रणाली आणि नेटवर्कचे निर्बंध ठरवतात.

या लेखात प्रथम Codex सँडबॉक्सच्या पूर्वनिर्धारित सेटिंग्जमागील तडजोडी पाहू. मग सँडबॉक्सची रचना आणि कमांड चालवण्यासाठी हार्नेस त्याचा वापर कसा करते हे स्पष्ट करू. वापरकर्ते आणि उद्योग आपल्या गरजांनुसार परवानग्या कशा बदलू शकतात आणि विकसक आपल्या साधनांत सँडबॉक्सचा पुनर्वापर कसा करू शकतात हेही पाहू. शेवटी, macOS, Linux आणि Windows वर हे निर्बंध कसे लागू होतात ते तपासू.

सँडबॉक्सच्या सीमा ठरवणे

अर्थपूर्ण काम करता येईल अशा सावध पूर्वनिर्धारित सेटिंग्ज सँडबॉक्ससाठी ठेवणे, हे Codex मधील आमचे तत्त्व आहे. उदाहरणार्थ, कार्यक्षेत्राची मूळ निर्देशिका Git रिपॉझिटरी असल्यास, अंगभूत :workspace परवानगी प्रोफाइल:

  • कार्यक्षेत्रात लेखनाची परवानगी देते, पण .git आणि .codex यांसारख्या निर्देशिका केवळ-वाचन ठेवते. यामुळे Codex प्रत्येक बदलासाठी परवानगी न मागता स्रोत कोड संपादित करू शकते. मात्र .codex/config.toml किंवा .git/hooks मधील Git हुकमध्ये थेट बदल करता येत नाहीत.

  • वापरकर्त्याच्या विद्यमान कार्यप्रणाली परवानग्यांच्या अधीन राहून फाइल प्रणालीत व्यापक वाचनाची परवानगी देते. कंपायलर, रनटाइम आणि बिल्ड साधने रिपॉझिटरीबाहेरील SDK, लायब्ररी आणि संरचनेवर अवलंबून असतात. वाचन केवळ कार्यक्षेत्रापुरते मर्यादित केल्यास अनेक नेहमीच्या कार्यपद्धती बंद पडतील. यातील तडजोड अशी की संगणकावरील इतर संवेदनशील फाइल्सही वाचता येऊ शकतात (जसे API की असलेल्या संरचना फाइल्स).

  • नेटवर्क प्रवेश अक्षम करते. यामुळे बाह्य सेवांवर थेट अपलोड करणे थांबते. कमांडला वाचता येणारा डेटा चोरून बाहेर पाठवण्याचे प्रयत्नही रोखले जातात. यामुळे अवलंबित घटक डाउनलोड करणे यांसारखी वैध कामेही थांबतात. त्यांसाठी अतिरिक्त प्रवेश आवश्यक असतो.

हे निर्बंध अनेक प्रकारचे गैरवर्तन रोखतात, तरीही हानिकारक कृती शक्य असतात. उदाहरणार्थ, एजंट node_modules/prettier सारख्या स्थानिकरीत्या स्थापित पॅकेजमध्ये दुर्भावनापूर्ण कोड घुसवू शकतो. असा बदल git status मध्ये दिसेलच असे नाही, कारण Git अनेकदा node_modules कडे दुर्लक्ष करते. वापरकर्त्याचा संपादक फाइल जतन करताना Prettier ची ती प्रत चालवत असेल, तर केवळ फाइल जतन केल्यानेही दुर्भावनापूर्ण कोड Codex सँडबॉक्सबाहेर चालू शकतो. म्हणूनच आम्ही बहुस्तरीय संरक्षण वापरतो: सँडबॉक्स कमांडच्या प्रवेशावर मर्यादा घालतो, तर प्रशिक्षण आणि उद्दिष्टांशी सुसंगती मॉडेलला तो प्रवेश वापरकर्त्याच्या हेतूनुसार वापरण्यास मदत करतात.

उद्योगाच्या वातावरणात सँडबॉक्स परवानग्या गरजेनुसार बदलण्याबाबत आणि इतर संरक्षणांसोबत वापरण्याबाबत मार्गदर्शनासाठी Codex सुरक्षा मार्गदर्शिका⁠(नवीन विंडोमध्ये उघडेल) पाहा.

सँडबॉक्सची रचना

आभासी यंत्रे आणि कंटेनर⁠(नवीन विंडोमध्ये उघडेल) या सँडबॉक्सिंगच्या दोन लोकप्रिय यंत्रणा आहेत. पण Codex सँडबॉक्ससाठी आम्ही वेगळा मार्ग स्वीकारतो. विलगीकरणासाठी गणनकार्य वेगळ्या वातावरणात हलवण्याऐवजी, Codex प्रत्येक प्लॅटफॉर्मच्या सँडबॉक्सिंग सुविधा वापरते. त्यामुळे वापरकर्त्याच्या विद्यमान वातावरणात चालणाऱ्या कमांडवर निर्बंध घालता येतात.

अनेक विकसकांचा लॅपटॉप हे त्यांच्या गरजेनुसार घडवलेले विकास वातावरण असते. त्यात ते हवे तेव्हा बदल करू शकतात. ते वातावरण Docker कंटेनरमध्ये पुन्हा उभारण्यासाठी मेहनत लागू शकते. शिवाय काही कार्यपद्धती होस्टवर चालणाऱ्या साधनांवरच अवलंबून असतात.

उदाहरणार्थ, Mac वर iOS ॲप विकसित करण्यासाठी Codex वापरण्याचा विचार करा. Codex ला Docker मध्ये चालवून सँडबॉक्समध्ये ठेवायचे ठरवल्यास, ते Mac साठीच्या मूळ कार्यान्वयनीय प्रोग्रामची iOS बिल्ड साधनसाखळी चालवू शकणार नाही. तसेच कोड चालवण्यासाठी iPhone सिम्युलेटरही सुरू करू शकणार नाही. Docker-आधारित कार्यपद्धतीत बिल्ड आणि सिम्युलेटरची कामे Mac होस्टकडे सोपवता येतील. पण ती कंटेनरच्या सँडबॉक्सबाहेर चालतील आणि त्यांवर स्वतंत्र निर्बंध लागतील. Codex साठी आम्ही कार्यप्रणाली-विशिष्ट सँडबॉक्सिंगमध्ये मोठी गुंतवणूक करून गोष्टी सोप्या ठेवण्यास प्राधान्य देतो. त्यामुळे Codex संबंधित कामाला सर्वाधिक योग्य अशा वातावरणात चालू शकते.

हार्नेस macOS, Windows आणि Linux वर एकाच API द्वारे या कार्यप्रणाली-विशिष्ट सँडबॉक्सिंग यंत्रणा उपलब्ध करते. हा API एक कमांड आणि एक परवानगी प्रोफाइल स्वीकारतो. परवानगी प्रोफाइल मर्यादित नेटवर्क प्रवेश देत असल्यास, त्या मर्यादा लागू करण्यासाठी कॉल करणाऱ्याने नेटवर्क प्रॉक्सी पुरवणे आवश्यक आहे:

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:

हे फंक्शन सँडबॉक्समध्ये प्रक्रिया सुरू करते आणि Child हँडल परत देते. हार्नेस त्याद्वारे प्रक्रिया पूर्ण होण्याची वाट पाहू शकते. प्रत्येक अपत्य प्रक्रियेला पालक प्रक्रियेचे सँडबॉक्स निर्बंध वारशाने मिळतात. त्यामुळे कमांडने सुरू केलेल्या संपूर्ण प्रक्रिया-वृक्षाला ते लागू होतात, अगदी मूळ प्रक्रिया संपल्यानंतरही चालू राहणाऱ्या वंशज प्रक्रियांनाही.

संरचनेपासून सँडबॉक्समध्ये कमांड चालवण्यापर्यंत हे घटक कसे एकत्र काम करतात ते पुढील आकृती दाखवते. पुढील विभाग प्रत्येक टप्पा स्पष्ट करतात.

प्रवाह आकृती: संरचना आणि व्यवस्थापित आवश्यकता सत्राचे परवानगी प्रोफाइल ठरवतात; Codex हार्नेस macOS, Linux किंवा Windows वर प्लॅटफॉर्म-विशिष्ट सँडबॉक्स निर्बंधांत कमांड सुरू करते. अपत्य प्रक्रियांना ते निर्बंध वारशाने मिळतात आणि पर्यायी नेटवर्क प्रॉक्सी डोमेन नियम लागू करते.

हार्नेस सँडबॉक्सचा वापर कसा करते

Codex एजंटचे कार्यचक्र उलगडताना या लेखात स्पष्ट केल्याप्रमाणे, मॉडेलने तयार केलेले साधन कॉल चालवण्याची जबाबदारी Codex हार्नेसची असते. कोडिंगच्या कामांसाठी सर्वाधिक वापरले जाणारे साधन म्हणजे शेल साधन. Bash सारख्या परस्परसंवादी शेलमध्ये वापरकर्ता जशा कमांड चालवतो, तशाच ते चालवते. हवे ते संरक्षण मिळवण्यासाठी हार्नेस सँडबॉक्स कसा वापरते हे दाखवण्यासाठी, इथे आपण वन-शॉट ⁠(नवीन विंडोमध्ये उघडेल)exec_command⁠(नवीन विंडोमध्ये उघडेल) शेल साधन⁠(नवीन विंडोमध्ये उघडेल) पाहू.

Codex हार्नेस
सँडबॉक्सिंगशिवाय exec_command साधन कॉल कसा चालवेल, याचे हे सोपे रूप आहे:

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}

कमांड सँडबॉक्समध्ये चालवण्यासाठी, हार्नेस subprocess.Popen() च्या जागी spawn_command_under_sandbox() कॉल करते. हार्नेस परवानगी प्रोफाइल आणि गरज असल्यास नेटवर्क प्रॉक्सी पुरवते:

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}

exec_command साधन मॉडेलला एखाद्या कमांडसाठी वेगळ्या परवानग्या मागू देते. पण त्या द्यायच्या की नाही हे हार्नेस ठरवते:

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

use_default निर्दिष्ट असल्यास, हार्नेस त्या फेरीसाठी पूर्वनिर्धारित सँडबॉक्स संरचना वापरते. with_additional_permissions सँडबॉक्समध्ये अधिक व्यापक प्रवेशाची विनंती करते, तर require_escalated त्याबाहेर चालवण्याची विनंती करते. कमांड चालवण्यापूर्वी हार्नेस वापरकर्त्याच्या पसंतीनुसार विनंतीचे मूल्यमापन करते. (उदाहरणार्थ, Codex थेट वापरकर्त्याला विचारू शकते किंवा विनंती स्वयंचलित पुनरावलोकनाकडे⁠(नवीन विंडोमध्ये उघडेल) पाठवू शकते.) चालवण्यास मंजुरी मिळाल्यास, Codex योग्य permission_profile आणि network_proxy, तसेच मूळ ExecCommandToolCall मधील कमांड आर्ग्युमेंट, perform_exec_command_with_sandboxing() ला देते.

spawn_command_under_sandbox() चा मुख्य वापर शेल साधन करते. हार्नेस स्थानिक फाइल्स वाचणे आणि बदलणे यांसारख्या कामांसाठीही आपल्या सँडबॉक्सिंग पायाभूत यंत्रणेचा पुनर्वापर करते. हा पुनर्वापर हार्नेसपुरता मर्यादित नाही: codex sandbox कमांडद्वारे तुमच्या स्वतःच्या साधनांतही सँडबॉक्समध्ये कमांड चालवण्याची सुविधा जोडता येते. पुढे ते पाहू. आता परवानगी प्रोफाइल कशी ठरवली जातात ते पाहू.

सँडबॉक्सची संरचना

नाव दिलेले परवानगी प्रोफाइल वापरून वेगवेगळ्या प्रकल्पांत तेच फाइल प्रणाली व नेटवर्क निर्बंध पुन्हा वापरता येतात. config.toml मध्ये [permissions] अंतर्गत तुम्ही स्वतःची प्रोफाइल ठरवू शकता. उदाहरणार्थ, पुढील संरचना अंगभूत :workspace प्रोफाइलचा विस्तार करणारे⁠(नवीन विंडोमध्ये उघडेल) dev नावाचे प्रोफाइल ठरवते:

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"

dev प्रोफाइल ~/build-cache मध्ये लेखनाची परवानगी जोडते आणि कार्यक्षेत्रातील फाइल्सवर अतिरिक्त निर्बंध घालते. फाइल प्रणालीच्या नोंदी केवळ-वाचन प्रवेश (read), वाचन व लेखन प्रवेश (write) देऊ शकतात किंवा प्रवेश पूर्णपणे रोखू शकतात (deny).

:workspace_roots तक्त्याद्वारे प्रकल्पाच्या कार्यक्षेत्रातील मूळ निर्देशिकांच्या सापेक्ष पथांसाठी नियम ठरवता येतात. पूर्वनिर्धारितपणे, Codex CLI आपली कार्यरत निर्देशिका हीच कार्यक्षेत्राची एकमेव मूळ निर्देशिका मानते. ChatGPT डेस्कटॉप ॲप मात्र प्रकल्पाचे स्रोत फोल्डर वापरते. Codex प्रत्येक नियम सर्व मूळ निर्देशिकांना लागू करते. त्यामुळे dev मधील .vscode नोंद प्रत्येक मूळ निर्देशिकेखालील .vscode निर्देशिका केवळ-वाचन करते.

स्वतःच्या नियमांव्यतिरिक्त, dev ला :workspace कडून पुढील संरक्षणे वारशाने मिळतात:

TOML

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

नेटवर्क परवानग्या

Codex सँडबॉक्ससाठी नेटवर्कची संरचना करताना साधारणपणे तीन पर्याय असतात:

  • सर्व नेटवर्क प्रवेश बंद करणे (:workspace प्रोफाइलसाठी पूर्वनिर्धारित)

  • संपूर्ण, थेट नेटवर्क प्रवेश सुरू करणे (:danger-full-access प्रोफाइलसाठी पूर्वनिर्धारित)

  • नेटवर्क प्रवेश प्रॉक्सीपुरता मर्यादित करणे; परवानगी प्रोफाइलनुसार काय पुढे जाऊ द्यायचे हे प्रॉक्सी ठरवते


dev ला थेट नेटवर्क प्रवेश देण्यासाठी, config.toml च्या सर्वोच्च स्तरावर permissions.dev.network.enabled = true सेट करा. नेटवर्क प्रॉक्सी अक्षम असताना यामुळे पूर्ण नेटवर्क प्रवेश मिळतो.

dev ला ठरावीक डोमेनपुरते मर्यादित करण्यासाठी, नेटवर्क प्रॉक्सी सक्षम करा आणि तिचे डोमेन नियम ठरवा:

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

डोमेन नियम अचूक नावे आणि वाइल्डकार्ड नमुने स्वीकारतात. स्पष्ट नकार नियमांना परवानगी नियमांपेक्षा प्राधान्य मिळते. खाली नेटवर्क प्रॉक्सी विभागात सांगितल्याप्रमाणे, इतर डोमेनच्या विनंत्यांसाठी मंजुरी आवश्यक असते किंवा त्या रोखल्या जातात.

संरचनेचे स्तर आणि मर्यादांची अंमलबजावणी

वैयक्तिक वापरकर्ते सर्व प्रकल्पांना लागू होणारी पूर्वनिर्धारित सेटिंग्ज ठरवू शकतात आणि विशिष्ट विश्वासार्ह प्रकल्पासाठी ती बदलू शकतात. उद्योगातील प्रशासकांनाही वापरकर्त्यांसाठी पूर्वनिर्धारित सेटिंग्ज ठरवायची आणि त्यांना कोणती सेटिंग्ज बदलता येतील यावर मर्यादा घालायची इच्छा असू शकते. स्तरित संरचना आणि व्यवस्थापित आवश्यकतांद्वारे Codex या दोन्ही गोष्टींना समर्थन देते.

संरचनेचा प्राधान्यक्रम,⁠(नवीन विंडोमध्ये उघडेल) या विभागात सांगितल्याप्रमाणे, Codex अनेक config.toml फाइल्समधील सेटिंग्ज एकत्र करते. तक्ते सर्व उपस्तरांवर एकत्र केले जातात. मूल्यांत विरोध असल्यास अधिक प्राधान्याच्या स्रोताचे मूल्य स्वीकारले जाते. अॅरे मात्र संपूर्णपणे बदलले जातात.

म्हणूनच परवानगी प्रोफाइलमध्ये फाइल प्रणालीचे पथ आणि नेटवर्क डोमेनसाठी तक्ते वापरले जातात. एखादा संघ स्वतःच्या संरचनेत स्वतंत्र नोंदी जोडू किंवा बदलू शकतो. संस्थेच्या मूळ संरचनेतील इतर सर्व नोंदींमधील बदल त्याला आपोआप वारशाने मिळतात:

TOML

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

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

वापरकर्त्यांच्या संरचना पर्यायांवर मर्यादा घालण्यासाठी प्रशासक requirements.toml द्वारे व्यवस्थापित आवश्यकता⁠(नवीन विंडोमध्ये उघडेल) देखील पुरवू शकतात. या आवश्यकता प्रणाली फाइल्स आणि क्लाउडमधून मिळणारे धोरण यांसह अनेक स्रोतांतून येऊ शकतात. उद्योगातील वापरकर्ता कोणती परवानगी प्रोफाइल निवडू शकतो ते मर्यादित करण्यासाठी allowed_permission_profiles निर्दिष्ट करणे हा एक सामान्य उपयोग आहे. उदाहरणार्थ, प्रशासक पुढील क्लाउड आवश्यकता निर्दिष्ट करू शकतो:

TOML

1
default_permissions = ":read-only"
2

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

क्लाउडमधील आवश्यकतांना /etc/codex/requirements.toml या प्रणाली आवश्यकता फाइलपेक्षा प्राधान्य मिळेल. त्यामुळे त्या फाइलमधील नोंद वर स्पष्टपणे दिलेले ":danger-full-access" = false बदलू शकत नाही. :workspace निर्दिष्ट न केल्यास, आवश्यकतांच्या दुसऱ्या स्तरातून ती नोंद पुरवता येते. अंतिम एकत्रित तक्त्यात ज्या प्रोफाइलच्या नोंदी false आहेत किंवा अनुपस्थित आहेत, ती प्रोफाइल उपलब्ध नसतात.

या विभाजनामुळे संस्था मर्यादा लागू करू शकतात आणि वापरकर्ते त्या मर्यादांमध्ये आपली संरचना बदलू शकतात. यातून मिळालेली परवानगी प्रोफाइल हार्नेस वापरू शकते किंवा थेट कमांडला लागू करता येतात. पुढे तेच पाहू.

codex sandbox कमांड वापरणे

Codex च्या संरचनेत परिभाषित परवानगी प्रोफाइलअंतर्गत कोणतीही कमांड सहज चालवण्यासाठी Codex CLI मध्ये sandbox कमांड उपलब्ध आहे. प्रोफाइलची चाचणी करण्यासाठी हे सामान्यतः वापरले जाते. ज्या वर्तनाला रोखण्यासाठी सँडबॉक्स बनवला आहे, ते तो खरोखर रोखतो याची खात्री करता येते.

उदाहरणार्थ, पुढील कमांड फाइल जतन करताना दुर्भावनापूर्ण स्वयंचलित स्वरूपक चालवण्यासाठी VS Code ची संरचना बदलण्याचा प्रयत्न करते. .vscode आधीपासून अस्तित्वात असल्यास, वर दिलेल्या dev प्रोफाइलने हे लेखन रोखले पाहिजे, कारण ती निर्देशिका केवळ-वाचन आहे (codex sandbox पूर्वनिर्धारितपणे cwd ला कार्यक्षेत्राची मूळ निर्देशिका मानते):

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 वर हे अयशस्वी होते आणि पुढील संदेश मिळतो:

साधा मजकूर

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

codex sandbox कमांड Codex ची सँडबॉक्सिंग यंत्रणा एजंट सत्राशिवायही उपलब्ध करून देते. तुमच्या स्वतःच्या साधनांनी सुरू केलेल्या कमांडवर निर्बंध घालण्यासाठी तीच संरचना भाषा आणि प्लॅटफॉर्म-विशिष्ट अंमलबजावणी वापरता येते.

उदाहरण: MCP सर्व्हरला सँडबॉक्समध्ये चालवणे

config.toml मध्ये संरचित stdio MCP सर्व्हरसाठी, सर्व्हर सुरू करणारी कमांड सँडबॉक्समध्ये चालवण्याचा प्रयत्न Codex हार्नेस करत नाही. त्या सर्व्हरला कोणत्या फाइल्स किंवा नेटवर्क सेवा लागतील हे Codex विश्वासार्हपणे ठरवू शकत नाही. त्यामुळे पूर्वनिर्धारित सँडबॉक्स प्रोफाइल लागू केल्याने अन्यथा वैध असलेली संरचना बिघडू शकते.

उदाहरणार्थ, Codex सोबत वापरण्यासाठी @modelcontextprotocol/server-memory⁠(नवीन विंडोमध्ये उघडेल) MCP सर्व्हरची संरचना करण्याची प्रमाणित पद्धत अशी आहे:

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"

ही npx कमांड सँडबॉक्सबाहेर चालत असल्याने, Codex चालवणाऱ्या वापरकर्त्याइतक्याच परवानग्यांनी ती फाइल्स लिहू शकते आणि नेटवर्क विनंत्या करू शकते. या परवानग्या गरजेपेक्षा जास्त आहेत. तिच्यावर निर्बंध घालण्यासाठी, memory-mcp नावाचे परवानगी प्रोफाइल ठरवून मूळ npx कमांड codex sandbox --permission-profile memory-mcp द्वारे चालवू शकतो. यामुळे सर्व्हर कुठे लिहू शकतो यावर मर्यादा येते आणि त्याचा नेटवर्क प्रवेश रोखता येतो:

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"

सर्व्हर सुरू करण्यापूर्वी, त्याची डेटा निर्देशिका तयार करा आणि निश्चित आवृत्तीचे पॅकेज npm कॅशेमध्ये भरा. त्यामुळे नेटवर्क प्रवेश बंद करणाऱ्या प्रोफाइलअंतर्गत npx --offline सर्व्हर सुरू करू शकते:

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

पॅकेज कॅशेमध्ये आल्यावर, Codex नेटवर्क प्रवेशाशिवाय मेमरी सर्व्हर सुरू करू शकते. लेखन केवळ npm कॅशे आणि सर्व्हरच्या डेटा निर्देशिकेपुरते मर्यादित राहते.

Codex सँडबॉक्सची अंमलबजावणी

सँडबॉक्सची अंमलबजावणी परवानगी प्रोफाइलचे रूपांतर कार्यप्रणाली लागू करेल अशा निर्बंधांत करते. नेटवर्क प्रॉक्सीचे मूलभूत विनंती हाताळणी व धोरण तर्क तिन्ही प्रमुख कार्यप्रणालींवर सामायिक आहेत. मात्र प्रॉक्सीची उभारणी आणि सँडबॉक्सशी एकत्रीकरण कार्यप्रणालीनुसार वेगळे असते. प्रथम सामायिक प्रॉक्सी पाहू, त्यानंतर macOS, Linux आणि Windows वरील अंमलबजावणी पाहू.

नेटवर्क प्रॉक्सी

परवानगी प्रोफाइलचे नेटवर्क निर्बंध लागू करण्यासाठी हार्नेस नेटवर्क प्रॉक्सी सुरू करते. सँडबॉक्सची संरचना अशी करते की त्या प्रॉक्सीशी जोडणी करता येईल, पण बाह्य होस्टशी थेट जोडणी करता येणार नाही. प्रत्येक विनंती पुढे पाठवायची की नाही हे ठरवण्यासाठी प्रॉक्सी ती प्रोफाइलच्या डोमेन नियमांनुसार तपासते.

Codex रिपॉझिटरीमध्ये नेटवर्क प्रॉक्सीची अंमलबजावणी codex-network-proxy⁠(नवीन विंडोमध्ये उघडेल) क्रेटमध्ये आहे. हार्नेस ते लायब्ररी म्हणून वापरते, पण ते स्वतंत्र CLI⁠(नवीन विंडोमध्ये उघडेल) म्हणूनही तयार करता येते. सक्षम केल्यावर, codex-network-proxy पूर्वनिर्धारितपणे HTTP प्रॉक्सी आणि SOCKS5 प्रॉक्सी दोन्ही सुरू करते. हे प्रॉक्सी पत्ते सँडबॉक्सने सुरू केलेल्या प्रक्रियेला पर्यावरण चलांद्वारे कळवले जातात. HTTP_PROXY, HTTPS_PROXY आणि ALL_PROXY यांसारख्या प्रमाणित पर्यावरण चलांसोबतच, PIP_PROXY सारखी अनेक परिचित ॲप्लिकेशन-विशिष्ट पर्यावरण चले⁠(नवीन विंडोमध्ये उघडेल) देखील समाविष्ट केली जातात. अर्थात, सर्व प्रोग्राम या पर्यावरण चलांचे पालन करत नाहीत. प्रोग्रामने बाह्य होस्टशी थेट जोडणीचा प्रयत्न केल्यास, कार्यप्रणालीचे सँडबॉक्स निर्बंध तो रोखतात. याचे वर्णन खालील प्लॅटफॉर्म-विशिष्ट विभागांत आहे.

परवानगी प्रोफाइलमध्ये ठरवलेले नेटवर्क निर्बंध लागू करण्याची जबाबदारी नेटवर्क प्रॉक्सीची असते. उदाहरणार्थ, आधी दाखवलेले dev प्रोफाइल *.openai.com वरील विनंत्यांना परवानगी देते आणि evil.example वरील विनंत्या स्पष्टपणे नाकारते. विनंतीचा डोमेन कोणत्याही परवानगी किंवा नकार नियमाशी जुळत नसल्यास, प्रॉक्सी ती विनंती थांबवून मंजुरीसाठी हार्नेसकडे पाठवू शकते. शेल कमांडच्या उदाहरणाप्रमाणे, Codex थेट वापरकर्त्याला विचारू शकते किंवा विनंती स्वयंचलित पुनरावलोकनाकडे⁠(नवीन विंडोमध्ये उघडेल) पाठवू शकते. निर्णय मिळाल्यावर, प्रॉक्सी विनंती पुढे जाऊ देते किंवा त्रुटी प्रतिसाद देऊन नाकारते.

इथे क्रम महत्त्वाचा आहे, कारण DNS शोधातूनही होस्टनावात सांकेतिक स्वरूपात ठेवलेली माहिती उघड होऊ शकते. म्हणूनच प्रॉक्सी विनंतीला परवानगी किंवा मंजुरी असल्याचे ठरवल्यानंतरच होस्टनावाचा पत्ता शोधते. लक्षात घ्या: व्यापक वाइल्डकार्ड नियम किंवा DNS सेवांचा प्रवेश यांमुळे DNS द्वारे डेटा चोरून बाहेर पाठवणे तरीही शक्य होऊ शकते.

macOS

macOS वर Codex Seatbelt⁠(नवीन विंडोमध्ये उघडेल) वापरते. ही Apple ची कर्नलद्वारे लागू होणारी सँडबॉक्सिंग यंत्रणा आहे. Seatbelt ची धोरणे Sandbox Profile Language (SBPL) मध्ये लिहिली जातात. सँडबॉक्सचे निर्बंध व्यक्त करण्यासाठी ही Scheme-आधारित भाषा आहे. Codex macOS च्या /usr/bin/sandbox-exec कमांडद्वारे Seatbelt चालवते. codex sandbox प्रमाणेच, ती सँडबॉक्सचे वर्णन करणारे पर्याय आणि त्यानंतर चालवायची कमांड स्वीकारते:

Bash

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

PROFILE ही SBPL स्ट्रिंग असते. त्यात सँडबॉक्सची संरचना ठरवणाऱ्या नोंदी असतात. उदाहरणार्थ, पुढील SBPL तुकडा सँडबॉक्स धोरणात /dev/null आणि /dev/zero यांना वाचन व लेखनाची परवानगी देतो:

Scheme

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

सँडबॉक्स सुरू करताना नेटवर्क प्रॉक्सी सक्षम असल्यास, जोडण्या योग्य स्थानिक पोर्टपुरत्या मर्यादित करण्यासाठी पुढील प्रकारचे नियम प्रोफाइलमध्ये समाविष्ट केले जातात:

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 चे मूळ प्रोफाइल
(deny default) ने सुरू होते. त्यामुळे स्पष्ट परवानगी नसल्यास बाहेर जाणाऱ्या जोडण्या बंदच राहतात.

शेवटी, SBPL मध्ये (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)))

त्यांची मूल्ये sandbox-exec ला दिलेल्या -Dkey=value पर्यायांतून भरली जातात.

स्वतःच्या सँडबॉक्स API ची अंमलबजावणी करण्यासाठी, Codex मूळ धोरणापासून⁠(नवीन विंडोमध्ये उघडेल) सुरुवात करून sandbox-exec साठी आर्ग्युमेंटची यादी तयार करते⁠(नवीन विंडोमध्ये उघडेल). मग permission_profile व इतर संदर्भ वापरून बदल करते आणि संपूर्ण Seatbelt प्रोफाइल तयार करते. तयार झालेले प्रोफाइल आणि सोबतचे -D आर्ग्युमेंट Seatbelt ने लागू करायचे निर्बंध ठरवतात. नेटवर्क प्रॉक्सी अतिरिक्त नेटवर्क नियम लागू करते. आर्ग्युमेंटची संपूर्ण यादी तयार झाल्यावर, sandbox-exec चालवणे सोपे असते.

अचूक SBPL तयार करणे आव्हानात्मक आहे, कारण Apple या भाषेचे तृतीय-पक्ष वापरासाठी दस्तऐवजीकरण करत नाही. खरे तर, man sandbox-exec मध्ये The sandbox-exec command is DEPRECATED असे म्हटले आहे (man 3 sandbox_init मध्ये वर्णन केलेले sandbox_init() लायब्ररी फंक्शनही कालबाह्य घोषित केलेले आहे). कालबाह्यतेचा इशारा असूनही, macOS अजूनही /usr/share/sandbox मध्ये Seatbelt प्रोफाइल पुरवते. तसेच Google Chrome आणि Chromium यांसह⁠(नवीन विंडोमध्ये उघडेल) तृतीय-पक्ष सॉफ्टवेअर अजूनही Seatbelt वर अवलंबून आहे. त्यामुळे नजीकच्या भविष्यातही Seatbelt वापरत राहण्याचा आमचा मानस आहे.

Linux

Linux वर सँडबॉक्स तयार करण्यासाठी Codex bubblewrap⁠(नवीन विंडोमध्ये उघडेल) (bwrap) आणि seccomp-bpf⁠(नवीन विंडोमध्ये उघडेल) एकत्र वापरते. पहिले विलग वातावरण तयार करणारे कमांड-लाइन साधन आहे; दुसरे प्रणाली कॉल गाळणारी Linux कर्नल यंत्रणा आहे. codex-linux-sandbox नावाचा अंतर्गत सहाय्यक या उभारणीचा समन्वय करतो. macOS वरील sandbox-exec प्रमाणे, तो सँडबॉक्सची संरचना आणि त्यानंतर चालवायची कमांड स्वीकारतो:

Bash

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

फाइल प्रणालीचे विलगीकरण किंवा प्रॉक्सीद्वारे मार्गस्थ करणे आवश्यक असल्यास, codex-linux-sandbox प्रारंभिक सँडबॉक्स वातावरण तयार करण्यासाठी bwrap चालवते. त्यानंतर bwrap त्यात codex-linux-sandbox --apply-seccomp-then-exec सुरू करते. या दुसऱ्या आवाहनात वापरकर्त्याची कमांड चालवण्यापूर्वी seccomp-bpf द्वारे अतिरिक्त निर्बंध लागू केले जातात.

प्रारंभिक सँडबॉक्स वातावरण तयार करण्यासाठी Codex bubblewrap वापरते. ते स्वतंत्र माउंट नामावकाशात परवानगी प्रोफाइलच्या नियमांनुसार फाइल प्रणालीचे दृश्य तयार करते. सँडबॉक्सच्या अंमलबजावणीचा हा पाया असल्याने, वापरकर्त्याने bwrap स्थापित केलेले नसल्यास वापरण्यासाठी Codex त्याची स्वतःची प्रत सोबत देते. मात्र PATH वर उपलब्ध असल्यास bwrap⁠(नवीन विंडोमध्ये उघडेल) च्या सुसंगत स्थापनेला प्राधान्य देते⁠(नवीन विंडोमध्ये उघडेल). प्रत्यक्ष अनुभवात, काही Linux वितरणे वापरकर्ता नामावकाशांचा प्रवेश पूर्वनिर्धारितपणे बंद करतात⁠(नवीन विंडोमध्ये उघडेल), पण प्रणालीतील bwrap साठी अपवाद करतात.

sandbox-exec प्रमाणेच, bwrap सँडबॉक्सची संरचना आणि त्यानंतर सँडबॉक्समध्ये चालवायची कमांड स्वीकारते. SBPL सारखी खास संरचना भाषा वापरण्याऐवजी, bwrap संरचनेसाठी स्वतंत्र फ्लॅग वापरते. फाइल प्रणालीचे दृश्य तयार करण्यासाठी Codex पुढील पर्याय वापरते:

  • लेखन करता येणारी फाइल किंवा निर्देशिका निर्दिष्ट करण्यासाठी --bind

  • केवळ-वाचन फाइल किंवा निर्देशिका निर्दिष्ट करण्यासाठी --ro-bind

  • DIR चा प्रवेश नाकारण्यासाठी --perms 000 --tmpfs DIR --remount-ro DIR

  • FILE चा प्रवेश नाकारण्यासाठी --perms 000 --ro-bind-data FD FILE (इथे FD हा /dev/null साठी उघडा फाइल डिस्क्रिप्टर आहे)

या पर्यायांद्वारे प्रवेश नाकारणारे ग्लॉब लागू करण्यासाठी Codex प्रत्येक कमांड सुरू करण्यापूर्वी त्यांचे ठोस पथांत रूपांतर करते. नव्याने जुळणारे पथ त्या कमांडच्या सँडबॉक्स निर्बंधांत आपोआप जोडले जात नाहीत.

होस्टवरील इतर प्रकारच्या संसाधनांचा सँडबॉक्सला प्रवेश मिळू नये म्हणून Codex --unshare-ipc आणि --unshare-pid सारखे पर्यायही देते. त्यामुळे bubblewrap चा परिणाम फक्त फाइल्स दिसण्यापुरता मर्यादित नसतो.

bubblewrap वापरताना, नेटवर्क बंद असेल किंवा जोडण्या नेटवर्क प्रॉक्सीमार्फतच करायच्या असतील तेव्हा Codex --unshare-net देते. यामुळे सँडबॉक्ससाठी नवा नेटवर्क नामावकाश तयार होतो. त्यानंतर कमांडला उपलब्ध नेटवर्क प्रणाली कॉल आणि सॉकेट गटांवर अतिरिक्त निर्बंध घालण्यासाठी आम्ही seccomp-bpf वापरतो.


विशेषतः, आम्ही
seccompiler क्रेट⁠(नवीन विंडोमध्ये उघडेल) वापरून हव्या असलेल्या फिल्टरनुसार BPF प्रोग्राम गतिशीलपणे संकलित करतो⁠(नवीन विंडोमध्ये उघडेल). तो सँडबॉक्समधील लाँचर प्रक्रियेला लागू करतो, जेणेकरून निर्बंध संपूर्ण प्रक्रिया-वृक्षाला वारशाने मिळतील. त्यामुळे bwrap वापरकर्त्याची कमांड थेट चालवत नाही. ते codex-linux-sandbox लाँचरला त्याचे संरचना आर्ग्युमेंट आणि त्यानंतर वापरकर्त्याची कमांड देऊन चालवते:

Bash

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

उन्नत अधिकारांशिवाय seccomp फिल्टर लागू करण्यासाठी, लाँचर Linux चा no_new_privs फ्लॅग सेट करते⁠(नवीन विंडोमध्ये उघडेल). हा फ्लॅग अपत्य प्रक्रियांना वारशाने मिळतो. त्यामुळे setuid कार्यान्वयनीय प्रोग्रामसारखा दुसरा प्रोग्राम चालवताना त्यांना अतिरिक्त अधिकार मिळत नाहीत.

seccomp फिल्टर नेटवर्कच्या संरचनेवर अवलंबून असतात. नेटवर्क प्रवेश बंद असल्यास, आम्ही connect(2) आणि bind(2) यांसारखे अनेक नेटवर्क-संबंधित प्रणाली कॉल रोखतो. मात्र सँडबॉक्समध्ये नेटवर्क प्रॉक्सी सक्षम असल्यास, codex-linux-sandbox ने तयार केलेल्या TCP लिसनरशी संपर्क साधता यावा म्हणून IP सॉकेटना परवानगी देतो. पण स्वतंत्र Unix डोमेन सॉकेटची निर्मिती पूर्वनिर्धारितपणे रोखतो, कारण त्यांमुळे होस्टवरील संसाधनांचा अनवधानाने प्रवेश मिळू शकतो.

नेटवर्क प्रॉक्सीशी जोडणी

सँडबॉक्सच्या संरचनेनुसार नेटवर्क प्रॉक्सीची गरज असेल, तेव्हा Codex हार्नेस प्रॉक्सीचा एक घटक सुरू करते. त्याच Codex थ्रेडमध्ये codex-linux-sandbox अनेकदा चालवताना त्याचा पुनर्वापर करता येतो. प्रत्येक सँडबॉक्सला स्वतःच्या विलग नेटवर्क नामावकाशातून त्या सामायिक प्रॉक्सीपर्यंत पोहोचण्याचा मार्ग हवा असतो. Codex त्या नामावकाशात लूपबॅक TCP लिसनर उपलब्ध करते. सँडबॉक्सबाहेरील प्रक्रिया त्याच्या जोडण्या स्वीकारून प्रॉक्सीकडे पाठवेल अशी व्यवस्था करते.

पुढील आकृत्या एका प्रॉक्सी एंडपॉइंटसाठी ही मांडणी दाखवतात. शेवटच्या आकृतीत त्यातून जाणारी एक जोडणी दाखवली आहे. bubblewrap सुरू करण्यापूर्वी, codex-linux-sandbox नियंत्रण वाहिनी म्हणून Unix सॉकेटची जोडी तयार करते आणि स्वतःला फोर्क करते. अपत्य प्रक्रिया run_host_bridge() चालवते आणि त्या वाहिनीवरून लिसनरचा फाइल डिस्क्रिप्टर मिळण्याची वाट पाहते:

Codex हार्नेस codex-linux-sandbox सुरू करत असल्याची आकृती. ते फोर्क करून Unix सॉकेट नियंत्रण वाहिनीने जोडलेली रिले प्रक्रिया तयार करते.

या उदाहरणात पालक प्रक्रिया exec वापरून स्वतःच्या प्रोग्राम प्रतिमेच्या जागी bwrap आणते. यामुळे सँडबॉक्स उभारला जातो आणि त्यात codex-linux-sandbox --apply-seccomp-then-exec सुरू होते. नियंत्रण वाहिनीचा FD ही पुढे दिला जातो:

bwrap सँडबॉक्सचा नेटवर्क नामावकाश तयार करून त्यात codex-linux-sandbox सुरू करत असल्याची आकृती. Unix सॉकेट नियंत्रण वाहिनी त्याला सँडबॉक्सबाहेरील रिले प्रक्रियेशी जोडते.

सँडबॉक्सच्या नेटवर्क नामावकाशात दुसऱ्यांदा चालवलेले codex-linux-sandbox लूपबॅक TCP लिसनर तयार करते आणि त्याचा फाइल डिस्क्रिप्टर सॉकेटद्वारे पाठवते. लिसनर सँडबॉक्सच्या नेटवर्क नामावकाशाशीच संबंधित राहतो. त्यामुळे सँडबॉक्सबाहेर राहिलेली अपत्य प्रक्रिया सँडबॉक्समधील प्रोग्रामच्या जोडण्या स्वीकारू शकते आणि स्वतःच्या पुढील जोडण्या होस्टच्या नेटवर्क नामावकाशात उघडू शकते. हस्तांतरणानंतर दोन्ही प्रक्रिया आपले नियंत्रण-वाहिनी डिस्क्रिप्टर बंद करतात. सँडबॉक्समधील प्रक्रिया लिसनरची स्वतःकडील प्रतही बंद करते.

TCP लिसनर तयार झाल्यावर, सँडबॉक्समधील प्रक्रिया त्या लिसनरकडे निर्देश करण्यासाठी HTTP_PROXY साठी योग्य मूल्य सेट करते⁠(नवीन विंडोमध्ये उघडेल) आणि संबंधित पर्यावरण चलांचीही मूल्ये सेट करते. त्यानंतर, फोर्क करून वापरकर्त्याची कमांड चालवण्यापूर्वी ती seccomp लागू करते:

सँडबॉक्समधील प्रोग्राम लूपबॅक TCP लिसनरशी जोडत असल्याची आकृती. बाहेरील codex-linux-sandbox रिले ही वाहतूक Codex नेटवर्क प्रॉक्सीकडे पाठवते.

सँडबॉक्सबाहेरील प्रक्रिया लिसनर उघडा ठेवते. प्रत्येक स्वीकारलेल्या जोडणीसाठी ती निर्धारित प्रॉक्सीशी जोडणी उघडते आणि दोन्ही दिशांनी डेटा पाठवते.

या अतिरिक्त यंत्रणेमुळे कमांडला स्वतंत्र लूपबॅक इंटरफेससह स्वतःचा नेटवर्क नामावकाश मिळतो. macOS वर, Seatbelt कमांडला होस्टच्या लूपबॅक इंटरफेसवरील निर्दिष्ट पोर्टशी थेट जोडणी करू देते. Linux वर मात्र कमांड स्वतःच्या विलग नामावकाशातील लिसनरशी जोडते आणि सँडबॉक्सबाहेरील प्रक्रिया त्या जोडण्या निर्धारित प्रॉक्सीकडे पाठवते. डिस्क्रिप्टरच्या हस्तांतरणामुळे होस्टचा नेटवर्क नामावकाश कमांडला उपलब्ध न करताही ही जोडणी शक्य होते.

Windows

या वर्षाच्या सुरुवातीला आम्ही Windows वर सँडबॉक्सिंगची अंमलबजावणी केली आणि या प्रयत्नांबद्दल लिहिले. त्यानंतर Microsoft ने Windows कार्यप्रणालीत प्रक्रिया विलगीकरणाची नवीन वैशिष्ट्ये आणि MXC नावाची लायब्ररी प्रसिद्ध केली. आम्ही सध्या आमच्या विद्यमान सँडबॉक्सऐवजी MXC लायब्ररी वापरणारा सँडबॉक्स आणत आहोत.

MXC म्हणजे काय?

MXC (Microsoft eXecution Container) ही Microsoft ची सँडबॉक्समध्ये कोड चालवणारी प्रणाली⁠(नवीन विंडोमध्ये उघडेल) आहे. ती Windows, Linux आणि macOS वरील अनेक बंदिस्तीकरण बॅकएंडना समर्थन देते. सुसंगत Windows उपकरणांवर Codex MXC-आधारित सँडबॉक्सला समर्थन देते. यात अंगभूत प्रक्रिया विलगीकरण वापरून वापरकर्त्याच्या विद्यमान वातावरणात कमांडवर निर्बंध घातले जातात.

सुरक्षा आणि वापरसुलभता सुधारण्यासाठी, तसेच विद्यमान Windows सँडबॉक्सच्या पुढील मर्यादा दूर करण्यासाठी आम्ही MXC कडे वळत आहोत:

  • सँडबॉक्स उभारण्यासाठी उन्नत/प्रशासकीय अधिकारांची गरज

  • संसाधनखाऊ/संथ ACL तपासणी आणि सेट करण्याच्या क्रिया

  • होस्ट संगणकावर कायम राहणारी सँडबॉक्सची मांडणी, ज्यात समाविष्ट आहेत

    • ACL प्रवेश नियंत्रण याद्या

    • फायरवॉलचे नियम

    • सँडबॉक्स वापरकर्ते

    • नियंत्रण स्तराच्या फाइल्स

MXC JSON संरचना स्कीमा⁠(नवीन विंडोमध्ये उघडेल) उपलब्ध करून देते. Codex MXC SDK⁠(नवीन विंडोमध्ये उघडेल) वापरून त्या स्कीमानुसार अंमलबजावणीची विनंती तयार करते. त्यात कमांड, कार्यरत निर्देशिका, वातावरण आणि परवानग्या असतात. या परवानग्यांत फाइल प्रणाली आणि नेटवर्क प्रवेशासह डेस्कटॉप व क्लिपबोर्ड यांसारख्या Windows संसाधनांचा समावेश असतो.

धोरणानुसार MXC चालवणे

सुसंगतता आणि सुरक्षा यांचा समतोल साधण्यासाठी Codex अनेक नियंत्रणांसाठी निश्चित सेटिंग्ज वापरते. ते रजिस्ट्री वाचण्यास परवानगी देते आणि सुरू होताना PowerShell ला आवश्यक असलेला Win32k व डेस्कटॉप प्रवेश कायम ठेवते. क्लिपबोर्ड प्रवेश, इनपुट घुसवणे आणि डेस्कटॉप व प्रणाली सेटिंग्जवरील नियंत्रण अक्षम केले जाते. शेवटी, पर्यायी उपाय म्हणून होस्टच्या फाइल प्रणालीच्या परवानग्या बदलण्यापासून MXC ला रोखले जाते.

Codex परवानगी प्रोफाइलमधील फाइल प्रणाली व नेटवर्कचे नियम MXC च्या संरचनेत रूपांतरित करते. आधीचे dev प्रोफाइल वापरून, पुढील गोष्टी गृहीत धरू:

  • C:\, D:\ आणि Z:\ हेच संगणकाचे स्थानिक ड्राइव्ह आहेत.

  • कार्यक्षेत्राची मूळ निर्देशिका आणि कार्यरत निर्देशिका C:\work\demo आहेत.

  • वापरकर्त्याची गृह निर्देशिका D:\Users\dev आहे, त्यामुळे ~/build-cache चा प्रत्यक्ष पथ D:\Users\dev\build-cache होतो.

  • प्रवेश नाकारणारा ग्लॉब फक्त C:\work\demo\config\dev.env आणि C:\work\demo\config\prod.env शी जुळतो.

संबंधित MXC सेटिंग्जमध्ये पुढील गोष्टी असतील:

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
}

ड्राइव्हच्या मूळ निर्देशिकेवरील प्रवेश

MXC चे फाइल प्रणाली धोरण पूर्वनिर्धारितपणे प्रवेश नाकारते. म्हणून या प्रोफाइलनुसार व्यापक वाचन शक्य करण्यासाठी Codex स्थानिक ड्राइव्हच्या मूळ निर्देशिकांना केवळ-वाचन परवानग्या देते. वापरकर्त्याच्या विद्यमान कार्यप्रणाली परवानग्यांच्या अधीन राहून या परवानग्या सर्व उपस्तरांनाही लागू होतात.

एक अपवाद: ड्राइव्हच्या मूळ निर्देशिकेवरील लेखनाच्या परवानग्या सर्व उपस्तरांना लागू होत नाहीत. म्हणून Codex त्यांत ड्राइव्हच्या थेट खालील विद्यमान घटकांचाही समावेश करते.

परस्परविरोधी परवानग्या

अधिक विशिष्ट पथांच्या परवानग्यांना वरच्या स्तरावरील परवानग्यांपेक्षा प्राधान्य मिळते. त्यामुळे केवळ-वाचन असलेल्या C:\ अंतर्गत C:\work\demo मध्ये लेखन करता येते, तर C:\work\demo\.git केवळ-वाचन राहते.

पथाची वेगवेगळी रूपे किंवा सिमलिंक/जंक्शन पर्यायी नावे एकाच पथाकडे निर्देश करत असल्यास, MXC अधिक कठोर परवानगी लागू करते: नकाराला केवळ-वाचनापेक्षा, तर केवळ-वाचनाला वाचन-लेखनापेक्षा प्राधान्य मिळते.

प्रवेश नाकारणारे ग्लॉब

MXC प्रवेश नाकारण्यासाठी फक्त ठोस पथ स्वीकारते. म्हणून सुरू करण्यापूर्वी Codex नकार ग्लॉबचे जुळणाऱ्या फाइल्स आणि निर्देशिकांत रूपांतर करते. कमांड चालू असताना ग्लॉबशी जुळणारे नवे पथ आपोआप जोडले जात नाहीत.

नेटवर्क प्रवेश

*.openai.com सारखे डोमेन नियम आधी वर्णन केलेली सामायिक Codex नेटवर्क प्रॉक्सी लागू करते. Codex ती प्रॉक्सी सँडबॉक्सबाहेर चालवते. आधी सांगितलेल्या प्रमाणित *_PROXY पर्यावरण चलांद्वारे तिचे पत्ते कमांडला देते. MXC थेट बाह्य जोडण्या रोखते, पण होस्ट-लूपबॅक जोडण्यांना परवानगी देते. त्यात प्रॉक्सीचा प्रवेशही समाविष्ट असतो. इतर स्थानिक सेवांशीही संपर्क साधता येतो.

macOS, Linux आणि Windows वर परवानगी प्रोफाइलअंतर्गत कमांड सुरू करण्यासाठी हार्नेस तोच सँडबॉक्स API वापरते. ते निर्बंध लागू करण्यासाठी आवश्यक मांडणी प्लॅटफॉर्म-विशिष्ट अंमलबजावणी हाताळते.

Codex सँडबॉक्सच्या आधारे पुढील विकास

कोड लिहिणे आणि चालवणे यामुळे एजंटना सॉफ्टवेअर विकासापलीकडील समस्याही लवचीकपणे सोडवता येतात. Codex सँडबॉक्समुळे त्यांना वापरकर्त्याच्या विद्यमान वातावरणात ही क्षमता वापरता येते, पण फाइल प्रणाली आणि नेटवर्क प्रवेशावर स्पष्ट मर्यादा असतात. हा हार्नेसमधील पुनर्वापरयोग्य मूलभूत घटक आहे. codex sandbox कमांड तो तुम्ही स्वतः तयार केलेल्या साधनांनाही उपलब्ध करून देते.

एजंट अधिक कामे हाती घेत असताना, अधिक साधने आणि वातावरणांसाठी सँडबॉक्सिंग व्यवहार्य करणे हे आमचे उद्दिष्ट आहे. यासाठी परवानग्या ठरवणे अधिक सोपे करणे आणि कार्यप्रणालीतील अधिक चांगली संरक्षणे उपलब्ध होतील तशी वापरणे आवश्यक आहे. एजंटच्या क्षमता वाढवतानाच त्यांना कशाचा प्रवेश मिळेल याचे नियंत्रण लोकांकडे ठेवणे, हे आमचे ध्येय आहे.

लेखक

OpenAI

आभार

या लेखासाठी योगदान दिल्याबद्दल डेव्हिड वीझन, चार्ली वीम्स, वियत भालोडिया आणि फोटिस चँट्झिस यांचे विशेष आभार.