actionpack 6.0.0

data/lib/action_dispatch/middleware/reloader.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  # ActionDispatch::Reloader wraps the request with callbacks provided by ActiveSupport::Reloader
+  # callbacks, intended to assist with code reloading during development.
+  #
+  # By default, ActionDispatch::Reloader is included in the middleware stack
+  # only in the development environment; specifically, when +config.cache_classes+
+  # is false.
+  class Reloader < Executor
+  end
+end

data/lib/action_dispatch/middleware/remote_ip.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+
+module ActionDispatch
+  # This middleware calculates the IP address of the remote client that is
+  # making the request. It does this by checking various headers that could
+  # contain the address, and then picking the last-set address that is not
+  # on the list of trusted IPs. This follows the precedent set by e.g.
+  # {the Tomcat server}[https://issues.apache.org/bugzilla/show_bug.cgi?id=50453],
+  # with {reasoning explained at length}[http://blog.gingerlime.com/2012/rails-ip-spoofing-vulnerabilities-and-protection]
+  # by @gingerlime. A more detailed explanation of the algorithm is given
+  # at GetIp#calculate_ip.
+  #
+  # Some Rack servers concatenate repeated headers, like {HTTP RFC 2616}[https://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2]
+  # requires. Some Rack servers simply drop preceding headers, and only report
+  # the value that was {given in the last header}[http://andre.arko.net/2011/12/26/repeated-headers-and-ruby-web-servers].
+  # If you are behind multiple proxy servers (like NGINX to HAProxy to Unicorn)
+  # then you should test your Rack server to make sure your data is good.
+  #
+  # IF YOU DON'T USE A PROXY, THIS MAKES YOU VULNERABLE TO IP SPOOFING.
+  # This middleware assumes that there is at least one proxy sitting around
+  # and setting headers with the client's remote IP address. If you don't use
+  # a proxy, because you are hosted on e.g. Heroku without SSL, any client can
+  # claim to have any IP address by setting the X-Forwarded-For header. If you
+  # care about that, then you need to explicitly drop or ignore those headers
+  # sometime before this middleware runs.
+  class RemoteIp
+    class IpSpoofAttackError < StandardError; end
+
+    # The default trusted IPs list simply includes IP addresses that are
+    # guaranteed by the IP specification to be private addresses. Those will
+    # not be the ultimate client IP in production, and so are discarded. See
+    # https://en.wikipedia.org/wiki/Private_network for details.
+    TRUSTED_PROXIES = [
+      "127.0.0.1",      # localhost IPv4
+      "::1",            # localhost IPv6
+      "fc00::/7",       # private IPv6 range fc00::/7
+      "10.0.0.0/8",     # private IPv4 range 10.x.x.x
+      "172.16.0.0/12",  # private IPv4 range 172.16.0.0 .. 172.31.255.255
+      "192.168.0.0/16", # private IPv4 range 192.168.x.x
+    ].map { |proxy| IPAddr.new(proxy) }
+
+    attr_reader :check_ip, :proxies
+
+    # Create a new +RemoteIp+ middleware instance.
+    #
+    # The +ip_spoofing_check+ option is on by default. When on, an exception
+    # is raised if it looks like the client is trying to lie about its own IP
+    # address. It makes sense to turn off this check on sites aimed at non-IP
+    # clients (like WAP devices), or behind proxies that set headers in an
+    # incorrect or confusing way (like AWS ELB).
+    #
+    # The +custom_proxies+ argument can take an Array of string, IPAddr, or
+    # Regexp objects which will be used instead of +TRUSTED_PROXIES+. If a
+    # single string, IPAddr, or Regexp object is provided, it will be used in
+    # addition to +TRUSTED_PROXIES+. Any proxy setup will put the value you
+    # want in the middle (or at the beginning) of the X-Forwarded-For list,
+    # with your proxy servers after it. If your proxies aren't removed, pass
+    # them in via the +custom_proxies+ parameter. That way, the middleware will
+    # ignore those IP addresses, and return the one that you want.
+    def initialize(app, ip_spoofing_check = true, custom_proxies = nil)
+      @app = app
+      @check_ip = ip_spoofing_check
+      @proxies = if custom_proxies.blank?
+        TRUSTED_PROXIES
+      elsif custom_proxies.respond_to?(:any?)
+        custom_proxies
+      else
+        Array(custom_proxies) + TRUSTED_PROXIES
+      end
+    end
+
+    # Since the IP address may not be needed, we store the object here
+    # without calculating the IP to keep from slowing down the majority of
+    # requests. For those requests that do need to know the IP, the
+    # GetIp#calculate_ip method will calculate the memoized client IP address.
+    def call(env)
+      req = ActionDispatch::Request.new env
+      req.remote_ip = GetIp.new(req, check_ip, proxies)
+      @app.call(req.env)
+    end
+
+    # The GetIp class exists as a way to defer processing of the request data
+    # into an actual IP address. If the ActionDispatch::Request#remote_ip method
+    # is called, this class will calculate the value and then memoize it.
+    class GetIp
+      def initialize(req, check_ip, proxies)
+        @req      = req
+        @check_ip = check_ip
+        @proxies  = proxies
+      end
+
+      # Sort through the various IP address headers, looking for the IP most
+      # likely to be the address of the actual remote client making this
+      # request.
+      #
+      # REMOTE_ADDR will be correct if the request is made directly against the
+      # Ruby process, on e.g. Heroku. When the request is proxied by another
+      # server like HAProxy or NGINX, the IP address that made the original
+      # request will be put in an X-Forwarded-For header. If there are multiple
+      # proxies, that header may contain a list of IPs. Other proxy services
+      # set the Client-Ip header instead, so we check that too.
+      #
+      # As discussed in {this post about Rails IP Spoofing}[http://blog.gingerlime.com/2012/rails-ip-spoofing-vulnerabilities-and-protection/],
+      # while the first IP in the list is likely to be the "originating" IP,
+      # it could also have been set by the client maliciously.
+      #
+      # In order to find the first address that is (probably) accurate, we
+      # take the list of IPs, remove known and trusted proxies, and then take
+      # the last address left, which was presumably set by one of those proxies.
+      def calculate_ip
+        # Set by the Rack web server, this is a single value.
+        remote_addr = ips_from(@req.remote_addr).last
+
+        # Could be a CSV list and/or repeated headers that were concatenated.
+        client_ips    = ips_from(@req.client_ip).reverse
+        forwarded_ips = ips_from(@req.x_forwarded_for).reverse
+
+        # +Client-Ip+ and +X-Forwarded-For+ should not, generally, both be set.
+        # If they are both set, it means that either:
+        #
+        # 1) This request passed through two proxies with incompatible IP header
+        #    conventions.
+        # 2) The client passed one of +Client-Ip+ or +X-Forwarded-For+
+        #    (whichever the proxy servers weren't using) themselves.
+        #
+        # Either way, there is no way for us to determine which header is the
+        # right one after the fact. Since we have no idea, if we are concerned
+        # about IP spoofing we need to give up and explode. (If you're not
+        # concerned about IP spoofing you can turn the +ip_spoofing_check+
+        # option off.)
+        should_check_ip = @check_ip && client_ips.last && forwarded_ips.last
+        if should_check_ip && !forwarded_ips.include?(client_ips.last)
+          # We don't know which came from the proxy, and which from the user
+          raise IpSpoofAttackError, "IP spoofing attack?! " \
+            "HTTP_CLIENT_IP=#{@req.client_ip.inspect} " \
+            "HTTP_X_FORWARDED_FOR=#{@req.x_forwarded_for.inspect}"
+        end
+
+        # We assume these things about the IP headers:
+        #
+        #   - X-Forwarded-For will be a list of IPs, one per proxy, or blank
+        #   - Client-Ip is propagated from the outermost proxy, or is blank
+        #   - REMOTE_ADDR will be the IP that made the request to Rack
+        ips = [forwarded_ips, client_ips, remote_addr].flatten.compact
+
+        # If every single IP option is in the trusted list, just return REMOTE_ADDR
+        filter_proxies(ips).first || remote_addr
+      end
+
+      # Memoizes the value returned by #calculate_ip and returns it for
+      # ActionDispatch::Request to use.
+      def to_s
+        @ip ||= calculate_ip
+      end
+
+    private
+
+      def ips_from(header) # :doc:
+        return [] unless header
+        # Split the comma-separated list into an array of strings.
+        ips = header.strip.split(/[,\s]+/)
+        ips.select do |ip|
+          # Only return IPs that are valid according to the IPAddr#new method.
+          range = IPAddr.new(ip).to_range
+          # We want to make sure nobody is sneaking a netmask in.
+          range.begin == range.end
+        rescue ArgumentError
+          nil
+        end
+      end
+
+      def filter_proxies(ips) # :doc:
+        ips.reject do |ip|
+          @proxies.any? { |proxy| proxy === ip }
+        end
+      end
+    end
+  end
+end

