OAuth スプリングブート

導入

OAuth 2.0 は、サードパーティのアプリケーションがユーザーの資格情報を必要とせずに、ユーザーに代わって保護されたリソースにアクセスできるようにする承認フレームワークです。これは、OAuth プロバイダーによって発行され、ユーザーのリソースにアクセスするためにサードパーティのアプリケーションによって使用されるアクセス トークンの使用によって実現されます。

Spring Boot は、Java で Web アプリケーションを構築するための人気のあるフレームワークです。安全でスケーラブルな Web アプリケーションを構築するための強力なツール セットを提供し、OAuth 2.0 の実装に最適です。

このブログ投稿では、Spring Boot を使用して OAuth 2.0 を実装するために必要な手順を説明します。 Spring Security OAuth 2.0 フレームワークを使用して、OAuth 2.0 認可と認証を実装します。

始める前に、OAuth 2.0 フローを見て、その仕組みをよりよく理解しましょう。

OAuth 2.0の概要

OAuth 2.0 は、サードパーティのアプリケーションがユーザーに代わってリソースにアクセスできるようにする承認プロトコルです。アクセス トークンを使用して、認証が成功した後に取得されるリソースへのアクセスを提供します。 OAuth 2.0 には、リソース オーナー、クライアント、認可サーバー、リソース サーバーの 4 つの役割があります。

1. リソース所有者: クライアントがアクセスしているリソースを所有するユーザー。

2.クライアント: ユーザーに代わってリソースへのアクセスを要求しているアプリケーション。

3.認可サーバー: ユーザーの認証が成功した後、クライアントにアクセス トークンを発行するサーバー。

4.リソースサーバー: クライアントがアクセスしているリソースを保持するサーバー。

OAuth 2.0 フロー

OAuth 2.0 フローには次の手順が含まれます:

ユーザーがサードパーティ アプリケーションから保護されたリソースへのアクセスを要求します。

1. サードパーティ アプリケーションは、アクセス トークンを取得するためにユーザーを OAuth プロバイダーにリダイレクトします。

2. ユーザーは OAuth プロバイダーにログインし、保護されたリソースにアクセスするための許可をサードパーティ アプリケーションに付与します。

3. OAuth プロバイダーは、サードパーティ アプリケーションにアクセス トークンを発行します。

4. サードパーティ アプリケーションは、アクセス トークンを使用して、ユーザーに代わって保護されたリソースにアクセスします。

OAuth 2.0 フローを理解したので、Spring Boot を使用した実装に進みましょう。

Spring Boot を使用した OAuth 2.0 の実装

依存関係を追加
まず、必要な依存関係を Spring Boot プロジェクトに追加します。これを行うには、次の依存関係を pom.xml ファイルに追加します。

`
org.springframework.boot
spring-boot-starter-oauth2-client

org.springframework.security
spring-security-oauth2-jose
`

OAuth 2.0を構成する

次に、WebSecurityConfigurerAdapter を拡張するクラスを作成して、OAuth 2.0 を構成します。以下に例を示します:

`@構成
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        .authorizeRequests()
            .antMatchers("/oauth2/**", "/login/**", "/logout/**")
            .permitAll()
            .anyRequest()
            .authenticated()
            .and()
        .oauth2Login()
            .loginPage("/login")
            .defaultSuccessURL("/home")
            .and()
        .logout()
            .logoutSuccessUrl("/")
            .logoutUrl("/logout")
            .and()
        .csrf().disable();
}

}`

