jro_apps/redmine Commit - r13971:b895f6434ddd

Make the sudo timeout configurable (#19851)....

Jean-Philippe Lang -

r13971:b895f6434ddd

parent child

Context file:

r13971:b895f6434ddd

Collapse all files

config/configuration.yml.example +3 -2

             # = Redmine configuration file
             #
             # Each environment has it's own configuration options.  If you are only
             # running in production, only the production block needs to be configured.
             # Environment specific configuration options override the default ones.
             #
             # Note that this file needs to be a valid YAML file.
             # DO NOT USE TABS! Use 2 spaces instead of tabs for identation.
             # default configuration options for all environments
             default:
               # Outgoing emails configuration
               # See the examples below and the Rails guide for more configuration options:
               # http://guides.rubyonrails.org/action_mailer_basics.html#action-mailer-configuration
               email_delivery:
               # ==== Simple SMTP server at localhost
               #
               #  email_delivery:
               #    delivery_method: :smtp
               #    smtp_settings:
               #      address: "localhost"
               #      port: 25
               #
               # ==== SMTP server at example.com using LOGIN authentication and checking HELO for foo.com
               #
               #  email_delivery:
               #    delivery_method: :smtp
               #    smtp_settings:
               #      address: "example.com"
               #      port: 25
               #      authentication: :login
               #      domain: 'foo.com'
               #      user_name: 'myaccount'
               #      password: 'password'
               #
               # ==== SMTP server at example.com using PLAIN authentication
               #
               #  email_delivery:
               #    delivery_method: :smtp
               #    smtp_settings:
               #      address: "example.com"
               #      port: 25
               #      authentication: :plain
               #      domain: 'example.com'
               #      user_name: 'myaccount'
               #      password: 'password'
               #
               # ==== SMTP server at using TLS (GMail)
               # This might require some additional configuration. See the guides at:
               # http://www.redmine.org/projects/redmine/wiki/EmailConfiguration
               #
               #  email_delivery:
               #    delivery_method: :smtp
               #    smtp_settings:
               #      enable_starttls_auto: true
               #      address: "smtp.gmail.com"
               #      port: 587
               #      domain: "smtp.gmail.com" # 'your.domain.com' for GoogleApps
               #      authentication: :plain
               #      user_name: "your_email@gmail.com"
               #      password: "your_password"
               #
               # ==== Sendmail command
               #
               #  email_delivery:
               #    delivery_method: :sendmail
               # Absolute path to the directory where attachments are stored.
               # The default is the 'files' directory in your Redmine instance.
               # Your Redmine instance needs to have write permission on this
               # directory.
               # Examples:
               # attachments_storage_path: /var/redmine/files
               # attachments_storage_path: D:/redmine/files
               attachments_storage_path:
               # Configuration of the autologin cookie.
               # autologin_cookie_name: the name of the cookie (default: autologin)
               # autologin_cookie_path: the cookie path (default: /)
               # autologin_cookie_secure: true sets the cookie secure flag (default: false)
               autologin_cookie_name:
               autologin_cookie_path:
               autologin_cookie_secure:
               # Configuration of SCM executable command.
               #
               # Absolute path (e.g. /usr/local/bin/hg) or command name (e.g. hg.exe, bzr.exe)
               # On Windows + CRuby, *.cmd, *.bat (e.g. hg.cmd, bzr.bat) does not work.
               #
               # On Windows + JRuby 1.6.2, path which contains spaces does not work.
               # For example, "C:\Program Files\TortoiseHg\hg.exe".
               # If you want to this feature, you need to install to the path which does not contains spaces.
               # For example, "C:\TortoiseHg\hg.exe".
               #
               # Examples:
               # scm_subversion_command: svn                                       # (default: svn)
               # scm_mercurial_command:  C:\Program Files\TortoiseHg\hg.exe        # (default: hg)
               # scm_git_command:        /usr/local/bin/git                        # (default: git)
               # scm_cvs_command:        cvs                                       # (default: cvs)
               # scm_bazaar_command:     bzr.exe                                   # (default: bzr)
               # scm_darcs_command:      darcs-1.0.9-i386-linux                    # (default: darcs)
               #
               scm_subversion_command:
               scm_mercurial_command:
               scm_git_command:
               scm_cvs_command:
               scm_bazaar_command:
               scm_darcs_command:
               # SCM paths validation.
               #
               # You can configure a regular expression for each SCM that will be used to
               # validate the path of new repositories (eg. path entered by users with the
               # "Manage repositories" permission and path returned by reposman.rb).
               # The regexp will be wrapped with \A \z, so it must match the whole path.
               # And the regexp is case sensitive.
               #
               # You can match the project identifier by using %project% in the regexp.
               #
               # You can also set a custom hint message for each SCM that will be displayed
               # on the repository form instead of the default one.
               #
               # Examples:
               # scm_subversion_path_regexp: file:///svnpath/[a-z0-9_]+
               # scm_subversion_path_info: SVN URL (eg. file:///svnpath/foo)
               #
               # scm_git_path_regexp: /gitpath/%project%(\.[a-z0-9_])?/
               #
               scm_subversion_path_regexp:
               scm_mercurial_path_regexp:
               scm_git_path_regexp:
               scm_cvs_path_regexp:
               scm_bazaar_path_regexp:
               scm_darcs_path_regexp:
               scm_filesystem_path_regexp:
               # Absolute path to the SCM commands errors (stderr) log file.
               # The default is to log in the 'log' directory of your Redmine instance.
               # Example:
               # scm_stderr_log_file: /var/log/redmine_scm_stderr.log
               scm_stderr_log_file:
               # Key used to encrypt sensitive data in the database (SCM and LDAP passwords).
               # If you don't want to enable data encryption, just leave it blank.
               # WARNING: losing/changing this key will make encrypted data unreadable.
               #
               # If you want to encrypt existing passwords in your database:
               # * set the cipher key here in your configuration file
               # * encrypt data using 'rake db:encrypt RAILS_ENV=production'
               #
               # If you have encrypted data and want to change this key, you have to:
               # * decrypt data using 'rake db:decrypt RAILS_ENV=production' first
               # * change the cipher key here in your configuration file
               # * encrypt data using 'rake db:encrypt RAILS_ENV=production'
               database_cipher_key:
               # Set this to false to disable plugins' assets mirroring on startup.
               # You can use `rake redmine:plugins:assets` to manually mirror assets
               # to public/plugin_assets when you install/upgrade a Redmine plugin.
               #
               #mirror_plugins_assets_on_startup: false
               # Your secret key for verifying cookie session data integrity. If you
               # change this key, all old sessions will become invalid! Make sure the
               # secret is at least 30 characters and all random, no regular words or
               # you'll be exposed to dictionary attacks.
               #
               # If you have a load-balancing Redmine cluster, you have to use the
               # same secret token on each machine.
               #secret_token: 'change it to a long random string'
               # Requires users to re-enter their password for sensitive actions (editing
               # of account data, project memberships, application settings, user, group,
-              # role, auth source management and project deletion).
+              # role, auth source management and project deletion). Disabled by default.
-              # Disabled by default.
+              # Timeout is set in minutes.
               #
               #sudo_mode: true
+              #sudo_mode_timeout: 15
               # Absolute path (e.g. /usr/bin/convert, c:/im/convert.exe) to
               # the ImageMagick's `convert` binary. Used to generate attachment thumbnails.
               #imagemagick_convert_command:
               # Configuration of RMagcik font.
               #
               # Redmine uses RMagcik in order to export gantt png.
               # You don't need this setting if you don't install RMagcik.
               #
               # In CJK (Chinese, Japanese and Korean),
               # in order to show CJK characters correctly,
               # you need to set this configuration.
               #
               # Because there is no standard font across platforms in CJK,
               # you need to set a font installed in your server.
               #
               # This setting is not necessary in non CJK.
               #
               # Examples for Japanese:
               #   Windows:
               #     rmagick_font_path: C:\windows\fonts\msgothic.ttc
               #   Linux:
               #     rmagick_font_path: /usr/share/fonts/ipa-mincho/ipam.ttf
               #
               rmagick_font_path:
               # Maximum number of simultaneous AJAX uploads
               #max_concurrent_ajax_uploads: 2
               # Configure OpenIdAuthentication.store
               #
               # allowed values: :memory, :file, :memcache
               #openid_authentication_store: :memory
             # specific configuration options for production environment
             # that overrides the default ones
             production:
             # specific configuration options for development environment
             # that overrides the default ones
             development:

lib/redmine/sudo_mode.rb +6 -6

             require 'active_support/core_ext/object/to_query'
             require 'rack/utils'
             module Redmine
               module SudoMode
-                # timespan after which sudo mode expires when unused.
-                MAX_INACTIVITY = 15.minutes
                 class SudoRequired < StandardError
                 end
                 class Form
                   include ActiveModel::Validations
                   attr_accessor :password, :original_fields
                   validate :check_password
                   def initialize(password = nil)
                     self.password = password
                   end
                   def check_password
                     unless password.present? && User.current.check_password?(password)
                       errors[:password] << :invalid
                     end
                   end
                 end
                 module Helper
                   # Represents params data from hash as hidden fields
                   #
                   # taken from https://github.com/brianhempel/hash_to_hidden_fields
                   def hash_to_hidden_fields(hash)
                     cleaned_hash = hash.reject { |k, v| v.nil? }
                     pairs = cleaned_hash.to_query.split(Rack::Utils::DEFAULT_SEP)
                     tags = pairs.map do |pair|
                       key, value = pair.split('=', 2).map { |str| Rack::Utils.unescape(str) }
                       hidden_field_tag(key, value)
                     end
                     tags.join("\n").html_safe
                   end
                 end
                 module Controller
                   extend ActiveSupport::Concern
                   included do
                     around_filter :sudo_mode
                   end
                   # Sudo mode Around Filter
                   #
                   # Checks the 'last used' timestamp from session and sets the
                   # SudoMode::active? flag accordingly.
                   #
                   # After the request refreshes the timestamp if sudo mode was used during
                   # this request.
                   def sudo_mode
                     if sudo_timestamp_valid?
                       SudoMode.active!
                     end
                     yield
                     update_sudo_timestamp! if SudoMode.was_used?
                   end
                   # This renders the sudo mode form / handles sudo form submission.
                   #
                   # Call this method in controller actions if sudo permissions are required
                   # for processing this request. This approach is good in cases where the
                   # action needs to be protected in any case or where the check is simple.
                   #
                   # In cases where this decision depends on complex conditions in the model,
                   # consider the declarative approach using the require_sudo_mode class
                   # method and a corresponding declaration in the model that causes it to throw
                   # a SudoRequired Error when necessary.
                   #
                   # All parameter names given are included as hidden fields to be resubmitted
                   # along with the password.
                   #
                   # Returns true when processing the action should continue, false otherwise.
                   # If false is returned, render has already been called for display of the
                   # password form.
                   #
                   # if @user.mail_changed?
                   #   require_sudo_mode :user or return
                   # end
                   #
                   def require_sudo_mode(*param_names)
                     return true if SudoMode.active?
                     if param_names.blank?
                       param_names = params.keys - %w(id action controller sudo_password)
                     end
                     process_sudo_form
                     if SudoMode.active?
                       true
                     else
                       render_sudo_form param_names
                       false
                     end
                   end
                   # display the sudo password form
                   def render_sudo_form(param_names)
                     @sudo_form ||= SudoMode::Form.new
                     @sudo_form.original_fields = params.slice( *param_names )
                     # a simple 'render "sudo_mode/new"' works when used directly inside an
                     # action, but not when called from a before_filter:
                     respond_to do |format|
                       format.html { render 'sudo_mode/new' }
                       format.js   { render 'sudo_mode/new' }
                     end
                   end
                   # handle sudo password form submit
                   def process_sudo_form
                     if params[:sudo_password]
                       @sudo_form = SudoMode::Form.new(params[:sudo_password])
                       if @sudo_form.valid?
                         SudoMode.active!
                       else
                         flash.now[:error] = l(:notice_account_wrong_password)
                       end
                     end
                   end
                   def sudo_timestamp_valid?
-                    session[:sudo_timestamp].to_i > MAX_INACTIVITY.ago.to_i
+                    session[:sudo_timestamp].to_i > SudoMode.timeout.ago.to_i
                   end
                   def update_sudo_timestamp!(new_value = Time.now.to_i)
                     session[:sudo_timestamp] = new_value
                   end
                   # Before Filter which is used by the require_sudo_mode class method.
                   class SudoRequestFilter < Struct.new(:parameters, :request_methods)
                     def before(controller)
                       method_matches = request_methods.blank? || request_methods.include?(controller.request.method_symbol)
                       if controller.api_request?
                         true
                       elsif SudoMode.possible? && method_matches
                         controller.require_sudo_mode( *parameters )
                       else
                         true
                       end
                     end
                   end
                   module ClassMethods
                     # Handles sudo requirements for the given actions, preserving the named
                     # parameters, or any parameters if you omit the :parameters option.
                     #
                     # Sudo enforcement by default is active for all requests to an action
                     # but may be limited to a certain subset of request methods via the
                     # :only option.
                     #
                     # Examples:
                     #
                     # require_sudo_mode :account, only: :post
                     # require_sudo_mode :update, :create, parameters: %w(role)
                     # require_sudo_mode :destroy
                     #
                     def require_sudo_mode(*args)
                       actions = args.dup
                       options = actions.extract_options!
                       filter = SudoRequestFilter.new Array(options[:parameters]), Array(options[:only])
                       before_filter filter, only: actions
                     end
                   end
                 end
                 # true if the sudo mode state was queried during this request
                 def self.was_used?
                   !!RequestStore.store[:sudo_mode_was_used]
                 end
                 # true if sudo mode is currently active.
                 #
                 # Calling this method also turns was_used? to true, therefore
                 # it is important to only call this when sudo is actually needed, as the last
                 # condition to determine wether a change can be done or not.
                 #
                 # If you do it wrong, timeout of the sudo mode will happen too late or not at
                 # all.
                 def self.active?
                   if !!RequestStore.store[:sudo_mode]
                     RequestStore.store[:sudo_mode_was_used] = true
                   end
                 end
                 def self.active!
                   RequestStore.store[:sudo_mode] = true
                 end
                 def self.possible?
                   enabled? && User.current.logged?
                 end
                 # Turn off sudo mode (never require password entry).
                 def self.disable!
                   RequestStore.store[:sudo_mode_disabled] = true
                 end
                 # Turn sudo mode back on
                 def self.enable!
                   RequestStore.store[:sudo_mode_disabled] = nil
                 end
                 def self.enabled?
                   Redmine::Configuration['sudo_mode'] && !RequestStore.store[:sudo_mode_disabled]
                 end
+                # Timespan after which sudo mode expires when unused.
+                def self.timeout
+                  Redmine::Configuration['sudo_mode_timeout'].to_i.minutes
+                end
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages