16.4. Сканирование и SBOM

понедельник:  образ sha256:8a3f...  → 0 находок critical
четверг:      образ sha256:8a3f...  → 3 находки critical

trivy image --severity HIGH,CRITICAL --ignore-unfixed --exit-code 1 ОБРАЗ

# .trivyignore
CVE-2026-12345

# .trivyignore
# Ложное срабатывание: пакет не используется в рантайме.
# Пересмотреть: 2026-10-01, ответственный: команда платформы
CVE-2026-12345 exp:2026-10-01

- uses: docker/build-push-action@v6
  with:
    push: true
    sbom: true
    provenance: mode=max

mkdir -p /tmp/scan && cd /tmp/scan

cat > policy.py <<'PY'
"""Политика реагирования на находки сканера.

Единственный работающий критерий блокировки — наличие действия.
Находка без доступного исправления действия не порождает.
"""
from __future__ import annotations

import json

FINDINGS = [
    {"id": "CVE-2026-1001", "severity": "CRITICAL", "pkg": "libssl3",
     "fixed": "3.0.15-1", "in_image": True},
    {"id": "CVE-2026-1002", "severity": "CRITICAL", "pkg": "libtiff",
     "fixed": None, "in_image": True},
    {"id": "CVE-2026-1003", "severity": "HIGH", "pkg": "requests",
     "fixed": "2.32.5", "in_image": True},
    {"id": "CVE-2026-1004", "severity": "HIGH", "pkg": "zlib",
     "fixed": None, "in_image": True},
    {"id": "CVE-2026-1005", "severity": "MEDIUM", "pkg": "curl",
     "fixed": "8.12.0-1", "in_image": True},
    {"id": "CVE-2026-1006", "severity": "CRITICAL", "pkg": "pytest",
     "fixed": "9.1.2", "in_image": False},
    {"id": "CVE-2026-1007", "severity": "LOW", "pkg": "perl-base",
     "fixed": None, "in_image": True},
]

BLOCKING_SEVERITY = {"CRITICAL", "HIGH"}


def decide(finding: dict) -> tuple[bool, str]:
    if not finding["in_image"]:
        return False, "пакета нет в образе — уязвимость к артефакту не относится"
    if finding["severity"] not in BLOCKING_SEVERITY:
        return False, "ниже порога — плановое обновление"
    if finding["fixed"] is None:
        return False, "исправления нет — действия не существует"
    return True, f"обновить до {finding['fixed']}"


def main() -> None:
    print(f"  {'CVE':<16} {'уровень':<10} {'пакет':<12} {'исправление':<12} "
          f"{'блокирует':<11} основание")
    print("  " + "─" * 108)
    blocking = 0
    for f in FINDINGS:
        block, reason = decide(f)
        if block:
            blocking += 1
        print(f"  {f['id']:<16} {f['severity']:<10} {f['pkg']:<12} "
              f"{str(f['fixed'] or '—'):<12} {'ДА' if block else 'нет':<11} {reason}")

    total = len(FINDINGS)
    crit_high = sum(1 for f in FINDINGS if f["severity"] in BLOCKING_SEVERITY)
    print()
    print(f"  всего находок: {total}")
    print(f"  уровня CRITICAL и HIGH: {crit_high}")
    print(f"  блокируют сборку: {blocking}")
    print()
    print("  Без --ignore-unfixed блокировали бы все "
          f"{crit_high} — включая те, где обновляться не на что.")
    print("  Pipeline стал бы постоянно красным, и его начали бы обходить.")
    print()
    print(json.dumps({"всего": total, "блокируют": blocking,
                      "critical_high": crit_high}, ensure_ascii=False))


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

echo "═══ политика реагирования ═══"
python3 policy.py

═══ политика реагирования ═══
  CVE              уровень    пакет        исправление  блокирует   основание
  ────────────────────────────────────────────────────────────────────────────────────────────────────────────
  CVE-2026-1001    CRITICAL   libssl3      3.0.15-1     ДА          обновить до 3.0.15-1
  CVE-2026-1002    CRITICAL   libtiff      —            нет         исправления нет — действия не существует
  CVE-2026-1003    HIGH       requests     2.32.5       ДА          обновить до 2.32.5
  CVE-2026-1004    HIGH       zlib         —            нет         исправления нет — действия не существует
  CVE-2026-1005    MEDIUM     curl         8.12.0-1     нет         ниже порога — плановое обновление
  CVE-2026-1006    CRITICAL   pytest       9.1.2        нет         пакета нет в образе — уязвимость к артефакту не относится
  CVE-2026-1007    LOW        perl-base    —            нет         ниже порога — плановое обновление

  всего находок: 7
  уровня CRITICAL и HIGH: 4
  блокируют сборку: 2

  Без --ignore-unfixed блокировали бы все 4 — включая те, где обновляться не на что.
  Pipeline стал бы постоянно красным, и его начали бы обходить.

