doorkeeper 4.2.0 → 5.6.8

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

@@ -1,27 +1,31 @@
+# frozen_string_literal: true
+
+require "rack/utils"
+
 module Doorkeeper
   module OAuth
     module Authorization
-      module URIBuilder
-        include Rack::Utils
+      class URIBuilder
+        class << self
+          def uri_with_query(url, parameters = {})
+            uri = URI.parse(url)
+            original_query = Rack::Utils.parse_query(uri.query)
+            uri.query = build_query(original_query.merge(parameters))
+            uri.to_s
+          end
 
-        extend self
+          def uri_with_fragment(url, parameters = {})
+            uri = URI.parse(url)
+            uri.fragment = build_query(parameters)
+            uri.to_s
+          end
 
-        def uri_with_query(url, parameters = {})
-          uri            = URI.parse(url)
-          original_query = parse_query(uri.query)
-          uri.query      = build_query(original_query.merge(parameters))
-          uri.to_s
-        end
-
-        def uri_with_fragment(url, parameters = {})
-          uri = URI.parse(url)
-          uri.fragment = build_query(parameters)
-          uri.to_s
-        end
+          private
 
-        def build_query(parameters = {})
-          parameters = parameters.reject { |_, v| v.blank? }
-          super parameters
+          def build_query(parameters = {})
+            parameters.reject! { |_, value| value.blank? }
+            Rack::Utils.build_query(parameters)
+          end
         end
       end
     end

data/lib/doorkeeper/oauth/authorization_code_request.rb

@@ -1,21 +1,25 @@
+# frozen_string_literal: true
+
 module Doorkeeper
   module OAuth
-    class AuthorizationCodeRequest
-      include Validations
-      include OAuth::RequestConcern
-
-      validate :attributes,   error: :invalid_request
-      validate :client,       error: :invalid_client
-      validate :grant,        error: :invalid_grant
-      validate :redirect_uri, error: :invalid_grant
+    class AuthorizationCodeRequest < BaseRequest
+      validate :params,       error: Errors::InvalidRequest
+      validate :client,       error: Errors::InvalidClient
+      validate :grant,        error: Errors::InvalidGrant
+      # @see https://datatracker.ietf.org/doc/html/rfc6749#section-5.2
+      validate :redirect_uri, error: Errors::InvalidGrant
+      validate :code_verifier, error: Errors::InvalidGrant
 
-      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
@@ -26,28 +30,84 @@ 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(
+            client,
+            resource_owner,
+            grant.scopes,
+            custom_token_attributes_with_data,
+            server,
+          )
+        end
+
+        super
+      end
+
+      def resource_owner
+        if Doorkeeper.config.polymorphic_resource_owner?
+          grant.resource_owner
+        else
+          grant.resource_owner_id
         end
       end
 
-      def validate_attributes
-        redirect_uri.present?
+      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
-        grant.redirect_uri == redirect_uri
+        Helpers::URIChecker.valid_for_authorization?(
+          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)
+        Doorkeeper.config.access_grant_model.generate_code_challenge(code_verifier)
+      end
+
+      def custom_token_attributes_with_data
+        grant
+          .attributes
+          .with_indifferent_access
+          .slice(*Doorkeeper.config.custom_access_token_attributes)
+          .symbolize_keys
       end
     end
   end

data/lib/doorkeeper/oauth/base_request.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module OAuth
+    class BaseRequest
+      include Validations
+
+      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 == Errors::InvalidRequest
+          @response = InvalidRequestResponse.from_request(self)
+        else
+          @response = ErrorResponse.from_request(self)
+        end
+      end
+
+      def scopes
+        @scopes ||= build_scopes
+      end
+
+      def find_or_create_access_token(client, resource_owner, scopes, custom_attributes, server)
+        context = Authorization::Token.build_context(client, grant_type, scopes, resource_owner)
+        application = client.is_a?(Doorkeeper.config.application_model) ? client : client&.application
+
+        token_attributes = {
+          application: application,
+          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),
+        }
+
+        @access_token =
+          Doorkeeper.config.access_token_model.find_or_create_for(**token_attributes.merge(custom_attributes))
+      end
+
+      def before_successful_response
+        Doorkeeper.config.before_successful_strategy_response.call(self)
+      end
+
+      def after_successful_response
+        Doorkeeper.config.after_successful_strategy_response.call(self, @response)
+      end
+
+      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
+end

