Skip to content

OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.

Python
9.3 KB
Raw Blame
"""OPENRAG_RBAC_ENFORCE kill switch.

When the flag is off, every authenticated user passes every gate:
- ``require_permission`` returns the user without checking
- ``RBACService.assert_owner_or_perm`` returns immediately
- API-key role overrides are also bypassed
- ``/users/me`` reports the full permission catalog so the UI shows
  every action

This is the "pre-RBAC behavior" mode the operator can toggle on for
single-user OSS installs or emergency debugging.
"""

import sys
from pathlib import Path
from unittest.mock import MagicMock

import httpx
import pytest
import pytest_asyncio
from fastapi import Depends, FastAPI, Request
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
from sqlmodel import SQLModel

ROOT = Path(__file__).resolve().parent.parent.parent.parent
SRC = ROOT / "src"
if str(SRC) not in sys.path:
    sys.path.insert(0, str(SRC))

import db.models  # noqa: E402,F401
from db.seed import seed_roles_and_permissions  # noqa: E402
from dependencies import (  # noqa: E402
    get_current_user,
    get_db_session,
    get_rbac_service,
)
from services.rbac_service import RBACService, is_rbac_enforced  # noqa: E402
from services.user_service import ensure_user_row  # noqa: E402
from session_manager import User  # noqa: E402

# ----------------------------------------------------------------------
# is_rbac_enforced() resolver
# ----------------------------------------------------------------------


def test_default_does_not_enforce(monkeypatch):
    """RBAC is opt-in: with no env var set, enforcement is off."""
    monkeypatch.delenv("OPENRAG_RBAC_ENFORCE", raising=False)
    assert is_rbac_enforced() is False


@pytest.mark.parametrize("v", ["true", "TRUE", "1", "yes", "on", "True"])
def test_on_values(monkeypatch, v):
    monkeypatch.setenv("OPENRAG_RBAC_ENFORCE", v)
    assert is_rbac_enforced() is True


@pytest.mark.parametrize("v", ["false", "0", "no", "off", "", "garbage"])
def test_off_values(monkeypatch, v):
    monkeypatch.setenv("OPENRAG_RBAC_ENFORCE", v)
    assert is_rbac_enforced() is False


# ----------------------------------------------------------------------
# Bypass — require_permission + assert_owner_or_perm
# ----------------------------------------------------------------------


@pytest_asyncio.fixture
async def app(monkeypatch):
    """Spin up a tiny FastAPI app with one gated endpoint, two personas
    (admin + non-admin), and the kill switch monkeypatch-controlled."""
    monkeypatch.setenv("OPENRAG_DEFAULT_ROLE", "user")
    engine = create_async_engine(
        "sqlite+aiosqlite:///:memory:",
        connect_args={"check_same_thread": False},
    )
    async with engine.begin() as conn:
        await conn.run_sync(SQLModel.metadata.create_all)
    SessionLocal = async_sessionmaker(engine, expire_on_commit=False)

    personas: dict[str, User] = {}
    async with SessionLocal() as s:
        await seed_roles_and_permissions(s)
        admin_db = await ensure_user_row(
            s, User(user_id="admin-sub", email="a@x", name="A", provider="google")
        )
        user_db = await ensure_user_row(
            s, User(user_id="user-sub", email="u@x", name="U", provider="google")
        )
        await s.commit()
        personas["admin"] = User(user_id=admin_db.id, email="a@x", name="A", provider="google")
        personas["user"] = User(user_id=user_db.id, email="u@x", name="U", provider="google")

    rbac = RBACService(SessionLocal)
    fastapi_app = FastAPI()

    async def _stub_user(request: Request) -> User:
        persona = request.headers.get("X-Test-Persona", "user")
        return personas[persona]

    async def _db_session():
        async with SessionLocal() as s:
            yield s

    fastapi_app.dependency_overrides[get_current_user] = _stub_user
    fastapi_app.dependency_overrides[get_rbac_service] = lambda: rbac
    fastapi_app.dependency_overrides[get_db_session] = _db_session

    # Mount a minimal endpoint behind a real require_permission gate so the
    # kill switch can be exercised without depending on any specific router.
    from dependencies import require_any_permission, require_permission

    require_anonymous_delete_permission = require_any_permission(
        ("knowledge:delete:anonymous", "users:delete")
    )

    @fastapi_app.get("/admin/users")
    async def _gated(_=Depends(require_permission("users:list"))):
        return []

    @fastapi_app.delete("/anonymous-documents")
    async def _any_gated(
        _=Depends(require_anonymous_delete_permission),
    ):
        return []

    yield fastapi_app, SessionLocal, rbac, personas
    await engine.dispose()


