OpenAI

18 พฤศจิกายน 2569

วิศวกรรม

เจาะลึกแซนด์บ็อกซ์ของ Codex

Codex เรียกใช้คำสั่งบนเครื่องของคุณภายใต้ขอบเขตที่คุณกำหนดได้อย่างไร

โดย Michael Bolin สมาชิกทีมเทคนิค

ที่ OpenAI เราใช้แนวทางการป้องกันหลายชั้น⁠(เปิดในหน้าต่างใหม่)เพื่อรักษาความปลอดภัยในการทำงานของเอเจนต์ แม้การลงทุนด้านการฝึกและการปรับให้สอดคล้องกับเจตนาของมนุษย์จะเป็นรากฐานของงานนี้ เรายังเพิ่มฟีเจอร์ใน harness สำหรับเอเจนต์อย่าง Codex⁠(เปิดในหน้าต่างใหม่) เพื่อเสริมการป้องกันด้วย เนื่องจากหนึ่งในงานที่ Codex ทำบ่อยที่สุด (และอาจมีความเสี่ยง) คือการรันคำสั่งบนคอมพิวเตอร์ของคุณ เราจึงสร้างแซนด์บ็อกซ์ของ Codex เพื่อให้ Codex ทำงานในสภาพแวดล้อมเดิมของคุณได้ ภายใต้ขอบเขตระบบไฟล์และเครือข่ายที่คุณควบคุม

⁠(เปิดในหน้าต่างใหม่)แซนด์บ็อกซ์⁠(เปิดในหน้าต่างใหม่)เป็นระบบที่จำกัดสิ่งที่โปรแกรมสามารถเข้าถึงได้ระหว่างทำงาน เช่น หากต้องการจัดระเบียบรูปภาพ คุณสามารถตั้งค่าแซนด์บ็อกซ์ของ Codex ให้อนุญาตให้คำสั่งอ่านและแก้ไขไฟล์ใน ~/Pictures ได้ แต่บล็อกการเข้าถึงเครือข่ายเพื่อป้องกันการอัปโหลดไฟล์ ส่วนการตรวจสอบโค้ด คุณอาจอนุญาตให้เข้าถึงเอกสารออนไลน์ได้ แต่จำกัดให้ไฟล์ซอร์สโค้ดอ่านได้อย่างเดียว ⁠(เปิดในหน้าต่างใหม่)ผู้ใช้สามารถกำหนดข้อจำกัดเหล่านี้ผ่านโปรไฟล์สิทธิ์⁠(เปิดในหน้าต่างใหม่) ซึ่งใช้กำหนดขอบเขตการเข้าถึงระบบไฟล์และเครือข่ายสำหรับแต่ละเซสชันของ Codex

บทความนี้จะเริ่มจากการอธิบายข้อดีและข้อจำกัดที่ต้องพิจารณาในการกำหนดค่าเริ่มต้นของแซนด์บ็อกซ์ใน Codex จากนั้นจะเจาะลึกการออกแบบแซนด์บ็อกซ์และวิธีที่ harness ใช้แซนด์บ็อกซ์เพื่อเรียกใช้คำสั่ง พร้อมแสดงให้เห็นว่าผู้ใช้ทั่วไปและองค์กรสามารถปรับสิทธิ์ให้เหมาะกับความต้องการได้อย่างไร รวมถึงวิธีที่นักพัฒนาสามารถนำแซนด์บ็อกซ์ไปใช้กับเครื่องมือของตนเอง ก่อนจะปิดท้ายด้วยการอธิบายว่าระบบบังคับใช้ข้อจำกัดเหล่านี้บน macOS, Linux และ Windows อย่างไร

การกำหนดขอบเขตของแซนด์บ็อกซ์

สำหรับ Codex เรามีแนวคิดในการกำหนดค่าเริ่มต้นของแซนด์บ็อกซ์ให้จำกัดสิทธิ์อย่างรัดกุม แต่ยังเปิดโอกาสให้ทำงานที่จำเป็นได้อย่างมีประสิทธิภาพ ตัวอย่างเช่น เมื่อใช้ Git repository เป็นรูทของเวิร์กสเปซ โปรไฟล์สิทธิ์ :workspace ที่มีมาให้ในระบบจะมีการตั้งค่าดังนี้

  • อนุญาตให้เขียนภายในเวิร์กสเปซ แต่กำหนดให้ไดเรกทอรี เช่น .git และ .codex อ่านได้อย่างเดียว ทำให้ Codex แก้ไขซอร์สโค้ดได้โดยไม่ต้องขออนุญาตทุกครั้ง ขณะเดียวกันก็ป้องกันการแก้ไข .codex/config.toml หรือ Git hook ใต้ .git/hooks โดยตรง

  • อนุญาตให้อ่านระบบไฟล์ได้อย่างครอบคลุม ภายใต้สิทธิ์ OS เดิมของผู้ใช้ คอมไพเลอร์ รันไทม์ และเครื่องมือบิลด์ต้องใช้ SDK ไลบรารี และการกำหนดค่าที่อยู่นอก Repository การจำกัดให้อ่านได้เฉพาะในเวิร์กสเปซจะทำให้เวิร์กโฟลว์ทั่วไปจำนวนมากใช้งานไม่ได้ สิ่งที่ต้องแลกคือไฟล์ที่มีข้อมูลละเอียดอ่อนในตำแหน่งอื่นบนเครื่องอาจยังถูกอ่านได้ด้วย (เช่น ไฟล์กำหนดค่าที่มีคีย์ API)

  • ปิดการเข้าถึงเครือข่าย เพื่อป้องกันการอัปโหลดข้อมูลไปยังบริการภายนอกโดยตรง รวมถึงความพยายามลักลอบส่งข้อมูลที่คำสั่งสามารถอ่านได้ออกไปภายนอก อย่างไรก็ตาม ข้อจำกัดนี้ยังทำให้ไม่สามารถดำเนินการบางอย่างที่จำเป็นตามปกติได้ เช่น การดาวน์โหลดแพ็กเกจที่ต้องใช้ ซึ่งจำเป็นต้องได้รับสิทธิ์เข้าถึงเพิ่มเติม

