19.2. Границы изоляции

mkdir -p /tmp/isolab && cd /tmp/isolab

cat > surface.py <<'PY'
"""Измерение площади атаки на общее ядро.

Все числа берутся из системы, а не задаются в коде: заголовок ядра
и /proc/self/status. Это отличает измерение от оценки.
"""
from __future__ import annotations

import json
import platform
import re
from pathlib import Path

SYSCALL_HEADERS = [
    "/usr/include/x86_64-linux-gnu/asm/unistd_64.h",
    "/usr/include/asm/unistd_64.h",
    "/usr/include/asm-generic/unistd.h",
]

# Параметры, значение которых внутри container'а совпадает с хостом,
# потому что ядро одно.
SHARED_SYSCTL = [
    "kernel.pid_max",
    "vm.max_map_count",
    "fs.file-max",
    "kernel.threads-max",
]


def count_syscalls() -> tuple[int, str]:
    for path in SYSCALL_HEADERS:
        p = Path(path)
        if p.exists():
            n = len(re.findall(r"^#define __NR_", p.read_text(), re.M))
            return n, path
    return 0, "заголовок не найден"


def count_capabilities() -> int:
    for line in Path("/proc/self/status").read_text().splitlines():
        if line.startswith("CapBnd:"):
            return bin(int(line.split()[1], 16)).count("1")
    return 0


def read_sysctl(name: str) -> str:
    p = Path("/proc/sys") / name.replace(".", "/")
    try:
        return p.read_text().strip()
    except OSError:
        return "недоступен"


def main() -> None:
    syscalls, header = count_syscalls()
    caps = count_capabilities()
    result = {
        "ядро": platform.release(),
        "системных_вызовов": syscalls,
        "источник": header,
        "capabilities": caps,
        "общие_параметры": {n: read_sysctl(n) for n in SHARED_SYSCTL},
        "userns_ограничен": read_sysctl("kernel.apparmor_restrict_unprivileged_userns"),
    }
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()
PY

cat > audit.py <<'PY'
"""Поиск конфигураций, эквивалентных выдаче root на хост.

Ищутся не уязвимости, а решения в конфигурации: именно этот класс
составляет подавляющее большинство случаев escape в эксплуатации.
"""
from __future__ import annotations

import json
import sys
from pathlib import Path

import yaml

# (признак, вес, что даёт атакующему, когда оправдан)
RULES = {
    "privileged": (10, "снимает seccomp и AppArmor, возвращает все capabilities",
                   "сборка образов, и то не всегда"),
    "docker_sock": (10, "создание container с любыми параметрами — это root на хосте",
                    "агенты CI, с осознанием последствий"),
    "cap_sys_admin": (8, "монтирование и значительная часть операций root",
                      "почти никогда"),
    "root_mount_rw": (9, "файловая система хоста доступна на запись",
                      "никогда"),
    "root_mount_ro": (4, "файловая система хоста доступна на чтение",
                      "резервное копирование"),
    "pid_host": (5, "видимость и сигналы всем процессам хоста",
                 "средства наблюдения"),
    "network_host": (4, "сетевая изоляция снята полностью",
                     "производительность сети ценой изоляции"),
    "run_as_root": (6, "UID 0 внутри равен UID 0 снаружи",
                    "почти никогда"),
    "cap_add_all": (10, "все capabilities возвращены",
                    "никогда"),
    "seccomp_off": (7, "фильтр системных вызовов отключён",
                    "отладка, временно"),
}


