Maison  >  Article  >  Java  >  Comment configurer Spring Security dans la gestion de la sécurité SpringBoot

Comment configurer Spring Security dans la gestion de la sécurité SpringBoot

WBOY
WBOYavant
2023-05-12 21:52:102300parcourir

    Les frameworks de sécurité courants dans le domaine du développement Java incluent Shiro et Spring Security. Shiro est un framework léger de gestion de la sécurité qui fournit l'authentification, l'autorisation, la gestion des sessions, la gestion des mots de passe, la gestion du cache et d'autres fonctions. Spring Security est un cadre de gestion de la sécurité relativement complexe avec des fonctions plus puissantes que Shiro, un contrôle des autorisations plus granulaire et une prise en charge conviviale d'OAuth 2. Étant donné que Spring Security est issu de la famille Spring, il peut être intégré de manière transparente au framework Spring, en particulier au framework Spring. solution de configuration automatisée fournie dans Spring Boot, peut rendre l'utilisation de Spring Security plus pratique.

    Configuration de base de Spring Security

    Utilisation de base

    1 Créez un projet pour ajouter des dépendances

    Créez un projet Spring Boot, puis ajoutez des dépendances spring-boot-starter-security

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    2.
    3. Démarrez le test du projet
    Après un démarrage réussi, l'accès à l'interface /hello passera automatiquement à la page de connexion. Cette page de connexion est fournie par Spring Security

    Comment configurer Spring Security dans la gestion de la sécurité SpringBoot

    Le nom d'utilisateur par défaut est user et le mot de passe de connexion par défaut. est généré aléatoirement à chaque démarrage du projet, vérifiez le journal de démarrage du projet

    Utilisation du mot de passe de sécurité généré : 4f845a17-7b09-479c-8701-48000e89d364

    Après une connexion réussie, l'utilisateur peut accéder à l'interface /hello

    Configurer le nom d'utilisateur et le mot de passe

    Si les développeurs ne sont pas satisfaits du nom d'utilisateur et du mot de passe par défaut, ils peuvent configurer le nom d'utilisateur, le mot de passe et le rôle d'utilisateur par défaut dans application.properties

    spring.security.user.name=tangsan

    spring.security .user. password=tangsan
    spring.security.user.roles=admin

    Authentification basée sur la mémoire

    Les développeurs peuvent également personnaliser les classes héritées de WebSecurityConfigurer pour obtenir des configurations plus personnalisées de Spring Security, telles que l'authentification basée sur la mémoire, le La méthode de configuration est la suivante :

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

    Explication du code :

    • Customized MyWebSecurityConfig hérite de WebSecurityConfigurerAdapter et réécrit la méthode configure(AuthenticationManagerBuilder auth), dans laquelle deux utilisateurs sont configurés, un utilisateur est administrateur et a deux rôles ADMIN, UTILISATEUR ; l'autre utilisateur est tangsan, avec un rôle UTILISATEUR

    • La version de Spring Security utilisée ici est 5.0.6. Plusieurs méthodes de cryptage de mot de passe ont été introduites dans Spring Security 5.x. Les développeurs doivent spécifier un aimablement, NoOpPasswordEncoder est utilisé. ici, c'est-à-dire que le mot de passe n'est pas crypté. Remarque : pour la configuration utilisateur basée sur la mémoire, vous n'avez pas besoin d'ajouter le préfixe « ROLE_ » lors de la configuration du rôle. Ceci est différent de l'authentification basée sur la base de données de la section 10.2.

      Une fois la configuration terminée, redémarrez le projet et vous pourrez vous connecter en utilisant les deux utilisateurs configurés ici.
    HttpSecurity

    Bien que la fonction d'authentification puisse désormais être implémentée, les ressources protégées sont par défaut et la gestion des rôles ne peut pas être basée sur la situation réelle. Si vous souhaitez implémenter ces fonctions, vous devez réécrire une autre méthode dans WebSecurityConfigurerAdapter

    @Configuration
    public class MyWebSecurityConfig extends WebSecurityConfigurerAdapter {
        @Bean
        PasswordEncoder passwordEncoder() {
            return NoOpPasswordEncoder.getInstance();
        }
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
            auth.inMemoryAuthentication()
                    .withUser("admin").password("123123").roles("ADMIN", "USER")
                    .and()
                    .withUser("tangsan").password("123123").roles("USER");
        }
    }

    Code. explication :

    Tout d'abord, trois utilisateurs sont configurés. L'utilisateur root a les rôles d'ADMIN et de DBA, l'utilisateur admin a les rôles d'ADMIN et d'UTILISATEUR, et tangsan est utilisé pour avoir le rôle d'UTILISATEUR

    • Appel. la méthode authorizeRequests() pour ouvrir la configuration de HttpSecurity, antMatchers(), hasRole(), la configuration de la méthode access() pour accéder à différents chemins nécessite différents utilisateurs et rôles

    • anyRequest(), Authenticated() indique qu'en plus de les utilisateurs définis précédemment accèdent à d'autres URL. Vous devez accéder à

    • formLogin(), loginProcessingUrl("/login"), permitAll() après l'authentification, ce qui signifie activer la connexion par formulaire que vous avez vue précédemment. interface de connexion en tant que /login, afin que vous puissiez appeler directement l'interface /login, lancer une requête POST pour vous connecter. Le nom d'utilisateur dans le paramètre de connexion doit être nommé username et le mot de passe doit être nommé password L'interface loginProcessingUrl est configurée pour faciliter Ajax. ou des terminaux mobiles pour appeler l'interface de connexion. Enfin, permitAll est configuré, ce qui signifie que toutes les interfaces liées à la connexion sont accessibles sans authentification.

    • Une fois la configuration terminée, ajoutez l'interface suivante au contrôleur pour tester :

      @Configuration
      public class MyWebSecurityConfig extends WebSecurityConfigurerAdapter {
          @Bean
          PasswordEncoder passwordEncoder() {
              return NoOpPasswordEncoder.getInstance();
          }
          @Override
          protected void configure(AuthenticationManagerBuilder auth) throws Exception {
              auth.inMemoryAuthentication()
                      .withUser("root").password("123123").roles("ADMIN", "DBA")
                      .and()
                      .withUser("admin").password("123123").roles("ADMIN", "USER")
                      .and()
                      .withUser("tangsan").password("123123").roles("USER");
          }
          @Override
          protected void configure(HttpSecurity http) throws Exception {
              http.authorizeRequests()
                      .antMatchers("/admin/**")
                      .hasRole("ADMIN")
                      .antMatchers("/user/**")
                      .access("hasAnyRole(&#39;ADMIN&#39;,&#39;USER&#39;)")
                      .antMatchers("/db/**")
                      .access("hasRole(&#39;ADMIN&#39;) and hasRole(&#39;DBA&#39;)")
                      .anyRequest()
                      .authenticated()
                      .and()
                      .formLogin()
                      .loginProcessingUrl("/login")
                      .permitAll()
                      .and()
                      .csrf()
                      .disable();
          }
      }

      Selon la configuration ci-dessus, les utilisateurs root et admin de l'interface "/admin/hello" ont des droits d'accès au "/user/ ; hello" interface admin et tangsan L'utilisateur a des droits d'accès ; "/db/hello" seul l'utilisateur root a des droits d'accès. Tester dans le navigateur est simple et je n’entrerai pas dans les détails ici.
    • 登录表单详细配置

      目前为止,登录表单一直使用 Spring Security 提供的页面,登录成功后也是默认的页面跳转,但是,前后端分离已经成为企业级应用开发的主流,在前后端分离的开发方式中,前后端的数据交互通过 JSON 进行,这时,登录成功后就不是页面跳转了,而是一段 JSON 提示。要实现这些功能,只需要继续完善上文的配置

      @Override
      protected void configure(HttpSecurity http) throws Exception {
          http.authorizeRequests()
              .antMatchers("/admin/**")
              .hasRole("ADMIN")
              .antMatchers("/user/**")
              .access("hasAnyRole(&#39;ADMIN&#39;,&#39;USER&#39;)")
              .antMatchers("/db/**")
              .access("hasRole(&#39;ADMIN&#39;) and hasRole(&#39;DBA&#39;)")
              .anyRequest()
              .authenticated()
              .and()
              .formLogin()
              .loginPage("/login_page")
              .loginProcessingUrl("/login")
              .usernameParameter("name")
              .passwordParameter("passwd")
              .successHandler(new AuthenticationSuccessHandler() {
                  @Override
                  public void onAuthenticationSuccess(HttpServletRequest req,
                                                      HttpServletResponse resp,
                                                      Authentication auth)
                      throws IOException {
                      Object principal = auth.getPrincipal();
                      resp.setContentType("application/json;charset=utf-8");
                      PrintWriter out = resp.getWriter();
                      resp.setStatus(200);
                      Map<String, Object> map = new HashMap<>();
                      map.put("status", 200);
                      map.put("msg", principal);
                      ObjectMapper om = new ObjectMapper();
                      out.write(om.writeValueAsString(map));
                      out.flush();
                      out.close();
                  }
              })
              .failureHandler(new AuthenticationFailureHandler() {
                  @Override
                  public void onAuthenticationFailure(HttpServletRequest req,
                                                      HttpServletResponse resp,
                                                      AuthenticationException e)
                      throws IOException {
                      resp.setContentType("application/json;charset=utf-8");
                      PrintWriter out = resp.getWriter();
                      resp.setStatus(401);
                      Map<String, Object> map = new HashMap<>();
                      map.put("status", 401);
                      if (e instanceof LockedException) {
                          map.put("msg", "账户被锁定,登录失败!");
                      } else if (e instanceof BadCredentialsException) {
                          map.put("msg", "账户名或密码输入错误,登录失败!");
                      } else if (e instanceof DisabledException) {
                          map.put("msg", "账户被禁用,登录失败!");
                      } else if (e instanceof AccountExpiredException) {
                          map.put("msg", "账户已过期,登录失败!");
                      } else if (e instanceof CredentialsExpiredException) {
                          map.put("msg", "密码已过期,登录失败!");
                      } else {
                          map.put("msg", "登录失败!");
                      }
                      ObjectMapper om = new ObjectMapper();
                      out.write(om.writeValueAsString(map));
                      out.flush();
                      out.close();
                  }
              })
              .permitAll()
              .and()
              .csrf()
              .disable();
      }

      代码解释:

      • loginPage(“/login_page”) 表示如果用户未获授权就访问一个需要授权才能访问的接口,就会自动跳转到 login_page 页面让用户登录,这个 login_page 就是开发者自定义的登录页面,而不再是 Spring Security 提供的默认登录页

      • loginProcessingUrl(“/login”) 表示登录请求处理接口,无论是自定义登录页面还是移动端登录,都需要使用该接口

      • usernameParameter(“name”),passwordParameter(“passwd”) 定义了认证所需要的用户名和密码的参数,默认用户名参数是 username,密码参数是 password,可以在这里定义

      • successHandler() 方法定义了登录成功的处理逻辑。用户登录成功后可以跳转到某一个页面,也可以返回一段 JSON ,这个要看具体业务逻辑,此处假设是第二种,用户登录成功后,返回一段登录成功的 JSON 。onAuthenticationSuccess 方法的第三个参数一般用来获取当前登录用户的信息,在登录后,可以获取当前登录用户的信息一起返回给客户端

      • failureHandler 方法定义了登录失败的处理逻辑,和登录成功类似,不同的是,登录失败的回调方法里有一个 AuthenticationException 参数,通过这个异常参数可以获取登录失败的原因,进而给用户一个明确的提示

      配置完成后,使用 Postman 进行测试

      Comment configurer Spring Security dans la gestion de la sécurité SpringBoot

      如果登录失败也会有相应的提示

      Comment configurer Spring Security dans la gestion de la sécurité SpringBoot

      注销登录配置

      如果想要注销登录,也只需要提供简单的配置即可

      @Override
      protected void configure(HttpSecurity http) throws Exception {
          http.authorizeRequests()
              .antMatchers("/admin/**")
              .hasRole("ADMIN")
              .antMatchers("/user/**")
              .access("hasAnyRole(&#39;ADMIN&#39;,&#39;USER&#39;)")
              .antMatchers("/db/**")
              .access("hasRole(&#39;ADMIN&#39;) and hasRole(&#39;DBA&#39;)")
              .anyRequest()
              .authenticated()
              .and()
              .formLogin()
              .loginPage("/login_page")
              .loginProcessingUrl("/login")
              .usernameParameter("name")
              .passwordParameter("passwd")
              .successHandler(new AuthenticationSuccessHandler() {
                  @Override
                  public void onAuthenticationSuccess(HttpServletRequest req,
                                                      HttpServletResponse resp,
                                                      Authentication auth)
                      throws IOException {
                      Object principal = auth.getPrincipal();
                      resp.setContentType("application/json;charset=utf-8");
                      PrintWriter out = resp.getWriter();
                      resp.setStatus(200);
                      Map<String, Object> map = new HashMap<>();
                      map.put("status", 200);
                      map.put("msg", principal);
                      ObjectMapper om = new ObjectMapper();
                      out.write(om.writeValueAsString(map));
                      out.flush();
                      out.close();
                  }
              })
              .failureHandler(new AuthenticationFailureHandler() {
                  @Override
                  public void onAuthenticationFailure(HttpServletRequest req,
                                                      HttpServletResponse resp,
                                                      AuthenticationException e)
                      throws IOException {
                      resp.setContentType("application/json;charset=utf-8");
                      PrintWriter out = resp.getWriter();
                      resp.setStatus(401);
                      Map<String, Object> map = new HashMap<>();
                      map.put("status", 401);
                      if (e instanceof LockedException) {
                          map.put("msg", "账户被锁定,登录失败!");
                      } else if (e instanceof BadCredentialsException) {
                          map.put("msg", "账户名或密码输入错误,登录失败!");
                      } else if (e instanceof DisabledException) {
                          map.put("msg", "账户被禁用,登录失败!");
                      } else if (e instanceof AccountExpiredException) {
                          map.put("msg", "账户已过期,登录失败!");
                      } else if (e instanceof CredentialsExpiredException) {
                          map.put("msg", "密码已过期,登录失败!");
                      } else {
                          map.put("msg", "登录失败!");
                      }
                      ObjectMapper om = new ObjectMapper();
                      out.write(om.writeValueAsString(map));
                      out.flush();
                      out.close();
                  }
              })
              .permitAll()
              .and()
              .logout()
              .logoutUrl("/logout")
              .clearAuthentication(true)
              .invalidateHttpSession(true)
              .addLogoutHandler(new LogoutHandler() {
                  @Override
                  public void logout(HttpServletRequest req,
                                     HttpServletResponse resp,
                                     Authentication auth) {
                  }
              })
              .logoutSuccessHandler(new LogoutSuccessHandler() {
                  @Override
                  public void onLogoutSuccess(HttpServletRequest req,
                                              HttpServletResponse resp,
                                              Authentication auth)
                      throws IOException {
                      resp.sendRedirect("/login_page");
                  }
              })
              .and()
              .csrf()
              .disable();
      }

      代码解释:

      • logout() 表示开启注销登录的配置

      • logoutUrl(“/logout”) 表示注销登录请求 URL 为 /logout ,默认也是 /logout

      • clearAuthentication(true) 表示是否清楚身份认证信息,默认为 true

      • invalidateHttpSession(true) 表示是否使 Session 失效,默认为 true

      • addLogoutHandler 方法中完成一些数据清楚工作,例如 Cookie 的清楚

      • logoutSuccessHandler 方法用于处理注销成功后的业务逻辑,例如返回一段 JSON 提示或者跳转到登录页面等

      多个 HttpSecurity

      如果业务比较复杂,也可以配置多个 HttpSecurity ,实现对 WebSecurityConfigurerAdapter 的多次扩展

      @Configuration
      public class MultiHttpSecurityConfig {
          @Bean
          PasswordEncoder passwordEncoder() {
              return NoOpPasswordEncoder.getInstance();
          }
          @Autowired
          protected void configure(AuthenticationManagerBuilder auth) throws Exception {
              auth.inMemoryAuthentication()
                      .withUser("admin").password("123123").roles("ADMIN", "USER")
                      .and()
                      .withUser("tangsan").password("123123").roles("USER");
          }
          @Configuration
          @Order(1)
          public static class AdminSecurityConfig extends WebSecurityConfigurerAdapter{
              @Override
              protected void configure(HttpSecurity http) throws Exception {
                  http.antMatcher("/admin/**").authorizeRequests()
                          .anyRequest().hasRole("ADMIN");
              }
          }
          @Configuration
          public static class OtherSecurityConfig extends WebSecurityConfigurerAdapter{
              @Override
              protected void configure(HttpSecurity http) throws Exception {
                  http.authorizeRequests()
                          .anyRequest().authenticated()
                          .and()
                          .formLogin()
                          .loginProcessingUrl("/login")
                          .permitAll()
                          .and()
                          .csrf()
                          .disable();
              }
          }
      }

      代码解释:

      • 配置多个 HttpSecurity 时,MultiHttpSecurityConfig 不需要继承 WebSecurityConfigurerAdapter ,在 MultiHttpSecurityConfig 中创建静态内部类继承 WebSecurityConfigurerAdapter 即可,静态内部类上添加 @Configuration 注解和 @Order注解,数字越大优先级越高,未加 @Order 注解的配置优先级最低

      • AdminSecurityConfig 类表示该类主要用来处理 “/admin/**” 模式的 URL ,其它 URL 将在 OtherSecurityConfig 类中处理

      密码加密

      1. 为什么要加密

      2. 加密方案

      Spring Security 提供了多种密码加密方案,官方推荐使用 BCryptPasswordEncoder,BCryptPasswordEncoder 使用 BCrypt 强哈希函数,开发者在使用时可以选择提供 strength 和 SecureRandom 实例。strength 越大,密码的迭代次数越多,密钥迭代次数为 2^strength 。strength 取值在 4~31 之间,默认为 10 。

      3. 实践

      只需要修改上文配置的 PasswordEncoder 这个 Bean 的实现即可

       @Bean
      PasswordEncoder passwordEncoder() {
          return new BCryptPasswordEncoder(10);
      }

      参数 10 就是 strength ,即密钥的迭代次数(也可以不配置,默认为 10)。

      使用以下方式获取加密后的密码。

      public static void main(String[] args) {
          BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder(10);
          String encode = bCryptPasswordEncoder.encode("123123");
          System.out.println(encode);
      }

      修改配置的内存用户的密码

      auth.inMemoryAuthentication()
          .withUser("admin")
          .password("$2a$10$.hZESNfpLSDUnuqnbnVaF..Xb2KsAqwvzN7hN65Gd9K0VADuUbUzy")
          .roles("ADMIN", "USER")
          .and()
          .withUser("tangsan")
          .password("$2a$10$4LJ/xgqxSnBqyuRjoB8QJeqxmUeL2ynD7Q.r8uWtzOGs8oFMyLZn2")
          .roles("USER");

      虽然 admin 和 tangsan 加密后的密码不一样,但是明文都是 123123 配置完成后,使用 admin/123123,或 tangsan/123123 就可以实现登录,一般情况下,用户信息是存储在数据库中的,因此需要用户注册时对密码进行加密处理

      @Service
      public class RegService {
          public int reg(String username, String password) {
              BCryptPasswordEncoder encoder = new BCryptPasswordEncoder(10);
              String encodePasswod = encoder.encode(password);
              return saveToDb(username, encodePasswod);
          }
          private int saveToDb(String username, String encodePasswod) {
              // 业务处理
              return 0;
          }
      }

      用户将密码从前端传来之后,通过 BCryptPasswordEncoder 实例中的 encode 方法对密码进行加密处理,加密完成后将密文存入数据库。

      方法安全

      上文介绍的认证和授权都是基于 URL 的,开发者也可通过注解来灵活配置方法安全,使用相关注解,首先要通过 @EnableGlobalMethodSecurity 注解开启基于注解的安全配置

      @Configuration
      @EnableGlobalMethodSecurity(prePostEnabled = true,securedEnabled = true)
      public class MultiHttpSecurityConfig{
      }

      代码解释:

      • prePostEnabled = true 会解锁 @PreAuthorize 和 @PostAuthorize 两个注解, @PreAuthorize 注解会在方法执行前进行验证,而 @PostAuthorize 注解在方法执行后进行验证

      • securedEnabled = true 会解锁 @Secured 注解

      开启注解安全后,创建一个 MethodService 进行测试

      @Service
      public class MethodService {
          @Secured("ROLE_ADMIN")
          public String admin() {
              return "hello admin";
          }
          @PreAuthorize("hasRole(&#39;ADMIN&#39;) and hasRole(&#39;DBA&#39;)")
          public String dba() {
              return "hello dba";
          }
          @PreAuthorize("hasAnyRole(&#39;ADMIN&#39;,&#39;DBA&#39;,&#39;USER&#39;)")
          public String user() {
              return "user";
          }
      }

      代码解释:

      • @Secured(“ROLE_ADMIN”) 注解表示访问该方法需要 ADMIN 角色,注意这里需要在角色前加一个前缀 ROLE_

      • @PreAuthorize(“hasRole(‘ADMIN’) and hasRole(‘DBA’)”) 注解表示访问该方法既需要 ADMIN 角色又需要 DBA 角色

      • @PreAuthorize(“hasAnyRole(‘ADMIN’,‘DBA’,‘USER’)”) 表示访问该方法需要 ADMIN 、DBA 或 USER 角色中至少一个

      • @PostAuthorize 和 @PreAuthorize 中都可以使用基于表达式的语法

      最后在 Controller 中注入 Service 并调用 Service 中的方法进行测试

      @RestController
      public class HelloController {
          @Autowired
          MethodService methodService;
          @GetMapping("/hello")
          public String hello() {
              String user = methodService.user();
              return user;
          }
          @GetMapping("/hello2")
          public String hello2() {
              String admin = methodService.admin();
              return admin;
          }
          @GetMapping("/hello3")
          public String hello3() {
              String dba = methodService.dba();
              return dba;
          }
      }

      admin 访问 hello

      Comment configurer Spring Security dans la gestion de la sécurité SpringBoot

      admin 访问 hello2

      Comment configurer Spring Security dans la gestion de la sécurité SpringBoot

      admin 访问 hello3

      Comment configurer Spring Security dans la gestion de la sécurité SpringBoot

    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!

    Déclaration:
    Cet article est reproduit dans:. en cas de violation, veuillez contacter admin@php.cn Supprimer