ข้อจำกัดเหล่านี้ป้องกันพฤติกรรมที่ไม่พึงประสงค์ได้หลายประเภท แต่การกระทำที่เป็นอันตรายยังคงเกิดขึ้นได้ ตัวอย่างเช่น เอเจนต์อาจแทรกโค้ดอันตรายลงในแพ็กเกจที่ติดตั้งไว้ในเครื่อง เช่น node_modules/prettier การเปลี่ยนแปลงดังกล่าวอาจไม่ปรากฏใน git status เพราะ Git มักถูกตั้งค่าให้ละเว้น node_modules หากโปรแกรมแก้ไขโค้ดของผู้ใช้รัน Prettier ชุดนั้นเมื่อบันทึกไฟล์ เพียงแค่บันทึกไฟล์ก็อาจทำให้โค้ดอันตรายรันนอกแซนด์บ็อกซ์ของ Codex ได้ นี่คือเหตุผลที่เราใช้การป้องกันหลายชั้น: แซนด์บ็อกซ์จำกัดสิ่งที่คำสั่งเข้าถึงได้ ส่วนการฝึกและการปรับให้สอดคล้องกับเจตนาของมนุษย์ช่วยให้โมเดลใช้สิทธิ์นั้นตามเจตนาของผู้ใช้

หากต้องการคำแนะนำเกี่ยวกับการปรับสิทธิ์ของแซนด์บ็อกซ์ให้เหมาะกับการใช้งาน และการใช้ร่วมกับมาตรการรักษาความปลอดภัยอื่นๆ ภายในองค์กร โปรดดูคู่มือแนวทางรักษาความปลอดภัยของ Codex⁠(เปิดในหน้าต่างใหม่)

การออกแบบแซนด์บ็อกซ์

เครื่องเสมือนและคอนเทนเนอร์⁠(เปิดในหน้าต่างใหม่)เป็นสองกลไกยอดนิยมในการสร้างแซนด์บ็อกซ์ แต่แซนด์บ็อกซ์ของ Codex ใช้แนวทางที่ต่างออกไป แทนที่จะย้ายการประมวลผลไปยังสภาพแวดล้อมแยกต่างหาก Codex ใช้กลไกแซนด์บ็อกซ์ของแต่ละแพลตฟอร์มเพื่อจำกัดคำสั่งที่รันอยู่ในสภาพแวดล้อมเดิมของผู้ใช้

สำหรับนักพัฒนาหลายคน แล็ปท็อปคือสภาพแวดล้อมการพัฒนาที่ปรับแต่งไว้เฉพาะตัว และเปลี่ยนแปลงได้ตามต้องการ การสร้างสภาพแวดล้อมนั้นขึ้นใหม่ในคอนเทนเนอร์ Docker อาจต้องใช้ความพยายาม และบางเวิร์กโฟลว์ก็ยังต้องพึ่งเครื่องมือที่รันบนโฮสต์

ตัวอย่างเช่น หากคุณใช้ Codex พัฒนาแอป iOS บน Mac แล้วเลือกใช้ Docker เพื่อแยก Codex ไว้ในแซนด์บ็อกซ์ Codex จะไม่สามารถใช้ชุดเครื่องมือสร้างแอป iOS ที่ประกอบด้วยโปรแกรมซึ่งทำงานบน Mac โดยตรงได้ และไม่สามารถเปิดโปรแกรมจำลอง iPhone เพื่อทดสอบการทำงานของโค้ดได้เช่นกัน แม้จะสามารถตั้งค่าให้ Docker ส่งงานสร้างแอปและควบคุมโปรแกรมจำลองไปทำบนเครื่อง Mac ได้ แต่การทำงานเหล่านั้นจะเกิดขึ้นนอกแซนด์บ็อกซ์ของคอนเทนเนอร์ จึงต้องมีมาตรการจำกัดการทำงานแยกต่างหาก สำหรับ Codex เราต้องการให้ระบบเรียบง่ายที่สุด จึงให้ความสำคัญกับการพัฒนาแซนด์บ็อกซ์ที่ออกแบบมาเฉพาะสำหรับแต่ละระบบปฏิบัติการ เพื่อให้ Codex ทำงานในสภาพแวดล้อมที่เหมาะสมกับงานแต่ละประเภทได้โดยตรง

harness มี API กลางสำหรับใช้งานกลไกแซนด์บ็อกซ์ของ macOS, Windows และ Linux โดยรับข้อมูลคำสั่งและโปรไฟล์สิทธิ์ หากโปรไฟล์กำหนดให้เข้าถึงเครือข่ายได้เฉพาะบางส่วน ผู้เรียกใช้ 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 handle เพื่อให้ harness ใช้รอจนกว่ากระบวนการจะทำงานเสร็จสิ้น โดยกระบวนการที่สร้างขึ้นแต่ละกระบวนการจะสืบทอดข้อจำกัดของแซนด์บ็อกซ์จากกระบวนการหลัก ทำให้ข้อจำกัดเหล่านี้มีผลกับทุกกระบวนการที่เกิดจากคำสั่งนั้น แม้กระบวนการบางส่วนจะยังทำงานต่อหลังจากกระบวนการเริ่มต้นสิ้นสุดลงแล้วก็ตาม

แผนภาพต่อไปนี้แสดงให้เห็นว่าส่วนต่างๆ ของระบบทำงานร่วมกันอย่างไร ตั้งแต่การกำหนดค่าไปจนถึงการเรียกใช้คำสั่งภายในแซนด์บ็อกซ์ โดยหัวข้อถัดไปจะอธิบายรายละเอียดของแต่ละขั้นตอน

แผนภาพแสดงลำดับการทำงาน ตั้งแต่การใช้การตั้งค่าและข้อกำหนดที่องค์กรควบคุมเพื่อกำหนดโปรไฟล์สิทธิ์สำหรับเซสชัน ไปจนถึงการที่ harness ของ Codex เรียกใช้คำสั่งภายใต้ข้อจำกัดของแซนด์บ็อกซ์ที่แตกต่างกันตามระบบปฏิบัติการ macOS, Linux หรือ Windows โดยกระบวนการที่สร้างขึ้นต่อจากนั้นจะได้รับข้อจำกัดเดียวกัน และสามารถใช้พร็อกซีเครือข่ายเพิ่มเติมเพื่อบังคับใช้กฎการเข้าถึงโดเมนได้

วิธีที่ harness ใช้ประโยชน์จากแซนด์บ็อกซ์

