OpenAI

18 नवंबर 2026

इंजीनियरिंग

Codex सैंडबॉक्स के भीतर

Codex आपकी तय की हुई सीमाओं के भीतर आपकी मशीन पर कमांड कैसे चलाता है.

माइकल बोलिन, तकनीकी स्टाफ़ के सदस्य

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

एक ⁠(एक नई विंडो में खुलेगा)सैंडबॉक्स⁠(एक नई विंडो में खुलेगा) तय करता है कि चलते समय प्रोग्राम किन चीज़ों तक पहुँच सकता है. तस्वीरें व्यवस्थित करने के लिए, आप Codex सैंडबॉक्स को इस तरह कॉन्फ़िगर कर सकते हैं कि कमांड ~/Pictures की फ़ाइलें पढ़ और बदल सकें, लेकिन अपलोड रोकने के लिए नेटवर्क पहुँच बंद रहे. कोड की समीक्षा के लिए, आप स्रोत फ़ाइलों को केवल पढ़ने योग्य रखते हुए ऑनलाइन दस्तावेज़ों तक पहुँच दे सकते हैं. उपयोगकर्ता Codex सैंडबॉक्स को ⁠(एक नई विंडो में खुलेगा)अनुमति प्रोफ़ाइलों⁠(एक नई विंडो में खुलेगा) से कॉन्फ़िगर करते हैं. ये Codex सत्र के लिए फ़ाइल सिस्टम और नेटवर्क प्रतिबंध तय करती हैं.

इस लेख में पहले हम Codex की डिफ़ॉल्ट सैंडबॉक्स सेटिंग के पीछे के समझौतों पर चर्चा करेंगे. फिर सैंडबॉक्स की बनावट और कमांड चलाने के लिए हार्नेस द्वारा उसके उपयोग को समझाएँगे. हम बताएँगे कि उपयोगकर्ता और उद्यम अपनी ज़रूरतों के अनुसार इसकी अनुमतियाँ कैसे बदल सकते हैं और डेवलपर अपने टूल में सैंडबॉक्स का दोबारा उपयोग कैसे कर सकते हैं. अंत में, हम देखेंगे कि ये प्रतिबंध macOS, Linux और Windows पर कैसे लागू किए जाते हैं.

सैंडबॉक्स की सीमाएँ चुनना

Codex में हमारा सिद्धांत है कि सैंडबॉक्स की डिफ़ॉल्ट सेटिंग सावधानीपूर्ण हों, लेकिन उपयोगी काम में बाधा न डालें. मसलन, जब वर्कस्पेस का रूट एक Git रिपॉज़िटरी हो, तो अंतर्निहित :वर्कस्पेस अनुमति प्रोफ़ाइल:

  • वर्कस्पेस में लिखने देती है, लेकिन .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 मूल ExecCommandToolCall के कमांड आर्ग्युमेंट के साथ उचित permission_profile और network_proxy, perform_exec_command_with_sandboxing() को देगा.

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

सैंडबॉक्स कॉन्फ़िगर करना

नाम वाली अनुमति प्रोफ़ाइल से आप अलग-अलग परियोजनाओं में वही फ़ाइल सिस्टम और नेटवर्क प्रतिबंध दोबारा इस्तेमाल कर सकते हैं. आप config.toml में [permissions] के अंतर्गत अपनी प्रोफ़ाइलें तय कर सकते हैं. मसलन, नीचे 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 कमांड-लाइन इंटरफ़ेस अपनी कार्यशील डायरेक्टरी को वर्कस्पेस का एकमात्र रूट मानता है, जबकि ChatGPT डेस्कटॉप ऐप परियोजना के स्रोत फ़ोल्डर इस्तेमाल करता है. Codex हर नियम को हर रूट पर लागू करता है. इसलिए dev की .vscode प्रविष्टि हर रूट के अंतर्गत .vscode डायरेक्टरी को केवल पढ़ने योग्य बनाती है.

अपने नियमों के अलावा, dev को :वर्कस्पेस से ये सुरक्षा उपाय विरासत में मिलते हैं:

TOML

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

नेटवर्क अनुमतियाँ

