首页 >邮件操作 > 内容

spring security

2023年10月11日 21:52

spring security

简介

概要

Spring是非常流行和成功的Java应用开发框架，Spring Security正是Spring家族中的成员。Spring Security基于Spring框架，提供了一套Web应用安全性的完整解决方案。

正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控制），一般来说，Web应用的安全性包括用户认证（Authentication）和用户授权（Authorization）两个部分，这两点也是Spring Security重要核心功能。

  1. 用户认证指的是：验证某个用户是否为系统中的合法主体，也就是说用户能否访问该系统。用户认证一般要求用户提供用户名和密码。系统通过校验用户名和密码来完成认证过程。通俗点说就是系统认为用户是否能登录
  2. 用户授权指的是验证某个用户是否有权限执行某个操作。在一个系统中，不同用户所具有的权限是不同的。比如对一个文件来说，有的用户只能进行读取，而有的用户可以进行修改。一般来说，系统会为不同的用户分配不同的角色，而每个角色则对应一系列的权限。通俗点讲就是系统判断用户是否有权限去做某些事情。

历史

“Spring Security 开始于 2003 年年底,““spring 的 acegi 安全系统”。 起因是 Spring
开发者邮件列表中的一个问题,有人提问是否考虑提供一个基于 spring 的安全实现。

Spring Security 以“The Acegi Secutity System for Spring” 的名字始于 2013 年晚些
时候。一个问题提交到 Spring 开发者的邮件列表，询问是否已经有考虑一个机遇 Spring
的安全性社区实现。那时候 Spring 的社区相对较小（相对现在）。实际上 Spring 自己在
2013 年只是一个存在于 ScourseForge 的项目，这个问题的回答是一个值得研究的领
域，虽然目前时间的缺乏组织了我们对它的探索。

考虑到这一点，一个简单的安全实现建成但是并没有发布。几周后， Spring 社区的其他成
员询问了安全性，这次这个代码被发送给他们。其他几个请求也跟随而来。到 2014 年一
月大约有 20 万人使用了这个代码。这些创业者的人提出一个 SourceForge 项目加入是为
了，这是在 2004 三月正式成立。

在早些时候，这个项目没有任何自己的验证模块，身份验证过程依赖于容器管理的安全性
和 Acegi 安全性。而不是专注于授权。开始的时候这很适合，但是越来越多的用户请求额
外的容器支持。容器特定的认证领域接口的基本限制变得清晰。还有一个相关的问题增加
新的容器的路径，这是最终用户的困惑和错误配置的常见问题。

Acegi 安全特定的认证服务介绍。大约一年后， Acegi 安全正式成为了 Spring 框架的子项
目。 1.0.0 最终版本是出版于 2006 -在超过两年半的大量生产的软件项目和数以百计的改
进和积极利用社区的贡献。

Acegi 安全 2007 年底正式成为了 Spring 组合项目，更名为"Spring Security"。

对比

Spring Security
Spring 技术栈的组成部分。

通过提供完整可扩展的认证和授权支持保护你的应用程序。
https://spring.io/projects/spring-security
SpringSecurity 特点：

  • 和 Spring 无缝整合。

  • 全面的权限控制。

  • 专门为 Web 开发而设计。

    • 旧版本不能脱离 Web 环境使用。

    • 新版本对整个框架进行了分层抽取，分成了核心模块和 Web 模块。单独引入核心模块就可以脱离 Web 环境。

  • 重量级。

Shiro

Apache 旗下的轻量级权限控制框架。

特点：

  • 轻量级。 Shiro 主张的理念是把复杂的事情变简单。针对对性能有更高要求的互联网应用有更好表现。
  • 通用性。
    • 好处：不局限于 Web 环境，可以脱离 Web 环境使用。
    • 缺陷：在 Web 环境下一些特定的需求需要手动编写代码定制。

Spring Security 是 Spring 家族中的一个安全管理框架，实际上，在 Spring Boot 出现之
前， Spring Security 就已经发展了多年了，但是使用的并不多，安全管理这个领域，一直
是 Shiro 的天下。
相对于 Shiro，在 SSM 中整合 Spring Security 都是比较麻烦的操作，所以， Spring
Security 虽然功能比 Shiro 强大，但是使用反而没有 Shiro 多（ Shiro 虽然功能没有
Spring Security 多，但是对于大部分项目而言， Shiro 也够用了）。
自从有了 Spring Boot 之后， Spring Boot 对于 Spring Security 提供了自动化配置方
案，可以使用更少的配置来使用 Spring Security。
因此，一般来说，常见的安全管理技术栈的组合是这样的：
• SSM + Shiro
• Spring Boot/Spring Cloud + Spring Security
以上只是一个推荐的组合而已，如果单纯从技术上来说，无论怎么组合，都是可以运行
的。

入门案例

idea创建Spring Security工程

springSeccurity基本原理

springsecurity本质是一个过滤器链

从启动是可以获取到过滤器链：

