actionpack 3.2.22.5 → 5.2.4

data/lib/action_dispatch/middleware/cookies.rb

@@ -1,12 +1,87 @@
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/module/attribute_accessors'
+# frozen_string_literal: true
+
+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
     def cookie_jar
-      env['action_dispatch.cookies'] ||= Cookies::CookieJar.build(self)
+      fetch_header("action_dispatch.cookies".freeze) 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".freeze
+    end
+
+    def cookie_jar=(jar)
+      set_header "action_dispatch.cookies".freeze, 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_token
+      get_header Cookies::SECRET_TOKEN
     end
+
+    def secret_key_base
+      get_header Cookies::SECRET_KEY_BASE
+    end
+
+    def cookies_serializer
+      get_header Cookies::COOKIES_SERIALIZER
+    end
+
+    def cookies_digest
+      get_header Cookies::COOKIES_DIGEST
+    end
+
+    def cookies_rotations
+      get_header Cookies::COOKIES_ROTATIONS
+    end
+
+    # :startdoc:
   end
 
   # \Cookies are read and written through ActionController#cookies.
@@ -15,34 +90,43 @@ module ActionDispatch
   # 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.
   #
-  # Examples for writing:
+  # Examples of writing:
   #
   #   # Sets a simple session cookie.
   #   # This cookie will be deleted when the user's browser is closed.
   #   cookies[:user_name] = "david"
   #
-  #   # Assign an array of values to a cookie.
-  #   cookies[:lat_lon] = [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.from_now }
+  #   cookies[:login] = { value: "XJ-122", expires: 1.hour }
+  #
+  #   # 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 a user from tampering with its value.
-  #   # The cookie is signed by your app's <tt>config.secret_token</tt> value.
-  #   # Rails generates this value by default when you create a new Rails app.
+  #   # 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 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
+  #
   #   # Sets a "permanent" cookie (which expires in 20 years from now).
   #   cookies.permanent[:login] = "XJ-122"
   #
   #   # You can also chain these methods:
-  #   cookies.permanent.signed[:login] = "XJ-122"
+  #   cookies.signed.permanent[:login] = "XJ-122"
   #
-  # Examples for reading:
+  # Examples of reading:
   #
-  #   cookies[:user_name] # => "david"
-  #   cookies.size        # => 2
-  #   cookies[:lat_lon]   # => [47.68, -122.37]
+  #   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:
   #
@@ -50,43 +134,153 @@ module ActionDispatch
   #
   # Please note that if you specify a :domain when setting a cookie, you must also specify the domain when deleting the cookie:
   #
-  #  cookies[:key] = {
-  #    :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(:key, :domain => 'domain.com')
+  #  cookies.delete(:name, domain: 'domain.com')
   #
   # The option symbols for setting cookies are:
   #
-  # * <tt>:value</tt> - The cookie's value or list of values (as an array).
+  # * <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> again when deleting keys.
+  #   <tt>:all</tt> or <tt>Array</tt> again when deleting cookies.
   #
-  #     :domain => nil  # Does not sets cookie domain. (default)
-  #     :domain => :all # Allow the cookie for the top most level
-  #                       domain and subdomains.
+  #     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.
   #
-  # * <tt>:expires</tt> - The time at which this cookie expires, as a \Time object.
-  # * <tt>:secure</tt> - Whether this cookie is a only transmitted to HTTPS servers.
+  # * <tt>:tld_length</tt> - When using <tt>:domain => :all</tt>, 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 <tt>:tld_length</tt> to 2.
+  # * <tt>:expires</tt> - The time at which this cookie expires, as a \Time or ActiveSupport::Duration 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
-    TOKEN_KEY   = "action_dispatch.secret_token".freeze
+    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
+    AUTHENTICATED_ENCRYPTED_COOKIE_SALT = "action_dispatch.authenticated_encrypted_cookie_salt".freeze
+    USE_AUTHENTICATED_COOKIE_ENCRYPTION = "action_dispatch.use_authenticated_cookie_encryption".freeze
+    ENCRYPTED_COOKIE_CIPHER = "action_dispatch.encrypted_cookie_cipher".freeze
+    SIGNED_COOKIE_DIGEST = "action_dispatch.signed_cookie_digest".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
+    COOKIES_ROTATIONS = "action_dispatch.cookies_rotations".freeze
+
+    # Cookies can typically store 4096 bytes.
+    MAX_COOKIE_SIZE = 4096
 
     # Raised when storing more than 4K of session data.
