rack 1.6.13 → 2.2.3

data/lib/rack/session/abstract/id.rb

@@ -1,15 +1,12 @@
+# frozen_string_literal: true
+
 # AUTHOR: blink <blinketje@gmail.com>; blink#ruby-lang@irc.freenode.net
 # bugrep: Andreas Zehnder
 
+require_relative '../../../rack'
 require 'time'
-require 'rack/request'
-require 'rack/response'
-begin
-  require 'securerandom'
-rescue LoadError
-  # We just won't get securerandom
-end
-require "digest/sha2"
+require 'securerandom'
+require 'digest/sha2'
 
 module Rack
 
@@ -42,40 +39,39 @@ module Rack
     end
 
     module Abstract
-      ENV_SESSION_KEY = 'rack.session'.freeze
-      ENV_SESSION_OPTIONS_KEY = 'rack.session.options'.freeze
-
       # SessionHash is responsible to lazily load the session from store.
 
       class SessionHash
         include Enumerable
         attr_writer :id
 
-        def self.find(env)
-          env[ENV_SESSION_KEY]
+        Unspecified = Object.new
+
+        def self.find(req)
+          req.get_header RACK_SESSION
         end
 
-        def self.set(env, session)
-          env[ENV_SESSION_KEY] = session
+        def self.set(req, session)
+          req.set_header RACK_SESSION, session
         end
 
-        def self.set_options(env, options)
-          env[ENV_SESSION_OPTIONS_KEY] = options.dup
+        def self.set_options(req, options)
+          req.set_header RACK_SESSION_OPTIONS, options.dup
         end
 
-        def initialize(store, env)
+        def initialize(store, req)
           @store = store
-          @env = env
+          @req = req
           @loaded = false
         end
 
         def id
           return @id if @loaded or instance_variable_defined?(:@id)
-          @id = @store.send(:extract_session_id, @env)
+          @id = @store.send(:extract_session_id, @req)
         end
 
         def options
-          @env[ENV_SESSION_OPTIONS_KEY]
+          @req.session_options
         end
 
         def each(&block)
@@ -87,7 +83,20 @@ module Rack
           load_for_read!
           @data[key.to_s]
         end
-        alias :fetch :[]
+
+        def dig(key, *keys)
+          load_for_read!
+          @data.dig(key.to_s, *keys)
+        end
+
+        def fetch(key, default = Unspecified, &block)
+          load_for_read!
+          if default == Unspecified
+            @data.fetch(key.to_s, &block)
+          else
+            @data.fetch(key.to_s, default, &block)
+          end
+        end
 
         def has_key?(key)
           load_for_read!
@@ -109,7 +118,7 @@ module Rack
 
         def destroy
           clear
-          @id = @store.send(:destroy_session, @env, id, options)
+          @id = @store.send(:delete_session, @req, id, options)
         end
 
         def to_hash
@@ -144,7 +153,7 @@ module Rack
         def exists?
           return @exists if instance_variable_defined?(:@exists)
           @data = {}
-          @exists = @store.send(:session_exists?, @env)
+          @exists = @store.send(:session_exists?, @req)
         end
 
         def loaded?
@@ -157,10 +166,12 @@ module Rack
         end
 
         def keys
+          load_for_read!
           @data.keys
         end
 
         def values
+          load_for_read!
           @data.values
         end
 
@@ -175,14 +186,15 @@ module Rack
         end
 
         def load!
-          @id, session = @store.send(:load_session, @env)
+          @id, session = @store.send(:load_session, @req)
           @data = stringify_keys(session)
           @loaded = true
         end
 
         def stringify_keys(other)
+          # Use transform_keys after dropping Ruby 2.4 support
           hash = {}
-          other.each do |key, value|
+          other.to_hash.each do |key, value|
             hash[key.to_s] = value
           end
           hash
