The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
fix(gateway): judge a readable gateway's elevation from its token
unsupportedpastels1130089e424f
diff --git a/gateway/runtime_bootstrap_windows.py b/gateway/runtime_bootstrap_windows.pyindex a9fa5ab63c4..39edd62a0dc 100644--- a/gateway/runtime_bootstrap_windows.py+++ b/gateway/runtime_bootstrap_windows.py@@ -452,17 +452,21 @@ class RefusedOwner(PermissionError):def judge_pipe_server(*, own_sid: str, process_sid: str | None, pipe: tuple[str, tuple] | None, pid: int,- own_elevated: bool, own_session: int | None, server_session: int | None) -> str:+ own_elevated: bool, own_session: int | None, server_session: int | None,+ server_elevated: bool | None = None) -> str:"""``sid:<own>`` when this client may talk to the pipe's server; raises otherwise. Pure: theWin32 facts are passed in (#140706).*process_sid* is the server process's token user, None when this client cannot open theprocess; *pipe* is the pipe object's ``(owner, dacl)`` (:func:`_pipe_security`), None when- unreadable.-- * Server process readable: its token user must be this user. A pipe owned by- BUILTIN\\Administrators was made by an elevated process, and a non-elevated client never- hands its requests to one (its tools would run with the full administrator token).+ unreadable; *server_elevated* is the readable server token's ``TokenElevation``, None when+ that probe failed.++ * Server process readable: its token user must be this user, and a non-elevated client never+ hands its requests to an elevated server (its tools would run with the full administrator+ token). The server token's elevation says so whatever owns the pipe (the 'Object creator'+ owner policy gives an elevated process's pipe to the user); only when that probe fails does+ the owner decide: BUILTIN\\Administrators means an elevated process made the pipe.* Server process unreadable (an elevated server seen from a filtered token): never attached.The pipe object says who made it: owner this user or BUILTIN\\Administrators, and a DACLgranting exactly this user, the gateway's own private shape (``_create_pipe``). Another@@ -473,7 +477,9 @@ def judge_pipe_server(*, own_sid: str, process_sid: str | None, pipe: tuple[str,if process_sid is not None:if process_sid != own_sid:raise PermissionError('named-pipe peer belongs to another user')- if owner != _ADMINISTRATORS_SID or own_elevated:+ if server_elevated is None:+ server_elevated = owner == _ADMINISTRATORS_SID+ if own_elevated or not server_elevated:return 'sid:' + own_sidowner_elevated = Trueelse:@@ -487,25 +493,28 @@ def judge_pipe_server(*, own_sid: str, process_sid: str | None, pipe: tuple[str,if reason is None:raise PermissionError('cannot verify bootstrap peer process')logger.info('control pipe server PID %s refused as %s: pipe owner %s, server process %s, '- 'server session %s, own session %s', pid, reason, owner,- 'readable' if process_sid else 'unreadable', server_session, own_session)+ 'server elevated %s, server session %s, own session %s', pid, reason, owner,+ 'readable' if process_sid else 'unreadable', server_elevated, server_session, own_session)raise RefusedOwner(reason, pid, refused_owner_remedy(reason, pid, server_session))def _server_subject(handle, pid: int) -> str:"""The client half of the pipe identity check: the Win32 facts for :func:`judge_pipe_server`."""- from hermes_dir_acl import process_is_elevated+ from hermes_dir_acl import process_elevation, process_is_elevatedtry:process_sid = _process_sid(pid)except PermissionError:process_sid = None+ # A readable process's token answers TokenElevation too (the same OpenProcess + TOKEN_QUERY);+ # None, the probe failing, leaves the pipe owner to decide.+ server_elevated = process_elevation(pid) if process_sid is not None else Nonetry:pipe = _pipe_security(handle)except PermissionError:pipe = Nonereturn judge_pipe_server(own_sid=_process_sid(os.getpid()), process_sid=process_sid, pipe=pipe, pid=pid,own_elevated=process_is_elevated(), own_session=_session_of(os.getpid()),- server_session=_pipe_server_session(handle))+ server_session=_pipe_server_session(handle), server_elevated=server_elevated)def _session_of(pid: int) -> int | None:diff --git a/tests/gateway/test_runtime_bootstrap_server_identity.py b/tests/gateway/test_runtime_bootstrap_server_identity.pyindex 57216031058..51e6f8a2cc0 100644--- a/tests/gateway/test_runtime_bootstrap_server_identity.py+++ b/tests/gateway/test_runtime_bootstrap_server_identity.py@@ -8,8 +8,9 @@ cannot ``OpenProcess`` an elevated gateway, so every Desktop/CLI attach failed wThese tests drive that entry on any host by injecting the Win32 calls, never ``sys.platform``:``ctypes.WinDLL`` answers the ULONG-out queries (server PID and session, own session),``_process_sid`` stands in for OpenProcess + token (raising for an elevated server),-``_pipe_security`` for ``GetSecurityInfo`` on the pipe handle, and ``process_is_elevated`` for-this client's token. ``test_runtime_bootstrap.py`` reads a real pipe's facts on Windows, and+``_pipe_security`` for ``GetSecurityInfo`` on the pipe handle, ``process_elevation`` for a+readable server's ``TokenElevation``, and ``process_is_elevated`` for this client's token.+``test_runtime_bootstrap.py`` reads a real pipe's facts on Windows, and``tests/e2e/core/windows_update/test_elevated_gateway_attach.py`` runs the realelevated-server / standard-user-client attach."""@@ -53,7 +54,7 @@ def pipe(monkeypatch):import hermes_dir_acldef install(*, process_sid, owner=OWN, aces=((0, OWN),), readable=True, own_elevated=False,- own_session=1, server_session=1, client_pid=None):+ own_session=1, server_session=1, client_pid=None, server_elevated=None):kernel = _Kernel32({"GetNamedPipeServerProcessId": SERVER_PID, "GetNamedPipeClientProcessId": client_pid,"GetNamedPipeServerSessionId": server_session, "ProcessIdToSessionId": own_session})monkeypatch.setattr(ctypes, "WinDLL", lambda name, use_last_error=False: kernel, raising=False)@@ -73,6 +74,12 @@ def pipe(monkeypatch):return owner, tuple(aces)monkeypatch.setattr(native, "_pipe_security", security, raising=False)monkeypatch.setattr(hermes_dir_acl, "process_is_elevated", lambda: own_elevated)++ def elevation(pid=None):+ # TokenElevation of the server's token; None (the probe failed) unless a test says otherwise.+ assert pid == SERVER_PID and process_sid is not None, "elevation probed for an unreadable server"+ return server_elevated+ monkeypatch.setattr(hermes_dir_acl, "process_elevation", elevation)return install@@ -104,6 +111,26 @@ def test_an_unopenable_same_user_pipe_is_the_elevation_boundary(pipe):assert getattr(_refusal(), "reason_code", None) == "gateway_elevated"+def test_a_readable_elevated_server_is_named_whatever_owns_its_pipe(pipe):+ """Under the 'Object creator' owner policy an elevated gateway's pipe is owned by the user, so+ the owner says nothing. The server's own token (``TokenElevation``, readable whenever the+ process is) says it is elevated and this client is not: the named refusal, not an attach."""+ pipe(process_sid=OWN, owner=OWN, server_elevated=True)+ refused = _refusal()+ assert getattr(refused, "reason_code", None) == "gateway_elevated", refused+ assert str(refused) == native.refused_owner_remedy("gateway_elevated", SERVER_PID, 1)++[email protected](("owner", "attached"), [(ADMINS, False), (OWN, True)])+def test_a_failing_elevation_probe_falls_back_to_the_pipe_owner(pipe, owner, attached):+ """The server is readable but its token's elevation is not: the owner inference decides, as before."""+ pipe(process_sid=OWN, owner=owner, server_elevated=None)+ if attached:+ assert native._peer_subject(HANDLE, server=True) == "sid:" + OWN+ else:+ assert getattr(_refusal(), "reason_code", None) == "gateway_elevated"++def test_an_unopenable_gateway_in_another_session_is_named_as_such(pipe):pipe(process_sid=None, owner=ADMINS, own_session=1, server_session=0)refused = _refusal()@@ -264,6 +291,17 @@ def test_a_same_user_server_at_the_clients_level_is_attached(pipe, owner, own_elassert native._peer_subject(HANDLE, server=True) == "sid:" + OWN[email protected](("owner", "own_elevated", "server_elevated"), [+ (OWN, True, True), # both elevated, user-owned pipe+ (ADMINS, True, True), # both elevated+ (OWN, False, False), # neither elevated+ (ADMINS, False, False), # the server's token says not elevated: it decides over the owner+])+def test_a_readable_server_at_the_clients_elevation_is_attached(pipe, owner, own_elevated, server_elevated):+ pipe(process_sid=OWN, owner=owner, own_elevated=own_elevated, server_elevated=server_elevated)+ assert native._peer_subject(HANDLE, server=True) == "sid:" + OWN++def test_the_serving_side_never_judges_a_client_by_the_pipe_owner(pipe, monkeypatch):"""Identifying a CLIENT is unchanged: no token and no readable process stays refused."""pipe(process_sid=None, client_pid=SERVER_PID + 1)