doorkeeper 4.2.6 → 5.0.0.rc1

data/lib/doorkeeper/models/access_token_mixin.rb

@@ -6,32 +6,8 @@ module Doorkeeper
     include Models::Expirable
     include Models::Revocable
     include Models::Accessible
+    include Models::Orderable
     include Models::Scopes
-    include ActiveModel::MassAssignmentSecurity if defined?(::ProtectedAttributes)
-
-    included do
-      belongs_to_options = {
-        class_name: 'Doorkeeper::Application',
-        inverse_of: :access_tokens
-      }
-      if defined?(ActiveRecord::Base) && ActiveRecord::VERSION::MAJOR >= 5
-        belongs_to_options[:optional] = true
-      end
-
-      belongs_to :application, belongs_to_options
-
-      validates :token, presence: true, uniqueness: true
-      validates :refresh_token, uniqueness: true, if: :use_refresh_token?
-
-      # @attr_writer [Boolean, nil] use_refresh_token
-      #   indicates the possibility of using refresh token
-      attr_writer :use_refresh_token
-
-      before_validation :generate_token, on: :create
-      before_validation :generate_refresh_token,
-                        on: :create,
-                        if: :use_refresh_token?
-    end
 
     module ClassMethods
       # Returns an instance of the Doorkeeper::AccessToken with
@@ -68,11 +44,11 @@ module Doorkeeper
       # @param resource_owner [ActiveRecord::Base]
       #   instance of the Resource Owner model
       #
-      def revoke_all_for(application_id, resource_owner)
+      def revoke_all_for(application_id, resource_owner, clock = Time)
         where(application_id: application_id,
               resource_owner_id: resource_owner.id,
               revoked_at: nil).
-          each(&:revoke)
+          update_all(revoked_at: clock.now.utc)
       end
 
       # Looking for not expired Access Token with a matching set of scopes
@@ -94,30 +70,34 @@ module Doorkeeper
                             else
                               resource_owner_or_id
                             end
-        token = last_authorized_token_for(application.try(:id), resource_owner_id)
-        if token && scopes_match?(token.scopes, scopes, application.try(:scopes))
-          token
+
+        tokens = authorized_tokens_for(application.try(:id), resource_owner_id)
+        tokens.detect do |token|
+          scopes_match?(token.scopes, scopes, application.try(:scopes))
         end
       end
 
-      # Checks whether the token scopes match the scopes from the parameters or
-      # Application scopes (if present).
+      # Checks whether the token scopes match the scopes from the parameters
       #
       # @param token_scopes [#to_s]
       #   set of scopes (any object that responds to `#to_s`)
-      # @param param_scopes [String]
+      # @param param_scopes [Doorkeeper::OAuth::Scopes]
       #   scopes from params
-      # @param app_scopes [String]
+      # @param app_scopes [Doorkeeper::OAuth::Scopes]
       #   Application scopes
       #
-      # @return [Boolean] true if all scopes and blank or matches
+      # @return [Boolean] true if the param scopes match the token scopes,
+      #   and all the param scopes are defined in the application (or in the
+      #   server configuration if the application doesn't define any scopes),
       #   and false in other cases
       #
       def scopes_match?(token_scopes, param_scopes, app_scopes)