@@ -191,14 +203,14 @@ module Rack
 
       # ID sets up a basic framework for implementing an id based sessioning
       # service. Cookies sent to the client for maintaining sessions will only
-      # contain an id reference. Only #get_session and #set_session are
-      # required to be overwritten.
+      # contain an id reference. Only #find_session, #write_session and
+      # #delete_session are required to be overwritten.
       #
       # All parameters are optional.
       # * :key determines the name of the cookie, by default it is
       #   'rack.session'
       # * :path, :domain, :expire_after, :secure, and :httponly set the related
-      #   cookie options as by Rack::Response#add_cookie
+      #   cookie options as by Rack::Response#set_cookie
       # * :skip will not a set a cookie in the response nor update the session state
       # * :defer will not set a cookie in the response but still update the session
       #   state if it is used with a backend
@@ -209,9 +221,9 @@ module Rack
       #   id will be.
       #
       # These options can be set on a per request basis, at the location of
-      # env['rack.session.options']. Additionally the id of the session can be
-      # found within the options hash at the key :id. It is highly not
-      # recommended to change its value.
+      # <tt>env['rack.session.options']</tt>. Additionally the id of the
+      # session can be found within the options hash at the key :id. It is
+      # highly not recommended to change its value.
       #
       # Is Rack::Utils::Context compatible.
       #
@@ -220,26 +232,27 @@ module Rack
 
       class Persisted
         DEFAULT_OPTIONS = {
-          :key =>           'rack.session',
-          :path =>          '/',
-          :domain =>        nil,
-          :expire_after =>  nil,
-          :secure =>        false,
-          :httponly =>      true,
-          :defer =>         false,
-          :renew =>         false,
-          :sidbits =>       128,
-          :cookie_only =>   true,
-          :secure_random => (::SecureRandom rescue false)
-        }
-
-        attr_reader :key, :default_options
-
-        def initialize(app, options={})
+          key: RACK_SESSION,
+          path: '/',
+          domain: nil,
+          expire_after: nil,
+          secure: false,
+          httponly: true,
+          defer: false,
+          renew: false,
+          sidbits: 128,
+          cookie_only: true,
+          secure_random: ::SecureRandom
+        }.freeze
+
+        attr_reader :key, :default_options, :sid_secure
+
+        def initialize(app, options = {})
           @app = app
           @default_options = self.class::DEFAULT_OPTIONS.merge(options)
           @key = @default_options.delete(:key)
           @cookie_only = @default_options.delete(:cookie_only)
+          @same_site = @default_options.delete(:same_site)
           initialize_sid
         end
 
@@ -247,14 +260,21 @@ module Rack
           context(env)
         end
 
-        def context(env, app=@app)
-          prepare_session(env)
-          status, headers, body = app.call(env)
-          commit_session(env, status, headers, body)
+        def context(env, app = @app)
+          req = make_request env
+          prepare_session(req)
+          status, headers, body = app.call(req.env)
+          res = Rack::Response::Raw.new status, headers
+          commit_session(req, res)
+          [status, headers, body]
         end
 
         private
 
+        def make_request(env)
+          Rack::Request.new env
+        end
+
         def initialize_sid
           @sidbits = @default_options[:sidbits]
           @sid_secure = @default_options[:secure_random]
@@ -278,26 +298,26 @@ module Rack
         # Sets the lazy session at 'rack.session' and places options and session
         # metadata into 'rack.session.options'.
 
-        def prepare_session(env)
-          session_was                  = env[ENV_SESSION_KEY]
-          env[ENV_SESSION_KEY]         = session_class.new(self, env)
-          env[ENV_SESSION_OPTIONS_KEY] = @default_options.dup
-          env[ENV_SESSION_KEY].merge! session_was if session_was
+        def prepare_session(req)
+          session_was               = req.get_header RACK_SESSION
+          session                   = session_class.new(self, req)
+          req.set_header RACK_SESSION, session
+          req.set_header RACK_SESSION_OPTIONS, @default_options.dup
+          session.merge! session_was if session_was
         end
 
         # Extracts the session id from provided cookies and passes it and the
