actionpack 6.0.0

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "action_dispatch/middleware/session/abstract_store"
+begin
+  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
+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
+      include SessionObject
+
+      def initialize(app, options = {})
+        options[:expire_after] ||= options[:expires]
+        super
+      end
+    end
+  end
+end

data/lib/action_dispatch/middleware/show_exceptions.rb

@@ -0,0 +1,62 @@
+# 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
+  # and calls an exceptions app that will wrap it in a format for the end user.
+  #
+  # 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.
+  #
+  # 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" },
+      ["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 " \
+       "went wrong."]]
+
+    def initialize(app, exceptions_app)
+      @app = app
+      @exceptions_app = exceptions_app
+    end
+
+    def call(env)
+      request = ActionDispatch::Request.new env
+      @app.call(env)
+    rescue Exception => exception
+      if request.show_exceptions?
+        render_exception(request, exception)
+      else
+        raise exception
+      end
+    end
+
+    private
+
+      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.unwrapped_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
+  end
+end

data/lib/action_dispatch/middleware/ssl.rb

@@ -0,0 +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
+    # :stopdoc:
+
+    # Default to 1 year, the minimum for browser preload lists.
+    HSTS_EXPIRES_IN = 31536000
+
+    def self.default_hsts_options
+      { expires: HSTS_EXPIRES_IN, subdomains: true, preload: false }
+    end
+
+    def initialize(app, redirect: {}, hsts: {}, secure_cookies: true)
+      @app = app
+
+      @redirect = redirect
+
+      @exclude = @redirect && @redirect[:exclude] || proc { !@redirect }
+      @secure_cookies = secure_cookies
+
+      @hsts_header = build_hsts_header(normalize_hsts_options(hsts))
+    end
+
+    def call(env)
+      request = Request.new env
+
+      if request.ssl?
+        @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
+        return redirect_to_https request unless @exclude.call(request)
+        @app.call(env)
+      end
+    end
+
+    private
+      def set_hsts_header!(headers)
+        headers["Strict-Transport-Security"] ||= @hsts_header
+      end
+
+      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}"
+        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")
+
+          headers["Set-Cookie"] = cookies.map { |cookie|
+            if !/;\s*secure\s*(;|$)/i.match?(cookie)
+              "#{cookie}; secure"
+            else
+              cookie
+            end
+          }.join("\n")
+        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}"
+        location << ":#{port}" if port != 80 && port != 443
+        location << request.fullpath
+        location
+      end
+  end
+end

data/lib/action_dispatch/middleware/stack.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "active_support/inflector/methods"
+require "active_support/dependencies"
+
+module ActionDispatch
+  class MiddlewareStack
+    class Middleware
+      attr_reader :args, :block, :klass
+
+      def initialize(klass, args, block)
+        @klass = klass
+        @args  = args
+        @block = block
+      end
+
+      def name; klass.name; end
+
+      def ==(middleware)
+        case middleware
+        when Middleware
+          klass == middleware.klass
+        when Class
+          klass == middleware
+        end
+      end
+
+      def inspect
+        if klass.is_a?(Class)
+          klass.to_s
+        else
+          klass.class.to_s
+        end
+      end
+
+      def build(app)
+        klass.new(app, *args, &block)
+      end
+
+      def build_instrumented(app)
+        InstrumentationProxy.new(build(app), inspect)
+      end
+    end
+
+    # This class is used to instrument the execution of a single middleware.
+    # It proxies the `call` method transparently and instruments the method
+    # call.
+    class InstrumentationProxy
+      EVENT_NAME = "process_middleware.action_dispatch"
+
+      def initialize(middleware, class_name)
+        @middleware = middleware
+
+        @payload = {
+          middleware: class_name,
+        }
+      end
+
+      def call(env)
+        ActiveSupport::Notifications.instrument(EVENT_NAME, @payload) do
+          @middleware.call(env)
+        end
+      end
+    end
+
+    include Enumerable
+
+    attr_accessor :middlewares
+
+    def initialize(*args)
+      @middlewares = []
+      yield(self) if block_given?
+    end
+
+    def each
+      @middlewares.each { |x| yield x }
+    end
+
+    def size
+      middlewares.size
+    end
+
+    def last
+      middlewares.last
+    end
+
+    def [](i)
+      middlewares[i]
+    end
+
+    def unshift(klass, *args, &block)
+      middlewares.unshift(build_middleware(klass, args, block))
+    end
+
+    def initialize_copy(other)
+      self.middlewares = other.middlewares.dup
+    end
+
+    def insert(index, klass, *args, &block)
+      index = assert_index(index, :before)
+      middlewares.insert(index, build_middleware(klass, args, block))
+    end
+
+    alias_method :insert_before, :insert
+
+    def insert_after(index, *args, &block)
+      index = assert_index(index, :after)
+      insert(index + 1, *args, &block)
+    end
+
+    def swap(target, *args, &block)
+      index = assert_index(target, :before)
+      insert(index, *args, &block)
+      middlewares.delete_at(index + 1)
+    end
+
+    def delete(target)
+      middlewares.delete_if { |m| m.klass == target }
+    end
+
+    def use(klass, *args, &block)
+      middlewares.push(build_middleware(klass, args, block))
+    end
+
+    def build(app = nil, &block)
+      instrumenting = ActiveSupport::Notifications.notifier.listening?(InstrumentationProxy::EVENT_NAME)
+      middlewares.freeze.reverse.inject(app || block) do |a, e|
+        if instrumenting
+          e.build_instrumented(a)
+        else
+          e.build(a)
+        end
+      end
+    end
+
+    private
+
+      def assert_index(index, where)
+        i = index.is_a?(Integer) ? index : middlewares.index { |m| m.klass == index }
+        raise "No such middleware to insert #{where}: #{index.inspect}" unless i
+        i
+      end
+
+      def build_middleware(klass, args, block)
+        Middleware.new(klass, args, block)
+      end
+  end
+end

