: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(access-control): gate object defaults on resource access (#126244)
Alex Lider99d188dabf48
diff --git a/products/access_control/backend/facade/user_access_control.py b/products/access_control/backend/facade/user_access_control.pyindex 3ad32307a83c..afd7952f86d6 100644--- a/products/access_control/backend/facade/user_access_control.py+++ b/products/access_control/backend/facade/user_access_control.py@@ -1383,12 +1383,15 @@ class UserAccessControl:blocked_resource_ids: set[str] = set()allowed_resource_ids: set[str] = set()+ resource_access = (+ self._most_specific_access_without_object_rules(resource, None)+ if rows_by_object_id and self._is_most_specific_access_control_enabled+ else None+ )for resource_id, rows in rows_by_object_id.items():if self._is_most_specific_access_control_enabled:- # The object has rows, so the resolver decides at the object rung and never- # falls back to the resource.- access = self._most_specific_object_access_from_rows(resource, rows)+ access = self._most_specific_object_access_from_rows(resource, rows, resource_access=resource_access)if access.access_level == NO_ACCESS_LEVEL:blocked_resource_ids.add(resource_id)else:@@ -1935,6 +1938,7 @@ class UserAccessControl:results: dict[str, Optional[AccessControlLevel]] = {}rows_by_object_id: Optional[dict[str, list[_AccessControl]]] = None+ resource_access: Optional[ResolvedAccess] = Nonefor object_id, created_by_id in objects:resolved, access = self._object_access_level_precheck(resource, self._is_creator_id(created_by_id))@@ -1946,10 +1950,14 @@ class UserAccessControl:rows_by_object_id = defaultdict(list)for ac in self._get_access_controls(self._access_controls_filters_for_queryset(resource)):rows_by_object_id[ac.resource_id].append(ac)+ if self._is_most_specific_access_control_enabled:+ resource_access = self._most_specific_access_without_object_rules(resource, None)object_rows = rows_by_object_id.get(object_id, [])if self._is_most_specific_access_control_enabled:- access = self._most_specific_object_access_from_rows(resource, object_rows)+ access = self._most_specific_object_access_from_rows(+ resource, object_rows, resource_access=resource_access+ )else:access = self._object_access_level_from_rows(resource, object_rows)access = self._apply_dashboard_edit_limit(@@ -1983,7 +1991,8 @@ class UserAccessControl:# - When the resource is in RESOURCE_FALLBACK_MAP (e.g. `warehouse_table` -># `external_data_source`), access resolves as: rules on the object -> its parent -># the resource -> the parent's resource.- # The first rule found in this order decides, even when it gives a lower level.+ # Object defaults apply only to subjects with resource access. Explicit object member/role+ # rules can still share with subjects whose resolved resource access is none.# The legacy methods resolve differently: they take the highest level across the# member and role overrides, and rules on the resource win over the object's own default.#@@ -2058,22 +2067,49 @@ class UserAccessControl:rows = self._get_access_controls(self._access_controls_filters_for_resource(resource))return self._most_specific_resource_access_from_rows(resource, rows)+ def _most_specific_access_without_object_rules(+ self, resource: APIScopeObject, parent: Optional[APIScopeObject]+ ) -> ResolvedAccess:+ if self.has_access_levels_for_resource(resource):+ access_for_resource = self.resolve_most_specific_resource_access(resource)+ if access_for_resource:+ return access_for_resource++ if parent and self.has_access_levels_for_resource(parent):+ access_for_parent = self.resolve_most_specific_resource_access(parent)+ if access_for_parent:+ return replace(access_for_parent, source="parent_resource")++ return ResolvedAccess(+ access_level=default_access_level(resource),+ source="system_default",+ source_subject=None,+ source_resource=RESOURCE_INHERITANCE_MAP.get(resource, resource),+ )+def _most_specific_object_access_from_rows(self,resource: APIScopeObject,object_rows: list[_AccessControl],fallback_parent_id: Optional[str] = None,+ *,+ resource_access: Optional[ResolvedAccess] = None,) -> ResolvedAccess:"""Resolve access to one object from its rows, which are already in memory.Scope order: the object's rows, the fallback parent's rows, the resource, the parent'sresource, the system default. The parent's rows are fetched only when- `fallback_parent_id` is given.+ `fallback_parent_id` is given. A default grant on either object scope cannot override+ resolved resource-level no access; sharing with a member or role can."""parent = RESOURCE_FALLBACK_MAP.get(resource) if fallback_parent_id else Nonerow = self._most_specific_rows_decision(resource, object_rows)if row:+ if self._row_subject(row) == "default" and row.access_level != NO_ACCESS_LEVEL:+ resource_access = resource_access or self._most_specific_access_without_object_rules(resource, parent)+ if resource_access.access_level == NO_ACCESS_LEVEL:+ return resource_accessreturn ResolvedAccess(access_level=row.access_level,source="object",@@ -2088,6 +2124,12 @@ class UserAccessControl:)parent_row = self._most_specific_rows_decision(parent, parent_rows)if parent_row:+ if self._row_subject(parent_row) == "default" and parent_row.access_level != NO_ACCESS_LEVEL:+ resource_access = resource_access or self._most_specific_access_without_object_rules(+ resource, parent+ )+ if resource_access.access_level == NO_ACCESS_LEVEL:+ return resource_accessreturn ResolvedAccess(access_level=parent_row.access_level,source="parent_object",@@ -2096,22 +2138,7 @@ class UserAccessControl:source_resource_id=parent_row.resource_id,)- if self.has_access_levels_for_resource(resource):- access_for_resource = self.resolve_most_specific_resource_access(resource)- if access_for_resource:- return access_for_resource-- if parent and self.has_access_levels_for_resource(parent):- access_for_parent = self.resolve_most_specific_resource_access(parent)- if access_for_parent:- return replace(access_for_parent, source="parent_resource")-- return ResolvedAccess(- access_level=default_access_level(resource),- source="system_default",- source_subject=None,- source_resource=RESOURCE_INHERITANCE_MAP.get(resource, resource),- )+ return resource_access or self._most_specific_access_without_object_rules(resource, parent)def _most_specific_resource_access_from_rows(self, resource: APIScopeObject, rows: list[_AccessControl]diff --git a/products/access_control/backend/tests/test_most_specific_resolution.py b/products/access_control/backend/tests/test_most_specific_resolution.pyindex d4fbc801dd3d..41aca2ccc0e9 100644--- a/products/access_control/backend/tests/test_most_specific_resolution.py+++ b/products/access_control/backend/tests/test_most_specific_resolution.py@@ -53,7 +53,13 @@ class TestResolveObjectAccess(BaseMostSpecificResolutionTest):# Within the object scope, the member's own row decides even when it grants less("member_deny_beats_role_grant", {"member": "none", "role_a": "editor"}, "none", "object", "member"),("member_grant_beats_role_deny", {"member": "editor", "role_a": "none"}, "editor", "object", "member"),- # The object's own default row is more specific than any resource-wide rule+ (+ "resource_member_grant_beats_role_deny_for_object_default",+ {"resource_member": "viewer", "resource_role_a": "none", "object_default": "manager"},+ "manager",+ "object",+ "default",+ ),("object_default_deny_beats_resource_grant",{"object_default": "none", "resource_default": "editor"},@@ -62,10 +68,10 @@ class TestResolveObjectAccess(BaseMostSpecificResolutionTest):"default",),(- "object_default_grant_beats_resource_deny",+ "resource_deny_gates_object_default_grant",{"object_default": "editor", "resource_default": "none"},- "editor",- "object",+ "none",+ "resource","default",),]@@ -80,6 +86,42 @@ class TestResolveObjectAccess(BaseMostSpecificResolutionTest):assert resolved.source == expected_sourceassert resolved.source_subject == expected_subject+ @parameterized.expand(+ [+ (resource_subject, resource_level, object_level, sharing)+ for resource_subject in ("resource_member", "resource_role_a", "resource_default")+ for resource_level, object_level, sharing in (+ ("none", "viewer", None),+ ("none", "manager", None),+ ("viewer", "editor", None),+ ("viewer", "manager", None),+ ("editor", "viewer", None),+ ("viewer", "none", None),+ ("none", "manager", "member"),+ ("none", "manager", "role_a"),+ )+ ]+ )+ def test_resource_gate_preserves_explicit_sharing(+ self, resource_subject: str, resource_level: str, object_level: str, sharing: str | None+ ) -> None:+ self.organization.uses_most_specific_access_resolution = True+ self.organization.save()+ rules = {resource_subject: resource_level, "object_default": object_level}+ if sharing:+ rules[sharing] = "viewer"+ self._apply(rules)+ expected = "viewer" if sharing else "none" if resource_level == "none" else object_level+ uac = self.user_access_control++ assert uac.get_user_access_level(self.dashboard) == expected+ assert uac.bulk_object_access_levels("dashboard", [(str(self.dashboard.id), self.dashboard.created_by_id)]) == {+ str(self.dashboard.id): expected+ }+ assert uac.filter_queryset_by_access_level(Dashboard.objects.filter(pk=self.dashboard.pk)).exists() == (+ expected != "none"+ )+def test_no_entitlement_resolves_to_system_default(self):self._apply({"member": "none"})self.organization.available_product_features = []@@ -113,6 +155,24 @@ class TestResolveObjectAccessFallbackParent(BaseMostSpecificResolutionTest):[# A rule about the source reaches the tables it syncs("source_deny_reaches_the_table", {"this_source": "none"}, "none", "parent_object"),+ (+ "table_default_respects_resource_deny",+ {"this_table_default": "editor", "resource_member": "none"},+ "none",+ "resource",+ ),+ (+ "source_default_respects_resource_deny",+ {"this_source": "editor", "resource_member": "none"},+ "none",+ "resource",+ ),+ (+ "source_member_grant_overrides_resource_deny",+ {"this_source_member": "viewer", "resource_member": "none"},+ "viewer",+ "parent_object",+ ),# The table's own default row is nearer than the source, so it wins — under the# enforced ladder the source's row would win here(@@ -134,6 +194,8 @@ class TestResolveObjectAccessFallbackParent(BaseMostSpecificResolutionTest):"this_table_member": ("warehouse_table", str(self.table.id), self.membership),"this_table_default": ("warehouse_table", str(self.table.id), None),"this_source": ("external_data_source", str(self.source.id), None),+ "this_source_member": ("external_data_source", str(self.source.id), self.membership),+ "resource_member": ("warehouse_objects", None, self.membership),}for target, level in rules.items():resource, resource_id, member = targets[target]diff --git a/products/access_control/backend/tests/test_resolution_preview.py b/products/access_control/backend/tests/test_resolution_preview.pyindex 01f734fda811..8891885f90f9 100644--- a/products/access_control/backend/tests/test_resolution_preview.py+++ b/products/access_control/backend/tests/test_resolution_preview.py@@ -106,7 +106,8 @@ class TestBuildResolutionPreview(BaseUserAccessControlTest):assert [(change.subject.type, change.object_id) for change in changes] == [("default", str(self.dashboard.id))]- def test_parent_resource_row_is_compared_against_child_objects(self):+ @parameterized.expand([("none", "none"), ("viewer", "editor")])+ def test_parent_resource_row_is_compared_against_child_objects(self, resource_level, proposed_level):# Resolution consults the parent resource (session_recording) for playlist objects, so# a member whose only rule sits there can still resolve a playlist differentlyfrom posthog.session_recordings.models.session_recording_playlist import SessionRecordingPlaylist@@ -116,16 +117,20 @@ class TestBuildResolutionPreview(BaseUserAccessControlTest):resource="session_recording_playlist", resource_id=str(playlist.id), access_level="editor")self._create_access_control(- resource="session_recording", access_level="none", organization_member=self.other_membership+ resource="session_recording", access_level=resource_level, organization_member=self.other_membership)changes = self._changes()member_changes = [change for change in changes if change.subject.type == "member"]- assert [(change.scope, change.object_id) for change in member_changes] == [("object", str(playlist.id))]- # Legacy: the member's parent-resource rule blocks the object. Most-specific: the object's- # own default row decides first, so the member's parent rule no longer reaches it.- assert (member_changes[0].current.access_level, member_changes[0].proposed.access_level) == ("none", "editor")+ if resource_level == "none":+ assert member_changes == []+ else:+ assert [(change.scope, change.object_id) for change in member_changes] == [("object", str(playlist.id))]+ assert (member_changes[0].current.access_level, member_changes[0].proposed.access_level) == (+ resource_level,+ proposed_level,+ )@parameterized.expand([diff --git a/products/access_control/backend/tests/test_user_access_control_pbt.py b/products/access_control/backend/tests/test_user_access_control_pbt.pyindex 2fec22fb1ee3..41e553f51a3a 100644--- a/products/access_control/backend/tests/test_user_access_control_pbt.py+++ b/products/access_control/backend/tests/test_user_access_control_pbt.py@@ -440,11 +440,14 @@ def _most_specific_tier(def oracle_most_specific_object_level(specs: list[RowSpec], order: list[AccessControlLevel]) -> Optional[AccessControlLevel]:- # Mirrors resolve_most_specific_object_access, restated from the rules rather than the code:- # the nearest scope with any rule decides (object rows before resource rows), and inside a- # scope the most specific subject decides: member -> max(roles) -> the everyone-row. A more- # specific rule wins even when it gives a lower level. None when no rule matches.- return _most_specific_tier(specs, "object", order) or _most_specific_tier(specs, "resource", order)+ explicit_object_rules = [s for s in specs if s.target != "team_default"]+ explicit_level = _most_specific_tier(explicit_object_rules, "object", order)+ if explicit_level is not None:+ return explicit_level+ resource_level = _most_specific_tier(specs, "resource", order)+ if resource_level == NO_ACCESS_LEVEL:+ return NO_ACCESS_LEVEL+ return _most_specific_tier(specs, "object", order) or resource_leveldef oracle_most_specific_object_access(