Skip to content

Always attempt to use PCKE for OAuth 2 auth code flows #7804

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 1 commit into from

Conversation

bdemers
Copy link
Contributor

@bdemers bdemers commented Jan 10, 2020

The "OAuth 2.0 Security Best Current Practice" (draft)
https://tools.ietf.org/html/draft-ietf-oauth-security-topics-13#section-3.1.1

Clients utilizing the authorization grant type MUST use PKCE
[RFC7636] in order to (with the help of the authorization server)
detect and prevent attempts to inject (replay) authorization codes
into the authorization response.

NOTE: this change should be backward compatible with IdPs who do not yet support PKCE (as the related parameters should be ignored)

The "OAuth 2.0 Security Best Current Practice" (draft)
https://tools.ietf.org/html/draft-ietf-oauth-security-topics-13#section-3.1.1

> Clients utilizing the authorization grant type MUST use PKCE
> [RFC7636] in order to (with the help of the authorization server)
> detect and prevent attempts to inject (replay) authorization codes
> into the authorization response.

*NOTE:* this change should be backward compatible with IdPs who do not yet support PKCE (as the related parameters should be ignored)
@spring-projects-issues spring-projects-issues added the status: waiting-for-triage An issue we've not yet triaged label Jan 10, 2020
@bdemers
Copy link
Contributor Author

bdemers commented Jan 10, 2020

(I'll update this issue if/when we get a time frame on this draft moving forward)
Currently looks like a couple of months out

@jzheaux jzheaux requested a review from jgrandja January 13, 2020 18:48
@jzheaux jzheaux added in: oauth2 An issue in OAuth2 modules (oauth2-core, oauth2-client, oauth2-resource-server, oauth2-jose) type: enhancement A general enhancement and removed status: waiting-for-triage An issue we've not yet triaged labels Jan 13, 2020
@jgrandja
Copy link
Contributor

@bdemers The issue with forcing PKCE for all Authorization Requests is that some providers do not support PKCE and therefore the request might fail.

@jgrandja jgrandja added the status: waiting-for-feedback We need additional information before we can continue label Jan 15, 2020
@jgrandja jgrandja self-assigned this Jan 15, 2020
@bdemers
Copy link
Contributor Author

bdemers commented Jan 15, 2020

Hey @jgrandja!
That was one of my concerns too. but the OAuth 2.0 RFC states:

The authorization server MUST ignore unrecognized request parameters.

I'll be honest and say that I've only tried this with one IdP ;) but we could also take the position of defaulting to PKCE, and then set a flag to turn it off for non-conforming servers (if it is an issue).

Thoughts?

@spring-projects-issues spring-projects-issues added status: feedback-provided Feedback has been provided and removed status: waiting-for-feedback We need additional information before we can continue labels Jan 15, 2020
@jgrandja jgrandja removed the status: feedback-provided Feedback has been provided label Jan 17, 2020
@jgrandja
Copy link
Contributor

@bdemers I understand using PKCE for public and confidential clients (#6548 #7132) is best practice but I'm still concerned with breaking existing client apps by forcing PKCE for all authorization_code flows.

At minimum, I would like to test a few providers to see how they behave with PKCE parameters.

@bdemers
Copy link
Contributor Author

bdemers commented Jan 17, 2020

@jgrandja, seems like a good idea ;)

I can do a little manual testing, how about, Google, FB, Google, Okta, and maybe Keycloak?

@jgrandja
Copy link
Contributor

jgrandja commented Jan 20, 2020

Sounds good @bdemers. Let me know how the testing goes with those providers.

@bdemers
Copy link
Contributor Author

bdemers commented Jan 24, 2020

@jgrandja I tested out the following with success:

  • GitHub
  • Okta
  • Facebook
  • Google
  • Keycloak

I also attempted to test Linkedin, but I couldn't get that to work with or without this patch. I tried to base my configuration off an older demo of yours: https://github.com/jgrandja/oauth2login-demo/blob/linkedin/src/main/resources/application.yml

Any chance you have an updated set of LinkedIn configuration?

@jgrandja
Copy link
Contributor

Nice @bdemers!

Did you configure the Converter, which is required to work with LinkedIn since the Token Response does not return the required token_type.

@jgrandja
Copy link
Contributor

jgrandja commented Jan 24, 2020