-        # environment to #get_session.
+        # environment to #find_session.
 
-        def load_session(env)
-          sid = current_session_id(env)
-          sid, session = get_session(env, sid)
+        def load_session(req)
+          sid = current_session_id(req)
+          sid, session = find_session(req, sid)
           [sid, session || {}]
         end
 
         # Extract session id from request object.
 
-        def extract_session_id(env)
-          request = Rack::Request.new(env)
+        def extract_session_id(request)
           sid = request.cookies[@key]
           sid ||= request.params[@key] unless @cookie_only
           sid
@@ -305,26 +325,26 @@ module Rack
 
         # Returns the current session id from the SessionHash.
 
-        def current_session_id(env)
-          env[ENV_SESSION_KEY].id
+        def current_session_id(req)
+          req.get_header(RACK_SESSION).id
         end
 
         # Check if the session exists or not.
 
-        def session_exists?(env)
-          value = current_session_id(env)
+        def session_exists?(req)
+          value = current_session_id(req)
           value && !value.empty?
         end
 
         # Session should be committed if it was loaded, any of specific options like :renew, :drop
         # or :expire_after was given and the security permissions match. Skips if skip is given.
 
-        def commit_session?(env, session, options)
+        def commit_session?(req, session, options)
           if options[:skip]
             false
           else
             has_session = loaded_session?(session) || forced_session_update?(session, options)
-            has_session && security_matches?(env, options)
+            has_session && security_matches?(req, options)
           end
         end
 
@@ -340,46 +360,50 @@ module Rack
           options.values_at(:max_age, :renew, :drop, :defer, :expire_after).any?
         end
 
-        def security_matches?(env, options)
+        def security_matches?(request, options)
           return true unless options[:secure]
-          request = Rack::Request.new(env)
           request.ssl?
         end
 
         # Acquires the session from the environment and the session id from
-        # the session options and passes them to #set_session. If successful
+        # the session options and passes them to #write_session. If successful
         # and the :defer option is not true, a cookie will be added to the
         # response with the session's id.
 
-        def commit_session(env, status, headers, body)
-          session = env[ENV_SESSION_KEY]
+        def commit_session(req, res)
+          session = req.get_header RACK_SESSION
           options = session.options
 
           if options[:drop] || options[:renew]
-            session_id = destroy_session(env, session.id || generate_sid, options)
-            return [status, headers, body] unless session_id
+            session_id = delete_session(req, session.id || generate_sid, options)
+            return unless session_id
           end
 
-          return [status, headers, body] unless commit_session?(env, session, options)
+          return unless commit_session?(req, session, options)
 
           session.send(:load!) unless loaded_session?(session)
           session_id ||= session.id
-          session_data = session.to_hash.delete_if { |k,v| v.nil? }
+          session_data = session.to_hash.delete_if { |k, v| v.nil? }
 
-          if not data = set_session(env, session_id, session_data, options)
-            env["rack.errors"].puts("Warning! #{self.class.name} failed to save session. Content dropped.")
+          if not data = write_session(req, session_id, session_data, options)
+            req.get_header(RACK_ERRORS).puts("Warning! #{self.class.name} failed to save session. Content dropped.")
           elsif options[:defer] and not options[:renew]
-            env["rack.errors"].puts("Deferring cookie for #{session_id.public_id}") if $VERBOSE
+            req.get_header(RACK_ERRORS).puts("Deferring cookie for #{session_id}") if $VERBOSE
           else
             cookie = Hash.new
             cookie[:value] = cookie_value(data)
             cookie[:expires] = Time.now + options[:expire_after] if options[:expire_after]
             cookie[:expires] = Time.now + options[:max_age] if options[:max_age]
-            set_cookie(env, headers, cookie.merge!(options))
-          end
 