cd /tmp/scan
cat > drift.py <<'PY'
"""Один образ, разные дни: результат сканирования меняется.

База уязвимостей обновляется; образ — нет.
"""
from __future__ import annotations

from datetime import date, timedelta

IMAGE_DIGEST = "sha256:8a3f2b1c4d5e6f7a"
BUILD_DATE = date(2026, 7, 1)

# Когда какая уязвимость стала известна и когда вышло исправление
CVES = [
    {"id": "CVE-2026-2001", "published": date(2026, 6, 15),
     "fixed_on": date(2026, 6, 20), "severity": "HIGH"},
    {"id": "CVE-2026-2002", "published": date(2026, 7, 10),
     "fixed_on": date(2026, 7, 25), "severity": "CRITICAL"},
    {"id": "CVE-2026-2003", "published": date(2026, 7, 18),
     "fixed_on": None, "severity": "CRITICAL"},
    {"id": "CVE-2026-2004", "published": date(2026, 7, 29),
     "fixed_on": date(2026, 7, 30), "severity": "HIGH"},
]


def scan_on(day: date) -> dict[str, object]:
    known = [c for c in CVES if c["published"] <= day]
    blocking = [c for c in known
                if c["fixed_on"] is not None and c["fixed_on"] <= day]
    return {"известно": len(known), "блокируют": len(blocking),
            "ids": [c["id"] for c in blocking]}


def main() -> None:
    print(f"  образ: {IMAGE_DIGEST} (собран {BUILD_DATE}, не менялся)\n")
    print(f"  {'дата проверки':<16} {'известно CVE':>14} {'блокируют':>11}  какие")
    print("  " + "─" * 74)
    for offset in (0, 10, 20, 25, 30):
        day = BUILD_DATE + timedelta(days=offset)
        r = scan_on(day)
        print(f"  {day.isoformat():<16} {r['известно']:>14} {r['блокируют']:>11}  "
              f"{', '.join(r['ids']) or '—'}")

    print()
    print("  Образ не менялся ни разу. Менялась база уязвимостей.")
    print()
    print("  Два следствия:")
    print("    1. «Зелёная» сборка не остаётся зелёной.")
    print("    2. Опубликованные образы нужно сканировать по расписанию,")
    print("       иначе уязвимость обнаружится случайно — при следующей сборке.")
    print()
    print("  Строка 2026-07-21: CVE-2026-2002 уже известна, но ещё не")
    print("  блокирует — исправление вышло только 25-го. До этой даты")
    print("  находка идёт в отчёт, а не в блокировку.")


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

echo "═══ дрейф результата ═══"
python3 drift.py

═══ дрейф результата ═══
  образ: sha256:8a3f2b1c4d5e6f7a (собран 2026-07-01, не менялся)

  дата проверки      известно CVE   блокируют  какие
  ──────────────────────────────────────────────────────────────────────────
  2026-07-01                    1           1  CVE-2026-2001
  2026-07-11                    2           1  CVE-2026-2001
  2026-07-21                    3           1  CVE-2026-2001
  2026-07-26                    3           2  CVE-2026-2001, CVE-2026-2002
  2026-07-31                    4           3  CVE-2026-2001, CVE-2026-2002, CVE-2026-2004

  Образ не менялся ни разу. Менялась база уязвимостей.
  ...

cd /tmp/scan
mkdir -p src

cat > requirements.txt <<'EOF'
click==8.3.0
httpx==0.28.1
EOF
cat > src/__init__.py <<'PY'
PY
cat > src/app.py <<'PY'
"""Приложение для сканирования."""
from __future__ import annotations


def main() -> int:
    print("работает")
    return 0


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