-    class CookieOverflow < StandardError; end
+    CookieOverflow = Class.new StandardError
+
+    # 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:
+      #
+      #   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 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
+      def permanent
+        @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.
+      #
+      # If +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 +secret_key_base+.
+      #
+      # Example:
+      #
+      #   cookies.signed[:discount] = 45
+      #   # => Set-Cookie: discount=BAhpMg==--2c1c6906c90a3bc4fd54a51ffb41dffa4bf6b5f7; path=/
+      #
+      #   cookies.signed[:discount] # => 45
+      def signed
+        @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.
+      #
+      # If +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 +secret_key_base+.
+      #
+      # Example:
+      #
+      #   cookies.encrypted[:discount] = 45
+      #   # => Set-Cookie: discount=DIQ7fw==--K3n//8vvnSbGq9dA--7Xh91HfLpwzbj1czhBiwOg==; path=/
+      #
+      #   cookies.encrypted[:discount] # => 45
+      def encrypted
+        @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.
+      def signed_or_encrypted
+        @signed_or_encrypted ||=
+          if request.secret_key_base.present?
+            encrypted
+          else
+            signed
+          end
+      end
+
+      private
+
+        def upgrade_legacy_signed_cookies?
+          request.secret_token.present? && request.secret_key_base.present?
+        end
+
+        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 encrypted_cookie_cipher
+          request.encrypted_cookie_cipher || "aes-256-gcm"
+        end
+
+        def signed_cookie_digest
+          request.signed_cookie_digest || "SHA1"
+        end
+    end
 
     class CookieJar #:nodoc:
-      include Enumerable
+      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
@@ -102,24 +296,28 @@ module ActionDispatch
       # $& => example.local
       DOMAIN_REGEXP = /[^.]*\.([^.]*|..\...|...\...)$/
 
-      def self.build(request)
-        secret = request.env[TOKEN_KEY]
-        host = request.host
-        secure = request.ssl?
-
-        new(secret, host, secure).tap do |hash|
-          hash.update(request.cookies)
+      def self.build(req, cookies)
+        new(req).tap do |hash|
+          hash.update(cookies)
         end
       end
 
-      def initialize(secret = nil, host = nil, secure = false)
-        @secret = secret
+      attr_reader :request
+
+      def initialize(request)
         @set_cookies = {}
         @delete_cookies = {}
-        @host = host
-        @secure = secure
-        @closed = false
+        @request = request
         @cookies = {}
+        @committed = false
+      end
+
+      def committed?; @committed; end
+
+      def commit!
+        @committed = true
+        @set_cookies.freeze
+        @delete_cookies.freeze
       end
 
       def each(&block)
@@ -131,205 +329,335 @@ module ActionDispatch
         @cookies[name.to_s]
       end
 
+      def fetch(name, *args, &block)
+        @cookies.fetch(name.to_s, *args, &block)
+      end
+
       def key?(name)
         @cookies.key?(name.to_s)
       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:
+      def update_cookies_from_jar
+        request_jar = @request.cookie_jar.instance_variable_get(:@cookies)
+        set_cookies = request_jar.reject { |k, _| @delete_cookies.key?(k) }
+
+        @cookies.update set_cookies if set_cookies
+      end
+
+      def to_header
+        @cookies.map { |k, v| "#{escape(k)}=#{escape(v)}" }.join "; "
+      end
+
+      def handle_options(options) # :nodoc:
+        if options[:expires].respond_to?(:from_now)
+          options[:expires] = options[:expires].from_now
+        end
+
         options[:path] ||= "/"
 
