standard_id 0.54.1 → 0.55.0

data/db/migrate/20261022000000_add_signup_source_to_standard_id_identifiers.rb

@@ -0,0 +1,13 @@
+# Records which flow created an identifier's sign-up. EmailPassword::Registration
+# writes "email_password"; nothing else writes it, so NULL means any other
+# sign-up (Web::SignupForm, social, passwordless, the host's own). The email +
+# password API reads it to tell its own pending sign-ups apart: a password
+# reset runs `after_email_verified` only for them, and
+# PurgeUnverifiedEmailSignupsJob only ever deletes them. One nullable string
+# column, no default, no index: metadata-only on PostgreSQL. Required before
+# enabling `c.email_password`.
+class AddSignupSourceToStandardIdIdentifiers < ActiveRecord::Migration[8.0]
+  def change
+    add_column :standard_id_identifiers, :signup_source, :string
+  end
+end

data/lib/standard_id/access_revocation.rb

@@ -0,0 +1,40 @@
+module StandardId
+  # Ends everything an account is signed in with: every session (cascading to
+  # the refresh tokens under it), then every refresh token with no session, such
+  # as one minted by a grant flow. Sessions alone would leave those alive.
+  # Revoking rather than destroying keeps the audit trail and fires one
+  # SESSION_REVOKED per session.
+  #
+  # Runs in one transaction, so a caller that wraps it in its own (a password
+  # change, say) commits the change and the revocation together. The
+  # SESSION_REVOKED events then publish before that commit; each is rescued
+  # (see Session.publish_session_revocations), so a subscriber cannot roll the
+  # change back, but one that reads the rows must do so after commit.
+  #
+  # Access tokens already issued are stateless JWTs and stay valid until they
+  # expire.
+  module AccessRevocation
+    module_function
+
+    # @param account [ActiveRecord::Base]
+    # @param reason [String] carried on each SESSION_REVOKED event
+    # @param issued_before [Time, nil] only revoke sessions and refresh tokens
+    #   CREATED before this. Activity (updated_at) never spares one.
+    def revoke_all!(account, reason:, issued_before: nil)
+      ActiveRecord::Base.transaction do
+        if issued_before
+          sessions = StandardId::Session
+            .where(account_id: account.id, revoked_at: nil)
+            .where(created_at: ...issued_before)
+          StandardId::Session.revoke_sessions!(sessions, account: account, reason: reason)
+        else
+          StandardId::Session.revoke_all_for!(account, reason: reason)
+        end
+
+        refresh_tokens = StandardId::RefreshToken.where(account_id: account.id, revoked_at: nil)
+        refresh_tokens = refresh_tokens.where(created_at: ...issued_before) if issued_before
+        refresh_tokens.update_all(revoked_at: Time.current)
+      end
+    end
+  end
+end

data/lib/standard_id/config/callable_validator.rb

@@ -70,6 +70,41 @@ module StandardId
           signature: "(audience:, client:, configured_scopes:)",
           kind: :keyword,
           keywords: %i[audience client configured_scopes]
+        },
+        "email_password.reset_url" => {
+          signature: "(request:)",
+          kind: :keyword,
+          keywords: %i[request]
+        },
+        "email_password.client_key" => {
+          signature: "(request:)",
+          kind: :keyword,
+          keywords: %i[request]
+        },
+        "email_password.account_creator" => {
+          signature: "(email:, name:, request:)",
+          kind: :keyword,
+          keywords: %i[email name request]
+        },
+        "email_password.password_validator" => {
+          signature: "(password:, email:)",
+          kind: :keyword,
+          keywords: %i[password email]
+        },
+        "email_password.after_email_verified" => {
+          signature: "(account:, name:, request:)",
+          kind: :keyword,
+          keywords: %i[account name request]
+        },
+        "email_password.account_in_use" => {
+          signature: "(account:)",
+          kind: :keyword,
+          keywords: %i[account]
+        },
+        "email_password.error_renderer" => {
+          signature: "(error:, request:)",
+          kind: :keyword,
+          keywords: %i[error request]
         }
       }.freeze
 
