12.3. Пользователи и namespaces

   container            host
   ─────────            ────
   UID 0        ──►     UID 100000
   UID 1        ──►     UID 100001
   UID 1000     ──►     UID 101000
   ...                  ...
   UID 65535    ──►     UID 165535

/etc/subuid    dockremap:100000:65536
/etc/subgid    dockremap:100000:65536

{
  "userns-remap": "default"
}

docker run --userns=host ...

rootful:   dockerd (root) ──► container (UID 0 = root на host)
rootless:  dockerd (evg)  ──► container (UID 0 = UID 100000 на host)
                │
                └── сам демон не имеет привилегий

0 100000 65536
│    │      └── размер диапазона
│    └───────── первый UID на host
└────────────── первый UID в namespace

cat /proc/self/uid_map

mkdir -p /tmp/users && cd /tmp/users

cat > probe.py <<'PY'
"""Что доступно процессу: UID, capabilities, привилегированные операции."""
from __future__ import annotations

import ctypes
import ctypes.util
import json
import os
from pathlib import Path

CAP_NAMES = {
    0: "CHOWN", 1: "DAC_OVERRIDE", 2: "DAC_READ_SEARCH", 3: "FOWNER", 4: "FSETID",
    5: "KILL", 6: "SETGID", 7: "SETUID", 8: "SETPCAP", 9: "LINUX_IMMUTABLE",
    10: "NET_BIND_SERVICE", 11: "NET_BROADCAST", 12: "NET_ADMIN", 13: "NET_RAW",
    14: "IPC_LOCK", 16: "SYS_MODULE", 17: "SYS_RAWIO", 18: "SYS_CHROOT",
    19: "SYS_PTRACE", 21: "SYS_ADMIN", 22: "SYS_BOOT", 23: "SYS_NICE",
    24: "SYS_RESOURCE", 25: "SYS_TIME", 27: "MKNOD", 29: "AUDIT_WRITE", 31: "SETFCAP",
}


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


def caps() -> list[str]:
    mask = int(status("CapEff"), 16)
    return [n for b, n in sorted(CAP_NAMES.items()) if mask & (1 << b)]


def uid_map() -> str:
    try:
        return Path("/proc/self/uid_map").read_text().strip()
    except OSError:
        return "нет"


def try_mount() -> str:
    """Монтирование требует CAP_SYS_ADMIN."""
    libc = ctypes.CDLL(ctypes.util.find_library("c"), use_errno=True)
    os.makedirs("/tmp/mnt-probe", exist_ok=True)
    res = libc.mount(b"tmpfs", b"/tmp/mnt-probe", b"tmpfs", 0, None)
    if res == 0:
        libc.umount(b"/tmp/mnt-probe")
        return "разрешено"
    return f"отказ (errno {ctypes.get_errno()})"


def try_settime() -> str:
    """Изменение времени требует CAP_SYS_TIME."""
    libc = ctypes.CDLL(ctypes.util.find_library("c"), use_errno=True)

    class Timespec(ctypes.Structure):
        _fields_ = [("tv_sec", ctypes.c_long), ("tv_nsec", ctypes.c_long)]

    ts = Timespec()
    libc.clock_gettime(0, ctypes.byref(ts))
    res = libc.clock_settime(0, ctypes.byref(ts))
    return "разрешено" if res == 0 else f"отказ (errno {ctypes.get_errno()})"


def try_module() -> str:
    """Загрузка модуля требует CAP_SYS_MODULE."""
    try:
        Path("/proc/sys/kernel/modprobe").read_text()
        return "чтение доступно; загрузка требует SYS_MODULE"
    except OSError as exc:
        return f"отказ: {exc.strerror}"


print(json.dumps({
    "uid": os.getuid(),
    "euid": os.geteuid(),
    "uid_map": uid_map(),
    "capabilities": caps(),
    "capabilities_всего": len(caps()),
    "монтирование tmpfs": try_mount(),
    "изменение времени": try_settime(),
    "модули ядра": try_module(),
}, ensure_ascii=False, indent=2))
PY

