doorkeeper 4.4.3 → 5.5.2

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

@@ -1,11 +1,28 @@
+# frozen_string_literal: true
+
 module Doorkeeper
   module OAuth
     module Helpers
+      # Default Doorkeeper token generator. Follows OAuth RFC and
+      # could be customized using `default_generator_method` in
+      # configuration.
       module UniqueToken
         def self.generate(options = {})
-          generator_method = options.delete(:generator) || SecureRandom.method(:hex)
-          token_size       = options.delete(:size)      || 32
-          generator_method.call(token_size)
+          # Access Token value must be 1*VSCHAR or
+          # 1*( ALPHA / DIGIT / "-" / "." / "_" / "~" / "+" / "/" ) *"="
+          #
+          # @see https://tools.ietf.org/html/rfc6749#appendix-A.12
+          # @see https://tools.ietf.org/html/rfc6750#section-2.1
+          #
+          generator = options.delete(:generator) || SecureRandom.method(default_generator_method)
+          token_size = options.delete(:size) || 32
+          generator.call(token_size)
+        end
+
+        # Generator method for default generator class (SecureRandom)
+        #
+        def self.default_generator_method
+          Doorkeeper.config.default_generator_method
         end
       end
     end

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

@@ -1,11 +1,16 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+
 module Doorkeeper
   module OAuth
     module Helpers
       module URIChecker
         def self.valid?(url)
-          return true if native_uri?(url)
+          return true if oob_uri?(url)
+
           uri = as_uri(url)
-          uri.fragment.nil? && !uri.host.nil? && !uri.scheme.nil?
+          valid_scheme?(uri) && iff_host?(uri) && uri.fragment.nil? && uri.opaque.nil?
         rescue URI::InvalidURIError
           false
         end
@@ -14,16 +19,31 @@ module Doorkeeper
           url = as_uri(url)
           client_url = as_uri(client_url)
 
-          if client_url.query.present?
+          unless client_url.query.nil?
             return false unless query_matches?(url.query, client_url.query)
+
             # Clear out queries so rest of URI can be tested. This allows query
             # params to be in the request but order not mattering.
             client_url.query = nil
           end
+
+          # RFC8252, Paragraph 7.3
+          # @see https://tools.ietf.org/html/rfc8252#section-7.3
+          if loopback_uri?(url) && loopback_uri?(client_url)
+            url.port = nil
+            client_url.port = nil
+          end
+
           url.query = nil
           url == client_url
         end
 
+        def self.loopback_uri?(uri)
+          IPAddr.new(uri.host).loopback?
+        rescue IPAddr::Error
+          false
+        end
+
         def self.valid_for_authorization?(url, client_url)
           valid?(url) && client_url.split.any? { |other_url| matches?(url, other_url) }
         end
@@ -33,14 +53,29 @@ module Doorkeeper
         end
 
         def self.query_matches?(query, client_query)
-          return true if client_query.nil? && query.nil?
+          return true if client_query.blank? && query.blank?
           return false if client_query.nil? || query.nil?
+
           # Will return true independent of query order
-          client_query.split('&').sort == query.split('&').sort
+          client_query.split("&").sort == query.split("&").sort
+        end
+
+        def self.valid_scheme?(uri)
+          return false if uri.scheme.nil?
+
+          %w[localhost].include?(uri.scheme) == false
+        end
+
+        def self.hypertext_scheme?(uri)
+          %w[http https].include?(uri.scheme)
+        end
+
+        def self.iff_host?(uri)
+          !(hypertext_scheme?(uri) && uri.host.nil?)
         end
 