ตามที่อธิบายไว้ในบทความ Unrolling the Codex Agent Loop harness ของ Codex มีหน้าที่เรียกใช้เครื่องมือตามคำสั่งที่โมเดลสร้างขึ้น สำหรับงานเขียนโค้ด เครื่องมือที่ใช้บ่อยที่สุดคือ เครื่องมือเชลล์ ซึ่งใช้เรียกใช้คำสั่งในลักษณะเดียวกับที่ผู้ใช้ป้อนคำสั่งผ่านเชลล์แบบโต้ตอบ เช่น Bash ในส่วนนี้เราจะเจาะลึกเครื่องมือเชลล์⁠(เปิดในหน้าต่างใหม่) อย่าง exec_command⁠(เปิดในหน้าต่างใหม่) ที่เรียกใช้คำสั่งเพียงครั้งเดียว⁠(เปิดในหน้าต่างใหม่) เพื่อแสดงให้เห็นว่า harness ใช้แซนด์บ็อกซ์เพื่อบังคับใช้มาตรการป้องกันตามที่ต้องการอย่างไร

ตัวอย่างต่อไปนี้เป็นการอธิบายแบบง่ายๆ ว่า harness ของ 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}

หากต้องการรันคำสั่งในแซนด์บ็อกซ์ harness จะเปลี่ยนจากการเรียก subprocess.Popen() เป็น spawn_command_under_sandbox() harness จะระบุโปรไฟล์สิทธิ์ และระบุพร็อกซีเครือข่ายเมื่อจำเป็น:

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 ยังให้โมเดลขอสิทธิ์ที่ต่างออกไปสำหรับคำสั่งแต่ละคำสั่งได้ แต่ harness จะเป็นผู้ตัดสินใจว่าจะอนุญาตหรือไม่:

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 harness จะใช้การตั้งค่าแซนด์บ็อกซ์เริ่มต้นสำหรับเทิร์นนั้น ส่วน with_additional_permissions ใช้ขอสิทธิ์เข้าถึงเพิ่มเติมภายในแซนด์บ็อกซ์ ขณะที่ require_escalated ใช้ขอเรียกใช้คำสั่งภายนอกแซนด์บ็อกซ์ โดย harness จะพิจารณาคำขอตามการตั้งค่าของผู้ใช้ก่อนเรียกใช้คำสั่ง (ตัวอย่างเช่น Codex อาจขออนุมัติจากผู้ใช้โดยตรง หรือส่งคำขอไปยังระบบตรวจสอบอัตโนมัติ⁠(เปิดในหน้าต่างใหม่)) หากได้รับอนุญาตให้เรียกใช้คำสั่ง Codex จะส่ง permission_profile และ network_proxy ที่เหมาะสมให้กับ perform_exec_command_with_sandboxing() พร้อมอาร์กิวเมนต์ของคำสั่งจาก ExecCommandToolCall เดิม

เครื่องมือเชลล์ เป็นเครื่องมือหลักที่เรียกใช้ spawn_command_under_sandbox() และ harness ยังนำระบบแซนด์บ็อกซ์เดียวกันมาใช้กับการทำงานอื่นๆ เช่น การอ่านและแก้ไขไฟล์ภายในเครื่องด้วย การนำระบบนี้กลับมาใช้ไม่ได้จำกัดอยู่แค่ใน harness เท่านั้น เพราะคำสั่ง codex sandbox ยังช่วยให้คุณนำความสามารถในการเรียกใช้คำสั่งภายในแซนด์บ็อกซ์ไปใช้กับเครื่องมือที่สร้างขึ้นเองได้ด้วย ดังที่จะอธิบายในภายหลัง ต่อไปเราจะมาดูวิธีกำหนดโปรไฟล์สิทธิ์กัน

การกำหนดค่าแซนด์บ็อกซ์

การตั้งชื่อโปรไฟล์สิทธิ์ช่วยให้คุณนำข้อจำกัดในการเข้าถึงระบบไฟล์และเครือข่ายชุดเดียวกันไปใช้กับหลายโปรเจกต์ได้ โดยคุณสามารถสร้างโปรไฟล์ของตัวเองในส่วน [permissions] ของไฟล์ config.toml ตัวอย่างต่อไปนี้เป็นการสร้างโปรไฟล์ชื่อ 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 CLI ใช้ไดเรกทอรีทำงานเป็นรูทเวิร์กสเปซเพียงแห่งเดียว ส่วนแอป ChatGPT บนเดสก์ท็อปใช้โฟลเดอร์ซอร์สโค้ดของโปรเจกต์ Codex ใช้แต่ละกฎกับทุกรูท ดังนั้นรายการ .vscode ใน dev จึงทำให้ไดเรกทอรี .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 เข้าถึงเครือข่ายโดยตรง ให้ตั้งค่า permissions.dev.network.enabled = true ที่ระดับบนสุดของ config.toml ค่านี้ให้สิทธิ์เข้าถึงเครือข่ายเต็มรูปแบบเมื่อปิดพร็อกซีเครือข่าย

หากต้องการจำกัด 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

กฎเกี่ยวกับโดเมนรองรับทั้งชื่อโดเมนแบบเจาะจงและรูปแบบ wildcard โดยกฎที่ระบุให้ปฏิเสธการเข้าถึงอย่างชัดเจนจะมีผลเหนือกว่ากฎที่อนุญาตให้เข้าถึง ส่วนคำขอไปยังโดเมนอื่นๆ จะต้องได้รับการอนุมัติก่อน มิฉะนั้นจะถูกบล็อก ตามที่อธิบายไว้ในหัวข้อ พร็อกซีเครือข่าย ด้านล่าง

การกำหนดค่าหลายระดับเพื่อควบคุมและจำกัดสิทธิ์

ผู้ใช้ทั่วไปสามารถกำหนดค่าเริ่มต้นที่ใช้ร่วมกันในหลายโปรเจกต์ และปรับเปลี่ยนค่าเหล่านั้นสำหรับโปรเจกต์ที่เชื่อถือได้เป็นรายโปรเจกต์ ส่วนผู้ดูแลระบบขององค์กรก็อาจต้องการกำหนดค่าเริ่มต้นให้ผู้ใช้ในองค์กร พร้อมจำกัดว่าผู้ใช้สามารถเปลี่ยนแปลงการตั้งค่าใดได้บ้าง 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 หรือไม่มีรายการอยู่ในตารางสุดท้ายหลังรวมข้อกำหนดทั้งหมดแล้วจะไม่สามารถใช้งานได้

การแยกการตั้งค่าในลักษณะนี้ช่วยให้องค์กรสามารถกำหนดข้อจำกัดที่ต้องปฏิบัติตาม ขณะที่ผู้ใช้ยังปรับแต่งการตั้งค่าของตัวเองได้ภายในขอบเขตดังกล่าว โดยโปรไฟล์สิทธิ์ที่ได้สามารถนำไปใช้ผ่าน harness หรือใช้กับคำสั่งโดยตรงได้ ดังที่จะอธิบายในหัวข้อถัดไป

การใช้คำสั่ง codex sandbox

