doorkeeper 5.3.0 → 5.4.0.rc1

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

@@ -7,9 +7,9 @@ module Doorkeeper
         attr_reader :client, :grant_type, :scopes
 
         def initialize(client, grant_type, scopes)
-          @client     = client
+          @client = client
           @grant_type = grant_type
-          @scopes     = scopes
+          @scopes = scopes
         end
       end
     end

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

@@ -4,7 +4,7 @@ module Doorkeeper
   module OAuth
     module Authorization
       class Token
-        attr_accessor :pre_auth, :resource_owner, :token
+        attr_reader :pre_auth, :resource_owner, :token
 
         class << self
           def build_context(pre_auth_or_oauth_client, grant_type, scopes)
@@ -57,12 +57,12 @@ module Doorkeeper
             pre_auth.scopes,
           )
 
-          @token = configuration.access_token_model.find_or_create_for(
-            pre_auth.client,
-            resource_owner.id,
-            pre_auth.scopes,
-            self.class.access_token_expires_in(configuration, context),
-            false,
+          @token = Doorkeeper.config.access_token_model.find_or_create_for(
+            application: pre_auth.client,
+            resource_owner: resource_owner,
+            scopes: pre_auth.scopes,
+            expires_in: self.class.access_token_expires_in(Doorkeeper.config, context),
+            use_refresh_token: false,
           )
         end
 
@@ -76,10 +76,6 @@ module Doorkeeper
 
         private
 
-        def configuration
-          Doorkeeper.config
-        end
-
         def controller
           @controller ||= begin
             mapping = Doorkeeper::Rails::Routes.mapping[:token_info] || {}

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

@@ -8,9 +8,9 @@ module Doorkeeper
       class URIBuilder
         class << self
           def uri_with_query(url, parameters = {})
-            uri            = URI.parse(url)
+            uri = URI.parse(url)
             original_query = Rack::Utils.parse_query(uri.query)
-            uri.query      = build_query(original_query.merge(parameters))
+            uri.query = build_query(original_query.merge(parameters))
             uri.to_s
           end
 
@@ -23,8 +23,8 @@ module Doorkeeper
           private
 
           def build_query(parameters = {})
-            parameters = parameters.reject { |_, v| v.blank? }
-            Rack::Utils.build_query parameters
+            parameters = parameters.reject { |_, value| value.blank? }
+            Rack::Utils.build_query(parameters)
           end
         end
       end

data/lib/doorkeeper/oauth/authorization_code_request.rb

@@ -11,9 +11,8 @@ module Doorkeeper
       validate :redirect_uri, error: :invalid_grant
       validate :code_verifier, error: :invalid_grant
 
-      attr_accessor :server, :grant, :client, :redirect_uri, :access_token,
-                    :code_verifier
-      attr_reader :invalid_request_reason, :missing_param
+      attr_reader :grant, :client, :redirect_uri, :access_token, :code_verifier,
+                  :invalid_request_reason, :missing_param
 
       def initialize(server, grant, client, parameters = {})
         @server = server
@@ -33,19 +32,30 @@ module Doorkeeper
 
           grant.revoke
 
+          resource_owner = if Doorkeeper.config.polymorphic_resource_owner?
+                             grant.resource_owner
+                           else
+                             grant.resource_owner_id
+                           end
+
           find_or_create_access_token(
             grant.application,
-            grant.resource_owner_id,
+            resource_owner,
             grant.scopes,
             server,
           )
         end
+
         super
       end
 
+      def pkce_supported?
+        Doorkeeper.config.access_grant_model.pkce_supported?
+      end
+
       def validate_pkce_support
         @invalid_request_reason = :not_support_pkce if grant &&
-                                                       !grant.pkce_supported? &&
+                                                       !pkce_supported? &&
                                                        code_verifier.present?
 
         @invalid_request_reason.nil?
@@ -78,11 +88,11 @@ module Doorkeeper
         )
       end
 
-      # if either side (server or client) request pkce, check the verifier
-      # against the DB - if pkce is supported
+      # if either side (server or client) request PKCE, check the verifier
+      # against the DB - if PKCE is supported
       def validate_code_verifier
         return true unless grant.uses_pkce? || code_verifier
