Utilisation de Spring Security OAuth pour une autorisation sécurisée dans le développement d'API Java

Une exigence courante dans le développement d'API Java est d'implémenter des fonctions d'authentification et d'autorisation des utilisateurs. Afin de fournir des services API plus sécurisés et plus fiables, la fonction d'autorisation est devenue particulièrement importante. Spring Security OAuth est un excellent framework open source qui peut nous aider à implémenter des fonctions d'autorisation dans les API Java. Cet article explique comment utiliser Spring Security OAuth pour une autorisation sécurisée.

1. Qu'est-ce que Spring Security OAuth ?

Spring Security OAuth est une extension du framework Spring Security, qui peut nous aider à implémenter les fonctions d'authentification et d'autorisation OAuth.

OAuth est un standard ouvert permettant d'autoriser des applications tierces à accéder à des ressources. Cela peut nous aider à réaliser le découplage de la logique métier et à sécuriser les applications. Le processus d'autorisation OAuth comprend généralement les rôles suivants :

• Utilisateur : le propriétaire de la ressource ;
• Client : l'application qui s'applique à accéder aux ressources utilisateur ;
• Serveur d'autorisation : le serveur qui gère l'autorisation des utilisateurs ; : stocke le serveur de ressources utilisateur ;

Processus d'autorisation

2. Spring Security OAuth implémente quatre points de terminaison dans le processus d'autorisation OAuth :

/oauth/authorize : le point de terminaison d'autorisation du serveur d'autorisation ; le point de terminaison du jeton du serveur d'autorisation ;

• /oauth/confirm_access : le point de terminaison permettant au client de confirmer l'autorisation ;
• /oauth/error : le point de terminaison pour les informations d'erreur du serveur d'autorisation
• Spring Security OAuth implémente les quatre modes d'autorisation d'OAuth ; 2.0 :

Mode code d'autorisation : le scénario d'utilisation est que l'autorisation de l'utilisateur est requise au démarrage de l'application ;

Mode mot de passe : le scénario d'utilisation est que le client gère les informations d'identification de l'utilisateur de manière indépendante

• Mode simplifié : le scénario d'utilisation est ; que le client s'exécute dans le navigateur et ne nécessite pas le client Protection côté client des informations d'identification de l'utilisateur ;
• Mode client : le scénario d'utilisation est que le client ne nécessite pas d'autorisation de l'utilisateur et que le jeton d'accès demandé représente uniquement le client lui-même ;
• Ajouter une dépendance Spring Security OAuth

Ajouter Spring aux dépendances Security OAuth du projet. Configurez les éléments suivants dans pom.xml :

3. <dependency>
       <groupId>org.springframework.security.oauth</groupId>
       <artifactId>spring-security-oauth2</artifactId>
       <version>2.3.4.RELEASE</version>
   </dependency>

Configurez le serveur d'autorisation

Nous devons définir le serveur d'autorisation pour l'autorisation. Dans Spring Security OAuth, vous pouvez définir un serveur d'autorisation en activant un serveur d'authentification OAuth2 et en implémentant l'interface AuthorizationServerConfigurer.

4. @Configuration
   @EnableAuthorizationServer
   public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
   
       @Autowired
       TokenStore tokenStore;
   
       @Autowired
       AuthenticationManager authenticationManager;
   
       @Override
       public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
           clients.inMemory()
               .withClient("client")
               .secret("{noop}secret")
               .authorizedGrantTypes("client_credentials", "password")
               .scopes("read", "write")
               .accessTokenValiditySeconds(3600)
               .refreshTokenValiditySeconds(7200);
       }
   
       @Override
       public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
           endpoints.tokenStore(tokenStore)
               .authenticationManager(authenticationManager);
       }
   }

Dans le code ci-dessus, nous définissons un service de détails client basé sur la mémoire, configurons le type d'autorisation comme client_credentials et mot de passe, et spécifions également la période de validité du jeton d'accès et du jeton d'actualisation. De plus, nous définissons les points de terminaison et leurs tokenStore et AuthenticationManager requis.

Configurer le serveur de ressources

Pour utiliser l'autorisation de sécurité Spring Security OAuth, nous devons également configurer le serveur de ressources. Dans Spring Security OAuth, nous pouvons définir des serveurs de ressources en implémentant l'interface ResourceServerConfigurer.

5. @Configuration
   @EnableResourceServer
   public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
   
       @Override
       public void configure(HttpSecurity http) throws Exception {
           http.authorizeRequests()
               .antMatchers("/api/**").authenticated()
               .anyRequest().permitAll();
       }
   
       @Override
       public void configure(ResourceServerSecurityConfigurer config) throws Exception {
           config.resourceId("my_resource_id");
       }
   }