Codex CLI มีคำสั่ง 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 ในแซนด์บ็อกซ์

สำหรับเซิร์ฟเวอร์ MCP แบบ stdio ที่กำหนดค่าไว้ใน config.toml harness ของ Codex จะไม่พยายามจำกัดการทำงานของคำสั่งที่ใช้เริ่มเซิร์ฟเวอร์ด้วยแซนด์บ็อกซ์ เนื่องจาก Codex ไม่สามารถระบุได้อย่างแน่นอนว่าเซิร์ฟเวอร์ต้องเข้าถึงไฟล์หรือบริการเครือข่ายใดบ้าง การใช้โปรไฟล์แซนด์บ็อกซ์เริ่มต้นจึงอาจทำให้การตั้งค่าที่ถูกต้องอยู่แล้วไม่สามารถใช้งานได้

ตัวอย่างเช่น วิธีมาตรฐานในการกำหนดค่าเซิร์ฟเวอร์ MCP @modelcontextprotocol/server-memory⁠(เปิดในหน้าต่างใหม่) เพื่อใช้กับ Codex เป็นดังนี้:

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

กลไกแซนด์บ็อกซ์แปลงโปรไฟล์สิทธิ์ให้เป็นข้อจำกัดที่ระบบปฏิบัติการบังคับใช้ ตรรกะหลักในการจัดการคำขอและนโยบายของพร็อกซีเครือข่ายใช้ร่วมกันทั้งสามระบบปฏิบัติการหลัก ส่วนการตั้งค่าพร็อกซีและการผสานกับแซนด์บ็อกซ์จะแตกต่างกันตาม OS เราจะเริ่มจากพร็อกซีที่ใช้ร่วมกัน แล้วจึงดูการทำงานบน macOS, Linux และ Windows

พร็อกซีเครือข่าย

เพื่อบังคับใช้ข้อจำกัดด้านเครือข่ายตามโปรไฟล์สิทธิ์ harness จะเริ่มใช้งานพร็อกซีเครือข่ายและตั้งค่าแซนด์บ็อกซ์ให้เชื่อมต่อผ่านพร็อกซีได้ แต่บล็อกการเชื่อมต่อโดยตรงไปยังโฮสต์ภายนอก โดยพร็อกซีจะตรวจสอบคำขอแต่ละรายการตามกฎเกี่ยวกับโดเมนที่ระบุไว้ในโปรไฟล์ เพื่อตัดสินใจว่าจะส่งต่อคำขอนั้นหรือไม่

ใน Repository ของ Codex พร็อกซีเครือข่ายถูกพัฒนาขึ้นใน crate ชื่อ codex-network-proxy⁠(เปิดในหน้าต่างใหม่) ซึ่ง harness เรียกใช้ในรูปแบบไลบรารี แต่ก็สามารถสร้างเป็นเครื่องมือ CLI ที่ทำงานแยกต่างหาก⁠(เปิดในหน้าต่างใหม่)ได้เช่นกัน เมื่อเปิดใช้งาน codex-network-proxy จะเริ่มทั้งพร็อกซี HTTP และ SOCKS5 ตามค่าเริ่มต้น โดยส่งที่อยู่ของพร็อกซีเหล่านี้ไปยังกระบวนการที่แซนด์บ็อกซ์สร้างขึ้นผ่านตัวแปรสภาพแวดล้อม นอกจากตัวแปรมาตรฐานอย่าง HTTP_PROXY, HTTPS_PROXY และ ALL_PROXY แล้ว ระบบยังเพิ่มตัวแปรสภาพแวดล้อมที่ใช้เฉพาะกับแอปพลิเคชันต่างๆ⁠(เปิดในหน้าต่างใหม่) ซึ่งเป็นที่รู้จักกันทั่วไป เช่น PIP_PROXY ด้วย อย่างไรก็ตาม ไม่ใช่ทุกโปรแกรมที่จะใช้ค่าจากตัวแปรเหล่านี้ หากโปรแกรมพยายามเชื่อมต่อกับโฮสต์ภายนอกโดยตรง ข้อจำกัดของแซนด์บ็อกซ์ในระบบปฏิบัติการจะบล็อกการเชื่อมต่อนั้น ตามที่อธิบายไว้ในหัวข้อของแต่ละแพลตฟอร์มด้านล่าง

พร็อกซีเครือข่ายทำหน้าที่ควบคุมการเข้าถึงเครือข่ายตามข้อจำกัดในโปรไฟล์สิทธิ์ เช่น โปรไฟล์ dev ที่กล่าวถึงก่อนหน้านี้อนุญาตให้ส่งคำขอไปยัง *.openai.com แต่ห้ามส่งคำขอไปยัง evil.example อย่างชัดเจน หากมีคำขอไปยังโดเมนที่ไม่ตรงกับกฎอนุญาตหรือปฏิเสธการเข้าถึง พร็อกซีสามารถพักคำขอนั้นไว้ชั่วคราว แล้วส่งให้ harness พิจารณาอนุมัติ เช่นเดียวกับตัวอย่างคำสั่งเชลล์ โดย Codex อาจขออนุมัติจากผู้ใช้โดยตรง หรือส่งคำขอไปให้ระบบตรวจสอบอัตโนมัติ⁠(เปิดในหน้าต่างใหม่) เมื่อได้รับผลการพิจารณาแล้ว พร็อกซีจะอนุญาตให้ดำเนินการตามคำขอต่อ หรือปฏิเสธคำขอพร้อมส่งข้อความแสดงข้อผิดพลาดกลับไป

ลำดับขั้นตอนนี้สำคัญ เพราะแม้แต่การค้นหา DNS ก็อาจทำให้ข้อมูลที่เข้ารหัสไว้ในชื่อโฮสต์รั่วไหลได้ พร็อกซีจึงค้นหาที่อยู่จากชื่อโฮสต์ที่ร้องขอหลังจากยืนยันแล้วว่าได้รับอนุญาตหรืออนุมัติเท่านั้น โปรดทราบว่ากฎไวลด์การ์ดที่ครอบคลุมกว้างหรือการเข้าถึงบริการ DNS ยังอาจเปิดทางให้ลักลอบส่งข้อมูลออกผ่าน DNS ได้

macOS

บน macOS นั้น Codex ใช้ Seatbelt⁠(เปิดในหน้าต่างใหม่) ซึ่งเป็นกลไกแซนด์บ็อกซ์ของ Apple ที่บังคับใช้ในระดับเคอร์เนล นโยบาย Seatbelt เขียนด้วย Sandbox Profile Language (SBPL) ซึ่งเป็นภาษาที่อิงจากสคีมาสำหรับระบุข้อจำกัดของแซนด์บ็อกซ์ Codex เรียกใช้ Seatbelt ผ่านคำสั่ง /usr/bin/sandbox-exec ของ macOS เช่นเดียวกับ 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)))