-        return false unless grant.pkce_supported?
+        return false unless pkce_supported?
 
         if grant.code_challenge_method == "S256"
           grant.code_challenge == generate_code_challenge(code_verifier)

data/lib/doorkeeper/oauth/base_request.rb

@@ -5,11 +5,11 @@ module Doorkeeper
     class BaseRequest
       include Validations
 
-      attr_reader :grant_type
+      attr_reader :grant_type, :server
 
-      def authorize
-        validate
+      delegate :default_scopes, to: :server
 
+      def authorize
         if valid?
           before_successful_response
           @response = TokenResponse.new(access_token)
@@ -26,22 +26,14 @@ module Doorkeeper
         @scopes ||= build_scopes
       end
 
-      def default_scopes
-        server.default_scopes
-      end
-
-      def valid?
-        error.nil?
-      end
-
-      def find_or_create_access_token(client, resource_owner_id, scopes, server)
+      def find_or_create_access_token(client, resource_owner, scopes, server)
         context = Authorization::Token.build_context(client, grant_type, scopes)
         @access_token = server_config.access_token_model.find_or_create_for(
-          client,
-          resource_owner_id,
-          scopes,
-          Authorization::Token.access_token_expires_in(server, context),
-          Authorization::Token.refresh_token_enabled?(server, context),
+          application: client,
+          resource_owner: resource_owner,
+          scopes: scopes,
+          expires_in: Authorization::Token.access_token_expires_in(server, context),
+          use_refresh_token: Authorization::Token.refresh_token_enabled?(server, context),
         )
       end
 
@@ -63,10 +55,10 @@ module Doorkeeper
         if @original_scopes.present?
           OAuth::Scopes.from_string(@original_scopes)
         else
-          client_scopes = @client.try(:scopes)
+          client_scopes = @client&.scopes
           return default_scopes if client_scopes.blank?
 
-          default_scopes & @client.scopes
+          default_scopes & client_scopes
         end
       end
     end

data/lib/doorkeeper/oauth/client/credentials.rb

@@ -9,7 +9,7 @@ module Doorkeeper
             credentials_methods.inject(nil) do |_, method|
               method = self.method(method) if method.is_a?(Symbol)
               credentials = Credentials.new(*method.call(request))
-              break credentials unless credentials.blank?
+              break credentials if credentials.present?
             end
           end
 
@@ -27,9 +27,7 @@ module Doorkeeper
 
         # Public clients may have their secret blank, but "credentials" are
         # still present
-        def blank?
-          uid.blank?
-        end
+        delegate :blank?, to: :uid
       end
     end
   end

data/lib/doorkeeper/oauth/client.rb

@@ -3,7 +3,7 @@
 module Doorkeeper
   module OAuth
     class Client
-      attr_accessor :application
+      attr_reader :application
 
       delegate :id, :name, :uid, :redirect_uri, :scopes, to: :@application
 

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

@@ -2,24 +2,42 @@
 
 module Doorkeeper
   module OAuth
-    class ClientCredentialsRequest < BaseRequest
+    module ClientCredentials
       class Creator
         def call(client, scopes, attributes = {})
+          existing_token = nil
+
           if lookup_existing_token?
             existing_token = find_existing_token_for(client, scopes)
             return existing_token if server_config.reuse_access_token && existing_token&.reusable?
-
-            existing_token&.revoke if server_config.revoke_previous_client_credentials_token
           end
 
-          server_config.access_token_model.find_or_create_for(
-            client, nil, scopes, attributes[:expires_in],
-            attributes[:use_refresh_token],
-          )
+          with_revocation(existing_token: existing_token) do
+            server_config.access_token_model.find_or_create_for(
+              application: client,
+              resource_owner: nil,
+              scopes: scopes,
+              **attributes,
+            )
+          end
         end
 
         private
 
+        def with_revocation(existing_token:)
+          if existing_token && server_config.revoke_previous_client_credentials_token
+            existing_token.with_lock do
+              raise Errors::DoorkeeperError, :invalid_token_reuse if existing_token.revoked?
+
+              existing_token.revoke
+
+              yield
+            end
+          else
+            yield
+          end
+        end
+
         def lookup_existing_token?
           server_config.reuse_access_token || server_config.revoke_previous_client_credentials_token
         end

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

