فشل `run_second_factor!` عند محاولة ترقية المسؤول

pfaffman · 1 يوليو 2024، 9:30م

Following on Can't upgrade user to admin - unhandled server error
(Hey @Discoursenaut.) I spent all afternoon on this. I still can’t track down what the problem actually is, but if I add a rescue around line 1099 (`manager.run!') the mysterious “An unhandled server error has occurred.” Error. I can’t find that string anywhere in the source.

github.com/discourse/discourse

app/controllers/application_controller.rb

main


      
          # frozen_string_literal: true
          
          require "current_user"
          
          class ApplicationController < ActionController::Base
            include CurrentUser
            include CanonicalURL::ControllerExtensions
            include JsonError
            include GlobalPath
            include Hijack
            include ReadOnlyMixin
            include ThemeResolver
            include VaryHeader
          
            attr_reader :theme_id
          
            delegate :server_session, to: :request
            alias_method :secure_session, :server_session
          
            serialization_scope :guardian
          
            protect_from_forgery
          
            # Default Rails 3.2 lets the request through with a blank session
            #  we are being more pedantic here and nulling session / current_user
            #  and then raising a CSRF exception
            def handle_unverified_request
              # NOTE: API key is secret, having it invalidates the need for a CSRF token
              unless is_api? || is_user_api?
                super
                clear_current_user
                render plain: "[\"BAD CSRF\"]", status: :forbidden
              end
            end
          
            before_action :check_readonly_mode
            before_action :handle_theme
            before_action :set_current_user_for_logs
            before_action :set_mp_snapshot_fields
            before_action :clear_notifications
            around_action :with_resolved_locale
            before_action :set_mobile_view
            before_action :block_if_readonly_mode
            before_action :authorize_mini_profiler
            before_action :redirect_to_login_if_required
            before_action :block_if_requires_login
            before_action :redirect_to_profile_if_required
            before_action :preload_json
            before_action :initialize_application_layout_preloader
            before_action :check_xhr
            before_action :set_crawler_header
            after_action :add_readonly_header
            after_action :perform_refresh_session
            after_action :dont_cache_page
            after_action :conditionally_allow_site_embedding
            after_action :ensure_vary_header
            after_action :add_noindex_header,
                         if: -> { is_feed_request? || !SiteSetting.allow_index_in_robots_txt }
            after_action :add_noindex_header_to_non_canonical, if: :spa_boot_request?
            after_action :set_cross_origin_opener_policy_header, if: :spa_boot_request?
            after_action :clean_xml, if: :is_feed_response?
            after_action :add_early_hint_header, if: -> { spa_boot_request? }
          
            HONEYPOT_KEY = "HONEYPOT_KEY"
            CHALLENGE_KEY = "CHALLENGE_KEY"
          
            layout :set_layout
          
            def has_escaped_fragment?
              SiteSetting.enable_escaped_fragments? && params.key?("_escaped_fragment_")
            end
          
            def show_browser_update?
              @show_browser_update ||= CrawlerDetection.show_browser_update?(request.user_agent)
            end
            helper_method :show_browser_update?
          
            def use_crawler_layout?
              @use_crawler_layout ||=
                request.user_agent && (request.media_type.blank? || request.media_type.include?("html")) &&
                  !%w[json rss].include?(params[:format]) &&
                  (
                    has_escaped_fragment? || params.key?("print") || show_browser_update? ||
                      CrawlerDetection.crawler?(request.user_agent, request.headers["HTTP_VIA"])
                  )
            end
            helper_method :use_crawler_layout?
          
            def perform_refresh_session
              refresh_session(current_user) unless @readonly_mode
            end
          
            def immutable_for(duration)
              response.cache_control[:max_age] = duration.to_i
              response.cache_control[:public] = true
              response.cache_control[:extras] = ["immutable"]
            end
          
            def dont_cache_page
              if !response.headers["Cache-Control"] && response.cache_control.blank?
                response.cache_control[:no_cache] = true
                response.cache_control[:extras] = ["no-store"]
              end
              response.headers["Discourse-No-Onebox"] = "1" if SiteSetting.login_required
            end
          
            def conditionally_allow_site_embedding
              response.headers.delete("X-Frame-Options") if SiteSetting.allow_embedding_site_in_an_iframe
            end
          
            def ember_cli_required?
              Rails.env.development? && ENV["ALLOW_EMBER_CLI_PROXY_BYPASS"] != "1" &&
                request.headers["X-Discourse-Ember-CLI"] != "true"
            end
          
            def application_layout
              ember_cli_required? ? "ember_cli" : "application"
            end
          
            def set_layout
              case request.headers["Discourse-Render"]
              when "desktop"
                return application_layout
              when "crawler"
                return "crawler"
              end
          
              use_crawler_layout? ? "crawler" : application_layout
            end
          
            class RenderEmpty < StandardError
            end
          
            class PluginDisabled < StandardError
            end
          
            rescue_from RenderEmpty do
              with_resolved_locale { render "default/empty" }
            end
          
            rescue_from ArgumentError do |e|
              if e.message == "string contains null byte"
                raise Discourse::InvalidParameters, e.message
              else
                raise e
              end
            end
          
            rescue_from PG::ReadOnlySqlTransaction do |e|
              Discourse.received_postgres_readonly!
              Rails.logger.error("#{e.class} #{e.message}: #{e.backtrace.join("\n")}")
              rescue_with_handler(Discourse::ReadOnly) || raise
            end
          
            rescue_from ActionController::ParameterMissing do |e|
              render_json_error e.message, status: 400
            end
          
            rescue_from Discourse::SiteSettingMissing do |e|
              render_json_error I18n.t("site_setting_missing", name: e.message), status: 500
            end
          
            rescue_from ActionController::RoutingError, PluginDisabled do
              rescue_discourse_actions(:not_found, 404)
            end
          
            # Handles requests for giant IDs that throw pg exceptions
            rescue_from ActiveModel::RangeError do |e|
              if e.message =~ /ActiveModel::Type::Integer/
                rescue_discourse_actions(:not_found, 404)
              else
                raise e
              end
            end
          
            rescue_from ActiveRecord::RecordInvalid do |e|
              if request.format && request.format.json?
                render_json_error e, type: :record_invalid, status: 422
              else
                raise e
              end
            end
          
            rescue_from ActiveRecord::StatementInvalid do |e|
              Discourse.reset_active_record_cache_if_needed(e)
              raise e
            end
          
            # If they hit the rate limiter
            rescue_from RateLimiter::LimitExceeded do |e|
              retry_time_in_seconds = e&.available_in
          
              response_headers = { "Retry-After": retry_time_in_seconds.to_s }
          
              response_headers["Discourse-Rate-Limit-Error-Code"] = e.error_code if e&.error_code
          
              with_resolved_locale do
                render_json_error(
                  e.description,
                  type: :rate_limit,
                  status: 429,
                  extras: {
                    wait_seconds: retry_time_in_seconds,
                    time_left: e&.time_left,
                  },
                  headers: response_headers,
                )
              end
            end
          
            rescue_from Discourse::NotLoggedIn do |e|
              if (request.format && request.format.json?) || request.xhr? || !request.get?
                rescue_discourse_actions(:not_logged_in, 403, include_ember: true)
              else
                rescue_discourse_actions(:not_found, 404)
              end
            end
          
            rescue_from Discourse::InvalidParameters do |e|
              opts = { custom_message: "invalid_params", custom_message_params: { message: e.message } }
          
              if (request.format && request.format.json?) || request.xhr? || !request.get?
                rescue_discourse_actions(:invalid_parameters, 400, opts.merge(include_ember: true))
              else
                rescue_discourse_actions(:not_found, 400, opts)
              end
            end
          
            rescue_from Discourse::NotFound do |e|
              rescue_discourse_actions(
                :not_found,
                e.status,
                check_permalinks: e.check_permalinks,
                original_path: e.original_path,
                custom_message: e.custom_message,
              )
            end
          
            rescue_from Discourse::InvalidAccess do |e|
              cookies.delete(e.opts[:delete_cookie]) if e.opts[:delete_cookie].present?
          
              rescue_discourse_actions(
                :invalid_access,
                403,
                include_ember: true,
                custom_message: e.custom_message,
                custom_message_params: e.custom_message_params,
                group: e.group,
              )
            end
          
            rescue_from Discourse::ReadOnly do
              unless response_body
                respond_to do |format|
                  format.json do
                    render_json_error I18n.t("read_only_mode_enabled"), type: :read_only, status: 503
                  end
                  format.html do
                    render status: :service_unavailable, layout: "no_ember", template: "exceptions/read_only"
                  end
                end
              end
            end
          
            rescue_from SecondFactor::AuthManager::SecondFactorRequired do |e|
              if request.xhr?
                render json: { second_factor_challenge_nonce: e.nonce }, status: :forbidden
              else
                redirect_to session_2fa_path(nonce: e.nonce)
              end
            end
          
            rescue_from SecondFactor::BadChallenge do |e|
              render json: { error: I18n.t(e.error_translation_key) }, status: e.status_code
            end
          
            def redirect_with_client_support(url, options = {})
              if request.xhr?
                response.headers["Discourse-Xhr-Redirect"] = "true"
                render plain: url
              else
                redirect_to url, options
              end
            end
          
            def rescue_discourse_actions(type, status_code, opts = nil)
              opts ||= {}
          
              show_json_errors =
                (request.format && request.format.json?) || (request.xhr?) ||
                  ((params[:external_id] || "").to_s.ends_with?(".json"))
          
              if type == :not_found && opts[:check_permalinks]
                url = opts[:original_path] || request.fullpath
                permalink = Permalink.find_by_url(url)
          
                # there are some cases where we have a permalink but no url
                # cause category / topic was deleted
                if permalink.present? && permalink.target_url
                  # permalink present, redirect to that URL
                  redirect_with_client_support permalink.target_url,
                                               status: :moved_permanently,
                                               allow_other_host: true
                  return
                end
              end
          
              message = title = nil
              with_resolved_locale(check_current_user: false) do
                if opts[:custom_message]
                  title = message = I18n.t(opts[:custom_message], opts[:custom_message_params] || {})
                else
                  message = I18n.t(type)
                  if status_code == 403
                    title = I18n.t("page_forbidden.title")
                  else
                    title = I18n.t("page_not_found.title")
                  end
                end
              end
          
              error_page_opts = { title: title, status: status_code, group: opts[:group] }
          
              if show_json_errors
                opts = { type: type, status: status_code }
          
                with_resolved_locale(check_current_user: false) do
                  # Include error in HTML format for topics#show.
                  if (request.params[:controller] == "topics" && request.params[:action] == "show") ||
                       (
                         request.params[:controller] == "categories" &&
                           request.params[:action] == "find_by_slug"
                       )
                    opts[:extras] = {
                      title: I18n.t("page_not_found.page_title"),
                      html: build_not_found_page(error_page_opts),
                      group: error_page_opts[:group],
                    }
                  end
                end
          
                render_json_error message, opts
              else
                begin
                  # 404 pages won't have the session and theme_keys without these:
                  current_user
                  handle_theme
                rescue Discourse::InvalidAccess
                  return render plain: message, status: status_code
                end
          
                with_resolved_locale do
                  error_page_opts[:layout] = opts[:include_ember] && @_preloaded ? set_layout : "no_ember"
                  render html: build_not_found_page(error_page_opts)
                end
              end
            end
          
            # If a controller requires a plugin, it will raise an exception if that plugin is
            # disabled. This allows plugins to be disabled programmatically.
            def self.requires_plugin(plugin_name)
              before_action do
                if plugin = Discourse.plugins_by_name[plugin_name]
                  raise PluginDisabled.new if !plugin.enabled?
                elsif Rails.env.test?
                  raise "Required plugin '#{plugin_name}' not found. The string passed to requires_plugin should match the plugin's name at the top of plugin.rb"
                else
                  Rails.logger.warn("Required plugin '#{plugin_name}' not found")
                end
              end
            end
          
            def set_current_user_for_logs
              if current_user
                Logster.add_to_env(request.env, "username", current_user.username)
                response.headers["X-Discourse-Username"] = current_user.username
              end
              response.headers["X-Discourse-Route"] = "#{controller_path}/#{action_name}"
            end
          
            def set_mp_snapshot_fields
              if defined?(Rack::MiniProfiler)
                Rack::MiniProfiler.add_snapshot_custom_field("Application version", Discourse.git_version)
                if Rack::MiniProfiler.snapshots_transporter?
                  Rack::MiniProfiler.add_snapshot_custom_field("Site", Discourse.current_hostname)
                end
              end
            end
          
            def clear_notifications
              if current_user && !@readonly_mode
                cookie_notifications = cookies["cn"]
                notifications = request.headers["Discourse-Clear-Notifications"]
          
                if cookie_notifications
                  if notifications.present?
                    notifications += ",#{cookie_notifications}"
                  else
                    notifications = cookie_notifications
                  end
                end
          
                if notifications.present?
                  notification_ids = notifications.split(",").map(&:to_i)
                  Notification.read(current_user, notification_ids)
                  current_user.reload
                  current_user.publish_notifications_state
                  cookie_args = {}
                  cookie_args[:path] = Discourse.base_path if Discourse.base_path.present?
                  cookies.delete("cn", cookie_args)
                end
              end
            end
          
            def with_resolved_locale(check_current_user: true)
              if check_current_user &&
                   (
                     user =
                       begin
                         current_user
                       rescue StandardError
                         nil
                       end
                   )
                locale = user.effective_locale
              else
                locale = Discourse.anonymous_locale(request)
                locale ||= SiteSetting.default_locale
              end
          
              locale = SiteSettings::DefaultsProvider::DEFAULT_LOCALE if !I18n.locale_available?(locale)
          
              I18n.ensure_all_loaded!
              I18n.with_locale(locale) { yield }
            end
          
            def set_mobile_view
              session[:mobile_view] = params[:mobile_view] if params.has_key?(:mobile_view)
            end
          
            NO_THEMES = "no_themes"
            NO_PLUGINS = "no_plugins"
            NO_UNOFFICIAL_PLUGINS = "no_unofficial_plugins"
            SAFE_MODE = "safe_mode"
          
            LEGACY_NO_THEMES = "no_custom"
            LEGACY_NO_UNOFFICIAL_PLUGINS = "only_official"
          
            def resolve_safe_mode
              return unless guardian.can_enable_safe_mode?
          
              safe_mode = params[SAFE_MODE]
              if safe_mode.is_a?(String)
                safe_mode = safe_mode.split(",")
                request.env[NO_THEMES] = safe_mode.include?(NO_THEMES) || safe_mode.include?(LEGACY_NO_THEMES)
                request.env[NO_PLUGINS] = safe_mode.include?(NO_PLUGINS)
                request.env[NO_UNOFFICIAL_PLUGINS] = safe_mode.include?(NO_UNOFFICIAL_PLUGINS) ||
                  safe_mode.include?(LEGACY_NO_UNOFFICIAL_PLUGINS)
              end
            end
          
            def handle_theme
              return if request.format == "js"
          
              resolve_safe_mode
              return if request.env[NO_THEMES]
          
              @theme_id ||= ThemeResolver.resolve_theme_id(request, guardian, current_user)
            end
          
            def guardian
              # sometimes we log on a user in the middle of a request so we should throw
              # away the cached guardian instance when we do that
              if (@guardian&.user).blank? && current_user.present?
                @guardian = Guardian.new(current_user, request)
              end
              @guardian ||= Guardian.new(current_user, request)
            end
          
            def current_homepage
              current_user&.user_option&.homepage || HomepageHelper.resolve(request, current_user)
            end
          
            def serialize_data(obj, serializer, opts = nil)
              # If it's an array, apply the serializer as an each_serializer to the elements
              serializer_opts = { scope: guardian }.merge!(opts || {})
              if obj.respond_to?(:to_ary)
                serializer_opts[:each_serializer] = serializer
                ActiveModel::ArraySerializer.new(obj.to_ary, serializer_opts).as_json
              else
                serializer.new(obj, serializer_opts).as_json
              end
            end
          
            # This is odd, but it seems that in Rails `render json: obj` is about
            # 20% slower than calling MultiJSON.dump ourselves. I'm not sure why
            # Rails doesn't call MultiJson.dump when you pass it json: obj but
            # it seems we don't need whatever Rails is doing.
            def render_serialized(obj, serializer, opts = nil)
              render_json_dump(serialize_data(obj, serializer, opts), opts)
            end
          
            def render_json_dump(obj, opts = nil)
              opts ||= {}
              if opts[:rest_serializer]
                obj["__rest_serializer"] = "1"
                opts.each { |k, v| obj[k] = v if k.to_s.start_with?("refresh_") }
          
                obj["extras"] = opts[:extras] if opts[:extras]
                obj["meta"] = opts[:meta] if opts[:meta]
              end
          
              render json: MultiJson.dump(obj), status: opts[:status] || 200
            end
          
            def can_cache_content?
              current_user.blank? && cookies[:authentication_data].blank?
            end
          
            # Our custom cache method
            def discourse_expires_in(time_length)
              return unless can_cache_content?
              Middleware::AnonymousCache.anon_cache(request.env, time_length)
            end
          
            def fetch_user_from_params(opts = nil, eager_load = [])
              opts ||= {}
              user =
                if params[:username]
                  username_lower = params[:username].downcase.chomp(".json")
          
                  if current_user && current_user.username_lower == username_lower
                    current_user
                  else
                    find_opts = { username_lower: username_lower }
                    find_opts[:active] = true unless opts[:include_inactive] || current_user.try(:staff?)
                    result = User
                    (result = result.includes(*eager_load)) if !eager_load.empty?
                    result.find_by(find_opts)
                  end
                elsif params[:external_id]
                  external_id = params[:external_id].chomp(".json")
                  if provider_name = params[:external_provider]
                    raise Discourse::InvalidAccess unless guardian.is_admin? # external_id might be something sensitive
                    provider = Discourse.enabled_authenticators.find { |a| a.name == provider_name }
                    raise Discourse::NotFound if !provider&.is_managed? # Only managed authenticators use UserAssociatedAccount
                    UserAssociatedAccount.find_by(
                      provider_name: provider_name,
                      provider_uid: external_id,
                    )&.user
                  else
                    SingleSignOnRecord.find_by(external_id: external_id).try(:user)
                  end
                end
              raise Discourse::NotFound if user.blank?
          
              guardian.ensure_can_see!(user)
              user
            end
          
            def post_ids_including_replies
              post_ids = params[:post_ids].map(&:to_i)
              post_ids |= PostReply.where(post_id: params[:reply_post_ids]).pluck(:reply_post_id) if params[
                :reply_post_ids
              ]
              post_ids
            end
          
            def no_cookies
              # do your best to ensure response has no cookies
              # longer term we may want to push this into middleware
              headers.delete "Set-Cookie"
              request.session_options[:skip] = true
            end
          
            def handle_permalink(path)
              permalink = Permalink.find_by_url(path)
              if permalink && permalink.target_url
                redirect_to permalink.target_url, status: :moved_permanently
              end
            end
          
            def rate_limit_second_factor!(user)
              return if params[:second_factor_token].blank?
              RateLimiter.new(nil, "second-factor-min-#{request.remote_ip}", 6, 1.minute).performed!
              RateLimiter.new(nil, "second-factor-min-#{user.username}", 6, 1.minute).performed! if user
            end
          
            def login_method
              return if !current_user || current_user.anonymous?
              current_user.authenticated_with_oauth ? Auth::LOGIN_METHOD_OAUTH : Auth::LOGIN_METHOD_LOCAL
            end
          
            private
          
            # This method is intended to be a no-op.
            # The only reason this `before_action` callback continues to exist is for backwards compatibility purposes which we cannot easily
            # solve at this point. In the `rescue_discourse_actions` method, the `@_preloaded` instance variable is used to determine
            # if the `no_ember` or `application` layout should be used. To use the `no_ember` layout, controllers have been
            # setting `skip_before_action :preload_json`. This is however a flawed implementation as which layout is used for rendering
            # errors should ideally not be set by skipping a `before_action` callback. To fix this properly will require some careful
            # planning which we do not intend to tackle at this point.
            def preload_json
              return if request.format&.json? || request.xhr? || !request.get?
              @_preloaded = {}
            end
          
            def initialize_application_layout_preloader
              @application_layout_preloader =
                ApplicationLayoutPreloader.new(
                  guardian:,
                  theme_id: @theme_id,
                  theme_target: view_context.mobile_view? ? :mobile : :desktop,
                  login_method:,
                )
            end
          
            def store_preloaded(key, json)
              @application_layout_preloader.store_preloaded(key, json)
            end
          
            # Render action for a JSON error.
            #
            # obj       - a translated string, an ActiveRecord model, or an array of translated strings
            # opts:
            #   type    - a machine-readable description of the error
            #   status  - HTTP status code to return
            #   headers - extra headers for the response
            def render_json_error(obj, opts = {})
              opts = { status: opts } if opts.is_a?(Integer)
              opts.fetch(:headers, {}).each { |name, value| headers[name.to_s] = value }
          
              render(
                json: MultiJson.dump(create_errors_json(obj, opts)),
                status: opts[:status] || status_code(obj),
              )
            end
          
            def status_code(obj)
              return 403 if obj.try(:forbidden)
              return 404 if obj.try(:not_found)
              422
            end
          
            def success_json
              { success: "OK" }
            end
          
            def failed_json
              { failed: "FAILED" }
            end
          
            def json_result(obj, opts = {})
              if yield(obj)
                json = success_json
          
                # If we were given a serializer, add the class to the json that comes back
                if opts[:serializer].present?
                  json[obj.class.name.underscore] = opts[:serializer].new(
                    obj,
                    scope: guardian,
                  ).serializable_hash
                end
          
                render json: MultiJson.dump(json)
              else
                error_obj = nil
                if opts[:additional_errors]
                  error_target =
                    opts[:additional_errors].find do |o|
                      target = obj.public_send(o)
                      target && target.errors.present?
                    end
                  error_obj = obj.public_send(error_target) if error_target
                end
                render_json_error(error_obj || obj)
              end
            end
          
            def mini_profiler_enabled?
              defined?(Rack::MiniProfiler) && (guardian.is_developer? || Rails.env.development?)
            end
          
            def authorize_mini_profiler
              return unless mini_profiler_enabled?
              Rack::MiniProfiler.authorize_request
            end
          
            def check_xhr
              # bypass xhr check on PUT / POST / DELETE provided api key is there, otherwise calling api is annoying
              return if !request.get? && (is_api? || is_user_api?)
              raise ApplicationController::RenderEmpty.new if !request.format&.json? && !request.xhr?
            end
          
            def apply_cdn_headers
              Discourse.apply_cdn_headers(response.headers)
            end
          
            def self.requires_login(arg = {})
              @requires_login_arg = arg
            end
          
            def self.requires_login_arg
              @requires_login_arg
            end
          
            def block_if_requires_login
              if arg = self.class.requires_login_arg
                check =
                  if except = arg[:except]
                    !except.include?(action_name.to_sym)
                  elsif only = arg[:only]
                    only.include?(action_name.to_sym)
                  else
                    true
                  end
                ensure_logged_in if check
              end
            end
          
            def ensure_logged_in
              raise Discourse::NotLoggedIn.new if current_user.blank?
            end
          
            def ensure_staff
              raise Discourse::InvalidAccess.new unless current_user && current_user.staff?
            end
          
            def ensure_admin
              raise Discourse::InvalidAccess.new unless current_user && current_user.admin?
            end
          
            def ensure_wizard_enabled
              raise Discourse::InvalidAccess.new unless SiteSetting.wizard_enabled?
            end
          
            # Keep in sync with `NO_DESTINATION_COOKIE` in `frontend/discourse/app/lib/utilities.js`
            NO_DESTINATION_COOKIE = %w[/login /signup /session/ /auth/ /uploads/].freeze
          
            def is_valid_destination_url?(url)
              url.present? && url != path("/") && NO_DESTINATION_COOKIE.none? { url.start_with? path(_1) }
            end
          
            def destination_url
              request.original_url if is_valid_destination_url?(request.original_url)
            end
          
            def redirect_to_login
              dont_cache_page
          
              if SiteSetting.auth_immediately && SiteSetting.enable_discourse_connect?
                # save original URL in the server session so we can redirect after login
                server_session[:destination_url] = destination_url
                redirect_to path("/session/sso")
              elsif SiteSetting.auth_immediately && !SiteSetting.enable_local_logins &&
                    Discourse.enabled_authenticators.one? && !cookies[:authentication_data]
                # Only one authentication provider, direct straight to it.
                # If authentication_data is present, then we are halfway though registration. Don't redirect offsite
                cookies[:destination_url] = destination_url
                redirect_to path("/auth/#{Discourse.enabled_authenticators.first.name}")
              else
                return if request.path == path("/") && !cookies[:authentication_data]
                # save original URL in a cookie (javascript redirects after login in this case)
                cookies[:destination_url] = destination_url
                redirect_to path("/login")
              end
            end
          
            def redirect_to_login_if_required
              return if request.format.json? && is_api?
          
              # Used by clients authenticated via user API.
              # Redirects to provided URL scheme if
              # - request uses a valid public key and auth_redirect scheme
              # - one_time_password scope is allowed
              if !current_user && params.has_key?(:user_api_public_key) && params.has_key?(:auth_redirect)
                begin
                  OpenSSL::PKey::RSA.new(params[:user_api_public_key])
                rescue OpenSSL::PKey::RSAError
                  return render plain: I18n.t("user_api_key.invalid_public_key")
                end
          
                if UserApiKeyClient.invalid_auth_redirect?(params[:auth_redirect])
                  return render plain: I18n.t("user_api_key.invalid_auth_redirect")
                end
          
                if UserApiKey.allowed_scopes.superset?(Set.new(["one_time_password"]))
                  redirect_to("#{params[:auth_redirect]}?otp=true", allow_other_host: true)
                  return
                end
              end
          
              if !current_user && SiteSetting.login_required?
                flash.keep
                if (request.format && request.format.json?) || request.xhr? || !request.get?
                  ensure_logged_in
                else
                  redirect_to_login
                end
                return
              end
          
              return if !current_user
              return if !should_enforce_2fa?
          
              redirect_path = path("/u/#{current_user.encoded_username}/preferences/second-factor")
              if !request.fullpath.start_with?(redirect_path)
                redirect_to redirect_path
                nil
              end
            end
          
            def should_enforce_2fa?
              enforcing_2fa =
                (
                  (SiteSetting.enforce_second_factor == "staff" && current_user.staff?) ||
                    SiteSetting.enforce_second_factor == "all"
                )
              !disqualified_from_2fa_enforcement && enforcing_2fa &&
                !current_user.has_any_second_factor_methods_enabled?
            end
          
            def disqualified_from_2fa_enforcement
              request.format.json? || is_api? || current_user.anonymous? ||
                (
                  !SiteSetting.enforce_second_factor_on_external_auth &&
                    login_method == Auth::LOGIN_METHOD_OAUTH
                )
            end
          
            def redirect_to_profile_if_required
              return if request.format.json?
              return if !current_user
              return if !current_user.needs_required_fields_check?
          
              if current_user.populated_required_custom_fields?
                current_user.bump_required_fields_version
                return
              end
          
              redirect_path = path("/u/#{current_user.encoded_username}/preferences/profile")
              second_factor_path = path("/u/#{current_user.encoded_username}/preferences/second-factor")
              allowed_paths = [redirect_path, second_factor_path, path("/admin"), path("/safe-mode")]
              if allowed_paths.none? { |p| request.fullpath.start_with?(p) }
                rate_limiter = RateLimiter.new(current_user, "redirect_to_required_fields_log", 1, 24.hours)
          
                if rate_limiter.performed!(raise_error: false)
                  UserHistory.create!(
                    action: UserHistory.actions[:redirected_to_required_fields],
                    acting_user_id: current_user.id,
                  )
                end
          
                redirect_to path(redirect_path)
                nil
              end
            end
          
            def build_not_found_page(opts = {})
              if SiteSetting.bootstrap_error_pages?
                initialize_application_layout_preloader
                opts[:layout] = "application" if opts[:layout] == "no_ember"
              end
          
              @current_user =
                begin
                  current_user
                rescue StandardError
                  nil
                end
          
              if !SiteSetting.login_required? || @current_user
                key = "page_not_found_topics:#{I18n.locale}"
                @topics_partial =
                  Discourse
                    .cache
                    .fetch(key, expires_in: 10.minutes) do
                      category_topic_ids = Category.select(:topic_id).where.not(topic_id: nil)
                      @top_viewed =
                        TopicQuery
                          .new(nil, except_topic_ids: category_topic_ids)
                          .list_top_for("monthly")
                          .topics
                          .first(10)
                      @recent = Topic.includes(:category).where.not(id: category_topic_ids).recent(10)
                      render_to_string partial: "/exceptions/not_found_topics", formats: [:html]
                    end
                    .html_safe
              end
          
              @container_class = "wrap not-found-container"
              @page_title = I18n.t("page_not_found.page_title")
              @title = opts[:title] || I18n.t("page_not_found.title")
              @subtitle = opts[:subtitle] || I18n.t("page_not_found.subtitle")
              @group = opts[:group]
              @hide_search = true if SiteSetting.login_required
          
              params[:slug] = params[:slug].first if params[:slug].kind_of?(Array)
              params[:id] = params[:id].first if params[:id].kind_of?(Array)
              @slug = (params[:slug].presence || params[:id].presence || "").to_s.tr("-", " ")
          
              render_to_string status: opts[:status],
                               layout: opts[:layout],
                               formats: [:html],
                               template: "/exceptions/not_found"
            end
          
            def is_asset_path
              request.env["DISCOURSE_IS_ASSET_PATH"] = 1
            end
          
            def is_feed_request?
              request.format.atom? || request.format.rss?
            end
          
            def is_feed_response?
              request.get? && response&.content_type&.match?(/(rss|atom)/)
            end
          
            def add_noindex_header
              if request.get? && !response.headers["X-Robots-Tag"]
                if SiteSetting.allow_index_in_robots_txt
                  response.headers["X-Robots-Tag"] = "noindex"
                else
                  response.headers["X-Robots-Tag"] = "noindex, nofollow"
                end
              end
            end
          
            def add_noindex_header_to_non_canonical
              canonical = (@canonical_url || @default_canonical)
              if canonical.present? && canonical != request.url &&
                   !SiteSetting.allow_indexing_non_canonical_urls
                response.headers["X-Robots-Tag"] ||= "noindex"
              end
            end
          
            def set_cross_origin_opener_policy_header
              if current_user.present? && SiteSetting.cross_origin_opener_unsafe_none_groups_map.any? &&
                   current_user.in_any_groups?(SiteSetting.cross_origin_opener_unsafe_none_groups_map)
                response.headers["Cross-Origin-Opener-Policy"] = "unsafe-none"
              else
                response.headers["Cross-Origin-Opener-Policy"] = SiteSetting.cross_origin_opener_policy_header
              end
            end
          
            protected
          
            def honeypot_value
              server_session[HONEYPOT_KEY] ||= SecureRandom.hex
            end
          
            def challenge_value
              server_session[CHALLENGE_KEY] ||= SecureRandom.hex
            end
          
            def render_post_json(post, add_raw: true)
              post_serializer = PostSerializer.new(post, scope: guardian, root: false)
              post_serializer.add_raw = add_raw
          
              counts = PostAction.counts_for([post], current_user)
              if counts && counts = counts[post.id]
                post_serializer.post_actions = counts
              end
              render_json_dump(post_serializer)
            end
          
            # returns an array of integers given a param key
            # returns nil if key is not found
            def param_to_integer_list(key, delimiter = ",")
              case params[key]
              when String
                params[key].split(delimiter).map(&:to_i)
              when Array
                params[key].map(&:to_i)
              end
            end
          
            def run_second_factor!(action_class, action_data: nil, target_user: current_user)
              if current_user && target_user != current_user
                # Anon can run 2fa against another target, but logged-in users should not.
                # This should be validated at the `run_second_factor!` call site.
                raise "running 2fa against another user is not allowed"
              end
          
              action = action_class.new(guardian, request, opts: action_data, target_user: target_user)
              manager = SecondFactor::AuthManager.new(guardian, action, target_user: target_user)
              yield(manager) if block_given?
              result = manager.run!(request, params, server_session)
          
              if !result.no_second_factors_enabled? && !result.second_factor_auth_completed? &&
                   !result.second_factor_auth_skipped?
                # should never happen, but I want to know if somehow it does! (osama)
                raise "2fa process ended up in a bad state!"
              end
          
              result
            end
          
            # We don't actually send 103 Early Hint responses from Discourse. However, upstream proxies can be configured
            # to cache a response header from the app and use that to send an Early Hint response to future clients.
            # See 'early_hint_header_mode' and 'early_hint_header_name' Global Setting descriptions for more info.
            def add_early_hint_header
              return if GlobalSetting.early_hint_header_mode.nil?
          
              links = []
          
              if GlobalSetting.early_hint_header_mode == "preconnect"
                [GlobalSetting.cdn_url, SiteSetting.s3_cdn_url].each do |url|
                  next if url.blank?
                  base_url = URI.join(url, "/").to_s.chomp("/")
                  links.push("<#{base_url}>; rel=preconnect")
                end
              elsif GlobalSetting.early_hint_header_mode == "preload"
                links.push(*@asset_preload_links)
              end
          
              response.headers[GlobalSetting.early_hint_header_name] = links.join(", ") if links.present?
            end
          
            def spa_boot_request?
              request.get? && !(request.format && request.format.json?) && !request.xhr?
            end
          
            def fetch_limit_from_params(params: self.params, default:, max:)
              fetch_int_from_params(:limit, params: params, default: default, max: max)
            end
          
            def fetch_int_from_params(key, params: self.params, default:, min: 0, max: nil)
              key = key.to_sym
          
              if default.present? && ((max.present? && default > max) || (min.present? && default < min))
                raise "default #{key.inspect} is not between #{min.inspect} and #{max.inspect}"
              end
          
              if params.has_key?(key)
                value =
                  begin
                    Integer(params[key])
                  rescue ArgumentError
                    raise Discourse::InvalidParameters.new(key)
                  end
          
                if (min.present? && value < min) || (max.present? && value > max)
                  raise Discourse::InvalidParameters.new(key)
                end
          
                value
              else
                default
              end
            end
          
            def clean_xml
              response.body = response.body.gsub(XmlCleaner::INVALID_CHARACTERS, "")
            end
          
            def service_params
              { params: params.to_unsafe_h, guardian: }
            end
          
            def set_crawler_header
              response.headers["X-Discourse-Crawler-View"] = "true" if use_crawler_layout?
            end
          end

This file has been truncated. show original

Catching the error doesn’t help since result isn’t defined, so it fails later.

I’ve tried this will all perrmutations of having the user with 2fa enabled/not enabled, enforce_second_factor off/staff. Strangely, when I added my user today and tried to make it an admin from another admin account, it worked as expected, but no other admins can make any other users admins. They say this has been a problem for a year. Could there be some database issue?

It’s a recent build (at least one today). Only standard plugins and even with safe-mode.

@Osama , you have a comment a couple lines later, maybe you have an idea?

sam · 1 يوليو 2024، 9:50م

لست متأكدًا من كيف يمكن أن يكون result غير معرف بالنظر إلى:

github.com/discourse/discourse

lib/second_factor/auth_manager.rb

9e8d8d37f


      
          def run!(request, params, secure_session)
            if nonce = params[:second_factor_nonce].presence
              data = verify_second_factor_auth_completed(nonce, secure_session)
              create_result(:second_factor_auth_completed, data)
            elsif @action.skip_second_factor_auth?(params)
              data = @action.second_factor_auth_skipped!(params)
              create_result(:second_factor_auth_skipped, data)
            elsif !allowed_methods.any? { |m| @target_user.valid_second_factor_method_for_user?(m) }
              data = @action.no_second_factors_enabled!(params)
              create_result(:no_second_factor, data)
            else
              nonce = initiate_second_factor_auth(params, secure_session, request)
              raise SecondFactorRequired.new(nonce: nonce)
            end
          end

github.com/discourse/discourse

lib/second_factor/auth_manager.rb

9e8d8d37f


      
          def create_result(status, data = nil)
            SecondFactor::AuthManagerResult.new(status, data)
          end

هل أنت متأكد تمامًا من أنك تستخدم أحدث إصدار؟

pfaffman · 2 يوليو 2024، 1:48ص

لقد قمت بإعادة بناء اليوم.

هل هناك مكان آخر يمكنني وضع سجل تصحيح الأخطاء فيه؟

j.jaffeux · 2 يوليو 2024، 8:00ص

إذا كان بإمكانك تزويدنا بنسخة طبق الأصل مصغرة (مثل قائمة بإعدادات الموقع وقيمها)، فسيكون ذلك مفيدًا للغاية.

Osama · 2 يوليو 2024، 10:40ص

github.com/discourse/discourse

app/controllers/application_controller.rb

53e150716


      
          def run_second_factor!(action_class, action_data: nil, target_user: current_user)
            if current_user && target_user != current_user
              # Anon can run 2fa against another target, but logged-in users should not.
              # This should be validated at the `run_second_factor!` call site.
              raise "running 2fa against another user is not allowed"
            end
          
            action = action_class.new(guardian, request, opts: action_data, target_user: target_user)
            manager = SecondFactor::AuthManager.new(guardian, action, target_user: target_user)
            yield(manager) if block_given?
            result = manager.run!(request, params, secure_session)
          
            if !result.no_second_factors_enabled? && !result.second_factor_auth_completed? &&
                 !result.second_factor_auth_skipped?
              # should never happen, but I want to know if somehow it does! (osama)
              raise "2fa process ended up in a bad state!"
            end
          
            result
          end

هل يمكنك rescue الطريقة بأكملها وتسجيل الخطأ؟

def run_second_factor!(action_class, action_data: nil, target_user: current_user)
  if current_user && target_user != current_user
    # Anon can run 2fa against another target, but logged-in users should not.
    # This should be validated at the `run_second_factor!` call site.
    raise "running 2fa against another user is not allowed"
  end

  action = action_class.new(guardian, request, opts: action_data, target_user: target_user)
  manager = SecondFactor::AuthManager.new(guardian, action, target_user: target_user)
  yield(manager) if block_given?
  result = manager.run!(request, params, secure_session)

  if !result.no_second_factors_enabled? && !result.second_factor_auth_completed? &&
       !result.second_factor_auth_skipped?
    # should never happen, but I want to know if somehow it does! (osama)
    raise "2fa process ended up in a bad state!"
  end

  result
+rescue => err
+  Rails.logger.error(err.full_message)
+  raise
end

يجب أن يظهر شيء ما في /logs بمجرد إجراء هذا التغيير (وإعادة تحميل عمال Unicorn) ويجب أن يساعدنا ذلك في معرفة المشكلة.

pfaffman · 2 يوليو 2024، 4:13م

تنهد. يبدو أن الخطأ في run_second_factor! كان بسبب عبارات التصحيح الخاصة بي؛ إن التسبب في أخطاء عند البحث عنها هو أحد هواياتي المفضلة.

Started PUT "/admin/users/30591/grant_admin" for 174.50.213.142 at 2024-07-02 14:14:38 +0000
Processing by Admin::UsersController#grant_admin as */*
  Parameters: {"user_id"=>"30591"}
Completed 403 Forbidden in 6ms (Views: 0.1ms | ActiveRecord: 0.0ms | Allocations: 2263)

أعتقد أن الوصي لا يسمح لي بجعل المستخدم مسؤولًا لسبب ما.

لكنني ما زلت لا أفهم لماذا يفشل ولماذا يحصل على خطأ “An unhandled server error has occurred.”، بينما لا يمكنني العثور على هذا الخطأ في أي مكان في كود Discourse.

آه. وهذا مثير للاهتمام. لقد تمكنت من التغيير من jay@example.com إلى myaddress@gmail.com، ولكن محاولة تأكيد عنوان myaddress+123@gmail.com يؤدي أيضًا إلى ظهور رسالة “An unhandled server error has occurred.”. لم يتم تعيين normalize_emails.

أعتقد أن هناك خطأ ما في run_second_factor!، لكنني لا أستطيع فهم ما هو بالضبط. أنا أضيف بعض Rails.logger.warn مع بعض xxx.inspect، لذلك ربما أجد شيئًا.

أفضل ما يمكنني تقديره هو أن هناك خطأ ما في auth_manager. يبدو أنه يحاول إعادة التوجيه لسبب ما؟ لا يُطلب من المستخدمين العاديين المصادقة الثنائية، لذلك لا أعرف لماذا لا يمكن للمستخدم العادي تغيير عنوان بريده الإلكتروني. لكنني حاولت مع مستخدم بدون مصادقة ثنائية، رموز احتياطية، تم تسجيل الدخول قبل النقر على رابط تأكيد البريد الإلكتروني الجديد وبعد تسجيل الدخول، وكلها تفشل مع رسالة “An unhandled server error has occurred.”.

يبدو هذا مرتبطًا:

github.com/discourse/discourse

lib/second_factor/auth_manager.rb

main


      
          After this method is called, the auth manager will send a 403 response with a
          JSON body. It does that by raising an exception that's then rescued by a
          `rescue_from` handler. The JSON response contains a challenge nonce which the
          client/frontend will need to complete the 2fa. More on this later.

Osama · 2 يوليو 2024، 8:18م

خطأ 403 طبيعي ومتوقع — التطبيق الأمامي يلتقط استجابة 403 ويفسرها على أنها “لا يمكن منح الإدارة لأن المصادقة الثنائية مطلوبة، دعنا ننتقل إلى صفحة المصادقة الثنائية”.

ما هو غير طبيعي هو:

هل يمكنك إخباري أين ترى هذا الخطأ؟ هل هو نافذة منبثقة في الواجهة الأمامية؟ خطأ في السجلات؟ كما ذكرت، لا يمكنني العثور على رسالة الخطأ هذه في أي مكان في تاريخ قاعدة التعليمات البرمجية بأكملها، لذا فهي غريبة جدًا.

pfaffman · 2 يوليو 2024، 8:30م

إذًا ربما لا يقوم الواجهة الخلفية بعرض الأشياء التي تحتوي على عنوان URL للمصادقة الثنائية؟ لكن الخطأ يحدث بغض النظر عما إذا كان المستخدم لديه المصادقة الثنائية مفعلة أم لا، وبغض النظر عما إذا كان إعداد الموقع “فرض المصادقة الثنائية” ممكّنًا أم لا. وبغض النظر عما إذا كان المستخدم قد سجل الدخول بالفعل مع إعداد المصادقة الثنائية.

صحيح. لقد جربت الوضع الآمن، ولكن هذه هي الإضافات:

          - git clone https://github.com/discourse/docker_manager.git
          - git clone https://github.com/discourse/discourse-topic-voting.git
          - git clone https://github.com/discourse/discourse-chat-integration.git
          - git clone https://github.com/discourse/discourse-solved.git
          - git clone https://github.com/discourse/discourse-reactions.git
          - git clone https://github.com/discourse/discourse-docs.git
          - git clone https://github.com/discourse/discourse-user-notes.git

الخيط الوحيد الذي وجدته هو أنه يشير إلى أن الرسالة تأتي من Rails نفسها. ومع ذلك، لم أتمكن من معرفة كيف يمكن أن يحدث ذلك.

إذًا ربما هناك شيء ما يؤدي إلى تشغيل “نحن بحاجة إلى المصادقة الثنائية” عندما لا تكون المصادقة الثنائية مطلوبة في الواقع. من المنطقي بالتأكيد أن يتم تشغيل خطأ لتسجيل الدخول بالمصادقة الثنائية عندما لا يكون هناك أي منها. أعتقد أن هذا في guardian؟ لا يمكنني معرفة مكان وضع تصحيح أخطاء Rails.logger لتصحيح ذلك.

RGJ · 2 يوليو 2024، 11:11م

هذه فرصة ضئيلة جدًا، لذا أعتذر عندما أقول شيئًا سخيفًا تمامًا… ولكن البحث على جوجل عن " An unhandled server error has occurred" يشير فقط إلى كود Bitwarden مما يجعلني أعتقد أنه قد يكون هناك شيء ما على نظامك المحلي يعترض / يعبث بطلبك. هل هذا شيء يمكنك تكراره من جهاز كمبيوتر آخر؟

Osama · 3 يوليو 2024، 2:03ص

هل يمكنك التحقق من علامة التبويب “الشبكات” في أدوات المطور في متصفحك ومعرفة كيف يبدو الرد للطلب إلى نقطة النهاية grant_admin؟

يرجى أيضًا عرض علامة التبويب “الحمولة”.

pfaffman · 3 يوليو 2024، 1:56م

يبدو أن هذا قادم من الخادم. لا يمكنني العثور على هذا النص في قاعدة البيانات (على سبيل المثال، في النصوص المخصصة) أو عن طريق البحث في كل /var/www/discourse

لا يوجد علامة تبويب Payload:

انتظر!!! لقد قمت باستعادة قاعدة البيانات إلى خادم آخر وتمت إعادة التوجيه بشكل صحيح إلى صفحة العامل الثاني، والتي، بعد الحصول على مفتاح العامل الثاني، تغير حالة مسؤول المستخدم على الفور (لا حاجة للبريد الإلكتروني! وهو ما لم أكن أعرفه!).

لذا، هناك شيء ما يتعلق بـ . . . شيء ما، لكن تثبيتًا نظيفًا قياسيًا إلى حد كبير يحل المشكلة. على أي حال، ليس (بشكل واضح؟) . لقد غيرت الفئة.

التفسير المحتمل الآخر، والذي يبدو بعيد المنال أيضًا، هو أن هناك شيئًا ما خاطئًا بطريقة ما مع نموذج UserSecondFactor، حيث قمت بتنفيذ UserSecondFactor.all.destroy_all;UserSecurityKey.all.destroy_all; على خادم الاختبار الخاص بي نظرًا لأنه كان له اسم نطاق مختلف. لقد استخدمت أيضًا مصادقة Google بدلاً من مفتاح Yubi الخاص بي.

pfaffman · 2 أغسطس 2024، 1:56م

تم إغلاق هذا الموضوع تلقائيًا بعد 30 يومًا من آخر رد. لم يعد يُسمح بالردود الجديدة.

الموضوع		الردود	مرات العرض
Can't upgrade user to admin - unhandled server error Support	11	548	6 سبتمبر 2023
Granting admin rights fails for usernames with special characters when admin account has 2FA enabled Bug 2fa	4	116	17 أكتوبر 2025
New admins can't enroll 2FA when enforce second factor is set to Staff Bug	9	431	25 نوفمبر 2023
Admin locked out of site after deleting two-factor keys from prefs Bug	26	2252	8 ديسمبر 2022
User can't change his email address Support	10	701	24 يوليو 2023

فشل `run_second_factor!` عند محاولة ترقية المسؤول

الموضوعات ذات الصلة