@bdemers Just a heads up that #7748 has been in the works for a bit now. It should really simplify customizing the OAuth2AuthorizationRequest. And I have an idea on how to resolve #6548, which is related to this PR. Let me get #7748 merged first and then we can circle back to this PR and see what changes are required to get this in. I have a couple of other priority items I need to address first so I should get back to this within 2 weeks maybe less. Thanks for testing those scenarios!

@jgrandja jgrandja added this to the 5.3.0.RC1 milestone Jan 24, 2020
@bdemers
Copy link
Contributor Author

bdemers commented Jan 24, 2020

@jgrandja ahh, I had missed that. I also needed to tweak the properties, and I was able to get it to work with the current RELEASE.

spring:
  security:
    oauth2:
      client:
        provider:
          linkedin:
            authorization-uri: "https://www.linkedin.com/oauth/v2/authorization"
            token-uri: "https://www.linkedin.com/oauth/v2/accessToken"
            user-info-uri: "https://api.linkedin.com/v2/me"
            user-name-attribute: id
        registration:
          linked:
            client-id: id-here
            client-secret: secret-here
            client-authentication-method: post
            authorization-grant-type: authorization_code
            redirect-uri: "{baseUrl}/login/oauth2/code/{registrationId}"
            scope: r_basicprofile, r_emailaddress, r_liteprofile
            client-name: Linkedin

I guess the previous user-info-uri was deprecated? (and requires a different scope).

However with this patch: It does look like LinkedIn responses with a 500 when the code_verifier is sent to https://www.linkedin.com/oauth/v2/accessToken.

I'll try to ask around. I'm not 100% sure I have this set up correctly, but it's not looking good...

@eleftherias eleftherias modified the milestones: 5.3.0.RC1, 5.3.0 Feb 5, 2020
@jgrandja jgrandja removed this from the 5.3.0 milestone Feb 10, 2020
@wpcfan
Copy link

wpcfan commented Jul 1, 2020

any update on this? which release is going to have this feature?

@bdemers
Copy link
Contributor Author

bdemers commented Jul 1, 2020

@wpcfan I started chatting with some folks at LinkedIn about the problem. They were looking into it, I'll reach out again and check the status

@adiseshan
Copy link

Could you please let know if there is any update for this task.

@bdemers
Copy link
Contributor Author

bdemers commented Feb 12, 2021

@adiseshan there is a little more talk on the topic on #6548

@ghost
Copy link

ghost commented Jun 29, 2021

I've just learned that OAuth 2.1 will require PKCE for confidential clients. I would be very happy to see support for it soon: https://datatracker.ietf.org/doc/html/draft-ietf-oauth-v2-1-02.txt#section-1.9

@drahkrub
Copy link

PKCE is also required by IdentityServer4 -> demo server.

@jgrandja
Copy link
Contributor

@bdemers I'm going to close this since the changes are not backward compatible with all tested providers.

I'll leave gh-6548 open so we don't lose track of this as the plan is to add this enhancement.

Feel free to create a new PR that would ensure backwards compatibility.

We're going to prioritize this for the 5.7 release.

@jgrandja jgrandja closed this Nov 18, 2021
@jgrandja jgrandja added the status: declined A suggestion or change that we don't feel we should currently apply label Nov 18, 2021
@shabloel
Copy link

shabloel commented Jan 25, 2022

Spring still does not deliver PKCE support out of the box for confidential clients. According to new best practice https://datatracker.ietf.org/doc/html/draft-ietf-oauth-browser-based-apps, PKCE always has to be enabled, also for a Confidential client. I am currently working on such an implementation where my client is a spring boot application and KEycloak is my authorisation server, so I am running into some problems

@jgrandja
Copy link
Contributor

@shabloel As mentioned in previous comment

We're going to prioritize this for the 5.7 release.

Please stay tuned.

@shabloel
Copy link

thank you!:). I also found a work-around, it works half out of the box. properties file:
spring.security.oauth2.client.registration.mywebclient.client-authentication-method=none.
spring does all the work for you....except it leaves out the client-secret in its final access token request. You can easily add the client-secret in the access token request manually, then everything works fine.

braunsonm added a commit to braunsonm/oauth2-proxy that referenced this pull request Feb 8, 2022
Adds Code Challenge PKCE support (RFC-7636) and partial
Authorization Server Metadata (RFC-8414) for detecting PKCE support.