ซึ่งจะรับค่าจากตัวเลือก -Dkey=value ที่ส่งให้ sandbox-exec

เพื่อให้ API แซนด์บ็อกซ์ของตัวเองทำงานได้ Codex จะสร้างรายการอาร์กิวเมนต์⁠(เปิดในหน้าต่างใหม่)สำหรับ sandbox-exec โดยเริ่มจากนโยบายพื้นฐาน⁠(เปิดในหน้าต่างใหม่) แล้วใช้ permission_profile และบริบทอื่นปรับแก้จนได้โปรไฟล์ Seatbelt ที่สมบูรณ์ โปรไฟล์ที่ได้และอาร์กิวเมนต์ -D ที่ส่งมาด้วยจะกำหนดข้อจำกัดที่ Seatbelt บังคับใช้ ส่วนพร็อกซีเครือข่ายจะบังคับใช้กฎเครือข่ายเพิ่มเติม เมื่อรวบรวมรายการอาร์กิวเมนต์ครบแล้ว การเรียก sandbox-exec ก็ทำได้ตรงไปตรงมา

การสร้าง SBPL ให้ถูกต้องเป็นเรื่องท้าทาย เนื่องจาก Apple ไม่มีเอกสารอธิบายภาษานี้สำหรับนักพัฒนาภายนอก โดยในคู่มือ man sandbox-exec ระบุไว้ชัดเจนว่า The sandbox-exec command is DEPRECATED (เช่นเดียวกับฟังก์ชัน sandbox_init() ในไลบรารี ซึ่งมีเอกสารอธิบายอยู่ใน man 3 sandbox_init) แม้จะมีคำเตือนว่าเลิกแนะนำให้ใช้งานแล้ว แต่ macOS ก็ยังมาพร้อมกับโปรไฟล์ Seatbelt ใน /usr/share/sandbox และซอฟต์แวร์จากผู้พัฒนาภายนอก เช่น Google Chrome และ Chromium⁠(เปิดในหน้าต่างใหม่) ก็ยังคงใช้ Seatbelt อยู่ ด้วยเหตุนี้ เราจึงวางแผนที่จะใช้ Seatbelt ต่อไปในอนาคตอันใกล้

Linux

ในการสร้างแซนด์บ็อกซ์บน Linux นั้น Codex ใช้ bubblewrap⁠(เปิดในหน้าต่างใหม่) (bwrap) ซึ่งเป็นเครื่องมือบรรทัดคำสั่งสำหรับสร้างสภาพแวดล้อมแยก ร่วมกับ seccomp-bpf⁠(เปิดในหน้าต่างใหม่) ซึ่งเป็นกลไกเคอร์เนล Linux สำหรับกรอง system call ตัวช่วยภายในชื่อ codex-linux-sandbox ทำหน้าที่ประสานขั้นตอนการตั้งค่า เช่นเดียวกับ sandbox-exec บน macOS ตัวช่วยนี้รับการกำหนดค่าแซนด์บ็อกซ์ ตามด้วยคำสั่งที่จะรัน:

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 เพื่อสร้างสภาพแวดล้อมเริ่มต้นของแซนด์บ็อกซ์ โดยจัดเตรียมมุมมองระบบไฟล์ใน mount namespace แยกต่างหากตามกฎที่ระบุไว้ในโปรไฟล์สิทธิ์ เนื่องจากเครื่องมือนี้จำเป็นต่อการทำงานของแซนด์บ็อกซ์ Codex จึงเตรียม bwrap ของตัวเองไว้เผื่อผู้ใช้ไม่ได้ติดตั้ง แต่จะเลือกใช้การติดตั้ง ⁠(เปิดในหน้าต่างใหม่)bwrap⁠(เปิดในหน้าต่างใหม่) ที่เข้ากันได้และพบใน PATH ก่อน จากการตรวจสอบพบว่าLinux บางดิสทริบิวชันไม่อนุญาตให้เข้าถึง user namespace ตามค่าเริ่มต้น⁠(เปิดในหน้าต่างใหม่) แต่ยกเว้นข้อจำกัดนี้ให้กับ bwrap ของระบบ

bwrap ทำงานคล้ายกับ sandbox-exec โดยรับการตั้งค่าแซนด์บ็อกซ์ก่อน แล้วตามด้วยคำสั่งที่จะเรียกใช้ภายในแซนด์บ็อกซ์ แต่ bwrap ไม่ได้ใช้ภาษากำหนดค่าเฉพาะอย่าง SBPL แต่ใช้แฟล็กแยกกันสำหรับการตั้งค่าแต่ละรายการ Codex จึงใช้ตัวเลือกต่อไปนี้เพื่อสร้างมุมมองระบบไฟล์:

  • --bind เพื่อระบุไฟล์หรือไดเรกทอรีที่เขียนได้

  • --ro-bind เพื่อระบุไฟล์หรือไดเรกทอรีที่อ่านได้อย่างเดียว

  • --perms 000 --tmpfs DIR --remount-ro DIR เพื่อปฏิเสธการเข้าถึง DIR

  • --perms 000 --ro-bind-data FD FILE เพื่อปฏิเสธการเข้าถึง FILE (โดย FD คือ file descriptor ที่เปิดไว้สำหรับ /dev/null)

Codex จะแปลงรูปแบบ glob สำหรับปฏิเสธการเข้าถึงเป็นพาธที่ตรงตามเงื่อนไขก่อนเรียกใช้แต่ละคำสั่ง เพื่อใช้กำหนดข้อจำกัดผ่านตัวเลือกเหล่านี้ โดยพาธใหม่ที่ตรงกับรูปแบบดังกล่าวจะไม่ถูกเพิ่มเข้าไปในข้อจำกัดของแซนด์บ็อกซ์สำหรับคำสั่งนั้นโดยอัตโนมัติ

Codex ยังระบุตัวเลือกอย่าง --unshare-ipc และ --unshare-pid เพื่อป้องกันแซนด์บ็อกซ์เข้าถึงทรัพยากรประเภทอื่นบนโฮสต์ ดังนั้น bubblewrap จึงควบคุมมากกว่าแค่การมองเห็นไฟล์