data/lib/action_dispatch/middleware/static.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "rack/utils"
+require "active_support/core_ext/uri"
+
+module ActionDispatch
+  # This middleware returns a file's contents from disk in the body response.
+  # When initialized, it can accept optional HTTP headers, which will be set
+  # when a response containing a file's contents is delivered.
+  #
+  # This middleware will render the file specified in <tt>env["PATH_INFO"]</tt>
+  # where the base path is in the +root+ directory. For example, if the +root+
+  # is set to +public/+, then a request with <tt>env["PATH_INFO"]</tt> of
+  # +assets/application.js+ will return a response with the contents of a file
+  # located at +public/assets/application.js+ if the file exists. If the file
+  # does not exist, a 404 "File not Found" response will be returned.
+  class FileHandler
+    def initialize(root, index: "index", headers: {})
+      @root          = root.chomp("/").b
+      @file_server   = ::Rack::File.new(@root, headers)
+      @index         = index
+    end
+
+    # Takes a path to a file. If the file is found, has valid encoding, and has
+    # correct read permissions, the return value is a URI-escaped string
+    # representing the filename. Otherwise, false is returned.
+    #
+    # Used by the +Static+ class to check the existence of a valid file
+    # in the server's +public/+ directory (see Static#call).
+    def match?(path)
+      path = ::Rack::Utils.unescape_path path
+      return false unless ::Rack::Utils.valid_path? path
+      path = ::Rack::Utils.clean_path_info path
+
+      paths = [path, "#{path}#{ext}", "#{path}/#{@index}#{ext}"]
+
+      if match = paths.detect { |p|
+        path = File.join(@root, p.b)
+        begin
+          File.file?(path) && File.readable?(path)
+        rescue SystemCallError
+          false
+        end
+      }
+        return ::Rack::Utils.escape_path(match).b
+      end
+    end
+
+    def call(env)
+      serve(Rack::Request.new(env))
+    end
+
+    def serve(request)
+      path      = request.path_info
+      gzip_path = gzip_file_path(path)
+
+      if gzip_path && gzip_encoding_accepted?(request)
+        request.path_info           = gzip_path
+        status, headers, body       = @file_server.call(request.env)
+        if status == 304
+          return [status, headers, body]
+        end
+        headers["Content-Encoding"] = "gzip"
+        headers["Content-Type"]     = content_type(path)
+      else
+        status, headers, body = @file_server.call(request.env)
+      end
+
+      headers["Vary"] = "Accept-Encoding" if gzip_path
+
+      [status, headers, body]
+    ensure
+      request.path_info = path
+    end
+
+    private
+      def ext
+        ::ActionController::Base.default_static_extension
+      end
+
+      def content_type(path)
+        ::Rack::Mime.mime_type(::File.extname(path), "text/plain")
+      end
+
+      def gzip_encoding_accepted?(request)
+        request.accept_encoding.any? { |enc, quality| enc =~ /\bgzip\b/i }
+      end
+
+      def gzip_file_path(path)
+        can_gzip_mime = content_type(path) =~ /\A(?:text\/|application\/javascript)/
+        gzip_path     = "#{path}.gz"
+        if can_gzip_mime && File.exist?(File.join(@root, ::Rack::Utils.unescape_path(gzip_path)))
+          gzip_path
+        else
+          false
+        end
+      end
+  end
+
+  # This middleware will attempt to return the contents of a file's body from
+  # disk in the response. If a file is not found on disk, the request will be
+  # delegated to the application stack. This middleware is commonly initialized
+  # to serve assets from a server's +public/+ directory.
+  #
+  # This middleware verifies the path to ensure that only files
+  # living in the root directory can be rendered. A request cannot
+  # produce a directory traversal using this middleware. Only 'GET' and 'HEAD'
+  # requests will result in a file being returned.
+  class Static
+    def initialize(app, path, index: "index", headers: {})
+      @app = app
+      @file_handler = FileHandler.new(path, index: index, headers: headers)
+    end
+
+    def call(env)
+      req = Rack::Request.new env
+
+      if req.get? || req.head?
+        path = req.path_info.chomp("/")
+        if match = @file_handler.match?(path)
+          req.path_info = match
+          return @file_handler.serve(req)
+        end
+      end
+
+      @app.call(req.env)
+    end
+  end
+end