Skip to content

Secure, Fast, and Extensible Sandbox runtime for AI agents.

65.0 KB
Raw Blame
# Copyright 2026 The OpenSandbox Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Live credential-bound admission tests for the egress system addon.

These tests drive the addon hooks directly with a fake mitmproxy context
(the same harness style as test_mitmscripts_system.py) plus the real
LiveReceiver/Registry publication stack, covering the OSEP-0023 phase-3
sidecar loop: TLS decrypt/pass-through decisions, per-revision request
admission, SNI/authority agreement, rotation, removal fencing, remove/re-add,
drain expiry, and fail-closed boundaries.
"""

from __future__ import annotations

import asyncio
import gc
import hashlib
import importlib.util
import json
import sys
import types
import unittest
import weakref
from dataclasses import replace
from pathlib import Path
from typing import Any
from unittest import mock

MITMSCRIPTS = Path(__file__).resolve().parents[1] / "mitmscripts"

ENV = {
    "socket": "OPENSANDBOX_EGRESS_REVISION_IPC_SOCKET",
    "token": "OPENSANDBOX_EGRESS_REVISION_IPC_TOKEN",
    "control": "OPENSANDBOX_EGRESS_REVISION_CONTROL_GENERATION",
    "subject": "OPENSANDBOX_EGRESS_REVISION_SUBJECT_GENERATION",
    "limit": "OPENSANDBOX_EGRESS_REVISION_MAX_SNAPSHOT_BYTES",
}
LIVE_ENV = {
    "tls_capacity": "OPENSANDBOX_EGRESS_REVISION_TLS_CAPACITY",
    "request_capacity": "OPENSANDBOX_EGRESS_REVISION_REQUEST_CAPACITY",
    "drain_timeout": "OPENSANDBOX_EGRESS_REVISION_DRAIN_TIMEOUT_SECONDS",
}

CONTROL = "control-live-a"
SUBJECT = "subject-live-a"
TOKEN = "a" * 43

_SYSTEM_MODULES = (
    "mitmproxy",
    "mitmproxy.tls",
    "credential_bound",
    "revision_ipc",
    "revision_publication",
    "revision_receiver",
    "tls_registry",
    "tls_decision",
    "decision_snapshot",
    "host_selectors",
    "static_passthrough",
)


def _isolate_system_modules(test: unittest.TestCase) -> None:
    # Discovery may already have loaded the real mitmproxy-backed H2 runtime.
    # Give this fake-context harness a fresh, consistent dependency graph, then
    # restore the exact cached objects so other tests retain their class identity.
    saved = {name: sys.modules[name] for name in _SYSTEM_MODULES if name in sys.modules}

    def restore() -> None:
        for name in _SYSTEM_MODULES:
            sys.modules.pop(name, None)
        sys.modules.update(saved)

    test.addCleanup(restore)
    for name in _SYSTEM_MODULES:
        sys.modules.pop(name, None)


class _Log:
    def __init__(self) -> None:
        self.messages: list[str] = []

    def warn(self, message: str) -> None:
        self.messages.append(message)

    def info(self, message: str) -> None:
        self.messages.append(message)


class _Headers:
    def __init__(self, values: dict[str, str] | None = None) -> None:
        self._values: dict[str, str] = dict(values or {})

    def get(self, name: str, default: str = "") -> str:
        for key, value in self._values.items():
            if key.lower() == name.lower():
                return value
        return default

    def get_all(self, name: str) -> list[str]:
        return [
            value for key, value in self._values.items() if key.lower() == name.lower()
        ]

    def items(self) -> list[tuple[str, str]]:
        return list(self._values.items())

    def __setitem__(self, name: str, value: str) -> None:
        self._values[name] = value

    def __contains__(self, name: str) -> bool:
        return any(key.lower() == name.lower() for key in self._values)

    def __delitem__(self, name: str) -> None:
        for key in list(self._values):
            if key.lower() == name.lower():
                del self._values[key]
                return


class _ClientHello:
    def __init__(self, sni: str | None, extensions: list | None = None) -> None:
        self.sni = sni
        # Mirrors mitmproxy 11: list[(int, bytes)]; a valid hello has a list.
        self.extensions = [] if extensions is None else extensions


class _ClientConn:
    _counter = 0

    def __init__(self, sni: str | None = None) -> None:
        _ClientConn._counter += 1
        self.id = f"fake-client-{_ClientConn._counter}"
        self.sni = sni
        self.peername = ("127.0.0.1", 51234)
        self.closed = False
        self.state = "open"

    def close(self) -> None:
        self.closed = True


class _ClientHelloData:
    def __init__(
        self,
        sni: str | None,
        client_conn: _ClientConn | None = None,
        extensions: list | None = None,
    ) -> None:
        self.client_hello = _ClientHello(sni, extensions)
        client = client_conn if client_conn is not None else _ClientConn(sni)
        self.context = types.SimpleNamespace(client=client)
        self.ignore_connection = False

    @property
    def client_conn(self) -> "_ClientConn":
        return self.context.client


class _Request:
    def __init__(self, host: str = "api.example.com", path: str = "/v1/data") -> None:
        self.pretty_host = host
        self.host = host
        self.port = 443
        self.scheme = "https"
        self.method = "GET"
        self.path = path
        self.headers = _Headers({"host": host})
        self.authority = ""
        self.raw_content: bytes | None = None
        self.content = b""
        self.stream = False
        self.http_version = "HTTP/1.1"


class _Response:
    def __init__(self) -> None:
        self.headers = _Headers({"content-type": "application/json"})
        self.stream = False

    @staticmethod
    def make(status_code: int, body: bytes = b"", headers: dict | None = None) -> "_Response":
        response = _Response()
        response.status_code = status_code
        response.body = body
        if headers:
            response.headers = _Headers(headers)
        return response


class _Flow:
    def __init__(self, client_conn: _ClientConn | None = None, host: str = "api.example.com") -> None:
        self.request = _Request(host=host)
        self.response: Any = None
        self.metadata: dict[str, Any] = {}
        self.client_conn = client_conn
        self.error = None
        self.live = True
        self.killable = True
        self.killed = False

    def kill(self) -> None:
        self.killed = True
        self.error = "Killed"
        self.live = False


def _drive_async_hook(hook):
    """Run the async requestheaders hook synchronously, like mitmproxy."""

    def run(*args, **kwargs):
        return asyncio.run(hook(*args, **kwargs))

    return run


def _load_system_module() -> Any:
    mitmproxy = types.ModuleType("mitmproxy")
    mitmproxy.ctx = types.SimpleNamespace(
        log=_Log(), options=types.SimpleNamespace(ignore_hosts=[], ssl_insecure=False)
    )
    mitmproxy.http = types.SimpleNamespace(HTTPFlow=object, Response=_Response)
    mitmproxy_tls = types.ModuleType("mitmproxy.tls")
    mitmproxy_tls.ClientHelloData = object
    sys.modules["mitmproxy"] = mitmproxy
    sys.modules["mitmproxy.tls"] = mitmproxy_tls
    spec = importlib.util.spec_from_file_location(
        "opensandbox_credential_bound_system", MITMSCRIPTS / "system.py"
    )
    assert spec is not None and spec.loader is not None
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    module.requestheaders = _drive_async_hook(module.requestheaders)
    return module


def _binding(name: str, host: str, header_value: str, methods=("GET",), paths=("/v1/*",)) -> dict[str, Any]:
    return {
        "name": name,
        "match": {
            "schemes": ["https"],
            "hosts": [host],
            "methods": list(methods),
            "paths": list(paths),
        },
        "headers": [{"name": "Authorization", "value": header_value}],
    }


def _decision_payload(
    bindings: list[dict[str, Any]], redactions: list[str], vault_revision: int
) -> bytes:
    selectors = sorted(
        {
            host
            for binding in bindings
            if "https" in binding["match"]["schemes"]
            for host in binding["match"]["hosts"]
        }
    )
    return json.dumps(
        {
            "version": 1,
            "vaultRevision": vault_revision,
            "effectivePolicyEpoch": 0,
            "interceptionMode": "credential-bound",
            "state": "active" if bindings else "active-empty",
            "tlsBindingHostSelectors": selectors,
            "fullRenderedBindings": sorted(bindings, key=lambda item: item["name"]),
            "redactions": sorted(redactions, key=lambda item: (-len(item.encode()), item)),
        },
        separators=(",", ":"),
    ).encode()


def _revision(payload: bytes, epoch: int, vault_revision: int) -> Any:
    from revision_receiver import Revision

    return Revision(CONTROL, SUBJECT, epoch, vault_revision, 0, hashlib.sha256(payload).hexdigest())


def _sort_bindings(bindings: list[dict[str, Any]]) -> list[dict[str, Any]]:
    return sorted(bindings, key=lambda item: item["name"])


def _system_with_live_runtime(static_json="[]") -> tuple[Any, Any, Any]:
    # Load the system module first: it installs the fake mitmproxy package
    # that the mitmscripts modules import at module scope.
    system = _load_system_module()
    from credential_bound import LiveRuntime
    from revision_publication import LiveReceiver
    from static_passthrough import parse_handoff

    receiver = LiveReceiver(
        CONTROL, SUBJECT, max_snapshot_bytes=1 << 20, capacity=64, request_capacity=256,
        drain_timeout_seconds=1, static_passthrough=parse_handoff(static_json),
    )
    runtime = LiveRuntime(receiver, identity=(CONTROL, SUBJECT))
    system._live_runtime = runtime
    return system, receiver, runtime


class CredentialBoundTLSTest(unittest.TestCase):
    def setUp(self) -> None:
        _isolate_system_modules(self)
        sys.path.insert(0, str(MITMSCRIPTS))
        self.system, self.receiver, self.runtime = _system_with_live_runtime()
        self._epoch = 0

    def tearDown(self) -> None:
        sys.path.remove(str(MITMSCRIPTS))

    def _install(self, bindings: list[dict[str, Any]], redactions: list[str], revision: int) -> None:
        self._epoch += 1
        payload = _decision_payload(bindings, redactions, revision)
        identity = _revision(payload, self._epoch, revision)
        self.receiver.prepare(identity, payload)
        self.receiver.commit(identity)

    def test_bootstrapping_state_denies_and_closes(self) -> None:
        data = _ClientHelloData("api.example.com")
        self.system.tls_clienthello(data)
        self.assertFalse(data.ignore_connection)
        self.assertTrue(data.client_conn.closed)

    def test_active_empty_passes_through(self) -> None:
        self._install([], [], 0)
        data = _ClientHelloData("api.example.com")
        self.system.tls_clienthello(data)
        self.assertTrue(data.ignore_connection)
        self.assertFalse(data.client_conn.closed)

    def test_bound_host_decrypts_and_tracks_token(self) -> None:
        self._install([_binding("api", "api.example.com", "token-v1")], ["token-v1"], 1)
        data = _ClientHelloData("api.example.com")
        self.system.tls_clienthello(data)
        self.assertFalse(data.ignore_connection)
        self.assertFalse(data.client_conn.closed)
        self.assertIsNotNone(self.runtime.token_for(data.client_conn))

    def test_unbound_host_passes_through(self) -> None:
        self._install([_binding("api", "api.example.com", "token-v1")], ["token-v1"], 1)
        data = _ClientHelloData("other.example.com")
        self.system.tls_clienthello(data)
        self.assertTrue(data.ignore_connection)
        self.assertFalse(data.client_conn.closed)

    def test_no_sni_passes_through(self) -> None:
        self._install([_binding("api", "api.example.com", "token-v1")], ["token-v1"], 1)
        data = _ClientHelloData(None)
        self.system.tls_clienthello(data)
        self.assertTrue(data.ignore_connection)
        self.assertFalse(data.client_conn.closed)

    def test_invalid_sni_denies(self) -> None:
        self._install([_binding("api", "api.example.com", "token-v1")], ["token-v1"], 1)
        data = _ClientHelloData("api..example.com")
        self.system.tls_clienthello(data)
        self.assertFalse(data.ignore_connection)
        self.assertTrue(data.client_conn.closed)

    def test_live_never_uses_dynamic_ignore_hosts(self) -> None:
        self.system.ctx.options.ignore_hosts = [".*"]
        data = _ClientHelloData("ignored.example.com")
        self.system.tls_clienthello(data)
        self.assertFalse(data.ignore_connection)
        self.assertTrue(data.client_conn.closed)

    def test_static_hook_uses_original_destination_without_snapshot_or_registry(self) -> None:
        self.system, self.receiver, self.runtime = _system_with_live_runtime('["*.example.com"]')
        self.assertIs(self.runtime.static_passthrough, self.receiver.static_passthrough)
        self.assertIs(self.runtime.static_passthrough, self.receiver._publisher.static_passthrough)
        for owner in (self.runtime, self.receiver, self.receiver._publisher):
            with self.assertRaises(AttributeError):
                owner.static_passthrough = ()
        for address, expected in ((("192.0.2.1", 443), True), (("192.0.2.1", 80), False),
                                  (("192.0.2.1", 8443), False), (None, False),
                                  (("192.0.2.1", True), False), (("192.0.2.1", "443"), False),
                                  (["192.0.2.1", 443], False), (("", 443), False)):
            with self.subTest(address=address):
                data = _ClientHelloData("A.B.Example.com.")
                data.context.server = types.SimpleNamespace(address=address, peername=None)
                self.system.tls_clienthello(data)
                self.assertEqual(data.ignore_connection, expected)
                self.assertEqual(data.client_conn.closed, not expected)
                self.assertIsNone(self.runtime.token_for(data.client_conn))
                self.assertEqual(len(self.runtime.registry._entries), 0)
        for sni, extensions in ((None, []), ("a.example.com", [(0xFE0D, b"ech")])):
            data = _ClientHelloData(sni, extensions=extensions)
            data.context.server = types.SimpleNamespace(address=None)
            self.system.tls_clienthello(data)
            self.assertTrue(data.ignore_connection)
        self.receiver.close()
        result = self.runtime.admit_tls("a.example.com", destination_port=443)
        self.assertEqual(result.action, "deny")

    def test_registry_exhaustion_closes_new_bound_connection(self) -> None:
        # capacity=64 in setUp: admit 64 connections first.
        self._install([_binding("api", "api.example.com", "token-v1")], ["token-v1"], 1)
        for _ in range(64):
            data = _ClientHelloData("api.example.com")
            self.system.tls_clienthello(data)
            self.assertFalse(data.ignore_connection)
        overflow = _ClientHelloData("api.example.com")
        self.system.tls_clienthello(overflow)
        self.assertFalse(overflow.ignore_connection)
        self.assertTrue(overflow.client_conn.closed)

    def test_disconnect_releases_token(self) -> None:
        self._install([_binding("api", "api.example.com", "token-v1")], ["token-v1"], 1)
        data = _ClientHelloData("api.example.com")
        self.system.tls_clienthello(data)
        token = self.runtime.token_for(data.client_conn)
        self.assertIsNotNone(token)
        self.system.client_disconnected(data.client_conn)
        self.assertIsNone(self.runtime.token_for(data.client_conn))
        self.assertEqual(self.runtime.registry.count, 0)


class CredentialBoundRequestTest(unittest.TestCase):
    def setUp(self) -> None:
        _isolate_system_modules(self)
        sys.path.insert(0, str(MITMSCRIPTS))
        self.system, self.receiver, self.runtime = _system_with_live_runtime()
        self._epoch = 0
        self.install_revision(1, "token-v1")

    def tearDown(self) -> None:
        sys.path.remove(str(MITMSCRIPTS))

    def install_revision(self, revision_value: int, token: str) -> None:
        self._epoch += 1
        payload = _decision_payload(
            [_binding("api", "api.example.com", token)], [token], revision_value
        )
        identity = _revision(payload, self._epoch, revision_value)
        self.receiver.prepare(identity, payload)
        self.receiver.commit(identity)

    def _admitted_flow(self, host: str = "api.example.com", path: str = "/v1/data") -> _Flow:
        conn = _ClientConn(sni="api.example.com")
        data = _ClientHelloData("api.example.com", conn)
        self.system.tls_clienthello(data)
        self.assertFalse(conn.closed)
        return _Flow(client_conn=conn, host=host)

    def test_authorized_request_receives_credential(self) -> None:
        flow = self._admitted_flow()
        self.system.requestheaders(flow)
        self.assertEqual(flow.request.headers.get("Authorization"), "token-v1")
        handle = flow.metadata.get("opensandbox_credential_request_handle")
        self.assertIsNotNone(handle)
        self.system.response(flow)
        self.assertNotIn("opensandbox_credential_request_handle", flow.metadata)
        self.assertEqual(self.runtime.registry.request_count, 0)

    def test_keepalive_rotation_uses_new_revision_per_request(self) -> None:
        flow_one = self._admitted_flow()
        self.system.requestheaders(flow_one)
        self.assertEqual(flow_one.request.headers.get("Authorization"), "token-v1")

        self.install_revision(2, "token-v2")
        flow_two = self._admitted_flow()
        self.system.requestheaders(flow_two)
        self.assertEqual(flow_two.request.headers.get("Authorization"), "token-v2")
        # The in-flight request admitted before the cutover keeps its snapshot.
        self.assertEqual(flow_one.request.headers.get("Authorization"), "token-v1")
        self.system.response(flow_one)
        self.system.response(flow_two)

    def test_protocol_upgrade_remains_admitted_until_disconnect(self) -> None:
        flow = self._admitted_flow()
        self.system.requestheaders(flow)
        token = self.runtime.token_for(flow.client_conn)
        flow.response = types.SimpleNamespace(status_code=101)
        self.system.response(flow)
        self.assertEqual(self.runtime.registry.request_count, 1)

        # Rotation keeps the host covered. Only the retained request handle
        # can cause this upgraded connection to retire at the old deadline.
        with mock.patch("tls_registry.time.monotonic", return_value=100):
            self.install_revision(2, "token-v2")
        with mock.patch("tls_registry.time.monotonic", return_value=1000):
            self.assertEqual(self.runtime.registry.expired_connections(), (token,))
        self.system.client_disconnected(flow.client_conn)
        self.assertEqual(self.runtime.registry.request_count, 0)
        self.assertEqual(self.runtime.registry.count, 0)

    def test_wrong_path_gets_no_credential(self) -> None:
        flow = self._admitted_flow()
        flow.request.path = "/health"
        self.system.requestheaders(flow)
        self.assertNotIn("Authorization", flow.request.headers)
        self.assertIsNone(flow.response)

    def test_wrong_method_gets_no_credential(self) -> None:
        flow = self._admitted_flow()
        flow.request.method = "DELETE"
        self.system.requestheaders(flow)
        self.assertNotIn("Authorization", flow.request.headers)
        self.assertIsNone(flow.response)

    def test_authority_mismatch_is_rejected(self) -> None:
        flow = self._admitted_flow(host="api.example.com")
        # The request authority still matches the binding, but the transport
        # was intercepted for a different SNI: credentials must not flow.
        flow.client_conn.sni = "front.example.com"
        self.system.requestheaders(flow)
        self.assertNotIn("Authorization", flow.request.headers)
        self.assertEqual(flow.response.status_code, 403)
        self.system.response(flow)

    def test_missing_sni_authority_is_rejected(self) -> None:
        flow = self._admitted_flow()
        flow.client_conn.sni = None
        self.system.requestheaders(flow)
        self.assertNotIn("Authorization", flow.request.headers)
        self.assertEqual(flow.response.status_code, 403)
        self.system.response(flow)

    def test_unadmitted_connection_is_rejected(self) -> None:
        flow = _Flow(client_conn=_ClientConn(sni="api.example.com"))
        self.system.requestheaders(flow)
        self.assertEqual(flow.response.status_code, 503)
        self.assertNotIn("Authorization", flow.request.headers)

    def test_plain_http_is_untouched(self) -> None:
        conn = _ClientConn(sni="api.example.com")
        data = _ClientHelloData("api.example.com", conn)
        self.system.tls_clienthello(data)
        flow = _Flow(client_conn=conn)
        flow.request.scheme = "http"
        flow.request.port = 80
        self.system.requestheaders(flow)
        self.assertNotIn("Authorization", flow.request.headers)
        self.assertIsNone(flow.response)

    def test_error_hook_releases_handle(self) -> None:
        flow = self._admitted_flow()
        self.system.requestheaders(flow)
        self.system.error(flow)
        self.assertNotIn("opensandbox_credential_request_handle", flow.metadata)
        self.assertEqual(self.runtime.registry.request_count, 0)


class CredentialBoundRemovalTest(unittest.TestCase):
    def setUp(self) -> None:
        _isolate_system_modules(self)
        sys.path.insert(0, str(MITMSCRIPTS))
        self.system, self.receiver, self.runtime = _system_with_live_runtime()
        self._epoch = 0
        self.install_revision(1, "token-v1", ["api.example.com"])

    def tearDown(self) -> None:
        sys.path.remove(str(MITMSCRIPTS))

    def install_revision(self, revision_value: int, token: str, hosts: list[str]) -> None:
        self._epoch += 1
        bindings = [_binding("api", host, token) for host in hosts]
        redactions = [token] if hosts else []
        payload = _decision_payload(bindings, redactions, revision_value)
        identity = _revision(payload, self._epoch, revision_value)
        self.receiver.prepare(identity, payload)
        self.receiver.commit(identity)

    def _admitted_flow(self) -> tuple[_Flow, _ClientConn]:
        conn = _ClientConn(sni="api.example.com")
        self.system.tls_clienthello(_ClientHelloData("api.example.com", conn))
        return _Flow(client_conn=conn), conn

    def test_delete_fences_new_requests_on_keepalive_connection(self) -> None:
        flow, _conn = self._admitted_flow()
        self.system.requestheaders(flow)
        self.assertEqual(flow.request.headers.get("Authorization"), "token-v1")
        self.system.response(flow)

        self.install_revision(2, "token-v2", [])
        denied = _Flow(client_conn=_conn)
        self.system.requestheaders(denied)
        self.assertNotIn("Authorization", denied.request.headers)
        self.assertEqual(denied.response.status_code, 403)
        self.assertEqual(denied.response.headers.get("connection"), "close")
        self.system.response(denied)

    def test_delete_drains_expired_connection(self) -> None:
        flow, conn = self._admitted_flow()
        self.system.requestheaders(flow)
        self.system.response(flow)
        self.install_revision(2, "token-v2", [])
        self.assertFalse(conn.closed)
        # drain_timeout_seconds=1 in setUp; advance the clock by expiry.
        import tls_registry

        with mock.patch.object(tls_registry.time, "monotonic", return_value=time_time() + 10):
            closed = self.runtime.drain_sweep_once()
        self.assertGreaterEqual(closed, 1)
        self.assertTrue(conn.closed)
        self.system.client_disconnected(conn)
        self.assertEqual(self.runtime.registry.count, 0)

    def test_remove_readd_does_not_resurrect_old_connection(self) -> None:
        flow, conn = self._admitted_flow()
        self.system.requestheaders(flow)
        self.system.response(flow)

        self.install_revision(2, "token-v2", [])
        denied = _Flow(client_conn=conn)
        self.system.requestheaders(denied)
        self.assertEqual(denied.response.status_code, 403)
        self.system.response(denied)

        self.install_revision(3, "token-v3", ["api.example.com"])
        still_denied = _Flow(client_conn=conn)
        self.system.requestheaders(still_denied)
        self.assertEqual(still_denied.response.status_code, 403)
        self.assertNotIn("Authorization", still_denied.request.headers)
        self.system.response(still_denied)

        # A fresh connection is admitted under the re-added host.
        fresh_conn = _ClientConn(sni="api.example.com")
        self.system.tls_clienthello(_ClientHelloData("api.example.com", fresh_conn))
        self.assertFalse(fresh_conn.closed)
        fresh = _Flow(client_conn=fresh_conn)
        self.system.requestheaders(fresh)
        self.assertEqual(fresh.request.headers.get("Authorization"), "token-v3")
        self.system.response(fresh)
        self.system.client_disconnected(conn)
        self.system.client_disconnected(fresh_conn)

    def test_new_connections_pass_through_after_delete(self) -> None:
        self.install_revision(2, "token-v2", [])
        data = _ClientHelloData("api.example.com")
        self.system.tls_clienthello(data)
        self.assertTrue(data.ignore_connection)
        self.assertFalse(data.client_conn.closed)


def time_time() -> float:
    import time

    return time.monotonic()


class CredentialBoundSnapshotValidationTest(unittest.TestCase):
    def setUp(self) -> None:
        _isolate_system_modules(self)
        sys.path.insert(0, str(MITMSCRIPTS))
        self.system, self.receiver, self.runtime = _system_with_live_runtime()
        self.conn = _ClientConn(sni="api.example.com")
        self.system.tls_clienthello(_ClientHelloData("api.example.com", self.conn))
        self.flow = _Flow(client_conn=self.conn)

    def tearDown(self) -> None:
        sys.path.remove(str(MITMSCRIPTS))

    def test_revision_disagreement_fails_closed(self) -> None:
        payload = _decision_payload(
            [_binding("api", "api.example.com", "token-v1")], ["token-v1"], 5
        )
        identity = _revision(payload, 1, 1)  # envelope revision 1, payload says 5
        # The receiver rejects digest/envelope disagreement at prepare, so
        # simulate the corrupted payload reaching the flow layer directly.
        from revision_receiver import Snapshot

        snapshot = Snapshot(identity, payload)
        with mock.patch.object(
            self.runtime, "token_for",
            return_value=types.SimpleNamespace(sni="api.example.com"),
        ), mock.patch.object(
            self.runtime, "acquire_request", return_value=_fake_admission(snapshot)
        ):
            self.system.requestheaders(self.flow)
        self.assertEqual(self.flow.response.status_code, 503)
        self.assertNotIn("Authorization", self.flow.request.headers)

    def test_empty_snapshot_passes_request_through(self) -> None:
        payload = _decision_payload([], [], 0)
        identity = _revision(payload, 1, 0)
        from revision_receiver import Snapshot

        snapshot = Snapshot(identity, payload)
        with mock.patch.object(
            self.runtime, "token_for",
            return_value=types.SimpleNamespace(sni="api.example.com"),
        ), mock.patch.object(
            self.runtime, "acquire_request", return_value=_fake_admission(snapshot)
        ):
            self.system.requestheaders(self.flow)
        self.assertIsNone(self.flow.response)
        self.assertNotIn("Authorization", self.flow.request.headers)
        self.system.response(self.flow)


class _FakeAdmission:
    def __init__(self, snapshot: Any) -> None:
        self.action = "allow"
        self.reason = "admitted"
        self.snapshot = snapshot
        self.handle = object()


def _fake_admission(snapshot: Any) -> _FakeAdmission:
    return _FakeAdmission(snapshot)


class CredentialBoundSnapshotMemoTest(unittest.TestCase):
    """Pure synthetic snapshots and fake hooks; no receiver or IPC startup."""

    def setUp(self) -> None:
        _isolate_system_modules(self)
        sys.path.insert(0, str(MITMSCRIPTS))
        self.system = _load_system_module()
        self.conn = _ClientConn(sni="api.example.com")
        self.runtime = mock.Mock()
        self.runtime.token_for.return_value = types.SimpleNamespace(sni=self.conn.sni)
        self.system._live_runtime = self.runtime

    def tearDown(self) -> None:
        self.system.done()
        sys.path.remove(str(MITMSCRIPTS))

    def _snapshot(self, revision: int = 1, *, empty: bool = False) -> Any:
        from revision_receiver import Snapshot

        value = f"fake-token-{revision}"
        payload = _decision_payload(
            [] if empty else [_binding("api", "api.example.com", value)],
            [] if empty else [value], revision,
        )
        return Snapshot(_revision(payload, revision, revision), payload)

    def _request(self, snapshot: Any) -> _Flow:
        self.runtime.acquire_request.return_value = _fake_admission(snapshot)
        flow = _Flow(client_conn=self.conn)
        self.system.requestheaders(flow)
        return flow

    def test_equal_revision_decodes_and_parses_once(self) -> None:
        snapshot = self._snapshot()
        with mock.patch.object(
            self.system.json, "loads", wraps=json.loads
        ) as decode, mock.patch.object(
            self.system, "_parse_active_vault", wraps=self.system._parse_active_vault
        ) as parse:
            first = self.system._live_snapshot_vault(snapshot)
            equivalent = replace(snapshot, revision=replace(snapshot.revision))
            self.assertIs(first, self.system._live_snapshot_vault(equivalent))
        self.assertEqual(decode.call_count, 1)
        self.assertEqual(parse.call_count, 1)

    def test_full_revision_identity_is_the_cache_key(self) -> None:
        snapshot = self._snapshot()
        variants = [
            replace(snapshot, revision=replace(snapshot.revision, **change))
            for change in (
                {"control_generation": "control-live-b"},
                {"subject_generation": "subject-live-b"},
                {"decision_epoch": 2},
                {"policy_epoch": 1},
            )
        ]
        # Different serialization has a different verified digest even though
        # its rendered bindings and numeric Vault revision have not changed.
        payload = snapshot.payload + b" "
        variants.append(replace(
            snapshot, payload=payload,
            revision=replace(snapshot.revision, digest=hashlib.sha256(payload).hexdigest()),
        ))
        variants.append(self._snapshot(2))
        for changed in variants:
            with self.subTest(revision=changed.revision):
                old = self.system._live_snapshot_vault(snapshot)
                current = self.system._live_snapshot_vault(changed)
                self.assertIsNot(old, current)
                self.assertEqual(self.system._live_vault_cache, (changed.revision, current))

        # Even a corrupt envelope differing only in vault_revision must miss
        # and fail validation, rather than return the cached valid view.
        self.system._live_snapshot_vault(snapshot)
        corrupt = replace(snapshot, revision=replace(snapshot.revision, vault_revision=2))
        with self.assertRaises(self.system.ActiveVaultLookupError):
            self.system._live_snapshot_vault(corrupt)
        self.assertIsNone(self.system._live_vault_cache)

    def test_active_empty_is_a_cached_success(self) -> None:
        self.system._live_snapshot_vault(self._snapshot())
        snapshot = self._snapshot(2, empty=True)
        with mock.patch.object(self.system.json, "loads", wraps=json.loads) as decode:
            for _ in range(2):
                flow = self._request(snapshot)
                self.assertIsNone(flow.response)
                self.assertNotIn("Authorization", flow.request.headers)
        self.assertEqual(decode.call_count, 1)
        self.assertEqual(self.system._live_vault_cache, (snapshot.revision, None))

    def test_invalid_snapshot_is_not_cached_or_replaced_with_old_view(self) -> None:
        good = self._snapshot()
        invalid_schema = json.loads(self._snapshot(2).payload)
        invalid_schema["fullRenderedBindings"][0]["headers"][0]["value"] = 123
        for payload in (b"not-json-fake-token", json.dumps(invalid_schema).encode()):
            with self.subTest(payload=payload):
                self.system._live_snapshot_vault(good)
                invalid = replace(good, payload=payload, revision=_revision(payload, 2, 2))
                with mock.patch.object(self.system.json, "loads", wraps=json.loads) as decode:
                    for _ in range(2):
                        flow = self._request(invalid)
                        self.assertEqual(flow.response.status_code, 503)
                        self.assertEqual(flow.response.body, b"credential proxy unavailable\n")
                        self.assertNotIn("Authorization", flow.request.headers)
                        self.assertNotIn(self.system.FLOW_REQUEST_HANDLE_KEY, flow.metadata)
                        self.assertIsNone(self.system._live_vault_cache)
                self.assertEqual(decode.call_count, 2)
        self.assertEqual(self.runtime.finish_request.call_count, 4)
        self.assertNotIn("not-json-fake-token", " ".join(self.system.ctx.log.messages))

    def test_cached_view_still_requires_admission_and_authority(self) -> None:
        snapshot = self._snapshot()
        with mock.patch.object(
            self.system, "_live_snapshot_vault", wraps=self.system._live_snapshot_vault
        ) as lookup:
            self._request(snapshot)
            self._request(snapshot)
            self.runtime.acquire_request.return_value = types.SimpleNamespace(
                action="deny", reason="connection_fenced",
            )
            denied = _Flow(client_conn=self.conn)
            self.system.requestheaders(denied)
            self.runtime.acquire_request.return_value = _fake_admission(snapshot)
            wrong_host = _Flow(client_conn=self.conn, host="other.example.com")
            self.system.requestheaders(wrong_host)
            self.assertEqual(lookup.call_count, 2)
        self.assertEqual(self.runtime.acquire_request.call_count, 4)
        for flow in (denied, wrong_host):
            self.assertEqual(flow.response.status_code, 403)
            self.assertNotIn("Authorization", flow.request.headers)

    def test_same_connection_uses_new_admission_snapshot(self) -> None:
        first = self._snapshot()
        self.runtime.token_for.return_value.revision = first.revision
        self.assertEqual(self._request(first).request.headers.get("Authorization"), "fake-token-1")
        self.assertEqual(self._request(self._snapshot(2)).request.headers.get("Authorization"), "fake-token-2")

    def test_many_revisions_retain_only_one_parsed_view(self) -> None:
        references = []
        for revision in range(1, 21):
            snapshot = self._snapshot(revision)
            vault = self.system._live_snapshot_vault(snapshot)
            references.append(weakref.ref(vault))
            self.assertEqual(self.system._live_vault_cache, (snapshot.revision, vault))
        del vault
        gc.collect()
        self.assertTrue(all(reference() is None for reference in references[:-1]))
        self.assertIsNotNone(references[-1]())

    def test_done_releases_memo_even_when_close_fails(self) -> None:
        for close_fails in (False, True):
            with self.subTest(close_fails=close_fails):
                snapshot = self._snapshot()
                reference = weakref.ref(self.system._live_snapshot_vault(snapshot))
                def close() -> None:
                    self.assertIsNone(self.system._live_vault_cache)
                    if close_fails:
                        raise RuntimeError("fake close failure")
                self.runtime.close.side_effect = close
                self.system._live_runtime = self.runtime
                self.system.done()
                gc.collect()
                self.assertIsNone(reference())
                # The same module can parse again after its owner teardown;
                # test isolation uses done(), not the transport-only reset.
                with mock.patch.object(self.system.json, "loads", wraps=json.loads) as decode:
                    self.system._live_snapshot_vault(snapshot)
                self.assertEqual(decode.call_count, 1)

    def test_eviction_and_done_preserve_existing_flow_material(self) -> None:
        payload = json.loads(self._snapshot().payload)
        binding = payload["fullRenderedBindings"][0]
        binding["headers"] = []
        binding["substitutions"] = [
            {"placeholder": "FAKE_PLACEHOLDER", "value": "fake-token-1", "in": ["body"]}
        ]
        payload["redactions"].append("FAKE_PLACEHOLDER")
        encoded = json.dumps(payload).encode()
        snapshot = replace(self._snapshot(), payload=encoded, revision=_revision(encoded, 1, 1))
        flow = self._request(snapshot)
        saved_binding = flow.metadata[self.system.FLOW_BINDING_KEY]
        saved_redactions = list(flow.metadata[self.system.FLOW_VAULT_REDACTIONS_KEY])
        self.system._live_snapshot_vault(self._snapshot(2))
        self.system.done()
        self.assertIs(flow.metadata[self.system.FLOW_BINDING_KEY], saved_binding)
        self.assertEqual(flow.metadata[self.system.FLOW_VAULT_REDACTIONS_KEY], saved_redactions)
        flow.request.content = b"FAKE_PLACEHOLDER"
        self.system.request(flow)
        self.assertEqual(flow.request.content, b"fake-token-1")
        flow.response = _Response.make(200, headers={"x-echo": "fake-token-1"})
        self.system.responseheaders(flow)
        self.assertEqual(flow.response.headers.get("x-echo"), "[REDACTED]")


class CredentialBoundEnvTest(unittest.TestCase):
    """configure() validation through the real IPC server path."""

    def setUp(self) -> None:
        _isolate_system_modules(self)
        import tempfile

        self.directory = tempfile.TemporaryDirectory(prefix="oscb-", dir="/tmp")
        self.path = str(Path(self.directory.name) / "receiver.sock")
        sys.path.insert(0, str(MITMSCRIPTS))

    def tearDown(self) -> None:
        sys.path.remove(str(MITMSCRIPTS))
        self.directory.cleanup()

    def _env(self, extra: dict[str, str]) -> dict[str, str]:
        env = {name: value for name, value in ENV.items()}
        env[ENV["socket"]] = self.path
        env[ENV["token"]] = TOKEN
        env[ENV["control"]] = CONTROL
        env[ENV["subject"]] = SUBJECT
        env[ENV["limit"]] = "1048576"
        env["OPENSANDBOX_EGRESS_MITMPROXY_PASSTHROUGH_HOSTS"] = "[]"
        env.update(extra)
        return env

    def test_live_configuration_builds_runtime_and_server(self) -> None:
        system = _load_system_module()
        live = {
            LIVE_ENV["tls_capacity"]: "64",
            LIVE_ENV["request_capacity"]: "256",
            LIVE_ENV["drain_timeout"]: "5",
        }
        with mock.patch.dict(os_environ(), self._env(live), clear=False):
            system.load(None)
        try:
            self.assertIsNotNone(system._live_runtime)
            self.assertIsNotNone(system._revision_server)
            self.assertTrue(Path(self.path).exists())
            system._live_runtime.close()
        finally:
            system.done()

    def test_native_selectors_and_bad_handoff_never_start_ipc(self) -> None:
        live = {LIVE_ENV["tls_capacity"]: "64", LIVE_ENV["request_capacity"]: "256",
                LIVE_ENV["drain_timeout"]: "5"}
        key = "OPENSANDBOX_EGRESS_MITMPROXY_PASSTHROUGH_HOSTS"
        cases = [("ignore_hosts", [".*"], "[]", ""),
                 ("allow_hosts", ["never-matches.example"], "[]", ""),
                 ("ignore_hosts", [], None, ""), ("ignore_hosts", [], "null", ""),
                 ("ignore_hosts", [], '["static.example"]', "http://proxy.example:8080")]
        for option, value, raw, upstream in cases:
            with self.subTest(option=option, raw=raw):
                system = _load_system_module()
                setattr(system.ctx.options, option, value)
                env = self._env(live)
                if raw is None:
                    env.pop(key)
                else:
                    env[key] = raw
                env["OPENSANDBOX_EGRESS_UPSTREAM_PROXY"] = upstream
                with mock.patch.dict(os_environ(), env, clear=True), mock.patch("revision_ipc.Server.start") as start:
                    with self.assertRaises(SystemExit):
                        system.load(None)
                    start.assert_not_called()
                self.assertFalse(Path(self.path).exists())
                self.assertIsNone(system._revision_server)
                self.assertIsNone(system._live_runtime)

    def test_native_selectors_rejected_on_configure_before_and_after_load(self) -> None:
        for option in ("ignore_hosts", "allow_hosts"):
            for value in ([".*"], ("",)):
                for enabled in (False, True):
                    system = _load_system_module()
                    system._live_runtime = object() if enabled else None
                    setattr(system.ctx.options, option, value)
                    with mock.patch.dict(os_environ(), {LIVE_ENV["tls_capacity"]: "64"}, clear=True):
                        with self.assertRaises(SystemExit):
                            system.configure({option})
                    system._live_runtime = None
                    with mock.patch.dict(os_environ(), {}, clear=True):
                        system.configure({option})  # Legacy options stay supported.

    def test_native_empty_regex_entries_never_start_ipc_on_either_path(self) -> None:
        system = _load_system_module()
        import credential_bound
        from static_passthrough import NATIVE_OPTIONS_ERROR

        live = {LIVE_ENV["tls_capacity"]: "64", LIVE_ENV["request_capacity"]: "256",
                LIVE_ENV["drain_timeout"]: "5"}
        actions = (lambda: system.load(None),
                   lambda: credential_bound.configure(self.path, TOKEN, CONTROL, SUBJECT, 1048576))
        for option in ("ignore_hosts", "allow_hosts"):
            for value in (("",), [""]):
                with self.subTest(option=option, value=value), \
                        mock.patch.object(system.ctx.options, option, value, create=True), \
                        mock.patch.dict(os_environ(), self._env(live), clear=True), \
                        mock.patch("revision_ipc.Server.start") as start:
                    for action in actions:
                        with self.assertRaises(SystemExit) as raised:
                            action()
                        self.assertEqual(str(raised.exception), NATIVE_OPTIONS_ERROR)
                    start.assert_not_called()
                    self.assertFalse(Path(self.path).exists())

    def test_empty_or_absent_native_options_are_valid_on_both_paths(self) -> None:
        system = _load_system_module()
        import credential_bound

        for options in (types.SimpleNamespace(),
                        types.SimpleNamespace(ignore_hosts=(), allow_hosts=()),
                        types.SimpleNamespace(ignore_hosts=[], allow_hosts=[])):
            with self.subTest(options=options), mock.patch.object(system.ctx, "options", options):
                system._validate_live_options()
                credential_bound.validate_live_options()

    def test_native_option_diagnostics_name_migration_without_values(self) -> None:
        for option in ("ignore_hosts", "allow_hosts"):
            system = _load_system_module()
            setattr(system.ctx.options, option, ["private-sensitive.example"])
            live = {LIVE_ENV["tls_capacity"]: "64", LIVE_ENV["request_capacity"]: "256",
                    LIVE_ENV["drain_timeout"]: "5"}
            with mock.patch.dict(os_environ(), self._env(live), clear=True):
                for action in (lambda: system.load(None), lambda: system.configure({option})):
                    with self.assertRaises(SystemExit) as raised:
                        action()
                    message = str(raised.exception)
                    self.assertIn("OPENSANDBOX_EGRESS_MITMPROXY_PASSTHROUGH_HOSTS", message)
                    self.assertNotIn("private-sensitive.example", message)
                    self.assertIn("must be empty", message)

    def test_partial_live_bundle_fails_closed(self) -> None:
        system = _load_system_module()
        partial = {LIVE_ENV["tls_capacity"]: "64"}
        with mock.patch.dict(os_environ(), self._env(partial), clear=False):
            with self.assertRaises(SystemExit):
                system.load(None)

    def test_invalid_drain_timeout_fails_closed(self) -> None:
        system = _load_system_module()
        invalid = {
            LIVE_ENV["tls_capacity"]: "64",
            LIVE_ENV["request_capacity"]: "256",
            LIVE_ENV["drain_timeout"]: "0",
        }
        with mock.patch.dict(os_environ(), self._env(invalid), clear=False):
            with self.assertRaises(SystemExit):
                system.load(None)

    def test_missing_live_bundle_keeps_installation_receiver(self) -> None:
        system = _load_system_module()
        with mock.patch.dict(os_environ(), self._env({}), clear=False):
            for key in LIVE_ENV.values():
                os_environ().pop(key, None)
            system.load(None)
        try:
            self.assertIsNone(system._live_runtime)
            self.assertIsNotNone(system._revision_server)
        finally:
            system.done()


def os_environ() -> dict[str, str]:
    import os

    return os.environ


class CredentialBoundSslInsecureTest(unittest.TestCase):
    """ssl_insecure must never combine with the live admission receiver."""

    def setUp(self) -> None:
        _isolate_system_modules(self)
        sys.path.insert(0, str(MITMSCRIPTS))
        self.system, self.receiver, self.runtime = _system_with_live_runtime()
        self._epoch = 0

    def tearDown(self) -> None:
        sys.path.remove(str(MITMSCRIPTS))
        self.system.ctx.options.ssl_insecure = False

    def _install_bound(self) -> None:
        self._epoch += 1
        payload = _decision_payload(
            [_binding("api", "api.example.com", "token-v1")], ["token-v1"], 1
        )
        identity = _revision(payload, self._epoch, 1)
        self.receiver.prepare(identity, payload)
        self.receiver.commit(identity)

    def test_load_rejects_ssl_insecure_with_live_bundle(self) -> None:
        system = _load_system_module()
        system.ctx.options.ssl_insecure = True
        env = {ENV["socket"]: "/nonexistent/x.sock", ENV["token"]: TOKEN,
               ENV["control"]: CONTROL, ENV["subject"]: SUBJECT,
               ENV["limit"]: "1048576",
               LIVE_ENV["tls_capacity"]: "64",
               LIVE_ENV["request_capacity"]: "256",
               LIVE_ENV["drain_timeout"]: "5"}
        with mock.patch.dict(os_environ(), env, clear=False):
            with self.assertRaises(SystemExit):
                system.load(None)

    def test_configure_hook_rejects_toggling_ssl_insecure(self) -> None:
        self.system.ctx.options.ssl_insecure = True
        with self.assertRaises(SystemExit):
            self.system.configure({"ssl_insecure"})
        self.system.ctx.options.ssl_insecure = False
        # Unrelated option changes and legacy mode stay non-fatal.
        self.system.configure({"other_option"})

    def test_handshake_denies_when_option_turned_true(self) -> None:
        self._install_bound()
        self.system.ctx.options.ssl_insecure = True
        data = _ClientHelloData("api.example.com")
        self.system.tls_clienthello(data)
        self.assertFalse(data.ignore_connection)
        self.assertTrue(data.client_conn.closed)

    def test_request_denies_injection_when_option_turned_true(self) -> None:
        self._install_bound()
        conn = _ClientConn(sni="api.example.com")
        self.system.tls_clienthello(_ClientHelloData("api.example.com", conn))
        self.assertFalse(conn.closed)
        self.system.ctx.options.ssl_insecure = True
        flow = _Flow(client_conn=conn)
        self.system.requestheaders(flow)
        self.assertIsNotNone(flow.response)
        self.assertEqual(flow.response.status_code, 503)
        self.assertNotIn("Authorization", flow.request.headers)


class CredentialBoundECHTest(unittest.TestCase):
    """ECH extension handling at hook level (real-wire cases in test_ech_wire)."""

    def setUp(self) -> None:
        _isolate_system_modules(self)
        sys.path.insert(0, str(MITMSCRIPTS))
        self.system, self.receiver, self.runtime = _system_with_live_runtime()
        self._epoch = 0
        self.install_bound()

    def tearDown(self) -> None:
        sys.path.remove(str(MITMSCRIPTS))

    def install_bound(self) -> None:
        self._epoch += 1
        payload = _decision_payload(
            [_binding("api", "api.example.com", "token-v1")], ["token-v1"], 1
        )
        identity = _revision(payload, self._epoch, 1)
        self.receiver.prepare(identity, payload)
        self.receiver.commit(identity)

    def test_ech_extension_passes_through_opaquely(self) -> None:
        # Bound outer SNI but an ECH extension is present: the connection is
        # passed through untouched — no decrypt, no admission token, no tunnel.
        data = _ClientHelloData(
            "api.example.com",
            extensions=[(0x0000, b"\x00\x14"), (0xFE0D, b"\x01\x02\x03")],
        )
        self.system.tls_clienthello(data)
        self.assertTrue(data.ignore_connection)
        self.assertFalse(data.client_conn.closed)
        self.assertIsNone(self.runtime.token_for(data.client_conn))

    def test_valid_extension_list_without_ech_still_decrypts(self) -> None:
        data = _ClientHelloData(
            "api.example.com",
            extensions=[(0x0000, b"\x00\x14"), (0x0010, b"\x00\x03\x02h2")],
        )
        self.system.tls_clienthello(data)
        self.assertFalse(data.ignore_connection)
        self.assertFalse(data.client_conn.closed)
        self.assertIsNotNone(self.runtime.token_for(data.client_conn))

    def test_malformed_extensions_deny_instead_of_decrypting(self) -> None:
        for bad in (
            [(0xFE0D,)],                        # short tuple
            [("0xfe0d", b"\x00")],              # non-int type
            [(0xFE0D, "not-bytes")],            # non-bytes body
            "not-a-list",                        # uninspectable shape
        ):
            data = _ClientHelloData("api.example.com", extensions=bad)
            self.system.tls_clienthello(data)
            self.assertFalse(data.ignore_connection, f"{bad!r} was tunneled")
            self.assertTrue(data.client_conn.closed, f"{bad!r} was not denied")


class CredentialBoundH1AuthorityTest(unittest.TestCase):
    """Strict HTTP/1 authority validation before binding selection."""

    def setUp(self) -> None:
        _isolate_system_modules(self)
        sys.path.insert(0, str(MITMSCRIPTS))
        self.system, self.receiver, self.runtime = _system_with_live_runtime()
        self._epoch = 0
        self.install_bound()

    def tearDown(self) -> None:
        sys.path.remove(str(MITMSCRIPTS))

    def install_bound(self) -> None:
        self._epoch += 1
        payload = _decision_payload(
            [_binding("api", "api.example.com", "token-v1")], ["token-v1"], 1
        )
        identity = _revision(payload, self._epoch, 1)
        self.receiver.prepare(identity, payload)
        self.receiver.commit(identity)

    def _admitted_flow(self, host: str = "api.example.com") -> _Flow:
        conn = _ClientConn(sni="api.example.com")
        self.system.tls_clienthello(_ClientHelloData("api.example.com", conn))
        flow = _Flow(client_conn=conn, host=host)
        return flow

    def _assert_denied(self, flow: _Flow) -> None:
        self.system.requestheaders(flow)
        self.assertIsNotNone(flow.response)
        self.assertEqual(flow.response.status_code, 403)
        self.assertNotIn("Authorization", flow.request.headers)
        self.system.response(flow)

    def _assert_allowed(self, flow: _Flow) -> None:
        self.system.requestheaders(flow)
        self.assertIsNone(flow.response)
        self.assertEqual(flow.request.headers.get("Authorization"), "token-v1")
        self.system.response(flow)

    def test_origin_form_matching_host_succeeds(self) -> None:
        self._assert_allowed(self._admitted_flow())

    def test_explicit_port_443_host_succeeds(self) -> None:
        flow = self._admitted_flow()
        flow.request.headers["host"] = "api.example.com:443"
        self._assert_allowed(flow)

    def test_uppercase_and_root_dot_normalize(self) -> None:
        flow = self._admitted_flow()
        flow.request.headers["host"] = "API.EXAMPLE.COM.:443"
        self._assert_allowed(flow)

    def test_valid_matching_absolute_target_succeeds(self) -> None:
        flow = self._admitted_flow()
        flow.request.authority = "api.example.com:443"
        self._assert_allowed(flow)

    def test_absolute_target_wrong_host_denies(self) -> None:
        flow = self._admitted_flow()
        flow.request.authority = "other.example.com:443"
        self._assert_denied(flow)

    def test_absolute_target_wrong_port_denies(self) -> None:
        flow = self._admitted_flow()
        flow.request.authority = "api.example.com:8443"
        self._assert_denied(flow)

    def test_conflicting_host_and_authority_deny(self) -> None:
        flow = self._admitted_flow()
        flow.request.headers["host"] = "api.example.com"
        flow.request.authority = "other.example.com"
        self._assert_denied(flow)

    def test_wrong_host_port_denies(self) -> None:
        flow = self._admitted_flow()
        flow.request.headers["host"] = "api.example.com:8443"
        self._assert_denied(flow)

    def test_missing_host_denies(self) -> None:
        flow = self._admitted_flow()
        del flow.request.headers["host"]
        self._assert_denied(flow)

    def test_duplicate_host_denies(self) -> None:
        flow = self._admitted_flow()
        flow.request.headers.get_all = lambda name: (
            ["api.example.com", "api.example.com"]
            if name.lower() == "host"
            else []
        )
        self._assert_denied(flow)

    def test_malformed_host_denies(self) -> None:
        for bad in (
            "api.example.com evil",
            "api.example.com:abc",
            "api.example.com:",
            "[email protected]",
            "api.example.com,other.example.com",
            "api%2eexample.com",
            "api.example.com/path",
            "api.example.com?q=1",
            "[::1]",
            "api.example.com:1",
            "no-tld",
            "127.0.0.1",
        ):
            flow = self._admitted_flow()
            flow.request.headers["host"] = bad
            self._assert_denied(flow)

    def test_cross_authority_denied_even_on_out_of_scope_path(self) -> None:
        flow = self._admitted_flow()
        flow.request.path = "/health"
        flow.request.headers["host"] = "other.example.com"
        self._assert_denied(flow)

    def test_token_sni_mismatch_denies(self) -> None:
        # A non-registry token object must never acquire admission; the
        # request is denied before any credential is consulted.
        flow = self._admitted_flow()
        with mock.patch.object(
            self.runtime, "token_for",
            return_value=types.SimpleNamespace(sni="other.example.com"),
        ):
            self.system.requestheaders(flow)
        self.assertTrue(
            flow.killed or (flow.response is not None and flow.response.status_code >= 400),
            "a foreign token object acquired request admission",
        )
        self.assertNotIn("Authorization", flow.request.headers)

    def test_http2_without_instance_adapter_denies_in_live_mode(self) -> None:
        # H2 cannot acquire a request without the exact raw-identity adapter.
        # Existing H1 fixtures deliberately do not attach one.
        flow = self._admitted_flow()
        flow.request.http_version = "HTTP/2.0"
        self.system.requestheaders(flow)
        self.assertTrue(
            flow.killed or (flow.response is not None and flow.response.status_code >= 400),
            "an HTTP/2 request received credentials in live mode",
        )
        self.assertNotIn("Authorization", flow.request.headers)

    def test_connect_method_denies(self) -> None:
        flow = self._admitted_flow()
        flow.request.method = "CONNECT"
        self._assert_denied(flow)

    def test_non_443_request_port_denies(self) -> None:
        flow = self._admitted_flow()
        flow.request.port = 8443
        self._assert_denied(flow)


class CredentialBoundDrainPagingTest(unittest.TestCase):
    """Drain sweeps page past _DRAIN_PAGE_LIMIT and retry failed closes."""

    def setUp(self) -> None:
        _isolate_system_modules(self)
        sys.path.insert(0, str(MITMSCRIPTS))
        self.system = _load_system_module()
        from credential_bound import LiveRuntime
        from revision_publication import LiveReceiver

        self.receiver = LiveReceiver(
            CONTROL, SUBJECT, max_snapshot_bytes=1 << 20, capacity=256,
            request_capacity=2048, drain_timeout_seconds=1,
        )
        self.runtime = LiveRuntime(self.receiver, identity=(CONTROL, SUBJECT))
        self.system._live_runtime = self.runtime
        self._epoch = 0
        self.install_bound()

    def tearDown(self) -> None:
        sys.path.remove(str(MITMSCRIPTS))

    def install_bound(self) -> None:
        self._epoch += 1
        payload = _decision_payload(
            [_binding("api", "api.example.com", "token-v1")], ["token-v1"], 1
        )
        identity = _revision(payload, self._epoch, 1)
        self.receiver.prepare(identity, payload)
        self.receiver.commit(identity)

    def _admit(self, count: int) -> list[tuple[Any, Any]]:
        pairs = []
        for _ in range(count):
            data = _ClientHelloData("api.example.com")
            self.system.tls_clienthello(data)
            token = self.runtime.token_for(data.client_conn)
            self.assertIsNotNone(token)
            pairs.append((token, data.client_conn))
        return pairs

    def _expire(self, pairs: list[tuple[Any, Any]], *, offset: float = -1) -> None:
        import time

        registry = self.runtime.registry
        with registry._lock:
            for token, _conn in pairs:
                registry._connection_deadlines[token.serial] = (
                    time.monotonic() + offset
                )

    def test_sweep_pages_past_page_limit_without_starvation(self) -> None:
        # 130 expired transports > 2 * _DRAIN_PAGE_LIMIT: one sweep must reach
        # every page, not stop at the first page or a stuck target.
        pairs = self._admit(130)
        self._expire(pairs)
        closed = self.runtime.drain_sweep_once()
        self.assertEqual(130, closed)
        for _token, conn in pairs:
            self.assertTrue(conn.closed)
        # A scheduled close is not a release: membership persists until the
        # disconnect hook confirms the transport is gone.
        self.assertEqual(130, self.runtime.registry.count)

    def test_failed_close_is_retried_next_sweep(self) -> None:
        pairs = self._admit(80)
        self._expire(pairs)
        failing = {token.serial for token, _ in pairs[:64]}
        original = self.runtime._close_established
        serials = {id(conn): token.serial for token, conn in pairs}
        failed_once: set = set()

        def flaky(conn):
            serial = serials.get(id(conn))
            if serial in failing and serial not in failed_once:
                failed_once.add(serial)
                return False
            return original(conn)

        self.runtime._close_established = flaky
        first = self.runtime.drain_sweep_once()
        self.assertEqual(16, first)  # only the last 16 of the first page close
        self.assertEqual(80, self.runtime.registry.count)  # nothing released
        second = self.runtime.drain_sweep_once()
        self.assertEqual(80, second)  # every still-registered transport retried
        for _token, conn in pairs:
            self.assertTrue(conn.closed)

    def test_delayed_disconnect_keeps_membership_until_confirmed(self) -> None:
        pairs = self._admit(3)
        self._expire(pairs)
        self.assertEqual(3, self.runtime.drain_sweep_once())
        self.assertEqual(3, self.runtime.registry.count)
        # A scheduled close is not confirmed: later sweeps keep retrying the
        # still-registered transports until client_disconnected releases them.
        self.assertEqual(3, self.runtime.drain_sweep_once())
        token, conn = pairs[0]
        self.assertIs(self.runtime.token_for(conn), token)
        self.system.client_disconnected(conn)
        self.assertEqual(2, self.runtime.registry.count)
        self.assertIsNone(self.runtime.token_for(conn))

    def test_expiry_boundary_is_exact(self) -> None:
        import time

        pairs = self._admit(2)
        expired, pending = pairs
        registry = self.runtime.registry
        with registry._lock:
            registry._connection_deadlines[expired[0].serial] = time.monotonic() - 0.001
            registry._connection_deadlines[pending[0].serial] = time.monotonic() + 100
        self.assertEqual(1, self.runtime.drain_sweep_once())
        self.assertTrue(expired[1].closed)
        self.assertFalse(pending[1].closed)
        # Exactly-at-now deadlines expire as well (deadline <= now).
        with registry._lock:
            registry._connection_deadlines[pending[0].serial] = time.monotonic()
        # The newly expired target is attempted, and the still-registered
        # earlier target is retried until its disconnect hook runs.
        self.assertEqual(2, self.runtime.drain_sweep_once())
        self.assertTrue(pending[1].closed)

    def test_event_loop_close_failure_retries_until_disconnect(self) -> None:
        # A scheduled event-loop close is not a confirmed close: a handler
        # failure must be retried by the next sweep, and later-page targets
        # must still be attempted.
        pairs = self._admit(4)
        self._expire(pairs)
        conns = {conn.id: conn for _token, conn in pairs}
        calls: dict[str, int] = {}

        class _Handler:
            def __init__(self, fail_once: bool) -> None:
                self.fail_once = fail_once

            def close_connection(self, client_conn: Any) -> None:
                calls[client_conn.id] = calls.get(client_conn.id, 0) + 1
                if self.fail_once:
                    self.fail_once = False
                    raise OSError("transient close failure")
                client_conn.closed = True

        handlers = {
            conn.id: _Handler(fail_once=(conn is pairs[0][1]))
            for conn in conns.values()
        }

        class _Loop:
            def call_soon_threadsafe(self, callback: Any, *args: Any) -> None:
                callback(*args)

        self.runtime._loop = _Loop()
        self.runtime._proxyserver = types.SimpleNamespace(connections=handlers)
        first = self.runtime.drain_sweep_once()
        self.assertEqual(4, first)  # every expired transport attempted
        self.assertFalse(pairs[0][1].closed, "failed close must not mark closed")
        self.assertEqual(1, calls[pairs[0][1].id])
        for _token, conn in pairs[1:]:
            self.assertEqual(1, calls[conn.id])
        # Still registered: a second sweep retries the failed target, and the
        # registry is only released by the disconnect hook.
        second = self.runtime.drain_sweep_once()
        self.assertEqual(4, second)
        self.assertEqual(2, calls[pairs[0][1].id])
        self.assertTrue(pairs[0][1].closed)
        self.assertEqual(4, self.runtime.registry.count)
        self.system.client_disconnected(pairs[0][1])
        self.assertEqual(3, self.runtime.registry.count)


class CredentialBoundModuleIsolationTest(unittest.TestCase):
    def test_restores_preloaded_modules_even_when_setup_fails(self) -> None:
        saved = {name: types.ModuleType(name) for name in _SYSTEM_MODULES}
        with mock.patch.dict(sys.modules, saved):
            case = unittest.TestCase()
            try:
                with self.assertRaisesRegex(RuntimeError, "synthetic setup failure"):
                    _isolate_system_modules(case)
                    for name in _SYSTEM_MODULES:
                        self.assertNotIn(name, sys.modules)
                        sys.modules[name] = types.ModuleType(name)
                    raise RuntimeError("synthetic setup failure")
            finally:
                case.doCleanups()
            for name, module in saved.items():
                self.assertIs(sys.modules[name], module)

    def test_removes_modules_that_were_not_preloaded(self) -> None:
        with mock.patch.dict(sys.modules):
            for name in _SYSTEM_MODULES:
                sys.modules.pop(name, None)
            case = unittest.TestCase()
            try:
                _isolate_system_modules(case)
                for name in _SYSTEM_MODULES:
                    sys.modules[name] = types.ModuleType(name)
            finally:
                case.doCleanups()
            for name in _SYSTEM_MODULES:
                self.assertNotIn(name, sys.modules)


if __name__ == "__main__":
    unittest.main()