-          [status, headers, body]
+            if @same_site.respond_to? :call
+              cookie[:same_site] = @same_site.call(req, res)
+            else
+              cookie[:same_site] = @same_site
+            end
+            set_cookie(req, res, cookie.merge!(options))
+          end
         end
+        public :commit_session
 
         def cookie_value(data)
           data
@@ -388,10 +412,10 @@ module Rack
         # Sets the cookie back to the client with session id. We skip the cookie
         # setting if the value didn't change (sid is the same) or expires was given.
 
-        def set_cookie(env, headers, cookie)
-          request = Rack::Request.new(env)
+        def set_cookie(request, res, cookie)
           if request.cookies[@key] != cookie[:value] || cookie[:expires]
-            Utils.set_cookie_header!(headers, @key, cookie)
+            res.set_cookie_header =
+              Utils.add_cookie_to_header(res.set_cookie_header, @key, cookie)
           end
         end
 
@@ -406,23 +430,23 @@ module Rack
         # If nil is provided as the session id, generation of a new valid id
         # should occur within.
 
-        def get_session(env, sid)
-          raise '#get_session not implemented.'
+        def find_session(env, sid)
+          raise '#find_session not implemented.'
         end
 
         # All thread safety and session storage procedures should occur here.
         # Must return the session id if the session was saved successfully, or
         # false if the session could not be saved.
 
-        def set_session(env, sid, session, options)
-          raise '#set_session not implemented.'
+        def write_session(req, sid, session, options)
+          raise '#write_session not implemented.'
         end
 
         # All thread safety and session destroy procedures should occur here.
         # Should return a new session id or nil if options[:drop]
 
-        def destroy_session(env, sid, options)
-          raise '#destroy_session not implemented'
+        def delete_session(req, sid, options)
+          raise '#delete_session not implemented'
         end
       end
 
@@ -469,6 +493,30 @@ module Rack
           end
           super
         end
+
+        # All thread safety and session retrieval procedures should occur here.
+        # Should return [session_id, session].
+        # If nil is provided as the session id, generation of a new valid id
+        # should occur within.
+
+        def find_session(req, sid)
+          get_session req.env, sid
+        end
+
+        # All thread safety and session storage procedures should occur here.
+        # Must return the session id if the session was saved successfully, or
+        # false if the session could not be saved.
+
+        def write_session(req, sid, session, options)
+          set_session req.env, sid, session, options
+        end
+
+        # All thread safety and session destroy procedures should occur here.
+        # Should return a new session id or nil if options[:drop]
+
+        def delete_session(req, sid, options)
+          destroy_session req.env, sid, options
+        end
       end
     end
   end

data/lib/rack/session/cookie.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'openssl'
 require 'zlib'
-require 'rack/request'
-require 'rack/response'
-require 'rack/session/abstract/id'
+require_relative 'abstract/id'
+require 'json'
+require 'base64'
 
 module Rack
 
@@ -48,11 +50,11 @@ module Rack
       # Encode session cookies as Base64
       class Base64
         def encode(str)
-          [str].pack('m')
+          ::Base64.strict_encode64(str)
         end
 
         def decode(str)
-          str.unpack('m').first
+          ::Base64.decode64(str)
         end
 
         # Encode session cookies as Marshaled Base64 data
@@ -71,23 +73,23 @@ module Rack
         # valid JSON composite type, either a Hash or an Array.
         class JSON < Base64
           def encode(obj)
-            super(::Rack::Utils::OkJson.encode(obj))
+            super(::JSON.dump(obj))
           end
 
           def decode(str)
             return unless str
-            ::Rack::Utils::OkJson.decode(super(str)) rescue nil
+            ::JSON.parse(super(str)) rescue nil
           end
         end
 
         class ZipJSON < Base64
           def encode(obj)
-            super(Zlib::Deflate.deflate(::Rack::Utils::OkJson.encode(obj)))
+            super(Zlib::Deflate.deflate(::JSON.dump(obj)))
           end
 
           def decode(str)
             return unless str