def audit_service(svc: dict) -> list[str]:
    found: list[str] = []
    if svc.get("privileged"):
        found.append("privileged")

    for v in svc.get("volumes") or []:
        if isinstance(v, str):
            parts = v.split(":")
            source = parts[0]
            mode = parts[2] if len(parts) > 2 else "rw"
        else:
            source = str(v.get("source", ""))
            mode = "ro" if v.get("read_only") else "rw"
        if "docker.sock" in source:
            found.append("docker_sock")
        elif source == "/":
            found.append("root_mount_ro" if mode == "ro" else "root_mount_rw")

    caps = {c.upper() for c in (svc.get("cap_add") or [])}
    if "ALL" in caps:
        found.append("cap_add_all")
    elif "SYS_ADMIN" in caps:
        found.append("cap_sys_admin")

    if svc.get("pid") == "host":
        found.append("pid_host")
    if svc.get("network_mode") == "host":
        found.append("network_host")

    user = str(svc.get("user", "")).strip()
    if user in ("0", "root", "0:0"):
        found.append("run_as_root")

    for opt in svc.get("security_opt") or []:
        if "seccomp=unconfined" in str(opt):
            found.append("seccomp_off")

    return found


def main(path: str) -> int:
    compose = yaml.safe_load(Path(path).read_text())
    services = compose.get("services", {})
    report: dict[str, dict[str, object]] = {}
    for name, svc in services.items():
        found = audit_service(svc or {})
        report[name] = {
            "находки": found,
            "вес": sum(RULES[f][0] for f in found),
        }

    total = sum(int(r["вес"]) for r in report.values())
    clean = [n for n, r in report.items() if not r["находки"]]
    print(json.dumps({
        "сервисов": len(services),
        "чистых": clean,
        "суммарный_вес": total,
        "отчёт": report,
        "правила": {k: {"вес": v[0], "даёт": v[1], "оправдан": v[2]}
                    for k, v in RULES.items()},
    }, ensure_ascii=False))
    return 1 if total else 0


if __name__ == "__main__":
    sys.exit(main(sys.argv[1] if len(sys.argv) > 1 else "compose.yaml"))
PY

cat > choose.py <<'PY'
"""Выбор средства изоляции по границе доверия."""
from __future__ import annotations

import json

MEANS = [
    ("Container", "нет", "нет", "да", "минимальная"),
    ("Container + userns-remap", "нет", "да", "да", "ломает часть сценариев"),
    ("gVisor", "частично", "да", "да", "часть вызовов не поддержана"),
    ("Kata Containers", "да", "да", "да", "память и время старта"),
    ("Firecracker", "да", "да", "да", "своя инфраструктура"),
    ("Виртуальная машина", "да", "да", "да", "тяжелее по всем статьям"),
    ("Отдельная машина", "да", "да", "НЕТ", "дороже всего"),
]

BOUNDARIES = [
    ("Ваша команда, ваш код", "Container",
     "граница между сервисами, а не против злоумышленника"),
    ("Разные команды организации", "Container + политики",
     "ошибка соседа не должна доходить до вас"),
    ("Зависимости из публичных репозиториев", "Container + сканирование",
     "код УЖЕ внутри границы: container от него не защищает"),
    ("Код пользователей продукта", "Микро-ВМ или ВМ",
     "недоверенный код у общего ядра недопустим"),
    ("Заведомо враждебный код", "Отдельная машина и сеть",
     "побочные каналы не устраняются настройками"),
]

SHARED_ANYWAY = [
    ("Кэш процессора", "данные соседа через измерение времени доступа"),
    ("Предсказатель переходов", "то же семейство атак"),
    ("Гиперпоточность", "соседний поток на том же физическом ядре"),
    ("Полоса памяти и диска", "косвенные сведения о нагрузке соседа"),
    ("Источники точного времени", "измерения, нужные для самих атак"),
]

ESCAPE_CLASSES = [
    ("Уязвимость runtime", "ошибка в runc, containerd, daemon", "редко, но громко"),
    ("Уязвимость ядра", "ошибка в обработке системного вызова", "регулярно"),
    ("Неверная конфигурация", "privileged, сокет, лишние capabilities",
     "ПОДАВЛЯЮЩЕЕ БОЛЬШИНСТВО"),
]