@@ -154,6 +189,7 @@ module StandardId
         def validate_keyword!(path, callable, allowed_keywords, signature)
           params = extract_parameters(callable)
           return if params.nil?
+          validate_no_required_positional!(path, callable, params, signature)
           # If the callable takes a double-splat, it accepts anything — fine.
           return if params.any? { |type, _| type == :keyrest }
 
@@ -167,6 +203,19 @@ module StandardId
             "(allowed keywords: #{allowed_keywords.inspect})."
         end
 
+        # EmailPassword.call_hook passes only the keywords a hook declares, so a
+        # lambda with a required positional argument (`->(request) { }`) would
+        # raise on its first call. Limited to the email_password hooks, which
+        # are new: older keyword hooks keep accepting what they always did.
+        def validate_no_required_positional!(path, callable, params, signature)
+          return unless path.start_with?("email_password.") && lambda_callable?(callable)
+          return unless params.any? { |type, _| type == :req }
+
+          raise StandardId::ConfigurationError,
+            "StandardId config: `#{path}` takes a positional argument, but it is called " \
+            "with keyword arguments. Expected signature #{signature}."
+        end
+
         def validate_claim_resolvers!(config)
           resolvers = config.oauth.claim_resolvers
           return if resolvers.nil? || resolvers.empty?

data/lib/standard_id/config/schema.rb

@@ -277,6 +277,93 @@ StandardId::ConfigSchema.define do
     field :mailer_subject, type: :string, default: "Reset your password"
   end
 
+  # Email + password sign-up and sign-in over JSON (Api::EmailPasswordController,
+  # StandardId::EmailPassword), for native and SPA clients that cannot use the
+  # WebEngine's cookie forms. Off by default: until `enabled` is true the
+  # routes are not drawn at all (a routing constraint, so a host's own routes
+  # behind the mount point still match). See README "Email + password API".
+  #
+  # Sign-up creates an UNVERIFIED account and emails a 6-digit code; tokens are
+  # issued only when the code is confirmed, together with the sign-up password.
+  scope :email_password do
+    field :enabled, type: :boolean, default: false
+
+    # Stamped on the tokens this flow mints. It plays the role a provider name
+    # plays for social tokens: the client presents it on the refresh_token
+    # grant, which must match the token's client_id claim.
+    field :token_client_id, type: :string, default: "email"
+    field :token_scope, type: :string, default: "profile"
+    field :token_audience, type: :string, default: nil
+
+    # OTP realm for the sign-up code. Deliberately not "authentication": that
+    # realm resolves (and can create) an account on verify.
+    field :verification_realm, type: :string, default: "email_verification"
+
+    # What sign-up answers for an address that already has a verified password
+    # account, or belongs to a social-only account:
+    #   true  — (default) 409 :account_exists / :social_account
+    #   false — the same 202 as a new address, and the owner is emailed
+    #           (AccountNoticeMailer#existing_account), so sign-up cannot be
+    #           used to learn which addresses are registered.
+    field :reveal_existing_accounts, type: :boolean, default: true
+
+    field :require_name, type: :boolean, default: false
+    field :name_max_length, type: :integer, default: 100
+
+    # Who emails the sign-up code:
+    #   :built_in — the engine, with PasswordlessMailer#verification_email
+    #   :custom   — a host PASSWORDLESS_CODE_GENERATED subscriber (the event
+    #               carries delivery: :custom and realm verification_realm)
+    # Independent of passwordless.delivery, so turning this on does not start
+    # delivering codes for the passwordless-login endpoint.
+    field :code_delivery, type: :symbol, default: :built_in
+
+    # Link emailed by forgot-password. A String containing "{token}", or a
+    # callable `(request:)` returning one. Required once enabled: the reset
+    # page lives on the host, not the API engine. Delivery follows
+    # reset_password.delivery.
+    field :reset_url, type: :any, default: nil
+
+    # Callable `(request:)` returning the key the per-IP limits and the daily
+    # per-network reset cap count under. Default: request.remote_ip. Return a
+    # masked network (an IPv4 /24, IPv6 /64) to stop address rotation inside
+    # one allocation from resetting the count.
+    field :client_key, type: :any, default: nil
+
+    # Callable `(email:, name:, request:)` returning a new, persisted account.
+    # Default: account_class.create! with email and name (the local part when
+    # name is blank), each only when the account has that attribute.
+    field :account_creator, type: :any, default: nil
+
+    # Callable `(password:, email:)` returning an Array of messages (empty when
+    # acceptable), run after PasswordStrength on sign-up and reset. For checks
+    # that must not be a model validation, e.g. a breached-password lookup.
+    field :password_validator, type: :any, default: nil
+
+    # Callable `(account:, name:, request:)` run when a sign-up's address is
+    # first verified, by its code or by a reset link, before tokens are
+    # minted, e.g. to provision a profile. +name+ is the one given at sign-up.
+    # Only sign-ups made through this API run it (a reset of a web sign-up
+    # does not). It runs in the verification's transaction, with the password
+    # credential and identifier rows locked: a raise undoes it, and a slow
+    # hook holds those locks for as long as it takes.
+    field :after_email_verified, type: :any, default: nil
+
+    # Callable `(account:)`; truthy keeps an account from
+    # PurgeUnverifiedEmailSignupsJob on top of the built-in checks.
+    field :account_in_use, type: :any, default: nil
+
+    # Callable `(error:, request:)` returning the JSON body for a
+    # StandardId::EmailPasswordError; the status stays error.http_status.
+    # Default: { error:, error_description:, details? }.
+    field :error_renderer, type: :any, default: nil
+
+    # PurgeUnverifiedEmailSignupsJob: unverified sign-ups older than this are
+    # removed, unless a code was requested within purge_recent_code_window.
+    field :unverified_purge_after, type: :integer, default: 259200 # 3 days in seconds
+    field :purge_recent_code_window, type: :integer, default: 86400 # 24 hours in seconds
+  end
+
   scope :session do
     field :browser_session_lifetime, type: :integer, default: 86400 # 24 hours in seconds
     field :browser_session_remember_me_lifetime, type: :integer, default: 2592000 # 30 days in seconds