- Introduces new option `--force-code-challenge-method` to force a
specific code challenge method (either `S256` or `plain`) for instances
when the server has not implemented RFC-8414 in order to detect
PKCE support on the discovery document.
- In all other cases, if the PKCE support can be determined during discovery
then the `code_challenge_methods_supported` is used and S256 is always
preferred.
- The force command line argument is helpful with some providers like Azure
who supports PKCE but does not list it in their discovery document yet.
- Initial thought was given to just always attempt PKCE since according to spec
additional URL parameters should be stopped by servers which implemented
OAuth 2, however other projects found cases in the wild where this causes 500
errors by buggy implementations.
See: spring-projects/spring-security#7804 (comment)
- Due to the fact that the `code_verifier` must be saved between the redirect and
callback, sessions are now created when the redirect takes place with `Authenticated: false`.
The session will be recreated and marked as `Authenticated` on callback.
- Individual provider implementations can choose to include or ignore code_challenge
and code_verifier function parameters passed to them

Note: Technically speaking `plain` is not required to be implemented since
oauth2-proxy will always be able to handle S256 and servers MUST implement
S256 support.
> If the client is capable of using "S256", it MUST use "S256", as "S256"
> is Mandatory To Implement (MTI) on the server.  Clients are permitted
> to use "plain" only if they cannot support "S256" for some technical
> reason and know via out-of-band configuration that the server supports
> "plain".
Ref: RFC-7636 Sec 4.2

oauth2-proxy will always use S256 unless the user explicitly forces `plain`.

Fixes oauth2-proxy#1361
braunsonm added a commit to braunsonm/oauth2-proxy that referenced this pull request Feb 8, 2022
Adds Code Challenge PKCE support (RFC-7636) and partial
Authorization Server Metadata (RFC-8414) for detecting PKCE support.

- Introduces new option `--force-code-challenge-method` to force a
specific code challenge method (either `S256` or `plain`) for instances
when the server has not implemented RFC-8414 in order to detect
PKCE support on the discovery document.
- In all other cases, if the PKCE support can be determined during discovery
then the `code_challenge_methods_supported` is used and S256 is always
preferred.
- The force command line argument is helpful with some providers like Azure
who supports PKCE but does not list it in their discovery document yet.
- Initial thought was given to just always attempt PKCE since according to spec
additional URL parameters should be stopped by servers which implemented
OAuth 2, however other projects found cases in the wild where this causes 500
errors by buggy implementations.
See: spring-projects/spring-security#7804 (comment)
- Due to the fact that the `code_verifier` must be saved between the redirect and
callback, sessions are now created when the redirect takes place with `Authenticated: false`.
The session will be recreated and marked as `Authenticated` on callback.
- Individual provider implementations can choose to include or ignore code_challenge
and code_verifier function parameters passed to them

Note: Technically speaking `plain` is not required to be implemented since
oauth2-proxy will always be able to handle S256 and servers MUST implement
S256 support.
> If the client is capable of using "S256", it MUST use "S256", as "S256"
> is Mandatory To Implement (MTI) on the server.  Clients are permitted
> to use "plain" only if they cannot support "S256" for some technical
> reason and know via out-of-band configuration that the server supports
> "plain".
Ref: RFC-7636 Sec 4.2

oauth2-proxy will always use S256 unless the user explicitly forces `plain`.

Fixes oauth2-proxy#1361
braunsonm added a commit to braunsonm/oauth2-proxy that referenced this pull request Feb 8, 2022
Adds Code Challenge PKCE support (RFC-7636) and partial
Authorization Server Metadata (RFC-8414) for detecting PKCE support.

- Introduces new option `--force-code-challenge-method` to force a
specific code challenge method (either `S256` or `plain`) for instances
when the server has not implemented RFC-8414 in order to detect
PKCE support on the discovery document.
- In all other cases, if the PKCE support can be determined during discovery
then the `code_challenge_methods_supported` is used and S256 is always
preferred.
- The force command line argument is helpful with some providers like Azure
who supports PKCE but does not list it in their discovery document yet.
- Initial thought was given to just always attempt PKCE since according to spec
additional URL parameters should be dropped by servers which implemented
OAuth 2, however other projects found cases in the wild where this causes 500
errors by buggy implementations.
See: spring-projects/spring-security#7804 (comment)
- Due to the fact that the `code_verifier` must be saved between the redirect and
callback, sessions are now created when the redirect takes place with `Authenticated: false`.
The session will be recreated and marked as `Authenticated` on callback.
- Individual provider implementations can choose to include or ignore code_challenge
and code_verifier function parameters passed to them

