doorkeeper 5.0.3 → 5.1.0

data/lib/doorkeeper/models/access_token_mixin.rb

@@ -6,23 +6,25 @@ module Doorkeeper
 
     include OAuth::Helpers
     include Models::Expirable
+    include Models::Reusable
     include Models::Revocable
     include Models::Accessible
     include Models::Orderable
+    include Models::SecretStorable
     include Models::Scopes
 
     module ClassMethods
       # Returns an instance of the Doorkeeper::AccessToken with
-      # specific token value.
+      # specific plain text token value.
       #
       # @param token [#to_s]
-      #   token value (any object that responds to `#to_s`)
+      #   Plain text token value (any object that responds to `#to_s`)
       #
       # @return [Doorkeeper::AccessToken, nil] AccessToken object or nil
       #   if there is no record with such token
       #
       def by_token(token)
-        find_by(token: token.to_s)
+        find_by_plaintext_token(:token, token)
       end
 
       # Returns an instance of the Doorkeeper::AccessToken
@@ -35,7 +37,7 @@ module Doorkeeper
       #   if there is no record with such refresh token
       #
       def by_refresh_token(refresh_token)
-        find_by(refresh_token: refresh_token.to_s)
+        find_by_plaintext_token(:refresh_token, refresh_token)
       end
 
       # Revokes AccessToken records that have not been revoked and associated
@@ -98,9 +100,9 @@ module Doorkeeper
 
         (token_scopes.sort == param_scopes.sort) &&
           Doorkeeper::OAuth::Helpers::ScopeChecker.valid?(
-            param_scopes.to_s,
-            Doorkeeper.configuration.scopes,
-            app_scopes
+            scope_str: param_scopes.to_s,
+            server_scopes: Doorkeeper.configuration.scopes,
+            app_scopes: app_scopes
           )
       end
 
@@ -125,14 +127,14 @@ module Doorkeeper
         if Doorkeeper.configuration.reuse_access_token
           access_token = matching_token_for(application, resource_owner_id, scopes)
 
-          return access_token if access_token && !access_token.expired?
+          return access_token if access_token&.reusable?
         end
 
         create!(
-          application_id:    application.try(:id),
+          application_id: application.try(:id),
           resource_owner_id: resource_owner_id,
-          scopes:            scopes.to_s,
-          expires_in:        expires_in,
+          scopes: scopes.to_s,
+          expires_in: expires_in,
           use_refresh_token: use_refresh_token
         )
       end
@@ -168,6 +170,20 @@ module Doorkeeper
       def last_authorized_token_for(application_id, resource_owner_id)
         authorized_tokens_for(application_id, resource_owner_id).first
       end
+
+      ##
+      # Determines the secret storing transformer
+      # Unless configured otherwise, uses the plain secret strategy
+      def secret_strategy
+        ::Doorkeeper.configuration.token_secret_strategy
+      end
+
+      ##
+      # Determine the fallback storing strategy
+      # Unless configured, there will be no fallback
+      def fallback_secret_strategy
+        ::Doorkeeper.configuration.token_secret_fallback_strategy
+      end
     end
 
     # Access Token type: Bearer.
@@ -175,7 +191,7 @@ module Doorkeeper
     #   The OAuth 2.0 Authorization Framework: Bearer Token Usage
     #
     def token_type
-      'Bearer'
+      "Bearer"
     end
 
     def use_refresh_token?
@@ -188,11 +204,11 @@ module Doorkeeper
     # @return [Hash] hash with token data
     def as_json(_options = {})
       {
-        resource_owner_id:  resource_owner_id,
-        scope:              scopes,
-        expires_in:         expires_in_seconds,
-        application:        { uid: application.try(:uid) },
-        created_at:         created_at.to_i
+        resource_owner_id: resource_owner_id,
+        scope: scopes,
+        expires_in: expires_in_seconds,
+        application: { uid: application.try(:uid) },
+        created_at: created_at.to_i,
       }
     end
 
@@ -219,6 +235,30 @@ module Doorkeeper
       accessible? && includes_scope?(*scopes)
     end
 
