14.2. Аутентификация

mkdir -p /tmp/authlab && cd /tmp/authlab
export DOCKER_CONFIG="$PWD/docker-config"
mkdir -p "$DOCKER_CONFIG"

# ─── Помощник, хранящий секреты вне config.json ───────────────────────
mkdir -p bin store
cat > bin/docker-credential-lab <<'PY'
#!/usr/bin/env python3
"""Credential helper: хранит секреты в отдельном файле с правами 600.

Это учебная реализация. В рабочей системе секреты хранят
в keyring, GPG-зашифрованных файлах или корпоративном хранилище —
но протокол общения с Docker точно такой же.
"""
from __future__ import annotations

import json
import os
import stat
import sys
from pathlib import Path

STORE = Path(os.environ.get("LAB_CRED_STORE", "./store/creds.json"))


def load() -> dict[str, dict[str, str]]:
    if not STORE.exists():
        return {}
    try:
        return json.loads(STORE.read_text())
    except json.JSONDecodeError:
        return {}


def save(data: dict[str, dict[str, str]]) -> None:
    STORE.parent.mkdir(parents=True, exist_ok=True)
    STORE.write_text(json.dumps(data, ensure_ascii=False))
    STORE.chmod(stat.S_IRUSR | stat.S_IWUSR)          # 600


def main() -> int:
    command = sys.argv[1] if len(sys.argv) > 1 else ""
    data = load()

    if command == "get":
        server = sys.stdin.read().strip()
        entry = data.get(server)
        if not entry:
            print(f"учётных данных для {server} нет", file=sys.stderr)
            return 1
        json.dump({"Username": entry["Username"], "Secret": entry["Secret"]},
                  sys.stdout)
        return 0

    if command == "store":
        payload = json.load(sys.stdin)
        data[payload["ServerURL"]] = {
            "Username": payload["Username"],
            "Secret": payload["Secret"],
        }
        save(data)
        return 0

    if command == "erase":
        server = sys.stdin.read().strip()
        data.pop(server, None)
        save(data)
        return 0

    if command == "list":
        json.dump({s: e["Username"] for s, e in data.items()}, sys.stdout)
        return 0

    print(f"неизвестная команда: {command}", file=sys.stderr)
    return 1


if __name__ == "__main__":
    sys.exit(main())
PY
chmod +x bin/docker-credential-lab
export PATH="$PWD/bin:$PATH"
export LAB_CRED_STORE="$PWD/store/creds.json"

# ─── Анализ config.json без раскрытия секретов ────────────────────────
cat > inspect-config.py <<'PY'
"""Разбирает config.json, НЕ раскрывая секреты.

Выводит имя поля, длину и факт обратимости кодирования —
этого достаточно для оценки, и это безопасно печатать в журнал.
"""
from __future__ import annotations

import base64
import json
import os
import sys
from pathlib import Path


def analyze(path: Path) -> dict[str, object]:
    if not path.exists():
        return {"файл": str(path), "существует": False}

    cfg = json.loads(path.read_text())
    auths = cfg.get("auths", {})
    entries = []
    for server, entry in auths.items():
        raw = entry.get("auth")
        if raw:
            try:
                decoded = base64.b64decode(raw).decode("utf-8", "replace")
                user, _, secret = decoded.partition(":")
            except Exception:
                user, secret = "?", ""
            entries.append({
                "registry": server,
                "хранение": "в файле, base64",
                "пользователь": user,
                "длина_секрета": len(secret),
                "обратимо": True,
            })
        else:
            entries.append({
                "registry": server,
                "хранение": "внешнее (credential helper)",
                "пользователь": entry.get("identitytoken", "") and "токен" or "—",
                "длина_секрета": 0,
                "обратимо": False,
            })

    mode = oct(path.stat().st_mode & 0o777)[2:]
    return {
        "файл": str(path),
        "существует": True,
        "права": mode,
        "credsStore": cfg.get("credsStore"),
        "credHelpers": cfg.get("credHelpers", {}),
        "записей": len(entries),
        "секретов_в_файле": sum(1 for e in entries if e["обратимо"]),
        "детали": entries,
    }


if __name__ == "__main__":
    base = Path(os.environ.get("DOCKER_CONFIG", Path.home() / ".docker"))
    print(json.dumps(analyze(base / "config.json"), ensure_ascii=False, indent=2))
PY

# ─── Проверка утечки ──────────────────────────────────────────────────
cat > audit-creds.sh <<'SH'
#!/usr/bin/env bash
# Поиск учётных данных там, где их быть не должно.
# ЗНАЧЕНИЯ НЕ ВЫВОДЯТСЯ: вывод попадает в журнал CI.
set -uo pipefail