Note: Technically speaking `plain` is not required to be implemented since
oauth2-proxy will always be able to handle S256 and servers MUST implement
S256 support.
> If the client is capable of using "S256", it MUST use "S256", as "S256"
> is Mandatory To Implement (MTI) on the server.  Clients are permitted
> to use "plain" only if they cannot support "S256" for some technical
> reason and know via out-of-band configuration that the server supports
> "plain".
Ref: RFC-7636 Sec 4.2

oauth2-proxy will always use S256 unless the user explicitly forces `plain`.

Fixes oauth2-proxy#1361
braunsonm added a commit to braunsonm/oauth2-proxy that referenced this pull request Feb 17, 2022
Adds Code Challenge PKCE support (RFC-7636) and partial
Authorization Server Metadata (RFC-8414) for detecting PKCE support.

- Introduces new option `--force-code-challenge-method` to force a
specific code challenge method (either `S256` or `plain`) for instances
when the server has not implemented RFC-8414 in order to detect
PKCE support on the discovery document.
- In all other cases, if the PKCE support can be determined during discovery
then the `code_challenge_methods_supported` is used and S256 is always
preferred.
- The force command line argument is helpful with some providers like Azure
who supports PKCE but does not list it in their discovery document yet.
- Initial thought was given to just always attempt PKCE since according to spec
additional URL parameters should be dropped by servers which implemented
OAuth 2, however other projects found cases in the wild where this causes 500
errors by buggy implementations.
See: spring-projects/spring-security#7804 (comment)
- Due to the fact that the `code_verifier` must be saved between the redirect and
callback, sessions are now created when the redirect takes place with `Authenticated: false`.
The session will be recreated and marked as `Authenticated` on callback.
- Individual provider implementations can choose to include or ignore code_challenge
and code_verifier function parameters passed to them

Note: Technically speaking `plain` is not required to be implemented since
oauth2-proxy will always be able to handle S256 and servers MUST implement
S256 support.
> If the client is capable of using "S256", it MUST use "S256", as "S256"
> is Mandatory To Implement (MTI) on the server.  Clients are permitted
> to use "plain" only if they cannot support "S256" for some technical
> reason and know via out-of-band configuration that the server supports
> "plain".
Ref: RFC-7636 Sec 4.2

oauth2-proxy will always use S256 unless the user explicitly forces `plain`.

Fixes oauth2-proxy#1361
braunsonm added a commit to braunsonm/oauth2-proxy that referenced this pull request Feb 17, 2022
Adds Code Challenge PKCE support (RFC-7636) and partial
Authorization Server Metadata (RFC-8414) for detecting PKCE support.

- Introduces new option `--force-code-challenge-method` to force a
specific code challenge method (either `S256` or `plain`) for instances
when the server has not implemented RFC-8414 in order to detect
PKCE support on the discovery document.
- In all other cases, if the PKCE support can be determined during discovery
then the `code_challenge_methods_supported` is used and S256 is always
preferred.
- The force command line argument is helpful with some providers like Azure
who supports PKCE but does not list it in their discovery document yet.
- Initial thought was given to just always attempt PKCE since according to spec
additional URL parameters should be dropped by servers which implemented
OAuth 2, however other projects found cases in the wild where this causes 500
errors by buggy implementations.
See: spring-projects/spring-security#7804 (comment)
- Due to the fact that the `code_verifier` must be saved between the redirect and
callback, sessions are now created when the redirect takes place with `Authenticated: false`.
The session will be recreated and marked as `Authenticated` on callback.
- Individual provider implementations can choose to include or ignore code_challenge
and code_verifier function parameters passed to them

Note: Technically speaking `plain` is not required to be implemented since
oauth2-proxy will always be able to handle S256 and servers MUST implement
S256 support.
> If the client is capable of using "S256", it MUST use "S256", as "S256"
> is Mandatory To Implement (MTI) on the server.  Clients are permitted
> to use "plain" only if they cannot support "S256" for some technical
> reason and know via out-of-band configuration that the server supports
> "plain".
Ref: RFC-7636 Sec 4.2

