super-smart-kit 0.0.1

data/doorkeeper-5.9.3/lib/doorkeeper/oauth/error_response.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module OAuth
+    class ErrorResponse < BaseResponse
+      include OAuth::Helpers
+
+      NON_REDIRECTABLE_STATES = %i[invalid_redirect_uri invalid_client unauthorized_client].freeze
+
+      def self.from_request(request, attributes = {})
+        new(
+          attributes.merge(
+            name: error_name_for(request.error),
+            exception_class: exception_class_for(request.error),
+            translate_options: request.error.try(:translate_options),
+            state: request.try(:state),
+            redirect_uri: request.try(:redirect_uri),
+          ),
+        )
+      end
+
+      def self.error_name_for(error)
+        error.respond_to?(:name_for_response) ? error.name_for_response : error
+      end
+
+      def self.exception_class_for(error)
+        return error if error.respond_to?(:name_for_response)
+
+        "Doorkeeper::Errors::#{error.to_s.classify}".safe_constantize
+      end
+
+      private_class_method :error_name_for, :exception_class_for
+
+      delegate :name, :description, :state, to: :@error
+
+      def initialize(attributes = {})
+        @error = OAuth::Error.new(*attributes.values_at(:name, :state, :translate_options))
+        @exception_class = attributes[:exception_class]
+        @redirect_uri = attributes[:redirect_uri]
+        @response_on_fragment = attributes[:response_on_fragment]
+      end
+
+      def body
+        {
+          error: name,
+          error_description: description,
+          state: state,
+        }.reject { |_, v| v.blank? }
+      end
+
+      def status
+        if name == :invalid_client || name == :unauthorized_client
+          :unauthorized
+        else
+          :bad_request
+        end
+      end
+
+      def redirectable?
+        !NON_REDIRECTABLE_STATES.include?(name) && !URIChecker.oob_uri?(@redirect_uri)
+      end
+
+      def redirect_uri
+        if @response_on_fragment
+          Authorization::URIBuilder.uri_with_fragment(@redirect_uri, body)
+        else
+          Authorization::URIBuilder.uri_with_query(@redirect_uri, body)
+        end
+      end
+
+      def headers
+        {
+          "Cache-Control" => "no-store, no-cache",
+          "Content-Type" => "application/json; charset=utf-8",
+          "WWW-Authenticate" => authenticate_info,
+        }
+      end
+
+      def raise_exception!
+        raise exception_class.new(self), description
+      end
+
+      protected
+
+      def realm
+        Doorkeeper.config.realm
+      end
+
+      def exception_class
+        return @exception_class if @exception_class
+
+        raise NotImplementedError, "error response must define #exception_class"
+      end
+
+      private
+
+      def authenticate_info
+        %(Bearer realm="#{realm}", error="#{sanitize_error_values(name)}", error_description="#{sanitize_error_values(description)}")
+      end
+
+      # This method removes any characters that are invalid in error
+      # details per RFC6750.
+      #
+      # > Values for the "error" and "error_description" attributes
+      # > (specified in Appendixes A.7 and A.8 of [RFC6749]) MUST NOT
+      # > include characters outside the set %x20-21 (" " or "!") / %x23-5B /
+      # > %x5D-7E (ascii "#" to "~" without "\").
+      def sanitize_error_values(string)
+        string.to_s.each_char.map do |char|
+          if char.in?("\x20".encode("utf-8").."\x21".encode("utf-8")) ||
+             char.in?("\x23".encode("utf-8").."\x5B".encode("utf-8")) ||
+             char.in?("\x5D".encode("utf-8").."\x7E".encode("utf-8"))
+            char
+          else
+            "_"
+          end
+        end.join("")
+      end
+    end
+  end
+end

