【编程不良人】SpringSecurity实战学习笔记05---会话管理、CSRF漏洞保护

原创 已于 2022-12-18 18:14:37 修改 · 2.1k 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#redis #java

于 2022-10-07 00:05:16 首次发布

1. 会话管理

配套视频：45.前后端分离开发记住我实现_哔哩哔哩_bilibili

  • 简介

  • 会话并发管理

  • 会话共享实战

1. 1 简介

       当浏览器调用登录接口登录成功后，服务端会和浏览器之间建立一个会话 (Session) ，浏览器在每次发送请求时都会携带一个 Sessionld，服务端则根据这个 Sessionld 来判断用户身份。当浏览器关闭后，服务端的 Session 并不会自动销毁，需要开发者手动在服务端调用 Session销毁方法，或者等 Session 过期时间到了自动销毁（默认在Java Web中Tomcat的session过期时间为30分钟）。

       在Spring Security 中，与HttpSession相关的功能由 SessionManagementFiter 和SessionAutheaticationStrateey 接口来处理，SessionManagomentFilter 过滤器将 Session 相关操作委托给 SessionAuthenticationStrateey 接口去完成。

1.2 会话并发管理

配套视频：46.会话管理以及简介_哔哩哔哩_bilibili

1.2.1 简介

       会话并发管理就是指在当前系统中，同一个用户可以同时创建多少个会话。如果一个设备对应一个会话，那么也可以简单理解为同一个用户可以同时在多少台设备上进行登录。默认情况下，同一用户在多少台设备上登录并没有限制，不过开发者可以在 Spring Security 中对此进行配置。举例：比如某某会员，一个账号可以在多个设备上进行登录。

1.2.2 开启会话管理

（1）新建SpringInitializr项目spring-security-session，引入Spring Web、Spring Security依赖。

（2）新建controller，测试项目是否创建成功

 package com.study.controller;
 ​
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RestController;
 ​
 /**
  * @ClassName IndexController
  * @Description TODO
  * @Author Jiangnan Cui
  * @Date 2022/10/6 22:07
  * @Version 1.0
  */
 @RestController
 public class IndexController {
     @GetMapping("/index")
     public String index() {
         System.out.println("index ok");
         return "Index Ok";
     }
 }

（3）配置SpringSecurity，开启会话管理

 package com.study.config;
 ​
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
 import org.springframework.security.web.session.HttpSessionEventPublisher;
 ​
 /**
  * @ClassName SecurityConfig
  * @Description SpringSecurity配置类
  * @Author Jiangnan Cui
  * @Date 2022/10/6 22:21
  * @Version 1.0
  */
 @Configuration
 public class SecurityConfig extends WebSecurityConfigurerAdapter {
     @Override
     protected void configure(HttpSecurity http) throws Exception {
         http.authorizeHttpRequests()
                 .anyRequest().authenticated()
                 .and()
                 .formLogin()
                 .and()
                 .csrf().disable()
                 .sessionManagement()// 开启会话管理
                 .maximumSessions(1);// 允许会话最大并发数为1个，即只有一个客户端能正常访问
     }
 ​
     // 监听会话的创建和过期，过期移除
     @Bean
     public HttpSessionEventPublisher httpSessionEventPublisher() {
         return new HttpSessionEventPublisher();
     }
 }

其中：

  1. sessionManagement() 用来开启会话管理，maximumSessions用于在会话开启后指定会话的并发数为 1。

  2. HttpSessionEventPublisher 提供了一个HttpSessionEvenePubishor实例。Spring Security中通过一个 Map 集合来维护当前的Http Session记录，进而实现会话的并发管理。当用户登录成功时，就向集合中添加一条HttpSession记录；当会话销毁时，就从集合中移除一条Httpsession记录。HttpSessionEventPublisher实现了HttpSessionListener 接口，可以监听到 HttpSession 的创建和销毀事件，并将 HttpSession的创建/销毁事件发布出去，这样，当有 HttpSession销毀时，Spring Security 就可以感知到该事件了。

  3. 最新版本已经不在添加httpSessionEventPublisher()方法了，为了更方便的监听会话的创建和删除，此处加上。

1.3 测试会话并发管理

       配置完成后，启动项目。这次测试我们需要两个浏览器，如果使用了 Chrome 浏览器，可以使用 Chrome 浏览器中的多用户方式（相当于两个浏览器），先在第一个浏览器中输入http://localhost:8080/index，此时会自动跳转到登录页面，完成登录操作，就可以访问到数据了；接下来在第二个浏览器中也输入http://localhost:8080/index，也需要登录， 完成登录操作；当第二个浏览器登录成功后，再回到第一个浏览器，刷新页面。结果出现下图：

此处使用Edge浏览器和联想浏览器进行测试：

（1）两个浏览器同时登录

（2）刷新Edge浏览器

       以上测试说明只能一个浏览器进行正常访问，额外的登录被挤下线，说明SpringSecurity的会话管理设置生效。