เมื่อใช้ bubblewrap หากมีการปิดการเข้าถึงเครือข่ายหรือกำหนดให้การเชื่อมต่อต้องผ่านพร็อกซีเครือข่าย Codex จะส่ง --unshare-net เพื่อสร้าง network namespace ใหม่สำหรับแซนด์บ็อกซ์ จากนั้นเราจะใช้ seccomp-bpf เพื่อกำหนดข้อจำกัดเพิ่มเติมเกี่ยวกับ system call สำหรับการทำงานด้านเครือข่ายและกลุ่มโปรโตคอลของซ็อกเก็ตที่คำสั่งสามารถใช้งานได้


โดยเราใช้
ไลบรารี seccompiler crate⁠(เปิดในหน้าต่างใหม่) เพื่อคอมไพล์โปรแกรม 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 โดยไม่ต้องใช้สิทธิ์ระดับสูง launcher จะตั้งค่าแฟล็ก no_new_privs ของ Linux⁠(เปิดในหน้าต่างใหม่) ซึ่งจะมีผลกับกระบวนการลูกที่สร้างขึ้นด้วย เพื่อป้องกันไม่ให้กระบวนการเหล่านั้นได้รับสิทธิ์เพิ่มขึ้นเมื่อเรียกใช้โปรแกรมอื่น เช่น โปรแกรมแบบ setuid

ตัวกรอง seccomp จะทำงานแตกต่างกันไปตามการตั้งค่าเครือข่าย เมื่อปิดการเข้าถึงเครือข่าย เราจะบล็อก syscall ที่เกี่ยวข้องกับเครือข่ายหลายรายการ เช่น connect(2) และ bind(2) แต่หากเปิดใช้พร็อกซีเครือข่ายในแซนด์บ็อกซ์ เราจะอนุญาตให้ใช้ซ็อกเก็ต IP เพื่อให้สามารถเชื่อมต่อกับ TCP listener ที่ codex-linux-sandbox สร้างขึ้นได้ ขณะเดียวกัน ระบบจะบล็อกการสร้าง Unix domain socket แบบแยกอิสระไว้เป็นค่าเริ่มต้น เพราะอาจทำให้เข้าถึงทรัพยากรบนเครื่องโฮสต์โดยไม่ตั้งใจ

การเชื่อมต่อกับพร็อกซีเครือข่าย

เมื่อการตั้งค่าแซนด์บ็อกซ์จำเป็นต้องใช้พร็อกซีเครือข่าย harness ของ Codex จะสร้างพร็อกซีขึ้นมาหนึ่งตัว ซึ่งสามารถใช้ร่วมกันในการเรียกใช้ codex-linux-sandbox หลายครั้งภายในเธรด Codex เดียวกัน โดยแซนด์บ็อกซ์แต่ละตัวต้องสามารถเชื่อมต่อกับพร็อกซีที่ใช้ร่วมกันนี้ได้จาก network namespace ที่แยกออกมา Codex จึงสร้าง TCP listener บนอินเทอร์เฟซ loopback ภายใน namespace ดังกล่าว และจัดให้มีกระบวนการภายนอกแซนด์บ็อกซ์คอยรับการเชื่อมต่อและส่งต่อไปยังพร็อกซี

แผนภาพต่อไปนี้แสดงการตั้งค่าดังกล่าวสำหรับปลายทางพร็อกซีหนึ่งแห่ง โดยแผนภาพสุดท้ายจะแสดงตัวอย่างการเชื่อมต่อหนึ่งรายการที่ผ่านพร็อกซีนี้ ก่อนเริ่มใช้งาน bubblewrap codex-linux-sandbox จะสร้าง Unix socket pair เพื่อใช้เป็นช่องทางสื่อสารสำหรับควบคุมการทำงาน แล้วแยกตัวเองออกเป็นสองกระบวนการ โดยกระบวนการลูกจะเรียกใช้ run_host_bridge() และรอรับ file descriptor ของ listener ผ่านช่องทางดังกล่าว:

แผนภาพแสดงการทำงานของ harness ใน Codex ที่เรียกใช้ codex-linux-sandbox ซึ่งจะแยกกระบวนการสำหรับส่งต่อข้อมูลออกมา โดยเชื่อมต่อกันผ่านช่องทางควบคุมที่ใช้ Unix socket

ในตัวอย่างนี้ กระบวนการหลักใช้ exec เพื่อแทนที่โปรแกรมที่กำลังทำงานอยู่ด้วย bwrap จากนั้น bwrap จะตั้งค่าแซนด์บ็อกซ์และเรียกใช้ codex-linux-sandbox --apply-seccomp-then-exec ภายในแซนด์บ็อกซ์ พร้อมส่งต่อ FD ของช่องทางควบคุมไปด้วย ดังนี้

แผนภาพแสดง bwrap สร้างเนมสเปซเครือข่ายของแซนด์บ็อกซ์และเปิด codex-linux-sandbox ภายใน โดยมีช่องทางควบคุมแบบ Unix socket เชื่อมต่อกับกระบวนการส่งต่อข้อมูลที่อยู่ภายนอกแซนด์บ็อกซ์

ภายใน network namespace ของแซนด์บ็อกซ์ การเรียกใช้ codex-linux-sandbox ครั้งที่สองจะสร้าง TCP listener บนอินเทอร์เฟซ loopback แล้วส่ง file descriptor ของ listener ผ่านซ็อกเก็ต โดย listener นี้ยังคงอยู่ใน network namespace ของแซนด์บ็อกซ์ ทำให้กระบวนการที่แยกออกมาก่อนหน้านี้และยังทำงานอยู่ภายนอกแซนด์บ็อกซ์สามารถรับการเชื่อมต่อจากโปรแกรมภายในแซนด์บ็อกซ์ได้ ขณะเดียวกันก็สามารถสร้างการเชื่อมต่อไปยังปลายทางผ่าน network namespace ของเครื่องโฮสต์ หลังจากส่งต่อ file descriptor แล้ว ทั้งสองกระบวนการจะปิด descriptor ของช่องทางควบคุม และกระบวนการภายในแซนด์บ็อกซ์จะปิด listener ในส่วนที่ตัวเองถืออยู่ด้วย

เมื่อ TCP listener พร้อมทำงาน กระบวนการภายในแซนด์บ็อกซ์จะกำหนดค่าที่เหมาะสมให้กับ HTTP_PROXY⁠(เปิดในหน้าต่างใหม่) และตัวแปรสภาพแวดล้อมอื่นๆ ที่เกี่ยวข้อง เพื่อให้ใช้ listener ดังกล่าว จากนั้นจึงบังคับใช้ seccomp ก่อนสร้างกระบวนการลูกและเรียกใช้คำสั่งของผู้ใช้

