Files
pages/internal/store/locality_access.go
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

379 lines
18 KiB
Go

package store
import (
"context"
"database/sql"
"encoding/json"
"errors"
"strings"
"time"
)
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 localityAccessLayer struct{ read, write, grant bool }
type localityAccessSnapshot struct {
admin bool
paths map[string][]localityAccessLayer
}
func (p *localityAccessSnapshot) decide(path, capability string, basis bool) bool {
if !strings.HasPrefix(path, "/") {
return false
}
if p == nil || p.admin {
return basis
}
grant := false
for at := path; ; {
for _, layer := range p.paths[at] {
allowed := layer.write
if capability == "read" {
allowed = layer.read
}
if !allowed {
return false
}
if layer.grant && (capability == "read" || capability == "write" || capability == "create" || capability == "upload") {
grant = true
}
}
if at == "/" {
break
}
i := strings.LastIndex(at, "/")
if i <= 0 {
at = "/"
} else {
at = at[:i]
}
}
return basis || grant
}
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.admin || len(p.paths) == 0 {
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) {
p := &localityAccessSnapshot{paths: map[string][]localityAccessLayer{}}
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 localityAccessLayer
var admin bool
if err = rows.Scan(&path, &layer.grant, &layer.read, &layer.write, &admin); err != nil {
return nil, err
}
p.admin = admin
p.paths[path] = append(p.paths[path], layer)
}
return p, rows.Err()
}
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()
}