org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFilterorg.springframework.security.web.context.SecurityContextPersistenceFilterorg.springframework.security.web.header.HeaderWriterFilterorg.springframework.security.web.csrf.CsrfFilterorg.springframework.security.web.authentication.logout.LogoutFilterorg.springframework.security.web.authentication.UsernamePasswordAuthenticationFilterorg.springframework.security.web.authentication.ui.DefaultLoginPageGeneratingFilterorg.springframework.security.web.authentication.ui.DefaultLogoutPageGeneratingFilterorg.springframework.security.web.savedrequest.RequestCacheAwareFilterorg.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilterorg.springframework.security.web.authentication.AnonymousAuthenticationFilterorg.springframework.security.web.session.SessionManagementFilterorg.springframework.security.web.access.ExceptionTranslationFilterorg.springframework.security.web.access.intercept.FilterSecurityInterceptor

代码底层流程：重点看三个过滤器：

FilterSecurityInterceptor

FilterSecurityInterceptor：是一个方法级的权限过滤器, 基本位于过滤链的最底部。

image-20220713200815289

ExceptionTranslationFilter

ExceptionTranslationFilter：是个异常过滤器，用来处理在认证授权过程中抛出的异常

image-20220713201058364

UsernamePasswordAuthenticationFilter

UsernamePasswordAuthenticationFilter ：对/login 的 POST 请求做拦截，校验表单中用户
名，密码

image-20220713201222602

过滤器的加载

  1. 配置springSeccurity过滤器DelegatingFilterProxy(springboot会自动配置)
  2. 调用DelegatingFilterProxy的doFilter方法
  3. 调用initDelegate方法从ioc容器通过name获取beanFilterChainProxy
  4. 调用FilterChainProxy的doFilter调用getFilters方法加载所有Filter到过滤链中

02-SpringSecurity基本原理

两个重要接口

UserDetailsService:

当什么也没有配置的时候，账号和密码是由 Spring Security 定义生成的。而在实际项目中
账号和密码都是从数据库中查询出来的。 所以我们要通过自定义逻辑控制认证逻辑。
如果需要自定义逻辑时，只需要实现 UserDetailsService 接口即可。接口定义如下：

image-20220713225812527

自定义查询数据库密码的步骤:

  1. 创建类继承UsernamePasswordAuthenticationFilter重写其中的三个方法
  2. 实现UserDetailsService接口,编写查询数据的过程,返回User对象(由springSecurity提供)

PasswordEncoder :

数据加密接口,用于返回user对象里面密码的加密

image-20220713231030901

web权限方案

设置用户名密码

一般有三种方法:

  1. 配置文件
  2. 配置类
  3. 自定义编写实现类(UserDetailsService)

配置文件方式

编写application.yml即可

spring:  security:    user:      name: fate      password: fate

配置类方式

Spring Security 5.4.x之前:

  1. 编写配置类实现WebSecurityConfigurerAdapter
  2. 重写**configure(AuthenticationManagerBuilder auth)**方法
  3. 设置用户名以及密码
@Configurationpublic class SecurityConfig extends WebSecurityConfigurerAdapter {    @Override    protected void configure(AuthenticationManagerBuilder auth) throws Exception {        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();        String encodedPassword = passwordEncoder.encode("fate123");        auth.inMemoryAuthentication().withUser("fate").password(encodedPassword).roles("admin");    }}@Bean    PasswordEncoder passwordEncoder(){        return new BCryptPasswordEncoder();    }

然而WebSecurityConfigurerAdapter已经在Spring Security 5.7.x版本之后被弃用

全新玩法(基本上第三种):

@Configurationpublic class SecurityConfig  {    @Bean    public UserDetailsService users() {        BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();        String password = bCryptPasswordEncoder.encode("password");        User.UserBuilder users = User.builder();        UserDetails user = users                .username("user")                .password(password)                .roles("USER")                .build();        UserDetails admin = users                .username("admin")                .password(password)                .roles("USER", "ADMIN")                .build();        return new InMemoryUserDetailsManager(user, admin);    }    @Bean    PasswordEncoder passwordEncoder(){        return new BCryptPasswordEncoder();    }}

自定义编写实现类方式

@Servicepublic class LoginServiceImpl implements UserDetailsService {          @Override    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {        if (!"admin".equals(username)){            throw new UsernameNotFoundException(username+"不存在");        }        BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();        String password = bCryptPasswordEncoder.encode("password");        return new User(username,password, AuthorityUtils.commaSeparatedStringToAuthorityList("admin"));    }}

在5.4版本之前编写完成实现类后还需要在实现WebSecurityConfigurerAdapter的配置类中配置

@Overrideprotected void configure(AuthenticationManagerBuilder auth) throws Exception {    auth.userDetailsService(loginService).passwordEncoder(passwordEncoder());}@BeanPasswordEncoder passwordEncoder(){    return new BCryptPasswordEncoder();}

通过数据库认证用户

引入数据库依赖

