Skip to content

Enterprise agent platform for building, deploying, and operating AI teammates.

9.4 KB
Raw Blame
import html
import json
import re
from urllib.parse import parse_qs, urlsplit

import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from sqlalchemy import create_engine
from sqlalchemy.orm import Session
from starlette.requests import Request
from starlette.responses import RedirectResponse

from xagent.web.api import auth
from xagent.web.models.database import Base, get_db
from xagent.web.models.oauth_provider import OAuthProvider
from xagent.web.models.user import User
from xagent.web.oauth_handoff import OAuthHandoffContext, issue_handoff, router

OLD = "https://cloud.xagent.co"
NEW = "https://tobybot.ai"


class Adapter:
    def context(self, request):
        return OAuthHandoffContext("xagent", "prod", "au", OLD)

    def set_route_cookie(self, response, *, state, kind, provider):
        response.set_cookie("scoped-" + kind, "au")


@pytest.fixture
def setup(tmp_path, monkeypatch):
    monkeypatch.setenv("XAGENT_APP_BASE_URL", OLD)
    monkeypatch.setenv("XAGENT_DUAL_ENTRY_OAUTH_ENABLED", "true")
    monkeypatch.setenv(
        "XAGENT_PUBLIC_ENTRIES_JSON",
        json.dumps(
            [
                {
                    "origin": origin,
                    "region_cookie_domain": None,
                    "google_oidc_redirect_uri": origin
                    + "/api/auth/oidc/google/callback",
                }
                for origin in [OLD, NEW]
            ]
        ),
    )
    engine = create_engine(
        f"sqlite:///{tmp_path / 'handoff.db'}",
        connect_args={"check_same_thread": False},
    )
    Base.metadata.create_all(engine)
    with Session(engine) as db:
        user = User(username="handoff", password_hash="unused", session_epoch="epoch")
        db.add(user)
        db.add(
            OAuthProvider(
                name="Sample",
                redirect_uri=OLD + "/api/auth/sample/callback",
                provider_name="sample",
                client_id="test",
                client_secret="test",
                auth_url="https://provider.test",
                token_url="https://provider.test/token",
            )
        )
        db.commit()
        app = FastAPI()
        app.state.oauth_handoff_adapter = Adapter()
        app.include_router(router)
        app.dependency_overrides[get_db] = lambda: db
        req = Request(
            {
                "type": "http",
                "method": "POST",
                "path": "/",
                "headers": [(b"host", b"tobybot.ai")],
                "app": app,
            }
        )
        launch = issue_handoff(
            req,
            user,
            kind="builtin",
            resource={"provider": "sample", "options": {"redirect": NEW}},
        )
        monkeypatch.setattr(
            auth,
            "_generic_oauth_login",
            lambda *a, **kw: RedirectResponse(
                "https://provider.test/authorize?state=signed-state"
            ),
        )
        yield TestClient(app, base_url=OLD), db, launch, app
    engine.dispose()


def _confirm_href(page) -> str:
    """The Continue link of the step-one confirmation page."""
    return html.unescape(re.search(r'href="([^"]+)"', page.text)[1])


def _confirmed_url(launch, page) -> str:
    return launch["authorization_url"].split("?", 1)[0] + _confirm_href(page)


def test_confirmation_page_names_account_and_consumes_nothing(setup):
    client, _, launch, _ = setup
    page = client.get(launch["authorization_url"], follow_redirects=False)
    assert page.status_code == 200
    assert "Connect Sample?" in page.text
    assert "<strong>handoff</strong>" in page.text
    assert "frame-ancestors 'none'" in page.headers["content-security-policy"]
    assert page.headers["x-frame-options"] == "DENY"
    assert page.headers["cache-control"] == "no-store"
    assert page.headers["referrer-policy"] == "no-referrer"
    cookie = page.headers["set-cookie"]
    assert cookie.startswith("oauth_launch_confirm_")
    assert "samesite=strict" in cookie.lower() and "httponly" in cookie.lower()
    assert "Path=/api/oauth/launch/au" in cookie
    assert "Secure" in cookie
    assert "scoped-builtin" not in cookie
    # Rendering again is harmless: the ticket was not consumed.
    assert client.get(launch["authorization_url"]).status_code == 200


def test_bootstrap_single_use_and_scoped_only(setup):
    client, _, launch, _ = setup
    client.cookies.set("selected_region", "sg")
    page = client.get(launch["authorization_url"], follow_redirects=False)
    response = client.get(_confirmed_url(launch, page), follow_redirects=False)
    assert response.status_code == 303
    assert "scoped-builtin" in response.headers["set-cookie"]
    assert "selected_region" not in response.headers["set-cookie"]
    assert response.headers["cache-control"] == "no-store"
    assert response.headers["referrer-policy"] == "no-referrer"
    assert (
        client.get(_confirmed_url(launch, page), follow_redirects=False).status_code
        == 401
    )


