diff --git a/litellm/proxy/management_endpoints/ui_sso.py b/litellm/proxy/management_endpoints/ui_sso.py index 80df6a95cc2..c7c2e2b4d21 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, @@ -4004,6 +4032,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). @@ -4029,6 +4058,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( @@ -4041,7 +4087,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"], @@ -4052,25 +4098,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 72416908c8d..61f199e426f 100644 --- a/tests/unit/proxy/management_endpoints/test_ui_sso.py +++ b/tests/unit/proxy/management_endpoints/test_ui_sso.py @@ -11463,3 +11463,73 @@ 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, + 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() +