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

372 lines
19 KiB
Go

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 {
if s.sqlBackend == storePostgreSQL {
return s.ensurePostgreSQLLocalityFoundation(context.Background())
}
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 := s.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 {
return s.policyRead(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
return s.checkObjectLocalityAccessCaps(ctx, tx, domain, principal, capability, object)
})
}
func (s *Store) checkObjectLocalityAccessCaps(ctx context.Context, tx *sql.Tx, 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 := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM locality_access_policies WHERE domain_uuid!=`+s.sqlParam(1)+`)`, domain).Scan(&foreign); err != nil {
return err
}
if foreign {
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM paths p JOIN locality_access_policies a ON a.domain_uuid=p.domain_uuid WHERE p.object_uuid=`+s.sqlParam(1)+` AND p.domain_uuid!=`+s.sqlParam(2)+` AND `+s.pathScopeSQL("a.scope_path", "p.path")+`)`, object, domain).Scan(&foreign); err != nil {
return err
}
if foreign {
return ErrAccessDenied
}
}
p, err := s.loadLocalityAccess(cityReadQuery{ctx, tx}, domain, principal)
if err != nil {
return err
}
if !p.RequiresPathChecks() {
return nil
}
rows, err := tx.QueryContext(ctx, `SELECT path FROM paths WHERE domain_uuid=`+s.sqlParam(1)+` AND object_uuid=`+s.sqlParam(2)+` 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) {
// Existing SQLite-only mutation transactions retain this entry point.
return (&Store{}).loadLocalityAccess(q, domain, principal)
}
func (s *Store) 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=`+s.sqlParam(1)+` 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=`+s.sqlParam(2)+` 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=`+s.sqlParam(3)+`)
FROM locality_access_policies a WHERE a.domain_uuid=`+s.sqlParam(4)+` 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 (s *Store) 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=`+s.sqlParam(1)+` AND node_kind=`+s.sqlParam(2)+` AND node_uuid=`+s.sqlParam(3)+``, 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=`+s.sqlParam(1)+` AND e.node_kind=`+s.sqlParam(2)+` AND e.node_uuid=`+s.sqlParam(3)+` 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) (result LocalityAccess, resultErr error) {
defer func() { resultErr = s.sqlError("locality access policy", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
options := s.policyReadOptions()
if change != nil {
options = &sql.TxOptions{Isolation: sql.LevelReadCommitted}
}
tx, err := s.DB.BeginTx(ctx, options)
if err != nil {
return LocalityAccess{}, err
}
defer tx.Rollback()
if change != nil {
if err = s.lockPolicyWrite(ctx, tx); err != nil {
return LocalityAccess{}, err
}
if _, err = tx.ExecContext(ctx, `INSERT INTO city_governance_epochs(domain_uuid,version) VALUES(`+s.sqlParam(1)+`,0) ON CONFLICT(domain_uuid) DO UPDATE SET version=city_governance_epochs.version`, domain); err != nil {
return LocalityAccess{}, err
}
}
g, err := s.governanceSnapshot(ctx, tx, domain, actor, kind, id)
if err != nil {
return LocalityAccess{}, err
}
before, err := s.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=`+s.sqlParam(1)+` AND g.builtin_key='domain_admin' AND g.state='active' AND gm.member_role IN ('owner','manager') AND m.principal_uuid=`+s.sqlParam(2)+` 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=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+``, 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=`+s.sqlParam(1)+` 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 `+s.sqlParam(1)+` AS scope) input WHERE p.domain_uuid=`+s.sqlParam(2)+` AND `+s.pathScopeSQL("input.scope", "p.path")+` AND (other.domain_uuid!=p.domain_uuid OR NOT `+s.pathScopeSQL("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=`+s.sqlParam(1)+` AND m.state='active' AND i.subject=`+s.sqlParam(2)+``, domain, e.Name).Scan(&e.ID)
} else {
err = tx.QueryRowContext(ctx, `SELECT uuid FROM groups WHERE domain_uuid=`+s.sqlParam(1)+` AND name=`+s.sqlParam(2)+` 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=`+s.sqlParam(1)+` AND node_kind=`+s.sqlParam(2)+` AND node_uuid=`+s.sqlParam(3)+``, domain, kind, id); err != nil {
return before, err
}
if _, err = tx.ExecContext(ctx, `DELETE FROM locality_access_policies WHERE domain_uuid=`+s.sqlParam(1)+` AND node_kind=`+s.sqlParam(2)+` AND node_uuid=`+s.sqlParam(3)+``, domain, kind, id); err != nil {
return before, err
}
if change.Mode == "restricted" {
if err = s.installLocalityAccessGuards(ctx, tx); err != nil {
return before, err
}
grantValue := 0
if grant {
grantValue = 1
}
if _, err = tx.ExecContext(ctx, `INSERT INTO locality_access_policies VALUES(`+s.sqlValues(7)+`)`, domain, kind, id, path, grantValue, actor, rank); err != nil {
return before, err
}
for _, e := range entries {
if _, err = tx.ExecContext(ctx, `INSERT INTO locality_access_entries VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,`+s.sqlParam(7)+`)`, 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=`+s.sqlParam(1)+``, domain); err != nil {
return before, err
}
g.Epoch++
after, err := s.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(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,`+s.sqlParam(7)+`,`+s.sqlParam(8)+`)`, domain, g.Epoch, actor, kind, id, string(b), string(a), time.Now().UnixMilli()); err != nil {
return before, err
}
return after, tx.Commit()
}