actionpack 4.2.11.1 → 5.2.4.3

data/lib/action_dispatch/middleware/session/cache_store.rb

@@ -1,13 +1,18 @@
-require 'action_dispatch/middleware/session/abstract_store'
+# frozen_string_literal: true
+
+require "action_dispatch/middleware/session/abstract_store"
 
 module ActionDispatch
   module Session
-    # Session store that uses an ActiveSupport::Cache::Store to store the sessions. This store is most useful
+    # A session store that uses an ActiveSupport::Cache::Store to store the sessions. This store is most useful
     # if you don't store critical data in your sessions and you don't need them to live for extended periods
     # of time.
-    class CacheStore < AbstractStore
-      # Create a new store. The cache to use can be passed in the <tt>:cache</tt> option. If it is
-      # not specified, <tt>Rails.cache</tt> will be used.
+    #
+    # ==== Options
+    # * <tt>cache</tt>         - The cache to use. If it is not specified, <tt>Rails.cache</tt> will be used.
+    # * <tt>expire_after</tt>  - The length of time a session will be stored before automatically expiring.
+    #   By default, the <tt>:expires_in</tt> option of the cache is used.
+    class CacheStore < AbstractSecureStore
       def initialize(app, options = {})
         @cache = options[:cache] || Rails.cache
         options[:expire_after] ||= @cache.options[:expires_in]
@@ -15,18 +20,18 @@ module ActionDispatch
       end
 
       # Get a session from the cache.
-      def get_session(env, sid)
-        unless sid and session = @cache.read(cache_key(sid))
+      def find_session(env, sid)
+        unless sid && (session = get_session_with_fallback(sid))
           sid, session = generate_sid, {}
         end
         [sid, session]
       end
 
       # Set a session in the cache.
-      def set_session(env, sid, session, options)
-        key = cache_key(sid)
+      def write_session(env, sid, session, options)
+        key = cache_key(sid.private_id)
         if session
-          @cache.write(key, session, :expires_in => options[:expire_after])
+          @cache.write(key, session, expires_in: options[:expire_after])
         else
           @cache.delete(key)
         end
@@ -34,15 +39,20 @@ module ActionDispatch
       end
 
       # Remove a session from the cache.
-      def destroy_session(env, sid, options)
-        @cache.delete(cache_key(sid))
+      def delete_session(env, sid, options)
+        @cache.delete(cache_key(sid.private_id))
+        @cache.delete(cache_key(sid.public_id))
         generate_sid
       end
 
       private
         # Turn the session id into a cache key.
-        def cache_key(sid)
-          "_session_id:#{sid}"
+        def cache_key(id)
+          "_session_id:#{id}"
+        end
+
+        def get_session_with_fallback(sid)
+          @cache.read(cache_key(sid.private_id)) || @cache.read(cache_key(sid.public_id))
         end
     end
   end

data/lib/action_dispatch/middleware/session/cookie_store.rb

@@ -1,6 +1,8 @@
-require 'active_support/core_ext/hash/keys'
-require 'action_dispatch/middleware/session/abstract_store'
-require 'rack/session/cookie'
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/keys"
+require "action_dispatch/middleware/session/abstract_store"
+require "rack/session/cookie"
 
 module ActionDispatch
   module Session
@@ -19,105 +21,108 @@ module ActionDispatch
     # knowing your app's secret key, but can easily read their +user_id+. This
     # was the default for Rails 3 apps.
     #
-    # If you have secret_key_base set, your cookies will be encrypted. This
+    # Your cookies will be encrypted using your apps secret_key_base. This
     # goes a step further than signed cookies in that encrypted cookies cannot
     # be altered or read by users. This is the default starting in Rails 4.
     #
-    # If you have both secret_token and secret_key base set, your cookies will
-    # be encrypted, and signed cookies generated by Rails 3 will be
-    # transparently read and encrypted to provide a smooth upgrade path.
-    #
-    # Configure your session store in config/initializers/session_store.rb:
+    # Configure your session store in <tt>config/initializers/session_store.rb</tt>:
     #
     #   Rails.application.config.session_store :cookie_store, key: '_your_app_session'
     #
