12.2. Daemon и socket

docker run ...  ──HTTP──►  /var/run/docker.sock  ──►  dockerd (root)
   (обычный                  (сокет, группа              │
    пользователь)             docker, права 660)          ▼
                                                    выполняет как root

sudo usermod -aG docker $USER

volumes:
  - /var/run/docker.sock:/var/run/docker.sock    # эквивалент root на host

dockerd -H tcp://0.0.0.0:2375        # НИКОГДА так не делайте

srw-rw---- 1 root docker 0 июл 31 09:12 /var/run/docker.sock

curl --unix-socket /var/run/docker.sock http://localhost/version

echo "═══ файл сокета ═══"
ls -l /var/run/docker.sock 2>/dev/null | sed 's/^/  /' || echo "  сокет не найден"

echo "═══ кто в группе docker ═══"
getent group docker 2>/dev/null | sed 's/^/  /' || echo "  группа docker отсутствует"

echo "═══ ваши группы ═══"
id -Gn | tr ' ' '\n' | grep -x docker > /dev/null \
    && echo "  вы в группе docker — то есть имеете права root через демон" \
    || echo "  вы НЕ в группе docker"

echo "═══ режим демона ═══"
docker info --format '  rootless: {{.SecurityOptions}}' 2>/dev/null | grep -o 'rootless' \
    || echo "  режим: rootful (демон работает от root)"

═══ файл сокета ═══
  srw-rw---- 1 root docker 0 июл 31 09:12 /var/run/docker.sock
═══ кто в группе docker ═══
  docker:x:999:evg
═══ ваши группы ═══
  вы в группе docker — то есть имеете права root через демон
═══ режим демона ═══
  режим: rootful (демон работает от root)

echo "═══ запрос к API напрямую ═══"
curl -s --unix-socket /var/run/docker.sock http://localhost/version 2>/dev/null \
    | python3 -c "
