Files
archie/internal/infrastructure/postgres/accounts.go
T

287 lines
10 KiB
Go

package postgres
import (
"context"
"crypto/rand"
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
"strings"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/samcharles93/archie-core/internal/domain/access"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/postgresdb"
)
func (s *Store) AccountSetupRequired(ctx context.Context) (bool, error) {
var required bool
err := s.pool.QueryRow(ctx, `SELECT NOT EXISTS (SELECT 1 FROM accounts)`).Scan(&required)
return required, err
}
func (s *Store) RegisterAccount(ctx context.Context, r identity.AccountRegistration, bootstrap bool) (identity.Identity, error) {
role, orgID, err := accountRegistrationScope(ctx, &r, bootstrap)
if err != nil {
return identity.Identity{}, err
}
hash, err := identity.HashPassword(r.Password)
if err != nil {
return identity.Identity{}, err
}
tx, err := s.pool.Begin(ctx)
if err != nil {
return identity.Identity{}, err
}
defer func() { _ = tx.Rollback(ctx) }()
// Every registration shares this lock so only one transaction can bootstrap.
if _, err = tx.Exec(ctx, `SELECT pg_advisory_xact_lock(484726231)`); err != nil {
return identity.Identity{}, err
}
var anyAccounts bool
if err = tx.QueryRow(ctx, `SELECT EXISTS (SELECT 1 FROM accounts)`).Scan(&anyAccounts); err != nil {
return identity.Identity{}, err
}
if bootstrap && anyAccounts {
return identity.Identity{}, identity.ErrSetupComplete
}
if !bootstrap && !anyAccounts {
return identity.Identity{}, identity.ErrCredentialRejected
}
value, err := writeAccount(ctx, tx, r, bootstrap, orgID, role, hash)
if err != nil {
return identity.Identity{}, err
}
if err = tx.Commit(ctx); err != nil {
return identity.Identity{}, err
}
return value, nil
}
func writeAccount(ctx context.Context, tx pgx.Tx, r identity.AccountRegistration, bootstrap bool, orgID org.OrgID, role org.Role, hash string) (identity.Identity, error) {
id := identity.IdentityID(rand.Text())
if bootstrap {
id = identity.OperatorID()
}
value, err := identity.New(id, identity.KindUser, r.DisplayName)
if err != nil {
return identity.Identity{}, err
}
now := time.Now().UTC()
value.CreatedAt, value.UpdatedAt = now, now
if bootstrap {
if err := setupAccountOrganisation(ctx, tx, r, orgID, now); err != nil {
return identity.Identity{}, err
}
}
_, err = tx.Exec(ctx, `INSERT INTO identities (id,kind,display_name,lifecycle,version,created_at,updated_at) VALUES ($1,'user',$2,'active',1,$3,$3)
ON CONFLICT (id) DO UPDATE SET display_name=EXCLUDED.display_name, lifecycle='active',version=identities.version+1,updated_at=EXCLUDED.updated_at`, string(id), r.DisplayName, now)
if err != nil {
return identity.Identity{}, err
}
_, err = tx.Exec(ctx, `INSERT INTO accounts (identity_id,email,password_hash) VALUES ($1,$2,$3)`, string(id), r.Email, hash)
if err != nil {
var pgerr *pgconn.PgError
if errors.As(err, &pgerr) && pgerr.Code == "23505" {
return identity.Identity{}, identity.ErrConflict
}
return identity.Identity{}, err
}
_, err = tx.Exec(ctx, `INSERT INTO memberships (identity_id,org_id,role) VALUES ($1,$2,$3) ON CONFLICT (identity_id,org_id,(COALESCE(workspace_id,''))) DO UPDATE SET role=EXCLUDED.role`, string(id), string(orgID), string(role))
if err != nil {
return identity.Identity{}, err
}
actor := id
if p, ok := access.PrincipalFromContext(ctx); ok {
actor = p.IdentityID
}
err = insertIdentityEvent(ctx, postgresdb.New(tx), id, identity.Event{Type: "create", To: identity.LifecycleActive, DisplayName: r.DisplayName}, identity.Audit{ActorID: actor, Source: "accounts", RequestID: "account:" + rand.Text()}, now)
if err != nil {
return identity.Identity{}, err
}
return value, nil
}
func sessionHash(token string) string {
sum := sha256.Sum256([]byte(token))
return hex.EncodeToString(sum[:])
}
func (s *Store) SignInAccount(ctx context.Context, email, password string) (identity.AccountSession, error) {
tx, err := s.pool.Begin(ctx)
if err != nil {
return identity.AccountSession{}, err
}
defer func() { _ = tx.Rollback(ctx) }()
var id, hash string
var attempts int
var locked *time.Time
err = tx.QueryRow(ctx, `SELECT identity_id,password_hash,failed_attempts,locked_until FROM accounts WHERE email=$1 FOR UPDATE`, strings.ToLower(strings.TrimSpace(email))).Scan(&id, &hash, &attempts, &locked)
if errors.Is(err, pgx.ErrNoRows) {
// An unknown email still pays the password hashing cost.
_, hashErr := identity.HashPassword("unknown account dummy password")
if hashErr != nil {
return identity.AccountSession{}, hashErr
}
return identity.AccountSession{}, identity.ErrCredentialRejected
}
if err != nil {
return identity.AccountSession{}, err
}
valid := identity.VerifyPassword(password, hash)
if locked != nil && time.Now().Before(*locked) {
return identity.AccountSession{}, identity.ErrCredentialRejected
}
if !valid {
return identity.AccountSession{}, recordFailedAccountLogin(ctx, tx, id, attempts, locked)
}
row, err := postgresdb.New(tx).GetIdentity(ctx, id)
if err != nil {
return identity.AccountSession{}, err
}
value := identityFromRow(row)
if !value.CanAct() {
return identity.AccountSession{}, identity.ErrCredentialRejected
}
token := rand.Text()
expires := time.Now().UTC().Add(identity.AccountSessionLifetime)
if _, err = tx.Exec(ctx, `UPDATE accounts SET failed_attempts=0,locked_until=NULL WHERE identity_id=$1`, id); err != nil {
return identity.AccountSession{}, err
}
if _, err = tx.Exec(ctx, `DELETE FROM account_sessions WHERE expires_at<=now()`); err != nil {
return identity.AccountSession{}, err
}
if _, err = tx.Exec(ctx, `INSERT INTO account_sessions (token_hash,identity_id,expires_at) VALUES ($1,$2,$3)`, sessionHash(token), id, expires); err != nil {
return identity.AccountSession{}, err
}
if err = tx.Commit(ctx); err != nil {
return identity.AccountSession{}, err
}
return identity.AccountSession{Identity: value, Token: token, Expires: expires}, nil
}
func (s *Store) ResolveAccountSession(ctx context.Context, token string) (identity.Identity, error) {
if len(token) < 26 || len(token) > 128 {
return identity.Identity{}, identity.ErrCredentialRejected
}
var id string
err := s.pool.QueryRow(ctx, `SELECT s.identity_id FROM account_sessions s JOIN identities i ON i.id=s.identity_id WHERE s.token_hash=$1 AND s.expires_at>now() AND i.lifecycle='active'`, sessionHash(token)).Scan(&id)
if errors.Is(err, pgx.ErrNoRows) {
return identity.Identity{}, identity.ErrCredentialRejected
}
if err != nil {
return identity.Identity{}, err
}
row, err := s.queries().GetIdentity(ctx, id)
return identityFromRow(row), err
}
func (s *Store) SignOutAccount(ctx context.Context, token string) error {
_, err := s.pool.Exec(ctx, `DELETE FROM account_sessions WHERE token_hash=$1`, sessionHash(token))
return err
}
func (s *Store) ChangeAccountPassword(ctx context.Context, current, next string) error {
p, ok := access.PrincipalFromContext(ctx)
if !ok {
return identity.ErrCredentialRejected
}
hash, err := identity.HashPassword(next)
if err != nil {
return err
}
tx, err := s.pool.Begin(ctx)
if err != nil {
return err
}
defer func() { _ = tx.Rollback(ctx) }()
var old string
err = tx.QueryRow(ctx, `SELECT password_hash FROM accounts WHERE identity_id=$1 FOR UPDATE`, string(p.IdentityID)).Scan(&old)
if errors.Is(err, pgx.ErrNoRows) {
return identity.ErrCredentialRejected
}
if err != nil {
return err
}
if !identity.VerifyPassword(current, old) {
return identity.ErrCredentialRejected
}
if _, err = tx.Exec(ctx, `UPDATE accounts SET password_hash=$2,failed_attempts=0,locked_until=NULL WHERE identity_id=$1`, string(p.IdentityID), hash); err != nil {
return err
}
if _, err = tx.Exec(ctx, `DELETE FROM account_sessions WHERE identity_id=$1`, string(p.IdentityID)); err != nil {
return err
}
return tx.Commit(ctx)
}
func accountRegistrationScope(ctx context.Context, r *identity.AccountRegistration, bootstrap bool) (org.Role, org.OrgID, error) {
if err := r.Validate(); err != nil {
return "", "", err
}
role := org.Role(r.Role)
orgID := org.OrgFromContext(ctx)
if bootstrap {
if err := validateAccountSetup(r); err != nil {
return "", "", err
}
return org.RoleOwner, org.DefaultOrgID, nil
}
p, ok := access.PrincipalFromContext(ctx)
if !ok || p.Org != orgID {
return "", "", identity.ErrCredentialRejected
}
if role != org.RoleAdmin && role != org.RoleDeveloper && role != org.RoleViewer {
return "", "", identity.ErrInvalid
}
return role, orgID, nil
}
func recordFailedAccountLogin(ctx context.Context, tx pgx.Tx, id string, attempts int, locked *time.Time) error {
if locked != nil {
attempts = 0
}
if _, err := tx.Exec(ctx, `UPDATE accounts SET failed_attempts=$2,locked_until=CASE WHEN $2>=5 THEN now()+interval '15 minutes' ELSE NULL END WHERE identity_id=$1`, id, attempts+1); err != nil {
return err
}
if err := tx.Commit(ctx); err != nil {
return err
}
return identity.ErrCredentialRejected
}
func setupAccountOrganisation(ctx context.Context, tx pgx.Tx, r identity.AccountRegistration, orgID org.OrgID, now time.Time) error {
_, err := tx.Exec(ctx, `UPDATE orgs SET name=$1, updated_at=$2 WHERE id=$3`, r.OrganisationName, now, string(orgID))
if err != nil {
return err
}
if _, err := tx.Exec(ctx, `UPDATE workspaces SET name=$1,updated_at=$2 WHERE org_id=$3 AND id=$4`, r.WorkspaceName, now, string(orgID), string(org.DefaultWorkspaceID)); err != nil {
return err
}
if _, err := tx.Exec(ctx, `INSERT INTO authentication_settings (public_url) VALUES ($1)`, r.PublicURL); err != nil {
return err
}
return nil
}
func validateAccountSetup(r *identity.AccountRegistration) error {
r.OrganisationName = strings.TrimSpace(r.OrganisationName)
r.WorkspaceName = strings.TrimSpace(r.WorkspaceName)
r.PublicURL = strings.TrimRight(r.PublicURL, "/")
if r.WorkspaceName == "" || len(r.WorkspaceName) > 200 {
return identity.ErrInvalid
}
if r.OrganisationName == "" || len(r.OrganisationName) > 200 {
return fmt.Errorf("%w: organisation name is required", identity.ErrInvalid)
}
return (identity.AuthenticationSettings{PublicURL: r.PublicURL}).Validate()
}