12.4. Capabilities и privileged

1. Запустить с --cap-drop=ALL
       │
       ├── работает? → готово
       │
       └── не работает → определить, какой вызов упал
                              │
                              └── добавить ОДНУ capability → повторить

docker run --device /dev/ttyUSB0 ...
docker run --device /dev/fuse --cap-add SYS_ADMIN ...
docker run --device /dev/nvidia0:/dev/nvidia0:rwm ...

mkdir -p /tmp/caps && cd /tmp/caps

cat > capcheck.py <<'PY'
"""Проверяет, какие привилегированные операции доступны процессу."""
from __future__ import annotations

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

_libc = ctypes.CDLL(ctypes.util.find_library("c"), use_errno=True)

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", 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",
}


def cap_field(name: str) -> int:
    for line in Path("/proc/self/status").read_text().splitlines():
        if line.startswith(name + ":"):
            return int(line.split()[1], 16)
    return 0


def cap_list(field: str) -> list[str]:
    mask = cap_field(field)
    return [n for b, n in sorted(CAP_NAMES.items()) if mask & (1 << b)]


def op_bind_low_port() -> str:
    """NET_BIND_SERVICE"""
    s = socket.socket()
    try:
        s.bind(("0.0.0.0", 80))
        return "ok"
    except PermissionError:
        return "EPERM"
    except OSError as exc:
        return f"errno {exc.errno}"
    finally:
        s.close()


def op_raw_socket() -> str:
    """NET_RAW"""
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP)
        s.close()
        return "ok"
    except PermissionError:
        return "EPERM"
    except OSError as exc:
        return f"errno {exc.errno}"


def op_mount() -> str:
    """SYS_ADMIN"""
    target = "/tmp/_cap_mnt"
    try:
        os.makedirs(target, exist_ok=True)
    except OSError:
        return "нет /tmp"
    ctypes.set_errno(0)
    if _libc.mount(b"tmpfs", target.encode(), b"tmpfs", 0, None) == 0:
        _libc.umount(target.encode())
        return "ok"
    return f"errno {ctypes.get_errno()}"


def op_settime() -> str:
    """SYS_TIME"""
    class Timespec(ctypes.Structure):
        _fields_ = [("tv_sec", ctypes.c_long), ("tv_nsec", ctypes.c_long)]

    ts = Timespec()
    _libc.clock_gettime(0, ctypes.byref(ts))
    ctypes.set_errno(0)
    return "ok" if _libc.clock_settime(0, ctypes.byref(ts)) == 0 \
        else f"errno {ctypes.get_errno()}"


def op_chown() -> str:
    """CHOWN"""
    p = Path("/tmp/_cap_chown")
    try:
        p.write_text("x")
        os.chown(p, 1, 1)
        p.unlink()
        return "ok"
    except PermissionError:
        p.unlink(missing_ok=True)
        return "EPERM"
    except OSError as exc:
        p.unlink(missing_ok=True)
        return f"errno {exc.errno}"


def op_devices() -> dict[str, str]:
    """Доступ к устройствам host."""
    out = {}
    for dev in ("/dev/sda", "/dev/mem", "/dev/kmsg", "/dev/null"):
        p = Path(dev)
        if not p.exists():
            out[dev] = "нет узла"
            continue
        try:
            with open(dev, "rb") as f:
                f.read(1)
            out[dev] = "ЧИТАЕТСЯ"
        except OSError as exc:
            out[dev] = f"отказ: {exc.strerror}"
    return out


if __name__ == "__main__":
    print(json.dumps({
        "uid": os.getuid(),
        "effective": cap_list("CapEff"),
        "bounding": cap_list("CapBnd"),
        "всего_effective": len(cap_list("CapEff")),
        "операции": {
            "привязка к порту 80 (NET_BIND_SERVICE)": op_bind_low_port(),
            "сырой сокет (NET_RAW)": op_raw_socket(),
            "монтирование (SYS_ADMIN)": op_mount(),
            "изменение времени (SYS_TIME)": op_settime(),
            "смена владельца (CHOWN)": op_chown(),
        },
        "устройства": op_devices(),
    }, ensure_ascii=False, indent=2))
PY