import json, sys
d = json.load(sys.stdin)
print(f\"  версия API:  {d.get('ApiVersion')}\")
print(f\"  версия:      {d.get('Version')}\")
print(f\"  ОС:          {d.get('Os')}/{d.get('Arch')}\")
" 2>/dev/null || echo "  (нет доступа к сокету)"

echo "═══ ни токена, ни пароля не потребовалось ═══"
echo "  Доступ определяется ТОЛЬКО правами файла сокета."

═══ запрос к API напрямую ═══
  версия API:  1.51
  версия:      29.0.1
  ОС:          linux/amd64
═══ ни токена, ни пароля не потребовалось ═══
  Доступ определяется ТОЛЬКО правами файла сокета.

mkdir -p /tmp/sockdemo && cd /tmp/sockdemo

echo "═══ создаём файл, доступный только root ═══"
sudo sh -c 'echo "секрет, доступный только root" > /root/only-root.txt' 2>/dev/null
sudo chmod 600 /root/only-root.txt 2>/dev/null
sudo ls -l /root/only-root.txt 2>/dev/null | sed 's/^/  /'

echo "═══ обычный пользователь прочитать не может ═══"
cat /root/only-root.txt 2>&1 | tail -1 | sed 's/^/  /'

echo "═══ но через socket — может ═══"
docker run --rm -v /:/host:ro alpine:3.21 cat /host/root/only-root.txt 2>/dev/null \
    | sed 's/^/  /'

echo "═══ что произошло ═══"
cat <<'TXT'
  Мы не обходили изоляцию container'а. Мы попросили демон,
  работающий от root, создать container с монтированием корня host.
  Демон выполнил запрос — у него есть права, и API их не ограничивает.
TXT

═══ создаём файл, доступный только root ═══
  -rw------- 1 root root 44 июл 31 15:02 /root/only-root.txt
═══ обычный пользователь прочитать не может ═══
  cat: /root/only-root.txt: Permission denied
═══ но через socket — может ═══
  секрет, доступный только root
═══ что произошло ═══
  Мы не обходили изоляцию container'а. Мы попросили демон,
  работающий от root, создать container с монтированием корня host.
  Демон выполнил запрос — у него есть права, и API их не ограничивает.

cd /tmp/sockdemo
echo "═══ container с сокетом, максимально ограниченный ═══"
docker run --rm \
    --user 10001:10001 \
    --cap-drop=ALL \
    --security-opt=no-new-privileges \
    --read-only --tmpfs /tmp:size=8m \
    --network none \
    -v /var/run/docker.sock:/var/run/docker.sock \
    alpine:3.21 sh -c '
        echo "  UID: $(id -u), capabilities отобраны, корень read-only, сети нет"
        apk add --no-cache curl > /dev/null 2>&1
        echo "  версия демона через сокет:"
        curl -s --unix-socket /var/run/docker.sock http://localhost/version \
            | sed "s/.*\"Version\":\"\([^\"]*\)\".*/    \1/" 2>/dev/null \
            || echo "    (нет доступа)"
    ' 2>/dev/null

echo "═══ вывод ═══"
cat <<'TXT'
  Все меры hardening применены — и ни одна не помешала.
  Они ограничивают процесс в container'е, а сокет позволяет
  попросить демон создать ДРУГОЙ container, уже без ограничений.
TXT

═══ container с сокетом, максимально ограниченный ═══
  UID: 10001, capabilities отобраны, корень read-only, сети нет
  версия демона через сокет:
    29.0.1
═══ вывод ═══
  Все меры hardening применены — и ни одна не помешала.
  Они ограничивают процесс в container'е, а сокет позволяет
  попросить демон создать ДРУГОЙ container, уже без ограничений.

cd /tmp/sockdemo
cat > find-socket-mounts.sh <<'SH'
#!/usr/bin/env bash
# Поиск container'ов с доступом к Docker socket.
set -uo pipefail

found=0
printf '  %-24s %-10s %s\n' "CONTAINER" "UID" "МОНТИРОВАНИЕ"
printf '  %s\n' "──────────────────────────────────────────────────────────────"

while read -r cid; do
    [ -z "$cid" ] && continue
    name="$(docker inspect "$cid" --format '{{.Name}}' | tr -d '/')"
    mounts="$(docker inspect "$cid" --format '{{range .Mounts}}{{.Source}}:{{.Destination}} {{end}}')"
    case "$mounts" in
        *docker.sock*)
            user="$(docker inspect "$cid" --format '{{if .Config.User}}{{.Config.User}}{{else}}root{{end}}')"
            sock="$(echo "$mounts" | tr ' ' '\n' | grep docker.sock | head -1)"
            printf '  %-24s %-10s %s\n' "${name:0:24}" "$user" "$sock"
            found=$((found + 1))
            ;;
    esac
done < <(docker ps -q)

if [ "$found" -eq 0 ]; then
    echo "  container'ов с доступом к сокету не найдено"
else
    printf '\n  НАЙДЕНО: %s. Каждый из них имеет права root на host.\n' "$found"
fi

echo
echo "  Поиск в конфигурациях:"
grep -rl 'docker\.sock' --include='*.yaml' --include='*.yml' . 2>/dev/null \
    | head -5 | sed 's/^/    /' || echo "    в файлах не найдено"

exit "$( [ "$found" -eq 0 ] && echo 0 || echo 1 )"
SH
chmod +x find-socket-mounts.sh

echo "═══ поднимаем container с сокетом для проверки ═══"
docker run -d --name sock-user \
    -v /var/run/docker.sock:/var/run/docker.sock \
    alpine:3.21 sleep 120 > /dev/null

cat > compose.example.yaml <<'EOF'
services:
  watchtower:
    image: containrrr/watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
EOF

./find-socket-mounts.sh || true
docker rm -f sock-user > /dev/null

═══ поднимаем container с сокетом для проверки ═══
  CONTAINER                UID        МОНТИРОВАНИЕ
  ──────────────────────────────────────────────────────────────
  sock-user                root       /var/run/docker.sock:/var/run/docker.sock

  НАЙДЕНО: 1. Каждый из них имеет права root на host.

  Поиск в конфигурациях:
    ./compose.example.yaml

cd /tmp/sockdemo
cat > proxy.py <<'PY'
"""Минимальный socket proxy: пропускает только разрешённые запросы.

Демонстрирует принцип. В эксплуатации используют готовые решения
(например, tecnativa/docker-socket-proxy) с полным разбором API.
"""
from __future__ import annotations

import http.server
import json
import re
import socket
import socketserver
import sys

SOCKET_PATH = "/var/run/docker.sock"

# Разрешаем только чтение: список и просмотр container'ов, версия.
ALLOWED = [
    (r"^GET$", r"^/v[\d.]+/version$|^/version$"),
    (r"^GET$", r"^/v[\d.]+/containers/json|^/containers/json"),
    (r"^GET$", r"^/v[\d.]+/containers/[^/]+/json$|^/containers/[^/]+/json$"),
]


def allowed(method: str, path: str) -> bool:
    return any(re.match(m, method) and re.match(p, path) for m, p in ALLOWED)


class Handler(http.server.BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def _forward(self) -> None:
        if not allowed(self.command, self.path):
            body = json.dumps({
                "message": f"запрещено политикой proxy: {self.command} {self.path}"
            }).encode()
            self.send_response(403)
            self.send_header("Content-Type", "application/json")
            self.send_header("Content-Length", str(len(body)))
            self.end_headers()
            self.wfile.write(body)
            print(f"  БЛОКИРОВАНО: {self.command} {self.path}", flush=True)
            return

        print(f"  разрешено:   {self.command} {self.path}", flush=True)
        s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
        s.connect(SOCKET_PATH)
        request = f"{self.command} {self.path} HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n"
        s.sendall(request.encode())
        chunks = []
        while True:
            data = s.recv(65536)
            if not data:
                break
            chunks.append(data)
        s.close()
        self.wfile.write(b"".join(chunks))

    do_GET = _forward
    do_POST = _forward
    do_DELETE = _forward

    def log_message(self, *args: object) -> None:
        pass


if __name__ == "__main__":
    port = int(sys.argv[1]) if len(sys.argv) > 1 else 2380
    print(f"proxy слушает {port}, разрешено только чтение", flush=True)
    with socketserver.ThreadingTCPServer(("0.0.0.0", port), Handler) as srv:
        srv.allow_reuse_address = True
        srv.serve_forever()
PY

echo "═══ запускаем proxy ═══"
docker run -d --name sockproxy \
    -v /var/run/docker.sock:/var/run/docker.sock:ro \
    -v "$PWD/proxy.py:/proxy.py:ro" \
    -p 127.0.0.1:2380:2380 \
    python:3.13-slim python -u /proxy.py 2380 > /dev/null
sleep 3

echo "═══ разрешённый запрос ═══"
curl -s -m 5 http://127.0.0.1:2380/version 2>/dev/null \
    | python3 -c "import json,sys; print('  версия:', json.load(sys.stdin).get('Version'))" 2>/dev/null \
    || echo "  (proxy недоступен)"

echo "═══ запрещённый запрос: создание container ═══"
curl -s -m 5 -X POST -H 'Content-Type: application/json' \
    -d '{"Image":"alpine","HostConfig":{"Binds":["/:/host"]}}' \
    "http://127.0.0.1:2380/containers/create" 2>/dev/null \
    | python3 -c "import json,sys; print('  ответ:', json.load(sys.stdin).get('message'))" 2>/dev/null \
    || echo "  (нет ответа)"

echo "═══ журнал proxy ═══"
docker logs sockproxy 2>&1 | tail -4 | sed 's/^/  /'

docker rm -f sockproxy > /dev/null

═══ запускаем proxy ═══
═══ разрешённый запрос ═══
  версия: 29.0.1
═══ запрещённый запрос: создание container ═══
  ответ: запрещено политикой proxy: POST /containers/create
═══ журнал proxy ═══
  proxy слушает 2380, разрешено только чтение
  разрешено:   GET /version
  БЛОКИРОВАНО: POST /containers/create
═══

cd /tmp/sockdemo
echo "═══ текущий режим демона ═══"
if docker info --format '{{json .SecurityOptions}}' 2>/dev/null | grep -q rootless; then
    echo "  rootless"
    printf '  сокет: %s\n' "${DOCKER_HOST:-unix://$XDG_RUNTIME_DIR/docker.sock}"
else
    echo "  rootful — демон работает от root"
    printf '  сокет: /var/run/docker.sock (владелец root, группа docker)\n'
fi

echo "═══ чем отличается rootless ═══"
cat <<'TXT'
  rootful:   демон root → создание container с -v /:/host даёт полный root
  rootless:  демон от вашего пользователя → монтирование / даёт
             ровно те права, что есть у вас; файлы root недоступны

  Цена rootless: ограничения сети (нет портов < 1024 без настройки),
  ограничения хранилища, часть возможностей недоступна.
TXT

echo "═══ проверка на текущей системе ═══"
docker run --rm -v /:/host:ro alpine:3.21 sh -c '
    if cat /host/etc/shadow > /dev/null 2>&1; then
        echo "  /etc/shadow ЧИТАЕТСЯ → демон работает от root"
    else
        echo "  /etc/shadow недоступен → вероятно, rootless"
    fi
' 2>/dev/null

═══ текущий режим демона ═══
  rootful — демон работает от root
  сокет: /var/run/docker.sock (владелец root, группа docker)
═══ чем отличается rootless ═══
  rootful:   демон root → создание container с -v /:/host даёт полный root
  rootless:  демон от вашего пользователя → монтирование / даёт
             ровно те права, что есть у вас; файлы root недоступны

  Цена rootless: ограничения сети (нет портов < 1024 без настройки),
  ограничения хранилища, часть возможностей недоступна.
═══ проверка на текущей системе ═══
  /etc/shadow ЧИТАЕТСЯ → демон работает от root

cd /tmp/sockdemo
echo "═══ проверка открытых портов API ═══"
for port in 2375 2376; do
    if ss -tln 2>/dev/null | grep -q ":$port "; then
        printf '  порт %s: ОТКРЫТ\n' "$port"
        [ "$port" = "2375" ] && printf '    ⚠ это API без TLS — root-доступ для всех, кто дойдёт\n'
    else
        printf '  порт %s: закрыт\n' "$port"
    fi
done

echo "═══ что было бы при открытом 2375 ═══"
cat <<'TXT'
  Любой, кто может подключиться к порту:
    curl -X POST http://УЗЕЛ:2375/containers/create \
      -d '{"Image":"alpine","HostConfig":{"Binds":["/:/host"]}}'
  — и получает запись в любой файл host.

  Такие узлы находят массовым сканированием сети.

  Правильные варианты удалённого доступа:
    1. docker context поверх SSH   ← предпочтительно
    2. TLS с взаимной проверкой на 2376
    3. TCP без TLS                 ← недопустимо никогда
TXT

echo "═══ настройка доступа по SSH ═══"
cat <<'TXT'
  docker context create prod --docker "host=ssh://user@узел"
  docker context use prod
  docker ps        # выполняется на удалённом узле через SSH
TXT
docker context ls --format '  {{.Name}}\t{{.DockerEndpoint}}' 2>/dev/null | head -3

═══ проверка открытых портов API ═══
  порт 2375: закрыт
  порт 2376: закрыт
═══ что было бы при открытом 2375 ═══
  Любой, кто может подключиться к порту:
    curl -X POST http://УЗЕЛ:2375/containers/create \
      -d '{"Image":"alpine","HostConfig":{"Binds":["/:/host"]}}'
  — и получает запись в любой файл host.

  Такие узлы находят массовым сканированием сети.

  Правильные варианты удалённого доступа:
    1. docker context поверх SSH   ← предпочтительно
    2. TLS с взаимной проверкой на 2376
    3. TCP без TLS                 ← недопустимо никогда
═══ настройка доступа по SSH ═══
  docker context create prod --docker "host=ssh://user@узел"
  docker context use prod
  docker ps        # выполняется на удалённом узле через SSH
  default	unix:///var/run/docker.sock

cd /tmp/sockdemo
echo "═══ типичный CI-агент с сокетом ═══"
cat <<'TXT'
  services:
    ci-agent:
      volumes:
        - /var/run/docker.sock:/var/run/docker.sock   ← root на host
TXT

echo "═══ альтернатива: сборка без сокета ═══"
cat <<'TXT'
  BuildKit умеет собирать образы, не обращаясь к демону Docker:

    docker buildx create --driver docker-container --name builder
    docker buildx build --builder builder -t app .

  Драйвер docker-container запускает BuildKit в отдельном container'е.
  Агенту нужен доступ к нему, а не к основному демону.

  Ещё варианты без сокета:
    kaniko    — сборка внутри Kubernetes без демона
    buildah   — сборка без демона вообще
TXT

echo "═══ доступные драйверы buildx ═══"
docker buildx ls 2>/dev/null | head -5 | sed 's/^/  /' || echo "  buildx недоступен"

═══ типичный CI-агент с сокетом ═══
  services:
    ci-agent:
      volumes:
        - /var/run/docker.sock:/var/run/docker.sock   ← root на host
═══ альтернатива: сборка без сокета ═══
  BuildKit умеет собирать образы, не обращаясь к демону Docker:

    docker buildx create --driver docker-container --name builder
    docker buildx build --builder builder -t app .

  Драйвер docker-container запускает BuildKit в отдельном container'е.
  Агенту нужен доступ к нему, а не к основному демону.

  Ещё варианты без сокета:
    kaniko    — сборка внутри Kubernetes без демона
    buildah   — сборка без демона вообще
═══ доступные драйверы buildx ═══
  NAME/NODE       DRIVER/ENDPOINT   STATUS    BUILDKIT   PLATFORMS
  default*        docker
   \_ default      \_ default       running   v0.28.1    linux/amd64

sudo rm -f /root/only-root.txt 2>/dev/null
cd /tmp && rm -rf /tmp/sockdemo

ls -l /var/run/docker.sock
getent group docker
docker run --rm -v /:/host:ro alpine:3.21 sh -c 'ls /host/root 2>&1 | head -2'