echo "═══ root в container по умолчанию ═══"
docker run --rm -v "$PWD/probe.py:/p.py:ro" python:3.13-slim python /p.py

═══ root в container по умолчанию ═══
{
  "uid": 0,
  "euid": 0,
  "uid_map": "0          0 4294967295",
  "capabilities": [
    "CHOWN", "DAC_OVERRIDE", "FOWNER", "FSETID", "KILL", "SETGID", "SETUID",
    "SETPCAP", "NET_BIND_SERVICE", "NET_RAW", "SYS_CHROOT", "MKNOD",
    "AUDIT_WRITE", "SETFCAP"
  ],
  "capabilities_всего": 14,
  "монтирование tmpfs": "отказ (errno 1)",
  "изменение времени": "отказ (errno 1)",
  "модули ядра": "чтение доступно; загрузка требует SYS_MODULE"
}

cd /tmp/users
echo "═══ тот же образ, но --user 10001 ═══"
docker run --rm --user 10001:10001 -v "$PWD/probe.py:/p.py:ro" \
    python:3.13-slim python /p.py | python3 -c "
import json, sys
d = json.load(sys.stdin)
print(f\"  uid: {d['uid']}, capabilities: {d['capabilities_всего']}\")
print(f\"  список: {d['capabilities'] or 'пусто'}\")
print(f\"  монтирование: {d['монтирование tmpfs']}\")
"

echo "═══ и с --cap-drop=ALL от root ═══"
docker run --rm --cap-drop=ALL -v "$PWD/probe.py:/p.py:ro" \
    python:3.13-slim python /p.py | python3 -c "
import json, sys
d = json.load(sys.stdin)
print(f\"  uid: {d['uid']}, capabilities: {d['capabilities_всего']}\")
print(f\"  монтирование: {d['монтирование tmpfs']}\")
"

═══ тот же образ, но --user 10001 ═══
  uid: 10001, capabilities: 0
  список: пусто
  монтирование: отказ (errno 1)
═══ и с --cap-drop=ALL от root ═══
  uid: 0, capabilities: 0
  монтирование: отказ (errno 1)

cd /tmp/users
mkdir -p shared && chmod 777 shared

echo "═══ файл, созданный root в container ═══"
docker run --rm -v "$PWD/shared:/data" alpine:3.21 \
    sh -c 'echo x > /data/from-root.txt'
ls -ln shared/from-root.txt | awk '{print "  владелец: " $3 ":" $4}'

echo "═══ файл, созданный UID 10001 ═══"
docker run --rm --user 10001:10001 -v "$PWD/shared:/data" alpine:3.21 \
    sh -c 'echo x > /data/from-user.txt'
ls -ln shared/from-user.txt | awk '{print "  владелец: " $3 ":" $4}'

echo "═══ удаление обычным пользователем ═══"
rm -f shared/from-user.txt 2>&1 && echo "  from-user.txt: удалён" || echo "  from-user.txt: отказ"
rm -f shared/from-root.txt 2>&1 | tail -1 | sed 's/^/  from-root.txt: /' \
    || echo "  from-root.txt: удалён"

sudo rm -rf shared 2>/dev/null || rm -rf shared

═══ файл, созданный root в container ═══
  владелец: 0:0
═══ файл, созданный UID 10001 ═══
  владелец: 10001:10001
═══ удаление обычным пользователем ═══
  from-user.txt: удалён
  from-root.txt: rm: cannot remove 'shared/from-root.txt': Permission denied

cd /tmp/users
echo "═══ uid_map на host ═══"
cat /proc/self/uid_map | sed 's/^/  /'

echo "═══ uid_map в обычном container ═══"
docker run --rm alpine:3.21 cat /proc/self/uid_map | sed 's/^/  /'

echo "═══ как читать ═══"
cat <<'TXT'
  формат: <первый UID внутри> <первый UID снаружи> <размер диапазона>

  "0 0 4294967295"        отображения нет: UID совпадают
  "0 100000 65536"        UID 0-65535 внутри = UID 100000-165535 снаружи
TXT

echo "═══ настройки subuid на этой машине ═══"
if [ -f /etc/subuid ]; then
    head -3 /etc/subuid | sed 's/^/  /'
else
    echo "  /etc/subuid отсутствует"
fi

═══ uid_map на host ═══
           0          0 4294967295
═══ uid_map в обычном container ═══
           0          0 4294967295
═══ как читать ═══
  формат: <первый UID внутри> <первый UID снаружи> <размер диапазона>

  "0 0 4294967295"        отображения нет: UID совпадают
  "0 100000 65536"        UID 0-65535 внутри = UID 100000-165535 снаружи
═══ настройки subuid на этой машине ═══
  evg:100000:65536

cd /tmp/users
cat > setup-userns.md <<'TXT'
# Включение userns-remap

## 1. Конфигурация демона

/etc/docker/daemon.json:

    {
      "userns-remap": "default"
    }

Значение "default" создаёт пользователя dockremap автоматически.
Можно указать существующего пользователя: "userns-remap": "myuser".

## 2. Перезапуск демона

    sudo systemctl restart docker

## 3. Проверка

    docker info --format '{{.SecurityOptions}}'
    # должно появиться: name=userns

    docker run --rm alpine cat /proc/self/uid_map
    # должно быть: 0 100000 65536 (вместо 0 0 4294967295)

## 4. Что сломается

| Проблема | Причина | Решение |
|---|---|---|
| Существующие volumes недоступны | Файлы принадлежат UID 0, процесс — 100000 | chown -R 100000:100000 или пересоздать |
| --privileged не работает | Несовместим с userns | --userns=host для этого container |
| --pid=host, --net=host ограничены | Требуют совпадения namespace | --userns=host |
| Образы скачиваются заново | Отдельное хранилище для remap | Ожидаемо, разово |

## 5. Отключение для отдельного container

    docker run --userns=host ...

Возвращает прежнее поведение и прежние риски. Применять точечно.

## 6. Проверка после включения

    # файл, созданный root в container, на host принадлежит 100000
    docker run --rm -v /tmp/probe:/data alpine sh -c 'touch /data/f'
    ls -ln /tmp/probe/f    # владелец 100000, а не 0
TXT

echo "═══ инструкция подготовлена ═══"
head -12 setup-userns.md | sed 's/^/  /'

echo
echo "═══ текущее состояние демона ═══"
if docker info --format '{{json .SecurityOptions}}' 2>/dev/null | grep -q userns; then
    echo "  userns-remap ВКЛЮЧЁН"
    docker run --rm alpine:3.21 cat /proc/self/uid_map | sed 's/^/    uid_map: /'
else
    echo "  userns-remap выключен"
    echo "  (включение требует правки daemon.json и перезапуска демона)"
fi

═══ инструкция подготовлена ═══
  # Включение userns-remap
  
  ## 1. Конфигурация демона
  
  /etc/docker/daemon.json:
  
      {
        "userns-remap": "default"
      }
  
  Значение "default" создаёт пользователя dockremap автоматически.
  Можно указать существующего пользователя: "userns-remap": "myuser".

═══ текущее состояние демона ═══
  userns-remap выключен
  (включение требует правки daemon.json и перезапуска демона)

cd /tmp/users
echo "═══ создаём user namespace вручную ═══"
if command -v unshare > /dev/null 2>&1; then
    echo "  на host:"
    printf '    UID: %s, uid_map: %s\n' "$(id -u)" "$(cat /proc/self/uid_map | tr -s ' ')"

    echo "  внутри нового user namespace:"
    unshare --user --map-root-user sh -c '
        printf "    UID: %s (внутри кажемся root)\n" "$(id -u)"
        printf "    uid_map: %s\n" "$(cat /proc/self/uid_map | tr -s " ")"
        printf "    capabilities: %s\n" "$(grep CapEff /proc/self/status | awk "{print \$2}")"
        printf "    чтение /etc/shadow: "
        cat /etc/shadow > /dev/null 2>&1 && echo "разрешено" || echo "ОТКАЗ"
    ' 2>/dev/null || echo "    (unshare требует поддержки в ядре)"
else
    echo "  утилита unshare недоступна"
fi

echo "═══ что это показывает ═══"
cat <<'TXT'
  Внутри namespace процесс видит себя как root (UID 0) и имеет
  полный набор capabilities. Но uid_map показывает отображение
  на реальный UID, и файлы root по-прежнему недоступны.

  Это ровно та модель, которую даёт userns-remap и rootless:
  root внутри — обычный пользователь снаружи.
TXT

═══ создаём user namespace вручную ═══
  на host:
    UID: 1000, uid_map: 0 0 4294967295
  внутри нового user namespace:
    UID: 0 (внутри кажемся root)
    uid_map: 0 1000 1
    capabilities: 000001ffffffffff
    чтение /etc/shadow: ОТКАЗ
═══ что это показывает ═══
  Внутри namespace процесс видит себя как root (UID 0) и имеет
  полный набор capabilities. Но uid_map показывает отображение
  на реальный UID, и файлы root по-прежнему недоступны.

  Это ровно та модель, которую даёт userns-remap и rootless:
  root внутри — обычный пользователь снаружи.

cd /tmp/users
cat > compare.py <<'PY'
"""Сравнение подходов к ограничению привилегий."""
from __future__ import annotations

MODELS = {
    "USER в образе": {
        "что защищает": "процесс не root внутри container",
        "root внутри возможен": "нет",
        "побег даёт": "UID приложения на host",
        "сокет даёт": "root на host",
        "сложность": 1,
        "совместимость": 5,
        "кто настраивает": "автор образа",
    },
    "userns-remap": {
        "что защищает": "UID container отображён в другой диапазон",
        "root внутри возможен": "да, но безвредный",
        "побег даёт": "смещённый UID (100000+)",
        "сокет даёт": "root на host",
        "сложность": 3,
        "совместимость": 3,
        "кто настраивает": "администратор узла",
    },
    "rootless": {
        "что защищает": "сам демон не имеет привилегий",
        "root внутри возможен": "да, но безвредный",
        "побег даёт": "смещённый UID",
        "сокет даёт": "права пользователя",
        "сложность": 4,
        "совместимость": 3,
        "кто настраивает": "пользователь",
    },
}

FIELDS = ["что защищает", "root внутри возможен", "побег даёт",
          "сокет даёт", "кто настраивает"]

print(f"  {'свойство':<24} " + " ".join(f"{name:<26}" for name in MODELS))
print("  " + "─" * 104)
for field in FIELDS:
    row = f"  {field:<24} "
    row += " ".join(f"{MODELS[name][field]:<26}" for name in MODELS)
    print(row[:106])

print()
print(f"  {'сложность (1-5)':<24} " +
      " ".join(f"{str(MODELS[n]['сложность']):<26}" for n in MODELS))
print(f"  {'совместимость (1-5)':<24} " +
      " ".join(f"{str(MODELS[n]['совместимость']):<26}" for n in MODELS))

print()
print("  Ключевая строка — «сокет даёт»: только rootless снимает этот вектор.")
print("  Подходы НЕ взаимоисключающие: USER применяют всегда,")
print("  остальное — дополнительно по модели угроз.")
PY

python3 compare.py

  свойство                 USER в образе              userns-remap               rootless                  
  ────────────────────────────────────────────────────────────────────────────────────────────────────────
  что защищает             процесс не root внутри con UID container отображён в  сам демон не имеет привиле
  root внутри возможен     нет                        да, но безвредный          да, но безвредный         
  побег даёт               UID приложения на host     смещённый UID (100000+)    смещённый UID             
  сокет даёт               root на host               root на host               права пользователя        
  кто настраивает          автор образа               администратор узла         пользователь              

  сложность (1-5)          1                          3                          4                         
  совместимость (1-5)      5                          3                          3                         

  Ключевая строка — «сокет даёт»: только rootless снимает этот вектор.
  Подходы НЕ взаимоисключающие: USER применяют всегда,
  остальное — дополнительно по модели угроз.

cd /tmp/users
cat > check-model.sh <<'SH'
#!/usr/bin/env bash
# Определяет, какая модель ограничения привилегий действует на системе.
set -uo pipefail

printf '\n── Демон ──\n'
if docker info --format '{{json .SecurityOptions}}' 2>/dev/null | grep -q rootless; then
    printf '  режим: ROOTLESS\n'
    printf '  сокет даёт: права вашего пользователя\n'
    mode="rootless"
elif docker info --format '{{json .SecurityOptions}}' 2>/dev/null | grep -q userns; then
    printf '  режим: rootful + userns-remap\n'
    printf '  сокет даёт: root на host\n'
    mode="userns"
else
    printf '  режим: rootful (демон работает от root)\n'
    printf '  сокет даёт: root на host\n'
    mode="rootful"
fi

printf '\n── Отображение UID ──\n'
map="$(docker run --rm alpine:3.21 cat /proc/self/uid_map 2>/dev/null | tr -s ' ' | sed 's/^ //')"
printf '  uid_map в container: %s\n' "$map"
case "$map" in
    "0 0 "*) printf '  → отображения нет: UID 0 внутри = UID 0 на host\n' ;;
    *)       printf '  → отображение действует\n' ;;
esac

printf '\n── Проверка: файл от root в container ──\n'
probe="$(mktemp -d)"
docker run --rm -v "$probe:/data" alpine:3.21 sh -c 'echo x > /data/f' 2>/dev/null
owner="$(stat -c '%u:%g' "$probe/f" 2>/dev/null || echo '?')"
printf '  владелец на host: %s\n' "$owner"
case "$owner" in
    "0:0") printf '  → UID 0 в container = настоящий root\n' ;;
    "?")   printf '  → проверка не удалась\n' ;;
    *)     printf '  → UID отображён, root в container безвреден\n' ;;
