diff --git a/CHANGES/kessel-content-guard.feature b/CHANGES/kessel-content-guard.feature new file mode 100644 index 000000000..c965c5596 --- /dev/null +++ b/CHANGES/kessel-content-guard.feature @@ -0,0 +1 @@ +Added KesselContentGuard, which permits content access only when Kessel grants the guard's permission (e.g. `content_sources_repository_view`) to the requesting user or service account on its org's default workspace. diff --git a/deploy/clowdapp.yaml b/deploy/clowdapp.yaml index 04186eb6e..243f2f279 100644 --- a/deploy/clowdapp.yaml +++ b/deploy/clowdapp.yaml @@ -439,6 +439,8 @@ objects: value: ${KESSEL_URL} - name: PULP_KESSEL_TOKEN_URL value: ${KESSEL_TOKEN_URL} + - name: PULP_KESSEL_RBAC_URL + value: ${KESSEL_RBAC_URL} - name: PULP_KESSEL_CLIENT_ID valueFrom: secretKeyRef: @@ -645,6 +647,8 @@ objects: value: ${KESSEL_URL} - name: PULP_KESSEL_TOKEN_URL value: ${KESSEL_TOKEN_URL} + - name: PULP_KESSEL_RBAC_URL + value: ${KESSEL_RBAC_URL} - name: PULP_KESSEL_CLIENT_ID valueFrom: secretKeyRef: @@ -1954,6 +1958,9 @@ parameters: - name: KESSEL_TOKEN_URL description: Red Hat SSO token endpoint for the Kessel client_credentials grant value: "https://sso.stage.redhat.com/auth/realms/redhat-external/protocol/openid-connect/token" + - name: KESSEL_RBAC_URL + description: RBAC base URL for the Kessel default-workspace lookup (set per environment in app-interface deploy.yml) + value: "" - name: PULP_TASK_PROTECTION_TIME description: Set the time in minutes to purge tasks value: "20160" diff --git a/pulp_service/pulp_service/app/kessel.py b/pulp_service/pulp_service/app/kessel.py new file mode 100644 index 000000000..8766dbf43 --- /dev/null +++ b/pulp_service/pulp_service/app/kessel.py @@ -0,0 +1,80 @@ +""" +Kessel client used by KesselContentGuard. + +Mirrors content-sources-backend: look up the org's default workspace via RBAC v2, then ask +Kessel Inventory (v1beta2 ``Check``) whether ``redhat/`` has ``permission`` on it. +""" + +from functools import lru_cache + +from django.conf import settings +from kessel.auth import OAuth2ClientCredentials, oauth2_auth_request +from kessel.inventory.v1beta2 import ClientBuilder +from kessel.inventory.v1beta2.allowed_pb2 import ALLOWED_TRUE +from kessel.inventory.v1beta2.check_request_pb2 import CheckRequest +from kessel.rbac.v2 import fetch_default_workspace, principal_subject, workspace_resource +from requests.adapters import HTTPAdapter + +_TIMEOUT = 5 # seconds, for the token fetch, the RBAC lookup and the gRPC call + + +class _TimeoutAdapter(HTTPAdapter): + """The SDK fetches tokens without a timeout; default one so a hung SSO can't block forever.""" + + def send(self, request, **kwargs): + kwargs["timeout"] = kwargs.get("timeout") or _TIMEOUT + return super().send(request, **kwargs) + + +@lru_cache(maxsize=1) +def _credentials(): + """OAuth2 client-credentials token source, or None when no credentials are configured (dev).""" + if not (settings.KESSEL_CLIENT_ID and settings.KESSEL_CLIENT_SECRET): + return None + creds = OAuth2ClientCredentials( + client_id=settings.KESSEL_CLIENT_ID, + client_secret=settings.KESSEL_CLIENT_SECRET, + token_endpoint=settings.KESSEL_TOKEN_URL, + retry={"max_retries": 1}, + ) + # ponytail: reaches into the SDK's private OAuth2Session; drop once kessel-sdk accepts a timeout. + creds._session.mount("https://", _TimeoutAdapter()) + creds._session.mount("http://", _TimeoutAdapter()) + return creds + + +@lru_cache(maxsize=1) +def _stub(): + creds = _credentials() + builder = ClientBuilder(settings.KESSEL_URL) + builder = builder.oauth2_client_authenticated(creds) if creds else builder.insecure() + stub, _channel = builder.build() + return stub + + +# Workspace ids don't change, so cache per org. lru_cache does not cache exceptions. +@lru_cache(maxsize=1024) +def _default_workspace_id(org_id): + creds = _credentials() + workspace = fetch_default_workspace( + settings.KESSEL_RBAC_URL, + org_id, + auth=oauth2_auth_request(creds) if creds else None, + timeout=_TIMEOUT, + ) + return workspace.id + + +def check_permission(org_id, user_id, permission): + """ + Return True only if Kessel answers ALLOWED_TRUE for ``permission`` on the org's default workspace. + + Raises on any transport/config error; the caller decides how to fail. + """ + request = CheckRequest( + object=workspace_resource(_default_workspace_id(org_id)), + relation=permission, + subject=principal_subject(user_id, "redhat"), + ) + response = _stub().Check(request, timeout=_TIMEOUT) + return response.allowed == ALLOWED_TRUE diff --git a/pulp_service/pulp_service/app/migrations/0027_kesselcontentguard.py b/pulp_service/pulp_service/app/migrations/0027_kesselcontentguard.py new file mode 100644 index 000000000..696928360 --- /dev/null +++ b/pulp_service/pulp_service/app/migrations/0027_kesselcontentguard.py @@ -0,0 +1,28 @@ +# Generated by Django 5.2.16 on 2026-11-17 20:11 + +import django.db.models.deletion +import pulpcore.app.models.access_policy +from django.db import migrations, models + + +class Migration(migrations.Migration): + + dependencies = [ + ('core', '0160_envvarheadercontentguard'), + ('service', '0026_andgatecontentguard'), + ] + + operations = [ + migrations.CreateModel( + name='KesselContentGuard', + fields=[ + ('contentguard_ptr', models.OneToOneField(auto_created=True, on_delete=django.db.models.deletion.CASCADE, parent_link=True, primary_key=True, serialize=False, to='core.contentguard')), + ('permission', models.TextField()), + ], + options={ + 'permissions': (('manage_roles_kesselcontentguard', 'Can manage role assignments on Kessel ContentGuard'),), + 'default_related_name': '%(app_label)s_%(model_name)s', + }, + bases=('core.contentguard', pulpcore.app.models.access_policy.AutoAddObjPermsMixin), + ), + ] diff --git a/pulp_service/pulp_service/app/models.py b/pulp_service/pulp_service/app/models.py index fc5d19a3e..56ca34d05 100755 --- a/pulp_service/pulp_service/app/models.py +++ b/pulp_service/pulp_service/app/models.py @@ -15,6 +15,7 @@ from pulp_service.app.content_view_models import ContentView, ContentViewSearchScope # noqa: F401 from pulp_service.app.features_service import check_subscription +from pulp_service.app.kessel import check_permission from pulp_service.exceptions import AuthenticationError _logger = logging.getLogger(__name__) @@ -136,6 +137,56 @@ class Meta: ) +def _principal_from_identity_header(request): + """ + Return ``(org_id, user_id)`` from the request's ``x-rh-identity`` header. + + Raises AuthenticationError when the header is missing, PermissionError when it can't be + parsed or carries no user/service-account principal. + """ + header = request.headers.get("x-rh-identity") + if header is None: + raise AuthenticationError(_("Authentication required.")) + try: + identity = json.loads(b64decode(header))["identity"] + org_id = identity.get("org_id") or identity.get("internal", {}).get("org_id") + principal_key = {"User": "user", "ServiceAccount": "service_account"}.get(identity.get("type")) + user_id = identity.get(principal_key, {}).get("user_id") if principal_key else None + except (Base64DecodeError, ValueError, KeyError, TypeError, AttributeError) as exc: + raise PermissionError(_("Access denied.")) from exc + if not (org_id and user_id): + raise PermissionError(_("Access denied.")) + return str(org_id), str(user_id) + + +class KesselContentGuard(ContentGuard, AutoAddObjPermsMixin): + """ + Content guard that permits access only when Kessel grants ``permission`` to the requesting + principal on its org's default workspace (e.g. ``content_sources_repository_view``). + + Fails closed: any error talking to RBAC/Kessel denies access. + """ + + TYPE = "kessel" + + permission = models.TextField() + + def permit(self, request): + org_id, user_id = _principal_from_identity_header(request) + try: + allowed = check_permission(org_id, user_id, self.permission) + except Exception as exc: + # permit() must only raise PermissionError/AuthenticationError (pulpcore's handler contract). + _logger.exception("Kessel permission check failed.") + raise PermissionError(_("Access denied.")) from exc + if not allowed: + raise PermissionError(_("Access denied.")) + + class Meta: + default_related_name = "%(app_label)s_%(model_name)s" + permissions = (("manage_roles_kesselcontentguard", "Can manage role assignments on Kessel ContentGuard"),) + + class YankedPackageReport(BaseModel): """ Stores the result of a PyPI yank check for Python packages stored in Pulp. diff --git a/pulp_service/pulp_service/app/serializers.py b/pulp_service/pulp_service/app/serializers.py index bc3af94e5..bfd13ce32 100755 --- a/pulp_service/pulp_service/app/serializers.py +++ b/pulp_service/pulp_service/app/serializers.py @@ -36,6 +36,7 @@ from pulp_service.app.models import ( AndGateContentGuard, FeatureContentGuard, + KesselContentGuard, PyPIYankMonitor, VulnerabilityReport, YankedPackageReport, @@ -69,6 +70,23 @@ class Meta(ContentGuardSerializer.Meta): fields = (*ContentGuardSerializer.Meta.fields, "header_name", "jq_filter", "features") +class KesselContentGuardSerializer(ContentGuardSerializer, GetOrCreateSerializerMixin): + """ + A serializer for KesselContentGuard. + """ + + permission = serializers.CharField( + help_text=_( + "Kessel permission the requesting principal must have on its org's default workspace, " + "e.g. content_sources_repository_view." + ), + ) + + class Meta(ContentGuardSerializer.Meta): + model = KesselContentGuard + fields = (*ContentGuardSerializer.Meta.fields, "permission") + + class AndGateContentGuardSerializer(ContentGuardSerializer, GetOrCreateSerializerMixin): """ A serializer for AndGateContentGuard. diff --git a/pulp_service/pulp_service/app/settings.py b/pulp_service/pulp_service/app/settings.py index 512bea2e9..e941d7565 100755 --- a/pulp_service/pulp_service/app/settings.py +++ b/pulp_service/pulp_service/app/settings.py @@ -17,6 +17,12 @@ # malformed timeout value and raises a ValueError. FEATURE_SERVICE_API_CONNECT_TIMEOUT = 2 FEATURE_SERVICE_API_READ_TIMEOUT = 5 +# Kessel (KesselContentGuard); set via PULP_KESSEL_* env vars in deploy/clowdapp.yaml. +KESSEL_URL = "" # Kessel Inventory gRPC host:port, no scheme (TLS when client credentials are set) +KESSEL_TOKEN_URL = "" +KESSEL_CLIENT_ID = "" +KESSEL_CLIENT_SECRET = "" +KESSEL_RBAC_URL = "" AUTHENTICATION_HEADER_DEBUG = False INSTALLED_APPS = "@merge django.contrib.admin.apps.SimpleAdminConfig,hijack,hijack.contrib.admin" TEST_TASK_INGESTION = False diff --git a/pulp_service/pulp_service/app/viewsets.py b/pulp_service/pulp_service/app/viewsets.py index 00c440d30..c355ef28b 100755 --- a/pulp_service/pulp_service/app/viewsets.py +++ b/pulp_service/pulp_service/app/viewsets.py @@ -66,12 +66,19 @@ RpmContentViewPackageListViewSet, RpmContentViewPackageSearchViewSet, ) -from pulp_service.app.models import AndGateContentGuard, FeatureContentGuard, PyPIYankMonitor, YankedPackageReport +from pulp_service.app.models import ( + AndGateContentGuard, + FeatureContentGuard, + KesselContentGuard, + PyPIYankMonitor, + YankedPackageReport, +) from pulp_service.app.models import VulnerabilityReport as VulnReport from pulp_service.app.serializers import ( AndGateContentGuardSerializer, ContentScanSerializer, FeatureContentGuardSerializer, + KesselContentGuardSerializer, NpmManifestBackfillSerializer, PublicDebugAuthenticationHeadersSerializer, PyPIYankMonitorSerializer, @@ -258,6 +265,77 @@ class FeatureContentGuardViewSet(ContentGuardViewSet, RolesMixin): } +class KesselContentGuardViewSet(ContentGuardViewSet, RolesMixin): + """ + Content guard to protect content with Kessel permission checks. + """ + + endpoint_name = "kessel" + queryset = KesselContentGuard.objects.all() + serializer_class = KesselContentGuardSerializer + queryset_filtering_required_permission = "service.view_kesselcontentguard" + + DEFAULT_ACCESS_POLICY = { + "statements": [ + {"action": ["list", "my_permissions"], "principal": "authenticated", "effect": "allow"}, + { + "action": ["create"], + "principal": "authenticated", + "effect": "allow", + "condition": "has_model_or_domain_perms:service.add_kesselcontentguard", + }, + { + "action": ["retrieve"], + "principal": "authenticated", + "effect": "allow", + "condition": "has_model_or_domain_or_obj_perms:service.view_kesselcontentguard", + }, + { + "action": ["update", "partial_update"], + "principal": "authenticated", + "effect": "allow", + "condition": [ + "has_model_or_domain_or_obj_perms:service.change_kesselcontentguard", + "has_model_or_domain_or_obj_perms:service.view_kesselcontentguard", + ], + }, + { + "action": ["destroy"], + "principal": "authenticated", + "effect": "allow", + "condition": [ + "has_model_or_domain_or_obj_perms:service.delete_kesselcontentguard", + "has_model_or_domain_or_obj_perms:service.view_kesselcontentguard", + ], + }, + { + "action": ["list_roles", "add_role", "remove_role"], + "principal": "authenticated", + "effect": "allow", + "condition": "has_model_or_domain_or_obj_perms:service.manage_roles_kesselcontentguard", + }, + ], + "creation_hooks": [ + { + "function": "add_roles_for_object_creator", + "parameters": {"roles": "service.kesselcontentguard_owner"}, + } + ], + "queryset_scoping": {"function": "scope_queryset"}, + } + + LOCKED_ROLES = { + "service.kesselcontentguard_creator": ["service.add_kesselcontentguard"], + "service.kesselcontentguard_owner": [ + "service.view_kesselcontentguard", + "service.change_kesselcontentguard", + "service.delete_kesselcontentguard", + "service.manage_roles_kesselcontentguard", + ], + "service.kesselcontentguard_viewer": ["service.view_kesselcontentguard"], + } + + class AndGateContentGuardViewSet(ContentGuardViewSet, RolesMixin): """ Content guard that permits access only when all of its sub-guards permit. diff --git a/pulp_service/pulp_service/tests/unit/test_kessel_client.py b/pulp_service/pulp_service/tests/unit/test_kessel_client.py new file mode 100644 index 000000000..261c85d5a --- /dev/null +++ b/pulp_service/pulp_service/tests/unit/test_kessel_client.py @@ -0,0 +1,107 @@ +""" +Unit tests for the Kessel client (pulp_service.app.kessel). + +The gRPC stub and the RBAC v2 workspace lookup are mocked, so no network is needed. +""" + +from types import SimpleNamespace +from unittest.mock import MagicMock, patch + +import pytest +import requests +from django.test import override_settings +from kessel.inventory.v1beta2.allowed_pb2 import ALLOWED_FALSE, ALLOWED_TRUE, ALLOWED_UNSPECIFIED +from kessel.inventory.v1beta2.check_response_pb2 import CheckResponse + +from pulp_service.app import kessel + +PERMISSION = "content_sources_repository_view" + + +@pytest.fixture +def stub(): + kessel._default_workspace_id.cache_clear() + stub = MagicMock() + with ( + patch.object(kessel, "_stub", return_value=stub), + patch.object(kessel, "_credentials", return_value=None), + ): + yield stub + kessel._default_workspace_id.cache_clear() + + +@pytest.fixture +def fetch_workspace(): + with patch.object(kessel, "fetch_default_workspace", return_value=SimpleNamespace(id="ws-1")) as fetch: + yield fetch + + +def test_allowed_true_grants(stub, fetch_workspace): + stub.Check.return_value = CheckResponse(allowed=ALLOWED_TRUE) + + assert kessel.check_permission("org1", "u1", PERMISSION) is True + + fetch_workspace.assert_called_once() + assert fetch_workspace.call_args.args[1] == "org1" + request = stub.Check.call_args.args[0] + assert request.object.resource_type == "workspace" + assert request.object.resource_id == "ws-1" + assert request.object.reporter.type == "rbac" + assert request.relation == PERMISSION + assert request.subject.resource.resource_type == "principal" + assert request.subject.resource.resource_id == "redhat/u1" + assert request.subject.resource.reporter.type == "rbac" + + +@pytest.mark.usefixtures("fetch_workspace") +@pytest.mark.parametrize("allowed", [ALLOWED_FALSE, ALLOWED_UNSPECIFIED]) +def test_allowed_false_and_unspecified_deny(stub, allowed): + stub.Check.return_value = CheckResponse(allowed=allowed) + + assert kessel.check_permission("org1", "u1", PERMISSION) is False + + +def test_workspace_lookup_cached_per_org(stub, fetch_workspace): + stub.Check.return_value = CheckResponse(allowed=ALLOWED_TRUE) + + kessel.check_permission("org1", "u1", PERMISSION) + kessel.check_permission("org1", "u2", PERMISSION) + + fetch_workspace.assert_called_once() + + +def test_workspace_lookup_failure_not_cached(stub, fetch_workspace): + stub.Check.return_value = CheckResponse(allowed=ALLOWED_TRUE) + fetch_workspace.side_effect = [requests.HTTPError("boom"), SimpleNamespace(id="ws-1")] + + with pytest.raises(requests.HTTPError): + kessel.check_permission("org1", "u1", PERMISSION) + + assert kessel.check_permission("org1", "u1", PERMISSION) is True + assert fetch_workspace.call_count == 2 + + +def test_token_fetch_has_timeout(): + """A hung SSO token endpoint must not block forever (the SDK passes no timeout itself).""" + kessel._credentials.cache_clear() + response = requests.Response() + response.status_code = 200 + response.headers["Content-Type"] = "application/json" + response._content = b'{"access_token": "t", "token_type": "Bearer", "expires_in": 300}' + + def _send(_adapter, request, **_kwargs): + response.request = request + return response + + with ( + override_settings( + KESSEL_CLIENT_ID="id", + KESSEL_CLIENT_SECRET="secret", # noqa: S106 + KESSEL_TOKEN_URL="https://sso.example/token", # noqa: S106 + ), + patch("requests.adapters.HTTPAdapter.send", autospec=True) as send, + ): + send.side_effect = _send + assert kessel._credentials().get_token().access_token == "t" # noqa: S105 + kessel._credentials.cache_clear() + assert send.call_args.kwargs["timeout"] == kessel._TIMEOUT diff --git a/pulp_service/pulp_service/tests/unit/test_kessel_content_guard.py b/pulp_service/pulp_service/tests/unit/test_kessel_content_guard.py new file mode 100644 index 000000000..178962e54 --- /dev/null +++ b/pulp_service/pulp_service/tests/unit/test_kessel_content_guard.py @@ -0,0 +1,85 @@ +""" +Unit tests for KesselContentGuard.permit(): identity parsing and fail-closed behavior. + +The Kessel client (check_permission) is mocked; its own behavior is covered in test_kessel_client.py. +""" + +import json +from base64 import b64encode +from types import SimpleNamespace +from unittest.mock import patch + +import pytest + +from pulp_service.app.models import KesselContentGuard +from pulp_service.exceptions import AuthenticationError + +PERMISSION = "content_sources_repository_view" +_CHECK = "pulp_service.app.models.check_permission" + + +def _guard(): + # pulp_domain must be explicit: its default (get_domain_pk) queries the DB. + return KesselContentGuard(name="test", permission=PERMISSION, pulp_domain=None) + + +def _request(identity): + header = b64encode(json.dumps({"identity": identity}).encode()).decode() + return SimpleNamespace(headers={"x-rh-identity": header}) + + +USER = {"type": "User", "org_id": "org1", "user": {"user_id": "u1"}} + + +def test_user_allowed(): + with patch(_CHECK, return_value=True) as check: + assert _guard().permit(_request(USER)) is None + check.assert_called_once_with("org1", "u1", PERMISSION) + + +def test_service_account_uses_service_account_user_id(): + identity = {"type": "ServiceAccount", "org_id": "org1", "service_account": {"user_id": "sa1"}} + with patch(_CHECK, return_value=True) as check: + _guard().permit(_request(identity)) + check.assert_called_once_with("org1", "sa1", PERMISSION) + + +def test_internal_org_id_fallback(): + identity = {"type": "User", "internal": {"org_id": "org2"}, "user": {"user_id": "u1"}} + with patch(_CHECK, return_value=True) as check: + _guard().permit(_request(identity)) + check.assert_called_once_with("org2", "u1", PERMISSION) + + +def test_denied_raises_permission_error(): + with patch(_CHECK, return_value=False), pytest.raises(PermissionError): + _guard().permit(_request(USER)) + + +def test_missing_header_raises_authentication_error(): + with patch(_CHECK) as check, pytest.raises(AuthenticationError): + _guard().permit(SimpleNamespace(headers={})) + check.assert_not_called() + + +@pytest.mark.parametrize( + "header", + [ + "not-base64!!", + b64encode(b"not json").decode(), + b64encode(json.dumps(["not", "a", "dict"]).encode()).decode(), + b64encode(json.dumps({"identity": {"type": "System", "org_id": "org1"}}).encode()).decode(), + b64encode(json.dumps({"identity": {"type": "User", "user": {"user_id": "u1"}}}).encode()).decode(), + b64encode(json.dumps({"identity": {"type": "User", "org_id": "org1", "user": {}}}).encode()).decode(), + ], + ids=["non-base64", "non-json", "non-dict", "system-type", "missing-org-id", "missing-user-id"], +) +def test_bad_header_raises_permission_error(header): + with patch(_CHECK) as check, pytest.raises(PermissionError): + _guard().permit(SimpleNamespace(headers={"x-rh-identity": header})) + check.assert_not_called() + + +def test_kessel_error_fails_closed(): + with patch(_CHECK, side_effect=RuntimeError("kessel down")), pytest.raises(PermissionError): + _guard().permit(_request(USER)) diff --git a/pulp_service/requirements.txt b/pulp_service/requirements.txt index 8ef962eed..58255bb3f 100644 --- a/pulp_service/requirements.txt +++ b/pulp_service/requirements.txt @@ -7,6 +7,7 @@ pulp-container==2.29.0 pulp-maven==0.37.2 pulp-cli requests +kessel-sdk[auth] sentry-sdk app-common-python uvloop==0.21.0