-        def self.native_uri?(url)
-          url == Doorkeeper.configuration.native_redirect_uri
+        def self.oob_uri?(uri)
+          NonStandard::IETF_WG_OAUTH2_OOB_METHODS.include?(uri)
         end
       end
     end

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_request_response.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module OAuth
+    class InvalidRequestResponse < ErrorResponse
+      attr_reader :reason
+
+      def self.from_request(request, attributes = {})
+        new(
+          attributes.merge(
+            state: request.try(:state),
+            redirect_uri: request.try(:redirect_uri),
+            missing_param: request.try(:missing_param),
+            reason: request.try(:invalid_request_reason),
+          ),
+        )
+      end
+
+      def initialize(attributes = {})
+        super(attributes.merge(name: :invalid_request))
+        @missing_param = attributes[:missing_param]
+        @reason = @missing_param.nil? ? attributes[:reason] : :missing_param
+      end
+
+      def status
+        :bad_request
+      end
+
+      def description
+        I18n.translate(
+          reason,
+          scope: %i[doorkeeper errors messages invalid_request],
+          default: :unknown,
+          value: @missing_param,
+        )
+      end
+
+      def redirectable?
+        super && @missing_param != :client_id
+      end
+    end
+  end
+end

data/lib/doorkeeper/oauth/invalid_token_response.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module Doorkeeper
   module OAuth
     class InvalidTokenResponse < ErrorResponse
       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
@@ -20,9 +22,32 @@ module Doorkeeper
         @reason = attributes[:reason] || :unknown
       end
 
+      def status
+        :unauthorized
+      end
+
       def description
-        scope = { scope: %i[doorkeeper errors messages invalid_token] }
-        @description ||= I18n.translate @reason, scope
+        @description ||=
+          I18n.translate(
+            @reason,
+            scope: %i[doorkeeper errors messages invalid_token],
+          )
+      end
+
+      protected
+
+      def exception_class
+        errors_mapping.fetch(reason)
+      end
+
+      private
+
+      def errors_mapping
+        {
+          expired: Doorkeeper::Errors::TokenExpired,
+          revoked: Doorkeeper::Errors::TokenRevoked,
+          unknown: Doorkeeper::Errors::TokenUnknown,
+        }
       end
     end
   end

data/lib/doorkeeper/oauth/nonstandard.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module OAuth
+    class NonStandard
+      # These are not part of the OAuth 2 specification but are still in use by Google
+      # and in some other implementations. Native applications should use one of the
+      # approaches discussed in RFC8252. OOB is 'Out of Band'
+
+      # This value signals to the Google Authorization Server that the authorization
+      # code should be returned in the title bar of the browser, with the page text
+      # prompting the user to copy the code and paste it in the application.
+      # This is useful when the client (such as a Windows application) cannot listen
+      # on an HTTP port without significant client configuration.
+
+      # When you use this value, your application can then detect that the page has loaded, and can
+      # read the title of the HTML page to obtain the authorization code. It is then up to your
+      # application to close the browser window if you want to ensure that the user never sees the
+      # page that contains the authorization code. The mechanism for doing this varies from platform
+      # to platform.
+      #
+      # If your platform doesn't allow you to detect that the page has loaded or read the title of
+      # the page, you can have the user paste the code back to your application, as prompted by the
+      # text in the confirmation page that the OAuth 2.0 server generates.
+      IETF_WG_OAUTH2_OOB = "urn:ietf:wg:oauth:2.0:oob"
+
+      # This is identical to urn:ietf:wg:oauth:2.0:oob, but the text in the confirmation page that
+      # the OAuth 2.0 server generates won't instruct the user to copy the authorization code, but
+      # instead will simply ask the user to close the window.
+      #
+      # This is useful when your application reads the title of the HTML page (by checking window
+      # titles on the desktop, for example) to obtain the authorization code, but can't close the
+      # page on its own.
+      IETF_WG_OAUTH2_OOB_AUTO = "urn:ietf:wg:oauth:2.0:oob:auto"
+
+      IETF_WG_OAUTH2_OOB_METHODS = [IETF_WG_OAUTH2_OOB, IETF_WG_OAUTH2_OOB_AUTO].freeze
+    end
+  end
+end

data/lib/doorkeeper/oauth/password_access_token_request.rb