-    # Configure your secret key in config/secrets.yml:
+    # In the development and test environments your application's secret key base is
+    # generated by Rails and stored in a temporary file in <tt>tmp/development_secret.txt</tt>.
+    # In all other environments, it is stored encrypted in the
+    # <tt>config/credentials.yml.enc</tt> file.
+    #
+    # If your application was not updated to Rails 5.2 defaults, the secret_key_base
+    # will be found in the old <tt>config/secrets.yml</tt> file.
     #
-    #   development:
-    #     secret_key_base: 'secret key'
+    # Note that changing your secret_key_base will invalidate all existing session.
+    # Additionally, you should take care to make sure you are not relying on the
+    # ability to decode signed cookies generated by your app in external
+    # applications or JavaScript before changing it.
     #
-    # To generate a secret key for an existing application, run `rake secret`.
+    # Because CookieStore extends Rack::Session::Abstract::Persisted, many of the
+    # options described there can be used to customize the session cookie that
+    # is generated. For example:
     #
-    # If you are upgrading an existing Rails 3 app, you should leave your
-    # existing secret_token in place and simply add the new secret_key_base.
-    # Note that you should wait to set secret_key_base until you have 100% of
-    # your userbase on Rails 4 and are reasonably sure you will not need to
-    # rollback to Rails 3. This is because cookies signed based on the new
-    # secret_key_base in Rails 4 are not backwards compatible with Rails 3.
-    # You are free to leave your existing secret_token in place, not set the
-    # new secret_key_base, and ignore the deprecation warnings until you are
-    # reasonably sure that your upgrade is otherwise complete. Additionally,
-    # you should take care to make sure you are not relying on the ability to
-    # decode signed cookies generated by your app in external applications or
-    # JavaScript before upgrading.
+    #   Rails.application.config.session_store :cookie_store, expire_after: 14.days
     #
-    # Note that changing the secret key will invalidate all existing sessions!
-    class CookieStore < Rack::Session::Abstract::ID
-      include Compatibility
-      include StaleSessionCheck
-      include SessionObject
+    # would set the session cookie to expire automatically 14 days after creation.
+    # Other useful options include <tt>:key</tt>, <tt>:secure</tt> and
+    # <tt>:httponly</tt>.
+    class CookieStore < AbstractSecureStore
+      class SessionId < DelegateClass(Rack::Session::SessionId)
+        attr_reader :cookie_value
+
+        def initialize(session_id, cookie_value = {})
+          super(session_id)
+          @cookie_value = cookie_value
+        end
+      end
 
-      def initialize(app, options={})
-        super(app, options.merge!(:cookie_only => true))
+      def initialize(app, options = {})
+        super(app, options.merge!(cookie_only: true))
       end
 
-      def destroy_session(env, session_id, options)
+      def delete_session(req, session_id, options)
         new_sid = generate_sid unless options[:drop]
         # Reset hash and Assign the new session id
-        env["action_dispatch.request.unsigned_session_cookie"] = new_sid ? { "session_id" => new_sid } : {}
+        req.set_header("action_dispatch.request.unsigned_session_cookie", new_sid ? { "session_id" => new_sid.public_id } : {})
         new_sid
       end
 
-      def load_session(env)
+      def load_session(req)
         stale_session_check! do
-          data = unpacked_cookie_data(env)
+          data = unpacked_cookie_data(req)
           data = persistent_session_id!(data)
-          [data["session_id"], data]
+          [Rack::Session::SessionId.new(data["session_id"]), data]
         end
       end
 
       private
 
-      def extract_session_id(env)
-        stale_session_check! do
-          unpacked_cookie_data(env)["session_id"]
+        def extract_session_id(req)
+          stale_session_check! do
+            sid = unpacked_cookie_data(req)["session_id"]
+            sid && Rack::Session::SessionId.new(sid)
+          end
         end
-      end
 
-      def unpacked_cookie_data(env)
-        env["action_dispatch.request.unsigned_session_cookie"] ||= begin
-          stale_session_check! do
-            if data = get_cookie(env)
-              data.stringify_keys!
+        def unpacked_cookie_data(req)
+          req.fetch_header("action_dispatch.request.unsigned_session_cookie") do |k|
+            v = stale_session_check! do
+              if data = get_cookie(req)
+                data.stringify_keys!
+              end
+              data || {}
             end
-            data || {}
+            req.set_header k, v
           end
         end
-      end
 