Dans le code ci-dessus, nous avons défini /api/** pour donner une authentification tandis que d'autres requêtes autorisent un accès anonyme. Nous configurons également l'ID de ressource "my_resource_id" pour une utilisation dans les processus d'autorisation ultérieurs.

Configurer la sécurité Web

Pour utiliser l'autorisation de sécurité Spring Security OAuth, nous devons également configurer la sécurité Web. Dans Spring Security OAuth, la sécurité peut être définie en implémentant l'interface SecurityConfigurer.

6. @Configuration
   public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
   
       @Override
       protected void configure(AuthenticationManagerBuilder auth) throws Exception {
           auth.inMemoryAuthentication()
               .withUser("user")
               .password("{noop}password")
               .roles("USER");
       }
   
       @Override
       @Bean
       public AuthenticationManager authenticationManagerBean() throws Exception {
           return super.authenticationManagerBean();
       }
   
       @Override
       protected void configure(HttpSecurity http) throws Exception {
           http.authorizeRequests()
               .antMatchers("/oauth/**")
               .permitAll()
               .anyRequest()
               .authenticated()
               .and()
               .formLogin()
               .permitAll();
       }
   }

Dans le code ci-dessus, nous définissons un service de détails utilisateur basé sur la mémoire et déclarons les demandes qui nécessitent une authentification (c'est-à-dire que les chemins après /oauth/** nécessitent tous une authentification, les autres chemins conviennent à un accès anonyme). Nous avons également configuré un simple formulaire de connexion permettant aux utilisateurs de se connecter à l'application.

Implement UserDetailsService

Nous devons implémenter l'interface UserDetailsService pour l'utiliser dans l'autorisation de sécurité. Ici, nous utilisons directement la mémoire pour enregistrer les comptes d'utilisateurs et les mots de passe, et n'impliquons pas d'opérations de base de données.

7. @Service
   public class UserDetailsServiceImpl implements UserDetailsService {
   
       @Override
       public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
           if ("user".equals(username)) {
               return new User("user", "{noop}password",
                       AuthorityUtils.createAuthorityList("ROLE_USER"));
           } else {
               throw new UsernameNotFoundException("username not found");
           }
       }
   }

Implémentation de l'API

Ensuite, nous devons implémenter une API simple. Nous avons ajouté une API getGreeting() sous le chemin /api/** pour renvoyer un message d'accueil au client.

8. @RestController
   @RequestMapping("/api")
   public class ApiController {
   
       @GetMapping("/greeting")
       public String getGreeting() {
           return "Hello, World!";
       }
   }

Test du processus d'autorisation

Enfin, nous devons tester si le processus d'autorisation fonctionne comme prévu. Tout d'abord, nous utilisons le mode code d'autorisation pour obtenir le code d'autorisation :

9. http://localhost:8080/oauth/authorize?response_type=code&client_id=client&redirect_uri=http://localhost:8080&scope=read

Visitez l'URL ci-dessus dans votre navigateur, il vous sera demandé de saisir votre nom d'utilisateur et votre mot de passe pour l'autorisation. Entrez le nom d'utilisateur et le mot de passe et cliquez sur Autoriser, vous serez redirigé vers http://localhost:8080/?code=xxx, où xxx est le code d'autorisation.

Ensuite, nous obtenons le jeton d'accès en utilisant le modèle de mot de passe :

curl -X POST 
  http://localhost:8080/oauth/token 
  -H 'content-type: application/x-www-form-urlencoded' 
  -d 'grant_type=password&username=user&password=password&client_id=client&client_secret=secret'

Vous recevrez une réponse JSON contenant le jeton d'accès et le jeton d'actualisation :

{
    "access_token":"...",
    "token_type":"bearer",
    "refresh_token":"...",
    "expires_in":3600,
    "scope":"read"
}

Vous pouvez maintenant utiliser ce jeton d'accès pour accéder au service API :

curl -X GET 
  http://localhost:8080/api/greeting 
  -H 'authorization: Bearer xxx'

où xxx est votre jeton d'accès. Vous recevrez une réponse JSON contenant le message d'accueil « Hello, World ! ».

Dans cet article, nous expliquons comment utiliser Spring Security OAuth pour une autorisation sécurisée. Spring Security OAuth est un framework très puissant qui peut nous aider à mettre en œuvre tous les rôles dans le processus d'autorisation OAuth. Dans les applications pratiques, nous pouvons choisir différents modes d'autorisation et configurations de service en fonction de différentes exigences de sécurité.

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!