dockerls 1.0.0__py3-none-any.whl

dockerls/domain/value_objects/scan_plan.py

@@ -0,0 +1,193 @@
+"""Quais tags medir, quando medir todas custa minutos.
+
+`recommend node` descobre até `max_tags` tags e mostra cinco. Com o padrão
+de 100 e o Trivy a 1,2-2,5s por imagem, isso são dois a quatro minutos de
+relógio -- e 95 dos 100 scans existem só para serem descartados no
+ranqueamento.
+
+O corte podia ser feito de dois jeitos, e só um deles é honesto neste
+projeto:
+
+* **baixar `max_tags`** faria uma tag boa fora da janela simplesmente não
+  existir, sem nada dizendo que ela existiu;
+* **escolher quem medir, e declarar quem ficou de fora**, que é o que este
+  módulo faz.
+
+A distinção que sustenta tudo aqui: uma tag adiada **não é uma tag pior**.
+Ela é uma tag *não medida*, e o resultado a carrega com o motivo, do mesmo
+jeito que `UnverifiedImage` carrega um scan que falhou. Em nenhum momento a
+ausência de medição é gasta como se fosse medição.
+
+Nenhuma regra aqui consulta rede, disco ou scanner: todas usam fatos que a
+listagem de tags já trouxe. Uma função pura de decisão se testa
+exaustivamente, e é isso que torna defensável cortar 75 scans.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from dockerls.domain.entities.image import DockerImage
+
+#: Quantas tags medir quando nada é configurado. `TOP_N` é 5 e a
+#: verificação final olha 10 finalistas, então 25 deixa folga de sobra para
+#: o ranqueamento ter de quem escolher.
+DEFAULT_SCAN_BUDGET = 25
+
+#: Versão no começo da tag: `22`, `22.14`, `3.21.0`. O resto, depois do
+#: primeiro `-`, é a variante (`alpine`, `bookworm-slim`, `jre-alpine`).
+_VERSION_PREFIX = re.compile(r"^v?(\d+(?:\.\d+)*)(?:[-_.](.*))?$", re.IGNORECASE)
+
+
+class DeferralReason(StrEnum):
+    """Por que uma tag não foi medida. Nunca "por ser pior"."""
+
+    #: Existe uma tag mais nova da mesma linha, com a mesma precisão de
+    #: versão e a mesma variante -- `22.13-alpine` diante de `22.14-alpine`.
+    SUPERSEDED = "SUPERSEDED"
+    #: Coube fora do orçamento de scans deste run.
+    OVER_BUDGET = "OVER_BUDGET"
+
+
+@dataclass(frozen=True)
+class DeferredTag:
+    """Uma tag que existe, foi descoberta, e não foi medida."""
+
+    reference: str
+    reason: DeferralReason
+    #: Frase para o humano. Diz o fato que motivou o adiamento, e nunca
+    #: uma conclusão sobre a segurança da imagem.
+    detail: str
+
+
+@dataclass(frozen=True)
+class ScanPlan:
+    """O que este run vai medir, e o que ele declaradamente não vai."""
+
+    selected: list[DockerImage]
+    deferred: list[DeferredTag] = field(default_factory=list)
+    #: Quantas tags a busca trouxe, antes de qualquer corte.
+    discovered: int = 0
+    #: O orçamento em vigor; 0 significa "medir todas".
+    budget: int = 0
+
+    @property
+    def deferred_count(self) -> int:
+        return len(self.deferred)
+
+
+def _version_and_variant(tag: str) -> tuple[tuple[int, ...] | None, str]:
+    """A versão numérica no início da tag e a variante que sobra.
+
+    `22.14-alpine` -> `((22, 14), "alpine")`. Uma tag sem versão numérica
+    (`latest`, `lts`, `bookworm`) devolve `None`, e tags assim nunca são
+    adiadas por sucessão: não há como ordenar o que não tem número.
+    """
+    match = _VERSION_PREFIX.match(tag.strip())
+    if match is None:
+        return None, tag.strip().lower()
+    version = tuple(int(part) for part in match.group(1).split("."))
+    return version, (match.group(2) or "").lower()
+
+
+def _superseded(tags: Sequence[DockerImage]) -> dict[str, DeferredTag]:
+    """As tags que uma irmã mais nova da mesma linha já representa.
+
+    "Mesma linha" é: mesma variante, mesmo major, e mesma quantidade de
+    componentes de versão. As duas primeiras condições são a linha em si;
+    a terceira é o que impede colapsar `22-alpine` com `22.14-alpine`, que
+    são respostas diferentes para perguntas diferentes -- uma acompanha a
+    linha, a outra fixa o patch, e escolher entre as duas é do usuário.
+
+    Majors não competem entre si: `20-alpine` continua sendo uma resposta
+    legítima ao lado de `22-alpine`, e frequentemente é a certa (LTS).
+    """
+    newest: dict[tuple[str, int, tuple[int, ...]], DockerImage] = {}
+    for image in tags:
+        version, variant = _version_and_variant(image.tag)
+        if version is None:
+            continue
+        key = (variant, len(version), version[:1])
+        current = newest.get(key)
+        if current is None:
+            newest[key] = image
+            continue
+        current_version, _ = _version_and_variant(current.tag)
+        if current_version is not None and version > current_version:
+            newest[key] = image
+
+    winners = {id(image) for image in newest.values()}
+    deferred: dict[str, DeferredTag] = {}
+    for image in tags:
+        version, variant = _version_and_variant(image.tag)
+        if version is None or id(image) in winners:
+            continue
+        key = (variant, len(version), version[:1])
+        winner = newest[key]
+        deferred[image.full_reference] = DeferredTag(
+            reference=image.full_reference,
+            reason=DeferralReason.SUPERSEDED,
+            detail=(f"a newer tag of the same line was measured instead ({winner.tag})"),
+        )
+    return deferred
+
+
+def _priority(image: DockerImage) -> tuple[int, float, str]:
+    """Ordem de preferência para gastar o orçamento.
+
+    Critérios que a listagem já conhece, sem scan: imagem oficial primeiro,
+    depois a mais recentemente publicada, depois o nome -- este último só
+    para que dois runs sobre os mesmos dados escolham as mesmas tags.
+    """
+    published = image.last_updated.timestamp() if image.last_updated is not None else 0.0
+    return (0 if image.is_official else 1, -published, image.full_reference)
+
+
+def plan_scans(tags: Sequence[DockerImage], budget: int = DEFAULT_SCAN_BUDGET) -> ScanPlan:
+    """Escolhe quem medir, e nomeia quem ficou de fora.
+
+    `budget <= 0` mede tudo, que é o comportamento de sempre e continua
+    disponível por configuração -- quem precisa da varredura completa não
+    perdeu nada.
+    """
+    discovered = len(tags)
+    if budget <= 0 or discovered <= budget:
+        return ScanPlan(
+            selected=list(tags), deferred=[], discovered=discovered, budget=max(0, budget)
+        )
+
+    superseded = _superseded(tags)
+    survivors = [image for image in tags if image.full_reference not in superseded]
+
+    deferred = [
+        superseded[image.full_reference] for image in tags if image.full_reference in superseded
+    ]
+
+    if len(survivors) > budget:
+        ranked = sorted(survivors, key=_priority)
+        kept = set(map(id, ranked[:budget]))
+        survivors = [image for image in tags if id(image) in kept]
+        for image in ranked[budget:]:
+            deferred.append(
+                DeferredTag(
+                    reference=image.full_reference,
+                    reason=DeferralReason.OVER_BUDGET,
+                    detail=f"beyond this run's budget of {budget} scans",
+                )
+            )
+
+    # A ordem de saída é a da descoberta: o ranqueamento por segurança
+    # acontece depois, sobre medições, e reordenar aqui embaralharia a
+    # entrada de uma decisão que nada tem a ver com esta.
+    return ScanPlan(
+        selected=survivors,
+        deferred=deferred,
+        discovered=discovered,
+        budget=budget,
+    )

dockerls/domain/value_objects/scanner_db.py

@@ -0,0 +1,143 @@
+"""Há quanto tempo o medidor foi atualizado, e o que isso permite afirmar.
+
+`doctor` conferia que o scanner **existe**. Não conferia que ele mede: um
+Trivy com base de vulnerabilidades de três semanas produz um scan limpo,
+verde e sem erro nenhum que simplesmente não conhece os CVEs do último mês.
+
+É a falha de medição mais silenciosa que existe aqui, e a mais perigosa
+justamente por ser silenciosa -- nada no relatório indica que a resposta
+está velha. É o tema central do projeto ("ausência de medição nunca é gasta
+como tranquilidade") aplicado ao próprio medidor.
+
+O tristate aparece de novo, e pela mesma razão de sempre: não conseguir ler
+a data da base **não** é a base estar fresca. `UNKNOWN` é o valor honesto
+para um arquivo de metadados ausente, ilegível ou com um formato que este
+código não reconhece, e ele nunca é apresentado como aprovação.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import UTC, datetime, timedelta
+from enum import StrEnum
+
+#: Até aqui, a base cobre o que se publicou recentemente. O Trivy reconstrói
+#: a dele a cada 6h e carimba `NextUpdate` cerca de 24h à frente; o Grype
+#: publica diariamente. Um dia é a janela normal dos dois.
+FRESH_WITHIN = timedelta(hours=24)
+
+#: Daqui em diante a base já perdeu dias de publicação. Não é inutilizável
+#: -- a maioria dos CVEs de uma imagem é antiga --, mas quem está decidindo
+#: um deploy precisa saber que a resposta tem essa idade.
+STALE_AFTER = timedelta(hours=72)
+
+
+class DatabaseState(StrEnum):
+    FRESH = "FRESH"
+    #: Entre um e três dias. Ainda mede, e já vale dizer a idade.
+    AGING = "AGING"
+    STALE = "STALE"
+    #: Não foi possível ler a data. **Não** é o mesmo que fresca.
+    UNKNOWN = "UNKNOWN"
+
+
+@dataclass(frozen=True)
+class DatabaseFreshness:
+    """O que se sabe sobre a idade da base de um scanner."""
+
+    scanner: str
+    state: DatabaseState
+    #: Quando a base foi construída, quando se conseguiu ler.
+    built_at: datetime | None = None
+    #: Idade no momento da checagem.
+    age: timedelta | None = None
+    #: Por que não foi possível ler, quando não foi.
+    detail: str = ""
+
+    @property
+    def is_usable_measurement(self) -> bool:
+        """Se um scan feito agora mediria o que se publicou recentemente.
+
+        `UNKNOWN` responde `False` de propósito: a pergunta é "dá para
+        confiar na atualidade desta base", e "não sei" não é sim.
+        """
+        return self.state in (DatabaseState.FRESH, DatabaseState.AGING)
+
+    def explain(self) -> str:
+        """A frase que diz o que se sabe, sem arredondar para o lado bom."""
+        match self.state:
+            case DatabaseState.FRESH:
+                return f"updated {_human(self.age)} ago"
+            case DatabaseState.AGING:
+                return (
+                    f"updated {_human(self.age)} ago: still usable, and already missing "
+                    "whatever was published since"
+                )
+            case DatabaseState.STALE:
+                return (
+                    f"updated {_human(self.age)} ago. A scan against it comes back clean "
+                    "for anything published since, which reads exactly like a clean "
+                    "image and is not one"
+                )
+            case DatabaseState.UNKNOWN:
+                reason = self.detail or "no readable metadata"
+                return (
+                    f"age unknown ({reason}). This is not the same as up to date: "
+                    "nothing here says how old the answers are"
+                )
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "scanner": self.scanner,
+            "state": str(self.state),
+            "built_at": self.built_at.isoformat() if self.built_at else "",
+            "age_hours": round(self.age.total_seconds() / 3600, 1) if self.age else None,
+            "explanation": self.explain(),
+        }
+
+
+def classify(
+    scanner: str,
+    built_at: datetime | None,
+    *,
+    now: datetime | None = None,
+    detail: str = "",
+) -> DatabaseFreshness:
+    """Classifica a idade de uma base a partir da data em que foi construída.
+
+    Puro: recebe a data já lida, para que a regra se teste sem tocar disco.
+    """
+    if built_at is None:
+        return DatabaseFreshness(scanner, DatabaseState.UNKNOWN, detail=detail)
+
+    moment = now or datetime.now(tz=UTC)
+    stamped = built_at if built_at.tzinfo is not None else built_at.replace(tzinfo=UTC)
+    age = moment - stamped
+
+    if age < timedelta(0):
+        # Uma base "do futuro" é relógio errado numa das duas pontas, e
+        # tratá-la como fresquíssima esconderia o problema.
+        return DatabaseFreshness(
+            scanner,
+            DatabaseState.UNKNOWN,
+            built_at=stamped,
+            detail="the database is stamped in the future; check the clock",
+        )
+    if age <= FRESH_WITHIN:
+        state = DatabaseState.FRESH
+    elif age <= STALE_AFTER:
+        state = DatabaseState.AGING
+    else:
+        state = DatabaseState.STALE
+    return DatabaseFreshness(scanner, state, built_at=stamped, age=age)
+
+
+def _human(age: timedelta | None) -> str:
+    if age is None:
+        return "an unknown time"
+    hours = age.total_seconds() / 3600
+    if hours < 1:
+        return f"{int(age.total_seconds() // 60)} minutes"
+    if hours < 48:
+        return f"{hours:.0f} hours"
+    return f"{hours / 24:.1f} days"

