actionpack 4.2.10 → 7.2.0.rc1

data/lib/action_dispatch/middleware/flash.rb

@@ -1,53 +1,93 @@
-require 'active_support/core_ext/hash/keys'
+# frozen_string_literal: true
 
-module ActionDispatch
-  class Request < Rack::Request
-    # Access the contents of the flash. Use <tt>flash["notice"]</tt> to
-    # read a notice you put there or <tt>flash["notice"] = "hello"</tt>
-    # to put a new one.
-    def flash
-      @env[Flash::KEY] ||= Flash::FlashHash.from_session_value(session["flash"])
-    end
-  end
+# :markup: markdown
 
-  # The flash provides a way to pass temporary primitive-types (String, Array, Hash) between actions. Anything you place in the flash will be exposed
-  # to the very next action and then cleared out. This is a great way of doing notices and alerts, such as a create
-  # action that sets <tt>flash[:notice] = "Post successfully created"</tt> before redirecting to a display action that can
-  # then expose the flash to its template. Actually, that exposure is automatically done.
+require "active_support/core_ext/hash/keys"
+
+module ActionDispatch
+  # # Action Dispatch Flash
   #
-  #   class PostsController < ActionController::Base
-  #     def create
-  #       # save post
-  #       flash[:notice] = "Post successfully created"
-  #       redirect_to @post
-  #     end
+  # The flash provides a way to pass temporary primitive-types (String, Array,
+  # Hash) between actions. Anything you place in the flash will be exposed to the
+  # very next action and then cleared out. This is a great way of doing notices
+  # and alerts, such as a create action that sets `flash[:notice] = "Post
+  # successfully created"` before redirecting to a display action that can then
+  # expose the flash to its template. Actually, that exposure is automatically
+  # done.
+  #
+  #     class PostsController < ActionController::Base
+  #       def create
+  #         # save post
+  #         flash[:notice] = "Post successfully created"
+  #         redirect_to @post
+  #       end
   #
-  #     def show
-  #       # doesn't need to assign the flash notice to the template, that's done automatically
+  #       def show
+  #         # doesn't need to assign the flash notice to the template, that's done automatically
+  #       end
   #     end
-  #   end
   #
-  #   show.html.erb
+  # Then in `show.html.erb`:
+  #
   #     <% if flash[:notice] %>
   #       <div class="notice"><%= flash[:notice] %></div>
   #     <% end %>
   #
-  # Since the +notice+ and +alert+ keys are a common idiom, convenience accessors are available:
+  # Since the `notice` and `alert` keys are a common idiom, convenience accessors
+  # are available:
   #
-  #   flash.alert = "You must be logged in"
-  #   flash.notice = "Post successfully created"
+  #     flash.alert = "You must be logged in"
+  #     flash.notice = "Post successfully created"
   #
-  # This example places a string in the flash. And of course, you can put as many as you like at a time too. If you want to pass
-  # non-primitive types, you will have to handle that in your application. Example: To show messages with links, you will have to
-  # use sanitize helper.
+  # This example places a string in the flash. And of course, you can put as many
+  # as you like at a time too. If you want to pass non-primitive types, you will
+  # have to handle that in your application. Example: To show messages with links,
+  # you will have to use sanitize helper.
   #
   # Just remember: They'll be gone by the time the next action has been performed.
   #
   # See docs on the FlashHash class for more details about the flash.
   class Flash
-    KEY = 'action_dispatch.request.flash_hash'.freeze
+    KEY = "action_dispatch.request.flash_hash"
+
+    module RequestMethods
+      # Access the contents of the flash. Returns a ActionDispatch::Flash::FlashHash.
+      #
+      # See ActionDispatch::Flash for example usage.
+      def flash
+        flash = flash_hash
+        return flash if flash
+        self.flash = Flash::FlashHash.from_session_value(session["flash"])
+      end
+
+      def flash=(flash)
+        set_header Flash::KEY, flash
+      end
+
+      def flash_hash # :nodoc:
+        get_header Flash::KEY
+      end
 
-    class FlashNow #:nodoc:
+      def commit_flash # :nodoc:
+        return unless session.enabled?
+
+        if flash_hash && (flash_hash.present? || session.key?("flash"))
+          session["flash"] = flash_hash.to_session_value
+          self.flash = flash_hash.dup
+        end
+
+        if session.loaded? && session.key?("flash") && session["flash"].nil?
+          session.delete("flash")
+        end
+      end
+
+      def reset_session # :nodoc:
+        super
+        self.flash = nil
+      end
+    end
+
+    class FlashNow # :nodoc:
       attr_accessor :flash
 
       def initialize(flash)
