actionpack 4.2.10 → 7.2.0.rc1

data/lib/action_dispatch/middleware/cookies.rb

@@ -1,99 +1,211 @@
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/core_ext/object/blank'
-require 'active_support/key_generator'
-require 'active_support/message_verifier'
-require 'active_support/json'
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/hash/keys"
+require "active_support/key_generator"
+require "active_support/message_verifier"
+require "active_support/json"
+require "rack/utils"
 
 module ActionDispatch
-  class Request < Rack::Request
+  module RequestCookieMethods
     def cookie_jar
-      env['action_dispatch.cookies'] ||= Cookies::CookieJar.build(self)
+      fetch_header("action_dispatch.cookies") do
+        self.cookie_jar = Cookies::CookieJar.build(self, cookies)
+      end
+    end
+
+    # :stopdoc:
+    prepend Module.new {
+      def commit_cookie_jar!
+        cookie_jar.commit!
+      end
+    }
+
+    def have_cookie_jar?
+      has_header? "action_dispatch.cookies"
+    end
+
+    def cookie_jar=(jar)
+      set_header "action_dispatch.cookies", jar
+    end
+
+    def key_generator
+      get_header Cookies::GENERATOR_KEY
     end
+
+    def signed_cookie_salt
+      get_header Cookies::SIGNED_COOKIE_SALT
+    end
+
+    def encrypted_cookie_salt
+      get_header Cookies::ENCRYPTED_COOKIE_SALT
+    end
+
+    def encrypted_signed_cookie_salt
+      get_header Cookies::ENCRYPTED_SIGNED_COOKIE_SALT
+    end
+
+    def authenticated_encrypted_cookie_salt
+      get_header Cookies::AUTHENTICATED_ENCRYPTED_COOKIE_SALT
+    end
+
+    def use_authenticated_cookie_encryption
+      get_header Cookies::USE_AUTHENTICATED_COOKIE_ENCRYPTION
+    end
+
+    def encrypted_cookie_cipher
+      get_header Cookies::ENCRYPTED_COOKIE_CIPHER
+    end
+
+    def signed_cookie_digest
+      get_header Cookies::SIGNED_COOKIE_DIGEST
+    end
+
+    def secret_key_base
+      get_header Cookies::SECRET_KEY_BASE
+    end
+
+    def cookies_serializer
+      get_header Cookies::COOKIES_SERIALIZER
+    end
+
+    def cookies_same_site_protection
+      get_header(Cookies::COOKIES_SAME_SITE_PROTECTION)&.call(self)
+    end
+
+    def cookies_digest
+      get_header Cookies::COOKIES_DIGEST
+    end
+
+    def cookies_rotations
+      get_header Cookies::COOKIES_ROTATIONS
+    end
+
+    def use_cookies_with_metadata
+      get_header Cookies::USE_COOKIES_WITH_METADATA
+    end
+
+    # :startdoc:
   end
 
-  # \Cookies are read and written through ActionController#cookies.
+  ActiveSupport.on_load(:action_dispatch_request) do
+    include RequestCookieMethods
+  end
+
+  # Read and write data to cookies through ActionController::Cookies#cookies.
   #
-  # The cookies being read are the ones received along with the request, the cookies
-  # being written will be sent out with the response. Reading a cookie does not get
-  # the cookie object itself back, just the value it holds.
+  # When reading cookie data, the data is read from the HTTP request header,
+  # Cookie. When writing cookie data, the data is sent out in the HTTP response
+  # header, `Set-Cookie`.
   #
   # Examples of writing:
   #
-  #   # Sets a simple session cookie.
-  #   # This cookie will be deleted when the user's browser is closed.
-  #   cookies[:user_name] = "david"
+  #     # Sets a simple session cookie.
+  #     # This cookie will be deleted when the user's browser is closed.
+  #     cookies[:user_name] = "david"
+  #
+  #     # Cookie values are String-based. Other data types need to be serialized.
+  #     cookies[:lat_lon] = JSON.generate([47.68, -122.37])
   #
-  #   # Cookie values are String based. Other data types need to be serialized.
-  #   cookies[:lat_lon] = JSON.generate([47.68, -122.37])
+  #     # Sets a cookie that expires in 1 hour.
+  #     cookies[:login] = { value: "XJ-122", expires: 1.hour }
   #
-  #   # Sets a cookie that expires in 1 hour.
-  #   cookies[:login] = { value: "XJ-122", expires: 1.hour.from_now }
+  #     # Sets a cookie that expires at a specific time.
+  #     cookies[:login] = { value: "XJ-122", expires: Time.utc(2020, 10, 15, 5) }
   #
-  #   # Sets a signed cookie, which prevents users from tampering with its value.
-  #   # The cookie is signed by your app's `secrets.secret_key_base` value.
-  #   # It can be read using the signed method `cookies.signed[:name]`
-  #   cookies.signed[:user_id] = current_user.id
+  #     # Sets a signed cookie, which prevents users from tampering with its value.
+  #     # It can be read using the signed method `cookies.signed[:name]`
+  #     cookies.signed[:user_id] = current_user.id
   #
-  #   # Sets a "permanent" cookie (which expires in 20 years from now).
-  #   cookies.permanent[:login] = "XJ-122"
+  #     # Sets an encrypted cookie value before sending it to the client which
+  #     # prevent users from reading and tampering with its value.
+  #     # It can be read using the encrypted method `cookies.encrypted[:name]`
+  #     cookies.encrypted[:discount] = 45
   #