data/lib/doorkeeper/oauth/base_response.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module OAuth
+    class BaseResponse
+      def body
+        {}
+      end
+
+      def description
+        ""
+      end
+
+      def headers
+        {}
+      end
+
+      def redirectable?
+        false
+      end
+
+      def redirect_uri
+        ""
+      end
+
+      def status
+        :ok
+      end
+    end
+  end
+end

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

@@ -1,20 +1,33 @@
+# frozen_string_literal: true
+
 module Doorkeeper
   module OAuth
     class Client
-      class Credentials < Struct.new(:uid, :secret)
-        extend Methods
+      Credentials = Struct.new(:uid, :secret) do
+        class << self
+          def from_request(request, *credentials_methods)
+            credentials_methods.inject(nil) do |_, method|
+              method = self.method(method) if method.is_a?(Symbol)
+              credentials = Credentials.new(*method.call(request))
+              break credentials if credentials.present?
+            end
+          end
 
-        def self.from_request(request, *credentials_methods)
-          credentials_methods.inject(nil) do |credentials, method|
-            method = self.method(method) if method.is_a?(Symbol)
-            credentials = Credentials.new(*method.call(request))
-            break credentials unless credentials.blank?
+          def from_params(request)
+            request.parameters.values_at(:client_id, :client_secret)
           end
-        end
 
-        def blank?
-          uid.blank? || secret.blank?
+          def from_basic(request)
+            authorization = request.authorization
+            if authorization.present? && authorization =~ /^Basic (.*)/m
+              Base64.decode64(Regexp.last_match(1)).split(/:/, 2)
+            end
+          end
         end
+
+        # Public clients may have their secret blank, but "credentials" are
+        # still present
+        delegate :blank?, to: :uid
       end
     end
   end

data/lib/doorkeeper/oauth/client.rb

@@ -1,10 +1,9 @@
-require 'doorkeeper/oauth/client/methods'
-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
 
@@ -12,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,51 @@
+# frozen_string_literal: true
+
 module Doorkeeper
   module OAuth
-    class ClientCredentialsRequest
+    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_active_existing_token_for(client, scopes)
+            return existing_token if Doorkeeper.config.reuse_access_token && existing_token&.reusable?
+          end
+
+          with_revocation(existing_token: existing_token) do
+            application = client.is_a?(Doorkeeper.config.application_model) ? client : client&.application
+            Doorkeeper.config.access_token_model.create_for(
+              application: application,
+              resource_owner: nil,
+              scopes: scopes,
+              **attributes,
+            )
+          end
+        end
+
+        private
+
+        def with_revocation(existing_token:)
+          if existing_token && Doorkeeper.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?
+          Doorkeeper.config.reuse_access_token ||
+            Doorkeeper.config.revoke_previous_client_credentials_token?
+        end
+
+        def find_active_existing_token_for(client, scopes)
+          Doorkeeper.config.access_token_model.matching_token_for(client, nil, scopes, include_expired: false)
         end
       end
     end

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

@@ -1,37 +1,45 @@
-require 'doorkeeper/oauth/client_credentials/validation'
+# frozen_string_literal: true
 
 module Doorkeeper
   module OAuth
-    class ClientCredentialsRequest
+    module ClientCredentials
       class Issuer
-        attr_accessor :token, :validation, :error
+        attr_reader :token, :validator, :error
 
-        def initialize(server, validation)
+        def initialize(server, validator)
           @server = server
-          @validation = validation
+          @validator = validator
         end
 
-        def create(client, scopes, creator = Creator.new)
-          if validation.valid?
-            @token = create_token(client, scopes, creator)
-            @error = :server_error unless @token
+        def create(client, scopes, attributes = {}, creator = Creator.new)
+          if validator.valid?
+            @token = create_token(client, scopes, attributes, creator)
+            @error = Errors::ServerError unless @token
           else
             @token = false
-            @error = validation.error
+            @error = validator.error
           end
+
           @token
         end
 
         private
 
-        def create_token(client, scopes, creator)
-          ttl = Authorization::Token.access_token_expires_in(@server, client)
+        def create_token(client, scopes, attributes, creator)
+          context = Authorization::Token.build_context(
+            client,
+            Doorkeeper::OAuth::CLIENT_CREDENTIALS,
+            scopes,
+            nil,
+          )
+          ttl = Authorization::Token.access_token_expires_in(@server, context)
 
           creator.call(
             client,
             scopes,
             use_refresh_token: false,
-            expires_in: ttl
+            expires_in: ttl,
+            **attributes
           )
         end
       end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module OAuth
