docker-host-audit 0.1.1__py3-none-any.whl

ca/__init__.py

@@ -0,0 +1,3 @@
+"""container-audit: read-only security audit for Docker hosts."""
+
+__version__ = "0.1.1"

ca/__main__.py

@@ -0,0 +1,6 @@
+"""Allow `python -m ca`."""
+
+from ca.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

ca/checks/__init__.py

@@ -0,0 +1,12 @@
+"""Check registry. Each submodule exposes `CHECKS: list[CheckFn]`; we aggregate them."""
+
+from __future__ import annotations
+
+from ca.models import CheckFn
+
+
+def get_checks() -> list[CheckFn]:
+    """Every registered check, across all submodules."""
+    from ca.checks import exposure, hardening, images, privilege
+
+    return [*privilege.CHECKS, *exposure.CHECKS, *hardening.CHECKS, *images.CHECKS]

ca/checks/exposure.py

@@ -0,0 +1,113 @@
+"""Exposure checks: published ports, secrets in env, unpinned images."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+
+from ca.models import CheckFn, Container, Finding, Severity
+from ca.redact import mask
+
+# Matches credentials embedded in a URL, e.g. postgres://user:pass@host/db.
+_URL_CREDENTIAL = re.compile(r"://[^/@:\s]+:[^/@\s]+@")
+
+_SECRET_MARKERS = (
+    "PASSWORD",
+    "PASSWD",
+    "SECRET",
+    "TOKEN",
+    "API_KEY",
+    "APIKEY",
+    "ACCESS_KEY",
+    "PRIVATE_KEY",
+    "CREDENTIAL",
+    "AUTH",
+)
+_PLACEHOLDERS = ("changeme", "example")
+_PLACEHOLDER_PREFIXES = ("${", "/run/secrets/")
+
+
+def _is_secret_name(key: str) -> bool:
+    upper = key.upper()
+    return (
+        upper == "KEY"
+        or upper.endswith("_KEY")
+        or any(marker in upper for marker in _SECRET_MARKERS)
+    )
+
+
+def _is_placeholder(value: str) -> bool:
+    stripped = value.strip()
+    return (
+        not stripped
+        or stripped.lower() in _PLACEHOLDERS
+        or stripped.startswith(_PLACEHOLDER_PREFIXES)
+    )
+
+
+def _is_unpinned(image: str) -> bool:
+    if not image or "@" in image:
+        return False
+    last_segment = image.rsplit("/", 1)[-1]  # a colon before the last "/" is a registry port
+    _, sep, tag = last_segment.partition(":")
+    return not sep or tag == "latest"
+
+
+def secret_in_env(containers: list[Container]) -> Iterable[Finding]:
+    for c in containers:
+        for entry in c.env:
+            key, sep, value = entry.partition("=")
+            if not sep or _is_placeholder(value):
+                continue
+            if not _is_secret_name(key) and not _URL_CREDENTIAL.search(value):
+                continue
+            yield Finding(
+                check_id="secret-in-env",
+                title="Secret stored in environment variable",
+                severity=Severity.HIGH,
+                container=c.name,
+                detail=(
+                    f"Environment variable {key} looks like a secret and has a literal "
+                    "value; it is visible via docker inspect and to anyone who can read the "
+                    "container configuration."
+                ),
+                evidence=f"{key}={mask(value)}",
+                remediation="Use Docker secrets or an env file kept outside the image.",
+            )
+
+
+def port_all_interfaces(containers: list[Container]) -> Iterable[Finding]:
+    for c in containers:
+        for p in c.ports:
+            if not p.all_interfaces:
+                continue
+            yield Finding(
+                check_id="port-all-interfaces",
+                title="Port published on all interfaces",
+                severity=Severity.MEDIUM,
+                container=c.name,
+                detail="The port is reachable from every network the host is attached to.",
+                evidence=f"0.0.0.0:{p.host_port} -> {p.container_port}",
+                remediation="Bind to 127.0.0.1 (e.g. 127.0.0.1:<port>:<port>) unless public.",
+            )
+
+
+def unpinned_image(containers: list[Container]) -> Iterable[Finding]:
+    for c in containers:
+        if not _is_unpinned(c.image):
+            continue
+        yield Finding(
+            check_id="unpinned-image",
+            title="Image is not pinned",
+            severity=Severity.LOW,
+            container=c.name,
+            detail="The image has no digest and uses no tag or the mutable ':latest' tag.",
+            evidence=c.image,
+            remediation="Pin to a digest (@sha256:...) or an explicit version tag.",
+        )
+
+
+CHECKS: list[CheckFn] = []
+CHECKS.append(secret_in_env)
+CHECKS.append(port_all_interfaces)
+CHECKS.append(unpinned_image)

ca/checks/hardening.py

@@ -0,0 +1,100 @@
+"""Host-isolation hardening checks: shared namespaces, no-new-privileges, memory limits."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any
+
+from ca.models import CheckFn, Container, Finding, Severity
+
+
+def _host_config(c: Container) -> dict[str, Any]:
+    host_config = c.raw.get("HostConfig")
+    return host_config if isinstance(host_config, dict) else {}
+
+
+def host_network(containers: list[Container]) -> Iterable[Finding]:
+    for c in containers:
+        if c.network_mode == "host":
+            yield Finding(
+                check_id="host-network",
+                title="Container shares the host network namespace",
+                severity=Severity.HIGH,
+                container=c.name,
+                detail="The container shares the host network namespace, bypassing network "
+                "isolation and port mapping.",
+                evidence="HostConfig.NetworkMode=host",
+                remediation="Use a bridge or user-defined network instead of `network_mode: host`.",
+            )
+
+
+def host_ipc(containers: list[Container]) -> Iterable[Finding]:
+    for c in containers:
+        if _host_config(c).get("IpcMode") == "host":
+            yield Finding(
+                check_id="host-ipc",
+                title="Container shares the host IPC namespace",
+                severity=Severity.MEDIUM,
+                container=c.name,
+                detail="The container can access host shared memory and IPC objects, "
+                "weakening isolation.",
+                evidence="HostConfig.IpcMode=host",
+                remediation="Remove `ipc: host`; do not share the host IPC namespace.",
+            )
+
+
+def host_uts(containers: list[Container]) -> Iterable[Finding]:
+    for c in containers:
+        if _host_config(c).get("UTSMode") == "host":
+            yield Finding(
+                check_id="host-uts",
+                title="Container shares the host UTS namespace",
+                severity=Severity.LOW,
+                container=c.name,
+                detail="The container shares the host hostname and domain name namespace.",
+                evidence="HostConfig.UTSMode=host",
+                remediation="Remove `uts: host`; do not share the host UTS namespace.",
+            )
+
+
+def no_new_privileges_missing(containers: list[Container]) -> Iterable[Finding]:
+    for c in containers:
+        security_opt = _host_config(c).get("SecurityOpt") or []
+        enabled = any(
+            str(opt).strip().lower().replace("=", ":") == "no-new-privileges:true"
+            for opt in security_opt
+        )
+        if not enabled:
+            yield Finding(
+                check_id="no-new-privileges-missing",
+                title="no-new-privileges is not set",
+                severity=Severity.MEDIUM,
+                container=c.name,
+                detail="Without no-new-privileges, setuid binaries inside the container "
+                "can escalate privileges.",
+                evidence="HostConfig.SecurityOpt lacks no-new-privileges",
+                remediation='Add `security_opt: ["no-new-privileges:true"]`.',
+            )
+
+
+def unlimited_memory(containers: list[Container]) -> Iterable[Finding]:
+    for c in containers:
+        if not _host_config(c).get("Memory"):
+            yield Finding(
+                check_id="unlimited-memory",
+                title="Container has no memory limit",
+                severity=Severity.LOW,
+                container=c.name,
+                detail="With no memory limit, one container can exhaust the host's RAM.",
+                evidence="HostConfig.Memory=0",
+                remediation="Set a memory limit (`mem_limit` in compose).",
+            )
+
+
+CHECKS: list[CheckFn] = [
+    host_network,
+    host_ipc,
+    host_uts,
+    no_new_privileges_missing,
+    unlimited_memory,
+]

