Каждый процесс в Linux работает поверх одного ядра, и именно ядро решает, где проходит граница доверия. Sandbox-технологии дают способ сузить эту границу до минимума: изолированному приложению показывают только нужные файловые системы, процессы и сетевые интерфейсы, а системные вызовы прогоняют через белый список. Контейнеры, службы systemd, браузеры, CI-раннеры и системы сборки используют одни и те же примитивы ядра, отличаясь лишь комбинацией и строгостью настройки. Понимание этих примитивов на уровне системных вызовов превращает работу с изоляцией из копирования чужих конфигов в осознанную инженерную задачу. Отдельный бонус в том, что все эти механизмы доступны и без контейнерных платформ: ими можно пользоваться прямо из шелла и из обычных программ.

Namespaces восемь типов изоляции и системные вызовы clone unshare setns

Основу изоляции в ядре образуют namespaces, механизм, который подменяет процессу его представление о системе. Каждый namespace скрывает или заменяет одно измерение окружения, а вместе они собирают для процесса отдельный мир. Ядро поддерживает восемь видов: mount, pid, net, uts, ipc, user, cgroup и time. Mount namespace даёт собственную таблицу монтирований, pid namespace прячет чужие процессы и даёт свой PID 1, net namespace отделяет стек, интерфейсы и маршрутизацию. Uts меняет имя узла, ipc изолирует очереди сообщений и разделяемую память, cgroup namespace маскирует положение процесса в иерархии ресурсов, time подменяет часы boottime и monotonic.

Отдельного разговора заслуживает user namespace. Он позволяет непривилегированному пользователю создать пространство, внутри которого его UID отображается в root, при этом снаружи никаких прав не появляется. Именно на нём держатся rootless-контейнеры Podman, песочницы браузеров и изоляция сборочных задач в CI. Разработчики ядра считают user namespace ключом ко всей непривилегированной изоляции: без него почти любой эксперимент требует root.

Живут namespaces, пока их кто-то держит: живой процесс или bind-монтирование дескриптора из /proc/PID/ns. Создают и переключают их три системных вызова. clone порождает новый процесс сразу в выбранных пространствах через флаги CLONE_NEWNS, CLONE_NEWPID, CLONE_NEWNET и другие. unshare переводит текущий процесс в свежие пространства без порождения потомков. setns вносит существующий процесс в чужой namespace, и на нём держится вся инспекция работающих контейнеров.

Пространства вкладываются друг в друга, и ограничение наследуется от родителя: дочерний mount namespace видит ровно ту картину монтирований, которую ему передали. Поэтому песочницу собирают слоями, а не одним махом. Удобный приём для отладки - запустить отдельный процесс в своих пространствах и подключаться к нему через nsenter в любой момент, не останавливая работу.

# shell with fresh user, mount and pid namespaces
unshare --user --map-root-user --mount --pid --fork --mount-proc bash

# named network namespace, kept alive by a bind mount
ip netns add lab0
ip netns exec lab0 ip -br addr

# map namespaces on the host to owning processes
lsns -t user,pid,net

# enter the network namespace of a running service
nsenter -t 4321 -n ip -br addr

Cgroups v2 контроль ресурсов и единая иерархия в systemd

Namespaces отвечают на вопрос о том, что процессу видно, cgroups отвечают, сколько ему можно. Версия v2 использует единую иерархию в /sys/fs/cgroup, где контроллеры cpu, memory, pids и io управляют процессорным временем, памятью, числом процессов и дисковыми операциями. Лимит задаётся записью значения в обычный файл: memory.max при превышении включает OOM-killer, pids.max останавливает fork-бомбы, cpu.max и cpu.weight делят процессор между соседями, io.max режет скорость диска. Мягкие лимиты вроде memory.high дают процессу шанс притормозить и выгрузить страницы до жёсткой стенки.

В боевом окружении ручными записями в sysfs пользуются редко: systemd раскладывает cgroups по своим slices, scopes и services, а инженер задаёт лимиты свойствами юнитов. Так ограничение ресурса становится частью декларации службы и переживает перезапуск. Смотреть на потребление по группам удобно через systemd-cgtop, разовые задачи с лимитами удобно запускать через systemd-run.

# one-off scope with hard limits for a build job
systemd-run --scope -p MemoryMax=1G -p TasksMax=200 -p CPUQuota=50% make all

