Skip to content

The agent that grows with you

9.0 KB
Raw Blame
"""Verified dashboard identities must own separate durable authority receipts."""
import json
import threading
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from types import SimpleNamespace

import jwt
import pytest
from cryptography.hazmat.primitives.asymmetric import rsa
from starlette.requests import Request
from starlette.websockets import WebSocket


@pytest.fixture
def oidc():
    from plugins.dashboard_auth.self_hosted import SelfHostedOIDCProvider
    key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
    jwk = json.loads(jwt.algorithms.RSAAlgorithm.to_jwk(key.public_key()))
    jwk.update(kid='test-key', use='sig', alg='RS256')

    class Handler(BaseHTTPRequestHandler):
        def log_message(self, *args):
            pass

        def do_GET(self):
            realm = self.path.removesuffix('/.well-known/openid-configuration')
            body = {'keys': [jwk]} if self.path.endswith('/jwks') else {
                'issuer': issuer + realm, 'jwks_uri': issuer + '/jwks',
                'authorization_endpoint': issuer + '/authorize', 'token_endpoint': issuer + '/token'}
            raw = json.dumps(body).encode()
            self.send_response(200)
            self.send_header('Content-Type', 'application/json')
            self.send_header('Content-Length', str(len(raw)))
            self.end_headers()
            self.wfile.write(raw)

    server = ThreadingHTTPServer(('127.0.0.1', 0), Handler)
    issuer = f'http://127.0.0.1:{server.server_port}'
    thread = threading.Thread(target=server.serve_forever, daemon=True)
    thread.start()
    def login(subject, realm=''):
        provider = SelfHostedOIDCProvider(issuer=issuer + realm, client_id='fixture-client')
        token = jwt.encode({'iss': issuer + realm, 'sub': subject, 'aud': 'fixture-client',
                            'iat': int(time.time()), 'exp': int(time.time()) + 600}, key, algorithm='RS256',
                           headers={'kid': 'test-key'})
        return provider.verify_session(access_token=token)

    try:
        yield login
    finally:
        server.shutdown()
        server.server_close()
        thread.join(5)


def connection(authority, session, monkeypatch):
    from hermes_cli import web_server as web
    from hermes_cli.dashboard_auth.routes import api_auth_ws_ticket
    from hermes_cli.web_server_chat import _ws_auth_reason
    from gateway.session_controls import AuthorityConnection
    # Exercise the production ticket endpoint and upgrade stamp, not a made-up Principal.
    monkeypatch.setattr(web.app.state, 'auth_required', True, raising=False)
    request = Request({'type': 'http', 'app': web.app, 'state': {'session': session},
                       'headers': [], 'method': 'POST', 'path': '/api/auth/ws-ticket'})
    return request, api_auth_ws_ticket, _ws_auth_reason, AuthorityConnection, WebSocket