-  #   # You can also chain these methods:
-  #   cookies.permanent.signed[:login] = "XJ-122"
+  #     # Sets a "permanent" cookie (which expires in 20 years from now).
+  #     cookies.permanent[:login] = "XJ-122"
+  #
+  #     # You can also chain these methods:
+  #     cookies.signed.permanent[:login] = "XJ-122"
   #
   # Examples of reading:
   #
-  #   cookies[:user_name]           # => "david"
-  #   cookies.size                  # => 2
-  #   JSON.parse(cookies[:lat_lon]) # => [47.68, -122.37]
-  #   cookies.signed[:login]        # => "XJ-122"
+  #     cookies[:user_name]           # => "david"
+  #     cookies.size                  # => 2
+  #     JSON.parse(cookies[:lat_lon]) # => [47.68, -122.37]
+  #     cookies.signed[:login]        # => "XJ-122"
+  #     cookies.encrypted[:discount]  # => 45
   #
   # Example for deleting:
   #
-  #   cookies.delete :user_name
+  #     cookies.delete :user_name
   #
-  # Please note that if you specify a :domain when setting a cookie, you must also specify the domain when deleting the cookie:
+  # Please note that if you specify a `:domain` when setting a cookie, you must
+  # also specify the domain when deleting the cookie:
   #
-  #  cookies[:name] = {
-  #    value: 'a yummy cookie',
-  #    expires: 1.year.from_now,
-  #    domain: 'domain.com'
-  #  }
+  #     cookies[:name] = {
+  #       value: 'a yummy cookie',
+  #       expires: 1.year,
+  #       domain: 'domain.com'
+  #     }
   #
-  #  cookies.delete(:name, domain: 'domain.com')
+  #     cookies.delete(:name, domain: 'domain.com')
   #
   # The option symbols for setting cookies are:
   #
-  # * <tt>:value</tt> - The cookie's value.
-  # * <tt>:path</tt> - The path for which this cookie applies. Defaults to the root
-  #   of the application.
-  # * <tt>:domain</tt> - The domain for which this cookie applies so you can
-  #   restrict to the domain level. If you use a schema like www.example.com
-  #   and want to share session with user.example.com set <tt>:domain</tt>
-  #   to <tt>:all</tt>. Make sure to specify the <tt>:domain</tt> option with
-  #   <tt>:all</tt> or <tt>Array</tt> again when deleting cookies.
+  # *   `:value` - The cookie's value.
+  # *   `:path` - The path for which this cookie applies. Defaults to the root of
+  #     the application.
+  # *   `:domain` - The domain for which this cookie applies so you can restrict
+  #     to the domain level. If you use a schema like www.example.com and want to
+  #     share session with user.example.com set `:domain` to `:all`. To support
+  #     multiple domains, provide an array, and the first domain matching
+  #     `request.host` will be used. Make sure to specify the `:domain` option
+  #     with `:all` or `Array` again when deleting cookies. For more flexibility
+  #     you can set the domain on a per-request basis by specifying `:domain` with
+  #     a proc.
+  #
+  #         domain: nil  # Does not set cookie domain. (default)
+  #         domain: :all # Allow the cookie for the top most level
+  #                      # domain and subdomains.
+  #         domain: %w(.example.com .example.org) # Allow the cookie
+  #                                               # for concrete domain names.
+  #         domain: proc { Tenant.current.cookie_domain } # Set cookie domain dynamically
+  #         domain: proc { |req| ".sub.#{req.host}" }     # Set cookie domain dynamically based on request
   #
-  #     domain: nil  # Does not sets cookie domain. (default)
-  #     domain: :all # Allow the cookie for the top most level
-  #                  # domain and subdomains.
-  #     domain: %w(.example.com .example.org) # Allow the cookie
-  #                                           # for concrete domain names.
+  # *   `:tld_length` - When using `:domain => :all`, this option can be used to
+  #     explicitly set the TLD length when using a short (<= 3 character) domain
+  #     that is being interpreted as part of a TLD. For example, to share cookies
+  #     between user1.lvh.me and user2.lvh.me, set `:tld_length` to 2.
+  # *   `:expires` - The time at which this cookie expires, as a Time or
+  #     ActiveSupport::Duration object.
+  # *   `:secure` - Whether this cookie is only transmitted to HTTPS servers.
+  #     Default is `false`.
+  # *   `:httponly` - Whether this cookie is accessible via scripting or only
+  #     HTTP. Defaults to `false`.
+  # *   `:same_site` - The value of the `SameSite` cookie attribute, which
+  #     determines how this cookie should be restricted in cross-site contexts.
+  #     Possible values are `nil`, `:none`, `:lax`, and `:strict`. Defaults to
+  #     `:lax`.
   #
-  # * <tt>:expires</tt> - The time at which this cookie expires, as a \Time object.
-  # * <tt>:secure</tt> - Whether this cookie is only transmitted to HTTPS servers.
-  #   Default is +false+.
-  # * <tt>:httponly</tt> - Whether this cookie is accessible via scripting or
-  #   only HTTP. Defaults to +false+.
   class Cookies
