:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
fix(data-management): restrict media preview urls to export viewers (#130490)
Matt Pua40134d44759f
diff --git a/ee/api/ee_event_definition.py b/ee/api/ee_event_definition.pyindex c1ac17299eab..eadfe43f29ba 100644--- a/ee/api/ee_event_definition.py+++ b/ee/api/ee_event_definition.py@@ -6,6 +6,7 @@ import posthoganalyticsfrom drf_spectacular.extensions import OpenApiSerializerExtensionfrom rest_framework import serializers+from posthog.api.object_media_preview import visible_previews, with_preview_mediafrom posthog.api.shared import UserBasicSerializerfrom posthog.api.tagged_item import TaggedItemSerializerMixinfrom posthog.event_usage import groups@@ -247,9 +248,7 @@ class EnterpriseEventDefinitionSerializer(TaggedItemSerializerMixin, serializersif not obj.id:return []- previews = (- ObjectMediaPreview.objects.filter(event_definition_id=obj.id)- .select_related("uploaded_media", "exported_asset")- .order_by("-updated_at")+ previews = with_preview_media(ObjectMediaPreview.objects.filter(event_definition_id=obj.id)).order_by(+ "-updated_at")- return [p.media_url for p in previews if p.media_url]+ return [p.media_url for p in visible_previews(previews, self.context.get("view")) if p.media_url]diff --git a/ee/api/test/test_event_definition.py b/ee/api/test/test_event_definition.pyindex b92f0756a67f..e0f56cc20a1f 100644--- a/ee/api/test/test_event_definition.py+++ b/ee/api/test/test_event_definition.py@@ -19,6 +19,7 @@ from posthog.api.test.test_user import create_userfrom posthog.models import ActivityLog, ObjectMediaPreview, Tag, Team, UploadedMedia, Userfrom products.event_definitions.backend.models.event_definition import EventDefinition+from products.exports.backend.models.exported_asset import ExportedAssetfrom ee.models.event_definition import EnterpriseEventDefinitionfrom ee.models.license import License, LicenseManager@@ -905,6 +906,33 @@ class TestEventDefinitionEnterpriseAPI(APIBaseTest):assert len(event_data["media_preview_urls"]) == 1assert "uploaded_media" in event_data["media_preview_urls"][0]+ @parameterized.expand(+ [+ ("other_members_export", None, False),+ ("event_screenshot", "session-1", True),+ ]+ )+ def test_media_preview_urls_follow_export_access(self, _name, session_recording_id, expects_url):+ super(LicenseManager, cast(LicenseManager, License.objects)).create(+ plan="enterprise", valid_until=datetime(2500, 1, 19, 3, 14, 7)+ )+ other_user = User.objects.create_and_join(self.organization, "[email protected]", "password")+ event = EnterpriseEventDefinition.objects.create(team=self.demo_team, name="event_with_export")+ asset = ExportedAsset.objects.create(+ team=self.demo_team,+ export_format="image/png",+ created_by=None if session_recording_id else other_user,+ export_context={"session_recording_id": session_recording_id} if session_recording_id else None,+ )+ ObjectMediaPreview.objects.create(team=self.demo_team, event_definition=event, exported_asset=asset)++ list_response = self.client.get("/api/projects/@current/event_definitions/")+ retrieve_response = self.client.get(f"/api/projects/@current/event_definitions/{event.id}")++ listed = next(r for r in list_response.json()["results"] if r["name"] == "event_with_export")+ for urls in (listed["media_preview_urls"], retrieve_response.json()["media_preview_urls"]):+ assert len(urls) == (1 if expects_url else 0)+def test_list_media_preview_urls_empty_when_no_media(self):"""Events without media previews return empty media_preview_urls."""super(LicenseManager, cast(LicenseManager, License.objects)).create(diff --git a/frontend/src/scenes/data-management/definition/DefinitionEdit.tsx b/frontend/src/scenes/data-management/definition/DefinitionEdit.tsxindex b50a11c40444..8ac115a0ff0a 100644--- a/frontend/src/scenes/data-management/definition/DefinitionEdit.tsx+++ b/frontend/src/scenes/data-management/definition/DefinitionEdit.tsx@@ -76,6 +76,8 @@ export function DefinitionEdit(rawProps: DefinitionLogicProps): JSX.Element {const showHiddenOption = 'hidden' in editDefinitionconst { previews, previewsLoading } = useValues(definitionLogicInstance)+ // A preview without a URL has nothing to show, and the delete handler below matches previews by URL+ const visiblePreviews = previews?.filter((p: ObjectMediaPreview) => p.media_url) ?? []const { createMediaPreview, deleteMediaPreview } = useActions(definitionLogicInstance)const { setFilesToUpload, filesToUpload, uploading } = useUploadFiles({@@ -268,12 +270,12 @@ export function DefinitionEdit(rawProps: DefinitionLogicProps): JSX.Element {/></div>- {(previewsLoading || (previews && previews.length > 0)) && (+ {(previewsLoading || visiblePreviews.length > 0) && (<ImageCarouselloading={previewsLoading}- imageUrls={previews?.map((p: ObjectMediaPreview) => p.media_url) ?? []}+ imageUrls={visiblePreviews.map((p: ObjectMediaPreview) => p.media_url)}onDelete={(url: string) => {- const preview = previews.find(+ const preview = visiblePreviews.find((p: ObjectMediaPreview) => p.media_url === url)if (preview) {diff --git a/posthog/api/event_definition.py b/posthog/api/event_definition.pyindex c6b4690e20ce..05b86af53cfe 100644--- a/posthog/api/event_definition.py+++ b/posthog/api/event_definition.py@@ -24,6 +24,7 @@ from posthog.api.event_definition_generators.base import EventDefinitionGeneratofrom posthog.api.event_definition_generators.golang import GolangGeneratorfrom posthog.api.event_definition_generators.python import PythonGeneratorfrom posthog.api.event_definition_generators.typescript import TypeScriptGenerator+from posthog.api.object_media_preview import visible_previews, with_preview_mediafrom posthog.api.pagination import CappedCountLimitOffsetPaginationfrom posthog.api.routing import TeamAndOrgViewSetMixinfrom posthog.api.shared import UserBasicSerializer@@ -783,12 +784,10 @@ class EventDefinitionViewSet(event_ids = [obj.id for obj in objects]media_map: dict[str, list[str]] = defaultdict(list)if event_ids:- previews = (+ previews = with_preview_media(ObjectMediaPreview.objects.filter(event_definition_id__in=event_ids)- .select_related("uploaded_media", "exported_asset")- .order_by("-updated_at")- )- for p in previews:+ ).order_by("-updated_at")+ for p in visible_previews(previews, self):if p.media_url:media_map[str(p.event_definition_id)].append(p.media_url)diff --git a/posthog/api/object_media_preview.py b/posthog/api/object_media_preview.pyindex a5d8b8707b16..5cd76ac3eb77 100644--- a/posthog/api/object_media_preview.py+++ b/posthog/api/object_media_preview.py@@ -1,3 +1,10 @@+import uuid+from collections.abc import Iterable++from django.db.models import QuerySet++from drf_spectacular.types import OpenApiTypes+from drf_spectacular.utils import OpenApiParameter, extend_schemafrom rest_framework import serializers, status, viewsetsfrom rest_framework.decorators import actionfrom rest_framework.exceptions import ValidationError@@ -7,18 +14,84 @@ from rest_framework.response import Responsefrom posthog.api.routing import TeamAndOrgViewSetMixinfrom posthog.models import ObjectMediaPreview, UploadedMedia-from posthog.permissions import is_scout_sandbox_request+from posthog.models.utils import strict_fetch+from posthog.permissions import is_scout_sandbox_request, scopes_caller_lacksfrom posthog.taxonomy.scout_writes import refuse_scout_taxonomy_writefrom products.event_definitions.backend.models import EventDefinition+from products.exports.backend.facade.auth import viewable_exported_asset_ids+++def with_preview_media(queryset: QuerySet[ObjectMediaPreview]) -> QuerySet[ObjectMediaPreview]:+ # An export's content column can hold the whole file when object storage is off, and no preview path reads it+ return queryset.select_related("uploaded_media", "exported_asset").defer("exported_asset__content")+++PREFERRED_EXPORTED_SCAN_LIMIT = 50+++def visible_exported_asset_ids(previews: Iterable[ObjectMediaPreview], view: object) -> set[int]:+ """Ids of the exported assets behind these previews that the requesting user may read.++ An exported asset's URL is a long-lived token that works without a session, so it is only handed to+ viewers the exports API would serve the asset to: the user must pass its access checks, and a scoped+ token must hold `export:read`. Without a request user and access control, no exported asset is visible.+ """+ request = getattr(view, "request", None)+ user_access_control = getattr(view, "user_access_control", None)+ user_id = getattr(getattr(request, "user", None), "id", None)+ team_id = getattr(view, "team_id", None)+ asset_ids = {preview.exported_asset_id for preview in previews if preview.exported_asset_id is not None}+ if user_access_control is None or user_id is None or team_id is None or not asset_ids:+ return set()+ if scopes_caller_lacks(request, ["export:read"]):+ return set()+ return viewable_exported_asset_ids(+ asset_ids, team_id=team_id, user_id=user_id, user_access_control=user_access_control+ )+++def visible_previews(previews: Iterable[ObjectMediaPreview], view: object) -> list[ObjectMediaPreview]:+ """The previews the requesting user may see, in their original order."""+ previews = list(previews)+ visible_ids = visible_exported_asset_ids(previews, view)+ return [+ preview+ for preview in previews+ if preview.uploaded_media_id or (preview.exported_asset_id and preview.exported_asset_id in visible_ids)+ ]+++def _as_uuids(values: Iterable[object]) -> list[uuid.UUID]:+ """The values that parse as UUIDs. A malformed id in the URL then matches nothing instead of raising."""+ parsed = []+ for value in values:+ try:+ parsed.append(uuid.UUID(str(value)))+ except ValueError:+ pass+ return parsedclass ObjectMediaPreviewSerializer(serializers.ModelSerializer):- media_url = serializers.SerializerMethodField()- media_type = serializers.SerializerMethodField()- uploaded_media_id = serializers.UUIDField(write_only=True, required=False, allow_null=True)- exported_asset_id = serializers.UUIDField(write_only=True, required=False, allow_null=True)- event_definition_id = serializers.UUIDField(write_only=True, required=False, allow_null=True)+ media_url = serializers.SerializerMethodField(+ help_text="URL of the preview image. For an exported asset this is a signed link that works without a session."+ )+ media_type = serializers.SerializerMethodField(+ help_text="Where the image comes from: 'uploaded' for user-uploaded media, 'exported' for an exported asset."+ )+ uploaded_media_id = serializers.UUIDField(+ write_only=True,+ required=False,+ allow_null=True,+ help_text="ID of uploaded media in this project to use as the preview. Required when creating a preview.",+ )+ event_definition_id = serializers.UUIDField(+ write_only=True,+ required=False,+ allow_null=True,+ help_text="ID of the event definition the preview belongs to. Required when creating a preview.",+ )class Meta:model = ObjectMediaPreview@@ -30,13 +103,18 @@ class ObjectMediaPreviewSerializer(serializers.ModelSerializer):"media_type","metadata","uploaded_media_id",- "exported_asset_id","event_definition_id",)read_only_fields = ("id", "created_at", "updated_at", "media_url", "media_type")def get_media_url(self, obj: ObjectMediaPreview) -> str:- return obj.media_url+ if obj.uploaded_media_id:+ return obj.media_url+ # The viewset leaves out previews the viewer may not read and passes the asset ids it allowed. A+ # serializer used without that context therefore returns no long-lived token for an exported asset.+ if obj.exported_asset_id and obj.exported_asset_id in self.context.get("visible_exported_asset_ids", set()):+ return obj.media_url+ return ""def get_media_type(self, obj: ObjectMediaPreview) -> str:"""Return 'uploaded' or 'exported' based on which media is set"""@@ -50,31 +128,18 @@ class ObjectMediaPreviewSerializer(serializers.ModelSerializer):team = self.context["get_team"]()uploaded_media_id = validated_data.pop("uploaded_media_id", None)- exported_asset_id = validated_data.pop("exported_asset_id", None)event_definition_id = validated_data.pop("event_definition_id", None)- if bool(uploaded_media_id) + bool(exported_asset_id) != 1:- raise ValidationError("Exactly one of uploaded_media_id or exported_asset_id must be provided")+ if not uploaded_media_id:+ raise ValidationError("uploaded_media_id must be provided")if not event_definition_id:raise ValidationError("event_definition_id must be provided")- uploaded_media = None- exported_asset = None-- if uploaded_media_id:- try:- uploaded_media = UploadedMedia.objects.get(id=uploaded_media_id, team=team)- except UploadedMedia.DoesNotExist:- raise ValidationError("Uploaded media not found or does not belong to this team")-- if exported_asset_id:- from products.exports.backend.models.exported_asset import ExportedAsset-- try:- exported_asset = ExportedAsset.objects.get(id=exported_asset_id, team=team)- except ExportedAsset.DoesNotExist:- raise ValidationError("Exported asset not found or does not belong to this team")+ try:+ uploaded_media = UploadedMedia.objects.get(id=uploaded_media_id, team=team)+ except UploadedMedia.DoesNotExist:+ raise ValidationError("Uploaded media not found or does not belong to this team")try:event_definition = EventDefinition.objects.get(id=event_definition_id, team=team)@@ -84,7 +149,6 @@ class ObjectMediaPreviewSerializer(serializers.ModelSerializer):preview = ObjectMediaPreview.objects.create(team=team,uploaded_media=uploaded_media,- exported_asset=exported_asset,event_definition=event_definition,**validated_data,)@@ -106,18 +170,50 @@ class ObjectMediaPreviewViewSet(refuse_scout_taxonomy_write(is_scout_sandbox_request(request))def safely_get_queryset(self, queryset):- # Filter by event_definition if provided+ # The mixin applies its team filter only after this method returns, and the access check below+ # loads every exported preview in the queryset, so scope to the team first.+ queryset = (+ with_preview_media(queryset.filter(team_id=self.team_id))+ .select_related("event_definition")+ .order_by("-updated_at", "-id")+ )event_definition_id = self.request.query_params.get("event_definition")+ if self.action == "list" and not event_definition_id:+ raise ValidationError("event_definition query parameter is required")if event_definition_id:- return (- queryset.filter(event_definition_id=event_definition_id)- .select_related("uploaded_media", "exported_asset", "event_definition")- .order_by("-updated_at", "-id")- )+ queryset = queryset.filter(event_definition_id=event_definition_id)+ if self.action == "list":+ queryset = strict_fetch(queryset)+ return self._without_hidden_exports(queryset)- return queryset.select_related("uploaded_media", "exported_asset", "event_definition").order_by(- "-updated_at", "-id"- )+ def _without_hidden_exports(self, queryset):+ # Hidden previews are removed from the result, not returned with an empty URL, because their metadata+ # (session id, page URL) is about the recording the viewer may not read.+ exported_previews = queryset.filter(exported_asset__isnull=False)+ if self.kwargs.get("pk"):+ exported_previews = exported_previews.filter(pk__in=_as_uuids([self.kwargs["pk"]]))+ exported = list(exported_previews)+ self._visible_exported_asset_ids = visible_exported_asset_ids(exported, self)+ hidden_ids = [p.id for p in exported if p.exported_asset_id not in self._visible_exported_asset_ids]+ return queryset.exclude(id__in=hidden_ids) if hidden_ids else queryset++ def get_serializer_context(self):+ context = super().get_serializer_context()+ context["visible_exported_asset_ids"] = getattr(self, "_visible_exported_asset_ids", set())+ return context++ @extend_schema(+ parameters=[+ OpenApiParameter(+ "event_definition",+ OpenApiTypes.UUID,+ required=True,+ description="ID of the event definition whose previews to list.",+ )+ ]+ )+ def list(self, request, *args, **kwargs):+ return super().list(request, *args, **kwargs)@action(methods=["GET"], detail=False, url_path="preferred_for_event")def preferred_for_event(self, request, *args, **kwargs):@@ -146,20 +242,21 @@ class ObjectMediaPreviewViewSet(serializer = self.get_serializer(user_uploaded)return Response(serializer.data)- # Fall back to most recent exported asset- exported = (- ObjectMediaPreview.objects.filter(- event_definition_id=event_definition_id,- team=self.team,- exported_asset__isnull=False,+ exported = list(+ with_preview_media(+ ObjectMediaPreview.objects.filter(+ event_definition_id=event_definition_id,+ team=self.team,+ exported_asset__isnull=False,+ ))- .select_related("exported_asset", "event_definition")- .order_by("-updated_at", "-id")- .first()+ .select_related("event_definition")+ .order_by("-updated_at", "-id")[:PREFERRED_EXPORTED_SCAN_LIMIT])+ self._visible_exported_asset_ids = visible_exported_asset_ids(exported, self)+ preferred = next((p for p in exported if p.exported_asset_id in self._visible_exported_asset_ids), None)- if exported:- serializer = self.get_serializer(exported)- return Response(serializer.data)+ if preferred:+ return Response(self.get_serializer(preferred).data)return Response({"detail": "No media preview found"}, status=status.HTTP_404_NOT_FOUND)diff --git a/posthog/api/test/test_object_media_preview.py b/posthog/api/test/test_object_media_preview.pyindex 2d5f3fda9cfd..74f83f7dd530 100644--- a/posthog/api/test/test_object_media_preview.py+++ b/posthog/api/test/test_object_media_preview.py@@ -1,12 +1,21 @@+import uuid+from posthog.test.base import APIBaseTest+from django.db import connection+from django.test.utils import CaptureQueriesContextfrom django.utils import timezone+from parameterized import parameterizedfrom rest_framework import status-from posthog.models import ObjectMediaPreview, UploadedMedia+from posthog.models import ObjectMediaPreview, Team, UploadedMedia, User+from posthog.models.personal_api_key import PersonalAPIKey+from posthog.models.utils import generate_random_token_personal, hash_key_value+from posthog.session_recordings.models.session_recording import SessionRecordingfrom products.event_definitions.backend.models import EventDefinition+from products.exports.backend.models.exported_asset import ExportedAssetclass TestObjectMediaPreviewAPI(APIBaseTest):@@ -42,3 +51,143 @@ class TestObjectMediaPreviewAPI(APIBaseTest):# Tied rows need a total order, or a page boundary can skip or repeat a previewassert seen == sorted((str(preview.id) for preview in previews), reverse=True)++ def test_list_requires_an_event_definition(self):+ response = self.client.get(f"/api/projects/{self.team.pk}/object_media_previews/")++ assert response.status_code == status.HTTP_400_BAD_REQUEST++ def test_create_links_only_the_uploaded_media(self):+ event_definition = EventDefinition.objects.create(team=self.team, name="purchase")+ media = UploadedMedia.objects.create(team=self.team, file_name="screenshot.png", content_type="image/png")+ response = self.client.post(+ f"/api/projects/{self.team.pk}/object_media_previews/",+ {+ "event_definition_id": str(event_definition.pk),+ "uploaded_media_id": str(media.pk),+ "exported_asset_id": str(uuid.uuid4()),+ },+ format="json",+ )++ assert response.status_code == status.HTTP_201_CREATED+ preview = ObjectMediaPreview.objects.get(id=response.json()["id"])+ assert preview.uploaded_media_id == media.pk+ assert preview.exported_asset_id is None++ @parameterized.expand(+ [+ ("own_export", "self", None, True),+ ("other_members_export", "other", None, False),+ ("event_screenshot", None, "session-1", True),+ ]+ )+ def test_exported_asset_media_url_follows_export_access(self, _name, created_by, session_recording_id, expects_url):+ event_definition = EventDefinition.objects.create(team=self.team, name="purchase")+ author = {+ "self": self.user,+ "other": User.objects.create_and_join(self.organization, "[email protected]", "password"),+ None: None,+ }[created_by]+ asset = ExportedAsset.objects.create(+ team=self.team,+ export_format="image/png",+ created_by=author,+ export_context={"session_recording_id": session_recording_id} if session_recording_id else None,+ )+ ObjectMediaPreview.objects.create(team=self.team, event_definition=event_definition, exported_asset=asset)++ list_response = self.client.get(+ f"/api/projects/{self.team.pk}/object_media_previews/?event_definition={event_definition.pk}"+ )+ preferred_response = self.client.get(+ f"/api/projects/{self.team.pk}/object_media_previews/preferred_for_event/?event_definition={event_definition.pk}"+ )++ assert list_response.status_code == status.HTTP_200_OK+ results = list_response.json()["results"]+ if expects_url:+ assert "token=" in results[0]["media_url"]+ assert preferred_response.json()["media_url"] == results[0]["media_url"]+ else:+ assert results == []+ assert preferred_response.status_code == status.HTTP_404_NOT_FOUND++ def test_preferred_for_event_skips_a_newer_export_the_viewer_may_not_read(self):+ event_definition = EventDefinition.objects.create(team=self.team, name="purchase")+ screenshot = ExportedAsset.objects.create(+ team=self.team, export_format="image/png", export_context={"session_recording_id": "session-1"}+ )+ visible = ObjectMediaPreview.objects.create(+ team=self.team, event_definition=event_definition, exported_asset=screenshot+ )+ other_member = User.objects.create_and_join(self.organization, "[email protected]", "password")+ hidden_asset = ExportedAsset.objects.create(team=self.team, export_format="text/csv", created_by=other_member)+ ObjectMediaPreview.objects.create(+ team=self.team, event_definition=event_definition, exported_asset=hidden_asset+ )++ response = self.client.get(+ f"/api/projects/{self.team.pk}/object_media_previews/preferred_for_event/?event_definition={event_definition.pk}"+ )++ assert response.status_code == status.HTTP_200_OK+ assert response.json()["id"] == str(visible.id)++ @parameterized.expand(+ [+ ("object_media_previews", "/api/projects/{team}/object_media_previews/?event_definition={event}"),+ ("event_definitions", "/api/projects/{team}/event_definitions/"),+ ]+ )+ def test_screenshot_access_checks_stay_bounded_to_the_project(self, _name, path):+ event_definition = EventDefinition.objects.create(team=self.team, name="purchase")+ other_team = Team.objects.create(organization=self.organization, name="Other project")++ def add_screenshot(team: Team, session_id: str, event: EventDefinition) -> None:+ SessionRecording.objects.create(team=team, session_id=session_id, distinct_id="user")+ asset = ExportedAsset.objects.create(+ team=team, export_format="image/png", export_context={"session_recording_id": session_id}+ )+ ObjectMediaPreview.objects.create(team=team, event_definition=event, exported_asset=asset)++ add_screenshot(other_team, "other-project-session", EventDefinition.objects.create(team=other_team, name="x"))++ def capture() -> list[str]:+ with CaptureQueriesContext(connection) as queries:+ response = self.client.get(path.format(team=self.team.pk, event=event_definition.pk))+ assert response.status_code == status.HTTP_200_OK+ return [query["sql"] for query in queries]++ add_screenshot(self.team, str(uuid.uuid4()), event_definition)+ capture()+ with_one = capture()+ for _ in range(3):+ add_screenshot(self.team, str(uuid.uuid4()), event_definition)+ with_four = capture()++ assert len(with_four) == len(with_one)+ assert not any("other-project-session" in sql for sql in with_four)+ assert not any('"posthog_exportedasset"."content"' in sql for sql in with_four)++ @parameterized.expand(+ [+ ("without_export_scope", ["event_definition:read"], 0),+ ("with_export_scope", ["event_definition:read", "export:read"], 1),+ ]+ )+ def test_scoped_key_needs_export_read_to_get_export_links(self, _name, scopes, expected_links):+ event_definition = EventDefinition.objects.create(team=self.team, name="purchase")+ asset = ExportedAsset.objects.create(team=self.team, export_format="text/csv", created_by=self.user)+ ObjectMediaPreview.objects.create(team=self.team, event_definition=event_definition, exported_asset=asset)+ key = generate_random_token_personal()+ PersonalAPIKey.objects.create(user=self.user, label="test", secure_value=hash_key_value(key), scopes=scopes)+ self.client.logout()++ response = self.client.get(+ f"/api/projects/{self.team.pk}/object_media_previews/?event_definition={event_definition.pk}",+ HTTP_AUTHORIZATION=f"Bearer {key}",+ )++ assert response.status_code == status.HTTP_200_OK+ assert len(response.json()["results"]) == expected_linksdiff --git a/products/exports/backend/api/exports.py b/products/exports/backend/api/exports.pyindex c7d1ccf1bf14..3862bbbd8553 100644--- a/products/exports/backend/api/exports.py+++ b/products/exports/backend/api/exports.py@@ -42,6 +42,7 @@ from products.access_control.backend.presentation.access_control import (AccessControlViewSetMixin,UserAccessControlSerializerMixin,)+from products.exports.backend.asset_access import can_user_view_exported_assetfrom products.exports.backend.facade.exporters import get_export_content_path, is_product_exportfrom products.exports.backend.models.exported_asset import (ExportedAsset,@@ -623,7 +624,6 @@ class ExportedAssetViewSet(def safely_get_object(self, queryset):instance = get_object_or_404(queryset, pk=self.kwargs["pk"])- export_context = instance.export_context or {}# The owning product authorizes these on its own endpoints, so this API only lists them and# redirects their content.@@ -633,49 +633,11 @@ class ExportedAssetViewSet():raise NotFound()- if not instance.is_session_recording_export and instance.created_by_id != self.request.user.id:- raise NotFound()-- if export_context.get("observation_id"):- # Media a product owns and authorizes on its own endpoint. This endpoint checks the recording,- # which is a weaker gate than the one the owner applies, and asset ids are guessable integers.+ if not can_user_view_exported_asset(+ instance, user_id=self.request.user.id, user_access_control=self.user_access_control+ ):raise NotFound()- session_recording_id = export_context.get("session_recording_id")-- # Both can be set on one asset, and the renderer prefers the insight, so checking only the- # first non-null one would let an accessible dashboard authorize an inaccessible insight.- for related in (instance.dashboard, instance.insight):- if related is not None and not self.user_access_control.check_access_level_for_object(- related, required_level="viewer"- ):- raise NotFound()-- if not session_recording_id:- return instance-- # Reached even when a dashboard or insight authorized above: an asset carrying both renders- # the recording too, so a viewable dashboard must not stand in for access to it.- from posthog.session_recordings.models.session_recording import SessionRecording-- recording = SessionRecording.objects.filter(team_id=instance.team_id, session_id=session_recording_id).first()- if recording is not None:- if not self.user_access_control.check_access_level_for_object(recording, required_level="viewer"):- raise NotFound()- elif instance.created_by_id != self.request.user.id:- # No SessionRecording row — cannot run object-level RBAC; still enforce the team's- # session_recording resource default for other users so detail/content are not fail-open.- # The creator is exempt from this fallback only, because _assert_may_export_session_recording- # ran the same check when they created the export, so retrieval must not be stricter than- # creation — otherwise a session_recording default below viewer 404s the very user who just- # took the screenshot, surfacing as an "Export complete!" toast followed by a blank error- # page. Explicit object-level denies (the branch above) still apply to the creator once a- # SessionRecording row exists.- if not self.user_access_control.check_access_level_for_resource(- "session_recording", required_level="viewer"- ):- raise NotFound()-return instance# TODO: This should be removed as it is only used by frontend exporter and can instead use the api/sharing.py endpointdiff --git a/products/exports/backend/asset_access.py b/products/exports/backend/asset_access.pynew file mode 100644index 000000000000..9fe8eefd043b--- /dev/null+++ b/products/exports/backend/asset_access.py@@ -0,0 +1,111 @@+from collections.abc import Iterable, Mapping+from typing import TYPE_CHECKING, cast++from django.db.models import Model++from products.exports.backend.models.exported_asset import ExportedAsset++if TYPE_CHECKING:+ from posthog.session_recordings.models.session_recording import SessionRecording++ from products.access_control.backend.facade.user_access_control import UserAccessControl+++def can_user_view_exported_asset(+ asset: ExportedAsset,+ *,+ user_id: int | None,+ user_access_control: "UserAccessControl",+ recordings: Mapping[tuple[int, str], "SessionRecording"] | None = None,+) -> bool:+ """Whether a user may read an asset's content. Product exports are not covered: their owner authorizes them.++ `recordings` maps (team_id, session_id) to the SessionRecording rows already loaded by the caller. When it is+ given, a session id missing from it means no row exists, and no query is made.+ """+ export_context = asset.export_context or {}++ if not asset.is_session_recording_export and asset.created_by_id != user_id:+ return False++ if export_context.get("observation_id"):+ # Media a product owns and authorizes on its own endpoint. This endpoint checks the recording,+ # which is a weaker gate than the one the owner applies, and asset ids are guessable integers.+ return False++ # Both can be set on one asset, and the renderer prefers the insight, so checking only the+ # first non-null one would let an accessible dashboard authorize an inaccessible insight.+ for related in (asset.dashboard, asset.insight):+ if related is not None and not user_access_control.check_access_level_for_object(+ related, required_level="viewer"+ ):+ return False++ session_recording_id = export_context.get("session_recording_id")+ if not session_recording_id:+ return True++ # Reached even when a dashboard or insight authorized above: an asset carrying both renders+ # the recording too, so a viewable dashboard must not stand in for access to it.+ if recordings is not None:+ recording = recordings.get((asset.team_id, session_recording_id))+ else:+ from posthog.session_recordings.models.session_recording import SessionRecording++ recording = SessionRecording.objects.filter(team_id=asset.team_id, session_id=session_recording_id).first()+ if recording is not None:+ return user_access_control.check_access_level_for_object(recording, required_level="viewer")+ if asset.created_by_id != user_id:+ # No SessionRecording row — cannot run object-level RBAC; still enforce the team's+ # session_recording resource default for other users so detail/content are not fail-open.+ # The creator is exempt from this fallback only, because _assert_may_export_session_recording+ # ran the same check when they created the export, so retrieval must not be stricter than+ # creation — otherwise a session_recording default below viewer 404s the very user who just+ # took the screenshot, surfacing as an "Export complete!" toast followed by a blank error+ # page. Explicit object-level denies (the branch above) still apply to the creator once a+ # SessionRecording row exists.+ return user_access_control.check_access_level_for_resource("session_recording", required_level="viewer")+ return True+++def viewable_assets(+ assets: Iterable[ExportedAsset], *, user_id: int | None, user_access_control: "UserAccessControl"+) -> set[int]:+ """Ids of the assets a user may read, under the rules of can_user_view_exported_asset.++ Use this instead of calling can_user_view_exported_asset in a loop: it loads the session recordings and their+ access controls once for all assets, so the cost does not grow with the number of assets. Product exports are+ never included, because their owning product authorizes them on its own endpoints.+ """+ from posthog.session_recordings.models.session_recording import SessionRecording++ from products.exports.backend.facade.exporters import is_product_export++ candidates = [+ asset for asset in assets if not is_product_export(export_format=asset.export_format, kind=asset.export_kind)+ ]++ wanted: set[tuple[int, str]] = set()+ for asset in candidates:+ session_id = (asset.export_context or {}).get("session_recording_id")+ if session_id:+ wanted.add((asset.team_id, session_id))++ recordings: dict[tuple[int, str], SessionRecording] = {}+ if wanted:+ rows = list(+ SessionRecording.objects.filter(+ team_id__in={team_id for team_id, _ in wanted},+ session_id__in={session_id for _, session_id in wanted},+ )+ )+ user_access_control.preload_object_access_controls(cast(list[Model], rows))+ recordings = {(row.team_id, row.session_id): row for row in rows}++ return {+ asset.id+ for asset in candidates+ if can_user_view_exported_asset(+ asset, user_id=user_id, user_access_control=user_access_control, recordings=recordings+ )+ }diff --git a/products/exports/backend/facade/auth.py b/products/exports/backend/facade/auth.pyindex 07b1478379e8..2df3878d4102 100644--- a/products/exports/backend/facade/auth.py+++ b/products/exports/backend/facade/auth.py@@ -1,5 +1,12 @@+from collections.abc import Iterable+from typing import TYPE_CHECKING++from products.exports.backend.asset_access import viewable_assetsfrom products.exports.backend.models.exported_asset import ExportedAsset+if TYPE_CHECKING:+ from products.access_control.backend.facade.user_access_control import UserAccessControl+def get_export_renderer_asset_context(*, asset_id: int, team_id: int, created_by_id: int, scope: str@@ -18,3 +25,19 @@ def get_export_renderer_asset_context(if scope == "session_recording:read":return export_context if export_context.get("session_recording_id") else Nonereturn None+++def viewable_exported_asset_ids(+ asset_ids: Iterable[int], *, team_id: int, user_id: int, user_access_control: "UserAccessControl"+) -> set[int]:+ """The ids, among `asset_ids` in this team, of the exported assets the user may read.++ Uses the same rules as the exports API, with a fixed number of queries however many ids are given.+ Product exports are never included, because their owning product authorizes them on its own endpoints.+ """+ assets = (+ ExportedAsset.objects.filter(id__in=set(asset_ids), team_id=team_id)+ .select_related("dashboard", "insight")+ .defer("content")+ )+ return viewable_assets(assets, user_id=user_id, user_access_control=user_access_control)diff --git a/services/mcp/src/api/generated.ts b/services/mcp/src/api/generated.tsindex 2cffd37cb67c..b9da72fecdc6 100644--- a/services/mcp/src/api/generated.ts+++ b/services/mcp/src/api/generated.ts@@ -69057,15 +69057,20 @@ export namespace Schemas {readonly created_at: string;/** @nullable */readonly updated_at: string | null;+ /** URL of the preview image. For an exported asset this is a signed link that works without a session. */readonly media_url: string;- /** Return 'uploaded' or 'exported' based on which media is set */+ /** Where the image comes from: 'uploaded' for user-uploaded media, 'exported' for an exported asset. */readonly media_type: string;metadata?: unknown;- /** @nullable */+ /**+ * ID of uploaded media in this project to use as the preview. Required when creating a preview.+ * @nullable+ */uploaded_media_id?: string | null;- /** @nullable */- exported_asset_id?: string | null;- /** @nullable */+ /**+ * ID of the event definition the preview belongs to. Required when creating a preview.+ * @nullable+ */event_definition_id?: string | null;}@@ -85347,15 +85352,20 @@ export namespace Schemas {readonly created_at?: string;/** @nullable */readonly updated_at?: string | null;+ /** URL of the preview image. For an exported asset this is a signed link that works without a session. */readonly media_url?: string;- /** Return 'uploaded' or 'exported' based on which media is set */+ /** Where the image comes from: 'uploaded' for user-uploaded media, 'exported' for an exported asset. */readonly media_type?: string;metadata?: unknown;- /** @nullable */+ /**+ * ID of uploaded media in this project to use as the preview. Required when creating a preview.+ * @nullable+ */uploaded_media_id?: string | null;- /** @nullable */- exported_asset_id?: string | null;- /** @nullable */+ /**+ * ID of the event definition the preview belongs to. Required when creating a preview.+ * @nullable+ */event_definition_id?: string | null;}@@ -132972,6 +132982,10 @@ export namespace Schemas {};export type ObjectMediaPreviewsListParams = {+ /**+ * ID of the event definition whose previews to list.+ */+ event_definition: string;/*** Number of results to return per page.*/