Files
pages/internal/store/auth.go
T
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

552 lines
24 KiB
Go

package store
import (
"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, &parallel); 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, err
}
func (s *Store) BootstrapOwner(domainUUID, username, password, displayName, email string) (*Principal, error) {
username = strings.ToLower(strings.TrimSpace(username))
if !authUsernamePattern.MatchString(username) {
return nil, errors.New("username must be 2-64 lowercase letters, digits, underscores, or hyphens")
}
encoded, err := HashPassword(password)
if err != nil {
return nil, err
}
tx, err := s.DB.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback()
var count int
if err = tx.QueryRow(`SELECT COUNT(*) FROM principals`).Scan(&count); err != nil || count != 0 {
if err == nil {
err = errors.New("owner already exists")
}
return nil, err
}
now := time.Now().UnixMilli()
principalID, membershipID, roleID := uuid.NewString(), uuid.NewString(), uuid.NewString()
if strings.TrimSpace(displayName) == "" {
displayName = username
}
queries := []struct {
q string
args []any
}{
{`INSERT INTO principals(uuid,display_name,email,state,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?)`, []any{principalID, displayName, strings.TrimSpace(email), "active", now, now}},
{`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,subject,created_at_ms) VALUES(?,?,?,?,?)`, []any{uuid.NewString(), principalID, "password", username, now}},
{`INSERT INTO auth_credentials(uuid,principal_uuid,kind,identifier,secret_hash,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?,?)`, []any{uuid.NewString(), principalID, "password", username, encoded, now, now}},
{`INSERT INTO domain_memberships(uuid,domain_uuid,principal_uuid,state,created_at_ms) VALUES(?,?,?,?,?)`, []any{membershipID, domainUUID, principalID, "active", now}},
{`INSERT INTO auth_roles(uuid,domain_uuid,name,description,created_at_ms) VALUES(?,?,?,?,?)`, []any{roleID, domainUUID, "owner", "Domain owner", now}},
{`INSERT INTO auth_role_bindings(membership_uuid,role_uuid,created_at_ms) VALUES(?,?,?)`, []any{membershipID, roleID, now}},
}
for _, item := range queries {
if _, err = tx.Exec(item.q, item.args...); err != nil {
return nil, err
}
}
for _, capability := range []string{"read", "write", "rename", "delete", "link", "manage", "delegate"} {
if _, err = tx.Exec(`INSERT INTO auth_capability_grants(uuid,role_uuid,capability,target_type,target_id,created_at_ms) VALUES(?,?,?,?,?,?)`, uuid.NewString(), roleID, capability, "domain", domainUUID, now); err != nil {
return nil, err
}
}
if err = tx.Commit(); err != nil {
return nil, err
}
if err = s.EnsureBuiltinAdminGroups(); err != nil {
return nil, err
}
return &Principal{UUID: principalID, DisplayName: displayName, Email: email, State: "active"}, nil
}
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=? 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) {
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()
result, err := s.DB.Exec(`INSERT INTO auth_sessions(uuid,token_hash,principal_uuid,domain_uuid,auth_time_ms,expires_at_ms,last_seen_at_ms,mfa_level)
SELECT ?,?,p.uuid,m.domain_uuid,?,?,?,? FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid
WHERE p.uuid=? AND p.state IN ('active','readonly') AND m.domain_uuid=? AND m.state='active'`,
uuid.NewString(), hash, now, now+int64((24*time.Hour)/time.Millisecond), now, mfaLevel, principalUUID, domainUUID)
if err != nil {
return "", err
}
if count, err := result.RowsAffected(); err != nil || count != 1 {
return "", ErrAccessDenied
}
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(`SELECT 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,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=? AND s.domain_uuid=? AND s.revoked_at_ms=0 AND s.expires_at_ms>?`, 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(`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=? WHERE i.provider_type='password' AND i.subject=?`, domainUUID, username).Scan(&p.UUID, &p.Username, &p.DisplayName, &p.Email, &p.State, &p.HasAvatar)
return &p, err
}
func (s *Store) SetPrincipalAvatar(principalUUID, contentType string, data []byte) error {
_, err := s.DB.Exec(`UPDATE principals SET avatar=?,avatar_content_type=?,updated_at_ms=? WHERE uuid=?`, data, contentType, time.Now().UnixMilli(), principalUUID)
return 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=?`, principalUUID).Scan(&contentType, &data)
return contentType, data, err
}
func (s *Store) RevokeAuthSession(token string) error {
sum := sha256.Sum256([]byte(token))
_, err := s.DB.Exec(`UPDATE auth_sessions SET revoked_at_ms=? WHERE token_hash=?`, time.Now().UnixMilli(), base64.RawURLEncoding.EncodeToString(sum[:]))
return 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=? 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(`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=? AND s.revoked_at_ms=0 AND s.expires_at_ms>? ORDER BY s.last_seen_at_ms DESC`, 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(`UPDATE auth_sessions SET revoked_at_ms=? WHERE domain_uuid=? AND uuid=? AND revoked_at_ms=0`, time.Now().UnixMilli(), domainUUID, sessionUUID)
if err != nil {
return err
}
count, _ := result.RowsAffected()
if count == 0 {
return sql.ErrNoRows
}
return nil
}
func (s *Store) SetPrincipalState(domainUUID, principalUUID, state string) error {
if state != "active" && state != "readonly" && state != "suspended" && state != "quarantined" {
return errors.New("invalid principal state")
}
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
result, err := tx.Exec(`UPDATE principals SET state=?,updated_at_ms=? WHERE uuid=? AND EXISTS(SELECT 1 FROM domain_memberships WHERE domain_uuid=? AND principal_uuid=?)`, state, time.Now().UnixMilli(), principalUUID, domainUUID, principalUUID)
if err != nil {
return err
}
count, _ := result.RowsAffected()
if count == 0 {
return sql.ErrNoRows
}
if state != "active" {
if _, err = tx.Exec(`UPDATE auth_sessions SET revoked_at_ms=? WHERE principal_uuid=?`, time.Now().UnixMilli(), principalUUID); err != nil {
return err
}
}
if err = projectCampusAdminMembershipsTx(tx); err != nil {
return err
}
return tx.Commit()
}
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(`UPDATE principals SET display_name=?,email=?,updated_at_ms=? WHERE uuid=?`, displayName, email, time.Now().UnixMilli(), principalUUID)
return err
}
func (s *Store) CreatePasswordAccount(domainUUID, username, password, displayName, email string) (*Principal, error) {
username = strings.ToLower(strings.TrimSpace(username))
if !authUsernamePattern.MatchString(username) {
return nil, errors.New("username must be 2-64 lowercase letters, digits, underscores, or hyphens")
}
encoded, err := HashPassword(password)
if err != nil {
return nil, err
}
tx, err := s.DB.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback()
now := time.Now().UnixMilli()
p := &Principal{UUID: uuid.NewString(), DisplayName: strings.TrimSpace(displayName), Email: strings.TrimSpace(email), State: "active"}
if p.DisplayName == "" {
p.DisplayName = username
}
membershipID := uuid.NewString()
roleID := ""
err = tx.QueryRow(`SELECT uuid FROM auth_roles WHERE domain_uuid=? AND name='member'`, domainUUID).Scan(&roleID)
if errors.Is(err, sql.ErrNoRows) {
roleID = uuid.NewString()
if _, err = tx.Exec(`INSERT INTO auth_roles(uuid,domain_uuid,name,description,created_at_ms) VALUES(?,?,?,?,?)`, roleID, domainUUID, "member", "Domain member", now); err != nil {
return nil, err
}
if _, err = tx.Exec(`INSERT INTO auth_capability_grants(uuid,role_uuid,capability,target_type,target_id,created_at_ms) VALUES(?,?,?,?,?,?)`, uuid.NewString(), roleID, "read", "domain", domainUUID, now); err != nil {
return nil, err
}
} else if err != nil {
return nil, err
}
queries := []struct {
q string
args []any
}{{`INSERT INTO principals(uuid,display_name,email,state,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?)`, []any{p.UUID, p.DisplayName, p.Email, p.State, now, now}}, {`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,subject,created_at_ms) VALUES(?,?,?,?,?)`, []any{uuid.NewString(), p.UUID, "password", username, now}}, {`INSERT INTO auth_credentials(uuid,principal_uuid,kind,identifier,secret_hash,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?,?)`, []any{uuid.NewString(), p.UUID, "password", username, encoded, now, now}}, {`INSERT INTO domain_memberships(uuid,domain_uuid,principal_uuid,state,created_at_ms) VALUES(?,?,?,?,?)`, []any{membershipID, domainUUID, p.UUID, "active", now}}, {`INSERT INTO auth_role_bindings(membership_uuid,role_uuid,created_at_ms) VALUES(?,?,?)`, []any{membershipID, roleID, now}}}
for _, item := range queries {
if _, err = tx.Exec(item.q, item.args...); err != nil {
return nil, err
}
}
if err = tx.Commit(); err != nil {
return nil, err
}
return p, nil
}
func (s *Store) EnsureAuthSchema() error {
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 {
request.Capability = strings.ToLower(strings.TrimSpace(request.Capability))
request.TargetType = strings.ToLower(strings.TrimSpace(request.TargetType))
base := s.authorizeGrant(request, false)
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(request.DomainUUID, request.PrincipalUUID, request.Capability, request.TargetID); err != nil {
return err
}
}
if request.TargetType != "path" {
return base
}
p, err := loadLocalityAccess(s.DB, 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 {
if request.TargetType != "object" || request.TargetID == "" || request.TargetID == "*" {
return ErrAccessDenied
}
request.Capability = strings.ToLower(strings.TrimSpace(request.Capability))
switch request.Capability {
case "read", "write", "create", "upload", "rename", "link", "delete":
if err := s.CheckObjectLocalityAccessCaps(request.DomainUUID, request.PrincipalUUID, request.Capability, request.TargetID); err != nil {
return err
}
}
return s.authorizeGrant(request, true)
}
func (s *Store) authorizeGrant(request AuthorizationRequest, exactObject bool) error {
return authorizeGrantFrom(s.DB, request, exactObject)
}
type authQueryer interface {
pathQueryer
QueryRow(string, ...any) *sql.Row
}
func authorizeGrantFrom(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 := `((g.target_type=? AND (g.target_id=? OR g.target_id='*')) OR (g.target_type='domain' AND g.target_id=?))`
args := []any{request.DomainUUID, request.PrincipalUUID, request.Capability, request.Capability, request.Capability, request.TargetType, request.TargetID}
if exactObject {
target = `(g.target_type=? AND g.target_id=?)`
} else {
args = append(args, request.DomainUUID)
}
var allowed int
err := q.QueryRow(`SELECT EXISTS(
SELECT 1 FROM principals p
JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.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 g ON g.role_uuid=r.uuid
WHERE p.uuid=? AND (p.state='active' OR (p.state='readonly' AND ?='read')) AND m.state='active'
AND (g.capability=? OR (? IN ('create','upload') AND g.capability='write'))
AND `+target+`)`, args...).Scan(&allowed)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
}
if allowed == 0 {
if request.TargetType == "path" {
groupAllowed, groupErr := groupPermissionAllowsFrom(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<? OR consumed_at_ms>0`, now)
return err
}