高階配置

HttpSecurity.oauth2Login() 提供了許多配置選項，用於自定義 OAuth 2.0 登入。主要配置選項根據其協議端點對應關係進行分組。

例如，oauth2Login().authorizationEndpoint() 允許配置 授權端點，而 oauth2Login().tokenEndpoint() 允許配置 令牌端點。

以下程式碼顯示了一個示例

高階 OAuth2 登入配置

  • Java

  • Kotlin

@Configuration
@EnableWebSecurity
public class OAuth2LoginSecurityConfig {

	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.oauth2Login((oauth2) -> oauth2
			    .authorizationEndpoint((authorization) -> authorization
			            ...
			    )
			    .redirectionEndpoint((redirection) -> redirection
			            ...
			    )
			    .tokenEndpoint((token) -> token
			            ...
			    )
			    .userInfoEndpoint((userInfo) -> userInfo
			            ...
			    )
			);
		return http.build();
	}
}
@Configuration
@EnableWebSecurity
class OAuth2LoginSecurityConfig {

    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login {
                authorizationEndpoint {
                    ...
                }
                redirectionEndpoint {
                    ...
                }
                tokenEndpoint {
                    ...
                }
                userInfoEndpoint {
                    ...
                }
            }
        }
        return http.build()
    }
}

oauth2Login() DSL 的主要目標是與規範中定義的命名保持緊密一致。

OAuth 2.0 授權框架將 協議端點 定義如下

授權過程使用兩個授權伺服器端點（HTTP 資源）

  • 授權端點：客戶端透過使用者代理重定向從資源所有者獲取授權。

  • 令牌端點：客戶端用於交換授權許可以獲取訪問令牌，通常伴隨客戶端認證。

授權過程還使用一個客戶端端點

  • 重定向端點：授權伺服器透過資源所有者使用者代理將包含授權憑證的響應返回給客戶端。

OpenID Connect Core 1.0 規範將 UserInfo 端點 定義如下

UserInfo 端點是一個 OAuth 2.0 受保護資源，返回有關已認證終端使用者的資訊。為了獲取有關終端使用者的請求資訊，客戶端透過使用透過 OpenID Connect 認證獲得的訪問令牌向 UserInfo 端點發出請求。這些資訊通常由一個 JSON 物件表示，該物件包含一組鍵值對。

以下程式碼顯示了 oauth2Login() DSL 的所有可用配置選項

OAuth2 登入配置選項

  • Java

  • Kotlin

@Configuration
@EnableWebSecurity
public class OAuth2LoginSecurityConfig {

	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.oauth2Login((oauth2) -> oauth2
			    .clientRegistrationRepository(this.clientRegistrationRepository())
			    .authorizedClientRepository(this.authorizedClientRepository())
			    .authorizedClientService(this.authorizedClientService())
			    .loginPage("/login")
			    .authorizationEndpoint((authorization) -> authorization
			        .baseUri(this.authorizationRequestBaseUri())
			        .authorizationRequestRepository(this.authorizationRequestRepository())
			        .authorizationRequestResolver(this.authorizationRequestResolver())
			    )
			    .redirectionEndpoint((redirection) -> redirection
			        .baseUri(this.authorizationResponseBaseUri())
			    )
			    .tokenEndpoint((token) -> token
			        .accessTokenResponseClient(this.accessTokenResponseClient())
			    )
			    .userInfoEndpoint((userInfo) -> userInfo
			        .userAuthoritiesMapper(this.userAuthoritiesMapper())
			        .userService(this.oauth2UserService())
			        .oidcUserService(this.oidcUserService())
			    )
			);
		return http.build();
	}
}
@Configuration
@EnableWebSecurity
class OAuth2LoginSecurityConfig {

    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login {
                clientRegistrationRepository = clientRegistrationRepository()
                authorizedClientRepository = authorizedClientRepository()
                authorizedClientService = authorizedClientService()
                loginPage = "/login"
                authorizationEndpoint {
                    baseUri = authorizationRequestBaseUri()
                    authorizationRequestRepository = authorizationRequestRepository()
                    authorizationRequestResolver = authorizationRequestResolver()
                }
                redirectionEndpoint {
                    baseUri = authorizationResponseBaseUri()
                }
                tokenEndpoint {
                    accessTokenResponseClient = accessTokenResponseClient()
                }
                userInfoEndpoint {
                    userAuthoritiesMapper = userAuthoritiesMapper()
                    userService = oauth2UserService()
                    oidcUserService = oidcUserService()
                }
            }
        }
        return http.build()
    }
}