-        if options[:domain] == :all
-          # if there is a provided tld length then we use it otherwise default domain regexp
+        if options[:domain] == :all || 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
 
-          # if host is not ip and matches domain regexp
+          # 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)
+          options[:domain] = if (request.host !~ /^[\d.]+$/) && (request.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[/^\.?(.*)$/, 1] }
+          # If host matches one of the supplied domains without a dot in front of it.
+          options[:domain] = options[:domain].find { |domain| request.host.include? domain.sub(/^\./, "") }
         end
       end
 
-      # Sets the cookie named +name+. The second argument may be the very cookie
-      # value, or a hash of options as documented above.
-      def []=(key, options)
+      # 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)
 
-        if @cookies[key.to_s] != value or options[:expires]
-          @cookies[key.to_s] = value
-          @set_cookies[key.to_s] = options
-          @delete_cookies.delete(key.to_s)
+        if @cookies[name.to_s] != value || options[:expires]
+          @cookies[name.to_s] = value
+          @set_cookies[name.to_s] = options
+          @delete_cookies.delete(name.to_s)
         end
 
         value
       end
 
       # Removes the cookie on the client machine by setting the value to an empty string
-      # and setting its expiration date into the past. Like <tt>[]=</tt>, you can pass in
+      # 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>.
-      def delete(key, options = {})
-        options.symbolize_keys!
+      def delete(name, options = {})
+        return unless @cookies.has_key? name.to_s
 
+        options.symbolize_keys!
         handle_options(options)
 
-        value = @cookies.delete(key.to_s)
-        @delete_cookies[key.to_s] = options
+        value = @cookies.delete(name.to_s)
+        @delete_cookies[name.to_s] = options
         value
       end
 
-      # Removes all cookies on the client machine by calling <tt>delete</tt> for each cookie
-      def clear(options = {})
-        @cookies.each_key{ |k| delete(k, options) }
-      end
-
-      # 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
-      #
-      # 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:
-      #
-      #   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, @secret)
+      # 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.
+      def deleted?(name, options = {})
+        options.symbolize_keys!
+        handle_options(options)
+        @delete_cookies[name.to_s] == options
       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), an ActiveSupport::MessageVerifier::InvalidSignature exception will