cat > Dockerfile <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim AS production
ENV PYTHONUNBUFFERED=1
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ ./src/
RUN useradd --create-home --uid 10001 app && chown -R app:app /app
USER app
ENTRYPOINT ["python", "-m", "src.app"]
EOF

echo "═══ два вида сканирования ═══"
cat > two-scans.py <<'PY'
"""Сканирование исходников и образа: что находит каждое."""
from __future__ import annotations

SCANS = [
    {
        "цель": "исходники и requirements.txt",
        "этап": "быстрые проверки, до сборки",
        "время": "секунды",
        "находит": ["CVE в зависимостях приложения"],
        "не находит": ["системные пакеты базового образа",
                       "пакеты, установленные вне менеджера"],
    },
    {
        "цель": "собранный образ",
        "этап": "после сборки",
        "время": "десятки секунд",
        "находит": ["CVE в зависимостях приложения",
                    "CVE в системных пакетах базового образа"],
        "не находит": ["пакеты без метаданных: скопированные бинарники"],
    },
]

TYPICAL_SPLIT = {"системные пакеты базового образа": 34,
                 "зависимости приложения": 6}


def main() -> None:
    for s in SCANS:
        print(f"  {s['цель']}")
        print(f"    этап:  {s['этап']}, {s['время']}")
        print(f"    находит:     {'; '.join(s['находит'])}")
        print(f"    НЕ находит:  {'; '.join(s['не находит'])}")
        print()

    total = sum(TYPICAL_SPLIT.values())
    print("  Типичное распределение находок в образе Python-приложения:")
    for source, n in TYPICAL_SPLIT.items():
        print(f"    {source:<38} {n:>3} ({n / total * 100:.0f} %)")
    print()
    print("  Большинство находок — в пакетах, которых в requirements.txt нет.")
    print("  Поэтому сканирование исходников не заменяет сканирование образа.")
    print()
    print("  Порядок в pipeline:")
    print("    быстрые проверки → сканирование исходников (секунды)")
    print("    после сборки     → сканирование образа (десятки секунд)")


if __name__ == "__main__":
    main()
PY
python3 two-scans.py

echo "═══ фактический запуск сканера ═══"
docker build -q --target production -t scan:demo . > /dev/null 2>&1
if command -v trivy > /dev/null 2>&1; then
    trivy image --severity HIGH,CRITICAL --ignore-unfixed --quiet scan:demo 2>&1 \
        | head -20 | sed 's/^/  /'
else
    cat <<'TXT'
  trivy НЕ УСТАНОВЛЕН — сканирование НЕ ВЫПОЛНЯЛОСЬ.

  Команды для справки:
    trivy fs --severity HIGH,CRITICAL --ignore-unfixed .
    trivy image --severity HIGH,CRITICAL --ignore-unfixed --exit-code 1 scan:demo

  Запуск через container, если инструмент не установлен локально:
    docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
        aquasec/trivy:latest image --severity HIGH,CRITICAL scan:demo
TXT
fi

═══ два вида сканирования ═══
  исходники и requirements.txt
    этап:  быстрые проверки, до сборки, секунды
    находит:     CVE в зависимостях приложения
    НЕ находит:  системные пакеты базового образа; пакеты, установленные вне менеджера

  собранный образ
    этап:  после сборки, десятки секунд
    находит:     CVE в зависимостях приложения; CVE в системных пакетах базового образа
    НЕ находит:  пакеты без метаданных: скопированные бинарники

  Типичное распределение находок в образе Python-приложения:
    системные пакеты базового образа           34 (85 %)
    зависимости приложения                      6 (15 %)

  Большинство находок — в пакетах, которых в requirements.txt нет.
  Поэтому сканирование исходников не заменяет сканирование образа.

  Порядок в pipeline:
    быстрые проверки → сканирование исходников (секунды)
    после сборки     → сканирование образа (десятки секунд)
═══ фактический запуск сканера ═══
  trivy НЕ УСТАНОВЛЕН — сканирование НЕ ВЫПОЛНЯЛОСЬ.

  Команды для справки:
    trivy fs --severity HIGH,CRITICAL --ignore-unfixed .
    trivy image --severity HIGH,CRITICAL --ignore-unfixed --exit-code 1 scan:demo
  ...

cd /tmp/scan
cat > .trivyignore <<'EOF'
# Формат: CVE [exp:ГГГГ-ММ-ДД]
# Исключение без даты пересмотра — не исключение, а забывание.