-        (!token_scopes.present? && !param_scopes.present?) ||
-          Doorkeeper::OAuth::Helpers::ScopeChecker.match?(
-            token_scopes.to_s,
-            param_scopes,
+        return true if token_scopes.empty? && param_scopes.empty?
+
+        (token_scopes.sort == param_scopes.sort) &&
+          Doorkeeper::OAuth::Helpers::ScopeChecker.valid?(
+            param_scopes.to_s,
+            Doorkeeper.configuration.scopes,
             app_scopes
           )
       end
@@ -142,9 +122,8 @@ module Doorkeeper
       def find_or_create_for(application, resource_owner_id, scopes, expires_in, use_refresh_token)
         if Doorkeeper.configuration.reuse_access_token
           access_token = matching_token_for(application, resource_owner_id, scopes)
-          if access_token && !access_token.expired?
-            return access_token
-          end
+
+          return access_token if access_token && !access_token.expired?
         end
 
         create!(
@@ -156,7 +135,7 @@ module Doorkeeper
         )
       end
 
-      # Looking for not revoked Access Token record that belongs to specific
+      # Looking for not revoked Access Token records that belongs to specific
       # Application and Resource Owner.
       #
       # @param application_id [Integer]
@@ -164,14 +143,28 @@ module Doorkeeper
       # @param resource_owner_id [Integer]
       #   ID of the Resource Owner model instance
       #
+      # @return [Doorkeeper::AccessToken] array of matching AccessToken objects
+      #
+      def authorized_tokens_for(application_id, resource_owner_id)
+        ordered_by(:created_at, :desc)
+          .where(application_id: application_id,
+                 resource_owner_id: resource_owner_id,
+                 revoked_at: nil)
+      end
+
+      # Convenience method for backwards-compatibility, return the last
+      # matching token for the given Application and Resource Owner.
+      #
+      # @param application_id [Integer]
+      #   ID of the Application model instance
+      # @param resource_owner_id [Integer]
+      #   ID of the Resource Owner model instance
+      #
       # @return [Doorkeeper::AccessToken, nil] matching AccessToken object or
       #   nil if nothing was found
       #
       def last_authorized_token_for(application_id, resource_owner_id)
-        send(order_method, created_at_desc).
-          find_by(application_id: application_id,
-                  resource_owner_id: resource_owner_id,
-                  revoked_at: nil)
+        authorized_tokens_for(application_id, resource_owner_id).first
       end
     end
 
@@ -231,7 +224,7 @@ module Doorkeeper
     # @return [String] refresh token value
     #
     def generate_refresh_token
-      write_attribute :refresh_token, UniqueToken.generate
+      self.refresh_token = UniqueToken.generate
     end
 
     # Generates and sets the token value with the
@@ -247,18 +240,24 @@ module Doorkeeper
     def generate_token
       self.created_at ||= Time.now.utc
 
-      generator = Doorkeeper.configuration.access_token_generator.constantize
-      self.token = generator.generate(
+      self.token = token_generator.generate(
         resource_owner_id: resource_owner_id,
         scopes: scopes,
         application: application,
         expires_in: expires_in,
         created_at: created_at
       )
-    rescue NoMethodError
+    end
+
+    def token_generator
+      generator_name = Doorkeeper.configuration.access_token_generator
+      generator = generator_name.constantize
+
+      return generator if generator.respond_to?(:generate)
+
       raise Errors::UnableToGenerateToken, "#{generator} does not respond to `.generate`."
     rescue NameError
-      raise Errors::TokenGeneratorNotFound, "#{generator} not found"
+      raise Errors::TokenGeneratorNotFound, "#{generator_name} not found"
     end
   end
 end

data/lib/doorkeeper/models/application_mixin.rb

@@ -3,24 +3,16 @@ module Doorkeeper
     extend ActiveSupport::Concern
 
     include OAuth::Helpers
+    include Models::Orderable
     include Models::Scopes
-    include ActiveModel::MassAssignmentSecurity if defined?(::ProtectedAttributes)
-
-    included do
-      has_many :access_grants, dependent: :delete_all, class_name: 'Doorkeeper::AccessGrant'
-      has_many :access_tokens, dependent: :delete_all, class_name: 'Doorkeeper::AccessToken'
-
-      validates :name, :secret, :uid, presence: true
-      validates :uid, uniqueness: true
-      validates :redirect_uri, redirect_uri: true
-
-      before_validation :generate_uid, :generate_secret, on: :create
-    end
 
     module ClassMethods
       # Returns an instance of the Doorkeeper::Application with
       # specific UID and secret.
       #
+      # Public/Non-confidential applications will only find by uid if secret is
+      # blank.
+      #
       # @param uid [#to_s] UID (any object that responds to `#to_s`)
       # @param secret [#to_s] secret (any object that responds to `#to_s`)
       #
@@ -28,7 +20,11 @@ module Doorkeeper
       #   if there is no record with such credentials
       #
       def by_uid_and_secret(uid, secret)
-        find_by(uid: uid.to_s, secret: secret.to_s)
+        app = by_uid(uid)
+        return unless app
+        return app if secret.blank? && !app.confidential?
+        return unless app.secret == secret
+        app
       end
 
       # Returns an instance of the Doorkeeper::Application with specific UID.
@@ -43,23 +39,13 @@ module Doorkeeper
       end
     end
 
-    private
-
-    def has_scopes?
-      Doorkeeper.configuration.orm != :active_record ||
-        Doorkeeper::Application.column_names.include?("scopes")
-    end
-
-    def generate_uid
-      if uid.blank?
-        self.uid = UniqueToken.generate
-      end
-    end
-
-    def generate_secret
-      if secret.blank?
-        self.secret = UniqueToken.generate
-      end
+    # Set an application's valid redirect URIs.
+    #
+    # @param uris [String, Array] Newline-separated string or array the URI(s)
+    #
+    # @return [String] The redirect URI(s) seperated by newlines.
+    def redirect_uri=(uris)
+      super(uris.is_a?(Array) ? uris.join("\n") : uris)
     end
   end
 end

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

@@ -6,7 +6,7 @@ module Doorkeeper
       #
       # @return [Boolean] true if object expired and false in other case
       def expired?
-        expires_in && Time.now.utc > expired_time
+        expires_in && Time.now.utc > expires_at
       end
 
       # Calculates expiration time in seconds.
@@ -15,14 +15,16 @@ module Doorkeeper
       #   or nil if object never expires.
       def expires_in_seconds
         return nil if expires_in.nil?
-        expires = (created_at + expires_in.seconds) - Time.now.utc
+        expires = expires_at - Time.now.utc
         expires_sec = expires.seconds.round(0)
         expires_sec > 0 ? expires_sec : 0
       end
 
-      private
-
-      def expired_time
+      # Expiration time (date time of creation + TTL).
+      #
+      # @return [Time] expiration time in UTC
+      #
+      def expires_at
         created_at + expires_in.seconds
       end
     end

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

@@ -0,0 +1,13 @@
+module Doorkeeper
+  module Models
+    module Orderable
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def ordered_by(attribute, direction = :asc)
+          order(attribute => direction)
+        end
+      end
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module Doorkeeper
       end
 
       def includes_scope?(*required_scopes)
-        required_scopes.blank? || required_scopes.any? { |s| scopes.exists?(s.to_s) }
+        required_scopes.blank? || required_scopes.any? { |scope| scopes.exists?(scope.to_s) }
       end
     end
   end

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

@@ -5,18 +5,12 @@ module Doorkeeper
         attr_accessor :pre_auth, :resource_owner, :token
 
         def initialize(pre_auth, resource_owner)
-          @pre_auth       = pre_auth
+          @pre_auth = pre_auth
           @resource_owner = resource_owner
         end
 
         def issue_token
-          @token ||= AccessGrant.create!(
-            application_id: pre_auth.client.id,
-            resource_owner_id: resource_owner.id,
-            expires_in: configuration.authorization_code_expires_in,
-            redirect_uri: pre_auth.redirect_uri,
-            scopes: pre_auth.scopes.to_s
-          )
+          @token ||= AccessGrant.create! access_grant_attributes
         end
 
         def native_redirect
@@ -26,6 +20,35 @@ module Doorkeeper
         def configuration
           Doorkeeper.configuration
         end
+
+        private
+
+        def authorization_code_expires_in
+          configuration.authorization_code_expires_in
+        end
+
+        def access_grant_attributes
+          pkce_attributes.merge application_id: pre_auth.client.id,
+                                resource_owner_id: resource_owner.id,
+                                expires_in: authorization_code_expires_in,
+                                redirect_uri: pre_auth.redirect_uri,
+                                scopes: pre_auth.scopes.to_s
+        end
+
+        def pkce_attributes
+          return {} unless pkce_supported?
+
+          {
+            code_challenge: pre_auth.code_challenge,
+            code_challenge_method: pre_auth.code_challenge_method
+          }
+        end
+
+        # ensures firstly, if migration with additional pcke columns was
+        # generated and migrated
+        def pkce_supported?
+          Doorkeeper::AccessGrant.pkce_supported?
+        end
       end
     end
   end

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

@@ -0,0 +1,15 @@
+module Doorkeeper
+  module OAuth
+    module Authorization
+      class Context
+        attr_reader :client, :grant_type, :scopes
+
+        def initialize(client, grant_type, scopes)
+          @client     = client
+          @grant_type = grant_type
+          @scopes     = scopes
+        end
+      end
+    end
+  end
+end

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

@@ -4,32 +4,56 @@ module Doorkeeper
       class Token
         attr_accessor :pre_auth, :resource_owner, :token
 
+        class << self
+          def access_token_expires_in(server, pre_auth_or_oauth_client, grant_type, scopes)
+            if (expiration = custom_expiration(server, pre_auth_or_oauth_client, grant_type, scopes))
+              expiration
+            else
+              server.access_token_expires_in
+            end
+          end
+
+          private
+
+          def custom_expiration(server, pre_auth_or_oauth_client, grant_type, scopes)
+            oauth_client = if pre_auth_or_oauth_client.respond_to?(:client)
+                             pre_auth_or_oauth_client.client
+                           else
+                             pre_auth_or_oauth_client
+                           end
+            context = Doorkeeper::OAuth::Authorization::Context.new(
+              oauth_client,
+              grant_type,
+              scopes
+            )
+
+            server.custom_access_token_expires_in.call(context)
+          end
+        end
+
         def initialize(pre_auth, resource_owner)
           @pre_auth       = pre_auth
           @resource_owner = resource_owner
         end
 
-        def self.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
-
         def issue_token
           @token ||= AccessToken.find_or_create_for(
             pre_auth.client,
             resource_owner.id,
             pre_auth.scopes,
-            self.class.access_token_expires_in(configuration, pre_auth),
+            self.class.access_token_expires_in(
+              configuration,
+              pre_auth,
+              Doorkeeper::OAuth::IMPLICIT,
+              pre_auth.scopes
+            ),
             false
           )
         end
 
         def native_redirect
           {
-            controller: 'doorkeeper/token_info',
+            controller: controller,
             action: :show,
             access_token: token.token
           }
@@ -37,19 +61,16 @@ module Doorkeeper
 
         private
 
-        def self.custom_expiration(server, pre_auth_or_oauth_client)
-          oauth_client = if 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)
-        end
-
         def configuration
           Doorkeeper.configuration
         end
+
+        def controller
+          @controller ||= begin
+            mapping = Doorkeeper::Rails::Routes.mapping[:token_info] || {}
+            mapping[:controllers] || 'doorkeeper/token_info'
+          end
+        end
       end
     end
   end

data/lib/doorkeeper/oauth/authorization_code_request.rb

@@ -4,19 +4,28 @@ module Doorkeeper
       validate :attributes,   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_accessor :server, :grant, :client, :redirect_uri, :access_token,
+                    :code_verifier
 
       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
 
+      def client_by_uid(parameters)
+        Doorkeeper::Application.by_uid(parameters[:client_id])
+      end
+
       def before_successful_response
         grant.transaction do
           grant.lock!
@@ -28,14 +37,17 @@ module Doorkeeper
                                       grant.scopes,
                                       server)
         end
