12.1. Модель угроз

mkdir -p /tmp/tmodel/{sec,app} && cd /tmp/tmodel

cat > app/inventory.py <<'PY'
"""Инвентаризация: что доступно процессу после компрометации.

Выполняет то же, что сделал бы атакующий, получивший выполнение кода:
осматривается и оценивает, куда можно продвинуться.
"""
from __future__ import annotations

import json
import os
import socket
import sys
from pathlib import Path

SECRET_HINTS = ("PASSWORD", "SECRET", "TOKEN", "KEY", "CREDENTIAL", "DSN", "PRIVATE")
SENSITIVE_PATHS = ("/var/run/docker.sock", "/root", "/etc/shadow", "/host")


def read_status(field: str) -> str:
    try:
        for line in Path("/proc/self/status").read_text().splitlines():
            if line.startswith(field + ":"):
                return line.split(maxsplit=1)[1].strip()
    except OSError:
        pass
    return "?"


def env_secrets() -> dict[str, str]:
    """Значения секретов в окружении — не только имена."""
    out = {}
    for key, value in os.environ.items():
        upper = key.upper()
        if any(h in upper for h in SECRET_HINTS) and not upper.endswith("_FILE"):
            out[key] = f"{value[:4]}…({len(value)} симв.)" if value else "(пусто)"
    return out


def secret_files() -> list[str]:
    d = Path("/run/secrets")
    return sorted(p.name for p in d.iterdir()) if d.is_dir() else []


def sensitive_access() -> dict[str, str]:
    out = {}
    for path in SENSITIVE_PATHS:
        p = Path(path)
        if not p.exists():
            continue
        try:
            if p.is_dir():
                list(p.iterdir())
                out[path] = "доступен на чтение"
            else:
                p.read_bytes()[:1]
                out[path] = "доступен на чтение"
        except OSError as exc:
            out[path] = f"отказ: {exc.strerror}"
    return out


def writable_paths() -> list[str]:
    out = []
    for path in ("/", "/app", "/usr/local/bin", "/etc", "/tmp"):
        probe = Path(path) / ".probe-write"
        try:
            probe.write_text("x")
            probe.unlink()
            out.append(path)
        except OSError:
            pass
    return out


def reachable(targets: list[tuple[str, int]]) -> list[str]:
    out = []
    for host, port in targets:
        s = socket.socket()
        s.settimeout(0.5)
        try:
            s.connect((host, port))
            out.append(f"{host}:{port}")
        except OSError:
            pass
        finally:
            s.close()
    return out


def score(report: dict[str, object]) -> int:
    """Грубая оценка поверхности: чем выше, тем хуже."""
    points = 0
    points += 3 if report["uid"] == 0 else 0
    points += 3 * len(report["секреты_в_окружении"])
    points += 5 if "доступен" in str(report["чувствительные_пути"].get("/var/run/docker.sock", "")) else 0
    points += 2 * len([p for p in report["записываемые_пути"] if p != "/tmp"])
    points += 1 if report["capabilities"] != "0000000000000000" else 0
    return points


if __name__ == "__main__":
    report: dict[str, object] = {
        "uid": os.getuid(),
        "capabilities": read_status("CapEff"),
        "no_new_privs": read_status("NoNewPrivs"),
        "секреты_в_окружении": env_secrets(),
        "секреты_файлами": secret_files(),
        "чувствительные_пути": sensitive_access(),
        "записываемые_пути": writable_paths(),
        "доступные_сервисы": reachable([("db", 5432), ("127.0.0.1", 8000)]),
    }
    report["оценка_поверхности"] = score(report)
    print(json.dumps(report, ensure_ascii=False, indent=2))
    sys.exit(0)
PY

printf 'пароль-базы-для-модели' > sec/db_password
chmod 600 sec/db_password

cat > THREAT-MODEL.md <<'TXT'
# Модель угроз: сервис обработки заказов

Дата составления: 2026-07-31. Пересмотр: при изменении состава сервисов
или появлении недоверенного кода.

## 1. Активы

| Актив | Ценность | Где находится |
|---|---|---|
| Персональные данные клиентов | Высокая: регуляторные требования | PostgreSQL |
| Учётные данные к базе | Критическая: доступ ко всем данным | Compose secret |
| Токен платёжного шлюза | Критическая: финансовые операции | Compose secret |
| Доступ во внутреннюю сеть | Высокая: плацдарм для продвижения | Сетевая конфигурация |
| Вычислительные ресурсы | Средняя: майнинг, рассылка спама | Лимиты cgroup |
| Доверие к домену | Средняя: фишинг от нашего имени | Вне контура container |

## 2. Нарушители