@@ -875,5 +962,26 @@ StandardId::ConfigSchema.define do
     # "throttled" from "token invalid" and turn the limiter into a token-validity
     # oracle.
     field :introspection_per_ip, type: :integer, default: 30              # per 15 minutes
+
+    # Email + password API (Api::EmailPasswordController). The other actions
+    # reuse the limits above: register signup_per_ip + verification_start_per_target,
+    # login login_per_*, resend verification_start_*, forgot password_reset_start_*.
+    field :email_password_verify_per_email, type: :integer, default: 10  # per 15 minutes
+    field :email_password_reset_per_ip, type: :integer, default: 20      # per 15 minutes
+
+    # Daily (24h) per-address caps (StandardId::EmailPassword::DailyLimit), on
+    # top of the short windows. Counted whether or not the address has an
+    # account, so reaching one reveals nothing.
+    #   failed_verifications — a wrong code sent WITH the right password; at the
+    #     cap the address cannot verify until the window passes. Wrong-password
+    #     attempts never count, so a stranger cannot lock the registrant out.
+    #   codes — sign-up codes (and existing-account notices) emailed.
+    #   reset_requests_per_network — forgot-password emails per address per
+    #     client_key, so one attacker cannot spend the owner's allowance.
+    #   reset_requests — the same across all networks.
+    field :email_password_failed_verifications_per_day, type: :integer, default: 10
+    field :email_password_codes_per_day, type: :integer, default: 10
+    field :email_password_reset_requests_per_network_per_day, type: :integer, default: 5
+    field :email_password_reset_requests_per_day, type: :integer, default: 20
   end
 end

data/lib/standard_id/email_password/authentication.rb

