X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/acfbc091982fbf74baeef7d16ff7d84f63c84951..f4e29905263efbb2eafdedad6a5c050ba559efd8:/app/controllers/application_controller.rb diff --git a/app/controllers/application_controller.rb b/app/controllers/application_controller.rb index 1df6dd7d1..227e5198f 100644 --- a/app/controllers/application_controller.rb +++ b/app/controllers/application_controller.rb @@ -4,6 +4,7 @@ class ApplicationController < ActionController::Base protect_from_forgery :with => :exception rescue_from CanCan::AccessDenied, :with => :deny_access + check_authorization before_action :fetch_body around_action :better_errors_allow_inline, :if => proc { Rails.env.development? } @@ -54,24 +55,6 @@ class ApplicationController < ActionController::Base @oauth = current_user.access_token(OAUTH_KEY) if current_user && defined? OAUTH_KEY end - ## - # requires the user to be logged in by the token or HTTP methods, or have an - # OAuth token with the right capability. this method is a bit of a pain to call - # directly, since it's cumbersome to call filters with arguments in rails. to - # make it easier to read and write the code, there are some utility methods - # below. - def require_capability(cap) - # when the current token is nil, it means the user logged in with a different - # method, otherwise an OAuth token was used, which has to be checked. - unless current_token.nil? - unless current_token.read_attribute(cap) - set_locale - report_error t("oauth.permissions.missing"), :forbidden - false - end - end - end - ## # require the user to have cookies enabled in their browser def require_cookies @@ -88,54 +71,6 @@ class ApplicationController < ActionController::Base end end - # Utility methods to make the controller filter methods easier to read and write. - def require_allow_read_prefs - require_capability(:allow_read_prefs) - end - - def require_allow_write_prefs - require_capability(:allow_write_prefs) - end - - def require_allow_write_diary - require_capability(:allow_write_diary) - end - - def require_allow_write_api - require_capability(:allow_write_api) - - if REQUIRE_TERMS_AGREED && current_user.terms_agreed.nil? - report_error "You must accept the contributor terms before you can edit.", :forbidden - return false - end - end - - def require_allow_read_gpx - require_capability(:allow_read_gpx) - end - - def require_allow_write_gpx - require_capability(:allow_write_gpx) - end - - def require_allow_write_notes - require_capability(:allow_write_notes) - end - - ## - # require that the user is a moderator, or fill out a helpful error message - # and return them to the index for the controller this is wrapped from. - def require_moderator - unless current_user.moderator? - if request.get? - flash[:error] = t("application.require_moderator.not_a_moderator") - redirect_to :action => "index" - else - head :forbidden - end - end - end - ## # sets up the current_user for use by other methods. this is mostly called # from the authorize method, but can be called elsewhere if authorisation @@ -170,7 +105,7 @@ class ApplicationController < ActionController::Base # if the user hasn't seen the contributor terms then don't # allow editing - they have to go to the web site and see # (but can decline) the CTs to continue. - if REQUIRE_TERMS_SEEN && !current_user.terms_seen && flash[:skip_terms].nil? + if !current_user.terms_seen && flash[:skip_terms].nil? set_locale report_error t("application.setup_user_auth.need_to_see_terms"), :forbidden end @@ -190,22 +125,6 @@ class ApplicationController < ActionController::Base end end - ## - # to be used as a before_filter *after* authorize. this checks that - # the user is a moderator and, if not, returns a forbidden error. - # - # NOTE: this isn't a very good way of doing it - it duplicates logic - # from require_moderator - but what we really need to do is a fairly - # drastic refactoring based on :format and respond_to? but not a - # good idea to do that in this branch. - def authorize_moderator(errormessage = "Access restricted to moderators") - # check user is a moderator - unless current_user.moderator? - render :plain => errormessage, :status => :forbidden - false - end - end - def check_database_readable(need_api = false) if STATUS == :database_offline || (need_api && STATUS == :api_offline) if request.xhr? @@ -414,10 +333,9 @@ class ApplicationController < ActionController::Base 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 => %w[nominatim.openstreetmap.org overpass-api.de router.project-osrm.org graphhopper.com], + :connect_src => [NOMINATIM_URL, OVERPASS_URL, FOSSGIS_OSRM_URL, GRAPHHOPPER_URL], :form_action => %w[render.openstreetmap.org], - :script_src => %w[open.mapquestapi.com], - :img_src => %w[developer.mapquest.com] + :style_src => %w['unsafe-inline'] ) if STATUS == :database_offline || STATUS == :api_offline @@ -469,28 +387,62 @@ class ApplicationController < ActionController::Base end def current_ability - # Add in capabilities from the oauth token if it exists and is a valid access token + # Use capabilities from the oauth token if it exists and is a valid access token if Authenticator.new(self, [:token]).allow? - Ability.new(current_user).merge(Capability.new(current_token)) + Ability.new(nil).merge(Capability.new(current_token)) else Ability.new(current_user) end end - def deny_access(_exception) + def deny_access(exception) + if @api_deny_access_handling + api_deny_access(exception) + else + web_deny_access(exception) + end + end + + def web_deny_access(_exception) if current_token set_locale report_error t("oauth.permissions.missing"), :forbidden elsif current_user set_locale - report_error t("application.permission_denied"), :forbidden + respond_to do |format| + format.html { redirect_to :controller => "errors", :action => "forbidden" } + format.any { report_error t("application.permission_denied"), :forbidden } + end elsif request.get? - redirect_to :controller => "users", :action => "login", :referer => request.fullpath + respond_to do |format| + format.html { redirect_to :controller => "users", :action => "login", :referer => request.fullpath } + format.any { head :forbidden } + end else head :forbidden end end + def api_deny_access(_exception) + if current_token + set_locale + report_error t("oauth.permissions.missing"), :forbidden + elsif current_user + head :forbidden + else + realm = "Web Password" + errormessage = "Couldn't authenticate you" + response.headers["WWW-Authenticate"] = "Basic realm=\"#{realm}\"" + render :plain => errormessage, :status => :unauthorized + end + end + + attr_accessor :api_access_handling + + def api_deny_access_handler + @api_deny_access_handling = true + end + private # extract authorisation credentials from headers, returns user = nil if none