-      def persistent_session_id!(data, sid=nil)
-        data ||= {}
-        data["session_id"] ||= sid || generate_sid
-        data
-      end
+        def persistent_session_id!(data, sid = nil)
+          data ||= {}
+          data["session_id"] ||= sid || generate_sid.public_id
+          data
+        end
 
-      def set_session(env, sid, session_data, options)
-        session_data["session_id"] = sid
-        session_data
-      end
+        def write_session(req, sid, session_data, options)
+          session_data["session_id"] = sid.public_id
+          SessionId.new(sid, session_data)
+        end
 
-      def set_cookie(env, session_id, cookie)
-        cookie_jar(env)[@key] = cookie
-      end
+        def set_cookie(request, session_id, cookie)
+          cookie_jar(request)[@key] = cookie
+        end
 
-      def get_cookie(env)
-        cookie_jar(env)[@key]
-      end
+        def get_cookie(req)
+          cookie_jar(req)[@key]
+        end
 
-      def cookie_jar(env)
-        request = ActionDispatch::Request.new(env)
-        request.cookie_jar.signed_or_encrypted
-      end
+        def cookie_jar(request)
+          request.cookie_jar.signed_or_encrypted
+        end
     end
   end
 end

data/lib/action_dispatch/middleware/session/mem_cache_store.rb

@@ -1,6 +1,8 @@
-require 'action_dispatch/middleware/session/abstract_store'
+# frozen_string_literal: true
+
+require "action_dispatch/middleware/session/abstract_store"
 begin
-  require 'rack/session/dalli'
+  require "rack/session/dalli"
 rescue LoadError => e
   $stderr.puts "You don't have dalli installed in your application. Please add it to your Gemfile and run bundle install"
   raise e
@@ -8,6 +10,10 @@ end
 
 module ActionDispatch
   module Session
+    # A session store that uses MemCache to implement storage.
+    #
+    # ==== Options
+    # * <tt>expire_after</tt>  - The length of time a session will be stored before automatically expiring.
     class MemCacheStore < Rack::Session::Dalli
       include Compatibility
       include StaleSessionCheck

data/lib/action_dispatch/middleware/show_exceptions.rb

@@ -1,5 +1,7 @@
-require 'action_dispatch/http/request'
-require 'action_dispatch/middleware/exception_wrapper'
+# frozen_string_literal: true
+
+require "action_dispatch/http/request"
+require "action_dispatch/middleware/exception_wrapper"
 
 module ActionDispatch
   # This middleware rescues any exception returned by the application
@@ -8,14 +10,14 @@ module ActionDispatch
   # The exceptions app should be passed as parameter on initialization
   # of ShowExceptions. Every time there is an exception, ShowExceptions will
   # store the exception in env["action_dispatch.exception"], rewrite the
-  # PATH_INFO to the exception status code and call the rack app.
+  # PATH_INFO to the exception status code and call the Rack app.
   #
   # If the application returns a "X-Cascade" pass response, this middleware
   # will send an empty response as result with the correct status code.
   # If any exception happens inside the exceptions app, this middleware
   # catches the exceptions and returns a FAILSAFE_RESPONSE.
   class ShowExceptions