| Нарушитель | Возможности | Вероятность | Ущерб |
|---|---|---|---|
| Внешний, без доступа | Запросы к публичному API | Высокая | Высокий |
| Аутентифицированный пользователь | Запросы от своего имени | Средняя | Средний |
| Скомпрометированная зависимость | Выполнение кода при сборке и работе | Низкая | Критический |
| Сосед по узлу | Другой container на том же host | Низкая | Высокий |
| Сотрудник с доступом к CI | Изменение образа | Очень низкая | Критический |

## 3. Векторы, меры, остаточный риск

| # | Вектор | Мера | Остаточный риск |
|---:|---|---|---|
| 1 | Инъекция через API → выполнение кода | Параметризованные запросы, валидация ввода | Уязвимость нулевого дня в зависимости |
| 2 | Выполнение кода → чтение секретов | Secrets файлами, не в переменных окружения | Процесс читает файл сам — устранить нельзя |
| 3 | Выполнение кода → закрепление | read-only корень, tmpfs только для /tmp | Работа целиком в памяти процесса |
| 4 | Выполнение кода → продвижение к базе | Сеть internal, отдельный пользователь БД с минимальными правами | Данные, доступные приложению, скомпрометированы |
| 5 | Выполнение кода → побег на host | non-root, cap-drop=ALL, no-new-privileges, seccomp по умолчанию | Уязвимость ядра: остаётся |
| 6 | Выполнение кода → исчерпание ресурсов узла | Лимиты памяти, CPU, PID | Деградация в пределах лимита |
| 7 | Вредоносная зависимость PyPI | Фиксация версий, lock-файл, сканирование | Атака на пакет до публикации |
| 8 | Утечка секрета в слой образа | BuildKit secret mounts, проверка history в CI | Секрет в логах приложения |
| 9 | Доступ к Docker socket | Socket не монтируется ни в один container | Доступ к socket на самом host |

## 4. Принятые решения

### НЕ применяем gVisor или Kata Containers

**Обоснование:** запускается только собственный код и код известных зависимостей.
Недоверенный код пользователей платформы не выполняется.

**Условие пересмотра:** появление плагинов от сторонних разработчиков,
выполнение пользовательских скриптов, переход на многопользовательскую модель.

### НЕ создаём собственный профиль seccomp

**Обоснование:** профиль Docker по умолчанию блокирует около 44 вызовов,
включая известные векторы побега. Свой профиль требует сопровождения
и ломается при обновлении зависимостей.

**Условие пересмотра:** обнаружение конкретной угрозы, не покрытой умолчанием.

### НЕ подписываем образы

**Обоснование:** реестр внутренний, доступ на запись только у CI.
Подмена образа требует компрометации CI, которая закрывается отдельно.

**Условие пересмотра:** публикация образов наружу, требование аудита.

## 5. Что НЕ покрыто мерами изоляции

- **Уязвимость в самом приложении.** Закрывается тестами, код-ревью
  и статическим анализом. Изоляция ограничивает последствия, а не вероятность.
- **Утечка данных через легитимный API.** Требует авторизации на уровне
  объектов и аудита обращений.
- **Компрометация конвейера сборки.** Отдельная модель угроз.
- **Атака на цепочку поставок до публикации пакета.** Частично закрывается
  фиксацией версий, полностью — нет.
- **Уязвимость нулевого дня в ядре.** Принимается как остаточный риск;
  снижается своевременным обновлением ядра host.
TXT

cat > measures.py <<'PY'
"""Оценка мер: цена, эффект, закрываемые векторы."""
from __future__ import annotations

MEASURES = [
    ("USER 10001 в образе",             1, 4, [5]),
    ("--cap-drop=ALL",                  1, 4, [5]),
    ("--security-opt no-new-privileges",1, 3, [5]),
    ("read-only + tmpfs",               2, 4, [3]),
    ("secrets файлами",                 2, 4, [2, 8]),
    ("лимиты памяти/CPU/PID",           1, 3, [6]),
    ("сеть internal для данных",        3, 4, [4]),
    ("фиксация версий + сканирование",  2, 4, [7]),
    ("BuildKit secret mounts",          2, 4, [8]),
    ("socket не монтируется",           1, 5, [9]),
    ("свой профиль seccomp",            5, 3, [5]),
    ("подпись образов",                 4, 3, [7]),
    ("gVisor / Kata",                   5, 5, [5]),
]


def decision(cost: int, effect: int) -> str:
    ratio = effect / cost
    if ratio >= 2.0:
        return "делать сразу"
    if ratio >= 1.0:
        return "делать"
    return "по модели угроз"


