120 lines
4.8 KiB
Go
120 lines
4.8 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
// Account identity, credential, membership and role bindings are committed
|
|
// together. Password hashing intentionally happens before acquiring DB locks.
|
|
func (s *Store) createPasswordAccountContext(ctx context.Context, domain, username, password, displayName, email string, bootstrap bool) (*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")
|
|
}
|
|
if err := ctx.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
encoded, err := HashPassword(password)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
p := &Principal{UUID: uuid.NewString(), DisplayName: strings.TrimSpace(displayName), Email: strings.TrimSpace(email), State: "active"}
|
|
if p.DisplayName == "" {
|
|
p.DisplayName = username
|
|
}
|
|
err = s.groupWrite(ctx, func(ctx context.Context, tx *sql.Tx) error {
|
|
if bootstrap {
|
|
var count int
|
|
if err := tx.QueryRowContext(ctx, `SELECT count(*) FROM principals`).Scan(&count); err != nil {
|
|
return err
|
|
}
|
|
if count != 0 {
|
|
return namespaceValidationError("owner already exists")
|
|
}
|
|
}
|
|
// PostgreSQL cannot bootstrap into a nonexistent or disabled namespace.
|
|
// SQLite retains its historical authentication-only fixture support.
|
|
if s.sqlBackend == storePostgreSQL {
|
|
var present bool
|
|
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM domains WHERE uuid=$1 AND enabled=1 AND placement='local')`, domain).Scan(&present); err != nil {
|
|
return err
|
|
}
|
|
if !present {
|
|
return sql.ErrNoRows
|
|
}
|
|
}
|
|
now := time.Now().UnixMilli()
|
|
membership, role := uuid.NewString(), ""
|
|
roleName, description := "member", "Domain member"
|
|
if bootstrap {
|
|
roleName, description = "owner", "Domain owner"
|
|
}
|
|
err := tx.QueryRowContext(ctx, `SELECT uuid FROM auth_roles WHERE domain_uuid=`+s.sqlParam(1)+` AND name=`+s.sqlParam(2), domain, roleName).Scan(&role)
|
|
if bootstrap && err == nil {
|
|
return namespaceValidationError("owner role already exists")
|
|
}
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
role = uuid.NewString()
|
|
if _, err = tx.ExecContext(ctx, `INSERT INTO auth_roles(uuid,domain_uuid,name,description,created_at_ms) VALUES(`+s.sqlValues(5)+`)`, role, domain, roleName, description, now); err != nil {
|
|
return err
|
|
}
|
|
capabilities := []string{"read"}
|
|
if bootstrap {
|
|
capabilities = []string{"read", "write", "rename", "delete", "link", "manage", "delegate"}
|
|
}
|
|
for _, capability := range capabilities {
|
|
if _, err = tx.ExecContext(ctx, `INSERT INTO auth_capability_grants(uuid,role_uuid,capability,target_type,target_id,created_at_ms) VALUES(`+s.sqlValues(6)+`)`, uuid.NewString(), role, capability, "domain", domain, now); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
} else if err != nil {
|
|
return err
|
|
}
|
|
queries := []struct {
|
|
q string
|
|
args []any
|
|
}{
|
|
{`INSERT INTO principals(uuid,display_name,email,state,created_at_ms,updated_at_ms) VALUES(` + s.sqlValues(6) + `)`, []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(` + s.sqlValues(5) + `)`, []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(` + s.sqlValues(7) + `)`, []any{uuid.NewString(), p.UUID, "password", username, encoded, now, now}},
|
|
{`INSERT INTO domain_memberships(uuid,domain_uuid,principal_uuid,state,created_at_ms) VALUES(` + s.sqlValues(5) + `)`, []any{membership, domain, p.UUID, "active", now}},
|
|
{`INSERT INTO auth_role_bindings(membership_uuid,role_uuid,created_at_ms) VALUES(` + s.sqlValues(3) + `)`, []any{membership, role, now}},
|
|
}
|
|
for _, q := range queries {
|
|
if _, err := tx.ExecContext(ctx, q.q, q.args...); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if bootstrap {
|
|
if s.sqlBackend == storeSQLite {
|
|
var present bool
|
|
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE name='domains' AND type='table')`).Scan(&present); err != nil {
|
|
return err
|
|
}
|
|
if !present {
|
|
return nil
|
|
}
|
|
}
|
|
return s.ensureBuiltinAdminGroupsContext(ctx, tx)
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return p, nil
|
|
}
|
|
|
|
func (s *Store) BootstrapOwnerContext(ctx context.Context, domain, username, password, displayName, email string) (*Principal, error) {
|
|
return s.createPasswordAccountContext(ctx, domain, username, password, displayName, email, true)
|
|
}
|
|
func (s *Store) CreatePasswordAccountContext(ctx context.Context, domain, username, password, displayName, email string) (*Principal, error) {
|
|
return s.createPasswordAccountContext(ctx, domain, username, password, displayName, email, false)
|
|
}
|