booth 0.0.1 → 0.0.2

data/lib/booth/userland/logins/transitions/create/enter_otp.rb

@@ -1,70 +0,0 @@
-module Booth
-  module Logins
-    module Transitions
-      module Create
-        class EnterOtp
-          include ::Booth::Concerns::Transition
-
-          def self.applicable?(params:)
-            params.dig :login, :otp
-          end
-
-          def call
-            do_check_stale_session
-              .on_success { do_find_credential }
-              .on_success { do_check_otp }
-          end
-
-          private
-
-          # Helpers
-
-          delegate :sudo, to: :request
-
-          def do_check_stale_session
-            return Tron.success :session_not_stale unless storage.timed_out?
-
-            public_message = I18n.t('booth.login_timeout', lifespan_minutes: (storage.lifespan / 60))
-            Tron.failure :stale_session, step: :enter_username,
-                                         public_message:
-          end
-
-          def do_find_credential
-            @credential = storage.password_authenticated_credential
-            return Tron.success :found_credential if @credential
-
-            Tron.failure :missing_credential
-          end
-
-          def do_check_credential_mode
-            return Tron.success :credential_is_otp if @credential.mode_username_password_and_otp?
-
-            Tron.failure :credential_is_not_otp
-          end
-
-          def do_check_otp
-            checking = ::Booth::Credentials::OtpAuthentication.call(
-              credential: @credential,
-              code: code_param,
-              ip: request.ip,
-              agent: request.agent
-            )
-            return checking if checking.failure
-
-            storage.reset
-            ::Booth::Sessions::CreateAndLogin.call(credential: @credential, request:)
-            Tron.success :login_completed
-          end
-
-          def code_param
-            params.require(:login).permit(:otp)[:otp]
-          end
-
-          def storage
-            request.storage.login
-          end
-        end
-      end
-    end
-  end
-end

data/lib/booth/userland/logins/transitions/create/verify_password.rb

@@ -1,70 +0,0 @@
-module Booth
-  module Logins
-    module Transitions
-      module Create
-        class VerifyPassword
-          include ::Booth::Concerns::Transition
-
-          def self.applicable?(params:)
-            params.dig :login, :password
-          end
-
-          def call
-            do_check_stale_session
-              .on_success { do_find_credential }
-              .on_success { do_check_password }
-          end
-
-          # Helpers
-
-          def do_check_stale_session
-            return Tron.success :session_not_stale unless storage.timed_out?
-
-            public_message = I18n.t('booth.login_timeout', lifespan_minutes: (storage.lifespan / 60))
-            Tron.failure :stale_session, step: :enter_username,
-                                         public_message:
-          end
-
-          def do_find_credential
-            @credential = storage.credential_for_username
-            return Tron.success :found_credential if @credential
-
-            Tron.failure :missing_credential
-          end
-
-          def do_check_password
-            checking = ::Booth::Credentials::PasswordAuthentication.call(
-              credential: @credential,
-              password: password_param,
-              ip: request.ip,
-              agent: request.agent
-            )
-            return checking if checking.failure
-
-            sudo.password!
-
-            # TODO: Re-check with haveibeenpwned and flag `flagged_pwned_at` password as insecure.
-
-            if @credential.mode_username_and_password?
-              ::Booth::Sessions::CreateAndLogin.call(credential: @credential, request:)
-              return Tron.success :login_completed, return_path: request.return_path
-            end
-
-            storage.password_authenticated_credential = @credential
-            Tron.success :correct_password
-          end
-
-          def password_param
-            params.require(:login).permit(:password)[:password]
-          end
-
-          def storage
-            request.storage.login
-          end
-
-          delegate :sudo, to: :request
-        end
-      end
-    end
-  end
-end

data/lib/booth/userland/logins/transitions/new/mode_first_time.rb

@@ -1,20 +0,0 @@
-module Booth
-  module Userland
-    module Logins
-      module Transitions
-        module New
-          class ModeFirstTime
-            include ::Booth::Concerns::Transition
-            include ::Booth::Userland::Logins::Transitions::New::Fallible
-
-            def call
-              debug { 'This credential has not gone through onboarding yet.' }
-              # storage.login.reset_credential_for_username
-              fail_with :need_webauth, step: :needs_onboarding
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/booth/userland/logins/transitions/new/mode_username_password_and_otp.rb