@@ -65,12 +105,12 @@ module ActionDispatch
         @flash[k.to_s]
       end
 
-      # Convenience accessor for <tt>flash.now[:alert]=</tt>.
+      # Convenience accessor for `flash.now[:alert]=`.
       def alert=(message)
         self[:alert] = message
       end
 
-      # Convenience accessor for <tt>flash.now[:notice]=</tt>.
+      # Convenience accessor for `flash.now[:notice]=`.
       def notice=(message)
         self[:notice] = message
       end
@@ -79,28 +119,34 @@ module ActionDispatch
     class FlashHash
       include Enumerable
 
-      def self.from_session_value(value) #:nodoc:
-        flash = case value
-                when FlashHash # Rails 3.1, 3.2
-                  new(value.instance_variable_get(:@flashes), value.instance_variable_get(:@used))
-                when Hash # Rails 4.0
-                  new(value['flashes'], value['discard'])
-                else
-                  new
-                end
-
-        flash.tap(&:sweep)
+      def self.from_session_value(value) # :nodoc:
+        case value
+        when FlashHash # Rails 3.1, 3.2
+          flashes = value.instance_variable_get(:@flashes)
+          if discard = value.instance_variable_get(:@used)
+            flashes.except!(*discard)
+          end
+          new(flashes, flashes.keys)
+        when Hash # Rails 4.0
+          flashes = value["flashes"]
+          if discard = value["discard"]
+            flashes.except!(*discard)
+          end
+          new(flashes, flashes.keys)
+        else
+          new
+        end
       end
-      
-      # Builds a hash containing the discarded values and the hashes
-      # representing the flashes.
-      # If there are no values in @flashes, returns nil.
-      def to_session_value #:nodoc:
-        return nil if empty?
-        {'discard' => @discard.to_a, 'flashes' => @flashes}
+
+      # Builds a hash containing the flashes to keep for the next request. If there
+      # are none to keep, returns `nil`.
+      def to_session_value # :nodoc:
+        flashes_to_keep = @flashes.except(*@discard)
+        return nil if flashes_to_keep.empty?
+        { "discard" => [], "flashes" => flashes_to_keep }
       end
 
-      def initialize(flashes = {}, discard = []) #:nodoc:
+      def initialize(flashes = {}, discard = []) # :nodoc:
         @discard = Set.new(stringify_array(discard))
         @flashes = flashes.stringify_keys
         @now     = nil
@@ -124,7 +170,7 @@ module ActionDispatch
         @flashes[k.to_s]
       end
 
-      def update(h) #:nodoc:
+      def update(h) # :nodoc:
         @discard.subtract stringify_array(h.keys)
         @flashes.update h.stringify_keys
         self
@@ -138,6 +184,8 @@ module ActionDispatch
         @flashes.key? name.to_s
       end
 
+      # Immediately deletes the single flash entry. Use this method when you want
+      # remove the message within the current action. See also #discard.
       def delete(key)
         key = key.to_s
         @discard.delete key
@@ -164,48 +212,55 @@ module ActionDispatch
 
       alias :merge! :update
 
-      def replace(h) #:nodoc:
+      def replace(h) # :nodoc:
         @discard.clear
         @flashes.replace h.stringify_keys
         self
       end
 
-      # Sets a flash that will not be available to the next action, only to the current.
+      # Sets a flash that will not be available to the next action, only to the
+      # current.
       #
       #     flash.now[:message] = "Hello current action"
       #
-      # This method enables you to use the flash as a central messaging system in your app.
-      # When you need to pass an object to the next action, you use the standard flash assign (<tt>[]=</tt>).
-      # When you need to pass an object to the current action, you use <tt>now</tt>, and your object will
-      # vanish when the current action is done.
+      # This method enables you to use the flash as a central messaging system in your
+      # app. When you need to pass an object to the next action, you use the standard
+      # flash assign (`[]=`). When you need to pass an object to the current action,
+      # you use `now`, and your object will vanish when the current action is done.
       #
-      # Entries set via <tt>now</tt> are accessed the same way as standard entries: <tt>flash['my-key']</tt>.
+      # Entries set via `now` are accessed the same way as standard entries:
+      # `flash['my-key']`.
       #
       # Also, brings two convenience accessors:
       #
