556 lines
25 KiB
Go
556 lines
25 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, ¶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, 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) {
|
|
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()
|
|
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+lifetime.Milliseconds(), 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
|
|
}
|