if __name__ == "__main__":
    print(f"  {'мера':<34} {'цена':>4} {'эфф.':>5} {'векторы':>9}  решение")
    print("  " + "─" * 74)
    applied = []
    for name, cost, effect, vectors in sorted(MEASURES, key=lambda m: -m[2] / m[1]):
        d = decision(cost, effect)
        print(f"  {name:<34} {cost:>4} {effect:>5} {str(vectors):>9}  {d}")
        if d == "делать сразу":
            applied.append(name)
    print()
    print(f"  применяем безусловно: {len(applied)} мер")
    covered = sorted({v for n, c, e, vs in MEASURES if e / c >= 2.0 for v in vs})
    print(f"  закрываемые векторы: {covered}")
    print(f"  вектор 1 (уязвимость приложения) изоляцией НЕ закрывается")
PY

cat > compose.yaml <<'EOF'
name: tmodel

services:
  # Конфигурация ДО применения мер
  before:
    image: python:3.13-slim
    command: ["sleep", "300"]
    environment:
      DATABASE_PASSWORD: "пароль-в-переменной"
      PAYMENT_API_TOKEN: "tok-live-abcdef123456"
    volumes:
      - ./app/inventory.py:/inventory.py:ro
      - /var/run/docker.sock:/var/run/docker.sock
    networks: [everything]

  # Конфигурация ПОСЛЕ применения мер
  after:
    image: python:3.13-slim
    command: ["sleep", "300"]
    user: "10001:10001"
    read_only: true
    tmpfs:
      - /tmp:size=8m,mode=1777,uid=10001,gid=10001
    cap_drop: [ALL]
    security_opt:
      - no-new-privileges:true
    pids_limit: 64
    environment:
      DB_PASSWORD_FILE: /run/secrets/db_password
    secrets:
      - db_password
    volumes:
      - ./app/inventory.py:/inventory.py:ro
    networks: [isolated]
    deploy:
      resources:
        limits:
          memory: 128M
          cpus: "0.5"

networks:
  everything:
  isolated:
    internal: true

secrets:
  db_password:
    file: ./sec/db_password
EOF

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

printf '\n═══ Требования 1-3: структура модели ═══\n'
python3 - <<'PY'
import pathlib, re
text = pathlib.Path("THREAT-MODEL.md").read_text()
checks = {
    "раздел «Активы»":            r"## 1\. Активы",
    "раздел «Нарушители»":        r"## 2\. Нарушители",
    "векторы с остаточным риском": r"Остаточный риск",
    "раздел «Принятые решения»":  r"## 4\. Принятые решения",
    "раздел «Что НЕ покрыто»":    r"## 5\. Что НЕ покрыто",
    "условия пересмотра":         r"Условие пересмотра",
}
missing = []
for name, pat in checks.items():
    found = bool(re.search(pat, text))
    print(f"    {'✓' if found else '✗'} {name}")
    if not found:
        missing.append(name)

vectors = re.findall(r"^\| (\d+) \| (.+?) \| (.+?) \| (.+?) \|$", text, re.M)
print(f"    векторов: {len(vectors)}")
empty_residual = [v[0] for v in vectors if not v[3].strip() or v[3].strip() == "—"]
print(f"    векторов без остаточного риска: {len(empty_residual)}")

import sys
sys.exit(1 if missing or empty_residual or len(vectors) < 5 else 0)
PY
[ $? -eq 0 ] && ok "модель полна, у каждого вектора указан остаточный риск" \
    || bad "модель неполна"

printf '\n═══ Требование 6: оценка мер ═══\n'
python3 measures.py

printf '\n═══ Требования 4-5: инвентаризация ДО и ПОСЛЕ ═══\n'
docker compose up -d > /dev/null 2>&1
sleep 3

for svc in before after; do
    printf '\n  ── конфигурация %s ──\n' "$svc"
    docker compose exec -T "$svc" python /inventory.py 2>/dev/null \
        | python3 -c "