@@ -2,9 +2,9 @@
 
 module Doorkeeper
   module OAuth
-    class ClientCredentialsRequest < BaseRequest
+    module ClientCredentials
       class Issuer
-        attr_accessor :token, :validator, :error
+        attr_reader :token, :validator, :error
 
         def initialize(server, validator)
           @server = server
@@ -19,6 +19,7 @@ module Doorkeeper
             @token = false
             @error = validator.error
           end
+
           @token
         end
 

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

@@ -2,7 +2,7 @@
 
 module Doorkeeper
   module OAuth
-    class ClientCredentialsRequest < BaseRequest
+    module ClientCredentials
       class Validator
         include Validations
         include OAuth::Helpers

data/lib/doorkeeper/oauth/client_credentials_request.rb

@@ -3,18 +3,12 @@
 module Doorkeeper
   module OAuth
     class ClientCredentialsRequest < BaseRequest
-      attr_accessor :server, :client, :original_scopes
-      attr_reader :response
-      attr_writer :issuer
+      attr_reader :client, :original_scopes, :response
 
       alias error_response response
 
       delegate :error, to: :issuer
 
-      def issuer
-        @issuer ||= Issuer.new(server, Validator.new(server, self))
-      end
-
       def initialize(server, client, parameters = {})
         @client = client
         @server = server
@@ -26,6 +20,13 @@ module Doorkeeper
         issuer.token
       end
 
+      def issuer
+        @issuer ||= ClientCredentials::Issuer.new(
+          server,
+          ClientCredentials::Validator.new(server, self),
+        )
+      end
+
       private
 
       def valid?

data/lib/doorkeeper/oauth/code_request.rb

@@ -3,7 +3,7 @@
 module Doorkeeper
   module OAuth
     class CodeRequest
-      attr_accessor :pre_auth, :resource_owner
+      attr_reader :pre_auth, :resource_owner
 
       def initialize(pre_auth, resource_owner)
         @pre_auth       = pre_auth

data/lib/doorkeeper/oauth/code_response.rb

@@ -5,7 +5,7 @@ module Doorkeeper
     class CodeResponse < BaseResponse
       include OAuth::Helpers
 
-      attr_accessor :pre_auth, :auth, :response_on_fragment
+      attr_reader :pre_auth, :auth, :response_on_fragment
 
       def initialize(pre_auth, auth, options = {})
         @pre_auth = pre_auth
@@ -17,8 +17,12 @@ module Doorkeeper
         true
       end
 
+      def issued_token
+        auth.token
+      end
+
       def redirect_uri