echo "═══ по умолчанию ═══"
docker run --rm -v "$PWD/capcheck.py:/c.py:ro" python:3.13-slim python /c.py \
    | python3 -c "
import json, sys
d = json.load(sys.stdin)
print(f\"  capabilities: {d['всего_effective']}\")
for op, res in d['операции'].items():
    print(f'  {op:<42} {res}')
print('  устройства:')
for dev, res in d['устройства'].items():
    print(f'    {dev:<12} {res}')
"

═══ по умолчанию ═══
  capabilities: 14
  привязка к порту 80 (NET_BIND_SERVICE)     ok
  сырой сокет (NET_RAW)                      ok
  монтирование (SYS_ADMIN)                   errno 1
  изменение времени (SYS_TIME)               errno 1
  смена владельца (CHOWN)                    ok
  устройства:
    /dev/sda     нет узла
    /dev/mem     нет узла
    /dev/kmsg    нет узла
    /dev/null    ЧИТАЕТСЯ

cd /tmp/caps
run_check() {
    docker run --rm "$@" -v "$PWD/capcheck.py:/c.py:ro" python:3.13-slim python /c.py 2>/dev/null
}
brief() {
    python3 -c "
import json, sys
d = json.load(sys.stdin)
ops = d['операции']
print(f\"{d['всего_effective']:>3}  \" +
      '  '.join(f\"{k.split('(')[1].rstrip(')'):<18}={v:<9}\" for k, v in list(ops.items())[:3]))
"
}

printf '  %-26s %s\n' "конфигурация" "caps  операции"
printf '  %s\n' "──────────────────────────────────────────────────────────────────────────────"
printf '  %-26s ' "по умолчанию";        run_check | brief
printf '  %-26s ' "--cap-drop=ALL";      run_check --cap-drop=ALL | brief
printf '  %-26s ' "+NET_BIND_SERVICE";   run_check --cap-drop=ALL --cap-add=NET_BIND_SERVICE | brief
printf '  %-26s ' "+NET_RAW";            run_check --cap-drop=ALL --cap-add=NET_RAW | brief
printf '  %-26s ' "+SYS_ADMIN";          run_check --cap-drop=ALL --cap-add=SYS_ADMIN | brief

  конфигурация               caps  операции
  ──────────────────────────────────────────────────────────────────────────────
  по умолчанию                14  NET_BIND_SERVICE  =ok         NET_RAW           =ok         SYS_ADMIN         =errno 1 
  --cap-drop=ALL               0  NET_BIND_SERVICE  =EPERM      NET_RAW           =EPERM      SYS_ADMIN         =errno 1 
  +NET_BIND_SERVICE            1  NET_BIND_SERVICE  =ok         NET_RAW           =EPERM      SYS_ADMIN         =errno 1 
  +NET_RAW                     1  NET_BIND_SERVICE  =EPERM      NET_RAW           =ok         SYS_ADMIN         =errno 1 
  +SYS_ADMIN                   1  NET_BIND_SERVICE  =EPERM      NET_RAW           =ok         SYS_ADMIN         =ok      

cd /tmp/caps
echo "═══ сравнение по всем признакам ═══"
compare() {
    local label="$1"; shift
    local out
    out="$(docker run --rm "$@" -v "$PWD/capcheck.py:/c.py:ro" python:3.13-slim python /c.py 2>/dev/null)"
    local caps seccomp devices
    caps="$(echo "$out" | python3 -c "import json,sys; print(json.load(sys.stdin)['всего_effective'])")"
    seccomp="$(docker run --rm "$@" python:3.13-slim sh -c 'grep Seccomp: /proc/self/status | awk "{print \$2}"' 2>/dev/null)"
    devices="$(docker run --rm "$@" python:3.13-slim sh -c 'ls /dev | wc -l' 2>/dev/null)"
    local sda
    sda="$(docker run --rm "$@" python:3.13-slim sh -c 'test -e /dev/sda && echo "ЕСТЬ" || echo "нет"' 2>/dev/null)"
    local sysrw
    sysrw="$(docker run --rm "$@" python:3.13-slim sh -c \
        'touch /sys/kernel/probe 2>/dev/null && echo "запись" || echo "только чтение"' 2>/dev/null)"
    printf '  %-18s %-6s %-9s %-9s %-8s %s\n' "$label" "$caps" "$seccomp" "$devices" "$sda" "$sysrw"
}

printf '  %-18s %-6s %-9s %-9s %-8s %s\n' "конфигурация" "caps" "seccomp" "узлов" "/dev/sda" "/sys"
printf '  %s\n' "─────────────────────────────────────────────────────────────────────────"
compare "по умолчанию"
compare "--cap-add=ALL" --cap-add=ALL
compare "--privileged" --privileged

  конфигурация       caps   seccomp   узлов     /dev/sda /sys
  ─────────────────────────────────────────────────────────────────────────
  по умолчанию       14     2         15        нет      только чтение
  --cap-add=ALL      32     2         15        нет      только чтение
  --privileged       32     0         187       ЕСТЬ     запись

cd /tmp/caps
echo "═══ устройства, видимые в разных режимах ═══"
printf '  по умолчанию: '
docker run --rm python:3.13-slim sh -c 'ls /dev | tr "\n" " "' 2>/dev/null | cut -c1-70
echo
printf '  с --privileged (первые 20): '
docker run --rm --privileged python:3.13-slim sh -c 'ls /dev | head -20 | tr "\n" " "' 2>/dev/null | cut -c1-70
echo

echo "═══ что это значит ═══"
cat <<'TXT'
  /dev/sda — блочное устройство диска host. Доступ к нему означает
  чтение файловой системы host в обход прав доступа: содержимое
  дисков читается напрямую, минуя проверки ядра на уровне файлов.

  Именно поэтому --privileged нельзя считать «просто расширенными
  правами»: он снимает границу между container и хранилищем host.
TXT

echo "═══ точечная альтернатива ═══"
cat <<'TXT'
  Нужен один конкретный узел:
    docker run --device /dev/ttyUSB0 ...          # последовательный порт
    docker run --device /dev/fuse --cap-add SYS_ADMIN ...   # FUSE
    docker run --device /dev/dri:/dev/dri ...     # видеоускоритель

  Формат: --device источник[:цель[:права]], права из r, w, m.
TXT

═══ устройства, видимые в разных режимах ═══
  по умолчанию: console core fd full mqueue null ptmx pts random shm stderr 
  с --privileged (первые 20): autofs bsg btrfs-control bus console core cpu_dma_latency 
═══ что это значит ═══
  /dev/sda — блочное устройство диска host. Доступ к нему означает
  чтение файловой системы host в обход прав доступа: содержимое
  дисков читается напрямую, минуя проверки ядра на уровне файлов.

  Именно поэтому --privileged нельзя считать «просто расширенными
  правами»: он снимает границу между container и хранилищем host.
═══ точечная альтернатива ═══
  Нужен один конкретный узел:
    docker run --device /dev/ttyUSB0 ...          # последовательный порт
    docker run --device /dev/fuse --cap-add SYS_ADMIN ...   # FUSE
    docker run --device /dev/dri:/dev/dri ...     # видеоускоритель

  Формат: --device источник[:цель[:права]], права из r, w, m.

cd /tmp/caps
cat > holder.py <<'PY'
"""Процесс, держащий «секрет» в памяти — цель для демонстрации."""
import os
import time

SECRET = "ЗНАЧЕНИЕ-В-ПАМЯТИ-ПРОЦЕССА-12345"
print(f"держу секрет в памяти, pid={os.getpid()}", flush=True)
while True:
    _ = SECRET
    time.sleep(1)
PY

cat > reader.py <<'PY'
"""Демонстрация: с SYS_PTRACE процесс читает память соседа.

Показывает, почему выдача SYS_PTRACE в общем PID namespace
означает доступ к секретам всех процессов рядом.
"""
from __future__ import annotations

import os
import re
import sys
from pathlib import Path

target = sys.argv[1] if len(sys.argv) > 1 else "1"
pattern = sys.argv[2].encode() if len(sys.argv) > 2 else b"SECRET"

mem_path = Path(f"/proc/{target}/mem")
maps_path = Path(f"/proc/{target}/maps")

if not maps_path.exists():
    print(f"  процесс {target} не найден")
    sys.exit(1)

try:
    regions = []
    for line in maps_path.read_text().splitlines():
        m = re.match(r"([0-9a-f]+)-([0-9a-f]+) (\S+)", line)
        if m and "r" in m.group(3) and "heap" in line:
            regions.append((int(m.group(1), 16), int(m.group(2), 16)))

    found = []
    with open(mem_path, "rb") as mem:
        for start, end in regions[:5]:
            try:
                mem.seek(start)
                data = mem.read(min(end - start, 4 * 1024 * 1024))
                for match in re.finditer(pattern + rb"[A-Za-z0-9\-]*", data):
                    found.append(match.group().decode("utf-8", "replace"))
            except OSError:
                continue

    if found:
        print(f"  ПРОЧИТАНО из памяти процесса {target}:")
        for item in sorted(set(found))[:3]:
            print(f"    {item}")
    else:
        print(f"  в heap процесса {target} совпадений не найдено")
except PermissionError as exc:
    print(f"  ОТКАЗ: {exc.strerror} — нет SYS_PTRACE")
    sys.exit(0)
except OSError as exc:
    print(f"  ошибка: {exc.strerror}")
    sys.exit(0)
PY

echo "═══ запускаем процесс с секретом ═══"
docker run -d --name holder -v "$PWD/holder.py:/h.py:ro" \
    python:3.13-slim python -u /h.py > /dev/null
sleep 3
docker logs holder 2>&1 | tail -1 | sed 's/^/  /'

echo "═══ сосед БЕЗ SYS_PTRACE ═══"
docker run --rm --pid "container:holder" --cap-drop=ALL \
    -v "$PWD/reader.py:/r.py:ro" \
    python:3.13-slim python /r.py 1 "ЗНАЧЕНИЕ-В-ПАМЯТИ" 2>/dev/null

echo "═══ сосед С SYS_PTRACE ═══"
docker run --rm --pid "container:holder" --cap-drop=ALL --cap-add=SYS_PTRACE \
    -v "$PWD/reader.py:/r.py:ro" \
    python:3.13-slim python /r.py 1 "ЗНАЧЕНИЕ-В-ПАМЯТИ" 2>/dev/null

docker rm -f holder > /dev/null

═══ запускаем процесс с секретом ═══
  держу секрет в памяти, pid=1
═══ сосед БЕЗ SYS_PTRACE ═══
  ОТКАЗ: Operation not permitted — нет SYS_PTRACE
═══ сосед С SYS_PTRACE ═══
  ПРОЧИТАНО из памяти процесса 1:
    ЗНАЧЕНИЕ-В-ПАМЯТИ-ПРОЦЕССА-12345

cd /tmp/caps
mkdir -p protected
echo "содержимое, закрытое правами" > protected/secret.txt
chmod 000 protected/secret.txt

echo "═══ файл с правами 000 ═══"
ls -l protected/secret.txt | awk '{print "  " $1 " " $9}'

echo "═══ от root БЕЗ DAC_OVERRIDE ═══"
docker run --rm --cap-drop=ALL -v "$PWD/protected:/p:ro" alpine:3.21 \
    sh -c 'cat /p/secret.txt 2>&1 | tail -1' | sed 's/^/  /'

echo "═══ от root С DAC_OVERRIDE ═══"
docker run --rm --cap-drop=ALL --cap-add=DAC_OVERRIDE -v "$PWD/protected:/p:ro" alpine:3.21 \
    sh -c 'cat /p/secret.txt 2>&1 | tail -1' | sed 's/^/  /'

echo "═══ вывод ═══"
cat <<'TXT'
  DAC_OVERRIDE обходит проверку прав файловой системы целиком.
  Она входит в набор Docker ПО УМОЛЧАНИЮ — то есть обычный container
  от root читает файлы с правами 000 в любом смонтированном каталоге.

  Ещё один довод за --cap-drop=ALL: набор по умолчанию не безобиден.
TXT

chmod 644 protected/secret.txt && rm -rf protected

═══ файл с правами 000 ═══
  ---------- secret.txt
═══ от root БЕЗ DAC_OVERRIDE ═══
  cat: can't open '/p/secret.txt': Permission denied
═══ от root С DAC_OVERRIDE ═══
  содержимое, закрытое правами
═══ вывод ═══
  DAC_OVERRIDE обходит проверку прав файловой системы целиком.
  Она входит в набор Docker ПО УМОЛЧАНИЮ — то есть обычный container
  от root читает файлы с правами 000 в любом смонтированном каталоге.

  Ещё один довод за --cap-drop=ALL: набор по умолчанию не безобиден.
TXT

cd /tmp/caps
cat > needs.py <<'PY'
"""Определяет, какие capabilities нужны приложению, по отказам операций."""
from __future__ import annotations

import ctypes
import ctypes.util
import json
import os
import socket
import sys

_libc = ctypes.CDLL(ctypes.util.find_library("c"), use_errno=True)

# Операции, которые приложение реально выполняет
OPERATIONS = {
    "привязка к порту 8000": ("NET_BIND_SERVICE?", lambda: _bind(8000)),
    "привязка к порту 80":   ("NET_BIND_SERVICE",  lambda: _bind(80)),
    "создание сырого сокета": ("NET_RAW",          _raw),
    "смена владельца файла":  ("CHOWN",            _chown),
    "монтирование tmpfs":     ("SYS_ADMIN",        _mount),
}


def _bind(port: int) -> str:
    s = socket.socket()
    try:
        s.bind(("0.0.0.0", port))
        return "ok"
    except PermissionError:
        return "EPERM"
    except OSError as exc:
        return f"errno {exc.errno}"
    finally:
        s.close()


def _raw() -> str:
    try:
        socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP).close()
        return "ok"
    except PermissionError:
        return "EPERM"
    except OSError as exc:
        return f"errno {exc.errno}"


def _chown() -> str:
    from pathlib import Path
    p = Path("/tmp/_needs_probe")
    try:
        p.write_text("x")
        os.chown(p, 1, 1)
        return "ok"
    except PermissionError:
        return "EPERM"
    except OSError as exc:
        return f"errno {exc.errno}"
    finally:
        p.unlink(missing_ok=True)


def _mount() -> str:
    os.makedirs("/tmp/_needs_mnt", exist_ok=True)
    ctypes.set_errno(0)
    if _libc.mount(b"tmpfs", b"/tmp/_needs_mnt", b"tmpfs", 0, None) == 0:
        _libc.umount(b"/tmp/_needs_mnt")
        return "ok"
    return f"errno {ctypes.get_errno()}"


if __name__ == "__main__":
    results = {}
    needed = []
    for label, (cap, fn) in OPERATIONS.items():
        res = fn()
        results[label] = {"результат": res, "требует": cap}
        if res != "ok" and not cap.endswith("?"):
            needed.append(cap)
    print(json.dumps({
        "операции": results,
        "не_хватает": sorted(set(needed)),
        "рекомендация": ("--cap-drop=ALL" if not needed
                         else "--cap-drop=ALL " + " ".join(f"--cap-add={c}" for c in sorted(set(needed)))),
    }, ensure_ascii=False, indent=2))
PY

echo "═══ определяем потребности приложения ═══"
docker run --rm --cap-drop=ALL -v "$PWD/needs.py:/n.py:ro" \
    python:3.13-slim python /n.py | python3 -c "
import json, sys
d = json.load(sys.stdin)
for label, info in d['операции'].items():
    mark = '✓' if info['результат'] == 'ok' else '✗'
    print(f\"  {mark} {label:<26} {info['результат']:<10} требует {info['требует']}\")
print()
print(f\"  не хватает: {d['не_хватает'] or 'ничего'}\")
print(f\"  рекомендация: {d['рекомендация']}\")
"

═══ определяем потребности приложения ═══
  ✓ привязка к порту 8000       ok         требует NET_BIND_SERVICE?
  ✗ привязка к порту 80         EPERM      требует NET_BIND_SERVICE
  ✗ создание сырого сокета      EPERM      требует NET_RAW
  ✗ смена владельца файла       EPERM      требует CHOWN
  ✗ монтирование tmpfs          errno 1    требует SYS_ADMIN

  не хватает: ['CHOWN', 'NET_BIND_SERVICE', 'NET_RAW', 'SYS_ADMIN']
  рекомендация: --cap-drop=ALL --cap-add=CHOWN --cap-add=NET_BIND_SERVICE --cap-add=NET_RAW --cap-add=SYS_ADMIN

cd /tmp/caps
cat > audit-caps.sh <<'SH'
#!/usr/bin/env bash
# Поиск container'ов с избыточными привилегиями.
set -uo pipefail

DANGEROUS="SYS_ADMIN SYS_MODULE SYS_RAWIO SYS_PTRACE NET_ADMIN DAC_READ_SEARCH SYS_TIME"
issues=0

printf '\n  %-24s %-12s %-10s %s\n' "CONTAINER" "PRIVILEGED" "CAP_DROP" "ДОБАВЛЕНО"
printf '  %s\n' "──────────────────────────────────────────────────────────────────────"

while read -r cid; do
    [ -z "$cid" ] && continue
    name="$(docker inspect "$cid" --format '{{.Name}}' | tr -d '/')"
    priv="$(docker inspect "$cid" --format '{{.HostConfig.Privileged}}')"
    drop="$(docker inspect "$cid" --format '{{json .HostConfig.CapDrop}}')"
    add="$(docker inspect "$cid" --format '{{json .HostConfig.CapAdd}}')"

    flag=""
    [ "$priv" = "true" ] && { flag="⚠"; issues=$((issues + 1)); }
    case "$drop" in
        *ALL*) ;;
        *) [ "$priv" != "true" ] && { flag="${flag}!"; issues=$((issues + 1)); } ;;
    esac
    for cap in $DANGEROUS; do
        case "$add" in
            *"$cap"*) flag="${flag}⚠"; issues=$((issues + 1)) ;;
        esac
    done

    printf '  %-24s %-12s %-10s %s %s\n' \
        "${name:0:24}" "$priv" "$(echo "$drop" | cut -c1-10)" \
        "$(echo "$add" | cut -c1-24)" "$flag"

    # Пояснения
    [ "$priv" = "true" ] && printf '      ⚠ privileged: все caps, все устройства, seccomp отключён\n'
    case "$drop" in
        *ALL*) ;;
        *) [ "$priv" != "true" ] && printf '      ! нет --cap-drop=ALL: действует набор по умолчанию (14 caps)\n' ;;
    esac
    for cap in $DANGEROUS; do
        case "$add" in
            *"$cap"*) printf '      ⚠ добавлена опасная capability: %s\n' "$cap" ;;
        esac
    done
