Skip to content

The agent that grows with you

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.py
index 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: the
Win32 facts are passed in (#140706).
*process_sid* is the server process's token user, None when this client cannot open the
process; *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 DACL
granting 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_sid
owner_elevated = True
else:
@@ -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_elevated
try:
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 None
try:
pipe = _pipe_security(handle)
except PermissionError:
pipe = None
return 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.py
index 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 w
These 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 real
elevated-server / standard-user-client attach.
"""
@@ -53,7 +54,7 @@ def pipe(monkeypatch):
import hermes_dir_acl
def 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_el
assert 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)