+        super
       end
 
       def validate_attributes
+        return false if grant && grant.uses_pkce? && code_verifier.blank?
+        return false if grant && !grant.pkce_supported? && !code_verifier.blank?
         redirect_uri.present?
       end
 
       def validate_client
-        !!client
+        !client.nil?
       end
 
       def validate_grant
@@ -44,7 +56,25 @@ module Doorkeeper
       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 grant.uses_pkce? || code_verifier
+        return false unless grant.pkce_supported?
+
+        if grant.code_challenge_method == 'S256'
+          grant.code_challenge == AccessGrant.generate_code_challenge(code_verifier)
+        elsif grant.code_challenge_method == 'plain'
+          grant.code_challenge == code_verifier
+        else
+          false
+        end
       end
     end
   end

data/lib/doorkeeper/oauth/base_request.rb

@@ -3,8 +3,11 @@ module Doorkeeper
     class BaseRequest
       include Validations
 
+      attr_reader :grant_type
+
       def authorize
         validate
+
         if valid?
           before_successful_response
           @response = TokenResponse.new(access_token)
@@ -16,11 +19,7 @@ module Doorkeeper
       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
@@ -36,14 +35,30 @@ module Doorkeeper
           client,
           resource_owner_id,
           scopes,
-          Authorization::Token.access_token_expires_in(server, client),
-          server.refresh_token_enabled?)
+          Authorization::Token.access_token_expires_in(server, client, grant_type, scopes),
+          server.refresh_token_enabled?
+        )
       end
 
       def before_successful_response
