| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140 |
- """Core-owned wrapper around a plugin-registered login backend.
- Every plugin backend reaches the browser vault only through ``PluginLoginBackend``, so the isolation
- rules hold however the plugin implements ``LoginBackend``:
- - Its namespace is ``<registered name>:``, taken from the registry key, never from attributes the plugin
- can change later. Ownership is decided here, so a plugin's own ``owns()`` is never consulted and it
- is never handed a handle outside its namespace (built-in ``vault_``/``op:``/``bw:`` or another plugin's).
- - It is handed the handle and nothing else: no page, CDP session, task id, other entries or master
- password. ``needs_unlock`` is always False, so Hermes' master-password prompt never runs for it.
- - Its exceptions are replaced by a fixed-text ``PluginBackendError`` raised outside the ``except``, so a
- secret in a plugin's error text reaches no tool result, log line or exception chain. Returned values
- are validated and copied into core-owned objects inside the same guard: reading a field of a
- plugin-owned object (a property, ``__getattribute__``, a ``str`` subclass) can run plugin code too.
- """
- from __future__ import annotations
- from contextlib import contextmanager
- from typing import Any, Callable, Optional
- from agent.vault_backends.base import LoginBackend
- from agent.vault_store import VAULT_KINDS, VaultItemMeta
- _FAILED = object()
- _INVALID = object()
- _TEXT_FIELDS = ("id", "kind", "label", "created_at")
- _OPTIONAL_TEXT_FIELDS = ("origin", "identifier", "identifier_type")
- def _text(value: Any) -> Any:
- """An exact ``str`` copy (a subclass's methods never run outside the guard), or ``_INVALID``."""
- return str.__str__(value) if isinstance(value, str) else _INVALID
- def _materialize(meta: Any) -> Any:
- """A core-owned ``VaultItemMeta`` copied from the plugin's, or ``_INVALID`` when a field has the wrong type."""
- if not isinstance(meta, VaultItemMeta):
- return _INVALID
- fields = {f: _text(getattr(meta, f)) for f in _TEXT_FIELDS}
- for f in _OPTIONAL_TEXT_FIELDS:
- value = getattr(meta, f)
- fields[f] = None if value is None else _text(value)
- has_otp, origins = meta.has_otp, meta.allowed_origins
- if not isinstance(origins, tuple) or type(has_otp) is not bool:
- return _INVALID
- fields["allowed_origins"] = tuple(_text(o) for o in origins)
- if _INVALID in fields.values() or _INVALID in fields["allowed_origins"] or fields["kind"] not in VAULT_KINDS:
- return _INVALID
- return VaultItemMeta(has_otp=has_otp, **fields)
- class PluginBackendError(RuntimeError):
- """A plugin login backend failed or broke its contract (fixed text: never the plugin's own message)."""
- class PluginLoginBackend(LoginBackend):
- needs_unlock = False
- def __init__(self, name: str, plugin: LoginBackend):
- self.name, self.prefix, self._plugin = name, f"{name}:", plugin
- self.display_name = f"{name} (plugin)" # core-composed: a plugin cannot present itself as a built-in manager
- def owns(self, handle: str) -> bool:
- return isinstance(handle, str) and handle.startswith(self.prefix)
- def _call(self, fn: Callable[[], Any]) -> Any:
- try:
- result = fn()
- except Exception: # health: allow BLE001 -- the plugin's error text may hold a credential; replaced below
- result = _FAILED
- if result is _FAILED:
- raise PluginBackendError(f"The {self.name} login backend failed.")
- return result
- def _require_own(self, handle: str) -> None:
- if not self.owns(handle):
- raise PluginBackendError(f"Handle is outside the {self.name} login backend's namespace.")
- def _require(self, ok: bool) -> None:
- if not ok:
- raise PluginBackendError(f"The {self.name} login backend returned an invalid value.")
- def list_items(self) -> list[VaultItemMeta]:
- items = self._call(lambda: [_materialize(m) for m in self._plugin.list_items()])
- self._require(all(m is not _INVALID for m in items))
- return [m for m in items if self.owns(m.id)]
- def get_meta(self, handle: str) -> Optional[VaultItemMeta]:
- if not self.owns(handle):
- return None
- def fetch() -> Any:
- meta = self._plugin.get_meta(handle)
- return None if meta is None else _materialize(meta)
- meta = self._call(fetch)
- self._require(meta is not _INVALID)
- return meta if meta is not None and meta.id == handle else None
- def resolve_password(self, handle: str) -> str:
- self._require_own(handle)
- value = self._call(lambda: _text(self._plugin.resolve_password(handle)))
- self._require(value is not _INVALID)
- return value
- def resolve_otp(self, handle: str) -> Optional[str]:
- self._require_own(handle)
- def fetch() -> Any:
- value = self._plugin.resolve_otp(handle)
- return None if value is None else _text(value)
- value = self._call(fetch)
- self._require(value is not _INVALID)
- return value
- def resolve_secret(self, handle: str) -> dict[str, str]:
- self._require_own(handle)
- def fetch() -> Any:
- value = self._plugin.resolve_secret(handle)
- if not isinstance(value, dict):
- return _INVALID
- copied = {_text(k): _text(v) for k, v in value.items()}
- return _INVALID if _INVALID in copied or _INVALID in copied.values() else copied
- value = self._call(fetch)
- self._require(value is not _INVALID)
- return value
- @contextmanager
- def fill_context(self):
- """The plugin's own context around one of ITS fills; it never sees the core's exception."""
- context = self._call(lambda: self._plugin.fill_context())
- self._call(lambda: context.__enter__())
- try:
- yield
- finally:
- self._call(lambda: context.__exit__(None, None, None))
|