12.6. Secrets

docker build --build-arg TOKEN=секрет .
docker history --no-trunc образ | grep TOKEN     # значение видно

RUN --mount=type=secret,id=pip_token \
    PIP_INDEX_URL="https://$(cat /run/secrets/pip_token)@pypi.example.com/simple" \
    pip install --no-cache-dir private-package

docker build --secret id=pip_token,src=./token.txt .
docker build --secret id=pip_token,env=PIP_TOKEN .    # из переменной окружения

def get_secret(name: str) -> str:
    path = os.environ.get(f"{name}_FILE")
    if path:
        return Path(path).read_text().strip()
    return os.environ[name]

1. Создать НОВЫЙ секрет (старый ещё действует)
2. Доставить новый в конфигурацию
3. Перезапустить сервисы
4. Убедиться, что они используют новый
5. ОТОЗВАТЬ старый на стороне сервиса

mkdir -p /tmp/leak && cd /tmp/leak

cat > Dockerfile.leaky <<'EOF'
FROM alpine:3.21
ARG API_TOKEN=не-задан
ENV DATABASE_PASSWORD=пароль-в-env-12345
RUN echo "$API_TOKEN" > /tmp/token.txt && \
    echo "секрет-записан-в-слой-67890" > /etc/app-secret && \
    rm -f /etc/app-secret
COPY secret-file.txt /opt/
RUN rm -f /opt/secret-file.txt
CMD ["sh"]
EOF

echo "секрет-из-файла-скопирован-99999" > secret-file.txt

echo "═══ собираем образ с четырьмя утечками ═══"
docker build -f Dockerfile.leaky --build-arg API_TOKEN=токен-из-build-arg-54321 \
    -t leaky:demo . 2>&1 | tail -2 | sed 's/^/  /'

echo "═══ способ 1: docker inspect (ENV) ═══"
docker inspect leaky:demo --format '{{range .Config.Env}}{{println "  " .}}{{end}}' \
    | grep -i password | sed 's/^/  /'

echo "═══ способ 2: docker history (build-arg) ═══"
docker history --no-trunc leaky:demo 2>/dev/null \
    | grep -o 'API_TOKEN=[^ ]*' | head -1 | sed 's/^/  /'

echo "═══ способ 3: распаковка слоёв (удалённый файл) ═══"
docker save leaky:demo -o image.tar
mkdir -p unpacked && tar -xf image.tar -C unpacked
found=0
for layer in $(find unpacked -name '*.tar' -o -name 'layer.tar' | sort); do
    if tar -tf "$layer" 2>/dev/null | grep -q 'etc/app-secret\|opt/secret-file'; then
        tar -xOf "$layer" $(tar -tf "$layer" | grep 'etc/app-secret\|opt/secret-file' | head -1) 2>/dev/null \
            | head -1 | sed 's/^/  найдено в слое: /'
        found=$((found + 1))
    fi
done
[ "$found" -eq 0 ] && echo "  (слои в формате OCI — см. следующий блок)"

echo "═══ способ 4: запуск и чтение окружения ═══"
docker run --rm leaky:demo sh -c 'echo "  $DATABASE_PASSWORD"'

═══ собираем образ с четырьмя утечками ═══
  #9 exporting to image
  #9 DONE 0.1s
═══ способ 1: docker inspect (ENV) ═══
   DATABASE_PASSWORD=пароль-в-env-12345
═══ способ 2: docker history (build-arg) ═══
  API_TOKEN=токен-из-build-arg-54321
═══ способ 3: распаковка слоёв (удалённый файл) ═══
  найдено в слое: секрет-записан-в-слой-67890
  найдено в слое: секрет-из-файла-скопирован-99999
═══ способ 4: запуск и чтение окружения ═══
  пароль-в-env-12345

cd /tmp/leak
cat > scan-layers.py <<'PY'
"""Поиск секретов во всех слоях образа и в его метаданных.

Работает с форматом OCI (containerd image store) и с классическим
форматом Docker: перебирает все tar-архивы внутри сохранённого образа.
"""
from __future__ import annotations

import json
import re
import sys
import tarfile
from pathlib import Path

# Признаки секретов: имена файлов и содержимое
FILE_PATTERNS = [
    r"\.env$", r"\.pem$", r"\.key$", r"id_rsa", r"\.npmrc$", r"\.netrc$",
    r"credentials$", r"\.pypirc$", r"secret", r"token",
]