<dependency>    <groupId>com.baomidou</groupId>    <artifactId>mybatis-plus-boot-starter</artifactId>    <version>3.5.1</version></dependency><!--mysql--><dependency>    <groupId>mysql</groupId>    <artifactId>mysql-connector-java</artifactId></dependency>

新建数据库和表

create table spring_security.users(    id       bigint auto_increment        primary key,    username varchar(20)  not null,    password varchar(100) null,    constraint username        unique (username));

构建java代码

image-20220714130805091

此处使用的是mybatisplus的逆向工程插件一键生成

image-20220714130645027

详情可见【漫漫Java路】mybatis-plus_fate _zore的博客-CSDN博客

实现UserDetailsService接口

重写loadUserByUsername方法

@Servicepublic class LoginServiceImpl implements UserDetailsService {    @Autowired    private UsersService usersService;        @Override    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {        LambdaQueryWrapper<Users> queryWrapper = new LambdaQueryWrapper<>();        queryWrapper.eq(Users::getUsername,username);        Users users = usersService.getOne(queryWrapper);        if (users == null) {            throw new UsernameNotFoundException("User not found: " + username);        }        return new User(username,users.getPassword(), AuthorityUtils.commaSeparatedStringToAuthorityList("admin"));    }}

自定义登录界面

配置

旧版操作在WebSecurityConfigurerAdapter实现类中重写**configure(HttpSecurity http)**方法

