Skip to content

Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.

fix(test-impact): accept the owner-only DACL as Windows stores it

Martin Vogel4f709c270776
diff --git a/src/mcp/test_impact_tree_windows_acl.c b/src/mcp/test_impact_tree_windows_acl.c
index 93aa1725c..833f6f0d1 100644
--- a/src/mcp/test_impact_tree_windows_acl.c
+++ b/src/mcp/test_impact_tree_windows_acl.c
@@ -59,6 +59,33 @@ bool tpt_win_security(tpt_context *c) {
return true;
}
+/* One DACL entry of the owner-only policy: an allow entry for the current
+ * user with full access and no flag but inheritance; 1 yes, 0 no, -1 broken. */
+static int tpt_owner_ace(PACL dacl, DWORD index, PSID sid, bool *effective) {
+ void *raw = NULL;
+ if (!GetAce(dacl, index, &raw))
+ return -1;
+ ACCESS_ALLOWED_ACE *ace = raw;
+ if (ace->Header.AceType != ACCESS_ALLOWED_ACE_TYPE)
+ return 0;
+ size_t prefix = offsetof(ACCESS_ALLOWED_ACE, SidStart);
+ if (ace->Header.AceSize < prefix + 8)
+ return -1;
+ BYTE inherit = OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE;
+ if ((ace->Header.AceFlags & ~inherit) ||
+ (ace->Mask != FILE_ALL_ACCESS && ace->Mask != GENERIC_ALL))
+ return 0;
+ const SID *principal = (const SID *)&ace->SidStart;
+ size_t sid_size = 8 + (size_t)principal->SubAuthorityCount * sizeof(DWORD);
+ if (sid_size > ace->Header.AceSize - prefix || !IsValidSid(&ace->SidStart))
+ return -1;
+ if (!EqualSid(&ace->SidStart, sid))
+ return 0;
+ if (!(ace->Header.AceFlags & INHERIT_ONLY_ACE))
+ *effective = true;
+ return 1;
+}
+
static int tpt_owner_acl(cbm_pinned_tree_t *t, PSECURITY_DESCRIPTOR sd) {
PSID owner = NULL;
PACL dacl = NULL;
@@ -80,25 +107,19 @@ static int tpt_owner_acl(cbm_pinned_tree_t *t, PSECURITY_DESCRIPTOR sd) {
ACL_SIZE_INFORMATION info;
if (!GetAclInformation(dacl, &info, sizeof(info), AclSizeInformation))
return -1;
- if (info.AceCount != 1)
- return 0;
- void *raw = NULL;
- if (!GetAce(dacl, 0, &raw))
- return -1;
- ACCESS_ALLOWED_ACE *ace = raw;
- if (ace->Header.AceType != ACCESS_ALLOWED_ACE_TYPE)
- return 0;
- size_t prefix = offsetof(ACCESS_ALLOWED_ACE, SidStart);
- if (ace->Header.AceSize < prefix + 8)
- return -1;
- if ((ace->Header.AceFlags & ~(OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE)) ||
- (ace->Mask != FILE_ALL_ACCESS && ace->Mask != GENERIC_ALL))
+ /* Windows stores one inheritable full-access grant either as a single
+ * OI|CI entry or, when it was written with generic rights (cbm_mkdir_p's
+ * owner stamp), as an effective entry plus an inherit-only one. Both are
+ * the owner-only policy; at least one entry must apply to the object. */
+ if (info.AceCount < 1 || info.AceCount > 2)
return 0;
- const SID *principal = (const SID *)&ace->SidStart;
- size_t sid_size = 8 + (size_t)principal->SubAuthorityCount * sizeof(DWORD);
- if (sid_size > ace->Header.AceSize - prefix || !IsValidSid(&ace->SidStart))
- return -1;
- return EqualSid(&ace->SidStart, sid) ? 1 : 0;
+ bool effective = false;
+ for (DWORD i = 0; i < info.AceCount; i++) {
+ int allowed = tpt_owner_ace(dacl, i, sid, &effective);
+ if (allowed != 1)
+ return allowed;
+ }
+ return effective ? 1 : 0;
}
bool tpt_native_acl(tpt_context *c, tpt_object *o, unsigned mode, bool changed) {
diff --git a/tests/test_test_impact_tree.c b/tests/test_test_impact_tree.c
index 2a77026b6..8e8e62e25 100644
--- a/tests/test_test_impact_tree.c
+++ b/tests/test_test_impact_tree.c
@@ -223,6 +223,31 @@ static bool pt_windows_acl(pt_fixture *fx, const char *path, bool extra) {
&descriptor);
}
+/* The encoding Windows stores for an inheritable generic grant: an effective
+ * full-access entry for the owner plus an inherit-only one, here naming
+ * `inherited` (the owner, or another principal for the negative). */
+static bool pt_windows_split_acl(pt_fixture *fx, const char *path, PSID inherited) {
+ PSID owner = pt_current_sid(fx);
+ wchar_t wide[PT_PATH];
+ unsigned char acl_bytes[1024];
+ ACL *acl = (ACL *)acl_bytes;
+ SECURITY_DESCRIPTOR descriptor;
+ return owner && inherited && pt_wide(path, wide) &&
+ InitializeAcl(acl, sizeof(acl_bytes), ACL_REVISION) &&
+ AddAccessAllowedAceEx(acl, ACL_REVISION, 0, FILE_ALL_ACCESS, owner) &&
+ AddAccessAllowedAceEx(acl, ACL_REVISION,
+ OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE,
+ FILE_ALL_ACCESS, inherited) &&
+ InitializeSecurityDescriptor(&descriptor, SECURITY_DESCRIPTOR_REVISION) &&
+ SetSecurityDescriptorOwner(&descriptor, owner, FALSE) &&
+ SetSecurityDescriptorDacl(&descriptor, TRUE, acl, FALSE) &&
+ SetSecurityDescriptorControl(&descriptor, SE_DACL_PROTECTED, SE_DACL_PROTECTED) &&
+ SetFileSecurityW(wide,
+ OWNER_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION |
+ PROTECTED_DACL_SECURITY_INFORMATION,
+ &descriptor);
+}
+
static bool pt_owner_is_current(PSID owner) {
HANDLE token = NULL;
union {
@@ -1771,6 +1796,45 @@ done:
return pt_finish(&fx, result);
}
+/* The work parent production makes is owner-only: cbm_mkdir_p stamps a fresh
+ * directory with one inheritable grant for the owner, which Windows stores as
+ * an effective entry plus an inherit-only one. The policy refused that form,
+ * so the engine on Windows ran everything (pinning HEAD failed). The same
+ * split naming another principal is still refused. */
+TEST(tree_e_windows_split_owner_dacl_is_owner_only) {
+#ifndef _WIN32
+ SKIP_PLATFORM("Win32 DACL encoding");
+#else
+ pt_fixture fx = {0};
+ int result = 1;
+ char stamped[PT_PATH] = {0};
+ unsigned char world[SECURITY_MAX_SID_SIZE];
+ DWORD world_length = sizeof(world);
+ PT_CHECK(pt_setup_step("setup:init", pt_init(&fx, 40)) &&
+ pt_setup_step("setup:populate", pt_populate(&fx)) &&
+ pt_setup_step("setup:facts", pt_open_facts(&fx)) &&
+ pt_setup_step("setup:control", pt_fact_control(&fx)));
+ PT_CHECK(pt_join(stamped, fx.home, "stamped-parent") && cbm_mkdir_p(stamped, 0700));
+ cbm_pinned_tree_options_t options = pt_options(&fx, CBM_GIT_REV_HEAD);
+ options.private_parent = stamped;
+ cbm_pinned_tree_error_t error;
+ PT_CHECK(cbm_pinned_tree_create(&options, &fx.tree, &error) == CBM_PINNED_TREE_OK);
+ PT_CHECK(pt_close_one(&fx.tree));
+ PT_CHECK(pt_windows_split_acl(&fx, stamped, pt_current_sid(&fx)));
+ PT_CHECK(cbm_pinned_tree_create(&options, &fx.tree, &error) == CBM_PINNED_TREE_OK);
+ PT_CHECK(pt_close_one(&fx.tree));
+ PT_CHECK(CreateWellKnownSid(WinWorldSid, NULL, world, &world_length));
+ PT_CHECK(pt_windows_split_acl(&fx, stamped, world));
+ PT_CHECK(cbm_pinned_tree_create(&options, &fx.tree, &error) == CBM_PINNED_TREE_UNSUPPORTED &&
+ !fx.tree);
+ result = 0;
+done:
+ if (stamped[0] && !pt_windows_split_acl(&fx, stamped, pt_current_sid(&fx)))
+ result = 1;
+ return pt_finish(&fx, result);
+#endif
+}
+
typedef struct {
size_t calls, stop;
} pt_cancel;
@@ -2536,6 +2600,7 @@ SUITE(test_impact_tree) {
RUN_TEST(tree_c_complete_inventory_and_native_names);
RUN_TEST(tree_d_native_collision_and_exact_spelling);
RUN_TEST(tree_e_native_permissions_and_acl_policy);
+ RUN_TEST(tree_e_windows_split_owner_dacl_is_owner_only);
RUN_TEST(tree_f_resource_limits_and_local_control);
RUN_TEST(tree_g_verify_state_and_complete_inventory);
RUN_TEST(tree_h_cleanup_owner_and_unrelated_resources);