ca/checks/images.py

@@ -0,0 +1,48 @@
+"""Image freshness: images built long ago likely miss upstream security patches."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from datetime import UTC, date, datetime
+
+from ca.models import CheckFn, Container, Finding, Severity
+
+MAX_IMAGE_AGE_DAYS = 180
+# Reproducible builds (distroless, ko, Nix) stamp a fixed epoch date; that is not a real age.
+_EARLIEST_REAL_BUILD = date(2000, 1, 1)
+
+
+def _today() -> date:
+    return datetime.now(UTC).date()
+
+
+def _build_date(created: str) -> date | None:
+    try:
+        built = date.fromisoformat(created[:10])
+    except ValueError:
+        return None
+    return built if built >= _EARLIEST_REAL_BUILD else None
+
+
+def stale_image(containers: list[Container]) -> Iterable[Finding]:
+    today = _today()
+    for c in containers:
+        built = _build_date(c.image_created)
+        if built is None:
+            continue
+        age = (today - built).days
+        if age > MAX_IMAGE_AGE_DAYS:
+            yield Finding(
+                check_id="stale-image",
+                title="Image was built long ago",
+                severity=Severity.MEDIUM,
+                container=c.name,
+                detail=f"The image is {age} days old, so it likely lacks security patches "
+                "released since it was built.",
+                evidence=f"image built {built.isoformat()} ({age} days ago)",
+                remediation="Pull or rebuild the image on a current base and recreate the "
+                "container; automate updates (e.g. Renovate, Dependabot).",
+            )
+
+
+CHECKS: list[CheckFn] = [stale_image]

ca/checks/privilege.py

@@ -0,0 +1,146 @@
+"""Privilege and isolation checks: root users, privileged mode, risky mounts."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from ca.models import CheckFn, Container, Finding, Mount, Severity
+
+DANGEROUS_CAPS = frozenset(
+    {"SYS_ADMIN", "NET_ADMIN", "SYS_PTRACE", "SYS_MODULE", "DAC_READ_SEARCH"}
+)
+SENSITIVE_SOURCES = frozenset({"/", "/etc", "/root", "/var/run", "/proc", "/sys"})
+
+
+def _normalize_cap(cap: str) -> str:
+    cap = cap.strip().upper()
+    return cap.removeprefix("CAP_")
+
+
+def _is_docker_sock(mount: Mount) -> bool:
+    return mount.source.endswith("docker.sock")
+
+
+def _is_sensitive_source(source: str) -> bool:
+    return source in SENSITIVE_SOURCES or source == "/home" or source.startswith("/home/")
+
+
+def privileged(containers: list[Container]) -> Iterable[Finding]:
+    for c in containers:
+        if c.privileged:
+            yield Finding(
+                check_id="privileged",
+                title="Container runs in privileged mode",
+                severity=Severity.CRITICAL,
+                container=c.name,
+                detail="Privileged mode grants all capabilities and host device access, "
+                "so a compromise is effectively a host compromise.",
+                evidence="HostConfig.Privileged=true",
+                remediation="Remove `privileged: true`; add only the capabilities needed.",
+            )
+
+
+def docker_socket_mount(containers: list[Container]) -> Iterable[Finding]:
+    for c in containers:
+        for m in c.mounts:
+            if _is_docker_sock(m):
+                yield Finding(
+                    check_id="docker-socket-mount",
+                    title="Docker socket mounted into container",
+                    severity=Severity.CRITICAL,
+                    container=c.name,
+                    detail="Access to the Docker socket grants control of the Docker daemon, "
+                    "and therefore of the host.",
+                    evidence=f"{m.source} -> {m.destination} ({'rw' if m.rw else 'ro'})",
+                    remediation="Remove the socket mount or use a restricted docker-socket-proxy.",
+                )
+
+
+def root_user(containers: list[Container]) -> Iterable[Finding]:
+    for c in containers:
+        if c.runs_as_root:
+            yield Finding(
+                check_id="root-user",
+                title="Container runs as root",
+                severity=Severity.HIGH,
+                container=c.name,
+                detail="The main process runs as UID 0, widening the impact of an escape.",
+                evidence=f"Config.User={c.user!r}",
+                remediation="Set a non-root USER in the image or `user:` in compose.",
+            )
+
+
+def dangerous_caps(containers: list[Container]) -> Iterable[Finding]:
+    for c in containers:
+        matched = sorted({_normalize_cap(cap) for cap in c.cap_add} & DANGEROUS_CAPS)
+        if matched:
+            yield Finding(
+                check_id="dangerous-caps",
+                title="Container adds dangerous Linux capabilities",
+                severity=Severity.HIGH,
+                container=c.name,
+                detail="These capabilities allow administrative or host-affecting operations "
+                "and weaken container isolation.",
+                evidence="cap_add: " + ", ".join(matched),
+                remediation="Remove these from `cap_add`; grant only what is required.",
+            )
+
+
+def sensitive_host_mount(containers: list[Container]) -> Iterable[Finding]:
+    for c in containers:
+        for m in c.mounts:
+            if (
+                m.mount_type == "bind"
+                and m.rw
+                and not _is_docker_sock(m)
+                and _is_sensitive_source(m.source)
+            ):
+                yield Finding(
+                    check_id="sensitive-host-mount",
+                    title="Sensitive host path mounted read-write",
+                    severity=Severity.HIGH,
+                    container=c.name,
+                    detail="A writable bind mount of a sensitive host directory lets the container "
+                    "modify host configuration or data.",
+                    evidence=f"{m.source} -> {m.destination} (rw)",
+                    remediation="Mount a narrower path, and read-only (`:ro`) where possible.",
+                )
+
+
+def host_pid(containers: list[Container]) -> Iterable[Finding]:
+    for c in containers:
+        if c.pid_mode == "host":
+            yield Finding(
+                check_id="host-pid",
+                title="Container shares the host PID namespace",
+                severity=Severity.HIGH,
+                container=c.name,
+                detail="The container can see and signal host processes, undermining isolation.",
+                evidence="HostConfig.PidMode=host",
+                remediation="Remove `pid: host` from the container configuration.",
+            )
+
+
+def writable_rootfs(containers: list[Container]) -> Iterable[Finding]:
+    for c in containers:
+        if not c.readonly_rootfs:
+            yield Finding(
+                check_id="writable-rootfs",
+                title="Root filesystem is writable",
+                severity=Severity.LOW,
+                container=c.name,
+                detail="A writable root filesystem lets an attacker persist changes.",
+                evidence="HostConfig.ReadonlyRootfs=false",
+                remediation="Set `read_only: true` and use tmpfs or volumes for writable paths.",
+            )
+
+
+CHECKS: list[CheckFn] = [
+    privileged,
+    docker_socket_mount,
+    root_user,
+    dangerous_caps,
+    sensitive_host_mount,
+    host_pid,
+    writable_rootfs,
+]