-        if URIChecker.oob_uri? pre_auth.redirect_uri
+        if URIChecker.oob_uri?(pre_auth.redirect_uri)
           auth.oob_redirect
         elsif response_on_fragment
           Authorization::URIBuilder.uri_with_fragment(

data/lib/doorkeeper/oauth/error_response.rb

@@ -67,10 +67,8 @@ module Doorkeeper
 
       protected
 
-      delegate :realm, to: :configuration
-
-      def configuration
-        Doorkeeper.config
+      def realm
+        Doorkeeper.config.realm
       end
 
       def exception_class

data/lib/doorkeeper/oauth/helpers/scope_checker.rb

@@ -27,11 +27,7 @@ module Doorkeeper
           private
 
           def valid_scopes(server_scopes, app_scopes)
-            if app_scopes.present?
-              app_scopes
-            else
-              server_scopes
-            end
+            app_scopes.presence || server_scopes
           end
 
           def permitted_to_grant_type?

data/lib/doorkeeper/oauth/hooks/context.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module OAuth
+    module Hooks
+      class Context
+        attr_reader :auth, :pre_auth
+
+        def initialize(**attributes)
+          attributes.each do |name, value|
+            instance_variable_set(:"@#{name}", value) if respond_to?(name)
+          end
+        end
+
+        def issued_token
+          auth&.issued_token
+        end
+      end
+    end
+  end
+end

data/lib/doorkeeper/oauth/invalid_token_response.rb

@@ -6,9 +6,9 @@ module Doorkeeper
       attr_reader :reason
 
       def self.from_access_token(access_token, attributes = {})
-        reason = if access_token.try(:revoked?)
+        reason = if access_token&.revoked?
                    :revoked
-                 elsif access_token.try(:expired?)
+                 elsif access_token&.expired?
                    :expired
                  else
                    :unknown

data/lib/doorkeeper/oauth/password_access_token_request.rb

@@ -10,8 +10,7 @@ module Doorkeeper
       validate :resource_owner, error: :invalid_grant
       validate :scopes, error: :invalid_scope
 
-      attr_accessor :server, :client, :resource_owner, :parameters,
-                    :access_token
+      attr_reader :client, :resource_owner, :parameters, :access_token
 
       def initialize(server, client, resource_owner, parameters = {})
         @server          = server
@@ -25,18 +24,17 @@ module Doorkeeper
       private
 
       def before_successful_response
-        find_or_create_access_token(client, resource_owner.id, scopes, server)
+        find_or_create_access_token(client, resource_owner, scopes, server)
         super
       end
 
       def validate_scopes
-        client_scopes = client.try(:scopes)
         return true if scopes.blank?
 
         ScopeChecker.valid?(
           scope_str: scopes.to_s,
           server_scopes: server.scopes,
-          app_scopes: client_scopes,
+          app_scopes: client.try(:scopes),
           grant_type: grant_type,
         )
       end

data/lib/doorkeeper/oauth/pre_authorization.rb

@@ -5,39 +5,37 @@ module Doorkeeper
     class PreAuthorization
       include Validations
 
-      validate :client_id,             error: :invalid_request
-      validate :client,                error: :invalid_client
-      validate :redirect_uri,          error: :invalid_redirect_uri
-      validate :params,                error: :invalid_request
-      validate :response_type,         error: :unsupported_response_type
-      validate :scopes,                error: :invalid_scope
+      validate :client_id, error: :invalid_request
+      validate :client, error: :invalid_client
+      validate :resource_owner_authorize_for_client, error: :invalid_client
+      validate :redirect_uri, error: :invalid_redirect_uri
+      validate :params, error: :invalid_request
+      validate :response_type, error: :unsupported_response_type
+      validate :scopes, error: :invalid_scope
       validate :code_challenge_method, error: :invalid_code_challenge_method
       validate :client_supports_grant_flow, error: :unauthorized_client
 
       attr_reader :server, :client_id, :client, :redirect_uri, :response_type, :state,
-                  :code_challenge, :code_challenge_method, :missing_param
+                  :code_challenge, :code_challenge_method, :missing_param, :resource_owner
 
-      def initialize(server, attrs = {})
+      def initialize(server, parameters = {}, resource_owner = nil)
         @server                = server
-        @client_id             = attrs[:client_id]
-        @response_type         = attrs[:response_type]
-        @redirect_uri          = attrs[:redirect_uri]
-        @scope                 = attrs[:scope]
-        @state                 = attrs[:state]
-        @code_challenge        = attrs[:code_challenge]
-        @code_challenge_method = attrs[:code_challenge_method]
+        @client_id             = parameters[:client_id]
+        @response_type         = parameters[:response_type]
+        @redirect_uri          = parameters[:redirect_uri]
+        @scope                 = parameters[:scope]
+        @state                 = parameters[:state]
+        @code_challenge        = parameters[:code_challenge]
+        @code_challenge_method = parameters[:code_challenge_method]
+        @resource_owner        = resource_owner
       end
 
       def authorizable?
         valid?
       end
 
-      def validate_client_supports_grant_flow
-        Doorkeeper.config.allow_grant_flow_for_client?(grant_type, client.application)
-      end
-
       def scopes
-        Scopes.from_string scope
+        Scopes.from_string(scope)
       end
 
       def scope
@@ -55,9 +53,7 @@ module Doorkeeper
         end
       end
 
-      def as_json(attributes = {})
-        return pre_auth_hash.merge(attributes.to_h) if attributes.respond_to?(:to_h)
-
+      def as_json(_options = nil)
         pre_auth_hash
       end
 
@@ -83,6 +79,10 @@ module Doorkeeper
         @client.present?
       end
 
+      def validate_client_supports_grant_flow
+        Doorkeeper.config.allow_grant_flow_for_client?(grant_type, client.application)
+      end
+
       def validate_redirect_uri
         return false if redirect_uri.blank?
 
@@ -115,19 +115,24 @@ module Doorkeeper
         )
       end
 
