Delete security

security/RELEASE_EVIDENCE_GUIDE.md

@@ -1,107 +0,0 @@
-# Production release evidence — B39
-
-B38 made the source release path reproducible. B39 prevents **evidence substitution**:
-a scan, SBOM or attestation is not accepted merely because a file named “scan” exists.
-Every production promotion must supply one short-lived `release-evidence.json` that
-binds the evidence to the exact repository lock/SBOM and to one immutable final OCI
-image digest.
-
-## Trust boundary
-
-The evidence manifest contains **no secrets and no deployment identity**. Do not put
-Redis URLs, hostnames, usernames, tokens, passwords, registry credentials, request
-samples, user content, IP addresses, or capability values in it. Evidence artifacts
-stay beside the manifest and are referenced only by relative path + SHA-256.
-
-The verifier rejects path traversal, symlinks, stale/expired manifests, source-hash
-drift, artifact tampering, a provenance subject that does not match the final image,
-missing signature-verification evidence, unsafe infrastructure logging attestations,
-unverified Redis lifecycle properties, and risk-exception bypasses.
-
-## Release flow
-
-```text
-exact source lock + Python SBOM
-          |
-          v
-networked dependency scan
-          |
-          v
-linux/amd64 image build -> immutable image digest
-          |                    |
-          |                    +--> full image CycloneDX SBOM
-          |                    +--> image vulnerability scan
-          |                    +--> SLSA/in-toto provenance
-          |                    +--> signature verification
-          v
-sanitized Redis + infrastructure logging evidence
-          |
-          v
-release-evidence.json (<= 72 h validity)
-          |
-          v
-python security/verify_release_gate.py release-evidence.json
-          |
-          +--> GREEN: promotion may continue
-          `--> RED: fail closed
-```
-
-SLSA provenance is expected as an in-toto Statement v1 whose predicate type is
-`https://slsa.dev/provenance/v1` and whose subject SHA-256 is the exact final image
-digest. Signature verification remains a separate artifact because provenance JSON
-alone does not prove who signed it.
-
-## Redis evidence without credential leakage
-
-`probe_redis_authority.py` is explicit opt-in and receives only the **name** of the
-environment variable that contains a Redis URL:
-
-```bash
-python security/probe_redis_authority.py \
-  --plane share \
-  --url-env SHARE_STORE_REDIS_URL \
-  --output redis-share-observation.json
-```
-
-It never accepts the URL as a CLI argument and never emits hostname, port, username,
-credentials, keys, values, replication offsets, or persistence timestamps. It uses
-`PING`, `ACL WHOAMI` where permitted, and bounded `INFO persistence` / `INFO replication`
-observations. These observations do **not** paper-prove least privilege, provider
-persistence guarantees, backup retention, or successful restores; those remain
-operator/provider evidence.
-
-For Share and Contribution lifecycle authority, production evidence additionally
-requires persistence, replication, and a successful backup/restore exercise no older
-than 90 days. Rate limiting needs TLS and non-default least-privilege identity but is
-not falsely classified as durable user-data storage.
-
-## Infrastructure logging / telemetry rule
-
-Production promotion fails unless operators attest that request bodies,
-Authorization headers, management-capability headers, query strings, WAF body
-capture, APM body capture, and third-party telemetry export are all disabled for the
-assistant service. This is independent of browser feedback consent: infrastructure
-logging must never become a hidden telemetry bypass.
-
-## What B39 still cannot prove locally
-
-The verifier validates **binding and policy**, not the truth of external scanner or
-provider claims. The release system must itself be trusted, scanners must run against
-the final artifact, and signature/provenance verification must be performed by the
-approved CI/registry trust root. Keep the raw external evidence according to your
-security retention policy; do not embed it in the application image.
-## Schema-v1 fail-closed parsing
-
-The production verifier treats the evidence document as a security protocol, not
-as an extensible metadata bag. Unknown root or nested schema-v1 fields are
-rejected. The manifest itself is capped at 256 KiB, referenced evidence files
-are separately bounded, and every required evidence artifact declares a
-non-empty bounded tool name/version. The release `proxyVersion` must equal the
-actual runtime source constant.
-
-Full-image CycloneDX evidence must be version 1.6 or newer. The resolved
-platform manifest digest must be distinct from the pinned multi-platform index
-digest; copying the index digest into the resolved-manifest field is rejected.
-Runtime source binding includes every regular file copied from `_utils/`, not
-only Python files, so future runtime policy/data files cannot silently escape
-the source subject.

security/SECURITY_RELEASE_GATES.md

@@ -1,128 +0,0 @@
-# Supply-chain, deployment, and evidence release gates
-
-Run 19 / B38 makes the source-controlled deployment path reproducible and
-fail-closed. Run 20 / B39 adds short-lived, content-addressed production
-evidence binding so stale or unrelated scanner/attestation files cannot be
-substituted for the current source and final image. It does **not** claim that a pinned image or lock file is free of
-future vulnerabilities. Release evidence must be renewed whenever the image,
-lock, deployment platform, or advisory database changes.
-
-## Source-controlled gates
-
-1. **Immutable base** — `Dockerfile` uses an exact Python tag plus immutable
-   OCI index digest. CI resolves the requested `linux/amd64` manifest from that
-   index and records the manifest digest used for the release.
-2. **Hash-locked Python closure** — production installs `requirements.lock`
-   with both `--require-hashes` and `--only-binary=:all:`. Source builds and
-   resolver drift are not accepted in the release path.
-3. **Minimal framework extras** — FastAPI and Uvicorn are installed without
-   their broad optional/`standard` extras. Every transitive runtime package is
-   named explicitly by the lock.
-4. **Runtime without install tooling** — dependencies are built in an isolated
-   venv in a builder stage. Runtime `pip`, `setuptools`, and `wheel` payloads
-   from the base image are removed and the finished venv is copied in.
-5. **Non-root strict profile** — runtime UID/GID is `1000:1000`, matching the
-   Hugging Face Docker Spaces convention. `DEPLOYMENT_PROFILE=strict` also
-   verifies non-root execution in application startup.
-6. **Deny-by-default build context** — `.dockerignore` allows only the service
-   runtime unit into the Docker build context, reducing accidental secret,
-   cache, repository-history, test-fixture, and unrelated-artifact inclusion.
-7. **Read-only/rootless reference** — the hardened Compose reference drops all
-   Linux capabilities, enables `no-new-privileges`, uses a read-only root
-   filesystem, and confines expected temporary writes to `/tmp`.
-8. **Redis transport authority** — strict deployments require `rediss://` for
-   every Redis-backed control plane. URL query parameters cannot downgrade TLS;
-   certificate and hostname verification are forced by code.
-9. **Python SBOM** — `python-runtime.cdx.json` describes the exact locked Python
-   closure. It is not a complete image SBOM because it intentionally excludes
-   OS/base-image packages.
-
-## Networked CI/release evidence — mandatory before production promotion
-
-Run these in a networked, current advisory environment. Tool names are examples;
-organizations may use equivalent scanners, but **do not turn scanner failure
-into a warning-only step**.
-
-```bash
-# Offline structure/ratchet verifier committed with the source.
-python security/verify_supply_chain.py
-
-# Dependency advisory gate. Generate/install in an isolated environment from
-# the exact lock first; fail on known vulnerabilities with no approved policy.
-pip-audit --strict --require-hashes -r requirements.lock
-
-# Build for the locked target architecture and identify the immutable result.
-docker build --platform linux/amd64 -t scikitplots-ai-proxy:b38 .
-docker image inspect scikitplots-ai-proxy:b38 --format '{{.Id}}'
-
-# Full image SBOM (includes OS packages) and vulnerability gate.
-syft scikitplots-ai-proxy:b38 -o cyclonedx-json > image.cdx.json
-trivy image --exit-code 1 --severity HIGH,CRITICAL scikitplots-ai-proxy:b38
-
-# Prefer signed provenance/SBOM attestations in the target registry (for
-# example, BuildKit provenance plus organization-approved signing tooling).
-```
-
-Scanner output is time-sensitive evidence. Never copy an old “0 CVEs” result
-forward to a new release. If a base-image CVE has no upstream fix yet, document
-its reachability, compensating controls, owner, expiration date, and explicit
-risk acceptance rather than silently suppressing it.
-
-## Dependency update protocol
-
-Update direct requirements, regenerate the complete wheel lock for the exact
-platform, regenerate the Python SBOM, run `verify_supply_chain.py`, review fresh
-advisories, run the complete proxy regression suite, build/scan the container,
-and only then update the maintenance checkpoint. A dependency bump is a security
-change even when application source is unchanged.
-
-## Current B38 advisory ratchets
-
-The B38 review found that the previous environment's Click 8.1.8 and Starlette
-0.50.0 are below current security fixes. The lock therefore ratchets Click to
-8.3.3 and Starlette to the reviewed 1.6.0 release;
-`supply_chain_policy.toml` prevents an accidental rollback below those reviewed
-floors. Fresh scanning remains mandatory because
-new advisories can appear after this checkpoint.
-
-
-## B39 machine-verifiable production evidence
-
-Before collecting external evidence, obtain the canonical non-secret subjects:
-
-```bash
-python security/release_subjects.py
-```
-
-The output contains only proxy version, target platform, exact lock/SBOM/runtime
-source digests, and the immutable base-image index digest. It contains no URLs,
-credentials, user data, deployment hostnames, or Redis identity.
-
-Store the fresh dependency scan, image scan, full-image CycloneDX SBOM, SLSA
-provenance, and signature-verification output beside `release-evidence.json`.
-Each referenced file is bound by relative path + SHA-256 + explicit subject.
-The production manifest also records the resolved base-image manifest digest,
-final OCI image digest, sanitized Redis operational evidence, and infrastructure
-logging/telemetry posture.
-
-The standard hardened B39 policy accepts no risk-exception entry in the promotion
-manifest. A release that needs an exception must change/review the policy rather
-than smuggling a waiver into evidence. Manifests expire within 72 hours.
-
-```bash
-# Source-only structural gate.
-python security/verify_supply_chain.py
-
-# One production promotion gate: source policy + bound fresh evidence.
-python security/verify_release_gate.py /secure/release/release-evidence.json
-```
-
-`verify_release_gate.py` fails closed on stale/expired evidence, source or artifact
-hash drift, path traversal/symlink substitution, mismatched artifact subjects,
-provenance that does not name the final image or resolved base manifest, missing
-signature-verification evidence, hidden infrastructure body/credential logging,
-unverified Share/Contribution persistence/replication, stale backup/restore
-exercises, or third-party telemetry export.
-
-See `RELEASE_EVIDENCE_GUIDE.md` and `release-evidence.example.json`. The example
-is intentionally non-authoritative and cannot pass verification unchanged.