def main() -> None:
    print(f"  {'средство':<26} {'своё ядро':<12} {'свои UID':<10} "
          f"{'общее железо':<14} цена")
    print("  " + "─" * 94)
    for name, kernel, uids, hw, cost in MEANS:
        print(f"  {name:<26} {kernel:<12} {uids:<10} {hw:<14} {cost}")
    only_full = [m[0] for m in MEANS if m[3] == "НЕТ"]
    print()
    print(f"  полное разделение даёт только: {', '.join(only_full)}")

    print()
    print(f"  {'класс escape':<26} {'механизм':<44} частота")
    print("  " + "─" * 96)
    for name, mech, freq in ESCAPE_CLASSES:
        print(f"  {name:<26} {mech:<44} {freq}")

    print()
    print(f"  {'кто выполняет код':<40} {'достаточно':<28} почему")
    print("  " + "─" * 112)
    for who, means, why in BOUNDARIES:
        print(f"  {who:<40} {means:<28} {why}")

    print()
    print(f"  {'общее даже при своём ядре':<30} что может утечь")
    print("  " + "─" * 78)
    for what, leak in SHARED_ANYWAY:
        print(f"  {what:<30} {leak}")

    print()
    print(json.dumps({"средств": len(MEANS), "границ": len(BOUNDARIES),
                      "общее_всегда": len(SHARED_ANYWAY),
                      "классов_escape": len(ESCAPE_CLASSES)}, ensure_ascii=False))


if __name__ == "__main__":
    main()
PY

cat > compose.yaml <<'EOF'
services:
  ci-runner:
    image: runner:1
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    user: "0:0"

  monitoring:
    image: monitor:1
    pid: host
    cap_add: [SYS_ADMIN]

  backup:
    image: backup:1
    volumes:
      - /:/host:ro

  legacy:
    image: legacy:1
    privileged: true
    security_opt:
      - seccomp=unconfined

  app:
    image: app:1
    user: "10001:10001"
    read_only: true
    cap_drop: [ALL]
    security_opt:
      - no-new-privileges:true
EOF

fail=0
ok()  { printf '  ✓ %s\n' "$1"; }
bad() { printf '  ✗ %s\n' "$1"; fail=1; }

printf '\n═══ Требование 1: площадь атаки числом ═══\n'
python3 surface.py > surface.json
python3 - <<'PY'
import json

d = json.load(open("surface.json"))
print(f"    ядро:                     {d['ядро']}")
print(f"    системных вызовов:        {d['системных_вызовов']}")
print(f"    источник числа:           {d['источник']}")
print(f"    capabilities в bounding:  {d['capabilities']}")
print()
print("    Профиль seccomp по умолчанию закрывает несколько десятков вызовов.")
print("    Основная часть интерфейса остаётся доступной — и иначе быть")
print("    не может: приложение обязано работать.")
print()
print("    Это и есть площадь атаки на ОБЩЕЕ ядро: она измерена,")
print("    а не оценена, и не зависит от настроек Docker.")
PY
syscalls="$(python3 -c "import json;print(json.load(open('surface.json'))['системных_вызовов'])")"
caps="$(python3 -c "import json;print(json.load(open('surface.json'))['capabilities'])")"
printf '\n  вызовов: %s, capabilities: %s\n' "$syscalls" "$caps"
[ "$syscalls" -gt 300 ] && [ "$caps" -gt 30 ] \
    && ok "площадь атаки измерена на реальном ядре" \
    || bad "вызовов $syscalls, capabilities $caps"

printf '\n═══ Требование 2: что общее, потому что ядро одно ═══\n'
python3 - <<'PY'
import json

d = json.load(open("surface.json"))
print(f"    {'параметр':<24} значение (одно на хост и все container'ы)")
print("    " + "─" * 72)
for name, value in d["общие_параметры"].items():
    print(f"    {name:<24} {value}")
print()
print(f"    версия ядра: {d['ядро']} — uname -r внутри вернёт то же самое")
print()
print(f"    ограничение непривилегированных user namespace: "
      f"{d['userns_ограничен']}")