@@ -0,0 +1,71 @@
+module StandardId
+  module EmailPassword
+    # The email + password check for login. Token minting is TokenFlow.
+    #
+    # An unknown address, a wrong password and an account that signs in only
+    # another way all raise one generic :invalid_credentials, so login cannot
+    # enumerate accounts. :unverified is only reachable WITH the right
+    # password, so it reveals nothing the caller did not already know.
+    # Publishes the events Oauth::PasswordFlow does.
+    #
+    # Given a block, yields the account with the password credential's row
+    # locked, after re-checking that the password has not changed since it was
+    # verified. Mint tokens inside it: PasswordReset.complete! takes the same
+    # lock to change the password and revoke access, so a login racing a reset
+    # either finishes first (and its tokens are revoked) or fails.
+    module Authentication
+      class << self
+        # @return [Account]
+        # @raise [StandardId::EmailPasswordError] :invalid_credentials, :unverified
+        def call(email:, password:)
+          email = EmailPassword.normalize_email(email)
+          password = password.to_s
+
+          StandardId::Events.publish(
+            StandardId::Events::AUTHENTICATION_ATTEMPT_STARTED,
+            account_lookup: email,
+            auth_method: "password"
+          )
+
+          password_credential = EmailPassword.find_password_credential(email)
+          unless password_credential
+            BCrypt::Password.new(DUMMY_PASSWORD_DIGEST.value).is_password?(password)
+            failed!(email)
+          end
+
+          identifier = password_credential.credential&.identifier
+          verified_digest = password_credential.password_digest
+          failed!(email) unless identifier && password_credential.authenticate(password)
+
+          account = identifier.account
+          StandardId::Events.publish(
+            StandardId::Events::PASSWORD_VALIDATED,
+            account: account,
+            credential_id: password_credential.id
+          )
+
+          raise StandardId::EmailPasswordError.new(:unverified) unless identifier.verified?
+          return account unless block_given?
+
+          password_credential.with_lock do
+            failed!(email) unless password_credential.password_digest == verified_digest
+            yield account
+          end
+        end
+
+        private
+
+        def failed!(email)
+          StandardId::Events.publish(
+            StandardId::Events::AUTHENTICATION_FAILED,
+            account_lookup: email,
+            auth_method: "password",
+            error_code: "invalid_credentials",
+            error_message: "Invalid email or password"
+          )
+          raise StandardId::EmailPasswordError.new(:invalid_credentials)
+        end
+      end
+    end
+  end
+end

data/lib/standard_id/email_password/daily_limit.rb

@@ -0,0 +1,67 @@
+require "digest"
+
+module StandardId
+  module EmailPassword
+    # Per-address caps over a 24-hour window, on top of the controller's short
+    # per-IP / per-email limits. Those bound bursts; these bound what one
+    # address can be put through in a day, however patiently it is spread out.
+    # The limits are `c.rate_limits.email_password_*_per_day` (see the schema).
+    #
+    # Counted per normalised address whether or not an account exists, so a cap
+    # being reached reveals nothing. Counters live in the engine's rate-limit
+    # store. The window is fixed from the first event: `increment(expires_in:)`
+    # only sets the expiry when it creates the entry.
+    #
+    # Check-then-record is not atomic, so concurrent requests can overshoot a
+    # cap by a few. That is fine for an abuse bound; do not use these as quotas.
+    module DailyLimit
+      WINDOW = 24.hours
+
+      LIMIT_FIELDS = {
+        failed_verification: :email_password_failed_verifications_per_day,
+        code_issued: :email_password_codes_per_day,
+        reset_requested_network: :email_password_reset_requests_per_network_per_day,
+        reset_requested: :email_password_reset_requests_per_day
+      }.freeze
+
+      class << self
+        def limit(kind)
+          StandardId.config.rate_limits.public_send(LIMIT_FIELDS.fetch(kind)).to_i
+        end
+
+        # +scope+ further partitions the counter (the client key for
+        # :reset_requested_network).
+        def exceeded?(kind, email, scope: nil)
+          count(kind, email, scope: scope) >= limit(kind)
+        end
+
+        def count(kind, email, scope: nil)
+          store.read(key(kind, email, scope: scope)).to_i
+        end
+
+        # Records one event; returns the new count.
+        def record!(kind, email, scope: nil)
+          store.increment(key(kind, email, scope: scope), 1, expires_in: WINDOW).to_i
+        end
+
+        # Records one event unless the cap is already reached. Returns true when
+        # the event may proceed.
+        def consume!(kind, email, scope: nil)
+          return false if exceeded?(kind, email, scope: scope)
+
+          record!(kind, email, scope: scope) <= limit(kind)
+        end
+
+        def key(kind, email, scope: nil)
+          LIMIT_FIELDS.fetch(kind) # unknown kinds raise
+          subject = [EmailPassword.normalize_email(email), scope].compact.join("|")
+          "standard_id:email-password-daily:#{kind}:#{Digest::SHA256.hexdigest(subject)}"
+        end
+
+        def store
+          StandardId::RateLimiter::STORE
+        end
+      end
+    end
+  end
+end