+    # We keep a volatile copy of the raw refresh token for initial communication
+    # The stored refresh_token may be mapped and not available in cleartext.
+    def plaintext_refresh_token
+      if secret_strategy.allows_restoring_secrets?
+        secret_strategy.restore_secret(self, :refresh_token)
+      else
+        @raw_refresh_token
+      end
+    end
+
+    # We keep a volatile copy of the raw token for initial communication
+    # The stored refresh_token may be mapped and not available in cleartext.
+    #
+    # Some strategies allow restoring stored secrets (e.g. symmetric encryption)
+    # while hashing strategies do not, so you cannot rely on this value
+    # returning a present value for persisted tokens.
+    def plaintext_token
+      if secret_strategy.allows_restoring_secrets?
+        secret_strategy.restore_secret(self, :token)
+      else
+        @raw_token
+      end
+    end
+
     private
 
     # Generates refresh token with UniqueToken generator.
@@ -226,7 +266,8 @@ module Doorkeeper
     # @return [String] refresh token value
     #
     def generate_refresh_token
-      self.refresh_token = UniqueToken.generate
+      @raw_refresh_token = UniqueToken.generate
+      secret_strategy.store_secret(self, :refresh_token, @raw_refresh_token)
     end
 
     # Generates and sets the token value with the
@@ -242,13 +283,16 @@ module Doorkeeper
     def generate_token
       self.created_at ||= Time.now.utc
 