Codex में सैंडबॉक्स का नेटवर्क कॉन्फ़िगर करने के मोटे तौर पर तीन विकल्प हैं:

  • सारी नेटवर्क पहुँच बंद करना (:वर्कस्पेस प्रोफ़ाइल की डिफ़ॉल्ट सेटिंग)

  • पूर्ण, सीधी नेटवर्क पहुँच चालू करना (: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 को बदल नहीं सकती. :वर्कस्पेस को अनिर्दिष्ट छोड़ने पर आवश्यकताओं की दूसरी परत वह प्रविष्टि दे सकती है. अंतिम विलय की गई तालिका में जिन प्रोफ़ाइलों की प्रविष्टियाँ false हैं या मौजूद नहीं हैं, वे उपलब्ध नहीं होतीं.

इस अलगाव से संगठन सीमाएँ लागू कर सकते हैं और उपयोगकर्ता उन्हीं सीमाओं के भीतर अपना कॉन्फ़िगरेशन बदल सकते हैं. बनी हुई अनुमति प्रोफ़ाइलों को हार्नेस इस्तेमाल कर सकता है या सीधे कमांड पर लागू किया जा सकता है, जैसा हम आगे देखेंगे.

codex sandbox कमांड का उपयोग

Codex कमांड-लाइन इंटरफ़ेस में सैंडबॉक्स कमांड मिलता है, जिससे Codex कॉन्फ़िगरेशन में तय अनुमति प्रोफ़ाइल के अंतर्गत कोई भी कमांड आसानी से चलाया जा सकता है. इसका आम उपयोग प्रोफ़ाइल को परखने के लिए होता है, ताकि सुनिश्चित हो सके कि सैंडबॉक्स वही व्यवहार रोकता है जिसे रोकने के लिए वह बनाया गया है.

मसलन, अगला कमांड 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⁠(एक नई विंडो में खुलेगा) क्रेट में लागू है. हार्नेस इसे लाइब्रेरी के रूप में इस्तेमाल करता है, हालाँकि इसे स्वतंत्र कमांड-लाइन इंटरफ़ेस⁠(एक नई विंडो में खुलेगा) के रूप में भी बनाया जा सकता है. चालू होने पर, 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 की नीतियाँ सैंडबॉक्स प्रोफ़ाइल भाषा (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 और क्रोमियम सहित⁠(एक नई विंडो में खुलेगा) तीसरे पक्ष के सॉफ़्टवेयर भी Seatbelt पर निर्भर हैं. इसलिए निकट भविष्य में हम Seatbelt का उपयोग जारी रखने की योजना रखते हैं.

Linux

Linux पर सैंडबॉक्स बनाने के लिए Codex दो चीज़ों को साथ इस्तेमाल करता है: अलग परिवेश बनाने वाला कमांड-लाइन टूल bubblewrap⁠(एक नई विंडो में खुलेगा) (bwrap), और सिस्टम कॉल फ़िल्टर करने वाला Linux कर्नेल तंत्र seccomp-bpf⁠(एक नई विंडो में खुलेगा). 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 से अलग माउंट नेमस्पेस में फ़ाइल सिस्टम का ऐसा दृश्य बनाता है जो अनुमति प्रोफ़ाइल के फ़ाइल सिस्टम नियमों के अनुरूप हो. यह सैंडबॉक्स के कार्यान्वयन का आधार है, इसलिए Codex अपने साथ bwrap की प्रति रखता है, ताकि उपयोगकर्ता को इसे स्थापित न करना पड़े. लेकिन उपलब्ध होने पर यह 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) जैसे कई नेटवर्क-संबंधी सिस्टम कॉल रोकते हैं. हालाँकि, सैंडबॉक्स में नेटवर्क प्रॉक्सी चालू होने पर हम IP सॉकेट की अनुमति देते हैं, ताकि codex-linux-sandbox के बनाए TCP लिसनर तक पहुँचा जा सके. लेकिन स्वतंत्र यूनिक्स डोमेन सॉकेट बनाना डिफ़ॉल्ट रूप से रोकते हैं, क्योंकि वे अनजाने में होस्ट के संसाधनों तक पहुँच दे सकते हैं.

नेटवर्क प्रॉक्सी से जुड़ना

जब सैंडबॉक्स कॉन्फ़िगरेशन के अनुसार नेटवर्क प्रॉक्सी चाहिए, तो Codex हार्नेस प्रॉक्सी का एक इंस्टेंस बनाता है. उसी Codex थ्रेड में codex-linux-sandbox की कई कॉल इसका दोबारा उपयोग कर सकती हैं. हर सैंडबॉक्स को अपने अलग नेटवर्क नेमस्पेस से उस साझा प्रॉक्सी तक पहुँचने का रास्ता चाहिए. Codex उस नेमस्पेस में लूपबैक TCP लिसनर देता है और सैंडबॉक्स के बाहर एक प्रक्रिया की व्यवस्था करता है, जो उसके कनेक्शन स्वीकार करके प्रॉक्सी तक पहुँचाती है.

अगले आरेख एक प्रॉक्सी एंडपॉइंट के लिए यह व्यवस्था दिखाते हैं. अंतिम आरेख में उससे होकर जाने वाला एक कनेक्शन दिखाया गया है. bubblewrap शुरू करने से पहले, codex-linux-sandbox नियंत्रण चैनल के लिए यूनिक्स सॉकेट की जोड़ी बनाता है और स्वयं को फ़ोर्क करता है. चाइल्ड प्रक्रिया run_host_bridge() चलाती है और उस चैनल से लिसनर का फ़ाइल डिस्क्रिप्टर मिलने की प्रतीक्षा करती है:

आरेख में Codex हार्नेस codex-linux-sandbox शुरू करता है, जो यूनिक्स सॉकेट नियंत्रण चैनल से जुड़ी रिले प्रक्रिया को फ़ोर्क करता है.

इस उदाहरण में, पैरेंट प्रक्रिया exec से अपनी प्रोग्राम इमेज की जगह bwrap रखती है. यह सैंडबॉक्स तैयार करके उसके भीतर codex-linux-sandbox --apply-seccomp-then-exec शुरू करता है और नियंत्रण चैनल का फ़ाइल डिस्क्रिप्टर भी आगे देता है:

आरेख में bwrap सैंडबॉक्स नेटवर्क नेमस्पेस बनाकर उसके भीतर codex-linux-sandbox शुरू करता है. यूनिक्स सॉकेट नियंत्रण चैनल इसे सैंडबॉक्स के बाहर की रिले प्रक्रिया से जोड़ता है.

सैंडबॉक्स के नेटवर्क नेमस्पेस के भीतर, 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), माइक्रोसॉफ़्ट की सैंडबॉक्स में कोड चलाने की प्रणाली⁠(एक नई विंडो में खुलेगा) है, जो Windows, Linux और macOS पर आइसोलेशन लागू करने वाले कई बैकएंड को सपोर्ट करता है. Codex, संगत Windows डिवाइस पर MXC-आधारित सैंडबॉक्स को सपोर्ट करता है. इसमें नेटिव प्रोसेस आइसोलेशन का इस्तेमाल करके उपयोगकर्ता के मौजूदा एनवायरनमेंट के भीतर कमांड को सीमित रखा जाता है.

हम सुरक्षा और उपयोग में आसानी बढ़ाने के लिए MXC अपना रहे हैं. इससे हमारे मौजूदा Windows सैंडबॉक्स की कई सीमाएँ भी दूर होंगी:

  • सैंडबॉक्स स्थापित करने के लिए उन्नत/प्रशासकीय अधिकारों की ज़रूरत

  • ACL जाँचने और तय करने में अधिक संसाधन और समय लगना

  • होस्ट मशीन पर सैंडबॉक्स की स्थापना से जुड़े बदलाव बने रहना, जिनमें शामिल हैं

    • ACLs

    • फ़ायरवॉल नियम

    • सैंडबॉक्स उपयोगकर्ता

    • नियंत्रण तंत्र की फ़ाइलें

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

आभार

इस लेख में योगदान के लिए डेविड वीज़न, चार्ली वीम्स, वियत भलोडिया और फ़ोटिस चांटज़िस का विशेष धन्यवाद.