1.4 会话失效处理

配套视频：47.会话的并发管理_哔哩哔哩_bilibili

1.4.1 传统 web 开发处理（跳转到登录界面）

 @Override
 protected void configure(HttpSecurity http) throws Exception {
     http.authorizeRequests()
             .anyRequest().authenticated()
             .and()
             .formLogin()
             .and()
             .csrf().disable()
             .sessionManagement()// 开启会话管理
             .maximumSessions(1)// 允许会话最大并发数为1个，即只有一个客户端能正常访问
             .expiredUrl("/login");// 当用户被挤下线之后的跳转路径<---传统web开发
 }

测试结果：

1.4.2 前后端分离开发处理（错误提示）

 @Override
 protected void configure(HttpSecurity http) throws Exception {
     http.authorizeRequests()
             .anyRequest().authenticated()
             .and()
             .formLogin()
             .and()
             .csrf().disable()
             .sessionManagement()// 开启会话管理
             .maximumSessions(1)// 允许会话最大并发数为1个，即只有一个客户端能正常访问
             //.expiredUrl("/login")// 当用户被挤下线之后的跳转路径  传统web开发
 //                .expiredSessionStrategy(new SessionInformationExpiredStrategy() { // 前后端分离处理方案，利用匿名内部类形式创建
 //                    @Override
 //                    public void onExpiredSessionDetected(SessionInformationExpiredEvent event) throws IOException, ServletException {
 //                        HttpServletResponse response = event.getResponse();
 //                        // map转json进行输出
 //                        Map<String, Object> result = new HashMap<>();
 //                        result.put("status", 500);
 //                        result.put("msg", "当前会话已经失效,请重新登录!");
 //                        String s = new ObjectMapper().writeValueAsString(result);
 //                        response.setContentType("application/json;charset=UTF-8");
 //                        response.getWriter().println(s);
 //                        response.flushBuffer();
 //                    }
 //                });
             .expiredSessionStrategy(event -> {// 匿名内部类优化
                 HttpServletResponse response = event.getResponse();
                     // map转json进行输出
                     Map<String, Object> result = new HashMap<>();
                     result.put("status", 500);
                     result.put("msg", "当前会话已经失效,请重新登录!");
                     String s = new ObjectMapper().writeValueAsString(result);
                     response.setContentType("application/json;charset=UTF-8");
                     response.getWriter().println(s);
                     response.flushBuffer();
             });
 }

测试结果：

1.5 禁止再次登录

配套视频：48.会话被挤下线时处理方案_哔哩哔哩_bilibili

配套视频：49.禁止再次登录_哔哩哔哩_bilibili 

       默认的效果是一种被 “挤下线”的效果，后面登录的用户会把前面登录的用户 “挤下线”。

       还有一种是禁止后来者登录，即一旦当前用户登录成功，后来者无法再次使用相同的用户登录，直到当前用户主动注销登录，配置如下：

 @Override
 protected void configure(HttpSecurity http) throws Exception {
     http.authorizeRequests()
             .anyRequest().authenticated()
             .and()
             .formLogin()
             .and()
             .logout() // 退出登录
             .and()
             .csrf().disable()
             .sessionManagement()// 开启会话管理
             .maximumSessions(1)// 允许会话最大并发数为1个，即只有一个客户端能正常访问
             .expiredSessionStrategy(event -> {// 匿名内部类优化
                 HttpServletResponse response = event.getResponse();
                 // map转json进行输出
                 Map<String, Object> result = new HashMap<>();
                 result.put("status", 500);
                 result.put("msg", "当前会话已经失效,请重新登录!");
                 String s = new ObjectMapper().writeValueAsString(result);
                 response.setContentType("application/json;charset=UTF-8");
                 response.getWriter().println(s);
                 response.flushBuffer();
             })
             .maxSessionsPreventsLogin(true);// 一旦一个登录成功，禁止其它再次登录
 }

测试结果：

1.6 会话共享

配套视频：50.集群下会话共享解决方案_哔哩哔哩_bilibili

       前面所讲的会话管理都是单机上的会话管理，如果当前是集群环境，前面所讲的会话管理方案就会失效。

模拟集群测试：在idea中复制一个Configuration进行启动

在VM Options下修改端口号：

启动两个服务：

测试：

       这种情况下，会话管理失效。

       此时可以利用redis或者memcached来解决，此处通过spring-session 结合 redis 实现 session 共享。

1.6.1 引入依赖

 <!--操作redis-->
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
 </dependency>
 ​
 <!--session序列化到redis-->
 <dependency>
     <groupId>org.springframework.session</groupId>
     <artifactId>spring-session-data-redis</artifactId>
 </dependency>

1.6.2 编写配置

 # 配置redis
 spring.redis.host=localhost
 spring.redis.port=6379
 spring.redis.database=0