# manual cgroup v2 hierarchy for experiments
mkdir /sys/fs/cgroup/lab
echo "+memory +pids" > /sys/fs/cgroup/cgroup.subtree_control
echo 512M > /sys/fs/cgroup/lab/memory.max
echo 64 > /sys/fs/cgroup/lab/pids.max
echo $$ > /sys/fs/cgroup/lab/cgroup.procs

Seccomp и seccomp-bpf фильтрация системных вызовов на уровне ядра

Namespaces и cgroups сужают картину мира, но не трогают поверхность атаки: изолированный процесс по-прежнему может обратиться к любому системному вызову, включая редкие и старые пути, где ошибки ядра встречаются чаще. Seccomp закрывает этот фланг прямо в точке входа в ядро. Строгий режим пропускает только read, write, _exit и sigreturn и для настоящих программ почти бесполезен. Рабочий инструмент - seccomp-bpf: процесс загружает фильтр из BPF-инструкций, и ядро прогоняет через него каждый вызов, решая, исполнить его, вернуть EPERM или ENOSYS, убить поток или записать событие в журнал.

Перед установкой фильтра процесс обязан выставить флаг no_new_privs через prctl, иначе фильтр можно было бы навязать setuid-программе и превратить её в орудие. Тот же флаг сам по себе запрещает процессу и его потомкам получать привилегии через setuid-биты, что делает его полезным и вне seccomp. Для многопоточных программ фильтр распространяют на все потоки опцией TSYNC, а удобную обёртку над BPF-машиной даёт библиотека libseccomp.

Разумный фильтр собирают по факту, а не по вере: сначала трассировка реальной нагрузки, затем allowlist из действительно используемых вызовов, затем наблюдение за журналами запрещённых обращений. Профили по умолчанию в Docker и Podman запрещают несколько десятков чувствительных вызовов вроде keyctl и bpf, и для типовых служб этого хватает, но для своей программы профиль стоит построить самому.

Тонкость совместимости: на старом ядре приложение может рассчитывать на вызов, которого фильтр не знает. Возврат ENOSYS вместо EPERM часто ведёт себя мягче, потому что библиотеки корректно откатываются на запасные пути. Для первых прогонов полезен режим SECCOMP_RET_LOG, который ничего не блокирует, а только пишет наблюдения в журнал. На этих записях макет фильтра собирается без риска уронить службу.

prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

/* libseccomp keeps the same idea behind a friendly API */
seccomp_rule_add(ctx, SCMP_ACT_ERRNO(EPERM), SCMP_SYS(openat), 0);
seccomp_load(ctx);
# measure the real syscall profile first
strace -c -f -S calls ./worker

Capabilities и no_new_privs точечная раздача привилегий вместо root

Права root в Linux давно разложены на несколько десятков отдельных capabilities. CAP_NET_BIND_SERVICE открывает порты ниже 1024, CAP_NET_ADMIN правит сетевыми настройками, CAP_SYS_PTRACE даёт доступ к чужим процессам, а CAP_SYS_ADMIN остаётся самым широким и опасным: он же нужен почти для всех операций с mount и namespaces. Sandbox-код обычно движется обратным путём: не добавляет права, а выбрасывает лишние, пока не останется минимальный набор.

Файловые capabilities позволяют убрать setuid-обёртки: бинарнику выдают ровно одну способность, и он запускается от обычного пользователя. Процессу стоит сразу усечь bounding set, чтобы права не вернулись через exec чужого файла. Свойство CapabilityBoundingSet= в юните systemd делает то же самое декларативно, а утилита setpriv помогает разово ограничить процесс из командной строки.

# one narrow capability for a plain binary
setcap 'cap_net_bind_service=+ep' /usr/local/bin/tinydns

# inspect effective, permitted and bounding sets of a shell
capsh --print

# drop everything for a one-off run
setpriv --no-new-privs --bounding-set=-all ./worker

Landlock и chroot с pivot_root файловая изоляция без привилегий

Старейший инструмент файловой изоляции chroot меняет корень процесса, но давно считается недостаточным: процесс с правами root и открытым дескриптором может выскользнуть наружу. Современная схема строже и предсказуемее. Внутри mount namespace корень делают точкой монтирования, propagation переводят в private, собирают новый корень из bind-монтирований и переключаются на него вызовом pivot_root, после чего старое дерево размонтируют. На этой схеме стоят все контейнерные рантаймы.