-      self.token = token_generator.generate(
+      @raw_token = token_generator.generate(
         resource_owner_id: resource_owner_id,
         scopes: scopes,
         application: application,
         expires_in: expires_in,
         created_at: created_at
       )
+
+      secret_strategy.store_secret(self, :token, @raw_token)
+      @raw_token
     end
 
     def token_generator

data/lib/doorkeeper/models/application_mixin.rb

@@ -6,8 +6,10 @@ module Doorkeeper
 
     include OAuth::Helpers
     include Models::Orderable
+    include Models::SecretStorable
     include Models::Scopes
 
+    # :nodoc
     module ClassMethods
       # Returns an instance of the Doorkeeper::Application with
       # specific UID and secret.
@@ -25,7 +27,8 @@ module Doorkeeper
         app = by_uid(uid)
         return unless app
         return app if secret.blank? && !app.confidential?
-        return unless app.secret == secret
+        return unless app.secret_matches?(secret)
+
         app
       end
 
@@ -39,6 +42,20 @@ module Doorkeeper
       def by_uid(uid)
         find_by(uid: uid.to_s)
       end
+
+      ##
+      # Determines the secret storing transformer
+      # Unless configured otherwise, uses the plain secret strategy
+      def secret_strategy
+        ::Doorkeeper.configuration.application_secret_strategy
+      end
+
+      ##
+      # Determine the fallback storing strategy
+      # Unless configured, there will be no fallback
+      def fallback_secret_strategy
+        ::Doorkeeper.configuration.application_secret_fallback_strategy
+      end
     end
 
     # Set an application's valid redirect URIs.
@@ -49,5 +66,30 @@ module Doorkeeper
     def redirect_uri=(uris)
       super(uris.is_a?(Array) ? uris.join("\n") : uris)
     end
+
+    # Check whether the given plain text secret matches our stored secret
+    #
+    # @param input [#to_s] Plain secret provided by user
+    #        (any object that responds to `#to_s`)
+    #
+    # @return [true] Whether the given secret matches the stored secret
+    #                of this application.
+    #
+    def secret_matches?(input)
+      # return false if either is nil, since secure_compare depends on strings
+      # but Application secrets MAY be nil depending on confidentiality.
+      return false if input.nil? || secret.nil?
+
+      # When matching the secret by comparer function, all is well.
+      return true if secret_strategy.secret_matches?(input, secret)
+
+      # When fallback lookup is enabled, ensure applications
+      # with plain secrets can still be found
+      if fallback_secret_strategy
+        fallback_secret_strategy.secret_matches?(input, secret)
+      else
+        false
+      end
+    end
   end
 end

data/lib/doorkeeper/models/concerns/expirable.rb

@@ -17,6 +17,7 @@ module Doorkeeper
       #   or nil if object never expires.
       def expires_in_seconds
         return nil if expires_in.nil?
+
         expires = expires_at - Time.now.utc
         expires_sec = expires.seconds.round(0)
         expires_sec > 0 ? expires_sec : 0
@@ -24,10 +25,11 @@ module Doorkeeper
 
       # Expiration time (date time of creation + TTL).
       #
-      # @return [Time] expiration time in UTC
+      # @return [Time, nil] expiration time in UTC
+      #   or nil if the object never expires.
       #
       def expires_at
-        created_at + expires_in.seconds
+        expires_in && created_at + expires_in.seconds
       end
     end
   end

data/lib/doorkeeper/models/concerns/ownership.rb

@@ -6,12 +6,7 @@ module Doorkeeper
       extend ActiveSupport::Concern
 
       included do
-        belongs_to_options = { polymorphic: true }
-        if defined?(ActiveRecord::Base) && ActiveRecord::VERSION::MAJOR >= 5
-          belongs_to_options[:optional] = true
-        end
-
-        belongs_to :owner, belongs_to_options
+        belongs_to :owner, polymorphic: true, optional: true
         validates :owner, presence: true, if: :validate_owner?
       end
 

data/lib/doorkeeper/models/concerns/reusable.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module Models
+    module Reusable
+      # Indicates whether the object is reusable (i.e. It is not expired and
+      # has not crossed reuse_limit).
+      #
+      # @return [Boolean] true if can be reused and false in other case
+      def reusable?
+        return false if expired?
+        return true unless expires_in
+
+        threshold_limit = 100 - Doorkeeper.configuration.token_reuse_limit
+        expires_in_seconds >= threshold_limit * expires_in / 100
+      end
+    end
+  end
+end

data/lib/doorkeeper/models/concerns/revocable.rb

@@ -25,7 +25,8 @@ module Doorkeeper
       #
       def revoke_previous_refresh_token!
         return unless refresh_token_revoked_on_use?
-        old_refresh_token.revoke if old_refresh_token
+
+        old_refresh_token&.revoke
         update_attribute :previous_refresh_token, ""
       end
 

data/lib/doorkeeper/models/concerns/scopes.rb

@@ -4,7 +4,11 @@ module Doorkeeper
   module Models
     module Scopes
       def scopes
-        OAuth::Scopes.from_string(self[:scopes])
+        OAuth::Scopes.from_string(scopes_string)
+      end
+
+      def scopes=(value)
+        super Array(value).join(" ")
       end
 
       def scopes_string

data/lib/doorkeeper/models/concerns/secret_storable.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module Models
+    ##
+    # Storable finder to provide lookups for input plaintext values which are
+    # mapped to their stored versions (e.g., hashing, encryption) before lookup.
+    module SecretStorable
+      extend ActiveSupport::Concern
+
+      delegate :secret_strategy,
+               :fallback_secret_strategy,
+               to: :class
+
+      # :nodoc
+      module ClassMethods
+        # Compare the given plaintext with the secret
+        #
+        # @param input [String]
+        #   The plain input to compare.
+        #
+        # @param secret [String]
+        #   The secret value to compare with.
+        #
+        # @return [Boolean]
+        #   Whether input matches secret as per the secret strategy
+        #
+        def secret_matches?(input, secret)
+          secret_strategy.secret_matches?(input, secret)
+        end
+
+        # Returns an instance of the Doorkeeper::AccessToken with
+        # specific token value.
+        #
+        # @param attr [Symbol]
+        #   The token attribute we're looking with.
+        #
+        # @param token [#to_s]
+        #   token value (any object that responds to `#to_s`)
+        #
+        # @return [Doorkeeper::AccessToken, nil] AccessToken object or nil
+        #   if there is no record with such token
+        #
+        def find_by_plaintext_token(attr, token)
+          token = token.to_s
+
+          find_by(attr => secret_strategy.transform_secret(token)) ||
+            find_by_fallback_token(attr, token)
+        end
+
+        # Allow looking up previously plain tokens as a fallback
+        # IFF a fallback strategy has been defined
+        #
+        # @param attr [Symbol]
+        #   The token attribute we're looking with.
+        #
+        # @param plain_secret [#to_s]
+        #   plain secret value (any object that responds to `#to_s`)
+        #
+        # @return [Doorkeeper::AccessToken, nil] AccessToken object or nil
+        #   if there is no record with such token
+        #
+        def find_by_fallback_token(attr, plain_secret)
+          return nil unless fallback_secret_strategy
+
+          # Use the previous strategy to look up
+          stored_token = fallback_secret_strategy.transform_secret(plain_secret)
+          find_by(attr => stored_token).tap do |resource|
+            return nil unless resource
+
+            upgrade_fallback_value resource, attr, plain_secret
+          end
+        end
+
+        # Allow implementations in ORMs to replace a plain
+        # value falling back to to avoid it remaining as plain text.
+        #
+        # @param instance
+        #   An instance of this model with a plain value token.
+        #
+        # @param attr
+        #   The secret attribute name to upgrade.
+        #
+        # @param plain_secret
+        #   The plain secret to upgrade.
+        #
+        def upgrade_fallback_value(instance, attr, plain_secret)
+          upgraded = secret_strategy.store_secret(instance, attr, plain_secret)
+          instance.update(attr => upgraded)
+        end
+
+        ##
+        # Determines the secret storing transformer
+        # Unless configured otherwise, uses the plain secret strategy
+        def secret_strategy
+          ::Doorkeeper::SecretStoring::Plain
+        end
+
+        ##
+        # Determine the fallback storing strategy
+        # Unless configured, there will be no fallback
+        def fallback_secret_strategy
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/doorkeeper/oauth/authorization/code.rb

@@ -16,7 +16,7 @@ module Doorkeeper
         end
 
         def native_redirect
-          { action: :show, code: token.token }
+          { action: :show, code: token.plaintext_token }
         end
 
         def configuration
@@ -42,7 +42,7 @@ module Doorkeeper
 
           {
             code_challenge: pre_auth.code_challenge,
-            code_challenge_method: pre_auth.code_challenge_method
+            code_challenge_method: pre_auth.code_challenge_method,
           }
         end
 

data/lib/doorkeeper/oauth/authorization/token.rb

@@ -8,7 +8,9 @@ module Doorkeeper
 
         class << self
           def build_context(pre_auth_or_oauth_client, grant_type, scopes)
-            oauth_client = if pre_auth_or_oauth_client.respond_to?(:client)
+            oauth_client = if pre_auth_or_oauth_client.respond_to?(:application)
+                             pre_auth_or_oauth_client.application
+                           elsif pre_auth_or_oauth_client.respond_to?(:client)
                              pre_auth_or_oauth_client.client
                            else
                              pre_auth_or_oauth_client
@@ -21,11 +23,14 @@ module Doorkeeper
             )
           end
 