@@ -1,24 +0,0 @@
-module Booth
-  module Userland
-    module Logins
-      module Transitions
-        module New
-          class ModeUsernamePasswordAndOtp
-            include ::Booth::Concerns::Transition
-            include ::Booth::Userland::Logins::Transitions::New::Fallible
-
-            def call
-              if storage.password_authenticated_credential
-                debug { 'I have your username and your password, now I need your OTP' }
-                fail_with :need_otp, step: :enter_otp
-              else
-                debug { 'I have your username but not your password, let alone your OTP' }
-                fail_with :need_password_and_otp, step: :enter_password
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/booth/userland/logins/transitions/new/mode_username_password_and_webauth.rb

@@ -1,24 +0,0 @@
-module Booth
-  module Userland
-    module Logins
-      module Transitions
-        module New
-          class ModeUsernamePasswordAndWebauth
-            include ::Booth::Concerns::Transition
-            include ::Booth::Userland::Logins::Transitions::New::Fallible
-
-            def call
-              if storage.password_authenticated_credential
-                debug { 'I have your username and your password, now I need your Webauth' }
-                fail_with :need_webauth, step: :enter_webauth
-              else
-                debug { 'I have your username but not your password, let alone your Webauth' }
-                fail_with :need_password_and_webauth, step: :enter_password
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/booth/userland/onboardings/transitions/update/choose_mode.rb

@@ -1,58 +0,0 @@
-module Booth
-  module Userland
-    module Onboardings
-      module Transitions
-        module Update
-          class ChooseMode
-            include ::Booth::Concerns::Transition
-
-            option :onboarding
-
-            def self.applicable?(params:)
-              # `mode` sets to a specific mode and `reset` clears any mode.
-              params.key?(:mode) || params.key?(:reset)
-            end
-
-            def call
-              do_reset_password
-                .on_success { do_reset_otp }
-                .on_success { do_reset_webauth }
-                .on_success { do_update_mode }
-            end
-
-            private
-
-            def do_reset_password
-              ::Booth::Userland::Onboardings::Transitions::Update::ResetPassword.call(onboarding:,
-                                                                                      request:)
-            end
-
-            def do_reset_otp
-              ::Booth::Userland::Onboardings::Transitions::Update::ResetOtp.call(onboarding:,
-                                                                                 request:)
-            end
-
-            def do_reset_webauth
-              ::Booth::Userland::Onboardings::Transitions::Update::ResetWebauth.call(onboarding:,
-                                                                                     request:)
-            end
-
-            def do_update_mode
-              if onboarding.update mode: mode_param
-                debug { "You chose the mode #{@onboarding.mode.inspect}" }
-                return Tron.success :mode_chosen
-              end
-
-              debug { "Could not choose mode #{mode_param.inspect}: #{onboarding.errors.to_a.to_sentence}" }
-              Tron.failure :mode_update_failed
-            end
-
-            def mode_param
-              params[:mode] || 'first_time'
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/booth/userland/onboardings/transitions/update/choose_password.rb

@@ -1,41 +0,0 @@
-module Booth
-  module Userland
-    module Onboardings
-      module Transitions
-        module Update
-          class ChoosePassword
-            include ::Booth::Concerns::Transition
-
-            option :onboarding
-
-            def self.applicable?(params:)
-              params.key?(:onboarding) && params[:onboarding].key?(:password)
-            end
-
-            def call
-              do_update_password
-            end
-
-            private
-
-            def do_update_password
-              if onboarding.update password: password_param,
-                                   password_chosen_at: Time.current
-                debug { 'You chose a password' }
-                return Tron.success :password_chosen
-              end
-
-              public_message = onboarding.errors.to_a.to_sentence
-              debug { "Could not choose password: #{public_message}" }
-              Tron.failure :password_update_failed, public_message:
-            end
-
-            def password_param
-              params.require(:onboarding).permit(:password)[:password]
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/booth/userland/onboardings/transitions/update/choose_webauth_nickname.rb

