Skip to content

armgit / ODS

Public Imported from GitHub
0

ODS V3 Pre-Release: Public testing and refinement ahead of the official V3 launch. Turn your PC, Mac, or Linux box into a private AI server.

fix(installer): support restrictive DGX device and manifest permissions (#8228)

Mike Bradley25bd8a64d0e6
diff --git a/.github/workflows/test-linux.yml b/.github/workflows/test-linux.yml
index c32eaad6b..2994e8e13 100644
--- a/.github/workflows/test-linux.yml
+++ b/.github/workflows/test-linux.yml
@@ -442,6 +442,11 @@ jobs:
- name: Installer Created Container Ownership Tests
run: bash tests/test-phase11-created-container-ownership.sh
+ - name: Installer Public Manifests and Containerd Device Policy
+ run: |
+ python3 tests/test_containerd_console_policy.py
+ sudo -n env ODS_MIXED_UID_TEST=1 python3 tests/test_public_extension_manifest_permissions.py
+
- name: Dotenv Serializer Tests
run: bash tests/test-dotenv-serializer.sh
diff --git a/ods/installers/lib/containerd-console.sh b/ods/installers/lib/containerd-console.sh
new file mode 100644
index 000000000..847959bad
--- /dev/null
+++ b/ods/installers/lib/containerd-console.sh
@@ -0,0 +1,38 @@
+#!/bin/bash
+# Prepare the known NVIDIA-only containerd device policy before image unpack.
+# Runtime discovery remains in phase 05; the Python helper owns the narrow,
+# revalidated host change and never restarts the daemon.
+ods_prepare_containerd_console() {
+ [[ "${GPU_BACKEND:-}" == nvidia && "${GPU_COUNT:-0}" -gt 0 ]] || return 0
+ [[ "$(uname -s)" == Linux ]] || return 0
+ if [[ "${DRY_RUN:-false}" == true ]]; then
+ log "[DRY RUN] Would check local containerd image-unpack permissions"
+ return 0
+ fi
+ _runtime_is_podman && return 0
+ _docker_is_desktop_engine && return 0
+
+ local endpoint security rc
+ if [[ -n "${DOCKER_HOST:-}" && -z "${DOCKER_CONTEXT:-}" ]]; then
+ endpoint="$DOCKER_HOST"
+ else
+ endpoint="$(docker_run context inspect --format '{{.Endpoints.docker.Host}}')" || return 1
+ fi
+ # Never repair this host for a remote daemon or a rootless user socket.
+ case "$endpoint" in
+ unix:///var/run/docker.sock|unix:///run/docker.sock) ;;
+ *) return 0 ;;
+ esac
+ security="$(docker_run info --format '{{json .SecurityOptions}}')" || return 1
+ [[ "$security" != *rootless* ]] || return 0
+
+ if python3 "$SCRIPT_DIR/scripts/prepare-containerd-console.py" --check; then
+ return 0
+ else
+ rc=$?
+ fi
+ [[ "$rc" == 10 ]] || return "$rc"
+ ai "Allowing containerd to create the standard console node while unpacking images..."
+ ods_sudo python3 "$SCRIPT_DIR/scripts/prepare-containerd-console.py" --apply || return 1
+ ai_ok "Containerd image-unpack permission verified; existing device rules retained"
+}
diff --git a/ods/installers/phases/05-docker.sh b/ods/installers/phases/05-docker.sh
index 54bb14716..622f60e17 100755
--- a/ods/installers/phases/05-docker.sh
+++ b/ods/installers/phases/05-docker.sh
@@ -19,6 +19,8 @@
# shellcheck source=installers/lib/podman-registries.sh
source "$SCRIPT_DIR/installers/lib/podman-registries.sh"
+# shellcheck source=installers/lib/containerd-console.sh
+source "$SCRIPT_DIR/installers/lib/containerd-console.sh"
ods_progress 30 "docker" "Setting up Docker"
show_phase 3 6 "Docker Setup" "~2 minutes"
@@ -672,3 +674,8 @@ fi
if [[ "${ENABLE_PIXEL_RUNTIME:-false}" == true && "$DRY_RUN" != true ]]; then
ods_pixel_check_owner_docker || return 1
fi
+
+ods_prepare_containerd_console || {
+ error "Could not verify containerd image-unpack permissions; review the device-policy diagnostic above."
+ return 1
+}
diff --git a/ods/installers/phases/06-directories.sh b/ods/installers/phases/06-directories.sh
index 0ec6691ac..28627ae72 100755
--- a/ods/installers/phases/06-directories.sh
+++ b/ods/installers/phases/06-directories.sh
@@ -753,6 +753,23 @@ Fix with: sudo chown -R \$(id -u):\$(id -g) $INSTALL_DIR/config $INSTALL_DIR/dat
chmod go-w "$INSTALL_DIR" || error "Could not secure installed root"
unset _installed_code_root
+ # Dashboard runs as a different UID and reads these public bind-mounted
+ # manifests. Keep .env, service-private files and runtime data private.
+ _phase06_step "prepare-extension-manifests"
+ _phase06_manifest_args=()
+ if [[ -n "${ODS_PIXEL_SOURCE_TRANSACTION:-}" ]]; then
+ # Pixel installed candidate file modes from its staged inventory.
+ # Preserve those and retained custom files while preparing traversal.
+ _phase06_manifest_args+=(--preserve-file-modes)
+ fi
+ if ! python3 "$INSTALL_DIR/scripts/prepare-extension-manifests.py" "$INSTALL_DIR" \
+ "${_phase06_manifest_args[@]}" \
+ >> "$LOG_FILE" 2>&1; then
+ error "Could not prepare public service manifests for the Dashboard API. See $LOG_FILE for details."
+ return 1
+ fi
+ unset _phase06_manifest_args
+
# Source staging under umask 077 makes the two public policy bind mounts
# unreadable to APE and remote-provider-egress, which run as non-root.
# Normalize them on fresh and retained installs before Compose starts.
diff --git a/ods/scripts/prepare-containerd-console.py b/ods/scripts/prepare-containerd-console.py
new file mode 100644
index 000000000..b3cb9df65
--- /dev/null
+++ b/ods/scripts/prepare-containerd-console.py
@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""Narrow ODS repair: add DeviceAllow=/dev/console m to containerd.
+
+Scope: Linux, rootful Docker, NVIDIA-only DeviceAllow policy on containerd.
+Only repairs the exact known auto+nonempty+NVIDIA-only+rwm case by adding
+an owned drop-in with `DeviceAllow=/dev/console m` (create-only, never rwm).
+Never restarts containerd, never edits vendor drop-ins, never touches
+DevicePolicy or existing DeviceAllow entries.
+
+Usage:
+ prepare-containerd-console.py [--check | --apply]
+
+Exit codes:
+ 0 no repair needed (or apply succeeded)
+ 10 repair needed (--check only)
+ 1 error / refused / apply failed
+"""
+
+import argparse
+import os
+import re
+import stat
+import subprocess
+import sys
+
+UNIT = "containerd.service"
+DROPIN_DIR = "/etc/systemd/system/containerd.service.d"
+DROPIN_PATH = os.path.join(DROPIN_DIR, "90-ods-image-unpack.conf")
+DROPIN_CONTENT = (
+ "# Managed by ODS: allow image unpack to create /dev/console (mknodat).\n"
+ "# Create-only; never grants read/write on /dev/console.\n"
+ "[Service]\n"
+ "DeviceAllow=/dev/console m\n"
+)
+
+# Known NVIDIA-only DeviceAllow patterns (device path, perms).
+_NVIDIA_DEV_RE = re.compile(r"^/dev/nvidia(?:[A-Za-z0-9_/-]*)$")
+_NVIDIA_CAPS_RE = re.compile(r"^char-nvidia-caps$")
+
+
+def _run_systemctl_show():
+ """Return dict of systemctl show properties for containerd.service."""
+ try:
+ proc = subprocess.run(
+ ["systemctl", "show", UNIT,
+ "--property=ActiveState",
+ "--property=DevicePolicy",
+ "--property=DeviceAllow"],
+ capture_output=True, text=True, check=True, timeout=15,
+ )
+ except FileNotFoundError:
+ return None
+ props: dict[str, list[str]] = {}
+ for line in proc.stdout.splitlines():
+ if "=" not in line:
+ continue
+ key, _, val = line.partition("=")
+ props.setdefault(key, []).append(val)
+ return props
+
+
+def _parse_device_allow(entries):
+ """Parse repeated DeviceAllow= values into [(device, perms), ...].
+
+ Each entry is 'device perms' with perms at the last space.
+ """
+ out = []
+ for raw in entries:
+ raw = raw.strip()
+ if not raw:
+ continue
+ idx = raw.rfind(" ")
+ if idx <= 0:
+ out.append((raw, ""))
+ else:
+ out.append((raw[:idx], raw[idx + 1:]))
+ return out
+
+
+def _is_nvidia_only(entries):
+ """True iff every entry is a known NVIDIA pattern with rwm perms."""
+ if not entries:
+ return False
+ for dev, perms in entries:
+ if perms != "rwm":
+ return False
+ if _NVIDIA_DEV_RE.match(dev):
+ continue
+ if _NVIDIA_CAPS_RE.match(dev):
+ continue
+ return False
+ return True
+
+
+def _has_console_m(entries):
+ for dev, perms in entries:
+ if dev == "/dev/console" and "m" in perms:
+ return True
+ return False
+
+
+def classify(props):
+ """Return (needs_repair: bool, reason: str)."""
+ if props is None:
+ return False, "systemctl unavailable or unit not queryable"
+ active = (props.get("ActiveState") or [""])[0]
+ if active != "active":
+ return False, "containerd.service not active (%s)" % (active or "unknown")
+ policy = (props.get("DevicePolicy") or [""])[0]
+ if policy != "auto":
+ return False, "DevicePolicy=%s (not auto); manual review if image unpack fails" % (policy or "unknown")
+ entries = _parse_device_allow(props.get("DeviceAllow") or [])
+ if not entries:
+ return False, "DeviceAllow empty (unrestricted); no repair"
+ if _has_console_m(entries):
+ return False, "already has DeviceAllow=/dev/console m"
+ if not _is_nvidia_only(entries):
+ return False, "custom/closed DeviceAllow policy; manual review if image unpack fails"
+ return True, "NVIDIA-only DeviceAllow with rwm; /dev/console m missing"
+
+
+def _is_root():
+ return os.geteuid() == 0
+
+
+def _read_existing():
+ """Return (state, content) where state in {'absent','owned','foreign','symlink'}."""
+ try:
+ st = os.lstat(DROPIN_PATH)
+ except FileNotFoundError:
+ return "absent", None
+ if stat.S_ISLNK(st.st_mode):
+ return "symlink", None
+ if (not stat.S_ISREG(st.st_mode) or st.st_nlink != 1
+ or st.st_uid != os.geteuid() or stat.S_IMODE(st.st_mode) & 0o022):
+ return "foreign", None
+ with open(DROPIN_PATH, "r", encoding="utf-8") as f:
+ content = f.read()
+ if content == DROPIN_CONTENT:
+ return "owned", content
+ return "foreign", content
+
+
+def _ensure_dir():
+ if os.path.islink(DROPIN_DIR):
+ raise RuntimeError("refusing: %s is a symlink" % DROPIN_DIR)
+ if not os.path.isdir(DROPIN_DIR):
+ os.makedirs(DROPIN_DIR, mode=0o755, exist_ok=True)
+ os.chmod(DROPIN_DIR, 0o755)
+ if os.path.islink(DROPIN_DIR):
+ raise RuntimeError("refusing: %s became a symlink" % DROPIN_DIR)
+ st = os.stat(DROPIN_DIR)
+ if st.st_uid != os.geteuid() or stat.S_IMODE(st.st_mode) & 0o022:
+ raise RuntimeError("refusing: containerd drop-in directory is not owner-controlled")
+
+
+def _write_owned():
+ """Create the owned drop-in atomically with O_EXCL/O_NOFOLLOW."""
+ _ensure_dir()
+ flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL
+ if hasattr(os, "O_NOFOLLOW"):
+ flags |= os.O_NOFOLLOW
+ fd = os.open(DROPIN_PATH, flags, 0o644)
+ with os.fdopen(fd, "w", encoding="utf-8") as stream:
+ os.fchmod(fd, 0o644)
+ stream.write(DROPIN_CONTENT)
+ stream.flush()
+ os.fsync(fd)
+
+
+def _daemon_reload():
+ proc = subprocess.run(
+ ["systemctl", "daemon-reload"],
+ capture_output=True, text=True, check=False, timeout=15,
+ )
+ if proc.returncode != 0:
+ raise RuntimeError("systemctl daemon-reload failed: %s" % (proc.stderr.strip() or proc.returncode))
+
+
+def _verify_after_apply(old_entries):
+ props = _run_systemctl_show()
+ if props is None:
+ raise RuntimeError("cannot verify: systemctl show failed after apply")
+ active = (props.get("ActiveState") or [""])[0]
+ if active != "active":
+ raise RuntimeError("containerd.service not active after apply (%s)" % (active or "unknown"))
+ if props.get("DevicePolicy") != ["auto"]:
+ raise RuntimeError("containerd DevicePolicy changed during repair; review host policy")
+ new_entries = _parse_device_allow(props.get("DeviceAllow") or [])
+ if not _has_console_m(new_entries):
+ raise RuntimeError("effective DeviceAllow missing /dev/console m after apply")
+ new_set = set(new_entries)
+ for e in old_entries:
+ if e not in new_set:
+ raise RuntimeError("effective DeviceAllow lost prior entry %r" % (e,))
+
+
+def do_check():
+ props = _run_systemctl_show()
+ needs, reason = classify(props)
+ print("containerd console policy: %s" % reason)
+ return 10 if needs else 0
+
+
+def do_apply():
+ props = _run_systemctl_show()
+ needs, reason = classify(props)
+ if not needs:
+ print("containerd console policy: %s" % reason)
+ return 0
+ if not _is_root():
+ print("error: --apply requires root", file=sys.stderr)
+ return 1
+
+ old_entries = _parse_device_allow(props.get("DeviceAllow") or [])
+ try:
+ _ensure_dir()
+ except (OSError, RuntimeError) as exc:
+ print("error: unsafe drop-in directory: %s" % exc, file=sys.stderr)
+ return 1
+ state, _ = _read_existing()
+ if state == "symlink":
+ print("error: refusing: %s is a symlink" % DROPIN_PATH, file=sys.stderr)
+ return 1
+ if state == "foreign":
+ print("error: refusing: %s exists with foreign content" % DROPIN_PATH, file=sys.stderr)
+ return 1
+
+ if state == "absent":
+ try:
+ _write_owned()
+ except FileExistsError:
+ # Race: someone created it; re-check ownership.
+ state2, _ = _read_existing()
+ if state2 != "owned":
+ print("error: refusing: %s appeared with foreign content" % DROPIN_PATH, file=sys.stderr)
+ return 1
+ except (OSError, RuntimeError) as e:
+ print("error: write failed: %s" % e, file=sys.stderr)
+ return 1
+ # state == 'owned': retry daemon-reload (safe idempotent path).
+
+ try:
+ _daemon_reload()
+ _verify_after_apply(old_entries)
+ except RuntimeError as e:
+ print("error: %s" % e, file=sys.stderr)
+ return 1
+
+ print("containerd console policy: repaired (DeviceAllow=/dev/console m)")
+ return 0
+
+
+def main(argv=None):
+ if not sys.platform.startswith("linux"):
+ print("containerd console policy: only applicable to Linux")
+ return 0
+ parser = argparse.ArgumentParser(description=__doc__)
+ g = parser.add_mutually_exclusive_group()
+ g.add_argument("--check", action="store_true", help="report whether repair is needed (default)")
+ g.add_argument("--apply", action="store_true", help="apply the repair")
+ args = parser.parse_args(argv)
+ if args.apply:
+ return do_apply()
+ return do_check()
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/ods/scripts/prepare-extension-manifests.py b/ods/scripts/prepare-extension-manifests.py
new file mode 100644
index 000000000..70716e706
--- /dev/null
+++ b/ods/scripts/prepare-extension-manifests.py
@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+"""Prepare public extension manifest permissions for ODS runtime bind-mounts.
+
+Root cause: with umask 077, copied extensions/services/ape directory is 0700 and
+manifest.yaml is 0600. The rootless dashboard-api (UID 1000) then fails in
+config.load_extension_manifests at candidate.exists()/read_text().
+
+This script only fixes the runtime manifest bind-mount surface:
+ - root extensions/services ancestors: traversal only (add x, remove g/o w)
+ - services root: 0755
+ - service child dirs: traversal only (add x, remove g/o w)
+ - public manifest files (manifest.yaml/.yml/.json): 0644
+
+It validates the full scoped tree before any mutation, refuses symlinks,
+special files, hardlinked manifests, and wrong path types. It does not descend
+into child dirs except for the listed manifest leaves. Private files such as
+private.key (0600) and unrelated dirs are left untouched.
+
+POSIX only. CLI: prepare-extension-manifests.py <install_dir>
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import stat
+import sys
+from pathlib import Path
+
+MANIFEST_NAMES = ("manifest.yaml", "manifest.yml", "manifest.json")
+
+
+class ManifestPermissionError(Exception):
+ """Actionable error for manifest permission preparation."""
+
+
+class _Plan:
+ def __init__(self) -> None:
+ # path -> target mode
+ self.modes: dict[Path, int] = {}
+ self.identities: dict[Path, tuple[int, int]] = {}
+ self.manifest_count = 0
+
+ def add(self, path: Path, mode: int) -> None:
+ self.modes[path] = mode
+ entry = os.lstat(path)
+ self.identities[path] = (entry.st_dev, entry.st_ino)
+
+
+def _lstat(path: Path) -> os.stat_result:
+ try:
+ return os.lstat(path)
+ except FileNotFoundError as exc:
+ raise ManifestPermissionError(f"required path missing: {path}") from exc
+ except OSError as exc:
+ raise ManifestPermissionError(f"cannot stat {path}: {exc}") from exc
+
+
+def _require_dir(path: Path, label: str) -> os.stat_result:
+ st = _lstat(path)
+ if stat.S_ISLNK(st.st_mode):
+ raise ManifestPermissionError(f"{label} is a symlink (refused): {path}")
+ if not stat.S_ISDIR(st.st_mode):
+ raise ManifestPermissionError(f"{label} is not a directory: {path}")
+ return st
+
+
+def _require_regular_manifest(path: Path) -> os.stat_result:
+ st = _lstat(path)
+ if stat.S_ISLNK(st.st_mode):
+ raise ManifestPermissionError(f"manifest is a symlink (refused): {path}")
+ if not stat.S_ISREG(st.st_mode):
+ raise ManifestPermissionError(f"manifest is not a regular file: {path}")
+ if st.st_nlink != 1:
+ raise ManifestPermissionError(
+ f"manifest is hardlinked (st_nlink={st.st_nlink}, refused): {path}"
+ )
+ return st
+
+
+def _dir_traversal_mode(st_mode: int) -> int:
+ """Keep existing read bits, add execute, remove group/other write."""
+ mode = stat.S_IMODE(st_mode)
+ mode |= stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
+ mode &= ~(stat.S_IWGRP | stat.S_IWOTH)
+ return mode
+
+
+def _services_root_mode(st_mode: int) -> int:
+ """Services root must be 0755."""
+ del st_mode
+ return 0o755
+
+
+def _manifest_mode(st_mode: int) -> int:
+ """Public manifest files must be 0644."""
+ del st_mode
+ return 0o644
+
+
+def _validate_ancestor(path: Path, label: str) -> None:
+ _require_dir(path, label)
+
+
+def _build_plan(install_dir: Path, *, preserve_file_modes: bool = False) -> _Plan:
+ plan = _Plan()
+
+ if not install_dir.is_absolute():
+ # abspath preserves a final symlink so validation can reject it.
+ install_dir = Path(os.path.abspath(install_dir))
+
+ # Only the installation and its children belong to this repair.
+ _validate_ancestor(install_dir, "install_dir")
+
+ extensions = install_dir / "extensions"
+ services = extensions / "services"
+
+ _validate_ancestor(extensions, "extensions dir")
+ _validate_ancestor(services, "services dir")
+
+ # Root and extensions: traversal only.
+ plan.add(install_dir, _dir_traversal_mode(_lstat(install_dir).st_mode))
+ plan.add(extensions, _dir_traversal_mode(_lstat(extensions).st_mode))
+
+ # Services root: 0755.
+ plan.add(services, _services_root_mode(_lstat(services).st_mode))
+
+ # Enumerate service child dirs (no descent beyond this level).
+ try:
+ entries = list(os.scandir(services))
+ except OSError as exc:
+ raise ManifestPermissionError(f"cannot list services dir {services}: {exc}") from exc
+
+ for entry in entries:
+ child = Path(entry.path)
+ try:
+ st = entry.stat(follow_symlinks=False)
+ except OSError as exc:
+ raise ManifestPermissionError(f"cannot stat service entry {child}: {exc}") from exc
+
+ if stat.S_ISLNK(st.st_mode):
+ raise ManifestPermissionError(f"service child is a symlink (refused): {child}")
+ if not stat.S_ISDIR(st.st_mode):
+ # Match the service loader: files beside service directories are
+ # not service packages and are outside this permission repair.
+ continue
+
+ plan.add(child, _dir_traversal_mode(st.st_mode))
+
+ # Only inspect listed manifest leaves; do not descend further.
+ for name in MANIFEST_NAMES:
+ manifest = child / name
+ try:
+ mst = _require_regular_manifest(manifest)
+ except ManifestPermissionError as exc:
+ # Missing manifest is okay; other errors are not.
+ if isinstance(exc.__cause__, FileNotFoundError):
+ continue
+ raise
+ mode = stat.S_IMODE(mst.st_mode)
+ if preserve_file_modes:
+ # Pixel's staged source inventory owns file modes during an
+ # upgrade. Candidates are already normalized to 0644/0755;
+ # retained custom files must not drift from that inventory.
+ if mode & 0o444 != 0o444 or mode & 0o022:
+ raise ManifestPermissionError(
+ f"public manifest is unreadable under a protected source "
+ f"transaction: {manifest}; preserve the pending upgrade "
+ "and resolve its source permissions before retrying"
+ )
+ else:
+ mode = _manifest_mode(mst.st_mode)
+ plan.add(manifest, mode)
+ plan.manifest_count += 1
+
+ return plan
+
+
+def _apply_plan(plan: _Plan) -> int:
+ changed = 0
+ for path, target in plan.modes.items():
+ try:
+ current = stat.S_IMODE(os.lstat(path).st_mode)
+ except OSError as exc:
+ raise ManifestPermissionError(f"cannot stat {path} before chmod: {exc}") from exc
+ if current == target:
+ continue
+ try:
+ # Do not follow a leaf replaced with a symlink after validation.
+ fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)
+ try:
+ opened = os.fstat(fd)
+ if (opened.st_dev, opened.st_ino) != plan.identities[path]:
+ raise ManifestPermissionError(f"path was replaced before chmod: {path}")
+ if not (stat.S_ISDIR(opened.st_mode) or stat.S_ISREG(opened.st_mode)):
+ raise ManifestPermissionError(f"path type changed before chmod: {path}")
+ if stat.S_ISREG(opened.st_mode) and opened.st_nlink != 1:
+ raise ManifestPermissionError(f"manifest became hardlinked: {path}")
+ os.fchmod(fd, target)
+ finally:
+ os.close(fd)
+ except OSError as exc:
+ raise ManifestPermissionError(
+ f"cannot chmod {path} from {oct(current)} to {oct(target)}: {exc}"
+ ) from exc
+ changed += 1
+ return changed
+
+
+def prepare(install_dir: Path, *, preserve_file_modes: bool = False) -> tuple[int, int]:
+ plan = _build_plan(install_dir, preserve_file_modes=preserve_file_modes)
+ changed = _apply_plan(plan)
+ return plan.manifest_count, changed
+
+
+def main(argv: list[str]) -> int:
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("install_dir", type=Path)
+ parser.add_argument("--preserve-file-modes", action="store_true",
+ help="validate protected source modes without changing manifest files")
+ args = parser.parse_args(argv[1:])
+ try:
+ manifest_count, changed = prepare(args.install_dir, preserve_file_modes=args.preserve_file_modes)
+ except ManifestPermissionError as exc:
+ print(f"error: {exc}", file=sys.stderr)
+ return 1
+
+ print(
+ f"prepare-extension-manifests: {manifest_count} manifest(s) validated, "
+ f"{changed} path(s) updated"
+ )
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main(sys.argv))
diff --git a/ods/tests/bats-tests/docker-phase.bats b/ods/tests/bats-tests/docker-phase.bats
index e2b927607..251d77a3e 100644
--- a/ods/tests/bats-tests/docker-phase.bats
+++ b/ods/tests/bats-tests/docker-phase.bats
@@ -37,7 +37,10 @@ setup() {
export DOCKER_COMPOSE_CMD=""
export DOCKER_NEEDS_SUDO=false
- mkdir -p "$SCRIPT_DIR"
+ mkdir -p "$SCRIPT_DIR/installers/lib"
+ cp "$BATS_TEST_DIRNAME/../../installers/lib/podman-registries.sh" \
+ "$BATS_TEST_DIRNAME/../../installers/lib/containerd-console.sh" \
+ "$SCRIPT_DIR/installers/lib/"
touch "$LOG_FILE"
}
diff --git a/ods/tests/ci-suite.txt b/ods/tests/ci-suite.txt
index 5217df499..6cf72d6e8 100644
--- a/ods/tests/ci-suite.txt
+++ b/ods/tests/ci-suite.txt
@@ -265,6 +265,8 @@ tests/test_build_installation_context_port.py
tests/test_chromadb_healthcheck.py
tests/test_cleanup_wsl_pixel_mounts.py
tests/test_compose_failure_report_port_check.py
+tests/test_containerd_console_policy.py
+tests/test_public_extension_manifest_permissions.py
tests/test_extension_audit_library.py
tests/test_generate_llama_architectures.py
tests/test_healthcheck_redirect_policy.py
diff --git a/ods/tests/test_containerd_console_policy.py b/ods/tests/test_containerd_console_policy.py
new file mode 100644
index 000000000..fe57ff883
--- /dev/null
+++ b/ods/tests/test_containerd_console_policy.py
@@ -0,0 +1,354 @@
+#!/usr/bin/env python3
+"""Unit tests for ods/scripts/prepare-containerd-console.py."""
+
+import importlib.util
+import os
+import subprocess
+import tempfile
+import unittest
+from unittest import mock
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+_SCRIPT = os.path.join(_HERE, "..", "scripts", "prepare-containerd-console.py")
+
+
+def _load_module():
+ spec = importlib.util.spec_from_file_location("ods_prepare_containerd_console", _SCRIPT)
+ mod = importlib.util.module_from_spec(spec)
+ spec.loader.exec_module(mod)
+ return mod
+
+
+class _FakeProc:
+ def __init__(self, returncode=0, stdout="", stderr=""):
+ self.returncode = returncode
+ self.stdout = stdout
+ self.stderr = stderr
+
+
+NVIDIA_ONLY_SHOW = (
+ "ActiveState=active\n"
+ "DevicePolicy=auto\n"
+ "DeviceAllow=/dev/nvidia0 rwm\n"
+ "DeviceAllow=/dev/nvidiactl rwm\n"
+ "DeviceAllow=char-nvidia-caps rwm\n"
+)
+
+NVIDIA_WITH_CONSOLE_SHOW = NVIDIA_ONLY_SHOW + "DeviceAllow=/dev/console m\n"
+
+CUSTOM_SHOW = (
+ "ActiveState=active\n"
+ "DevicePolicy=auto\n"
+ "DeviceAllow=/dev/nvidia0 rwm\n"
+ "DeviceAllow=/dev/dri/card0 rwm\n"
+)
+
+STRICT_SHOW = (
+ "ActiveState=active\n"
+ "DevicePolicy=closed\n"
+ "DeviceAllow=/dev/nvidia0 rwm\n"
+)
+
+EMPTY_SHOW = (
+ "ActiveState=active\n"
+ "DevicePolicy=auto\n"
+ "DeviceAllow=\n"
+)
+
+INACTIVE_SHOW = (
+ "ActiveState=inactive\n"
+ "DevicePolicy=auto\n"
+ "DeviceAllow=/dev/nvidia0 rwm\n"
+)
+
+
+class ContainerdConsolePolicyTests(unittest.TestCase):
+ def setUp(self):
+ self.mod = _load_module()
+ self.tmp = tempfile.TemporaryDirectory()
+ self.addCleanup(self.tmp.cleanup)
+ self.dropin_dir = os.path.join(self.tmp.name, "containerd.service.d")
+ self.dropin_path = os.path.join(self.dropin_dir, "90-ods-image-unpack.conf")
+ self.mod.DROPIN_DIR = self.dropin_dir
+ self.mod.DROPIN_PATH = self.dropin_path
+
+ def _patch_show(self, stdout, returncode=0):
+ return mock.patch.object(
+ self.mod.subprocess, "run",
+ return_value=_FakeProc(returncode=returncode, stdout=stdout),
+ )
+
+ def _patch_run_sequence(self, *procs):
+ return mock.patch.object(
+ self.mod.subprocess, "run",
+ side_effect=list(procs),
+ )
+
+ def test_check_nvidia_only_needs_repair(self):
+ with self._patch_show(NVIDIA_ONLY_SHOW):
+ rc = self.mod.main(["--check"])
+ self.assertEqual(rc, 10)
+ self.assertFalse(os.path.exists(self.dropin_path))
+
+ def test_check_already_has_console_m(self):
+ with self._patch_show(NVIDIA_WITH_CONSOLE_SHOW):
+ rc = self.mod.main(["--check"])
+ self.assertEqual(rc, 0)
+
+ def test_existing_broader_console_permission_is_not_rewritten(self):
+ with self._patch_show(NVIDIA_ONLY_SHOW + "DeviceAllow=/dev/console rwm\n"):
+ self.assertEqual(self.mod.main(["--apply"]), 0)
+ self.assertFalse(os.path.exists(self.dropin_path))
+
+ def test_systemctl_failure_is_not_reported_as_success(self):
+ with mock.patch.object(self.mod.subprocess, "run", side_effect=subprocess.CalledProcessError(1, "systemctl")):
+ with self.assertRaises(subprocess.CalledProcessError):
+ self.mod.main(["--check"])
+
+ def test_check_custom_policy_no_change(self):
+ with self._patch_show(CUSTOM_SHOW):
+ rc = self.mod.main(["--check"])
+ self.assertEqual(rc, 0)
+
+ def test_check_strict_policy_no_change(self):
+ with self._patch_show(STRICT_SHOW):
+ rc = self.mod.main(["--check"])
+ self.assertEqual(rc, 0)
+
+ def test_check_empty_allow_no_change(self):
+ with self._patch_show(EMPTY_SHOW):
+ rc = self.mod.main(["--check"])
+ self.assertEqual(rc, 0)
+
+ def test_check_inactive_no_change(self):
+ with self._patch_show(INACTIVE_SHOW):
+ rc = self.mod.main(["--check"])
+ self.assertEqual(rc, 0)
+
+ def test_check_no_writes(self):
+ with self._patch_show(NVIDIA_ONLY_SHOW):
+ self.mod.main(["--check"])
+ self.assertFalse(os.path.exists(self.dropin_dir))
+
+ def test_apply_creates_owned_dropin_with_m_only(self):
+ with mock.patch.object(self.mod, "_is_root", return_value=True), \
+ self._patch_run_sequence(
+ _FakeProc(stdout=NVIDIA_ONLY_SHOW),
+ _FakeProc(returncode=0),
+ _FakeProc(stdout=NVIDIA_WITH_CONSOLE_SHOW),
+ ):
+ rc = self.mod.main(["--apply"])
+ self.assertEqual(rc, 0)
+ with open(self.dropin_path, "r", encoding="utf-8") as f:
+ content = f.read()
+ self.assertIn("DeviceAllow=/dev/console m\n", content)
+ self.assertNotIn("rwm", content)
+ self.assertEqual(content, self.mod.DROPIN_CONTENT)
+ self.assertEqual(os.stat(self.dropin_path).st_mode & 0o777, 0o644)
+
+ def test_apply_requires_root(self):
+ with mock.patch.object(self.mod, "_is_root", return_value=False), \
+ self._patch_show(NVIDIA_ONLY_SHOW):
+ rc = self.mod.main(["--apply"])
+ self.assertEqual(rc, 1)
+ self.assertFalse(os.path.exists(self.dropin_path))
+
+ def test_apply_idempotent_when_already_repaired(self):
+ with self._patch_show(NVIDIA_WITH_CONSOLE_SHOW):
+ rc = self.mod.main(["--apply"])
+ self.assertEqual(rc, 0)
+ self.assertFalse(os.path.exists(self.dropin_path))
+
+ def test_apply_refuses_foreign_file(self):
+ os.makedirs(self.dropin_dir)
+ with open(self.dropin_path, "w", encoding="utf-8") as f:
+ f.write("[Service]\nDeviceAllow=/dev/console rwm\n")
+ with mock.patch.object(self.mod, "_is_root", return_value=True), \
+ self._patch_show(NVIDIA_ONLY_SHOW):
+ rc = self.mod.main(["--apply"])
+ self.assertEqual(rc, 1)
+ with open(self.dropin_path, "r", encoding="utf-8") as f:
+ self.assertIn("rwm", f.read())
+
+ def test_apply_preserves_vendor_file(self):
+ os.makedirs(self.dropin_dir)
+ vendor = os.path.join(self.dropin_dir, "containerd-override.conf")
+ original = "[Service]\nDeviceAllow=/dev/nvidia0\n"
+ with open(vendor, "w", encoding="utf-8") as stream:
+ stream.write(original)
+ with mock.patch.object(self.mod, "_is_root", return_value=True), self._patch_run_sequence(
+ _FakeProc(stdout=NVIDIA_ONLY_SHOW), _FakeProc(), _FakeProc(stdout=NVIDIA_WITH_CONSOLE_SHOW)
+ ):
+ self.assertEqual(self.mod.main(["--apply"]), 0)
+ with open(vendor, encoding="utf-8") as stream:
+ self.assertEqual(stream.read(), original)
+
+ def test_apply_refuses_symlink(self):
+ os.makedirs(self.dropin_dir)
+ target = os.path.join(self.tmp.name, "target.conf")
+ with open(target, "w", encoding="utf-8") as f:
+ f.write("x")
+ os.symlink(target, self.dropin_path)
+ with mock.patch.object(self.mod, "_is_root", return_value=True), \
+ self._patch_show(NVIDIA_ONLY_SHOW):
+ rc = self.mod.main(["--apply"])
+ self.assertEqual(rc, 1)
+ self.assertTrue(os.path.islink(self.dropin_path))
+
+ def test_apply_refuses_symlink_dir(self):
+ real_dir = os.path.join(self.tmp.name, "real")
+ os.makedirs(real_dir)
+ os.symlink(real_dir, self.dropin_dir)
+ with mock.patch.object(self.mod, "_is_root", return_value=True), \
+ self._patch_show(NVIDIA_ONLY_SHOW):
+ rc = self.mod.main(["--apply"])
+ self.assertEqual(rc, 1)
+ self.assertFalse(os.path.exists(os.path.join(real_dir, "90-ods-image-unpack.conf")))
+
+ def test_apply_reload_failure_returns_error_and_retry_succeeds(self):
+ with mock.patch.object(self.mod, "_is_root", return_value=True), \
+ self._patch_run_sequence(
+ _FakeProc(stdout=NVIDIA_ONLY_SHOW),
+ _FakeProc(returncode=1, stderr="boom"),
+ ):
+ rc = self.mod.main(["--apply"])
+ self.assertEqual(rc, 1)
+ self.assertTrue(os.path.exists(self.dropin_path))
+
+ # Retry: owned file exists, daemon-reload succeeds, verify passes.
+ with mock.patch.object(self.mod, "_is_root", return_value=True), \
+ self._patch_run_sequence(
+ _FakeProc(stdout=NVIDIA_ONLY_SHOW),
+ _FakeProc(returncode=0),
+ _FakeProc(stdout=NVIDIA_WITH_CONSOLE_SHOW),
+ ):
+ rc = self.mod.main(["--apply"])
+ self.assertEqual(rc, 0)
+
+ def test_apply_verify_fails_if_console_missing(self):
+ with mock.patch.object(self.mod, "_is_root", return_value=True), \
+ self._patch_run_sequence(
+ _FakeProc(stdout=NVIDIA_ONLY_SHOW),
+ _FakeProc(returncode=0),
+ _FakeProc(stdout=NVIDIA_ONLY_SHOW),
+ ):
+ rc = self.mod.main(["--apply"])
+ self.assertEqual(rc, 1)
+
+ def test_apply_verify_fails_if_old_entry_lost(self):
+ lost = (
+ "ActiveState=active\n"
+ "DevicePolicy=auto\n"
+ "DeviceAllow=/dev/console m\n"
+ )
+ with mock.patch.object(self.mod, "_is_root", return_value=True), \
+ self._patch_run_sequence(
+ _FakeProc(stdout=NVIDIA_ONLY_SHOW),
+ _FakeProc(returncode=0),
+ _FakeProc(stdout=lost),
+ ):
+ rc = self.mod.main(["--apply"])
+ self.assertEqual(rc, 1)
+
+ def test_apply_never_calls_restart_or_stop(self):
+ calls = []
+ state = {"shows": 0}
+
+ def fake_run(cmd, **kwargs):
+ calls.append(list(cmd))
+ if cmd[:2] == ["systemctl", "show"]:
+ state["shows"] += 1
+ return _FakeProc(stdout=NVIDIA_ONLY_SHOW if state["shows"] == 1 else NVIDIA_WITH_CONSOLE_SHOW)
+ return _FakeProc(returncode=0)
+
+ with mock.patch.object(self.mod, "_is_root", return_value=True), \
+ mock.patch.object(self.mod.subprocess, "run", side_effect=fake_run):
+ rc = self.mod.main(["--apply"])
+ self.assertEqual(rc, 0)
+ for c in calls:
+ self.assertNotIn("restart", c)
+ self.assertNotIn("stop", c)
+ self.assertNotIn("start", c)
+
+ def test_parse_device_allow_repeated_keys(self):
+ entries = self.mod._parse_device_allow([
+ "/dev/nvidia0 rwm",
+ "/dev/nvidiactl rwm",
+ "char-nvidia-caps rwm",
+ ])
+ self.assertEqual(entries, [
+ ("/dev/nvidia0", "rwm"),
+ ("/dev/nvidiactl", "rwm"),
+ ("char-nvidia-caps", "rwm"),
+ ])
+
+ def test_nvidia_patterns(self):
+ self.assertTrue(self.mod._NVIDIA_DEV_RE.match("/dev/nvidia0"))
+ self.assertTrue(self.mod._NVIDIA_DEV_RE.match("/dev/nvidiactl"))
+ self.assertTrue(self.mod._NVIDIA_DEV_RE.match("/dev/nvidia-caps/nvidia-cap1"))
+ self.assertFalse(self.mod._NVIDIA_DEV_RE.match("/dev/dri/card0"))
+ self.assertFalse(self.mod._NVIDIA_DEV_RE.match("/dev/nvidia0/../dri"))
+
+
+class InstallerRuntimeGateTests(unittest.TestCase):
+ def run_gate(self, **overrides):
+ with tempfile.TemporaryDirectory() as directory:
+ env = dict(os.environ, GPU_BACKEND="nvidia", GPU_COUNT="2", DRY_RUN="false",
+ PODMAN="1", DESKTOP="1", ENDPOINT="unix:///var/run/docker.sock",
+ SECURITY='["name=apparmor"]', CHECK_RC="10", APPLY_RC="0",
+ CALLS=os.path.join(directory, "calls"), DOCKER_HOST="", DOCKER_CONTEXT="")
+ env.update(overrides)
+ wrapper = os.path.abspath(os.path.join(_HERE, "..", "installers", "lib", "containerd-console.sh"))
+ script = r'''
+set -euo pipefail
+source "$1"
+SCRIPT_DIR=/reviewed-source
+uname() { printf 'Linux\n'; }
+_runtime_is_podman() { return "$PODMAN"; }
+_docker_is_desktop_engine() { return "$DESKTOP"; }
+log() { :; }
+ai() { :; }
+ai_ok() { :; }
+docker_run() {
+ if [[ "$1" == context ]]; then printf '%s\n' "$ENDPOINT";
+ else printf '%s\n' "$SECURITY"; fi
+}
+python3() { printf 'check\n' >> "$CALLS"; return "$CHECK_RC"; }
+ods_sudo() { printf 'apply\n' >> "$CALLS"; return "$APPLY_RC"; }
+ods_prepare_containerd_console
+'''
+ result = subprocess.run(["bash", "-c", script, "_", wrapper], env=env, capture_output=True, text=True)
+ calls = []
+ if os.path.exists(env["CALLS"]):
+ with open(env["CALLS"], encoding="utf-8") as stream:
+ calls = stream.read().splitlines()
+ return result.returncode, calls
+
+ def test_local_nvidia_requires_check_before_apply(self):
+ self.assertEqual(self.run_gate(), (0, ["check", "apply"]))
+
+ def test_unsupported_runtime_never_applies_host_change(self):
+ for values in [dict(GPU_BACKEND="cpu"), dict(DRY_RUN="true"), dict(PODMAN="0"),
+ dict(DESKTOP="0"), dict(ENDPOINT="ssh://remote"),
+ dict(DOCKER_HOST="tcp://remote:2375"),
+ dict(ENDPOINT="unix:///run/user/1000/docker.sock"),
+ dict(SECURITY='["name=rootless"]')]:
+ with self.subTest(values=values):
+ self.assertEqual(self.run_gate(**values), (0, []))
+
+ def test_failed_check_or_apply_fails_phase(self):
+ self.assertEqual(self.run_gate(CHECK_RC="2"), (2, ["check"]))
+ self.assertEqual(self.run_gate(APPLY_RC="1"), (1, ["check", "apply"]))
+
+ def test_already_ready_does_not_request_sudo(self):
+ self.assertEqual(self.run_gate(CHECK_RC="0"), (0, ["check"]))
+
+ def test_explicit_context_takes_precedence_over_docker_host(self):
+ self.assertEqual(self.run_gate(DOCKER_HOST="unix:///var/run/docker.sock",
+ DOCKER_CONTEXT="remote", ENDPOINT="ssh://remote"), (0, []))
+ self.assertEqual(self.run_gate(DOCKER_HOST="tcp://ignored:2375", DOCKER_CONTEXT="default"),
+ (0, ["check", "apply"]))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/ods/tests/test_public_extension_manifest_permissions.py b/ods/tests/test_public_extension_manifest_permissions.py
new file mode 100644
index 000000000..68b546487
--- /dev/null
+++ b/ods/tests/test_public_extension_manifest_permissions.py
@@ -0,0 +1,378 @@
+#!/usr/bin/env python3
+"""Tests for ods/scripts/prepare-extension-manifests.py.
+
+Covers:
+ - real temp dirs with umask 077 and 022
+ - in-place rerun and idempotence
+ - private file modes unchanged (private.key 0600)
+ - all three manifest extensions
+ - symlink / fifo / hardlink refusal before any mode changes
+ - invalid root refusal
+ - mixed-UID actual read (optional, skipped unless env set)
+
+Run: python3 -m unittest ods/tests/test_public_extension_manifest_permissions.py
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+import stat
+import tempfile
+import unittest
+from pathlib import Path
+
+
+_HERE = Path(__file__).resolve()
+_SCRIPT = _HERE.parent.parent / "scripts" / "prepare-extension-manifests.py"
+
+
+def _load_module():
+ spec = importlib.util.spec_from_file_location(
+ "prepare_extension_manifests", _SCRIPT
+ )
+ if spec is None or spec.loader is None:
+ raise RuntimeError(f"cannot load {_SCRIPT}")
+ module = importlib.util.module_from_spec(spec)
+ spec.loader.exec_module(module)
+ return module
+
+
+_mod = _load_module()
+
+
+class _Umask:
+ def __init__(self, mask: int) -> None:
+ self.mask = mask
+ self.prev = None
+
+ def __enter__(self):
+ self.prev = os.umask(self.mask)
+ return self
+
+ def __exit__(self, *exc):
+ os.umask(self.prev)
+ return False
+
+
+def _mode(path: Path) -> int:
+ return stat.S_IMODE(os.lstat(path).st_mode)
+
+
+def _make_tree(root: Path, umask: int) -> dict[str, Path]:
+ """Create a realistic ODS install tree under root with given umask."""
+ with _Umask(umask):
+ extensions = root / "extensions"
+ services = extensions / "services"
+ services.mkdir(parents=True)
+
+ paths: dict[str, Path] = {
+ "root": root,
+ "extensions": extensions,
+ "services": services,
+ }
+
+ for name, manifest_name in (
+ ("ape", "manifest.yaml"),
+ ("beta", "manifest.yml"),
+ ("gamma", "manifest.json"),
+ ):
+ child = services / name
+ child.mkdir()
+ manifest = child / manifest_name
+ manifest.write_text(f"name: {name}\n", encoding="utf-8")
+ private = child / "private.key"
+ private.write_text("secret\n", encoding="utf-8")
+ private.chmod(0o600)
+ paths[f"child_{name}"] = child
+ paths[f"manifest_{name}"] = manifest
+ paths[f"private_{name}"] = private
+
+ # A child with no manifest is valid.
+ empty = services / "empty"
+ empty.mkdir()
+ paths["child_empty"] = empty
+
+ # Unrelated sibling dir under install root must be untouched.
+ unrelated = root / "data"
+ unrelated.mkdir()
+ paths["unrelated"] = unrelated
+ env = root / ".env"
+ env.write_text("fixture-only\n", encoding="utf-8")
+ env.chmod(0o600)
+ paths["env"] = env
+
+ return paths
+
+
+def _snapshot_modes(paths: dict[str, Path]) -> dict[str, int]:
+ return {k: _mode(v) for k, v in paths.items()}
+
+
+class PrepareExtensionManifestsTests(unittest.TestCase):
+ def test_protected_source_inventory_is_unchanged(self) -> None:
+ spec = importlib.util.spec_from_file_location(
+ "pixel_source_upgrade", _HERE.parent.parent / "bin/pixel_source_upgrade.py"
+ )
+ upgrade = importlib.util.module_from_spec(spec)
+ spec.loader.exec_module(upgrade)
+ with tempfile.TemporaryDirectory() as td:
+ root = Path(td) / "install"
+ root.mkdir(mode=0o700)
+ paths = _make_tree(root, 0o077)
+ for name in upgrade.ROOTS:
+ (root / name).mkdir(exist_ok=True)
+ for key, mode in (("manifest_ape", 0o644), ("manifest_beta", 0o755),
+ ("manifest_gamma", 0o444)):
+ paths[key].chmod(mode)
+ before = upgrade.inventory(root, os.getuid())
+ _mod.prepare(root, preserve_file_modes=True)
+ self.assertEqual(upgrade.inventory(root, os.getuid()), before)
+ self.assertEqual(_mode(paths["services"]), 0o755)
+
+ def test_private_manifest_in_protected_source_refused_before_mutation(self) -> None:
+ with tempfile.TemporaryDirectory() as td:
+ root = Path(td) / "install"
+ root.mkdir(mode=0o700)
+ paths = _make_tree(root, 0o077)
+ before = {key: _mode(path) for key, path in paths.items()}
+ with self.assertRaisesRegex(_mod.ManifestPermissionError, "protected source"):
+ _mod.prepare(root, preserve_file_modes=True)
+ self.assertEqual({key: _mode(path) for key, path in paths.items()}, before)
+
+ def _run(self, root: Path) -> tuple[int, int]:
+ return _mod.prepare(root)
+
+ def test_relative_symlink_root_is_refused(self) -> None:
+ with tempfile.TemporaryDirectory() as td:
+ root = Path(td) / "install"
+ root.mkdir()
+ paths = _make_tree(root, 0o077)
+ (Path(td) / "linked").symlink_to(root, target_is_directory=True)
+ previous = Path.cwd()
+ try:
+ os.chdir(td)
+ with self.assertRaises(_mod.ManifestPermissionError):
+ self._run(Path("linked"))
+ finally:
+ os.chdir(previous)
+ self.assertEqual(_mode(paths["manifest_ape"]), 0o600)
+
+ def test_umask_077_fixes_public_surface(self) -> None:
+ with tempfile.TemporaryDirectory() as td:
+ root = Path(td) / "install"
+ root.mkdir()
+ paths = _make_tree(root, 0o077)
+
+ # Preconditions: umask 077 produced restrictive modes.
+ self.assertEqual(_mode(paths["services"]), 0o700)
+ self.assertEqual(_mode(paths["manifest_ape"]), 0o600)
+ self.assertEqual(_mode(paths["private_ape"]), 0o600)
+
+ manifest_count, changed = self._run(root)
+ self.assertEqual(manifest_count, 3)
+ self.assertGreater(changed, 0)
+ self.assertEqual(_mode(paths["env"]), 0o600)
+
+ # Services root 0755.
+ self.assertEqual(_mode(paths["services"]), 0o755)
+ # Child dirs: traversal (x added, g/o w removed, read bits kept).
+ for key in ("child_ape", "child_beta", "child_gamma", "child_empty"):
+ m = _mode(paths[key])
+ self.assertTrue(m & stat.S_IXUSR, key)
+ self.assertTrue(m & stat.S_IXGRP, key)
+ self.assertTrue(m & stat.S_IXOTH, key)
+ self.assertFalse(m & stat.S_IWGRP, key)
+ self.assertFalse(m & stat.S_IWOTH, key)
+ # Manifests 0644.
+ for key in ("manifest_ape", "manifest_beta", "manifest_gamma"):
+ self.assertEqual(_mode(paths[key]), 0o644, key)
+ # Private keys unchanged.
+ for key in ("private_ape", "private_beta", "private_gamma"):
+ self.assertEqual(_mode(paths[key]), 0o600, key)
+ # Unrelated dir untouched.
+ self.assertEqual(_mode(paths["unrelated"]), 0o700)
+
+ def test_umask_022_idempotent(self) -> None:
+ with tempfile.TemporaryDirectory() as td:
+ root = Path(td) / "install"
+ root.mkdir()
+ paths = _make_tree(root, 0o022)
+
+ self._run(root)
+ first = _snapshot_modes(paths)
+ manifest_count, changed = self._run(root)
+ second = _snapshot_modes(paths)
+
+ self.assertEqual(manifest_count, 3)
+ self.assertEqual(changed, 0)
+ self.assertEqual(first, second)
+ self.assertEqual(_mode(paths["manifest_ape"]), 0o644)
+ self.assertEqual(_mode(paths["private_ape"]), 0o600)
+
+ def test_in_place_rerun_after_umask_077(self) -> None:
+ with tempfile.TemporaryDirectory() as td:
+ root = Path(td) / "install"
+ root.mkdir()
+ paths = _make_tree(root, 0o077)
+
+ self._run(root)
+ first = _snapshot_modes(paths)
+ _, changed = self._run(root)
+ second = _snapshot_modes(paths)
+
+ self.assertEqual(changed, 0)
+ self.assertEqual(first, second)
+
+ def test_symlink_manifest_refused_before_mutation(self) -> None:
+ with tempfile.TemporaryDirectory() as td:
+ root = Path(td) / "install"
+ root.mkdir()
+ paths = _make_tree(root, 0o077)
+
+ target = paths["manifest_ape"]
+ real = target.with_name("real.yaml")
+ real.write_text("name: ape\n", encoding="utf-8")
+ target.unlink()
+ target.symlink_to(real)
+
+ before = _snapshot_modes(paths)
+ with self.assertRaises(_mod.ManifestPermissionError):
+ self._run(root)
+ after = _snapshot_modes(paths)
+ self.assertEqual(before, after)
+
+ def test_symlink_child_dir_refused_before_mutation(self) -> None:
+ with tempfile.TemporaryDirectory() as td:
+ root = Path(td) / "install"
+ root.mkdir()
+ paths = _make_tree(root, 0o077)
+
+ real = paths["child_ape"]
+ link = paths["services"] / "linked"
+ link.symlink_to(real)
+
+ before = _snapshot_modes(paths)
+ with self.assertRaises(_mod.ManifestPermissionError):
+ self._run(root)
+ after = _snapshot_modes(paths)
+ self.assertEqual(before, after)
+
+ def test_fifo_manifest_refused_before_mutation(self) -> None:
+ with tempfile.TemporaryDirectory() as td:
+ root = Path(td) / "install"
+ root.mkdir()
+ paths = _make_tree(root, 0o077)
+
+ target = paths["manifest_ape"]
+ target.unlink()
+ os.mkfifo(target)
+
+ before = _snapshot_modes(paths)
+ with self.assertRaises(_mod.ManifestPermissionError):
+ self._run(root)
+ after = _snapshot_modes(paths)
+ self.assertEqual(before, after)
+
+ def test_hardlinked_manifest_refused_before_mutation(self) -> None:
+ with tempfile.TemporaryDirectory() as td:
+ root = Path(td) / "install"
+ root.mkdir()
+ paths = _make_tree(root, 0o077)
+
+ target = paths["manifest_ape"]
+ other = target.with_name("other.yaml")
+ os.link(target, other)
+
+ before = _snapshot_modes(paths)
+ with self.assertRaises(_mod.ManifestPermissionError):
+ self._run(root)
+ after = _snapshot_modes(paths)
+ self.assertEqual(before, after)
+
+ def test_invalid_root_refused(self) -> None:
+ with tempfile.TemporaryDirectory() as td:
+ root = Path(td) / "install"
+ root.mkdir()
+ _make_tree(root, 0o077)
+
+ missing = Path(td) / "does-not-exist"
+ with self.assertRaises(_mod.ManifestPermissionError):
+ self._run(missing)
+
+ def test_root_is_file_refused(self) -> None:
+ with tempfile.TemporaryDirectory() as td:
+ root = Path(td) / "install"
+ root.write_text("not a dir\n", encoding="utf-8")
+ with self.assertRaises(_mod.ManifestPermissionError):
+ self._run(root)
+
+ def test_missing_manifest_in_child_ok(self) -> None:
+ with tempfile.TemporaryDirectory() as td:
+ root = Path(td) / "install"
+ root.mkdir()
+ paths = _make_tree(root, 0o077)
+
+ manifest_count, _ = self._run(root)
+ self.assertEqual(manifest_count, 3)
+ self.assertTrue(paths["child_empty"].is_dir())
+
+ def test_names_with_spaces_ok(self) -> None:
+ with tempfile.TemporaryDirectory() as td:
+ root = Path(td) / "install"
+ root.mkdir()
+ paths = _make_tree(root, 0o077)
+
+ spaced = paths["services"] / "with space"
+ spaced.mkdir()
+ manifest = spaced / "manifest.yaml"
+ manifest.write_text("name: spaced\n", encoding="utf-8")
+
+ manifest_count, _ = self._run(root)
+ self.assertEqual(manifest_count, 4)
+ self.assertEqual(_mode(manifest), 0o644)
+
+ @unittest.skipUnless(
+ os.environ.get("ODS_MIXED_UID_TEST") == "1",
+ "set ODS_MIXED_UID_TEST=1 and run as root to exercise mixed-UID read",
+ )
+ def test_mixed_uid_actual_read(self) -> None:
+ """Optional integration: verify a non-owner UID can read manifests.
+
+ Run separately as root, e.g.:
+ ODS_MIXED_UID_TEST=1 python3 -m unittest \
+ ods/tests/test_public_extension_manifest_permissions.py
+ """
+ import pwd
+
+ with tempfile.TemporaryDirectory() as td:
+ os.chmod(td, 0o755)
+ root = Path(td) / "install"
+ root.mkdir()
+ paths = _make_tree(root, 0o077)
+ nobody = pwd.getpwnam("nobody")
+
+ def can_read(path):
+ pid = os.fork()
+ if pid == 0:
+ try:
+ os.setgroups([])
+ os.setgid(nobody.pw_gid)
+ os.setuid(nobody.pw_uid)
+ with open(path, "rb") as fh:
+ fh.read(1)
+ except OSError:
+ os._exit(1)
+ os._exit(0)
+ _, status = os.waitpid(pid, 0)
+ return os.waitstatus_to_exitcode(status) == 0
+
+ self.assertFalse(can_read(paths["manifest_ape"]))
+ self._run(root)
+ for key in ("manifest_ape", "manifest_beta", "manifest_gamma"):
+ self.assertTrue(can_read(paths[key]), key)
+ self.assertFalse(can_read(paths["private_ape"]))
+
+
+if __name__ == "__main__":
+ unittest.main()