-          def access_token_expires_in(server, context)
-            if (expiration = server.custom_access_token_expires_in.call(context))
-              expiration
+          def access_token_expires_in(configuration, context)
+            if configuration.option_defined?(:custom_access_token_expires_in)
+              expiration = configuration.custom_access_token_expires_in.call(context)
+              return nil if expiration == Float::INFINITY
+
+              expiration || configuration.access_token_expires_in
             else
-              server.access_token_expires_in
+              configuration.access_token_expires_in
             end
           end
 
@@ -62,7 +67,7 @@ module Doorkeeper
           {
             controller: controller,
             action: :show,
-            access_token: token.token
+            access_token: token.plaintext_token,
           }
         end
 
@@ -75,7 +80,7 @@ module Doorkeeper
         def controller
           @controller ||= begin
             mapping = Doorkeeper::Rails::Routes.mapping[:token_info] || {}
-            mapping[:controllers] || 'doorkeeper/token_info'
+            mapping[:controllers] || "doorkeeper/token_info"
           end
         end
       end

data/lib/doorkeeper/oauth/authorization/uri_builder.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rack/utils'
+require "rack/utils"
 
 module Doorkeeper
   module OAuth

data/lib/doorkeeper/oauth/authorization_code_request.rb

@@ -43,17 +43,19 @@ module Doorkeeper
       end
 
       def validate_attributes