@@ -1,41 +1,74 @@
+# frozen_string_literal: true
+
 module Doorkeeper
   module OAuth
     class PasswordAccessTokenRequest < BaseRequest
       include OAuth::Helpers
 
-      validate :client,         error: :invalid_client
+      validate :client, error: :invalid_client
+      validate :client_supports_grant_flow, error: :unauthorized_client
       validate :resource_owner, error: :invalid_grant
-      validate :scopes,         error: :invalid_scope
+      validate :scopes, error: :invalid_scope
 
-      attr_accessor :server, :client, :resource_owner, :parameters,
-                    :access_token
+      attr_reader :client, :credentials, :resource_owner, :parameters, :access_token
 
-      def initialize(server, client, resource_owner, parameters = {})
+      def initialize(server, client, credentials, resource_owner, parameters = {})
         @server          = server
         @resource_owner  = resource_owner
         @client          = client
+        @credentials     = credentials
         @parameters      = parameters
         @original_scopes = parameters[:scope]
+        @grant_type      = Doorkeeper::OAuth::PASSWORD
       end
 
       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
-        return true unless @original_scopes.present?
-        ScopeChecker.valid? @original_scopes, server.scopes, client.try(:scopes)
+        return true if scopes.blank?
+
+        ScopeChecker.valid?(
+          scope_str: scopes.to_s,
+          server_scopes: server.scopes,
+          app_scopes: client.try(:scopes),
+          grant_type: grant_type,
+        )
       end
 
       def validate_resource_owner
-        !!resource_owner
+        resource_owner.present?
       end
 
+      # Section 4.3.2. Access Token Request for Resource Owner Password Credentials Grant:
+      #
+      #   If the client type is confidential or the client was issued client credentials (or assigned
+      #   other authentication requirements), the client MUST authenticate with the authorization
+      #   server as described in Section 3.2.1.
+      #
+      #   The authorization server MUST:
+      #
+      #    o  require client authentication for confidential clients or for any  client that was
+      #       issued client credentials (or with other authentication requirements)
+      #
+      #    o  authenticate the client if client authentication is included,
+      #
+      #   @see https://tools.ietf.org/html/rfc6749#section-4.3
+      #
       def validate_client
-        !parameters[:client_id] || !!client
+        if Doorkeeper.config.skip_client_authentication_for_password_grant
+          client.present? || (!parameters[:client_id] && credentials.blank?)
+        else
+          client.present?
+        end
+      end
+
+      def validate_client_supports_grant_flow
+        server_config.allow_grant_flow_for_client?(grant_type, client&.application)
       end
     end
   end

data/lib/doorkeeper/oauth/pre_authorization.rb

@@ -1,23 +1,36 @@
+# frozen_string_literal: true
+
 module Doorkeeper
   module OAuth
     class PreAuthorization
       include Validations
 
-      validate :response_type, error: :unsupported_response_type
+      validate :client_id, error: :invalid_request
       validate :client, error: :invalid_client
-      validate :scopes, error: :invalid_scope
+      validate :client_supports_grant_flow, error: :unauthorized_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 :response_mode, error: :unsupported_response_mode
+      validate :scopes, error: :invalid_scope
+      validate :code_challenge_method, error: :invalid_code_challenge_method
 
-      attr_accessor :server, :client, :response_type, :redirect_uri, :state
-      attr_writer   :scope
+      attr_reader :client, :code_challenge, :code_challenge_method, :missing_param,
+                  :redirect_uri, :resource_owner, :response_type, :state,
+                  :authorization_response_flow, :response_mode
 
-      def initialize(server, client, attrs = {})
-        @server        = server
-        @client        = client
-        @response_type = attrs[:response_type]
-        @redirect_uri  = attrs[:redirect_uri]
-        @scope         = attrs[:scope]
-        @state         = attrs[:state]
+      def initialize(server, parameters = {}, resource_owner = nil)
+        @server                = server
+        @client_id             = parameters[:client_id]
+        @response_type         = parameters[:response_type]
+        @response_mode         = parameters[:response_mode]
+        @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?
@@ -25,44 +38,138 @@ module Doorkeeper
       end
 
       def scopes