@pytest.mark.asyncio
async def test_kill_switch_bypasses_require_permission(app, monkeypatch):
    """`user` persona has no admin role but DELETE /admin/users requires
    `users:delete`. Default = 403. With kill switch = 200/4xx-from-handler."""
    fastapi_app, _, _, personas = app

    transport = httpx.ASGITransport(app=fastapi_app)
    async with httpx.AsyncClient(transport=transport, base_url="http://t") as c:
        # Enforced: blocked
        monkeypatch.setenv("OPENRAG_RBAC_ENFORCE", "true")
        r = await c.get("/admin/users", headers={"X-Test-Persona": "user"})
        assert r.status_code == 403
        assert r.json()["detail"]["required"] == "users:list"

        # Kill switch off (default): passes
        monkeypatch.setenv("OPENRAG_RBAC_ENFORCE", "false")
        r = await c.get("/admin/users", headers={"X-Test-Persona": "user"})
        assert r.status_code == 200


@pytest.mark.asyncio
async def test_kill_switch_bypasses_require_any_permission(app, monkeypatch):
    fastapi_app, _, _, _ = app
    transport = httpx.ASGITransport(app=fastapi_app)
    async with httpx.AsyncClient(transport=transport, base_url="http://t") as c:
        monkeypatch.setenv("OPENRAG_RBAC_ENFORCE", "true")
        r = await c.delete("/anonymous-documents", headers={"X-Test-Persona": "user"})
        assert r.status_code == 403

        monkeypatch.setenv("OPENRAG_RBAC_ENFORCE", "false")
        r = await c.delete("/anonymous-documents", headers={"X-Test-Persona": "user"})
        assert r.status_code == 200


@pytest.mark.asyncio
async def test_kill_switch_bypasses_assert_owner_or_perm(monkeypatch):
    """The shared helper used by `:own` endpoints must also bypass."""
    monkeypatch.setenv("OPENRAG_RBAC_ENFORCE", "false")

    # Mock session_factory — it should never be hit
    factory = MagicMock(side_effect=AssertionError("DB should not be queried"))
    rbac = RBACService(factory)

    # Non-owner, no permissions → would normally 403; kill switch returns silently
    user = User(user_id="alice", email="a@x", name="A", provider="google")
    await rbac.assert_owner_or_perm(
        user=user,
        owner_id="bob",
        owned_perm="kf:delete:own",
        any_perm="kf:delete",
    )


@pytest.mark.asyncio
async def test_kill_switch_bypasses_api_key_role_override(app, monkeypatch):
    """API-key role_override is also bypassed — the flag is unconditional."""
    fastapi_app, _, _, _ = app
    monkeypatch.setenv("OPENRAG_RBAC_ENFORCE", "false")

    # Inject a request middleware that pretends an API key with a
    # "viewer-only" role override is in play. With the kill switch the
    # role_override is never consulted, so the request still succeeds.
    @fastapi_app.middleware("http")
    async def _inject_key_scope(request, call_next):
        request.state.api_key_role_ids = ["nonexistent-role-id"]
        return await call_next(request)

    transport = httpx.ASGITransport(app=fastapi_app)
    async with httpx.AsyncClient(transport=transport, base_url="http://t") as c:
        r = await c.get("/admin/users", headers={"X-Test-Persona": "user"})
    assert r.status_code == 200


# ----------------------------------------------------------------------
# /users/me — full catalog when the kill switch is on
# ----------------------------------------------------------------------


@pytest.mark.asyncio
async def test_me_returns_full_permission_catalog_when_disabled(app, monkeypatch):
    fastapi_app, SessionLocal, _, _ = app
    monkeypatch.setenv("OPENRAG_RBAC_ENFORCE", "false")

    from api import users as users_api

    fastapi_app.include_router(users_api.router)

    transport = httpx.ASGITransport(app=fastapi_app)
    async with httpx.AsyncClient(transport=transport, base_url="http://t") as c:
        r = await c.get("/users/me", headers={"X-Test-Persona": "user"})
    assert r.status_code == 200
    body = r.json()

    # Should include the entire seeded catalog
    expected_subset = {"users:list", "users:delete", "config:write", "chat:use"}
    assert expected_subset.issubset(set(body["permissions"]))
    # And the flag is surfaced so the UI can hide RBAC-only sections
    assert body["rbac_enforced"] is False


@pytest.mark.asyncio
async def test_me_returns_only_user_perms_when_enforced(app, monkeypatch):
    fastapi_app, _, _, _ = app
    monkeypatch.setenv("OPENRAG_RBAC_ENFORCE", "true")

    from api import users as users_api

    fastapi_app.include_router(users_api.router)

    transport = httpx.ASGITransport(app=fastapi_app)
    async with httpx.AsyncClient(transport=transport, base_url="http://t") as c:
        r = await c.get("/users/me", headers={"X-Test-Persona": "user"})
    assert r.status_code == 200
    body = r.json()

    # Should NOT include admin-only perms when enforced
    assert "users:delete" not in body["permissions"]
    assert body["rbac_enforced"] is True