Comment utiliser le framework OAuth2 de gestion de la sécurité SpringBoot

Introduction à OAuth3

OAuth est un standard ouvert qui permet aux utilisateurs de permettre aux applications tierces d'accéder aux ressources privées de l'utilisateur (telles que les avatars, les photos, les vidéos, etc.). Des mots de passe sont fournis aux applications tierces.

L'accès aux données stockées chez un fournisseur de services spécifique s'effectue à l'aide d'un jeton au lieu d'un nom d'utilisateur et d'un mot de passe. Chaque jeton autorise un site Web spécifique à accéder à des ressources spécifiques pendant une période de temps spécifique.

OAuth permet aux utilisateurs d'autoriser des sites Web tiers à accéder de manière flexible à des informations spécifiques stockées sur d'autres serveurs de ressources, plutôt qu'à toutes les informations. Par exemple, si un utilisateur souhaite se connecter à Zhihu via QQ, alors Zhihu est une application tierce. Si Zhihu souhaite accéder à certaines informations de base de l'utilisateur, il a besoin de l'autorisation de l'utilisateur. Si l'utilisateur indique à Zhihu son utilisateur QQ. nom et mot de passe, alors Zhihu peut accéder à toutes les données de l'utilisateur, et seul l'utilisateur peut révoquer l'autorisation en changeant son mot de passe. Cette méthode d'autorisation présente de grands risques de sécurité. Si vous utilisez OAuth, ce problème peut être bien résolu.

L'utilisation de jetons permet aux utilisateurs d'autoriser ou de retirer de manière flexible les autorisations des applications tierces. OAuth 2 est la prochaine version du protocole OAuth, mais n'est pas rétrocompatible avec OAuth 1.0.

OAuth 2 se concentre sur la simplicité pour les développeurs clients, tout en fournissant des processus d'authentification spécialisés pour les applications Web, les applications de bureau, les appareils mobiles et les appareils de salon. L'authentification de connexion de développement Web traditionnelle est généralement basée sur Session, mais continuer à utiliser Session dans une architecture séparée front-end et back-end entraînera de nombreux inconvénients, car le terminal mobile (Android, IOS, applet WeChat, etc.) non plus. prend en charge Cookie (applet WeChat), ou il est très peu pratique à utiliser. Pour ces problèmes, l'utilisation de l'authentification OAuth 2 peut les résoudre.

Rôles OAuth3

Comprenez d'abord plusieurs rôles de base dans OAuth 2

• Propriétaire de la ressource : c'est-à-dire l'utilisateur, qui a des avatars, des photos, des vidéos et d'autres ressources

• Client : c'est-à-dire des applications tierces

• Serveur d'autorisation : utilisé pour vérifier si les informations fournies par l'utilisateur sont correctes et renvoyer un token à l'application tierce

• Serveur de ressources : un serveur qui fournit des ressources à l'utilisateur, telles que des avatars, des photos, des vidéos et d'autres ressources

D'une manière générale, disons, le serveur d'autorisation et le serveur de ressources peuvent être le même serveur.

Processus d'autorisation OAuth3

Étape 01 : Le client (application tierce) demande l'autorisation à l'utilisateur.

Lorsque l'utilisateur clique sur le bouton Accepter l'autorisation sur la page d'autorisation du service, le serveur renvoie un certificat d'autorisation au client.

Étape 03 : Le client apporte la licence d'autorisation au serveur d'autorisation pour demander un jeton.

Étape 04 : Une fois que le serveur d'autorisation a vérifié que les informations sont correctes, il délivre le jeton au client.

Étape 05 : Le client apporte le jeton au serveur de ressources pour accéder aux ressources.

Étape 06 : Le serveur de ressources ouvre la ressource après avoir vérifié que le jeton est correct.

Mode d'autorisation

Les modes d'autorisation du protocole OAuth sont répartis en 4 types, comme suit

