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 トークンを指定すると、リソースサーバーは

  1. 指定された資格情報とトークンを使用して、指定されたイントロスペクションエンドポイントを照会します

  2. { 'active' : true } 属性のレスポンスをインスペクションします

  3. 各スコープをプレフィックス 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
図 1: OpaqueTokenAuthenticationProvider の使用箇所

number 1 ベアラートークンの読み取りからの認証 Filter は、ProviderManager によって実装される AuthenticationManager に BearerTokenAuthenticationToken を渡します。

number 2ProviderManager は、型 OpaqueTokenAuthenticationProvider の AuthenticationProvider を使用するように構成されています。

number 3OpaqueTokenAuthenticationProvider は 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 は次のようになります。

Opaque トークンのデフォルト設定

  • 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 を公開するのと同じくらい簡単です。

カスタム Opaque トークン構成

  • 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 で指定できます。

フィルターチェーンは次のように指定されます。

Opaque トークンのデフォルト設定

  • XML

<http>
    <intercept-uri pattern="/**" access="authenticated"/>
    <oauth2-resource-server>
        <opaque-token introspector-ref="opaqueTokenIntrospector"
                authentication-converter-ref="opaqueTokenAuthenticationConverter"/>
    </oauth2-resource-server>
</http>

そして、OpaqueTokenIntrospector は次のようになります。

Opaque トークンイントロスペクター

  • 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 は次のようになります。

Opaque トークン認証コンバーター

  • XML

<bean id="opaqueTokenAuthenticationConverter"
        class="com.example.CustomOpaqueTokenAuthenticationConverter"/>

introspectionUri() を使用する

認可サーバーの Introspection Uri は、構成プロパティとして構成するか、DSL で提供できます。

イントロスペクション URI 設定

  • 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 トークンから派生したスコープを持つエンドポイントまたはメソッドを保護するには、対応する式に次のプレフィックスを含める必要があります。

認可 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(...)
}