data/lib/action_dispatch/middleware/request_id.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "active_support/core_ext/string/access"
+
+module ActionDispatch
+  # Makes a unique request id available to the +action_dispatch.request_id+ env variable (which is then accessible
+  # through <tt>ActionDispatch::Request#request_id</tt> or the alias <tt>ActionDispatch::Request#uuid</tt>) and sends
+  # the same id to the client via the X-Request-Id header.
+  #
+  # The unique request id is either based on the X-Request-Id header in the request, which would typically be generated
+  # by a firewall, load balancer, or the web server, or, if this header is not available, a random uuid. If the
+  # header is accepted from the outside world, we sanitize it to a max of 255 chars and alphanumeric and dashes only.
+  #
+  # The unique request id can be used to trace a request end-to-end and would typically end up being part of log files
+  # from multiple pieces of the stack.
+  class RequestId
+    X_REQUEST_ID = "X-Request-Id" #:nodoc:
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      req = ActionDispatch::Request.new env
+      req.request_id = make_request_id(req.x_request_id)
+      @app.call(env).tap { |_status, headers, _body| headers[X_REQUEST_ID] = req.request_id }
+    end
+
+    private
+      def make_request_id(request_id)
+        if request_id.presence
+          request_id.gsub(/[^\w\-@]/, "").first(255)
+        else
+          internal_request_id
+        end
+      end
+
+      def internal_request_id
+        SecureRandom.uuid
+      end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "rack/utils"
+require "rack/request"
+require "rack/session/abstract/id"
+require "action_dispatch/middleware/cookies"
+require "action_dispatch/request/session"
+
+module ActionDispatch
+  module Session
+    class SessionRestoreError < StandardError #:nodoc:
+      def initialize
+        super("Session contains objects whose class definition isn't available.\n" \
+          "Remember to require the classes for all objects kept in the session.\n" \
+          "(Original exception: #{$!.message} [#{$!.class}])\n")
+        set_backtrace $!.backtrace
+      end
+    end
+
+    module Compatibility
+      def initialize(app, options = {})
+        options[:key] ||= "_session_id"
+        super
+      end
+
+      def generate_sid
+        sid = SecureRandom.hex(16)
+        sid.encode!(Encoding::UTF_8)
+        sid
+      end
+
+    private
+
+      def initialize_sid # :doc:
+        @default_options.delete(:sidbits)
+        @default_options.delete(:secure_random)
+      end
+
+      def make_request(env)
+        ActionDispatch::Request.new env
+      end
+    end
+
+    module StaleSessionCheck
+      def load_session(env)
+        stale_session_check! { super }
+      end
+
+      def extract_session_id(env)
+        stale_session_check! { super }
+      end
+
+      def stale_session_check!
+        yield
+      rescue ArgumentError => argument_error
+        if argument_error.message =~ %r{undefined class/module ([\w:]*\w)}
+          begin
+            # Note that the regexp does not allow $1 to end with a ':'.
+            $1.constantize
+          rescue LoadError, NameError
+            raise ActionDispatch::Session::SessionRestoreError
+          end
+          retry
+        else
+          raise
+        end
+      end
+    end
+
+    module SessionObject # :nodoc:
+      def prepare_session(req)
+        Request::Session.create(self, req, @default_options)
+      end
+
+      def loaded_session?(session)
+        !session.is_a?(Request::Session) || session.loaded?
+      end
+    end
+
+    class AbstractStore < Rack::Session::Abstract::Persisted
+      include Compatibility
+      include StaleSessionCheck
+      include SessionObject
+
+      private
+
+        def set_cookie(request, session_id, cookie)
+          request.cookie_jar[key] = cookie
+        end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "action_dispatch/middleware/session/abstract_store"
+
+module ActionDispatch
+  module Session
+    # 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.
+    #
+    # ==== 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 < AbstractStore
+      def initialize(app, options = {})
+        @cache = options[:cache] || Rails.cache
+        options[:expire_after] ||= @cache.options[:expires_in]
+        super
+      end
+
+      # Get a session from the cache.
+      def find_session(env, sid)
+        unless sid && (session = @cache.read(cache_key(sid)))
+          sid, session = generate_sid, {}
+        end
+        [sid, session]
+      end
+
+      # Set a session in the cache.
+      def write_session(env, sid, session, options)
+        key = cache_key(sid)
+        if session
+          @cache.write(key, session, expires_in: options[:expire_after])
+        else
+          @cache.delete(key)
+        end
+        sid
+      end
+
+      # Remove a session from the cache.
+      def delete_session(env, sid, options)
+        @cache.delete(cache_key(sid))
+        generate_sid
+      end
+
+      private
+        # Turn the session id into a cache key.
+        def cache_key(sid)
+          "_session_id:#{sid}"
+        end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# 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
+    # This cookie-based session store is the Rails default. It is
+    # dramatically faster than the alternatives.
+    #
+    # Sessions typically contain at most a user_id and flash message; both fit
+    # within the 4K cookie size limit. A CookieOverflow exception is raised if
+    # you attempt to store more than 4K of data.
+    #
+    # The cookie jar used for storage is automatically configured to be the
+    # best possible option given your application's configuration.
+    #
+    # 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.
+    #
+    # Configure your session store in an initializer:
+    #
+    #   Rails.application.config.session_store :cookie_store, key: '_your_app_session'
+    #
+    # 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.
+    #
+    # 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.
+    #
+    # 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:
+    #
+    #   Rails.application.config.session_store :cookie_store, expire_after: 14.days
+    #
+    # 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 < AbstractStore
+      def initialize(app, options = {})
+        super(app, options.merge!(cookie_only: true))
+      end
+
+      def delete_session(req, session_id, options)
+        new_sid = generate_sid unless options[:drop]
+        # Reset hash and Assign the new session id
+        req.set_header("action_dispatch.request.unsigned_session_cookie", new_sid ? { "session_id" => new_sid } : {})
+        new_sid
+      end
+
+      def load_session(req)
+        stale_session_check! do
+          data = unpacked_cookie_data(req)
+          data = persistent_session_id!(data)
+          [data["session_id"], data]
+        end
+      end
+
+      private
+
+        def extract_session_id(req)
+          stale_session_check! do
+            unpacked_cookie_data(req)["session_id"]
+          end
+        end
+
+        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
+            req.set_header k, v
+          end
+        end
+
+        def persistent_session_id!(data, sid = nil)
+          data ||= {}
+          data["session_id"] ||= sid || generate_sid
+          data
+        end
+
+        def write_session(req, sid, session_data, options)
+          session_data["session_id"] = sid
+          session_data
+        end
+
+        def set_cookie(request, session_id, cookie)
+          cookie_jar(request)[@key] = cookie
+        end
+
+        def get_cookie(req)
+          cookie_jar(req)[@key]
+        end
+
+        def cookie_jar(request)
+          request.cookie_jar.signed_or_encrypted
+        end
+    end
+  end
+end