首頁  >  文章  >  Java  >  SpringBoot安全管理之Spring Security如何配置

SpringBoot安全管理之Spring Security如何配置

WBOY
WBOY轉載
2023-05-12 21:52:102300瀏覽

    在 Java 開發領域常見的安全性框架有 Shiro 和 Spring Security。 Shiro 是一個輕量級的安全管理框架,提供了認證、授權、會話管理、密碼管理、快取管理等功能。 Spring Security 是一個相對複雜的安全管理框架,功能比Shiro 更加強大,權限控制細粒度更高,對OAuth 2 的支援也很友好,又因為Spring Security 源自Spring 家族,因此可以和Spring 框架無縫整合,特別是Spring Boot 中提供的自動化配置方案,讓Spring Security 的使用更加便利。

    Spring Security 的基本設定

    基本用法

    1. 建立專案新增依賴

    建立一個Spring Boot 項目,然後新增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. 新增hello 介面
    @RestController
    public class HelloController {
        @GetMapping("/hello")
        public String hello() {
            return "hello";
        }
    }
    3. 啟動專案測試

    啟動成功後,存取/hello 介面就會自動跳到登入頁面,這個登入頁面是由Spring Security 提供的

    SpringBoot安全管理之Spring Security如何配置

    預設的使用者名稱是user ,預設的登入密碼則在每次啟動專案時隨機生成,查看專案啟動日誌

    Using generated security password: 4f845a17-7b09-479c-8701-48000e89d364

    登入成功後,使用者就可以存取/hello 介面了

    # #配置使用者名稱和密碼

    如果開發者對預設的使用者名稱和密碼不滿意,可以在application.properties 中配置預設的使用者名稱、密碼以及使用者角色

    spring. security.user.name=tangsan

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

    ##基於記憶體的認證

    開發者也可以自訂類別繼承自WebSecurityConfigurer,進而實現對Spring Security 更多的自訂配置,例如基於記憶體的認證,設定方式如下:

    @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");
        }
    }

    程式碼解釋:

      自訂MyWebSecurityConfig 繼承自WebSecurityConfigurerAdapter ,並重寫configure(AuthenticationManagerBuilder auth) 方法,在該方法中配置兩個用戶,一個用戶是admin ,具備兩個角色ADMIN、USER;另一個用戶是tangsan ,擁有一個角色USER
    • 這裡使用的Spring Security 版本是5.0.6 ,在Spring Security 5.x 中引入了多種密碼加密方式,開發者必須指定一種,此處使用NoOpPasswordEncoder ,即不對密碼進行加密
    • 注意:基於內存的用戶配置,在配置角色時不需要添加“ROLE_” 前綴,這點和後面10.2 節中基於資料庫的認證有差別。

    配置完成後,重新啟動項目,就可以使用這裡配置的兩個使用者進行登入了。

    HttpSecurity

    雖然現在可以實現認證功能,但是受保護的資源都是預設的,而且不能根據實際情況進行角色管理,如果要實現這些功能,就需要重寫WebSecurityConfigurerAdapter中的另一個方法

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

    程式碼解釋:

      首先配置了三個用戶,root 用戶具備ADMIN 和DBA 的角色,admin 用戶具備ADMIN 和USER 角色,tangsan 用於具備USER 角色
    • 呼叫authorizeRequests() 方法開啟HttpSecurity 的配置,antMatchers() ,hasRole() ,access() 方法配置存取不同的路徑需要不同的用戶及角色
    • anyRequest(),authenticated() 表示了前面定義的之外,使用者存取其他的URL 都必須認證後存取
    • formLogin(),loginProcessingUrl(“/login”),permitAll(),表示開啟表單登錄,前面看到的登錄頁面,同時配置了登錄接口為/login 即可以直接調用/login 接口,發起一個POST 請求進行登錄,登入參數中使用者名稱必須命名為username ,密碼必須命名為password,設定loginProcessingUrl 介面主要是方便Ajax 或行動端呼叫登入介面。最後也配置了 permitAll,表示和登入相關的介面都不需要認證即可存取。
    • 配置完成後,在Controller 中新增以下介面進行測試:
    @RestController
    public class HelloController {
        @GetMapping("/admin/hello")
        public String admin() {
            return "hello admin";
        }
        @GetMapping("/user/hello")
        public String user() {
            return "hello user";
        }
        @GetMapping("/db/hello")
        public String dba() {
            return "hello dba";
        }
        @GetMapping("/hello")
        public String hello() {
            return "hello";
        }
    }

    根據上文配置,「/admin/hello」 介面root 和admin 使用者俱有訪問權限;“/user/hello” 介面admin 和tangsan 使用者俱有存取權限;“/db/hello” 只有root 使用者有存取權限。瀏覽器中的測試很容易,這裡不再贅述。

    登录表单详细配置

    目前为止,登录表单一直使用 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 进行测试

    SpringBoot安全管理之Spring Security如何配置

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

    SpringBoot安全管理之Spring Security如何配置

    注销登录配置

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

    @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

    SpringBoot安全管理之Spring Security如何配置

    admin 访问 hello2

    SpringBoot安全管理之Spring Security如何配置

    admin 访问 hello3

    SpringBoot安全管理之Spring Security如何配置

    以上是SpringBoot安全管理之Spring Security如何配置的詳細內容。更多資訊請關注PHP中文網其他相關文章!

    陳述:
    本文轉載於:yisu.com。如有侵權,請聯絡admin@php.cn刪除