11.2. Runtime hardening

USER 10001:10001

docker run --user 10001:10001 ...

docker run --cap-drop=ALL --cap-add=NET_BIND_SERVICE ...

docker run --security-opt=no-new-privileges ...

атакующий получил выполнение кода от appuser (UID 10001)
   │
   ├── без флага: находит setuid-бинарник (например, /usr/bin/passwd)
   │              и пытается через него повысить привилегии
   │
   └── с флагом:  setuid-бит игнорируется, повышение невозможно

docker run --read-only --tmpfs /tmp:size=32m,mode=1777 ...

docker run -d --name probe образ        # без --read-only
# ... нагрузка ...
docker diff probe                        # список записанных путей

docker run --pids-limit 100 ...

pids_limit ≈ (число worker'ов + 2) × (потоков на worker + 2)

CapPrm: 0000000000000000
CapEff: 0000000000000000
CapBnd: 0000000000000000

grep NoNewPrivs /proc/self/status

echo "═══ пользователь и capabilities по умолчанию ═══"
docker run --rm python:3.13-slim sh -c '
    echo "  UID: $(id -u)"
    echo "  CapEff: $(grep CapEff /proc/self/status | awk "{print \$2}")"
    echo "  NoNewPrivs: $(grep NoNewPrivs /proc/self/status | awk "{print \$2}")"
'

echo "═══ расшифровка набора ═══"
docker run --rm python:3.13-slim sh -c '
    caps=$(grep CapEff /proc/self/status | awk "{print \$2}")
    python3 -c "
import sys
KNOWN = {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\",15:\"IPC_OWNER\",16:\"SYS_MODULE\",17:\"SYS_RAWIO\",
         18:\"SYS_CHROOT\",19:\"SYS_PTRACE\",20:\"SYS_PACCT\",21:\"SYS_ADMIN\",
         22:\"SYS_BOOT\",23:\"SYS_NICE\",24:\"SYS_RESOURCE\",25:\"SYS_TIME\",
         26:\"SYS_TTY_CONFIG\",27:\"MKNOD\",28:\"LEASE\",29:\"AUDIT_WRITE\",
         30:\"AUDIT_CONTROL\",31:\"SETFCAP\"}
mask = int(\"$caps\", 16)
have = [n for b, n in KNOWN.items() if mask & (1 << b)]
print(f\"  всего: {len(have)}\")
print(\"  \" + \", \".join(have))
"
'

═══ пользователь и capabilities по умолчанию ═══
  UID: 0
  CapEff: 00000000a80425fb
  NoNewPrivs: 0
═══ расшифровка набора ═══
  всего: 14
  CHOWN, DAC_OVERRIDE, FOWNER, FSETID, KILL, SETGID, SETUID, SETPCAP, NET_BIND_SERVICE, NET_RAW, SYS_CHROOT, MKNOD, AUDIT_WRITE, SETFCAP
</text>

echo "═══ с --cap-drop=ALL ═══"
docker run --rm --cap-drop=ALL python:3.13-slim sh -c '
    echo "  UID: $(id -u)"
    echo "  CapEff: $(grep CapEff /proc/self/status | awk "{print \$2}")"
    echo "  CapBnd: $(grep CapBnd /proc/self/status | awk "{print \$2}")"
'

echo "═══ что перестало работать ═══"
docker run --rm --cap-drop=ALL python:3.13-slim sh -c '
    chown nobody /tmp 2>&1 | head -1 | sed "s/^/  chown: /"
    python3 -c "
import socket
s = socket.socket()
try:
    s.bind((\"0.0.0.0\", 80)); print(\"  порт 80: занят\")
except PermissionError:
    print(\"  порт 80: PermissionError — нужен NET_BIND_SERVICE\")
finally:
    s.close()
"
'

echo "═══ а что работает ═══"
docker run --rm --cap-drop=ALL python:3.13-slim python3 -c "
import socket
s = socket.socket()
s.bind(('0.0.0.0', 8000))
print('  порт 8000: занят без единой capability')
s.close()
"

═══ с --cap-drop=ALL ═══
  UID: 0
  CapEff: 0000000000000000
  CapBnd: 0000000000000000
═══ что перестало работать ═══
  chown: chown: changing ownership of '/tmp': Operation not permitted
  порт 80: PermissionError — нужен NET_BIND_SERVICE
═══ а что работает ═══
  порт 8000: занят без единой capability

mkdir -p /tmp/hard && cd /tmp/hard

cat > Dockerfile.setuid <<'EOF'
FROM python:3.13-slim
# Демонстрация: setuid-программа, печатающая эффективный UID
RUN printf '#include <stdio.h>\n#include <unistd.h>\nint main(){printf("euid=%%d\\n", geteuid()); return 0;}\n' > /tmp/whoami.c \
    && apt-get update && apt-get install -y --no-install-recommends gcc > /dev/null \
    && gcc -o /usr/local/bin/show-euid /tmp/whoami.c \
    && chown root:root /usr/local/bin/show-euid \
    && chmod u+s /usr/local/bin/show-euid \
    && apt-get purge -y gcc > /dev/null && apt-get autoremove -y > /dev/null \
    && rm -rf /var/lib/apt/lists/* /tmp/whoami.c
RUN useradd --create-home --uid 10001 appuser
USER 10001:10001
CMD ["show-euid"]
EOF

docker build -q -f Dockerfile.setuid -t hard:setuid . > /dev/null

echo "═══ без no-new-privileges ═══"
docker run --rm hard:setuid 2>&1 | sed 's/^/  /'

echo "═══ с no-new-privileges ═══"
docker run --rm --security-opt=no-new-privileges hard:setuid 2>&1 | sed 's/^/  /'

echo "═══ флаг виден процессу ═══"
docker run --rm --security-opt=no-new-privileges python:3.13-slim \
    sh -c 'grep NoNewPrivs /proc/self/status' | sed 's/^/  /'

═══ без no-new-privileges ═══
  euid=0
═══ с no-new-privileges ═══
  euid=10001
═══ флаг виден процессу ═══
  NoNewPrivs:	1

cd /tmp/hard
mkdir -p app
cat > app/main.py <<'PY'
"""Приложение, пишущее в разные места — как это обычно и бывает."""
import os
import tempfile
from pathlib import Path

with tempfile.NamedTemporaryFile("w", delete=False, suffix=".tmp") as f:
    f.write("временные данные\n")
    print(f"tempfile: {f.name}", flush=True)

cache = Path(os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache")) / "app"
cache.mkdir(parents=True, exist_ok=True)
(cache / "state").write_text("ok\n")
print(f"кэш: {cache}", flush=True)

print("готово", flush=True)
PY

cat > Dockerfile <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim
ENV PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 HOME=/home/appuser
RUN useradd --create-home --uid 10001 appuser
WORKDIR /app
COPY --chown=10001:10001 app/ ./app/
USER 10001:10001
CMD ["python", "app/main.py"]
EOF

docker build -q -t hard:app . > /dev/null

echo "═══ шаг 1: обычный запуск ═══"
docker run --name measure hard:app 2>&1 | sed 's/^/  /'

echo "═══ шаг 2: что было записано ═══"
docker diff measure | grep '^A' | sed 's/^A /  /' | head -10
docker rm measure > /dev/null

echo "═══ шаг 3: --read-only без подготовки ═══"
docker run --rm --read-only hard:app 2>&1 | tail -2 | sed 's/^/  /'

echo "═══ шаг 4: --read-only с нужными tmpfs ═══"
docker run --rm --read-only \
    --tmpfs /tmp:size=16m,mode=1777 \
    --tmpfs /home/appuser/.cache:size=16m,uid=10001,gid=10001 \
    hard:app 2>&1 | sed 's/^/  /'

═══ шаг 1: обычный запуск ═══
  tempfile: /tmp/tmpk3x9v2p1.tmp
  кэш: /home/appuser/.cache/app
  готово
═══ шаг 2: что было записано ═══
  /home/appuser/.cache
  /home/appuser/.cache/app
  /home/appuser/.cache/app/state
  /tmp/tmpk3x9v2p1.tmp
═══ шаг 3: --read-only без подготовки ═══
  OSError: [Errno 30] Read-only file system: '/tmp/tmpXXXXXXX'
═══ шаг 4: --read-only с нужными tmpfs ═══
  tempfile: /tmp/tmpq8w1e5r3.tmp
  кэш: /home/appuser/.cache/app
  готово

cd /tmp/hard
docker run -d --name ro-test --read-only \
    --tmpfs /tmp:size=16m,mode=1777 \
    --cap-drop=ALL --security-opt=no-new-privileges \
    hard:app sleep 60 > /dev/null 2>&1 || \
docker run -d --name ro-test --read-only \
    --tmpfs /tmp:size=16m,mode=1777 \
    --cap-drop=ALL --security-opt=no-new-privileges \
    --entrypoint sleep hard:app 60 > /dev/null
sleep 2

echo "═══ попытки записи ═══"
for path in / /app /usr/local/bin /etc; do
    result="$(docker exec ro-test sh -c "echo x > $path/probe 2>&1" | tail -1)"
    printf '  %-16s %s\n' "$path" "${result:-запись прошла!}"
done
printf '  %-16s %s\n' "/tmp" "$(docker exec ro-test sh -c 'echo x > /tmp/probe && echo "запись разрешена"')"

echo "═══ и вся конфигурация целиком ═══"
docker inspect ro-test --format '  ReadonlyRootfs: {{.HostConfig.ReadonlyRootfs}}
  CapDrop:        {{json .HostConfig.CapDrop}}
  SecurityOpt:    {{json .HostConfig.SecurityOpt}}
  User:           {{if .Config.User}}{{.Config.User}}{{else}}(не задан){{end}}'

docker rm -f ro-test > /dev/null

═══ попытки записи ═══
  /                sh: 1: cannot create /probe: Read-only file system
  /app             sh: 1: cannot create /app/probe: Read-only file system
  /usr/local/bin   sh: 1: cannot create /usr/local/bin/probe: Read-only file system
  /etc             sh: 1: cannot create /etc/probe: Read-only file system
  /tmp             запись разрешена
═══ и вся конфигурация целиком ═══
  ReadonlyRootfs: true
  CapDrop:        ["ALL"]
  SecurityOpt:    ["no-new-privileges"]
  User:           10001:10001

cd /tmp/hard
cat > forkbomb.py <<'PY'
"""Имитация неконтролируемого порождения процессов."""
import os
import sys
import time

spawned = 0
try:
    while spawned < 500:
        pid = os.fork()
        if pid == 0:
            time.sleep(30)
            os._exit(0)
        spawned += 1
except BlockingIOError as exc:
    print(f"остановлено на {spawned} процессах: {exc}", flush=True)
    sys.exit(0)
except OSError as exc:
    print(f"остановлено на {spawned} процессах: {type(exc).__name__} {exc}", flush=True)
    sys.exit(0)
print(f"создано {spawned} процессов без ограничений", flush=True)
PY

echo "═══ без --pids-limit ═══"
timeout 30 docker run --rm --memory 256m \
    -v "$PWD/forkbomb.py:/f.py:ro" python:3.13-slim python -u /f.py 2>&1 | tail -1 | sed 's/^/  /'

echo "═══ с --pids-limit 50 ═══"
timeout 30 docker run --rm --memory 256m --pids-limit 50 \
    -v "$PWD/forkbomb.py:/f.py:ro" python:3.13-slim python -u /f.py 2>&1 | tail -1 | sed 's/^/  /'

echo "═══ что видно в cgroup ═══"
docker run --rm --pids-limit 50 python:3.13-slim \
    sh -c 'echo "  pids.max: $(cat /sys/fs/cgroup/pids.max)"; echo "  pids.current: $(cat /sys/fs/cgroup/pids.current)"'

═══ без --pids-limit ═══
  создано 500 процессов без ограничений
═══ с --pids-limit 50 ═══
  остановлено на 47 процессах: [Errno 11] Resource temporarily unavailable
═══ что видно в cgroup ═══
  pids.max: 50
  pids.current: 2

echo "═══ профиль по умолчанию ═══"
docker run --rm python:3.13-slim sh -c '
    grep Seccomp /proc/self/status | sed "s/^/  /"
'

echo "═══ заблокированный вызов ═══"
docker run --rm python:3.13-slim python3 -c "
import ctypes, ctypes.util
libc = ctypes.CDLL(ctypes.util.find_library('c'), use_errno=True)
# unshare(CLONE_NEWUSER) — есть в профиле по умолчанию, но capability нет
res = libc.unshare(0x10000000)
import os
print('  unshare(CLONE_NEWUSER):', 'разрешён' if res == 0 else f'errno={ctypes.get_errno()}')
" 2>&1 | tail -1

echo "═══ с seccomp=unconfined (ТАК НЕ ДЕЛАЙТЕ) ═══"
docker run --rm --security-opt seccomp=unconfined python:3.13-slim sh -c '
    grep Seccomp /proc/self/status | sed "s/^/  /"
'

═══ профиль по умолчанию ═══
  Seccomp:	2
  Seccomp_filters:	1
═══ заблокированный вызов ═══
  unshare(CLONE_NEWUSER): errno=1
═══ с seccomp=unconfined (ТАК НЕ ДЕЛАЙТЕ) ═══
  Seccomp:	0
  Seccomp_filters:	0

cd /tmp/hard
cat > compose.yaml <<'EOF'
name: hardened

services:
  # Без hardening — как получается по умолчанию
  plain:
    image: python:3.13-slim
    command: ["sleep", "300"]

  # С hardening
  hardened:
    image: python:3.13-slim
    command: ["sleep", "300"]
    user: "10001:10001"
    read_only: true
    tmpfs:
      - /tmp:size=16m,mode=1777
    cap_drop: [ALL]
    security_opt:
      - no-new-privileges:true
    pids_limit: 100
    deploy:
      resources:
        limits:
          memory: 256M
          cpus: "1.0"
EOF

docker compose up -d > /dev/null 2>&1
sleep 3

printf '%-16s %-8s %-18s %-12s %-10s %s\n' "СЕРВИС" "UID" "CapEff" "NoNewPrivs" "read-only" "pids.max"
for svc in plain hardened; do
    cid="$(docker compose ps -q $svc)"
    printf '%-16s %-8s %-18s %-12s %-10s %s\n' \
        "$svc" \
        "$(docker exec "$cid" id -u)" \
        "$(docker exec "$cid" sh -c 'grep CapEff /proc/self/status | awk "{print \$2}"')" \
        "$(docker exec "$cid" sh -c 'grep NoNewPrivs /proc/self/status | awk "{print \$2}"')" \
        "$(docker inspect "$cid" --format '{{.HostConfig.ReadonlyRootfs}}')" \
        "$(docker exec "$cid" cat /sys/fs/cgroup/pids.max)"
done

echo
echo "═══ что может сделать атакующий, получив выполнение кода ═══"
for svc in plain hardened; do
    cid="$(docker compose ps -q $svc)"
    printf '  %s:\n' "$svc"
    printf '    записать в /usr/local/bin: %s\n' \
        "$(docker exec "$cid" sh -c 'echo x > /usr/local/bin/evil 2>&1 && echo "ДА" || echo "нет"' | tail -1)"
    printf '    сменить владельца файла:   %s\n' \
        "$(docker exec "$cid" sh -c 'chown 0:0 /tmp 2>&1 >/dev/null && echo "ДА" || echo "нет"' | tail -1)"
    printf '    открыть привилегированный порт: %s\n' \
        "$(docker exec "$cid" python3 -c "
import socket
s = socket.socket()
try:
    s.bind(('0.0.0.0', 80)); print('ДА')
except PermissionError:
    print('нет')
finally:
    s.close()
" 2>/dev/null)"
done

docker compose down > /dev/null 2>&1
docker rmi -f hard:setuid hard:app > /dev/null 2>&1
cd /tmp && rm -rf /tmp/hard

СЕРВИС           UID      CapEff             NoNewPrivs   read-only  pids.max
plain            0        00000000a80425fb   0            false      max
hardened         10001    0000000000000000   1            true       100

═══ что может сделать атакующий, получив выполнение кода ═══
  plain:
    записать в /usr/local/bin: ДА
    сменить владельца файла:   ДА
    открыть привилегированный порт: ДА
  hardened:
    записать в /usr/local/bin: нет
    сменить владельца файла:   нет
    открыть привилегированный порт: нет

docker run --rm --user 10001:10001 --cap-drop=ALL \
    --security-opt=no-new-privileges --read-only \
    --tmpfs /tmp:size=8m --pids-limit 20 \
    python:3.13-slim sh -c '
        echo "uid: $(id -u)"
        grep -E "CapEff|NoNewPrivs|Seccomp:" /proc/self/status
        cat /sys/fs/cgroup/pids.max
        echo x > /probe 2>&1 | tail -1
    '