security/probe_redis_authority.py

@@ -1,162 +0,0 @@
-#!/usr/bin/env python3
-"""
-Collect sanitized Redis operational evidence for one control plane.
-
-The Redis URL is read only from an environment variable named by the operator;
-it is never accepted as a command-line value and never printed.  Output contains
-no host, port, username, keys, values, replication offsets, or credentials.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import logging
-import os
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-ROOT = Path(__file__).resolve().parents[1]
-if str(ROOT) not in sys.path:
-    sys.path.insert(0, str(ROOT))
-from _utils._redis_security import (  # noqa: E402
-    RedisSecurityError,
-    redis_connection_kwargs,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def _now() -> str:
-    return (
-        datetime.now(timezone.utc).isoformat(timespec="seconds").replace("+00:00", "Z")
-    )
-
-
-def _int(value: Any, default: int = 0) -> int:
-    try:
-        return int(value)
-    except (TypeError, ValueError):
-        return default
-
-
-def collect(  # ruff: ignore[too-many-branches, undocumented-public-function]
-    *,
-    plane: str,
-    url_env: str,
-    client: Any | None = None,
-) -> dict[str, Any]:
-    if plane not in {"rateLimit", "share", "contribution"}:
-        raise RuntimeError("PLANE_INVALID")
-    if not url_env or any(
-        ch not in "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_" for ch in url_env
-    ):
-        raise RuntimeError("URL_ENV_NAME_INVALID")
-    url = os.environ.get(url_env, "")
-    try:
-        policy, kwargs = redis_connection_kwargs(
-            url, require_tls=True, socket_timeout_seconds=3.0
-        )
-    except RedisSecurityError as exc:
-        raise RuntimeError(exc.code) from exc
-    if client is None:
-        try:
-            import redis  # type: ignore[]  # ruff: ignore[import-outside-top-level]
-
-            client = redis.Redis.from_url(url, **kwargs)
-        except Exception as exc:
-            raise RuntimeError("REDIS_CLIENT_UNAVAILABLE") from exc
-    try:
-        ping = bool(client.ping())
-    except Exception as exc:
-        raise RuntimeError("REDIS_PING_FAILED") from exc
-    if not ping:
-        raise RuntimeError("REDIS_PING_FAILED")
-
-    non_default_identity = False
-    acl_identity_observed = False
-    try:
-        who = client.execute_command("ACL", "WHOAMI")
-        if isinstance(who, bytes):
-            who = who.decode("utf-8", "replace")
-        acl_identity_observed = bool(str(who or "").strip())
-        non_default_identity = (
-            acl_identity_observed and str(who).strip().lower() != "default"
-        )
-    except Exception:  # ruff: ignore[blind-except]
-        # Managed providers may deny ACL inspection. Do not broaden permissions
-        # just for this probe; leave the fact unproven for operator evidence.
-        pass
-
-    try:
-        persistence = client.info("persistence") or {}
-        replication = client.info("replication") or {}
-    except Exception as exc:
-        raise RuntimeError("REDIS_INFO_UNAVAILABLE") from exc
-    aof_enabled = _int(persistence.get("aof_enabled")) == 1
-    loading = _int(persistence.get("loading")) == 1
-    role = str(replication.get("role") or "").lower()
-    if role == "master":
-        replication_observed = _int(replication.get("connected_slaves")) >= 1
-    elif role in {"slave", "replica"}:
-        replication_observed = (
-            str(replication.get("master_link_status") or "").lower() == "up"
-        )
-    else:
-        replication_observed = False
-
-    return {
-        "schemaVersion": 1,
-        "plane": plane,
-        "observedAt": _now(),
-        "transport": policy.manifest(),
-        "reachable": True,
-        "aclIdentityObserved": acl_identity_observed,
-        "nonDefaultIdentity": non_default_identity,
-        "aofPersistenceObserved": aof_enabled,
-        "loading": loading,
-        "replicationObserved": replication_observed,
-        "note": (
-            "Observations only; least-privilege ACL review, provider durability, backups and restore tests require separate operator evidence."
-        ),
-    }
-
-
-def main(argv: list[str] | None = None) -> int:
-    """Run."""
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument(
-        "--plane", required=True, choices=("rateLimit", "share", "contribution")
-    )
-    parser.add_argument(
-        "--url-env",
-        required=True,
-        help="Environment-variable name containing the Redis URL",
-    )
-    parser.add_argument("--output", type=Path)
-    args = parser.parse_args(argv)
-    try:
-        result = collect(plane=args.plane, url_env=args.url_env)
-    except RuntimeError as exc:
-        logger.warning(
-            json.dumps(
-                {
-                    "ok": False,
-                    "code": str(exc),
-                },
-                sort_keys=True,
-            ),
-        )
-        return 2
-    payload = json.dumps(result, indent=2, sort_keys=True) + "\n"
-    if args.output:
-        args.output.write_text(payload)
-    else:
-        sys.stdout.write(payload)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

security/python-runtime.cdx.json

@@ -1,721 +0,0 @@
-{
-  "bomFormat": "CycloneDX",
-  "components": [
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320"
-        }
-      ],
-      "name": "annotated-doc",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/annotated-doc@0.0.4",
-      "scope": "required",
-      "type": "library",
-      "version": "0.0.4"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53"
-        }
-      ],
-      "name": "annotated-types",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/annotated-types@0.7.0",
-      "scope": "required",
-      "type": "library",
-      "version": "0.7.0"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708"
-        }
-      ],
-      "name": "anyio",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/anyio@4.13.0",
-      "scope": "required",
-      "type": "library",
-      "version": "4.13.0"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "3c52e209ba0a4ad7aebe60436a4ab349c39e1e602e8c134221e546902ad25897"
-        }
-      ],
-      "name": "certifi",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/certifi@2026.5.20",
-      "scope": "required",
-      "type": "library",
-      "version": "2026.5.20"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "a2bf429bb3033c89fa4936ffb35d5cb471e3719e1f3c8a7c3fff0b8314305613"
-        }
-      ],
-      "name": "click",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/click@8.3.3",
-      "scope": "required",
-      "type": "library",
-      "version": "8.3.3"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "bfb91aa2d334c61cb35ba9a116fc123b3d3df31640b801cf57a7a78ec3f603b3"
-        }
-      ],
-      "name": "fastapi",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/fastapi@0.141.1",
-      "scope": "required",
-      "type": "library",
-      "version": "0.141.1"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258"
-        }
-      ],
-      "name": "filelock",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/filelock@3.29.0",
-      "scope": "required",
-      "type": "library",
-      "version": "3.29.0"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "11ef7bb35dab8a394fde6e608221d5cf3e8499401c249bebaeaad760a1a8dec2"
-        }
-      ],
-      "name": "fsspec",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/fsspec@2026.4.0",
-      "scope": "required",
-      "type": "library",
-      "version": "2026.4.0"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86"
-        }
-      ],
-      "name": "h11",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/h11@0.16.0",
-      "scope": "required",
-      "type": "library",
-      "version": "0.16.0"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "3531b1823a0e6d77d80f9ed15ca0e00f0d115094f8ac033d5cae88f4564cc949"
-        }
-      ],
-      "name": "hf-xet",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/hf-xet@1.5.0",
-      "scope": "required",
-      "type": "library",
-      "version": "1.5.0"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55"
-        }
-      ],
-      "name": "httpcore",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/httpcore@1.0.9",
-      "scope": "required",
-      "type": "library",
-      "version": "1.0.9"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad"
-        }
-      ],
-      "name": "httpx",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/httpx@0.28.1",
-      "scope": "required",
-      "type": "library",
-      "version": "0.28.1"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "64340de934b9ce37857ef85a82de72f5629e8a270f9119eabb12bf495eb53c22"
-        }
-      ],
-      "name": "huggingface-hub",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/huggingface-hub@1.16.1",
-      "scope": "required",
-      "type": "library",
-      "version": "1.16.1"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "466e48829084efe2548012b855df21540b96f2e20e51bd124c851536556a592c"
-        }
-      ],
-      "name": "idna",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/idna@3.17",
-      "scope": "required",
-      "type": "library",
-      "version": "3.17"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a"
-        }
-      ],
-      "name": "markdown-it-py",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/markdown-it-py@4.2.0",
-      "scope": "required",
-      "type": "library",
-      "version": "4.2.0"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"
-        }
-      ],
-      "name": "mdurl",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/mdurl@0.1.2",
-      "scope": "required",
-      "type": "library",
-      "version": "0.1.2"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484"
-        }
-      ],
-      "name": "packaging",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/packaging@25.0",
-      "scope": "required",
-      "type": "library",
-      "version": "25.0"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba"
-        }
-      ],
-      "name": "pydantic",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/pydantic@2.13.4",
-      "scope": "required",
-      "type": "library",
-      "version": "2.13.4"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "f9fa868638bf362d3d138ea55829cefb3d5f4b0d7f142234382a15e2485dbec4"
-        }
-      ],
-      "name": "pydantic-core",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/pydantic-core@2.46.4",
-      "scope": "required",
-      "type": "library",
-      "version": "2.46.4"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176"
-        }
-      ],
-      "name": "pygments",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/pygments@2.20.0",
-      "scope": "required",
-      "type": "library",
-      "version": "2.20.0"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d"
-        }
-      ],
-      "name": "pyyaml",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/pyyaml@6.0.3",
-      "scope": "required",
-      "type": "library",
-      "version": "6.0.3"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "a4fe1aac3d3b3cc791d4b3d5931c5a956045dc951ee74d1c913ee3ac4d2ee9fb"
-        }
-      ],
-      "name": "redis",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/redis@8.1.0",
-      "scope": "required",
-      "type": "library",
-      "version": "8.1.0"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb"
-        }
-      ],
-      "name": "rich",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/rich@15.0.0",
-      "scope": "required",
-      "type": "library",
-      "version": "15.0.0"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686"
-        }
-      ],
-      "name": "shellingham",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/shellingham@1.5.4",
-      "scope": "required",
-      "type": "library",
-      "version": "1.5.4"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "a86dd39d14bb45f85a3d18525215a9ef0cfd1f192ac793220e72598c90335f0c"
-        }
-      ],
-      "name": "starlette",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/starlette@1.6.0",
-      "scope": "required",
-      "type": "library",
-      "version": "1.6.0"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf"
-        }
-      ],
-      "name": "tqdm",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/tqdm@4.67.3",
-      "scope": "required",
-      "type": "library",
-      "version": "4.67.3"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "e70549ec5a403ca8a0bf0802ddd9f3c6ff7a14ccbb859b01b697baa943636f33"
-        }
-      ],
-      "name": "typer",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/typer@0.26.3",
-      "scope": "required",
-      "type": "library",
-      "version": "0.26.3"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8"
-        }
-      ],
-      "name": "typing-extensions",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/typing-extensions@4.16.0",
-      "scope": "required",
-      "type": "library",
-      "version": "4.16.0"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7"
-        }
-      ],
-      "name": "typing-inspection",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/typing-inspection@0.4.2",
-      "scope": "required",
-      "type": "library",
-      "version": "0.4.2"
-    },
-    {
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "48097851328b87ec36117d3d575234519eb58c2b22d79666e9bbc6c49a761dad"
-        }
-      ],
-      "name": "uvicorn",
-      "properties": [
-        {
-          "name": "scikitplot:lock-target",
-          "value": "CPython 3.11 / linux/amd64"
-        },
-        {
-          "name": "scikitplot:artifact-policy",
-          "value": "binary-wheel-only"
-        }
-      ],
-      "purl": "pkg:pypi/uvicorn@0.48.0",
-      "scope": "required",
-      "type": "library",
-      "version": "0.48.0"
-    }
-  ],
-  "metadata": {
-    "component": {
-      "bom-ref": "pkg:generic/scikit-plots-ai-proxy@6.8.0",
-      "name": "scikit-plots-ai-proxy",
-      "type": "application",
-      "version": "6.8.0"
-    },
-    "properties": [
-      {
-        "name": "scikitplot:scope",
-        "value": "python-runtime-lock-only"
-      },
-      {
-        "name": "scikitplot:target",
-        "value": "CPython 3.11 / linux/amd64"
-      },
-      {
-        "name": "scikitplot:note",
-        "value": "A full image SBOM must be generated from the built container before release."
-      }
-    ],
-    "timestamp": "2026-08-30T00:00:00Z"
-  },
-  "serialNumber": "urn:uuid:d714f9a3-0034-5843-b870-51885c937bc8",
-  "specVersion": "1.6",
-  "version": 1
-}

security/release-evidence.example.json

@@ -1,112 +0,0 @@
-{
-  "artifacts": {
-    "dependencyScan": {
-      "path": "pip-audit.json",
-      "sha256": "REPLACE_WITH_64_HEX",
-      "status": "pass",
-      "subject": "sha256:REPLACE_WITH_64_HEX",
-      "tool": {
-        "name": "pip-audit",
-        "version": "REPLACE"
-      }
-    },
-    "imageSbom": {
-      "path": "image.cdx.json",
-      "sha256": "REPLACE_WITH_64_HEX",
-      "status": "pass",
-      "subject": "sha256:REPLACE_WITH_64_HEX",
-      "tool": {
-        "name": "syft",
-        "version": "REPLACE"
-      }
-    },
-    "imageScan": {
-      "path": "image-scan.json",
-      "sha256": "REPLACE_WITH_64_HEX",
-      "status": "pass",
-      "subject": "sha256:REPLACE_WITH_64_HEX",
-      "tool": {
-        "name": "REPLACE",
-        "version": "REPLACE"
-      }
-    },
-    "provenance": {
-      "path": "provenance.json",
-      "predicateType": "https://slsa.dev/provenance/v1",
-      "sha256": "REPLACE_WITH_64_HEX",
-      "signatureVerified": true,
-      "status": "pass",
-      "subject": "sha256:REPLACE_WITH_64_HEX",
-      "tool": {
-        "name": "REPLACE",
-        "version": "REPLACE"
-      }
-    },
-    "signatureVerification": {
-      "path": "signature-verification.json",
-      "sha256": "REPLACE_WITH_64_HEX",
-      "status": "pass",
-      "subject": "sha256:REPLACE_WITH_64_HEX",
-      "tool": {
-        "name": "REPLACE",
-        "version": "REPLACE"
-      }
-    }
-  },
-  "image": {
-    "digest": "sha256:REPLACE_WITH_64_HEX",
-    "platform": "linux/amd64"
-  },
-  "logging": {
-    "apmBodyCapture": false,
-    "authorizationHeaderLogging": false,
-    "capabilityHeaderLogging": false,
-    "queryStringLogging": false,
-    "requestBodyLogging": false,
-    "reviewedAt": "2099-01-01T00:00:00Z",
-    "thirdPartyTelemetryExport": false,
-    "wafBodyCapture": false
-  },
-  "redis": {
-    "contribution": {
-      "backupRestoreTestedAt": "2098-12-15T00:00:00Z",
-      "leastPrivilegeReviewed": true,
-      "nonDefaultIdentity": true,
-      "persistenceVerified": true,
-      "replicationVerified": true,
-      "tlsVerified": true
-    },
-    "rateLimit": {
-      "backupRestoreTestedAt": null,
-      "leastPrivilegeReviewed": true,
-      "nonDefaultIdentity": true,
-      "persistenceVerified": false,
-      "replicationVerified": false,
-      "tlsVerified": true
-    },
-    "share": {
-      "backupRestoreTestedAt": "2098-12-15T00:00:00Z",
-      "leastPrivilegeReviewed": true,
-      "nonDefaultIdentity": true,
-      "persistenceVerified": true,
-      "replicationVerified": true,
-      "tlsVerified": true
-    }
-  },
-  "release": {
-    "expiresAt": "2099-01-02T00:00:00Z",
-    "generatedAt": "2099-01-01T00:00:00Z",
-    "proxyVersion": "7.0.0",
-    "releaseId": "example-only-not-production",
-    "targetPlatform": "linux/amd64"
-  },
-  "riskExceptions": [],
-  "schemaVersion": 1,
-  "source": {
-    "baseImageIndexDigest": "sha256:REPLACE_WITH_64_HEX",
-    "baseImageManifestDigest": "sha256:REPLACE_WITH_64_HEX",
-    "pythonSbomSha256": "REPLACE_WITH_64_HEX",
-    "requirementsLockSha256": "REPLACE_WITH_64_HEX",
-    "runtimeSourceSha256": "REPLACE_WITH_64_HEX"
-  }
-}

security/release_evidence_policy.toml

@@ -1,34 +0,0 @@
-schema_version = 1
-evidence_schema_version = 1
-target_platform = "linux/amd64"
-max_age_hours = 72
-max_clock_skew_minutes = 10
-max_manifest_bytes = 262144
-max_evidence_file_bytes = 52428800
-minimum_cyclonedx_spec_version = "1.6"
-require_dependency_scan = true
-require_full_image_sbom = true
-require_image_vulnerability_scan = true
-require_slsa_provenance = true
-require_signature_verification = true
-require_log_privacy_attestation = true
-forbid_unexpired_risk_exceptions = true
-
-[redis]
-require_tls = true
-require_non_default_identity = true
-require_least_privilege_review = true
-share_require_persistence = true
-share_require_replication = true
-contribution_require_persistence = true
-contribution_require_replication = true
-backup_restore_max_age_days = 90
-
-[logging]
-request_body_logging = false
-authorization_header_logging = false
-capability_header_logging = false
-query_string_logging = false
-waf_body_capture = false
-apm_body_capture = false
-third_party_telemetry_export = false

security/release_subjects.py

@@ -1,43 +0,0 @@
-#!/usr/bin/env python3
-"""Print canonical non-secret subjects that production release evidence must bind."""
-
-from __future__ import annotations
-
-import hashlib
-import json
-import logging
-import sys
-from pathlib import Path
-
-HERE = Path(__file__).resolve().parent
-ROOT = HERE.parent
-if str(HERE) not in sys.path:
-    sys.path.insert(0, str(HERE))
-if str(ROOT) not in sys.path:
-    sys.path.insert(0, str(ROOT))
-
-import verify_release_evidence  # noqa: E402
-from _utils._shared_logic import PROXY_VERSION  # noqa: E402
-
-logger = logging.getLogger(__name__)
-
-
-def subjects() -> dict[str, object]:  # ruff: ignore[undocumented-public-function]
-    supply = verify_release_evidence.SUPPLY
-    return {
-        "schema_version": 1,
-        "proxy_version": PROXY_VERSION,
-        "target_platform": verify_release_evidence.POLICY["target_platform"],
-        "requirements_lock_sha256": (
-            hashlib.sha256((ROOT / supply["lock_file"]).read_bytes()).hexdigest()
-        ),
-        "python_sbom_sha256": (
-            hashlib.sha256((ROOT / supply["sbom_file"]).read_bytes()).hexdigest()
-        ),
-        "runtime_source_sha256": verify_release_evidence._runtime_source_sha256(),
-        "base_image_index_digest": supply["base_image"]["index_digest"],
-    }
-
-
-if __name__ == "__main__":
-    sys.stdout.write(json.dumps(subjects(), sort_keys=True) + "\n")

security/supply_chain_policy.toml

@@ -1,38 +0,0 @@
-schema_version = 1
-reviewed_at = "2026-08-30"
-target_python = "3.11.16"
-target_platform = "linux/amd64"
-lock_file = "requirements.lock"
-sbom_file = "security/python-runtime.cdx.json"
-require_hashes = true
-binary_only = true
-require_non_root = true
-require_read_only_reference = true
-require_redis_tls_in_strict = true
-
-[base_image]
-repository = "python"
-tag = "3.11.16-slim-bookworm"
-index_digest = "sha256:0bee7276f83efd4a1ee05bbbf4281d95ed28e079220a9457f25a93e3f1e3c31b"
-# This is an immutable multi-platform index. CI must resolve linux/amd64 from
-# this exact index and record the resulting manifest digest in release evidence.
-
-[advisory_floors]
-# Current explicit floors discovered during the B38 review.  These are
-# ratchets, not a substitute for a fresh advisory database scan.
-click = "8.3.3"
-starlette = "1.6.0"
-
-[release_gates]
-python_advisory_scan = true
-container_vulnerability_scan = true
-container_sbom = true
-provenance_attestation = true
-
-[release_evidence]
-policy_file = "security/release_evidence_policy.toml"
-example_file = "security/release-evidence.example.json"
-verifier_file = "security/verify_release_evidence.py"
-combined_gate_file = "security/verify_release_gate.py"
-redis_probe_file = "security/probe_redis_authority.py"
-subject_printer_file = "security/release_subjects.py"

security/verify_release_evidence.py

@@ -1,603 +0,0 @@
-#!/usr/bin/env python3
-"""
-Verify production release evidence without externalizing secrets.
-
-This verifier binds time-sensitive CI/deployment evidence to the exact B39
-source lock, Python SBOM, immutable base-image policy, target platform and final
-OCI image digest.  It deliberately does not contact registries, scanners,
-Redis, or telemetry services; evidence collection is a separate explicit CI or
-operator action.
-"""
-
-from __future__ import annotations
-
-import argparse
-import hashlib
-import json
-import logging
-import re
-import sys
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-from typing import Any
-
-import tomllib
-
-logger = logging.getLogger(__name__)
-
-HERE = Path(__file__).resolve().parent
-ROOT = HERE.parent
-POLICY = tomllib.loads((HERE / "release_evidence_policy.toml").read_text())
-SUPPLY = tomllib.loads((HERE / "supply_chain_policy.toml").read_text())
-HEX64 = re.compile(r"^[0-9a-f]{64}$")
-DIGEST = re.compile(r"^sha256:([0-9a-f]{64})$")
-SLSA_PREDICATE = "https://slsa.dev/provenance/v1"
-RELEASE_ID = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{2,127}$")
-RUNTIME_SOURCE_FILES = (
-    "Dockerfile",
-    ".dockerignore",
-    "requirements.lock",
-    "app.py",
-    "deduplicate_dataset.py",
-)
-PROXY_VERSION_RE = re.compile(
-    r'^PROXY_VERSION: str = "([0-9]+\.[0-9]+\.[0-9]+)"$', re.MULTILINE
-)
-CYCLONEDX_VERSION_RE = re.compile(r"^[0-9]+\.[0-9]+$")
-FORBIDDEN_SECRET_KEYS = {
-    "authorization",
-    "cookie",
-    "password",
-    "passwd",
-    "secret",
-    "token",
-    "apikey",
-    "api_key",
-    "privatekey",
-    "private_key",
-    "redisurl",
-    "redis_url",
-    "connectionstring",
-    "connection_string",
-    "hostname",
-    "username",
-    "host",
-}
-SECRET_VALUE_PATTERNS = (
-    re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----"),
-    re.compile(r"(?i)\bbearer\s+[A-Za-z0-9._~+/-]{12,}"),
-    re.compile(r"(?i)\b(?:redis|rediss|https?)://[^\s/@:]+:[^\s/@]+@"),
-)
-
-
-class EvidenceError(RuntimeError):  # ruff: ignore[undocumented-public-class]
-    pass
-
-
-def _fail(code: str) -> None:
-    raise EvidenceError(code)
-
-
-def _runtime_source_sha256(root: Path = ROOT) -> str:
-    """Hash exact application/container inputs with stable names and lengths."""
-    paths = [root / name for name in RUNTIME_SOURCE_FILES]
-    utils_root = root / "_utils"
-    if not utils_root.is_dir() or utils_root.is_symlink():
-        _fail("RUNTIME_SOURCE_UTILS_INVALID")
-    paths.extend(
-        sorted(
-            path
-            for path in utils_root.rglob("*")
-            if path.is_file()
-            and "__pycache__" not in path.parts
-            and path.suffix not in {".pyc", ".pyo"}
-        )
-    )
-    h = hashlib.sha256()
-    for path in paths:
-        if not path.is_file() or path.is_symlink():
-            _fail("RUNTIME_SOURCE_FILE_INVALID")
-        rel = path.relative_to(root).as_posix().encode("utf-8")
-        data = path.read_bytes()
-        h.update(len(rel).to_bytes(4, "big"))
-        h.update(rel)
-        h.update(len(data).to_bytes(8, "big"))
-        h.update(data)
-    return h.hexdigest()
-
-
-def _sha256(path: Path) -> str:
-    h = hashlib.sha256()
-    with path.open("rb") as handle:
-        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
-            h.update(chunk)
-    return h.hexdigest()
-
-
-def _parse_time(value: Any, code: str) -> datetime:
-    if not isinstance(value, str) or not value.endswith("Z"):
-        _fail(code)
-    try:
-        dt = datetime.fromisoformat(value[:-1] + "+00:00")
-    except ValueError:
-        _fail(code)
-    if dt.tzinfo is None:
-        _fail(code)
-    return dt.astimezone(timezone.utc)
-
-
-def _hex(value: Any, code: str) -> str:
-    if not isinstance(value, str) or HEX64.fullmatch(value) is None:
-        _fail(code)
-    return value
-
-
-def _digest(value: Any, code: str) -> str:
-    if not isinstance(value, str) or DIGEST.fullmatch(value) is None:
-        _fail(code)
-    return value
-
-
-def _mapping(value: Any, code: str) -> dict[str, Any]:
-    if not isinstance(value, dict):
-        _fail(code)
-    return value
-
-
-def _exact_keys(value: dict[str, Any], expected: set[str], code: str) -> None:
-    if set(value) != expected:
-        _fail(code)
-
-
-def _tool(value: Any, code: str) -> None:
-    tool = _mapping(value, code)
-    _exact_keys(tool, {"name", "version"}, code)
-    for field in ("name", "version"):
-        item = tool.get(field)
-        if (
-            not isinstance(item, str)
-            or not item.strip()
-            or len(item) > 128  # ruff: ignore[magic-value-comparison]
-            or any(ord(ch) < 32 for ch in item)  # ruff: ignore[magic-value-comparison]
-        ):
-            _fail(code)
-
-
-def _current_proxy_version() -> str:
-    shared = ROOT / "_utils" / "_shared_logic.py"
-    try:
-        text = shared.read_text(encoding="utf-8")
-    except OSError:
-        _fail("PROXY_VERSION_SOURCE_UNREADABLE")
-    match = PROXY_VERSION_RE.search(text)
-    if match is None:
-        _fail("PROXY_VERSION_SOURCE_INVALID")
-    return match.group(1)
-
-
-def _version_tuple(value: Any, code: str) -> tuple[int, int]:
-    if not isinstance(value, str) or CYCLONEDX_VERSION_RE.fullmatch(value) is None:
-        _fail(code)
-    major, minor = value.split(".", 1)
-    return int(major), int(minor)
-
-
-def _bool(value: Any, expected: bool, code: str) -> None:
-    if value is not expected:
-        _fail(code)
-
-
-def _walk_values(value: Any) -> None:
-    if isinstance(value, dict):
-        for key, child in value.items():
-            if str(key).replace("-", "_").lower() in FORBIDDEN_SECRET_KEYS:
-                _fail("EVIDENCE_SECRET_FIELD_FORBIDDEN")
-            _walk_values(child)
-    elif isinstance(value, list):
-        for child in value:
-            _walk_values(child)
-    elif isinstance(value, str):
-        if "\x00" in value or len(value) > 4096:  # ruff: ignore[magic-value-comparison]
-            _fail("EVIDENCE_STRING_UNSAFE")
-        for pattern in SECRET_VALUE_PATTERNS:
-            if pattern.search(value):
-                _fail("EVIDENCE_SECRET_LIKE_VALUE_FORBIDDEN")
-
-
-def _artifact_path(evidence_dir: Path, raw: Any) -> Path:
-    if not isinstance(raw, str) or not raw or raw.startswith(("/", "~")) or "\\" in raw:
-        _fail("ARTIFACT_PATH_INVALID")
-    rel = Path(raw)
-    if rel.is_absolute() or any(part in {"", ".", ".."} for part in rel.parts):
-        _fail("ARTIFACT_PATH_TRAVERSAL")
-    root = evidence_dir.resolve()
-    candidate = root / rel
-    current = root
-    for part in rel.parts:
-        current = current / part
-        if current.is_symlink():
-            _fail("ARTIFACT_SYMLINK_FORBIDDEN")
-    path = candidate.resolve()
-    if root not in path.parents:
-        _fail("ARTIFACT_PATH_ESCAPE")
-    if not path.is_file():
-        _fail("ARTIFACT_FILE_MISSING")
-    if path.stat().st_size > int(POLICY["max_evidence_file_bytes"]):
-        _fail("ARTIFACT_FILE_TOO_LARGE")
-    return path
-
-
-def _verify_artifact(
-    evidence_dir: Path,
-    obj: Any,
-    name: str,
-    *,
-    subject: str,
-    extra_keys: set[str] | None = None,
-) -> Path:
-    item = _mapping(obj, f"{name.upper()}_INVALID")
-    expected_keys = {"path", "sha256", "status", "subject", "tool"} | (
-        extra_keys or set()
-    )
-    _exact_keys(item, expected_keys, f"{name.upper()}_SCHEMA_INVALID")
-    _tool(item.get("tool"), f"{name.upper()}_TOOL_INVALID")
-    if item.get("status") != "pass":
-        _fail(f"{name.upper()}_NOT_PASS")
-    if item.get("subject") != subject:
-        _fail(f"{name.upper()}_SUBJECT_MISMATCH")
-    path = _artifact_path(evidence_dir, item.get("path"))
-    expected = _hex(item.get("sha256"), f"{name.upper()}_SHA256_INVALID")
-    if _sha256(path) != expected:
-        _fail(f"{name.upper()}_HASH_MISMATCH")
-    return path
-
-
-def _verify_provenance(
-    path: Path, image_digest: str, base_manifest_digest: str, item: dict[str, Any]
-) -> None:
-    if item.get("predicateType") != SLSA_PREDICATE:
-        _fail("PROVENANCE_PREDICATE_UNSUPPORTED")
-    _bool(item.get("signatureVerified"), True, "PROVENANCE_SIGNATURE_NOT_VERIFIED")
-    try:
-        statement = json.loads(path.read_text())
-    except Exception as exc:
-        raise EvidenceError("PROVENANCE_JSON_INVALID") from exc
-    if (
-        not isinstance(statement, dict)
-        or statement.get("_type") != "https://in-toto.io/Statement/v1"
-    ):
-        _fail("PROVENANCE_STATEMENT_INVALID")
-    if statement.get("predicateType") != SLSA_PREDICATE:
-        _fail("PROVENANCE_STATEMENT_PREDICATE_MISMATCH")
-    wanted = image_digest.split(":", 1)[1]
-    subjects = statement.get("subject")
-    if not isinstance(subjects, list) or not any(
-        isinstance(s, dict)
-        and isinstance(s.get("digest"), dict)
-        and s["digest"].get("sha256") == wanted
-        for s in subjects
-    ):
-        _fail("PROVENANCE_SUBJECT_IMAGE_MISMATCH")
-    base_wanted = base_manifest_digest.split(":", 1)[1]
-    predicate = statement.get("predicate")
-    definition = (
-        predicate.get("buildDefinition") if isinstance(predicate, dict) else None
-    )
-    dependencies = (
-        definition.get("resolvedDependencies") if isinstance(definition, dict) else None
-    )
-    if not isinstance(dependencies, list) or not any(
-        isinstance(dep, dict)
-        and isinstance(dep.get("digest"), dict)
-        and dep["digest"].get("sha256") == base_wanted
-        for dep in dependencies
-    ):
-        _fail("PROVENANCE_BASE_MANIFEST_UNBOUND")
-
-
-def _verify_redis(doc: dict[str, Any], now: datetime) -> None:
-    redis_policy = POLICY["redis"]
-    planes = _mapping(doc.get("redis"), "REDIS_EVIDENCE_MISSING")
-    _exact_keys(planes, {"rateLimit", "share", "contribution"}, "REDIS_SCHEMA_INVALID")
-    for name in ("rateLimit", "share", "contribution"):
-        item = _mapping(planes.get(name), f"REDIS_{name.upper()}_MISSING")
-        _exact_keys(
-            item,
-            {
-                "tlsVerified",
-                "nonDefaultIdentity",
-                "leastPrivilegeReviewed",
-                "persistenceVerified",
-                "replicationVerified",
-                "backupRestoreTestedAt",
-            },
-            f"REDIS_{name.upper()}_SCHEMA_INVALID",
-        )
-        if redis_policy["require_tls"]:
-            _bool(item.get("tlsVerified"), True, f"REDIS_{name.upper()}_TLS_UNVERIFIED")
-        if redis_policy["require_non_default_identity"]:
-            _bool(
-                item.get("nonDefaultIdentity"),
-                True,
-                f"REDIS_{name.upper()}_DEFAULT_IDENTITY",
-            )
-        if redis_policy["require_least_privilege_review"]:
-            _bool(
-                item.get("leastPrivilegeReviewed"),
-                True,
-                f"REDIS_{name.upper()}_ACL_UNREVIEWED",
-            )
-    for name, prefix in (("share", "share"), ("contribution", "contribution")):
-        item = planes[name]
-        if redis_policy[f"{prefix}_require_persistence"]:
-            _bool(
-                item.get("persistenceVerified"),
-                True,
-                f"REDIS_{name.upper()}_PERSISTENCE_UNVERIFIED",
-            )
-        if redis_policy[f"{prefix}_require_replication"]:
-            _bool(
-                item.get("replicationVerified"),
-                True,
-                f"REDIS_{name.upper()}_REPLICATION_UNVERIFIED",
-            )
-        tested = _parse_time(
-            item.get("backupRestoreTestedAt"),
-            f"REDIS_{name.upper()}_BACKUP_TIME_INVALID",
-        )
-        if tested > now + timedelta(minutes=int(POLICY["max_clock_skew_minutes"])):
-            _fail(f"REDIS_{name.upper()}_BACKUP_TIME_FUTURE")
-        if now - tested > timedelta(
-            days=int(redis_policy["backup_restore_max_age_days"])
-        ):
-            _fail(f"REDIS_{name.upper()}_BACKUP_RESTORE_STALE")
-
-
-def _verify_logging(doc: dict[str, Any], now: datetime) -> None:
-    logging = _mapping(doc.get("logging"), "LOGGING_EVIDENCE_MISSING")
-    _exact_keys(
-        logging,
-        {
-            "requestBodyLogging",
-            "authorizationHeaderLogging",
-            "capabilityHeaderLogging",
-            "queryStringLogging",
-            "wafBodyCapture",
-            "apmBodyCapture",
-            "thirdPartyTelemetryExport",
-            "reviewedAt",
-        },
-        "LOGGING_SCHEMA_INVALID",
-    )
-    mapping = {
-        "requestBodyLogging": "request_body_logging",
-        "authorizationHeaderLogging": "authorization_header_logging",
-        "capabilityHeaderLogging": "capability_header_logging",
-        "queryStringLogging": "query_string_logging",
-        "wafBodyCapture": "waf_body_capture",
-        "apmBodyCapture": "apm_body_capture",
-        "thirdPartyTelemetryExport": "third_party_telemetry_export",
-    }
-    for evidence_name, policy_name in mapping.items():
-        _bool(
-            logging.get(evidence_name),
-            bool(POLICY["logging"][policy_name]),
-            f"LOGGING_{evidence_name.upper()}_POLICY_MISMATCH",
-        )
-    reviewed = _parse_time(logging.get("reviewedAt"), "LOGGING_REVIEW_TIME_INVALID")
-    if reviewed > now + timedelta(minutes=int(POLICY["max_clock_skew_minutes"])):
-        _fail("LOGGING_REVIEW_TIME_FUTURE")
-    if now - reviewed > timedelta(hours=int(POLICY["max_age_hours"])):
-        _fail("LOGGING_REVIEW_STALE")
-
-
-def verify(  # ruff: ignore[too-many-branches, undocumented-public-function]
-    evidence_file: Path,
-    *,
-    now: datetime | None = None,
-) -> dict[str, Any]:
-    if evidence_file.is_symlink():
-        _fail("EVIDENCE_SYMLINK_FORBIDDEN")
-    if not evidence_file.exists() or not evidence_file.is_file():
-        _fail("EVIDENCE_FILE_MISSING")
-    if evidence_file.stat().st_size > int(POLICY["max_manifest_bytes"]):
-        _fail("EVIDENCE_MANIFEST_TOO_LARGE")
-    evidence_file = evidence_file.resolve()
-    try:
-        doc = json.loads(evidence_file.read_text(encoding="utf-8"))
-    except Exception as exc:
-        raise EvidenceError("EVIDENCE_JSON_INVALID") from exc
-    doc = _mapping(doc, "EVIDENCE_ROOT_INVALID")
-    _walk_values(doc)
-    _exact_keys(
-        doc,
-        {
-            "schemaVersion",
-            "release",
-            "source",
-            "image",
-            "artifacts",
-            "redis",
-            "logging",
-            "riskExceptions",
-        },
-        "EVIDENCE_SCHEMA_FIELDS_INVALID",
-    )
-    if doc.get("schemaVersion") != POLICY["evidence_schema_version"]:
-        _fail("EVIDENCE_SCHEMA_UNSUPPORTED")
-    release = _mapping(doc.get("release"), "RELEASE_BLOCK_MISSING")
-    _exact_keys(
-        release,
-        {"releaseId", "generatedAt", "expiresAt", "proxyVersion", "targetPlatform"},
-        "RELEASE_SCHEMA_INVALID",
-    )
-    if (
-        not isinstance(release.get("releaseId"), str)
-        or RELEASE_ID.fullmatch(release["releaseId"]) is None
-    ):
-        _fail("RELEASE_ID_INVALID")
-    if release.get("targetPlatform") != POLICY["target_platform"]:
-        _fail("RELEASE_PLATFORM_MISMATCH")
-    if release.get("proxyVersion") != _current_proxy_version():
-        _fail("RELEASE_PROXY_VERSION_MISMATCH")
-    current = (now or datetime.now(timezone.utc)).astimezone(timezone.utc)
-    generated = _parse_time(release.get("generatedAt"), "RELEASE_GENERATED_AT_INVALID")
-    expires = _parse_time(release.get("expiresAt"), "RELEASE_EXPIRES_AT_INVALID")
-    skew = timedelta(minutes=int(POLICY["max_clock_skew_minutes"]))
-    if generated > current + skew:
-        _fail("RELEASE_EVIDENCE_FROM_FUTURE")
-    if current - generated > timedelta(hours=int(POLICY["max_age_hours"])):
-        _fail("RELEASE_EVIDENCE_STALE")
-    if expires <= current or expires <= generated:
-        _fail("RELEASE_EVIDENCE_EXPIRED")
-    if expires - generated > timedelta(hours=int(POLICY["max_age_hours"])):
-        _fail("RELEASE_EVIDENCE_EXPIRY_TOO_LONG")
-
-    source = _mapping(doc.get("source"), "SOURCE_BLOCK_MISSING")
-    _exact_keys(
-        source,
-        {
-            "requirementsLockSha256",
-            "pythonSbomSha256",
-            "runtimeSourceSha256",
-            "baseImageIndexDigest",
-            "baseImageManifestDigest",
-        },
-        "SOURCE_SCHEMA_INVALID",
-    )
-    lock_sha = _hex(source.get("requirementsLockSha256"), "LOCK_SHA256_INVALID")
-    sbom_sha = _hex(source.get("pythonSbomSha256"), "PYTHON_SBOM_SHA256_INVALID")
-    if lock_sha != _sha256(ROOT / SUPPLY["lock_file"]):
-        _fail("LOCK_EVIDENCE_SOURCE_MISMATCH")
-    if sbom_sha != _sha256(ROOT / SUPPLY["sbom_file"]):
-        _fail("PYTHON_SBOM_EVIDENCE_SOURCE_MISMATCH")
-    runtime_sha = _hex(
-        source.get("runtimeSourceSha256"), "RUNTIME_SOURCE_SHA256_INVALID"
-    )
-    if runtime_sha != _runtime_source_sha256():
-        _fail("RUNTIME_SOURCE_EVIDENCE_MISMATCH")
-    if source.get("baseImageIndexDigest") != SUPPLY["base_image"]["index_digest"]:
-        _fail("BASE_IMAGE_INDEX_MISMATCH")
-    base_manifest_digest = _digest(
-        source.get("baseImageManifestDigest"), "BASE_IMAGE_MANIFEST_DIGEST_INVALID"
-    )
-    if base_manifest_digest == source.get("baseImageIndexDigest"):
-        _fail("BASE_IMAGE_MANIFEST_UNRESOLVED")
-
-    image = _mapping(doc.get("image"), "IMAGE_BLOCK_MISSING")
-    _exact_keys(image, {"digest", "platform"}, "IMAGE_SCHEMA_INVALID")
-    image_digest = _digest(image.get("digest"), "IMAGE_DIGEST_INVALID")
-    if image.get("platform") != POLICY["target_platform"]:
-        _fail("IMAGE_PLATFORM_MISMATCH")
-
-    artifacts = _mapping(doc.get("artifacts"), "ARTIFACTS_BLOCK_MISSING")
-    _exact_keys(
-        artifacts,
-        {
-            "dependencyScan",
-            "imageScan",
-            "imageSbom",
-            "provenance",
-            "signatureVerification",
-        },
-        "ARTIFACTS_SCHEMA_INVALID",
-    )
-    if POLICY["require_dependency_scan"]:
-        _verify_artifact(
-            evidence_file.parent,
-            artifacts.get("dependencyScan"),
-            "dependency_scan",
-            subject="sha256:" + lock_sha,
-        )
-    if POLICY["require_image_vulnerability_scan"]:
-        _verify_artifact(
-            evidence_file.parent,
-            artifacts.get("imageScan"),
-            "image_scan",
-            subject=image_digest,
-        )
-    if POLICY["require_full_image_sbom"]:
-        sbom_path = _verify_artifact(
-            evidence_file.parent,
-            artifacts.get("imageSbom"),
-            "image_sbom",
-            subject=image_digest,
-        )
-        try:
-            image_sbom = json.loads(sbom_path.read_text())
-        except Exception as exc:
-            raise EvidenceError("IMAGE_SBOM_JSON_INVALID") from exc
-        if (
-            not isinstance(image_sbom, dict)
-            or image_sbom.get("bomFormat") != "CycloneDX"
-        ):
-            _fail("IMAGE_SBOM_NOT_CYCLONEDX")
-        if _version_tuple(
-            image_sbom.get("specVersion"), "IMAGE_SBOM_SPEC_VERSION_INVALID"
-        ) < _version_tuple(
-            POLICY["minimum_cyclonedx_spec_version"], "POLICY_CYCLONEDX_VERSION_INVALID"
-        ):
-            _fail("IMAGE_SBOM_SPEC_VERSION_TOO_OLD")
-    if POLICY["require_slsa_provenance"]:
-        provenance_item = _mapping(artifacts.get("provenance"), "PROVENANCE_INVALID")
-        provenance_path = _verify_artifact(
-            evidence_file.parent,
-            provenance_item,
-            "provenance",
-            subject=image_digest,
-            extra_keys={"predicateType", "signatureVerified"},
-        )
-        _verify_provenance(
-            provenance_path, image_digest, base_manifest_digest, provenance_item
-        )
-    if POLICY["require_signature_verification"]:
-        _verify_artifact(
-            evidence_file.parent,
-            artifacts.get("signatureVerification"),
-            "signature_verification",
-            subject=image_digest,
-        )
-
-    _verify_redis(doc, current)
-    if POLICY["require_log_privacy_attestation"]:
-        _verify_logging(doc, current)
-    exceptions = doc.get("riskExceptions")
-    if not isinstance(exceptions, list):
-        _fail("RISK_EXCEPTIONS_INVALID")
-    if POLICY["forbid_unexpired_risk_exceptions"] and exceptions:
-        _fail("RISK_EXCEPTIONS_FORBIDDEN")
-
-    return {
-        "ok": True,
-        "schema_version": doc["schemaVersion"],
-        "release_id": release["releaseId"],
-        "proxy_version": release["proxyVersion"],
-        "target_platform": release["targetPlatform"],
-        "image_digest": image_digest,
-        "runtime_source_sha256": runtime_sha,
-        "evidence_sha256": _sha256(evidence_file),
-        "evidence_expires_at": release["expiresAt"],
-        "redis_planes": ["rateLimit", "share", "contribution"],
-        "logging_privacy": "verified",
-    }
-
-
-def main(  # ruff: ignore[undocumented-public-function]
-    argv: list[str] | None = None,
-) -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("evidence", type=Path, help="Path to release-evidence.json")
-    args = parser.parse_args(argv)
-    try:
-        result = verify(args.evidence)
-    except EvidenceError as exc:
-        sys.stderr.write(
-            json.dumps({"ok": False, "code": str(exc)}, sort_keys=True) + "\n"
-        )
-        return 2
-    sys.stdout.write(json.dumps(result, sort_keys=True) + "\n")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

security/verify_release_gate.py

@@ -1,53 +0,0 @@
-#!/usr/bin/env python3
-"""One fail-closed command for source policy plus production evidence binding."""
-
-from __future__ import annotations
-
-import argparse
-import json
-import logging
-import sys
-from pathlib import Path
-
-HERE = Path(__file__).resolve().parent
-if str(HERE) not in sys.path:
-    sys.path.insert(0, str(HERE))
-
-import verify_release_evidence  # noqa: E402
-import verify_supply_chain  # noqa: E402
-
-logger = logging.getLogger(__name__)
-
-
-def verify(  # ruff: ignore[undocumented-public-function]
-    evidence: Path,
-) -> dict[str, object]:
-    source = verify_supply_chain.verify()
-    release = verify_release_evidence.verify(evidence)
-    return {
-        "ok": True,
-        "source_policy": source,
-        "release_evidence": release,
-    }
-
-
-def main(  # ruff: ignore[undocumented-public-function]
-    argv: list[str] | None = None,
-) -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("evidence", type=Path)
-    args = parser.parse_args(argv)
-    try:
-        result = verify(args.evidence)
-    except Exception as exc:  # ruff: ignore[blind-except]
-        code = getattr(exc, "args", ["RELEASE_GATE_FAILED"])[0] or "RELEASE_GATE_FAILED"
-        sys.stderr.write(
-            json.dumps({"ok": False, "code": str(code)}, sort_keys=True) + "\n"
-        )
-        return 2
-    sys.stdout.write(json.dumps(result, sort_keys=True) + "\n")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

security/verify_supply_chain.py

@@ -1,223 +0,0 @@
-#!/usr/bin/env python3
-"""
-Offline structural verifier for the B38/B39 supply-chain policy.
-
-This verifier proves committed-file consistency and downgrade ratchets.  It
-cannot prove that today's advisory database has no newer finding; networked
-release scanning remains a separate mandatory gate.
-"""
-
-from __future__ import annotations
-
-import hashlib
-import json
-import logging
-import re
-import sys
-from pathlib import Path
-
-import tomllib
-
-logger = logging.getLogger(__name__)
-
-ROOT = Path(__file__).resolve().parents[1]
-POLICY = tomllib.loads((ROOT / "security/supply_chain_policy.toml").read_text())
-LOCK = ROOT / POLICY["lock_file"]
-SBOM = ROOT / POLICY["sbom_file"]
-DIRECT = ROOT / "requirements.txt"
-DOCKER = ROOT / "Dockerfile"
-IGNORE = ROOT / ".dockerignore"
-COMPOSE = ROOT / "docker-compose.hardened.reference.yml"
-
-LINE_RE = re.compile(
-    r"^(?P<name>[A-Za-z0-9_.-]+)==(?P<version>[^\s]+) "
-    r"--hash=sha256:(?P<digest>[0-9a-f]{64})$"
-)
-
-
-def _version_tuple(text: str) -> tuple[int | str, ...]:
-    # Floors in this policy are simple numeric PEP-440 releases. Keep this
-    # parser intentionally narrow so unusual versions fail review rather than
-    # gaining surprising ordering semantics.
-    out: list[int | str] = []
-    for part in re.split(r"[.-]", text):
-        out.append(int(part) if part.isdigit() else part)
-    return tuple(out)
-
-
-def _locked() -> dict[str, tuple[str, str]]:
-    result: dict[str, tuple[str, str]] = {}
-    for raw in LOCK.read_text().splitlines():
-        line = raw.strip()
-        if not line or line.startswith("#"):
-            continue
-        match = LINE_RE.fullmatch(line)
-        if not match:
-            raise AssertionError(f"LOCK_LINE_NOT_EXACT_HASHED:{line}")
-        name = match.group("name").lower().replace("_", "-")
-        if name in result:
-            raise AssertionError(f"LOCK_DUPLICATE:{name}")
-        result[name] = (match.group("version"), match.group("digest"))
-    if not result:
-        raise AssertionError("LOCK_EMPTY")
-    return result
-
-
-def verify() -> dict[str, object]:  # ruff: ignore[too-many-branches]
-    """Verify."""
-    locked = _locked()
-
-    direct: dict[str, str] = {}
-    for raw in DIRECT.read_text().splitlines():
-        line = raw.strip()
-        if not line or line.startswith("#"):
-            continue
-        if any(token in line for token in (">", "<", "~=", "[", "]", "@", ";")):
-            raise AssertionError(f"DIRECT_REQUIREMENT_NOT_EXACT_MINIMAL:{line}")
-        if line.count("==") != 1:
-            raise AssertionError(f"DIRECT_REQUIREMENT_NOT_EXACT:{line}")
-        name, version = line.split("==", 1)
-        direct[name.lower().replace("_", "-")] = version
-    for name, version in direct.items():
-        if locked.get(name, (None,))[0] != version:
-            raise AssertionError(f"DIRECT_LOCK_DRIFT:{name}")
-
-    for name, floor in POLICY["advisory_floors"].items():
-        normalized = name.lower().replace("_", "-")
-        if normalized not in locked:
-            raise AssertionError(f"ADVISORY_FLOOR_PACKAGE_MISSING:{normalized}")
-        if _version_tuple(locked[normalized][0]) < _version_tuple(str(floor)):
-            raise AssertionError(f"ADVISORY_FLOOR_REGRESSION:{normalized}")
-
-    docker = DOCKER.read_text()
-    image = POLICY["base_image"]
-    expected = f"{image['repository']}:{image['tag']}@{image['index_digest']}"
-    required_docker = (
-        expected,
-        "--require-hashes",
-        "--only-binary=:all:",
-        "USER 1000:1000",
-        "DEPLOYMENT_PROFILE=strict",
-        "COPY --from=builder /opt/venv /opt/venv",
-        "FROM --platform=linux/amd64 ${PYTHON_IMAGE} AS builder",
-        "FROM --platform=linux/amd64 ${PYTHON_IMAGE} AS runtime",
-    )
-    for marker in required_docker:
-        if marker not in docker:
-            raise AssertionError(f"DOCKER_HARDENING_MISSING:{marker}")
-    if "uvicorn[standard]" in docker or "fastapi[standard]" in docker:
-        raise AssertionError("DOCKER_BROAD_EXTRAS_FORBIDDEN")
-
-    ignore_lines = {
-        line.strip()
-        for line in IGNORE.read_text().splitlines()
-        if line.strip() and not line.startswith("#")
-    }
-    if "*" not in ignore_lines:
-        raise AssertionError("DOCKERIGNORE_NOT_DENY_BY_DEFAULT")
-    for required in ("!requirements.lock", "!app.py", "!_utils/**"):
-        if required not in ignore_lines:
-            raise AssertionError(f"DOCKERIGNORE_RUNTIME_ALLOWLIST_MISSING:{required}")
-    for required in (
-        "_utils/__pycache__/",
-        "_utils/**/__pycache__/",
-        "_utils/**/*.pyc",
-        "_utils/**/*.pyo",
-    ):
-        if required not in ignore_lines:
-            raise AssertionError(
-                f"DOCKERIGNORE_GENERATED_BYTECODE_EXCLUSION_MISSING:{required}"
-            )
-
-    compose = COMPOSE.read_text()
-    for marker in (
-        "read_only: true",
-        'user: "1000:1000"',
-        "no-new-privileges:true",
-        "cap_drop:",
-        "DEPLOYMENT_PROFILE: strict",
-    ):
-        if marker not in compose:
-            raise AssertionError(f"HARDENED_REFERENCE_MISSING:{marker}")
-
-    release_policy = POLICY.get("release_evidence", {})
-    for field in (
-        "policy_file",
-        "example_file",
-        "verifier_file",
-        "combined_gate_file",
-        "redis_probe_file",
-        "subject_printer_file",
-    ):
-        raw = release_policy.get(field)
-        if not isinstance(raw, str) or not raw:
-            raise AssertionError(f"RELEASE_EVIDENCE_POLICY_MISSING:{field}")
-        path = ROOT / raw
-        if not path.is_file():
-            raise AssertionError(f"RELEASE_EVIDENCE_FILE_MISSING:{field}")
-    evidence_policy = tomllib.loads((ROOT / release_policy["policy_file"]).read_text())
-    if (int(evidence_policy.get("max_age_hours", 0)) <= 0) or int(
-        evidence_policy.get("max_age_hours", 999)
-    ) > (
-        72  # ruff: ignore[magic-value-comparison]
-    ):
-        raise AssertionError("RELEASE_EVIDENCE_MAX_AGE_UNSAFE")
-    manifest_cap = int(evidence_policy.get("max_manifest_bytes", 0))
-    if manifest_cap <= 0 or manifest_cap > 1024 * 1024:
-        raise AssertionError("RELEASE_EVIDENCE_MANIFEST_CAP_UNSAFE")
-    minimum_cdx = str(evidence_policy.get("minimum_cyclonedx_spec_version", ""))
-    if not re.fullmatch(r"[0-9]+\.[0-9]+", minimum_cdx) or _version_tuple(
-        minimum_cdx
-    ) < _version_tuple("1.6"):
-        raise AssertionError("RELEASE_EVIDENCE_CYCLONEDX_FLOOR_UNSAFE")
-    if evidence_policy.get("target_platform") != POLICY.get("target_platform"):
-        raise AssertionError("RELEASE_EVIDENCE_PLATFORM_DRIFT")
-    if evidence_policy.get("forbid_unexpired_risk_exceptions") is not True:
-        raise AssertionError("RELEASE_EVIDENCE_RISK_EXCEPTION_BYPASS")
-    if evidence_policy.get("logging", {}).get("request_body_logging") is not False:
-        raise AssertionError("RELEASE_EVIDENCE_BODY_LOGGING_NOT_FORBIDDEN")
-    if (
-        evidence_policy.get("logging", {}).get("third_party_telemetry_export")
-        is not False
-    ):
-        raise AssertionError("RELEASE_EVIDENCE_TELEMETRY_NOT_FORBIDDEN")
-
-    sbom = json.loads(SBOM.read_text())
-    components = {
-        c["name"].lower().replace("_", "-"): c for c in sbom.get("components", [])
-    }
-    if set(components) != set(locked):
-        missing = sorted(set(locked) - set(components))
-        extra = sorted(set(components) - set(locked))
-        raise AssertionError(f"SBOM_LOCK_SET_DRIFT:missing={missing}:extra={extra}")
-    for name, (version, digest) in locked.items():
-        comp = components[name]
-        if comp.get("version") != version:
-            raise AssertionError(f"SBOM_VERSION_DRIFT:{name}")
-        hashes = {
-            h.get("content")
-            for h in comp.get("hashes", [])
-            if h.get("alg") == "SHA-256"
-        }
-        if digest not in hashes:
-            raise AssertionError(f"SBOM_HASH_DRIFT:{name}")
-
-    return {
-        "ok": True,
-        "locked_packages": len(locked),
-        "direct_packages": len(direct),
-        "base_index_digest": image["index_digest"],
-        "lock_sha256": hashlib.sha256(LOCK.read_bytes()).hexdigest(),
-        "sbom_sha256": hashlib.sha256(SBOM.read_bytes()).hexdigest(),
-        "release_evidence_policy": True,
-    }
-
-
-if __name__ == "__main__":
-    try:
-        sys.stdout.write(json.dumps(verify(), sort_keys=True) + "\n")
-    except Exception as exc:  # ruff: ignore[blind-except]
-        sys.stderr.write(
-            json.dumps({"ok": False, "error": str(exc)}, sort_keys=True) + "\n"
-        )
-        raise SystemExit(1) from exc