data/lib/standard_id/email_password/password_reset.rb

@@ -0,0 +1,148 @@
+module StandardId
+  module EmailPassword
+    # Forgot-password and the reset it leads to.
+    module PasswordReset
+      class TokenAlreadyUsed < StandardError; end
+
+      class << self
+        # Queues the reset email for +email+. The lookup, the token and the
+        # CREDENTIAL_PASSWORD_RESET_INITIATED event all happen in
+        # PasswordResetDeliveryJob, so the request path is identical whether or
+        # not the address has an account. Delivery follows
+        # reset_password.delivery.
+        #
+        # Daily caps, counted whether or not the address has an account:
+        # rate_limits.email_password_reset_requests_per_network_per_day per
+        # address per client key, so an attacker who burns their own allowance
+        # does not stop the owner, elsewhere, from getting a link; and
+        # email_password_reset_requests_per_day per address overall. The
+        # network cap is checked first, so requests it refuses never spend the
+        # shared ceiling.
+        #
+        # @return [void]
+        def request(email:, request: nil)
+          email = EmailPassword.normalize_email(email)
+          return if email.blank?
+
+          url_template = reset_url_template(request)
+          client_key = EmailPassword.client_key(request)
+          return if DailyLimit.exceeded?(:reset_requested_network, email, scope: client_key)
+          return unless DailyLimit.consume!(:reset_requested, email)
+
+          DailyLimit.record!(:reset_requested_network, email, scope: client_key)
+          StandardId::PasswordResetDeliveryJob.perform_later(email: email, reset_url_template: url_template)
+        end
+
+        # Whether +token+ still resolves (not expired, used or tampered with).
+        def valid_token?(token)
+          find_credential(token).present?
+        end
+
+        # Sets a new password from a reset token, verifies the address and
+        # revokes every session and refresh token (AccessRevocation).
+        #
+        # A reset that verifies a pending sign-up is its first verification, so
+        # it runs `c.email_password.after_email_verified` too, in the same
+        # transaction (EmailPassword.complete_verification!): if the hook
+        # raises, nothing changes and the token still works. An unverified
+        # account that did not sign up through Registration (no signup_source,
+        # EmailPassword.api_signup?) is verified without the hook.
+        #
+        # The token is PasswordCredential's `generates_token_for
+        # :password_reset`: it embeds the current digest, so the change below is
+        # what makes it single-use. That holds under concurrency too: the row is
+        # locked and the token re-resolved inside the transaction, so of two
+        # requests racing with one token, the second sees the new digest.
+        #
+        # @param password_confirmation [String, nil] compared when given
+        # @return [Account]
+        # @raise [StandardId::EmailPasswordError] :invalid_reset_token,
+        #   :weak_password
+        def complete!(token:, password:, password_confirmation: nil, request: nil)
+          password = password.to_s
+          password_credential = find_credential(token)
+          identifier = password_credential&.credential&.identifier
+          raise StandardId::EmailPasswordError.new(:invalid_reset_token) if identifier.nil?
+
+          validate!(password, password_confirmation, password_credential.login)
+
+          account = identifier.account
+          issued_for_digest = password_credential.password_digest
+
+          ActiveRecord::Base.transaction do
+            password_credential.lock!
+            unless password_credential.password_digest == issued_for_digest &&
+                find_credential(token)&.id == password_credential.id
+              raise TokenAlreadyUsed
+            end
+
+            password_credential.update!(password: password)
+            api_signup = !identifier.verified? && EmailPassword.api_signup?(identifier)
+            EmailPassword.complete_verification!(
+              identifier,
+              name: (EmailPassword.signup_name(password_credential.login) if api_signup),
+              request: request,
+              run_hook: api_signup
+            )
+            StandardId::AccessRevocation.revoke_all!(account, reason: "password_reset")
+          end
+
+          publish_reset_completed(account, password_credential)
+          account
+        rescue TokenAlreadyUsed
+          raise StandardId::EmailPasswordError.new(:invalid_reset_token)
+        end
+
+        private
+
+        def find_credential(token)
+          return nil if token.blank?
+
+          StandardId::PasswordCredential
+            .includes(credential: { identifier: :account })
+            .find_by_token_for(:password_reset, token.to_s)
+        end
+
+        def validate!(password, password_confirmation, login)
+          # has_secure_password ignores an empty assignment on an existing
+          # record, which would "succeed" without changing anything.
+          errors = password.empty? ? ["can't be blank"] : EmailPassword.password_errors(password, email: login)
+          details = {}
+          details[:password] = errors if errors.any?
+          if !password_confirmation.nil? && password_confirmation.to_s != password
+            details[:password_confirmation] = ["doesn't match Password"]
+          end
+          raise StandardId::EmailPasswordError.new(:weak_password, details: details) if details.any?
+        end
+
+        def reset_url_template(request)
+          setting = EmailPassword.config.reset_url
+          template = setting.respond_to?(:call) ? EmailPassword.call_hook(setting, request: request) : setting
+          return template.to_s if template.to_s.include?("{token}")
+
+          raise StandardId::ConfigurationError,
+            "c.email_password.reset_url must be a URL containing \"{token}\" (or a callable (request:) returning one), " \
+            "e.g. \"https://app.example.com/password-reset?token={token}\"."
+        end
+
+        # The reset has already happened, so a failing subscriber must not turn
+        # it into an error; log and carry on, as Web::ResetPasswordConfirmForm does.
+        def publish_reset_completed(account, password_credential)
+          StandardId::Events.publish(
+            StandardId::Events::CREDENTIAL_PASSWORD_RESET_COMPLETED,
+            credential: password_credential,
+            account: account
+          )
+        rescue StandardError => e
+          logger = StandardId.logger
+          return unless logger.respond_to?(:error)
+
+          logger.error(
+            "[StandardId::EmailPassword::PasswordReset] Failed to publish " \
+            "CREDENTIAL_PASSWORD_RESET_COMPLETED for account #{account.id}: #{e.class}: #{e.message}"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/standard_id/email_password/registration.rb

@@ -0,0 +1,141 @@
+module StandardId
+  module EmailPassword
+    # Sign-up: creates an unverified account with a password credential and
+    # emails it a code. No tokens here; those come from Verification.verify!.
+    #
+    # Re-submitting sign-up for an address whose sign-up was never verified
+    # NEVER changes the pending password: overwriting it would let anyone
+    # re-register a stranger's pending address with their own password and
+    # then ride the owner's code into the account. It is treated like a resend:
+    #   * same password as the pending one -> a fresh code is sent;
+    #   * different password               -> nothing changes, nothing is sent.
+    # Both get the same answer as a brand-new address, so sign-up cannot be used
+    # to learn that someone started a sign-up. The owner of a squatted address
+    # recovers through forgot-password (the link verifies the address and
+    # replaces the password), a social sign-in (see
+    # EmailPassword.discard_pending_credentials!), or
+    # PurgeUnverifiedEmailSignupsJob.
+    #
+    # An address that already has a verified password account, or belongs to
+    # an account that signs in another way, raises :account_exists /
+    # :social_account, unless `c.email_password.reveal_existing_accounts` is
+    # false: then it returns normally and the address is emailed
+    # (AccountNoticeMailer#existing_account) instead.
+    #
+    # ACCOUNT_CREATED and CREDENTIAL_PASSWORD_CREATED fire here, inside the
+    # sign-up transaction, for an account whose address is NOT yet verified
+    # (as they do for Web::SignupForm). Provision anything that should wait for
+    # a proven address from `c.email_password.after_email_verified` instead.
+    module Registration
+      class << self
+        # @return [String] the normalised email
+        # @raise [StandardId::EmailPasswordError] :invalid_request,
+        #   :weak_password, :account_exists, :social_account
+        def call(email:, password:, name: nil, request: nil)
+          email = EmailPassword.normalize_email(email)
+          name = name.to_s.strip
+          password = password.to_s
+          validate!(email, name, password)
+
+          existing = EmailPassword.find_password_credential(email)
+          if existing
+            identifier = existing.credential&.identifier
+            return existing_account!(email, :account_exists, password) if identifier.nil? || identifier.verified?
+
+            Verification.issue_code(email, name: name, request: request) if existing.authenticate(password)
+            return email
+          end
+
+          return existing_account!(email, :social_account, password) if StandardId::EmailIdentifier.exists?(value: email)
+
+          create_account!(email, name, password, request)
+          Verification.issue_code(email, name: name, request: request)
+          email
+        rescue ActiveRecord::RecordNotUnique
+          # Lost a race with a concurrent sign-up for the same address.
+          existing_account!(email, :account_exists)
+        rescue ActiveRecord::RecordInvalid => e
+          # The same race, caught by the uniqueness validation instead.
+          return existing_account!(email, :account_exists) if e.record.errors.of_kind?(:login, :taken)
+
+          # A host Account validation (or account_creator) refused the record.
+          raise StandardId::EmailPasswordError.new(:invalid_request, details: e.record.errors.to_hash)
+        end
+
+        private
+
+        def validate!(email, name, password)
+          config = EmailPassword.config
+          details = {}
+          details[:name] = ["can't be blank"] if config.require_name && name.blank?
+          if name.length > config.name_max_length.to_i
+            details[:name] = ["is too long (maximum is #{config.name_max_length} characters)"]
+          end
+          details[:email] = ["is invalid"] unless EmailPassword.valid_email?(email)
+          raise StandardId::EmailPasswordError.new(:invalid_request, details: details) if details.any?
+
+          errors = EmailPassword.password_errors(password, email: email)
+          raise StandardId::EmailPasswordError.new(:weak_password, details: { password: errors }) if errors.any?
+        end
+
+        # +password+ is hashed and thrown away when concealing: a new address
+        # pays one bcrypt to store its password, so an existing one must too,
+        # or the response time would tell them apart.
+        def existing_account!(email, code, password = nil)
+          raise StandardId::EmailPasswordError.new(code) if EmailPassword.config.reveal_existing_accounts
+
+          StandardId::PasswordCredential.new(password: password) unless password.nil?
+          if DailyLimit.consume!(:code_issued, email)
+            StandardId::AccountNoticeMailer.with(email: email).existing_account.deliver_later
+          end
+          email
+        end
+
+        def create_account!(email, name, password, request)
+          EmailPassword.require_signup_source_column!
+          ActiveRecord::Base.transaction do
+            StandardId::Events.publish(
+              StandardId::Events::ACCOUNT_CREATING,
+              account_params: { email: email, name: name.presence }.compact,
+              auth_method: "password"
+            )
+
+            account = build_account(email, name, request)
+            identifier = StandardId::EmailIdentifier.create!(
+              account: account, value: email, signup_source: EmailPassword::SIGNUP_SOURCE
+            )
+            password_credential = StandardId::PasswordCredential.create!(login: email, password: password)
+            StandardId::Credential.create!(identifier: identifier, credentialable: password_credential)
+
+            StandardId::Events.publish(
+              StandardId::Events::ACCOUNT_CREATED,
+              account: account,
+              auth_method: "password",
+              source: "email_password_signup"
+            )
+            StandardId::Events.publish(
+              StandardId::Events::CREDENTIAL_PASSWORD_CREATED,
+              credential: password_credential,
+              account: account
+            )
+            account
+          end
+        end
+
+        def build_account(email, name, request)
+          creator = EmailPassword.config.account_creator
+          if creator.respond_to?(:call)
+            account = EmailPassword.call_hook(creator, email: email, name: name.presence, request: request)
+            raise StandardId::ConfigurationError, "c.email_password.account_creator must return a persisted account" unless account&.persisted?
+
+            return account
+          end
+
+          account_class = StandardId.account_class
+          attributes = { email: email, name: name.presence || email.split("@").first }
+          account_class.create!(attributes.slice(*account_class.attribute_names.map(&:to_sym)))
+        end
+      end
+    end
+  end
+end