done < <(docker ps -q 2>/dev/null)

printf '\n  найдено проблем: %s\n' "$issues"
exit "$( [ "$issues" -eq 0 ] && echo 0 || echo 1 )"
SH
chmod +x audit-caps.sh

echo "═══ поднимаем container'ы с разными настройками ═══"
docker run -d --name good --cap-drop=ALL alpine:3.21 sleep 120 > /dev/null
docker run -d --name default-caps alpine:3.21 sleep 120 > /dev/null
docker run -d --name with-ptrace --cap-drop=ALL --cap-add=SYS_PTRACE alpine:3.21 sleep 120 > /dev/null
docker run -d --name privileged-one --privileged alpine:3.21 sleep 120 > /dev/null

./audit-caps.sh || true
docker rm -f good default-caps with-ptrace privileged-one > /dev/null

═══ поднимаем container'ы с разными настройками ═══

  CONTAINER                PRIVILEGED   CAP_DROP   ДОБАВЛЕНО
  ──────────────────────────────────────────────────────────────────────
  privileged-one           true         null       null ⚠
      ⚠ privileged: все caps, все устройства, seccomp отключён
  with-ptrace              false        ["ALL"]    ["SYS_PTRACE"] ⚠
      ⚠ добавлена опасная capability: SYS_PTRACE
  default-caps             false        null       null !
      ! нет --cap-drop=ALL: действует набор по умолчанию (14 caps)
  good                     false        ["ALL"]    null 

  найдено проблем: 3

cd /tmp && rm -rf /tmp/caps

docker run --rm --cap-drop=ALL python:3.13-slim sh -c '
    grep -E "CapEff|CapBnd" /proc/self/status
    grep Seccomp: /proc/self/status
    ls /dev | wc -l
'
docker run --rm --privileged python:3.13-slim sh -c '
    grep Seccomp: /proc/self/status
    ls /dev | wc -l
'