"""Enforce offline task networking in Pier without changing task images.""" from __future__ import annotations import asyncio import ipaddress import json from pathlib import Path from urllib.parse import urlsplit from pier.environments.agent_setup import EGRESS_PROXY_SERVICE from pier.environments.docker.docker import DockerEnvironment NETWORK_POLICY = "internal-isolated-squid-v1" NETWORK_CAPABILITIES = ["NET_ADMIN", "NET_RAW"] ISOLATED_OPTION = "com.docker.network.bridge.gateway_mode_ipv4" def gateway_endpoints(urls: list[str]) -> list[tuple[str, str, int]]: endpoints = set() for url in urls: parsed = urlsplit(url) if parsed.scheme not in {"http", "https"} or not parsed.hostname: raise ValueError("Inference URLs must be absolute HTTP or HTTPS URLs") host = parsed.hostname.lower().rstrip(".") if not all(char.isalnum() or char in ".-:" for char in host): raise ValueError("Invalid inference gateway hostname") port = parsed.port or (443 if parsed.scheme == "https" else 80) endpoints.add((parsed.scheme, host, port)) return sorted(endpoints) def gateway_proxy_script(script: str, endpoints: list[tuple[str, str, int]]) -> str: """Allow nonstandard ports only for the corresponding configured gateway.""" extra = [(scheme, host, port) for scheme, host, port in endpoints if port not in {80, 443}] if not extra: return script safe_ports = " ".join(str(port) for port in sorted({80, 443, *(port for _, _, port in extra)})) tls_ports = " ".join(str(port) for port in sorted({443, *(port for scheme, _, port in extra if scheme == "https")})) script = script.replace("acl Safe_ports port 80 443", "acl Safe_ports port " + safe_ports) script = script.replace("acl SSL_ports port 443", "acl SSL_ports port " + tls_ports) rules = ["acl standard_ports port 80 443", "http_access allow authenticated allowed_domains standard_ports"] for index, (_, host, port) in enumerate(extra): try: address = ipaddress.ip_address(host) except ValueError: host_acl = f"dstdomain {host}" else: host_acl = f"dst {host}/{address.max_prefixlen}" rules.extend([ f"acl gateway_{index}_host {host_acl}", f"acl gateway_{index}_port port {port}", f"http_access allow authenticated gateway_{index}_host gateway_{index}_port", ]) original = "http_access allow authenticated allowed_domains" if original not in script: raise RuntimeError("Unsupported Pier proxy configuration; expected datacurve-pier 0.3.0") return script.replace(original, "\n".join(rules)) def assert_isolated_network(network: dict) -> None: options = network.get("Options") or {} addresses = (network.get("IPAM") or {}).get("Config") or [] if not ( network.get("Driver") == "bridge" and network.get("Internal") is True and not network.get("EnableIPv6", False) and options.get(ISOLATED_OPTION) == "isolated" and addresses and all(not address.get("Gateway") for address in addresses) ): raise RuntimeError("Offline Agent requires an internal bridge with an isolated gateway (Docker Engine 28+)") def assert_container_capabilities(container: dict) -> None: host = container.get("HostConfig") or {} dropped = {name.upper().removeprefix("CAP_") for name in host.get("CapDrop") or []} if host.get("Privileged") or host.get("CapAdd") or not set(NETWORK_CAPABILITIES) <= dropped: raise RuntimeError("Offline containers must drop NET_ADMIN and NET_RAW without added capabilities") class ScienceBenchDocker(DockerEnvironment): """A shared Docker environment for every Science benchmark harness.""" def __init__(self, *args, inference_urls: list[str] | None = None, **kwargs): self._inference_endpoints = gateway_endpoints(inference_urls or []) self._isolation_compose_path: Path | None = None super().__init__(*args, **kwargs) def _prepare_egress_proxy_compose(self) -> None: if self.task_env_config.allow_internet: raise ValueError("SWE-bench Science tasks require allow_internet=false") super()._prepare_egress_proxy_compose() if self._egress_proxy_compose_path: path = self._egress_proxy_compose_path compose = json.loads(path.read_text()) network = compose["networks"]["pier-egress-internal"] network.update({"driver": "bridge", "enable_ipv6": False, "driver_opts": {ISOLATED_OPTION: "isolated"}}) proxy = compose["services"][EGRESS_PROXY_SERVICE] proxy.update({ "cap_drop": NETWORK_CAPABILITIES, "sysctls": {"net.ipv4.ip_forward": "0", "net.ipv6.conf.all.forwarding": "0"}, }) path.write_text(json.dumps(compose, indent=2) + "\n") bootstrap = path.parent / "egress-proxy" / "start-squid.sh" permitted = [ endpoint for endpoint in self._inference_endpoints if any(endpoint[1] == domain or (domain.startswith(".") and endpoint[1].endswith(domain)) for domain in self.network_allowlist.domains) ] bootstrap.write_text(gateway_proxy_script(bootstrap.read_text(), permitted)) self._egress_proxy_env.update({ "ALL_PROXY": self._egress_proxy_env["HTTP_PROXY"], "all_proxy": self._egress_proxy_env["http_proxy"], }) self._isolation_compose_path = self.trial_paths.trial_dir / f"docker-compose-isolation-{self.session_id}.json" self._isolation_compose_path.write_text(json.dumps({"services": {"main": {"cap_drop": NETWORK_CAPABILITIES}}}, indent=2) + "\n") @property def _docker_compose_paths(self) -> list[Path]: paths = super()._docker_compose_paths if self._isolation_compose_path: paths.append(self._isolation_compose_path) return paths @staticmethod async def _docker_inspect(*args: str) -> dict: process = await asyncio.create_subprocess_exec( "docker", *args, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE, ) try: stdout, _ = await asyncio.wait_for(process.communicate(), timeout=15) except asyncio.TimeoutError: process.kill() await process.communicate() raise RuntimeError("Timed out validating Docker network isolation") from None if process.returncode: raise RuntimeError("Docker network isolation inspection failed") return json.loads(stdout)[0] async def _validate_running_network(self) -> dict: result = await self._run_docker_compose_command(["ps", "--quiet", "main"]) container_id = (result.stdout or "").strip() if not container_id: raise RuntimeError("No Agent container exists for network validation") main = await self._docker_inspect("container", "inspect", container_id) assert_container_capabilities(main) report = {"policy": NETWORK_POLICY, "container_id": container_id, "inference_domains": self.network_allowlist.domains} if not self._egress_proxy_compose_path: if main["HostConfig"].get("NetworkMode") != "none": raise RuntimeError("Offline containers without inference egress must use network_mode=none") report["network_mode"] = "none" return report networks = main["NetworkSettings"]["Networks"] if len(networks) != 1: raise RuntimeError("Agent must be connected exclusively to its isolated internal network") internal_name = next(iter(networks)) network = await self._docker_inspect("network", "inspect", internal_name) assert_isolated_network(network) result = await self._run_docker_compose_command(["ps", "--quiet", EGRESS_PROXY_SERVICE]) proxy = await self._docker_inspect("container", "inspect", (result.stdout or "").strip()) assert_container_capabilities(proxy) proxy_networks = proxy["NetworkSettings"]["Networks"] sysctls = proxy["HostConfig"].get("Sysctls") or {} if not (len(proxy_networks) == 2 and internal_name in proxy_networks and sysctls.get("net.ipv4.ip_forward") == "0" and sysctls.get("net.ipv6.conf.all.forwarding") == "0"): raise RuntimeError("Inference proxy must have two networks and IP forwarding disabled") report.update({"network_mode": "isolated-allowlist", "internal_network": internal_name, "host_gateway": None, "proxy_forwarding": False}) return report async def start(self, force_build: bool): try: await super().start(force_build) report = await self._validate_running_network() path = self.trial_paths.trial_dir / f"network-policy-{self.session_id}.json" path.write_text(json.dumps(report, indent=2) + "\n") except BaseException: await self.stop(delete=False) raise