import json, sys
r = json.load(sys.stdin)
print(f\"    uid: {r['uid']}, capabilities: {r['capabilities']}, no_new_privs: {r['no_new_privs']}\")
print(f\"    секреты в окружении: {list(r['секреты_в_окружении']) or 'нет'}\")
print(f\"    секреты файлами:     {r['секреты_файлами'] or 'нет'}\")
print(f\"    чувствительные пути: {r['чувствительные_пути'] or 'нет доступа'}\")
print(f\"    записываемые пути:   {r['записываемые_пути']}\")
print(f\"    ОЦЕНКА ПОВЕРХНОСТИ:  {r['оценка_поверхности']}\")
"
done

score_before="$(docker compose exec -T before python /inventory.py 2>/dev/null \
    | python3 -c "import json,sys; print(json.load(sys.stdin)['оценка_поверхности'])")"
score_after="$(docker compose exec -T after python /inventory.py 2>/dev/null \
    | python3 -c "import json,sys; print(json.load(sys.stdin)['оценка_поверхности'])")"

printf '\n    оценка до: %s, после: %s\n' "$score_before" "$score_after"
[ "$score_before" -gt "$score_after" ] && ok "поверхность атаки сокращена измеримо" \
    || bad "различия нет: до=$score_before после=$score_after"
[ "$score_after" -le 3 ] && ok "остаточная поверхность минимальна" \
    || bad "остаточная оценка высока: $score_after"

printf '\n═══ Остаточный риск: что осталось доступным ═══\n'
docker compose exec -T after sh -c 'cat /run/secrets/db_password' 2>/dev/null | sed 's/^/    пароль базы читается процессом: /'
cat <<'TXT'
    Это НЕ дефект конфигурации: приложение обязано читать пароль,
    иначе не подключится к базе. Мера сократила поверхность
    (пароля нет в окружении и в docker inspect), но не устранила
    угрозу — что и зафиксировано в модели как остаточный риск вектора 2.
TXT
ok "остаточный риск продемонстрирован, а не скрыт"

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

docker compose down > /dev/null 2>&1
cd /tmp && rm -rf /tmp/tmodel
exit "$fail"

═══ Требования 1-3: структура модели ═══
    ✓ раздел «Активы»
    ✓ раздел «Нарушители»
    ✓ векторы с остаточным риском
    ✓ раздел «Принятые решения»
    ✓ раздел «Что НЕ покрыто»
    ✓ условия пересмотра
    векторов: 9
    векторов без остаточного риска: 0
  ✓ модель полна, у каждого вектора указан остаточный риск

═══ Требование 6: оценка мер ═══
  мера                                 цена  эфф.   векторы  решение
  ──────────────────────────────────────────────────────────────────────────
  socket не монтируется                   1     5       [9]  делать сразу
  USER 10001 в образе                     1     4       [5]  делать сразу
  --cap-drop=ALL                          1     4       [5]  делать сразу
  --security-opt no-new-privileges        1     3       [5]  делать сразу
  лимиты памяти/CPU/PID                   1     3       [6]  делать сразу
  read-only + tmpfs                       2     4       [3]  делать сразу
  secrets файлами                         2     4    [2, 8]  делать сразу
  фиксация версий + сканирование          2     4       [7]  делать сразу
  BuildKit secret mounts                  2     4       [8]  делать сразу
  сеть internal для данных                3     4       [4]  делать
  gVisor / Kata                           5     5       [5]  делать
  подпись образов                         4     3       [7]  по модели угроз
  свой профиль seccomp                    5     3       [5]  по модели угроз

  применяем безусловно: 9 мер
  закрываемые векторы: [2, 3, 5, 6, 7, 8, 9]
  вектор 1 (уязвимость приложения) изоляцией НЕ закрывается

═══ Требования 4-5: инвентаризация ДО и ПОСЛЕ ═══

  ── конфигурация before ──
    uid: 0, capabilities: 00000000a80425fb, no_new_privs: 0
    секреты в окружении: ['DATABASE_PASSWORD', 'PAYMENT_API_TOKEN']
    секреты файлами:     нет
    чувствительные пути: {'/var/run/docker.sock': 'доступен на чтение', '/root': 'доступен на чтение'}
    записываемые пути:   ['/', '/app', '/usr/local/bin', '/etc', '/tmp']
    ОЦЕНКА ПОВЕРХНОСТИ:  23

  ── конфигурация after ──
    uid: 10001, capabilities: 0000000000000000, no_new_privs: 1
    секреты в окружении: нет
    секреты файлами:     ['db_password']
    чувствительные пути: нет доступа
    записываемые пути:   ['/tmp']
    ОЦЕНКА ПОВЕРХНОСТИ:  0

    оценка до: 23, после: 0
  ✓ поверхность атаки сокращена измеримо
  ✓ остаточная поверхность минимальна

═══ Остаточный риск: что осталось доступным ═══
    пароль базы читается процессом: пароль-базы-для-модели
    Это НЕ дефект конфигурации: приложение обязано читать пароль,
    иначе не подключится к базе. Мера сократила поверхность
    (пароля нет в окружении и в docker inspect), но не устранила
    угрозу — что и зафиксировано в модели как остаточный риск вектора 2.
  ✓ остаточный риск продемонстрирован, а не скрыт

═══ ИТОГ ═══
  все требования выполнены