OpenAI

18 નવેમ્બર, 2026

ઇજનેરી

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માં ચલાવીને સેન્ડબોક્સમાં રાખવાનું નક્કી કરો, તો Codex મૂળ 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] હેઠળ તમારી પોતાની પ્રોફાઇલો નિર્ધારિત કરી શકો છો. ઉદાહરણ તરીકે, નીચે dev નામની પ્રોફાઇલ નિર્ધારિત કરેલી છે, જે બિલ્ટ-ઇન :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"

dev પ્રોફાઇલ ~/build-cacheમાં લખવાનો ઍક્સેસ ઉમેરે છે અને કાર્યક્ષેત્રની ફાઇલો પર વધારાના પ્રતિબંધો મૂકે છે. ફાઇલસિસ્ટમની નોંધો માત્ર-વાંચનનો ઍક્સેસ (read) અથવા વાંચન અને લેખનનો ઍક્સેસ (write) આપી શકે છે, અથવા ઍક્સેસ સંપૂર્ણપણે રોકી શકે છે (deny).

:workspace_roots કોષ્ટકથી તમે પ્રોજેક્ટના કાર્યક્ષેત્રની મૂળ ડિરેક્ટરીઓને સાપેક્ષ પાથ માટે નિયમો નક્કી કરી શકો છો. મૂળભૂત રીતે, Codexનું આદેશ-રેખા ઇન્ટરફેસ તેની કાર્યકારી ડિરેક્ટરીને કાર્યક્ષેત્રની એકમાત્ર મૂળ ડિરેક્ટરી ગણે છે, જ્યારે 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નું આદેશ-રેખા ઇન્ટરફેસ sandbox આદેશ આપે છે, જેથી 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ની નીતિઓ 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), અને સિસ્ટમ કૉલ ફિલ્ટર કરવા માટેની 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 વડે અલગ માઉન્ટ નેમસ્પેસમાં ફાઇલસિસ્ટમનું દૃશ્ય બનાવે છે, જે પરવાનગી પ્રોફાઇલના ફાઇલસિસ્ટમ નિયમોને અનુરૂપ હોય છે. સેન્ડબોક્સના અમલીકરણમાં આ પાયાની બાબત હોવાથી, વપરાશકર્તાએ 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) જેવા અનેક નેટવર્ક-સંબંધિત સિસ્ટમ કૉલ રોકીએ છીએ. જોકે સેન્ડબોક્સમાં નેટવર્ક પ્રોક્સી ચાલુ હોય ત્યારે અમે IP સૉકેટની મંજૂરી આપીએ છીએ, જેથી codex-linux-sandboxએ બનાવેલા TCP લિસનર સુધી પહોંચી શકાય. પરંતુ સ્વતંત્ર Unix ડોમેન સૉકેટ બનાવવાનું મૂળભૂત રીતે રોકીએ છીએ, કારણ કે તેનાથી અજાણતાં યજમાનનાં સંસાધનોનો ઍક્સેસ મળી શકે.

નેટવર્ક પ્રોક્સી સાથે જોડાવું

સેન્ડબોક્સની ગોઠવણી મુજબ નેટવર્ક પ્રોક્સી જરૂરી હોય ત્યારે Codex કાર્યપ્રણાલી પ્રોક્સીનો એક ઇન્સ્ટન્સ બનાવે છે. એ જ Codex થ્રેડમાં codex-linux-sandboxના અનેક કૉલ માટે તેનો ફરી ઉપયોગ કરી શકાય છે. દરેક સેન્ડબોક્સને પોતાની અલગ નેટવર્ક નેમસ્પેસમાંથી તે સહિયારી પ્રોક્સી સુધી પહોંચવાની રીત જરૂરી છે. Codex તે નેમસ્પેસની અંદર લૂપબૅક TCP લિસનર આપે છે અને સેન્ડબોક્સની બહારની પ્રક્રિયા તેના જોડાણો સ્વીકારીને પ્રોક્સી સુધી પહોંચાડે તેવી વ્યવસ્થા કરે છે.

નીચેનાં આકૃતિઓ એક પ્રોક્સી એન્ડપોઇન્ટ માટેની આ ગોઠવણી દર્શાવે છે. છેલ્લી આકૃતિમાં તેના મારફતે થતું એક જોડાણ બતાવ્યું છે. bubblewrap શરૂ કરતાં પહેલાં, codex-linux-sandbox નિયંત્રણ ચૅનલ તરીકે Unix સૉકેટની જોડી બનાવે છે અને પોતાને ફોર્ક કરે છે. સંતાન પ્રક્રિયા run_host_bridge() ચલાવે છે અને તે ચૅનલ મારફતે લિસનરનો ફાઇલ ડિસ્ક્રિપ્ટર મળવાની રાહ જુએ છે:

Codex કાર્યપ્રણાલી codex-linux-sandbox શરૂ કરે છે, જે Unix સૉકેટ નિયંત્રણ ચૅનલથી જોડાયેલી રિલે પ્રક્રિયાને ફોર્ક કરે છે તે દર્શાવતી આકૃતિ.

આ ઉદાહરણમાં, પિતૃ પ્રક્રિયા પોતાની પ્રોગ્રામ ઇમેજને bwrapથી બદલવા exec વાપરે છે. આ સેન્ડબોક્સ ગોઠવે છે અને તેની અંદર codex-linux-sandbox --apply-seccomp-then-exec શરૂ કરે છે, સાથે નિયંત્રણ ચૅનલનો ફાઇલ ડિસ્ક્રિપ્ટર પણ આપે છે:

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

આભારવિધિ

આ લેખમાં યોગદાન આપવા બદલ ડેવિડ વિઝન, ચાર્લી વીમ્સ, વિયત ભાલોડિયા અને ફોતિસ ચાન્ત્ઝિસનો વિશેષ આભાર.