oauth2-proxy will always use S256 unless the user explicitly forces `plain`.

Fixes oauth2-proxy#1361
braunsonm added a commit to braunsonm/oauth2-proxy that referenced this pull request Feb 18, 2022
Adds Code Challenge PKCE support (RFC-7636) and partial
Authorization Server Metadata (RFC-8414) for detecting PKCE support.

- Introduces new option `--force-code-challenge-method` to force a
specific code challenge method (either `S256` or `plain`) for instances
when the server has not implemented RFC-8414 in order to detect
PKCE support on the discovery document.
- In all other cases, if the PKCE support can be determined during discovery
then the `code_challenge_methods_supported` is used and S256 is always
preferred.
- The force command line argument is helpful with some providers like Azure
who supports PKCE but does not list it in their discovery document yet.
- Initial thought was given to just always attempt PKCE since according to spec
additional URL parameters should be dropped by servers which implemented
OAuth 2, however other projects found cases in the wild where this causes 500
errors by buggy implementations.
See: spring-projects/spring-security#7804 (comment)
- Due to the fact that the `code_verifier` must be saved between the redirect and
callback, sessions are now created when the redirect takes place with `Authenticated: false`.
The session will be recreated and marked as `Authenticated` on callback.
- Individual provider implementations can choose to include or ignore code_challenge
and code_verifier function parameters passed to them

Note: Technically speaking `plain` is not required to be implemented since
oauth2-proxy will always be able to handle S256 and servers MUST implement
S256 support.
> If the client is capable of using "S256", it MUST use "S256", as "S256"
> is Mandatory To Implement (MTI) on the server.  Clients are permitted
> to use "plain" only if they cannot support "S256" for some technical
> reason and know via out-of-band configuration that the server supports
> "plain".
Ref: RFC-7636 Sec 4.2

oauth2-proxy will always use S256 unless the user explicitly forces `plain`.

Fixes oauth2-proxy#1361
braunsonm added a commit to braunsonm/oauth2-proxy that referenced this pull request Feb 18, 2022
Adds Code Challenge PKCE support (RFC-7636) and partial
Authorization Server Metadata (RFC-8414) for detecting PKCE support.

- Introduces new option `--force-code-challenge-method` to force a
specific code challenge method (either `S256` or `plain`) for instances
when the server has not implemented RFC-8414 in order to detect
PKCE support on the discovery document.
- In all other cases, if the PKCE support can be determined during discovery
then the `code_challenge_methods_supported` is used and S256 is always
preferred.
- The force command line argument is helpful with some providers like Azure
who supports PKCE but does not list it in their discovery document yet.
- Initial thought was given to just always attempt PKCE since according to spec
additional URL parameters should be dropped by servers which implemented
OAuth 2, however other projects found cases in the wild where this causes 500
errors by buggy implementations.
See: spring-projects/spring-security#7804 (comment)
- Due to the fact that the `code_verifier` must be saved between the redirect and
callback, sessions are now created when the redirect takes place with `Authenticated: false`.
The session will be recreated and marked as `Authenticated` on callback.
- Individual provider implementations can choose to include or ignore code_challenge
and code_verifier function parameters passed to them

Note: Technically speaking `plain` is not required to be implemented since
oauth2-proxy will always be able to handle S256 and servers MUST implement
S256 support.
> If the client is capable of using "S256", it MUST use "S256", as "S256"
> is Mandatory To Implement (MTI) on the server.  Clients are permitted
> to use "plain" only if they cannot support "S256" for some technical
> reason and know via out-of-band configuration that the server supports
> "plain".
Ref: RFC-7636 Sec 4.2

oauth2-proxy will always use S256 unless the user explicitly forces `plain`.

Fixes oauth2-proxy#1361
braunsonm added a commit to braunsonm/oauth2-proxy that referenced this pull request Feb 20, 2022
Adds Code Challenge PKCE support (RFC-7636) and partial
Authorization Server Metadata (RFC-8414) for detecting PKCE support.

