197 lines
11 KiB
Go
197 lines
11 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
"time"
|
|
)
|
|
|
|
// campusAdminInheritancePrefix is deliberately not a LIKE pattern: underscore
|
|
// is a wildcard in SQL LIKE. Derived grants must never become projection roots.
|
|
const campusAdminInheritancePrefix = "campus_admin_inherit:"
|
|
|
|
func (s *Store) ensureCampusAdminInheritanceSchema() error {
|
|
tx, err := s.DB.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.Rollback()
|
|
for _, statement := range []string{
|
|
`CREATE TABLE IF NOT EXISTS campus_admin_grants (
|
|
group_uuid TEXT NOT NULL, membership_uuid TEXT NOT NULL,
|
|
source TEXT NOT NULL, member_role TEXT NOT NULL,
|
|
created_at_ms INTEGER NOT NULL,
|
|
PRIMARY KEY(group_uuid,membership_uuid,source))`,
|
|
`CREATE INDEX IF NOT EXISTS campus_admin_grants_membership ON campus_admin_grants(membership_uuid)`,
|
|
`CREATE TABLE IF NOT EXISTS campus_admin_membership_origins (
|
|
membership_uuid TEXT PRIMARY KEY, domain_uuid TEXT NOT NULL,
|
|
principal_uuid TEXT NOT NULL, UNIQUE(domain_uuid,principal_uuid))`,
|
|
`CREATE TABLE IF NOT EXISTS campus_admin_migrations (key TEXT PRIMARY KEY)`,
|
|
} {
|
|
if _, err = tx.Exec(statement); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
// Only the old direct grants are authoritative. Copying old inherited rows
|
|
// would perpetuate cycles from the former insert-only implementation. Do not
|
|
// infer ownership of old Domain memberships: their origin was not recorded.
|
|
if _, err = tx.Exec(`INSERT OR IGNORE INTO campus_admin_grants
|
|
(group_uuid,membership_uuid,source,member_role,created_at_ms)
|
|
SELECT gm.group_uuid,gm.membership_uuid,gm.source,gm.member_role,gm.created_at_ms
|
|
FROM group_members gm JOIN groups g ON g.uuid=gm.group_uuid
|
|
WHERE g.builtin_key='campus_admin' AND substr(gm.source,1,21)!='campus_admin_inherit:'
|
|
AND NOT EXISTS(SELECT 1 FROM campus_admin_migrations WHERE key='direct-grants-v1')`); err != nil {
|
|
return err
|
|
}
|
|
if _, err = tx.Exec(`INSERT OR IGNORE INTO campus_admin_migrations(key) VALUES('direct-grants-v1')`); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit()
|
|
}
|
|
|
|
// seedCampusAdminRoleGrantsContext is the one-time migration of each independent
|
|
// Domain administrator binding. A later explicit group removal must not be
|
|
// undone by restarting the server or creating another Domain.
|
|
func (s *Store) seedCampusAdminRoleGrantsContext(ctx context.Context, tx *sql.Tx, now int64) error {
|
|
const candidates = `SELECT DISTINCT g.uuid AS group_uuid,m.uuid AS membership_uuid
|
|
FROM groups g JOIN domain_memberships m ON m.domain_uuid=g.domain_uuid
|
|
JOIN auth_role_bindings b ON b.membership_uuid=m.uuid
|
|
JOIN auth_roles r ON r.uuid=b.role_uuid AND r.domain_uuid=m.domain_uuid
|
|
JOIN auth_capability_grants c ON c.role_uuid=r.uuid
|
|
AND c.capability='manage' AND c.target_type='domain'
|
|
AND (c.target_id=m.domain_uuid OR c.target_id='*')
|
|
WHERE g.builtin_key='campus_admin'`
|
|
if _, err := tx.ExecContext(ctx, fmt.Sprintf(`INSERT INTO campus_admin_grants
|
|
(group_uuid,membership_uuid,source,member_role,created_at_ms)
|
|
SELECT group_uuid,membership_uuid,'migration','owner',%s FROM (`+candidates+`) AS candidates
|
|
WHERE NOT EXISTS(SELECT 1 FROM campus_admin_migrations
|
|
WHERE key='role:'||group_uuid||':'||membership_uuid) ON CONFLICT(group_uuid,membership_uuid,source) DO NOTHING`, s.sqlParam(1)), now); err != nil {
|
|
return err
|
|
}
|
|
_, err := tx.ExecContext(ctx, `INSERT INTO campus_admin_migrations(key)
|
|
SELECT 'role:'||group_uuid||':'||membership_uuid FROM (`+candidates+`) AS candidates WHERE 1=1 ON CONFLICT(key) DO NOTHING`)
|
|
return err
|
|
}
|
|
|
|
func (s *Store) ProjectCampusAdminMemberships() error {
|
|
return s.ProjectCampusAdminMembershipsContext(context.Background())
|
|
}
|
|
|
|
func (s *Store) ProjectCampusAdminMembershipsContext(ctx context.Context) error {
|
|
return s.groupWrite(ctx, s.projectCampusAdminMembershipsContext)
|
|
}
|
|
|
|
// projectCampusAdminMembershipsTx materializes effective group membership from
|
|
// independent roots, never from its own output. The caller's mutation and this
|
|
// reconciliation commit together, so revocation has no observable stale window.
|
|
func projectCampusAdminMembershipsTx(tx *sql.Tx) error {
|
|
// Compatibility entry point for legacy SQLite-only mutation transactions.
|
|
// Native backend writers call the Store method with their request context.
|
|
return (&Store{}).projectCampusAdminMembershipsContext(context.Background(), tx)
|
|
}
|
|
|
|
func (s *Store) projectCampusAdminMembershipsContext(ctx context.Context, tx *sql.Tx) error {
|
|
if s.sqlBackend == storeSQLite {
|
|
var hasDomains int
|
|
if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='domains'`).Scan(&hasDomains); err != nil || hasDomains == 0 {
|
|
return err
|
|
}
|
|
}
|
|
now := time.Now().UnixMilli()
|
|
// These statements also obtain a write lock before reading projection input.
|
|
if _, err := tx.ExecContext(ctx, `DELETE FROM campus_admin_grants WHERE substr(source,1,21)='campus_admin_inherit:'`); err != nil {
|
|
return err
|
|
}
|
|
const roots = `SELECT src.uuid AS source_group_uuid,origin.uuid AS source_domain_uuid,
|
|
origin.campus_uuid,srcm.principal_uuid,MIN(gr.created_at_ms) AS created_at_ms,
|
|
CASE MAX(CASE gr.member_role WHEN 'owner' THEN 3 WHEN 'manager' THEN 2 ELSE 1 END)
|
|
WHEN 3 THEN 'owner' WHEN 2 THEN 'manager' ELSE 'member' END AS member_role
|
|
FROM campus_admin_grants gr
|
|
JOIN groups src ON src.uuid=gr.group_uuid AND src.builtin_key='campus_admin'
|
|
AND src.state='active' AND src.inherit_members=1
|
|
JOIN domains origin ON origin.uuid=src.domain_uuid AND origin.enabled=1
|
|
JOIN domain_memberships srcm ON srcm.uuid=gr.membership_uuid
|
|
AND srcm.domain_uuid=src.domain_uuid AND srcm.state='active'
|
|
JOIN principals p ON p.uuid=srcm.principal_uuid AND p.state='active'
|
|
WHERE substr(gr.source,1,21)!='campus_admin_inherit:'
|
|
GROUP BY src.uuid,origin.uuid,origin.campus_uuid,srcm.principal_uuid`
|
|
// Record exactly the memberships this projection creates. Existing local
|
|
// memberships (including deliberately suspended ones) are never reactivated.
|
|
newUUID := `lower(hex(randomblob(4)))||'-'||lower(hex(randomblob(2)))||'-4'||substr(lower(hex(randomblob(2))),2)||'-a'||substr(lower(hex(randomblob(2))),2)||'-'||lower(hex(randomblob(6)))`
|
|
if s.sqlBackend == storePostgreSQL {
|
|
newUUID = `gen_random_uuid()::text`
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `INSERT INTO campus_admin_membership_origins
|
|
(membership_uuid,domain_uuid,principal_uuid)
|
|
SELECT `+newUUID+`,domain_uuid,principal_uuid FROM (
|
|
SELECT DISTINCT dst.uuid AS domain_uuid,root.principal_uuid FROM (`+roots+`) root
|
|
JOIN domains dst ON dst.campus_uuid=root.campus_uuid AND dst.uuid!=root.source_domain_uuid AND dst.enabled=1
|
|
JOIN groups dstg ON dstg.domain_uuid=dst.uuid AND dstg.builtin_key='campus_admin' AND dstg.state='active'
|
|
WHERE NOT EXISTS(SELECT 1 FROM domain_memberships m
|
|
WHERE m.domain_uuid=dst.uuid AND m.principal_uuid=root.principal_uuid)) AS missing_memberships WHERE 1=1 ON CONFLICT(domain_uuid,principal_uuid) DO NOTHING`); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `INSERT INTO domain_memberships
|
|
(uuid,domain_uuid,principal_uuid,state,created_at_ms)
|
|
SELECT membership_uuid,domain_uuid,principal_uuid,'active',`+s.sqlParam(1)+`
|
|
FROM campus_admin_membership_origins WHERE 1=1 ON CONFLICT(domain_uuid,principal_uuid) DO NOTHING`, now); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `INSERT INTO campus_admin_grants
|
|
(group_uuid,membership_uuid,source,member_role,created_at_ms)
|
|
SELECT dstg.uuid,dstm.uuid,'campus_admin_inherit:'||root.source_group_uuid,root.member_role,root.created_at_ms
|
|
FROM (`+roots+`) root
|
|
JOIN domains dst ON dst.campus_uuid=root.campus_uuid AND dst.uuid!=root.source_domain_uuid AND dst.enabled=1
|
|
JOIN groups dstg ON dstg.domain_uuid=dst.uuid AND dstg.builtin_key='campus_admin' AND dstg.state='active'
|
|
JOIN domain_memberships dstm ON dstm.domain_uuid=dst.uuid AND dstm.principal_uuid=root.principal_uuid
|
|
AND dstm.state='active'`); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `DELETE FROM group_members WHERE
|
|
group_uuid IN (SELECT uuid FROM groups WHERE builtin_key='campus_admin')
|
|
OR substr(source,1,21)='campus_admin_inherit:'`); err != nil {
|
|
return err
|
|
}
|
|
// The strongest remaining grant wins. Prefer the independent local source
|
|
// on ties; weaker local grants remain in provenance and reappear on revoke.
|
|
if _, err := tx.ExecContext(ctx, `INSERT INTO group_members(group_uuid,membership_uuid,member_role,source,created_at_ms)
|
|
SELECT group_uuid,membership_uuid,member_role,source,created_at_ms FROM (
|
|
SELECT gr.*,ROW_NUMBER() OVER(PARTITION BY gr.group_uuid,gr.membership_uuid
|
|
ORDER BY CASE gr.member_role WHEN 'owner' THEN 3 WHEN 'manager' THEN 2 ELSE 1 END DESC,
|
|
CASE WHEN substr(gr.source,1,21)='campus_admin_inherit:' THEN 1 ELSE 0 END,
|
|
gr.source) AS rank
|
|
FROM campus_admin_grants gr JOIN groups g ON g.uuid=gr.group_uuid
|
|
JOIN domains d ON d.uuid=g.domain_uuid
|
|
JOIN domain_memberships m ON m.uuid=gr.membership_uuid AND m.domain_uuid=g.domain_uuid
|
|
) AS ranked_grants WHERE rank=1`); err != nil {
|
|
return err
|
|
}
|
|
// A newly added independent group/role grant adopts an inherited membership
|
|
// as local. Revocation must not delete that membership, binding, or session.
|
|
if _, err := tx.ExecContext(ctx, `DELETE FROM campus_admin_membership_origins WHERE
|
|
EXISTS(SELECT 1 FROM auth_role_bindings b WHERE b.membership_uuid=campus_admin_membership_origins.membership_uuid)
|
|
OR EXISTS(SELECT 1 FROM group_members gm WHERE gm.membership_uuid=campus_admin_membership_origins.membership_uuid
|
|
AND substr(gm.source,1,21)!='campus_admin_inherit:')
|
|
OR EXISTS(SELECT 1 FROM campus_admin_grants gr WHERE gr.membership_uuid=campus_admin_membership_origins.membership_uuid
|
|
AND substr(gr.source,1,21)!='campus_admin_inherit:')`); err != nil {
|
|
return err
|
|
}
|
|
const noGrants = `NOT EXISTS(SELECT 1 FROM group_members gm
|
|
WHERE gm.membership_uuid=origin.membership_uuid)
|
|
AND NOT EXISTS(SELECT 1 FROM auth_role_bindings b WHERE b.membership_uuid=origin.membership_uuid)`
|
|
if _, err := tx.ExecContext(ctx, `UPDATE auth_sessions SET revoked_at_ms=`+s.sqlParam(1)+` WHERE revoked_at_ms=0 AND EXISTS(
|
|
SELECT 1 FROM campus_admin_membership_origins origin
|
|
WHERE origin.domain_uuid=auth_sessions.domain_uuid AND origin.principal_uuid=auth_sessions.principal_uuid
|
|
AND `+noGrants+`)`, now); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `DELETE FROM domain_memberships WHERE uuid IN (
|
|
SELECT origin.membership_uuid FROM campus_admin_membership_origins origin WHERE `+noGrants+`)`); err != nil {
|
|
return err
|
|
}
|
|
_, err := tx.ExecContext(ctx, `DELETE FROM campus_admin_membership_origins WHERE
|
|
NOT EXISTS(SELECT 1 FROM domain_memberships m WHERE m.uuid=campus_admin_membership_origins.membership_uuid)`)
|
|
return err
|
|
}
|