esac
rm -rf "$probe" 2>/dev/null || sudo rm -rf "$probe" 2>/dev/null

printf '\n── Рекомендации ──\n'
case "$mode" in
    rootful)
        printf '  1. USER в образе — обязательно (сейчас единственная защита)\n'
        printf '  2. Рассмотреть userns-remap для узла\n'
        printf '  3. Rootless — если возможно по совместимости\n'
        printf '  4. Не монтировать сокет никуда\n'
        ;;
    userns)
        printf '  1. USER в образе — всё равно применять\n'
        printf '  2. Сокет по-прежнему опасен: не монтировать\n'
        ;;
    rootless)
        printf '  1. USER в образе — всё равно применять\n'
        printf '  2. Основные векторы закрыты\n'
        ;;
esac
SH
chmod +x check-model.sh
./check-model.sh

cd /tmp && rm -rf /tmp/users

── Демон ──
  режим: rootful (демон работает от root)
  сокет даёт: root на host

── Отображение UID ──
  uid_map в container: 0 0 4294967295
  → отображения нет: UID 0 внутри = UID 0 на host

── Проверка: файл от root в container ──
  владелец на host: 0:0
  → UID 0 в container = настоящий root

── Рекомендации ──
  1. USER в образе — обязательно (сейчас единственная защита)
  2. Рассмотреть userns-remap для узла
  3. Rootless — если возможно по совместимости
  4. Не монтировать сокет никуда

docker run --rm alpine:3.21 sh -c '
    echo "uid: $(id -u)"
    echo "uid_map: $(cat /proc/self/uid_map)"
    echo "capabilities: $(grep CapEff /proc/self/status | awk "{print \$2}")"
'