# Пакет присутствует в образе, но не используется в рантайме:
# он подтянут как зависимость сборки и не импортируется.
# Пересмотреть: 2026-10-01, ответственный: команда платформы
CVE-2026-1002 exp:2026-10-01

# Исправление не выпущено. Компенсирующая мера: сервис не принимает
# файлы от пользователей, путь эксплуатации закрыт.
# Пересмотреть: 2026-09-01, ответственный: команда безопасности
CVE-2026-1004 exp:2026-09-01

# ПРОСРОЧЕНО — попадёт в отчёт проверки
CVE-2026-0999 exp:2026-06-01
EOF

cat > check-ignores.py <<'PY'
"""Проверка файла исключений: даты, обоснования, просроченные записи."""
from __future__ import annotations

import json
import re
import sys
from datetime import date
from pathlib import Path

CVE_LINE = re.compile(r"^\s*(CVE-\d{4}-\d+)\s*(?:exp:(\d{4}-\d{2}-\d{2}))?\s*$")
TODAY = date(2026, 7, 31)


def parse(path: Path) -> list[dict[str, object]]:
    entries: list[dict[str, object]] = []
    comment_lines: list[str] = []
    for raw in path.read_text().splitlines():
        line = raw.rstrip()
        if line.startswith("#"):
            comment_lines.append(line.lstrip("# ").strip())
            continue
        if not line.strip():
            comment_lines.clear()
            continue
        m = CVE_LINE.match(line)
        if not m:
            continue
        cve, expiry = m.group(1), m.group(2)
        entries.append({
            "cve": cve,
            "истекает": expiry,
            "обоснование": " ".join(comment_lines) or None,
        })
        comment_lines.clear()
    return entries


def audit(entries: list[dict[str, object]]) -> list[dict[str, object]]:
    out = []
    for e in entries:
        problems: list[str] = []
        if not e["истекает"]:
            problems.append("нет даты пересмотра — исключение вечное")
        else:
            exp = date.fromisoformat(str(e["истекает"]))
            if exp < TODAY:
                problems.append(f"просрочено {(TODAY - exp).days} дн. назад")
        if not e["обоснование"]:
            problems.append("нет обоснования")
        out.append({**e, "проблемы": problems})
    return out


def main(path: str) -> int:
    entries = audit(parse(Path(path)))
    print(f"  {'CVE':<18} {'истекает':<14} {'статус':<12} обоснование / проблема")
    print("  " + "─" * 100)
    bad = 0
    for e in entries:
        if e["проблемы"]:
            bad += 1
            status = "ТРЕБУЕТ"
            detail = "; ".join(e["проблемы"])
        else:
            status = "действует"
            detail = str(e["обоснование"])[:52]
        print(f"  {e['cve']:<18} {str(e['истекает'] or '—'):<14} {status:<12} {detail}")

    print()
    print(f"  записей: {len(entries)}, требуют внимания: {bad}")
    print()
    print("  Просроченное исключение перестаёт действовать — находка")
    print("  возвращается в отчёт. Это и есть напоминание пересмотреть.")
    print()
    print(json.dumps({"записей": len(entries), "проблемных": bad},
                     ensure_ascii=False))
    return 1 if bad else 0


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

echo "═══ проверка исключений ═══"
python3 check-ignores.py .trivyignore || true

═══ проверка исключений ═══
  CVE                истекает       статус       обоснование / проблема
  ────────────────────────────────────────────────────────────────────────────────────────────────────
  CVE-2026-1002      2026-10-01     действует    Пакет присутствует в образе, но не используется в ра
  CVE-2026-1004      2026-09-01     действует    Исправление не выпущено. Компенсирующая мера: сервис
  CVE-2026-0999      2026-06-01     ТРЕБУЕТ      просрочено 60 дн. назад

  записей: 3, требуют внимания: 1

  Просроченное исключение перестаёт действовать — находка
  возвращается в отчёт. Это и есть напоминание пересмотреть.

cd /tmp/scan
cat > sbom-sources.py <<'PY'
"""Чем SBOM из сборки отличается от восстановленного сканером."""
from __future__ import annotations