SECRET_PATTERN="${1:-}"
found=0
warn()  { printf '  ⚠ %-26s %s\n' "$1" "$2"; found=$((found + 1)); }
fine()  { printf '  ✓ %-26s %s\n' "$1" "$2"; }

printf '\n  Аудит учётных данных\n\n'

cfg="${DOCKER_CONFIG:-$HOME/.docker}/config.json"
if [ -f "$cfg" ]; then
    mode="$(stat -c '%a' "$cfg" 2>/dev/null || echo '?')"
    [ "$mode" = "600" ] && fine "права config.json" "$mode" \
                        || warn "права config.json" "$mode вместо 600"
    plain="$(python3 -c "
import json
try:
    c = json.load(open('$cfg'))
    print(sum(1 for v in c.get('auths', {}).values() if v.get('auth')))
except Exception:
    print(0)
" 2>/dev/null)"
    helper="$(python3 -c "
import json
try:
    c = json.load(open('$cfg'))
    print(c.get('credsStore') or 'нет')
except Exception:
    print('нет')
" 2>/dev/null)"
    fine "credential helper" "$helper"
    [ "${plain:-0}" -gt 0 ] && warn "секретов в config.json" "$plain (обратимый base64)" \
                            || fine "секретов в config.json" "0 — хранятся вне файла"
else
    fine "config.json" "отсутствует"
fi

if [ -n "$SECRET_PATTERN" ]; then
    for hist in "$HOME/.bash_history" "$HOME/.zsh_history"; do
        [ -f "$hist" ] || continue
        if grep -qF "$SECRET_PATTERN" "$hist" 2>/dev/null; then
            warn "история $(basename "$hist")" "секрет найден"
        else
            fine "история $(basename "$hist")" "секрета нет"
        fi
    done
    if ps -eo args 2>/dev/null | grep -v grep | grep -qF "$SECRET_PATTERN"; then
        warn "список процессов" "секрет виден в аргументах"
    else
        fine "список процессов" "секрета нет"
    fi
    if [ -n "${LAB_CRED_STORE:-}" ] && [ -f "$LAB_CRED_STORE" ]; then
        smode="$(stat -c '%a' "$LAB_CRED_STORE" 2>/dev/null || echo '?')"
        [ "$smode" = "600" ] && fine "права хранилища helper" "$smode" \
                             || warn "права хранилища helper" "$smode вместо 600"
    fi
fi

printf '\n  находок: %s\n' "$found"
printf '  значения не выводились\n\n'
[ "$found" -gt 0 ] && exit 1
exit 0
SH
chmod +x audit-creds.sh

fail=0
ok()  { printf '  ✓ %s\n' "$1"; }
bad() { printf '  ✗ %s\n' "$1"; fail=1; }

SECRET="ОченьДлинныйТестовыйПароль12345"

printf '\n═══ Требование 1: registry с аутентификацией ═══\n'
mkdir -p htpasswd-dir
docker run --rm --entrypoint htpasswd httpd:2.4-alpine \
    -Bbn labuser "$SECRET" > htpasswd-dir/htpasswd 2>/dev/null
docker run -d --name lab-authreg -p 5001:5000 \
    -v "$PWD/htpasswd-dir:/auth:ro" \
    -e REGISTRY_AUTH=htpasswd \
    -e REGISTRY_AUTH_HTPASSWD_REALM=Registry \
    -e REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd \
    registry:2 > /dev/null 2>&1
sleep 4
anon="$(curl -s -o /dev/null -w '%{http_code}' http://localhost:5001/v2/ 2>/dev/null)"
auth="$(curl -s -u "labuser:$SECRET" -o /dev/null -w '%{http_code}' \
    http://localhost:5001/v2/ 2>/dev/null)"
printf '    без учётных данных: HTTP %s\n' "$anon"
printf '    с учётными данными: HTTP %s\n' "$auth"
[ "$anon" = "401" ] && [ "$auth" = "200" ] \
    && ok "registry требует аутентификации и принимает верные данные" \
    || bad "коды: $anon и $auth"

printf '\n═══ Требование 2: вход без следов ═══\n'
printf "%s" "$SECRET" | docker login localhost:5001 -u labuser --password-stdin 2>&1 \
    | sed 's/^/    /'

hist_hit=0
for h in "$HOME/.bash_history" "$HOME/.zsh_history"; do
    [ -f "$h" ] && grep -qF "$SECRET" "$h" 2>/dev/null && hist_hit=1