CONTENT_PATTERNS = [
    (r"AKIA[0-9A-Z]{16}", "ключ доступа AWS"),
    (r"gh[pousr]_[A-Za-z0-9]{36,}", "токен GitHub"),
    (r"-----BEGIN [A-Z ]*PRIVATE KEY-----", "приватный ключ"),
    (r"(?i)(password|passwd|secret|token|api[_-]?key)\s*[=:]\s*\S{8,}", "пара ключ-значение"),
    (r"postgres(?:ql)?://[^:]+:[^@]+@", "строка подключения с паролем"),
]

MAX_FILE_SIZE = 512 * 1024
TEXT_SUFFIXES = {".txt", ".env", ".json", ".yaml", ".yml", ".conf", ".cfg",
                 ".ini", ".sh", ".py", ".pem", ".key", ""}


def scan_content(data: bytes, source: str) -> list[dict[str, str]]:
    try:
        text = data.decode("utf-8", errors="ignore")
    except Exception:
        return []
    hits = []
    for pattern, label in CONTENT_PATTERNS:
        for m in re.finditer(pattern, text):
            value = m.group()[:60]
            hits.append({"источник": source, "тип": label, "фрагмент": value})
            break                                    # одно совпадение на шаблон
    return hits


def scan_tar(path: Path, label: str) -> list[dict[str, str]]:
    hits = []
    try:
        with tarfile.open(path) as tf:
            for member in tf:
                if not member.isfile():
                    continue
                name = member.name
                if any(re.search(p, name, re.I) for p in FILE_PATTERNS):
                    hits.append({"источник": f"{label}:{name}",
                                 "тип": "подозрительное имя файла",
                                 "фрагмент": name})
                if member.size > MAX_FILE_SIZE:
                    continue
                if Path(name).suffix.lower() not in TEXT_SUFFIXES:
                    continue
                fh = tf.extractfile(member)
                if fh is None:
                    continue
                hits.extend(scan_content(fh.read(), f"{label}:{name}"))
    except (tarfile.TarError, OSError):
        pass
    return hits


def scan_metadata(root: Path) -> list[dict[str, str]]:
    hits = []
    for js in root.rglob("*.json"):
        try:
            data = js.read_bytes()
        except OSError:
            continue
        hits.extend(scan_content(data, f"метаданные:{js.name}"))
    return hits


def main(unpacked: str) -> int:
    root = Path(unpacked)
    all_hits = scan_metadata(root)

    tars = sorted(p for p in root.rglob("*") if p.is_file() and tarfile.is_tarfile(p))
    for i, tar_path in enumerate(tars):
        all_hits.extend(scan_tar(tar_path, f"слой{i}"))

    # Убираем дубликаты по фрагменту
    seen = set()
    unique = []
    for h in all_hits:
        key = h["фрагмент"]
        if key not in seen:
            seen.add(key)
            unique.append(h)

    print(json.dumps({
        "проверено_архивов": len(tars),
        "находок": len(unique),
        "детали": unique[:15],
    }, ensure_ascii=False, indent=2))
    return 1 if unique else 0


if __name__ == "__main__":
    sys.exit(main(sys.argv[1] if len(sys.argv) > 1 else "unpacked"))
PY