-    HTTP_HEADER   = "Set-Cookie".freeze
-    GENERATOR_KEY = "action_dispatch.key_generator".freeze
-    SIGNED_COOKIE_SALT = "action_dispatch.signed_cookie_salt".freeze
-    ENCRYPTED_COOKIE_SALT = "action_dispatch.encrypted_cookie_salt".freeze
-    ENCRYPTED_SIGNED_COOKIE_SALT = "action_dispatch.encrypted_signed_cookie_salt".freeze
-    SECRET_TOKEN = "action_dispatch.secret_token".freeze
-    SECRET_KEY_BASE = "action_dispatch.secret_key_base".freeze
-    COOKIES_SERIALIZER = "action_dispatch.cookies_serializer".freeze
-    COOKIES_DIGEST = "action_dispatch.cookies_digest".freeze
+    HTTP_HEADER   = "Set-Cookie"
+    GENERATOR_KEY = "action_dispatch.key_generator"
+    SIGNED_COOKIE_SALT = "action_dispatch.signed_cookie_salt"
+    ENCRYPTED_COOKIE_SALT = "action_dispatch.encrypted_cookie_salt"
+    ENCRYPTED_SIGNED_COOKIE_SALT = "action_dispatch.encrypted_signed_cookie_salt"
+    AUTHENTICATED_ENCRYPTED_COOKIE_SALT = "action_dispatch.authenticated_encrypted_cookie_salt"
+    USE_AUTHENTICATED_COOKIE_ENCRYPTION = "action_dispatch.use_authenticated_cookie_encryption"
+    ENCRYPTED_COOKIE_CIPHER = "action_dispatch.encrypted_cookie_cipher"
+    SIGNED_COOKIE_DIGEST = "action_dispatch.signed_cookie_digest"
+    SECRET_KEY_BASE = "action_dispatch.secret_key_base"
+    COOKIES_SERIALIZER = "action_dispatch.cookies_serializer"
+    COOKIES_DIGEST = "action_dispatch.cookies_digest"
+    COOKIES_ROTATIONS = "action_dispatch.cookies_rotations"
+    COOKIES_SAME_SITE_PROTECTION = "action_dispatch.cookies_same_site_protection"
+    USE_COOKIES_WITH_METADATA = "action_dispatch.use_cookies_with_metadata"
 
     # Cookies can typically store 4096 bytes.
     MAX_COOKIE_SIZE = 4096
@@ -101,150 +213,116 @@ module ActionDispatch
     # Raised when storing more than 4K of session data.
     CookieOverflow = Class.new StandardError
 
-    # Include in a cookie jar to allow chaining, e.g. cookies.permanent.signed
+    # Include in a cookie jar to allow chaining, e.g. `cookies.permanent.signed`.
     module ChainedCookieJars
-      # Returns a jar that'll automatically set the assigned cookies to have an expiration date 20 years from now. Example:
+      # Returns a jar that'll automatically set the assigned cookies to have an
+      # expiration date 20 years from now. Example:
       #
-      #   cookies.permanent[:prefers_open_id] = true
-      #   # => Set-Cookie: prefers_open_id=true; path=/; expires=Sun, 16-Dec-2029 03:24:16 GMT
+      #     cookies.permanent[:prefers_open_id] = true
+      #     # => Set-Cookie: prefers_open_id=true; path=/; expires=Sun, 16-Dec-2029 03:24:16 GMT
       #
-      # This jar is only meant for writing. You'll read permanent cookies through the regular accessor.
+      # This jar is only meant for writing. You'll read permanent cookies through the
+      # regular accessor.
       #
-      # This jar allows chaining with the signed jar as well, so you can set permanent, signed cookies. Examples:
+      # This jar allows chaining with the signed jar as well, so you can set
+      # permanent, signed cookies. Examples:
       #
-      #   cookies.permanent.signed[:remember_me] = current_user.id
-      #   # => Set-Cookie: remember_me=BAhU--848956038e692d7046deab32b7131856ab20e14e; path=/; expires=Sun, 16-Dec-2029 03:24:16 GMT
+      #     cookies.permanent.signed[:remember_me] = current_user.id
+      #     # => Set-Cookie: remember_me=BAhU--848956038e692d7046deab32b7131856ab20e14e; path=/; expires=Sun, 16-Dec-2029 03:24:16 GMT
       def permanent
-        @permanent ||= PermanentCookieJar.new(self, @key_generator, @options)
+        @permanent ||= PermanentCookieJar.new(self)
       end
 
-      # Returns a jar that'll automatically generate a signed representation of cookie value and verify it when reading from
-      # the cookie again. This is useful for creating cookies with values that the user is not supposed to change. If a signed
-      # cookie was tampered with by the user (or a 3rd party), nil will be returned.
+      # Returns a jar that'll automatically generate a signed representation of cookie
+      # value and verify it when reading from the cookie again. This is useful for
+      # creating cookies with values that the user is not supposed to change. If a
+      # signed cookie was tampered with by the user (or a 3rd party), `nil` will be
+      # returned.
       #
-      # If +secrets.secret_key_base+ and +secrets.secret_token+ (deprecated) are both set,
-      # legacy cookies signed with the old key generator will be transparently upgraded.
-      #
-      # This jar requires that you set a suitable secret for the verification on your app's +secrets.secret_key_base+.
+      # This jar requires that you set a suitable secret for the verification on your
+      # app's `secret_key_base`.
       #
       # Example:
       #
-      #   cookies.signed[:discount] = 45
-      #   # => Set-Cookie: discount=BAhpMg==--2c1c6906c90a3bc4fd54a51ffb41dffa4bf6b5f7; path=/
+      #     cookies.signed[:discount] = 45
+      #     # => Set-Cookie: discount=BAhpMg==--2c1c6906c90a3bc4fd54a51ffb41dffa4bf6b5f7; path=/
       #
