OAuth 2.0 リソースサーバー Opaque トークン
イントロスペクションの最小限の依存関係
JWT の最小依存関係に従って、ほとんどの リソースサーバーサポートは spring-security-oauth2-resource-server
に集められています。ただし、カスタム OpaqueTokenIntrospector
が提供されない限り、リソースサーバーは NimbusOpaqueTokenIntrospector にフォールバックします。つまり、不透明なベアラートークンをサポートする最小限のリソースサーバーを機能させるには、spring-security-oauth2-resource-server
と oauth2-oidc-sdk
の両方が必要です。oauth2-oidc-sdk
の正しいバージョンを確認するには、spring-security-oauth2-resource-server
を参照してください。
イントロスペクションの最小構成
通常、Opaque トークンは、認可サーバーによってホストされる OAuth 2.0 イントロスペクションエンドポイント [IETF] (英語) を介して検証できます。これは、失効が必要な場合に便利です。
Spring Boot を使用する場合、イントロスペクションを使用するリソースサーバーとしてアプリケーションを構成するには、2 つの基本的な手順が必要です。まず、必要な依存関係を含め、次に、イントロスペクションエンドポイントの詳細を示します。
認可サーバーの指定
イントロスペクションエンドポイントの場所を指定するには、次のようにします。
spring:
security:
oauth2:
resourceserver:
opaque-token:
introspection-uri: https://idp.example.com/introspect
client-id: client
client-secret: secret
ここで、idp.example.com/introspect (英語)
は認証サーバーによってホストされるイントロスペクションエンドポイントであり、client-id
および client-secret
はそのエンドポイントをヒットするために必要な資格情報です。
リソースサーバーはこれらのプロパティを使用して、さらに自己構成し、受信 JWT を検証します。
イントロスペクションを使用する場合、認可サーバーの言葉は法律です。認可サーバーがトークンが有効であるとレスポンスした場合、有効です。 |
以上です!
スタートアップの期待
このプロパティとこれらの依存関係が使用されると、リソースサーバーは自動的に不透明なベアラートークンを検証するように構成します。
この起動プロセスは、エンドポイントを検出する必要がなく、追加の検証ルールが追加されないため、JWT よりもかなり単純です。
ランタイムの期待
アプリケーションが起動すると、リソースサーバーは Authorization: Bearer
ヘッダーを含むリクエストの処理を試みます。
GET / HTTP/1.1
Authorization: Bearer some-token-value # Resource Server will process this
このスキームが示されている限り、リソースサーバーはベアラートークン仕様に従ってリクエストの処理を試みます。
Opaque トークンを指定すると、リソースサーバーは
指定された資格情報とトークンを使用して、指定されたイントロスペクションエンドポイントを照会します
{ 'active' : true }
属性のレスポンスをインスペクションします各スコープをプレフィックス
SCOPE_
を持つオーソリティにマップします
結果の Authentication#getPrincipal
は、デフォルトでは Spring Security OAuth2AuthenticatedPrincipal
(Javadoc) オブジェクトであり、Authentication#getName
はトークンの sub
プロパティ(存在する場合)にマップされます。
ここから、次の場所にジャンプできます。
Opaque トークン認証のしくみ
次に、今見たような、サーブレットベースのアプリケーションで Opaque トークン [IETF] (英語) 認証をサポートするために Spring Security [IETF] (英語) が使用するアーキテクチャコンポーネントを見てみましょう。
OpaqueTokenAuthenticationProvider
(Javadoc) は、OpaqueTokenIntrospector
を利用して Opaque トークンを認証する AuthenticationProvider
実装です。
OpaqueTokenAuthenticationProvider
が Spring Security 内でどのように機能するかを見てみましょう。この図は、ベアラートークンの読み取りの図で AuthenticationManager
がどのように機能するかの詳細を説明しています。
OpaqueTokenAuthenticationProvider
の使用箇所 ベアラートークンの読み取りからの認証 Filter
は、ProviderManager
によって実装される AuthenticationManager
に BearerTokenAuthenticationToken
を渡します。
ProviderManager
は、型 OpaqueTokenAuthenticationProvider
の AuthenticationProvider を使用するように構成されています。
OpaqueTokenAuthenticationProvider
は Opaque トークンをイントロスペクトし、OpaqueTokenIntrospector
を使用して付与された権限を追加します。認証が成功すると、返される Authentication
は型 BearerTokenAuthentication
であり、構成された OpaqueTokenIntrospector
によって返される OAuth2AuthenticatedPrincipal
であるプリンシパルを持ちます。最終的に、返された BearerTokenAuthentication
は認証 Filter
によって SecurityContextHolder
に設定されます。
認証後の属性の検索
トークンが認証されると、BearerTokenAuthentication
のインスタンスが SecurityContext
に設定されます。
つまり、構成で @EnableWebMvc
を使用する場合、@Controller
メソッドで使用できます。
Java
Kotlin
@GetMapping("/foo")
public String foo(BearerTokenAuthentication authentication) {
return authentication.getTokenAttributes().get("sub") + " is the subject";
}
@GetMapping("/foo")
fun foo(authentication: BearerTokenAuthentication): String {
return authentication.tokenAttributes["sub"].toString() + " is the subject"
}
BearerTokenAuthentication
は OAuth2AuthenticatedPrincipal
を保持するため、コントローラーメソッドでも使用できることも意味します。
Java
Kotlin
@GetMapping("/foo")
public String foo(@AuthenticationPrincipal OAuth2AuthenticatedPrincipal principal) {
return principal.getAttribute("sub") + " is the subject";
}
@GetMapping("/foo")
fun foo(@AuthenticationPrincipal principal: OAuth2AuthenticatedPrincipal): String {
return principal.getAttribute<Any>("sub").toString() + " is the subject"
}
SpEL を介した属性の検索
もちろん、これは、SpEL を介して属性にアクセスできることも意味します。
例: @PreAuthorize
アノテーションを使用できるように @EnableGlobalMethodSecurity
を使用する場合、次のことができます。
Java
Kotlin
@PreAuthorize("principal?.attributes['sub'] == 'foo'")
public String forFoosEyesOnly() {
return "foo";
}
@PreAuthorize("principal?.attributes['sub'] == 'foo'")
fun forFoosEyesOnly(): String {
return "foo"
}
Boot 自動構成のオーバーライドまたは置換
Spring Boot がリソースサーバーに代わって生成する 2 つの @Bean
があります。
1 つ目は、アプリをリソースサーバーとして構成する SecurityFilterChain
です。Opaque トークンを使用する場合、この SecurityFilterChain
は次のようになります。
Java
Kotlin
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
.authorizeHttpRequests(authorize -> authorize
.anyRequest().authenticated()
)
.oauth2ResourceServer(oauth2 -> oauth2
.opaqueToken(Customizer.withDefaults())
);
return http.build();
}
@Bean
open fun filterChain(http: HttpSecurity): SecurityFilterChain {
http {
authorizeRequests {
authorize(anyRequest, authenticated)
}
oauth2ResourceServer {
opaqueToken { }
}
}
return http.build()
}
アプリケーションが SecurityFilterChain
Bean を公開しない場合、Spring Boot は上記のデフォルトを公開します。
これを置き換えることは、アプリケーション内で Bean を公開するのと同じくらい簡単です。
Java
Kotlin
import static org.springframework.security.oauth2.core.authorization.OAuth2AuthorizationManagers.hasScope;
@Configuration
@EnableWebSecurity
public class MyCustomSecurityConfiguration {
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
.authorizeHttpRequests(authorize -> authorize
.requestMatchers("/messages/**").access(hasScope("message:read"))
.anyRequest().authenticated()
)
.oauth2ResourceServer(oauth2 -> oauth2
.opaqueToken(opaqueToken -> opaqueToken
.introspector(myIntrospector())
)
);
return http.build();
}
}
import org.springframework.security.oauth2.core.authorization.OAuth2AuthorizationManagers.hasScope;
@Configuration
@EnableWebSecurity
class MyCustomSecurityConfiguration {
@Bean
open fun filterChain(http: HttpSecurity): SecurityFilterChain {
http {
authorizeRequests {
authorize("/messages/**", hasScope("SCOPE_message:read"))
authorize(anyRequest, authenticated)
}
oauth2ResourceServer {
opaqueToken {
introspector = myIntrospector()
}
}
}
return http.build()
}
}
上記では、/messages/
で始まる URL の message:read
のスコープが必要です。
oauth2ResourceServer
DSL のメソッドも自動構成をオーバーライドまたは置き換えます。
例: 2 番目の @Bean
Spring Boot が作成する OpaqueTokenIntrospector
は、String
トークンを OAuth2AuthenticatedPrincipal
の検証済みインスタンスにデコードします。
Java
Kotlin
@Bean
public OpaqueTokenIntrospector introspector() {
return new NimbusOpaqueTokenIntrospector(introspectionUri, clientId, clientSecret);
}
@Bean
fun introspector(): OpaqueTokenIntrospector {
return NimbusOpaqueTokenIntrospector(introspectionUri, clientId, clientSecret)
}
アプリケーションが OpaqueTokenIntrospector
Bean を公開しない場合、Spring Boot は上記のデフォルトのものを公開します。
そして、その構成は、introspectionUri()
および introspectionClientCredentials()
を使用してオーバーライドするか、introspector()
を使用して置き換えることができます。
アプリケーションが OpaqueTokenAuthenticationConverter
Bean を公開しない場合、spring-security は BearerTokenAuthentication
をビルドします。
または、Spring Boot をまったく使用していない場合は、これらすべてのコンポーネント (フィルターチェーン、OpaqueTokenIntrospector
、OpaqueTokenAuthenticationConverter
) を XML で指定できます。
フィルターチェーンは次のように指定されます。
XML
<http>
<intercept-uri pattern="/**" access="authenticated"/>
<oauth2-resource-server>
<opaque-token introspector-ref="opaqueTokenIntrospector"
authentication-converter-ref="opaqueTokenAuthenticationConverter"/>
</oauth2-resource-server>
</http>
そして、OpaqueTokenIntrospector
は次のようになります。
XML
<bean id="opaqueTokenIntrospector"
class="org.springframework.security.oauth2.server.resource.introspection.NimbusOpaqueTokenIntrospector">
<constructor-arg value="${spring.security.oauth2.resourceserver.opaquetoken.introspection_uri}"/>
<constructor-arg value="${spring.security.oauth2.resourceserver.opaquetoken.client_id}"/>
<constructor-arg value="${spring.security.oauth2.resourceserver.opaquetoken.client_secret}"/>
</bean>
OpaqueTokenAuthenticationConverter
は次のようになります。
XML
<bean id="opaqueTokenAuthenticationConverter"
class="com.example.CustomOpaqueTokenAuthenticationConverter"/>
introspectionUri()
を使用する
認可サーバーの Introspection Uri は、構成プロパティとして構成するか、DSL で提供できます。
Java
Kotlin
XML
@Configuration
@EnableWebSecurity
public class DirectlyConfiguredIntrospectionUri {
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
.authorizeHttpRequests(authorize -> authorize
.anyRequest().authenticated()
)
.oauth2ResourceServer(oauth2 -> oauth2
.opaqueToken(opaqueToken -> opaqueToken
.introspectionUri("https://idp.example.com/introspect")
.introspectionClientCredentials("client", "secret")
)
);
return http.build();
}
}
@Configuration
@EnableWebSecurity
class DirectlyConfiguredIntrospectionUri {
@Bean
open fun filterChain(http: HttpSecurity): SecurityFilterChain {
http {
authorizeRequests {
authorize(anyRequest, authenticated)
}
oauth2ResourceServer {
opaqueToken {
introspectionUri = "https://idp.example.com/introspect"
introspectionClientCredentials("client", "secret")
}
}
}
return http.build()
}
}
<bean id="opaqueTokenIntrospector"
class="org.springframework.security.oauth2.server.resource.introspection.NimbusOpaqueTokenIntrospector">
<constructor-arg value="https://idp.example.com/introspect"/>
<constructor-arg value="client"/>
<constructor-arg value="secret"/>
</bean>
introspectionUri()
の使用は、構成プロパティよりも優先されます。
introspector()
を使用する
introspectionUri()
よりも強力なのは introspector()
で、これは OpaqueTokenIntrospector
の Boot 自動構成を完全に置き換えます。
Java
Kotlin
XML
@Configuration
@EnableWebSecurity
public class DirectlyConfiguredIntrospector {
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
.authorizeHttpRequests(authorize -> authorize
.anyRequest().authenticated()
)
.oauth2ResourceServer(oauth2 -> oauth2
.opaqueToken(opaqueToken -> opaqueToken
.introspector(myCustomIntrospector())
)
);
return http.build();
}
}
@Configuration
@EnableWebSecurity
class DirectlyConfiguredIntrospector {
@Bean
open fun filterChain(http: HttpSecurity): SecurityFilterChain {
http {
authorizeRequests {
authorize(anyRequest, authenticated)
}
oauth2ResourceServer {
opaqueToken {
introspector = myCustomIntrospector()
}
}
}
return http.build()
}
}
<http>
<intercept-uri pattern="/**" access="authenticated"/>
<oauth2-resource-server>
<opaque-token introspector-ref="myCustomIntrospector"/>
</oauth2-resource-server>
</http>
これは、権限マッピング、JWT の取り消し、リクエストタイムアウトなどのより深い構成が必要な場合に便利です。
OpaqueTokenIntrospector
の公開 @Bean
または、OpaqueTokenIntrospector
@Bean
を公開すると、introspector()
と同じ効果があります。
@Bean
public OpaqueTokenIntrospector introspector() {
return new NimbusOpaqueTokenIntrospector(introspectionUri, clientId, clientSecret);
}
認可の構成
OAuth 2.0 Introspection エンドポイントは、通常、scope
属性を返し、付与されたスコープ(または権限)を示します。例:
{ …, "scope" : "messages contacts"}
この場合、リソースサーバーはこれらのスコープを付与された権限のリストに強制し、各スコープの前に文字列 "SCOPE_" を付けようとします。
つまり、Opaque トークンから派生したスコープを持つエンドポイントまたはメソッドを保護するには、対応する式に次のプレフィックスを含める必要があります。
Java
Kotlin
XML
import static org.springframework.security.oauth2.core.authorization.OAuth2AuthorizationManagers.hasScope;
@Configuration
@EnableWebSecurity
public class MappedAuthorities {
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
.authorizeHttpRequests(authorizeRequests -> authorizeRequests
.requestMatchers("/contacts/**").access(hasScope("contacts"))
.requestMatchers("/messages/**").access(hasScope("messages"))
.anyRequest().authenticated()
)
.oauth2ResourceServer(oauth2 -> oauth2
.opaqueToken(Customizer.withDefaults())
);
return http.build();
}
}
import org.springframework.security.oauth2.core.authorization.OAuth2AuthorizationManagers.hasScope
@Configuration
@EnableWebSecurity
class MappedAuthorities {
@Bean
open fun filterChain(http: HttpSecurity): SecurityFilterChain {
http {
authorizeRequests {
authorize("/contacts/**", hasScope("contacts"))
authorize("/messages/**", hasScope("messages"))
authorize(anyRequest, authenticated)
}
oauth2ResourceServer {
opaqueToken { }
}
}
return http.build()
}
}
<http>
<intercept-uri pattern="/contacts/**" access="hasAuthority('SCOPE_contacts')"/>
<intercept-uri pattern="/messages/**" access="hasAuthority('SCOPE_messages')"/>
<oauth2-resource-server>
<opaque-token introspector-ref="opaqueTokenIntrospector"/>
</oauth2-resource-server>
</http>
または、同様にメソッドセキュリティで:
Java
Kotlin
@PreAuthorize("hasAuthority('SCOPE_messages')")
public List<Message> getMessages(...) {}
@PreAuthorize("hasAuthority('SCOPE_messages')")
fun getMessages(): List<Message?> {}
権限の手動抽出
デフォルトでは、Opaque トークンサポートは、イントロスペクションレスポンスからスコープ要求を抽出し、個々の GrantedAuthority
インスタンスに解析します。
例: イントロスペクションのレスポンスが次の場合:
{
"active" : true,
"scope" : "message:read message:write"
}
次に、リソースサーバーは、message:read
用と message:write
用の 2 つの権限を持つ Authentication
を生成します。
もちろん、これは、属性セットを調べて独自の方法で変換するカスタム OpaqueTokenIntrospector
を使用してカスタマイズできます。
Java
Kotlin
public class CustomAuthoritiesOpaqueTokenIntrospector implements OpaqueTokenIntrospector {
private OpaqueTokenIntrospector delegate =
new NimbusOpaqueTokenIntrospector("https://idp.example.org/introspect", "client", "secret");
public OAuth2AuthenticatedPrincipal introspect(String token) {
OAuth2AuthenticatedPrincipal principal = this.delegate.introspect(token);
return new DefaultOAuth2AuthenticatedPrincipal(
principal.getName(), principal.getAttributes(), extractAuthorities(principal));
}
private Collection<GrantedAuthority> extractAuthorities(OAuth2AuthenticatedPrincipal principal) {
List<String> scopes = principal.getAttribute(OAuth2IntrospectionClaimNames.SCOPE);
return scopes.stream()
.map(SimpleGrantedAuthority::new)
.collect(Collectors.toList());
}
}
class CustomAuthoritiesOpaqueTokenIntrospector : OpaqueTokenIntrospector {
private val delegate: OpaqueTokenIntrospector = NimbusOpaqueTokenIntrospector("https://idp.example.org/introspect", "client", "secret")
override fun introspect(token: String): OAuth2AuthenticatedPrincipal {
val principal: OAuth2AuthenticatedPrincipal = delegate.introspect(token)
return DefaultOAuth2AuthenticatedPrincipal(
principal.name, principal.attributes, extractAuthorities(principal))
}
private fun extractAuthorities(principal: OAuth2AuthenticatedPrincipal): Collection<GrantedAuthority> {
val scopes: List<String> = principal.getAttribute(OAuth2IntrospectionClaimNames.SCOPE)
return scopes
.map { SimpleGrantedAuthority(it) }
}
}
その後、このカスタムイントロスペクターは、@Bean
として公開するだけで構成できます。
Java
Kotlin
@Bean
public OpaqueTokenIntrospector introspector() {
return new CustomAuthoritiesOpaqueTokenIntrospector();
}
@Bean
fun introspector(): OpaqueTokenIntrospector {
return CustomAuthoritiesOpaqueTokenIntrospector()
}
タイムアウトの構成
デフォルトでは、リソースサーバーは認可サーバーとの調整にそれぞれ 30 秒の接続およびソケットタイムアウトを使用します。
これはいくつかのシナリオでは短すぎるかもしれません。さらに、バックオフや発見などのより高度なパターンは考慮されません。
リソースサーバーが認可サーバーに接続する方法を調整するために、NimbusOpaqueTokenIntrospector
は RestOperations
のインスタンスを受け入れます。
Java
Kotlin
@Bean
public OpaqueTokenIntrospector introspector(RestTemplateBuilder builder, OAuth2ResourceServerProperties properties) {
RestOperations rest = builder
.basicAuthentication(properties.getOpaquetoken().getClientId(), properties.getOpaquetoken().getClientSecret())
.setConnectTimeout(Duration.ofSeconds(60))
.setReadTimeout(Duration.ofSeconds(60))
.build();
return new NimbusOpaqueTokenIntrospector(introspectionUri, rest);
}
@Bean
fun introspector(builder: RestTemplateBuilder, properties: OAuth2ResourceServerProperties): OpaqueTokenIntrospector? {
val rest: RestOperations = builder
.basicAuthentication(properties.opaquetoken.clientId, properties.opaquetoken.clientSecret)
.setConnectTimeout(Duration.ofSeconds(60))
.setReadTimeout(Duration.ofSeconds(60))
.build()
return NimbusOpaqueTokenIntrospector(introspectionUri, rest)
}
JWT でのイントロスペクションの使用
よくある質問は、イントロスペクションが JWT と互換性があるかどうかです。Spring Security の Opaque トークンサポートは、トークンの形式を気にしないように設計されています。提供されたイントロスペクションエンドポイントにトークンを喜んで渡します。
JWT が取り消された場合に備えて、リクエストごとに認可サーバーで確認する必要がある要件があるとしましょう。
トークンに JWT 形式を使用している場合でも、検証方法はイントロスペクションです。つまり、次のようにします。
spring:
security:
oauth2:
resourceserver:
opaque-token:
introspection-uri: https://idp.example.org/introspection
client-id: client
client-secret: secret
この場合、結果の Authentication
は BearerTokenAuthentication
になります。対応する OAuth2AuthenticatedPrincipal
の属性は、イントロスペクションエンドポイントによって返されたものです。
しかし、奇妙なことに、イントロスペクションエンドポイントは、トークンがアクティブであるかどうかのみを返します。それで?
この場合、エンドポイントにヒットするカスタム OpaqueTokenIntrospector
を作成できますが、返されたプリンシパルを更新して、JWT クレームを属性として持ちます。
Java
Kotlin
public class JwtOpaqueTokenIntrospector implements OpaqueTokenIntrospector {
private OpaqueTokenIntrospector delegate =
new NimbusOpaqueTokenIntrospector("https://idp.example.org/introspect", "client", "secret");
private JwtDecoder jwtDecoder = new NimbusJwtDecoder(new ParseOnlyJWTProcessor());
public OAuth2AuthenticatedPrincipal introspect(String token) {
OAuth2AuthenticatedPrincipal principal = this.delegate.introspect(token);
try {
Jwt jwt = this.jwtDecoder.decode(token);
return new DefaultOAuth2AuthenticatedPrincipal(jwt.getClaims(), NO_AUTHORITIES);
} catch (JwtException ex) {
throw new OAuth2IntrospectionException(ex);
}
}
private static class ParseOnlyJWTProcessor extends DefaultJWTProcessor<SecurityContext> {
JWTClaimsSet process(SignedJWT jwt, SecurityContext context)
throws JOSEException {
return jwt.getJWTClaimsSet();
}
}
}
class JwtOpaqueTokenIntrospector : OpaqueTokenIntrospector {
private val delegate: OpaqueTokenIntrospector = NimbusOpaqueTokenIntrospector("https://idp.example.org/introspect", "client", "secret")
private val jwtDecoder: JwtDecoder = NimbusJwtDecoder(ParseOnlyJWTProcessor())
override fun introspect(token: String): OAuth2AuthenticatedPrincipal {
val principal = delegate.introspect(token)
return try {
val jwt: Jwt = jwtDecoder.decode(token)
DefaultOAuth2AuthenticatedPrincipal(jwt.claims, NO_AUTHORITIES)
} catch (ex: JwtException) {
throw OAuth2IntrospectionException(ex.message)
}
}
private class ParseOnlyJWTProcessor : DefaultJWTProcessor<SecurityContext>() {
override fun process(jwt: SignedJWT, context: SecurityContext): JWTClaimsSet {
return jwt.jwtClaimsSet
}
}
}
その後、このカスタムイントロスペクターは、@Bean
として公開するだけで構成できます。
Java
Kotlin
@Bean
public OpaqueTokenIntrospector introspector() {
return new JwtOpaqueTokenIntrospector();
}
@Bean
fun introspector(): OpaqueTokenIntrospector {
return JwtOpaqueTokenIntrospector()
}
/userinfo
エンドポイントの呼び出し
一般的に、リソースサーバーは、基になるユーザーを気にするのではなく、付与された権限を気にします。
ただし、認証ステートメントをユーザーに結び付けることが重要な場合があります。
アプリケーションが spring-security-oauth2-client
も使用していて、適切な ClientRegistrationRepository
を設定している場合、これはカスタム OpaqueTokenIntrospector
を使用すると非常に簡単です。以下のこの実装は、3 つのことを行います。
トークンの有効性を確認するために、イントロスペクションエンドポイントに委譲します
/userinfo
エンドポイントに関連付けられた適切なクライアント登録を検索します/userinfo
エンドポイントからレスポンスを呼び出して返します
Java
Kotlin
public class UserInfoOpaqueTokenIntrospector implements OpaqueTokenIntrospector {
private final OpaqueTokenIntrospector delegate =
new NimbusOpaqueTokenIntrospector("https://idp.example.org/introspect", "client", "secret");
private final OAuth2UserService oauth2UserService = new DefaultOAuth2UserService();
private final ClientRegistrationRepository repository;
// ... constructor
@Override
public OAuth2AuthenticatedPrincipal introspect(String token) {
OAuth2AuthenticatedPrincipal authorized = this.delegate.introspect(token);
Instant issuedAt = authorized.getAttribute(ISSUED_AT);
Instant expiresAt = authorized.getAttribute(EXPIRES_AT);
ClientRegistration clientRegistration = this.repository.findByRegistrationId("registration-id");
OAuth2AccessToken token = new OAuth2AccessToken(BEARER, token, issuedAt, expiresAt);
OAuth2UserRequest oauth2UserRequest = new OAuth2UserRequest(clientRegistration, token);
return this.oauth2UserService.loadUser(oauth2UserRequest);
}
}
class UserInfoOpaqueTokenIntrospector : OpaqueTokenIntrospector {
private val delegate: OpaqueTokenIntrospector = NimbusOpaqueTokenIntrospector("https://idp.example.org/introspect", "client", "secret")
private val oauth2UserService = DefaultOAuth2UserService()
private val repository: ClientRegistrationRepository? = null
// ... constructor
override fun introspect(token: String): OAuth2AuthenticatedPrincipal {
val authorized = delegate.introspect(token)
val issuedAt: Instant? = authorized.getAttribute(ISSUED_AT)
val expiresAt: Instant? = authorized.getAttribute(EXPIRES_AT)
val clientRegistration: ClientRegistration = repository!!.findByRegistrationId("registration-id")
val accessToken = OAuth2AccessToken(BEARER, token, issuedAt, expiresAt)
val oauth2UserRequest = OAuth2UserRequest(clientRegistration, accessToken)
return oauth2UserService.loadUser(oauth2UserRequest)
}
}
spring-security-oauth2-client
を使用していない場合でも、非常に簡単です。WebClient
の独自のインスタンスで /userinfo
を呼び出すだけです。
Java
Kotlin
public class UserInfoOpaqueTokenIntrospector implements OpaqueTokenIntrospector {
private final OpaqueTokenIntrospector delegate =
new NimbusOpaqueTokenIntrospector("https://idp.example.org/introspect", "client", "secret");
private final WebClient rest = WebClient.create();
@Override
public OAuth2AuthenticatedPrincipal introspect(String token) {
OAuth2AuthenticatedPrincipal authorized = this.delegate.introspect(token);
return makeUserInfoRequest(authorized);
}
}
class UserInfoOpaqueTokenIntrospector : OpaqueTokenIntrospector {
private val delegate: OpaqueTokenIntrospector = NimbusOpaqueTokenIntrospector("https://idp.example.org/introspect", "client", "secret")
private val rest: WebClient = WebClient.create()
override fun introspect(token: String): OAuth2AuthenticatedPrincipal {
val authorized = delegate.introspect(token)
return makeUserInfoRequest(authorized)
}
}
どちらの方法でも、OpaqueTokenIntrospector
を作成したら、それを @Bean
として公開してデフォルトをオーバーライドする必要があります。
Java
Kotlin
@Bean
OpaqueTokenIntrospector introspector() {
return new UserInfoOpaqueTokenIntrospector(...);
}
@Bean
fun introspector(): OpaqueTokenIntrospector {
return UserInfoOpaqueTokenIntrospector(...)
}