除了 oauth2Login() DSL，還支援 XML 配置。

以下程式碼顯示了 security namespace 中所有可用的配置選項

OAuth2 登入 XML 配置選項
<http>
	<oauth2-login client-registration-repository-ref="clientRegistrationRepository"
				  authorized-client-repository-ref="authorizedClientRepository"
				  authorized-client-service-ref="authorizedClientService"
				  authorization-request-repository-ref="authorizationRequestRepository"
				  authorization-request-resolver-ref="authorizationRequestResolver"
				  access-token-response-client-ref="accessTokenResponseClient"
				  user-authorities-mapper-ref="userAuthoritiesMapper"
				  user-service-ref="oauth2UserService"
				  oidc-user-service-ref="oidcUserService"
				  login-processing-url="/login/oauth2/code/*"
				  login-page="/login"
				  authentication-success-handler-ref="authenticationSuccessHandler"
				  authentication-failure-handler-ref="authenticationFailureHandler"
				  jwt-decoder-factory-ref="jwtDecoderFactory"/>
</http>

以下各節將詳細介紹每個可用配置選項

OAuth 2.0 登入頁面

預設情況下，OAuth 2.0 登入頁面由 DefaultLoginPageGeneratingFilter 自動生成。預設登入頁面顯示每個配置的 OAuth 客戶端，其 ClientRegistration.clientName 作為連結，能夠發起授權請求（或 OAuth 2.0 登入）。

為了讓 DefaultLoginPageGeneratingFilter 顯示配置的 OAuth 客戶端的連結，註冊的 ClientRegistrationRepository 也需要實現 Iterable<ClientRegistration>。請參閱 InMemoryClientRegistrationRepository 以供參考。

每個 OAuth 客戶端的連結目標預設為以下內容

OAuth2AuthorizationRequestRedirectFilter.DEFAULT_AUTHORIZATION_REQUEST_BASE_URI + "/{registrationId}"

以下行顯示了一個示例

<a href="/oauth2/authorization/google">Google</a>

要覆蓋預設登入頁面，請配置 oauth2Login().loginPage() 和（可選）oauth2Login().authorizationEndpoint().baseUri()。

以下列表顯示了一個示例

OAuth2 登入頁面配置

  • Java

  • Kotlin

  • Xml

@Configuration
@EnableWebSecurity
public class OAuth2LoginSecurityConfig {

	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.oauth2Login((oauth2) -> oauth2
			    .loginPage("/login/oauth2")
			    ...
			    .authorizationEndpoint((authorization) -> authorization
			        .baseUri("/login/oauth2/authorization")
			        ...
			    )
			);
		return http.build();
	}
}
@Configuration
@EnableWebSecurity
class OAuth2LoginSecurityConfig {

    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login {
                loginPage = "/login/oauth2"
                authorizationEndpoint {
                    baseUri = "/login/oauth2/authorization"
                }
            }
        }
        return http.build()
    }
}
<http>
	<oauth2-login login-page="/login/oauth2"
				  ...
    />
</http>

您需要提供一個帶有 @RequestMapping("/login/oauth2") 的 @Controller，它能夠渲染自定義登入頁面。

如前所述，配置 oauth2Login().authorizationEndpoint().baseUri() 是可選的。但是，如果您選擇自定義它，請確保每個 OAuth 客戶端的連結與 authorizationEndpoint().baseUri() 匹配。

以下行顯示了一個示例

<a href="/login/oauth2/authorization/google">Google</a>

重定向端點

重定向端點由授權伺服器用於透過資源所有者使用者代理將授權響應（包含授權憑證）返回給客戶端。

OAuth 2.0 登入利用授權碼授權。因此，授權憑證是授權碼。