-      # be raised.
-      #
-      # This jar requires that you set a suitable secret for the verification on your app's config.secret_token.
-      #
-      # Example:
-      #
-      #   cookies.signed[:discount] = 45
-      #   # => Set-Cookie: discount=BAhpMg==--2c1c6906c90a3bc4fd54a51ffb41dffa4bf6b5f7; path=/
-      #
-      #   cookies.signed[:discount] # => 45
-      def signed
-        @signed ||= SignedCookieJar.new(self, @secret)
+      # Removes all cookies on the client machine by calling <tt>delete</tt> for each cookie.
+      def clear(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 recycle! #:nodoc:
-        @set_cookies.clear
-        @delete_cookies.clear
+        if header = make_set_cookie_header(headers[HTTP_HEADER])
+          headers[HTTP_HEADER] = header
+        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 make_set_cookie_header(header)
+          header = @set_cookies.inject(header) { |m, (k, v)|
+            if write_cookie?(v)
+              ::Rack::Utils.add_cookie_to_header(m, k, v)
+            else
+              m
+            end
+          }
+          @delete_cookies.inject(header) { |m, (k, v)|
+            ::Rack::Utils.add_remove_cookie_to_header(m, k, v)
+          }
+        end
+
         def write_cookie?(cookie)
-          @secure || !cookie[:secure] || always_write_cookie
+          request.ssl? || !cookie[:secure] || always_write_cookie
         end
     end
 
-    class PermanentCookieJar < CookieJar #:nodoc:
-      def initialize(parent_jar, secret)
-        @parent_jar, @secret = parent_jar, secret
+    class AbstractCookieJar # :nodoc:
+      include ChainedCookieJars
+
+      def initialize(parent_jar)
+        @parent_jar = parent_jar
       end
 
-      def []=(key, options)
+      def [](name)
+        if data = @parent_jar[name.to_s]
+          parse name, data
+        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
-        @parent_jar[key] = options
+        commit(options)
+        @parent_jar[name] = options
       end
 
-      def signed
-        @signed ||= SignedCookieJar.new(self, @secret)
+      protected
+        def request; @parent_jar.request; end
+
+      private
+        def expiry_options(options)
+          if request.use_authenticated_cookie_encryption
+            if options[:expires].respond_to?(:from_now)
+              { expires_in: options[:expires] }
+            else
+              { expires_at: options[:expires] }
+            end
+          else
+            {}
+          end
+        end
+
+        def parse(name, data); data; end
+        def commit(options); end
+    end
+
+    class PermanentCookieJar < AbstractCookieJar # :nodoc:
+      private
+        def commit(options)
+          options[:expires] = 20.years.from_now
+        end
+    end
+
+    class JsonSerializer # :nodoc:
+      def self.load(value)
+        ActiveSupport::JSON.decode(value)
       end
 
-      def method_missing(method, *arguments, &block)
-        @parent_jar.send(method, *arguments, &block)
+      def self.dump(value)
+        ActiveSupport::JSON.encode(value)
       end
     end
 
-    class SignedCookieJar < CookieJar #:nodoc:
-      MAX_COOKIE_SIZE = 4096 # Cookies can typically store 4096 bytes.
-      SECRET_MIN_LENGTH = 30 # Characters
+    module SerializedCookieJars # :nodoc:
+      MARSHAL_SIGNATURE = "\x04\x08".freeze
+      SERIALIZER = ActiveSupport::MessageEncryptor::NullSerializer
 
-      def initialize(parent_jar, secret)
-        ensure_secret_secure(secret)
-        @parent_jar = parent_jar
-        @verifier   = ActiveSupport::MessageVerifier.new(secret)
-      end
+      protected
+        def needs_migration?(value)
+          request.cookies_serializer == :hybrid && value.start_with?(MARSHAL_SIGNATURE)
+        end
 
-      def [](name)
-        if signed_message = @parent_jar[name]
-          @verifier.verify(signed_message)
+        def serialize(value)
+          serializer.dump(value)
+        end
+
+        def deserialize(name)
+          rotate = false
+          value  = yield -> { rotate = true }
+
+          if value
+            case
+            when needs_migration?(value)
+              self[name] = Marshal.load(value)
+            when rotate
+              self[name] = serializer.load(value)
+            else
+              serializer.load(value)
+            end
+          end
+        end
+
+        def serializer
+          serializer = request.cookies_serializer || :marshal
+          case serializer
+          when :marshal
+            Marshal
+          when :json, :hybrid
+            JsonSerializer
+          else
+            serializer
+          end
+        end
+
+        def digest
+          request.cookies_digest || "SHA1"
+        end
+    end
+
+    class SignedKeyRotatingCookieJar < AbstractCookieJar # :nodoc:
+      include SerializedCookieJars
+
+      def initialize(parent_jar)
+        super
+
+        secret = request.key_generator.generate_key(request.signed_cookie_salt)
+        @verifier = ActiveSupport::MessageVerifier.new(secret, digest: signed_cookie_digest, serializer: SERIALIZER)
+
+        request.cookies_rotations.signed.each do |*secrets, **options|
+          @verifier.rotate(*secrets, serializer: SERIALIZER, **options)
+        end
+
+        if upgrade_legacy_signed_cookies?
+          @verifier.rotate request.secret_token, serializer: SERIALIZER
         end
-      rescue ActiveSupport::MessageVerifier::InvalidSignature
-        nil
       end
 
-      def []=(key, options)
-        if options.is_a?(Hash)
-          options.symbolize_keys!
-          options[:value] = @verifier.generate(options[:value])
+      private
+        def parse(name, signed_message)
+          deserialize(name) do |rotate|
+            @verifier.verified(signed_message, on_rotation: rotate)
+          end
+        end
+
+        def commit(options)
+          options[:value] = @verifier.generate(serialize(options[:value]), expiry_options(options))
+
+          raise CookieOverflow if options[:value].bytesize > MAX_COOKIE_SIZE
+        end
+    end
+
+    class EncryptedKeyRotatingCookieJar < AbstractCookieJar # :nodoc:
+      include SerializedCookieJars
+
+      def initialize(parent_jar)
+        super
+
+        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
-          options = { :value => @verifier.generate(options) }
+          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
 
-        raise CookieOverflow if options[:value].size > MAX_COOKIE_SIZE
-        @parent_jar[key] = options
-      end
+        request.cookies_rotations.encrypted.each do |*secrets, **options|
+          @encryptor.rotate(*secrets, serializer: SERIALIZER, **options)
+        end
+
+        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)
 
