OAuth Spring Boot

Einführung

OAuth 2.0 ist ein Autorisierungsframework, das es Drittanbieteranwendungen ermöglicht, im Namen eines Benutzers auf geschützte Ressourcen zuzugreifen, ohne dass die Anmeldeinformationen des Benutzers erforderlich sind. Dies wird durch die Verwendung von Zugriffstokens erreicht, die von einem OAuth-Anbieter ausgegeben und von Drittanbieteranwendungen verwendet werden, um auf die Ressourcen des Benutzers zuzugreifen.

Spring Boot ist ein beliebtes Framework zum Erstellen von Webanwendungen in Java. Es bietet leistungsstarke Tools zum Erstellen sicherer und skalierbarer Webanwendungen und eignet sich gut für die Implementierung von OAuth 2.0.

In diesem Blogbeitrag gehen wir die Schritte durch, die zur Implementierung von OAuth 2.0 mit Spring Boot erforderlich sind. Wir werden das Spring Security OAuth 2.0-Framework verwenden, um die OAuth 2.0-Autorisierung und -Authentifizierung zu implementieren.

Bevor wir beginnen, gehen wir zunächst den OAuth 2.0-Ablauf durch, um besser zu verstehen, wie es funktioniert.

Überblick über OAuth 2.0

OAuth 2.0 ist ein Autorisierungsprotokoll, das es Drittanbieteranwendungen ermöglicht, im Namen eines Benutzers auf Ressourcen zuzugreifen. Es verwendet Zugriffstoken, um Zugriff auf Ressourcen zu ermöglichen, die nach erfolgreicher Authentifizierung erhalten werden. In OAuth 2.0 gibt es vier Rollen: Ressourcenbesitzer, Client, Autorisierungsserver und Ressourcenserver.

1. Ressourcenbesitzer: Der Benutzer, der Eigentümer der Ressource ist, auf die der Client zugreift.

2.Client: Die Anwendung, die im Namen des Benutzers Zugriff auf die Ressource anfordert.

3.Autorisierungsserver: Der Server, der nach erfolgreicher Authentifizierung des Benutzers Zugriffstokens an den Client ausstellt.

4.Ressourcenserver: Der Server, der die Ressource enthält, auf die der Client zugreift.

OAuth 2.0-Ablauf

Der OAuth 2.0-Ablauf umfasst die folgenden Schritte:

Benutzer fordert Zugriff auf eine geschützte Ressource von einer Drittanbieteranwendung an.

1. Die Drittanbieteranwendung leitet den Benutzer an einen OAuth-Anbieter weiter, um ein Zugriffstoken zu erhalten.

2. Der Benutzer meldet sich beim OAuth-Anbieter an und erteilt der Drittanbieteranwendung die Erlaubnis, auf die geschützte Ressource zuzugreifen.

3. Der OAuth-Anbieter stellt ein Zugriffstoken für die Drittanbieteranwendung aus.

4. Die Drittanbieteranwendung verwendet das Zugriffstoken, um im Namen des Benutzers auf die geschützte Ressource zuzugreifen.

Da wir nun den Ablauf von OAuth 2.0 verstanden haben, fahren wir mit der Implementierung mit Spring Boot fort.

Implementierung von OAuth 2.0 mit Spring Boot

Abhängigkeiten hinzufügen
Fügen Sie zunächst die erforderlichen Abhängigkeiten zu Ihrem Spring Boot-Projekt hinzu. Sie können dies tun, indem Sie die folgenden Abhängigkeiten zu Ihrer pom.xml-Datei hinzufügen:

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

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

Konfigurieren Sie OAuth 2.0

Als nächstes konfigurieren Sie OAuth 2.0, indem Sie eine Klasse erstellen, die WebSecurityConfigurerAdapter erweitert. Hier ist ein Beispiel:

`@Konfiguration
@EnableWebSecurity
Die öffentliche Klasse SecurityConfig erweitert 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();
}

}`

Diese Konfiguration ermöglicht jedem den Zugriff auf die Endpunkte /oauth2/, /login/ und /logout/**. Alle anderen Endpunkte erfordern eine Authentifizierung. Wenn sich ein Benutzer über OAuth 2.0 anmeldet, wird er zum /home-Endpunkt umgeleitet. Wenn sie sich abmelden, werden sie zum /-Endpunkt weitergeleitet.

Generieren Sie ein Token

Um ein Token zu generieren, können Sie die JwtBuilder-Klasse aus der Abhängigkeit spring-security-oauth2-jose verwenden. Hier ist ein Beispiel:

`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;

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

TokenGenerator der öffentlichen Klasse {

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

}`

Dieser Code generiert ein Schlüsselpaar, erstellt ein JWT mit den erforderlichen Ansprüchen und signiert es mit dem privaten Schlüssel. Der resultierende Token wird auf der Konsole gedruckt.

Beachten Sie, dass dies nur ein Beispiel für die Generierung eines Tokens ist. In der Praxis möchten Sie den privaten Schlüssel sicher speichern und eine andere Methode zur Generierung der Ablaufzeit verwenden.

Konfigurieren Sie den OAuth 2.0-Client

Um OAuth 2.0 in Ihrer Anwendung zu verwenden, müssen Sie einen Client konfigurieren. In Spring Boot können Sie dies tun, indem Sie Eigenschaften zu Ihrer application.properties-Datei hinzufügen. Hier ist ein Beispiel:

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.

Das obige ist der detaillierte Inhalt vonOAuth Spring Boot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!