data/doorkeeper-5.9.3/lib/doorkeeper/oauth/forbidden_token_response.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module OAuth
+    class ForbiddenTokenResponse < ErrorResponse
+      def self.from_scopes(scopes, attributes = {})
+        new(attributes.merge(scopes: scopes))
+      end
+
+      def initialize(attributes = {})
+        super(attributes.merge(name: :insufficient_scope, state: :forbidden))
+        @scopes = attributes[:scopes]
+      end
+
+      def status
+        :forbidden
+      end
+
+      def description
+        @description ||= I18n.t("doorkeeper.errors.messages.forbidden_token.missing_scope",
+                                oauth_scopes: @scopes.map(&:to_s).join(" "),)
+      end
+
+      protected
+
+      def exception_class
+        Doorkeeper::Errors::TokenForbidden
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module OAuth
+    module Helpers
+      module ScopeChecker
+        class Validator
+          attr_reader :parsed_scopes, :scope_str
+
+          def initialize(scope_str, server_scopes, app_scopes, grant_type)
+            @parsed_scopes = OAuth::Scopes.from_string(scope_str)
+            @scope_str = scope_str
+            @valid_scopes = valid_scopes(server_scopes, app_scopes)
+
+            @scopes_by_grant_type = Doorkeeper.config.scopes_by_grant_type[grant_type.to_sym] if grant_type
+          end
+
+          def valid?
+            scope_str.present? &&
+              scope_str !~ /[\n\r\t]/ &&
+              @valid_scopes.has_scopes?(parsed_scopes) &&
+              permitted_to_grant_type?
+          end
+
+          private
+
+          def valid_scopes(server_scopes, app_scopes)
+            app_scopes.presence || server_scopes
+          end
+
+          def permitted_to_grant_type?
+            return true unless @scopes_by_grant_type
+
+            OAuth::Scopes.from_array(@scopes_by_grant_type)
+              .has_scopes?(parsed_scopes)
+          end
+        end
+
+        def self.valid?(scope_str:, server_scopes:, app_scopes: nil, grant_type: nil)
+          Validator.new(
+            scope_str,
+            server_scopes,
+            app_scopes,
+            grant_type,
+          ).valid?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# 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 = {})
+          # Access Token value must be 1*VSCHAR or
+          # 1*( ALPHA / DIGIT / "-" / "." / "_" / "~" / "+" / "/" ) *"="
+          #
+          # @see https://datatracker.ietf.org/doc/html/rfc6749#appendix-A.12
+          # @see https://datatracker.ietf.org/doc/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
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+
+module Doorkeeper
+  module OAuth
+    module Helpers
+      module URIChecker
+        def self.valid?(url)
+          return true if oob_uri?(url)
+
+          uri = as_uri(url)
+          valid_scheme?(uri) && iff_host?(uri) && uri.fragment.nil? && uri.opaque.nil?
+        rescue URI::InvalidURIError
+          false
+        end
+
+        def self.matches?(url, client_url)
+          url = as_uri(url)
+          client_url = as_uri(client_url)
+
+          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://datatracker.ietf.org/doc/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, IPAddr::InvalidAddressError
+          false
+        end
+
+        def self.valid_for_authorization?(url, client_url)
+          valid?(url) && client_url.split.any? { |other_url| matches?(url, other_url) }
+        end
+
+        def self.as_uri(url)
+          URI.parse(url)
+        end
+
+        def self.query_matches?(query, client_query)
+          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
+        end
+
+        def self.valid_scheme?(uri)
+          return false if uri.scheme.blank?
+
+          %w[localhost].exclude?(uri.scheme)
+        end
+
+        def self.hypertext_scheme?(uri)
+          %w[http https].include?(uri.scheme)
+        end
+
+        def self.iff_host?(uri)
+          !(hypertext_scheme?(uri) && uri.host.blank?)
+        end
+
+        def self.oob_uri?(uri)
+          NonStandard::IETF_WG_OAUTH2_OOB_METHODS.include?(uri)
+        end
+      end
+    end
+  end
+end

data/doorkeeper-5.9.3/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/doorkeeper-5.9.3/lib/doorkeeper/oauth/invalid_request_response.rb

@@ -0,0 +1,47 @@
+# 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 exception_class
+        Doorkeeper::Errors::InvalidRequest
+      end
+
+      def redirectable?
+        super && @missing_param != :client_id
+      end
+    end
+  end
+end

data/doorkeeper-5.9.3/lib/doorkeeper/oauth/invalid_token_response.rb

@@ -0,0 +1,54 @@
+# 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&.revoked?
+                   :revoked
+                 elsif access_token&.expired?
+                   :expired
+                 else
+                   :unknown
+                 end
+
+        new(attributes.merge(reason: reason))
+      end
+
+      def initialize(attributes = {})
+        super(attributes.merge(name: :invalid_token, state: :unauthorized))
+        @reason = attributes[:reason] || :unknown
+      end
+
+      def status
+        :unauthorized
+      end
+
+      def description
+        @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
+end

data/doorkeeper-5.9.3/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/doorkeeper-5.9.3/lib/doorkeeper/oauth/password_access_token_request.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module OAuth
+    class PasswordAccessTokenRequest < BaseRequest
+      include OAuth::Helpers
+
+      validate :client, error: Errors::InvalidClient
+      validate :client_supports_grant_flow, error: Errors::UnauthorizedClient
+      validate :resource_owner, error: Errors::InvalidGrant
+      validate :scopes, error: Errors::InvalidScope
+
+      attr_reader :client, :credentials, :resource_owner, :parameters, :access_token
+
+      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, scopes, {}, server)
+        super
+      end
+
+      def validate_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.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://datatracker.ietf.org/doc/html/rfc6749#section-4.3
+      #
+      def validate_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
+        Doorkeeper.config.allow_grant_flow_for_client?(grant_type, client&.application)
+      end
+    end
+  end
+end