@pytest.mark.parametrize("variant", ["no-cookie", "wrong-nonce", "foreign-cookie"])
def test_confirmation_requires_this_browsers_nonce(setup, variant):
    """A link straight to step two (e.g. from someone else's ticket) is refused."""
    client, _, launch, _ = setup
    page = client.get(launch["authorization_url"], follow_redirects=False)
    url = _confirmed_url(launch, page)
    if variant == "no-cookie":
        client.cookies.clear()
    if variant == "wrong-nonce":
        url = url.rsplit("confirm=", 1)[0] + "confirm=forged"
    if variant == "foreign-cookie":
        name = page.headers["set-cookie"].split("=", 1)[0]
        client.cookies.clear()
        client.cookies.set(name, "attacker-nonce", path="/api/oauth/launch/au")
    response = client.get(url, follow_redirects=False)
    assert response.status_code == 401
    assert "set-cookie" not in response.headers
    # The refusal did not consume the ticket: the real browser can still finish.
    page = client.get(launch["authorization_url"], follow_redirects=False)
    finished = client.get(_confirmed_url(launch, page), follow_redirects=False)
    assert finished.status_code == 303


def test_consume_storage_failure_is_unavailable(setup, monkeypatch):
    from sqlalchemy.exc import OperationalError

    from xagent.web.services import oauth_launch

    def unavailable(*args, **kwargs):
        raise OperationalError("consume", {}, Exception("down"))

    client, _, launch, _ = setup
    page = client.get(launch["authorization_url"], follow_redirects=False)
    monkeypatch.setattr(oauth_launch, "consume_oauth_launch_ticket", unavailable)
    response = client.get(_confirmed_url(launch, page), follow_redirects=False)
    assert response.status_code == 503


@pytest.mark.parametrize(
    "field,value",
    [
        ("product", "toby"),
        ("environment", "dev"),
        ("region", "sg"),
        ("target_origin", NEW),
        ("purpose", "toby"),
        ("type", "oauth_launch"),
        ("session_epoch", "old"),
        ("exp", 1),
        ("user_id", 2**31),
        ("jti", None),
        ("return_origin", "https://evil.test"),
    ],
)
def test_bound_claims_rejected_before_proof(setup, field, value):
    client, _, launch, _ = setup
    claims = auth.verify_token(
        parse_qs(urlsplit(launch["authorization_url"]).query)["ticket"][0]
    )
    claims[field] = value
    # Encode directly so the token helper cannot overwrite the expiry under test.
    jwt = auth.jwt

    ticket = jwt.encode(claims, auth.JWT_SECRET_KEY, algorithm=auth.JWT_ALGORITHM)
    response = client.get(
        "/api/oauth/launch/au", params={"ticket": ticket}, follow_redirects=False
    )
    assert response.status_code == 401
    assert "set-cookie" not in response.headers


@pytest.mark.parametrize(
    "variant", ["region", "host", "duplicate", "head", "adapter", "disabled"]
)
def test_request_context_fail_closed(setup, monkeypatch, variant):
    client, _, launch, app = setup
    url = launch["authorization_url"]
    if variant == "region":
        url = url.replace("/au?", "/sg?")
    if variant == "host":
        url = url.replace(OLD, NEW)
    if variant == "duplicate":
        url += "&ticket=second"
    if variant == "adapter":
        del app.state.oauth_handoff_adapter
    if variant == "disabled":
        monkeypatch.setenv("XAGENT_DUAL_ENTRY_OAUTH_ENABLED", "false")
    response = client.request(
        "HEAD" if variant == "head" else "GET", url, follow_redirects=False
    )
    assert response.status_code in {401, 405, 503}
    assert "set-cookie" not in response.headers


@pytest.mark.parametrize("enabled,version", [(False, "2"), (True, None), (True, "1")])
def test_old_frontend_keeps_legacy_response(setup, monkeypatch, enabled, version):
    client, db, _, app = setup
    monkeypatch.setenv("XAGENT_DUAL_ENTRY_OAUTH_ENABLED", str(enabled).lower())
    user = db.query(User).filter_by(username="handoff").one()
    headers = [(b"host", b"tobybot.ai")]
    if version:
        headers.append((b"x-xagent-oauth-launch-version", version.encode()))
    req = Request(
        {
            "type": "http",
            "method": "POST",
            "path": "/",
            "query_string": b"",
            "headers": headers,
            "app": app,
        }
    )
    response = auth.start_oauth_authorization(
        "sample", req, auth.OAuthLaunchRequest(), db, user
    )
    data = json.loads(response.body)
    assert "launch_mode" not in data
    assert data["authorization_url"].startswith("/api/auth/sample/login?ticket=")