-      def method_missing(method, *arguments, &block)
-        @parent_jar.send(method, *arguments, &block)
+          @encryptor.rotate(secret, sign_secret, cipher: legacy_cipher, digest: digest, serializer: SERIALIZER)
+        end
+
+        if upgrade_legacy_signed_cookies?
+          @legacy_verifier = ActiveSupport::MessageVerifier.new(request.secret_token, digest: digest, serializer: SERIALIZER)
+        end
       end
 
-    protected
+      private
+        def parse(name, encrypted_message)
+          deserialize(name) do |rotate|
+            @encryptor.decrypt_and_verify(encrypted_message, on_rotation: rotate)
+          end
+        rescue ActiveSupport::MessageEncryptor::InvalidMessage, ActiveSupport::MessageVerifier::InvalidSignature
+          parse_legacy_signed_message(name, encrypted_message)
+        end
+
+        def commit(options)
+          options[:value] = @encryptor.encrypt_and_sign(serialize(options[:value]), expiry_options(options))
 
-      # To prevent users from using something insecure like "Password" we make sure that the
-      # secret they've provided is at least 30 characters in length.
-      def ensure_secret_secure(secret)
-        if secret.blank?
-          raise ArgumentError, "A secret is required to generate an " +
-            "integrity hash for cookie session data. Use " +
-            "config.secret_token = \"some secret phrase of at " +
-            "least #{SECRET_MIN_LENGTH} characters\"" +
-            "in config/initializers/secret_token.rb"
+          raise CookieOverflow if options[:value].bytesize > MAX_COOKIE_SIZE
         end
 
-        if secret.length < SECRET_MIN_LENGTH
-          raise ArgumentError, "Secret should be something secure, " +
-            "like \"#{SecureRandom.hex(16)}\". The value you " +
-            "provided, \"#{secret}\", is shorter than the minimum length " +
-            "of #{SECRET_MIN_LENGTH} characters"
+        def parse_legacy_signed_message(name, legacy_signed_message)
+          if defined?(@legacy_verifier)
+            deserialize(name) do |rotate|
+              rotate.call
+
+              @legacy_verifier.verified(legacy_signed_message)
+            end
+          end
         end
-      end
     end
 
     def initialize(app)
@@ -337,13 +665,17 @@ module ActionDispatch
     end
 
     def call(env)
-      cookie_jar = nil
+      request = ActionDispatch::Request.new env
+
       status, headers, body = @app.call(env)
 
-      if cookie_jar = env['action_dispatch.cookies']
-        cookie_jar.write(headers)
-        if headers[HTTP_HEADER].respond_to?(:join)
-          headers[HTTP_HEADER] = headers[HTTP_HEADER].join("\n")
+      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
         end
       end