ca/cli.py

@@ -0,0 +1,114 @@
+"""CLI entrypoint."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import socket
+import sys
+from datetime import UTC, datetime
+from pathlib import Path
+
+from ca import __version__
+from ca.checks import get_checks
+from ca.models import Container, Finding, Report, Severity
+from ca.report import render
+
+_FAIL_LEVELS = {
+    "low": Severity.LOW,
+    "medium": Severity.MEDIUM,
+    "high": Severity.HIGH,
+    "critical": Severity.CRITICAL,
+}
+_MIN_LEVELS = {"info": Severity.INFO, **_FAIL_LEVELS}
+
+
+def _parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="container-audit", description="Read-only security audit of a Docker host."
+    )
+    p.add_argument("--version", action="version", version=f"container-audit {__version__}")
+    p.add_argument("--input", metavar="PATH", help="JSON array of `docker inspect` objects")
+    p.add_argument("--format", choices=["text", "json", "markdown"], default="text")
+    p.add_argument("--include-stopped", action="store_true", help="also audit stopped containers")
+    p.add_argument(
+        "--fail-on",
+        choices=["none", *_FAIL_LEVELS],
+        default="none",
+        help="exit 1 if any finding is at or above this severity",
+    )
+    p.add_argument(
+        "--min-severity",
+        choices=list(_MIN_LEVELS),
+        default="info",
+        help="hide findings below this severity from the report (--fail-on sees the same list)",
+    )
+    p.add_argument(
+        "--include-host",
+        action="store_true",
+        help="include the real hostname in the report (off by default so output is safe to share)",
+    )
+    return p
+
+
+def _load_unchecked(args: argparse.Namespace) -> list[Container] | None:
+    if args.input:
+        from ca.collect import parse_inspect
+
+        objects = json.loads(Path(args.input).read_text(encoding="utf-8"))
+        if not isinstance(objects, list) or not all(isinstance(o, dict) for o in objects):
+            raise ValueError("input must be a JSON array of docker inspect objects")
+        return parse_inspect(objects)
+
+    from ca.docker_cli import collect_running, docker_available
+
+    if not docker_available():
+        print("error: docker is not available (is it installed and running?)", file=sys.stderr)
+        return None
+    return collect_running(include_stopped=args.include_stopped)
+
+
+def _load(args: argparse.Namespace) -> list[Container] | None:
+    """Load containers; on an expected failure print a short error and return None."""
+    try:
+        return _load_unchecked(args)
+    except FileNotFoundError:
+        print("error: input file not found", file=sys.stderr)
+    except OSError as exc:
+        print(f"error: cannot read input ({type(exc).__name__})", file=sys.stderr)
+    except RecursionError:
+        print("error: input JSON is nested too deeply", file=sys.stderr)
+    except ValueError as exc:
+        print(f"error: invalid input: {exc}", file=sys.stderr)
+    except RuntimeError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+    return None
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    containers = _load(args)
+    if containers is None:
+        return 2
+
+    findings: list[Finding] = []
+    for check in get_checks():
+        findings.extend(check(containers))
+    floor = _MIN_LEVELS[args.min_severity]
+    findings = [f for f in findings if f.severity >= floor]
+
+    report = Report(
+        host=socket.gethostname() if args.include_host else "(redacted)",
+        scanned=len(containers),
+        findings=findings,
+        timestamp=datetime.now(UTC).isoformat(),
+    )
+    print(render(report, args.format))
+
+    if args.fail_on != "none" and report.worst >= _FAIL_LEVELS[args.fail_on]:
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ca/collect.py

@@ -0,0 +1,102 @@
+"""Map raw `docker inspect` JSON to Container models (read-only, no I/O)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ca.models import Container, Mount, PortBinding
+
+
+def _as_dict(x: Any) -> dict:
+    return x if isinstance(x, dict) else {}
+
+
+def _as_list(x: Any) -> list:
+    return x if isinstance(x, list) else []
+
+
+def _as_str(x: Any) -> str:
+    return x if isinstance(x, str) else ""
+
+
+def _str_items(x: Any) -> tuple[str, ...]:
+    return tuple(i for i in _as_list(x) if isinstance(i, str))
+
+
+def _parse_ports(ports: Any) -> tuple[PortBinding, ...]:
+    """Flatten NetworkSettings.Ports; a null value means the port is not published."""
+    result: list[PortBinding] = []
+    for container_port, bindings in _as_dict(ports).items():
+        for binding in _as_list(bindings):
+            if not isinstance(binding, dict):
+                continue
+            result.append(
+                PortBinding(
+                    host_ip=_as_str(binding.get("HostIp")),
+                    host_port=_as_str(binding.get("HostPort")),
+                    container_port=_as_str(container_port),
+                )
+            )
+    return tuple(result)
+
+
+def _parse_mounts(mounts: Any) -> tuple[Mount, ...]:
+    result: list[Mount] = []
+    for item in _as_list(mounts):
+        if not isinstance(item, dict):
+            continue
+        result.append(
+            Mount(
+                source=_as_str(item.get("Source")) or _as_str(item.get("Name")),
+                destination=_as_str(item.get("Destination")),
+                mode=_as_str(item.get("Mode")),
+                rw=bool(item.get("RW", True)),
+                mount_type=_as_str(item.get("Type")),
+            )
+        )
+    return tuple(result)
+
+
+def _parse_one(obj: dict[str, Any], image_created: dict[str, str]) -> Container:
+    config = _as_dict(obj.get("Config"))
+    host_config = _as_dict(obj.get("HostConfig"))
+    state = _as_dict(obj.get("State"))
+    network = _as_dict(obj.get("NetworkSettings"))
+    restart = _as_dict(host_config.get("RestartPolicy"))
+
+    return Container(
+        id=_as_str(obj.get("Id")),
+        name=_as_str(obj.get("Name")).lstrip("/"),
+        image=_as_str(config.get("Image")),
+        image_id=_as_str(obj.get("Image")),
+        status=_as_str(state.get("Status")),
+        user=_as_str(config.get("User")),
+        privileged=host_config.get("Privileged") is True,
+        cap_add=_str_items(host_config.get("CapAdd")),
+        cap_drop=_str_items(host_config.get("CapDrop")),
+        pid_mode=_as_str(host_config.get("PidMode")),
+        network_mode=_as_str(host_config.get("NetworkMode")),
+        readonly_rootfs=host_config.get("ReadonlyRootfs") is True,
+        ports=_parse_ports(network.get("Ports")),
+        mounts=_parse_mounts(obj.get("Mounts")),
+        env=_str_items(config.get("Env")),
+        restart_policy=_as_str(restart.get("Name")),
+        image_created=image_created.get(_as_str(obj.get("Image")), ""),
+        raw=obj,
+    )
+
+
+def _is_image(obj: dict[str, Any]) -> bool:
+    """Image inspect objects carry RootFS; container objects never do."""
+    return "RootFS" in obj
+
+
+def parse_inspect(objects: list[dict]) -> list[Container]:
+    """Parse `docker inspect` JSON objects into Container models; non-dict items are skipped.
+
+    Image objects (from `docker image inspect`) may be mixed in; they are not containers but
+    supply each container's image build time.
+    """
+    dicts = [o for o in objects if isinstance(o, dict)]
+    image_created = {_as_str(o.get("Id")): _as_str(o.get("Created")) for o in dicts if _is_image(o)}
+    return [_parse_one(o, image_created) for o in dicts if not _is_image(o)]

