12.7. Supply chain security

базовый образ ─┐
               ├─→ сборка ─→ образ ─→ registry ─→ развёртывание
зависимости ───┤              ↑
               │              │
ваш код ───────┘         CI-система

requests==2.32.4 \
    --hash=sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c

pip install --require-hashes -r requirements.txt

cosign sign ghcr.io/org/app@sha256:...
cosign verify ghcr.io/org/app@sha256:... \
    --certificate-identity-regexp 'https://github.com/org/repo/.*' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com

mkdir -p /tmp/supply && cd /tmp/supply

cat > check-official.py <<'PY'
"""Определяет, является ли образ официальным, по его имени.

Официальные образы Docker не имеют пространства имён: python, postgres.
Любой префикс перед именем означает, что образ опубликован
сторонним пользователем.
"""
from __future__ import annotations

import json
import sys

# Небольшая выборка официальных образов
OFFICIAL = {
    "python", "postgres", "redis", "nginx", "alpine", "debian", "ubuntu",
    "node", "mysql", "mongo", "rabbitmq", "golang", "openjdk", "busybox",
    "memcached", "traefik", "httpd", "mariadb", "elasticsearch",
}

TRUSTED_REGISTRIES = {
    "gcr.io/distroless": "Google Distroless",
    "registry.access.redhat.com": "Red Hat",
    "public.ecr.aws/docker/library": "AWS ECR Public (зеркало официальных)",
    "mcr.microsoft.com": "Microsoft",
}


def classify(ref: str) -> dict[str, object]:
    # Отделяем тег и digest
    name = ref.split("@")[0]
    if ":" in name.rsplit("/", 1)[-1]:
        name = name.rsplit(":", 1)[0]

    for prefix, owner in TRUSTED_REGISTRIES.items():
        if name.startswith(prefix):
            return {"категория": "доверенный реестр", "владелец": owner,
                    "риск": "низкий"}

    parts = name.split("/")

    if len(parts) == 1:
        official = parts[0] in OFFICIAL
        return {
            "категория": "Docker Official Image" if official
                         else "без пространства имён, но не в списке официальных",
            "владелец": "Docker Official Images" if official else "неизвестен",
            "риск": "низкий" if official else "проверить вручную",
        }

    if len(parts) == 2 and parts[0] == "library":
        return {"категория": "Docker Official Image (полная форма)",
                "владелец": "Docker Official Images", "риск": "низкий"}

    # Есть пространство имён — сторонний
    namespace = parts[-2]
    base = parts[-1]
    lookalike = None
    for off in OFFICIAL:
        if base == off or namespace == off:
            lookalike = off
        elif _close(base, off) or _close(namespace, off):
            lookalike = off
    return {
        "категория": "сторонний образ",
        "владелец": namespace,
        "риск": "ВЫСОКИЙ: похож на официальный" if lookalike else "средний",
        "похож_на": lookalike,
    }


def _close(a: str, b: str) -> bool:
    """Расстояние редактирования не больше 1 или отличие только суффиксом."""
    if abs(len(a) - len(b)) > 2:
        return False
    if a.rstrip("0123456789-_") == b.rstrip("0123456789-_") and a != b:
        return True
    if len(a) == len(b):
        return sum(x != y for x, y in zip(a, b)) == 1
    short, long_ = (a, b) if len(a) < len(b) else (b, a)
    for i in range(len(long_)):
        if long_[:i] + long_[i + 1:] == short:
            return True
    return False


if __name__ == "__main__":
    refs = sys.argv[1:] or ["python:3.13-slim"]
    print(json.dumps({r: classify(r) for r in refs}, ensure_ascii=False, indent=2))
PY

echo "═══ классификация ссылок на образы ═══"
python3 check-official.py \
    "python:3.13-slim" \
    "library/python:3.13" \
    "gcr.io/distroless/python3-debian12" \
    "someuser/python:3.13-slim" \
    "pythonn/python:3.13" \
    "docker.io/postgress/postgres:17" \
    | python3 -c "