CASES = [
    {"компонент": "click 8.3.0 (pip install)",
     "в_сборке": True, "в_сканере": True,
     "почему": "есть метаданные dist-info"},
    {"компонент": "libssl3 (apt-get install)",
     "в_сборке": True, "в_сканере": True,
     "почему": "есть запись в /var/lib/dpkg/status"},
    {"компонент": "бинарник, скопированный COPY",
     "в_сборке": True, "в_сканере": False,
     "почему": "метаданных пакета нет — сканер о нём не знает"},
    {"компонент": "библиотека, собранная из исходников",
     "в_сборке": True, "в_сканере": False,
     "почему": "то же"},
    {"компонент": "распакованный архив с зависимостями",
     "в_сборке": True, "в_сканере": False,
     "почему": "то же"},
    {"компонент": "пакет, установленный и затем удалённый",
     "в_сборке": True, "в_сканере": False,
     "почему": "в готовом образе его нет; сборщик видел установку"},
]


def main() -> None:
    print(f"  {'компонент':<44} {'из сборки':<11} {'из сканера':<12} почему")
    print("  " + "─" * 108)
    only_build = 0
    for c in CASES:
        if c["в_сборке"] and not c["в_сканере"]:
            only_build += 1
        print(f"  {c['компонент']:<44} {'да' if c['в_сборке'] else 'нет':<11} "
              f"{'да' if c['в_сканере'] else 'НЕТ':<12} {c['почему']}")

    print()
    print(f"  видит только сборщик: {only_build} из {len(CASES)}")
    print()
    print("  Сборщик НАБЛЮДАЕТ установку; сканер ВОССТАНАВЛИВАЕТ список")
    print("  по метаданным пакетных менеджеров в готовом образе.")
    print()
    print("  Отсюда практика: генерировать SBOM при сборке")
    print("    docker/build-push-action: sbom: true, provenance: mode=max")
    print("  и хранить как attestation рядом с образом.")
    print()
    print("  Ограничение: attestations живут в registry и теряются")
    print("  при --load. Локально собранный образ их не имеет.")


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

echo "═══ два источника SBOM ═══"
python3 sbom-sources.py

echo "═══ генерация SBOM в pipeline ═══"
cat <<'TXT'
  При сборке:
    - uses: docker/build-push-action@v6
      with:
        push: true
        sbom: true
        provenance: mode=max

  Проверка наличия attestation у опубликованного образа:
    docker buildx imagetools inspect ОБРАЗ --format '{{json .SBOM}}'
    docker buildx imagetools inspect ОБРАЗ --format '{{json .Provenance}}'

  Отдельным файлом-артефактом (когда нужен для аудита):
    syft ОБРАЗ -o spdx-json=sbom.spdx.json
    syft ОБРАЗ -o cyclonedx-json=sbom.cdx.json
TXT

echo "═══ проверка attestation у локального образа ═══"
if docker buildx imagetools inspect scan:demo --format '{{json .SBOM}}' > /dev/null 2>&1; then
    docker buildx imagetools inspect scan:demo --format '{{json .SBOM}}' 2>&1 \
        | head -c 200 | sed 's/^/  /'
    echo
else
    echo "  attestation отсутствует — образ собран локально с --load"
    echo "  (это ожидаемо: attestations живут в registry)"
fi

═══ два источника SBOM ═══
  компонент                                    из сборки   из сканера   почему
  ────────────────────────────────────────────────────────────────────────────────────────────────────────────
  click 8.3.0 (pip install)                    да          да           есть метаданные dist-info
  libssl3 (apt-get install)                    да          да           есть запись в /var/lib/dpkg/status
  бинарник, скопированный COPY                 да          НЕТ          метаданных пакета нет — сканер о нём не знает
  библиотека, собранная из исходников          да          НЕТ          то же
  распакованный архив с зависимостями          да          НЕТ          то же
  пакет, установленный и затем удалённый       да          НЕТ          в готовом образе его нет; сборщик видел установку

  видит только сборщик: 4 из 6
  ...
═══ проверка attestation у локального образа ═══
  attestation отсутствует — образ собран локально с --load
  (это ожидаемо: attestations живут в registry)

cd /tmp/scan
cat > base-image.py <<'PY'
"""Выбор действия при уязвимости в системном пакете базового образа."""
from __future__ import annotations