+        Doorkeeper.configuration.before_successful_strategy_response.call(self)
       end
 
       def after_successful_response
+        Doorkeeper.configuration.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.try(:scopes)
+          return default_scopes if client_scopes.blank?
+
+          default_scopes & @client.scopes
+        end
       end
     end
   end

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

@@ -1,10 +1,10 @@
 module Doorkeeper
   module OAuth
     class Client
-      class Credentials < Struct.new(:uid, :secret)
+      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?
@@ -18,13 +18,15 @@ module Doorkeeper
           def from_basic(request)
             authorization = request.authorization
             if authorization.present? && authorization =~ /^Basic (.*)/m
-              Base64.decode64($1).split(/:/, 2)
+              Base64.decode64(Regexp.last_match(1)).split(/:/, 2)
             end
           end
         end
 
+        # Public clients may have their secret blank, but "credentials" are
+        # still present
         def blank?
-          uid.blank? || secret.blank?
+          uid.blank?
         end
       end
     end

data/lib/doorkeeper/oauth/client.rb

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

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

@@ -25,7 +25,12 @@ module Doorkeeper
         private
 
         def create_token(client, scopes, creator)
-          ttl = Authorization::Token.access_token_expires_in(@server, client)
+          ttl = Authorization::Token.access_token_expires_in(
+            @server,
+            client,
+            Doorkeeper::OAuth::CLIENT_CREDENTIALS,
+            scopes
+          )
 
           creator.call(
             client,