print()
print("    Тот же механизм, который УСИЛИВАЕТ изоляцию container'ов")
print("    (userns-remap), ОСЛАБЛЯЕТ защиту хоста, если доступен всем.")
print("    Универсально правильной настройки нет.")
PY
shared="$(python3 -c "
import json
print(len(json.load(open('surface.json'))['общие_параметры']))")"
[ "$shared" -ge 3 ] \
    && ok "общие параметры прочитаны из системы, а не перечислены по памяти" \
    || bad "параметров: $shared"

printf '\n═══ Требование 3: конфигурации, равные root на хосте ═══\n'
python3 audit.py compose.yaml > audit.json; audit_code=$?
python3 - <<'PY'
import json

d = json.load(open("audit.json"))
rules = d["правила"]
print(f"    {'сервис':<14} {'признак':<16} {'вес':>4}  что даёт")
print("    " + "─" * 100)
for name, r in d["отчёт"].items():
    for f in r["находки"]:
        print(f"    {name:<14} {f:<16} {rules[f]['вес']:>4}  {rules[f]['даёт']}")
print()
print(f"    суммарный вес: {d['суммарный_вес']}")
print()
print(f"    {'признак':<16} когда оправдан")
print("    " + "─" * 66)
seen = sorted({f for r in d["отчёт"].values() for f in r["находки"]})
for f in seen:
    print(f"    {f:<16} {rules[f]['оправдан']}")
print()
print("    Всё перечисленное — НЕ уязвимости, а конфигурация.")
print("    Именно этот класс составляет подавляющее большинство")
print("    случаев escape в эксплуатации.")
PY
weight="$(python3 -c "import json;print(json.load(open('audit.json'))['суммарный_вес'])")"
printf '\n  код возврата: %s, суммарный вес находок: %s\n' "$audit_code" "$weight"
[ "$audit_code" -eq 1 ] && [ "$weight" -gt 0 ] \
    && ok "опасные конфигурации найдены, код возврата отличает их от чистой" \
    || bad "код $audit_code, вес $weight"

printf '\n═══ Требование 4: проверка на безопасном сервисе ═══\n'
python3 - <<'PY'
import json

d = json.load(open("audit.json"))
clean = d["чистых"]
print(f"    сервисов всего: {d['сервисов']}")
print(f"    без единой находки: {clean}")
print()
if clean:
    print("    Сервис app не попал в находки: user числовой, read_only,")
    print("    capabilities сняты, повышение привилегий запрещено.")
    print()
    print("    Это проверка инструмента, а не конфигурации: средство,")
    print("    отмечающее ВСЁ, ничем не лучше средства, не отмечающего")
    print("    ничего. Без чистого сервиса находки ничего не значат.")
else:
    print("    ПРОБЛЕМА: чистых сервисов нет — инструмент не различает")
PY
n_clean="$(python3 -c "import json;print(len(json.load(open('audit.json'))['чистых']))")"
[ "$n_clean" -ge 1 ] \
    && ok "есть сервис, проходящий проверку — находки различимы" \
    || bad "чистых сервисов: $n_clean"

printf '\n═══ Требования 5 и 6: выбор средства и что общее всегда ═══\n'
python3 choose.py > choose.log
sed -n '1,40p' choose.log | sed 's/^/  /'
means="$(tail -1 choose.log | python3 -c "import json,sys;print(json.load(sys.stdin)['средств'])")"
always="$(tail -1 choose.log | python3 -c "import json,sys;print(json.load(sys.stdin)['общее_всегда'])")"
printf '\n  средств: %s, общего даже при своём ядре: %s\n' "$means" "$always"
[ "$means" -ge 6 ] && [ "$always" -ge 4 ] \
    && ok "таблица выбора построена; названо общее, не устранимое настройками" \
    || bad "средств $means, общего $always"

