package store import ( "context" "crypto/rand" "crypto/sha256" "database/sql" "encoding/base64" "errors" "fmt" "regexp" "strings" "time" "github.com/google/uuid" "golang.org/x/crypto/argon2" ) var ErrAccessDenied = errors.New("access denied") var authUsernamePattern = regexp.MustCompile(`^[a-z0-9][a-z0-9_-]{1,63}$`) type Principal struct { UUID, Username, DisplayName, Email, State string HasAvatar bool } type AuthorizationRequest struct { DomainUUID, PrincipalUUID, Capability, TargetType, TargetID string } type AuthSessionInfo struct { UUID, PrincipalUUID, DisplayName string AuthTimeMS, ExpiresAtMS, LastSeenAtMS int64 MFALevel int } func authToken() (string, string, error) { raw := make([]byte, 32) if _, err := rand.Read(raw); err != nil { return "", "", err } token := base64.RawURLEncoding.EncodeToString(raw) hash := sha256.Sum256([]byte(token)) return token, base64.RawURLEncoding.EncodeToString(hash[:]), nil } func HashPassword(password string) (string, error) { if len(password) < 12 || len(password) > 1024 { return "", errors.New("password must be between 12 and 1024 characters") } salt := make([]byte, 16) if _, err := rand.Read(salt); err != nil { return "", err } hash := argon2.IDKey([]byte(password), salt, 3, 64*1024, 2, 32) return fmt.Sprintf("$argon2id$v=19$m=65536,t=3,p=2$%s$%s", base64.RawStdEncoding.EncodeToString(salt), base64.RawStdEncoding.EncodeToString(hash)), nil } func VerifyPassword(encoded, password string) bool { parts := strings.Split(encoded, "$") if len(parts) != 6 || parts[1] != "argon2id" { return false } var memory uint32 var iterations uint32 var parallel uint8 if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &iterations, ¶llel); err != nil { return false } salt, err1 := base64.RawStdEncoding.DecodeString(parts[4]) expected, err2 := base64.RawStdEncoding.DecodeString(parts[5]) if err1 != nil || err2 != nil || memory > 256*1024 || iterations > 10 || parallel > 8 { return false } actual := argon2.IDKey([]byte(password), salt, iterations, memory, parallel, uint32(len(expected))) var mismatch byte for i := range expected { mismatch |= expected[i] ^ actual[i] } return mismatch == 0 } func (s *Store) PrincipalCount() (int, error) { var count int err := s.DB.QueryRow(`SELECT COUNT(*) FROM principals`).Scan(&count) return count, s.sqlError("principal count", err) } func (s *Store) BootstrapOwner(domainUUID, username, password, displayName, email string) (*Principal, error) { return s.BootstrapOwnerContext(context.Background(), domainUUID, username, password, displayName, email) } func (s *Store) AuthenticatePassword(identifier, password string) (*Principal, error) { identifier = strings.ToLower(strings.TrimSpace(identifier)) var p Principal var encoded string err := s.DB.QueryRow(`SELECT p.uuid,p.display_name,p.email,p.state,c.secret_hash FROM auth_credentials c JOIN principals p ON p.uuid=c.principal_uuid WHERE c.kind='password' AND c.identifier=`+s.sqlParam(1)+` AND c.enabled=1`, identifier).Scan(&p.UUID, &p.DisplayName, &p.Email, &p.State, &encoded) if err != nil || (p.State != "active" && p.State != "readonly") || !VerifyPassword(encoded, password) { return nil, ErrAccessDenied } return &p, nil } func (s *Store) CreateAuthSession(domainUUID, principalUUID string) (string, error) { return s.CreateAuthSessionWithMFA(domainUUID, principalUUID, 0) } func (s *Store) CreateAuthSessionWithMFA(domainUUID, principalUUID string, mfaLevel int) (string, error) { return s.createTypedAuthSession(domainUUID, principalUUID, mfaLevel, "pw_api_") } func (s *Store) CreateBrowserAuthSession(domainUUID, principalUUID string, mfaLevel int) (string, error) { return s.createTypedAuthSession(domainUUID, principalUUID, mfaLevel, "pw_browser_") } func (s *Store) createTypedAuthSession(domainUUID, principalUUID string, mfaLevel int, prefix string) (string, error) { return s.createTypedAuthSessionForLifetime(domainUUID, principalUUID, mfaLevel, prefix, s.AuthSessionLifetime(domainUUID)) } func (s *Store) createTypedAuthSessionForLifetime(domainUUID, principalUUID string, mfaLevel int, prefix string, lifetime time.Duration) (string, error) { raw, _, err := authToken() if err != nil { return "", err } // The purpose prefix is inside the hashed credential, so removing or // changing it cannot turn a browser token into an API token or vice versa. token := prefix + raw sum := sha256.Sum256([]byte(token)) hash := base64.RawURLEncoding.EncodeToString(sum[:]) now := time.Now().UnixMilli() // Share the administration lock with suspension and inherited-membership // revocation; an INSERT snapshot alone can race a concurrent suspension. err = s.groupWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error { result, err := tx.ExecContext(ctx, fmt.Sprintf(`INSERT INTO auth_sessions(uuid,token_hash,principal_uuid,domain_uuid,auth_time_ms,expires_at_ms,last_seen_at_ms,mfa_level) SELECT %s,%s,p.uuid,m.domain_uuid,%s,%s,%s,%s FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid WHERE p.uuid=%s AND p.state IN ('active','readonly') AND m.domain_uuid=%s AND m.state='active'`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3), s.sqlParam(4), s.sqlParam(5), s.sqlParam(6), s.sqlParam(7), s.sqlParam(8)), uuid.NewString(), hash, now, now+lifetime.Milliseconds(), now, mfaLevel, principalUUID, domainUUID) if err != nil { return err } if count, err := result.RowsAffected(); err != nil || count != 1 { return ErrAccessDenied } return nil }) if err != nil { return "", err } return token, nil } func (s *Store) PrincipalForSession(domainUUID, token string) (*Principal, error) { sum := sha256.Sum256([]byte(token)) hash := base64.RawURLEncoding.EncodeToString(sum[:]) var p Principal err := s.DB.QueryRow(fmt.Sprintf(`SELECT p.uuid,COALESCE((SELECT subject FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' ORDER BY i.subject,i.uuid LIMIT 1),p.uuid),p.display_name,p.email,p.state,length(p.avatar)>0 FROM auth_sessions s JOIN principals p ON p.uuid=s.principal_uuid JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=s.domain_uuid AND m.state='active' WHERE s.token_hash=%s AND s.domain_uuid=%s AND s.revoked_at_ms=0 AND s.expires_at_ms>%s`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3)), hash, domainUUID, time.Now().UnixMilli()).Scan(&p.UUID, &p.Username, &p.DisplayName, &p.Email, &p.State, &p.HasAvatar) if err != nil || (p.State != "active" && p.State != "readonly") { return nil, ErrAccessDenied } return &p, nil } func (s *Store) PrincipalByUsername(domainUUID, username string) (*Principal, error) { username = strings.ToLower(strings.TrimSpace(username)) var p Principal err := s.DB.QueryRow(fmt.Sprintf(`SELECT p.uuid,i.subject,p.display_name,p.email,p.state,length(p.avatar)>0 FROM principal_identities i JOIN principals p ON p.uuid=i.principal_uuid JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=%s WHERE i.provider_type='password' AND i.subject=%s ORDER BY i.uuid LIMIT 1`, s.sqlParam(1), s.sqlParam(2)), domainUUID, username).Scan(&p.UUID, &p.Username, &p.DisplayName, &p.Email, &p.State, &p.HasAvatar) return &p, s.sqlError("principal username", err) } func (s *Store) SetPrincipalAvatar(principalUUID, contentType string, data []byte) error { // An empty avatar is stored as a zero-length BLOB/BYTEA, never SQL NULL. if data == nil { data = []byte{} } _, err := s.DB.Exec(fmt.Sprintf(`UPDATE principals SET avatar=%s,avatar_content_type=%s,updated_at_ms=%s WHERE uuid=%s`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3), s.sqlParam(4)), data, contentType, time.Now().UnixMilli(), principalUUID) return s.sqlError("principal avatar update", err) } func (s *Store) PrincipalAvatar(principalUUID string) (string, []byte, error) { var contentType string var data []byte err := s.DB.QueryRow(`SELECT avatar_content_type,avatar FROM principals WHERE uuid=`+s.sqlParam(1), principalUUID).Scan(&contentType, &data) return contentType, data, s.sqlError("principal avatar", err) } func (s *Store) RevokeAuthSession(token string) error { sum := sha256.Sum256([]byte(token)) _, err := s.DB.Exec(`UPDATE auth_sessions SET revoked_at_ms=`+s.sqlParam(1)+` WHERE token_hash=`+s.sqlParam(2)+` AND revoked_at_ms=0`, time.Now().UnixMilli(), base64.RawURLEncoding.EncodeToString(sum[:])) return s.sqlError("revoke session", err) } func (s *Store) ListDomainPrincipals(domainUUID string) ([]Principal, error) { rows, err := s.DB.Query(`SELECT p.uuid,p.display_name,p.email,p.state FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid WHERE m.domain_uuid=`+s.sqlParam(1)+` ORDER BY lower(p.display_name),p.uuid`, domainUUID) if err != nil { return nil, err } defer rows.Close() var out []Principal for rows.Next() { var p Principal if err := rows.Scan(&p.UUID, &p.DisplayName, &p.Email, &p.State); err != nil { return nil, err } out = append(out, p) } return out, rows.Err() } func (s *Store) ListAuthSessions(domainUUID string) ([]AuthSessionInfo, error) { rows, err := s.DB.Query(fmt.Sprintf(`SELECT s.uuid,s.principal_uuid,p.display_name,s.auth_time_ms,s.expires_at_ms,s.last_seen_at_ms,s.mfa_level FROM auth_sessions s JOIN principals p ON p.uuid=s.principal_uuid WHERE s.domain_uuid=%s AND s.revoked_at_ms=0 AND s.expires_at_ms>%s ORDER BY s.last_seen_at_ms DESC,s.uuid`, s.sqlParam(1), s.sqlParam(2)), domainUUID, time.Now().UnixMilli()) if err != nil { return nil, err } defer rows.Close() var out []AuthSessionInfo for rows.Next() { var item AuthSessionInfo if err := rows.Scan(&item.UUID, &item.PrincipalUUID, &item.DisplayName, &item.AuthTimeMS, &item.ExpiresAtMS, &item.LastSeenAtMS, &item.MFALevel); err != nil { return nil, err } out = append(out, item) } return out, rows.Err() } func (s *Store) RevokeAuthSessionByID(domainUUID, sessionUUID string) error { result, err := s.DB.Exec(fmt.Sprintf(`UPDATE auth_sessions SET revoked_at_ms=%s WHERE domain_uuid=%s AND uuid=%s AND revoked_at_ms=0`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3)), time.Now().UnixMilli(), domainUUID, sessionUUID) if err != nil { return s.sqlError("revoke session by ID", err) } count, _ := result.RowsAffected() if count == 0 { return sql.ErrNoRows } return nil } func (s *Store) SetPrincipalState(domainUUID, principalUUID, state string) error { return s.SetPrincipalStateContext(context.Background(), domainUUID, principalUUID, state) } func (s *Store) SetPrincipalStateContext(ctx context.Context, domainUUID, principalUUID, state string) error { if state != "active" && state != "readonly" && state != "suspended" && state != "quarantined" { return errors.New("invalid principal state") } return s.groupWrite(ctx, func(ctx context.Context, tx *sql.Tx) error { result, err := tx.ExecContext(ctx, fmt.Sprintf(`UPDATE principals SET state=%s,updated_at_ms=%s WHERE uuid=%s AND EXISTS(SELECT 1 FROM domain_memberships WHERE domain_uuid=%s AND principal_uuid=%s)`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3), s.sqlParam(4), s.sqlParam(5)), state, time.Now().UnixMilli(), principalUUID, domainUUID, principalUUID) if err != nil { return err } count, err := result.RowsAffected() if err != nil { return err } if count == 0 { return sql.ErrNoRows } if state != "active" { if _, err := tx.ExecContext(ctx, fmt.Sprintf(`UPDATE auth_sessions SET revoked_at_ms=%s WHERE principal_uuid=%s AND revoked_at_ms=0`, s.sqlParam(1), s.sqlParam(2)), time.Now().UnixMilli(), principalUUID); err != nil { return err } } return s.projectCampusAdminMembershipsContext(ctx, tx) }) } func (s *Store) UpdatePrincipalProfile(principalUUID, displayName, email string) error { displayName = strings.TrimSpace(displayName) email = strings.TrimSpace(email) if displayName == "" { return errors.New("display name is required") } _, err := s.DB.Exec(fmt.Sprintf(`UPDATE principals SET display_name=%s,email=%s,updated_at_ms=%s WHERE uuid=%s`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3), s.sqlParam(4)), displayName, email, time.Now().UnixMilli(), principalUUID) return s.sqlError("principal profile update", err) } func (s *Store) CreatePasswordAccount(domainUUID, username, password, displayName, email string) (*Principal, error) { return s.CreatePasswordAccountContext(context.Background(), domainUUID, username, password, displayName, email) } func (s *Store) EnsureAuthSchema() error { if s.sqlBackend == storePostgreSQL { if err := s.ensurePostgreSQLAuthFoundation(context.Background()); err != nil { return err } return s.ensurePostgreSQLLocalityFoundation(context.Background()) } statements := []string{ `CREATE TABLE IF NOT EXISTS principals ( uuid TEXT PRIMARY KEY, display_name TEXT NOT NULL DEFAULT '', email TEXT NOT NULL DEFAULT '', state TEXT NOT NULL DEFAULT 'active', avatar BLOB NOT NULL DEFAULT X'', avatar_content_type TEXT NOT NULL DEFAULT '', created_at_ms INTEGER NOT NULL, updated_at_ms INTEGER NOT NULL)`, `CREATE TABLE IF NOT EXISTS principal_identities ( uuid TEXT PRIMARY KEY, principal_uuid TEXT NOT NULL, provider_type TEXT NOT NULL, provider_uuid TEXT NOT NULL DEFAULT '', issuer TEXT NOT NULL DEFAULT '', subject TEXT NOT NULL, attributes_json TEXT NOT NULL DEFAULT '{}', created_at_ms INTEGER NOT NULL, UNIQUE(provider_type, provider_uuid, issuer, subject))`, `CREATE TABLE IF NOT EXISTS auth_credentials ( uuid TEXT PRIMARY KEY, principal_uuid TEXT NOT NULL, kind TEXT NOT NULL, identifier TEXT NOT NULL DEFAULT '', secret_hash TEXT NOT NULL, parameters_json TEXT NOT NULL DEFAULT '{}', enabled INTEGER NOT NULL DEFAULT 1, created_at_ms INTEGER NOT NULL, updated_at_ms INTEGER NOT NULL, UNIQUE(kind, identifier))`, `CREATE TABLE IF NOT EXISTS domain_memberships ( uuid TEXT PRIMARY KEY, domain_uuid TEXT NOT NULL, principal_uuid TEXT NOT NULL, state TEXT NOT NULL DEFAULT 'active', created_at_ms INTEGER NOT NULL, UNIQUE(domain_uuid, principal_uuid))`, `CREATE TABLE IF NOT EXISTS auth_roles ( uuid TEXT PRIMARY KEY, domain_uuid TEXT NOT NULL, name TEXT NOT NULL, description TEXT NOT NULL DEFAULT '', created_at_ms INTEGER NOT NULL, UNIQUE(domain_uuid, name))`, `CREATE TABLE IF NOT EXISTS auth_role_bindings ( membership_uuid TEXT NOT NULL, role_uuid TEXT NOT NULL, created_at_ms INTEGER NOT NULL, PRIMARY KEY(membership_uuid, role_uuid))`, `CREATE TABLE IF NOT EXISTS auth_capability_grants ( uuid TEXT PRIMARY KEY, role_uuid TEXT NOT NULL, capability TEXT NOT NULL, target_type TEXT NOT NULL, target_id TEXT NOT NULL DEFAULT '*', created_at_ms INTEGER NOT NULL, UNIQUE(role_uuid, capability, target_type, target_id))`, `CREATE TABLE IF NOT EXISTS auth_sessions ( uuid TEXT PRIMARY KEY, token_hash TEXT NOT NULL UNIQUE, principal_uuid TEXT NOT NULL, domain_uuid TEXT NOT NULL, auth_time_ms INTEGER NOT NULL, expires_at_ms INTEGER NOT NULL, last_seen_at_ms INTEGER NOT NULL, mfa_level INTEGER NOT NULL DEFAULT 0, revoked_at_ms INTEGER NOT NULL DEFAULT 0)`, `CREATE TABLE IF NOT EXISTS auth_challenges ( uuid TEXT PRIMARY KEY, domain_uuid TEXT NOT NULL, principal_uuid TEXT NOT NULL DEFAULT '', kind TEXT NOT NULL, token_hash TEXT NOT NULL UNIQUE, payload_json TEXT NOT NULL DEFAULT '{}', expires_at_ms INTEGER NOT NULL, consumed_at_ms INTEGER NOT NULL DEFAULT 0, attempt_count INTEGER NOT NULL DEFAULT 0, created_at_ms INTEGER NOT NULL)`, `CREATE TABLE IF NOT EXISTS auth_providers ( uuid TEXT PRIMARY KEY, domain_uuid TEXT NOT NULL, kind TEXT NOT NULL, config_json TEXT NOT NULL DEFAULT '{}', secret_encrypted TEXT NOT NULL DEFAULT '', enabled INTEGER NOT NULL DEFAULT 0, created_at_ms INTEGER NOT NULL, updated_at_ms INTEGER NOT NULL, UNIQUE(domain_uuid,kind))`, `CREATE TABLE IF NOT EXISTS groups ( uuid TEXT PRIMARY KEY, domain_uuid TEXT NOT NULL, name TEXT NOT NULL, display_name TEXT NOT NULL DEFAULT '', description TEXT NOT NULL DEFAULT '', visibility TEXT NOT NULL DEFAULT 'members', state TEXT NOT NULL DEFAULT 'active', builtin_key TEXT NOT NULL DEFAULT '', inherit_members INTEGER NOT NULL DEFAULT 0, created_at_ms INTEGER NOT NULL, updated_at_ms INTEGER NOT NULL, UNIQUE(domain_uuid,name))`, `CREATE TABLE IF NOT EXISTS group_members ( group_uuid TEXT NOT NULL, membership_uuid TEXT NOT NULL, member_role TEXT NOT NULL DEFAULT 'member', source TEXT NOT NULL DEFAULT 'local', created_at_ms INTEGER NOT NULL, PRIMARY KEY(group_uuid,membership_uuid))`, `CREATE TABLE IF NOT EXISTS auth_group_role_bindings ( group_uuid TEXT NOT NULL, role_uuid TEXT NOT NULL, created_at_ms INTEGER NOT NULL, PRIMARY KEY(group_uuid,role_uuid))`, `CREATE TABLE IF NOT EXISTS group_permissions ( uuid TEXT PRIMARY KEY, group_uuid TEXT NOT NULL, scope_path TEXT NOT NULL, permission TEXT NOT NULL, created_at_ms INTEGER NOT NULL, UNIQUE(group_uuid,scope_path))`, `CREATE TABLE IF NOT EXISTS auth_group_mappings ( uuid TEXT PRIMARY KEY, domain_uuid TEXT NOT NULL, provider_type TEXT NOT NULL, provider_uuid TEXT NOT NULL, external_group TEXT NOT NULL, group_uuid TEXT NOT NULL, mode TEXT NOT NULL DEFAULT 'additive', enabled INTEGER NOT NULL DEFAULT 1, UNIQUE(domain_uuid,provider_type,provider_uuid,external_group))`, `CREATE TABLE IF NOT EXISTS auth_audit_log ( id INTEGER PRIMARY KEY AUTOINCREMENT, domain_uuid TEXT NOT NULL DEFAULT '', principal_uuid TEXT NOT NULL DEFAULT '', event TEXT NOT NULL, outcome TEXT NOT NULL, target_type TEXT NOT NULL DEFAULT '', target_id TEXT NOT NULL DEFAULT '', request_id TEXT NOT NULL DEFAULT '', detail_json TEXT NOT NULL DEFAULT '{}', created_at_ms INTEGER NOT NULL)`, } for _, statement := range statements { if _, err := s.DB.Exec(statement); err != nil { return err } } _, _ = s.DB.Exec(`ALTER TABLE principals ADD COLUMN avatar BLOB NOT NULL DEFAULT X''`) _, _ = s.DB.Exec(`ALTER TABLE principals ADD COLUMN avatar_content_type TEXT NOT NULL DEFAULT ''`) _, _ = s.DB.Exec(`ALTER TABLE auth_challenges ADD COLUMN attempt_count INTEGER NOT NULL DEFAULT 0`) _, _ = s.DB.Exec(`ALTER TABLE groups ADD COLUMN builtin_key TEXT NOT NULL DEFAULT ''`) _, _ = s.DB.Exec(`ALTER TABLE groups ADD COLUMN inherit_members INTEGER NOT NULL DEFAULT 0`) if err := s.ensureLocalityAccessSchema(); err != nil { return err } return s.ensureCampusAdminInheritanceSchema() } func (s *Store) Authorize(request AuthorizationRequest) error { return s.AuthorizeContext(context.Background(), request) } func (s *Store) AuthorizeContext(ctx context.Context, request AuthorizationRequest) error { return s.policyRead(ctx, func(ctx context.Context, tx *sql.Tx) error { return s.authorizeSnapshot(ctx, tx, request, false) }) } func (s *Store) authorizeSnapshot(ctx context.Context, tx *sql.Tx, request AuthorizationRequest, exactObject bool) error { request.Capability = strings.ToLower(strings.TrimSpace(request.Capability)) request.TargetType = strings.ToLower(strings.TrimSpace(request.TargetType)) base := s.authorizeGrantContext(ctx, tx, request, exactObject) if base != nil && !errors.Is(base, ErrAccessDenied) { return base } switch request.Capability { case "read", "write", "create", "upload", "rename", "link", "delete": default: return base } if request.TargetType == "object" { if err := s.checkObjectLocalityAccessCaps(ctx, tx, request.DomainUUID, request.PrincipalUUID, request.Capability, request.TargetID); err != nil { return err } } if request.TargetType != "path" { return base } p, err := s.loadLocalityAccess(cityReadQuery{ctx, tx}, request.DomainUUID, request.PrincipalUUID) if err != nil { return err } if p.Decide(request.TargetID, request.Capability, base == nil) { return nil } return ErrAccessDenied } // AuthorizeExactObject excludes broad Domain/wildcard grants. Global identity // alone must not extend a Domain administrator's authority to another Domain. func (s *Store) AuthorizeExactObject(request AuthorizationRequest) error { return s.AuthorizeExactObjectContext(context.Background(), request) } func (s *Store) AuthorizeExactObjectContext(ctx context.Context, request AuthorizationRequest) error { if request.TargetType != "object" || request.TargetID == "" || request.TargetID == "*" { return ErrAccessDenied } return s.policyRead(ctx, func(ctx context.Context, tx *sql.Tx) error { return s.authorizeSnapshot(ctx, tx, request, true) }) } func (s *Store) authorizeGrant(request AuthorizationRequest, exactObject bool) error { return s.authorizeGrantContext(context.Background(), s.DB, request, exactObject) } type authQueryer interface { groupPermissionQueryer QueryRowContext(context.Context, string, ...any) *sql.Row } func authorizeGrantFrom(q authQueryer, request AuthorizationRequest, exactObject bool) error { // Compatibility entry point for existing SQLite-only transactions. return (&Store{}).authorizeGrantContext(context.Background(), q, request, exactObject) } // Evaluates direct role bindings and group grants only. Object locality, // publication and protected namespace restrictions remain in Authorize and // must not be bypassed by treating this component as complete authorization. func (s *Store) authorizeGrantContext(ctx context.Context, q authQueryer, request AuthorizationRequest, exactObject bool) error { request.Capability = strings.ToLower(strings.TrimSpace(request.Capability)) request.TargetType = strings.ToLower(strings.TrimSpace(request.TargetType)) if request.DomainUUID == "" || request.PrincipalUUID == "" || request.Capability == "" { return ErrAccessDenied } target := fmt.Sprintf(`((g.target_type=%s AND (g.target_id=%s OR g.target_id='*')) OR (g.target_type='domain' AND g.target_id=%s))`, s.sqlParam(6), s.sqlParam(7), s.sqlParam(8)) args := []any{request.DomainUUID, request.PrincipalUUID, request.Capability, request.Capability, request.Capability, request.TargetType, request.TargetID} if exactObject { target = fmt.Sprintf(`(g.target_type=%s AND g.target_id=%s)`, s.sqlParam(6), s.sqlParam(7)) } else { args = append(args, request.DomainUUID) } var allowed bool err := q.QueryRowContext(ctx, fmt.Sprintf(`SELECT EXISTS( SELECT 1 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=%s 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 g ON g.role_uuid=r.uuid WHERE p.uuid=%s AND (p.state='active' OR (p.state='readonly' AND %s='read')) AND m.state='active' AND (g.capability=%s OR (%s IN ('create','upload') AND g.capability='write')) AND `+target+`)`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3), s.sqlParam(4), s.sqlParam(5)), args...).Scan(&allowed) if err != nil && !errors.Is(err, sql.ErrNoRows) { return s.sqlError("role grant evaluation", err) } if !allowed { if request.TargetType == "path" { groupAllowed, groupErr := s.groupPermissionAllowsContext(ctx, q, request.DomainUUID, request.PrincipalUUID, request.Capability, request.TargetID) if groupErr != nil { return groupErr } if groupAllowed { return nil } } return ErrAccessDenied } return nil } func (s *Store) PurgeExpiredAuthArtifacts() error { now := time.Now().UnixMilli() _, err := s.DB.Exec(`DELETE FROM auth_challenges WHERE expires_at_ms<`+s.sqlParam(1)+` OR consumed_at_ms>0`, now) return s.sqlError("expired auth artifacts", err) }