-      #   flash.now.alert = "Beware now!"
-      #   # Equivalent to flash.now[:alert] = "Beware now!"
+      #     flash.now.alert = "Beware now!"
+      #     # Equivalent to flash.now[:alert] = "Beware now!"
       #
-      #   flash.now.notice = "Good luck now!"
-      #   # Equivalent to flash.now[:notice] = "Good luck now!"
+      #     flash.now.notice = "Good luck now!"
+      #     # Equivalent to flash.now[:notice] = "Good luck now!"
       def now
         @now ||= FlashNow.new(self)
       end
 
-      # Keeps either the entire current flash or a specific flash entry available for the next action:
+      # Keeps either the entire current flash or a specific flash entry available for
+      # the next action:
       #
-      #    flash.keep            # keeps the entire flash
-      #    flash.keep(:notice)   # keeps only the "notice" entry, the rest of the flash is discarded
+      #     flash.keep            # keeps the entire flash
+      #     flash.keep(:notice)   # keeps only the "notice" entry, the rest of the flash is discarded
       def keep(k = nil)
         k = k.to_s if k
         @discard.subtract Array(k || keys)
         k ? self[k] : self
       end
 
-      # Marks the entire flash or a single flash entry to be discarded by the end of the current action:
+      # Marks the entire flash or a single flash entry to be discarded by the end of
+      # the current action:
       #
       #     flash.discard              # discard the entire flash at the end of the current action
       #     flash.discard(:warning)    # discard only the "warning" entry at the end of the current action
+      #
+      # Use this method when you want to display the message in the current action but
+      # not in the next one. See also #delete.
       def discard(k = nil)
         k = k.to_s if k
         @discard.merge Array(k || keys)
@@ -214,63 +269,50 @@ module ActionDispatch
 
       # Mark for removal entries that were kept, and delete unkept ones.
       #
-      # This method is called automatically by filters, so you generally don't need to care about it.
-      def sweep #:nodoc:
+      # This method is called automatically by filters, so you generally don't need to
+      # care about it.
+      def sweep # :nodoc:
         @discard.each { |k| @flashes.delete k }
         @discard.replace @flashes.keys
       end
 
-      # Convenience accessor for <tt>flash[:alert]</tt>.
+      # Convenience accessor for `flash[:alert]`.
       def alert
         self[:alert]
       end
 
-      # Convenience accessor for <tt>flash[:alert]=</tt>.
+      # Convenience accessor for `flash[:alert]=`.
       def alert=(message)
         self[:alert] = message
       end
 
-      # Convenience accessor for <tt>flash[:notice]</tt>.
+      # Convenience accessor for `flash[:notice]`.
       def notice
         self[:notice]
       end
 
-      # Convenience accessor for <tt>flash[:notice]=</tt>.
+      # Convenience accessor for `flash[:notice]=`.
       def notice=(message)
         self[:notice] = message
       end
 
       protected
-      def now_is_loaded?
-        @now
-      end
-
-      def stringify_array(array)
-        array.map do |item|
-          item.kind_of?(Symbol) ? item.to_s : item
+        def now_is_loaded?
+          @now
         end
-      end
-    end
 
-    def initialize(app)
-      @app = app
+      private
+        def stringify_array(array) # :doc:
+          array.map do |item|
+            item.kind_of?(Symbol) ? item.to_s : item
+          end
+        end
     end
 
-    def call(env)
-      @app.call(env)
-    ensure
-      session    = Request::Session.find(env) || {}
-      flash_hash = env[KEY]
-
-      if flash_hash && (flash_hash.present? || session.key?('flash'))
-        session["flash"] = flash_hash.to_session_value
-        env[KEY] = flash_hash.dup
-      end
+    def self.new(app) app; end
+  end
 
-      if (!session.respond_to?(:loaded?) || session.loaded?) && # (reset_session uses {}, which doesn't implement #loaded?)
-        session.key?('flash') && session['flash'].nil?
-        session.delete('flash')
-      end
-    end
+  class Request
+    prepend Flash::RequestMethods
   end
 end