@pytest.mark.asyncio
async def test_every_bundled_sign_in_acts_as_the_owner_and_keeps_durable_receipts(tmp_path, monkeypatch, oidc):
    from gateway import run
    from gateway.config import GatewayConfig
    from gateway.session import SessionStore
    from gateway.session_authority import initialize_session_authority
    from gateway.session_local import create_local_session
    from gateway.session_contract import Principal
    from hermes_cli.web_server_sessions import _session_mutation_context
    from hermes_state_runtime import RuntimeStoreError
    from plugins.dashboard_auth.basic import BasicAuthProvider, hash_password

    monkeypatch.setattr(run, '_load_gateway_config', lambda: {'platform_toolsets': {'cli': []}})
    store = SessionStore(tmp_path / 'sessions', GatewayConfig())
    runner = SimpleNamespace(session_store=store, _session_db=store._db, adapters={}, _draining=False)
    authority = await initialize_session_authority(runner, profile_id=str(tmp_path), instance_id='first')

    async def actor(session):
        request, endpoint, auth, factory, ws_type = connection(authority, session, monkeypatch)
        monkeypatch.setattr(request.app.state, 'session_authority', authority, raising=False)
        ticket = (await endpoint(request))['ticket']
        ws = ws_type({'type': 'websocket', 'path': '/api/ws', 'headers': [],
                      'query_string': ('ticket=' + ticket).encode(), 'client': ('127.0.0.1', 1)},
                     None, None)
        assert auth(ws)[0] is None
        result = factory(authority, object(), ws._hermes_auth_identity).actor
        # HTTP mutation must use precisely the WS ownership/retry key.
        monkeypatch.setattr('hermes_state._default_db_path', lambda: authority.db.db_path)
        assert _session_mutation_context(request, None)[1].subject == result.subject
        return result

    oauth = oidc('user-a')
    basic = BasicAuthProvider(username='user-a', password_hash=hash_password('fixture-password'), secret=b'fixture-secret-32-characters-long')
    password = basic.complete_password_login(username='user-a', password='fixture-password')
    owner, by_password = await actor(oauth), await actor(password)
    # The Webapp is single-user: whichever bundled sign-in opened it, the tab acts as the machine
    # owner, the same subject native Desktop's ticket carries (gateway.owner_identity).
    from gateway.owner_identity import host_owner_subject
    assert owner.subject == by_password.subject == host_owner_subject()
    params = {'request_id': 'same-request', 'source': 'gui', 'cwd': str(tmp_path), 'model': 'fixture', 'toolsets': []}
    ref = create_local_session(authority, owner, params)
    from gateway.session_mutations import mutate_session
    edit = dict(session_id=ref.session_id, request_id='oauth-rename', expected_revision=0,
                operation='rename', payload={'title': 'OAuth owned'})
    receipt = await mutate_session(authority, owner, ref, edit)
    assert create_local_session(authority, by_password, params) == ref
    assert await mutate_session(authority, by_password, ref, edit) == receipt
    from gateway.session_identity import authenticated_principal_digest
    assert authenticated_principal_digest({'provider': oauth.provider, 'issuer': oauth.issuer, 'user_id': oauth.user_id}) != authenticated_principal_digest(
        {'provider': oauth.provider, 'issuer': oauth.issuer + '/other', 'user_id': oauth.user_id})
    runner.adapters = {}
    cold = await initialize_session_authority(runner, profile_id=str(tmp_path), instance_id='second')
    reconnect = await actor(oidc('user-a'))
    assert create_local_session(cold, reconnect, params) == ref
    assert await mutate_session(cold, reconnect, ref, edit) == receipt
    assert (await cold.resolve(reconnect, ref)).ref == ref
    # A bare pre-cutover subject is not a sign-in the owner stored: never adopted on first request.
    old = create_local_session(cold, Principal('user-a', owner.profile_id, owner.capabilities, 'old'),
                               {**params, 'request_id': 'old-ambiguous'})
    with pytest.raises(RuntimeStoreError, match='permission_denied'):
        await cold.resolve(reconnect, old)


@pytest.mark.asyncio
async def test_private_native_subject_preserves_existing_creation_and_mutation_retries(tmp_path, monkeypatch):
    from gateway import run
    from gateway.config import GatewayConfig
    from gateway.session import SessionStore
    from gateway.session_authority import initialize_session_authority
    from gateway.session_controls import AuthorityConnection
    from gateway.session_contract import Principal
    from gateway.session_local import create_local_session
    from gateway.session_mutations import mutate_session
    from hermes_state_runtime import RuntimeStoreError

    monkeypatch.setattr(run, '_load_gateway_config', lambda: {'platform_toolsets': {'cli': []}})
    store = SessionStore(tmp_path / 'sessions', GatewayConfig())
    runner = SimpleNamespace(session_store=store, _session_db=store._db, adapters={}, _draining=False)
    authority = await initialize_session_authority(runner, profile_id='fixture', instance_id='first')
    caps = frozenset({'session:create', 'session:read', 'session:control'})
    old = Principal('uid:1000', 'fixture', caps, 'old')
    params = {'request_id': 'original', 'source': 'cli', 'cwd': str(tmp_path), 'model': 'fixture', 'toolsets': []}
    ref = create_local_session(authority, old, params)
    native = AuthorityConnection(authority, object(), {'provider': 'local', 'user_id': old.subject,
        'profile_id': 'fixture', 'instance_id': 'first', 'capabilities': caps}).actor
    assert native.subject == old.subject
    assert create_local_session(authority, native, params) == ref
    edit = dict(session_id=ref.session_id, request_id='rename', expected_revision=0, operation='rename', payload={'title': 'Native preserved'})
    result = await mutate_session(authority, old, ref, edit)
    assert await mutate_session(authority, native, ref, edit) == result
    remote = AuthorityConnection(authority, object(), {'provider': 'local', 'user_id': old.subject}).actor
    with pytest.raises(RuntimeStoreError, match='permission_denied'):
        await authority.resolve(remote, ref)