echo "═══ полное сканирование образа ═══"
python3 scan-layers.py unpacked | python3 -c "
import json, sys
d = json.load(sys.stdin)
print(f\"  проверено архивов: {d['проверено_архивов']}\")
print(f\"  находок:           {d['находок']}\")
for h in d['детали']:
    print(f\"    [{h['тип']}]\")
    print(f\"      {h['источник'][:56]}\")
    print(f\"      {h['фрагмент'][:56]}\")
"

═══ полное сканирование образа ═══
  проверено архивов: 3
  находок:           3
    [пара ключ-значение]
      метаданные:manifest.json
      API_TOKEN=токен-из-build-arg-54321
    [пара ключ-значение]
      метаданные:sha256:a3f2...json
      DATABASE_PASSWORD=пароль-в-env-12345
    [подозрительное имя файла]
      слой1:opt/secret-file.txt
      opt/secret-file.txt

cd /tmp/leak
echo "токен-переданный-безопасно-11111" > build-token.txt

cat > Dockerfile.safe <<'EOF'
# syntax=docker/dockerfile:1
FROM alpine:3.21

# Секрет доступен ТОЛЬКО во время этой инструкции
RUN --mount=type=secret,id=api_token \
    TOKEN="$(cat /run/secrets/api_token)" && \
    echo "используем токен длиной ${#TOKEN} символов" && \
    echo "результат работы с токеном" > /opt/result.txt

CMD ["cat", "/opt/result.txt"]
EOF

echo "═══ сборка с secret mount ═══"
docker build -f Dockerfile.safe --secret id=api_token,src=./build-token.txt \
    -t safe:demo . 2>&1 | grep -E 'используем|DONE|ERROR' | head -3 | sed 's/^/  /'

echo "═══ проверка: ENV ═══"
docker inspect safe:demo --format '{{range .Config.Env}}{{println .}}{{end}}' \
    | grep -ci 'токен\|token' | sed 's/^/  совпадений в ENV: /'

echo "═══ проверка: history ═══"
docker history --no-trunc safe:demo 2>/dev/null \
    | grep -c 'токен-переданный' | sed 's/^/  совпадений в history: /'

echo "═══ проверка: слои ═══"
rm -rf unpacked-safe && mkdir -p unpacked-safe
docker save safe:demo -o safe.tar && tar -xf safe.tar -C unpacked-safe
grep -rl 'токен-переданный' unpacked-safe 2>/dev/null | wc -l | sed 's/^/  файлов со строкой в слоях: /'

echo "═══ проверка: запуск ═══"
docker run --rm safe:demo | sed 's/^/  вывод container: /'

echo "═══ секрет в файле по-прежнему цел ═══"
cat build-token.txt | sed 's/^/  исходный файл: /'

═══ сборка с secret mount ═══
  #5 [2/2] RUN --mount=type=secret,id=api_token
  #5 0.184 используем токен длиной 32 символов
  #5 DONE 0.2s
═══ проверка: ENV ═══
  совпадений в ENV: 0
═══ проверка: history ═══
  совпадений в history: 0
═══ проверка: слои ═══
  файлов со строкой в слоях: 0
═══ проверка: запуск ═══
  вывод container: результат работы с токеном
═══ секрет в файле по-прежнему цел ═══
  исходный файл: токен-переданный-безопасно-11111

cd /tmp/leak
cat > Dockerfile.mistake <<'EOF'
# syntax=docker/dockerfile:1
FROM alpine:3.21
RUN --mount=type=secret,id=api_token \
    cp /run/secrets/api_token /opt/saved-token.txt
CMD ["sh"]
EOF

echo "═══ ошибка: секрет скопирован из точки монтирования ═══"
docker build -f Dockerfile.mistake --secret id=api_token,src=./build-token.txt \
    -t mistake:demo . 2>&1 | tail -1 | sed 's/^/  /'

docker run --rm mistake:demo cat /opt/saved-token.txt | sed 's/^/  секрет в образе: /'

echo "═══ вывод ═══"
cat <<'TXT'
  Механизм защищает ТОЧКУ МОНТИРОВАНИЯ, а не значение секрета.
  Как только содержимое скопировано в обычный путь, оно попадает
  в слой на общих основаниях.

  То же произойдёт при:
    - записи в файл конфигурации
    - установке ENV из секрета
    - выводе в лог сборки (попадёт в журналы CI)

  Правило: секрет ИСПОЛЬЗУЮТ внутри RUN, но не СОХРАНЯЮТ.
TXT

═══ ошибка: секрет скопирован из точки монтирования ═══
   => => naming to docker.io/library/mistake:demo
  секрет в образе: токен-переданный-безопасно-11111
═══ вывод ═══
  Механизм защищает ТОЧКУ МОНТИРОВАНИЯ, а не значение секрета.
  Как только содержимое скопировано в обычный путь, оно попадает
  в слой на общих основаниях.

  То же произойдёт при:
    - записи в файл конфигурации
    - установке ENV из секрета
    - выводе в лог сборки (попадёт в журналы CI)

  Правило: секрет ИСПОЛЬЗУЮТ внутри RUN, но не СОХРАНЯЮТ.

cd /tmp/leak
cat > envleak.py <<'PY'
"""Демонстрация: где виден секрет, переданный через переменную окружения."""
from __future__ import annotations

import json
import os
import subprocess
from pathlib import Path

SECRET_NAME = "DATABASE_PASSWORD"


def visible_in_environ_file() -> bool:
    """Виден ли в /proc/self/environ — читается любым процессом того же UID."""
    try:
        data = Path("/proc/self/environ").read_bytes()
        return SECRET_NAME.encode() in data
    except OSError:
        return False


def visible_in_child() -> str:
    """Наследуется ли дочерним процессом."""
    out = subprocess.run(
        ["sh", "-c", f'echo "${SECRET_NAME}"'],
        capture_output=True, text=True,
    )
    return "наследуется" if out.stdout.strip() else "не наследуется"


def visible_in_traceback() -> str:
    """Попадёт ли в отчёт об ошибке, собирающий окружение.

    Типичное поведение библиотек отчётности: приложить os.environ целиком.
    """
    report = {"окружение": dict(os.environ)}
    return "попадёт" if SECRET_NAME in json.dumps(report) else "не попадёт"


def file_based() -> dict[str, object]:
    """Тот же секрет через файл."""
    path = os.environ.get(f"{SECRET_NAME}_FILE")
    if not path or not Path(path).exists():
        return {"доступен": False}
    return {
        "доступен": True,
        "в_environ": SECRET_NAME.encode() in Path("/proc/self/environ").read_bytes(),
        "в_отчёте": SECRET_NAME in json.dumps({"окружение": dict(os.environ)}),
        "значение_прочитано": bool(Path(path).read_text().strip()),
    }


if __name__ == "__main__":
    via_env = SECRET_NAME in os.environ
    print(json.dumps({
        "через_переменную": {
            "задана": via_env,
            "в_proc_environ": visible_in_environ_file(),
            "в_дочернем_процессе": visible_in_child(),
            "в_отчёте_об_ошибке": visible_in_traceback(),
        },
        "через_файл": file_based(),
    }, ensure_ascii=False, indent=2))
PY

echo "═══ секрет через переменную окружения ═══"
docker run --rm -e DATABASE_PASSWORD=пароль-12345 \
    -v "$PWD/envleak.py:/e.py:ro" python:3.13-slim python /e.py \
    | python3 -c "
import json, sys
d = json.load(sys.stdin)['через_переменную']
for k, v in d.items():
    print(f'  {k:<24} {v}')
"

echo "═══ тот же секрет через файл ═══"
echo "пароль-12345" > runtime-secret.txt
docker run --rm \
    -e DATABASE_PASSWORD_FILE=/run/secrets/db \
    -v "$PWD/runtime-secret.txt:/run/secrets/db:ro" \
    -v "$PWD/envleak.py:/e.py:ro" python:3.13-slim python /e.py \
    | python3 -c "
import json, sys
d = json.load(sys.stdin)
print(f\"  через_переменную.задана  {d['через_переменную']['задана']}\")
for k, v in d['через_файл'].items():
    print(f'  файл.{k:<20} {v}')
"

echo "═══ видно ли снаружи ═══"
docker run -d --name envtest -e DATABASE_PASSWORD=пароль-12345 \
    alpine:3.21 sleep 60 > /dev/null
docker inspect envtest --format '{{range .Config.Env}}{{println .}}{{end}}' \
    | grep DATABASE | sed 's/^/  docker inspect: /'
docker rm -f envtest > /dev/null

docker run -d --name filetest \
    -e DATABASE_PASSWORD_FILE=/run/secrets/db \
    -v "$PWD/runtime-secret.txt:/run/secrets/db:ro" \
    alpine:3.21 sleep 60 > /dev/null
docker inspect filetest --format '{{range .Config.Env}}{{println .}}{{end}}' \
    | grep DATABASE | sed 's/^/  docker inspect: /'
docker rm -f filetest > /dev/null

═══ секрет через переменную окружения ═══
  задана                   True
  в_proc_environ           True
  в_дочернем_процессе      наследуется
  в_отчёте_об_ошибке       попадёт
═══ тот же секрет через файл ═══
  через_переменную.задана  False
  файл.доступен            True
  файл.в_environ           False
  файл.в_отчёте            False
  файл.значение_прочитано  True
═══ видно ли снаружи ═══
  docker inspect: DATABASE_PASSWORD=пароль-12345
  docker inspect: DATABASE_PASSWORD_FILE=/run/secrets/db

cd /tmp/leak
cat > audit-images.sh <<'SH'
#!/usr/bin/env bash
# Проверка образов на утечку секретов в ENV и history.
set -uo pipefail

PATTERN='(?i)(password|passwd|secret|token|api[_-]?key|private[_-]?key|credential)'
issues=0
checked=0

check_image() {
    local image="$1"
    local found=0
    checked=$((checked + 1))

    # ENV
    local env_hits
    env_hits="$(docker inspect "$image" --format '{{range .Config.Env}}{{println .}}{{end}}' 2>/dev/null \
        | grep -Pi "$PATTERN=..\S{6,}" || true)"
    if [ -n "$env_hits" ]; then
        printf '  %-28s ENV\n' "$image"
        echo "$env_hits" | while read -r line; do
            printf '      %s=***\n' "${line%%=*}"
        done
        found=1
    fi

    # history
    local hist_hits
    hist_hits="$(docker history --no-trunc "$image" 2>/dev/null \
        | grep -Poi "$PATTERN=\S{6,}" | sort -u || true)"
    if [ -n "$hist_hits" ]; then
        printf '  %-28s HISTORY\n' "$image"
        echo "$hist_hits" | while read -r line; do
            printf '      %s=***\n' "${line%%=*}"
        done
        found=1
    fi

    [ "$found" -eq 1 ] && issues=$((issues + 1))
    return 0
}

printf '\n  Аудит образов на секреты\n\n'
if [ "$#" -gt 0 ]; then
    for img in "$@"; do check_image "$img"; done
else
    while read -r img; do
        [ -z "$img" ] && continue
        case "$img" in *"<none>"*) continue ;; esac
        check_image "$img"
    done < <(docker images --format '{{.Repository}}:{{.Tag}}' 2>/dev/null | head -20)
fi

printf '\n  проверено образов: %s, с находками: %s\n' "$checked" "$issues"
[ "$issues" -gt 0 ] && exit 1
printf '  секретов в ENV и history не найдено\n'
exit 0
SH
chmod +x audit-images.sh

echo "═══ аудит трёх образов ═══"
./audit-images.sh leaky:demo safe:demo alpine:3.21 || true

═══ аудит трёх образов ═══

  Аудит образов на секреты

  leaky:demo                   ENV
      DATABASE_PASSWORD=***
  leaky:demo                   HISTORY
      API_TOKEN=***
  
  проверено образов: 3, с находками: 1

cd /tmp/leak
cat > INCIDENT.md <<'TXT'
# Порядок действий при утечке секрета в образ

## Немедленно (минуты)

1. **ОТОЗВАТЬ секрет** на стороне сервиса, который его выдал.
   Это единственное действие, реально устраняющее риск.
   Не откладывать до выяснения обстоятельств.

2. Выпустить новый секрет и доставить его в конфигурацию.

3. Перезапустить сервисы, проверить работу.

## В тот же день (часы)

4. Проверить журналы доступа сервиса: использовался ли утёкший секрет
   с неизвестных адресов и когда.

5. Определить область: где ещё мог оказаться образ.
   - публичный или внутренний registry
   - кэш CI-сборщиков
   - локальные машины разработчиков
   - резервные копии registry

6. Пересобрать образ без секрета, опубликовать, обновить развёртывания.

7. Удалить образ из registry.
   ВАЖНО: это НЕ устраняет утечку, а только сокращает распространение.

## В течение недели

8. Разобрать, как секрет попал в образ:
   - ARG/--build-arg вместо secret mount
   - COPY каталога с .env (проверить .dockerignore)
   - ENV в Dockerfile
   - копирование из /run/secrets в обычный путь

9. Добавить автоматическую проверку в CI: сканирование образа
   перед публикацией, блокировка при находках.

10. Проверить остальные образы тем же сканером.

## Чего НЕ делать

- Не считать удаление образа устранением утечки.
- Не откладывать отзыв до полного расследования.
- Не переписывать историю git вместо отзыва — репозиторий уже склонирован.
- Не оставлять старый секрет действующим «на время перехода».
TXT

echo "═══ порядок действий записан ═══"
head -12 INCIDENT.md | sed 's/^/  /'
echo "  ..."

echo "═══ ключевой пункт ═══"
cat <<'TXT'
  Первое действие — ОТЗЫВ, а не удаление образа.

  Причина: образ мог быть скачан кем угодно с момента публикации.
  Удаление из registry не отменяет уже сделанных копий: кэш CI,
  локальные машины, резервные копии.

  Секрет считается скомпрометированным с момента публикации образа,
  а не с момента обнаружения.
TXT

cd /tmp && rm -rf /tmp/leak

═══ порядок действий записан ═══
  # Порядок действий при утечке секрета в образ
  
  ## Немедленно (минуты)
  
  1. **ОТОЗВАТЬ секрет** на стороне сервиса, который его выдал.
     Это единственное действие, реально устраняющее риск.
     Не откладывать до выяснения обстоятельств.
  
  2. Выпустить новый секрет и доставить его в конфигурацию.
  
  3. Перезапустить сервисы, проверить работу.
  ...
═══ ключевой пункт ═══
  Первое действие — ОТЗЫВ, а не удаление образа.

  Причина: образ мог быть скачан кем угодно с момента публикации.
  Удаление из registry не отменяет уже сделанных копий: кэш CI,
  локальные машины, резервные копии.

  Секрет считается скомпрометированным с момента публикации образа,
  а не с момента обнаружения.

docker history --no-trunc ВАШ_ОБРАЗ | grep -Ei 'password|token|secret|key='
docker inspect ВАШ_ОБРАЗ --format '{{range .Config.Env}}{{println .}}{{end}}' | grep -Ei 'password|token|secret'
docker save ВАШ_ОБРАЗ | tar -t | head