Skip to content

: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.

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.py
index c1ac17299eab..eadfe43f29ba 100644
--- a/ee/api/ee_event_definition.py
+++ b/ee/api/ee_event_definition.py
@@ -6,6 +6,7 @@ import posthoganalytics
from drf_spectacular.extensions import OpenApiSerializerExtension
from rest_framework import serializers
+from posthog.api.object_media_preview import visible_previews, with_preview_media
from posthog.api.shared import UserBasicSerializer
from posthog.api.tagged_item import TaggedItemSerializerMixin
from posthog.event_usage import groups
@@ -247,9 +248,7 @@ class EnterpriseEventDefinitionSerializer(TaggedItemSerializerMixin, serializers
if 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.py
index 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_user
from posthog.models import ActivityLog, ObjectMediaPreview, Tag, Team, UploadedMedia, User
from products.event_definitions.backend.models.event_definition import EventDefinition
+from products.exports.backend.models.exported_asset import ExportedAsset
from ee.models.event_definition import EnterpriseEventDefinition
from ee.models.license import License, LicenseManager
@@ -905,6 +906,33 @@ class TestEventDefinitionEnterpriseAPI(APIBaseTest):
assert len(event_data["media_preview_urls"]) == 1
assert "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.tsx
index 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 editDefinition
const { 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) && (
<ImageCarousel
loading={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.py
index 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 EventDefinitionGenerato
from posthog.api.event_definition_generators.golang import GolangGenerator
from posthog.api.event_definition_generators.python import PythonGenerator
from posthog.api.event_definition_generators.typescript import TypeScriptGenerator
+from posthog.api.object_media_preview import visible_previews, with_preview_media
from posthog.api.pagination import CappedCountLimitOffsetPagination
from posthog.api.routing import TeamAndOrgViewSetMixin
from 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.py
index 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_schema
from rest_framework import serializers, status, viewsets
from rest_framework.decorators import action
from rest_framework.exceptions import ValidationError
@@ -7,18 +14,84 @@ from rest_framework.response import Response
from posthog.api.routing import TeamAndOrgViewSetMixin
from 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_lacks
from posthog.taxonomy.scout_writes import refuse_scout_taxonomy_write
from 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 parsed
class 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.py
index 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 CaptureQueriesContext
from django.utils import timezone
+from parameterized import parameterized
from 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 SessionRecording
from products.event_definitions.backend.models import EventDefinition
+from products.exports.backend.models.exported_asset import ExportedAsset
class TestObjectMediaPreviewAPI(APIBaseTest):
@@ -42,3 +51,143 @@ class TestObjectMediaPreviewAPI(APIBaseTest):
# Tied rows need a total order, or a page boundary can skip or repeat a preview
assert 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_links
diff --git a/products/exports/backend/api/exports.py b/products/exports/backend/api/exports.py
index 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_asset
from products.exports.backend.facade.exporters import get_export_content_path, is_product_export
from 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 endpoint
diff --git a/products/exports/backend/asset_access.py b/products/exports/backend/asset_access.py
new file mode 100644
index 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.py
index 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_assets
from 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 None
return 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.ts
index 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.
*/