import json, sys
d = json.load(sys.stdin)
for ref, info in d.items():
    risk = info['риск']
    mark = '✗' if 'ВЫСОК' in risk else ('!' if 'проверить' in risk or risk == 'средний' else '✓')
    print(f\"  {mark} {ref:<40} {info['категория']}\")
    print(f\"      владелец: {info['владелец']}, риск: {risk}\")
    if info.get('похож_на'):
        print(f\"      ⚠ имя похоже на официальный образ: {info['похож_на']}\")
"

═══ классификация ссылок на образы ═══
  ✓ python:3.13-slim                         Docker Official Image
      владелец: Docker Official Images, риск: низкий
  ✓ library/python:3.13                      Docker Official Image (полная форма)
      владелец: Docker Official Images, риск: низкий
  ✓ gcr.io/distroless/python3-debian12       доверенный реестр
      владелец: Google Distroless, риск: низкий
  ✗ someuser/python:3.13-slim                сторонний образ
      владелец: someuser, риск: ВЫСОКИЙ: похож на официальный
      ⚠ имя похоже на официальный образ: python
  ✗ pythonn/python:3.13                      сторонний образ
      владелец: pythonn, риск: ВЫСОКИЙ: похож на официальный
      ⚠ имя похоже на официальный образ: python
  ✗ docker.io/postgress/postgres:17          сторонний образ
      владелец: postgress, риск: ВЫСОКИЙ: похож на официальный
      ⚠ имя похоже на официальный образ: postgres

cd /tmp/supply
cat > inspect-image.sh <<'SH'
#!/usr/bin/env bash
# Оценка образа ДО запуска. Скачивание безопасно, запуск — нет.
set -uo pipefail

IMAGE="${1:?укажите образ}"
flags=0
note() { printf '    %s %s\n' "$1" "$2"; }
warn() { note "⚠" "$1"; flags=$((flags + 1)); }

printf '\n  Оценка образа: %s\n\n' "$IMAGE"

printf '  1. Существование и платформы\n'
if ! docker manifest inspect "$IMAGE" > /dev/null 2>&1; then
    warn "манифест недоступен — образа нет или нужна аутентификация"
else
    plat="$(docker manifest inspect "$IMAGE" 2>/dev/null \
        | python3 -c "
import json,sys
d = json.load(sys.stdin)
ms = d.get('manifests', [])
if ms:
    print(', '.join(f\"{m['platform']['os']}/{m['platform']['architecture']}\"
                     for m in ms if 'platform' in m and m['platform'].get('architecture') != 'unknown')[:70])
else:
    print('одна платформа')
" 2>/dev/null)"
    note "·" "платформы: ${plat:-неизвестно}"
fi

printf '  2. Скачивание (код НЕ выполняется)\n'
docker pull -q "$IMAGE" > /dev/null 2>&1 || { warn "не удалось скачать"; exit 1; }
digest="$(docker inspect "$IMAGE" --format '{{index .RepoDigests 0}}' 2>/dev/null || echo "-")"
note "·" "digest: ${digest##*@}"

printf '  3. Конфигурация\n'
user="$(docker inspect "$IMAGE" --format '{{.Config.User}}' 2>/dev/null)"
entry="$(docker inspect "$IMAGE" --format '{{json .Config.Entrypoint}}' 2>/dev/null)"
cmd="$(docker inspect "$IMAGE" --format '{{json .Config.Cmd}}' 2>/dev/null)"
note "·" "Entrypoint: $entry"
note "·" "Cmd:        $cmd"
if [ -z "$user" ] || [ "$user" = "root" ] || [ "$user" = "0" ]; then
    warn "USER не задан или root"
else
    note "·" "USER: $user"
fi

env_susp="$(docker inspect "$IMAGE" --format '{{range .Config.Env}}{{println .}}{{end}}' 2>/dev/null \
    | grep -Pi '(password|token|secret|key)=.{6,}' || true)"
[ -n "$env_susp" ] && warn "подозрительные переменные в ENV: $(echo "$env_susp" | wc -l)"

printf '  4. История сборки\n'
layers="$(docker history --no-trunc "$IMAGE" 2>/dev/null | tail -n +2 | wc -l)"
note "·" "слоёв: $layers"
susp="$(docker history --no-trunc "$IMAGE" 2>/dev/null \
    | grep -Ei 'curl [^|]*\| *(ba)?sh|wget [^|]*\| *(ba)?sh|nc -|/dev/tcp/' || true)"
[ -n "$susp" ] && warn "в истории есть загрузка и выполнение скрипта из сети"

onbuild="$(docker inspect "$IMAGE" --format '{{json .Config.OnBuild}}' 2>/dev/null)"
if [ "$onbuild" != "null" ] && [ "$onbuild" != "[]" ]; then
    warn "есть ONBUILD: код выполнится при сборке производного образа"
fi

printf '  5. Размер\n'
size="$(docker inspect "$IMAGE" --format '{{.Size}}' 2>/dev/null)"
note "·" "$((size / 1024 / 1024)) МиБ"

printf '\n'
if [ "$flags" -gt 0 ]; then
    printf '  замечаний: %s — оценить перед запуском\n' "$flags"
    exit 1
fi
printf '  замечаний нет\n'
exit 0
SH
chmod +x inspect-image.sh

echo "═══ оценка официального образа ═══"
./inspect-image.sh python:3.13-slim || true

═══ оценка официального образа ═══

  Оценка образа: python:3.13-slim

  1. Существование и платформы
    · платформы: linux/amd64, linux/arm64, linux/arm, linux/386, linux/ppc64le
  2. Скачивание (код НЕ выполняется)
    · digest: sha256:9b8...
  3. Конфигурация
    · Entrypoint: null
    · Cmd:        ["python3"]
    ⚠ USER не задан или root
  4. История сборки
    · слоёв: 9
  5. Размер
    · 124 МиБ

  замечаний: 1 — оценить перед запуском

cd /tmp/supply
cat > check-deps.py <<'PY'
"""Поиск подозрительных имён пакетов в requirements.txt.

Проверяет три признака:
  1. Малое расстояние редактирования до популярного пакета
  2. Отсутствие закрепления версии
  3. Отсутствие хеша при наличии хешей у других пакетов
"""
from __future__ import annotations

import json
import re
import sys
from pathlib import Path

# Популярные пакеты — цели для подделки
POPULAR = {
    "requests", "urllib3", "numpy", "pandas", "flask", "django", "fastapi",
    "pydantic", "sqlalchemy", "psycopg", "redis", "celery", "boto3",
    "pytest", "click", "jinja2", "pyyaml", "cryptography", "certifi",
    "setuptools", "beautifulsoup4", "python-dateutil", "httpx", "uvicorn",
    "gunicorn", "aiohttp", "attrs", "six", "typing-extensions",
}

# Имена, похожие на популярные, но существующие легитимно
KNOWN_GOOD = {"pyaml", "attr", "requests-toolbelt", "redis-py-cluster"}


def levenshtein(a: str, b: str) -> int:
    if len(a) < len(b):
        a, b = b, a
    prev = list(range(len(b) + 1))
    for i, ca in enumerate(a, 1):
        cur = [i]
        for j, cb in enumerate(b, 1):
            cur.append(min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (ca != cb)))
        prev = cur
    return prev[-1]


def normalize(name: str) -> str:
    return re.sub(r"[-_.]+", "-", name).lower()


def parse(path: Path) -> list[dict[str, object]]:
    entries = []
    for raw in path.read_text().splitlines():
        line = raw.split("#")[0].strip()
        if not line or line.startswith("-"):
            continue
        m = re.match(r"^([A-Za-z0-9._-]+)\s*(\[[^\]]*\])?\s*(.*)$", line)
        if not m:
            continue
        entries.append({
            "имя": m.group(1),
            "спецификация": m.group(3).strip(),
            "закреплён": "==" in m.group(3),
            "хеш": "--hash=" in raw,
        })
    return entries


def audit(entries: list[dict[str, object]]) -> list[dict[str, object]]:
    findings = []
    any_hashes = any(e["хеш"] for e in entries)

    for e in entries:
        name = normalize(str(e["имя"]))

        if name not in POPULAR and name not in KNOWN_GOOD:
            for pop in POPULAR:
                d = levenshtein(name, pop)
                if 0 < d <= 1 or (d == 2 and len(pop) > 8):
                    findings.append({
                        "пакет": e["имя"], "уровень": "ВЫСОКИЙ",
                        "признак": f"имя отличается от «{pop}» на {d}",
                        "действие": "проверить на PyPI: автор, дата, число загрузок",
                    })
                    break

        if not e["закреплён"]:
            findings.append({
                "пакет": e["имя"], "уровень": "средний",
                "признак": "версия не закреплена",
                "действие": "указать ==версия",
            })

        if any_hashes and not e["хеш"]:
            findings.append({
                "пакет": e["имя"], "уровень": "средний",
                "признак": "нет хеша при наличии хешей у других",
                "действие": "--require-hashes требует хеш для каждого пакета",
            })

    return findings


if __name__ == "__main__":
    path = Path(sys.argv[1] if len(sys.argv) > 1 else "requirements.txt")
    entries = parse(path)
    findings = audit(entries)
    print(json.dumps({
        "пакетов": len(entries),
        "находок": len(findings),
        "высокий_уровень": sum(1 for f in findings if f["уровень"] == "ВЫСОКИЙ"),
        "детали": findings,
    }, ensure_ascii=False, indent=2))
    sys.exit(1 if any(f["уровень"] == "ВЫСОКИЙ" for f in findings) else 0)
PY

cat > requirements.txt <<'EOF'
# Реалистичный файл с двумя подделками и одной незакреплённой версией
fastapi==0.141.1
uvicorn==0.52.0
requsts==2.31.0
python-dateutils==2.9.0
redis==8.1.0
httpx
pyaml==25.7.0
EOF

echo "═══ аудит requirements.txt ═══"
python3 check-deps.py requirements.txt | python3 -c "
import json, sys
d = json.load(sys.stdin)
print(f\"  пакетов: {d['пакетов']}, находок: {d['находок']} \" +
      f\"(высокого уровня: {d['высокий_уровень']})\")
for f in d['детали']:
    mark = '✗' if f['уровень'] == 'ВЫСОКИЙ' else '!'
    print(f\"  {mark} {f['пакет']:<22} {f['признак']}\")
    print(f\"      → {f['действие']}\")
" || true

═══ аудит requirements.txt ═══
  пакетов: 7, находок: 3 (высокого уровня: 2)
  ✗ requsts                имя отличается от «requests» на 1
      → проверить на PyPI: автор, дата, число загрузок
  ✗ python-dateutils       имя отличается от «python-dateutil» на 1
      → проверить на PyPI: автор, дата, число загрузок
  ! httpx                  версия не закреплена
      → проверить на PyPI: автор, дата, число загрузок

cd /tmp/supply
echo "═══ демонстрация: код выполняется при установке ═══"
mkdir -p fakepkg && cd fakepkg
cat > setup.py <<'PY'
"""Демонстрация механизма: setup.py выполняется при установке из sdist.

Здесь — безобидный вывод. Вредоносный пакет на этом месте
читал бы переменные окружения CI и отправлял их наружу.
"""
from setuptools import setup

print("=" * 55)
print("КОД ИЗ setup.py ВЫПОЛНЕН НА ЭТАПЕ УСТАНОВКИ")
print("Здесь доступны: переменные окружения, файловая система,")
print("сеть — всё, что доступно процессу сборки образа.")
print("=" * 55)

setup(name="demo-pkg", version="0.1", py_modules=[])
PY
cd ..

docker run --rm -v "$PWD/fakepkg:/pkg:ro" python:3.13-slim \
    sh -c 'pip install --no-cache-dir --quiet /pkg 2>&1 | grep -v "^\s*$" | head -8' \
    2>/dev/null | sed 's/^/  /'

echo "═══ защита: только wheel ═══"
docker run --rm -v "$PWD/fakepkg:/pkg:ro" python:3.13-slim \
    sh -c 'pip install --no-cache-dir --only-binary=:all: /pkg 2>&1 | tail -2' \
    2>/dev/null | sed 's/^/  /'

echo "═══ вывод ═══"
cat <<'TXT'
  Установка из sdist выполняет setup.py с правами процесса сборки.
  В CI это означает доступ к переменным окружения сборщика:
  токенам registry, ключам развёртывания, учётным данным.

  Меры:
    pip install --only-binary=:all:    запрет сборки из исходников
    pip install --require-hashes       проверка целостности
    отдельный этап установки в multi-stage сборке

  Ни одна не защищает от вредоносного кода в самом wheel —
  он выполнится при импорте, а не при установке.
TXT

═══ демонстрация: код выполняется при установке ═══
  =======================================================
  КОД ИЗ setup.py ВЫПОЛНЕН НА ЭТАПЕ УСТАНОВКИ
  Здесь доступны: переменные окружения, файловая система,
  сеть — всё, что доступно процессу сборки образа.
  =======================================================
═══ защита: только wheel ═══
  ERROR: Could not find a version that satisfies the requirement demo-pkg
  ERROR: No matching distribution found for demo-pkg
═══ вывод ═══
  Установка из sdist выполняет setup.py с правами процесса сборки.
  В CI это означает доступ к переменным окружения сборщика:
  токенам registry, ключам развёртывания, учётным данным.

  Меры:
    pip install --only-binary=:all:    запрет сборки из исходников
    pip install --require-hashes       проверка целостности
    отдельный этап установки в multi-stage сборке

  Ни одна не защищает от вредоносного кода в самом wheel —
  он выполнится при импорте, а не при установке.

cd /tmp/supply
echo "═══ генерация файла с хешами ═══"
docker run --rm -v "$PWD:/w" -w /w python:3.13-slim sh -c '
    pip install --quiet --no-cache-dir pip-tools 2>/dev/null
    cat > base.in <<EOF
click==8.3.0
EOF
    pip-compile --generate-hashes --quiet --output-file locked.txt base.in 2>&1 | tail -2
    echo "---"
    head -12 locked.txt
' 2>/dev/null | sed 's/^/  /'

echo "═══ проверка: неверный хеш прерывает установку ═══"
cat > broken.txt <<'EOF'
click==8.3.0 \
    --hash=sha256:0000000000000000000000000000000000000000000000000000000000000000
EOF
docker run --rm -v "$PWD/broken.txt:/r.txt:ro" python:3.13-slim \
    sh -c 'pip install --no-cache-dir --require-hashes -r /r.txt 2>&1 | tail -4' \
    2>/dev/null | sed 's/^/  /'

echo "═══ от чего защищает, от чего нет ═══"
cat <<'TXT'
  Защищает:  подмена файла в зеркале, перезалив версии, атака на канал
  НЕ защищает: typosquatting (имя вписали вы), вредоносный код
               в легитимном пакете, взлом учётной записи сопровождающего
               с публикацией НОВОЙ версии

  Механизм подтверждает «то же, что и раньше», а не «безопасное».
TXT

═══ генерация файла с хешами ═══
  ---
  #
  # This file is autogenerated by pip-compile with Python 3.13
  # by the following command:
  #
  #    pip-compile --generate-hashes --output-file=locked.txt base.in
  #
  click==8.3.0 \
      --hash=sha256:9b9f285302c6e3064f4330c05f05b81945b2a39544279343e6e7c5f27a9baddc \
      --hash=sha256:cb3b7a4d1c69ed83f5db1f6d3ea9d5c7d0a1b0e2e8c5a5d3b8c2f7e1a4d6b9c0
═══ проверка: неверный хеш прерывает установку ═══
  ERROR: THESE PACKAGES DO NOT MATCH THE HASHES FROM THE REQUIREMENTS FILE.
      click==8.3.0 from https://files.pythonhosted.org/packages/.../click-8.3.0-py3-none-any.whl:
          Expected sha256 0000000000000000000000000000000000000000000000000000000000000000
               Got        9b9f285302c6e3064f4330c05f05b81945b2a39544279343e6e7c5f27a9baddc
═══ от чего защищает, от чего нет ═══
  Защищает:  подмена файла в зеркале, перезалив версии, атака на канал
  НЕ защищает: typosquatting (имя вписали вы), вредоносный код
               в легитимном пакете, взлом учётной записи сопровождающего
               с публикацией НОВОЙ версии

  Механизм подтверждает «то же, что и раньше», а не «безопасное».

cd /tmp/supply
echo "═══ доступность cosign ═══"
if command -v cosign > /dev/null 2>&1; then
    cosign version 2>/dev/null | head -2 | sed 's/^/  /'
    COSIGN_OK=1
else
    echo "  cosign не установлен — команды показаны для справки, НЕ ВЫПОЛНЕНЫ"
    COSIGN_OK=0
fi

echo "═══ проверка подписи: правильно и неправильно ═══"
cat <<'TXT'
  НЕДОСТАТОЧНО — подтверждает лишь, что кто-то подписал:
    cosign verify ghcr.io/org/app@sha256:...

  ПРАВИЛЬНО — подтверждает, КТО именно:
    cosign verify ghcr.io/org/app@sha256:... \
        --certificate-identity-regexp '^https://github\.com/org/repo/\.github/workflows/.*' \
        --certificate-oidc-issuer https://token.actions.githubusercontent.com

  Без указания ожидаемой идентичности проверка почти бессмысленна:
  подписать образ может кто угодно, включая атакующего.
TXT

echo "═══ проверка provenance через docker buildx ═══"
if docker buildx imagetools inspect python:3.13-slim --format '{{json .Provenance}}' > /dev/null 2>&1; then
    docker buildx imagetools inspect python:3.13-slim \
        --format '{{json .Provenance}}' 2>/dev/null | head -c 200 | sed 's/^/  /'
    echo
else
    echo "  provenance для этого образа недоступен или buildx не поддерживает формат"
fi

echo "═══ что проверять в provenance ═══"
cat <<'TXT'
  Ключевые поля:
    buildDefinition.externalParameters   — из какого репозитория и коммита
    runDetails.builder.id                — какая CI-система собирала
    buildDefinition.resolvedDependencies — какие базовые образы

  Проверка: совпадает ли репозиторий с ожидаемым.
  Образ, собранный из чужого репозитория, но подписанный валидно, —
  штатный сценарий атаки при компрометации организации в CI.
TXT
if [ "$COSIGN_OK" = "0" ]; then
    echo "  ⚠ проверка подписи в этом прогоне НЕ ВЫПОЛНЯЛАСЬ: cosign отсутствует"
fi

═══ доступность cosign ═══
  cosign не установлен — команды показаны для справки, НЕ ВЫПОЛНЕНЫ
═══ проверка подписи: правильно и неправильно ═══
  НЕДОСТАТОЧНО — подтверждает лишь, что кто-то подписал:
    cosign verify ghcr.io/org/app@sha256:...

  ПРАВИЛЬНО — подтверждает, КТО именно:
    cosign verify ghcr.io/org/app@sha256:... \
        --certificate-identity-regexp '^https://github\.com/org/repo/\.github/workflows/.*' \
        --certificate-oidc-issuer https://token.actions.githubusercontent.com

  Без указания ожидаемой идентичности проверка почти бессмысленна:
  подписать образ может кто угодно, включая атакующего.
═══ проверка provenance через docker buildx ═══
  provenance для этого образа недоступен или buildx не поддерживает формат
═══ что проверять в provenance ═══
  Ключевые поля:
    buildDefinition.externalParameters   — из какого репозитория и коммита
    runDetails.builder.id                — какая CI-система собирала
    buildDefinition.resolvedDependencies — какие базовые образы

  Проверка: совпадает ли репозиторий с ожидаемым.
  Образ, собранный из чужого репозитория, но подписанный валидно, —
  штатный сценарий атаки при компрометации организации в CI.
  ⚠ проверка подписи в этом прогоне НЕ ВЫПОЛНЯЛАСЬ: cosign отсутствует

cd /tmp/supply
cat > supply-report.py <<'PY'
"""Сводная оценка контроля над звеньями цепочки поставок."""
from __future__ import annotations

import json

LINKS = [
    ("Базовый образ", [
        ("официальный или доверенный реестр", True),
        ("закреплён по digest", True),
        ("обновляется по расписанию", False),
    ]),
    ("Зависимости", [
        ("версии закреплены", True),
        ("хеши закреплены", True),
        ("имена проверены на typosquatting", True),
        ("транзитивные зафиксированы", True),
    ]),
    ("Ваш код", [
        ("проверка на секреты в CI", True),
        ("статический анализ", True),
    ]),
    ("CI-система", [
        ("секреты не в переменных окружения job", False),
        ("подпись образов", False),
        ("provenance", False),
    ]),
    ("Registry", [
        ("доступ на запись ограничен", True),
        ("релизные теги неизменяемы", True),
    ]),
    ("Развёртывание", [
        ("проверка подписи перед запуском", False),
        ("развёртывание по digest, не по тегу", True),
    ]),
]


def main() -> None:
    total = done = 0
    rows = []
    for link, checks in LINKS:
        d = sum(1 for _, ok in checks if ok)
        rows.append({
            "звено": link, "выполнено": d, "всего": len(checks),
            "невыполненное": [c for c, ok in checks if not ok],
        })
        done += d
        total += len(checks)

    print(f"  {'звено':<18} {'покрытие':>10}  невыполненное")
    print("  " + "─" * 74)
    for r in rows:
        cov = f"{r['выполнено']}/{r['всего']}"
        gaps = "; ".join(r["невыполненное"]) or "—"
        print(f"  {r['звено']:<18} {cov:>10}  {gaps[:44]}")
    print()
    print(f"  итого: {done} из {total} ({done * 100 // total}%)")
    print()
    print("  Наименее покрытое звено определяет реальный уровень защиты:")
    weakest = min(rows, key=lambda r: r["выполнено"] / r["всего"])
    print(f"    {weakest['звено']} — {weakest['выполнено']}/{weakest['всего']}")


if __name__ == "__main__":
    main()
PY

echo "═══ сводная оценка ═══"
python3 supply-report.py
cd /tmp && rm -rf /tmp/supply

═══ сводная оценка ═══
  звено              покрытие  невыполненное
  ──────────────────────────────────────────────────────────────────────────
  Базовый образ           2/3  обновляется по расписанию
  Зависимости             4/4  —
  Ваш код                 2/2  —
  CI-система              0/3  секреты не в переменных окружения job; подпись
  Registry                2/2  —
  Развёртывание           1/2  проверка подписи перед запуском

  итого: 11 из 16 (68%)

  Наименее покрытое звено определяет реальный уровень защиты:
    CI-система — 0/3

docker inspect python:3.13-slim --format '{{index .RepoDigests 0}}'
docker inspect python:3.13-slim --format '{{json .Config.OnBuild}}'
docker history --no-trunc python:3.13-slim | grep -Ei 'curl.*\|.*sh' || echo "загрузки скриптов нет"