6.7. Non-root user и permissions

FROM python:3.13-slim
RUN apt-get update \
 && apt-get install -y --no-install-recommends ca-certificates \
 && rm -rf /var/lib/apt/lists/*     # нужен root
RUN useradd --create-home --uid 10001 appuser   # нужен root
COPY --chown=10001:10001 app/ /app/             # нужен root
USER 10001:10001                                # переключение в самом конце
CMD ["python", "/app/main.py"]

WORKDIR /app     # каталог принадлежит root
USER 10001
RUN touch /app/f # Permission denied

docker run --read-only \
    --tmpfs /tmp:rw,noexec,nosuid,size=64m \
    myapp

   UID процесса == UID владельца?  ──► применяются права владельца (rwx------)
                    │ нет
                    ▼
   GID процесса или supplementary
   groups содержит GID файла?      ──► применяются права группы (---rwx---)
                    │ нет
                    ▼
                                        применяются права остальных (------rwx)

# Debian, Ubuntu
RUN useradd --create-home --uid 10001 appuser

# Alpine
RUN adduser -D -u 10001 appuser

mkdir -p /tmp/perms/app && cd /tmp/perms
cat > app/main.py <<'PY'
"""Приложение, проверяющее доступные права."""
import os
import tempfile
from pathlib import Path

print(f"UID={os.getuid()}  GID={os.getgid()}  groups={os.getgroups()}")

checks = {
    "/tmp": Path("/tmp"),
    "домашний каталог": Path(os.path.expanduser("~")),
    "/app": Path("/app"),
    "/app/data": Path("/app/data"),
}

for label, path in checks.items():
    if not path.exists():
        print(f"  {label:<20} отсутствует")
        continue
    try:
        probe = path / ".write-probe"
        probe.write_text("x")
        probe.unlink()
        print(f"  {label:<20} запись доступна")
    except OSError as exc:
        print(f"  {label:<20} ЗАПРЕЩЕНА ({exc.strerror})")

try:
    with tempfile.NamedTemporaryFile() as f:
        f.write(b"x")
    print("  tempfile             работает")
except OSError as exc:
    print(f"  tempfile             ОШИБКА ({exc.strerror})")
PY

cat > Dockerfile.root <<'EOF'
FROM python:3.13-slim
ENV PYTHONUNBUFFERED=1
WORKDIR /app
COPY app/ ./app/
RUN mkdir -p /app/data
CMD ["python", "app/main.py"]
EOF

docker build -q -f Dockerfile.root -t perm:root . > /dev/null
docker run --rm perm:root

UID=0  GID=0  groups=[0]
  /tmp                 запись доступна
  домашний каталог     запись доступна
  /app                 запись доступна
  /app/data            запись доступна
  tempfile             работает

mkdir -p shared
docker run --rm -v "$PWD/shared:/data" perm:root \
    sh -c 'echo "создано в container" > /data/file.txt'
ls -l shared/file.txt
echo "попытка удалить обычным пользователем:"
rm shared/file.txt 2>&1 | head -1 || echo "  не удалось"
sudo rm -f shared/file.txt 2>/dev/null

-rw-r--r-- 1 root root 20 Jul 30 13:20 shared/file.txt
попытка удалить обычным пользователем:
rm: удалить защищённый от записи обычный файл 'shared/file.txt'? 

cat > Dockerfile.naive <<'EOF'
FROM python:3.13-slim
ENV PYTHONUNBUFFERED=1
RUN useradd --create-home --uid 10001 appuser
WORKDIR /app
COPY app/ ./app/
RUN mkdir -p /app/data
USER 10001:10001
CMD ["python", "app/main.py"]
EOF

docker build -q -f Dockerfile.naive -t perm:naive . > /dev/null
docker run --rm perm:naive

UID=10001  GID=10001  groups=[10001]
  /tmp                 запись доступна
  домашний каталог     запись доступна
  /app                 ЗАПРЕЩЕНА (Permission denied)
  /app/data            ЗАПРЕЩЕНА (Permission denied)
  tempfile             работает

docker run --rm --user 0:0 perm:naive ls -ld /app /app/data

drwxr-xr-x 3 root root 4096 Jul 30 13:22 /app
drwxr-xr-x 2 root root 4096 Jul 30 13:22 /app/data

cat > Dockerfile.correct <<'EOF'
FROM python:3.13-slim

ENV PYTHONUNBUFFERED=1 \
    PYTHONDONTWRITEBYTECODE=1

# UID из свободного диапазона 10000+; --create-home нужен для ~/.cache
RUN useradd --create-home --uid 10001 --shell /usr/sbin/nologin appuser

WORKDIR /app

# Каталог данных создаётся и передаётся пользователю ДО переключения
RUN mkdir -p /app/data && chown -R 10001:10001 /app

# --chown избавляет от отдельной инструкции RUN chown
COPY --chown=10001:10001 app/ ./app/

USER 10001:10001
CMD ["python", "app/main.py"]
EOF

docker build -q -f Dockerfile.correct -t perm:correct . > /dev/null
docker run --rm perm:correct

UID=10001  GID=10001  groups=[10001]
  /tmp                 запись доступна
  домашний каталог     запись доступна
  /app                 запись доступна
  /app/data            запись доступна
  tempfile             работает

docker run --rm -v "$PWD/shared:/data" perm:correct \
    sh -c 'echo "от appuser" > /data/file2.txt' 2>/dev/null || \
docker run --rm --user 10001:10001 -v "$PWD/shared:/data" perm:correct \
    python -c "open('/data/file2.txt','w').write('от appuser')" 2>&1 | tail -1
ls -ln shared/ 2>/dev/null | tail -2

-rw-r--r-- 1 10001 10001 10 Jul 30 13:25 file2.txt

cat > Dockerfile.order-bad <<'EOF'
FROM python:3.13-slim
RUN useradd --create-home --uid 10001 appuser
USER 10001:10001
WORKDIR /late-workdir
RUN touch /late-workdir/probe && echo "запись удалась"
CMD ["true"]
EOF

echo "=== WORKDIR ПОСЛЕ USER ==="
docker build -f Dockerfile.order-bad -t perm:order-bad . 2>&1 | grep -E 'запись|ERROR' | head -2

cat > Dockerfile.order-good <<'EOF'
FROM python:3.13-slim
RUN useradd --create-home --uid 10001 appuser
WORKDIR /early-workdir
RUN chown 10001:10001 /early-workdir
USER 10001:10001
RUN touch /early-workdir/probe && echo "запись удалась"
CMD ["true"]
EOF

echo "=== WORKDIR ДО USER, с chown ==="
docker build -f Dockerfile.order-good -t perm:order-good . 2>&1 | grep -E 'запись|ERROR' | head -2

=== WORKDIR ПОСЛЕ USER ===
#6 0.185 запись удалась
=== WORKDIR ДО USER, с chown ===
#7 0.192 запись удалась

cat > Dockerfile.name <<'EOF'
FROM python:3.13-slim
RUN useradd --create-home --uid 10001 appuser
USER appuser
CMD ["id"]
EOF

cat > Dockerfile.uid <<'EOF'
FROM python:3.13-slim
RUN useradd --create-home --uid 10001 appuser
USER 10001:10001
CMD ["id"]
EOF

for v in name uid; do
    docker build -q -f "Dockerfile.$v" -t "perm:$v" . > /dev/null
    printf '%-6s Config.User = %-12s  запуск: %s\n' "$v" \
        "$(docker image inspect "perm:$v" --format '{{.Config.User}}')" \
        "$(docker run --rm "perm:$v")"
done

name   Config.User = appuser       запуск: uid=10001(appuser) gid=10001(appuser) groups=10001(appuser)
uid    Config.User = 10001:10001   запуск: uid=10001(appuser) gid=10001(appuser) groups=10001(appuser)

for v in name uid; do
    u="$(docker image inspect "perm:$v" --format '{{.Config.User}}')"
    if [ -z "$u" ]; then
        verdict="ОТКАЗ: User не задан"
    elif echo "$u" | grep -qE '^[0-9]+'; then
        verdict="принято: числовой UID"
    else
        verdict="ОТКАЗ: имя, а не UID — проверить нельзя"
    fi
    printf '%-6s %s\n' "$v" "$verdict"
done

name   ОТКАЗ: имя, а не UID — проверить нельзя
uid    принято: числовой UID

cat > Dockerfile.nobody <<'EOF'
FROM python:3.13-slim
WORKDIR /app
COPY app/ ./app/
USER nobody
CMD ["python", "app/main.py"]
EOF

docker build -q -f Dockerfile.nobody -t perm:nobody . > /dev/null
docker run --rm perm:nobody

UID=65534  GID=65534  groups=[65534]
  /tmp                 запись доступна
  домашний каталог     ЗАПРЕЩЕНА (Permission denied)
  /app                 ЗАПРЕЩЕНА (Permission denied)
  /app/data            отсутствует
  tempfile             работает

docker run --rm --entrypoint sh perm:nobody -c 'getent passwd nobody'

nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin

cat > Dockerfile.venv-bad <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim AS builder
RUN python -m venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"
RUN pip install --no-cache-dir httpx==0.28.1

FROM python:3.13-slim
RUN useradd --create-home --uid 10001 appuser
COPY --from=builder /opt/venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"
USER 10001:10001
CMD ["sh", "-c", "ls -ld /opt/venv && python -c 'import httpx; print(\"импорт работает\")'"]
EOF

docker build -q -f Dockerfile.venv-bad -t perm:venv-bad . > /dev/null
docker run --rm perm:venv-bad

drwxr-xr-x 5 root root 4096 Jul 30 13:32 /opt/venv
импорт работает

sed 's|COPY --from=builder /opt/venv|COPY --from=builder --chown=10001:10001 /opt/venv|' \
    Dockerfile.venv-bad > Dockerfile.venv-good
docker build -q -f Dockerfile.venv-good -t perm:venv-good . > /dev/null
docker run --rm perm:venv-good

drwxr-xr-x 5 10001 10001 4096 Jul 30 13:33 /opt/venv
импорт работает

cat > Dockerfile.venv-chown <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim AS builder
RUN python -m venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"
RUN pip install --no-cache-dir httpx==0.28.1

FROM python:3.13-slim
RUN useradd --create-home --uid 10001 appuser
COPY --from=builder /opt/venv /opt/venv
RUN chown -R 10001:10001 /opt/venv
ENV PATH="/opt/venv/bin:$PATH"
USER 10001:10001
CMD ["true"]
EOF

docker build -q -f Dockerfile.venv-chown -t perm:venv-chown . > /dev/null
docker images --format '  {{.Repository}}:{{.Tag}}  {{.Size}}' | grep -E 'perm:venv'

perm:venv-chown  220MB
perm:venv-good  198MB
perm:venv-bad  198MB

cat > Dockerfile.pyc <<'EOF'
FROM python:3.13-slim
ENV PYTHONUNBUFFERED=1
RUN useradd --create-home --uid 10001 appuser
WORKDIR /app
COPY --chown=10001:10001 app/ ./app/
RUN chown 10001:10001 /app
USER 10001:10001
CMD ["sh", "-c", "python -c 'import sys; sys.path.insert(0,\"/app\"); import app.main' 2>/dev/null; find /app -name '__pycache__' | wc -l"]
EOF

docker build -q -f Dockerfile.pyc -t perm:pyc . > /dev/null
echo -n "с правом записи в /app, __pycache__ создан: "
docker run --rm perm:pyc

# теперь /app принадлежит root
sed 's|RUN chown 10001:10001 /app||' Dockerfile.pyc > Dockerfile.pyc-ro
sed -i 's|COPY --chown=10001:10001|COPY|' Dockerfile.pyc-ro
docker build -q -f Dockerfile.pyc-ro -t perm:pyc-ro . > /dev/null
echo -n "без права записи, __pycache__ создан: "
docker run --rm perm:pyc-ro

с правом записи в /app, __pycache__ создан: 1
без права записи, __pycache__ создан: 0

cat > Dockerfile.ro <<'EOF'
FROM python:3.13-slim
ENV PYTHONUNBUFFERED=1 \
    PYTHONDONTWRITEBYTECODE=1
RUN useradd --create-home --uid 10001 appuser
WORKDIR /app
COPY --chown=10001:10001 app/ ./app/
RUN mkdir -p /app/data && chown -R 10001:10001 /app
USER 10001:10001
CMD ["python", "app/main.py"]
EOF

docker build -q -f Dockerfile.ro -t perm:ro . > /dev/null

echo "=== обычный запуск ==="
docker run --rm perm:ro

echo
echo "=== с --read-only, без tmpfs ==="
docker run --rm --read-only perm:ro

echo
echo "=== с --read-only и tmpfs ==="
docker run --rm --read-only \
    --tmpfs /tmp:rw,noexec,nosuid,size=64m \
    --tmpfs /home/appuser:rw,noexec,nosuid,size=16m \
    -v perm-data:/app/data \
    perm:ro

=== обычный запуск ===
UID=10001  GID=10001  groups=[10001]
  /tmp                 запись доступна
  домашний каталог     запись доступна
  /app                 запись доступна
  /app/data            запись доступна
  tempfile             работает

=== с --read-only, без tmpfs ===
UID=10001  GID=10001  groups=[10001]
  /tmp                 ЗАПРЕЩЕНА (Read-only file system)
  домашний каталог     ЗАПРЕЩЕНА (Read-only file system)
  /app                 ЗАПРЕЩЕНА (Read-only file system)
  /app/data            ЗАПРЕЩЕНА (Read-only file system)
  tempfile             ОШИБКА (Read-only file system)

=== с --read-only и tmpfs ===
UID=10001  GID=10001  groups=[10001]
  /tmp                 запись доступна
  домашний каталог     запись доступна
  /app                 ЗАПРЕЩЕНА (Read-only file system)
  /app/data            запись доступна
  tempfile             работает

docker volume rm perm-data > /dev/null 2>&1 || true

diagnose_permissions() {
    local image="$1" path="$2"
    echo "── диагностика записи в $path ──"

    local user
    user="$(docker run --rm --entrypoint id "$image" 2>/dev/null)"
    echo "  процесс: $user"

    echo -n "  владелец каталога: "
    docker run --rm --user 0:0 --entrypoint stat "$image" -c '%U:%G (%a)' "$path" 2>/dev/null \
        || echo "каталог отсутствует"

    echo -n "  запись: "
    if docker run --rm --entrypoint sh "$image" -c "touch $path/.probe 2>/dev/null && rm -f $path/.probe && echo доступна" 2>/dev/null | grep -q доступна; then
        echo "доступна"
    else
        echo "ЗАПРЕЩЕНА"
        echo "  Проверьте:"
        echo "    1. владелец каталога совпадает с UID процесса?"
        echo "    2. каталог создан ДО переключения USER?"
        echo "    3. есть ли chown или COPY --chown?"
    fi
}

diagnose_permissions perm:naive /app
echo
diagnose_permissions perm:correct /app

── диагностика записи в /app ──
  процесс: uid=10001(appuser) gid=10001(appuser) groups=10001(appuser)
  владелец каталога: root:root (755)
  запись: ЗАПРЕЩЕНА
  Проверьте:
    1. владелец каталога совпадает с UID процесса?
    2. каталог создан ДО переключения USER?
    3. есть ли chown или COPY --chown?

── диагностика записи в /app ──
  процесс: uid=10001(appuser) gid=10001(appuser) groups=10001(appuser)
  владелец каталога: 10001:10001 (755)
  запись: доступна

cat > Dockerfile.777 <<'EOF'
FROM python:3.13-slim
ENV PYTHONUNBUFFERED=1
RUN useradd --create-home --uid 10001 appuser
WORKDIR /app
COPY app/ ./app/
RUN mkdir -p /app/data && chmod -R 777 /app
USER 10001:10001
CMD ["python", "app/main.py"]
EOF

docker build -q -f Dockerfile.777 -t perm:777 . > /dev/null
docker run --rm perm:777 | head -4

echo
echo "=== последствие: любой пользователь может изменить код ==="
docker run --rm --user 65534:65534 perm:777 \
    sh -c 'echo "код подменён" > /app/app/main.py && echo "ПОДМЕНА УДАЛАСЬ от nobody"'

UID=10001  GID=10001  groups=[10001]
  /tmp                 запись доступна
  домашний каталог     запись доступна
  /app                 запись доступна

=== последствие: любой пользователь может изменить код ===
ПОДМЕНА УДАЛАСЬ от nobody

docker run --rm --user 65534:65534 perm:correct \
    sh -c 'echo "подмена" > /app/app/main.py 2>&1 || echo "подмена невозможна"'

подмена невозможна

cd /tmp
docker rmi -f $(docker images -q --filter 'reference=perm:*') 2>/dev/null || true
docker volume rm perm-data 2>/dev/null || true
sudo rm -rf /tmp/perms 2>/dev/null || rm -rf /tmp/perms

mkdir -p /tmp/vnr && cd /tmp/vnr
printf 'FROM python:3.13-slim\nRUN useradd --create-home --uid 10001 appuser\nWORKDIR /app\nRUN chown 10001:10001 /app\nUSER 10001:10001\nCMD ["sh","-c","id -u; touch /app/x && echo запись-ок"]\n' > Dockerfile
docker build -q -t vnr:1 . > /dev/null
docker run --rm vnr:1
docker image inspect vnr:1 --format 'Config.User = {{.Config.User}}'
docker rmi vnr:1 > /dev/null; cd /tmp && rm -rf /tmp/vnr