printf '\n═══ Требование 7: проверенное и предполагаемое ═══\n'
python3 - <<'PY'
VERIFIED = [
    ("число системных вызовов", "прочитано из заголовка ядра"),
    ("число capabilities", "прочитано из /proc/self/status"),
    ("общие параметры ядра", "прочитаны из /proc/sys"),
    ("ограничение user namespace", "прочитано значение sysctl"),
    ("разбор конфигурации", "выполнен на файле, включая чистый сервис"),
]
NOT_RUN = [
    ("любой container escape", "Docker не установлен; воспроизведение эксплойта не входит в задачу"),
    ("действие профиля seccomp", "требует запущенного container'а"),
    ("поведение userns-remap", "требует настройки daemon"),
    ("побочные каналы", "требует специальных условий и оборудования"),
    ("причина отказа unshare", "среда дополнительно ограничена: mount ns тоже недоступен"),
]
print(f"    {'ВЫПОЛНЕНО':<34} как")
print("    " + "─" * 84)
for name, how in VERIFIED:
    print(f"    {name:<34} {how}")
print()
print(f"    {'НЕ ВЫПОЛНЯЛОСЬ':<34} причина")
print("    " + "─" * 104)
for name, why in NOT_RUN:
    print(f"    {name:<34} {why}")
print()
print(f"    проверено: {len(VERIFIED)}, не проверялось: {len(NOT_RUN)}")
print()
print("    Последняя строка важнее остальных: отказ unshare НЕЛЬЗЯ")
print("    приписать одному лишь параметру apparmor_restrict — среда")
print("    ограничена дополнительно. Подмена «команда не сработала»")
print("    на «сработало ограничение X» — обычный источник ложных")
print("    выводов при отладке изоляции.")
print()
print("    Частота классов escape («подавляющее большинство —")
print("    конфигурация») взята из публичных разборов, а не измерена здесь.")
PY
ok "проверенное отделено от предполагаемого; причина отказа не додумана"

printf '\n═══ ИТОГ ═══\n'
[ "$fail" -eq 0 ] && echo "  все требования выполнены" || echo "  ЕСТЬ ПРОВАЛЫ"
echo "  примечание: Docker не использовался; измерения выполнены на ядре хоста"

cd /tmp && rm -rf /tmp/isolab
exit "$fail"

═══ Требование 1: площадь атаки числом ═══
    ядро:                     6.8.0-88-generic
    системных вызовов:        373
    источник числа:           /usr/include/x86_64-linux-gnu/asm/unistd_64.h
    capabilities в bounding:  41

    Профиль seccomp по умолчанию закрывает несколько десятков вызовов.
    Основная часть интерфейса остаётся доступной — и иначе быть
    не может: приложение обязано работать.

    Это и есть площадь атаки на ОБЩЕЕ ядро: она измерена,
    а не оценена, и не зависит от настроек Docker.

  вызовов: 373, capabilities: 41
  ✓ площадь атаки измерена на реальном ядре