# classic root switch inside a mount namespace
mount --bind /newroot /newroot
mount --make-rprivate /newroot
pivot_root /newroot /newroot/old
umount -l /old

Landlock добавляет к этой картине тонкий слой прав доступа к файловой системе. Механизм появился в ядре 5.13 и не требует никаких привилегий: процесс объявляет ruleset, добавляет правила вида "чтение и исполнение под деревом /usr", а затем вызывает landlock_restrict_self. После этого вернуть себе права невозможно, ограничения при наследовании только складываются, а свежие ядра научились ограничивать ещё и сетевые порты. Так веб-приложению оставляют запись в один рабочий каталог, и даже найденная в нём уязвимость не превращается в доступ ко всему диску.

/* landlock: declare a ruleset, fill it, enforce */
int fd = landlock_create_ruleset(&attr, sizeof(attr), 0);
landlock_add_rule(fd, LANDLOCK_RULE_PATH_BENEATH, &rule, 0);
prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
landlock_restrict_self(fd, 0);

Инструменты инженера unshare nsenter и systemd-run в ежедневной работе

Для разовых экспериментов хватает утилит: unshare строит песочницу из шелла, nsenter заходит внутрь чужих пространств для отладки, lsns показывает, кто где живёт. Постоянные службы выгоднее изолировать декларативно, и здесь язык юнитов systemd поверх тех же примитивов ядра работает как готовый конструктор песочницы. Свойства группируются естественно: что видно из файловой системы, какие остаются привилегии, какие сетевые семейства доступны, какие системные вызовы разрешены.

Проверять результат удобно через systemd-analyze security, который оценивает экспозицию юнита и прямо перечисляет незакрытые направления. Разовые изолированные задачи без написания юнитов запускает systemd-run, показанный выше: строка свойств превращается во временный scope с лимитами.

[Service]
ExecStart=/usr/bin/myapi
NoNewPrivileges=yes
ProtectSystem=strict
ProtectHome=yes
PrivateTmp=yes
PrivateDevices=yes
ReadWritePaths=/var/lib/myapi
CapabilityBoundingSet=
RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX
SystemCallFilter=@system-service
SystemCallErrorNumber=EPERM
# score a unit and list the remaining exposure
systemd-analyze security myapi.service

Практические сценарии от изолированной сборки до мультитенантности

Слои примитивов собирают под задачу, и почти каждая практическая схема выглядит как их комбинация. Непривилегированная сборка в CI живёт в паре user и mount namespaces и не выходит за пределы каталога проекта даже при злонамеренном Makefile. Парсер загруженных документов получает seccomp-фильтр по трассировке и правила Landlock на один каталог, и эксплуатация уязвимости в нём не приносит атакующему ни сети, ни файлов. На хосте с чужими пользователями каждому сервису выделяют собственные лимиты в cgroups, чтобы шумный сосед не съел память и процессор, а отдельные сетевые namespaces с парой veth-интерфейсов дают лабораторный стенд для отладки правил файрвола без риска для боевой сети.

Песочницу проверяют и снаружи, и изнутри. Снаружи смотрят, в каких namespaces живёт процесс и какие права у него остались. Изнутри пробуют то, что должно быть запрещено: запись в чужой каталог, доступ к сети, редко используемый вызов. Отрицательные тесты важнее положительных, потому что атака придёт именно с той стороны, которую забыли закрыть.

Порядок внедрения удобно держать стандартным:

  1. собрать минимальный корень из нужных bind-монтирований;
  2. включить user и pid namespaces, если задача позволяет обходиться без привилегий;
  3. ограничить память, число процессов и ввод-вывод через cgroups;
  4. наложить seccomp-фильтр, собранный по трассировке реальной нагрузки;
  5. усечь набор capabilities и включить no_new_privs;
  6. закрыть файловую систему правилами Landlock.

Ни один слой не защищает поодиночке. Песочница в Linux - это сумма решений о том, что процессу видно, сколько ему можно, что ему разрешено вызывать и куда он может писать. Хорошая практика - собирать конфигурацию по частям, проверять её через lsns, capsh и systemd-analyze security, а затем повторять трассировку после каждого обновления приложения, потому что новые версии кода приносят с собой новые системные вызовы. Ядро уже выдало все инструменты, а аккуратность их комбинации остаётся делом инженера.