ca/docker_cli.py

@@ -0,0 +1,79 @@
+"""Thin read-only wrapper around the Docker CLI: only `docker ps` and `docker inspect`."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from typing import Any
+
+from ca.collect import parse_inspect
+from ca.models import Container
+
+_INSPECT_CHUNK = 100
+
+
+def _docker_path() -> str | None:
+    return shutil.which("docker")
+
+
+def docker_available() -> bool:
+    return _docker_path() is not None
+
+
+def _run(args: list[str], allow_failure: bool = False) -> str:
+    path = _docker_path()
+    if path is None:
+        raise RuntimeError("docker executable not found in PATH")
+    try:
+        proc = subprocess.run(
+            [path, *args],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=30,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise RuntimeError("docker timed out after 30s") from exc
+    except OSError as exc:
+        raise RuntimeError(f"failed to run docker: {exc}") from exc
+    if proc.returncode != 0 and not allow_failure:
+        raise RuntimeError(
+            f"docker {args[0]} failed (exit {proc.returncode}): {proc.stderr.strip()}"
+        )
+    return proc.stdout
+
+
+def inspect_json(
+    ids: list[str], kind: str = "container", best_effort: bool = False
+) -> list[dict[str, Any]]:
+    """Run `docker inspect --type <kind>` on the given ids and return the parsed JSON.
+
+    With `best_effort`, ids Docker cannot find are skipped: it still prints the objects it
+    found as JSON and exits 1, e.g. when a running container's image was deleted.
+    """
+    if not ids:
+        return []
+    result: list[dict[str, Any]] = []
+    for start in range(0, len(ids), _INSPECT_CHUNK):
+        chunk = ids[start : start + _INSPECT_CHUNK]
+        out = _run(["inspect", "--type", kind, "--", *chunk], allow_failure=best_effort)
+        try:
+            data = json.loads(out)
+        except json.JSONDecodeError as exc:
+            if best_effort:
+                continue
+            raise RuntimeError(f"docker inspect returned invalid JSON: {exc}") from exc
+        result.extend(data)
+    return result
+
+
+def collect_running(include_stopped: bool = False) -> list[Container]:
+    """List containers with `docker ps -q` (`-a` if requested) and parse their inspect data."""
+    args = ["ps", "-q"]
+    if include_stopped:
+        args.append("-a")
+    ids = _run(args).split()
+    containers = inspect_json(ids)
+    image_ids = sorted({c["Image"] for c in containers if isinstance(c.get("Image"), str)})
+    return parse_inspect([*containers, *inspect_json(image_ids, kind="image", best_effort=True)])

ca/models.py

@@ -0,0 +1,105 @@
+"""Shared data types. Every module imports from here; keep it dependency-free.
+
+The whole tool is read-only: it parses `docker inspect` output and reports
+misconfigurations. It never starts, stops, or changes a container.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass, field
+from enum import IntEnum
+from typing import Any
+
+
+class Severity(IntEnum):
+    """Ordered so findings sort high-to-low with `sorted(..., reverse=True)`."""
+
+    INFO = 0
+    LOW = 1
+    MEDIUM = 2
+    HIGH = 3
+    CRITICAL = 4
+
+    @property
+    def label(self) -> str:
+        return self.name.lower()
+
+
+@dataclass(frozen=True)
+class PortBinding:
+    """A published port. `host_ip` empty means Docker's default (all interfaces)."""
+
+    host_ip: str
+    host_port: str
+    container_port: str  # e.g. "5432/tcp"
+
+    @property
+    def all_interfaces(self) -> bool:
+        return self.host_ip in ("", "0.0.0.0", "::")  # noqa: S104 - detecting this, not binding
+
+
+@dataclass(frozen=True)
+class Mount:
+    source: str  # host path (bind) or volume name
+    destination: str  # path inside the container
+    mode: str  # "rw" / "ro" as reported
+    rw: bool
+    mount_type: str  # "bind", "volume", "tmpfs", ...
+
+
+@dataclass(frozen=True)
+class Container:
+    """The essentials parsed from one `docker inspect` object, plus the raw dict."""
+
+    id: str
+    name: str
+    image: str
+    image_id: str
+    status: str  # running, exited, ...
+    user: str  # Config.User; "" or "0"/"root" means root
+    privileged: bool
+    cap_add: tuple[str, ...]
+    cap_drop: tuple[str, ...]
+    pid_mode: str
+    network_mode: str
+    readonly_rootfs: bool
+    ports: tuple[PortBinding, ...]
+    mounts: tuple[Mount, ...]
+    env: tuple[str, ...] = field(repr=False)  # raw "KEY=VALUE"; repr hidden so secrets never leak
+    restart_policy: str
+    image_created: str = ""  # image build time from `docker image inspect`; "" if unknown
+    raw: dict[str, Any] = field(default_factory=dict, repr=False)
+
+    @property
+    def runs_as_root(self) -> bool:
+        return self.user.strip() in ("", "0", "root", "0:0")
+
+
+@dataclass(frozen=True)
+class Finding:
+    """One problem on one container. `evidence` must already be redacted."""
+
+    check_id: str  # stable kebab-case id, e.g. "root-user"
+    title: str
+    severity: Severity
+    container: str  # container name the finding is about
+    detail: str  # human-readable explanation, safe to print publicly
+    evidence: str = ""  # short redacted proof, e.g. "0.0.0.0:5432->5432/tcp"
+    remediation: str = ""  # one-line fix suggestion
+
+
+# A check receives every collected container and yields findings. Pure, read-only.
+CheckFn = Callable[[list[Container]], Iterable[Finding]]
+
+
+@dataclass
+class Report:
+    host: str
+    scanned: int  # number of containers inspected
+    findings: list[Finding]
+    timestamp: str  # ISO 8601 UTC
+
+    @property
+    def worst(self) -> Severity:
+        return max((f.severity for f in self.findings), default=Severity.INFO)