dockerls/domain/value_objects/security_score.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import math
+from typing import TYPE_CHECKING
+
+from loguru import logger
+
+from dockerls.domain.entities.scan_result import ScanResult, ScanStatus
+
+if TYPE_CHECKING:
+    from dockerls.domain.entities.image import DockerImage
+
+
+CRITICAL_PENALTY = 20.0
+HIGH_PENALTY = 5.0
+MEDIUM_PENALTY = 1.0
+EOL_PENALTY = 20.0
+# Age is a staleness signal, not a vulnerability. Uncapped it grew by one
+# point per year, so a 10-year-old image lost as much as two HIGH findings
+# on age alone. Capped at 3, it can order equally-clean images without
+# ever competing with measured severity.
+MAX_AGE_PENALTY = 3.0
+EXPLOITED_PENALTY = 10.0
+# The step: a vulnerability at or above this probability draws a flat
+# penalty. Kept because it is the part an operator can reason about ("EPSS
+# over 0.5 costs 5 points"), and because removing it would silently change
+# every score this tool has ever produced.
+HIGH_EPSS_PENALTY = 5.0
+HIGH_EPSS_THRESHOLD = 0.5
+# The slope, added on top. The step alone made 0.97 and 0.51 cost exactly
+# the same, and 0.49 cost nothing -- a cliff edge in the middle of a
+# continuous measurement, where the difference between "half the time" and
+# "almost certainly" is the whole point of having the number. The term is
+# proportional to the probability itself and is capped well below a single
+# HIGH finding, so it orders comparable images without ever competing with
+# measured severity.
+EPSS_SLOPE_PENALTY = 4.0
+
+# Qualitative bonuses. Their total is deliberately held *below* the HIGH
+# penalty: no amount of "official + minimal + signed + LTS + recent" may
+# lift an image with an extra HIGH or CRITICAL above a cleaner one. They
+# can outweigh a MEDIUM or two, which is intended -- a signed official
+# distroless image with a couple of mediums is a reasonable pick over an
+# unremarkable image with none.
+OFFICIAL_BONUS = 1.0
+MINIMAL_BASE_BONUS = 1.0
+SIGNED_BONUS = 1.0
+LTS_BONUS = 0.5
+RECENT_BONUS = 0.5
+MAX_BONUS = OFFICIAL_BONUS + MINIMAL_BASE_BONUS + SIGNED_BONUS + LTS_BONUS + RECENT_BONUS
+
+# Scoring starts here rather than at 100 so a fully-decorated clean image
+# lands exactly on 100 without being clamped. Clamping at the top was
+# collapsing genuinely different images onto the same number: a clean
+# image, a 1-HIGH image and a 5-MEDIUM image all read 100.0.
+BASE_SCORE = 100.0 - MAX_BONUS
+
+
+class SecurityScore:
+    def __init__(
+        self,
+        image: DockerImage,
+        scan: ScanResult,
+        is_eol: bool = False,
+        is_lts: bool = False,
+    ):
+        if scan.status not in (ScanStatus.OK, ScanStatus.PARTIAL):
+            raise ValueError(
+                f"Cannot score {image.full_reference}: scan status is "
+                f"{scan.status.value} ({scan.error_message or 'no details'})"
+            )
+        self._image = image
+        self._scan = scan
+        self._is_eol = is_eol
+        self._is_lts = is_lts
+        self._value = self._calculate()
+
+    @property
+    def value(self) -> float:
+        return self._value
+
+    @property
+    def penalty(self) -> float:
+        """Everything measured about the image's vulnerabilities.
+
+        This alone decides the ordering between images with different
+        severity profiles -- the qualitative bonuses cannot overturn it for
+        HIGH or CRITICAL findings.
+        """
+        penalty = (
+            self._scan.critical_count * CRITICAL_PENALTY
+            + self._scan.high_count * HIGH_PENALTY
+            + self._scan.medium_count * MEDIUM_PENALTY
+        )
+
+        # CISA KEV / EPSS threat-intel signal: a vulnerability with a
+        # confirmed real-world exploit (or a high predicted exploitation
+        # probability) is materially worse than an unweighted CVSS count
+        # suggests, so it draws an extra penalty on top of the base
+        # severity penalties above.
+        penalty += EXPLOITED_PENALTY * sum(1 for v in self._scan.vulnerabilities if v.exploit_known)
+        penalty += HIGH_EPSS_PENALTY * sum(
+            1 for v in self._scan.vulnerabilities if v.epss_score >= HIGH_EPSS_THRESHOLD
+        )
+        # Continuous term, over the same findings as the step. No
+        # `epss_known` check is needed here and adding one would be wrong:
+        # the field defaults to 0.0, so a *non-zero* score is itself proof
+        # that a lookup returned it, and a zero contributes nothing either
+        # way. `epss_known` earns its keep in the reporting layer, where the
+        # difference between "scored at zero" and "never looked up" is a
+        # statement rather than a number.
+        penalty += EPSS_SLOPE_PENALTY * sum(v.epss_score for v in self._scan.vulnerabilities)
+
+        if self._is_eol:
+            penalty += EOL_PENALTY
+        # Age only moves the score when the source actually reported a
+        # publish date. Registries that list tag names only (Chainguard,
+        # most OCI catalogues) would otherwise be charged the maximum age
+        # penalty and denied the recency bonus for missing metadata.
+        if self._image.age_known:
+            penalty += min(self._image.age_days / 365.0, MAX_AGE_PENALTY)
+        return penalty
+
+    @property
+    def bonus(self) -> float:
+        """Qualitative signals, capped below a single HIGH finding."""
+        bonus = 0.0
+        if self._image.is_official:
+            bonus += OFFICIAL_BONUS
+        # Distroless, hardened-vendor (Chainguard/Wolfi/Bitnami), and Alpine
+        # are all "minimal base" signals; an image matching more than one
+        # must not be double-counted.
+        if self._image.is_distroless or self._image.is_hardened_source or self._image.is_alpine:
+            bonus += MINIMAL_BASE_BONUS
+        if self._image.is_signed:
+            bonus += SIGNED_BONUS
+        if self._is_lts:
+            bonus += LTS_BONUS
+        if self._image.age_known and self._image.recently_updated:
+            bonus += RECENT_BONUS
+        return bonus
+
+    def _calculate(self) -> float:
+        # No "zero vulnerabilities" bonus: zero findings already means zero
+        # penalty, so rewarding it again double-counted the same fact and
+        # was part of what pushed clean images into the clamp.
+        score = BASE_SCORE - self.penalty + self.bonus
+        if not math.isfinite(score):
+            # The clamp below cannot catch this: every comparison against
+            # NaN is False, so `max(0.0, min(100.0, nan))` answers 100.0 --
+            # the arithmetic failing produced the highest possible score.
+            # Whatever went wrong, it is not evidence that the image is
+            # clean, so the score collapses to the bottom and the reason is
+            # loud.
+            logger.error(
+                f"Security score for {self._image.name}:{self._image.tag} was not a finite "
+                f"number (penalty={self.penalty}, bonus={self.bonus}); reporting 0.0"
+            )
+            return 0.0
+        return max(0.0, min(100.0, round(score, 1)))

