feat(storage): add native PostgreSQL runtime and verified offline application import
Build and publish container images / images (push) Failing after 12m29s

This commit is contained in:
Anya Tokugawa committed 2026-11-15 05:47:14 +09:00
1 parent 96065d1e89
commit 0ba1dcfef0
243 files changed
+21441 -3090

No files matched your search

+111 -170
View File
@@ -1,6 +1,7 @@
package store
import (
"context"
"crypto/rand"
"crypto/sha256"
"database/sql"
@@ -82,70 +83,18 @@ func VerifyPassword(encoded, password string) bool {
func (s *Store) PrincipalCount() (int, error) {
var count int
err := s.DB.QueryRow(`SELECT COUNT(*) FROM principals`).Scan(&count)
return count, err
return count, s.sqlError("principal 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
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=? AND c.enabled=1`, identifier).Scan(&p.UUID, &p.DisplayName, &p.Email, &p.State, &encoded)
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
}
@@ -178,25 +127,33 @@ func (s *Store) createTypedAuthSessionForLifetime(domainUUID, principalUUID stri
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)
// 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
}
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
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=? 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)
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
}
@@ -206,28 +163,32 @@ func (s *Store) PrincipalForSession(domainUUID, token string) (*Principal, error
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
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 {
_, err := s.DB.Exec(`UPDATE principals SET avatar=?,avatar_content_type=?,updated_at_ms=? WHERE uuid=?`, data, contentType, time.Now().UnixMilli(), principalUUID)
return err
// 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=?`, principalUUID).Scan(&contentType, &data)
return contentType, data, err
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=? WHERE token_hash=?`, time.Now().UnixMilli(), base64.RawURLEncoding.EncodeToString(sum[:]))
return err
_, 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=? ORDER BY lower(p.display_name),p.uuid`, domainUUID)
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
}
@@ -243,7 +204,7 @@ func (s *Store) ListDomainPrincipals(domainUUID string) ([]Principal, error) {
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())
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
}
@@ -259,9 +220,9 @@ func (s *Store) ListAuthSessions(domainUUID string) ([]AuthSessionInfo, error) {
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)
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 err
return s.sqlError("revoke session by ID", err)
}
count, _ := result.RowsAffected()
if count == 0 {
@@ -270,31 +231,32 @@ func (s *Store) RevokeAuthSessionByID(domainUUID, sessionUUID string) error {
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")
}
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 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
}
}
if err = projectCampusAdminMembershipsTx(tx); err != nil {
return err
}
return tx.Commit()
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 {
@@ -303,59 +265,21 @@ func (s *Store) UpdatePrincipalProfile(principalUUID, displayName, email string)
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
_, 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) {
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
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 '',
@@ -453,9 +377,19 @@ func (s *Store) EnsureAuthSchema() error {
}
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.authorizeGrant(request, false)
base := s.authorizeGrantContext(ctx, tx, request, exactObject)
if base != nil && !errors.Is(base, ErrAccessDenied) {
return base
}
@@ -465,14 +399,14 @@ func (s *Store) Authorize(request AuthorizationRequest) error {
return base
}
if request.TargetType == "object" {
if err := s.CheckObjectLocalityAccessCaps(request.DomainUUID, request.PrincipalUUID, request.Capability, request.TargetID); err != nil {
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 := loadLocalityAccess(s.DB, request.DomainUUID, request.PrincipalUUID)
p, err := s.loadLocalityAccess(cityReadQuery{ctx, tx}, request.DomainUUID, request.PrincipalUUID)
if err != nil {
return err
}
@@ -485,57 +419,64 @@ func (s *Store) Authorize(request AuthorizationRequest) error {
// 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
}
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)
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 authorizeGrantFrom(s.DB, request, exactObject)
return s.authorizeGrantContext(context.Background(), s.DB, request, exactObject)
}
type authQueryer interface {
pathQueryer
QueryRow(string, ...any) *sql.Row
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 := `((g.target_type=? AND (g.target_id=? OR g.target_id='*')) OR (g.target_type='domain' AND g.target_id=?))`
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 = `(g.target_type=? AND g.target_id=?)`
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 int
err := q.QueryRow(`SELECT EXISTS(
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=?
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=? 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)
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 err
return s.sqlError("role grant evaluation", err)
}
if allowed == 0 {
if !allowed {
if request.TargetType == "path" {
groupAllowed, groupErr := groupPermissionAllowsFrom(q, request.DomainUUID, request.PrincipalUUID, request.Capability, request.TargetID)
groupAllowed, groupErr := s.groupPermissionAllowsContext(ctx, q, request.DomainUUID, request.PrincipalUUID, request.Capability, request.TargetID)
if groupErr != nil {
return groupErr
}
@@ -550,6 +491,6 @@ func authorizeGrantFrom(q authQueryer, request AuthorizationRequest, exactObject
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
_, 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)
}