-        return false if grant && grant.uses_pkce? && code_verifier.blank?
+        return false if grant&.uses_pkce? && code_verifier.blank?
         return false if grant && !grant.pkce_supported? && !code_verifier.blank?
+
         redirect_uri.present?
       end
 
       def validate_client
-        !client.nil?
+        client.present?
       end
 
       def validate_grant
         return false unless grant && grant.application_id == client.id
+
         grant.accessible?
       end
 
@@ -70,9 +72,9 @@ module Doorkeeper
         return true unless grant.uses_pkce? || code_verifier
         return false unless grant.pkce_supported?
 
-        if grant.code_challenge_method == 'S256'
+        if grant.code_challenge_method == "S256"
           grant.code_challenge == AccessGrant.generate_code_challenge(code_verifier)
-        elsif grant.code_challenge_method == 'plain'
+        elsif grant.code_challenge_method == "plain"
           grant.code_challenge == code_verifier
         else
           false

data/lib/doorkeeper/oauth/client.rb

@@ -18,7 +18,7 @@ module Doorkeeper
       end
 
       def self.authenticate(credentials, method = Application.method(:by_uid_and_secret))
-        return false if credentials.blank?
+        return if credentials.blank?
 
         if (application = method.call(credentials.uid, credentials.secret))
           new(application)

data/lib/doorkeeper/oauth/client_credentials/validation.rb

@@ -30,13 +30,14 @@ module Doorkeeper
           application_scopes = if @client.present?
                                  @client.application.scopes
                                else
-                                 ''
+                                 ""
                                end
 
           ScopeChecker.valid?(
-            @request.scopes.to_s,
-            @server.scopes,
-            application_scopes
+            scope_str: @request.scopes.to_s,
+            server_scopes: @server.scopes,
+            app_scopes: application_scopes,
+            grant_type: Doorkeeper::OAuth::CLIENT_CREDENTIALS
           )
         end
       end

data/lib/doorkeeper/oauth/client_credentials_request.rb

@@ -7,7 +7,7 @@ module Doorkeeper
       attr_reader :response
       attr_writer :issuer
 
-      alias_method :error_response, :response
+      alias error_response response
 
       delegate :error, to: :issuer
 

data/lib/doorkeeper/oauth/code_response.rb

@@ -23,7 +23,7 @@ module Doorkeeper
         elsif response_on_fragment
           Authorization::URIBuilder.uri_with_fragment(
             pre_auth.redirect_uri,
-            access_token: auth.token.token,
+            access_token: auth.token.plaintext_token,
             token_type: auth.token.token_type,
             expires_in: auth.token.expires_in_seconds,
             state: pre_auth.state
@@ -31,7 +31,7 @@ module Doorkeeper
         else
           Authorization::URIBuilder.uri_with_query(
             pre_auth.redirect_uri,
-            code: auth.token.token,
+            code: auth.token.plaintext_token,
             state: pre_auth.state
           )
         end

data/lib/doorkeeper/oauth/error_response.rb

@@ -27,12 +27,16 @@ module Doorkeeper
         {
           error: name,
           error_description: description,
-          state: state
+          state: state,
         }.reject { |_, v| v.blank? }
       end
 
       def status
-        :unauthorized
+        if name == :invalid_client
+          :unauthorized
+        else
+          :bad_request
+        end
       end
 
       def redirectable?
@@ -50,10 +54,10 @@ module Doorkeeper
 
       def headers
         {
-          'Cache-Control' => 'no-store',
-          'Pragma' => 'no-cache',
-          'Content-Type' => 'application/json; charset=utf-8',
-          'WWW-Authenticate' => authenticate_info
+          "Cache-Control" => "no-store",
+          "Pragma" => "no-cache",
+          "Content-Type" => "application/json; charset=utf-8",
+          "WWW-Authenticate" => authenticate_info,
         }
       end
 

data/lib/doorkeeper/oauth/forbidden_token_response.rb

@@ -18,7 +18,7 @@ module Doorkeeper
 
       def headers
         headers = super
-        headers.delete 'WWW-Authenticate'
+        headers.delete "WWW-Authenticate"
         headers
       end