-        Scopes.from_string scope
+        Scopes.from_string(scope)
       end
 
       def scope
-        @scope.presence || server.default_scopes.to_s
+        @scope.presence || (server.default_scopes.presence && build_scopes)
       end
 
       def error_response
-        OAuth::ErrorResponse.from_request(self)
+        if error == :invalid_request
+          OAuth::InvalidRequestResponse.from_request(
+            self,
+            response_on_fragment: response_on_fragment?,
+          )
+        else
+          OAuth::ErrorResponse.from_request(self, response_on_fragment: response_on_fragment?)
+        end
+      end
+
+      def as_json(_options = nil)
+        pre_auth_hash
+      end
+
+      def form_post_response?
+        response_mode == "form_post"
       end
 
       private
 
-      def validate_response_type
-        server.authorization_response_types.include? response_type
+      attr_reader :client_id, :server
+
+      def build_scopes
+        client_scopes = client.scopes
+        if client_scopes.blank?
+          server.default_scopes.to_s
+        else
+          (server.default_scopes & client_scopes).to_s
+        end
+      end
+
+      def validate_client_id
+        @missing_param = :client_id if client_id.blank?
+        @missing_param.nil?
       end
 
       def validate_client
-        client.present?
+        @client = OAuth::Client.find(client_id)
+        @client.present?
       end
 
-      def validate_scopes
-        return true unless scope.present?
-        Helpers::ScopeChecker.valid?(
-          scope,
-          server.scopes,
-          client.application.scopes
-        )
+      def validate_client_supports_grant_flow
+        Doorkeeper.config.allow_grant_flow_for_client?(grant_type, client.application)
+      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
 
-      # TODO: test uri should be matched against the client's one
       def validate_redirect_uri
         return false if redirect_uri.blank?
 
         Helpers::URIChecker.valid_for_authorization?(
-          redirect_uri, client.redirect_uri
+          redirect_uri,
+          client.redirect_uri,
+        )
+      end
+
+      def validate_params
+        @missing_param = if response_type.blank?
+                           :response_type
+                         elsif @scope.blank? && server.default_scopes.blank?
+                           :scope
+                         end
+
+        @missing_param.nil?
+      end
+
+      def validate_response_type
+        server.authorization_response_flows.any? do |flow|
+          if flow.matches_response_type?(response_type)
+            @authorization_response_flow = flow
+            true
+          end
+        end
+      end
+
+      def validate_response_mode
+        if response_mode.blank?
+          @response_mode = authorization_response_flow.default_response_mode
+          return true
+        end
+
+        authorization_response_flow.matches_response_mode?(response_mode)
+      end
+
+      def validate_scopes
+        Helpers::ScopeChecker.valid?(
+          scope_str: scope,
+          server_scopes: server.scopes,
+          app_scopes: client.scopes,
+          grant_type: grant_type,
         )
       end
+
+      def validate_code_challenge_method
+        return true unless Doorkeeper.config.access_grant_model.pkce_supported?
+
+        code_challenge.blank? ||
+          (code_challenge_method.present? && code_challenge_method =~ /^plain$|^S256$/)
+      end
+
+      def response_on_fragment?
+        return response_type == "token" if response_mode.nil?
+
+        response_mode == "fragment"
+      end
+
+      def grant_type
+        response_type == "code" ? AUTHORIZATION_CODE : IMPLICIT
+      end
+
+      def pre_auth_hash
+        {
+          client_id: client.uid,
+          redirect_uri: redirect_uri,
+          state: state,
+          response_type: response_type,
+          scope: scope,
+          client_name: client.name,
+          status: I18n.t("doorkeeper.pre_authorization.status"),
+        }
+      end
     end
   end
 end