Démarrage de printemps OAuth

Introduction

OAuth 2.0 est un cadre d'autorisation qui permet aux applications tierces d'accéder à des ressources protégées au nom d'un utilisateur sans nécessiter les informations d'identification de l'utilisateur. Ceci est réalisé grâce à l'utilisation de jetons d'accès, qui sont émis par un fournisseur OAuth et utilisés par des applications tierces pour accéder aux ressources de l'utilisateur.

Spring Boot est un framework populaire pour créer des applications Web en Java. Il fournit un ensemble d'outils puissants pour créer des applications Web sécurisées et évolutives et est bien adapté à la mise en œuvre d'OAuth 2.0.

Dans cet article de blog, nous passerons en revue les étapes nécessaires à la mise en œuvre d'OAuth 2.0 à l'aide de Spring Boot. Nous utiliserons le framework Spring Security OAuth 2.0 pour implémenter l'autorisation et l'authentification OAuth 2.0.

Avant de commencer, passons en revue le flux OAuth 2.0 pour mieux comprendre son fonctionnement.

Présentation d'OAuth 2.0

OAuth 2.0 est un protocole d'autorisation qui permet aux applications tierces d'accéder aux ressources au nom d'un utilisateur. Il utilise des jetons d'accès pour donner accès aux ressources, qui sont obtenues après une authentification réussie. Il existe quatre rôles dans OAuth 2.0 : propriétaire de ressources, client, serveur d'autorisation et serveur de ressources.

1. Propriétaire de la ressource : l'utilisateur qui possède la ressource à laquelle le client accède.

2.Client : l'application qui demande l'accès à la ressource au nom de l'utilisateur.

3.Serveur d'autorisation : le serveur qui émet des jetons d'accès au client après une authentification réussie de l'utilisateur.

4.Resource Server : le serveur qui contient la ressource à laquelle le client accède.

Flux OAuth 2.0

Le flux OAuth 2.0 comprend les étapes suivantes :

L'utilisateur demande l'accès à une ressource protégée à partir d'une application tierce.

1. L'application tierce redirige l'utilisateur vers un fournisseur OAuth pour obtenir un jeton d'accès.

2. L'utilisateur se connecte au fournisseur OAuth et autorise l'application tierce à accéder à la ressource protégée.

3. Le fournisseur OAuth émet un jeton d'accès à l'application tierce.

4. L'application tierce utilise le jeton d'accès pour accéder à la ressource protégée au nom de l'utilisateur.

Maintenant que nous comprenons le flux OAuth 2.0, passons à sa mise en œuvre à l'aide de Spring Boot.

Implémentation d'OAuth 2.0 à l'aide de Spring Boot

Ajouter des dépendances
Tout d’abord, ajoutez les dépendances nécessaires à votre projet Spring Boot. Vous pouvez le faire en ajoutant les dépendances suivantes à votre fichier pom.xml :

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

org.springframework.security
printemps-sécurité-oauth2-jose
`

Configurer OAuth 2.0

Ensuite, configurez OAuth 2.0 en créant une classe qui étend WebSecurityConfigurerAdapter. Voici un exemple :

`@Configuration
@EnableWebSecurity
la classe publique SecurityConfig étend 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();
}

}`

Cette configuration permet à quiconque d'accéder aux points de terminaison /oauth2/, /login/ et /logout/**. Tous les autres points de terminaison nécessitent une authentification. Lorsqu'un utilisateur se connecte via OAuth 2.0, il sera redirigé vers le point de terminaison /home. Lorsqu'ils se déconnecteront, ils seront redirigés vers le point de terminaison /.

Générer un jeton

Pour générer un token, vous pouvez utiliser la classe JwtBuilder de la dépendance spring-security-oauth2-jose. Voici un exemple :

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

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

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

}`

Ce code génère une paire de clés, construit un JWT avec les revendications nécessaires et le signe avec la clé privée. Le jeton résultant est imprimé sur la console.

Notez qu'il ne s'agit que d'un exemple de la façon de générer un jeton. En pratique, vous voudriez stocker la clé privée en toute sécurité et utiliser une méthode différente pour générer le délai d'expiration.

Configurer le client OAuth 2.0

Pour utiliser OAuth 2.0 dans votre application, vous devrez configurer un client. Dans Spring Boot, vous pouvez le faire en ajoutant des propriétés à votre fichier application.properties. Voici un exemple :

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.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!