+    module ClientCredentials
+      class Validator
+        include Validations
+        include OAuth::Helpers
+
+        validate :client, error: Errors::InvalidClient
+        validate :client_supports_grant_flow, error: Errors::UnauthorizedClient
+        validate :scopes, error: Errors::InvalidScope
+
+        def initialize(server, request)
+          @server = server
+          @request = request
+          @client = request.client
+
+          validate
+        end
+
+        private
+
+        def validate_client
+          @client.present?
+        end
+
+        def validate_client_supports_grant_flow
+          return if @client.blank?
+
+          Doorkeeper.config.allow_grant_flow_for_client?(
+            Doorkeeper::OAuth::CLIENT_CREDENTIALS,
+            @client.application,
+          )
+        end
+
+        def validate_scopes
+          application_scopes = if @client.present?
+                                 @client.application.scopes
+                               else
+                                 ""
+                               end
+          return true if @request.scopes.blank? && application_scopes.blank?
+
+          ScopeChecker.valid?(
+            scope_str: @request.scopes.to_s,
+            server_scopes: @server.scopes,
+            app_scopes: application_scopes,
+            grant_type: Doorkeeper::OAuth::CLIENT_CREDENTIALS,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/doorkeeper/oauth/client_credentials_request.rb

@@ -1,40 +1,44 @@
-require 'doorkeeper/oauth/client_credentials/creator'
-require 'doorkeeper/oauth/client_credentials/issuer'
-require 'doorkeeper/oauth/client_credentials/validation'
+# frozen_string_literal: true
 
 module Doorkeeper
   module OAuth
-    class ClientCredentialsRequest
-      include Validations
-      include OAuth::RequestConcern
+    class ClientCredentialsRequest < BaseRequest
+      attr_reader :client, :original_scopes, :parameters, :response
 
-      attr_accessor :server, :client, :original_scopes
-      attr_reader :response
-      attr_writer :issuer
-
-      alias_method :error_response, :response
+      alias error_response response
 
       delegate :error, to: :issuer
 
-      def issuer
-        @issuer ||= Issuer.new(server, Validation.new(server, self))
-      end
-
       def initialize(server, client, parameters = {})
         @client = client
         @server = server
         @response = nil
         @original_scopes = parameters[:scope]
+        @parameters = parameters.except(:scope)
       end
 
       def access_token
         issuer.token
       end
 
+      def issuer
+        @issuer ||= ClientCredentials::Issuer.new(
+          server,
+          ClientCredentials::Validator.new(server, self),
+        )
+      end
+
       private
 
       def valid?
-        issuer.create(client, scopes)
+        issuer.create(client, scopes, custom_token_attributes_with_data)
+      end
+
+      def custom_token_attributes_with_data
+        parameters
+          .with_indifferent_access
+          .slice(*Doorkeeper.config.custom_access_token_attributes)
+          .symbolize_keys
       end
     end
   end

data/lib/doorkeeper/oauth/code_request.rb

@@ -1,28 +1,24 @@
+# frozen_string_literal: true
+
 module Doorkeeper
   module OAuth
     class CodeRequest
-      attr_accessor :pre_auth, :resource_owner, :client
+      attr_reader :pre_auth, :resource_owner
 
       def initialize(pre_auth, resource_owner)
-        @pre_auth       = pre_auth
-        @client         = pre_auth.client
+        @pre_auth = pre_auth
         @resource_owner = resource_owner
       end
 
       def authorize
-        if pre_auth.authorizable?
-          auth = Authorization::Code.new(pre_auth, resource_owner)
-          auth.issue_token
-          @response = CodeResponse.new pre_auth, auth
-        else
-          @response = ErrorResponse.from_request pre_auth
-        end
+        auth = Authorization::Code.new(pre_auth, resource_owner)
+        auth.issue_token!
+        CodeResponse.new(pre_auth, auth, response_on_fragment: pre_auth.response_mode == "fragment")
       end
 
       def deny
-        pre_auth.error = :access_denied
-        ErrorResponse.from_request pre_auth,
-                                   redirect_uri: pre_auth.redirect_uri
+        pre_auth.error = Errors::AccessDenied
+        pre_auth.error_response
       end
     end
   end