-      #   cookies.signed[:discount] # => 45
+      #     cookies.signed[:discount] # => 45
       def signed
-        @signed ||=
-          if @options[:upgrade_legacy_signed_cookies]
-            UpgradeLegacySignedCookieJar.new(self, @key_generator, @options)
-          else
-            SignedCookieJar.new(self, @key_generator, @options)
-          end
+        @signed ||= SignedKeyRotatingCookieJar.new(self)
       end
 
-      # Returns a jar that'll automatically encrypt cookie values before sending them to the client and will decrypt them for read.
-      # If the cookie was tampered with by the user (or a 3rd party), nil will be returned.
+      # Returns a jar that'll automatically encrypt cookie values before sending them
+      # to the client and will decrypt them for read. If the cookie was tampered with
+      # by the user (or a 3rd party), `nil` will be returned.
       #
-      # If +secrets.secret_key_base+ and +secrets.secret_token+ (deprecated) are both set,
-      # legacy cookies signed with the old key generator will be transparently upgraded.
+      # If `config.action_dispatch.encrypted_cookie_salt` and
+      # `config.action_dispatch.encrypted_signed_cookie_salt` are both set, legacy
+      # cookies encrypted with HMAC AES-256-CBC will be transparently upgraded.
       #
-      # This jar requires that you set a suitable secret for the verification on your app's +secrets.secret_key_base+.
+      # This jar requires that you set a suitable secret for the verification on your
+      # app's `secret_key_base`.
       #
       # Example:
       #
-      #   cookies.encrypted[:discount] = 45
-      #   # => Set-Cookie: discount=ZS9ZZ1R4cG1pcUJ1bm80anhQang3dz09LS1mbDZDSU5scGdOT3ltQ2dTdlhSdWpRPT0%3D--ab54663c9f4e3bc340c790d6d2b71e92f5b60315; path=/
+      #     cookies.encrypted[:discount] = 45
+      #     # => Set-Cookie: discount=DIQ7fw==--K3n//8vvnSbGq9dA--7Xh91HfLpwzbj1czhBiwOg==; path=/
       #
-      #   cookies.encrypted[:discount] # => 45
+      #     cookies.encrypted[:discount] # => 45
       def encrypted
-        @encrypted ||=
-          if @options[:upgrade_legacy_signed_cookies]
-            UpgradeLegacyEncryptedCookieJar.new(self, @key_generator, @options)
-          else
-            EncryptedCookieJar.new(self, @key_generator, @options)
-          end
+        @encrypted ||= EncryptedKeyRotatingCookieJar.new(self)
       end
 
-      # Returns the +signed+ or +encrypted+ jar, preferring +encrypted+ if +secret_key_base+ is set.
-      # Used by ActionDispatch::Session::CookieStore to avoid the need to introduce new cookie stores.
+      # Returns the `signed` or `encrypted` jar, preferring `encrypted` if
+      # `secret_key_base` is set. Used by ActionDispatch::Session::CookieStore to
+      # avoid the need to introduce new cookie stores.
       def signed_or_encrypted
         @signed_or_encrypted ||=
-          if @options[:secret_key_base].present?
+          if request.secret_key_base.present?
             encrypted
           else
             signed
           end
       end
-    end
 
-    # Passing the ActiveSupport::MessageEncryptor::NullSerializer downstream
-    # to the Message{Encryptor,Verifier} allows us to handle the
-    # (de)serialization step within the cookie jar, which gives us the
-    # opportunity to detect and migrate legacy cookies.
-    module VerifyAndUpgradeLegacySignedMessage # :nodoc:
-      def initialize(*args)
-        super
-        @legacy_verifier = ActiveSupport::MessageVerifier.new(@options[:secret_token], serializer: ActiveSupport::MessageEncryptor::NullSerializer)
-      end
+      private
+        def upgrade_legacy_hmac_aes_cbc_cookies?
+          request.secret_key_base.present? &&
+            request.encrypted_signed_cookie_salt.present? &&
+            request.encrypted_cookie_salt.present? &&
+            request.use_authenticated_cookie_encryption
+        end
 
-      def verify_and_upgrade_legacy_signed_message(name, signed_message)
-        deserialize(name, @legacy_verifier.verify(signed_message)).tap do |value|
-          self[name] = { value: value }
+        def prepare_upgrade_legacy_hmac_aes_cbc_cookies?
+          request.secret_key_base.present? &&
+            request.authenticated_encrypted_cookie_salt.present? &&
+            !request.use_authenticated_cookie_encryption
+        end
+
+        def encrypted_cookie_cipher
+          request.encrypted_cookie_cipher || "aes-256-gcm"
+        end
+
+        def signed_cookie_digest
+          request.signed_cookie_digest || "SHA1"
         end
-      rescue ActiveSupport::MessageVerifier::InvalidSignature
-        nil
-      end
     end
 
-    class CookieJar #:nodoc:
+    class CookieJar # :nodoc:
       include Enumerable, ChainedCookieJars
 