- Introduces new option `--force-code-challenge-method` to force a
specific code challenge method (either `S256` or `plain`) for instances
when the server has not implemented RFC-8414 in order to detect
PKCE support on the discovery document.
- In all other cases, if the PKCE support can be determined during discovery
then the `code_challenge_methods_supported` is used and S256 is always
preferred.
- The force command line argument is helpful with some providers like Azure
who supports PKCE but does not list it in their discovery document yet.
- Initial thought was given to just always attempt PKCE since according to spec
additional URL parameters should be dropped by servers which implemented
OAuth 2, however other projects found cases in the wild where this causes 500
errors by buggy implementations.
See: spring-projects/spring-security#7804 (comment)
- Due to the fact that the `code_verifier` must be saved between the redirect and
callback, sessions are now created when the redirect takes place with `Authenticated: false`.
The session will be recreated and marked as `Authenticated` on callback.
- Individual provider implementations can choose to include or ignore code_challenge
and code_verifier function parameters passed to them

Note: Technically speaking `plain` is not required to be implemented since
oauth2-proxy will always be able to handle S256 and servers MUST implement
S256 support.
> If the client is capable of using "S256", it MUST use "S256", as "S256"
> is Mandatory To Implement (MTI) on the server.  Clients are permitted
> to use "plain" only if they cannot support "S256" for some technical
> reason and know via out-of-band configuration that the server supports
> "plain".
Ref: RFC-7636 Sec 4.2

oauth2-proxy will always use S256 unless the user explicitly forces `plain`.

Fixes oauth2-proxy#1361
JoelSpeed added a commit to oauth2-proxy/oauth2-proxy that referenced this pull request Mar 13, 2022
* Add the allowed_email_domains and the allowed_groups on the auth_request endpoint + support standard wildcard char for validation with sub-domain and email-domain.

Signed-off-by: Valentin Pichard <[email protected]>

* Fix provider data initialisation

* PKCE Support

Adds Code Challenge PKCE support (RFC-7636) and partial
Authorization Server Metadata (RFC-8414) for detecting PKCE support.

- Introduces new option `--force-code-challenge-method` to force a
specific code challenge method (either `S256` or `plain`) for instances
when the server has not implemented RFC-8414 in order to detect
PKCE support on the discovery document.
- In all other cases, if the PKCE support can be determined during discovery
then the `code_challenge_methods_supported` is used and S256 is always
preferred.
- The force command line argument is helpful with some providers like Azure
who supports PKCE but does not list it in their discovery document yet.
- Initial thought was given to just always attempt PKCE since according to spec
additional URL parameters should be dropped by servers which implemented
OAuth 2, however other projects found cases in the wild where this causes 500
errors by buggy implementations.
See: spring-projects/spring-security#7804 (comment)
- Due to the fact that the `code_verifier` must be saved between the redirect and
callback, sessions are now created when the redirect takes place with `Authenticated: false`.
The session will be recreated and marked as `Authenticated` on callback.
- Individual provider implementations can choose to include or ignore code_challenge
and code_verifier function parameters passed to them

Note: Technically speaking `plain` is not required to be implemented since
oauth2-proxy will always be able to handle S256 and servers MUST implement
S256 support.
> If the client is capable of using "S256", it MUST use "S256", as "S256"
> is Mandatory To Implement (MTI) on the server.  Clients are permitted
> to use "plain" only if they cannot support "S256" for some technical
> reason and know via out-of-band configuration that the server supports
> "plain".
Ref: RFC-7636 Sec 4.2

oauth2-proxy will always use S256 unless the user explicitly forces `plain`.

Fixes #1361

* Address PR comments by moving pkce generation

* Make PKCE opt-in, move to using the Nonce generater for code verifier

* Make PKCE opt-in, move to using the Nonce generater for code verifier

* Encrypt CodeVerifier in CSRF Token instead of Session

- Update Dex for PKCE support
- Expose HTTPBin for further use cases

* Correct the tests

* Move code challenges into extra params

* Correct typo in code challenge method

Co-authored-by: Joel Speed <[email protected]>

* Correct the extra space in docs

Co-authored-by: Joel Speed <[email protected]>

* Address changelog and new line nits

* Add generated docs

Co-authored-by: Valentin Pichard <[email protected]>
Co-authored-by: Joel Speed <[email protected]>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
in: oauth2 An issue in OAuth2 modules (oauth2-core, oauth2-client, oauth2-resource-server, oauth2-jose) status: declined A suggestion or change that we don't feel we should currently apply type: enhancement A general enhancement
Projects
None yet
Development

Successfully merging this pull request may close these issues.

9 participants