Files
pages/internal/store/locality_backend_test.go
T
2026-11-15 05:47:14 +09:00

214 lines
8.6 KiB
Go

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")
}
}
})
}
}