-      def grant_type
-        response_type == "code" ? AUTHORIZATION_CODE : IMPLICIT
-      end
-
       def validate_code_challenge_method
         code_challenge.blank? ||
           (code_challenge_method.present? && code_challenge_method =~ /^plain$|^S256$/)
       end
 
+      def validate_resource_owner_authorize_for_client
+        # The `authorize_resource_owner_for_client` config option is used for this validation
+        client.application.authorized_for_resource_owner?(@resource_owner)
+      end
+
       def response_on_fragment?
         response_type == "token"
       end
 
+      def grant_type
+        response_type == "code" ? AUTHORIZATION_CODE : IMPLICIT
+      end
+
       def pre_auth_hash
         {
           client_id: client.uid,

data/lib/doorkeeper/oauth/refresh_token_request.rb

@@ -11,9 +11,8 @@ module Doorkeeper
       validate :client_match, error: :invalid_grant
       validate :scope,        error: :invalid_scope
 
-      attr_accessor :access_token, :client, :credentials, :refresh_token,
-                    :server
-      attr_reader   :missing_param
+      attr_reader :access_token, :client, :credentials, :refresh_token
+      attr_reader :missing_param
 
       def initialize(server, refresh_token, credentials, parameters = {})
         @server = server
@@ -50,30 +49,27 @@ module Doorkeeper
       end
 
       def create_access_token
-        @access_token = server_config.access_token_model.create!(access_token_attributes)
-      end
+        attributes = {}
 
-      def access_token_attributes
-        {
-          application_id: refresh_token.application_id,
-          resource_owner_id: refresh_token.resource_owner_id,
-          scopes: scopes.to_s,
-          expires_in: access_token_expires_in,
-          use_refresh_token: true,
-        }.tap do |attributes|
-          if refresh_token_revoked_on_use?
-            attributes[:previous_refresh_token] = refresh_token.refresh_token
+        resource_owner =
+          if Doorkeeper.config.polymorphic_resource_owner?
+            refresh_token.resource_owner
+          else
+            refresh_token.resource_owner_id
           end
+
+        if refresh_token_revoked_on_use?
+          attributes[:previous_refresh_token] = refresh_token.refresh_token
         end
-      end
 
-      def access_token_expires_in
-        context = Authorization::Token.build_context(
-          client,
-          Doorkeeper::OAuth::REFRESH_TOKEN,
-          scopes,
+        @access_token = server_config.access_token_model.create_for(
+          application: refresh_token.application,
+          resource_owner: resource_owner,
+          scopes: scopes,
+          expires_in: refresh_token.expires_in,
+          use_refresh_token: true,
+          **attributes,
         )
-        Authorization::Token.access_token_expires_in(server, context)
       end
 
       def validate_token_presence

data/lib/doorkeeper/oauth/token.rb

@@ -8,7 +8,7 @@ module Doorkeeper
           methods.inject(nil) do |_, method|
             method = self.method(method) if method.is_a?(Symbol)
             credentials = method.call(request)
-            break credentials unless credentials.blank?
+            break credentials if credentials.present?
           end
         end
 

data/lib/doorkeeper/oauth/token_introspection.rb

@@ -6,9 +6,6 @@ module Doorkeeper
     #
     # @see https://tools.ietf.org/html/rfc7662
     class TokenIntrospection
-      attr_reader :server, :token
-      attr_reader :error, :invalid_request_reason
-
       def initialize(server, token)
         @server = server
         @token = token
@@ -38,6 +35,9 @@ module Doorkeeper
 
       private
 
+      attr_reader :server, :token
+      attr_reader :error, :invalid_request_reason
+
       # If the protected resource uses OAuth 2.0 client credentials to
       # authenticate to the introspection endpoint and its credentials are
       # invalid, the authorization server responds with an HTTP 401