From 2a10c4fbc83ce7bb8861f1e7c002762d067141a9 Mon Sep 17 00:00:00 2001 From: Md Mosharaf Hossan Date: Thu, 15 Jun 2023 12:51:05 +0700 Subject: [PATCH 1/4] [#18] Require user authentication for resource access --- app/controllers/application_controller.rb | 2 ++ 1 file changed, 2 insertions(+) diff --git a/app/controllers/application_controller.rb b/app/controllers/application_controller.rb index c1805be..b8ab80d 100644 --- a/app/controllers/application_controller.rb +++ b/app/controllers/application_controller.rb @@ -3,4 +3,6 @@ class ApplicationController < ActionController::Base include Localization include Pagy::Backend + + before_action :authenticate_user! end From 920e891f5b9bfb606bf08626c1a626506a595860 Mon Sep 17 00:00:00 2001 From: Md Mosharaf Hossan Date: Thu, 15 Jun 2023 17:55:49 +0700 Subject: [PATCH 2/4] [#18] Add registration throught api --- Gemfile | 1 + Gemfile.lock | 3 + .../api/v1/application_controller.rb | 17 + app/controllers/api/v1/users_controller.rb | 75 +++ app/controllers/application_controller.rb | 2 +- app/models/concerns/authenticable.rb | 7 + config/initializers/doorkeeper.rb | 511 ++++++++++++++++++ config/locales/doorkeeper.en.yml | 151 ++++++ config/routes.rb | 10 + ...20230615070454_create_doorkeeper_tables.rb | 76 +++ db/schema.rb | 31 +- db/seeds.rb | 6 + spec/fabricators/application_fabricator.rb | 5 + spec/fabricators/search_stat_fabricator.rb | 2 +- spec/requests/api/v1/users_controller_spec.rb | 48 ++ 15 files changed, 942 insertions(+), 3 deletions(-) create mode 100644 app/controllers/api/v1/application_controller.rb create mode 100644 app/controllers/api/v1/users_controller.rb create mode 100644 config/initializers/doorkeeper.rb create mode 100644 config/locales/doorkeeper.en.yml create mode 100644 db/migrate/20230615070454_create_doorkeeper_tables.rb create mode 100644 spec/fabricators/application_fabricator.rb create mode 100644 spec/requests/api/v1/users_controller_spec.rb diff --git a/Gemfile b/Gemfile index 72d2ea1..e06198e 100644 --- a/Gemfile +++ b/Gemfile @@ -19,6 +19,7 @@ gem 'devise' # Flexible authentication solution for Rails with Warden # Authentications & Authorizations gem 'pundit' # Minimal authorization through OO design and pure Ruby classes +gem 'doorkeeper' # Awesome OAuth 2 provider for your Rails / Grape app # Assets gem 'sassc' diff --git a/Gemfile.lock b/Gemfile.lock index ce57ccf..d26739f 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -167,6 +167,8 @@ GEM docile (1.4.0) dockerfile-rails (1.3.0) rails + doorkeeper (5.6.6) + railties (>= 5) erubi (1.12.0) fabrication (2.30.0) faraday (2.7.5) @@ -464,6 +466,7 @@ DEPENDENCIES devise discard dockerfile-rails (>= 1.2) + doorkeeper fabrication ffaker figaro diff --git a/app/controllers/api/v1/application_controller.rb b/app/controllers/api/v1/application_controller.rb new file mode 100644 index 0000000..d4c8f48 --- /dev/null +++ b/app/controllers/api/v1/application_controller.rb @@ -0,0 +1,17 @@ +# frozen_string_literal: true + +module Api + module V1 + class ApplicationController < ActionController::API + # equivalent of authenticate_user! on devise, but this one will check the oauth token + before_action :doorkeeper_authorize! + + private + + # helper method to access the current user from the token + def current_user + @current_user ||= User.find_by(id: doorkeeper_token[:resource_owner_id]) + end + end + end +end diff --git a/app/controllers/api/v1/users_controller.rb b/app/controllers/api/v1/users_controller.rb new file mode 100644 index 0000000..c303593 --- /dev/null +++ b/app/controllers/api/v1/users_controller.rb @@ -0,0 +1,75 @@ +# frozen_string_literal: true + +module Api + module V1 + class UsersController < ApplicationController + skip_before_action :doorkeeper_authorize!, only: %i[create] + + def create + user = build_user + client_app = find_client_application + + return render(json: { error: 'Invalid client ID' }, status: :forbidden) unless client_app + + if user.save + access_token = create_access_token(user, client_app) + render_success_response(user, access_token) + else + render_failure_response(user) + end + end + + private + + def user_params + params.permit(:email, :password) + end + + def build_user + User.new(email: user_params[:email], password: user_params[:password]) + end + + def find_client_application + Doorkeeper::Application.find_by(uid: params[:client_id]) + end + + def generate_refresh_token + loop do + token = SecureRandom.hex(32) + break token unless Doorkeeper::AccessToken.exists?(refresh_token: token) + end + end + + def create_access_token(user, client_app) + Doorkeeper::AccessToken.create( + resource_owner_id: user.id, + application_id: client_app.id, + refresh_token: generate_refresh_token, + expires_in: Doorkeeper.configuration.access_token_expires_in.to_i, + scopes: '' + ) + end + + def render_success_response(user, access_token) + user_data = build_user_data(user, access_token) + render(json: { user: user_data }) + end + + def build_user_data(user, access_token) + { + id: user.id, + email: user.email, + access_token: access_token.token, + token_type: 'bearer', + expires_in: access_token.expires_in, + refresh_token: access_token.refresh_token, + created_at: access_token.created_at.to_time.to_i + } + end + + def render_failure_response(user) + render(json: { error: user.errors.full_messages }, status: :unprocessable_entity) + end + end + end +end diff --git a/app/controllers/application_controller.rb b/app/controllers/application_controller.rb index b8ab80d..999dc4e 100644 --- a/app/controllers/application_controller.rb +++ b/app/controllers/application_controller.rb @@ -4,5 +4,5 @@ class ApplicationController < ActionController::Base include Localization include Pagy::Backend - before_action :authenticate_user! + before_action :authenticate_user!, unless: -> { is_a?(HealthCheckController) } end diff --git a/app/models/concerns/authenticable.rb b/app/models/concerns/authenticable.rb index b556429..c3bc140 100644 --- a/app/models/concerns/authenticable.rb +++ b/app/models/concerns/authenticable.rb @@ -7,5 +7,12 @@ module Authenticable # Include default devise modules. Others available are: # :confirmable, :lockable, :timeoutable and :omniauthable devise :database_authenticatable, :registerable, :recoverable, :rememberable, :validatable + + # the authenticate method from devise documentation + # todo extract it inside authenticable + def self.authenticate(email, password) + user = User.find_for_authentication(email: email) + user&.valid_password?(password) ? user : nil + end end end diff --git a/config/initializers/doorkeeper.rb b/config/initializers/doorkeeper.rb new file mode 100644 index 0000000..8df0a68 --- /dev/null +++ b/config/initializers/doorkeeper.rb @@ -0,0 +1,511 @@ +# frozen_string_literal: true + +Doorkeeper.configure do + # Change the ORM that doorkeeper will use (requires ORM extensions installed). + # Check the list of supported ORMs here: https://github.com/doorkeeper-gem/doorkeeper#orms + orm :active_record + + # This block will be called to check whether the resource owner is authenticated or not. + resource_owner_authenticator do + # Put your resource owner authentication logic here. + # Example implementation: + # User.find_by(id: session[:user_id]) || redirect_to(new_user_session_url) + end + + resource_owner_from_credentials do |_routes| + User.authenticate(params[:email], params[:password]) + end + # If you didn't skip applications controller from Doorkeeper routes in your application routes.rb + # file then you need to declare this block in order to restrict access to the web interface for + # adding oauth authorized applications. In other case it will return 403 Forbidden response + # every time somebody will try to access the admin web interface. + # + # admin_authenticator do + # # Put your admin authentication logic here. + # # Example implementation: + # + # if current_user + # head :forbidden unless current_user.admin? + # else + # redirect_to sign_in_url + # end + # end + + # You can use your own model classes if you need to extend (or even override) default + # Doorkeeper models such as `Application`, `AccessToken` and `AccessGrant. + # + # Be default Doorkeeper ActiveRecord ORM uses it's own classes: + # + # access_token_class "Doorkeeper::AccessToken" + # access_grant_class "Doorkeeper::AccessGrant" + # application_class "Doorkeeper::Application" + # + # Don't forget to include Doorkeeper ORM mixins into your custom models: + # + # * ::Doorkeeper::Orm::ActiveRecord::Mixins::AccessToken - for access token + # * ::Doorkeeper::Orm::ActiveRecord::Mixins::AccessGrant - for access grant + # * ::Doorkeeper::Orm::ActiveRecord::Mixins::Application - for application (OAuth2 clients) + # + # For example: + # + # access_token_class "MyAccessToken" + # + # class MyAccessToken < ApplicationRecord + # include ::Doorkeeper::Orm::ActiveRecord::Mixins::AccessToken + # + # self.table_name = "hey_i_wanna_my_name" + # + # def destroy_me! + # destroy + # end + # end + + # Enables polymorphic Resource Owner association for Access Tokens and Access Grants. + # By default this option is disabled. + # + # Make sure you properly setup you database and have all the required columns (run + # `bundle exec rails generate doorkeeper:enable_polymorphic_resource_owner` and execute Rails + # migrations). + # + # If this option enabled, Doorkeeper will store not only Resource Owner primary key + # value, but also it's type (class name). See "Polymorphic Associations" section of + # Rails guides: https://guides.rubyonrails.org/association_basics.html#polymorphic-associations + # + # [NOTE] If you apply this option on already existing project don't forget to manually + # update `resource_owner_type` column in the database and fix migration template as it will + # set NOT NULL constraint for Access Grants table. + # + # use_polymorphic_resource_owner + + # If you are planning to use Doorkeeper in Rails 5 API-only application, then you might + # want to use API mode that will skip all the views management and change the way how + # Doorkeeper responds to a requests. + # + # api_only + + # Enforce token request content type to application/x-www-form-urlencoded. + # It is not enabled by default to not break prior versions of the gem. + # + # enforce_content_type + + # Authorization Code expiration time (default: 10 minutes). + # + # authorization_code_expires_in 10.minutes + + # Access token expiration time (default: 2 hours). + # If you want to disable expiration, set this to `nil`. + # + # access_token_expires_in 2.hours + + # Assign custom TTL for access tokens. Will be used instead of access_token_expires_in + # option if defined. In case the block returns `nil` value Doorkeeper fallbacks to + # +access_token_expires_in+ configuration option value. If you really need to issue a + # non-expiring access token (which is not recommended) then you need to return + # Float::INFINITY from this block. + # + # `context` has the following properties available: + # + # * `client` - the OAuth client application (see Doorkeeper::OAuth::Client) + # * `grant_type` - the grant type of the request (see Doorkeeper::OAuth) + # * `scopes` - the requested scopes (see Doorkeeper::OAuth::Scopes) + # * `resource_owner` - authorized resource owner instance (if present) + # + # custom_access_token_expires_in do |context| + # context.client.additional_settings.implicit_oauth_expiration + # end + + # Use a custom class for generating the access token. + # See https://doorkeeper.gitbook.io/guides/configuration/other-configurations#custom-access-token-generator + # + # access_token_generator '::Doorkeeper::JWT' + + # The controller +Doorkeeper::ApplicationController+ inherits from. + # Defaults to +ActionController::Base+ unless +api_only+ is set, which changes the default to + # +ActionController::API+. The return value of this option must be a stringified class name. + # See https://doorkeeper.gitbook.io/guides/configuration/other-configurations#custom-controllers + # + # base_controller 'ApplicationController' + + # Reuse access token for the same resource owner within an application (disabled by default). + # + # This option protects your application from creating new tokens before old **valid** one becomes + # expired so your database doesn't bloat. Keep in mind that when this option is enabled Doorkeeper + # doesn't update existing token expiration time, it will create a new token instead if no active matching + # token found for the application, resources owner and/or set of scopes. + # Rationale: https://github.com/doorkeeper-gem/doorkeeper/issues/383 + # + # You can not enable this option together with +hash_token_secrets+. + # + # reuse_access_token + + # In case you enabled `reuse_access_token` option Doorkeeper will try to find matching + # token using `matching_token_for` Access Token API that searches for valid records + # in batches in order not to pollute the memory with all the database records. By default + # Doorkeeper uses batch size of 10 000 records. You can increase or decrease this value + # depending on your needs and server capabilities. + # + # token_lookup_batch_size 10_000 + + # Set a limit for token_reuse if using reuse_access_token option + # + # This option limits token_reusability to some extent. + # If not set then access_token will be reused unless it expires. + # Rationale: https://github.com/doorkeeper-gem/doorkeeper/issues/1189 + # + # This option should be a percentage(i.e. (0,100]) + # + # token_reuse_limit 100 + + # Only allow one valid access token obtained via client credentials + # per client. If a new access token is obtained before the old one + # expired, the old one gets revoked (disabled by default) + # + # When enabling this option, make sure that you do not expect multiple processes + # using the same credentials at the same time (e.g. web servers spanning + # multiple machines and/or processes). + # + # revoke_previous_client_credentials_token + + # Hash access and refresh tokens before persisting them. + # This will disable the possibility to use +reuse_access_token+ + # since plain values can no longer be retrieved. + # + # Note: If you are already a user of doorkeeper and have existing tokens + # in your installation, they will be invalid without adding 'fallback: :plain'. + # + # hash_token_secrets + # By default, token secrets will be hashed using the + # +Doorkeeper::Hashing::SHA256+ strategy. + # + # If you wish to use another hashing implementation, you can override + # this strategy as follows: + # + # hash_token_secrets using: '::Doorkeeper::Hashing::MyCustomHashImpl' + # + # Keep in mind that changing the hashing function will invalidate all existing + # secrets, if there are any. + + # Hash application secrets before persisting them. + # + # hash_application_secrets + # + # By default, applications will be hashed + # with the +Doorkeeper::SecretStoring::SHA256+ strategy. + # + # If you wish to use bcrypt for application secret hashing, uncomment + # this line instead: + # + # hash_application_secrets using: '::Doorkeeper::SecretStoring::BCrypt' + + # When the above option is enabled, and a hashed token or secret is not found, + # you can allow to fall back to another strategy. For users upgrading + # doorkeeper and wishing to enable hashing, you will probably want to enable + # the fallback to plain tokens. + # + # This will ensure that old access tokens and secrets + # will remain valid even if the hashing above is enabled. + # + # This can be done by adding 'fallback: plain', e.g. : + # + # hash_application_secrets using: '::Doorkeeper::SecretStoring::BCrypt', fallback: :plain + + # Issue access tokens with refresh token (disabled by default), you may also + # pass a block which accepts `context` to customize when to give a refresh + # token or not. Similar to +custom_access_token_expires_in+, `context` has + # the following properties: + # + # `client` - the OAuth client application (see Doorkeeper::OAuth::Client) + # `grant_type` - the grant type of the request (see Doorkeeper::OAuth) + # `scopes` - the requested scopes (see Doorkeeper::OAuth::Scopes) + # + use_refresh_token + + # Provide support for an owner to be assigned to each registered application (disabled by default) + # Optional parameter confirmation: true (default: false) if you want to enforce ownership of + # a registered application + # NOTE: you must also run the rails g doorkeeper:application_owner generator + # to provide the necessary support + # + # enable_application_owner confirmation: false + + # Define access token scopes for your provider + # For more information go to + # https://doorkeeper.gitbook.io/guides/ruby-on-rails/scopes + # + # default_scopes :public + # optional_scopes :write, :update + + # Allows to restrict only certain scopes for grant_type. + # By default, all the scopes will be available for all the grant types. + # + # Keys to this hash should be the name of grant_type and + # values should be the array of scopes for that grant type. + # Note: scopes should be from configured_scopes (i.e. default or optional) + # + # scopes_by_grant_type password: [:write], client_credentials: [:update] + + # Forbids creating/updating applications with arbitrary scopes that are + # not in configuration, i.e. +default_scopes+ or +optional_scopes+. + # (disabled by default) + # + # enforce_configured_scopes + + # Change the way client credentials are retrieved from the request object. + # By default it retrieves first from the `HTTP_AUTHORIZATION` header, then + # falls back to the `:client_id` and `:client_secret` params from the `params` object. + # Check out https://github.com/doorkeeper-gem/doorkeeper/wiki/Changing-how-clients-are-authenticated + # for more information on customization + # + # client_credentials :from_basic, :from_params + + # Change the way access token is authenticated from the request object. + # By default it retrieves first from the `HTTP_AUTHORIZATION` header, then + # falls back to the `:access_token` or `:bearer_token` params from the `params` object. + # Check out https://github.com/doorkeeper-gem/doorkeeper/wiki/Changing-how-clients-are-authenticated + # for more information on customization + # + # access_token_methods :from_bearer_authorization, :from_access_token_param, :from_bearer_param + + # Forces the usage of the HTTPS protocol in non-native redirect uris (enabled + # by default in non-development environments). OAuth2 delegates security in + # communication to the HTTPS protocol so it is wise to keep this enabled. + # + # Callable objects such as proc, lambda, block or any object that responds to + # #call can be used in order to allow conditional checks (to allow non-SSL + # redirects to localhost for example). + # + # force_ssl_in_redirect_uri !Rails.env.development? + # + # force_ssl_in_redirect_uri { |uri| uri.host != 'localhost' } + + # Specify what redirect URI's you want to block during Application creation. + # Any redirect URI is allowed by default. + # + # You can use this option in order to forbid URI's with 'javascript' scheme + # for example. + # + # forbid_redirect_uri { |uri| uri.scheme.to_s.downcase == 'javascript' } + + # Allows to set blank redirect URIs for Applications in case Doorkeeper configured + # to use URI-less OAuth grant flows like Client Credentials or Resource Owner + # Password Credentials. The option is on by default and checks configured grant + # types, but you **need** to manually drop `NOT NULL` constraint from `redirect_uri` + # column for `oauth_applications` database table. + # + # You can completely disable this feature with: + # + allow_blank_redirect_uri true + # + # Or you can define your custom check: + # + # allow_blank_redirect_uri do |grant_flows, client| + # client.superapp? + # end + + # Specify how authorization errors should be handled. + # By default, doorkeeper renders json errors when access token + # is invalid, expired, revoked or has invalid scopes. + # + # If you want to render error response yourself (i.e. rescue exceptions), + # set +handle_auth_errors+ to `:raise` and rescue Doorkeeper::Errors::InvalidToken + # or following specific errors: + # + # Doorkeeper::Errors::TokenForbidden, Doorkeeper::Errors::TokenExpired, + # Doorkeeper::Errors::TokenRevoked, Doorkeeper::Errors::TokenUnknown + # + # handle_auth_errors :raise + + # Customize token introspection response. + # Allows to add your own fields to default one that are required by the OAuth spec + # for the introspection response. It could be `sub`, `aud` and so on. + # This configuration option can be a proc, lambda or any Ruby object responds + # to `.call` method and result of it's invocation must be a Hash. + # + # custom_introspection_response do |token, context| + # { + # "sub": "Z5O3upPC88QrAjx00dis", + # "aud": "https://protected.example.net/resource", + # "username": User.find(token.resource_owner_id).username + # } + # end + # + # or + # + # custom_introspection_response CustomIntrospectionResponder + + # Specify what grant flows are enabled in array of Strings. The valid + # strings and the flows they enable are: + # + # "authorization_code" => Authorization Code Grant Flow + # "implicit" => Implicit Grant Flow + # "password" => Resource Owner Password Credentials Grant Flow + # "client_credentials" => Client Credentials Grant Flow + # + # If not specified, Doorkeeper enables authorization_code and + # client_credentials. + # + # implicit and password grant flows have risks that you should understand + # before enabling: + # https://datatracker.ietf.org/doc/html/rfc6819#section-4.4.2 + # https://datatracker.ietf.org/doc/html/rfc6819#section-4.4.3 + # + grant_flows %w[password] + + # Allows to customize OAuth grant flows that +each+ application support. + # You can configure a custom block (or use a class respond to `#call`) that must + # return `true` in case Application instance supports requested OAuth grant flow + # during the authorization request to the server. This configuration +doesn't+ + # set flows per application, it only allows to check if application supports + # specific grant flow. + # + # For example you can add an additional database column to `oauth_applications` table, + # say `t.array :grant_flows, default: []`, and store allowed grant flows that can + # be used with this application there. Then when authorization requested Doorkeeper + # will call this block to check if specific Application (passed with client_id and/or + # client_secret) is allowed to perform the request for the specific grant type + # (authorization, password, client_credentials, etc). + # + # Example of the block: + # + # ->(flow, client) { client.grant_flows.include?(flow) } + # + # In case this option invocation result is `false`, Doorkeeper server returns + # :unauthorized_client error and stops the request. + # + # @param allow_grant_flow_for_client [Proc] Block or any object respond to #call + # @return [Boolean] `true` if allow or `false` if forbid the request + # + # allow_grant_flow_for_client do |grant_flow, client| + # # `grant_flows` is an Array column with grant + # # flows that application supports + # + # client.grant_flows.include?(grant_flow) + # end + + # If you need arbitrary Resource Owner-Client authorization you can enable this option + # and implement the check your need. Config option must respond to #call and return + # true in case resource owner authorized for the specific application or false in other + # cases. + # + # Be default all Resource Owners are authorized to any Client (application). + # + # authorize_resource_owner_for_client do |client, resource_owner| + # resource_owner.admin? || client.owners_allowlist.include?(resource_owner) + # end + + # Allows additional data fields to be sent while granting access to an application, + # and for this additional data to be included in subsequently generated access tokens. + # The 'authorizations/new' page will need to be overridden to include this additional data + # in the request params when granting access. The access grant and access token models + # will both need to respond to these additional data fields, and have a database column + # to store them in. + # + # Example: + # You have a multi-tenanted platform and want to be able to grant access to a specific + # tenant, rather than all the tenants a user has access to. You can use this config + # option to specify that a ':tenant_id' will be passed when authorizing. This tenant_id + # will be included in the access tokens. When a request is made with one of these access + # tokens, you can check that the requested data belongs to the specified tenant. + # + # Default value is an empty Array: [] + # custom_access_token_attributes [:tenant_id] + + # Hook into the strategies' request & response life-cycle in case your + # application needs advanced customization or logging: + # + # before_successful_strategy_response do |request| + # puts "BEFORE HOOK FIRED! #{request}" + # end + # + # after_successful_strategy_response do |request, response| + # puts "AFTER HOOK FIRED! #{request}, #{response}" + # end + + # Hook into Authorization flow in order to implement Single Sign Out + # or add any other functionality. Inside the block you have an access + # to `controller` (authorizations controller instance) and `context` + # (Doorkeeper::OAuth::Hooks::Context instance) which provides pre auth + # or auth objects with issued token based on hook type (before or after). + # + # before_successful_authorization do |controller, context| + # Rails.logger.info(controller.request.params.inspect) + # + # Rails.logger.info(context.pre_auth.inspect) + # end + # + # after_successful_authorization do |controller, context| + # controller.session[:logout_urls] << + # Doorkeeper::Application + # .find_by(controller.request.params.slice(:redirect_uri)) + # .logout_uri + # + # Rails.logger.info(context.auth.inspect) + # Rails.logger.info(context.issued_token) + # end + + # Under some circumstances you might want to have applications auto-approved, + # so that the user skips the authorization step. + # For example if dealing with a trusted application. + # + skip_authorization do |resource_owner, client| + true + end + + # Configure custom constraints for the Token Introspection request. + # By default this configuration option allows to introspect a token by another + # token of the same application, OR to introspect the token that belongs to + # authorized client (from authenticated client) OR when token doesn't + # belong to any client (public token). Otherwise requester has no access to the + # introspection and it will return response as stated in the RFC. + # + # Block arguments: + # + # @param token [Doorkeeper::AccessToken] + # token to be introspected + # + # @param authorized_client [Doorkeeper::Application] + # authorized client (if request is authorized using Basic auth with + # Client Credentials for example) + # + # @param authorized_token [Doorkeeper::AccessToken] + # Bearer token used to authorize the request + # + # In case the block returns `nil` or `false` introspection responses with 401 status code + # when using authorized token to introspect, or you'll get 200 with { "active": false } body + # when using authorized client to introspect as stated in the + # RFC 7662 section 2.2. Introspection Response. + # + # Using with caution: + # Keep in mind that these three parameters pass to block can be nil as following case: + # `authorized_client` is nil if and only if `authorized_token` is present, and vice versa. + # `token` will be nil if and only if `authorized_token` is present. + # So remember to use `&` or check if it is present before calling method on + # them to make sure you doesn't get NoMethodError exception. + # + # You can define your custom check: + # + # allow_token_introspection do |token, authorized_client, authorized_token| + # if authorized_token + # # customize: require `introspection` scope + # authorized_token.application == token&.application || + # authorized_token.scopes.include?("introspection") + # elsif token.application + # # `protected_resource` is a new database boolean column, for example + # authorized_client == token.application || authorized_client.protected_resource? + # else + # # public token (when token.application is nil, token doesn't belong to any application) + # true + # end + # end + # + # Or you can completely disable any token introspection: + # + # allow_token_introspection false + # + # If you need to block the request at all, then configure your routes.rb or web-server + # like nginx to forbid the request. + + # WWW-Authenticate Realm (default: "Doorkeeper"). + # + # realm "Doorkeeper" +end diff --git a/config/locales/doorkeeper.en.yml b/config/locales/doorkeeper.en.yml new file mode 100644 index 0000000..99fa3d4 --- /dev/null +++ b/config/locales/doorkeeper.en.yml @@ -0,0 +1,151 @@ +en: + activerecord: + attributes: + doorkeeper/application: + name: 'Name' + redirect_uri: 'Redirect URI' + errors: + models: + doorkeeper/application: + attributes: + redirect_uri: + fragment_present: 'cannot contain a fragment.' + invalid_uri: 'must be a valid URI.' + unspecified_scheme: 'must specify a scheme.' + relative_uri: 'must be an absolute URI.' + secured_uri: 'must be an HTTPS/SSL URI.' + forbidden_uri: 'is forbidden by the server.' + scopes: + not_match_configured: "doesn't match configured on the server." + + doorkeeper: + applications: + confirmations: + destroy: 'Are you sure?' + buttons: + edit: 'Edit' + destroy: 'Destroy' + submit: 'Submit' + cancel: 'Cancel' + authorize: 'Authorize' + form: + error: 'Whoops! Check your form for possible errors' + help: + confidential: 'Application will be used where the client secret can be kept confidential. Native mobile apps and Single Page Apps are considered non-confidential.' + redirect_uri: 'Use one line per URI' + blank_redirect_uri: "Leave it blank if you configured your provider to use Client Credentials, Resource Owner Password Credentials or any other grant type that doesn't require redirect URI." + scopes: 'Separate scopes with spaces. Leave blank to use the default scopes.' + edit: + title: 'Edit application' + index: + title: 'Your applications' + new: 'New Application' + name: 'Name' + callback_url: 'Callback URL' + confidential: 'Confidential?' + actions: 'Actions' + confidentiality: + 'yes': 'Yes' + 'no': 'No' + new: + title: 'New Application' + show: + title: 'Application: %{name}' + application_id: 'UID' + secret: 'Secret' + secret_hashed: 'Secret hashed' + scopes: 'Scopes' + confidential: 'Confidential' + callback_urls: 'Callback urls' + actions: 'Actions' + not_defined: 'Not defined' + + authorizations: + buttons: + authorize: 'Authorize' + deny: 'Deny' + error: + title: 'An error has occurred' + new: + title: 'Authorization required' + prompt: 'Authorize %{client_name} to use your account?' + able_to: 'This application will be able to' + show: + title: 'Authorization code' + form_post: + title: 'Submit this form' + + authorized_applications: + confirmations: + revoke: 'Are you sure?' + buttons: + revoke: 'Revoke' + index: + title: 'Your authorized applications' + application: 'Application' + created_at: 'Created At' + date_format: '%Y-%m-%d %H:%M:%S' + + pre_authorization: + status: 'Pre-authorization' + + errors: + messages: + # Common error messages + invalid_request: + unknown: 'The request is missing a required parameter, includes an unsupported parameter value, or is otherwise malformed.' + missing_param: 'Missing required parameter: %{value}.' + request_not_authorized: 'Request need to be authorized. Required parameter for authorizing request is missing or invalid.' + invalid_redirect_uri: "The requested redirect uri is malformed or doesn't match client redirect URI." + unauthorized_client: 'The client is not authorized to perform this request using this method.' + access_denied: 'The resource owner or authorization server denied the request.' + invalid_scope: 'The requested scope is invalid, unknown, or malformed.' + invalid_code_challenge_method: 'The code challenge method must be plain or S256.' + server_error: 'The authorization server encountered an unexpected condition which prevented it from fulfilling the request.' + temporarily_unavailable: 'The authorization server is currently unable to handle the request due to a temporary overloading or maintenance of the server.' + + # Configuration error messages + credential_flow_not_configured: 'Resource Owner Password Credentials flow failed due to Doorkeeper.configure.resource_owner_from_credentials being unconfigured.' + resource_owner_authenticator_not_configured: 'Resource Owner find failed due to Doorkeeper.configure.resource_owner_authenticator being unconfigured.' + admin_authenticator_not_configured: 'Access to admin panel is forbidden due to Doorkeeper.configure.admin_authenticator being unconfigured.' + + # Access grant errors + unsupported_response_type: 'The authorization server does not support this response type.' + unsupported_response_mode: 'The authorization server does not support this response mode.' + + # Access token errors + invalid_client: 'Client authentication failed due to unknown client, no client authentication included, or unsupported authentication method.' + invalid_grant: 'The provided authorization grant is invalid, expired, revoked, does not match the redirection URI used in the authorization request, or was issued to another client.' + unsupported_grant_type: 'The authorization grant type is not supported by the authorization server.' + + invalid_token: + revoked: "The access token was revoked" + expired: "The access token expired" + unknown: "The access token is invalid" + revoke: + unauthorized: "You are not authorized to revoke this token" + + forbidden_token: + missing_scope: 'Access to this resource requires scope "%{oauth_scopes}".' + + flash: + applications: + create: + notice: 'Application created.' + destroy: + notice: 'Application deleted.' + update: + notice: 'Application updated.' + authorized_applications: + destroy: + notice: 'Application revoked.' + + layouts: + admin: + title: 'Doorkeeper' + nav: + oauth2_provider: 'OAuth2 Provider' + applications: 'Applications' + home: 'Home' + application: + title: 'OAuth authorization required' diff --git a/config/routes.rb b/config/routes.rb index 032b63f..1aee3e3 100644 --- a/config/routes.rb +++ b/config/routes.rb @@ -1,5 +1,8 @@ Rails.application.routes.draw do + use_doorkeeper do + skip_controllers :authorizations, :applications, :authorized_applications + end # Define your application routes per the DSL in https://guides.rubyonrails.org/routing.html devise_for :users @@ -9,4 +12,11 @@ get "/health_check", to: 'health_check#health_check', as: :rails_health_check resources :search_stats, only: [:index, :show] + + namespace :api do + namespace :v1 do + # User sign_up + resources :users, only: :create + end + end end diff --git a/db/migrate/20230615070454_create_doorkeeper_tables.rb b/db/migrate/20230615070454_create_doorkeeper_tables.rb new file mode 100644 index 0000000..e2cfac5 --- /dev/null +++ b/db/migrate/20230615070454_create_doorkeeper_tables.rb @@ -0,0 +1,76 @@ +# frozen_string_literal: true + +class CreateDoorkeeperTables < ActiveRecord::Migration[7.0] + def change + create_table :oauth_applications do |t| + t.string :name, null: false + t.string :uid, null: false + t.string :secret, null: false + + # Remove `null: false` if you are planning to use grant flows + # that doesn't require redirect URI to be used during authorization + # like Client Credentials flow or Resource Owner Password. + t.text :redirect_uri + t.string :scopes, null: false, default: '' + t.boolean :confidential, null: false, default: true + t.timestamps null: false + end + + add_index :oauth_applications, :uid, unique: true + + create_table :oauth_access_tokens do |t| + t.references :resource_owner, index: true + + # Remove `null: false` if you are planning to use Password + # Credentials Grant flow that doesn't require an application. + t.references :application, null: false + + # If you use a custom token generator you may need to change this column + # from string to text, so that it accepts tokens larger than 255 + # characters. More info on custom token generators in: + # https://github.com/doorkeeper-gem/doorkeeper/tree/v3.0.0.rc1#custom-access-token-generator + # + # t.text :token, null: false + t.string :token, null: false + + t.string :refresh_token + t.integer :expires_in + t.string :scopes + t.datetime :created_at, null: false + t.datetime :revoked_at + + # The authorization server MAY issue a new refresh token, in which case + # *the client MUST discard the old refresh token* and replace it with the + # new refresh token. The authorization server MAY revoke the old + # refresh token after issuing a new refresh token to the client. + # @see https://datatracker.ietf.org/doc/html/rfc6749#section-6 + # + # Doorkeeper implementation: if there is a `previous_refresh_token` column, + # refresh tokens will be revoked after a related access token is used. + # If there is no `previous_refresh_token` column, previous tokens are + # revoked as soon as a new access token is created. + # + # Comment out this line if you want refresh tokens to be instantly + # revoked after use. + t.string :previous_refresh_token, null: false, default: "" + end + + add_index :oauth_access_tokens, :token, unique: true + + # See https://github.com/doorkeeper-gem/doorkeeper/issues/1592 + if ActiveRecord::Base.connection.adapter_name == "SQLServer" + execute <<~SQL.squish + CREATE UNIQUE NONCLUSTERED INDEX index_oauth_access_tokens_on_refresh_token ON oauth_access_tokens(refresh_token) + WHERE refresh_token IS NOT NULL + SQL + else + add_index :oauth_access_tokens, :refresh_token, unique: true + end + + add_foreign_key( + :oauth_access_tokens, + :oauth_applications, + column: :application_id + ) + end +end diff --git a/db/schema.rb b/db/schema.rb index 5f377a0..fd91cf5 100644 --- a/db/schema.rb +++ b/db/schema.rb @@ -10,12 +10,40 @@ # # It's strongly recommended that you check this file into your version control system. -ActiveRecord::Schema.define(version: 2023_06_12_121926) do +ActiveRecord::Schema.define(version: 2023_06_15_070454) do # These are extensions that must be enabled in order to support this database enable_extension "citext" enable_extension "plpgsql" + create_table "oauth_access_tokens", force: :cascade do |t| + t.bigint "resource_owner_id" + t.bigint "application_id", null: false + t.string "token", null: false + t.string "refresh_token" + t.integer "expires_in" + t.string "scopes" + t.datetime "created_at", precision: 6, null: false + t.datetime "revoked_at", precision: 6 + t.string "previous_refresh_token", default: "", null: false + t.index ["application_id"], name: "index_oauth_access_tokens_on_application_id" + t.index ["refresh_token"], name: "index_oauth_access_tokens_on_refresh_token", unique: true + t.index ["resource_owner_id"], name: "index_oauth_access_tokens_on_resource_owner_id" + t.index ["token"], name: "index_oauth_access_tokens_on_token", unique: true + end + + create_table "oauth_applications", force: :cascade do |t| + t.string "name", null: false + t.string "uid", null: false + t.string "secret", null: false + t.text "redirect_uri" + t.string "scopes", default: "", null: false + t.boolean "confidential", default: true, null: false + t.datetime "created_at", precision: 6, null: false + t.datetime "updated_at", precision: 6, null: false + t.index ["uid"], name: "index_oauth_applications_on_uid", unique: true + end + create_table "result_links", force: :cascade do |t| t.bigint "search_stat_id", null: false t.string "link_type", null: false @@ -54,6 +82,7 @@ t.index ["reset_password_token"], name: "index_users_on_reset_password_token", unique: true end + add_foreign_key "oauth_access_tokens", "oauth_applications", column: "application_id" add_foreign_key "result_links", "search_stats" add_foreign_key "search_stats", "users" end diff --git a/db/seeds.rb b/db/seeds.rb index 5ebbdc8..ebf87fe 100644 --- a/db/seeds.rb +++ b/db/seeds.rb @@ -8,6 +8,12 @@ require 'fabrication' +# if there is no OAuth application created, create them +if Doorkeeper::Application.count.zero? + Doorkeeper::Application.create(name: "iOS client", redirect_uri: "", scopes: "") + Doorkeeper::Application.create(name: "Android client", redirect_uri: "", scopes: "") +end + # Generate dummy data for SearchStat user = User.where(email: 'user@demo.com').first_or_create(Fabricate.attributes_for(:user, email: 'user@demo.com')) diff --git a/spec/fabricators/application_fabricator.rb b/spec/fabricators/application_fabricator.rb new file mode 100644 index 0000000..257c085 --- /dev/null +++ b/spec/fabricators/application_fabricator.rb @@ -0,0 +1,5 @@ +# frozen_string_literal: true + +Fabricator(:application, from: Doorkeeper::Application) do + name 'Android client' +end diff --git a/spec/fabricators/search_stat_fabricator.rb b/spec/fabricators/search_stat_fabricator.rb index d39524c..da3e360 100644 --- a/spec/fabricators/search_stat_fabricator.rb +++ b/spec/fabricators/search_stat_fabricator.rb @@ -11,5 +11,5 @@ top_ad_count { rand(1..5) } status { rand(1..3) } raw_response { FFaker::HTMLIpsum.body } - user_id { demo_user.id } + user { demo_user } end diff --git a/spec/requests/api/v1/users_controller_spec.rb b/spec/requests/api/v1/users_controller_spec.rb new file mode 100644 index 0000000..9ad819c --- /dev/null +++ b/spec/requests/api/v1/users_controller_spec.rb @@ -0,0 +1,48 @@ +# frozen_string_literal: true + +require 'rails_helper' + +RSpec.describe Api::V1::UsersController, type: :request do + describe 'POST /api/v1/users' do + context 'when a user registers' do + let(:create_user_params) do + application ||= Fabricate(:application) + { + email: 'dummy@dummy.com', + password: 'aaaaaaA1', + client_id: application.uid + } + end + + context 'given valid params' do + it 'returns the user' do + post '/api/v1/users', params: create_user_params + expect(JSON.parse(response.body)['user']['email']).to eq('dummy@dummy.com') + expect(response).to have_http_status(:success) + end + end + + context 'given an existing email' do + it 'receives an error' do + User.create(email: 'user@demo.com', password: 'Secret@11') + post '/api/v1/users', params: create_user_params.merge(email: 'user@demo.com') + expect(JSON.parse(response.body).keys).to contain_exactly('error') + end + end + + context 'given an invalid password' do + it 'receives an error' do + post '/api/v1/users', params: create_user_params.merge(password: '123') + expect(JSON.parse(response.body).keys).to contain_exactly('error') + end + end + + context 'given an invalid client_id' do + it 'receives an error' do + post '/api/v1/users', params: create_user_params.merge(client_id: 'not valid') + expect(JSON.parse(response.body).keys).to contain_exactly('error') + end + end + end + end +end From f60450711e22477ec9d7fb0976e0d4b6a5b2a4d0 Mon Sep 17 00:00:00 2001 From: Md Mosharaf Hossan Date: Thu, 15 Jun 2023 18:06:51 +0700 Subject: [PATCH 3/4] [#18] Remove unnecessary comments from doorkeeper initializer --- config/initializers/doorkeeper.rb | 485 ------------------------------ 1 file changed, 485 deletions(-) diff --git a/config/initializers/doorkeeper.rb b/config/initializers/doorkeeper.rb index 8df0a68..53741db 100644 --- a/config/initializers/doorkeeper.rb +++ b/config/initializers/doorkeeper.rb @@ -15,497 +15,12 @@ resource_owner_from_credentials do |_routes| User.authenticate(params[:email], params[:password]) end - # If you didn't skip applications controller from Doorkeeper routes in your application routes.rb - # file then you need to declare this block in order to restrict access to the web interface for - # adding oauth authorized applications. In other case it will return 403 Forbidden response - # every time somebody will try to access the admin web interface. - # - # admin_authenticator do - # # Put your admin authentication logic here. - # # Example implementation: - # - # if current_user - # head :forbidden unless current_user.admin? - # else - # redirect_to sign_in_url - # end - # end - # You can use your own model classes if you need to extend (or even override) default - # Doorkeeper models such as `Application`, `AccessToken` and `AccessGrant. - # - # Be default Doorkeeper ActiveRecord ORM uses it's own classes: - # - # access_token_class "Doorkeeper::AccessToken" - # access_grant_class "Doorkeeper::AccessGrant" - # application_class "Doorkeeper::Application" - # - # Don't forget to include Doorkeeper ORM mixins into your custom models: - # - # * ::Doorkeeper::Orm::ActiveRecord::Mixins::AccessToken - for access token - # * ::Doorkeeper::Orm::ActiveRecord::Mixins::AccessGrant - for access grant - # * ::Doorkeeper::Orm::ActiveRecord::Mixins::Application - for application (OAuth2 clients) - # - # For example: - # - # access_token_class "MyAccessToken" - # - # class MyAccessToken < ApplicationRecord - # include ::Doorkeeper::Orm::ActiveRecord::Mixins::AccessToken - # - # self.table_name = "hey_i_wanna_my_name" - # - # def destroy_me! - # destroy - # end - # end - - # Enables polymorphic Resource Owner association for Access Tokens and Access Grants. - # By default this option is disabled. - # - # Make sure you properly setup you database and have all the required columns (run - # `bundle exec rails generate doorkeeper:enable_polymorphic_resource_owner` and execute Rails - # migrations). - # - # If this option enabled, Doorkeeper will store not only Resource Owner primary key - # value, but also it's type (class name). See "Polymorphic Associations" section of - # Rails guides: https://guides.rubyonrails.org/association_basics.html#polymorphic-associations - # - # [NOTE] If you apply this option on already existing project don't forget to manually - # update `resource_owner_type` column in the database and fix migration template as it will - # set NOT NULL constraint for Access Grants table. - # - # use_polymorphic_resource_owner - - # If you are planning to use Doorkeeper in Rails 5 API-only application, then you might - # want to use API mode that will skip all the views management and change the way how - # Doorkeeper responds to a requests. - # - # api_only - - # Enforce token request content type to application/x-www-form-urlencoded. - # It is not enabled by default to not break prior versions of the gem. - # - # enforce_content_type - - # Authorization Code expiration time (default: 10 minutes). - # - # authorization_code_expires_in 10.minutes - - # Access token expiration time (default: 2 hours). - # If you want to disable expiration, set this to `nil`. - # - # access_token_expires_in 2.hours - - # Assign custom TTL for access tokens. Will be used instead of access_token_expires_in - # option if defined. In case the block returns `nil` value Doorkeeper fallbacks to - # +access_token_expires_in+ configuration option value. If you really need to issue a - # non-expiring access token (which is not recommended) then you need to return - # Float::INFINITY from this block. - # - # `context` has the following properties available: - # - # * `client` - the OAuth client application (see Doorkeeper::OAuth::Client) - # * `grant_type` - the grant type of the request (see Doorkeeper::OAuth) - # * `scopes` - the requested scopes (see Doorkeeper::OAuth::Scopes) - # * `resource_owner` - authorized resource owner instance (if present) - # - # custom_access_token_expires_in do |context| - # context.client.additional_settings.implicit_oauth_expiration - # end - - # Use a custom class for generating the access token. - # See https://doorkeeper.gitbook.io/guides/configuration/other-configurations#custom-access-token-generator - # - # access_token_generator '::Doorkeeper::JWT' - - # The controller +Doorkeeper::ApplicationController+ inherits from. - # Defaults to +ActionController::Base+ unless +api_only+ is set, which changes the default to - # +ActionController::API+. The return value of this option must be a stringified class name. - # See https://doorkeeper.gitbook.io/guides/configuration/other-configurations#custom-controllers - # - # base_controller 'ApplicationController' - - # Reuse access token for the same resource owner within an application (disabled by default). - # - # This option protects your application from creating new tokens before old **valid** one becomes - # expired so your database doesn't bloat. Keep in mind that when this option is enabled Doorkeeper - # doesn't update existing token expiration time, it will create a new token instead if no active matching - # token found for the application, resources owner and/or set of scopes. - # Rationale: https://github.com/doorkeeper-gem/doorkeeper/issues/383 - # - # You can not enable this option together with +hash_token_secrets+. - # - # reuse_access_token - - # In case you enabled `reuse_access_token` option Doorkeeper will try to find matching - # token using `matching_token_for` Access Token API that searches for valid records - # in batches in order not to pollute the memory with all the database records. By default - # Doorkeeper uses batch size of 10 000 records. You can increase or decrease this value - # depending on your needs and server capabilities. - # - # token_lookup_batch_size 10_000 - - # Set a limit for token_reuse if using reuse_access_token option - # - # This option limits token_reusability to some extent. - # If not set then access_token will be reused unless it expires. - # Rationale: https://github.com/doorkeeper-gem/doorkeeper/issues/1189 - # - # This option should be a percentage(i.e. (0,100]) - # - # token_reuse_limit 100 - - # Only allow one valid access token obtained via client credentials - # per client. If a new access token is obtained before the old one - # expired, the old one gets revoked (disabled by default) - # - # When enabling this option, make sure that you do not expect multiple processes - # using the same credentials at the same time (e.g. web servers spanning - # multiple machines and/or processes). - # - # revoke_previous_client_credentials_token - - # Hash access and refresh tokens before persisting them. - # This will disable the possibility to use +reuse_access_token+ - # since plain values can no longer be retrieved. - # - # Note: If you are already a user of doorkeeper and have existing tokens - # in your installation, they will be invalid without adding 'fallback: :plain'. - # - # hash_token_secrets - # By default, token secrets will be hashed using the - # +Doorkeeper::Hashing::SHA256+ strategy. - # - # If you wish to use another hashing implementation, you can override - # this strategy as follows: - # - # hash_token_secrets using: '::Doorkeeper::Hashing::MyCustomHashImpl' - # - # Keep in mind that changing the hashing function will invalidate all existing - # secrets, if there are any. - - # Hash application secrets before persisting them. - # - # hash_application_secrets - # - # By default, applications will be hashed - # with the +Doorkeeper::SecretStoring::SHA256+ strategy. - # - # If you wish to use bcrypt for application secret hashing, uncomment - # this line instead: - # - # hash_application_secrets using: '::Doorkeeper::SecretStoring::BCrypt' - - # When the above option is enabled, and a hashed token or secret is not found, - # you can allow to fall back to another strategy. For users upgrading - # doorkeeper and wishing to enable hashing, you will probably want to enable - # the fallback to plain tokens. - # - # This will ensure that old access tokens and secrets - # will remain valid even if the hashing above is enabled. - # - # This can be done by adding 'fallback: plain', e.g. : - # - # hash_application_secrets using: '::Doorkeeper::SecretStoring::BCrypt', fallback: :plain - - # Issue access tokens with refresh token (disabled by default), you may also - # pass a block which accepts `context` to customize when to give a refresh - # token or not. Similar to +custom_access_token_expires_in+, `context` has - # the following properties: - # - # `client` - the OAuth client application (see Doorkeeper::OAuth::Client) - # `grant_type` - the grant type of the request (see Doorkeeper::OAuth) - # `scopes` - the requested scopes (see Doorkeeper::OAuth::Scopes) - # use_refresh_token - - # Provide support for an owner to be assigned to each registered application (disabled by default) - # Optional parameter confirmation: true (default: false) if you want to enforce ownership of - # a registered application - # NOTE: you must also run the rails g doorkeeper:application_owner generator - # to provide the necessary support - # - # enable_application_owner confirmation: false - - # Define access token scopes for your provider - # For more information go to - # https://doorkeeper.gitbook.io/guides/ruby-on-rails/scopes - # - # default_scopes :public - # optional_scopes :write, :update - - # Allows to restrict only certain scopes for grant_type. - # By default, all the scopes will be available for all the grant types. - # - # Keys to this hash should be the name of grant_type and - # values should be the array of scopes for that grant type. - # Note: scopes should be from configured_scopes (i.e. default or optional) - # - # scopes_by_grant_type password: [:write], client_credentials: [:update] - - # Forbids creating/updating applications with arbitrary scopes that are - # not in configuration, i.e. +default_scopes+ or +optional_scopes+. - # (disabled by default) - # - # enforce_configured_scopes - - # Change the way client credentials are retrieved from the request object. - # By default it retrieves first from the `HTTP_AUTHORIZATION` header, then - # falls back to the `:client_id` and `:client_secret` params from the `params` object. - # Check out https://github.com/doorkeeper-gem/doorkeeper/wiki/Changing-how-clients-are-authenticated - # for more information on customization - # - # client_credentials :from_basic, :from_params - - # Change the way access token is authenticated from the request object. - # By default it retrieves first from the `HTTP_AUTHORIZATION` header, then - # falls back to the `:access_token` or `:bearer_token` params from the `params` object. - # Check out https://github.com/doorkeeper-gem/doorkeeper/wiki/Changing-how-clients-are-authenticated - # for more information on customization - # - # access_token_methods :from_bearer_authorization, :from_access_token_param, :from_bearer_param - - # Forces the usage of the HTTPS protocol in non-native redirect uris (enabled - # by default in non-development environments). OAuth2 delegates security in - # communication to the HTTPS protocol so it is wise to keep this enabled. - # - # Callable objects such as proc, lambda, block or any object that responds to - # #call can be used in order to allow conditional checks (to allow non-SSL - # redirects to localhost for example). - # - # force_ssl_in_redirect_uri !Rails.env.development? - # - # force_ssl_in_redirect_uri { |uri| uri.host != 'localhost' } - - # Specify what redirect URI's you want to block during Application creation. - # Any redirect URI is allowed by default. - # - # You can use this option in order to forbid URI's with 'javascript' scheme - # for example. - # - # forbid_redirect_uri { |uri| uri.scheme.to_s.downcase == 'javascript' } - - # Allows to set blank redirect URIs for Applications in case Doorkeeper configured - # to use URI-less OAuth grant flows like Client Credentials or Resource Owner - # Password Credentials. The option is on by default and checks configured grant - # types, but you **need** to manually drop `NOT NULL` constraint from `redirect_uri` - # column for `oauth_applications` database table. - # - # You can completely disable this feature with: - # allow_blank_redirect_uri true - # - # Or you can define your custom check: - # - # allow_blank_redirect_uri do |grant_flows, client| - # client.superapp? - # end - - # Specify how authorization errors should be handled. - # By default, doorkeeper renders json errors when access token - # is invalid, expired, revoked or has invalid scopes. - # - # If you want to render error response yourself (i.e. rescue exceptions), - # set +handle_auth_errors+ to `:raise` and rescue Doorkeeper::Errors::InvalidToken - # or following specific errors: - # - # Doorkeeper::Errors::TokenForbidden, Doorkeeper::Errors::TokenExpired, - # Doorkeeper::Errors::TokenRevoked, Doorkeeper::Errors::TokenUnknown - # - # handle_auth_errors :raise - - # Customize token introspection response. - # Allows to add your own fields to default one that are required by the OAuth spec - # for the introspection response. It could be `sub`, `aud` and so on. - # This configuration option can be a proc, lambda or any Ruby object responds - # to `.call` method and result of it's invocation must be a Hash. - # - # custom_introspection_response do |token, context| - # { - # "sub": "Z5O3upPC88QrAjx00dis", - # "aud": "https://protected.example.net/resource", - # "username": User.find(token.resource_owner_id).username - # } - # end - # - # or - # - # custom_introspection_response CustomIntrospectionResponder - - # Specify what grant flows are enabled in array of Strings. The valid - # strings and the flows they enable are: - # - # "authorization_code" => Authorization Code Grant Flow - # "implicit" => Implicit Grant Flow - # "password" => Resource Owner Password Credentials Grant Flow - # "client_credentials" => Client Credentials Grant Flow - # - # If not specified, Doorkeeper enables authorization_code and - # client_credentials. - # - # implicit and password grant flows have risks that you should understand - # before enabling: - # https://datatracker.ietf.org/doc/html/rfc6819#section-4.4.2 - # https://datatracker.ietf.org/doc/html/rfc6819#section-4.4.3 - # grant_flows %w[password] - - # Allows to customize OAuth grant flows that +each+ application support. - # You can configure a custom block (or use a class respond to `#call`) that must - # return `true` in case Application instance supports requested OAuth grant flow - # during the authorization request to the server. This configuration +doesn't+ - # set flows per application, it only allows to check if application supports - # specific grant flow. - # - # For example you can add an additional database column to `oauth_applications` table, - # say `t.array :grant_flows, default: []`, and store allowed grant flows that can - # be used with this application there. Then when authorization requested Doorkeeper - # will call this block to check if specific Application (passed with client_id and/or - # client_secret) is allowed to perform the request for the specific grant type - # (authorization, password, client_credentials, etc). - # - # Example of the block: - # - # ->(flow, client) { client.grant_flows.include?(flow) } - # - # In case this option invocation result is `false`, Doorkeeper server returns - # :unauthorized_client error and stops the request. - # - # @param allow_grant_flow_for_client [Proc] Block or any object respond to #call - # @return [Boolean] `true` if allow or `false` if forbid the request - # - # allow_grant_flow_for_client do |grant_flow, client| - # # `grant_flows` is an Array column with grant - # # flows that application supports - # - # client.grant_flows.include?(grant_flow) - # end - - # If you need arbitrary Resource Owner-Client authorization you can enable this option - # and implement the check your need. Config option must respond to #call and return - # true in case resource owner authorized for the specific application or false in other - # cases. - # - # Be default all Resource Owners are authorized to any Client (application). - # - # authorize_resource_owner_for_client do |client, resource_owner| - # resource_owner.admin? || client.owners_allowlist.include?(resource_owner) - # end - - # Allows additional data fields to be sent while granting access to an application, - # and for this additional data to be included in subsequently generated access tokens. - # The 'authorizations/new' page will need to be overridden to include this additional data - # in the request params when granting access. The access grant and access token models - # will both need to respond to these additional data fields, and have a database column - # to store them in. - # - # Example: - # You have a multi-tenanted platform and want to be able to grant access to a specific - # tenant, rather than all the tenants a user has access to. You can use this config - # option to specify that a ':tenant_id' will be passed when authorizing. This tenant_id - # will be included in the access tokens. When a request is made with one of these access - # tokens, you can check that the requested data belongs to the specified tenant. - # - # Default value is an empty Array: [] - # custom_access_token_attributes [:tenant_id] - - # Hook into the strategies' request & response life-cycle in case your - # application needs advanced customization or logging: - # - # before_successful_strategy_response do |request| - # puts "BEFORE HOOK FIRED! #{request}" - # end - # - # after_successful_strategy_response do |request, response| - # puts "AFTER HOOK FIRED! #{request}, #{response}" - # end - - # Hook into Authorization flow in order to implement Single Sign Out - # or add any other functionality. Inside the block you have an access - # to `controller` (authorizations controller instance) and `context` - # (Doorkeeper::OAuth::Hooks::Context instance) which provides pre auth - # or auth objects with issued token based on hook type (before or after). - # - # before_successful_authorization do |controller, context| - # Rails.logger.info(controller.request.params.inspect) - # - # Rails.logger.info(context.pre_auth.inspect) - # end - # - # after_successful_authorization do |controller, context| - # controller.session[:logout_urls] << - # Doorkeeper::Application - # .find_by(controller.request.params.slice(:redirect_uri)) - # .logout_uri - # - # Rails.logger.info(context.auth.inspect) - # Rails.logger.info(context.issued_token) - # end - - # Under some circumstances you might want to have applications auto-approved, - # so that the user skips the authorization step. - # For example if dealing with a trusted application. - # skip_authorization do |resource_owner, client| true end - # Configure custom constraints for the Token Introspection request. - # By default this configuration option allows to introspect a token by another - # token of the same application, OR to introspect the token that belongs to - # authorized client (from authenticated client) OR when token doesn't - # belong to any client (public token). Otherwise requester has no access to the - # introspection and it will return response as stated in the RFC. - # - # Block arguments: - # - # @param token [Doorkeeper::AccessToken] - # token to be introspected - # - # @param authorized_client [Doorkeeper::Application] - # authorized client (if request is authorized using Basic auth with - # Client Credentials for example) - # - # @param authorized_token [Doorkeeper::AccessToken] - # Bearer token used to authorize the request - # - # In case the block returns `nil` or `false` introspection responses with 401 status code - # when using authorized token to introspect, or you'll get 200 with { "active": false } body - # when using authorized client to introspect as stated in the - # RFC 7662 section 2.2. Introspection Response. - # - # Using with caution: - # Keep in mind that these three parameters pass to block can be nil as following case: - # `authorized_client` is nil if and only if `authorized_token` is present, and vice versa. - # `token` will be nil if and only if `authorized_token` is present. - # So remember to use `&` or check if it is present before calling method on - # them to make sure you doesn't get NoMethodError exception. - # - # You can define your custom check: - # - # allow_token_introspection do |token, authorized_client, authorized_token| - # if authorized_token - # # customize: require `introspection` scope - # authorized_token.application == token&.application || - # authorized_token.scopes.include?("introspection") - # elsif token.application - # # `protected_resource` is a new database boolean column, for example - # authorized_client == token.application || authorized_client.protected_resource? - # else - # # public token (when token.application is nil, token doesn't belong to any application) - # true - # end - # end - # - # Or you can completely disable any token introspection: - # - # allow_token_introspection false - # - # If you need to block the request at all, then configure your routes.rb or web-server - # like nginx to forbid the request. - - # WWW-Authenticate Realm (default: "Doorkeeper"). - # - # realm "Doorkeeper" end From 4964688f46ed1299386890c0d436a6aca412a4e5 Mon Sep 17 00:00:00 2001 From: Md Mosharaf Hossan Date: Wed, 21 Jun 2023 09:34:21 +0700 Subject: [PATCH 4/4] Update Gemfile Co-authored-by: Sang Huynh Thanh <63148598+sanG-github@users.noreply.github.com> --- Gemfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Gemfile b/Gemfile index e06198e..282fa0b 100644 --- a/Gemfile +++ b/Gemfile @@ -19,7 +19,7 @@ gem 'devise' # Flexible authentication solution for Rails with Warden # Authentications & Authorizations gem 'pundit' # Minimal authorization through OO design and pure Ruby classes -gem 'doorkeeper' # Awesome OAuth 2 provider for your Rails / Grape app +gem 'doorkeeper' # OAuth 2 provider for your Rails / Grape app # Assets gem 'sassc'