OPTIONS = [
    {"действие": "Пересобрать на свежем базовом образе",
     "стоимость": "минуты", "надёжность": "высокая",
     "когда": "ОСНОВНОЙ вариант; проверяется одной пересборкой"},
    {"действие": "Обновить пакет в Dockerfile (apt-get install --only-upgrade)",
     "стоимость": "часы", "надёжность": "средняя",
     "когда": "исправление вышло, но базовый образ его ещё не включил"},
    {"действие": "Сменить базовый образ на меньший (slim, distroless)",
     "стоимость": "дни", "надёжность": "высокая",
     "когда": "находок много и большинство — в ненужных пакетах"},
    {"действие": "Ждать обновления базового образа",
     "стоимость": "нет", "надёжность": "низкая",
     "когда": "исправления пока нет ни у кого"},
    {"действие": "Исключить с датой пересмотра",
     "стоимость": "минуты", "надёжность": "низкая",
     "когда": "путь эксплуатации закрыт компенсирующей мерой"},
]

SIZE_EFFECT = [
    ("python:3.13", 1020, 68),
    ("python:3.13-slim", 124, 34),
    ("gcr.io/distroless/python3", 52, 6),
]


def main() -> None:
    print(f"  {'действие':<58} {'стоимость':<12} {'надёжность':<12} когда")
    print("  " + "─" * 120)
    for o in OPTIONS:
        print(f"  {o['действие']:<58} {o['стоимость']:<12} "
              f"{o['надёжность']:<12} {o['когда']}")

    print()
    print("  Влияние базового образа на число находок (типичные значения):")
    print(f"    {'базовый образ':<32} {'размер, МБ':>12} {'находок':>10}")
    print("    " + "─" * 56)
    for name, size, findings in SIZE_EFFECT:
        print(f"    {name:<32} {size:>12} {findings:>10}")

    biggest, smallest = SIZE_EFFECT[0], SIZE_EFFECT[-1]
    print()
    print(f"  Переход с {biggest[0]} на {smallest[0]}:")
    print(f"    размер   {biggest[1]} → {smallest[1]} МБ "
          f"({(1 - smallest[1] / biggest[1]) * 100:.0f} % меньше)")
    print(f"    находок  {biggest[2]} → {smallest[2]} "
          f"({(1 - smallest[2] / biggest[2]) * 100:.0f} % меньше)")
    print()
    print("  Значительная часть находок — в пакетах, которые приложению")
    print("  не нужны. Их отсутствие устраняет уязвимость надёжнее патча.")


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

echo "═══ действия при уязвимости в базовом образе ═══"
python3 base-image.py

docker rmi -f scan:demo > /dev/null 2>&1
cd /tmp && rm -rf /tmp/scan

═══ действия при уязвимости в базовом образе ═══
  действие                                                   стоимость    надёжность   когда
  ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  Пересобрать на свежем базовом образе                       минуты       высокая      ОСНОВНОЙ вариант; проверяется одной пересборкой
  Обновить пакет в Dockerfile (apt-get install --only-upgrade)  часы      средняя      исправление вышло, но базовый образ его ещё не включил
  Сменить базовый образ на меньший (slim, distroless)        дни          высокая      находок много и большинство — в ненужных пакетах
  Ждать обновления базового образа                           нет          низкая       исправления пока нет ни у кого
  Исключить с датой пересмотра                               минуты       низкая       путь эксплуатации закрыт компенсирующей мерой

  Влияние базового образа на число находок (типичные значения):
    базовый образ                      размер, МБ    находок
    ────────────────────────────────────────────────────────
    python:3.13                              1020         68
    python:3.13-slim                          124         34
    gcr.io/distroless/python3                  52          6

  Переход с python:3.13 на gcr.io/distroless/python3:
    размер   1020 → 52 МБ (95 % меньше)
    находок  68 → 6 (91 % меньше)

  Значительная часть находок — в пакетах, которые приложению
  не нужны. Их отсутствие устраняет уязвимость надёжнее патча.

trivy image --severity HIGH,CRITICAL --ignore-unfixed --exit-code 1 ОБРАЗ; echo "код: $?"
trivy image --severity HIGH,CRITICAL --format json ОБРАЗ | python3 -c "
import json,sys
d=json.load(sys.stdin)
v=[x for r in d.get('Results',[]) for x in (r.get('Vulnerabilities') or [])]
print('всего:',len(v),'без исправления:',sum(1 for x in v if not x.get('FixedVersion')))"
docker buildx imagetools inspect ОБРАЗ --format '{{json .SBOM}}' | head -c 300