Как устроена песочница 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 в.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 мог работать в окружении, наиболее подходящем для текущей задачи.
Обвязка предоставляет доступ к этим механизмам изоляции через единый API для macOS, Windows и Linux. Этот API принимает команду и профиль разрешений. Если профиль разрешает ограниченный доступ к сети, вызывающая сторона должна предоставить сетевой прокси, который обеспечит соблюдение этих ограничений:
Эта функция запускает процесс в песочнице и возвращает дескриптор Child, с помощью которого обвязка может дождаться его завершения. Каждый дочерний процесс наследует ограничения песочницы родителя. Поэтому они действуют во всём дереве процессов, созданном командой, даже для потомков, которые продолжают работать после завершения исходного процесса.
Следующая схема показывает, как эти компоненты связаны между собой: от конфигурации до выполнения команды в песочнице. В следующих разделах мы разберём каждый этап.

Как объясняется в статье «Разбираем цикл работы агента Codex», обвязка Codex отвечает за выполнение вызовов инструментов, сгенерированных моделью. В задачах программирования чаще всего используется инструмент командной оболочки: он запускает команды примерно так же, как пользователь в интерактивной оболочке, например Bash. Здесь мы рассмотрим инструмент (открывается в новом окне)exec_command(открывается в новом окне) для разового выполнения команд в оболочке(открывается в новом окне), чтобы показать, как обвязка использует песочницу для обеспечения нужной защиты.
Ниже приведен упрощенный вариант того, как обвязка Codex обрабатывала бы вызов инструмента exec_command без песочницы:
Чтобы выполнить команду в песочнице, обвязка заменяет вызов subprocess.Popen() на spawn_command_under_sandbox(). Обвязка передаёт профиль разрешений и, при необходимости, сетевой прокси:
Инструмент exec_command также позволяет модели запрашивать другие разрешения для отдельной команды, но решение об их предоставлении принимает обвязка:
Если указано use_default, обвязка использует конфигурацию песочницы по умолчанию для текущего хода. with_additional_permissions запрашивает расширенный доступ внутри песочницы, а require_escalated — выполнение вне нее. Перед выполнением команды обвязка оценивает запрос с учетом настроек пользователя. (Например, Codex может запросить разрешение напрямую у пользователя или направить запрос на автоматическую проверку(открывается в новом окне).) Если выполнение одобрено, Codex передаст соответствующие permission_profile и network_proxy в perform_exec_command_with_sandboxing() вместе с аргументами команды из исходного ExecCommandToolCall.
Основной потребитель spawn_command_under_sandbox() — инструмент командной оболочки. Обвязка также использует ту же инфраструктуру песочницы для таких операций, как чтение и изменение локальных файлов. Повторное использование не ограничивается обвязкой: команда 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 набором доменов, включите сетевой прокси и настройте его доменные правила:
Доменные правила поддерживают точные имена и шаблоны с подстановочными знаками. Явные запреты имеют приоритет над разрешающими правилами. Запросы к другим доменам требуют одобрения или блокируются, как описано ниже в разделе «Сетевой прокси».
Пользователи могут задавать настройки по умолчанию для всех проектов и переопределять их для отдельного доверенного проекта. Корпоративным администраторам также может потребоваться задать настройки по умолчанию для пользователей и ограничить набор параметров, которые те могут менять. Codex поддерживает оба сценария с помощью многоуровневой конфигурации и управляемых требований.
Как описано в разделе «Приоритет конфигурации»,(открывается в новом окне) Codex объединяет настройки из нескольких файлов config.toml. Таблицы объединяются рекурсивно; при конфликте используется значение из источника с более высоким приоритетом. Массивы заменяются целиком.
Именно поэтому в профилях разрешений пути файловой системы и сетевые домены задаются таблицами. Команда может добавлять или переопределять отдельные записи в своей конфигурации и автоматически наследовать изменения всех остальных записей из базовой конфигурации организации:
Администраторы также могут задавать управляемые требования(открывается в новом окне) через requirements.toml, ограничивая доступные пользователям варианты настройки. Эти требования могут поступать из разных источников, включая системные файлы и облачные политики. Типичный сценарий — задать allowed_permission_profiles, чтобы ограничить набор профилей разрешений, доступных корпоративному пользователю. Например, администратор может задать такие облачные требования:
Облачные требования имеют приоритет над системным файлом требований /etc/codex/requirements.toml, поэтому запись в нем не может переопределить явное указание ":danger-full-access" = false выше. Если не задавать :workspace, эту запись сможет предоставить другой уровень требований. Профили, для которых в итоговой объединенной таблице задано false или нет записи, недоступны.
Такое разделение позволяет организациям устанавливать обязательные ограничения, а пользователям — настраивать конфигурацию в их пределах. Полученные профили разрешений может использовать обвязка. Их также можно применять непосредственно к команде, как мы покажем далее.
В Codex CLI есть команда sandbox, которая позволяет запускать произвольную команду с профилем разрешений, заданным в конфигурации Codex. Обычно ее используют для проверки профиля, чтобы убедиться, что песочница действительно блокирует действия, запрещенные профилем.
Например, следующая команда пытается настроить VS Code на запуск вредоносного автоформатировщика при сохранении. Если .vscode уже существует, заданный выше профиль dev должен заблокировать эту запись, поскольку каталог доступен только для чтения (по умолчанию codex sandbox считает cwd корневым каталогом рабочей области):
И действительно, в macOS команда завершается с ошибкой:
Команда codex sandbox позволяет использовать механизм изоляции Codex независимо от сеанса агента. Вы можете использовать тот же язык конфигурации и механизмы защиты конкретной платформы для ограничения команд, запускаемых вашими инструментами.
Для MCP-сервера со stdio, настроенного в config.toml, обвязка 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.
Чтобы обеспечить сетевые ограничения профиля разрешений, обвязка запускает сетевой прокси и настраивает песочницу так, чтобы разрешить соединения с ним, но блокировать прямые соединения с внешними хостами. Прокси проверяет каждый запрос по доменным правилам профиля и решает, пересылать ли его дальше.
В репозитории 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 Codex использует Seatbelt(открывается в новом окне) — механизм изоляции Apple, обеспечиваемый ядром. Политики Seatbelt пишутся на Sandbox Profile Language (SBPL) — языке на основе Scheme для описания ограничений песочницы. Codex вызывает Seatbelt через команду macOS /usr/bin/sandbox-exec. Как и 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 мы дополнительно ограничиваем доступные команде сетевые системные вызовы и семейства сокетов.
Для этого мы используем крейт seccompiler(открывается в новом окне), чтобы динамически скомпилировать BPF-программу на основе нужных фильтров(открывается в новом окне) и применить ее к процессу запуска внутри песочницы. Так ограничения наследуются всем деревом процессов. Поэтому bwrap запускает не команду пользователя, а программу запуска codex-linux-sandbox, передавая ей аргументы конфигурации, за которыми следует команда пользователя:
Чтобы применить фильтры seccomp без повышенных привилегий, программа запуска устанавливает флаг no_new_privs в Linux(открывается в новом окне). Этот флаг наследуется дочерними процессами и не дает им получать дополнительные привилегии при выполнении другой программы, например исполняемого файла с setuid.
Фильтры seccomp зависят от конфигурации сети. Когда доступ к сети отключен, мы блокируем ряд сетевых системных вызовов, таких как connect(2) и bind(2). Если в песочнице включен сетевой прокси, мы разрешаем IP-сокеты, чтобы обеспечить доступ к прослушивающему TCP-сокету, созданному codex-linux-sandbox. Но по умолчанию мы блокируем создание отдельных Unix-сокетов, поскольку они могут непреднамеренно открыть доступ к ресурсам хоста.
Если по настройкам песочницы нужен сетевой прокси, обвязка Codex создает один экземпляр прокси. Он может повторно использоваться при нескольких вызовах codex-linux-sandbox в рамках одного диалога Codex. Каждой песочнице нужен способ обратиться к этому общему прокси из своего изолированного сетевого пространства имен. В этом пространстве имен Codex создает прослушивающий TCP-сокет на loopback-интерфейсе. Вне песочницы Codex настраивает процесс, который принимает входящие соединения на этом сокете и перенаправляет их на прокси.
Следующие схемы показывают эту конфигурацию для одного эндпоинта прокси. На последней схеме показано одно соединение через него. Перед запуском bubblewrap программа codex-linux-sandbox создает пару Unix-сокетов для канала управления и порождает дочерний процесс. Дочерний процесс выполняет run_host_bridge() и ждет передачи файлового дескриптора прослушивающего сокета по этому каналу:
В этом примере родительский процесс использует exec, чтобы заменить образ своей программы на bwrap. Так создается песочница, и внутри нее запускается codex-linux-sandbox --apply-seccomp-then-exec с передачей файлового дескриптора канала управления:
Второй экземпляр codex-linux-sandbox создает прослушивающий TCP-сокет на loopback-интерфейсе в сетевом пространстве имен песочницы и передает его файловый дескриптор через сокет. Прослушивающий сокет остается связанным с сетевым пространством имен песочницы. Это позволяет дочернему процессу, оставшемуся снаружи, принимать соединения от программ внутри песочницы и при этом открывать соединения с прокси в сетевом пространстве имен хоста. После передачи оба процесса закрывают дескрипторы канала управления, а процесс внутри песочницы закрывает свою копию прослушивающего сокета.
Когда прослушивающий TCP-сокет готов, процесс внутри песочницы указывает адрес сокета в переменной HTTP_PROXY(открывается в новом окне) и связанных с ней переменных окружения. Затем он применяет seccomp перед созданием дочернего процесса и выполнением команды пользователя:
Процесс вне песочницы оставляет прослушивающий сокет открытым. Для каждого принятого соединения он открывает соединение с настроенным прокси и передает данные в обоих направлениях.
Этот дополнительный механизм предоставляет команде собственное сетевое пространство имен с отдельным loopback-интерфейсом. В macOS Seatbelt позволяет команде напрямую подключаться к заданным портам loopback-интерфейса хоста. В Linux команда вместо этого подключается к прослушивающему сокету в своем изолированном пространстве имен, а процесс вне песочницы перенаправляет эти соединения на настроенный прокси. Передача дескриптора делает такое соединение возможным, не открывая команде доступ к сетевому пространству имен хоста.
Ранее в этом году мы создали песочницу для Windows и рассказали, как мы ее разрабатывали. С тех пор Microsoft выпустила библиотеку MXC вместе с новыми возможностями изоляции процессов в операционной системе Windows. Сейчас мы заменяем существующую песочницу новой, использующей библиотеку MXC.
MXC (Microsoft eXecution Container) — система выполнения кода в песочнице(открывается в новом окне) от Microsoft, поддерживающая несколько механизмов изоляции в Windows, Linux и macOS. На совместимых устройствах Windows Codex поддерживает песочницу на базе MXC. Она использует встроенную изоляцию процессов, чтобы ограничивать команды в существующем окружении пользователя.
Мы переходим на 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 добавляет разрешения только на чтение для корневых каталогов локальных дисков. Это дает предусмотренный профилем доступ на чтение по всему диску. Эти разрешения действуют рекурсивно, в пределах имеющихся у пользователя прав в ОС.
Разрешение на запись в корневом каталоге диска не распространяется на его содержимое рекурсивно. Поэтому Codex отдельно предоставляет это разрешение для уже существующих файлов и каталогов непосредственно в корне диска.
Для более конкретного пути его собственные разрешения имеют приоритет над разрешениями вышестоящих каталогов. Например, запись в C:\work\demo может быть разрешена, даже если C:\ доступен только для чтения. При этом C:\work\demo\.git остается доступным только для чтения.
Если разные варианты записи пути, символические ссылки или точки соединения указывают на один и тот же путь, MXC применяет более строгое разрешение: наивысший приоритет имеет запрет доступа, затем идет режим «только чтение», а самый низкий приоритет у режима «чтение и запись».
MXC принимает только конкретные запрещенные пути, поэтому перед запуском Codex разворачивает запрещающие glob-шаблоны в список соответствующих файлов и каталогов. Во время выполнения команды новые пути, соответствующие шаблону, автоматически не добавляются.
Доменные правила, такие как *.openai.com, применяет описанный ранее общий сетевой прокси Codex. Codex запускает этот прокси вне песочницы и передает его адреса команде через те же стандартные переменные окружения *_PROXY, о которых говорилось выше. MXC блокирует прямые внешние соединения, но разрешает соединения через loopback-интерфейс хоста, в том числе доступ к прокси. Другие локальные сервисы остаются доступными.
В macOS, Linux и Windows обвязка использует один и тот же API песочницы для запуска команд с профилем разрешений. Реализации для конкретных платформ выполняют настройку, необходимую для применения этих ограничений.
Агенты могут писать и выполнять код и тем самым решать самые разные задачи, в том числе за пределами разработки ПО. Песочница Codex позволяет им использовать эту возможность в существующем окружении пользователя с явно заданными ограничениями доступа к файловой системе и сети. Песочница — базовый компонент обвязки, который можно использовать повторно. Команда codex sandbox делает его доступным для инструментов, которые вы создаете сами.
По мере того как агенты берут на себя все больше задач, мы хотим сделать изоляцию в песочнице удобной для большего числа инструментов и окружений. Для этого нужно упрощать настройку разрешений и использовать более совершенные средства защиты операционных систем по мере их появления. Наша цель — расширять возможности агентов, чтобы люди по-прежнему могли решать, к каким ресурсам разрешить агентам доступ.


