X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/ddac660f3b7cc09a7718f20d1b857b0794d5a4ef..e89a78fff858d5db07f6959a39dd9655dc46008e:/app/controllers/application_controller.rb diff --git a/app/controllers/application_controller.rb b/app/controllers/application_controller.rb index 052858932..32b53bad7 100644 --- a/app/controllers/application_controller.rb +++ b/app/controllers/application_controller.rb @@ -1,4 +1,6 @@ class ApplicationController < ActionController::Base + require "timeout" + include SessionPersistence protect_from_forgery :with => :exception @@ -8,20 +10,38 @@ class ApplicationController < ActionController::Base rescue_from CanCan::AccessDenied, :with => :deny_access check_authorization + rescue_from RailsParam::InvalidParameterError, :with => :invalid_parameter + before_action :fetch_body - around_action :better_errors_allow_inline, :if => proc { Rails.env.development? } attr_accessor :current_user, :oauth_token helper_method :current_user helper_method :oauth_token - helper_method :preferred_langauges + + def self.allow_thirdparty_images(**options) + content_security_policy(options) do |policy| + policy.img_src("*", :data) + end + end + + def self.allow_social_login(**options) + content_security_policy(options) do |policy| + policy.form_action(*policy.form_action, "accounts.google.com", "*.facebook.com", "login.microsoftonline.com", "github.com", "meta.wikimedia.org") + end + end + + def self.allow_all_form_action(**options) + content_security_policy(options) do |policy| + policy.form_action(nil) + end + end private def authorize_web if session[:user] - self.current_user = User.where(:id => session[:user]).where("status IN ('active', 'confirmed', 'suspended')").first + self.current_user = User.find_by(:id => session[:user], :status => %w[active confirmed suspended]) if session[:fingerprint] && session[:fingerprint] != current_user.fingerprint @@ -43,8 +63,6 @@ class ApplicationController < ActionController::Base redirect_to :controller => "users", :action => "terms", :referer => request.fullpath end end - elsif session[:token] - session[:user] = current_user.id if self.current_user = User.authenticate(:token => session[:token]) end session[:fingerprint] = current_user.fingerprint if current_user && session[:fingerprint].nil? @@ -57,7 +75,7 @@ class ApplicationController < ActionController::Base def require_user unless current_user if request.get? - redirect_to :controller => "users", :action => "login", :referer => request.fullpath + redirect_to login_path(:referer => request.fullpath) else head :forbidden end @@ -65,7 +83,7 @@ class ApplicationController < ActionController::Base end def require_oauth - @oauth_token = current_user.access_token(Settings.oauth_key) if current_user && Settings.key?(:oauth_key) + @oauth_token = current_user.oauth_token(Settings.oauth_application) if current_user && Settings.key?(:oauth_application) end ## @@ -84,7 +102,7 @@ class ApplicationController < ActionController::Base end end - def check_database_readable(need_api = false) + def check_database_readable(need_api: false) if Settings.status == "database_offline" || (need_api && Settings.status == "api_offline") if request.xhr? report_error "Database offline for maintenance", :service_unavailable @@ -94,7 +112,7 @@ class ApplicationController < ActionController::Base end end - def check_database_writable(need_api = false) + def check_database_writable(need_api: false) if Settings.status == "database_offline" || Settings.status == "database_readonly" || (need_api && (Settings.status == "api_offline" || Settings.status == "api_readonly")) if request.xhr? @@ -159,8 +177,8 @@ class ApplicationController < ActionController::Base # TODO: some sort of escaping of problem characters in the message response.headers["Error"] = message - if request.headers["X-Error-Format"]&.casecmp("xml")&.zero? - result = OSM::API.new.get_xml_doc + if request.headers["X-Error-Format"]&.casecmp?("xml") + result = OSM::API.new.xml_doc result.root.name = "osmError" result.root << (XML::Node.new("status") << "#{Rack::Utils.status_code(status)} #{Rack::Utils::HTTP_STATUS_CODES[status]}") result.root << (XML::Node.new("message") << message) @@ -171,8 +189,7 @@ class ApplicationController < ActionController::Base end end - def preferred_languages(reset = false) - @preferred_languages = nil if reset + def preferred_languages @preferred_languages ||= if params[:locale] Locale.list(params[:locale]) elsif current_user @@ -184,89 +201,40 @@ class ApplicationController < ActionController::Base helper_method :preferred_languages - def set_locale(reset = false) + def set_locale if current_user&.languages&.empty? && !http_accept_language.user_preferred_languages.empty? current_user.languages = http_accept_language.user_preferred_languages current_user.save end - I18n.locale = Locale.available.preferred(preferred_languages(reset)) + I18n.locale = Locale.available.preferred(preferred_languages) response.headers["Vary"] = "Accept-Language" response.headers["Content-Language"] = I18n.locale.to_s end - def api_call_handle_error - yield - rescue ActionController::UnknownFormat - head :not_acceptable - rescue ActiveRecord::RecordNotFound => e - head :not_found - rescue LibXML::XML::Error, ArgumentError => e - report_error e.message, :bad_request - rescue ActiveRecord::RecordInvalid => e - message = "#{e.record.class} #{e.record.id}: " - e.record.errors.each { |attr, msg| message << "#{attr}: #{msg} (#{e.record[attr].inspect})" } - report_error message, :bad_request - rescue OSM::APIError => e - report_error e.message, e.status - rescue AbstractController::ActionNotFound => e - raise - rescue StandardError => e - logger.info("API threw unexpected #{e.class} exception: #{e.message}") - e.backtrace.each { |l| logger.info(l) } - report_error "#{e.class}: #{e.message}", :internal_server_error - end - - ## - # asserts that the request method is the +method+ given as a parameter - # or raises a suitable error. +method+ should be a symbol, e.g: :put or :get. - def assert_method(method) - ok = request.send(:"#{method.to_s.downcase}?") - raise OSM::APIBadMethodError, method unless ok - end - - ## - # wrap an api call in a timeout - def api_call_timeout(&block) - OSM::Timer.timeout(Settings.api_timeout, Timeout::Error, &block) - rescue Timeout::Error - raise OSM::APITimeoutError - end - ## # wrap a web page in a timeout - def web_timeout(&block) - OSM::Timer.timeout(Settings.web_timeout, Timeout::Error, &block) + def web_timeout(&) + raise Timeout::Error if Settings.web_timeout.negative? + + Timeout.timeout(Settings.web_timeout, &) rescue ActionView::Template::Error => e e = e.cause if e.is_a?(Timeout::Error) || (e.is_a?(ActiveRecord::StatementInvalid) && e.message.include?("execution expired")) - render :action => "timeout" + respond_to_timeout else raise end rescue Timeout::Error - render :action => "timeout" - end - - ## - # ensure that there is a "user" instance variable - def lookup_user - render_unknown_user params[:display_name] unless @user = User.active.find_by(:display_name => params[:display_name]) + respond_to_timeout end - ## - # render a "no such user" page - def render_unknown_user(name) - @title = t "users.no_such_user.title" - @not_found_user = name - - respond_to do |format| - format.html { render :template => "users/no_such_user", :status => :not_found } - format.all { head :not_found } - end + def respond_to_timeout + ActiveRecord::Base.connection.raw_connection.cancel + render :action => "timeout", :status => :gateway_timeout end ## @@ -283,13 +251,13 @@ class ApplicationController < ActionController::Base end def map_layout - append_content_security_policy_directives( - :child_src => %w[http://127.0.0.1:8111 https://127.0.0.1:8112], - :frame_src => %w[http://127.0.0.1:8111 https://127.0.0.1:8112], - :connect_src => [Settings.nominatim_url, Settings.overpass_url, Settings.fossgis_osrm_url, Settings.graphhopper_url], - :form_action => %w[render.openstreetmap.org], - :style_src => %w['unsafe-inline'] - ) + policy = request.content_security_policy.clone + + policy.connect_src(*policy.connect_src, "http://127.0.0.1:8111", Settings.nominatim_url, Settings.overpass_url, Settings.fossgis_osrm_url, Settings.graphhopper_url, Settings.fossgis_valhalla_url) + policy.form_action(*policy.form_action, "render.openstreetmap.org") + policy.style_src(*policy.style_src, :unsafe_inline) + + request.content_security_policy = policy case Settings.status when "database_offline", "api_offline" @@ -301,10 +269,6 @@ class ApplicationController < ActionController::Base request.xhr? ? "xhr" : "map" end - def allow_thirdparty_images - append_content_security_policy_directives(:img_src => %w[*]) - end - def preferred_editor if params[:editor] params[:editor] @@ -315,7 +279,15 @@ class ApplicationController < ActionController::Base end end - helper_method :preferred_editor + def preferred_color_scheme(subject) + if current_user + current_user.preferences.find_by(:k => "#{subject}.color_scheme")&.v || "auto" + else + "auto" + end + end + + helper_method :preferred_editor, :preferred_color_scheme def update_totp if Settings.key?(:totp_key) @@ -327,34 +299,23 @@ class ApplicationController < ActionController::Base end end - def better_errors_allow_inline - yield - rescue StandardError - append_content_security_policy_directives( - :script_src => %w['unsafe-inline'], - :style_src => %w['unsafe-inline'] - ) - - raise - end - def current_ability Ability.new(current_user) end def deny_access(_exception) - if current_token + if doorkeeper_token set_locale report_error t("oauth.permissions.missing"), :forbidden elsif current_user set_locale respond_to do |format| - format.html { redirect_to :controller => "errors", :action => "forbidden" } + format.html { redirect_to :controller => "/errors", :action => "forbidden" } format.any { report_error t("application.permission_denied"), :forbidden } end elsif request.get? respond_to do |format| - format.html { redirect_to :controller => "users", :action => "login", :referer => request.fullpath } + format.html { redirect_to login_path(:referer => request.fullpath) } format.any { head :forbidden } end else @@ -362,35 +323,41 @@ class ApplicationController < ActionController::Base end end - # extract authorisation credentials from headers, returns user = nil if none - def get_auth_data - if request.env.key? "X-HTTP_AUTHORIZATION" # where mod_rewrite might have put it - authdata = request.env["X-HTTP_AUTHORIZATION"].to_s.split - elsif request.env.key? "REDIRECT_X_HTTP_AUTHORIZATION" # mod_fcgi - authdata = request.env["REDIRECT_X_HTTP_AUTHORIZATION"].to_s.split - elsif request.env.key? "HTTP_AUTHORIZATION" # regular location - authdata = request.env["HTTP_AUTHORIZATION"].to_s.split + def invalid_parameter(_exception) + if request.get? + respond_to do |format| + format.html { redirect_to :controller => "/errors", :action => "bad_request" } + format.any { head :bad_request } + end + else + head :bad_request end - # only basic authentication supported - user, pass = Base64.decode64(authdata[1]).split(":", 2) if authdata && authdata[0] == "Basic" - [user, pass] end - # override to stop oauth plugin sending errors - def invalid_oauth_response; end - # clean any referer parameter def safe_referer(referer) - referer = URI.parse(referer) + begin + referer = URI.parse(referer) + + if referer.scheme == "http" || referer.scheme == "https" + referer.scheme = nil + referer.host = nil + referer.port = nil + elsif referer.scheme || referer.host || referer.port + referer = nil + end - if referer.scheme == "http" || referer.scheme == "https" - referer.scheme = nil - referer.host = nil - referer.port = nil - elsif referer.scheme || referer.host || referer.port + referer = nil if referer&.path&.first != "/" + rescue URI::InvalidURIError referer = nil end - referer.to_s + referer&.to_s end + + def scope_enabled?(scope) + doorkeeper_token&.includes_scope?(scope) + end + + helper_method :scope_enabled? end