1.6.3 配置Security

 package com.study.config;
 ​
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
 import org.springframework.session.FindByIndexNameSessionRepository;
 import org.springframework.session.security.SpringSessionBackedSessionRegistry;
 ​
 import javax.servlet.http.HttpServletResponse;
 import java.util.HashMap;
 import java.util.Map;
 ​
 /**
  * @ClassName SecurityConfig
  * @Description SpringSecurity配置类
  * @Author Jiangnan Cui
  * @Date 2022/10/6 22:21
  * @Version 1.0
  */
 @Configuration
 public class SecurityConfig extends WebSecurityConfigurerAdapter {
     // 注入FindByIndexNameSessionRepository，操作session
     private final FindByIndexNameSessionRepository findByIndexNameSessionRepository;
     
     @Autowired
     public SecurityConfig(FindByIndexNameSessionRepository findByIndexNameSessionRepository) {
         this.findByIndexNameSessionRepository = findByIndexNameSessionRepository;
     }
 ​
     @Override
     protected void configure(HttpSecurity http) throws Exception {
         http.authorizeRequests()
                 .anyRequest().authenticated()
                 .and()
                 .formLogin()
                 .and()
                 .logout() // 退出登录
                 .and()
                 .csrf().disable()
                 .sessionManagement()// 开启会话管理
                 .maximumSessions(1)// 允许会话最大并发数为1个，即只有一个客户端能正常访问
                 //.expiredUrl("/login")// 当用户被挤下线之后的跳转路径  传统web开发
                 .expiredSessionStrategy(event -> {// 匿名内部类优化
                     HttpServletResponse response = event.getResponse();
                     // map转json进行输出
                     Map<String, Object> result = new HashMap<>();
                     result.put("status", 500);
                     result.put("msg", "当前会话已经失效,请重新登录!");
                     String s = new ObjectMapper().writeValueAsString(result);
                     response.setContentType("application/json;charset=UTF-8");
                     response.getWriter().println(s);
                     response.flushBuffer();
                 })
                 .maxSessionsPreventsLogin(true)// 一旦一个登录成功，禁止其它再次登录
                 .sessionRegistry(sessionRegistry());// 将session交给谁管理
     }
 ​
     // 创建session同步到redis中的方案
     @Bean
     public SpringSessionBackedSessionRegistry sessionRegistry() {
         return new SpringSessionBackedSessionRegistry(findByIndexNameSessionRepository);
     }
 ​
     // 此时自身就不需要再去监听了，直接交给redis管理 ↓↓↓↓↓↓
     // 监听会话的创建和过期，过期移除
 //    @Bean
 //    public HttpSessionEventPublisher httpSessionEventPublisher() {
 //        return new HttpSessionEventPublisher();
 //    }
 }

1.6.4 测试

先启动redis，在分别启动两个服务，分别进行访问：

redis中结果：

上述操作解决了集群环境下的session共享问题，保证只有一个可以登录成功。

1.7 最终项目目录结构

2. CSRF 漏洞保护

配套视频：51.CSRF 漏洞保护简介_哔哩哔哩_bilibili

  • CSRF 简介

  • CSRF 防御&基本配置

  • 实战