dockerls/domain/value_objects/security_tier.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from dockerls.domain.entities.scan_result import ScanResult
+
+
+class Tier(StrEnum):
+    A = "A"
+    B = "B"
+    C = "C"
+    D = "D"
+    E = "E"
+    F = "F"
+
+
+#: Do melhor para o pior. A ordem é explícita porque a trava de CRITICAL
+#: precisa comparar tiers, e comparar letras alfabeticamente só funciona por
+#: coincidência -- deixaria de funcionar no instante em que a escala mudar.
+TIER_ORDER: tuple[Tier, ...] = (Tier.A, Tier.B, Tier.C, Tier.D, Tier.E, Tier.F)
+
+#: Piso de score de cada faixa, do topo para a base. Cobre toda a faixa
+#: 0-100: antes a escala parava em C, então um score 0.0 com 6 CRITICAL e 170
+#: vulnerabilidades recebia exatamente o mesmo tier de uma imagem 36 pontos
+#: melhor -- a nota deixava de discriminar justamente onde mais importava.
+TIER_BANDS: tuple[tuple[float, Tier], ...] = (
+    (90.0, Tier.A),
+    (75.0, Tier.B),
+    (60.0, Tier.C),
+    (40.0, Tier.D),
+    (20.0, Tier.E),
+)
+LOWEST_TIER = Tier.F
+
+#: Melhor tier que uma imagem com CRITICAL sem correção disponível pode
+#: alcançar. Um CRITICAL que nem dá para consertar não é compensável por
+#: nenhum outro sinal: por mais alto que o score fique, a imagem não passa de
+#: "exige revisão humana".
+UNFIXABLE_CRITICAL_CEILING = Tier.C
+
+#: Tiers que uma imagem precisa alcançar para ser considerada pronta para
+#: produção, alinhado com `DockerfileAnalysis.is_production_ready`.
+PRODUCTION_READY_TIERS = (Tier.A, Tier.B)
+
+
+def tier_for_score(score: float) -> Tier:
+    for floor, tier in TIER_BANDS:
+        if score >= floor:
+            return tier
+    return LOWEST_TIER
+
+
+class SecurityTier:
+    """Traduz o score de segurança numa nota de A a F.
+
+    A escala completa, documentada também no README:
+
+    | Tier | Score   | Leitura                                    |
+    |------|---------|--------------------------------------------|
+    | A    | 90-100  | pronta para produção                       |
+    | B    | 75-89   | pronta para produção                       |
+    | C    | 60-74   | condicional: exige revisão humana           |
+    | D    | 40-59   | não pronta para produção                    |
+    | E    | 20-39   | não pronta para produção                    |
+    | F    | 0-19    | não usar                                    |
+
+    Sobre a trava: uma imagem com CRITICAL **sem correção disponível** nunca
+    passa de C, por mais alto que o score tenha ficado. E uma base EOL nunca é
+    production-ready, independentemente do tier -- ela vai parar de receber
+    correções de segurança de qualquer forma.
+    """
+
+    ADVICE = {
+        Tier.C: "conditional -- requires human review before production use",
+        Tier.D: "not production ready",
+        Tier.E: "not production ready",
+        Tier.F: "not production ready -- do not deploy",
+    }
+
+    def __init__(self, scan: ScanResult, security_score: float, is_eol: bool = False):
+        self._scan = scan
+        self._score = security_score
+        self._is_eol = is_eol
+        self._tier = self._classify()
+
+    @property
+    def tier(self) -> Tier:
+        return self._tier
+
+    @property
+    def unfixable_critical_count(self) -> int:
+        return self._scan.critical_count - self._scan.fixable_critical_count
+
+    @property
+    def production_ready(self) -> bool:
+        """Whether the *tier* alone would permit production use.
+
+        **This is not the verdict.** It answers a narrower question than it
+        appears to: it can see the score and the EOL flag, and nothing else
+        -- not whether the scan completed, not whether two scanners agreed,
+        not whether anything was verified. Read as the verdict, it reported
+        a PARTIAL scan with no findings as production ready on the same
+        analysis that reported UNVERIFIED.
+
+        `ProductionReadiness` in `domain/value_objects/production_readiness.py`
+        is the policy that decides, and `ImageAnalysis.production_ready` is
+        written only by it. This property survives as the tier-level rule
+        that policy consumes.
+        """
+        # An EOL base is never production-ready, regardless of its
+        # vulnerability tier -- it will stop receiving security patches.
+        if self._is_eol:
+            return False
+        return self._tier in PRODUCTION_READY_TIERS
+
+    def _classify(self) -> Tier:
+        tier = tier_for_score(self._score)
+        if self.unfixable_critical_count > 0:
+            tier = max(tier, UNFIXABLE_CRITICAL_CEILING, key=TIER_ORDER.index)
+        return tier