แผนภาพแสดงโปรแกรมภายในแซนด์บ็อกซ์ที่เชื่อมต่อกับ TCP listener บนอินเทอร์เฟซ loopback โดยมีกระบวนการ codex-linux-sandbox ภายนอกแซนด์บ็อกซ์ทำหน้าที่ส่งต่อข้อมูลไปยังพร็อกซีเครือข่ายของ Codex

กระบวนการที่ทำงานอยู่นอกแซนด์บ็อกซ์จะเปิด listener ค้างไว้ เมื่อมีการรับการเชื่อมต่อแต่ละครั้ง กระบวนการนี้จะสร้างการเชื่อมต่อกับพร็อกซีที่กำหนดค่าไว้ และส่งต่อข้อมูลระหว่างทั้งสองฝั่ง

กลไกที่เพิ่มเข้ามานี้ทำให้คำสั่งมีเนมสเปซเครือข่ายแยกเป็นของตัวเอง พร้อมอินเทอร์เฟซ loopback เฉพาะ บน macOS Seatbelt อนุญาตให้คำสั่งเชื่อมต่อโดยตรงกับพอร์ตที่กำหนดไว้บนอินเทอร์เฟซ loopback ของเครื่องโฮสต์ แต่บน Linux คำสั่งจะเชื่อมต่อกับ listener ที่อยู่ภายในเนมสเปซแยกต่างหาก โดยกระบวนการนอกแซนด์บ็อกซ์จะรับหน้าที่ส่งต่อการเชื่อมต่อไปยังพร็อกซีที่ตั้งค่าไว้ การส่งต่อ descriptor ช่วยให้ดำเนินการเช่นนี้ได้โดยไม่จำเป็นต้องให้คำสั่งเข้าถึงเนมสเปซเครือข่ายของเครื่องโฮสต์

Windows

เมื่อต้นปีนี้ เราได้พัฒนาและนำระบบแซนด์บ็อกซ์บน Windows มาใช้งาน พร้อมทั้งเผยแพร่บทความเกี่ยวกับการพัฒนาแซนด์บ็อกซ์บน Windows หลังจากนั้น Microsoft ได้เปิดตัวไลบรารี MXC พร้อมฟีเจอร์ใหม่สำหรับแยกกระบวนการทำงานภายในระบบปฏิบัติการ Windows ขณะนี้เรากำลังเปลี่ยนมาใช้ระบบแซนด์บ็อกซ์ใหม่ที่ใช้ไลบรารี MXC แทนระบบเดิม

MXC คืออะไร

MXC (Microsoft eXecution Container) เป็นระบบเรียกใช้โค้ดภายในแซนด์บ็อกซ์⁠(เปิดในหน้าต่างใหม่)ของ Microsoft ที่รองรับกลไกแยกและจำกัดการทำงานหลายรูปแบบบน Windows, Linux และ macOS โดย Codex รองรับแซนด์บ็อกซ์ที่ใช้ MXC บนอุปกรณ์ Windows ที่เข้ากันได้ และอาศัยกลไกแยกกระบวนการทำงานที่มีอยู่ในระบบปฏิบัติการเพื่อจำกัดขอบเขตการทำงานของคำสั่งภายในสภาพแวดล้อมเดิมของผู้ใช้

เรากำลังเปลี่ยนไปใช้ MXC เพื่อเพิ่มความปลอดภัยและความสะดวกในการใช้งาน พร้อมแก้ข้อจำกัดหลายประการของแซนด์บ็อกซ์ Windows เดิม:

  • ต้องใช้สิทธิ์ระดับสูงหรือสิทธิ์ผู้ดูแลระบบเพื่อตั้งค่าแซนด์บ็อกซ์

  • การตรวจสอบและตั้งค่า ACL ใช้ทรัพยากรมากและทำงานช้า

  • ข้อมูลการตั้งค่าแซนด์บ็อกซ์ที่ยังคงอยู่บนเครื่องโฮสต์ ซึ่งรวมถึง

    • ACL

    • กฎไฟร์วอลล์

    • บัญชีผู้ใช้แซนด์บ็อกซ์

    • ไฟล์ส่วนควบคุม

MXC มีสคีมาสำหรับกำหนดค่าในรูปแบบ JSON⁠(เปิดในหน้าต่างใหม่) ให้ใช้งาน โดย Codex ใช้ MXC SDK⁠(เปิดในหน้าต่างใหม่) เพื่อสร้างคำขอเรียกใช้คำสั่งตามสคีมาดังกล่าว ซึ่งประกอบด้วยคำสั่ง ไดเรกทอรีที่ใช้ทำงาน ตัวแปรสภาพแวดล้อม และสิทธิ์การเข้าถึง โดยสิทธิ์เหล่านี้ครอบคลุมการเข้าถึงระบบไฟล์และเครือข่าย รวมถึงทรัพยากรของ Windows เช่น เดสก์ท็อปและคลิปบอร์ด

การนำข้อกำหนดด้านนโยบายไปใช้ในการเรียกใช้งาน MXC

Codex ใช้การตั้งค่าตายตัวสำหรับการควบคุมบางส่วน เพื่อให้ระบบทำงานร่วมกันได้อย่างเหมาะสมโดยยังคงความปลอดภัย โดยอนุญาตให้อ่านรีจิสทรีและเข้าถึง Win32k รวมถึงเดสก์ท็อปที่ PowerShell ต้องใช้เมื่อเริ่มทำงาน ขณะเดียวกันก็ปิดการเข้าถึงคลิปบอร์ด การแทรกข้อมูลอินพุต และการควบคุมเดสก์ท็อปกับการตั้งค่าระบบ รวมถึงไม่อนุญาตให้ MXC ใช้วิธีแก้ไขสิทธิ์ของระบบไฟล์บนเครื่องโฮสต์เป็นทางเลือกสำรอง