-      # This regular expression is used to split the levels of a domain.
-      # The top level domain can be any string without a period or
-      # **.**, ***.** style TLDs like co.uk or com.au
-      #
-      # www.example.co.uk gives:
-      # $& => example.co.uk
-      #
-      # example.com gives:
-      # $& => example.com
-      #
-      # lots.of.subdomains.example.local gives:
-      # $& => example.local
-      DOMAIN_REGEXP = /[^.]*\.([^.]*|..\...|...\...)$/
-
-      def self.options_for_env(env) #:nodoc:
-        { signed_cookie_salt: env[SIGNED_COOKIE_SALT] || '',
-          encrypted_cookie_salt: env[ENCRYPTED_COOKIE_SALT] || '',
-          encrypted_signed_cookie_salt: env[ENCRYPTED_SIGNED_COOKIE_SALT] || '',
-          secret_token: env[SECRET_TOKEN],
-          secret_key_base: env[SECRET_KEY_BASE],
-          upgrade_legacy_signed_cookies: env[SECRET_TOKEN].present? && env[SECRET_KEY_BASE].present?,
-          serializer: env[COOKIES_SERIALIZER],
-          digest: env[COOKIES_DIGEST]
-        }
+      def self.build(req, cookies)
+        jar = new(req)
+        jar.update(cookies)
+        jar
       end
 
-      def self.build(request)
-        env = request.env
-        key_generator = env[GENERATOR_KEY]
-        options = options_for_env env
-
-        host = request.host
-        secure = request.ssl?
-
-        new(key_generator, host, secure, options).tap do |hash|
-          hash.update(request.cookies)
-        end
-      end
+      attr_reader :request
 
-      def initialize(key_generator, host = nil, secure = false, options = {})
-        @key_generator = key_generator
+      def initialize(request)
         @set_cookies = {}
         @delete_cookies = {}
-        @host = host
-        @secure = secure
-        @options = options
+        @request = request
         @cookies = {}
         @committed = false
       end
@@ -261,7 +339,7 @@ module ActionDispatch
         @cookies.each(&block)
       end
 
-      # Returns the value of the cookie by +name+, or +nil+ if no such cookie exists.
+      # Returns the value of the cookie by `name`, or `nil` if no such cookie exists.
       def [](name)
         @cookies[name.to_s]
       end
@@ -275,38 +353,34 @@ module ActionDispatch
       end
       alias :has_key? :key?
 
+      # Returns the cookies as Hash.
+      alias :to_hash :to_h
+
       def update(other_hash)
         @cookies.update other_hash.stringify_keys
         self
       end
 
-      def handle_options(options) #:nodoc:
-        options[:path] ||= "/"
+      def update_cookies_from_jar
+        request_jar = @request.cookie_jar.instance_variable_get(:@cookies)
+        set_cookies = request_jar.reject { |k, _| @delete_cookies.key?(k) || @set_cookies.key?(k) }
 
