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 = insertIdentityEventInOrg(ctx, postgresdb.New(tx), orgID, 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() }