session_ingress_context.py 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266
  1. """Process-local callback provenance; private snapshots are revalidated, not grants."""
  2. from contextlib import contextmanager
  3. from copy import copy
  4. from contextvars import ContextVar
  5. from pathlib import Path
  6. import weakref
  7. import hashlib
  8. import hmac
  9. import json
  10. from hermes_state_runtime import RuntimeStoreError
  11. _callback: ContextVar[tuple | None] = ContextVar('native_ingress_callback', default=None)
  12. _relay_callback: ContextVar[tuple | None] = ContextVar('relay_ingress_callback', default=None)
  13. @contextmanager
  14. def relay_callback(transport, event):
  15. # Only the authenticated WS reader installs this; wire fields cannot mint it.
  16. token = _relay_callback.set((transport, event))
  17. try:
  18. yield
  19. finally:
  20. _relay_callback.reset(token)
  21. @contextmanager
  22. def relay_passthrough_event(transport, forward, event):
  23. # A passthrough frame is decoded after the reader bound its proof to the raw forward; move
  24. # that proof onto the decoded event. Without the reader's binding nothing is minted.
  25. bound = _relay_callback.get()
  26. if bound is None or bound[0] is not transport or bound[1] is not forward:
  27. yield
  28. return
  29. with relay_callback(transport, event):
  30. yield
  31. def _relay_connector(adapter, source):
  32. from gateway.relay.ws_transport import WebSocketRelayTransport
  33. transport = getattr(adapter, '_transport', None)
  34. if (not isinstance(transport, WebSocketRelayTransport)
  35. or not transport._gateway_id or not transport._upgrade_secret
  36. or transport.auth_revoked or transport._closing or transport._ws is None
  37. or transport.descriptor_for_platform(source.platform.value) is None
  38. or transport._bot_id_for(source.platform.value) is None):
  39. raise RuntimeStoreError('permission_denied')
  40. identity = json.dumps([transport._url, transport._gateway_id, transport._identities],
  41. sort_keys=True, separators=(',', ':'))
  42. connector = hmac.new(transport._upgrade_secret.encode(), identity.encode(), hashlib.sha256).hexdigest()
  43. return transport, connector
  44. def _relay_seal(transport, source, provenance):
  45. binding = [provenance, source.to_dict(), source.is_bot]
  46. return hmac.new(transport._upgrade_secret.encode(),
  47. json.dumps(binding, sort_keys=True, separators=(',', ':')).encode(),
  48. hashlib.sha256).hexdigest()
  49. def reseal_relay(adapter, source, provenance):
  50. """*provenance* bound to the stored *source* dict instead; only for a seal the caller verified."""
  51. from gateway.session import SessionSource
  52. stored = SessionSource.from_dict(source)
  53. stored.is_bot = source['is_bot']
  54. base = {key: value for key, value in provenance.items() if key != 'relay'}
  55. return {**base, 'relay': _relay_seal(adapter._transport, stored, base)}
  56. def register_transport_home(runner, profile, home):
  57. """Called when the server creates a callback, never from event home fields."""
  58. homes = getattr(runner, '_native_transport_homes', None)
  59. if homes is None:
  60. homes = runner._native_transport_homes = {}
  61. homes[profile] = Path(home).resolve() if home is not None else None
  62. @contextmanager
  63. def native_callback(runner, event, transport_home, profile=None):
  64. if transport_home is None:
  65. if getattr(runner, 'session_authority', None) is not None:
  66. raise RuntimeStoreError('profile_mismatch')
  67. yield
  68. return
  69. token = _callback.set((runner, event, Path(transport_home).resolve(), profile))
  70. try:
  71. yield
  72. finally:
  73. _callback.reset(token)
  74. def carry_callback(event, rewritten):
  75. """Gateway code that rebuilds a callback's event (a ``pre_gateway_dispatch`` rewrite, the
  76. ``/retry`` re-send) keeps the callback's provenance, but only on the source object the callback
  77. authenticated: a new event with a swapped source carries nothing (#139045, #139040)."""
  78. for bound_var in (_callback, _relay_callback):
  79. bound = bound_var.get()
  80. if bound is not None and bound[1] is event and rewritten.source is event.source:
  81. bound_var.set((bound[0], rewritten, *bound[2:]))
  82. _PREFIX_PRODUCERS = ('webhook', 'api_server', 'msgraph_webhook')
  83. def _runtime_profile(runner, source, profile, owner_name, homes, relay):
  84. """The multiplexed runtime profile *source* routes to; ``_binding`` checks it is served."""
  85. # Same matcher as ingress stamping, ``user_id`` included: a ``user_id`` route stamps the
  86. # source upstream, so it must resolve here too. A route applies only to its bot_profile's
  87. # bot (#104933), so the receiving adapter's owner is part of the match.
  88. matches = [route for route in runner.config.profile_routes if route.matches(
  89. source.platform.value, guild_id=source.scope_id, chat_id=source.chat_id,
  90. thread_id=source.thread_id, parent_chat_id=source.parent_chat_id,
  91. adapter_profile=profile, user_id=source.user_id)]
  92. if source.profile and source.platform.value in _PREFIX_PRODUCERS:
  93. # ``/p/<profile>/`` producers address a profile explicitly on the HOST's listener; that
  94. # URL prefix names the profile and wins over ``profile_routes`` (webhook.py /
  95. # api_server.py stamp it; a bare producer source carries the routed name itself).
  96. return source.profile
  97. if matches:
  98. rank = max(route.specificity for route in matches)
  99. best = [route for route in matches if route.specificity == rank]
  100. if len(best) != 1:
  101. raise RuntimeStoreError('admission_conflict')
  102. return best[0].profile
  103. if relay and profile is None and source.profile in homes:
  104. # The instance's one authenticated connector (relay is process-level) routes scopes to
  105. # served profiles (Team Gateway); the relay seal covers ``source.profile``.
  106. return source.profile
  107. return owner_name
  108. def _binding(runner, source, profile):
  109. registries = [(None, runner.adapters), *getattr(runner, '_profile_adapters', {}).items()]
  110. from gateway.config import Platform
  111. relay = source.delivered_via_upstream_relay is True
  112. platform = Platform.RELAY if relay else source.platform
  113. candidates = [(owner, mapping.get(platform)) for owner, mapping in registries]
  114. adapter = next((adapter for owner, adapter in candidates if owner == profile), None)
  115. if adapter is None or sum(item is adapter for _, item in candidates) != 1:
  116. raise RuntimeStoreError('not_found')
  117. home = getattr(runner, '_native_transport_homes', {}).get(profile)
  118. if home is None or not home.is_dir():
  119. raise RuntimeStoreError('profile_mismatch')
  120. runtime_home = home
  121. multiplex = getattr(runner.config, 'multiplex_profiles', False)
  122. if not multiplex and source.profile:
  123. raise RuntimeStoreError('profile_mismatch')
  124. if multiplex:
  125. # Only the reservation-backed server registry proves a served home. Directory
  126. # discovery and _resolve_profile_home_for_source's primary fallback do not.
  127. reserved = getattr(runner.config, '_runtime_profile_homes', None)
  128. if reserved is None:
  129. raise RuntimeStoreError('profile_mismatch')
  130. homes = {}
  131. for name, path in reserved:
  132. canonical = Path(path).resolve()
  133. if name in homes or canonical in homes.values():
  134. raise RuntimeStoreError('profile_mismatch')
  135. homes[name] = canonical
  136. # The primary is the reserved entry whose home IS the launch home (identity, not the
  137. # display name: a custom HERMES_HOME reports 'custom' while its reservation says 'default').
  138. from hermes_constants import get_process_hermes_home
  139. launch = get_process_hermes_home().resolve()
  140. primary = next((name for name, path in homes.items() if path == launch), None)
  141. if primary is None:
  142. raise RuntimeStoreError('profile_mismatch')
  143. owner_name = profile or primary
  144. if homes.get(owner_name) != home:
  145. raise RuntimeStoreError('profile_mismatch')
  146. runtime_profile = _runtime_profile(runner, source, profile, owner_name, homes, relay)
  147. if (source.profile or primary) != runtime_profile or runtime_profile not in homes:
  148. raise RuntimeStoreError('profile_mismatch')
  149. runtime_home = homes[runtime_profile]
  150. # Revoking ONE served profile (its directory removed) fails that profile only.
  151. if not runtime_home.is_dir():
  152. raise RuntimeStoreError('profile_mismatch')
  153. # A configured/transport home is NOT proof of a runtime DB owner: the runtime home must be
  154. # one this process reserved and built an authority for, never a borrowed launch DB.
  155. from gateway.session_authorities import authority_for_home
  156. authority = authority_for_home(runner, runtime_home)
  157. if authority is None:
  158. raise RuntimeStoreError('profile_mismatch')
  159. if relay:
  160. transport, connector = _relay_connector(adapter, source)
  161. else:
  162. # The connector pins "the same credential still serves this route" across a restart. A
  163. # plugin platform with no discoverable credential (in-memory / socket-only adapters) is
  164. # still one registered adapter; it binds by platform + owning profile rather than being
  165. # refused as not_found.
  166. connector = (runner._adapter_credential_fingerprint(adapter)
  167. or f'adapter:{source.platform.value}:{profile or ""}')
  168. if connector is None:
  169. raise RuntimeStoreError('not_found')
  170. provenance = {'transport_home': str(home), 'runtime_home': str(runtime_home),
  171. 'platform': source.platform.value, 'connector': connector}
  172. if multiplex:
  173. provenance['transport_profile'] = profile
  174. if relay:
  175. provenance['relay'] = _relay_seal(transport, source, provenance)
  176. return adapter, home, runtime_home, provenance
  177. def capture_provenance(runner, event):
  178. context = _callback.get()
  179. if context is None or context[0] is not runner or context[1] is not event:
  180. return None
  181. adapter, home, _, provenance = _binding(runner, event.source, context[3])
  182. if event.source.delivered_via_upstream_relay:
  183. delivery = _relay_callback.get()
  184. if delivery is None or delivery[0] is not adapter._transport or delivery[1] is not event:
  185. raise RuntimeStoreError('permission_denied')
  186. owner = (adapter, context[3])
  187. else:
  188. owner = runner._transport_owner(event.source)
  189. if owner is None or owner[0] is not adapter or home != context[2]:
  190. raise RuntimeStoreError('not_found')
  191. return provenance
  192. def restore_provenance(runner, source, provenance):
  193. """Resolve current owned connector/home before installing in-process auth context."""
  194. if not isinstance(provenance, dict):
  195. raise RuntimeStoreError('invalid_params')
  196. candidate = copy(source)
  197. candidate.delivered_via_upstream_relay = 'relay' in provenance
  198. adapter, home, runtime_home, expected = _binding(runner, candidate, provenance.get('transport_profile'))
  199. if provenance != expected:
  200. raise RuntimeStoreError('profile_mismatch')
  201. source.delivered_via_upstream_relay = candidate.delivered_via_upstream_relay
  202. source._transport_adapter_ref = weakref.ref(adapter)
  203. # Re-pin the identity ingress resolved: the drained turn's route records the receiving bot from it
  204. # (``SessionEntry.transport_profile``), so after a restart its session still answers through that bot.
  205. from gateway.session_identity import canonical_identity
  206. canonical_identity(source, runner=runner, adapter=adapter, transport_profile=provenance.get('transport_profile'))
  207. source._authorization_profile_home = home
  208. return runtime_home
  209. async def reauthorize_roles(runner, source, provenance):
  210. """A role flag requests a connector check; it never supplies permission."""
  211. if not source.role_authorized:
  212. return False
  213. if provenance is None or source.delivered_via_upstream_relay:
  214. raise RuntimeStoreError('invalid_params')
  215. restore_provenance(runner, source, provenance)
  216. adapter = runner._adapter_for_source(source)
  217. if runner._is_user_authorized_for_source(source, allow_adapter_delegation=False):
  218. return True # Direct allowlist/pairing remains an independent grant.
  219. check = getattr(type(adapter), 'reauthorize_native_roles', None)
  220. if check is None:
  221. raise RuntimeStoreError('permission_denied')
  222. from gateway.run import _profile_runtime_scope
  223. with _profile_runtime_scope(Path(provenance['transport_home'])):
  224. allowed = await check(adapter, source)
  225. # A registry/profile/credential change during SDK I/O cannot borrow its result.
  226. restore_provenance(runner, source, provenance)
  227. if runner._adapter_for_source(source) is not adapter:
  228. raise RuntimeStoreError('not_found')
  229. if allowed is not True:
  230. raise RuntimeStoreError('permission_denied')
  231. return True
  232. def callback_runner():
  233. context = _callback.get()
  234. return context[0] if context else None