ca/redact.py

@@ -0,0 +1,14 @@
+"""Redaction helpers shared by checks so no secret value ever reaches output."""
+
+from __future__ import annotations
+
+
+def mask(value: str) -> str:
+    """Mask a sensitive value without revealing any character of it.
+
+    >>> mask("supersecret")
+    '***'
+    >>> mask("")
+    '***'
+    """
+    return "***"

ca/report.py

@@ -0,0 +1,105 @@
+"""Render a Report as text / json / markdown."""
+
+from __future__ import annotations
+
+import json
+import unicodedata
+
+from ca.models import Finding, Report, Severity
+
+
+def _sanitize(text: str) -> str:
+    """Drop control (Cc), format (Cf) and other C* characters so output cannot drive a terminal."""
+    return "".join(ch for ch in text if not unicodedata.category(ch).startswith("C"))
+
+
+def _sorted(findings: list[Finding]) -> list[Finding]:
+    return sorted(findings, key=lambda f: (-f.severity, f.container, f.check_id))
+
+
+def _as_dict(f: Finding) -> dict[str, str]:
+    return {
+        "check_id": _sanitize(f.check_id),
+        "title": _sanitize(f.title),
+        "severity": f.severity.label,
+        "container": _sanitize(f.container),
+        "detail": _sanitize(f.detail),
+        "evidence": _sanitize(f.evidence),
+        "remediation": _sanitize(f.remediation),
+    }
+
+
+def _text(report: Report) -> str:
+    lines = [
+        "container-audit report",
+        f"Host:      {_sanitize(report.host)}",
+        f"Scanned:   {report.scanned} container(s)",
+        f"Timestamp: {_sanitize(report.timestamp)}",
+    ]
+    counts = ", ".join(
+        f"{sev.label}={sum(1 for f in report.findings if f.severity == sev)}"
+        for sev in sorted(Severity, reverse=True)
+    )
+    lines.append(f"Findings:  {len(report.findings)} ({counts})")
+    lines.append("")
+    if not report.findings:
+        lines.append("No findings.")
+    for f in _sorted(report.findings):
+        d = _as_dict(f)
+        lines.append(f"[{f.severity.name}] {d['check_id']}  {d['container']} - {d['detail']}")
+        if d["evidence"]:
+            lines.append(f"    evidence:    {d['evidence']}")
+        if d["remediation"]:
+            lines.append(f"    remediation: {d['remediation']}")
+    return "\n".join(lines) + "\n"
+
+
+def _json(report: Report) -> str:
+    data = {
+        "host": _sanitize(report.host),
+        "scanned": report.scanned,
+        "timestamp": _sanitize(report.timestamp),
+        "worst": report.worst.label,
+        "findings": [_as_dict(f) for f in _sorted(report.findings)],
+    }
+    return json.dumps(data, indent=2, sort_keys=False)
+
+
+def _cell(text: str) -> str:
+    out = _sanitize(text.replace("\n", " ").replace("\r", " "))
+    out = out.replace("\\", "\\\\")  # a lone backslash before "|" would otherwise cancel its escape
+    for ch in "|`<>[":
+        out = out.replace(ch, "\\" + ch)
+    return out
+
+
+def _markdown(report: Report) -> str:
+    host = _sanitize(report.host).replace("`", "'")  # inside a code span, escapes do not work
+    lines = [
+        "# container-audit report",
+        "",
+        f"Host `{host}`, {report.scanned} container(s) "
+        f"scanned at {_cell(report.timestamp)}: "
+        f"{len(report.findings)} finding(s), worst severity {report.worst.label}.",
+        "",
+    ]
+    if not report.findings:
+        lines.append("No findings.")
+    else:
+        lines.append("| Severity | Check | Container | Detail | Remediation |")
+        lines.append("| --- | --- | --- | --- | --- |")
+        for f in _sorted(report.findings):
+            cells = [f.severity.label, f.check_id, f.container, f.detail, f.remediation]
+            lines.append("| " + " | ".join(_cell(c) for c in cells) + " |")
+    return "\n".join(lines) + "\n"
+
+
+_RENDERERS = {"text": _text, "json": _json, "markdown": _markdown}
+
+
+def render(report: Report, fmt: str = "text") -> str:
+    try:
+        renderer = _RENDERERS[fmt]
+    except KeyError:
+        raise ValueError(f"unknown format: {fmt!r}") from None
+    return renderer(report)

