package store import ( "errors" "regexp" "strings" "time" "github.com/google/uuid" ) var groupNamePattern = regexp.MustCompile(`^[a-z0-9][a-z0-9_-]{1,63}$`) type Group struct { UUID, DomainUUID, Name, DisplayName, Description, Visibility, State, BuiltinKey string InheritMembers bool CreatedAtMS, UpdatedAtMS int64 } type GroupMember struct { MembershipUUID, PrincipalUUID, Username, DisplayName, MemberRole, Source string } type GroupPermission struct { UUID, GroupUUID, ScopePath, Permission string } var groupPermissions = map[string]map[string]bool{ "read": {"read": true}, "read_write_once": {"read": true, "create": true, "upload": true}, "read_write": {"read": true, "create": true, "write": true, "upload": true, "rename": true, "link": true}, "upload_only": {"upload": true}, } func NormalizeGroupPermission(value string) (string, error) { value = strings.ToLower(strings.TrimSpace(value)) if _, ok := groupPermissions[value]; !ok { return "", errors.New("invalid group permission") } return value, nil } func normalizeGroupName(name string) (string, error) { name = strings.ToLower(strings.TrimSpace(name)) if !groupNamePattern.MatchString(name) || name == "new" || name == "sys" || name == "campus_admin" || name == "domain_admin" { return "", errors.New("group name must be 2-64 lowercase letters, digits, underscores, or hyphens") } return name, nil } func (s *Store) EnsureBuiltinAdminGroups() error { now := time.Now().UnixMilli() var hasDomains int if err := s.DB.QueryRow(`SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='domains'`).Scan(&hasDomains); err != nil || hasDomains == 0 { return err } rows, err := s.DB.Query(`SELECT uuid FROM domains`) if err != nil { return err } var domains []string for rows.Next() { var id string if err := rows.Scan(&id); err != nil { rows.Close() return err } domains = append(domains, id) } rows.Close() tx, err := s.DB.Begin() if err != nil { return err } defer tx.Rollback() for _, domainUUID := range domains { for _, key := range []string{"campus_admin", "domain_admin"} { _, err = tx.Exec(`INSERT INTO groups(uuid,domain_uuid,name,display_name,description,visibility,state,builtin_key,inherit_members,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,'members','active',?,?,?,?) ON CONFLICT(domain_uuid,name) DO UPDATE SET builtin_key=excluded.builtin_key`, uuid.NewString(), domainUUID, key, strings.ReplaceAll(key, "_", " "), "Built-in administrative group", key, key == "campus_admin", now, now) if err != nil { return err } } _, err = tx.Exec(`INSERT OR IGNORE INTO group_members(group_uuid,membership_uuid,member_role,source,created_at_ms) SELECT g.uuid,m.uuid,'owner','migration',? 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 JOIN auth_capability_grants c ON c.role_uuid=r.uuid AND c.capability='manage' AND c.target_type='domain' WHERE g.domain_uuid=? AND g.builtin_key='domain_admin'`, now, domainUUID) if err != nil { return err } } if err = seedCampusAdminRoleGrantsTx(tx, now); err != nil { return err } if err = projectCampusAdminMembershipsTx(tx); err != nil { return err } return tx.Commit() } func (s *Store) IsBuiltinGroupAdmin(domainUUID, principalUUID, key string) bool { var allowed int _ = s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM groups g JOIN domains d ON d.uuid=g.domain_uuid AND d.enabled=1 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 JOIN principals p ON p.uuid=m.principal_uuid WHERE g.domain_uuid=? AND g.builtin_key=? AND g.state='active' AND m.principal_uuid=? AND m.state='active' AND p.state='active' AND gm.member_role IN ('owner','manager'))`, domainUUID, key, principalUUID).Scan(&allowed) return allowed != 0 } func (s *Store) IsCampusAdmin(campusUUID, principalUUID string) bool { var allowed int _ = s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM groups g JOIN domains d ON d.uuid=g.domain_uuid AND d.enabled=1 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 JOIN principals p ON p.uuid=m.principal_uuid WHERE d.campus_uuid=? AND g.builtin_key='campus_admin' AND g.state='active' AND m.principal_uuid=? AND m.state='active' AND p.state='active' AND gm.member_role IN ('owner','manager'))`, campusUUID, principalUUID).Scan(&allowed) return allowed != 0 } func (s *Store) SetCampusAdminInheritance(groupUUID string, enabled bool) error { value := 0 if enabled { value = 1 } tx, err := s.DB.Begin() if err != nil { return err } defer tx.Rollback() result, err := tx.Exec(`UPDATE groups SET inherit_members=?,updated_at_ms=? WHERE uuid=? AND builtin_key='campus_admin'`, value, time.Now().UnixMilli(), groupUUID) if err != nil { return err } changed, _ := result.RowsAffected() if changed != 1 { return errors.New("campus_admin group not found") } if err = projectCampusAdminMembershipsTx(tx); err != nil { return err } return tx.Commit() } func (s *Store) CreateGroup(domainUUID, ownerPrincipalUUID, name, displayName, description, visibility string) (*Group, error) { name, err := normalizeGroupName(name) if err != nil { return nil, err } if visibility != "public" && visibility != "domain" && visibility != "members" { visibility = "members" } if strings.TrimSpace(displayName) == "" { displayName = name } now := time.Now().UnixMilli() group := &Group{UUID: uuid.NewString(), DomainUUID: domainUUID, Name: name, DisplayName: strings.TrimSpace(displayName), Description: strings.TrimSpace(description), Visibility: visibility, State: "active", CreatedAtMS: now, UpdatedAtMS: now} tx, err := s.DB.Begin() if err != nil { return nil, err } defer tx.Rollback() var membershipUUID string if err := tx.QueryRow(`SELECT uuid FROM domain_memberships WHERE domain_uuid=? AND principal_uuid=? AND state='active'`, domainUUID, ownerPrincipalUUID).Scan(&membershipUUID); err != nil { return nil, err } if _, err = tx.Exec(`INSERT INTO groups(uuid,domain_uuid,name,display_name,description,visibility,state,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?,?,?,?)`, group.UUID, domainUUID, group.Name, group.DisplayName, group.Description, group.Visibility, group.State, now, now); err != nil { return nil, err } if _, err = tx.Exec(`INSERT INTO group_members(group_uuid,membership_uuid,member_role,source,created_at_ms) VALUES(?,?, 'owner','local',?)`, group.UUID, membershipUUID, now); err != nil { return nil, err } return group, tx.Commit() } func (s *Store) GroupByName(domainUUID, name string) (*Group, error) { var group Group err := s.DB.QueryRow(`SELECT uuid,domain_uuid,name,display_name,description,visibility,state,builtin_key,inherit_members,created_at_ms,updated_at_ms FROM groups WHERE domain_uuid=? AND name=? AND state!='archived'`, domainUUID, strings.ToLower(strings.TrimSpace(name))).Scan(&group.UUID, &group.DomainUUID, &group.Name, &group.DisplayName, &group.Description, &group.Visibility, &group.State, &group.BuiltinKey, &group.InheritMembers, &group.CreatedAtMS, &group.UpdatedAtMS) return &group, err } func (s *Store) GroupByUUID(domainUUID, groupUUID string) (*Group, error) { var group Group err := s.DB.QueryRow(`SELECT uuid,domain_uuid,name,display_name,description,visibility,state,builtin_key,inherit_members,created_at_ms,updated_at_ms FROM groups WHERE domain_uuid=? AND uuid=?`, domainUUID, groupUUID).Scan(&group.UUID, &group.DomainUUID, &group.Name, &group.DisplayName, &group.Description, &group.Visibility, &group.State, &group.BuiltinKey, &group.InheritMembers, &group.CreatedAtMS, &group.UpdatedAtMS) return &group, err } func (s *Store) ListGroups(domainUUID, principalUUID string) ([]Group, error) { rows, err := s.DB.Query(`SELECT DISTINCT g.uuid,g.domain_uuid,g.name,g.display_name,g.description,g.visibility,g.state,g.builtin_key,g.inherit_members,g.created_at_ms,g.updated_at_ms FROM groups g LEFT JOIN group_members gm ON gm.group_uuid=g.uuid LEFT JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.principal_uuid=? WHERE g.domain_uuid=? AND g.state!='archived' AND (g.visibility='public' OR (?!='' AND g.visibility='domain') OR m.uuid IS NOT NULL) ORDER BY lower(g.display_name),g.name`, principalUUID, domainUUID, principalUUID) if err != nil { return nil, err } defer rows.Close() var groups []Group for rows.Next() { var group Group if err := rows.Scan(&group.UUID, &group.DomainUUID, &group.Name, &group.DisplayName, &group.Description, &group.Visibility, &group.State, &group.BuiltinKey, &group.InheritMembers, &group.CreatedAtMS, &group.UpdatedAtMS); err != nil { return nil, err } groups = append(groups, group) } return groups, rows.Err() } func (s *Store) GroupMemberRole(groupUUID, principalUUID string) string { var role string _ = s.DB.QueryRow(`SELECT gm.member_role FROM group_members gm JOIN domain_memberships m ON m.uuid=gm.membership_uuid WHERE gm.group_uuid=? AND m.principal_uuid=? AND m.state='active'`, groupUUID, principalUUID).Scan(&role) return role } func (s *Store) GroupMemberRoleByMembership(groupUUID, membershipUUID string) string { var role string _ = s.DB.QueryRow(`SELECT member_role FROM group_members WHERE group_uuid=? AND membership_uuid=?`, groupUUID, membershipUUID).Scan(&role) return role } func (s *Store) ListGroupMembers(groupUUID string) ([]GroupMember, error) { rows, err := s.DB.Query(`SELECT m.uuid,p.uuid,COALESCE((SELECT subject FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' LIMIT 1),p.uuid),p.display_name,gm.member_role,gm.source FROM group_members gm JOIN domain_memberships m ON m.uuid=gm.membership_uuid JOIN principals p ON p.uuid=m.principal_uuid WHERE gm.group_uuid=? ORDER BY CASE gm.member_role WHEN 'owner' THEN 0 WHEN 'manager' THEN 1 ELSE 2 END,lower(p.display_name)`, groupUUID) if err != nil { return nil, err } defer rows.Close() var members []GroupMember for rows.Next() { var member GroupMember if err := rows.Scan(&member.MembershipUUID, &member.PrincipalUUID, &member.Username, &member.DisplayName, &member.MemberRole, &member.Source); err != nil { return nil, err } members = append(members, member) } return members, rows.Err() } func (s *Store) AddGroupMemberByUsername(domainUUID, groupUUID, username, role string) error { if role != "owner" && role != "manager" && role != "member" { return errors.New("invalid group member role") } tx, err := s.DB.Begin() if err != nil { return err } defer tx.Rollback() // Serialize before the identity lookup as well as the ownership check. if _, err = tx.Exec(`UPDATE groups SET updated_at_ms=updated_at_ms WHERE uuid=? AND domain_uuid=?`, groupUUID, domainUUID); err != nil { return err } var membershipUUID, builtinKey string err = tx.QueryRow(`SELECT m.uuid,g.builtin_key FROM domain_memberships m JOIN principal_identities i ON i.principal_uuid=m.principal_uuid AND i.provider_type='password' JOIN groups g ON g.uuid=? AND g.domain_uuid=m.domain_uuid WHERE m.domain_uuid=? AND i.subject=? AND m.state='active'`, groupUUID, domainUUID, strings.ToLower(strings.TrimSpace(username))).Scan(&membershipUUID, &builtinKey) if err != nil { return err } // Ordinary add/update is not an ownership-transfer API. Keep this check in // the write itself, including when another request just promoted the member. result, err := tx.Exec(`INSERT INTO group_members(group_uuid,membership_uuid,member_role,source,created_at_ms) VALUES(?,?,?,'local',?) ON CONFLICT(group_uuid,membership_uuid) DO UPDATE SET member_role=excluded.member_role,source=excluded.source WHERE group_members.member_role!='owner' OR excluded.member_role='owner'`, groupUUID, membershipUUID, role, time.Now().UnixMilli()) if err != nil { return err } if count, err := result.RowsAffected(); err != nil { return err } else if count == 0 { return errors.New("owner role cannot be downgraded by a member update") } if builtinKey == "campus_admin" { if _, err = tx.Exec(`DELETE FROM campus_admin_grants WHERE group_uuid=? AND membership_uuid=? AND substr(source,1,21)!='campus_admin_inherit:'`, groupUUID, membershipUUID); err != nil { return err } if _, err = tx.Exec(`INSERT INTO campus_admin_grants(group_uuid,membership_uuid,source,member_role,created_at_ms) VALUES(?,?,'local',?,?)`, groupUUID, membershipUUID, role, time.Now().UnixMilli()); err != nil { return err } if err = projectCampusAdminMembershipsTx(tx); err != nil { return err } } // An explicit local grant adopts a previously projected Domain membership. if _, err = tx.Exec(`DELETE FROM campus_admin_membership_origins WHERE membership_uuid=?`, membershipUUID); err != nil { return err } return tx.Commit() } func (s *Store) RemoveGroupMember(groupUUID, membershipUUID string) error { return s.RemoveGroupMemberWithAuthority(groupUUID, membershipUUID, true) } func (s *Store) RemoveGroupMemberWithAuthority(groupUUID, membershipUUID string, ownerAuthority bool) error { tx, err := s.DB.Begin() if err != nil { return err } defer tx.Rollback() if _, err = tx.Exec(`UPDATE groups SET updated_at_ms=updated_at_ms WHERE uuid=?`, groupUUID); err != nil { return err } var builtinKey string if err = tx.QueryRow(`SELECT builtin_key FROM groups WHERE uuid=?`, groupUUID).Scan(&builtinKey); err != nil { return err } if builtinKey == "campus_admin" { // Inherited-only entries can only be revoked at their source. Inherited // owners do not satisfy the guard for removing the last independent owner. var allowed int if err = tx.QueryRow(`SELECT EXISTS(SELECT 1 FROM campus_admin_grants grant WHERE grant.group_uuid=? AND grant.membership_uuid=? AND substr(grant.source,1,21)!='campus_admin_inherit:' AND (? OR NOT EXISTS(SELECT 1 FROM group_members gm WHERE gm.group_uuid=grant.group_uuid AND gm.membership_uuid=grant.membership_uuid AND gm.member_role!='member')) AND (NOT EXISTS(SELECT 1 FROM campus_admin_grants mine WHERE mine.group_uuid=grant.group_uuid AND mine.membership_uuid=grant.membership_uuid AND mine.member_role='owner' AND substr(mine.source,1,21)!='campus_admin_inherit:') OR EXISTS(SELECT 1 FROM campus_admin_grants other WHERE other.group_uuid=grant.group_uuid AND other.membership_uuid!=grant.membership_uuid AND other.member_role='owner' AND substr(other.source,1,21)!='campus_admin_inherit:')) )`, groupUUID, membershipUUID, ownerAuthority).Scan(&allowed); err != nil { return err } if allowed == 0 { return errors.New("member removal requires a local grant, sufficient authority, and at least one remaining local owner; inherited grants must be revoked at their source") } if _, err = tx.Exec(`DELETE FROM campus_admin_grants WHERE group_uuid=? AND membership_uuid=? AND substr(source,1,21)!='campus_admin_inherit:'`, groupUUID, membershipUUID); err != nil { return err } if err = projectCampusAdminMembershipsTx(tx); err != nil { return err } return tx.Commit() } // A single SQLite write serializes the check and deletion. A manager cannot // delete a member concurrently promoted to owner/manager by another request. result, err := tx.Exec(`DELETE FROM group_members WHERE group_uuid=? AND membership_uuid=? AND (? OR member_role='member') AND (member_role!='owner' OR EXISTS ( SELECT 1 FROM group_members other WHERE other.group_uuid=? AND other.membership_uuid!=? AND other.member_role='owner' ))`, groupUUID, membershipUUID, ownerAuthority, groupUUID, membershipUUID) if err != nil { return err } if count, err := result.RowsAffected(); err != nil { return err } else if count == 0 { return errors.New("member removal requires sufficient authority and at least one remaining owner") } return tx.Commit() } func (s *Store) SetGroupPermission(groupUUID, scopePath, permission string) error { permission, err := NormalizeGroupPermission(permission) if err != nil { return err } scopePath = "/" + strings.Trim(strings.TrimSpace(scopePath), "/") if scopePath == "//" { scopePath = "/" } _, err = s.DB.Exec(`INSERT INTO group_permissions(uuid,group_uuid,scope_path,permission,created_at_ms) VALUES(?,?,?,?,?) ON CONFLICT(group_uuid,scope_path) DO UPDATE SET permission=excluded.permission`, uuid.NewString(), groupUUID, scopePath, permission, time.Now().UnixMilli()) return err } func (s *Store) ListGroupPermissions(groupUUID string) ([]GroupPermission, error) { rows, err := s.DB.Query(`SELECT uuid,group_uuid,scope_path,permission FROM group_permissions WHERE group_uuid=? ORDER BY scope_path`, groupUUID) if err != nil { return nil, err } defer rows.Close() var out []GroupPermission for rows.Next() { var item GroupPermission if err := rows.Scan(&item.UUID, &item.GroupUUID, &item.ScopePath, &item.Permission); err != nil { return nil, err } out = append(out, item) } return out, rows.Err() } func (s *Store) groupPermissionAllows(domainUUID, principalUUID, capability, targetPath string) (bool, error) { return groupPermissionAllowsFrom(s.DB, domainUUID, principalUUID, capability, targetPath) } func groupPermissionAllowsFrom(q pathQueryer, domainUUID, principalUUID, capability, targetPath string) (bool, error) { rows, err := q.Query(`SELECT gp.scope_path,gp.permission FROM group_permissions gp JOIN groups g ON g.uuid=gp.group_uuid AND g.domain_uuid=? AND g.state='active' JOIN group_members gm ON gm.group_uuid=g.uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.principal_uuid=? AND m.state='active' JOIN principals p ON p.uuid=m.principal_uuid AND (p.state='active' OR (p.state='readonly' AND ?='read'))`, domainUUID, principalUUID, capability) if err != nil { return false, err } defer rows.Close() for rows.Next() { var scope, permission string if err := rows.Scan(&scope, &permission); err != nil { return false, err } inside := targetPath == scope || scope == "/" || strings.HasPrefix(targetPath, strings.TrimRight(scope, "/")+"/") if inside && groupPermissions[permission][capability] { return true, nil } } return false, rows.Err() }