data/lib/action_dispatch/middleware/host_authorization.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  # # Action Dispatch HostAuthorization
+  #
+  # This middleware guards from DNS rebinding attacks by explicitly permitting the
+  # hosts a request can be sent to, and is passed the options set in
+  # `config.host_authorization`.
+  #
+  # Requests can opt-out of Host Authorization with `exclude`:
+  #
+  #     config.host_authorization = { exclude: ->(request) { request.path =~ /healthcheck/ } }
+  #
+  # When a request comes to an unauthorized host, the `response_app` application
+  # will be executed and rendered. If no `response_app` is given, a default one
+  # will run. The default response app logs blocked host info with level 'error'
+  # and responds with `403 Forbidden`. The body of the response contains debug
+  # info if `config.consider_all_requests_local` is set to true, otherwise the
+  # body is empty.
+  class HostAuthorization
+    ALLOWED_HOSTS_IN_DEVELOPMENT = [".localhost", ".test", IPAddr.new("0.0.0.0/0"), IPAddr.new("::/0")]
+    PORT_REGEX = /(?::\d+)/ # :nodoc:
+    SUBDOMAIN_REGEX = /(?:[a-z0-9-]+\.)/i # :nodoc:
+    IPV4_HOSTNAME = /(?<host>\d+\.\d+\.\d+\.\d+)#{PORT_REGEX}?/ # :nodoc:
+    IPV6_HOSTNAME = /(?<host>[a-f0-9]*:[a-f0-9.:]+)/i # :nodoc:
+    IPV6_HOSTNAME_WITH_PORT = /\[#{IPV6_HOSTNAME}\]#{PORT_REGEX}/i # :nodoc:
+    VALID_IP_HOSTNAME = Regexp.union( # :nodoc:
+      /\A#{IPV4_HOSTNAME}\z/,
+      /\A#{IPV6_HOSTNAME}\z/,
+      /\A#{IPV6_HOSTNAME_WITH_PORT}\z/,
+    )
+
+    class Permissions # :nodoc:
+      def initialize(hosts)
+        @hosts = sanitize_hosts(hosts)
+      end
+
+      def empty?
+        @hosts.empty?
+      end
+
+      def allows?(host)
+        @hosts.any? do |allowed|
+          if allowed.is_a?(IPAddr)
+            begin
+              allowed === extract_hostname(host)
+            rescue
+              # IPAddr#=== raises an error if you give it a hostname instead of IP. Treat
+              # similar errors as blocked access.
+              false
+            end
+          else
+            allowed === host
+          end
+        end
+      end
+
+      private
+        def sanitize_hosts(hosts)
+          Array(hosts).map do |host|
+            case host
+            when Regexp then sanitize_regexp(host)
+            when String then sanitize_string(host)
+            else host
+            end
+          end
+        end
+
+        def sanitize_regexp(host)
+          /\A#{host}#{PORT_REGEX}?\z/
+        end
+
+        def sanitize_string(host)
+          if host.start_with?(".")
+            /\A#{SUBDOMAIN_REGEX}?#{Regexp.escape(host[1..-1])}#{PORT_REGEX}?\z/i
+          else
+            /\A#{Regexp.escape host}#{PORT_REGEX}?\z/i
+          end
+        end
+
+        def extract_hostname(host)
+          host.slice(VALID_IP_HOSTNAME, "host") || host
+        end
+    end
+
+    class DefaultResponseApp # :nodoc:
+      RESPONSE_STATUS = 403
+
+      def call(env)
+        request = Request.new(env)
+        format = request.xhr? ? "text/plain" : "text/html"
+
+        log_error(request)
+        response(format, response_body(request))
+      end
+
+      private
+        def response_body(request)
+          return "" unless request.get_header("action_dispatch.show_detailed_exceptions")
+
+          template = DebugView.new(hosts: request.env["action_dispatch.blocked_hosts"])
+          template.render(template: "rescues/blocked_host", layout: "rescues/layout")
+        end
+
+        def response(format, body)
+          [RESPONSE_STATUS,
+           { Rack::CONTENT_TYPE => "#{format}; charset=#{Response.default_charset}",
+             Rack::CONTENT_LENGTH => body.bytesize.to_s },
+           [body]]
+        end
+
+        def log_error(request)
+          logger = available_logger(request)
+
+          return unless logger
+
+          logger.error("[#{self.class.name}] Blocked hosts: #{request.env["action_dispatch.blocked_hosts"].join(", ")}")
+        end
+
+        def available_logger(request)
+          request.logger || ActionView::Base.logger
+        end
+    end
+
+    def initialize(app, hosts, exclude: nil, response_app: nil)
+      @app = app
+      @permissions = Permissions.new(hosts)
+      @exclude = exclude
+
+      @response_app = response_app || DefaultResponseApp.new
+    end
+
+    def call(env)
+      return @app.call(env) if @permissions.empty?
+
+      request = Request.new(env)
+      hosts = blocked_hosts(request)
+
+      if hosts.empty? || excluded?(request)
+        mark_as_authorized(request)
+        @app.call(env)
+      else
+        env["action_dispatch.blocked_hosts"] = hosts
+        @response_app.call(env)
+      end
+    end
+
+    private
+      def blocked_hosts(request)
+        hosts = []
+
+        origin_host = request.get_header("HTTP_HOST")
+        hosts << origin_host unless @permissions.allows?(origin_host)
+
+        forwarded_host = request.x_forwarded_host&.split(/,\s?/)&.last
+        hosts << forwarded_host unless forwarded_host.blank? || @permissions.allows?(forwarded_host)
+
+        hosts
+      end
+
+      def excluded?(request)
+        @exclude && @exclude.call(request)
+      end
+
+      def mark_as_authorized(request)
+        request.set_header("action_dispatch.authorized_host", request.host)
+      end
+  end
+end

data/lib/action_dispatch/middleware/public_exceptions.rb

@@ -1,11 +1,17 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionDispatch
+  # # Action Dispatch PublicExceptions
+  #
   # When called, this middleware renders an error page. By default if an HTML
   # response is expected it will render static error pages from the `/public`
   # directory. For example when this middleware receives a 500 response it will
-  # render the template found in `/public/500.html`.
-  # If an internationalized locale is set, this middleware will attempt to render
-  # the template in `/public/500.<locale>.html`. If an internationalized template
-  # is not found it will fall back on `/public/500.html`.
+  # render the template found in `/public/500.html`. If an internationalized
+  # locale is set, this middleware will attempt to render the template in
+  # `/public/500.<locale>.html`. If an internationalized template is not found it
+  # will fall back on `/public/500.html`.
   #
   # When a request with a content type other than HTML is made, this middleware
   # will attempt to convert error information into the appropriate response type.
@@ -17,39 +23,42 @@ module ActionDispatch
     end
 
     def call(env)
-      status       = env["PATH_INFO"][1..-1]
       request      = ActionDispatch::Request.new(env)
-      content_type = request.formats.first
-      body         = { :status => status, :error => Rack::Utils::HTTP_STATUS_CODES.fetch(status.to_i, Rack::Utils::HTTP_STATUS_CODES[500]) }
+      status       = request.path_info[1..-1].to_i
+      begin
+        content_type = request.formats.first
+      rescue ActionDispatch::Http::MimeNegotiation::InvalidType
+        content_type = Mime[:text]
+      end
+      body = { status: status, error: Rack::Utils::HTTP_STATUS_CODES.fetch(status, Rack::Utils::HTTP_STATUS_CODES[500]) }
 
       render(status, content_type, body)
     end
 
     private
-
-    def render(status, content_type, body)
-      format = "to_#{content_type.to_sym}" if content_type
-      if format && body.respond_to?(format)
-        render_format(status, content_type, body.public_send(format))
-      else
-        render_html(status)
+      def render(status, content_type, body)
+        format = "to_#{content_type.to_sym}" if content_type
+        if format && body.respond_to?(format)
+          render_format(status, content_type, body.public_send(format))
+        else
+          render_html(status)
+        end
       end
-    end
 
-    def render_format(status, content_type, body)
-      [status, {'Content-Type' => "#{content_type}; charset=#{ActionDispatch::Response.default_charset}",
-                'Content-Length' => body.bytesize.to_s}, [body]]
-    end
+      def render_format(status, content_type, body)
+        [status, { Rack::CONTENT_TYPE => "#{content_type}; charset=#{ActionDispatch::Response.default_charset}",
+                  Rack::CONTENT_LENGTH => body.bytesize.to_s }, [body]]
+      end
 
-    def render_html(status)
-      path = "#{public_path}/#{status}.#{I18n.locale}.html"
-      path = "#{public_path}/#{status}.html" unless (found = File.exist?(path))
+      def render_html(status)
+        path = "#{public_path}/#{status}.#{I18n.locale}.html"
+        path = "#{public_path}/#{status}.html" unless (found = File.exist?(path))
 
-      if found || File.exist?(path)
-        render_format(status, 'text/html', File.read(path))
-      else
-        [404, { "X-Cascade" => "pass" }, []]
+        if found || File.exist?(path)
+          render_format(status, "text/html", File.read(path))
+        else
+          [404, { Constants::X_CASCADE => "pass" }, []]
+        end
       end
-    end
   end
 end