docker_host_audit-0.1.1.dist-info/METADATA

@@ -0,0 +1,274 @@
+Metadata-Version: 2.4
+Name: docker-host-audit
+Version: 0.1.1
+Summary: Read-only security audit for Docker hosts: flags root containers, exposed ports, secrets in env, privileged mode and mounted docker sockets.
+Author: Petr Hromádka
+Author-email: Petr Hromádka <109349500+petrhromadka@users.noreply.github.com>
+License-Expression: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# 🛡️ container-audit
+
+**Read-only security audit for Docker hosts.**
+
+Point it at your containers and it reports the risky configuration — root users, exposed ports,
+secrets in environment variables, privileged mode, dangerous capabilities, mounted Docker sockets,
+shared host namespaces, outdated images and missing hardening — as a clean text, JSON or Markdown report.
+
+[![CI](https://github.com/petrhromadka/container-audit/actions/workflows/ci.yml/badge.svg)](https://github.com/petrhromadka/container-audit/actions/workflows/ci.yml)
+![defensive](https://img.shields.io/badge/purpose-defensive-blue)
+![read-only](https://img.shields.io/badge/access-read--only-brightgreen)
+![python](https://img.shields.io/badge/python-3.12%2B-informational)
+![license](https://img.shields.io/badge/license-MIT-lightgrey)
+
+[Quick start](#-quick-start) · [What it checks](#-what-it-checks) · [Usage](#-usage) · [How it works](#-how-it-works) · [Safety](#-safety)
+
+</div>
+
+> [!NOTE]
+> **Defensive and read-only.** container-audit only runs `docker ps` and `docker inspect` (or reads
+> a saved copy of that JSON). It never starts, stops, or modifies a container, and it never sends
+> data anywhere.
+
+---
+
+## 🚀 Quick start
+
+No Docker needed to try it — the repo ships a sample `docker inspect` dump:
+
+```bash
+git clone https://github.com/petrhromadka/container-audit
+cd container-audit
+uv run container-audit --input tests/fixtures/sample_inspect.json
+```
+
+You'll see eleven findings on the intentionally-insecure `bad-db` container and a clean bill of health
+for the hardened `good-web` one. To scan your own host instead, just run `container-audit` — it
+reads live containers via `docker ps` / `docker inspect`.
+
+---
+
+## 🔍 What it checks
+
+Severity key: 🔴 critical · 🟠 high · 🟡 medium · 🔵 low. Each finding carries a title, a plain-language
+explanation, short **redacted** evidence, and a one-line remediation.
+
+### Privilege &amp; escape
+
+| | Check id | What | Why it matters |
+| :-: | --- | --- | --- |
+| 🔴 | `docker-socket-mount` | `/var/run/docker.sock` is mounted in | Socket access is effectively root on the host: it can start any other container. |
+| 🔴 | `privileged` | Container runs `--privileged` | Disables most isolation: full device access and all capabilities. |
+| 🟠 | `root-user` | Runs as root (no `USER`, or `0`/`root`) | A process escape or file-permission bug has root inside the container. |
+| 🟠 | `dangerous-caps` | Caps like `SYS_ADMIN`, `NET_ADMIN`, `SYS_PTRACE` added | Common container-escape building blocks. |
+| 🟠 | `sensitive-host-mount` | Host paths (`/`, `/etc`, `/proc`, `/root`, …) bind-mounted | A compromised container can read or alter host config and credentials. |
+
+### Namespaces &amp; exposure
+
+| | Check id | What | Why it matters |
+| :-: | --- | --- | --- |
+| 🟠 | `host-pid` | Shares the host PID namespace (`--pid=host`) | It can see and signal every process on the host. |
+| 🟠 | `host-network` | Shares the host network namespace (`--network=host`) | Network isolation and port mapping are bypassed. |
+| 🟡 | `port-all-interfaces` | Port published on `0.0.0.0` / `::` | Reachable from every network the host is on, not just where you intend. |
+| 🟡 | `host-ipc` | Shares the host IPC namespace (`--ipc=host`) | Shared memory and semaphores cross the container boundary. |
+| 🔵 | `host-uts` | Shares the host UTS namespace (`--uts=host`) | It can change the host's hostname. |
+
+### Secrets &amp; hardening
+
+| | Check id | What | Why it matters |
+| :-: | --- | --- | --- |
+| 🟠 | `secret-in-env` | Env var that looks like a secret, or a URL with embedded credentials | Secrets in env vars leak via `docker inspect`, logs and child processes. |
+| 🟡 | `no-new-privileges-missing` | `no-new-privileges:true` is not set | setuid binaries inside the container can still escalate privileges. |
+| 🔵 | `writable-rootfs` | Root filesystem is writable (not `read_only`) | An attacker can persist changes and tooling. |
+| 🟡 | `stale-image` | Image was built more than 180 days ago | Old images usually miss security patches released since; rebuild or pull a current one. |
+| 🔵 | `unpinned-image` | Image uses `:latest`, no tag, or no digest | Pulls aren't reproducible; upstream can silently change what runs. |
+| 🔵 | `unlimited-memory` | No memory limit set | A single container can exhaust host RAM and take the host down. |
+
+---
+
+## 📦 Install
+
+Requires Python 3.12+ and [uv](https://docs.astral.sh/uv/). The `docker` CLI is only needed to audit
+a live host; auditing a saved file with `--input` does not need it.
+
+```bash
+uv tool install .                 # install as a tool from a checkout
+uvx --from . container-audit      # or run without installing
+uv run container-audit            # or run inside the project environment
+uv run python -m ca               # module form (use this if the console script is blocked)
+```
+
+> On Windows, Smart App Control may block the generated `container-audit.exe` launcher. Run the
+> tool as a module instead: `python -m ca` (or `uv run python -m ca`).
+
+Once published to PyPI: `pipx install docker-host-audit` (then run `container-audit`), or `uvx docker-host-audit`.
+
+### Run with Docker
+
+The image ships the tool (the Docker CLI is intentionally not bundled); feed it a saved inspect dump
+on stdin:
+
+```bash
+docker build -t container-audit .
+docker inspect $(docker ps -aq) $(docker inspect -f '{{.Image}}' $(docker ps -aq) | sort -u) | docker run --rm -i container-audit --input /dev/stdin --fail-on high
+```
+
+---
+
+## 💻 Usage
+
+```bash
+container-audit                                             # audit running containers
+container-audit --include-stopped                          # include stopped ones too
+container-audit --format json                              # machine-readable output
+container-audit --format markdown > report.md              # for an issue / PR / wiki
+
+docker inspect $(docker ps -aq) $(docker inspect -f '{{.Image}}' $(docker ps -aq) | sort -u) > sample.json  # save containers + their images
+container-audit --input sample.json --fail-on high         # audit the dump; non-zero exit for CI
+```
+
+| Flag | Meaning |
+| --- | --- |
+| `--input FILE` | Read `docker inspect` JSON from `FILE` instead of calling Docker. |
+| `--format FORMAT` | Output format: `text` (default), `json` or `markdown`. |
+| `--include-stopped` | Also inspect containers that are not running. |
+| `--include-host` | Include the real hostname in the report (off by default, so output is safe to share). |
+| `--min-severity LEVEL` | Hide findings below `LEVEL` (`info`, `low`, `medium`, `high`, `critical`). Default `info` (show all). |
+| `--fail-on LEVEL` | Exit non-zero if any shown finding is at or above `LEVEL` (`none`, `low`, `medium`, `high`, `critical`). Default `none`. |
+| `--version` | Print the version and exit. |
+
+**Exit codes:** `0` clean (nothing reached `--fail-on`) · `1` a finding met `--fail-on` · `2` could
+not run (Docker unavailable, or a missing/invalid `--input` file).
+
+Image age comes from `docker inspect --type image`. If an image was deleted while its container
+still runs, or the dump has no image objects, the age is unknown and `stale-image` skips that
+container. Images from reproducible builds (distroless, ko, Nix) carry a fixed 1970 date and are
+skipped too.
+
+### Coolify and other self-hosted PaaS
+
+It works unchanged on a [Coolify](https://coolify.io) host. Expect `docker-socket-mount` on Coolify's
+own `coolify-proxy` (Traefik) and `coolify-sentinel` containers: they need the socket by design. Review
+everything else, especially apps you deployed from public templates, which often publish database
+ports on `0.0.0.0` and keep passwords in environment variables.
+
+### Use in CI
+
+```yaml
+- name: Audit containers
+  run: |
+    docker inspect $(docker ps -aq) $(docker inspect -f '{{.Image}}' $(docker ps -aq) | sort -u) > containers.json
+    uvx --from git+https://github.com/petrhromadka/container-audit \
+      container-audit --input containers.json --fail-on high
+```
+
+---
+
+## ⚙️ How it works
+
+```text
+docker ps / docker inspect  ->  parse into Container objects  ->  run checks  ->  render report
+       (or --input file)                                        (pure functions)   text / json / markdown
+```
+
+1. **Collect** — list containers with `docker ps` and read their config with `docker inspect` (or
+   parse a saved copy via `--input`).
+2. **Check** — each check is a pure function over the parsed containers that yields findings. Checks
+   never talk to Docker and never change anything.
+3. **Report** — findings are sorted by severity and rendered as text, JSON or Markdown; with
+   `--fail-on`, the exit code reflects the worst severity found.
+
+<details>
+<summary>📋 Example report (from the bundled sample fixture)</summary>
+
+```text
+container-audit report
+Host:      (redacted)
+Scanned:   2 container(s)
+Timestamp: 2026-11-05T19:32:19+00:00
+Findings:  11 (critical=2, high=3, medium=4, low=2, info=0)
+
+[CRITICAL] docker-socket-mount  bad-db - Access to the Docker socket grants control of the Docker daemon, and therefore of the host.
+    evidence:    /var/run/docker.sock -> /var/run/docker.sock (rw)
+    remediation: Remove the socket mount or use a restricted docker-socket-proxy.
+[CRITICAL] privileged  bad-db - Privileged mode grants all capabilities and host device access, so a compromise is effectively a host compromise.
+    evidence:    HostConfig.Privileged=true
+    remediation: Remove `privileged: true`; add only the capabilities needed.
+[HIGH] dangerous-caps  bad-db - These capabilities allow administrative or host-affecting operations and weaken container isolation.
+    evidence:    cap_add: SYS_ADMIN
+    remediation: Remove these from `cap_add`; grant only what is required.
+[HIGH] root-user  bad-db - The main process runs as UID 0, widening the impact of an escape.
+    evidence:    Config.User=''
+    remediation: Set a non-root USER in the image or `user:` in compose.
+[HIGH] secret-in-env  bad-db - Environment variable DB_PASSWORD looks like a secret and has a literal value; it is visible via docker inspect and to anyone who can read the container configuration.
+    evidence:    DB_PASSWORD=***
+    remediation: Use Docker secrets or an env file kept outside the image.
+[MEDIUM] host-ipc  bad-db - The container can access host shared memory and IPC objects, weakening isolation.
+    evidence:    HostConfig.IpcMode=host
+    remediation: Remove `ipc: host`; do not share the host IPC namespace.
+[MEDIUM] no-new-privileges-missing  bad-db - Without no-new-privileges, setuid binaries inside the container can escalate privileges.
+    evidence:    HostConfig.SecurityOpt lacks no-new-privileges
+    remediation: Add `security_opt: ["no-new-privileges:true"]`.
+[MEDIUM] port-all-interfaces  bad-db - The port is reachable from every network the host is attached to.
+    evidence:    0.0.0.0:5432 -> 5432/tcp
+    remediation: Bind to 127.0.0.1 (e.g. 127.0.0.1:<port>:<port>) unless public.
+[MEDIUM] stale-image  bad-db - The image is 1390 days old, so it likely lacks security patches released since it was built.
+    evidence:    image built 2023-01-15 (1390 days ago)
+    remediation: Pull or rebuild the image on a current base and recreate the container; automate updates (e.g. Renovate, Dependabot).
+[LOW] unlimited-memory  bad-db - With no memory limit, one container can exhaust the host's RAM.
+    evidence:    HostConfig.Memory=0
+    remediation: Set a memory limit (`mem_limit` in compose).
+[LOW] writable-rootfs  bad-db - A writable root filesystem lets an attacker persist changes.
+    evidence:    HostConfig.ReadonlyRootfs=false
+    remediation: Set `read_only: true` and use tmpfs or volumes for writable paths.
+```
+
+The second container, `good-web`, is hardened (non-root, read-only rootfs, memory limit,
+`no-new-privileges`, port bound to `127.0.0.1`) and produces no findings.
+
+</details>
+
+---
+
+## 🔒 Safety
+
+- **Read-only.** The only Docker commands used are `docker ps` and `docker inspect`. Nothing is
+  started, stopped, restarted, or reconfigured.
+- **Secret values are never printed.** For env vars that look like secrets, only the variable
+  **name** is reported, with the value masked to `***` — no characters of the value appear in any
+  output format.
+- **Hostname hidden by default.** Reports show `(redacted)` as the host unless you pass
+  `--include-host`.
+- **Output is sanitized.** Control and terminal-escape characters from container metadata are
+  stripped, so a report is safe to print in a terminal or paste into Markdown.
+- **No network use, no runtime dependencies.** The tool never transmits data anywhere.
+- Reports can still reveal your container names, image names, ports and mount paths — review one
+  before sharing it publicly.
+
+---
+
+## 🧰 Development
+
+```bash
+uv sync                      # create the environment
+uv run ruff check .          # lint
+uv run ruff format --check . # formatting
+uv run ty check src          # type check
+uv run pytest                # tests
+```
+
+Pre-commit hooks (ruff, gitleaks, whitespace fixes) live in `.pre-commit-config.yaml`; install them
+with [`prek`](https://github.com/j178/prek) or `pre-commit`. CI runs the same checks plus a gitleaks
+scan over the full history.
+
+To add a check, write a function that takes `list[Container]` and yields `Finding` objects, then
+register it in the `CHECKS` list of the relevant module under `src/ca/checks/`.
+
+---
+
+## 📄 License
+
+[MIT](LICENSE) © 2026 Petr Hromádka

docker_host_audit-0.1.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+ca/__init__.py,sha256=kATKlJStlr1EPkIQx9aZ2Aj7xHg7AanU4RAofvoS-eg,89
+ca/__main__.py,sha256=z9v9LxLFsVruHJOhaRefPb2NsJks2Uq-WP4tCYmEew8,110
+ca/checks/__init__.py,sha256=xpp1mLa90ysWbp51QD-Van77m6svty6412TPlbyCfVo,400
+ca/checks/exposure.py,sha256=qmlRAWGrNzmzZsKad2OImQ2sssQWbQh_fCeNHCbWc3A,3652
+ca/checks/hardening.py,sha256=fKT690-yj-RKn9403rub0B7H5dvUnNUPYd1vPcSpG5A,3847
+ca/checks/images.py,sha256=dbGx-BIjgq9xamNUkrjYnHm9kUiOyYunTGc5N4kYri8,1601
+ca/checks/privilege.py,sha256=QCx3UVBdmYwWK1_qPVhP04j-GGpNz6v8g0_bBvgdMZE,5646
+ca/cli.py,sha256=Zt9zSaY9N0VIiBtCSn_XraPNoDSMkZZXCRm2HfUVeG8,3812
+ca/collect.py,sha256=ZsYMhyYF8s0UXvVYyg-_QPocY0LqhN9KJ51G7_oiRi4,3669
+ca/docker_cli.py,sha256=6JvZgzfPMj_LGJtn8nSJ5DM6cgsrJe-eNGhHigjhaxw,2623
+ca/models.py,sha256=h9LMfv9wJSHIAs1THM0TOhtmIEBu__bv8SjV7Sm9WU0,3051
+ca/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ca/redact.py,sha256=MS0eZy6YoryxqA8L0J8tebcc5gjlP-byfMk6t5J9qIo,308
+ca/report.py,sha256=_kjFv1tl8So4gr29tU63xlrPs6Irib9TCQ5grF5OyrQ,3571
+docker_host_audit-0.1.1.dist-info/WHEEL,sha256=MWx7psoF7KNST9G72pGtiBYuaXRXQXBk9pw5R6FzYko,80
+docker_host_audit-0.1.1.dist-info/entry_points.txt,sha256=Ksza9Z2cEtVLyVkUVNklyYYkE8iwOJNqUeIV8AmFnSk,81
+docker_host_audit-0.1.1.dist-info/METADATA,sha256=RDrfqGZrLdi8C9xQ4oMorSsh4nZgCgGXu8Mlc6GUbho,13971
+docker_host_audit-0.1.1.dist-info/RECORD,,

docker_host_audit-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.13.7
+Root-Is-Purelib: true
+Tag: py3-none-any

docker_host_audit-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+container-audit = ca.cli:main
+docker-host-audit = ca.cli:main
+