この構成では、誰でも /oauth2/、/login/、および /logout/** エンドポイントにアクセスできます。他のすべてのエンドポイントには認証が必要です。ユーザーが OAuth 2.0 経由でログインすると、/home エンドポイントにリダイレクトされます。ログアウトすると、/ エンドポイントにリダイレクトされます。

トークンを生成する

トークンを生成するには、spring-security-oauth2-jose 依存関係の JwtBuilder クラスを使用できます。以下に例を示します:

`import org.springframework.security.oauth2.jwt.Jwt;
import org.springframework.security.oauth2.jwt.JwtBuilder;
import org.springframework.security.oauth2.jwt.Jwts;
import org.springframework.security.oauth2.jwt.NimbusJwtEncoder;

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.time.Instant;
import java.util.Date;

パブリック クラス TokenGenerator {

public static void main(String[] args) throws NoSuchAlgorithmException {
    // Generate a key pair
    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
    keyPairGenerator.initialize(2048);
    KeyPair keyPair = keyPairGenerator.generateKeyPair();

    // Build the JWT
    JwtBuilder jwtBuilder = Jwts.builder()
            .setIssuer("https://example.com")
            .setAudience("https://example.com/resources")
            .setId("123")
            .setSubject("user@example.com")
            .setExpiration(Date.from(Instant.now().plusSeconds(3600)))
            .setIssuedAt(new Date())
            .signWith(new NimbusJwtEncoder(keyPair.getPrivate()));

    Jwt jwt = jwtBuilder.build();
    System.out.println(jwt.getTokenValue());
}

}`

このコードはキー ペアを生成し、必要なクレームを含む JWT を構築し、秘密キーで署名します。結果のトークンがコンソールに出力されます。

これはトークンを生成する方法の単なる例であることに注意してください。実際には、秘密キーを安全に保存し、有効期限を生成する別の方法を使用する必要があります。

OAuth 2.0 クライアントの構成

アプリケーションで OAuth 2.0 を使用するには、クライアントを構成する必要があります。 Spring Boot では、application.properties ファイルにプロパティを追加することでこれを行うことができます。以下に例を示します:

spring.security.oauth2.client.registration.example.client-id=client-id
spring.security.oauth2.client.registration.example.client-secret=client-secret
spring.security.oauth2.client.registration.example.scope=read,write
spring.security.oauth2.client.registration.example.redirect-uri=http://localhost:8080/login/oauth2/code/example
spring.security.oauth2.client.provider.example.authorization-uri=https://example.com/oauth2/authorize
spring.security.oauth2.client.provider.example.token-uri=https://example.com/oauth2/token
spring.security.oauth2.client.provider.example.user-info-uri=https://example.com/userinfo
spring.security.oauth2.client.provider.example.user-name-attribute=name

This configuration sets up an OAuth 2.0 client with the client ID and client secret provided by the example registration. It also sets the desired scope, redirect URI, and authorization, token, and user info URIs for the provider. Finally, it specifies that the user's name should be retrieved from the name attribute in the user info response.

Use the Token

Once you have a token, you can use it to access protected resources. For example, you can make an authenticated request to a resource server using the RestTemplate class. Here's an example:

`import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

public class ResourceClient {

public static void main(String[] args) {
    // Create a RestTemplate
    RestTemplate restTemplate = new RestTemplate();

    // Set the authorization header
    HttpHeaders headers = new HttpHeaders();
    headers.setBearerAuth("token");

    // Make the request
    HttpEntity<String> entity = new HttpEntity<>(headers);
    ResponseEntity<String> response = restTemplate.exchange(
            "https://example.com/resource",
            HttpMethod.GET,
            entity,
            String.class
    );

    // Print the response body
    System.out.println(response.getBody());
}

}`

This code sets the authorization header to the JWT token and makes a GET request to the /resource endpoint on the resource server. The response body is printed to the console.

Protect Endpoints

To protect endpoints in your Spring Boot application, you can use annotations provided by Spring Security. For example, you can use the @PreAuthorize annotation to ensure that a user has a specific role before they can access an endpoint. Here's an example:

`import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

@GetMapping("/admin")
@PreAuthorize("hasRole('ADMIN')")
public String adminEndpoint() {
    return "Hello, admin!";
}

}`

This code defines a controller with an endpoint that requires the user to have the ADMIN role in order to access it. If the user does not have the required role, they will receive a 403 Forbidden error.

Test the OAuth 2.0 flow

1. Start the application First, start the Spring Boot application that you’ve configured to use OAuth 2.0. You can do this by running the main() method in your application's main class.

2. Navigate to the login endpoint Next, navigate to the /login endpoint in your browser. For example, if your application is running on localhost:8080, you would go to http://localhost:8080/login.

3. Authenticate with the authorization server When you navigate to the login endpoint, your application will redirect you to the authorization server to authenticate. Depending on the authorization server, you may be prompted to enter your username and password, or you may be presented with a login button to authenticate with a third-party provider (such as Google or Facebook).

4. Grant access After you authenticate, you will be prompted to grant access to the scopes requested by the client. For example, if the client requested the read and write scopes, you may be prompted to grant access to read and write the user's data.

5. Receive the token Once you grant access, you will be redirected back to your application with an OAuth 2.0 token. This token can then be used to access protected resources.

6. For example, if you protected an endpoint with the @PreAuthorize annotation as described in the previous example, you could navigate to that endpoint and test whether or not you have access. If you have the required role, you will see the response from the endpoint. If you do not have the required role, you will receive a 403 Forbidden error.

以上がOAuth スプリングブートの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。