═══ Требование 2: что общее, потому что ядро одно ═══
    параметр                 значение (одно на хост и все container'ы)
    ────────────────────────────────────────────────────────────────────────
    kernel.pid_max           4194304
    vm.max_map_count         1048576
    fs.file-max              9223372036854775807
    kernel.threads-max       ...

    версия ядра: 6.8.0-88-generic — uname -r внутри вернёт то же самое

    ограничение непривилегированных user namespace: 1

    Тот же механизм, который УСИЛИВАЕТ изоляцию container'ов
    (userns-remap), ОСЛАБЛЯЕТ защиту хоста, если доступен всем.
  ✓ общие параметры прочитаны из системы, а не перечислены по памяти

═══ Требование 3: конфигурации, равные root на хосте ═══
    сервис         признак           вес  что даёт
    ────────────────────────────────────────────────────────────────────────────────────────────────────
    ci-runner      docker_sock        10  создание container с любыми параметрами — это root на хосте
    ci-runner      run_as_root         6  UID 0 внутри равен UID 0 снаружи
    monitoring     cap_sys_admin       8  монтирование и значительная часть операций root
    monitoring     pid_host            5  видимость и сигналы всем процессам хоста
    backup         root_mount_ro       4  файловая система хоста доступна на чтение
    legacy         privileged         10  снимает seccomp и AppArmor, возвращает все capabilities
    legacy         seccomp_off         7  фильтр системных вызовов отключён

    суммарный вес: 50

    признак          когда оправдан
    ──────────────────────────────────────────────────────────────────
    cap_sys_admin    почти никогда
    docker_sock      агенты CI, с осознанием последствий
    pid_host         средства наблюдения
    privileged       сборка образов, и то не всегда
    root_mount_ro    резервное копирование
    run_as_root      почти никогда
    seccomp_off      отладка, временно

  код возврата: 1, суммарный вес находок: 50
  ✓ опасные конфигурации найдены, код возврата отличает их от чистой

═══ Требование 4: проверка на безопасном сервисе ═══
    сервисов всего: 5
    без единой находки: ['app']

    Сервис app не попал в находки: user числовой, read_only,
    capabilities сняты, повышение привилегий запрещено.

    Это проверка инструмента, а не конфигурации: средство,
    отмечающее ВСЁ, ничем не лучше средства, не отмечающего
    ничего. Без чистого сервиса находки ничего не значат.
  ✓ есть сервис, проходящий проверку — находки различимы

═══ Требования 5 и 6: выбор средства и что общее всегда ═══
  средство                   своё ядро    свои UID   общее железо   цена
  ──────────────────────────────────────────────────────────────────────────────────────────────
  Container                  нет          нет        да             минимальная
  Container + userns-remap   нет          да         да             ломает часть сценариев
  gVisor                     частично     да         да             часть вызовов не поддержана
  Kata Containers            да           да         да             память и время старта
  Firecracker                да           да         да             своя инфраструктура
  Виртуальная машина         да           да         да             тяжелее по всем статьям
  Отдельная машина           да           да         НЕТ            дороже всего

  полное разделение даёт только: Отдельная машина

  класс escape               механизм                                     частота
  ────────────────────────────────────────────────────────────────────────────────────────────────
  Уязвимость runtime         ошибка в runc, containerd, daemon            редко, но громко
  Уязвимость ядра            ошибка в обработке системного вызова         регулярно
  Неверная конфигурация      privileged, сокет, лишние capabilities       ПОДАВЛЯЮЩЕЕ БОЛЬШИНСТВО
  ...
  ✓ таблица выбора построена; названо общее, не устранимое настройками

═══ Требование 7: проверенное и предполагаемое ═══
    ВЫПОЛНЕНО                          как
    ────────────────────────────────────────────────────────────────────────────────────
    число системных вызовов            прочитано из заголовка ядра
    число capabilities                 прочитано из /proc/self/status
    общие параметры ядра               прочитаны из /proc/sys
    ограничение user namespace         прочитано значение sysctl
    разбор конфигурации                выполнен на файле, включая чистый сервис

    НЕ ВЫПОЛНЯЛОСЬ                     причина
    ────────────────────────────────────────────────────────────────────────────────────────────────────────
    любой container escape             Docker не установлен; воспроизведение эксплойта не входит в задачу
    действие профиля seccomp           требует запущенного container'а
    поведение userns-remap             требует настройки daemon
    побочные каналы                    требует специальных условий и оборудования
    причина отказа unshare             среда дополнительно ограничена: mount ns тоже недоступен

    проверено: 5, не проверялось: 5

    Последняя строка важнее остальных: отказ unshare НЕЛЬЗЯ
    приписать одному лишь параметру apparmor_restrict — среда
    ограничена дополнительно.
  ✓ проверенное отделено от предполагаемого; причина отказа не додумана

═══ ИТОГ ═══
  все требования выполнены
  примечание: Docker не использовался; измерения выполнены на ядре хоста