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

ตามที่อธิบายไว้ในบทความ Unrolling the Codex Agent Loop harness ของ Codex มีหน้าที่เรียกใช้เครื่องมือตามคำสั่งที่โมเดลสร้างขึ้น สำหรับงานเขียนโค้ด เครื่องมือที่ใช้บ่อยที่สุดคือ เครื่องมือเชลล์ ซึ่งใช้เรียกใช้คำสั่งในลักษณะเดียวกับที่ผู้ใช้ป้อนคำสั่งผ่านเชลล์แบบโต้ตอบ เช่น Bash ในส่วนนี้เราจะเจาะลึกเครื่องมือเชลล์(เปิดในหน้าต่างใหม่) อย่าง exec_command(เปิดในหน้าต่างใหม่) ที่เรียกใช้คำสั่งเพียงครั้งเดียว(เปิดในหน้าต่างใหม่) เพื่อแสดงให้เห็นว่า harness ใช้แซนด์บ็อกซ์เพื่อบังคับใช้มาตรการป้องกันตามที่ต้องการอย่างไร
ตัวอย่างต่อไปนี้เป็นการอธิบายแบบง่ายๆ ว่า harness ของ Codex จะจัดการคำสั่งที่เรียกผ่านเครื่องมือ exec_command อย่างไร หากไม่มีการใช้แซนด์บ็อกซ์:
หากต้องการรันคำสั่งในแซนด์บ็อกซ์ harness จะเปลี่ยนจากการเรียก subprocess.Popen() เป็น spawn_command_under_sandbox() harness จะระบุโปรไฟล์สิทธิ์ และระบุพร็อกซีเครือข่ายเมื่อจำเป็น:
เครื่องมือ exec_command ยังให้โมเดลขอสิทธิ์ที่ต่างออกไปสำหรับคำสั่งแต่ละคำสั่งได้ แต่ harness จะเป็นผู้ตัดสินใจว่าจะอนุญาตหรือไม่:
เมื่อระบุ 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 ที่มีอยู่ในระบบ:
โปรไฟล์ dev เพิ่มสิทธิ์เขียนใน ~/build-cache และเพิ่มข้อจำกัดให้ไฟล์ในเวิร์กสเปซ รายการระบบไฟล์สามารถให้สิทธิ์อ่านอย่างเดียว (read) ให้สิทธิ์อ่านและเขียน (write) หรือปิดกั้นการเข้าถึงทั้งหมด (deny)
ตาราง :workspace_roots ให้คุณกำหนดกฎสำหรับพาธที่อ้างอิงจากรูทเวิร์กสเปซของโปรเจกต์ โดยค่าเริ่มต้น Codex CLI ใช้ไดเรกทอรีทำงานเป็นรูทเวิร์กสเปซเพียงแห่งเดียว ส่วนแอป ChatGPT บนเดสก์ท็อปใช้โฟลเดอร์ซอร์สโค้ดของโปรเจกต์ Codex ใช้แต่ละกฎกับทุกรูท ดังนั้นรายการ .vscode ใน dev จึงทำให้ไดเรกทอรี .vscode ใต้แต่ละรูทอ่านได้อย่างเดียว
นอกจากกฎที่กำหนดไว้เองแล้ว dev ยังได้รับการป้องกันต่อไปนี้จากโปรไฟล์ :workspace ด้วย:
การกำหนดค่าเครือข่ายสำหรับแซนด์บ็อกซ์ใน Codex มีตัวเลือกหลักๆ สามแบบ:
ปิดการเข้าถึงเครือข่ายทั้งหมด (ค่าเริ่มต้นของโปรไฟล์
:workspace)เปิดการเข้าถึงเครือข่ายโดยตรงแบบเต็มรูปแบบ (ค่าเริ่มต้นของโปรไฟล์
:danger-full-access)จำกัดการเข้าถึงเครือข่ายให้ผ่านพร็อกซี ซึ่งจะตัดสินใจว่าจะอนุญาตอะไรตามโปรไฟล์สิทธิ์
หากต้องการให้ dev เข้าถึงเครือข่ายโดยตรง ให้ตั้งค่า permissions.dev.network.enabled = true ที่ระดับบนสุดของ config.toml ค่านี้ให้สิทธิ์เข้าถึงเครือข่ายเต็มรูปแบบเมื่อปิดพร็อกซีเครือข่าย
หากต้องการจำกัด dev ให้เข้าถึงได้เฉพาะโดเมนที่กำหนด ให้เปิดพร็อกซีเครือข่ายและตั้งค่ากฎโดเมน:
กฎเกี่ยวกับโดเมนรองรับทั้งชื่อโดเมนแบบเจาะจงและรูปแบบ wildcard โดยกฎที่ระบุให้ปฏิเสธการเข้าถึงอย่างชัดเจนจะมีผลเหนือกว่ากฎที่อนุญาตให้เข้าถึง ส่วนคำขอไปยังโดเมนอื่นๆ จะต้องได้รับการอนุมัติก่อน มิฉะนั้นจะถูกบล็อก ตามที่อธิบายไว้ในหัวข้อ พร็อกซีเครือข่าย ด้านล่าง
ผู้ใช้ทั่วไปสามารถกำหนดค่าเริ่มต้นที่ใช้ร่วมกันในหลายโปรเจกต์ และปรับเปลี่ยนค่าเหล่านั้นสำหรับโปรเจกต์ที่เชื่อถือได้เป็นรายโปรเจกต์ ส่วนผู้ดูแลระบบขององค์กรก็อาจต้องการกำหนดค่าเริ่มต้นให้ผู้ใช้ในองค์กร พร้อมจำกัดว่าผู้ใช้สามารถเปลี่ยนแปลงการตั้งค่าใดได้บ้าง Codex รองรับความต้องการทั้งสองรูปแบบผ่านระบบการตั้งค่าหลายระดับและข้อกำหนดที่องค์กรสามารถควบคุมได้
ตามที่อธิบายในลำดับความสำคัญของการกำหนดค่า(เปิดในหน้าต่างใหม่) Codex จะรวมการตั้งค่าจากไฟล์ config.toml หลายไฟล์ ตารางจะถูกรวมลงไปทุกระดับ โดยใช้ค่าจากแหล่งที่มีลำดับความสำคัญสูงกว่าเมื่อค่าขัดแย้งกัน ส่วนอาร์เรย์จะถูกแทนที่ทั้งชุด
ด้วยเหตุนี้ โปรไฟล์สิทธิ์จึงใช้ตารางในการกำหนดพาธของระบบไฟล์และโดเมนเครือข่าย เพื่อให้แต่ละทีมสามารถเพิ่มหรือเปลี่ยนการตั้งค่าเฉพาะรายการในส่วนของตัวเองได้ ขณะเดียวกันก็รับการเปลี่ยนแปลงของรายการอื่นๆ ทั้งหมดจากการตั้งค่าพื้นฐานขององค์กรโดยอัตโนมัติ ดังนี้
ผู้ดูแลระบบสามารถใช้ requirements.toml กำหนดข้อจำกัดในการตั้งค่า(เปิดในหน้าต่างใหม่)ของผู้ใช้เพิ่มเติมได้ โดยข้อกำหนดอาจมาจากหลายแหล่ง เช่น ไฟล์ของระบบหรือนโยบายบนคลาวด์ ตัวอย่างการใช้งานที่พบบ่อยคือการกำหนด allowed_permission_profiles เพื่อจำกัดโปรไฟล์สิทธิ์ที่ผู้ใช้ในองค์กรสามารถเลือกได้ เช่น ผู้ดูแลระบบอาจตั้งข้อกำหนดผ่านคลาวด์ดังต่อไปนี้:
ข้อกำหนดจากระบบคลาวด์จะมีผลเหนือกว่าไฟล์ข้อกำหนดของระบบที่ /etc/codex/requirements.toml ดังนั้น การตั้งค่าในไฟล์นี้จึงไม่สามารถเปลี่ยนค่าที่กำหนดไว้อย่างชัดเจนข้างต้นว่า ":danger-full-access" = false ได้ ส่วนการไม่ระบุค่า :workspace จะเปิดให้ข้อกำหนดจากระดับอื่นเข้ามากำหนดค่านี้ได้ โปรไฟล์ที่กำหนดค่าเป็น false หรือไม่มีรายการอยู่ในตารางสุดท้ายหลังรวมข้อกำหนดทั้งหมดแล้วจะไม่สามารถใช้งานได้
การแยกการตั้งค่าในลักษณะนี้ช่วยให้องค์กรสามารถกำหนดข้อจำกัดที่ต้องปฏิบัติตาม ขณะที่ผู้ใช้ยังปรับแต่งการตั้งค่าของตัวเองได้ภายในขอบเขตดังกล่าว โดยโปรไฟล์สิทธิ์ที่ได้สามารถนำไปใช้ผ่าน harness หรือใช้กับคำสั่งโดยตรงได้ ดังที่จะอธิบายในหัวข้อถัดไป
Codex CLI มีคำสั่ง sandbox เพื่อช่วยให้รันคำสั่งใดก็ได้ภายใต้โปรไฟล์สิทธิ์ที่กำหนดไว้ในการกำหนดค่าของ Codex โดยทั่วไปจะใช้เพื่อทดสอบโปรไฟล์ ให้แน่ใจว่าแซนด์บ็อกซ์ป้องกันพฤติกรรมที่ออกแบบมาให้ปิดกั้นได้จริง
ตัวอย่างเช่น คำสั่งต่อไปนี้พยายามตั้งค่า VS Code ให้รันตัวจัดรูปแบบอัตโนมัติที่เป็นอันตรายเมื่อบันทึกไฟล์ หากมี .vscode อยู่แล้ว โปรไฟล์ dev ที่กำหนดไว้ข้างต้นควรปิดกั้นการเขียนนี้ เพราะไดเรกทอรีนั้นอ่านได้อย่างเดียว (โดยค่าเริ่มต้น codex sandbox ถือว่า cwd เป็นรูทของเวิร์กสเปซ):
เมื่อรันบน macOS ก็ล้มเหลวจริง โดยแสดงข้อความว่า:
คำสั่ง codex sandbox ทำให้ใช้กลไกแซนด์บ็อกซ์ของ Codex ได้โดยไม่ต้องมีเซสชันเอเจนต์ คุณสามารถใช้ภาษากำหนดค่าแบบเดียวกันและการบังคับใช้เฉพาะแพลตฟอร์ม เพื่อจำกัดคำสั่งที่เครื่องมือของคุณเรียกใช้
สำหรับเซิร์ฟเวอร์ MCP แบบ stdio ที่กำหนดค่าไว้ใน config.toml harness ของ Codex จะไม่พยายามจำกัดการทำงานของคำสั่งที่ใช้เริ่มเซิร์ฟเวอร์ด้วยแซนด์บ็อกซ์ เนื่องจาก Codex ไม่สามารถระบุได้อย่างแน่นอนว่าเซิร์ฟเวอร์ต้องเข้าถึงไฟล์หรือบริการเครือข่ายใดบ้าง การใช้โปรไฟล์แซนด์บ็อกซ์เริ่มต้นจึงอาจทำให้การตั้งค่าที่ถูกต้องอยู่แล้วไม่สามารถใช้งานได้
ตัวอย่างเช่น วิธีมาตรฐานในการกำหนดค่าเซิร์ฟเวอร์ MCP @modelcontextprotocol/server-memory(เปิดในหน้าต่างใหม่) เพื่อใช้กับ Codex เป็นดังนี้:
เนื่องจากคำสั่ง npx นี้รันนอกแซนด์บ็อกซ์ จึงเขียนไฟล์และส่งคำขอเครือข่ายได้ด้วยสิทธิ์เดียวกับผู้ใช้ที่รัน Codex ซึ่งเป็นการให้สิทธิ์มากเกินไป เพื่อจำกัดสิทธิ์ เราสามารถกำหนดโปรไฟล์สิทธิ์ชื่อ memory-mcp แล้วครอบคำสั่ง npx เดิมด้วย codex sandbox --permission-profile memory-mcp เพื่อจำกัดตำแหน่งที่เซิร์ฟเวอร์เขียนได้และป้องกันการเข้าถึงเครือข่าย:
ก่อนเริ่มเซิร์ฟเวอร์ ให้สร้างไดเรกทอรีข้อมูลของเซิร์ฟเวอร์ และนำแพ็กเกจเวอร์ชันที่ตรึงไว้มาเก็บในแคช npm จากนั้น npx --offline จะเปิดเซิร์ฟเวอร์ภายใต้โปรไฟล์ที่ปิดการเข้าถึงเครือข่ายได้:
เมื่อแพ็กเกจอยู่ในแคชแล้ว Codex จะเริ่มเซิร์ฟเวอร์หน่วยความจำได้โดยไม่ต้องเข้าถึงเครือข่าย และเขียนได้เฉพาะในแคช npm กับไดเรกทอรีข้อมูลของเซิร์ฟเวอร์
กลไกแซนด์บ็อกซ์แปลงโปรไฟล์สิทธิ์ให้เป็นข้อจำกัดที่ระบบปฏิบัติการบังคับใช้ ตรรกะหลักในการจัดการคำขอและนโยบายของพร็อกซีเครือข่ายใช้ร่วมกันทั้งสามระบบปฏิบัติการหลัก ส่วนการตั้งค่าพร็อกซีและการผสานกับแซนด์บ็อกซ์จะแตกต่างกันตาม 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 นั้น Codex ใช้ Seatbelt(เปิดในหน้าต่างใหม่) ซึ่งเป็นกลไกแซนด์บ็อกซ์ของ Apple ที่บังคับใช้ในระดับเคอร์เนล นโยบาย Seatbelt เขียนด้วย Sandbox Profile Language (SBPL) ซึ่งเป็นภาษาที่อิงจากสคีมาสำหรับระบุข้อจำกัดของแซนด์บ็อกซ์ Codex เรียกใช้ Seatbelt ผ่านคำสั่ง /usr/bin/sandbox-exec ของ macOS เช่นเดียวกับ codex sandbox คำสั่งนี้รับตัวเลือกที่ระบุรายละเอียดแซนด์บ็อกซ์ ตามด้วยคำสั่งที่จะรัน:
PROFILE เป็นสตริงที่เขียนด้วยภาษา SBPL ซึ่งประกอบด้วยรายการต่างๆ สำหรับกำหนดค่าแซนด์บ็อกซ์ ตัวอย่างโค้ด SBPL ต่อไปนี้กำหนดให้สามารถอ่านและเขียนข้อมูลใน /dev/null และ /dev/zero ได้ภายใต้นโยบายของแซนด์บ็อกซ์:
เมื่อเปิดใช้พร็อกซีเครือข่ายในการเรียกใช้แซนด์บ็อกซ์ ระบบจะเพิ่มกฎลักษณะต่อไปนี้ลงในโปรไฟล์ เพื่อจำกัดให้เชื่อมต่อได้เฉพาะพอร์ตภายในเครื่องที่กำหนดไว้:
โปรไฟล์พื้นฐานของ Codex เริ่มต้นด้วย (deny default) ดังนั้น การเชื่อมต่อออกไปยังภายนอกจะยังคงถูกบล็อก เว้นแต่จะได้รับอนุญาตอย่างชัดเจน
สุดท้าย SBPL สามารถมีตัวแทนค่าโดยใช้ (param):
ซึ่งจะรับค่าจากตัวเลือก -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 นั้น Codex ใช้ bubblewrap(เปิดในหน้าต่างใหม่) (bwrap) ซึ่งเป็นเครื่องมือบรรทัดคำสั่งสำหรับสร้างสภาพแวดล้อมแยก ร่วมกับ seccomp-bpf(เปิดในหน้าต่างใหม่) ซึ่งเป็นกลไกเคอร์เนล Linux สำหรับกรอง system call ตัวช่วยภายในชื่อ codex-linux-sandbox ทำหน้าที่ประสานขั้นตอนการตั้งค่า เช่นเดียวกับ sandbox-exec บน macOS ตัวช่วยนี้รับการกำหนดค่าแซนด์บ็อกซ์ ตามด้วยคำสั่งที่จะรัน:
เมื่อต้องแยกระบบไฟล์หรือกำหนดเส้นทางผ่านพร็อกซี 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 ซึ่งทำหน้าที่เริ่มกระบวนการ โดยส่งอาร์กิวเมนต์การกำหนดค่าของตัวเองก่อน แล้วตามด้วยคำสั่งของผู้ใช้ ดังนี้
หากต้องการใช้ตัวกรอง 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 ผ่านช่องทางดังกล่าว:
ในตัวอย่างนี้ กระบวนการหลักใช้ exec เพื่อแทนที่โปรแกรมที่กำลังทำงานอยู่ด้วย bwrap จากนั้น bwrap จะตั้งค่าแซนด์บ็อกซ์และเรียกใช้ codex-linux-sandbox --apply-seccomp-then-exec ภายในแซนด์บ็อกซ์ พร้อมส่งต่อ FD ของช่องทางควบคุมไปด้วย ดังนี้
ภายใน 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 ก่อนสร้างกระบวนการลูกและเรียกใช้คำสั่งของผู้ใช้
กระบวนการที่ทำงานอยู่นอกแซนด์บ็อกซ์จะเปิด listener ค้างไว้ เมื่อมีการรับการเชื่อมต่อแต่ละครั้ง กระบวนการนี้จะสร้างการเชื่อมต่อกับพร็อกซีที่กำหนดค่าไว้ และส่งต่อข้อมูลระหว่างทั้งสองฝั่ง
กลไกที่เพิ่มเข้ามานี้ทำให้คำสั่งมีเนมสเปซเครือข่ายแยกเป็นของตัวเอง พร้อมอินเทอร์เฟซ loopback เฉพาะ บน macOS Seatbelt อนุญาตให้คำสั่งเชื่อมต่อโดยตรงกับพอร์ตที่กำหนดไว้บนอินเทอร์เฟซ loopback ของเครื่องโฮสต์ แต่บน Linux คำสั่งจะเชื่อมต่อกับ listener ที่อยู่ภายในเนมสเปซแยกต่างหาก โดยกระบวนการนอกแซนด์บ็อกซ์จะรับหน้าที่ส่งต่อการเชื่อมต่อไปยังพร็อกซีที่ตั้งค่าไว้ การส่งต่อ descriptor ช่วยให้ดำเนินการเช่นนี้ได้โดยไม่จำเป็นต้องให้คำสั่งเข้าถึงเนมสเปซเครือข่ายของเครื่องโฮสต์
เมื่อต้นปีนี้ เราได้พัฒนาและนำระบบแซนด์บ็อกซ์บน Windows มาใช้งาน พร้อมทั้งเผยแพร่บทความเกี่ยวกับการพัฒนาแซนด์บ็อกซ์บน Windows หลังจากนั้น Microsoft ได้เปิดตัวไลบรารี MXC พร้อมฟีเจอร์ใหม่สำหรับแยกกระบวนการทำงานภายในระบบปฏิบัติการ Windows ขณะนี้เรากำลังเปลี่ยนมาใช้ระบบแซนด์บ็อกซ์ใหม่ที่ใช้ไลบรารี MXC แทนระบบเดิม
MXC (Microsoft eXecution Container) เป็นระบบเรียกใช้โค้ดภายในแซนด์บ็อกซ์(เปิดในหน้าต่างใหม่)ของ Microsoft ที่รองรับกลไกแยกและจำกัดการทำงานหลายรูปแบบบน Windows, Linux และ macOS โดย Codex รองรับแซนด์บ็อกซ์ที่ใช้ MXC บนอุปกรณ์ Windows ที่เข้ากันได้ และอาศัยกลไกแยกกระบวนการทำงานที่มีอยู่ในระบบปฏิบัติการเพื่อจำกัดขอบเขตการทำงานของคำสั่งภายในสภาพแวดล้อมเดิมของผู้ใช้
เรากำลังเปลี่ยนไปใช้ MXC เพื่อเพิ่มความปลอดภัยและความสะดวกในการใช้งาน พร้อมแก้ข้อจำกัดหลายประการของแซนด์บ็อกซ์ Windows เดิม:
ต้องใช้สิทธิ์ระดับสูงหรือสิทธิ์ผู้ดูแลระบบเพื่อตั้งค่าแซนด์บ็อกซ์
การตรวจสอบและตั้งค่า ACL ใช้ทรัพยากรมากและทำงานช้า
ข้อมูลการตั้งค่าแซนด์บ็อกซ์ที่ยังคงอยู่บนเครื่องโฮสต์ ซึ่งรวมถึง
ACL
กฎไฟร์วอลล์
บัญชีผู้ใช้แซนด์บ็อกซ์
ไฟล์ส่วนควบคุม
MXC มีสคีมาสำหรับกำหนดค่าในรูปแบบ JSON(เปิดในหน้าต่างใหม่) ให้ใช้งาน โดย Codex ใช้ MXC SDK(เปิดในหน้าต่างใหม่) เพื่อสร้างคำขอเรียกใช้คำสั่งตามสคีมาดังกล่าว ซึ่งประกอบด้วยคำสั่ง ไดเรกทอรีที่ใช้ทำงาน ตัวแปรสภาพแวดล้อม และสิทธิ์การเข้าถึง โดยสิทธิ์เหล่านี้ครอบคลุมการเข้าถึงระบบไฟล์และเครือข่าย รวมถึงทรัพยากรของ Windows เช่น เดสก์ท็อปและคลิปบอร์ด
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 ที่สอดคล้องกันจะมีดังนี้:
นโยบายระบบไฟล์ของ MXC ปฏิเสธการเข้าถึงโดยค่าเริ่มต้น Codex จึงเพิ่มสิทธิ์อ่านอย่างเดียวให้รูทไดรฟ์ในเครื่อง เพื่อเปิดให้อ่านได้อย่างครอบคลุมตามที่โปรไฟล์นี้อนุญาต สิทธิ์เหล่านี้มีผลต่อเนื่องลงไปทุกระดับ โดยยังอยู่ภายใต้สิทธิ์ OS เดิมของผู้ใช้
แต่มีข้อควรระวังอย่างหนึ่งคือ สิทธิ์ในการเขียนข้อมูลที่ให้กับรูทของไดรฟ์จะไม่ครอบคลุมโฟลเดอร์และไฟล์ภายในทั้งหมดโดยอัตโนมัติ Codex จึงขยายขอบเขตสิทธิ์ให้ครอบคลุมโฟลเดอร์และไฟล์ที่อยู่ภายใต้รูทของไดรฟ์โดยตรงและมีอยู่แล้วด้วย
การกำหนดสิทธิ์ให้กับพาธที่เฉพาะเจาะจงกว่าจะมีผลเหนือกว่าสิทธิ์ที่กำหนดไว้ในโฟลเดอร์ระดับบน ดังนั้น แม้ C:\ จะอนุญาตให้อ่านข้อมูลได้อย่างเดียว แต่ C:\work\demo ก็สามารถเขียนข้อมูลได้ ขณะที่ C:\work\demo\.git ยังคงอนุญาตให้อ่านข้อมูลได้อย่างเดียว
เมื่อมีการเขียนพาธต่างรูปแบบกัน หรือใช้ symlink/junction เป็นชื่ออ้างอิงไปยังพาธเดียวกัน MXC จะใช้สิทธิ์ที่เข้มงวดที่สุด โดยการปฏิเสธการเข้าถึงมีผลเหนือกว่าสิทธิ์อ่านอย่างเดียว และสิทธิ์อ่านอย่างเดียวมีผลเหนือกว่าสิทธิ์อ่านและเขียน
MXC ไม่สามารถใช้รูปแบบ glob เพื่อบล็อกการเข้าถึงได้โดยตรง Codex จึงต้องค้นหาไฟล์และโฟลเดอร์ที่ตรงกับรูปแบบ glob แล้วนำพาธที่พบมากำหนดเป็นรายการที่ห้ามเข้าถึงก่อนเริ่มคำสั่ง หากมีไฟล์หรือโฟลเดอร์ใหม่ที่ตรงกับรูปแบบเดียวกันเกิดขึ้นระหว่างนั้น ระบบจะไม่เพิ่มพาธเหล่านี้เข้าไปในรายการที่บล็อกไว้โดยอัตโนมัติ
กฎเกี่ยวกับโดเมน เช่น *.openai.com จะถูกบังคับใช้ผ่านพร็อกซีเครือข่ายของ Codex ที่ใช้ร่วมกันตามที่อธิบายไว้ก่อนหน้านี้ โดย Codex จะเรียกใช้พร็อกซีดังกล่าวภายนอกแซนด์บ็อกซ์ และส่งที่อยู่ของพร็อกซีให้คำสั่งผ่านตัวแปรสภาพแวดล้อมมาตรฐาน *_PROXY ตามที่กล่าวถึงก่อนหน้านี้ MXC จะบล็อกการเชื่อมต่อโดยตรงกับเครือข่ายภายนอก แต่ยังอนุญาตให้เชื่อมต่อผ่าน loopback ของเครื่องโฮสต์ได้ รวมถึงการเข้าถึงพร็อกซี โดยบริการอื่นๆ ภายในเครื่องยังคงเข้าถึงได้
harness ใช้ API ของแซนด์บ็อกซ์ร่วมกันบน macOS, Linux และ Windows เพื่อเรียกใช้คำสั่งตามโปรไฟล์สิทธิ์ ส่วนการตั้งค่าที่จำเป็นสำหรับบังคับใช้ข้อจำกัดจะจัดการด้วยกลไกเฉพาะของแต่ละระบบปฏิบัติการ
ความสามารถในการเขียนและเรียกใช้โค้ดช่วยให้เอเจนต์แก้ปัญหาได้อย่างยืดหยุ่น ไม่จำกัดเฉพาะงานพัฒนาซอฟต์แวร์ แซนด์บ็อกซ์ของ Codex ช่วยให้เอเจนต์ใช้ความสามารถนี้ในสภาพแวดล้อมเดิมของผู้ใช้ได้ โดยมีข้อจำกัดด้านการเข้าถึงระบบไฟล์และเครือข่ายที่กำหนดไว้อย่างชัดเจน แซนด์บ็อกซ์นี้เป็นองค์ประกอบของ harness ที่สามารถนำกลับมาใช้ซ้ำได้ และคำสั่ง codex sandbox ยังช่วยให้นักพัฒนานำแซนด์บ็อกซ์ไปใช้กับเครื่องมือที่สร้างขึ้นเองได้ด้วย
เมื่อเอเจนต์สามารถรับผิดชอบงานได้หลากหลายมากขึ้น เราก็ต้องการให้เครื่องมือและสภาพแวดล้อมต่างๆ สามารถนำแซนด์บ็อกซ์ไปใช้งานได้จริงมากขึ้นด้วย ซึ่งหมายถึงการทำให้การกำหนดสิทธิ์เป็นเรื่องง่ายขึ้น และนำความสามารถด้านการป้องกันของระบบปฏิบัติการที่ได้รับการพัฒนาให้ดีขึ้นมาใช้เมื่อพร้อมใช้งาน เป้าหมายของเราคือขยายขีดความสามารถของเอเจนต์ โดยยังให้ผู้ใช้เป็นผู้ควบคุมว่าเอเจนต์สามารถเข้าถึงสิ่งใดได้บ้าง