done
ps_hit=0
ps -eo args 2>/dev/null | grep -v grep | grep -qF "$SECRET" && ps_hit=1
printf '    секрет в истории оболочки:  %s\n' \
    "$([ "$hist_hit" = "1" ] && echo "НАЙДЕН" || echo "не найден")"
printf '    секрет в списке процессов:  %s\n' \
    "$([ "$ps_hit" = "1" ] && echo "НАЙДЕН" || echo "не найден")"
[ "$hist_hit" -eq 0 ] && [ "$ps_hit" -eq 0 ] \
    && ok "проверено: следов нет (проверка выполнена, а не заявлена)" \
    || bad "история=$hist_hit процессы=$ps_hit"

printf '\n═══ Требование 3: что в config.json ═══\n'
python3 inspect-config.py | python3 -c "
import json, sys
d = json.load(sys.stdin)
print(f\"    файл: {d['файл']}\")
print(f\"    права: {d['права']}, записей: {d['записей']}, \"
      f\"секретов в файле: {d['секретов_в_файле']}\")
for e in d['детали']:
    print(f\"      {e['registry']}: {e['хранение']}, \"
          f\"пользователь={e['пользователь']}, \"
          f\"длина секрета={e['длина_секрета']}, обратимо={e['обратимо']}\")
"
plain_before="$(python3 inspect-config.py \
    | python3 -c "import json,sys; print(json.load(sys.stdin)['секретов_в_файле'])")"
printf '    секрет НЕ напечатан — только его длина\n'
[ "$plain_before" -ge 1 ] \
    && ok "подтверждено: секрет лежит в файле в обратимом виде" \
    || bad "секретов в файле: $plain_before"

printf '\n═══ Требование 4: область токена ═══\n'
python3 - <<'PY'
SCOPES = {
    "полный доступ": {
        "права": ["write:packages", "read:packages", "delete:packages"],
        "при утечке": "подмена образа, удаление версий, чтение всего",
        "тяжесть": "катастрофа",
    },
    "только публикация": {
        "права": ["write:packages", "read:packages"],
        "при утечке": "подмена образа — развёрнутое окажется чужим",
        "тяжесть": "инцидент",
    },
    "только чтение": {
        "права": ["read:packages"],
        "при утечке": "скачивание образов; подменить нельзя",
        "тяжесть": "неприятность",
    },
}
print(f"    {'токен':<22} {'права':<38} {'тяжесть утечки':<14} последствие")
print('    ' + '─' * 108)
for name, info in SCOPES.items():
    print(f"    {name:<22} {', '.join(info['права']):<38} "
          f"{info['тяжесть']:<14} {info['при утечке']}")
print()
print("    Правило: развёртывание получает токен ТОЛЬКО на чтение.")
print("    Тогда компрометация сервера не позволяет подменить образ в registry.")
PY
ok "разница областей показана через последствия утечки, а не через список прав"

printf '\n═══ Требование 5: credential helper ═══\n'
docker logout localhost:5001 > /dev/null 2>&1
python3 - <<'PY'
import json, os
from pathlib import Path
p = Path(os.environ["DOCKER_CONFIG"]) / "config.json"
cfg = json.loads(p.read_text()) if p.exists() else {}
cfg["credsStore"] = "lab"
p.write_text(json.dumps(cfg, ensure_ascii=False, indent=2))
print(f"    credsStore установлен: {cfg['credsStore']}")
PY

printf "%s" "$SECRET" | docker login localhost:5001 -u labuser --password-stdin 2>&1 \
    | sed 's/^/    /'

python3 inspect-config.py | python3 -c "
import json, sys
d = json.load(sys.stdin)
print(f\"    credsStore: {d['credsStore']}\")
print(f\"    секретов в config.json: {d['секретов_в_файле']}\")
for e in d['детали']:
    print(f\"      {e['registry']}: {e['хранение']}\")
"
plain_after="$(python3 inspect-config.py \
    | python3 -c "import json,sys; print(json.load(sys.stdin)['секретов_в_файле'])")"
if [ -f "$LAB_CRED_STORE" ]; then
    smode="$(stat -c '%a' "$LAB_CRED_STORE")"
    n_stored="$(python3 -c "
import json
print(len(json.load(open('$LAB_CRED_STORE'))))
" 2>/dev/null || echo 0)"
    printf '    хранилище helper: %s записей, права %s\n' "$n_stored" "$smode"
else
    n_stored=0
    printf '    хранилище helper не создано\n'
fi
printf '    было секретов в config.json: %s → стало: %s\n' "$plain_before" "$plain_after"
[ "$plain_after" -eq 0 ] && [ "${n_stored:-0}" -ge 1 ] \
    && ok "секрет ушёл из config.json в хранилище helper с правами $smode" \
    || bad "в config.json: $plain_after, в хранилище: $n_stored"

printf '\n═══ Требование 6: аудит без второй утечки ═══\n'
audit_out="$(./audit-creds.sh "$SECRET" 2>&1)"
echo "$audit_out" | sed 's/^/  /'
rc_audit=$?
if echo "$audit_out" | grep -qF "$SECRET"; then
    bad "аудит напечатал сам секрет — это вторая утечка"
else
    ok "секрет в выводе аудита не появился"
fi

printf '  проверка на плохой конфигурации:\n'
docker logout localhost:5001 > /dev/null 2>&1
python3 - <<'PY'
import json, os
from pathlib import Path
p = Path(os.environ["DOCKER_CONFIG"]) / "config.json"
cfg = json.loads(p.read_text())
cfg.pop("credsStore", None)
p.write_text(json.dumps(cfg, ensure_ascii=False))
PY
printf "%s" "$SECRET" | docker login localhost:5001 -u labuser --password-stdin > /dev/null 2>&1
./audit-creds.sh "$SECRET" > /dev/null 2>&1; rc_bad=$?
printf '    код возврата с секретом в config.json: %s\n' "$rc_bad"
[ "$rc_bad" -eq 1 ] \
    && ok "аудит сигнализирует о секрете в открытом виде" \
    || bad "код возврата: $rc_bad"

printf '\n═══ ИТОГ ═══\n'
[ "$fail" -eq 0 ] && echo "  все требования выполнены" || echo "  ЕСТЬ ПРОВАЛЫ"

docker logout localhost:5001 > /dev/null 2>&1
docker rm -f lab-authreg > /dev/null 2>&1
unset DOCKER_CONFIG LAB_CRED_STORE
cd /tmp && rm -rf /tmp/authlab
exit "$fail"

═══ Требование 1: registry с аутентификацией ═══
    без учётных данных: HTTP 401
    с учётными данными: HTTP 200
  ✓ registry требует аутентификации и принимает верные данные

═══ Требование 2: вход без следов ═══
    Login Succeeded
    секрет в истории оболочки:  не найден
    секрет в списке процессов:  не найден
  ✓ проверено: следов нет (проверка выполнена, а не заявлена)

═══ Требование 3: что в config.json ═══
    файл: /tmp/authlab/docker-config/config.json
    права: 600, записей: 1, секретов в файле: 1
      localhost:5001: в файле, base64, пользователь=labuser, длина секрета=31, обратимо=True
    секрет НЕ напечатан — только его длина
  ✓ подтверждено: секрет лежит в файле в обратимом виде

═══ Требование 4: область токена ═══
    токен                  права                                  тяжесть утечки последствие
    ────────────────────────────────────────────────────────────────────────────────────────────────────────────
    полный доступ          write:packages, read:packages, delete:packages  катастрофа     подмена образа, удаление версий, чтение всего
    только публикация      write:packages, read:packages          инцидент       подмена образа — развёрнутое окажется чужим
    только чтение          read:packages                          неприятность   скачивание образов; подменить нельзя

    Правило: развёртывание получает токен ТОЛЬКО на чтение.
    Тогда компрометация сервера не позволяет подменить образ в registry.
  ✓ разница областей показана через последствия утечки, а не через список прав

═══ Требование 5: credential helper ═══
    credsStore установлен: lab
    Login Succeeded
    credsStore: lab
    секретов в config.json: 0
      localhost:5001: внешнее (credential helper)
    хранилище helper: 1 записей, права 600
    было секретов в config.json: 1 → стало: 0
  ✓ секрет ушёл из config.json в хранилище helper с правами 600

═══ Требование 6: аудит без второй утечки ═══

    Аудит учётных данных

    ✓ права config.json          600
    ✓ credential helper          нет
    ⚠ секретов в config.json     1 (обратимый base64)
    ✓ история .bash_history      секрета нет
    ✓ список процессов           секрета нет

    находок: 1
    значения не выводились

  ✓ секрет в выводе аудита не появился
  проверка на плохой конфигурации:
    код возврата с секретом в config.json: 1
  ✓ аудит сигнализирует о секрете в открытом виде

═══ ИТОГ ═══
  все требования выполнены