Codex แปลงกฎการเข้าถึงระบบไฟล์และเครือข่ายที่กำหนดไว้ในโปรไฟล์สิทธิ์ให้อยู่ในรูปแบบการกำหนดค่าของ MXC โดยใช้โปรไฟล์ dev ที่กล่าวถึงก่อนหน้านี้เป็นตัวอย่าง และสมมติว่า

  • C:\, D:\ และ Z:\ เป็นไดรฟ์ภายในเครื่องทั้งหมดที่มีอยู่

  • รูทของเวิร์กสเปซและโฟลเดอร์ที่ใช้ทำงานอยู่ที่ C:\work\demo

  • โฮมไดเรกทอรีของผู้ใช้อยู่ที่ D:\Users\dev ดังนั้น ~/build-cache จึงหมายถึง D:\Users\dev\build-cache

  • รูปแบบ glob สำหรับปฏิเสธการเข้าถึงจะตรงกับ 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 จึงเพิ่มสิทธิ์อ่านอย่างเดียวให้รูทไดรฟ์ในเครื่อง เพื่อเปิดให้อ่านได้อย่างครอบคลุมตามที่โปรไฟล์นี้อนุญาต สิทธิ์เหล่านี้มีผลต่อเนื่องลงไปทุกระดับ โดยยังอยู่ภายใต้สิทธิ์ OS เดิมของผู้ใช้

แต่มีข้อควรระวังอย่างหนึ่งคือ สิทธิ์ในการเขียนข้อมูลที่ให้กับรูทของไดรฟ์จะไม่ครอบคลุมโฟลเดอร์และไฟล์ภายในทั้งหมดโดยอัตโนมัติ Codex จึงขยายขอบเขตสิทธิ์ให้ครอบคลุมโฟลเดอร์และไฟล์ที่อยู่ภายใต้รูทของไดรฟ์โดยตรงและมีอยู่แล้วด้วย

สิทธิ์ที่ขัดแย้งกัน

การกำหนดสิทธิ์ให้กับพาธที่เฉพาะเจาะจงกว่าจะมีผลเหนือกว่าสิทธิ์ที่กำหนดไว้ในโฟลเดอร์ระดับบน ดังนั้น แม้ C:\ จะอนุญาตให้อ่านข้อมูลได้อย่างเดียว แต่ C:\work\demo ก็สามารถเขียนข้อมูลได้ ขณะที่ C:\work\demo\.git ยังคงอนุญาตให้อ่านข้อมูลได้อย่างเดียว

เมื่อมีการเขียนพาธต่างรูปแบบกัน หรือใช้ symlink/junction เป็นชื่ออ้างอิงไปยังพาธเดียวกัน MXC จะใช้สิทธิ์ที่เข้มงวดที่สุด โดยการปฏิเสธการเข้าถึงมีผลเหนือกว่าสิทธิ์อ่านอย่างเดียว และสิทธิ์อ่านอย่างเดียวมีผลเหนือกว่าสิทธิ์อ่านและเขียน

รูปแบบ glob สำหรับปฏิเสธการเข้าถึง

MXC ไม่สามารถใช้รูปแบบ glob เพื่อบล็อกการเข้าถึงได้โดยตรง Codex จึงต้องค้นหาไฟล์และโฟลเดอร์ที่ตรงกับรูปแบบ glob แล้วนำพาธที่พบมากำหนดเป็นรายการที่ห้ามเข้าถึงก่อนเริ่มคำสั่ง หากมีไฟล์หรือโฟลเดอร์ใหม่ที่ตรงกับรูปแบบเดียวกันเกิดขึ้นระหว่างนั้น ระบบจะไม่เพิ่มพาธเหล่านี้เข้าไปในรายการที่บล็อกไว้โดยอัตโนมัติ

การเข้าถึงเครือข่าย

กฎเกี่ยวกับโดเมน เช่น *.openai.com จะถูกบังคับใช้ผ่านพร็อกซีเครือข่ายของ Codex ที่ใช้ร่วมกันตามที่อธิบายไว้ก่อนหน้านี้ โดย Codex จะเรียกใช้พร็อกซีดังกล่าวภายนอกแซนด์บ็อกซ์ และส่งที่อยู่ของพร็อกซีให้คำสั่งผ่านตัวแปรสภาพแวดล้อมมาตรฐาน *_PROXY ตามที่กล่าวถึงก่อนหน้านี้ MXC จะบล็อกการเชื่อมต่อโดยตรงกับเครือข่ายภายนอก แต่ยังอนุญาตให้เชื่อมต่อผ่าน loopback ของเครื่องโฮสต์ได้ รวมถึงการเข้าถึงพร็อกซี โดยบริการอื่นๆ ภายในเครื่องยังคงเข้าถึงได้

harness ใช้ API ของแซนด์บ็อกซ์ร่วมกันบน macOS, Linux และ Windows เพื่อเรียกใช้คำสั่งตามโปรไฟล์สิทธิ์ ส่วนการตั้งค่าที่จำเป็นสำหรับบังคับใช้ข้อจำกัดจะจัดการด้วยกลไกเฉพาะของแต่ละระบบปฏิบัติการ

ต่อยอดจากแซนด์บ็อกซ์ของ Codex

ความสามารถในการเขียนและเรียกใช้โค้ดช่วยให้เอเจนต์แก้ปัญหาได้อย่างยืดหยุ่น ไม่จำกัดเฉพาะงานพัฒนาซอฟต์แวร์ แซนด์บ็อกซ์ของ Codex ช่วยให้เอเจนต์ใช้ความสามารถนี้ในสภาพแวดล้อมเดิมของผู้ใช้ได้ โดยมีข้อจำกัดด้านการเข้าถึงระบบไฟล์และเครือข่ายที่กำหนดไว้อย่างชัดเจน แซนด์บ็อกซ์นี้เป็นองค์ประกอบของ harness ที่สามารถนำกลับมาใช้ซ้ำได้ และคำสั่ง codex sandbox ยังช่วยให้นักพัฒนานำแซนด์บ็อกซ์ไปใช้กับเครื่องมือที่สร้างขึ้นเองได้ด้วย

เมื่อเอเจนต์สามารถรับผิดชอบงานได้หลากหลายมากขึ้น เราก็ต้องการให้เครื่องมือและสภาพแวดล้อมต่างๆ สามารถนำแซนด์บ็อกซ์ไปใช้งานได้จริงมากขึ้นด้วย ซึ่งหมายถึงการทำให้การกำหนดสิทธิ์เป็นเรื่องง่ายขึ้น และนำความสามารถด้านการป้องกันของระบบปฏิบัติการที่ได้รับการพัฒนาให้ดีขึ้นมาใช้เมื่อพร้อมใช้งาน เป้าหมายของเราคือขยายขีดความสามารถของเอเจนต์ โดยยังให้ผู้ใช้เป็นผู้ควบคุมว่าเอเจนต์สามารถเข้าถึงสิ่งใดได้บ้าง

ผู้เขียน

OpenAI

กิตติกรรมประกาศ

ขอขอบคุณ David Wiesen, Charlie Weems, Viyat Bhalodia และ Fotis Chantzis เป็นอย่างสูงที่ร่วมสร้างสรรค์บทความนี้