• Le mode d'autorisation par code d'autorisation est le plus complet et le plus rigoureux parmi les méthodes d'autorisation, et son code d'autorisation (code d'autorisation) est la clé. La caractéristique de ce mode est que le serveur du client interagit avec le serveur d'autorisation. Les fonctions de connexion courantes des plateformes tierces nationales adoptent essentiellement cette méthode

• Mode simplifié : le mode simplifié ne nécessite pas la participation du serveur client, directement dans le navigateur Demander un jeton auprès du serveur d'autorisation. Généralement, s'il s'agit d'une page purement statique, vous pouvez utiliser cette méthode

• En mode mot de passe, l'utilisateur fournit directement son nom d'utilisateur et son mot de passe au client, et le client utilise ces informations pour demander au serveur d'autorisation de demander un jeton d'accès. Les utilisateurs doivent connaître des informations de haut niveau sur le client, par exemple si l'application client et le fournisseur de services sont la même entreprise.

• En mode client, le fournisseur de services autorise le client plutôt qu'un utilisateur spécifique. À proprement parler, le mode client ne peut pas être considéré comme une solution aux problèmes que résout le protocole OAuth. Cependant, pour les développeurs, il est utile d'utiliser cette méthode dans certaines applications de séparation front-end et back-end ou dans les serveurs d'authentification et d'autorisation fournis. pour les terminaux mobiles. Le mode est toujours très pratique

Les 4 modes ont chacun leurs propres avantages et conviennent à différents scénarios de développement. Les développeurs peuvent choisir en fonction de la situation réelle

Pratique

Ce qui est introduit ici est de séparer. applications au front et au back-end (ou pour mobile, Comment créer le service OAuth dans le serveur d'authentification fourni par l'applet WeChat, etc., le mode mot de passe est donc principalement introduit.

1. Créez un projet et ajoutez des dépendances

Créez un projet Web Spring Boot et ajoutez les dépendances suivantes

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
  <exclusions>
    <exclusion>
      <groupId>io.lettuce</groupId>
      <artifactId>lettuce-core</artifactId>
    </exclusion>
  </exclusions>
</dependency>
<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.security.oauth</groupId>
  <artifactId>spring-security-oauth3</artifactId>
  <version>2.3.3.RELEASE</version>
</dependency>

Étant donné que le protocole OAuth de Spring Boot est basé sur Spring Security, vous devez d'abord ajouter la dépendance Spring Security. 2, ajoutez donc les dépendances liées à OAuth 2. Le jeton peut être stocké sur le serveur de cache Redis. En même temps, Redis a des fonctions telles que l'expiration, ce qui est très approprié pour le stockage des jetons, donc des dépendances Redis sont également ajoutées.

Configurer application.properties

spring.redis.database=0
spring.redis.host=ip地址
spring.redis.port=6379
spring.redis.password=root
spring.redis.jedis.pool.max-active=8
spring.redis.jedis.pool.max-idle=8
spring.redis.jedis.pool.max-wait=-1ms
spring.redis.jedis.pool.min-idle=0

2. 配置授权服务器

授权服务器和资源服务器可以是同一台服务器，也可以是不同服务器，此处假设是同一台服务器，通过不同的配置分别开启授权服务器和资源服务器，首先是授权服务器：

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
    @Autowired
    AuthenticationManager authenticationManager;
    @Autowired
    RedisConnectionFactory redisConnectionFactory;
    @Autowired
    UserDetailsService userDetailsService;
    @Bean
    PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
                .withClient("password")
                .authorizedGrantTypes("password", "refresh_token")
                .accessTokenValiditySeconds(1800)
                .resourceIds("rid")
                .scopes("all")
                .secret("$2a$10$RMuFXGQ5AtH4wOvkUqyvuecpqUSeoxZYqilXzbz50dceRsga.WYiq");
    }
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.tokenStore(new RedisTokenStore(redisConnectionFactory))
                .authenticationManager(authenticationManager)
                .userDetailsService(userDetailsService);
    }
    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        security.allowFormAuthenticationForClients();
    }
}

代码解释：

• 自定义类继承自 AuthorizationServerConfigurerAdapter ，完成对授权服务器的配置，然后通过 @EnableAuthorizationServer 注解开启授权服务器

• 注入 AuthenticationManager 用来支持 password 模式

• 注入 RedisConnectionFactory 用来完成 Redis 缓存，将令牌信息储存到 Redis 缓存中

• 注入 UserDetailsService 该对象为刷新 token 提供支持

• 在 configure(ClientDetailsServiceConfigurer clients) 方法中配置 password 授权模式，authorizedGrantTypes 表示 OAuth 2 中的授权模式为 password 和 refresh_token 两种，在标准的 OAuth 2 协议中，授权模式并不包括 refresh_token ，但是在 Spring Security 的实现中将其归为一种，因此如果要实现 access_token 的刷新，就需要添加这样一种授权模式；accessTokenValiditySeconds 方法配置了 access_token 的过期时间；resourceIds 配置了资源 id；secret 方法配置了加密后的密码，明文是 123

• configure(AuthorizationServerEndpointsConfigurer endpoints) 方法配置了令牌的存储，AuthenticationManager 和 UserDetailsService 主要用于支持 password 模式以及令牌的刷新

• configure(AuthorizationServerSecurityConfigurer security) 方法配置表示支持 client_id 和 client_secret 做登录认证

