package store import ( "context" "errors" "fmt" "testing" ) func localityBackendStore(t *testing.T, b storeSQLBackend) (*Store, string) { t.Helper() s, domain := accountBackendStore(t, b) if err := s.ensureLocalityAccessSchema(); err != nil { t.Fatal(err) } if b == storeSQLite { tx, err := s.DB.Begin() if err != nil { t.Fatal(err) } defer tx.Rollback() if err = installLocalityAccessGuards(context.Background(), tx); err != nil { t.Fatal(err) } if err = tx.Commit(); err != nil { t.Fatal(err) } } return s, domain } func TestLocalityBackendPolicy(t *testing.T) { for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} { t.Run(fmt.Sprint(b), func(t *testing.T) { s, d := localityBackendStore(t, b) exec := func(q string, args ...any) { t.Helper() if _, err := s.DB.Exec(q, args...); err != nil { t.Fatal(err) } } owner, err := s.BootstrapOwner(d, "owner", "synthetic password for locality tests", "Owner", "") if err != nil { t.Fatal(err) } reader, err := s.CreatePasswordAccount(d, "reader", "synthetic password for locality tests", "Reader", "") if err != nil { t.Fatal(err) } var member string if err = s.DB.QueryRow(`SELECT uuid FROM domain_memberships WHERE principal_uuid=`+s.sqlParam(1), reader.UUID).Scan(&member); err != nil { t.Fatal(err) } if err = s.SetConfigInDomain(d, "authorization_mode", "enforcing"); err != nil { t.Fatal(err) } for _, p := range []struct{ id, path string }{{"outer", "/private_%"}, {"inner", "/private_%/深い"}} { exec(`INSERT INTO locality_access_policies VALUES(`+s.sqlValues(7)+`)`, d, "spot", p.id, p.path, 1, owner.UUID, 3) } exec(`INSERT INTO locality_access_entries VALUES(`+s.sqlValues(7)+`)`, d, "spot", "outer", "user", member, "reader", "read_write") check := func(principal, path, cap string, want bool) { t.Helper() err := s.Authorize(AuthorizationRequest{DomainUUID: d, PrincipalUUID: principal, Capability: cap, TargetType: "path", TargetID: path}) if (err == nil) != want || err != nil && !errors.Is(err, ErrAccessDenied) { t.Fatalf("%s %s %s: %v want=%v", principal, path, cap, err, want) } } check(reader.UUID, "/private_%/file", "read", true) check(reader.UUID, "/private_%/file", "write", true) check(reader.UUID, "/private_%/深い/file", "read", false) check(reader.UUID, "/privateXX/深い/file", "read", true) check(reader.UUID, "/private_%2/file", "read", true) check(reader.UUID, "/PRIVATE_%/深い/file", "read", true) check("anonymous", "/private_%/file", "read", false) check(owner.UUID, "/private_%/深い/file", "read", true) check(reader.UUID, "/private_%/file", "delete", false) policy, err := s.LoadReadPathPolicy(d, reader.UUID) if err != nil { t.Fatal(err) } if !policy.Allows("/private_%/file") || policy.Allows("/private_%/深い/file") { t.Fatal("navigation policy differs from authorization") } // Remove the positive domain role: a matching explicit locality grant // can still provide read/write, but cannot provide delete. exec(`DELETE FROM auth_role_bindings WHERE membership_uuid=`+s.sqlParam(1), member) check(reader.UUID, "/elsewhere", "read", false) check(reader.UUID, "/private_%/file", "read", true) if err = s.SetPrincipalState(d, reader.UUID, "readonly"); err != nil { t.Fatal(err) } check(reader.UUID, "/private_%/file", "read", true) check(reader.UUID, "/private_%/file", "write", false) if err = s.SetPrincipalState(d, reader.UUID, "suspended"); err != nil { t.Fatal(err) } check(reader.UUID, "/private_%/file", "read", false) if err = s.SetPrincipalState(d, reader.UUID, "active"); err != nil { t.Fatal(err) } exec(`DELETE FROM locality_access_entries WHERE domain_uuid=`+s.sqlParam(1), d) fresh, err := s.LoadReadPathPolicy(d, reader.UUID) if err != nil || fresh.Allows("/private_%/file") || !policy.Allows("/private_%/file") { t.Fatal("request snapshot revocation", err) } ctx, cancel := context.WithCancel(context.Background()) cancel() if _, err = s.LoadReadPathPolicyContext(ctx, d, reader.UUID); !errors.Is(err, context.Canceled) { t.Fatal("cancellation lost", err) } group, err := s.CreateGroup(d, owner.UUID, "readers", "Readers", "", "members") if err != nil { t.Fatal(err) } if err = s.AddGroupMemberByUsername(d, group.UUID, "reader", "member"); err != nil { t.Fatal(err) } exec(`INSERT INTO locality_access_entries VALUES(`+s.sqlValues(7)+`)`, d, "spot", "outer", "group", group.UUID, "readers", "read") check(reader.UUID, "/private_%/file", "read", true) check(reader.UUID, "/private_%/file", "write", false) exec(`UPDATE groups SET state='archived' WHERE uuid=`+s.sqlParam(1), group.UUID) check(reader.UUID, "/private_%/file", "read", false) exec(`ALTER TABLE locality_access_entries RENAME COLUMN permission TO missing_permission`) if _, err = s.LoadReadPathPolicy(d, reader.UUID); err == nil { t.Fatal("incomplete policy accepted") } }) } } func TestLocalityBackendNamespaceGuards(t *testing.T) { for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} { t.Run(fmt.Sprint(b), func(t *testing.T) { s, d := localityBackendStore(t, b) exec := func(q string, args ...any) { t.Helper() if _, err := s.DB.Exec(q, args...); err != nil { t.Fatal(err) } } if err := s.SetConfigInDomain(d, "authorization_mode", "enforcing"); err != nil { t.Fatal(err) } for _, id := range []string{"protected", "free", "fresh", "foreign"} { exec(`INSERT INTO objects(uuid,kind,created_at) VALUES(`+s.sqlValues(3)+`)`, id, "page", 1) } path := func(domain, p, obj string) error { _, err := s.DB.Exec(`INSERT INTO paths(domain_uuid,path,object_uuid,created_at) VALUES(`+s.sqlValues(4)+`)`, domain, p, obj, 1) return err } if err := path(d, "/private_%/doc", "protected"); err != nil { t.Fatal(err) } if err := path(d, "/free/doc", "free"); err != nil { t.Fatal(err) } exec(`INSERT INTO locality_access_policies VALUES(`+s.sqlValues(7)+`)`, d, "spot", "scope", "/private_%", 1, "actor", 3) for _, value := range []string{"permissive", "disabled"} { if err := s.SetConfigInDomain(d, "authorization_mode", value); err == nil { t.Fatal("enforcement downgrade accepted") } } if _, err := s.DB.Exec(`DELETE FROM config WHERE domain_uuid=`+s.sqlParam(1)+` AND key='authorization_mode'`, d); err == nil { t.Fatal("enforcement deletion accepted") } if err := s.SetConfigInDomain(d, "unrelated", "retained"); err != nil { t.Fatal(err) } if err := path(d, "/alias", "protected"); err == nil { t.Fatal("protected alias escaped") } if err := path(d, "/private_%/alias", "free"); err == nil { t.Fatal("existing object entered protected scope") } if err := path(d, "/private_%/new", "fresh"); err != nil { t.Fatal("new protected object rejected", err) } if err := path(d, "/privateXX/alias", "free"); err != nil { t.Fatal("wildcard scope leak", err) } if _, err := s.DB.Exec(`UPDATE paths SET path='/escape' WHERE domain_uuid=`+s.sqlParam(1)+` AND path='/private_%/doc'`, d); err == nil { t.Fatal("protected rename accepted") } if _, err := s.DB.Exec(`UPDATE paths SET object_uuid='free' WHERE domain_uuid=`+s.sqlParam(1)+` AND path='/private_%/doc'`, d); err == nil { t.Fatal("protected retarget accepted") } if _, err := s.DB.Exec(`DELETE FROM paths WHERE domain_uuid=`+s.sqlParam(1)+` AND path='/private_%/doc'`, d); err == nil { t.Fatal("protected delete accepted") } exec(`UPDATE paths SET path=path WHERE object_uuid='protected'`) // Foreign-domain restrictions precede even local administrator bypass. if err := path("outside", "/日本語/a", "foreign"); err != nil { t.Fatal(err) } exec(`INSERT INTO locality_access_policies VALUES(`+s.sqlValues(7)+`)`, "outside", "spot", "foreign-scope", "/日本語", 1, "actor", 3) if err := s.CheckObjectLocalityAccessCaps(d, "actor", "read", "foreign"); !errors.Is(err, ErrAccessDenied) { t.Fatal("foreign restriction bypass", err) } if err := s.CheckObjectLocalityAccessCaps(d, "actor", "read", "free"); err != nil { t.Fatal("unrelated object blocked", err) } if b == storePostgreSQL { if err := s.ensurePostgreSQLLocalityFoundation(context.Background()); err != nil { t.Fatal(err) } exec(`ALTER TABLE paths DISABLE TRIGGER locality_access_path_guard`) if err := s.ensurePostgreSQLLocalityFoundation(context.Background()); err == nil { t.Fatal("disabled protection silently accepted") } } }) } }