]> git.openstreetmap.org Git - rails.git/blob - config/initializers/doorkeeper.rb
bc70f02f03a35aca3d73305a249312dfa724a16d
[rails.git] / config / initializers / doorkeeper.rb
1 # frozen_string_literal: true
2
3 Doorkeeper.configure do
4   # Change the ORM that doorkeeper will use (requires ORM extensions installed).
5   # Check the list of supported ORMs here: https://github.com/doorkeeper-gem/doorkeeper#orms
6   orm :active_record
7
8   # This block will be called to check whether the resource owner is authenticated or not.
9   resource_owner_authenticator do
10     current_user
11   end
12
13   # If you didn't skip applications controller from Doorkeeper routes in your application routes.rb
14   # file then you need to declare this block in order to restrict access to the web interface for
15   # adding oauth authorized applications. In other case it will return 403 Forbidden response
16   # every time somebody will try to access the admin web interface.
17
18   admin_authenticator do
19     current_user
20   end
21
22   # You can use your own model classes if you need to extend (or even override) default
23   # Doorkeeper models such as `Application`, `AccessToken` and `AccessGrant.
24   #
25   # Be default Doorkeeper ActiveRecord ORM uses it's own classes:
26   #
27   # access_token_class "Doorkeeper::AccessToken"
28   # access_grant_class "Doorkeeper::AccessGrant"
29   # application_class "Doorkeeper::Application"
30   #
31   # Don't forget to include Doorkeeper ORM mixins into your custom models:
32   #
33   #   *  ::Doorkeeper::Orm::ActiveRecord::Mixins::AccessToken - for access token
34   #   *  ::Doorkeeper::Orm::ActiveRecord::Mixins::AccessGrant - for access grant
35   #   *  ::Doorkeeper::Orm::ActiveRecord::Mixins::Application - for application (OAuth2 clients)
36   #
37   # For example:
38   #
39   # access_token_class "MyAccessToken"
40   #
41   # class MyAccessToken < ApplicationRecord
42   #   include ::Doorkeeper::Orm::ActiveRecord::Mixins::AccessToken
43   #
44   #   self.table_name = "hey_i_wanna_my_name"
45   #
46   #   def destroy_me!
47   #     destroy
48   #   end
49   # end
50
51   # Enables polymorphic Resource Owner association for Access Tokens and Access Grants.
52   # By default this option is disabled.
53   #
54   # Make sure you properly setup you database and have all the required columns (run
55   # `bundle exec rails generate doorkeeper:enable_polymorphic_resource_owner` and execute Rails
56   # migrations).
57   #
58   # If this option enabled, Doorkeeper will store not only Resource Owner primary key
59   # value, but also it's type (class name). See "Polymorphic Associations" section of
60   # Rails guides: https://guides.rubyonrails.org/association_basics.html#polymorphic-associations
61   #
62   # [NOTE] If you apply this option on already existing project don't forget to manually
63   # update `resource_owner_type` column in the database and fix migration template as it will
64   # set NOT NULL constraint for Access Grants table.
65   #
66   # use_polymorphic_resource_owner
67
68   # If you are planning to use Doorkeeper in Rails 5 API-only application, then you might
69   # want to use API mode that will skip all the views management and change the way how
70   # Doorkeeper responds to a requests.
71   #
72   # api_only
73
74   # Enforce token request content type to application/x-www-form-urlencoded.
75   # It is not enabled by default to not break prior versions of the gem.
76
77   enforce_content_type
78
79   # Authorization Code expiration time (default: 10 minutes).
80   #
81   # authorization_code_expires_in 10.minutes
82
83   # Access token expiration time (default: 2 hours).
84   # If you want to disable expiration, set this to `nil`.
85
86   access_token_expires_in nil
87
88   # Assign custom TTL for access tokens. Will be used instead of access_token_expires_in
89   # option if defined. In case the block returns `nil` value Doorkeeper fallbacks to
90   # +access_token_expires_in+ configuration option value. If you really need to issue a
91   # non-expiring access token (which is not recommended) then you need to return
92   # Float::INFINITY from this block.
93   #
94   # `context` has the following properties available:
95   #
96   # `client` - the OAuth client application (see Doorkeeper::OAuth::Client)
97   # `grant_type` - the grant type of the request (see Doorkeeper::OAuth)
98   # `scopes` - the requested scopes (see Doorkeeper::OAuth::Scopes)
99   #
100   # custom_access_token_expires_in do |context|
101   #   context.client.application.additional_settings.implicit_oauth_expiration
102   # end
103
104   # Use a custom class for generating the access token.
105   # See https://doorkeeper.gitbook.io/guides/configuration/other-configurations#custom-access-token-generator
106   #
107   # access_token_generator '::Doorkeeper::JWT'
108
109   # The controller +Doorkeeper::ApplicationController+ inherits from.
110   # Defaults to +ActionController::Base+ unless +api_only+ is set, which changes the default to
111   # +ActionController::API+. The return value of this option must be a stringified class name.
112   # See https://doorkeeper.gitbook.io/guides/configuration/other-configurations#custom-base-controller
113
114   base_controller "ApplicationController"
115
116   # Reuse access token for the same resource owner within an application (disabled by default).
117   #
118   # This option protects your application from creating new tokens before old valid one becomes
119   # expired so your database doesn't bloat. Keep in mind that when this option is `on` Doorkeeper
120   # doesn't updates existing token expiration time, it will create a new token instead.
121   # Rationale: https://github.com/doorkeeper-gem/doorkeeper/issues/383
122   #
123   # You can not enable this option together with +hash_token_secrets+.
124   #
125   # reuse_access_token
126
127   # In case you enabled `reuse_access_token` option Doorkeeper will try to find matching
128   # token using `matching_token_for` Access Token API that searches for valid records
129   # in batches in order not to pollute the memory with all the database records. By default
130   # Doorkeeper uses batch size of 10 000 records. You can increase or decrease this value
131   # depending on your needs and server capabilities.
132   #
133   # token_lookup_batch_size 10_000
134
135   # Set a limit for token_reuse if using reuse_access_token option
136   #
137   # This option limits token_reusability to some extent.
138   # If not set then access_token will be reused unless it expires.
139   # Rationale: https://github.com/doorkeeper-gem/doorkeeper/issues/1189
140   #
141   # This option should be a percentage(i.e. (0,100])
142   #
143   # token_reuse_limit 100
144
145   # Only allow one valid access token obtained via client credentials
146   # per client. If a new access token is obtained before the old one
147   # expired, the old one gets revoked (disabled by default)
148   #
149   # When enabling this option, make sure that you do not expect multiple processes
150   # using the same credentials at the same time (e.g. web servers spanning
151   # multiple machines and/or processes).
152   #
153   # revoke_previous_client_credentials_token
154
155   # Hash access and refresh tokens before persisting them.
156   # This will disable the possibility to use +reuse_access_token+
157   # since plain values can no longer be retrieved.
158   #
159   # Note: If you are already a user of doorkeeper and have existing tokens
160   # in your installation, they will be invalid without enabling the additional
161   # setting `fallback_to_plain_secrets` below.
162
163   hash_token_secrets
164
165   # Hash application secrets before persisting them.
166
167   hash_application_secrets
168
169   # When the above option is enabled, and a hashed token or secret is not found,
170   # you can allow to fall back to another strategy. For users upgrading
171   # doorkeeper and wishing to enable hashing, you will probably want to enable
172   # the fallback to plain tokens.
173   #
174   # This will ensure that old access tokens and secrets
175   # will remain valid even if the hashing above is enabled.
176   #
177   # fallback_to_plain_secrets
178
179   # Issue access tokens with refresh token (disabled by default), you may also
180   # pass a block which accepts `context` to customize when to give a refresh
181   # token or not. Similar to +custom_access_token_expires_in+, `context` has
182   # the following properties:
183   #
184   # `client` - the OAuth client application (see Doorkeeper::OAuth::Client)
185   # `grant_type` - the grant type of the request (see Doorkeeper::OAuth)
186   # `scopes` - the requested scopes (see Doorkeeper::OAuth::Scopes)
187   #
188   # use_refresh_token
189
190   # Provide support for an owner to be assigned to each registered application (disabled by default)
191   # Optional parameter confirmation: true (default: false) if you want to enforce ownership of
192   # a registered application
193   # NOTE: you must also run the rails g doorkeeper:application_owner generator
194   # to provide the necessary support
195
196   enable_application_owner :confirmation => true
197
198   # Define access token scopes for your provider
199   # For more information go to
200   # https://doorkeeper.gitbook.io/guides/ruby-on-rails/scopes
201
202   # default_scopes  :public
203   optional_scopes(*Oauth::SCOPES)
204
205   # Allows to restrict only certain scopes for grant_type.
206   # By default, all the scopes will be available for all the grant types.
207   #
208   # Keys to this hash should be the name of grant_type and
209   # values should be the array of scopes for that grant type.
210   # Note: scopes should be from configured_scopes (i.e. default or optional)
211   #
212   # scopes_by_grant_type password: [:write], client_credentials: [:update]
213
214   # Forbids creating/updating applications with arbitrary scopes that are
215   # not in configuration, i.e. +default_scopes+ or +optional_scopes+.
216   # (disabled by default)
217
218   enforce_configured_scopes
219
220   # Change the way client credentials are retrieved from the request object.
221   # By default it retrieves first from the `HTTP_AUTHORIZATION` header, then
222   # falls back to the `:client_id` and `:client_secret` params from the `params` object.
223   # Check out https://github.com/doorkeeper-gem/doorkeeper/wiki/Changing-how-clients-are-authenticated
224   # for more information on customization
225   #
226   # client_credentials :from_basic, :from_params
227
228   # Change the way access token is authenticated from the request object.
229   # By default it retrieves first from the `HTTP_AUTHORIZATION` header, then
230   # falls back to the `:access_token` or `:bearer_token` params from the `params` object.
231   # Check out https://github.com/doorkeeper-gem/doorkeeper/wiki/Changing-how-clients-are-authenticated
232   # for more information on customization
233
234   access_token_methods :from_bearer_authorization
235
236   # Forces the usage of the HTTPS protocol in non-native redirect uris (enabled
237   # by default in non-development environments). OAuth2 delegates security in
238   # communication to the HTTPS protocol so it is wise to keep this enabled.
239   #
240   # Callable objects such as proc, lambda, block or any object that responds to
241   # #call can be used in order to allow conditional checks (to allow non-SSL
242   # redirects to localhost for example).
243
244   force_ssl_in_redirect_uri !Rails.env.development?
245
246   # Specify what redirect URI's you want to block during Application creation.
247   # Any redirect URI is whitelisted by default.
248   #
249   # You can use this option in order to forbid URI's with 'javascript' scheme
250   # for example.
251   #
252   # forbid_redirect_uri { |uri| uri.scheme.to_s.downcase == 'javascript' }
253
254   # Allows to set blank redirect URIs for Applications in case Doorkeeper configured
255   # to use URI-less OAuth grant flows like Client Credentials or Resource Owner
256   # Password Credentials. The option is on by default and checks configured grant
257   # types, but you **need** to manually drop `NOT NULL` constraint from `redirect_uri`
258   # column for `oauth_applications` database table.
259   #
260   # You can completely disable this feature with:
261   #
262   # allow_blank_redirect_uri false
263   #
264   # Or you can define your custom check:
265   #
266   # allow_blank_redirect_uri do |grant_flows, client|
267   #   client.superapp?
268   # end
269
270   # Specify how authorization errors should be handled.
271   # By default, doorkeeper renders json errors when access token
272   # is invalid, expired, revoked or has invalid scopes.
273   #
274   # If you want to render error response yourself (i.e. rescue exceptions),
275   # set +handle_auth_errors+ to `:raise` and rescue Doorkeeper::Errors::InvalidToken
276   # or following specific errors:
277   #
278   #   Doorkeeper::Errors::TokenForbidden, Doorkeeper::Errors::TokenExpired,
279   #   Doorkeeper::Errors::TokenRevoked, Doorkeeper::Errors::TokenUnknown
280   #
281   # handle_auth_errors :raise
282
283   # Customize token introspection response.
284   # Allows to add your own fields to default one that are required by the OAuth spec
285   # for the introspection response. It could be `sub`, `aud` and so on.
286   # This configuration option can be a proc, lambda or any Ruby object responds
287   # to `.call` method and result of it's invocation must be a Hash.
288   #
289   # custom_introspection_response do |token, context|
290   #   {
291   #     "sub": "Z5O3upPC88QrAjx00dis",
292   #     "aud": "https://protected.example.net/resource",
293   #     "username": User.find(token.resource_owner_id).username
294   #   }
295   # end
296   #
297   # or
298   #
299   # custom_introspection_response CustomIntrospectionResponder
300
301   # Specify what grant flows are enabled in array of Strings. The valid
302   # strings and the flows they enable are:
303   #
304   # "authorization_code" => Authorization Code Grant Flow
305   # "implicit"           => Implicit Grant Flow
306   # "password"           => Resource Owner Password Credentials Grant Flow
307   # "client_credentials" => Client Credentials Grant Flow
308   #
309   # If not specified, Doorkeeper enables authorization_code and
310   # client_credentials.
311   #
312   # implicit and password grant flows have risks that you should understand
313   # before enabling:
314   #   http://tools.ietf.org/html/rfc6819#section-4.4.2
315   #   http://tools.ietf.org/html/rfc6819#section-4.4.3
316
317   grant_flows %w[authorization_code]
318
319   # Allows to customize OAuth grant flows that +each+ application support.
320   # You can configure a custom block (or use a class respond to `#call`) that must
321   # return `true` in case Application instance supports requested OAuth grant flow
322   # during the authorization request to the server. This configuration +doesn't+
323   # set flows per application, it only allows to check if application supports
324   # specific grant flow.
325   #
326   # For example you can add an additional database column to `oauth_applications` table,
327   # say `t.array :grant_flows, default: []`, and store allowed grant flows that can
328   # be used with this application there. Then when authorization requested Doorkeeper
329   # will call this block to check if specific Application (passed with client_id and/or
330   # client_secret) is allowed to perform the request for the specific grant type
331   # (authorization, password, client_credentials, etc).
332   #
333   # Example of the block:
334   #
335   #   ->(flow, client) { client.grant_flows.include?(flow) }
336   #
337   # In case this option invocation result is `false`, Doorkeeper server returns
338   # :unauthorized_client error and stops the request.
339   #
340   # @param allow_grant_flow_for_client [Proc] Block or any object respond to #call
341   # @return [Boolean] `true` if allow or `false` if forbid the request
342   #
343   # allow_grant_flow_for_client do |grant_flow, client|
344   #   # `grant_flows` is an Array column with grant
345   #   # flows that application supports
346   #
347   #   client.grant_flows.include?(grant_flow)
348   # end
349
350   # If you need arbitrary Resource Owner-Client authorization you can enable this option
351   # and implement the check your need. Config option must respond to #call and return
352   # true in case resource owner authorized for the specific application or false in other
353   # cases.
354   #
355   # Be default all Resource Owners are authorized to any Client (application).
356   #
357   # authorize_resource_owner_for_client do |client, resource_owner|
358   #   resource_owner.admin? || client.owners_whitelist.include?(resource_owner)
359   # end
360
361   # Hook into the strategies' request & response life-cycle in case your
362   # application needs advanced customization or logging:
363   #
364   # before_successful_strategy_response do |request|
365   #   puts "BEFORE HOOK FIRED! #{request}"
366   # end
367   #
368   # after_successful_strategy_response do |request, response|
369   #   puts "AFTER HOOK FIRED! #{request}, #{response}"
370   # end
371
372   # Hook into Authorization flow in order to implement Single Sign Out
373   # or add any other functionality. Inside the block you have an access
374   # to `controller` (authorizations controller instance) and `context`
375   # (Doorkeeper::OAuth::Hooks::Context instance) which provides pre auth
376   # or auth objects with issued token based on hook type (before or after).
377   #
378   # before_successful_authorization do |controller, context|
379   #   Rails.logger.info(controller.request.params.inspect)
380   #
381   #   Rails.logger.info(context.pre_auth.inspect)
382   # end
383   #
384   # after_successful_authorization do |controller, context|
385   #   controller.session[:logout_urls] <<
386   #     Doorkeeper::Application
387   #       .find_by(controller.request.params.slice(:redirect_uri))
388   #       .logout_uri
389   #
390   #   Rails.logger.info(context.auth.inspect)
391   #   Rails.logger.info(context.issued_token)
392   # end
393
394   # Under some circumstances you might want to have applications auto-approved,
395   # so that the user skips the authorization step.
396   # For example if dealing with a trusted application.
397   #
398   # skip_authorization do |resource_owner, client|
399   #   client.superapp? or resource_owner.admin?
400   # end
401
402   # Configure custom constraints for the Token Introspection request.
403   # By default this configuration option allows to introspect a token by another
404   # token of the same application, OR to introspect the token that belongs to
405   # authorized client (from authenticated client) OR when token doesn't
406   # belong to any client (public token). Otherwise requester has no access to the
407   # introspection and it will return response as stated in the RFC.
408   #
409   # Block arguments:
410   #
411   # @param token [Doorkeeper::AccessToken]
412   #   token to be introspected
413   #
414   # @param authorized_client [Doorkeeper::Application]
415   #   authorized client (if request is authorized using Basic auth with
416   #   Client Credentials for example)
417   #
418   # @param authorized_token [Doorkeeper::AccessToken]
419   #   Bearer token used to authorize the request
420   #
421   # In case the block returns `nil` or `false` introspection responses with 401 status code
422   # when using authorized token to introspect, or you'll get 200 with { "active": false } body
423   # when using authorized client to introspect as stated in the
424   # RFC 7662 section 2.2. Introspection Response.
425   #
426   # Using with caution:
427   # Keep in mind that these three parameters pass to block can be nil as following case:
428   #  `authorized_client` is nil if and only if `authorized_token` is present, and vice versa.
429   #  `token` will be nil if and only if `authorized_token` is present.
430   # So remember to use `&` or check if it is present before calling method on
431   # them to make sure you doesn't get NoMethodError exception.
432   #
433   # You can define your custom check:
434   #
435   # allow_token_introspection do |token, authorized_client, authorized_token|
436   #   if authorized_token
437   #     # customize: require `introspection` scope
438   #     authorized_token.application == token&.application ||
439   #       authorized_token.scopes.include?("introspection")
440   #   elsif token.application
441   #     # `protected_resource` is a new database boolean column, for example
442   #     authorized_client == token.application || authorized_client.protected_resource?
443   #   else
444   #     # public token (when token.application is nil, token doesn't belong to any application)
445   #     true
446   #   end
447   # end
448   #
449   # Or you can completely disable any token introspection:
450   #
451   # allow_token_introspection false
452   #
453   # If you need to block the request at all, then configure your routes.rb or web-server
454   # like nginx to forbid the request.
455
456   # WWW-Authenticate Realm (default: "Doorkeeper").
457   #
458   # realm "Doorkeeper"
459 end