@Overrideprotected void configure(HttpSecurity http) throws Exception {    http.formLogin()            .loginPage("/login.html")//登录界面            .loginProcessingUrl("/user/login")//登陆访问路径            .defaultSuccessUrl("/index")//登录成功跳转的路径            .permitAll()            .and().authorizeRequests()            .antMatchers("/","/test/hello","/user/login").permitAll()//设置哪些路径不需要认证,可以直接访问            .anyRequest().authenticated()            .and().csrf().disable();//关闭csrf防护}

最新版的需要声明一个SecurityFilterChainbean:

其他配置基本相同

@BeanSecurityFilterChain filterChain(HttpSecurity http) throws Exception {    return http.formLogin()            .loginPage("/login.html")//登录界面            .loginProcessingUrl("/user/login")//登陆访问路径            .defaultSuccessUrl("/test/index")//登录成功跳转的路径            .permitAll()            .and().authorizeRequests()            .antMatchers("/","/test/hello","/user/login").permitAll()//设置哪些路径不需要认证,可以直接访问            .anyRequest().authenticated()            .and().csrf().disable()//关闭csrf防护            .build();}

编写login.html

<!DOCTYPE html><html lang="en"><head>    <meta charset="UTF-8">    <title>Title</title></head><body>    <form action="/user/login" method="post">        <label>            用户名:            <input type="text" name="username">        </label>        <br/>        <label>            密码:            <input type="password" name="password">        </label>        <br/>        <input type="submit" value="登录">    </form></body></html>

值得注意的是:

两个input表单的name属性必须是username和password否则springsecurity无法识别

基于角色或权限进行访问控制

hasAnyAuthority方法

配置当前访问地址需要哪个权限

新玩法:
在先前的SecurityFilterChain 中配置

//设置当前用户,只有admin权限才能访问这个路径                .antMatchers("/test/index").hasAnyAuthority("admins")

具体操作:

@BeanSecurityFilterChain filterChain(HttpSecurity http) throws Exception {    return http.formLogin()            //登录界面            .loginPage("/login.html")            //登陆访问路径            .loginProcessingUrl("/user/login")            //登录成功跳转的路径            .defaultSuccessUrl("/test/index")            .permitAll()            .and().authorizeRequests()            //设置哪些路径不需要认证,可以直接访问            .antMatchers("/","/test/hello","/user/login").permitAll()            //设置当前用户,只有admin权限才能访问这个路径            .antMatchers("/test/index").hasAnyAuthority("admins")            .anyRequest().authenticated()            //关闭csrf防护            .and().csrf().disable()            .build();}

旧玩法:

自然是在实现WebSecurityConfigurerAdapter的配置类中的**configure(HttpSecurity http)**中添加

//设置当前用户,只有admin权限才能访问这个路径                .antMatchers("/test/index").hasAnyAuthority("admins")

具体操作:

@Overrideprotected void configure(HttpSecurity http) throws Exception {    http.formLogin()            .loginPage("/login.html")//登录界面            .loginProcessingUrl("/user/login")//登陆访问路径            .defaultSuccessUrl("/index")//登录成功跳转的路径            .permitAll()            .and().authorizeRequests()            .antMatchers("/","/test/hello","/user/login").permitAll()//设置哪些路径不需要认证,可以直接访问            .antMatchers("/test/index").hasAnyAuthority("admins")            .anyRequest().authenticated()            .and().csrf().disable();//关闭csrf防护}
给对象添加权限

springsecurity的user对象存在这样一个构造方法

image-20220714165632896

第三个参数就是权限的集合

我们可以调用工具类AuthorityUtils 的**commaSeparatedStringToAuthorityList(“admins”)**方法设置user的权限

new User(username,users.getPassword(), AuthorityUtils.commaSeparatedStringToAuthorityList("admins"));

hasAnyAuthority

给当前访问地址配置多个权限

用法与上个方法基本完全一样

.antMatchers("/test/index").hasAnyAuthority("admins,manager")

权限之间用逗号进行分隔

hasRole

给当前访问地址配置角色

换汤不换药的用法…

.antMatchers("/test/index").hasRole("user")
给user设置角色

查看hasRole()的源码我们可以发现

image-20220714174314150

image-20220714174351641

每个role前面都加上了ROLE_前缀,前面说到,user构造方法第三个参数可以设置权限,同样的,也可以设置角色:只需要在角色名前加上ROLE_

new User(username,users.getPassword(), AuthorityUtils.commaSeparatedStringToAuthorityList("admins,ROLE_ADMIN"));

hasAnyRole

给当前访问地址配置多个角色

换汤不换药的用法…

.antMatchers("/test/hello").hasAnyRole("USER,ADMIN")

自定义403界面

编写界面

略.这里以unAuth.html作为界面,实际操作中,可任意编写

配置类

只需要在beanSecurityFilterChain 中配置

http.exceptionHandling().accessDeniedPage("/unAuth.html");
  @Bean    SecurityFilterChain filterChain(HttpSecurity http) throws Exception {         http.formLogin()                //登录界面                .loginPage("/login.html")                //登陆访问路径                .loginProcessingUrl("/user/login")                //登录成功跳转的路径                .defaultSuccessUrl("/test/index")                .permitAll()                .and().authorizeRequests()                //设置哪些路径不需要认证,可以直接访问                .antMatchers("/","/test/hello","/user/login").permitAll()//                //设置当前用户,只有admin权限才能访问这个路径//                .antMatchers("/test/index").hasAnyAuthority("admins")//                .antMatchers("/test/index").hasAnyAuthority("admins,manager")                .antMatchers("/test/index").hasRole("user")                .anyRequest().authenticated()                //关闭csrf防护                .and().csrf().disable();         http.exceptionHandling().accessDeniedPage("/unAuth.html");         return http.build();    }

常见注解

@Secured

判断是否具有角色，另外需要注意的是这里匹配的字符串需要添加前缀“ROLE_“。
使用注解先要开启注解功能！

基本流程:

  1. 启动类(配置类)上添加@EnableGlobalMethodSecurity(securedEnabled=true) image-20220714194657024

  2. 在controller使用该注解,设置角色

    @GetMapping("/update")@Secured({"ROLE_normal","ROLE_admin"})public String update(){    return "update";}

  3. UserDetailService中设置user的角色

@PreAuthorize

注解适合进入方法前的权限验证， @PreAuthorize 可以将登录用户的 roles/permissions 参数传到方法中

基本流程:

  1. 启动类(配置类)上添加@EnableGlobalMethodSecurity(securedEnabled=true)

  2. 在controller使用该注解

    image-20220714201325098

    @GetMapping("preAuthorize")@PreAuthorize("hasAuthority('admins')")public String preAuthorize(){    return "preAuthorize";}

  3. 给user设置权限(同上)

@PostAuthorize

在方法执行完成后进行校验

只控制返回的数据,不会影响方法的执行

其他与上一个方法基本没有差别

@PostFilter

权限验证之后对数据进行过滤

留下用户名是 admin1 的数据
表达式中的 filterObject 引用的是方法返回值 List 中的某一个元素

@RequestMapping("getAll")@PreAuthorize("hasRole('ROLE_管理员')")@PostFilter("filterObject.username == 'admin1'")@ResponseBodypublic List<UserInfo> getAllUser(){ArrayList<UserInfo> list = new ArrayList<>();list.add(new UserInfo(1l,"admin1","6666"));list.add(new UserInfo(2l,"admin2","888"));return list;}

@PreFilter

进入控制器之前对数据进行过滤

@RequestMapping("getTestPreFilter") @PreAuthorize("hasRole('ROLE_管理员')") @PreFilter(value = "filterObject.id%2==0") @ResponseBody public List<UserInfo> getTestPreFilter(@RequestBody List<UserInfo> list){ list.forEach(t-> { System.out.println(t.getId()+"\t"+t.getUsername()); }); return list; }

用户注销

在配置类的beanSecurityFilterChain中添加配置即可

http.logout().logoutUrl("/logout").logoutSuccessUrl("/test/index").permitAll();

自动登录

在javaweb中,通过cookie技术就可以做到自动登录,但是cookie是存储在浏览器中的,并不适合拿来存放密码等敏感信息

springsecurity中也提供了自动登录的技术

实现原理

cookie+数据库

第一次登录:

在用户认证成功之后,会生成一段加密字符串在cookie中,与此同时,也会将加密字符串和用户信息字符串存储在数据库中

再次访问:

从cookie中拿到加密字符串,到数据库库中进行查询,如果存在对应信息,自动认证成功,登录

image-20220714222109248

具体实现

  1. 创建数据库表

    CREATE TABLE `persistent_logins` (`username` varchar(64) NOT NULL,`series` varchar(64) NOT NULL,`token` varchar(64) NOT NULL,`last_used` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATECURRENT_TIMESTAMP,PRIMARY KEY (`series`)) ENGINE=InnoDB DEFAULT CHARSET=utf8;

  2. 注入数据源,配置bean

    @Autowiredprivate  DataSource dataSource;@Beanpublic PersistentTokenRepository persistentTokenRepository(){    JdbcTokenRepositoryImpl tokenRepository = new JdbcTokenRepositoryImpl();    tokenRepository.setDataSource(dataSource);    //自动生成表    tokenRepository.setCreateTableOnStartup(true);    return tokenRepository;}

  3. 修改登录界面

    <form action="/user/login" method="post">    <label>        用户名:        <input type="text" name="username">    </label>    <br/>    <label>        密码:        <input type="password" name="password">    </label>    <br/>    <label>        自动登录:        <input type="checkbox" name="remember-me" >    </label>    <input type="submit" value="登录"></form>

    自动登录的复选框name属性必须是name="remember-me"

CSRF

简介

跨站请求伪造（英语： Cross-site request forgery），也被称为 one-click
attack 或者 session riding，通常缩写为 CSRF 或者 XSRF， 是一种挟制用户在当前已
登录的 Web 应用程序上执行非本意的操作的攻击方法。跟跨网站脚本（XSS）相比， XSS
利用的是用户对指定网站的信任， CSRF 利用的是网站对用户网页浏览器的信任。
跨站请求攻击，简单地说，是攻击者通过一些技术手段欺骗用户的浏览器去访问一个
自己曾经认证过的网站并运行一些操作（如发邮件，发消息，甚至财产操作如转账和购买
商品）。由于浏览器曾经认证过，所以被访问的网站会认为是真正的用户操作而去运行。
这利用了 web 中用户身份验证的一个漏洞： 简单的身份验证只能保证请求发自某个用户的
浏览器，却不能保证请求本身是用户自愿发出的。
从 Spring Security 4.0 开始，默认情况下会启用 CSRF 保护，以防止 CSRF 攻击应用
程序， Spring Security CSRF 会针对 PATCH， POST， PUT 和 DELETE 方法进行防护。

使用

在登录页面添加一个隐藏域：

<inputtype="hidden"th:if="${_csrf}!=null"th:value="${_csrf.token}"name="_csrf"/>

取消关闭安全配置的类中的 csrf

原理

  1. 生成 csrfToken 保存到 HttpSession 或者 Cookie 中。

  2. 请求到来时，从请求中提取 csrfToken，和保存的csrfToken 做比较，进而判断当前请求是否合法。主要通过 CsrfFilter 过滤器来完成。

源码解析

底层逻辑全部存在与classCsrfFilter中

image-20220714230616198

可以看到springsecurity对于"GET", "HEAD", "TRACE", "OPTIONS"请求是不做保护的

image-20220714230716348

微服务权限方案

微服务认证与授权实现思路

认证授权过程分析

  1. 如果是基于 Session，那么 Spring-security 会对 cookie 里的 sessionid 进行解析，找到服务器存储的 session 信息，然后判断当前用户是否符合请求的要求。
  2. 如果是 token，则是解析出 token，然后将当前请求加入到 Spring-security 管理的权限信息中去

image-20220715105007382

如果系统的模块众多，每个模块都需要进行授权与认证，所以我们选择基于 token 的形式进行授权与认证，用户根据用户名密码认证成功，然后获取当前用户角色的一系列权限值，并以用户名为 key，权限列表为 value 的形式存入 redis 缓存中，根据用户名相关信息生成 token 返回，浏览器将 token 记录到 cookie 中，每次调用 api 接口都默认将 token 携带到 header 请求头中， Spring-security 解析 header 头获取 token 信息，解析 token 获取当前用户名，根据用户名就可以从 redis 中获取权限列表，这样 Spring-security 就能够判断当前请求是否有权限访问

权限管理数据模型

一般的权限管理系统,需要五张表

  1. 菜单表
  2. 角色表
  3. 用户表
  4. 角色菜单关系表
  5. 用户角色关系表

image-20220715123619944

SET NAMES utf8mb4;SET FOREIGN_KEY_CHECKS = 0;-- ------------------------------ Table structure for acl_permission-- ----------------------------DROP TABLE IF EXISTS `acl_permission`;CREATE TABLE `acl_permission`  (  `id` char(19) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '编号',  `pid` char(19) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '所属上级',  `name` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '名称',  `type` tinyint(3) NOT NULL DEFAULT 0 COMMENT '类型(1:菜单,2:按钮)',  `permission_value` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '权限值',  `path` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '访问路径',  `component` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '组件路径',  `icon` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '图标',  `status` tinyint(4) NULL DEFAULT NULL COMMENT '状态(0:禁止,1:正常)',  `is_deleted` tinyint(1) UNSIGNED NOT NULL DEFAULT 0 COMMENT '逻辑删除 1（true）已删除， 0（false）未删除',  `gmt_create` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',  `gmt_modified` datetime(0) NULL DEFAULT NULL COMMENT '更新时间',  PRIMARY KEY (`id`) USING BTREE,  INDEX `idx_pid`(`pid`) USING BTREE) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '权限' ROW_FORMAT = Dynamic;-- ------------------------------ Table structure for acl_role-- ----------------------------DROP TABLE IF EXISTS `acl_role`;CREATE TABLE `acl_role`  (  `id` char(19) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL DEFAULT '' COMMENT '角色id',  `role_name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL DEFAULT '' COMMENT '角色名称',  `role_code` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色编码',  `remark` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '备注',  `is_deleted` tinyint(1) UNSIGNED NOT NULL DEFAULT 0 COMMENT '逻辑删除 1（true）已删除， 0（false）未删除',  `gmt_create` datetime(0) NOT NULL COMMENT '创建时间',  `gmt_modified` datetime(0) NOT NULL COMMENT '更新时间',  PRIMARY KEY (`id`) USING BTREE) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;-- ------------------------------ Table structure for acl_role_permission-- ----------------------------DROP TABLE IF EXISTS `acl_role_permission`;CREATE TABLE `acl_role_permission`  (  `id` char(19) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL DEFAULT '',  `role_id` char(19) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL DEFAULT '',  `permission_id` char(19) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL DEFAULT '',  `is_deleted` tinyint(1) UNSIGNED NOT NULL DEFAULT 0 COMMENT '逻辑删除 1（true）已删除， 0（false）未删除',  `gmt_create` datetime(0) NOT NULL COMMENT '创建时间',  `gmt_modified` datetime(0) NOT NULL COMMENT '更新时间',  PRIMARY KEY (`id`) USING BTREE,  INDEX `idx_role_id`(`role_id`) USING BTREE,  INDEX `idx_permission_id`(`permission_id`) USING BTREE) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '角色权限' ROW_FORMAT = Dynamic;-- ------------------------------ Table structure for acl_user-- ----------------------------DROP TABLE IF EXISTS `acl_user`;CREATE TABLE `acl_user`  (  `id` char(19) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '会员id',  `username` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '微信openid',  `password` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '密码',  `nick_name` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '昵称',  `salt` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '用户头像',  `token` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '用户签名',  `is_deleted` tinyint(1) UNSIGNED NOT NULL DEFAULT 0 COMMENT '逻辑删除 1（true）已删除， 0（false）未删除',  `gmt_create` datetime(0) NOT NULL COMMENT '创建时间',  `gmt_modified` datetime(0) NOT NULL COMMENT '更新时间',  PRIMARY KEY (`id`) USING BTREE,  UNIQUE INDEX `uk_username`(`username`) USING BTREE) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '用户表' ROW_FORMAT = Dynamic;-- ------------------------------ Table structure for acl_user_role-- ----------------------------DROP TABLE IF EXISTS `acl_user_role`;CREATE TABLE `acl_user_role`  (  `id` char(19) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL DEFAULT '' COMMENT '主键id',  `role_id` char(19) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL DEFAULT '0' COMMENT '角色id',  `user_id` char(19) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL DEFAULT '0' COMMENT '用户id',  `is_deleted` tinyint(1) UNSIGNED NOT NULL DEFAULT 0 COMMENT '逻辑删除 1（true）已删除， 0（false）未删除',  `gmt_create` datetime(0) NOT NULL COMMENT '创建时间',  `gmt_modified` datetime(0) NOT NULL COMMENT '更新时间',  PRIMARY KEY (`id`) USING BTREE,  INDEX `idx_role_id`(`role_id`) USING BTREE,  INDEX `idx_user_id`(`user_id`) USING BTREE) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;SET FOREIGN_KEY_CHECKS = 1;

源码剖析

SpringSecurity 的过滤器介绍

SpringSecurity 采用的是责任链的设计模式，它有一条很长的过滤器链。现在对这条过滤器链的 15 个过滤器进行说明:

  1. WebAsyncManagerIntegrationFilter：将 Security 上下文与 Spring Web 中用于
    处理异步请求映射的 WebAsyncManager 进行集成。
  2. SecurityContextPersistenceFilter：在每次请求处理之前将该请求相关的安全上下文信息加载到 SecurityContextHolder 中，然后在该次请求处理完成之后，将SecurityContextHolder 中关于这次请求的信息存储到一个“仓储” 中，然后将SecurityContextHolder 中的信息清除，例如在 Session 中维护一个用户的安全信息就是这个过滤器处理的。
  3. HeaderWriterFilter：用于将头信息加入响应中。
  4. CsrfFilter：用于处理跨站请求伪造。
  5. LogoutFilter：用于处理退出登录。
  6. UsernamePasswordAuthenticationFilter：用于处理基于表单的登录请求，从表单中获取用户名和密码。默认情况下处理来自 /login 的请求。从表单中获取用户名和密码时，默认使用的表单 name 值为 username 和 password，这两个值可以通过设置这个过滤器的 usernameParameter 和passwordParameter 两个参数的值进行修改。
  7. DefaultLoginPageGeneratingFilter：如果没有配置登录页面，那系统初始化时就会配置这个过滤器，并且用于在需要进行登录时生成一个登录表单页面。
  8. BasicAuthenticationFilter：检测和处理 http basic 认证。
  9. RequestCacheAwareFilter：用来处理请求的缓存。
  10. SecurityContextHolderAwareRequestFilter：主要是包装请求对象 request。
  11. AnonymousAuthenticationFilter：检测SecurityContextHolder 中是否存在Authentication 对象，如果不存在为其提供一个匿名Authentication。
  12. SessionManagementFilter：管理 session 的过滤器
  13. ExceptionTranslationFilter：处理AccessDeniedException 和AuthenticationException 异常。
  14. FilterSecurityInterceptor：可以看做过滤器链的出口。
  15. RememberMeAuthenticationFilter：当用户没有登录而直接访问资源时, 从 cookie里找出用户的信息, 如果 Spring Security 能够识别出用户提供的remember me cookie,用户将不必填写用户名和密码, 而是直接登录进入系统，该过滤器默认不开启

认证流程

UsernamePasswordAuthenticationFilter

查看父类AbstractAuthenticationProcessingFilter

第一步

image-20220717152320394

判断是否为post方式,非post方式直接进行放行

第二步

image-20220717152712623

调用子类方法进行身份认证,认证通过将信息存储在Authentication对象中

第三步

image-20220717152924770

session策略处理

第四步

  1. 失败

image-20220717153149494

认证失败抛出异常,执行认证失败处理方法

  1. 成功

image-20220717153255815

调用认证成功方法

上面第二步,调用子类的方法进行认证过程

主要

public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException{}方法

第一步

image-20220717154116834

判断是否为post请求,如果不是就抛异常

第二步

image-20220717154356980

获取用户名和密码

第三步

image-20220717154419037

使用获取到的数据,构造对象,标记为未认证,吧请求的一些属性设置到对象中,调用UserDetailsService的方法进行身份认证

查看UsernamePasswordAuthenticationToken构造过程

未认证的方法

image-20220717160424765

已经认证的方法

image-20220717160447458

查看AuthenticationManager源码,认证实现

上述过程中， UsernamePasswordAuthenticationFilter 过滤器的attemptAuthentication() 方法的（ 5）过程将未认证的 Authentication 对象传入ProviderManager 类的 authenticate() 方法进行身份认证。 ProviderManager 是 AuthenticationManager 接口的实现类，该接口是认证相关的核心接口，也是认证的入口。在实际开发中，我们可能有多种不同的认证方式，例如：用户名+密码、邮箱+密码、手机号+验证码等，而这些认证方式的入口始终只有一个，那就是AuthenticationManager。在该接口的常用实现类ProviderManager 内部会维护一个List列表，存放多种认证方式，实际上这是委托者模式（ Delegate）的应用。每种认证方式对应着一个 AuthenticationProvider，
AuthenticationManager 根据认证方式的不同（根据传入的 Authentication 类型判断）委托对应的 AuthenticationProvider 进行用户认证

image-20220717163945270

上述认证成功之后，调用CredentialsContainer 接口定义的eraseCredentials() 方法去除敏感信息。

UsernamePasswordAuthenticationToken 实现的 eraseCredentials() 方法，该方法实现在其父类中：

image-20220717170141798

认证成功/失败处理

上述过程就是认证流程的最核心部分，接下来重新回到
UsernamePasswordAuthenticationFilter 过滤器的 doFilter() 方法，查看认证成功/失败的处理：

image-20220717170400266

权限访问流程

上一个部分通过源码的方式介绍了认证流程，下面介绍权限访问流程，主要是对ExceptionTranslationFilter 过滤器和 FilterSecurityInterceptor 过滤器进行介绍。

ExceptionTranslationFilter 过滤器

该过滤器是用于处理异常的，不需要我们配置，对于前端提交的请求会直接放行，捕获后续抛出的异常并进行处理（例如：权限访问限制）。具体源码如下：

public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {    HttpServletRequest request = (HttpServletRequest)req;    HttpServletResponse response = (HttpServletResponse)res;    try {        chain.doFilter(request, response);        this.logger.debug("Chain processed normally");    } catch (IOException var9) {        throw var9;    } catch (Exception var10) {        Throwable[] causeChain = this.throwableAnalyzer.determineCauseChain(var10);        RuntimeException ase = (AuthenticationException)this.throwableAnalyzer.getFirstThrowableOfType(AuthenticationException.class, causeChain);        if (ase == null) {            ase = (AccessDeniedException)this.throwableAnalyzer.getFirstThrowableOfType(AccessDeniedException.class, causeChain);        }        if (ase == null) {            if (var10 instanceof ServletException) {                throw (ServletException)var10;            }            if (var10 instanceof RuntimeException) {                throw (RuntimeException)var10;            }            throw new RuntimeException(var10);        }        if (response.isCommitted()) {            throw new ServletException("Unable to handle the Spring Security Exception because the response is already committed.", var10);        }        this.handleSpringSecurityException(request, response, chain, (RuntimeException)ase);    }}

FilterSecurityInterceptor 过滤器

FilterSecurityInterceptor 是过滤器链的最后一个过滤器，该过滤器是过滤器链的最后一个过滤器，根据资源权限配置来判断当前请求是否有权限访问对应的资源。如果
访问受限会抛出相关异常，最终所抛出的异常会由前一个过滤器ExceptionTranslationFilter 进行捕获和处理。具体源码如下：

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {    FilterInvocation fi = new FilterInvocation(request, response, chain);    this.invoke(fi);}
public void invoke(FilterInvocation fi) throws IOException, ServletException {    if (fi.getRequest() != null && fi.getRequest().getAttribute("__spring_security_filterSecurityInterceptor_filterApplied") != null && this.observeOncePerRequest) {        fi.getChain().doFilter(fi.getRequest(), fi.getResponse());    } else {        if (fi.getRequest() != null && this.observeOncePerRequest) {            fi.getRequest().setAttribute("__spring_security_filterSecurityInterceptor_filterApplied", Boolean.TRUE);        }//根据资源权限配置来判断当前请求是否有权限访问对应的资源,不能则抛出异常        InterceptorStatusToken token = super.beforeInvocation(fi);        try {            fi.getChain().doFilter(fi.getRequest(), fi.getResponse());        } finally {            super.finallyInvocation(token);        }        super.afterInvocation(token, (Object)null);    }

需要注意， Spring Security 的过滤器链是配置在 SpringMVC 的核心组件DispatcherServlet 运行之前。也就是说，请求通过 Spring Security 的所有过滤器，不意味着能够正常访问资源，该请求还需要通过 SpringMVC 的拦截器链。

SpringSecurity 请求间共享认证信息

一般认证成功后的用户信息是通过 Session 在多个请求之间共享，那么 SpringSecurity 中是如何实现将已认证的用户信息对象 Authentication 与 Session 绑定的进行
具体分析。

image-20220717171358584

认证成功的方法,把认证信息放到对象

吧认证信息对象放到springContext中,存入到springContextHolder中

image-20220717172651718

查 看 SecurityContext 接 口 及 其 实 现 类SecurityContextImpl ， 该 类 其 实 就 是 对Authentication 的封装：

查 看 SecurityContextHolder 类 ， 该 类 其 实 是 对 ThreadLocal 的 封 装 ， 存 储SecurityContext 对象：

image-20220717173146336

image-20220717173155183

image-20220717173200776

image-20220717173206077

image-20220717173210460

SecurityContextPersistenceFilter 过滤器

前面提到过，在UsernamePasswordAuthenticationFilter 过滤器认证成功之后，会在认证成功的处理方法中将已认证的用户信息对象 Authentication 封装进SecurityContext，并存入 SecurityContextHolder。

之后，响应会通过 SecurityContextPersistenceFilter 过滤器，该过滤器的位置在所有过滤器的最前面，请求到来先进它，响应返回最后一个通过它，所以在该过滤器中处理已认证的用户信息对象 Authentication 与 Session 绑定。

认证成功的响应通过 SecurityContextPersistenceFilter 过滤器时，会从SecurityContextHolder 中取出封装了已认证用户信息对象 Authentication 的SecurityContext，放进 Session 中。当请求再次到来时，请求首先经过该过滤器，该过滤器会判断当前请求的 Session 是否存有 SecurityContext 对象，如果有则将该对象取出再次放入 SecurityContextHolder 中，之后该请求所在的线程获得认证用户信息，后续的资源访问不需要进行身份认证；当响应再次返回时，该过滤器同样从 SecurityContextHolder 取出SecurityContext 对象，放入 Session 中。具体源码如下：

image-20220717173346708

image-20220717173350283


参考文章：https://blog.csdn.net/weixin_60223449/article/details/125835950

郑重声明：本文版权归原作者所有，转载文章仅为传播更多信息之目的，如作者信息标记有误，请第一时候联系我们修改或删除，在此表示感谢。

相关阅读

特别提醒:

1、请用户自行保存原始数据，为确保安全网站使用完即被永久销毁，如何人将无法再次获取。

2、如果上次文件较大或者涉及到复杂运算的数据，可能需要一定的时间，请耐心等待一会。

3、请按照用户协议文明上网，如果发现用户存在恶意行为，包括但不限于发布不合适言论、妄图

     获取用户隐私信息等行为，网站将根据掌握的情况对用户进行限制部分行为、永久封号等处罚。

4、如果文件下载失败可能是弹出窗口被浏览器拦截,点击允许弹出即可,一般在网址栏位置设置

5、欢迎将网站推荐给其他人，网站持续更新更多功能敬请期待，收藏网站高效办公不迷路。

      


请登录后回复

共有0条评论

© 2022 慧工作 版权所有 | 闽ICP备2022009970号