From d1859d879bdb84ba53f939889c03e8e8df5df2e7 Mon Sep 17 00:00:00 2001 From: John Grubb Date: Thu, 5 Nov 2026 10:42:39 -0500 Subject: [PATCH 1/2] fix(sso): skip DB user insert and key mint when ui_access_mode=admin_only rejects non-admin When `general_settings.ui_access_mode: "admin_only"` is configured, `SSOAuthenticationHandler.get_redirect_response_from_openid` previously called `get_user_info_from_db()` -> `upsert_sso_user()` -> `insert_sso_user()` and `generate_key_helper_fn()` before checking `check_is_admin_only_access()`. As a result, any uninvited non-admin SSO login attempt: 1. Inserted a new `internal_user_viewer` row into `LiteLLM_UserTable` (consuming one of the 5 free-tier SSO user slots), and 2. Minted an orphaned `litellm-dashboard` key in `LiteLLM_VerificationToken` before raising `HTTPException(401, "User not allowed to access proxy...")`. Fix by: - Skipping `upsert_sso_user()` in `get_user_info_from_db()` when `user_info is None`, `ui_access_mode == "admin_only"`, and the incoming SSO/default role (or `PROXY_ADMIN_ID`) does not grant admin UI access. - Running the `check_is_admin_only_access()` check before calling `generate_key_helper_fn()`. --- litellm/proxy/management_endpoints/ui_sso.py | 64 ++++++++++++----- .../proxy/management_endpoints/test_ui_sso.py | 71 +++++++++++++++++++ 2 files changed, 119 insertions(+), 16 deletions(-) diff --git a/litellm/proxy/management_endpoints/ui_sso.py b/litellm/proxy/management_endpoints/ui_sso.py index 53079d84fdd..a9b7b353b0e 100644 --- a/litellm/proxy/management_endpoints/ui_sso.py +++ b/litellm/proxy/management_endpoints/ui_sso.py @@ -2003,6 +2003,23 @@ def sso_lookup_user_ids(alternate_user_id: str | None, provider_id: str | None) ) +def _would_new_sso_user_have_admin_ui_access( + user_defined_values: SSOUserDefinedValues | None, +) -> bool: + if user_defined_values is None: + return False + proxy_admin_id: Final = os.getenv("PROXY_ADMIN_ID") + if proxy_admin_id is not None and proxy_admin_id == user_defined_values.get("user_id"): + return True + sso_role: Final = user_defined_values.get("user_role") + if _should_use_role_from_sso_response(sso_role) and sso_role is not None: + return has_admin_ui_access(sso_role) + default_role: Final = (litellm.default_internal_user_params or {}).get("user_role") + if isinstance(default_role, str): + return has_admin_ui_access(default_role) + return False + + async def get_user_info_from_db( result: CustomOpenID | OpenID | dict, prisma_client: PrismaClient, @@ -2011,6 +2028,7 @@ async def get_user_info_from_db( user_email: str | None, user_defined_values: SSOUserDefinedValues | None, alternate_user_id: str | None = None, + ui_access_mode: dict | str | None = None, ) -> LiteLLM_UserTable | NewUserResponse | None: mapped_user_id: Final = None if user_defined_values is None else user_defined_values.get("user_id") resolved_by_database_only: Final = user_defined_values is not None and ( @@ -2044,6 +2062,16 @@ async def get_user_info_from_db( "user_info: %s; litellm.default_internal_user_params: %s", user_info, litellm.default_internal_user_params ) + if ( + user_info is None + and check_is_admin_only_access(ui_access_mode or {}) + and not _would_new_sso_user_have_admin_ui_access(user_defined_values) + ): + verbose_proxy_logger.debug( + "Skipping SSO user creation in DB because ui_access_mode is admin_only and user has no admin role" + ) + return None + # Upsert SSO User to LiteLLM DB user_info = await SSOAuthenticationHandler.upsert_sso_user( result=result, @@ -4006,6 +4034,7 @@ class SSOAuthenticationHandler: user_email=user_email, user_defined_values=user_defined_values, alternate_user_id=user_id, + ui_access_mode=ui_access_mode, ) # Sync user role from JWT claims via jwt_litellm_role_map (if configured). @@ -4031,6 +4060,23 @@ class SSOAuthenticationHandler: "Unable to map user identity to known values. 'user_defined_values' is None. File an issue - https://github.com/BerriAI/litellm/issues" ) + target_user_id: Final = _require_sso_user_id(user_defined_values["user_id"]) + user_role = user_defined_values["user_role"] or LitellmUserRoles.INTERNAL_USER_VIEW_ONLY.value + is_admin_only_access: Final = check_is_admin_only_access(ui_access_mode or {}) + if is_admin_only_access: + user_role = await check_and_update_if_proxy_admin_id( + user_role=user_role, user_id=target_user_id, prisma_client=prisma_client + ) + verbose_proxy_logger.debug("user_role: %s; ui_access_mode: %s", user_role, ui_access_mode) + has_access: Final = has_admin_ui_access(user_role or "") + if not has_access: + raise HTTPException( + status_code=401, + detail={ + "error": f"User not allowed to access proxy. User role={user_role}, proxy mode={ui_access_mode}" + }, + ) + verbose_proxy_logger.info("user_defined_values for creating ui key: %s", user_defined_values) response: Final = await generate_key_helper_fn( @@ -4043,7 +4089,7 @@ class SSOAuthenticationHandler: spend=0, team_id="litellm-dashboard", models=user_defined_values["models"], - user_id=_require_sso_user_id(user_defined_values["user_id"]), + user_id=target_user_id, user_email=user_defined_values["user_email"], user_role=user_defined_values["user_role"], max_budget=user_defined_values["max_budget"], @@ -4054,25 +4100,11 @@ class SSOAuthenticationHandler: key = response["token"] user_id = response["user_id"] - user_role = user_defined_values["user_role"] or LitellmUserRoles.INTERNAL_USER_VIEW_ONLY.value - if user_id and isinstance(user_id, str): + if not is_admin_only_access and user_id and isinstance(user_id, str): user_role = await check_and_update_if_proxy_admin_id( user_role=user_role, user_id=user_id, prisma_client=prisma_client ) - verbose_proxy_logger.debug("user_role: %s; ui_access_mode: %s", user_role, ui_access_mode) - ## CHECK IF ROLE ALLOWED TO USE PROXY ## - is_admin_only_access: Final = check_is_admin_only_access(ui_access_mode or {}) - if is_admin_only_access: - has_access: Final = has_admin_ui_access(user_role or "") - if not has_access: - raise HTTPException( - status_code=401, - detail={ - "error": f"User not allowed to access proxy. User role={user_role}, proxy mode={ui_access_mode}" - }, - ) - from litellm.proxy.management_endpoints.sso.agent_subject_enrollment import enroll_microsoft_subject await enroll_microsoft_subject( diff --git a/tests/unit/proxy/management_endpoints/test_ui_sso.py b/tests/unit/proxy/management_endpoints/test_ui_sso.py index ba78fefd653..35a72c9d122 100644 --- a/tests/unit/proxy/management_endpoints/test_ui_sso.py +++ b/tests/unit/proxy/management_endpoints/test_ui_sso.py @@ -11397,3 +11397,74 @@ async def test_sso_login_still_joins_the_team_and_warns_when_creating_it_fails( warnings: Final = [r.getMessage() for r in caplog.records if r.levelno == logging.WARNING] assert events == [("join", "finance")] assert len(warnings) == 1 and "finance" in warnings[0] and str(create_error.detail) in warnings[0] + + +@pytest.mark.asyncio +async def test_get_user_info_from_db_skips_insert_when_admin_only_and_user_not_in_db() -> None: + """When ui_access_mode='admin_only', an uninvited SSO user without an admin role must not be inserted into LiteLLM_UserTable.""" + from litellm.proxy._types import SSOUserDefinedValues + from litellm.proxy.management_endpoints.ui_sso import get_user_info_from_db + + result: Final = CustomOpenID( + id="uninvited-google-sub", + email="uninvited@example.com", + first_name="Uninvited", + last_name="User", + display_name="Uninvited User", + provider="google", + team_ids=[], + ) + user_defined_values: Final = SSOUserDefinedValues( + models=[], + user_id="uninvited-google-sub", + user_email="uninvited@example.com", + user_role=None, + max_budget=None, + budget_duration=None, + ) + mock_upsert: Final = AsyncMock() + with ( + patch( # test-quality-ok: unit test stubs DB lookup boundary + "litellm.proxy.management_endpoints.ui_sso.get_existing_user_info_from_db", + AsyncMock(return_value=None), + ) as mock_get_existing, + patch.object(SSOAuthenticationHandler, "upsert_sso_user", mock_upsert), + ): + user_info: Final = await get_user_info_from_db( + result=result, + prisma_client=MagicMock(), + user_api_key_cache=MagicMock(), + proxy_logging_obj=MagicMock(), + user_email="uninvited@example.com", + user_defined_values=user_defined_values, + alternate_user_id="uninvited-google-sub", + ui_access_mode="admin_only", + ) + + assert user_info is None + mock_get_existing.assert_awaited_once() + mock_upsert.assert_not_awaited() + + +@pytest.mark.asyncio +async def test_redirect_from_openid_admin_only_rejects_non_admin_before_key_mint() -> None: + """When ui_access_mode='admin_only', a non-admin SSO login must raise 401 before minting a UI session key.""" + user_info_from_db: Final = AsyncMock(return_value=None) + generate_key: Final = AsyncMock(side_effect=AssertionError("Non-admin login must not mint a UI key")) + mock_request, stack = _empty_identity_redirect_patches(None, user_info_from_db, generate_key) + + with stack, pytest.raises(HTTPException) as exc_info: + await SSOAuthenticationHandler.get_redirect_response_from_openid( + result=CustomOpenID(id="uninvited-sub", email="uninvited@example.com", provider="google", team_ids=[]), + request=mock_request, + received_response=None, + generic_client_id=None, + ui_access_mode="admin_only", # type: ignore[arg-type] + ) + + assert exc_info.value.status_code == 401 + assert "User not allowed to access proxy" in str(exc_info.value.detail) + user_info_from_db.assert_awaited_once() + assert user_info_from_db.await_args.kwargs["ui_access_mode"] == "admin_only" + generate_key.assert_not_awaited() + From cc75f66606d9f0c5dacdb8e8feb56c8c920f556a Mon Sep 17 00:00:00 2001 From: John Grubb Date: Thu, 5 Nov 2026 11:03:20 -0500 Subject: [PATCH 2/2] test(sso): avoid duplicate alternate_user_id in admin_only skip-insert test --- tests/unit/proxy/management_endpoints/test_ui_sso.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/unit/proxy/management_endpoints/test_ui_sso.py b/tests/unit/proxy/management_endpoints/test_ui_sso.py index 35a72c9d122..72abee61208 100644 --- a/tests/unit/proxy/management_endpoints/test_ui_sso.py +++ b/tests/unit/proxy/management_endpoints/test_ui_sso.py @@ -11437,7 +11437,6 @@ async def test_get_user_info_from_db_skips_insert_when_admin_only_and_user_not_i proxy_logging_obj=MagicMock(), user_email="uninvited@example.com", user_defined_values=user_defined_values, - alternate_user_id="uninvited-google-sub", ui_access_mode="admin_only", )