@@ -1,50 +0,0 @@
-module Booth
-  module Userland
-    module Onboardings
-      module Transitions
-        module Update
-          class ChooseWebauthNickname
-            include ::Booth::Concerns::Transition
-
-            option :onboarding
-
-            def self.applicable?(params:)
-              params&.key?(:onboarding) && params[:onboarding]&.key?(:authenticator_nickname)
-            end
-
-            def call
-              do_check_blank_nickname
-                .on_success { do_update_webauth }
-            end
-
-            private
-
-            def do_check_blank_nickname
-              return Tron.success :nickname_is_present if nickname_param.present?
-
-              onboarding.errors.add(:authenticator_nickname, :blank)
-              public_message = onboarding.errors.to_a.to_sentence
-              debug { 'The nickname was blank' }
-              Tron.failure :nickname_is_blank, public_message:
-            end
-
-            def do_update_webauth
-              if onboarding.update authenticator_nickname: nickname_param
-                debug { 'The nickname successfully changed' }
-                Tron.success :webauth_nickname_saved
-              else
-                public_message = onboarding.errors.to_a.to_sentence
-                debug { "The nickname could not be updated: #{public_message}" }
-                Tron.failure :webauth_nickname_failed, public_message:
-              end
-            end
-
-            def nickname_param
-              params.require(:onboarding).permit(:authenticator_nickname)[:authenticator_nickname]
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/booth/userland/onboardings/transitions/update/confirm_otp.rb

@@ -1,58 +0,0 @@
-module Booth
-  module Userland
-    module Onboardings
-      module Transitions
-        module Update
-          class ConfirmOtp
-            include ::Booth::Concerns::Transition
-
-            option :onboarding
-
-            def self.applicable?(params:)
-              params.key?(:onboarding) && params[:onboarding].key?(:otp_confirmation)
-            end
-
-            def call
-              do_check_otp_code_syntax
-                .on_success { do_authenticate_otp }
-                .on_success { do_update_confirmation }
-            end
-
-            private
-
-            def do_check_otp_code_syntax
-              check = ::Booth::Syntaxes::Otp.call(code_param)
-              return check if check.failure?
-
-              @normalized_otp_code = check.normalized_otp
-              check
-            end
-
-            def do_authenticate_otp
-              return Tron.success :correct_code if @onboarding.authenticate_otp(@normalized_otp_code)
-
-              @onboarding.errors.add :base, I18n.t('booth.wrong_otp')
-              public_message = onboarding.errors.to_a.to_sentence
-              debug { "Could not confirm otp: #{public_message}" }
-              Tron.failure :otp_did_not_match, public_message:
-            end
-
-            def do_update_confirmation
-              if @onboarding.update(otp_confirmed_at: Time.current)
-                debug { 'You confirmed your otp' }
-                return Tron.success :otp_confirmed
-              end
-
-              debug { "The confirmation was correct but the update failed: #{onboarding.errors.to_a.to_sentence}" }
-              Tron.failure :correct_otp_confirmation_failed
-            end
-
-            def code_param
-              params.require(:onboarding).permit(:otp_confirmation)[:otp_confirmation]
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/booth/userland/onboardings/transitions/update/confirm_password.rb

@@ -1,49 +0,0 @@
-module Booth
-  module Userland
-    module Onboardings
-      module Transitions
-        module Update
-          class ConfirmPassword
-            include ::Booth::Concerns::Transition
-
-            option :onboarding
-
-            def self.applicable?(params:)
-              params.key?(:onboarding) && params[:onboarding].key?(:password_confirmation)
-            end
-
-            def call
-              do_authenticate_password
-                .on_success { do_update_confirmation }
-            end
-
-            private
-
-            def do_authenticate_password
-              return Tron.success :password_matches if @onboarding.authenticate_password(password)
-
-              @onboarding.errors.add :password_confirmation, :confirmation
-              public_message = onboarding.errors.to_a.to_sentence
-              debug { "Could not confirm password: #{public_message}" }
-              Tron.failure :password_did_not_match, public_message:
-            end
-
-            def do_update_confirmation
-              if @onboarding.update(password_confirmed_at: Time.current)
-                debug { 'You confirmed your password' }
-                return Tron.success :password_confirmed
-              end
-
-              debug { "The confirmation was correct but the update failed: #{onboarding.errors.to_a.to_sentence}" }
-              Tron.failure :correct_password_confirmation_failed
-            end
-
-            def password
-              params.require(:onboarding).permit(:password_confirmation)[:password_confirmation]
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/booth/userland/onboardings/transitions/update/register_otp.rb