-    FAILSAFE_RESPONSE = [500, { 'Content-Type' => 'text/plain' },
+    FAILSAFE_RESPONSE = [500, { "Content-Type" => "text/plain" },
       ["500 Internal Server Error\n" \
        "If you are the administrator of this website, then please read this web " \
        "application's log file and/or the web server's log file to find out what " \
@@ -27,32 +29,34 @@ module ActionDispatch
     end
 
     def call(env)
+      request = ActionDispatch::Request.new env
       @app.call(env)
     rescue Exception => exception
-      if env['action_dispatch.show_exceptions'] == false
-        raise exception
+      if request.show_exceptions?
+        render_exception(request, exception)
       else
-        render_exception(env, exception)
+        raise exception
       end
     end
 
     private
 
-    def render_exception(env, exception)
-      wrapper = ExceptionWrapper.new(env, exception)
-      status  = wrapper.status_code
-      env["action_dispatch.exception"] = wrapper.exception
-      env["action_dispatch.original_path"] = env["PATH_INFO"]
-      env["PATH_INFO"] = "/#{status}"
-      response = @exceptions_app.call(env)
-      response[1]['X-Cascade'] == 'pass' ? pass_response(status) : response
-    rescue Exception => failsafe_error
-      $stderr.puts "Error during failsafe response: #{failsafe_error}\n  #{failsafe_error.backtrace * "\n  "}"
-      FAILSAFE_RESPONSE
-    end
+      def render_exception(request, exception)
+        backtrace_cleaner = request.get_header "action_dispatch.backtrace_cleaner"
+        wrapper = ExceptionWrapper.new(backtrace_cleaner, exception)
+        status  = wrapper.status_code
+        request.set_header "action_dispatch.exception", wrapper.exception
+        request.set_header "action_dispatch.original_path", request.path_info
+        request.path_info = "/#{status}"
+        response = @exceptions_app.call(request.env)
+        response[1]["X-Cascade"] == "pass" ? pass_response(status) : response
+      rescue Exception => failsafe_error
+        $stderr.puts "Error during failsafe response: #{failsafe_error}\n  #{failsafe_error.backtrace * "\n  "}"
+        FAILSAFE_RESPONSE
+      end
 
-    def pass_response(status)
-      [status, {"Content-Type" => "text/html; charset=#{Response.default_charset}", "Content-Length" => "0"}, []]
-    end
+      def pass_response(status)
+        [status, { "Content-Type" => "text/html; charset=#{Response.default_charset}", "Content-Length" => "0" }, []]
+      end
   end
 end

data/lib/action_dispatch/middleware/ssl.rb

@@ -1,72 +1,150 @@
+# frozen_string_literal: true
+
 module ActionDispatch
+  # This middleware is added to the stack when <tt>config.force_ssl = true</tt>, and is passed
+  # the options set in +config.ssl_options+. It does three jobs to enforce secure HTTP
+  # requests:
+  #
+  # 1. <b>TLS redirect</b>: Permanently redirects +http://+ requests to +https://+
+  #    with the same URL host, path, etc. Enabled by default. Set +config.ssl_options+
+  #    to modify the destination URL
+  #    (e.g. <tt>redirect: { host: "secure.widgets.com", port: 8080 }</tt>), or set
+  #    <tt>redirect: false</tt> to disable this feature.
+  #
+  #    Requests can opt-out of redirection with +exclude+:
+  #
+  #      config.ssl_options = { redirect: { exclude: -> request { request.path =~ /healthcheck/ } } }
+  #
+  #    Cookies will not be flagged as secure for excluded requests.
+  #
+  # 2. <b>Secure cookies</b>: Sets the +secure+ flag on cookies to tell browsers they
+  #    must not be sent along with +http://+ requests. Enabled by default. Set
+  #    +config.ssl_options+ with <tt>secure_cookies: false</tt> to disable this feature.
+  #
+  # 3. <b>HTTP Strict Transport Security (HSTS)</b>: Tells the browser to remember
+  #    this site as TLS-only and automatically redirect non-TLS requests.
+  #    Enabled by default. Configure +config.ssl_options+ with <tt>hsts: false</tt> to disable.
+  #
+  #    Set +config.ssl_options+ with <tt>hsts: { ... }</tt> to configure HSTS:
+  #
+  #    * +expires+: How long, in seconds, these settings will stick. The minimum
+  #      required to qualify for browser preload lists is 1 year. Defaults to
+  #      1 year (recommended).
+  #
+  #    * +subdomains+: Set to +true+ to tell the browser to apply these settings
+  #      to all subdomains. This protects your cookies from interception by a
+  #      vulnerable site on a subdomain. Defaults to +true+.
+  #
+  #    * +preload+: Advertise that this site may be included in browsers'
+  #      preloaded HSTS lists. HSTS protects your site on every visit <i>except the
+  #      first visit</i> since it hasn't seen your HSTS header yet. To close this
+  #      gap, browser vendors include a baked-in list of HSTS-enabled sites.
+  #      Go to https://hstspreload.org to submit your site for inclusion.
+  #      Defaults to +false+.
+  #
+  #    To turn off HSTS, omitting the header is not enough. Browsers will remember the
+  #    original HSTS directive until it expires. Instead, use the header to tell browsers to
+  #    expire HSTS immediately. Setting <tt>hsts: false</tt> is a shortcut for
+  #    <tt>hsts: { expires: 0 }</tt>.
   class SSL
-    YEAR = 31536000
+    # :stopdoc:
+
+    # Default to 1 year, the minimum for browser preload lists.
+    HSTS_EXPIRES_IN = 31536000
 
     def self.default_hsts_options
-      { :expires => YEAR, :subdomains => false }
+      { expires: HSTS_EXPIRES_IN, subdomains: true, preload: false }
     end
 
-    def initialize(app, options = {})
+    def initialize(app, redirect: {}, hsts: {}, secure_cookies: true)
       @app = app
 
-      @hsts = options.fetch(:hsts, {})
-      @hsts = {} if @hsts == true
-      @hsts = self.class.default_hsts_options.merge(@hsts) if @hsts
+      @redirect = redirect
+
+      @exclude = @redirect && @redirect[:exclude] || proc { !@redirect }
+      @secure_cookies = secure_cookies
 
-      @host    = options[:host]
-      @port    = options[:port]
+      @hsts_header = build_hsts_header(normalize_hsts_options(hsts))
     end
 
     def call(env)
-      request = Request.new(env)
+      request = Request.new env
 
       if request.ssl?
-        status, headers, body = @app.call(env)
-        headers.reverse_merge!(hsts_headers)
-        flag_cookies_as_secure!(headers)
-        [status, headers, body]
+        @app.call(env).tap do |status, headers, body|
+          set_hsts_header! headers
+          flag_cookies_as_secure! headers if @secure_cookies && !@exclude.call(request)
+        end
       else
-        redirect_to_https(request)
+        return redirect_to_https request unless @exclude.call(request)
+        @app.call(env)
       end
     end
 
     private
-      def redirect_to_https(request)
-        host = @host || request.host
-        port = @port || request.port
-
-        location = "https://#{host}"
-        location << ":#{port}" if port != 80
-        location << request.fullpath
-
-        headers = { 'Content-Type' => 'text/html', 'Location' => location }
-
-        [301, headers, []]
+      def set_hsts_header!(headers)
+        headers["Strict-Transport-Security".freeze] ||= @hsts_header
       end
 
-      # http://tools.ietf.org/html/draft-hodges-strict-transport-sec-02
-      def hsts_headers
-        if @hsts
-          value = "max-age=#{@hsts[:expires].to_i}"
-          value += "; includeSubDomains" if @hsts[:subdomains]
-          { 'Strict-Transport-Security' => value }
+      def normalize_hsts_options(options)
+        case options
+        # Explicitly disabling HSTS clears the existing setting from browsers
+        # by setting expiry to 0.
+        when false
+          self.class.default_hsts_options.merge(expires: 0)
+        # Default to enabled, with default options.
+        when nil, true
+          self.class.default_hsts_options
         else
-          {}
+          self.class.default_hsts_options.merge(options)
         end
       end
 
+      # https://tools.ietf.org/html/rfc6797#section-6.1
+      def build_hsts_header(hsts)
+        value = "max-age=#{hsts[:expires].to_i}".dup
+        value << "; includeSubDomains" if hsts[:subdomains]
+        value << "; preload" if hsts[:preload]
+        value
+      end
+
       def flag_cookies_as_secure!(headers)
-        if cookies = headers['Set-Cookie']
-          cookies = cookies.split("\n")
+        if cookies = headers["Set-Cookie".freeze]
+          cookies = cookies.split("\n".freeze)
 
-          headers['Set-Cookie'] = cookies.map { |cookie|
+          headers["Set-Cookie".freeze] = cookies.map { |cookie|
             if cookie !~ /;\s*secure\s*(;|$)/i
               "#{cookie}; secure"
             else
               cookie
             end
-          }.join("\n")
+          }.join("\n".freeze)
         end
       end
+
+      def redirect_to_https(request)
+        [ @redirect.fetch(:status, redirection_status(request)),
+          { "Content-Type" => "text/html",
+            "Location" => https_location_for(request) },
+          @redirect.fetch(:body, []) ]
+      end
+
+      def redirection_status(request)
+        if request.get? || request.head?
+          301 # Issue a permanent redirect via a GET request.
+        else
+          307 # Issue a fresh request redirect to preserve the HTTP method.
+        end
+      end
+
+      def https_location_for(request)
+        host = @redirect[:host] || request.host
+        port = @redirect[:port] || request.port
+
+        location = "https://#{host}".dup
+        location << ":#{port}" if port != 80 && port != 443
+        location << request.fullpath
+        location
+      end
   end
 end