2.1 简介

        CSRF (Cross-Site Request Forgery 跨站请求伪造)，也可称为一键式攻击 (one-click-attack），通常缩写为 CSRF 或者 XSRF。

   CSRF 攻击是一种挟持用户在当前已登录的浏览器上发送恶意请求的攻击方法。相对于XSS利用用户对指定网站的信任而言，CSRF则是利用网站对用户网页浏览器的信任。简单来说，CSRF是攻击者通过一些技术手段欺骗用户的浏览器，去访问一个用户曾经认证过的网站，并执行恶意请求，例如发送邮件、发消息、甚至财产操作 (如转账和购买商品）。由于客户端(浏览器)已经在该网站上认证过，所以该网站会认为是真正用户在操作而执行请求，实际上这个并非用户的本意。

举个简单的例子：

假设 blr 现在登录了某银行的网站准备完成一项转账操作，转账的链接如下：

       https: //bank .xxx .com/withdraw?account=blr&amount=1000&for=zhangsan

       可以看到，这个链接是想从 blr 这个账户下转账 1000 元到 zhangsan 账户下，假设blr 没有注销登录该银行的网站，就在同一个浏览器新的选项卡中打开了一个危险网站，这个危险网站中有一幅图片，代码如下：

 <img src="https ://bank.xxx.com/withdraw?account=blr&amount=1000&for=1isi">

        一旦用户打开了这个网站，这个图片链接中的请求就会自动发送出去。由于是同一个浏览器，并且用户尚未注销登录，所以该请求会自动携带上对应的有效的 Cookie 信息，进而完成一次转账操作，这就是跨站请求伪造。

注意：应用工作时无法区分哪些是用用户自己想要执行的，哪些是攻击的，只要有请求来，它就会执行。

2.2 CSRF攻击演示

配套视频：52.CSRF 攻击演示_哔哩哔哩_bilibili

2.2.1 创建银行应用

       在SpringSecurity项目下新建module：spring-security-csrf-bank，引入Spring Web、Spring Security依赖。

  • pom.xml中添加依赖

     <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
 </dependency>
 <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
 </dependency>

  • config包下新建SpringSecurity配置类

     package com.study.config;
 ​
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
 import org.springframework.security.core.userdetails.User;
 import org.springframework.security.core.userdetails.UserDetailsService;
 import org.springframework.security.provisioning.InMemoryUserDetailsManager;
 ​
 /**
  * @ClassName SecurityConfig
  * @Description SpringSecurity配置类
  * @Author Jiangnan Cui
  * @Date 2022/12/17 10:29
  * @Version 1.0
  */
 @Configuration
 public class SecurityConfig extends WebSecurityConfigurerAdapter {
     // 使用内存数据源
     @Bean
     public UserDetailsService userDetailsService() {
         InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();
         inMemoryUserDetailsManager.createUser(User.withUsername("root").password("{noop}123456").roles("admin").build());
         return inMemoryUserDetailsManager;
     }
 ​
     // 使用内存数据源指定全局的AuthenticationManager
     @Override
     protected void configure(AuthenticationManagerBuilder auth) throws Exception {
         auth.userDetailsService(userDetailsService());
     }
 ​
     // SpringSecurity基本配置
     @Override
     protected void configure(HttpSecurity http) throws Exception {
         http.authorizeRequests().anyRequest().authenticated()
                 .and().formLogin()
                 .and()
                 .csrf().disable();  //关闭CSRF跨站请求保护  ←--←--←--重点看这里
     }
 }

  • 创建 BankController用于项目测试转账业务

     package com.study.controller;
 ​
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RestController;
 ​
 /**
  * @ClassName BankController
  * @Description 银行转账相关操作
  * @Author Jiangnan Cui
  * @Date 2022/12/17 10:33
  * @Version 1.0
  */
 @RestController
 public class BankController {
     @PostMapping("/withdraw")
     public String withdraw() {
         System.out.println("执行一次银行转账操作");
         return "Perform a bank transfer operation.";
     }
 ​
     // 主页
     @GetMapping("index")
     public String index() {
         return "欢迎光临！";
     }
 }
 ​

2.2.2 创建恶意应用

在SpringSecurity项目下新建module：spring-security-csrf-attack，引入Spring Web依赖。

  • pom.xml中添加依赖

     <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
 </dependency>

  • application.properties修改端口配置：避免8080被重复使用，导致新的项目启动不起来

     server.port: 8081

  • resources目录下新建index.html作为攻击页面

     <!DOCTYPE html>
 <html lang="en">
 <head>
     <meta charset="UTF-8">
     <title>模拟csrf跨站请求伪造</title>
 </head>
 <body>
 <form action="http://localhost:8080/withdraw" method="post">
     <input name="name" type="hidden" value="cjn"/>
     <input name="money" type="hidden" value="10000">
     <input type="submit" value="点我">
 </form>
 </body>
 </html>

注意：上面的localhost或者127.0.0.1要保持一致。

2.2.3 测试

        （1）启动两个module服务，浏览器先访问：http://localhost:8080/index，输入用户名：root，密码：123456，提示登录成功：

 

       （2）然后，在同一浏览器新建标签页，浏览器访问：http://localhost:8081，点击“点我”，输出转账成功提示，表示已经遭受了CSRF攻击。​​​​​​​

2.2.4 报错总结

  • 报错1：

 java: 无法访问org.springframework.boot.SpringApplication
   错误的类文件: /C:/.../.m2/repository/org/springframework/boot/spring-boot/3.0.0/spring-boot-3.0.0.jar!/org/springframework/boot/SpringApplication.class
     类文件具有错误的版本 61.0, 应为 52.0
     请删除该文件或确保该文件位于正确的类路径子目录中。

解决办法：报错信息里所说的类文件版本指的是java class file version，即：java类文件版本，该版本号与jdk版本号存在对应关系，61.0对应jdk17，52.0对应jdk8。完整对应关系参见： List of Java class file format major version numbers? - Stack Overflow，所以报错是因为某个依赖的版本太高，降低版本即可，具体是哪个依赖需要自己排查。

参考链接：java: 无法访问org.springframework.boot.SpringApplication_我叫嘻嘻呵呵的博客-优快云博客

我的报错来源：

       此处只需要降低boot版本，我的由3.0.0修改为2.6.12，重新刷新maven后就可以正常启动项目了。

       同时，还发现了一个问题：如果创建SpringBoot项目时boot版本选3.0.0，即使jdk版本选8，生成后的pom文件也会指定jdk版本为17，后续还需要自己修改成8，否则编译不成功，这点还需要进一步研究一下。

2.3 CSRF防御

配套视频：54.CSRF防御配置_哔哩哔哩_bilibili

        CSRF攻击的根源在于浏览器默认的身份验证机制(自动携带当前网站的Cookie信息)，这种机制虽然可以保证请求是来自用户的某个浏览器，但是无法确保这请求是用户授权发送。攻击者和用户发送的请求一模一样，这意味着我们没有办法去直接拒绝这里的某一个请求。如果能在合法清求中额外携带一个攻击者无法获取的参数，就可以成功区分出两种不同的请求，进而直接拒绝掉恶意请求。在 SpringSecurity 中就提供了这种机制来防御 CSRF 攻击，这种机制我们称之为令牌同步模式。

2.3.1 令牌同步模式

        这是目前主流的 CSRF 攻击防御方案。具体的操作方式就是在每一个 HTTP 请求中，除了默认自动携带的 Cookie 参数之外，再提供一个安全的、随机生成的宇符串，我们称之为 CSRF 令牌。这个 CSRF 令牌由服务端生成，生成后在 HttpSession 中保存一份。当前端请求到达后，将请求携带的 CSRF 令牌信息和服务端中保存的令牌进行对比，如果两者不相等，则拒绝掉该 Http 请求。

       注意: 考虑到会有一些外部站点链接到我们的网站，所以我们要求请求是幂等的(多次请求结果一致)，这样对子HEAD、OPTIONS、TRACE 等方法就没有必要使用 CSRF 令牌了，强行使用可能会导致令牌泄露！

2.3.2 开启CSRF防御

 @Configuration
 public class SecurityConfig extends WebSecurityConfigurerAdapter {
     @Override
     protected void configure(HttpSecurity http) throws Exception {
         http.
           ...
           formLogin()
           .and()
           .csrf(); // 开启csrf
     }
 }

通过这种方式能够在一定程度上保证当前应用的安全性！

2.3.3 测试

       （1）启动两个module服务，浏览器先访问：http://localhost:8080/index，输入用户名：root，密码：123456，提示登录成功，查看网页源代码可找到页面渲染时自动生成的随机token令牌信息：

       （2）然后，在同一浏览器新建标签页，浏览器访问：http://localhost:8081，点击“点我”，无法进行转账操作，表示开启了csrf攻击防护：

   

2.4 传统web开发使用CSRF

配套视频：55.CSRF 传统 web 开发使用_哔哩哔哩_bilibili

        开启CSRF防御后会自动在提交的表单中加入如下代码，如果不能自动加入，需要在开启之后手动加入如下代码，并随着请求提交。获取服务端令牌方式如下:

 <input type="hidden" th:name="${_csrf.parameterName}" th:value="${_csrf.token}"/>

2.4.1 开发流程

在SpringSecurity下面新建module：spring-security-csrf-web

  • pom.xml引入依赖：

 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-security</artifactId>
 </dependency>
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-thymeleaf</artifactId>
 </dependency>
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 <dependency>
     <groupId>org.thymeleaf.extras</groupId>
     <artifactId>thymeleaf-extras-springsecurity5</artifactId>
 </dependency>

  • application.properties添加配置：

 spring.thymeleaf.cache=false
 spring.thymeleaf.mode=HTML
 spring.thymeleaf.encoding=UTF-8
 spring.thymeleaf.prefix=classpath:/templates/
 spring.thymeleaf.suffix=.html

  • 创建config包，包下创建SpringSecurity配置类SecurityConfig:

 package com.study.config;
 ​
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
 import org.springframework.security.core.userdetails.User;
 import org.springframework.security.core.userdetails.UserDetailsService;
 import org.springframework.security.provisioning.InMemoryUserDetailsManager;
 ​
 /**
  * @ClassName SecurityConfig
  * @Description SpringSecurity配置类
  * @Author Jiangnan Cui
  * @Date 2022/12/18 11:54
  * @Version 1.0
  */
 @Configuration
 public class SecurityConfig extends WebSecurityConfigurerAdapter {
     // 使用内存数据源
     @Bean
     public UserDetailsService userDetailsService() {
         InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();
         inMemoryUserDetailsManager.createUser(User.withUsername("root").password("{noop}123456").roles("admin").build());
         return inMemoryUserDetailsManager;
     }
 ​
     // 使用内存数据源指定全局的AuthenticationManager
     @Override
     protected void configure(AuthenticationManagerBuilder auth) throws Exception {
         auth.userDetailsService(userDetailsService());
     }
 ​
     // SpringSecurity基本配置
     @Override
     protected void configure(HttpSecurity http) throws Exception {
         http.authorizeRequests().anyRequest().authenticated()
                 .and().formLogin()
                 .and()
                 .csrf();  //开启CSRF跨站请求保护  ←--←--←--重点看这里
     }
 }

  • 开发测试controller: HelloController

 package com.study.controller;
 ​
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RestController;
 ​
 /**
  * @ClassName HelloController
  * @Description TODO
  * @Author Jiangnan Cui
  * @Date 2022/12/18 11:57
  * @Version 1.0
  */
 @RestController
 public class HelloController {
     @PostMapping("/hello")
     public String hello() {
         System.out.println("hello success");
         return "hello success";
     }
 ​
     @GetMapping("/index.html")
     public String index() {
         return "index";
     }
 }

  • templates路径下添加主页index.html

 <!DOCTYPE html>
 <html lang="en">
 <head>
     <meta charset="UTF-8">
     <title>测试开启CSRF</title>
 </head>
 <body>
 <h1>主页</h1>
 <form method="post" th:action="@{/hello}">
     信息: <input name="name" type="text"> <br>
           <input type="submit" value="提交">
 </form>
 </body>
 </html>

2.4.2 测试

        启动服务，访问路径：http://localhost:8080/，输入用户名：root，密码：123456，登录后，查看网页源代码：

发现渲染页面时，自动开启csrf防护。

总结：传统web开发使用csrf时，只要开启csrf防护即可，无需额外操作。

2.5 前后端分离使用 CSRF

配套视频：56.CSRF 前后端分离使用&原理分析_哔哩哔哩_bilibili

       注意：前后端分离开发时，由于前后端分别属于两个不同的系统，所以前端系统没法使用这种操作作用域(${_csrf})的，因此前后端请求都是通过Ajax处理的。在服务端开启csrf后，默认开启的csrf是保存在Session作用域的，不适用于前后端分离开发的系统，因此要重新指定令牌的存储方式。

       解决办法：前后端分离开发时，只需要将生成 csrf 放入到cookie 中，并在请求时获取 cookie 中令牌信息进行提交即可，即令牌在浏览器本身进行保存。

2.5.1 开发流程

在SpringSecurity项目下新建module：spring-security-csrf-split

  • pom.xml中引入依赖：

 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-security</artifactId>
 </dependency>
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
 </dependency>

  • 创建SpringSecurity配置类SecurityConfig类：

 package com.study.config;
 ​
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.study.filter.LoginFilter;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.http.HttpStatus;
 import org.springframework.security.authentication.AuthenticationManager;
 import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
 import org.springframework.security.core.userdetails.User;
 import org.springframework.security.core.userdetails.UserDetailsService;
 import org.springframework.security.provisioning.InMemoryUserDetailsManager;
 import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
 import org.springframework.security.web.csrf.CookieCsrfTokenRepository;
 ​
 import java.util.HashMap;
 import java.util.Map;
 ​
 /**
  * @ClassName SecurityConfig
  * @Description SpringSecurity配置类
  * @Author Jiangnan Cui
  * @Date 2022/12/18 16:58
  * @Version 1.0
  */
 @Configuration
 public class SecurityConfig extends WebSecurityConfigurerAdapter {
     // 使用内置的数据源
     @Bean
     public UserDetailsService userDetailsService() {
         InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();
         inMemoryUserDetailsManager.createUser(User.withUsername("root").password("{noop}123456").roles("admin").build());
         return inMemoryUserDetailsManager;
     }
 ​
     // 使用内置的数据源指定AuthenticationManager
     @Override
     protected void configure(AuthenticationManagerBuilder auth) throws Exception {
         auth.userDetailsService(userDetailsService());
     }
 ​
     // 指定全局的authenticationManagerBean，并对外暴露
     @Override
     @Bean
     public AuthenticationManager authenticationManagerBean() throws Exception {
         return super.authenticationManagerBean();
     }
 ​
     // 自定义filter，并交给工厂管理
     @Bean
     public LoginFilter loginFilter() throws Exception {
         LoginFilter loginFilter = new LoginFilter();
         loginFilter.setFilterProcessesUrl("/doLogin");//指定认证 url
         loginFilter.setUsernameParameter("uname");//指定接收json 用户名 key
         loginFilter.setPasswordParameter("passwd");//指定接收 json 密码 key
         loginFilter.setAuthenticationManager(authenticationManagerBean());
         //认证成功处理
         loginFilter.setAuthenticationSuccessHandler((req, resp, authentication) -> {
             Map<String, Object> result = new HashMap<String, Object>();
             result.put("msg", "登录成功");
             result.put("用户信息", authentication.getPrincipal());
             resp.setContentType("application/json;charset=UTF-8");
             resp.setStatus(HttpStatus.OK.value());
             String s = new ObjectMapper().writeValueAsString(result);
             resp.getWriter().println(s);
         });
         //认证失败处理
         loginFilter.setAuthenticationFailureHandler((req, resp, ex) -> {
             Map<String, Object> result = new HashMap<String, Object>();
             result.put("msg", "登录失败: " + ex.getMessage());
             resp.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
             resp.setContentType("application/json;charset=UTF-8");
             String s = new ObjectMapper().writeValueAsString(result);
             resp.getWriter().println(s);
         });
         return loginFilter;
     }
 ​
     // Security基本配置
     @Override
     protected void configure(HttpSecurity http) throws Exception {
         http.authorizeRequests().anyRequest().authenticated()
                 .and()
                 .formLogin()
                 //.and().csrf().disable();// 注意此处单独注释csrf()是不生效的，默认开始csrf，要csrf().disable()一起写才能关闭csrf防御
                 .and()
                 .csrf()// 开启csrf防御
                 .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse());// 作用：1.将令牌保存到cookie中; 2.允许cookie被前端获取
         http.addFilterAt(loginFilter(), UsernamePasswordAuthenticationFilter.class);// 使用LoginFilter替换UsernamePasswordAuthenticationFilter
     }
 }

注意：上面的username已经修改成uname、password已经修改成：passwd，Postman JSON格式请求数据时要注意修改！！！

  • 创建filter包，包下新建LoginFilter替换UsernamePasswordAuthenticationFilter：

 package com.study.filter;
 ​
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.springframework.http.MediaType;
 import org.springframework.security.authentication.AuthenticationServiceException;
 import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
 import org.springframework.security.core.Authentication;
 import org.springframework.security.core.AuthenticationException;
 import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
 ​
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.Map;
 ​
 /**
  * @ClassName LoginFilter
  * @Description 自定义前后端分离认证Filter
  * @Author Jiangnan Cui
  * @Date 2022/12/18 16:59
  * @Version 1.0
  */
 public class LoginFilter extends UsernamePasswordAuthenticationFilter {
     @Override
     public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
         System.out.println("========================================");
         //1. 判断是否是post方式请求
         if (!request.getMethod().equals("POST")) {
             throw new AuthenticationServiceException("Authentication method not supported: " + request.getMethod());
         }
         //2. 判断是否是json格式请求类型
         if (request.getContentType().equalsIgnoreCase(MediaType.APPLICATION_JSON_VALUE)) {
             //3. 从json数据中获取用户输入用户名和密码进行认证{"uname":"xxx","password":"xxx"}
             try {
                 Map<String, String> userInfo = new ObjectMapper().readValue(request.getInputStream(), Map.class);
                 String username = userInfo.get(getUsernameParameter());
                 String password = userInfo.get(getPasswordParameter());
                 System.out.println("用户名: " + username + ", 密码: " + password);
                 UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(username, password);
                 setDetails(request, authRequest);
                 return this.getAuthenticationManager().authenticate(authRequest);
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         return super.attemptAuthentication(request, response);
     }
 }

  • 创建controller包，包下新建HelloController测试类：

 package com.study.controller;
 ​
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RestController;
 ​
 /**
  * @ClassName HelloController
  * @Description 测试类
  * @Author Jiangnan Cui
  * @Date 2022/12/18 17:05
  * @Version 1.0
  */
 @RestController
 public class HelloController {
     @PostMapping("/hello")
     public String hello() {
         System.out.println("hello");
         return "hello";
     }
 }

2.5.2 测试流程

（1）启动服务，打开Postman，以Post方式请求路径：http://localhost:8080/doLogin，请求体内容为：

 {
     "uname": "root",
     "passwd": "123456"
 }

       注意：此处不再是username、password，SecurityConfig类中已经对名称进行修改，否则会一直登录不成功！！！

测试结果：

通过返回信息可知，没有登录成功，是因为没有携带token令牌信息。

（2）在上面请求的结果中打开Cookies，获得令牌信息：XSCF-TOKEN：value：

添加值该请求路径的请求头header，再次发起请求：

提示登录成功，表示令牌生效。

（3）以Post方式请求路径：http://localhost:8080/hello，请求体内容为：

 {
     "uname": "root",
     "passwd": "123456"
 }

注意：此处不再是username、password，SecurityConfig类中已经对名称进行修改，否则会一直登录不成功！！！

另外，还需在请求头header中添加token令牌信息，注意是“X-XSRF-TOKEN"而不是”XSRF-TOKEN“：

返回hello表示请求成功！！！

2.5.3 总结

发送请求时携带令牌即可：

  • 方式1：请求参数中携带令牌

 key: _csrf  
 value:"xxx"

  • 方式2：请求头中携带令牌

 X-XSRF-TOKEN:value

2.6 项目目录结构

 初次接触，如有问题，欢迎评论区批评指正。

【编程不良人】SpringSecurity实战学习笔记01---权限管理、环境搭建
亚索@哈塞给
10-23 397
【编程不良人】SpringSecurity 最新实战教程，更新中…_哔哩哔哩_bilibiliSpring Security是一个功能强大、可高度定制的身份验证和访问控制框架。它是保护基于Spring的应用程序的事实标准。Spring Security是一个面向Java应用程序、提供身份验证和安全性的框架。与所有Spring项目一样，Spring Security的真正威力在于它可以轻松地扩展以满足定制需求。**总结：**Spring Security是一个功能强大、可高度定制的身份验证和访问控制。
Spring Security(学习笔记) --会话管理（会话并发管理实现以及源码分析，会话固定攻击）！
最新发布
TONGZHOUGONGDU的博客
04-28 1246
本篇介绍了会话概念，以及并发会话管理，看了下并发会话的源码，最后介绍了下会话固定攻击的概念，以及Security自带的防御会话攻击的策略，下一篇我们来看看Security中的防火墙。
Spring Security会话并发管理
Leon_Jinhai_Sun的博客
05-15 620
简介 会话并发管理就是指在当前系统中，同一个用户可以同时创建多少个会话，如果一个设备对应一个会话，那么也可以简单理解为同一个用户可以同时在多少台设备上进行登录。默认情况下，同一用户在多少台设备上登录并没有限制，不过开发者可以在 Spring Security 中对此进行配置。 开启会话管理 @Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { //... @Override
【编程不良人】SpringSecurity实战学习笔记07---授权
Mr.Cui的Java学习之路
02-19 997
【编程不良人】SpringSecurity实战学习笔记07---授权
【编程不良人】SpringSecurity实战学习笔记08---OAuth（简介、授权服务器与资源服务器构建、JWT令牌使用）【完结篇】
Mr.Cui的Java学习之路
02-19 1583
【编程不良人】SpringSecurity实战学习笔记08---OAuth
【编程不良人】SpringSecurity实战学习笔记06---跨域、异常处理
Mr.Cui的Java学习之路
12-18 862
【编程不良人】SpringSecurity实战学习笔记06---跨域、异常处理
精选资源
SpringSecurity笔记，编程不良人笔记
10-28
SpringSecurity是Java领域中一款强大的安全框架，主要用于Web应用程序的安全管理。它提供了全面的身份验证、授权、会话管理以及安全相关的功能，可以帮助开发者构建安全的Web应用。在本笔记中，我们将深入探讨Spring...
SpringSecurity - 学习笔记 - 会话管理之并发控制：同一账号只允许在一个设备登录
灵台方寸山斜月三星洞
01-18 2134
SpringSecurity - 学习笔记 - 会话管理之并发控制：同一账号只允许在一个设备登录场景需求分析配置`web.xml``application-security.xml`参考消息 场景 接手一个老项目： 先上pom.xml ...略 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId>
精选资源
springsecurity学习笔记
12-13
在"springsecurity学习笔记"中，你可能会涉及以下主题： - Spring Security的基本配置，包括web安全配置和全局安全配置。 - 如何自定义认证和授权流程，比如实现自定义的AuthenticationProvider和...
Spring Security 实战读书笔记精要
该笔记围绕Spring Security这一主流的Java安全框架展开，深入剖析其在认证、授权、权限控制、会话管理、跨站攻击防护等关键领域的技术细节，并结合真实项目场景提供可落地的实战解决方案。作为Spring生态体系中的...
编程不良人的SpringCloud笔记和资料，全套
06-21
编程不良人的SpringCloud笔记和资料，全套 编程不良人的SpringCloud笔记和资料，全套 编程不良人的SpringCloud笔记和资料，全套
011-Web安全基础7 - 会话管理漏洞.pptx
10-22
011-Web安全基础7 - 会话管理漏洞
【编程不良人】SpringSecurity实战学习笔记02---自定义认证
Mr.Cui的Java学习之路
07-21 3433
【编程不良人】SpringSecurity实战学习笔记02---认证原理&自定义认证
【编程不良人】SpringSecurity实战学习笔记04---RememberMe
Mr.Cui的Java学习之路
08-27 1792
【编程不良人】SpringSecurity实战学习笔记04---RememberMe
Spring Security--会话管理
a2285786446的博客
06-13 937
在服务器，Spring Security维护了一个会话注册表，所有的登录上来的用户，都会注册到这个注册表中，本质上是一个map集合，map是用户对象，value保存了用户所有的会话对象，Map。如图，在这个层级还可以配置一些会话的其他策略，比如：超过了一个了怎么办，是把上一个踢掉还是怎么办，就是说这个会话策略里还有其他配置，你目前处于这个层级，是会话配置的层级。同样的，回到这一级又可以配其他策略，比如session的策略，就是在这一级。不同浏览器之间也是不同的会话。
spring security之会话管理
xkshihaoren的博客
12-03 947
1.会话固定攻击 会话固定攻击（session fixation attack）是利用应用系统在服务器的会话ID固定不变机制，借助他人用相同的会话ID获取认证和授权，然后利用该会话ID劫持他人的会话以成功冒充他人，造成会话固定攻击。 整个攻击流程是： 1、攻击者Attacker能正常访问该应用网站； 2、应用网站服务器返回一个会话ID给他； 3、攻击者Attacker用该会话ID构造...
Spring Security 4会话管理
liuxing9345的博客
02-04 1479
Spring Security 4会话管理 博客描述使用spring security4.1.0版本，其他版本可能会稍有不同，仅用于作学习记录，也给各位网友作参考，可能会存在不足之处，望见谅并指正。本篇博客主要讲述spring security中多个用户不能使用同一个帐号同时登录系统，不涉及会话管理的其他部分内容。 Spring Security 4会话管理 配置webxml文件 在spr
评论 12
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值