3. 配置资源服务器

@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        resources.resourceId("rid").stateless(true);
    }
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/admin/**").hasRole("admin")
                .antMatchers("/user/**").hasRole("user")
                .anyRequest().authenticated();
    }
}

代码解释：

• 自定义类继承自 ResourceServerConfigurerAdapter ，并添加 @EnableResourceServer 注解开启资源服务器配置

• resources.resourceId(“rid”).stateless(true); 配置资源 id，这里的资源 id 和授权服务器中的资源 id 一直，然后设置这些资源仅基于令牌认证

• configure(HttpSecurity http) 方法配置 HttpSecurity

4. 配置 Security

@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
    @Bean
    @Override
    protected UserDetailsService userDetailsService() {
        return super.userDetailsService();
    }
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
                .withUser("admin")
                .password("$2a$10$RMuFXGQ5AtH4wOvkUqyvuecpqUSeoxZYqilXzbz50dceRsga.WYiq")
                .roles("admin")
                .and()
                .withUser("sang")
                .password("$2a$10$RMuFXGQ5AtH4wOvkUqyvuecpqUSeoxZYqilXzbz50dceRsga.WYiq")
                .roles("user");
    }
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.antMatcher("/oauth/**").authorizeRequests()
                .antMatchers("/oauth/**").permitAll()
                .and().csrf().disable();
    }
}

这里两个 Bean 将注入授权服务器配置类中使用，另外，这里的 HttpSecurity 配置主要是配置 /oauth/** 模式的 URL ，这一类的请求直接放行。在 Spring Security 配置和资源服务器配置中，一共涉及两个 HttpSecurity ，其中 Spring Security 中的配置优先级高于资源服务器中的配置，即请求地址先经过 Spring Security 的 HttpSecurity ，再经过资源服务器的 HttpSecurity。

5. 验证测试

首先创建三个简单的请求地址

@RestController
public class HelloController {
    @GetMapping("/admin/hello")
    public String admin() {
        return "Hello admin!";
    }
    @GetMapping("/user/hello")
    public String user() {
        return "Hello user!";
    }
    @GetMapping("/hello")
    public String hello() {
        return "hello";
    }
}

根据前文的配置，要请求这三个地址，分别需要 admin 角色、user 角色以及登录后访问。

所有都配置完成后，启动 Redis 服务器，再启动 Spring Boot 项目，首先发送一个 POST 请求获取 token，请求地址如下（注意这里是一个 POST 请求，为了显示方便，将参数写在地址栏中）：http://localhost:8080/oauth/token?username=sang&password=123&grant_type=password&client_id=password&scope=all&client_secret=123

请求地址中包含的参数有用户名、密码、授权模式、客户端 id 、scope 以及客户端密码，基本就是授权服务器中所配置的数据，请求结果如图

其中 access_token 是获取其它资源时要用的令牌，refresh_token 用来刷新令牌，expires_in 表示 access_token 过期时间，当 access_token 过期后，使用 refresh_token 重新获取新的 access_token （前提是 refresh_token 未过期），请求地址（注意也是POST请求）：http://localhost:8080/oauth/token?grant_type=refresh_token&refresh_token=693b0e36-4515-442a-8c5d-90bade3c74d2&client_id=password&client_secret=123

获取新的 access_token 时需要携带上 refresh_token ，同事授权模式设置为 refresh_token ，在获取的结果中 access_token 会变化，同时 access_token 有效期也会变化，如图

接下来访问所有资源，携带上 access_token 参数即可，例如 /user/hello 接口：http://localhost:8080/user/hello?access_token=0497e4bc-df37-460e-8755-b813b9dbf36a，访问结果如图

Si une ressource est accédée illégalement, par exemple, l'utilisateur sang accède à l'interface /admin/hello, le résultat est tel qu'indiqué dans la figure

# 🎜🎜#

#🎜🎜 #À ce stade, un système d'authentification OAuth en mode mot de passe a été mis en place avec succès.

Il existe 4 modes d'authentification dans OAuth. Les développeurs doivent choisir l'un d'entre eux en fonction de la situation réelle de leur propre développement. Ce qui est présenté ici est le mode de mot de passe couramment utilisé en front-end et en back-end. les applications de séparation de fin et d'autres modes d'autorisation ont également leurs propres scénarios d'utilisation.

Dans l'ensemble, l'utilisation de Spring Security OAuth 2 est encore relativement compliquée, et la configuration est également relativement lourde. Si le scénario d'application du développeur est relativement simple, vous pouvez créer OAuth 2 vous-même selon le processus d'autorisation. introduit ici.

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!