@@ -1,31 +0,0 @@
-module Booth
-  module Userland
-    module Onboardings
-      module Transitions
-        module Update
-          class RegisterOtp
-            include ::Booth::Concerns::Transition
-
-            option :onboarding
-
-            def self.applicable?(params:)
-              params&.key?(:register_otp) && !params&.key?(:onboarding)
-            end
-
-            def call
-              do_register
-            end
-
-            private
-
-            def do_register
-              return Tron.success :otp_secret_regenerated if onboarding.update(otp_registered_at: Time.current)
-
-              Tron.failure :generating_otp_secret_failed
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/booth/userland/onboardings/transitions/update/reset_otp.rb

@@ -1,40 +0,0 @@
-module Booth
-  module Userland
-    module Onboardings
-      module Transitions
-        module Update
-          class ResetOtp
-            include ::Booth::Concerns::Transition
-
-            option :onboarding
-
-            def self.applicable?(params:)
-              params.key?(:reset_otp)
-            end
-
-            def call
-              do_regenerate_secret
-                .on_success { do_reset_confirmation }
-            end
-
-            def do_regenerate_secret
-              return Tron.success :secret_regenerated if onboarding.otp_regenerate_secret
-
-              Tron.failure :secret_regeneration_failed
-            end
-
-            def do_reset_confirmation
-              if onboarding.update(otp_registered_at: nil, otp_confirmed_at: nil)
-                debug { 'The Onboarding otp was reset.' }
-                return Tron.success :otp_reset
-              end
-
-              debug { "Could not reset otp: #{onboarding.errors.to_a.to_sentence}" }
-              Tron.failure :otp_reset_failed
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/booth/userland/onboardings/transitions/update/reset_password.rb

@@ -1,35 +0,0 @@
-module Booth
-  module Userland
-    module Onboardings
-      module Transitions
-        module Update
-          class ResetPassword
-            include ::Booth::Concerns::Transition
-
-            option :onboarding
-
-            def self.applicable?(params:)
-              params.key?(:reset_password)
-            end
-
-            def call
-              do_reset_password_confirmation
-            end
-
-            private
-
-            def do_reset_password_confirmation
-              if onboarding.update(password_chosen_at: nil, password_confirmed_at: nil)
-                debug { 'The Onboarding password was reset.' }
-                return Tron.success :password_reset
-              end
-
-              debug { "Could not reset password: #{onboarding.errors.to_a.to_sentence}" }
-              Tron.failure :password_reset_failed
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/booth/userland/onboardings/transitions/update/reset_webauth.rb

@@ -1,46 +0,0 @@
-module Booth
-  module Userland
-    module Onboardings
-      module Transitions
-        module Update
-          class ResetWebauth
-            include ::Booth::Concerns::Transition
-
-            option :onboarding
-
-            def self.applicable?(params:)
-              params.key?(:reset_webauth)
-            end
-
-            def call
-              do_clear_webauth
-            end
-
-            private
-
-            def do_clear_webauth
-              if onboarding.update(niled_attributes)
-                debug { 'The Onboarding webauth was reset.' }
-                return Tron.success :webauth_reset
-              end
-
-              debug { "Could not reset webauth: #{onboarding.errors.to_a.to_sentence}" }
-              Tron.failure :webauth_reset_failed
-            end
-
-            def niled_attributes
-              {
-                webauthn_id: nil,
-                authenticator_id: nil,
-                authenticator_nickname: nil,
-                authenticator_challenge: nil,
-                authenticator_public_key: nil,
-                authenticator_sign_count: nil
-              }
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/booth/userland/onboardings/transitions/update/webauth_authentication_initiation.rb

@@ -1,40 +0,0 @@
-module Booth
-  module Userland
-    module Onboardings
-      module Transitions
-        module Update
-          class WebauthAuthenticationInitiation
-            include ::Booth::Concerns::Transition
-
-            option :onboarding
-
-            def self.applicable?(params:)
-              params&.key?(:test_webauth) && !params&.key?(:onboarding)
-            end
-
-            def call
-              do_challenge
-            end
-
-            private
-
-            def do_challenge
-              webauth = ::Booth::Webauth::OptionsForGet.call(
-                allowed_device_ids: onboarding.authenticator_id,
-                requires_user_verification: onboarding.requires_user_verification?
-              )
-
-              debug { "Remembering test challenge #{webauth.challenge.inspect}" }
-
-              if onboarding.update authenticator_challenge: webauth.challenge
-                Tron.success :test_challenge_created, public_json: webauth.as_json, http_status: :created
-              else
-                Tron.failure :storing_test_challenge_failed
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end