預設的授權響應 baseUri（重定向端點）是 /login/oauth2/code/*，它在 OAuth2LoginAuthenticationFilter.DEFAULT_FILTER_PROCESSES_URI 中定義。

如果您想自定義授權響應 baseUri，請按以下方式配置它

重定向端點配置

  • Java

  • Kotlin

  • Xml

@Configuration
@EnableWebSecurity
public class OAuth2LoginSecurityConfig {

    @Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.oauth2Login((oauth2) -> oauth2
			    .redirectionEndpoint((redirection) -> redirection
			        .baseUri("/login/oauth2/callback/*")
			        ...
			    )
			);
		return http.build();
	}
}
@Configuration
@EnableWebSecurity
class OAuth2LoginSecurityConfig {

    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login {
                redirectionEndpoint {
                    baseUri = "/login/oauth2/callback/*"
                }
            }
        }
        return http.build()
    }
}
<http>
	<oauth2-login login-processing-url="/login/oauth2/callback/*"
				  ...
    />
</http>

您還需要確保 ClientRegistration.redirectUri 與自定義授權響應 baseUri 匹配。

以下列表顯示了一個示例

  • Java

  • Kotlin

return CommonOAuth2Provider.GOOGLE.getBuilder("google")
	.clientId("google-client-id")
	.clientSecret("google-client-secret")
	.redirectUri("{baseUrl}/login/oauth2/callback/{registrationId}")
	.build();
return CommonOAuth2Provider.GOOGLE.getBuilder("google")
    .clientId("google-client-id")
    .clientSecret("google-client-secret")
    .redirectUri("{baseUrl}/login/oauth2/callback/{registrationId}")
    .build()

UserInfo 端點

UserInfo 端點包括許多配置選項，如下面子節所述

對映使用者許可權

使用者成功透過 OAuth 2.0 提供者進行身份驗證後，OAuth2User.getAuthorities()（或 OidcUser.getAuthorities()）包含一個許可權列表，這些許可權從 OAuth2UserRequest.getAccessToken().getScopes() 中填充並以 SCOPE_ 為字首。這些授予的許可權可以對映到一組新的 GrantedAuthority 例項，這些例項在完成身份驗證時提供給 OAuth2AuthenticationToken。

OAuth2AuthenticationToken.getAuthorities() 用於授權請求，例如在 hasRole('USER') 或 hasRole('ADMIN') 中。

對映使用者許可權時有幾個選項可供選擇

使用 GrantedAuthoritiesMapper

GrantedAuthoritiesMapper 接收一個許可權列表，其中包含一個型別為 OAuth2UserAuthority 的特殊許可權和許可權字串 OAUTH2_USER（或 OidcUserAuthority 和許可權字串 OIDC_USER）。

提供 GrantedAuthoritiesMapper 的實現並按如下方式配置它

授予許可權對映器配置

  • Java

  • Kotlin

  • Xml

@Configuration
@EnableWebSecurity
public class OAuth2LoginSecurityConfig {

    @Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.oauth2Login((oauth2) -> oauth2
			    .userInfoEndpoint((userInfo) -> userInfo
			        .userAuthoritiesMapper(this.userAuthoritiesMapper())
			        ...
			    )
			);
		return http.build();
	}

	private GrantedAuthoritiesMapper userAuthoritiesMapper() {
		return (authorities) -> {
			Set<GrantedAuthority> mappedAuthorities = new HashSet<>();

			authorities.forEach(authority -> {
				if (OidcUserAuthority.class.isInstance(authority)) {
					OidcUserAuthority oidcUserAuthority = (OidcUserAuthority)authority;

					OidcIdToken idToken = oidcUserAuthority.getIdToken();
					OidcUserInfo userInfo = oidcUserAuthority.getUserInfo();

					// Map the claims found in idToken and/or userInfo
					// to one or more GrantedAuthority's and add it to mappedAuthorities

				} else if (OAuth2UserAuthority.class.isInstance(authority)) {
					OAuth2UserAuthority oauth2UserAuthority = (OAuth2UserAuthority)authority;

					Map<String, Object> userAttributes = oauth2UserAuthority.getAttributes();

					// Map the attributes found in userAttributes
					// to one or more GrantedAuthority's and add it to mappedAuthorities

				}
			});

			return mappedAuthorities;
		};
	}
}
@Configuration
@EnableWebSecurity
class OAuth2LoginSecurityConfig {

    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login {
                userInfoEndpoint {
                    userAuthoritiesMapper = userAuthoritiesMapper()
                }
            }
        }
        return http.build()
    }

    private fun userAuthoritiesMapper(): GrantedAuthoritiesMapper = GrantedAuthoritiesMapper { authorities: Collection<GrantedAuthority> ->
        val mappedAuthorities = emptySet<GrantedAuthority>()

        authorities.forEach { authority ->
            if (authority is OidcUserAuthority) {
                val idToken = authority.idToken
                val userInfo = authority.userInfo
                // Map the claims found in idToken and/or userInfo
                // to one or more GrantedAuthority's and add it to mappedAuthorities
            } else if (authority is OAuth2UserAuthority) {
                val userAttributes = authority.attributes
                // Map the attributes found in userAttributes
                // to one or more GrantedAuthority's and add it to mappedAuthorities
            }
        }

        mappedAuthorities
    }
}
<http>
	<oauth2-login user-authorities-mapper-ref="userAuthoritiesMapper"
				  ...
    />
</http>

或者，您可以註冊一個 GrantedAuthoritiesMapper @Bean，使其自動應用於配置，如下所示

授予許可權對映器 Bean 配置

  • Java

  • Kotlin

@Configuration
@EnableWebSecurity
public class OAuth2LoginSecurityConfig {

	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
		    .oauth2Login(withDefaults());
		return http.build();
	}

	@Bean
	public GrantedAuthoritiesMapper userAuthoritiesMapper() {
		...
	}
}
@Configuration
@EnableWebSecurity
class OAuth2LoginSecurityConfig {

    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login { }
        }
        return http.build()
    }

    @Bean
    fun userAuthoritiesMapper(): GrantedAuthoritiesMapper {
        ...
    }
}

身份驗證完成後，它還包含 FACTOR_AUTHORIZATION_CODE 授予許可權。

基於委託的 OAuth2UserService 策略

與使用 GrantedAuthoritiesMapper 相比，此策略更為高階。但是，它也更靈活，因為它允許您訪問 OAuth2UserRequest 和 OAuth2User（在使用 OAuth 2.0 UserService 時）或 OidcUserRequest 和 OidcUser（在使用 OpenID Connect 1.0 UserService 時）。

OAuth2UserRequest（和 OidcUserRequest）允許您訪問關聯的 OAuth2AccessToken，這在 委託者 需要從受保護資源獲取許可權資訊才能為使用者對映自定義許可權的情況下非常有用。

以下示例顯示瞭如何使用 OpenID Connect 1.0 UserService 實現和配置基於委託的策略

OAuth2UserService 配置

  • Java

  • Kotlin

  • Xml

@Configuration
@EnableWebSecurity
public class OAuth2LoginSecurityConfig {

	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.oauth2Login((oauth2) -> oauth2
			    .userInfoEndpoint((userInfo) -> userInfo
			        .oidcUserService(this.oidcUserService())
			        ...
			    )
			);
		return http.build();
	}

	private OAuth2UserService<OidcUserRequest, OidcUser> oidcUserService() {
		final OidcUserService delegate = new OidcUserService();

		return (userRequest) -> {
			// Delegate to the default implementation for loading a user
			OidcUser oidcUser = delegate.loadUser(userRequest);

			OAuth2AccessToken accessToken = userRequest.getAccessToken();
			Set<GrantedAuthority> mappedAuthorities = new HashSet<>();

			// TODO
			// 1) Fetch the authority information from the protected resource using accessToken
			// 2) Map the authority information to one or more GrantedAuthority's and add it to mappedAuthorities

			// 3) Create a copy of oidcUser but use the mappedAuthorities instead
			ProviderDetails providerDetails = userRequest.getClientRegistration().getProviderDetails();
			String userNameAttributeName = providerDetails.getUserInfoEndpoint().getUserNameAttributeName();
			if (StringUtils.hasText(userNameAttributeName)) {
				oidcUser = new DefaultOidcUser(mappedAuthorities, oidcUser.getIdToken(), oidcUser.getUserInfo(), userNameAttributeName);
			} else {
				oidcUser = new DefaultOidcUser(mappedAuthorities, oidcUser.getIdToken(), oidcUser.getUserInfo());
			}

			return oidcUser;
		};
	}
}
@Configuration
@EnableWebSecurity
class OAuth2LoginSecurityConfig  {

    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login {
                userInfoEndpoint {
                    oidcUserService = oidcUserService()
                }
            }
        }
        return http.build()
    }

    @Bean
    fun oidcUserService(): OAuth2UserService<OidcUserRequest, OidcUser> {
        val delegate = OidcUserService()

        return OAuth2UserService { userRequest ->
            // Delegate to the default implementation for loading a user
            val oidcUser = delegate.loadUser(userRequest)

            val accessToken = userRequest.accessToken
            val mappedAuthorities = HashSet<GrantedAuthority>()

            // TODO
            // 1) Fetch the authority information from the protected resource using accessToken
            // 2) Map the authority information to one or more GrantedAuthority's and add it to mappedAuthorities
            // 3) Create a copy of oidcUser but use the mappedAuthorities instead
            val providerDetails = userRequest.getClientRegistration().getProviderDetails()
            val userNameAttributeName = providerDetails.getUserInfoEndpoint().getUserNameAttributeName()
            if (StringUtils.hasText(userNameAttributeName)) {
                DefaultOidcUser(mappedAuthorities, oidcUser.idToken, oidcUser.userInfo, userNameAttributeName)
            } else {
                DefaultOidcUser(mappedAuthorities, oidcUser.idToken, oidcUser.userInfo)
            }
        }
    }
}
<http>
	<oauth2-login oidc-user-service-ref="oidcUserService"
				  ...
    />
</http>

OAuth 2.0 UserService

DefaultOAuth2UserService 是 OAuth2UserService 的實現，支援標準的 OAuth 2.0 提供者。

OAuth2UserService 從 UserInfo 端點（透過在授權流程中授予客戶端的訪問令牌）獲取終端使用者（資源所有者）的使用者屬性，並以 OAuth2User 的形式返回一個 AuthenticatedPrincipal。

DefaultOAuth2UserService 在 UserInfo 端點請求使用者屬性時使用 RestOperations 例項。

如果您需要自定義 UserInfo 請求的預處理，可以透過自定義的 Converter<OAuth2UserRequest, RequestEntity<?>> 提供給 DefaultOAuth2UserService.setRequestEntityConverter()。預設實現 OAuth2UserRequestEntityConverter 構建了 UserInfo 請求的 RequestEntity 表示，預設情況下將 OAuth2AccessToken 設定在 Authorization 頭中。

另一方面，如果您需要自定義 UserInfo 響應的後處理，您需要向 DefaultOAuth2UserService.setRestOperations() 提供一個自定義配置的 RestOperations。預設的 RestOperations 配置如下

RestTemplate restTemplate = new RestTemplate();
restTemplate.setErrorHandler(new OAuth2ErrorResponseErrorHandler());

OAuth2ErrorResponseErrorHandler 是一個 ResponseErrorHandler，可以處理 OAuth 2.0 錯誤（400 Bad Request）。它使用 OAuth2ErrorHttpMessageConverter 將 OAuth 2.0 錯誤引數轉換為 OAuth2Error。

無論您是自定義 DefaultOAuth2UserService 還是提供自己的 OAuth2UserService 實現，都需要按以下方式配置它

  • Java

  • Kotlin

@Configuration
@EnableWebSecurity
public class OAuth2LoginSecurityConfig {

	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.oauth2Login((oauth2) -> oauth2
			    .userInfoEndpoint((userInfo) -> userInfo
			        .userService(this.oauth2UserService())
			        ...
			    )
			);
		return http.build();
	}

	private OAuth2UserService<OAuth2UserRequest, OAuth2User> oauth2UserService() {
		...
	}
}
@Configuration
@EnableWebSecurity
class OAuth2LoginSecurityConfig {

    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login {
                userInfoEndpoint {
                    userService = oauth2UserService()
                    // ...
                }
            }
        }
        return http.build()
    }

    private fun oauth2UserService(): OAuth2UserService<OAuth2UserRequest, OAuth2User> {
        // ...
    }
}

OpenID Connect 1.0 UserService

OidcUserService 是 OAuth2UserService 的一個實現，支援 OpenID Connect 1.0 提供者。

OidcUserService 在 UserInfo 端點請求使用者屬性時利用 DefaultOAuth2UserService。

如果您需要自定義 UserInfo 請求的預處理或 UserInfo 響應的後處理，您需要向 OidcUserService.setOauth2UserService() 提供一個自定義配置的 DefaultOAuth2UserService。

無論您是自定義 OidcUserService 還是為 OpenID Connect 1.0 提供者提供自己的 OAuth2UserService 實現，都需要按以下方式配置它

  • Java

  • Kotlin

@Configuration
@EnableWebSecurity
public class OAuth2LoginSecurityConfig {

	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.oauth2Login((oauth2) -> oauth2
				.userInfoEndpoint((userInfo) -> userInfo
				    .oidcUserService(this.oidcUserService())
				    ...
			    )
			);
		return http.build();
	}

	private OAuth2UserService<OidcUserRequest, OidcUser> oidcUserService() {
		...
	}
}
@Configuration
@EnableWebSecurity
class OAuth2LoginSecurityConfig {

    @Bean
    open fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            oauth2Login {
                userInfoEndpoint {
                    oidcUserService = oidcUserService()
                    // ...
                }
            }
        }
        return http.build()
    }

    private fun oidcUserService(): OAuth2UserService<OidcUserRequest, OidcUser> {
        // ...
    }
}

ID 令牌簽名驗證

OpenID Connect 1.0 認證引入了 ID 令牌，它是一個安全令牌，在客戶端使用時包含有關授權伺服器對終端使用者進行認證的資訊。

ID 令牌表示為 JSON Web 令牌 (JWT)，並且必須使用 JSON Web 簽名 (JWS) 進行簽名。

OidcIdTokenDecoderFactory 提供了一個 JwtDecoder，用於 OidcIdToken 簽名驗證。預設演算法是 RS256，但在客戶端註冊期間分配時可能有所不同。對於這些情況，您可以配置一個解析器，以返回為特定客戶端分配的預期 JWS 演算法。

JWS 演算法解析器是一個 Function，它接受一個 ClientRegistration 並返回客戶端的預期 JwsAlgorithm，例如 SignatureAlgorithm.RS256 或 MacAlgorithm.HS256

以下程式碼顯示瞭如何配置 OidcIdTokenDecoderFactory @Bean，以便所有 ClientRegistration 例項預設使用 MacAlgorithm.HS256

  • Java

  • Kotlin

@Bean
public JwtDecoderFactory<ClientRegistration> idTokenDecoderFactory() {
	OidcIdTokenDecoderFactory idTokenDecoderFactory = new OidcIdTokenDecoderFactory();
	idTokenDecoderFactory.setJwsAlgorithmResolver((clientRegistration) -> clientRegistration.HS256);
	return idTokenDecoderFactory;
}
@Bean
fun idTokenDecoderFactory(): JwtDecoderFactory<ClientRegistration?> {
    val idTokenDecoderFactory = OidcIdTokenDecoderFactory()
    idTokenDecoderFactory.setJwsAlgorithmResolver { MacAlgorithm.HS256 }
    return idTokenDecoderFactory
}

對於基於 MAC 的演算法（如 HS256、HS384 或 HS512），與 client-id 對應的 client-secret 用作簽名驗證的對稱金鑰。

如果為 OpenID Connect 1.0 認證配置了多個 ClientRegistration，JWS 演算法解析器可以評估提供的 ClientRegistration 以確定返回哪個演算法。

然後，您可以繼續配置 登出

© . This site is unofficial and not affiliated with VMware.