package store import ( "context" "database/sql" "encoding/json" "errors" "strings" "time" "pageswiki/internal/schutzaria" ) var ErrLocalityAccessEnforcing = errors.New("city.access.enforcing_error") var ErrLocalityAccessAlias = errors.New("city.access.alias_error") type LocalityAccessEntry struct { Kind string `json:"kind"` Name string `json:"name"` Permission string `json:"permission"` ID string `json:"id,omitempty"` } type LocalityAccess struct { AuthorityRank int `json:"authority_rank"` Epoch int64 `json:"epoch"` TopologyVersion int64 `json:"topology_version"` Mode string `json:"mode"` Entries []LocalityAccessEntry `json:"entries"` GrantsAccess bool `json:"grants_access"` ScopePath string `json:"scope_path"` } func (s *Store) ensureLocalityAccessSchema() error { for _, query := range []string{ `CREATE TABLE IF NOT EXISTS locality_access_policies(domain_uuid TEXT NOT NULL,node_kind TEXT NOT NULL,node_uuid TEXT NOT NULL,scope_path TEXT NOT NULL,grants_access INTEGER NOT NULL CHECK(grants_access IN (0,1)),actor_uuid TEXT NOT NULL,authority_rank INTEGER NOT NULL CHECK(authority_rank BETWEEN 1 AND 3),PRIMARY KEY(domain_uuid,node_kind,node_uuid))`, `CREATE INDEX IF NOT EXISTS idx_locality_access_scope ON locality_access_policies(domain_uuid,scope_path)`, `CREATE TABLE IF NOT EXISTS locality_access_entries(domain_uuid TEXT NOT NULL,node_kind TEXT NOT NULL,node_uuid TEXT NOT NULL,subject_kind TEXT NOT NULL CHECK(subject_kind IN ('user','group')),subject_uuid TEXT NOT NULL,subject_name TEXT NOT NULL,permission TEXT NOT NULL CHECK(permission IN ('read','read_write')),PRIMARY KEY(domain_uuid,node_kind,node_uuid,subject_kind,subject_uuid))`, } { if _, err := s.DB.Exec(query); err != nil { return err } } return nil } type localityAccessSnapshot = schutzaria.LocalityAccess func (s *Store) CheckLocalityAccessCaps(domain, principal, capability, path string) error { p, err := loadLocalityAccess(s.DB, domain, principal) if err != nil { return err } if !p.Decide(path, capability, true) { return ErrAccessDenied } return nil } func (s *Store) CheckObjectLocalityAccessCaps(domain, principal, capability, object string) error { // An exceptional foreign Object grant must not bypass the source Domain's // restricted audience. Cross-Domain delegation of these new ACLs is not // implemented. Check before the local administrator/empty-policy shortcut. var foreign bool if err := s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM locality_access_policies WHERE domain_uuid!=?)`, domain).Scan(&foreign); err != nil { return err } if foreign { if err := s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM paths p JOIN locality_access_policies a ON a.domain_uuid=p.domain_uuid WHERE p.object_uuid=? AND p.domain_uuid!=? AND `+cityPathScopeSQL("a.scope_path", "p.path")+`)`, object, domain).Scan(&foreign); err != nil { return err } if foreign { return ErrAccessDenied } } p, err := loadLocalityAccess(s.DB, domain, principal) if err != nil { return err } if !p.RequiresPathChecks() { return nil } rows, err := s.DB.Query(`SELECT path FROM paths WHERE domain_uuid=? AND object_uuid=? LIMIT 10001`, domain, object) if err != nil { return err } defer rows.Close() count := 0 for rows.Next() { count++ if count > 10000 { return ErrAccessDenied } var path string if err = rows.Scan(&path); err != nil { return err } if !p.Decide(path, capability, true) { return ErrAccessDenied } } return rows.Err() } // Until namespace impact/approval exists, protected bindings cannot be removed, // retargeted or aliased. New objects may still be created and inherit the ACL. // These SQLite guards cover CLI/import/background writers, not only HTTP. func installLocalityAccessGuards(ctx context.Context, tx *sql.Tx) error { scope := func(candidate string) string { return `EXISTS(SELECT 1 FROM locality_access_policies a WHERE a.domain_uuid=OLD.domain_uuid AND ` + cityPathScopeSQL("a.scope_path", candidate) + `)` } statements := []string{ `CREATE TRIGGER IF NOT EXISTS locality_access_config_update BEFORE UPDATE ON config WHEN OLD.key='authorization_mode' AND (NEW.key!=OLD.key OR NEW.domain_uuid!=OLD.domain_uuid OR NEW.value!='enforcing') AND EXISTS(SELECT 1 FROM locality_access_policies WHERE domain_uuid=OLD.domain_uuid) BEGIN SELECT RAISE(ABORT,'locality_access_requires_enforcing'); END`, `CREATE TRIGGER IF NOT EXISTS locality_access_config_delete BEFORE DELETE ON config WHEN OLD.key='authorization_mode' AND EXISTS(SELECT 1 FROM locality_access_policies WHERE domain_uuid=OLD.domain_uuid) BEGIN SELECT RAISE(ABORT,'locality_access_requires_enforcing'); END`, `CREATE TRIGGER IF NOT EXISTS locality_access_config_insert BEFORE INSERT ON config WHEN NEW.key='authorization_mode' AND NEW.value!='enforcing' AND EXISTS(SELECT 1 FROM locality_access_policies WHERE domain_uuid=NEW.domain_uuid) BEGIN SELECT RAISE(ABORT,'locality_access_requires_enforcing'); END`, `CREATE TRIGGER IF NOT EXISTS locality_access_path_delete BEFORE DELETE ON paths WHEN ` + scope("OLD.path") + ` BEGIN SELECT RAISE(ABORT,'locality_access_protected_namespace'); END`, `CREATE TRIGGER IF NOT EXISTS locality_access_path_update BEFORE UPDATE OF path,object_uuid,domain_uuid ON paths WHEN (OLD.path!=NEW.path OR OLD.object_uuid!=NEW.object_uuid OR OLD.domain_uuid!=NEW.domain_uuid) AND (` + scope("OLD.path") + ` OR EXISTS(SELECT 1 FROM locality_access_policies a WHERE a.domain_uuid=NEW.domain_uuid AND ` + cityPathScopeSQL("a.scope_path", "NEW.path") + `) OR EXISTS(SELECT 1 FROM paths p JOIN locality_access_policies a ON a.domain_uuid=p.domain_uuid WHERE p.object_uuid=NEW.object_uuid AND ` + cityPathScopeSQL("a.scope_path", "p.path") + `)) BEGIN SELECT RAISE(ABORT,'locality_access_protected_namespace'); END`, `CREATE TRIGGER IF NOT EXISTS locality_access_path_insert BEFORE INSERT ON paths WHEN (EXISTS(SELECT 1 FROM revisions WHERE object_uuid=NEW.object_uuid) OR EXISTS(SELECT 1 FROM paths WHERE object_uuid=NEW.object_uuid)) AND (EXISTS(SELECT 1 FROM locality_access_policies a WHERE a.domain_uuid=NEW.domain_uuid AND ` + cityPathScopeSQL("a.scope_path", "NEW.path") + `) OR EXISTS(SELECT 1 FROM paths p JOIN locality_access_policies a ON a.domain_uuid=p.domain_uuid WHERE p.object_uuid=NEW.object_uuid AND ` + cityPathScopeSQL("a.scope_path", "p.path") + `)) BEGIN SELECT RAISE(ABORT,'locality_access_protected_namespace'); END`, } for _, table := range []string{"zones", "spots"} { columns := "path_prefix,state" if table == "zones" { columns += ",parent_uuid" } statements = append(statements, `CREATE TRIGGER IF NOT EXISTS locality_access_`+table+`_structure BEFORE UPDATE OF `+columns+` ON `+table+` WHEN EXISTS(SELECT 1 FROM locality_access_policies WHERE domain_uuid=OLD.domain_uuid) BEGIN SELECT RAISE(ABORT,'locality_access_protected_namespace'); END`, `CREATE TRIGGER IF NOT EXISTS locality_access_`+table+`_delete BEFORE DELETE ON `+table+` WHEN EXISTS(SELECT 1 FROM locality_access_policies WHERE domain_uuid=OLD.domain_uuid) BEGIN SELECT RAISE(ABORT,'locality_access_protected_namespace'); END`) } for _, op := range []string{"INSERT", "DELETE", "UPDATE"} { ref := "OLD" if op == "INSERT" { ref = "NEW" } statements = append(statements, `CREATE TRIGGER IF NOT EXISTS locality_access_street_spots_`+strings.ToLower(op)+` BEFORE `+op+` ON street_spots WHEN EXISTS(SELECT 1 FROM spots s JOIN locality_access_policies a ON a.domain_uuid=s.domain_uuid WHERE s.uuid=`+ref+`.spot_uuid) BEGIN SELECT RAISE(ABORT,'locality_access_protected_namespace'); END`) } for _, query := range statements { if _, err := tx.ExecContext(ctx, query); err != nil { return err } } return nil } func loadLocalityAccess(q pathQueryer, domain, principal string) (*localityAccessSnapshot, error) { var layers []schutzaria.AccessLayer var admin bool rows, err := q.Query(`SELECT a.scope_path,a.grants_access, EXISTS(SELECT 1 FROM locality_access_entries e JOIN domain_memberships m ON m.domain_uuid=e.domain_uuid AND m.principal_uuid=? AND m.state='active' JOIN principals u ON u.uuid=m.principal_uuid AND u.state IN ('active','readonly') WHERE e.domain_uuid=a.domain_uuid AND e.node_kind=a.node_kind AND e.node_uuid=a.node_uuid AND ((e.subject_kind='user' AND e.subject_uuid=m.uuid) OR (e.subject_kind='group' AND EXISTS(SELECT 1 FROM groups g JOIN group_members gm ON gm.group_uuid=g.uuid AND gm.membership_uuid=m.uuid WHERE g.uuid=e.subject_uuid AND g.domain_uuid=m.domain_uuid AND g.state='active')))), EXISTS(SELECT 1 FROM locality_access_entries e JOIN domain_memberships m ON m.domain_uuid=e.domain_uuid AND m.principal_uuid=? AND m.state='active' JOIN principals u ON u.uuid=m.principal_uuid AND u.state='active' WHERE e.domain_uuid=a.domain_uuid AND e.node_kind=a.node_kind AND e.node_uuid=a.node_uuid AND e.permission='read_write' AND ((e.subject_kind='user' AND e.subject_uuid=m.uuid) OR (e.subject_kind='group' AND EXISTS(SELECT 1 FROM groups g JOIN group_members gm ON gm.group_uuid=g.uuid AND gm.membership_uuid=m.uuid WHERE g.uuid=e.subject_uuid AND g.domain_uuid=m.domain_uuid AND g.state='active')))), EXISTS(SELECT 1 FROM groups g JOIN group_members gm ON gm.group_uuid=g.uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.domain_uuid=g.domain_uuid AND m.state='active' JOIN principals u ON u.uuid=m.principal_uuid AND u.state='active' WHERE g.domain_uuid=a.domain_uuid AND g.builtin_key='domain_admin' AND g.state='active' AND gm.member_role IN ('owner','manager') AND m.principal_uuid=?) FROM locality_access_policies a WHERE a.domain_uuid=? LIMIT 4097`, principal, principal, principal, domain) if err != nil { return nil, err } defer rows.Close() count := 0 for rows.Next() { count++ if count > 4096 { return nil, ErrGovernanceInvalid } var path string var layer schutzaria.AccessLayer if err = rows.Scan(&path, &layer.Grant, &layer.Read, &layer.Write, &admin); err != nil { return nil, err } layer.Path = path layers = append(layers, layer) } if err := rows.Err(); err != nil { return nil, err } return schutzaria.NewLocalityAccess(admin, layers), nil } func readLocalityAccess(ctx context.Context, tx *sql.Tx, domain, kind, id string, g CityGovernance) (LocalityAccess, error) { a := LocalityAccess{Epoch: g.Epoch, TopologyVersion: g.TopologyVersion, Mode: "inherit", Entries: []LocalityAccessEntry{}} err := tx.QueryRowContext(ctx, `SELECT scope_path,grants_access,authority_rank FROM locality_access_policies WHERE domain_uuid=? AND node_kind=? AND node_uuid=?`, domain, kind, id).Scan(&a.ScopePath, &a.GrantsAccess, &a.AuthorityRank) if err == sql.ErrNoRows { return a, nil } if err != nil { return a, err } a.Mode = "restricted" rows, err := tx.QueryContext(ctx, `SELECT e.subject_kind,e.subject_uuid,CASE WHEN e.subject_kind='user' THEN COALESCE((SELECT i.subject FROM domain_memberships m JOIN principal_identities i ON i.principal_uuid=m.principal_uuid AND i.provider_type='password' WHERE m.uuid=e.subject_uuid AND m.domain_uuid=e.domain_uuid LIMIT 1),e.subject_name) ELSE COALESCE((SELECT name FROM groups WHERE uuid=e.subject_uuid AND domain_uuid=e.domain_uuid),e.subject_name) END,e.permission FROM locality_access_entries e WHERE e.domain_uuid=? AND e.node_kind=? AND e.node_uuid=? ORDER BY e.subject_kind,e.subject_name LIMIT 65`, domain, kind, id) if err != nil { return a, err } defer rows.Close() for rows.Next() { var entry LocalityAccessEntry if err = rows.Scan(&entry.Kind, &entry.ID, &entry.Name, &entry.Permission); err != nil { return a, err } a.Entries = append(a.Entries, entry) } if len(a.Entries) > 64 { return a, ErrGovernanceInvalid } return a, rows.Err() } func (s *Store) LocalityAccess(ctx context.Context, domain, actor, kind, id string, change *LocalityAccess) (LocalityAccess, error) { ctx, cancel := context.WithTimeout(ctx, 2*time.Second) defer cancel() tx, err := s.DB.BeginTx(ctx, nil) if err != nil { return LocalityAccess{}, err } defer tx.Rollback() if change != nil { if _, err = tx.ExecContext(ctx, `INSERT INTO city_governance_epochs(domain_uuid,version) VALUES(?,0) ON CONFLICT(domain_uuid) DO UPDATE SET version=version`, domain); err != nil { return LocalityAccess{}, err } } g, err := governanceSnapshot(ctx, tx, domain, actor, kind, id) if err != nil { return LocalityAccess{}, err } before, err := readLocalityAccess(ctx, tx, domain, kind, id, g) if err != nil || change == nil { return before, err } if change.Epoch != g.Epoch || change.TopologyVersion != g.TopologyVersion { return before, ErrGovernanceConflict } if change.Mode != "inherit" && change.Mode != "restricted" || len(change.Entries) > 64 || change.Mode == "inherit" && len(change.Entries) > 0 { return before, ErrGovernanceInvalid } var admin bool if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM groups g JOIN group_members gm ON gm.group_uuid=g.uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.domain_uuid=g.domain_uuid WHERE g.domain_uuid=? AND g.builtin_key='domain_admin' AND g.state='active' AND gm.member_role IN ('owner','manager') AND m.principal_uuid=? AND m.state='active')`, domain, actor).Scan(&admin); err != nil { return before, err } path := "/" if kind != "domain" { table := "zones" if kind == "spot" { table = "spots" } if err = tx.QueryRowContext(ctx, `SELECT path_prefix FROM `+table+` WHERE uuid=? AND domain_uuid=?`, id, domain).Scan(&path); err != nil { return before, err } } if change.Mode == "restricted" { var mode string if err = tx.QueryRowContext(ctx, `SELECT value FROM config WHERE domain_uuid=? AND key='authorization_mode'`, domain).Scan(&mode); err != nil { return before, err } if mode != "enforcing" { return before, ErrLocalityAccessEnforcing } var crossAlias bool if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM paths p JOIN paths other ON other.object_uuid=p.object_uuid CROSS JOIN (SELECT ? AS scope) input WHERE p.domain_uuid=? AND `+cityPathScopeSQL("input.scope", "p.path")+` AND (other.domain_uuid!=p.domain_uuid OR NOT `+cityPathScopeSQL("input.scope", "other.path")+`))`, path, domain).Scan(&crossAlias); err != nil { return before, err } if crossAlias { return before, ErrLocalityAccessAlias } } entries := append([]LocalityAccessEntry{}, change.Entries...) rank := 1 if kind == "quartier" || kind == "street" || g.CanAppoint { rank = 2 } if admin { rank = 3 } grant := admin if before.AuthorityRank > rank && before.Mode == "restricted" && change.Mode != "restricted" { return before, ErrGovernanceCeiling } seen := map[string]bool{} for i := range entries { e := &entries[i] previousID := e.ID e.Name = strings.ToLower(strings.TrimSpace(e.Name)) if (e.Kind != "user" && e.Kind != "group") || (e.Permission != "read" && e.Permission != "read_write") || len(e.Name) > 64 || e.Name == "" { return before, ErrGovernanceInvalid } if e.Kind == "user" { err = tx.QueryRowContext(ctx, `SELECT m.uuid FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid AND p.state IN ('active','readonly') JOIN principal_identities i ON i.principal_uuid=p.uuid AND i.provider_type='password' WHERE m.domain_uuid=? AND m.state='active' AND i.subject=?`, domain, e.Name).Scan(&e.ID) } else { err = tx.QueryRowContext(ctx, `SELECT uuid FROM groups WHERE domain_uuid=? AND name=? AND state='active'`, domain, e.Name).Scan(&e.ID) } if err != nil { return before, ErrGovernanceInvalid } if previousID != "" && previousID != e.ID { return before, ErrGovernanceInvalid } key := e.Kind + ":" + e.ID if seen[key] { return before, ErrGovernanceInvalid } seen[key] = true } if before.AuthorityRank > rank && before.Mode == "restricted" { for _, e := range entries { allowed := false for _, old := range before.Entries { if old.Kind == e.Kind && old.ID == e.ID && (old.Permission == "read_write" || e.Permission == "read") { allowed = true break } } if !allowed { return before, ErrGovernanceCeiling } } rank = before.AuthorityRank grant = before.GrantsAccess } if _, err = tx.ExecContext(ctx, `DELETE FROM locality_access_entries WHERE domain_uuid=? AND node_kind=? AND node_uuid=?`, domain, kind, id); err != nil { return before, err } if _, err = tx.ExecContext(ctx, `DELETE FROM locality_access_policies WHERE domain_uuid=? AND node_kind=? AND node_uuid=?`, domain, kind, id); err != nil { return before, err } if change.Mode == "restricted" { if err = installLocalityAccessGuards(ctx, tx); err != nil { return before, err } if _, err = tx.ExecContext(ctx, `INSERT INTO locality_access_policies VALUES(?,?,?,?,?,?,?)`, domain, kind, id, path, grant, actor, rank); err != nil { return before, err } for _, e := range entries { if _, err = tx.ExecContext(ctx, `INSERT INTO locality_access_entries VALUES(?,?,?,?,?,?,?)`, domain, kind, id, e.Kind, e.ID, e.Name, e.Permission); err != nil { return before, err } } } if _, err = tx.ExecContext(ctx, `UPDATE city_governance_epochs SET version=version+1 WHERE domain_uuid=?`, domain); err != nil { return before, err } g.Epoch++ after, err := readLocalityAccess(ctx, tx, domain, kind, id, g) if err != nil { return before, err } b, _ := json.Marshal(before) a, _ := json.Marshal(after) if _, err = tx.ExecContext(ctx, `INSERT INTO city_governance_events(domain_uuid,epoch,actor_uuid,node_kind,node_uuid,before_json,after_json,created_at_ms) VALUES(?,?,?,?,?,?,?,?)`, domain, g.Epoch, actor, kind, id, string(b), string(a), time.Now().UnixMilli()); err != nil { return before, err } return after, tx.Commit() }