But Spring OAuth

pengenalan

OAuth 2.0 ialah rangka kerja kebenaran yang membolehkan aplikasi pihak ketiga mengakses sumber yang dilindungi bagi pihak pengguna tanpa memerlukan kelayakan pengguna. Ini dicapai melalui penggunaan token akses, yang dikeluarkan oleh penyedia OAuth dan digunakan oleh aplikasi pihak ketiga untuk mengakses sumber pengguna.

Spring Boot ialah rangka kerja yang popular untuk membina aplikasi web di Java. Ia menyediakan satu set alat yang berkuasa untuk membina aplikasi web yang selamat dan berskala serta sangat sesuai untuk melaksanakan OAuth 2.0.

Dalam catatan blog ini, kami akan melalui langkah-langkah yang diperlukan untuk melaksanakan OAuth 2.0 menggunakan Spring Boot. Kami akan menggunakan rangka kerja Spring Security OAuth 2.0 untuk melaksanakan kebenaran dan pengesahan OAuth 2.0.

Sebelum bermula, mari kita lihat aliran OAuth 2.0 dahulu untuk mendapatkan pemahaman yang lebih baik tentang cara ia berfungsi.

Gambaran keseluruhan OAuth 2.0

OAuth 2.0 ialah protokol kebenaran yang membenarkan aplikasi pihak ketiga mengakses sumber bagi pihak pengguna. Ia menggunakan token akses untuk menyediakan akses kepada sumber, yang diperoleh selepas pengesahan berjaya. Terdapat empat peranan dalam OAuth 2.0: Pemilik Sumber, Pelanggan, Pelayan Kebenaran dan Pelayan Sumber.

1. Pemilik Sumber: Pengguna yang memiliki sumber yang sedang diakses oleh pelanggan.

2.Pelanggan: Aplikasi yang meminta akses kepada sumber bagi pihak pengguna.

3.Pelayan Kebenaran: Pelayan yang mengeluarkan token akses kepada klien selepas pengesahan pengguna berjaya.

4.Pelayan Sumber: Pelayan yang menyimpan sumber yang sedang diakses oleh pelanggan.

Aliran OAuth 2.0

Aliran OAuth 2.0 melibatkan langkah berikut:

Pengguna meminta akses kepada sumber yang dilindungi daripada aplikasi pihak ketiga.

1. Aplikasi pihak ketiga mengubah hala pengguna ke penyedia OAuth untuk mendapatkan token akses.

2. Pengguna log masuk ke penyedia OAuth dan memberikan kebenaran kepada aplikasi pihak ketiga untuk mengakses sumber yang dilindungi.

3. Pembekal OAuth mengeluarkan token akses kepada aplikasi pihak ketiga.

4. Aplikasi pihak ketiga menggunakan token akses untuk mengakses sumber yang dilindungi bagi pihak pengguna.

Sekarang kita mempunyai pemahaman tentang aliran OAuth 2.0, mari kita teruskan untuk melaksanakannya menggunakan Spring Boot.

Melaksanakan OAuth 2.0 menggunakan Spring Boot

Tambah kebergantungan
Mula-mula, tambahkan kebergantungan yang diperlukan pada projek Spring Boot anda. Anda boleh melakukan ini dengan menambahkan kebergantungan berikut pada fail pom.xml anda:

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

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

Konfigurasikan OAuth 2.0

Seterusnya, konfigurasikan OAuth 2.0 dengan mencipta kelas yang memanjangkan WebSecurityConfigurerAdapter. Berikut ialah contoh:

`@Konfigurasi
@EnableWebSecurity
SecurityConfig kelas awam memanjangkan 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();
}

}`

Konfigurasi ini membenarkan sesiapa sahaja mengakses titik akhir /oauth2/, /login/ dan /logout/**. Semua titik akhir lain memerlukan pengesahan. Apabila pengguna log masuk melalui OAuth 2.0, mereka akan diubah hala ke titik akhir /home. Apabila mereka log keluar, mereka akan diubah hala ke / titik akhir.

Hasilkan Token

Untuk menjana token, anda boleh menggunakan kelas JwtBuilder daripada kebergantungan spring-security-oauth2-jose. Berikut ialah contoh:

`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 kelas awam {

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());
}

}`

Kod ini menjana pasangan kunci, membina JWT dengan tuntutan yang diperlukan dan menandatanganinya dengan kunci persendirian. Token yang terhasil dicetak ke konsol.

Perhatikan bahawa ini hanyalah contoh cara menjana token. Dalam amalan, anda ingin menyimpan kunci persendirian dengan selamat dan menggunakan kaedah lain untuk menjana masa tamat tempoh.

Konfigurasikan Klien OAuth 2.0

Untuk menggunakan OAuth 2.0 dalam aplikasi anda, anda perlu mengkonfigurasi klien. Dalam Spring Boot, anda boleh melakukan ini dengan menambahkan sifat pada fail application.properties anda. Berikut ialah contoh:

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.

Atas ialah kandungan terperinci But Spring OAuth. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!