-        if options[:domain] == :all
-          # if there is a provided tld length then we use it otherwise default domain regexp
-          domain_regexp = options[:tld_length] ? /([^.]+\.?){#{options[:tld_length]}}$/ : DOMAIN_REGEXP
+        @cookies.update set_cookies if set_cookies
+      end
 
-          # if host is not ip and matches domain regexp
-          # (ip confirms to domain regexp so we explicitly check for ip)
-          options[:domain] = if (@host !~ /^[\d.]+$/) && (@host =~ domain_regexp)
-            ".#{$&}"
-          end
-        elsif options[:domain].is_a? Array
-          # if host matches one of the supplied domains without a dot in front of it
-          options[:domain] = options[:domain].find {|domain| @host.include? domain.sub(/^\./, '') }
-        end
+      def to_header
+        @cookies.map { |k, v| "#{escape(k)}=#{escape(v)}" }.join "; "
       end
 
-      # Sets the cookie named +name+. The second argument may be the cookie's
-      # value or a hash of options as documented above.
+      # Sets the cookie named `name`. The second argument may be the cookie's value or
+      # a hash of options as documented above.
       def []=(name, options)
         if options.is_a?(Hash)
           options.symbolize_keys!
           value = options[:value]
         else
           value = options
-          options = { :value => value }
+          options = { value: value }
         end
 
         handle_options(options)
@@ -320,9 +394,11 @@ module ActionDispatch
         value
       end
 
-      # Removes the cookie on the client machine by setting the value to an empty string
-      # and the expiration date in the past. Like <tt>[]=</tt>, you can pass in
-      # an options hash to delete cookies with extra data such as a <tt>:path</tt>.
+      # Removes the cookie on the client machine by setting the value to an empty
+      # string and the expiration date in the past. Like `[]=`, you can pass in an
+      # options hash to delete cookies with extra data such as a `:path`.
+      #
+      # Returns the value of the cookie, or `nil` if the cookie does not exist.
       def delete(name, options = {})
         return unless @cookies.has_key? name.to_s
 
@@ -334,222 +410,289 @@ module ActionDispatch
         value
       end
 
-      # Whether the given cookie is to be deleted by this CookieJar.
-      # Like <tt>[]=</tt>, you can pass in an options hash to test if a
-      # deletion applies to a specific <tt>:path</tt>, <tt>:domain</tt> etc.
+      # Whether the given cookie is to be deleted by this CookieJar. Like `[]=`, you
+      # can pass in an options hash to test if a deletion applies to a specific
+      # `:path`, `:domain` etc.
       def deleted?(name, options = {})
         options.symbolize_keys!
         handle_options(options)
         @delete_cookies[name.to_s] == options
       end
 
-      # Removes all cookies on the client machine by calling <tt>delete</tt> for each cookie
+      # Removes all cookies on the client machine by calling `delete` for each cookie.
       def clear(options = {})
-        @cookies.each_key{ |k| delete(k, options) }
+        @cookies.each_key { |k| delete(k, options) }
       end
 
-      def write(headers)
-        @set_cookies.each { |k, v| ::Rack::Utils.set_cookie_header!(headers, k, v) if write_cookie?(v) }
-        @delete_cookies.each { |k, v| ::Rack::Utils.delete_cookie_header!(headers, k, v) }
-      end
+      def write(response)
+        @set_cookies.each do |name, value|
+          if write_cookie?(value)
+            response.set_cookie(name, value)
+          end
+        end
 
-      def recycle! #:nodoc:
-        @set_cookies = {}
-        @delete_cookies = {}
+        @delete_cookies.each do |name, value|
+          response.delete_cookie(name, value)
+        end
       end
 
-      mattr_accessor :always_write_cookie
-      self.always_write_cookie = false
+      mattr_accessor :always_write_cookie, default: false
 
       private
+        def escape(string)
+          ::Rack::Utils.escape(string)
+        end
+
         def write_cookie?(cookie)
-          @secure || !cookie[:secure] || always_write_cookie
+          request.ssl? || !cookie[:secure] || always_write_cookie || request.host.end_with?(".onion")
+        end
+
+        def handle_options(options)
+          if options[:expires].respond_to?(:from_now)
+            options[:expires] = options[:expires].from_now
+          end
+
+          options[:path]      ||= "/"
+
+          unless options.key?(:same_site)
+            options[:same_site] = request.cookies_same_site_protection
+          end
+
+          if options[:domain] == :all || options[:domain] == "all"
+            cookie_domain = ""
+            dot_splitted_host = request.host.split(".", -1)
+
+            # Case where request.host is not an IP address or it's an invalid domain (ip
+            # confirms to the domain structure we expect so we explicitly check for ip)
+            if request.host.match?(/^[\d.]+$/) || dot_splitted_host.include?("") || dot_splitted_host.length == 1
+              options[:domain] = nil
+              return
+            end
+
+            # If there is a provided tld length then we use it otherwise default domain.
+            if options[:tld_length].present?
+              # Case where the tld_length provided is valid
+              if dot_splitted_host.length >= options[:tld_length]
+                cookie_domain = dot_splitted_host.last(options[:tld_length]).join(".")
+              end
+            # Case where tld_length is not provided
+            else
+              # Regular TLDs
+              if !(/\.[^.]{2,3}\.[^.]{2}\z/.match?(request.host))
+                cookie_domain = dot_splitted_host.last(2).join(".")
+              # **.**, ***.** style TLDs like co.uk and com.au
+              else
+                cookie_domain = dot_splitted_host.last(3).join(".")
+              end
+            end
+
+            options[:domain] = if cookie_domain.present?
+              cookie_domain
+            end
+          elsif options[:domain].is_a? Array
+            # If host matches one of the supplied domains.
+            options[:domain] = options[:domain].find do |domain|
+              domain = domain.delete_prefix(".")
+              request.host == domain || request.host.end_with?(".#{domain}")
+            end
+          elsif options[:domain].respond_to?(:call)
+            options[:domain] = options[:domain].call(request)
+          end
         end
     end
 
-    class PermanentCookieJar #:nodoc:
+    class AbstractCookieJar # :nodoc:
       include ChainedCookieJars
 
-      def initialize(parent_jar, key_generator, options = {})
+      def initialize(parent_jar)
         @parent_jar = parent_jar
-        @key_generator = key_generator
-        @options = options
       end
 
       def [](name)
-        @parent_jar[name.to_s]
+        if data = @parent_jar[name.to_s]
+          result = parse(name, data, purpose: "cookie.#{name}")
+
+          if result.nil?
+            parse(name, data)
+          else
+            result
+          end
+        end
       end
 
       def []=(name, options)
         if options.is_a?(Hash)
           options.symbolize_keys!
         else
-          options = { :value => options }
+          options = { value: options }
         end
 
-        options[:expires] = 20.years.from_now
+        commit(name, options)
         @parent_jar[name] = options
       end
-    end
 
-    class JsonSerializer # :nodoc:
-      def self.load(value)
-        ActiveSupport::JSON.decode(value)
-      end
+      protected
+        def request; @parent_jar.request; end
 
-      def self.dump(value)
-        ActiveSupport::JSON.encode(value)
-      end
+      private
+        def expiry_options(options)
+          if options[:expires].respond_to?(:from_now)
+            { expires_in: options[:expires] }
+          else
+            { expires_at: options[:expires] }
+          end
+        end
+
+        def cookie_metadata(name, options)
+          expiry_options(options).tap do |metadata|
+            metadata[:purpose] = "cookie.#{name}" if request.use_cookies_with_metadata
+          end
+        end
+
+        def parse(name, data, purpose: nil); data; end
+        def commit(name, options); end
+    end
+
+    class PermanentCookieJar < AbstractCookieJar # :nodoc:
+      private
+        def commit(name, options)
+          options[:expires] = 20.years.from_now
+        end
     end
 
     module SerializedCookieJars # :nodoc:
-      MARSHAL_SIGNATURE = "\x04\x08".freeze
+      SERIALIZER = ActiveSupport::MessageEncryptor::NullSerializer
 
       protected
-        def needs_migration?(value)
-          @options[:serializer] == :hybrid && value.start_with?(MARSHAL_SIGNATURE)
+        def digest
+          request.cookies_digest || "SHA1"
         end
 
-        def serialize(name, value)
-          serializer.dump(value)
+      private
+        def serializer
+          @serializer ||=
+            case request.cookies_serializer
+            when nil
+              ActiveSupport::Messages::SerializerWithFallback[:marshal]
+            when :hybrid
+              ActiveSupport::Messages::SerializerWithFallback[:json_allow_marshal]
+            when Symbol
+              ActiveSupport::Messages::SerializerWithFallback[request.cookies_serializer]
+            else
+              request.cookies_serializer
+            end
         end
 
-        def deserialize(name, value)
-          if value
-            if needs_migration?(value)
-              Marshal.load(value).tap do |v|
-                self[name] = { value: v }
-              end
-            else
-              serializer.load(value)
+        def reserialize?(dumped)
+          serializer.is_a?(ActiveSupport::Messages::SerializerWithFallback) &&
+            serializer != ActiveSupport::Messages::SerializerWithFallback[:marshal] &&
+            !serializer.dumped?(dumped)
+        end
+
+        def parse(name, dumped, force_reserialize: false, **)
+          if dumped
+            begin
+              value = serializer.load(dumped)
+            rescue StandardError
+              return
             end
+
+            self[name] = { value: value } if force_reserialize || reserialize?(dumped)
+
+            value
           end
         end
 
-        def serializer
-          serializer = @options[:serializer] || :marshal
-          case serializer
-          when :marshal
-            Marshal
-          when :json, :hybrid
-            JsonSerializer
-          else
-            serializer
-          end
+        def commit(name, options)
+          options[:value] = serializer.dump(options[:value])
         end
 
-        def digest
-          @options[:digest] || 'SHA1'
+        def check_for_overflow!(name, options)
+          if options[:value].bytesize > MAX_COOKIE_SIZE
+            raise CookieOverflow, "#{name} cookie overflowed with size #{options[:value].bytesize} bytes"
+          end
         end
     end
 
-    class SignedCookieJar #:nodoc:
-      include ChainedCookieJars
+    class SignedKeyRotatingCookieJar < AbstractCookieJar # :nodoc:
       include SerializedCookieJars
 
-      def initialize(parent_jar, key_generator, options = {})
-        @parent_jar = parent_jar
-        @options = options
-        secret = key_generator.generate_key(@options[:signed_cookie_salt])
-        @verifier = ActiveSupport::MessageVerifier.new(secret, digest: digest, serializer: ActiveSupport::MessageEncryptor::NullSerializer)
-      end
+      def initialize(parent_jar)
+        super
 
-      def [](name)
-        if signed_message = @parent_jar[name]
-          deserialize name, verify(signed_message)
-        end
-      end
+        secret = request.key_generator.generate_key(request.signed_cookie_salt)
+        @verifier = ActiveSupport::MessageVerifier.new(secret, digest: signed_cookie_digest, serializer: SERIALIZER)
 
-      def []=(name, options)
-        if options.is_a?(Hash)
-          options.symbolize_keys!
-          options[:value] = @verifier.generate(serialize(name, options[:value]))
-        else
-          options = { :value => @verifier.generate(serialize(name, options)) }
+        request.cookies_rotations.signed.each do |(*secrets)|
+          options = secrets.extract_options!
+          @verifier.rotate(*secrets, serializer: SERIALIZER, **options)
         end
-
-        raise CookieOverflow if options[:value].bytesize > MAX_COOKIE_SIZE
-        @parent_jar[name] = options
       end
 
       private
-        def verify(signed_message)
-          @verifier.verify(signed_message)
-        rescue ActiveSupport::MessageVerifier::InvalidSignature
-          nil
+        def parse(name, signed_message, purpose: nil)
+          rotated = false
+          data = @verifier.verified(signed_message, purpose: purpose, on_rotation: -> { rotated = true })
+          super(name, data, force_reserialize: rotated)
         end
-    end
-
-    # UpgradeLegacySignedCookieJar is used instead of SignedCookieJar if
-    # secrets.secret_token and secrets.secret_key_base are both set. It reads
-    # legacy cookies signed with the old dummy key generator and re-saves
-    # them using the new key generator to provide a smooth upgrade path.
-    class UpgradeLegacySignedCookieJar < SignedCookieJar #:nodoc:
-      include VerifyAndUpgradeLegacySignedMessage
 
-      def [](name)
-        if signed_message = @parent_jar[name]
-          deserialize(name, verify(signed_message)) || verify_and_upgrade_legacy_signed_message(name, signed_message)
+        def commit(name, options)
+          super
+          options[:value] = @verifier.generate(options[:value], **cookie_metadata(name, options))
+          check_for_overflow!(name, options)
         end
-      end
     end
 
-    class EncryptedCookieJar #:nodoc:
-      include ChainedCookieJars
+    class EncryptedKeyRotatingCookieJar < AbstractCookieJar # :nodoc:
       include SerializedCookieJars
 
-      def initialize(parent_jar, key_generator, options = {})
-        if ActiveSupport::LegacyKeyGenerator === key_generator
-          raise "You didn't set secrets.secret_key_base, which is required for this cookie jar. " +
-            "Read the upgrade documentation to learn more about this new config option."
-        end
-
-        @parent_jar = parent_jar
-        @options = options
-        secret = key_generator.generate_key(@options[:encrypted_cookie_salt])[0, ActiveSupport::MessageEncryptor.key_len]
-        sign_secret = key_generator.generate_key(@options[:encrypted_signed_cookie_salt])
-        @encryptor = ActiveSupport::MessageEncryptor.new(secret, sign_secret, digest: digest, serializer: ActiveSupport::MessageEncryptor::NullSerializer)
-      end
+      def initialize(parent_jar)
+        super
 
-      def [](name)
-        if encrypted_message = @parent_jar[name]
-          deserialize name, decrypt_and_verify(encrypted_message)
+        if request.use_authenticated_cookie_encryption
+          key_len = ActiveSupport::MessageEncryptor.key_len(encrypted_cookie_cipher)
+          secret = request.key_generator.generate_key(request.authenticated_encrypted_cookie_salt, key_len)
+          @encryptor = ActiveSupport::MessageEncryptor.new(secret, cipher: encrypted_cookie_cipher, serializer: SERIALIZER)
+        else
+          key_len = ActiveSupport::MessageEncryptor.key_len("aes-256-cbc")
+          secret = request.key_generator.generate_key(request.encrypted_cookie_salt, key_len)
+          sign_secret = request.key_generator.generate_key(request.encrypted_signed_cookie_salt)
+          @encryptor = ActiveSupport::MessageEncryptor.new(secret, sign_secret, cipher: "aes-256-cbc", serializer: SERIALIZER)
         end
-      end
 
-      def []=(name, options)
-        if options.is_a?(Hash)
-          options.symbolize_keys!
-        else
-          options = { :value => options }
+        request.cookies_rotations.encrypted.each do |(*secrets)|
+          options = secrets.extract_options!
+          @encryptor.rotate(*secrets, serializer: SERIALIZER, **options)
         end
 
-        options[:value] = @encryptor.encrypt_and_sign(serialize(name, options[:value]))
+        if upgrade_legacy_hmac_aes_cbc_cookies?
+          legacy_cipher = "aes-256-cbc"
+          secret = request.key_generator.generate_key(request.encrypted_cookie_salt, ActiveSupport::MessageEncryptor.key_len(legacy_cipher))
+          sign_secret = request.key_generator.generate_key(request.encrypted_signed_cookie_salt)
 
-        raise CookieOverflow if options[:value].bytesize > MAX_COOKIE_SIZE
-        @parent_jar[name] = options
+          @encryptor.rotate(secret, sign_secret, cipher: legacy_cipher, digest: digest, serializer: SERIALIZER)
+        elsif prepare_upgrade_legacy_hmac_aes_cbc_cookies?
+          future_cipher = encrypted_cookie_cipher
+          secret = request.key_generator.generate_key(request.authenticated_encrypted_cookie_salt, ActiveSupport::MessageEncryptor.key_len(future_cipher))
+
+          @encryptor.rotate(secret, nil, cipher: future_cipher, serializer: SERIALIZER)
+        end
       end
 
       private
-        def decrypt_and_verify(encrypted_message)
-          @encryptor.decrypt_and_verify(encrypted_message)
-        rescue ActiveSupport::MessageVerifier::InvalidSignature, ActiveSupport::MessageEncryptor::InvalidMessage
+        def parse(name, encrypted_message, purpose: nil)
+          rotated = false
+          data = @encryptor.decrypt_and_verify(encrypted_message, purpose: purpose, on_rotation: -> { rotated = true })
+          super(name, data, force_reserialize: rotated)
+        rescue ActiveSupport::MessageEncryptor::InvalidMessage, ActiveSupport::MessageVerifier::InvalidSignature
           nil
         end
-    end
-
-    # UpgradeLegacyEncryptedCookieJar is used by ActionDispatch::Session::CookieStore
-    # instead of EncryptedCookieJar if secrets.secret_token and secrets.secret_key_base
-    # are both set. It reads legacy cookies signed with the old dummy key generator and
-    # encrypts and re-saves them using the new key generator to provide a smooth upgrade path.
-    class UpgradeLegacyEncryptedCookieJar < EncryptedCookieJar #:nodoc:
-      include VerifyAndUpgradeLegacySignedMessage
 
-      def [](name)
-        if encrypted_or_signed_message = @parent_jar[name]
-          deserialize(name, decrypt_and_verify(encrypted_or_signed_message)) || verify_and_upgrade_legacy_signed_message(name, encrypted_or_signed_message)
+        def commit(name, options)
+          super
+          options[:value] = @encryptor.encrypt_and_sign(options[:value], **cookie_metadata(name, options))
+          check_for_overflow!(name, options)
         end
-      end
     end
 
     def initialize(app)
@@ -557,18 +700,18 @@ module ActionDispatch
     end
 
     def call(env)
-      status, headers, body = @app.call(env)
+      request = ActionDispatch::Request.new(env)
+      response = @app.call(env)
 
-      if cookie_jar = env['action_dispatch.cookies']
+      if request.have_cookie_jar?
+        cookie_jar = request.cookie_jar
         unless cookie_jar.committed?
-          cookie_jar.write(headers)
-          if headers[HTTP_HEADER].respond_to?(:join)
-            headers[HTTP_HEADER] = headers[HTTP_HEADER].join("\n")
-          end
+          response = Rack::Response[*response]
+          cookie_jar.write(response)
         end
       end
 
-      [status, headers, body]
+      response.to_a
     end
   end
 end