ב-OpenAI, אנחנו נוקטים גישת הגנה לעומק(נפתח בחלון חדש) בכל הנוגע לאבטחת סוכנים. ההשקעה שלנו באימון ובהתאמה לכוונות המשתמש היא נדבך יסודי במאמץ הזה, ולצדה אנחנו מממשים יכולות גם ב-harness האג'נטי שלנו, Codex(נפתח בחלון חדש), כדי לספק שכבות הגנה נוספות. הרצת פקודות במחשב שלכם היא אחת הפעולות הנפוצות ביותר של Codex — וגם פעולה שעלולה להיות מסוכנת. לכן בנינו את ארגז החול של Codex, כדי שיוכל לפעול בסביבה הקיימת שלכם במסגרת מגבלות על מערכת הקבצים והרשת שאתם שולטים בהן.
ארגז חול(נפתח בחלון חדש) (נפתח בחלון חדש)מגביל את המשאבים שתוכנית יכולה לגשת אליהם בזמן שהיא רצה. במשימה של ארגון תמונות, אפשר להגדיר את ארגז החול של Codex כך שיאפשר לפקודות לקרוא ולשנות קבצים ב-~/Pictures, ובמקביל לחסום גישה לרשת כדי למנוע העלאות. לצורך סקירת קוד, אפשר לאפשר גישה לתיעוד מקוון ולהשאיר את קובצי המקור לקריאה בלבד. משתמשים מגדירים את ארגז החול של Codex באמצעות (נפתח בחלון חדש)פרופילי הרשאות(נפתח בחלון חדש), המגדירים את ההגבלות על מערכת הקבצים והרשת עבור סשן של Codex.
במאמר הזה נתחיל בשיקולים ובפשרות שמאחורי ברירות המחדל של ארגז החול ב-Codex, ולאחר מכן נסביר את התכנון שלו ואת האופן שבו ה-harness משתמש בו להרצת פקודות. נראה איך משתמשי קצה וארגונים יכולים להתאים את ההרשאות לצורכיהם, ואיך מפתחים יכולים לשלב את ארגז החול בכלים משלהם. לבסוף נבחן איך ההגבלות האלה נאכפות ב-macOS, ב-Linux וב-Windows.
הגישה שלנו ב-Codex היא לקבוע לארגז החול ברירות מחדל שמרניות, שעדיין מאפשרות לבצע עבודה משמעותית. לדוגמה, כשמאגר Git משמש כשורש סביבת העבודה, פרופיל ההרשאות המובנה :workspace:
מאפשר כתיבה בתוך סביבת העבודה, ומשאיר תיקיות כמו
.gitו-.codexלקריאה בלבד. כך Codex יכול לערוך קוד מקור בלי לבקש רשות על כל שינוי, ובמקביל נמנעים שינויים ישירים ב-.codex/config.tomlאו ב-Git hooks שנמצאים תחת.git/hooks.מאפשר גישת קריאה רחבה למערכת הקבצים, בכפוף להרשאות הקיימות של המשתמש במערכת ההפעלה. מהדרים, סביבות ריצה וכלי בנייה תלויים בערכות SDK, בספריות ובתצורה שנמצאות מחוץ למאגר. הגבלת הקריאה לסביבת העבודה בלבד הייתה משבשת תהליכי עבודה שגרתיים רבים. הפשרה היא שגם קבצים רגישים במקומות אחרים במחשב עשויים להישאר זמינים לקריאה, למשל קובצי תצורה המכילים מפתחות API.
משבית את הגישה לרשת. כך נחסמות העלאות ישירות לשירותים חיצוניים, כולל ניסיונות להדליף נתונים שהפקודה יכולה לקרוא. הדבר מונע גם פעולות לגיטימיות, כמו הורדת תלויות, שדורשות הרשאות גישה נוספות.
ההגבלות האלה מונעות מגוון רחב של התנהגויות לא רצויות, אך פעולות מזיקות עדיין אפשריות. לדוגמה, הסוכן עלול להזריק קוד זדוני לחבילה שמותקנת מקומית, כמו node_modules/prettier. שינוי כזה עשוי שלא להופיע ב-git status, משום שלעיתים קרובות Git מתעלם מ-node_modules. אם העורך של המשתמש מפעיל את העותק הזה של Prettier בעת שמירה, עצם שמירת הקובץ עלולה להריץ את הקוד הזדוני מחוץ לארגז החול של Codex. לכן אנחנו נוקטים גישת הגנה לעומק: ארגז החול מגביל את המשאבים שפקודות יכולות לגשת אליהם, ואילו האימון וההתאמה לכוונות המשתמש מסייעים למודל להשתמש בגישה הזו בהתאם לכוונת המשתמש.
להנחיות להתאמת הרשאות ארגז החול ולשילובן עם הגנות נוספות בסביבה ארגונית, עיינו ב מדריך האבטחה המעשי של Codex(נפתח בחלון חדש).
מכונות וירטואליות וקונטיינרים(נפתח בחלון חדש) הם שני מנגנונים נפוצים ליצירת ארגזי חול, אבל בארגז החול של Codex בחרנו בגישה אחרת. במקום להעביר את החישוב לסביבה נפרדת כדי להשיג בידוד, Codex משתמש במנגנוני ארגז החול של כל פלטפורמה כדי להגביל פקודות שרצות בסביבה הקיימת של המשתמש.
עבור מפתחים רבים, המחשב הנייד הוא סביבת פיתוח מותאמת אישית שהם יכולים לשנות כרצונם. שחזור הסביבה הזו בקונטיינר Docker עשוי לדרוש עבודה, ותהליכי עבודה מסוימים עדיין תלויים בכלים שרצים על המארח.
לדוגמה, נבחן שימוש ב-Codex לפיתוח אפליקציית iOS במחשב Mac. אם תבחרו לבודד את Codex באמצעות הרצה בתוך Docker, הוא לא יוכל להריץ את שרשרת כלי הבנייה של iOS, המורכבת מקובצי הרצה ייעודיים ל-Mac, וגם לא להפעיל את סימולטור ה-iPhone כדי להריץ את הקוד. תהליך עבודה מבוסס Docker יכול להעביר את הבנייה ואת פעולות הסימולטור למארח ה-Mac, אך הפעולות האלה יתבצעו מחוץ לארגז החול של הקונטיינר ויזדקקו להגבלות משלהן. ב-Codex אנחנו מעדיפים לשמור על פשטות ולהשקיע רבות במנגנוני ארגז חול ייעודיים לכל מערכת הפעלה, כך ש-Codex יוכל לרוץ בסביבה המתאימה ביותר למשימה שעל הפרק.
ה-harness חושף את מנגנוני ארגז החול הייעודיים לכל מערכת הפעלה דרך API משותף ל-macOS, ל-Windows ול-Linux. ה-API הזה מקבל פקודה ופרופיל הרשאות. אם פרופיל ההרשאות מאפשר גישה מוגבלת לרשת, הגורם הקורא חייב לספק פרוקסי רשת שיאכוף את ההגבלות האלה:
הפונקציה הזו מפעילה את התהליך בארגז חול ומחזירה ידית Child, שה-harness יכול להשתמש בה כדי להמתין לסיום התהליך. כל תהליך בן יורש את מגבלות ארגז החול של תהליך האב שלו, ולכן ההגבלות חלות על כל עץ התהליכים שהפקודה יוזמת — גם על צאצאים שממשיכים לרוץ לאחר שהתהליך המקורי הסתיים.
התרשים הבא מציג כיצד הרכיבים האלה משתלבים, מהגדרת התצורה ועד להרצת פקודה בארגז חול. הסעיפים הבאים מסבירים כל שלב.

