doorkeeper 4.4.3 → 5.5.2

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module OAuth
+    module Authorization
+      class Context
+        attr_reader :client, :grant_type, :resource_owner, :scopes
+
+        def initialize(**attributes)
+          attributes.each do |name, value|
+            instance_variable_set(:"@#{name}", value) if respond_to?(name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,28 +1,46 @@
+# frozen_string_literal: true
+
 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 access_token_expires_in(server, pre_auth_or_oauth_client)
-            if (expiration = custom_expiration(server, pre_auth_or_oauth_client))
-              expiration
-            else
-              server.access_token_expires_in
-            end
-          end
-
-          private
-
-          def custom_expiration(server, pre_auth_or_oauth_client)
-            oauth_client = if pre_auth_or_oauth_client.respond_to?(:client)
+          def build_context(pre_auth_or_oauth_client, grant_type, scopes, resource_owner)
+            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
                            end
 
-            server.custom_access_token_expires_in.call(oauth_client)
+            Doorkeeper::OAuth::Authorization::Context.new(
+              client: oauth_client,
+              grant_type: grant_type,
+              scopes: scopes,
+              resource_owner: resource_owner,
+            )
+          end
+
+          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
+              configuration.access_token_expires_in
+            end
+          end
+
+          def refresh_token_enabled?(server, context)
+            if server.refresh_token_enabled?.respond_to?(:call)
+              server.refresh_token_enabled?.call(context)
+            else
+              !!server.refresh_token_enabled?
+            end
           end
         end
 
@@ -31,28 +49,44 @@ module Doorkeeper
           @resource_owner = resource_owner
         end
 
-        def issue_token
-          @token ||= AccessToken.find_or_create_for(
+        def issue_token!
+          return @token if defined?(@token)
+
+          context = self.class.build_context(
             pre_auth.client,
-            resource_owner.id,
+            Doorkeeper::OAuth::IMPLICIT,
             pre_auth.scopes,
-            self.class.access_token_expires_in(configuration, pre_auth),
-            false
+            resource_owner,
+          )
+
+          @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
 
-        def native_redirect
+        def oob_redirect
           {
-            controller: 'doorkeeper/token_info',
+            controller: controller,
             action: :show,
-            access_token: token.token
+            access_token: token.plaintext_token,
           }
         end
 
+        def access_token?
+          true
+        end
+
         private
 
-        def configuration
-          Doorkeeper.configuration
+        def controller
+          @controller ||= begin
+            mapping = Doorkeeper::Rails::Routes.mapping[:token_info] || {}
+            mapping[:controllers] || "doorkeeper/token_info"
+          end
         end
       end
     end

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

@@ -1,4 +1,6 @@
-require 'rack/utils'
+# frozen_string_literal: true
+
+require "rack/utils"
 
 module Doorkeeper
   module OAuth
@@ -6,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
 
@@ -21,8 +23,8 @@ module Doorkeeper
           private
 
           def build_query(parameters = {})
-            parameters = parameters.reject { |_, v| v.blank? }
-            Rack::Utils.build_query parameters
+            parameters.reject! { |_, value| value.blank? }
+            Rack::Utils.build_query(parameters)
           end
         end
       end

data/lib/doorkeeper/oauth/authorization_code_request.rb

@@ -1,19 +1,25 @@
+# frozen_string_literal: true
+
 module Doorkeeper
   module OAuth
     class AuthorizationCodeRequest < BaseRequest
-      validate :attributes,   error: :invalid_request
+      validate :params,       error: :invalid_request
       validate :client,       error: :invalid_client
       validate :grant,        error: :invalid_grant
       # @see https://tools.ietf.org/html/rfc6749#section-5.2
       validate :redirect_uri, error: :invalid_grant
+      validate :code_verifier, error: :invalid_grant
 
-      attr_accessor :server, :grant, :client, :redirect_uri, :access_token
+      attr_reader :grant, :client, :redirect_uri, :access_token, :code_verifier,
+                  :invalid_request_reason, :missing_param
 
       def initialize(server, grant, client, parameters = {})
         @server = server
         @client = client
         @grant  = grant
+        @grant_type = Doorkeeper::OAuth::AUTHORIZATION_CODE
         @redirect_uri = parameters[:redirect_uri]
+        @code_verifier = parameters[:code_verifier]
       end
 
       private
@@ -24,33 +30,75 @@ module Doorkeeper
           raise Errors::InvalidGrantReuse if grant.revoked?
 
           grant.revoke
-          find_or_create_access_token(grant.application,
-                                      grant.resource_owner_id,
-                                      grant.scopes,
-                                      server)
+
+          find_or_create_access_token(
+            grant.application,
+            resource_owner,
+            grant.scopes,
+            server,
+          )
         end
+
         super
       end
 
-      def validate_attributes
-        redirect_uri.present?
+      def resource_owner
+        if Doorkeeper.config.polymorphic_resource_owner?
+          grant.resource_owner
+        else
+          grant.resource_owner_id
+        end
+      end
+
+      def pkce_supported?
+        Doorkeeper.config.access_grant_model.pkce_supported?
+      end
+
+      def validate_params
+        @missing_param = if grant&.uses_pkce? && code_verifier.blank?
+                           :code_verifier
+                         elsif redirect_uri.blank?
+                           :redirect_uri
+                         end
+
+        @missing_param.nil?
       end
 
       def validate_client
-        !!client
+        client.present?
       end
 
       def validate_grant
         return false unless grant && grant.application_id == client.id
+
         grant.accessible?
       end
 
       def validate_redirect_uri
         Helpers::URIChecker.valid_for_authorization?(
           redirect_uri,
-          grant.redirect_uri
+          grant.redirect_uri,
         )
       end
+
+      # 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 pkce_supported?
+        return grant.code_challenge.blank? if code_verifier.blank?
+
+        if grant.code_challenge_method == "S256"
+          grant.code_challenge == generate_code_challenge(code_verifier)
+        elsif grant.code_challenge_method == "plain"
+          grant.code_challenge == code_verifier
+        else
+          false
+        end
+      end
+
+      def generate_code_challenge(code_verifier)
+        server_config.access_grant_model.generate_code_challenge(code_verifier)
+      end
     end
   end
 end

data/lib/doorkeeper/oauth/base_request.rb

@@ -1,54 +1,65 @@
+# frozen_string_literal: true
+
 module Doorkeeper
   module OAuth
     class BaseRequest
       include Validations
 
-      def authorize
-        validate
+      attr_reader :grant_type, :server
 
+      delegate :default_scopes, to: :server
+
+      def authorize
         if valid?
           before_successful_response
           @response = TokenResponse.new(access_token)
           after_successful_response
           @response
+        elsif error == :invalid_request
+          @response = InvalidRequestResponse.from_request(self)
         else
           @response = ErrorResponse.from_request(self)
         end
       end
 
       def scopes
-        @scopes ||= if @original_scopes.present?
-                      OAuth::Scopes.from_string(@original_scopes)
-                    else
-                      default_scopes
-                    end
+        @scopes ||= build_scopes
       end
 
-      def default_scopes
-        server.default_scopes
+      def find_or_create_access_token(client, resource_owner, scopes, server)
+        context = Authorization::Token.build_context(client, grant_type, scopes, resource_owner)
+        @access_token = server_config.access_token_model.find_or_create_for(
+          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
 
-      def valid?
-        error.nil?
+      def before_successful_response
+        server_config.before_successful_strategy_response.call(self)
       end
 
-      def find_or_create_access_token(client, resource_owner_id, scopes, server)
-        @access_token = AccessToken.find_or_create_for(
-          client,
-          resource_owner_id,
-          scopes,
-          Authorization::Token.access_token_expires_in(server, client),
-          server.refresh_token_enabled?
-        )
+      def after_successful_response
+        server_config.after_successful_strategy_response.call(self, @response)
       end
 
-      def before_successful_response
-        Doorkeeper.configuration.before_successful_strategy_response.call(self)
+      def server_config
+        Doorkeeper.config
       end
 
-      def after_successful_response
-        Doorkeeper.configuration.after_successful_strategy_response.
-          call(self, @response)
+      private
+
+      def build_scopes
+        if @original_scopes.present?
+          OAuth::Scopes.from_string(@original_scopes)
+        else
+          client_scopes = @client&.scopes
+          return default_scopes if client_scopes.blank?
+
+          default_scopes & client_scopes
+        end
       end
     end
   end

data/lib/doorkeeper/oauth/base_response.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Doorkeeper
   module OAuth
     class BaseResponse

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

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 module Doorkeeper
   module OAuth
     class Client
       Credentials = Struct.new(:uid, :secret) do
         class << self
           def from_request(request, *credentials_methods)
-            credentials_methods.inject(nil) do |credentials, method|
+            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
 
@@ -25,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

@@ -1,9 +1,9 @@
-require 'doorkeeper/oauth/client/credentials'
+# frozen_string_literal: true
 
 module Doorkeeper
   module OAuth
     class Client
-      attr_accessor :application
+      attr_reader :application
 
       delegate :id, :name, :uid, :redirect_uri, :scopes, to: :@application
 
@@ -11,18 +11,17 @@ module Doorkeeper
         @application = application
       end
 
-      def self.find(uid, method = Application.method(:by_uid))
-        if (application = method.call(uid))
-          new(application)
-        end
+      def self.find(uid, method = Doorkeeper.config.application_model.method(:by_uid))
+        return unless (application = method.call(uid))
+
+        new(application)
       end
 
-      def self.authenticate(credentials, method = Application.method(:by_uid_and_secret))
-        return false if credentials.blank?
+      def self.authenticate(credentials, method = Doorkeeper.config.application_model.method(:by_uid_and_secret))
+        return if credentials.blank?
+        return unless (application = method.call(credentials.uid, credentials.secret))
 
-        if (application = method.call(credentials.uid, credentials.secret))
-          new(application)
-        end
+        new(application)
       end
     end
   end

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

@@ -1,11 +1,54 @@
+# frozen_string_literal: true
+
 module Doorkeeper
   module OAuth
-    class ClientCredentialsRequest < BaseRequest
+    module ClientCredentials
       class Creator
         def call(client, scopes, attributes = {})
-          AccessToken.find_or_create_for(
-            client, nil, scopes, attributes[:expires_in],
-            attributes[:use_refresh_token])
+          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?
+          end
+
+          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
+
+        def find_existing_token_for(client, scopes)
+          server_config.access_token_model.matching_token_for(client, nil, scopes)
+        end
+
+        def server_config
+          Doorkeeper.config
         end
       end
     end