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(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.py
index 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] = None
for 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's
resource, 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 None
row = 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_access
return 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_access
return 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.py
index 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_source
assert 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.py
index 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 differently
from 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.py
index 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_level
def oracle_most_specific_object_access(