כפי שמוסבר ב-מבט מקרוב על לולאת הסוכן של Codex, ה-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 מאפשרת להגדיר כללים לנתיבים יחסיים לשורשי סביבת העבודה של פרויקט. כברירת מחדל, ה-CLI של Codex משתמש בתיקיית העבודה שלו כשורש היחיד של סביבת העבודה, ואילו אפליקציית ChatGPT למחשב משתמשת בתיקיות המקור של הפרויקט. Codex מחיל כל כלל על כל שורש, ולכן הרשומה .vscode בפרופיל dev מגדירה את תיקיית .vscode לקריאה בלבד תחת כל שורש.
נוסף על הכללים שלו, dev יורש את ההגנות הבאות מ-:workspace:
בהגדרת הרשת לארגז החול ב-Codex, יש שלוש אפשרויות עיקריות:
השבתת כל הגישה לרשת (ברירת המחדל בפרופיל
:workspace)מתן גישה מלאה וישירה לרשת (ברירת המחדל בפרופיל
:danger-full-access)הגבלת הגישה לרשת לפרוקסי, שמחליט מה להעביר בהתאם לפרופיל ההרשאות
כדי לתת ל-dev גישה ישירה לרשת, הגדירו permissions.dev.network.enabled = true ברמה העליונה של config.toml. ההגדרה הזו מעניקה גישה מלאה לרשת כשפרוקסי הרשת מושבת.
כדי להגביל את dev לקבוצת דומיינים, הפעילו את פרוקסי הרשת והגדירו את כללי הדומיינים שלו:
כללי דומיינים תומכים בשמות מדויקים ובתבניות עם תווים כלליים, וכללי חסימה מפורשים גוברים על כללי היתר. בקשות לדומיינים אחרים דורשות אישור או נחסמות, כפי שמתואר בסעיף פרוקסי רשת בהמשך.
משתמשים יכולים להגדיר ברירות מחדל שיחולו על כל הפרויקטים, ולדרוס אותן עבור פרויקט מסוים שהם נותנים בו אמון. גם מנהלי מערכת בארגונים עשויים לרצות להגדיר ברירות מחדל למשתמשים שלהם, ולהגביל את ההגדרות שהמשתמשים יכולים לשנות. Codex תומך בשני הצרכים האלה באמצעות תצורה בשכבות ודרישות מנוהלות.
כפי שמתואר ב-סדר הקדימויות של התצורה,(נפתח בחלון חדש) Codex ממזג הגדרות מכמה קובצי config.toml. טבלאות מתמזגות באופן רקורסיבי, ובמקרה של ערכים סותרים גובר המקור בעל הקדימות הגבוהה יותר. מערכים מוחלפים בשלמותם.
זו הסיבה שפרופילי הרשאות משתמשים בטבלאות לנתיבי מערכת הקבצים ולדומיינים ברשת. צוות יכול להוסיף או לדרוס רשומות בודדות בתצורה שלו, ולרשת אוטומטית שינויים בכל יתר הרשומות בתצורת הבסיס של הארגון:
מנהלי מערכת יכולים גם לספק דרישות מנוהלות(נפתח בחלון חדש) דרך requirements.toml כדי להגביל את אפשרויות התצורה של המשתמשים. הדרישות האלה יכולות להגיע ממקורות שונים, ובהם קובצי מערכת ומדיניות שמסופקת מהענן. שימוש נפוץ הוא הגדרת allowed_permission_profiles כדי להגביל את קבוצת פרופילי ההרשאות שמשתמש ארגוני יכול לבחור. לדוגמה, מנהל מערכת יכול להגדיר את דרישות הענן הבאות:
דרישות הענן יקבלו קדימות על פני קובץ דרישות המערכת שבנתיב /etc/codex/requirements.toml, ולכן רשומה בקובץ הזה לא יכולה לדרוס את ההגדרה המפורשת ":danger-full-access" = false שלעיל. השארת :workspace ללא הגדרה מאפשרת לשכבת דרישות אחרת לספק את הרשומה הזו. פרופילים שהרשומות שלהם הן false או שאינם מופיעים בטבלה הממוזגת הסופית אינם זמינים.
ההפרדה הזו מאפשרת לארגונים לאכוף מגבלות, ולמשתמשים להתאים את התצורה שלהם בתוך הגבולות האלה. ה-harness יכול להשתמש בפרופילי ההרשאות שמתקבלים, ואפשר גם להחיל אותם ישירות על פקודה, כפי שנראה בהמשך.
ה-CLI של Codex מספק פקודת 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 ולתיקיית הנתונים של השרת.
המימוש של ארגז החול הופך פרופיל הרשאות להגבלות שנאכפות על ידי מערכת ההפעלה. לוגיקת הליבה של פרוקסי הרשת לטיפול בבקשות ולאכיפת מדיניות משותפת לשלוש מערכות ההפעלה העיקריות, ואילו הקמת הפרוקסי והשילוב שלו בארגז החול ייעודיים לכל מערכת הפעלה. נבחן תחילה את הפרוקסי המשותף, ולאחר מכן את המימושים ל-macOS, ל-Linux ול-Windows.
כדי לאכוף את הגבלות הרשת של פרופיל הרשאות, ה-harness מפעיל פרוקסי רשת ומגדיר את ארגז החול כך שיאפשר חיבורים אליו ויחסום חיבורים ישירים למארחים חיצוניים. הפרוקסי בודק כל בקשה מול כללי הדומיינים של הפרופיל כדי לקבוע אם להעביר אותה הלאה.
במאגר של 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 עדיין עשויים לאפשר הדלפת נתונים דרך DNS.
ב-macOS, Codex משתמש ב-Seatbelt(נפתח בחלון חדש), מנגנון ארגז החול של Apple שנאכף ברמת ליבת מערכת ההפעלה. כללי המדיניות של Seatbelt נכתבים ב-Sandbox Profile Language (SBPL), שפה מבוססת Scheme להגדרת הגבלות ארגז חול. 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 לסינון קריאות מערכת. כלי עזר פנימי בשם codex-linux-sandbox מתאם את ההקמה. בדומה ל-sandbox-exec ב-macOS, הוא מקבל תצורה של ארגז חול ואחריה פקודה להרצה:
כשנדרש בידוד של מערכת הקבצים או ניתוב דרך פרוקסי, codex-linux-sandbox מפעיל את bwrap כדי ליצור את סביבת ארגז החול הראשונית. לאחר מכן bwrap מפעיל בתוכה את codex-linux-sandbox --apply-seccomp-then-exec. ההפעלה השנייה הזו משתמשת ב-seccomp-bpf כדי להחיל הגבלות נוספות לפני הרצת פקודת המשתמש.
כדי לבנות את סביבת ארגז החול הראשונית, Codex משתמש ב-bubblewrap ליצירת תצוגת מערכת קבצים במרחב שמות נפרד לעיגון, המשקפת את כללי מערכת הקבצים שבפרופיל ההרשאות. מכיוון שזהו מרכיב יסודי במימוש ארגז החול, Codex כולל עותק משלו של bwrap למקרה שהמשתמש לא התקין עותק בעצמו. עם זאת, הוא מעדיף התקנה תואמת של (נפתח בחלון חדש)bwrap(נפתח בחלון חדש) שנמצאת ב-PATH, אם יש כזו. בפועל, חלק מהפצות Linux משביתות כברירת מחדל גישה למרחבי שמות של משתמשים(נפתח בחלון חדש), אך מעניקות חריגה ל-bwrap של המערכת.
בדומה ל-sandbox-exec, גם bwrap מקבל תצורה של ארגז חול ואחריה פקודה להרצה בתוכו. במקום להשתמש בשפת תצורה ייעודית כמו SBPL, bwrap משתמש בדגלים נפרדים להגדרת התצורה. Codex משתמש באפשרויות הבאות כדי ליצור את תצוגת מערכת הקבצים:
--bindלציון קובץ או תיקייה שניתן לכתוב אליהם--ro-bindלציון קובץ או תיקייה לקריאה בלבד--perms 000 --tmpfs DIR --remount-ro DIRלחסימת הגישה ל-DIR--perms 000 --ro-bind-data FD FILEלחסימת הגישה ל-FILE(כאשרFDהוא מתאר קובץ פתוח ל-/dev/null)
כדי להחיל תבניות glob לחסימה באמצעות האפשרויות האלה, Codex מרחיב אותן לנתיבים קונקרטיים לפני הפעלת כל פקודה. נתיבים תואמים חדשים אינם מתווספים אוטומטית להגבלות ארגז החול של אותה פקודה.
Codex מציין גם אפשרויות כמו --unshare-ipc ו---unshare-pid כדי למנוע מארגז החול לגשת לסוגים אחרים של משאבים במארח. לכן ההשפעה של bubblewrap אינה מוגבלת רק לקבצים הגלויים לתהליך.
בשימוש ב-bubblewrap, Codex מעביר את --unshare-net בכל פעם שהגישה לרשת מושבתת או שהחיבורים חייבים לעבור דרך פרוקסי הרשת. כך נוצר לארגז החול מרחב שמות חדש לרשת. לאחר מכן אנחנו משתמשים ב-seccomp-bpf כדי להחיל הגבלות נוספות על קריאות המערכת הקשורות לרשת ועל משפחות ה-sockets הזמינות לפקודה.
לשם כך אנחנו משתמשים ב-crate בשם seccompiler(נפתח בחלון חדש) כדי להדר באופן דינמי תוכנית BPF על סמך המסננים הרצויים(נפתח בחלון חדש), ולהחיל אותה על תהליך מפעיל בארגז החול, כך שההגבלות יעברו בירושה לכל עץ התהליכים. לכן bwrap אינו מריץ את פקודת המשתמש, אלא את המפעיל codex-linux-sandbox, עם ארגומנטי התצורה שלו ואחריהם פקודת המשתמש:
כדי להחיל מסנני seccomp ללא הרשאות מוגברות, המפעיל מגדיר את הדגל no_new_privs של Linux(נפתח בחלון חדש). הדגל הזה עובר בירושה לתהליכי צאצא ומונע מהם לקבל הרשאות נוספות בעת הרצת תוכנית אחרת, למשל קובץ הרצה עם setuid.
מסנני seccomp תלויים בתצורת הרשת. כשהגישה לרשת מושבתת, אנחנו חוסמים כמה קריאות מערכת הקשורות לרשת, כמו connect(2) ו-bind(2). לעומת זאת, כשפרוקסי הרשת מופעל בארגז החול, אנחנו מאפשרים שימוש ב-IP sockets כדי שאפשר יהיה להגיע למאזין ה-TCP שיוצר codex-linux-sandbox, אך חוסמים כברירת מחדל יצירה של Unix domain sockets עצמאיים, שכן אלה עלולים לאפשר גישה לא מכוונת למשאבי המארח.
כאשר תצורת ארגז החול מצריכה שימוש בפרוקסי הרשת, ה-harness של Codex יוצר מופע אחד של הפרוקסי, שאפשר להשתמש בו שוב ושוב בהפעלות מרובות של codex-linux-sandbox באותו שרשור של Codex. כל ארגז חול זקוק לדרך להגיע לפרוקסי המשותף הזה מתוך מרחב שמות הרשת המבודד שלו. Codex מספק מאזין TCP בממשק loopback בתוך מרחב השמות הזה, ודואג שתהליך מחוץ לארגז החול יקבל את החיבורים שלו ויעביר אותם לפרוקסי.
התרשימים הבאים ממחישים את המבנה הזה עבור endpoint אחד של הפרוקסי. בתרשים האחרון מוצג חיבור אחד שעובר דרכו. לפני הפעלת bubblewrap, codex-linux-sandbox יוצר זוג Unix sockets שישמש כערוץ בקרה, ומתפצל. תהליך הבן מריץ את run_host_bridge() וממתין לקבלת מתאר הקובץ של המאזין דרך הערוץ הזה:
בדוגמה הזו, תהליך האב משתמש ב-exec כדי להחליף את תמונת התוכנית שלו ב-bwrap. כך הוא מקים את ארגז החול ומפעיל בתוכו את codex-linux-sandbox --apply-seccomp-then-exec, תוך העברת מתאר הקובץ של ערוץ הבקרה:
בתוך מרחב שמות הרשת של ארגז החול, ההפעלה השנייה של codex-linux-sandbox יוצרת מאזין TCP בממשק loopback ומעבירה את מתאר הקובץ שלו דרך ה-socket. המאזין נשאר משויך למרחב שמות הרשת של ארגז החול. כך תהליך הבן שנשאר מחוץ לארגז החול יכול לקבל חיבורים מתוכניות שבתוכו, ובמקביל לפתוח את החיבורים היוצאים שלו במרחב שמות הרשת של המארח. לאחר ההעברה, שני התהליכים סוגרים את המתארים שלהם לערוץ הבקרה, והתהליך שבתוך ארגז החול סוגר את העותק שלו של המאזין.
לאחר שמאזין ה-TCP מוכן, התהליך שבתוך ארגז החול מגדיר את הערך המתאים עבור HTTP_PROXY(נפתח בחלון חדש) ומשתני הסביבה הקשורים אליו, כך שיפנו למאזין הזה. לאחר מכן הוא מחיל seccomp לפני שהוא מתפצל ומריץ את פקודת המשתמש:
התהליך שמחוץ לארגז החול משאיר את המאזין פתוח. עבור כל חיבור שמתקבל, הוא פותח חיבור לפרוקסי שהוגדר ומעביר נתונים בשני הכיוונים.
המנגנון הנוסף הזה מספק לפקודה מרחב שמות משלה לרשת, כולל ממשק loopback נפרד. ב-macOS, Seatbelt מאפשר לפקודה להתחבר ישירות לפורטים מוגדרים בממשק ה-loopback של המארח. ב-Linux, לעומת זאת, הפקודה מתחברת למאזין בתוך מרחב השמות המבודד שלה, ותהליך מחוץ לארגז החול מעביר את החיבורים האלה לפרוקסי שהוגדר. העברת המתאר מאפשרת את החיבור הזה בלי לחשוף לפקודה את מרחב שמות הרשת של המארח.
מוקדם יותר השנה מימשנו ארגז חול ב-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 משתמש בהגדרות קבועות לכמה מנגנוני בקרה כדי לאזן בין תאימות לאבטחה. הוא מאפשר קריאה מה-registry ומשמר את הגישה ל-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 מוסיף הרשאות קריאה בלבד לשורשי הכוננים המקומיים, כדי לספק את גישת הקריאה הרחבה שהפרופיל הזה מאפשר. ההרשאות האלה חלות באופן רקורסיבי, בכפוף להרשאות הקיימות של המשתמש במערכת ההפעלה.
יש כאן סייג אחד: הרשאות כתיבה לשורש כונן אינן חלות באופן רקורסיבי, ולכן Codex מרחיב אותן כך שיכללו את הפריטים הקיימים ישירות מתחת לשורש הכונן.
נתיבים ספציפיים יותר גוברים על הרשאות של תיקיות אב, כך ש-C:\work\demo יכול להיות זמין לכתיבה תחת C:\ המוגדר לקריאה בלבד, בעוד C:\work\demo\.git נשאר לקריאה בלבד.
כאשר צורות כתיבה שונות של נתיב או כינויים דרך symlink או junction מפנים לאותו נתיב, MXC מחיל את ההרשאה המחמירה יותר: חסימה גוברת על קריאה בלבד, וקריאה בלבד גוברת על קריאה וכתיבה.
MXC מקבל רק נתיבים קונקרטיים לחסימה, ולכן Codex מרחיב את תבניות ה-glob לחסימה לקבצים ולתיקיות תואמים לפני ההפעלה. נתיבים חדשים שתואמים לתבנית ה-glob אינם מתווספים אוטומטית בזמן שהפקודה רצה.
כללי דומיינים כמו *.openai.com נאכפים על ידי פרוקסי הרשת המשותף של Codex שתואר קודם. Codex מריץ את הפרוקסי הזה מחוץ לארגז החול ומעביר את הכתובות שלו לפקודה דרך אותם משתני סביבה סטנדרטיים מסוג *_PROXY שהוזכרו קודם. MXC חוסם חיבורים ישירים החוצה, אך מאפשר חיבורים לממשק ה-loopback של המארח, כולל גישה לפרוקסי. שירותים מקומיים אחרים נשארים נגישים.
ב-macOS, ב-Linux וב-Windows, ה-harness משתמש באותו API של ארגז החול כדי להפעיל פקודות תחת פרופיל הרשאות. המימושים הייעודיים לכל פלטפורמה מטפלים בהכנות הדרושות להחלת ההגבלות האלה.
כתיבת קוד והרצתו נותנות לסוכנים דרך גמישה לפתור בעיות גם מעבר לפיתוח תוכנה. ארגז החול של Codex מאפשר להם להשתמש ביכולת הזו בסביבה הקיימת של המשתמש, עם מגבלות מפורשות על הגישה למערכת הקבצים ולרשת. זהו רכיב בסיסי לשימוש חוזר בתוך ה-harness, והפקודה codex sandbox מעמידה אותו גם לרשות כלים שתבנו בעצמכם.
ככל שסוכנים מקבלים על עצמם יותר משימות, אנחנו רוצים להפוך את השימוש בארגזי חול למעשי עבור יותר כלים וסביבות. לשם כך נפשט את הגדרת ההרשאות וננצל הגנות טובות יותר של מערכות ההפעלה ככל שיהיו זמינות. המטרה שלנו היא להרחיב את היכולות של סוכנים, תוך שמירה על שליטה אנושית במשאבים שאליהם הם יכולים לגשת.