-            ::Rack::Utils::OkJson.decode(Zlib::Inflate.inflate(super(str)))
+            ::JSON.parse(Zlib::Inflate.inflate(super(str)))
           rescue
             nil
           end
@@ -102,9 +104,11 @@ module Rack
 
       attr_reader :coder
 
-      def initialize(app, options={})
+      def initialize(app, options = {})
         @secrets = options.values_at(:secret, :old_secret).compact
-        warn <<-MSG unless @secrets.size >= 1
+        @hmac = options.fetch(:hmac, OpenSSL::Digest::SHA1)
+
+        warn <<-MSG unless secure?(options)
         SECURITY WARNING: No secret option provided to Rack::Session::Cookie.
         This poses a security threat. It is strongly recommended that you
         provide a secret to prevent exploits that may be possible from crafted
@@ -113,39 +117,36 @@ module Rack
 
         Called from: #{caller[0]}.
         MSG
-        @coder  = options[:coder] ||= Base64::Marshal.new
-        super(app, options.merge!(:cookie_only => true))
+        @coder = options[:coder] ||= Base64::Marshal.new
+        super(app, options.merge!(cookie_only: true))
       end
 
       private
 
-      def get_session(env, sid)
-        data = unpacked_cookie_data(env)
+      def find_session(req, sid)
+        data = unpacked_cookie_data(req)
         data = persistent_session_id!(data)
         [data["session_id"], data]
       end
 
-      def extract_session_id(env)
-        unpacked_cookie_data(env)["session_id"]
+      def extract_session_id(request)
+        unpacked_cookie_data(request)["session_id"]
       end
 
-      def unpacked_cookie_data(env)
-        env["rack.session.unpacked_cookie_data"] ||= begin
-          request = Rack::Request.new(env)
+      def unpacked_cookie_data(request)
+        request.fetch_header(RACK_SESSION_UNPACKED_COOKIE_DATA) do |k|
           session_data = request.cookies[@key]
 
           if @secrets.size > 0 && session_data
-            digest, session_data = session_data.reverse.split("--", 2)
-            digest.reverse! if digest
-            session_data.reverse! if session_data
+            session_data, _, digest = session_data.rpartition('--')
             session_data = nil unless digest_match?(session_data, digest)
           end
 
-          coder.decode(session_data) || {}
+          request.set_header(k, coder.decode(session_data) || {})
         end
       end
 
-      def persistent_session_id!(data, sid=nil)
+      def persistent_session_id!(data, sid = nil)
         data ||= {}
         data["session_id"] ||= sid || generate_sid
         data
@@ -160,7 +161,7 @@ module Rack
         end
       end
 
-      def set_session(env, session_id, session, options)
+      def write_session(req, session_id, session, options)
         session = session.merge("session_id" => session_id)
         session_data = coder.encode(session)
 
@@ -169,14 +170,14 @@ module Rack
         end
 
         if session_data.size > (4096 - @key.size)
-          env["rack.errors"].puts("Warning! Rack::Session::Cookie data size exceeds 4K.")
+          req.get_header(RACK_ERRORS).puts("Warning! Rack::Session::Cookie data size exceeds 4K.")
           nil
         else
           SessionId.new(session_id, session_data)
         end
       end
 
-      def destroy_session(env, session_id, options)
+      def delete_session(req, session_id, options)
         # Nothing to do here, data is in the client
         generate_sid unless options[:drop]
       end
@@ -189,7 +190,12 @@ module Rack
       end
 
       def generate_hmac(data, secret)
-        OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA1.new, secret, data)
+        OpenSSL::HMAC.hexdigest(@hmac.new, secret, data)
+      end
+
+      def secure?(options)
+        @secrets.size >= 1 ||
+        (options[:coder] && options[:let_coder_handle_secure_encoding])
       end
 
     end