SpringSecurity总结
图片如果太小可以右键在新标签打开或者按住 ctrl+鼠标滑轮调整页面尺寸调整。
基础
核心
认证与授权
与Shiro联系
SpringSecurity 在 SpringBoot 出现前因为配置复杂使用较少，但是在SpringBoot 出现后搭配使用开发效率大大提高。是一款重量级框架。而 Shiro 是一款轻量级框架，配置简单一些，所以如果不使用 SpringBoot，那么一般搭配 Shiro，而使用SpringBoot 就搭配 SpringSecurity。
核心接口
UserDetailsService
定义了SpringSecurity 查询用户信息的接口方法，在SpringSecurity 认证时，并不是直接通过用户名密码去数据库比对，没有对应就返回，而是先通过 username 去数据库查到对应的用户信息，然后进行拼接成 SpringSecurity 内部维护的用户对象，然后由内部方法进行密码比对。而查询数据库返回用户对象的接口方法就是由 UserDetailsService 接口定义的。
UserDetails
上面说到数据库查询用户信息会返回一个SpringSecurity 内部维护的用户对象。这个用户抽象类就是 UserDetails，其内部结构如下
public interface UserDetails extends Serializable { // ~ Methods // ======================================================================================================== /** * Returns the authorities granted to the user. Cannot return <code>null</code>. * 授权列表 * @return the authorities, sorted by natural key (never <code>null</code>) */ Collection<? extends GrantedAuthority> getAuthorities(); /** * Returns the password used to authenticate the user. * * @return the password */ String getPassword(); /** * Returns the username used to authenticate the user. Cannot return <code>null</code>. * * @return the username (never <code>null</code>) */ String getUsername(); /** * Indicates whether the user's account has expired. An expired account cannot be * authenticated. * 是否过期 * @return <code>true</code> if the user's account is valid (ie non-expired), * <code>false</code> if no longer valid (ie expired) */ boolean isAccountNonExpired(); /** * Indicates whether the user is locked or unlocked. A locked user cannot be * authenticated. * 是否锁定，如果锁定就无法验证 * @return <code>true</code> if the user is not locked, <code>false</code> otherwise */ boolean isAccountNonLocked(); /** * Indicates whether the user's credentials (password) has expired. Expired * credentials prevent authentication. * 用户凭证是否过期，过期的凭证会阻止身份验证 * @return <code>true</code> if the user's credentials are valid (ie non-expired), * <code>false</code> if no longer valid (ie expired) */ boolean isCredentialsNonExpired(); /** * Indicates whether the user is enabled or disabled. A disabled user cannot be * authenticated. * 用户是启用还是禁用，无法对禁用的用户进行身份验证 * @return <code>true</code> if the user is enabled, <code>false</code> otherwise */ boolean isEnabled(); }
在使用时可以让自定义用户来实现这个接口。
PasswordEncoder
密码接口，一般使用 BCryptPasswordEncoder 来作为默认的密码转换器。SpringSecurity 在加密时引入盐，使得加密过程是不可逆的，而加密后的字符串包含盐信息，在比较方法中会对加密后的密码进行解析，解析出盐值，然后对输入密码进行加密，比较输入密码加密后的结果是否与原密码加密后的结果一致。使用 encode 方法进行加密， matches 方法进行密码比较。如果一致返回 true。
常用配置
用户名密码配置
方式一、配置文件
方式二、配置类
@Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { @Resource private PasswordEncoder passwordEncoder; @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { String encode = passwordEncoder.encode("123"); auth.inMemoryAuthentication().withUser("lucy").password(encode).roles("admin"); // super.configure(auth); } @Bean public PasswordEncoder passwordEncoder(){ return new BCryptPasswordEncoder(); } }
方式三、自定义配置
因为一般项目用户名密码都是存在数据库的，所以这是最主流的。
1、配置UserDetails，返回用户信息
@Service("userDetailsService")
public class MyUserDetailService implements UserDetailsService {
@Resource
private PasswordEncoder passwordEncoder;
@Resource
private UsersMapper usersMapper;
@Override
public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
Users user = usersMapper.selectOne(new QueryWrapper<Users>().eq("username", s));
if(user == null){
throw new UsernameNotFoundException("用户名不存在!");
}
// 权限列表，role
List<GrantedAuthority> auths = AuthorityUtils.commaSeparatedStringToAuthorityList("role");
return new User(s, passwordEncoder.encode(user.getPassword()),auths);
}
}
2、添加配置类，将userDetails注册进 SpringSecurity
@Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { @Resource private UserDetailsService userDetailsService; @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder()); } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } }
记住我
原理
在登陆后会向数据库的 persistent_logins 表中插入一条记录，表结构如下
series 是主键， 随后将 series 和 token 进行算法转换成字符串发给客户端，后面客户端会携带 Cookie ，当下次访问时后端会解析 Cookie ，解析成 series 和 token ，然后去表中匹配，验证token是否一致，以及 last_used + 存活时间是否到期，如果都满足就再以 name 走 UserDetailsService 的方法，返回用户信息。
配置
建表语句：
DROP TABLE IF EXISTS `persistent_logins`; 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 UPDATE CURRENT_TIMESTAMP, PRIMARY KEY (`series`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
@Resource private DataSource datasource; /** * 注入记住我token表的数据源 * @return */ @Bean public PersistentTokenRepository persistentTokenRepository(){ JdbcTokenRepositoryImpl jdbcTokenRepository = new JdbcTokenRepositoryImpl(); jdbcTokenRepository.setDataSource(datasource); // jdbcTokenRepository.setCreateTableOnStartup(true); // 是否自动创建token数据表，如果是第一次可以勾选，后面表存在还开启就会报错 return jdbcTokenRepository; }
可以使用在配置方法中添加 ".rememberMeParameter("rem") " 配置记住我功能的name
注意：
1、这里的 last_used 是拒上次打开浏览器登陆开始计算的，也就是每次打开浏览器访问一次 last_used 都会刷新一次。而浏览器内部访问并不会刷新时间。
2、退出后（退出登陆状态）会清除数据库的token数据记录，再次访问需要重新登录
登陆成功处理器
步骤一：增加组件
方式一、继承实现类
@Slf4j @Component public class AuthenticationSuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler { @Override public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws ServletException, IOException { User user = (User) authentication.getPrincipal(); // 获取Security 内部维护的user对象 System.out.println(user.getUsername()); // 用户名：aa System.out.println(user.getPassword()); // 密码，由于加密，得到的是null：null System.out.println(user.getAuthorities()); // 用户权限列表：[ROLE_AAA, ROLE_sale, admins, manager] response.sendRedirect("http://www.baidu.com"); } }
方式二、实现底层接口
public class MyAuthenticationSuccessHandler implements AuthenticationSuccessHandler { private String url; public MyAuthenticationSuccessHandler(String url) { this.url = url; } @Override public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException { response.sendRedirect(url); } }
步骤二：将组件注册进成功处理器配置中
登陆失败处理器
步骤一：增加组件
方式一、实现接口
方式二、继承实现类
步骤二：将组件注册进失败处理器配置中
权限认证失败处理器
1、组件
2、配置
用户退出处理器
1、组件
2、配置
角色权限
访问一个需要权限或角色的页面需要先登陆，如果登陆后还是不能访问就会返回500.
角色、权限、用户关系
权限与角色是多对多，角色与用户也是多对多。权限指的是对某个表具体的增删改查权限，而角色是一系列权限的集合。比如管理员角色拥有对所有表增删改查的权限，普通用户角色只拥有对所有表查询的权限，而用户 admin 拥有管理员角色，用户 A 拥有普通用户的角色。
定义权限
在config里配置路径所需权限，在UserDetailsService里配置用户所拥有的权限。
1、hasAuthority 是与关系，如果在config里配置了多个权限，如”admin,manager”，那么在UserDetailsService也必须对用户配置两个角色权限才可以访问
2、hasAnyAuthority 是或关系，如果在 config里配置了多个权限，如”admin,manager”，那么在UserDetailsService只需要对用户配置一个权限就可以访问
定义角色
角色在 UserDetailsService 实现类中配置需要加 "ROLE_" 前缀
而hasRole 和hasAnyRole 对应权限里的hasAuthority 和hasAnyAuthority，是与和或的关系。
Access 来定义权限、角色
上面的hasRole、hasAuthority 底层都是使用 access 来实现的，所以我们还可以通过底层的access 方法来主直接定义权限、角色。
那么 config 里配置就是如下：
自定义 Access 校验规则
1、组件
2、配置
基于 IP 来限制
这样的话只能接收来自 127.0.0.1 的请求。
定义角色注解
@Secured单个””里不支持使用,隔开，也就是不支持与关系。如果要配置多个或关系，可以使用{}， 在UserDetailsService里只要配置一个就可以访问。
并且只支持定义角色，不支持定义权限，也就是Secured里必须是ROLE_开头
定义角色、权限注解
可以定义角色、也可以定义权限
如果用户拥有的角色是abc，那么在这里可以配置hasRole(‘abc’)，也可以配置hasRole(‘ROLE_abc’)，而使用config配置类配置则不可以，会报错。而大小写则和配置类一样会区分
先执行后校验注解
可以用于记录访问日志
对返回和传入数据过滤注解
CSRF
CSRF 是为了防止用户在开启记住登陆后，其他非法用户截取到登陆用户的 Cookie ，登陆其他用户进行非法操作。
默认是开启的，开启后用户登录时，系统发放一个CsrfToken值（key是 _csrf，value是token值），用户携带该CsrfToken值与用户名、密码等参数完成登录。系统记录该会话的 CsrfToken 值，之后在用户的任何请求中，都必须带上该CsrfToken值，并由系统进行校验。
配置：
相关依赖：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency> <!--对Thymeleaf添加Spring Security标签支持--> <dependency> <groupId>org.thymeleaf.extras</groupId> <artifactId>thymeleaf-extras-springsecurity5</artifactId> </dependency>
开启 CSRF 时配置类不能配置 loginProcessingUrl 和 defaultSuccessUrl 。会影响登陆跳转逻辑。
其他配置
1、如果配置了登陆的URL（也就是loginProcessingUrl），那么自定义Controller里处理的登陆请求就会用不到，走的是SpringSecurity内部的验证方法。
2、anyRequest()必须配置在所有的antMatches后面，也就是笼统的权限配置必须放在其他权限的最后
3、and()是用于连接多个http配置。
4、在开发时需要添加@EnableWebSecurity注解，这个注解会自动配置安全认证策略和认证信息。
整合OAuth2
关于 OAuth2 与 JWT 可以移步 浅谈常见的认证机制 。
基础依赖
<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-oauth2</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-security</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>
基础配置
因为 OAuth2 涉及到资源服务器和授权服务器，所以除了配置 SpringSecurity ，还需要配置资源服务器和授权服务器。
1、SpringSecurity配置：
@EnableWebSecurity @Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests() .antMatchers("/oauth/**", "/login/**", "/logout/**").permitAll() .anyRequest().authenticated() .and() .formLogin().permitAll() .and() .csrf().disable(); } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } }
2、授权服务器配置：定义 app_id、app_secret，以及重定向地址，授权范围等
这里直接贴下包含下面整合 redis 存储、JWT、SSO总的配置，根据图片需要进行选择
@Configuration @EnableAuthorizationServer public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter { @Resource private PasswordEncoder passwordEncoder; @Resource private AuthenticationManager authenticationManager; @Resource private UserService userDetailsService; @Resource private TokenStore jwtTokenStore; // 使用jwt存储（因为jwt是无状态的，所以并不会持久化） // @Resource // private TokenStore redisTokenStore; // 使用redis存储 @Resource private JwtAccessTokenConverter jwtAccessTokenConverter; @Resource private JwtTokenEnhancer jwtTokenEnhancer; /** * @param endpoints * @throws Exception */ @Override public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception { // 设置 JWT 增强内容 TokenEnhancerChain tokenEnhancerChain = new TokenEnhancerChain(); List<TokenEnhancer> delegates = new ArrayList<>(); delegates.add(jwtTokenEnhancer); delegates.add(jwtAccessTokenConverter); tokenEnhancerChain.setTokenEnhancers(delegates); endpoints.authenticationManager(authenticationManager) .userDetailsService(userDetailsService) // 密码模式需要配置的 .tokenStore(jwtTokenStore) .tokenEnhancer(tokenEnhancerChain) // 增加额外数据 .accessTokenConverter(jwtAccessTokenConverter); // 使用jwt来代替默认的令牌 } @Override public void configure(ClientDetailsServiceConfigurer clients) throws Exception { clients.inMemory() // 放入内存 .withClient("client") // 客户端ID .secret(passwordEncoder.encode("112233")) // 密钥 // 重定向地址，这里整合SSO设置为客户端的login页面是因为SpringSecurity默认登陆页面的URL就是login，在客户端通过授权服务器通过后 // 携带令牌重定向到客户端8081的login页面，自动解析令牌完成登陆。 .redirectUris("http://www.baidu.com") .scopes("all") // 授权范围 .autoApprove(true) // 开启自动授权（不需要进入授权页面手动选择授权） .accessTokenValiditySeconds(60) // 过期时间，单位s .refreshTokenValiditySeconds(86400) // 刷新令牌过期时间 .authorizedGrantTypes("authorization_code","password","refresh_token"); //授权类型: // authorization_code：授权码模式 // password：密码模式 // refresh_token：支持刷新令牌 } /** * 配置单点登陆 * @param security * @throws Exception */ @Override public void configure(AuthorizationServerSecurityConfigurer security) throws Exception { security.tokenKeyAccess("isAuthenticated()"); } }
3、资源服务器配置：定义资源服务器资源权限角色配置。
4、其他：userDetailsService 配置
@Service("userDetailsService")
public class UserService implements UserDetailsService {
@Resource
private PasswordEncoder passwordEncoder;
@Override
public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
// 权限列表，role
List<GrantedAuthority> auths = AuthorityUtils.commaSeparatedStringToAuthorityList("admin1");
return new User(s, passwordEncoder.encode("123456"),auths);
}
}
自定义用户实体类 user ，权限属性全部设为 true。
public class User implements UserDetails { private String username; private String password; private List<GrantedAuthority> authorities; public User(String username, String password, List<GrantedAuthority> authorities) { this.username = username; this.password = password; this.authorities = authorities; } @Override public Collection<? extends GrantedAuthority> getAuthorities() { return authorities; } @Override public String getPassword() { return password; } @Override public String getUsername() { return username; } @Override public boolean isAccountNonExpired() { return true; } @Override public boolean isAccountNonLocked() { return true; } @Override public boolean isCredentialsNonExpired() { return true; } @Override public boolean isEnabled() { return true; } }
资源服务器的资源Controller
同样贴上完整代码，根据图片需要选择
@RestController @RequestMapping("/user") public class UserController { @RequestMapping("/getCurrentUser") public Object getCurrentUser(HttpServletRequest request,Authentication authentication){ String authorization = request.getHeader("Authorization"); String token = authorization.substring(authorization.lastIndexOf("bearer") + 7); return Jwts.parser() .setSigningKey("test_key".getBytes(StandardCharsets.UTF_8)) // 密钥必须和加密所用的一致 .parseClaimsJws(token) .getBody(); // return authentication.getPrincipal(); } }
授权码模式
在上面的授权服务器配置中，已将授权类型设为 授权码模式，所以直接使用上面的配置。
验证
1、获取授权码
访问 http://localhost:8080/oauth/authorize?response_type=code&client_id=client&redirect_uri=http://www.baidu.com&scope=all ，在登陆成功后（因为走的是上面 userDetailsService 的方法，所以用户名任意，密码123456就通过登陆），会重定向授权服务器配置中配置好的 http://www.baidu.com 。并且携带授权服务器返回的授权码 code。
2、获取授权令牌
接下来就可以再次访问 localhost:8080/oauth/token 携带授权码及其他数据来向授权服务器获取授权令牌。
3、通过令牌访问资源服务器的资源，访问资源服务器上资源的 URL，并携带授权令牌。
密码模式
密码模式因为是通过密码直接获取授权令牌，所以不需要先获取授权码，同时需要设置自定义的 userDetailsService 实现类，以及 authenticationManager 组件
1、ServurityConfig里增加配置：
2、授权服务器增加配置：
这样配置是同时支持授权码模式与密码模式
验证
通过密码获取授权令牌
访问资源服务器的资源则和授权码模式验证一样。
整合 redis 将令牌存入 redis
1、引入依赖
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> </dependency>
2、注册 redis 的 tokenStore 组件进容器
@Configuration public class RedisConfig { @Resource private RedisConnectionFactory redisConnectionFactory; @Bean public TokenStore redisTokenStore(){ return new RedisTokenStore(redisConnectionFactory); } }
3、在授权服务器里注册 tokenStore
4、在配置文件里配置 redis 地址密码等。
使用 JWT 作为令牌
1、增加依赖
<dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9.0</version> </dependency>
2、从容器中移除 redis 的 tokenStore 组件，同时想容器中加入 jwt 的 tokenStore 组件，并且配置 jwt 的转换器
完整代码，根据图片需要自取
@Configuration public class JwtTokenStoreConfig { @Resource private JwtAccessTokenConverter jwtAccessTokenConverter; // 保存 token的组件 @Bean public TokenStore jwtTokenStore(){ return new JwtTokenStore(jwtAccessTokenConverter); } // Jwt 转换器，用于将jwt转换成 OAuth2的令牌 @Bean public JwtAccessTokenConverter jwtAccessTokenConverter(){ JwtAccessTokenConverter jwtAccessTokenConverter = new JwtAccessTokenConverter(); // 设置jwt密匙 jwtAccessTokenConverter.setSigningKey("test_key"); return jwtAccessTokenConverter; } // 配置Jwt的附加信息 @Bean public JwtTokenEnhancer jwtTokenEnhancer(){ return new JwtTokenEnhancer(); } }
3、注册进授权服务器
JWT 增加额外信息
1、增加 Jwt 附加信息组件并注册进容器
public class JwtTokenEnhancer implements TokenEnhancer { @Override public OAuth2AccessToken enhance(OAuth2AccessToken oAuth2AccessToken, OAuth2Authentication oAuth2Authentication) { HashMap<String, Object> map = new HashMap<>(); map.put("enhance", "enhancer info"); ((DefaultOAuth2AccessToken)oAuth2AccessToken).setAdditionalInformation(map); return oAuth2AccessToken; } }
2、在授权服务器里配置 jwt 附加信息组件
3、验证，修改资源服务器资源返回的信息
设置过期时间和刷新令牌
在授权服务器里增加配置：
在60s后token令牌（access_token）失效后，可以使用刷新令牌重新获取新的令牌，新的令牌过期时间也是60s。
因为密码模式不支持刷新令牌，所以通过授权码模式使用刷新令牌来获取新的令牌
通过刷新令牌获取令牌
整合SSO（单点登陆）
整合 SSO 后验证的原理就成了下面
各个服务模块都使用同一个授权服务器，也就是图中的认证中心，在第一次访问模块A时会去跳转到授权服务器进行验证，如果通过，那么就会返回给前端一个 token 令牌，以后在访问A或B时，都会携带这个令牌，而验证时都是通过同一个授权服务器验证，所以都会解析通过，进而访问对应的资源。
1、引入依赖
<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-oauth2</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-security</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9.0</version> </dependency>
2、新建一个模块，配置 SSO 访问授权服务器的地址
server.port=8081
#防止Cookie冲突，冲突会导致登陆验证不通过
server.servlet.session.cookie.name=OAUTH2-CLIENT-SESSIONID1
#授权服务器地址
oauth2-server-url: http://localhost:8080
#与授权服务器对应的配置
security.oauth2.client.client-id=client
security.oauth2.client.client-secret=112233
#获取授权码地址
security.oauth2.client.user-authorization-uri=${oauth2-server-url}/oauth/authorize
#获取令牌地址
security.oauth2.client.access-token-uri=${oauth2-server-url}/oauth/token
#获取jwt令牌地址
security.oauth2.resource.jwt.key-uri=${oauth2-server-url}/oauth/token_key
3、增加 SSO 模块的资源
@RestController @RequestMapping("/user") public class UserController { @RequestMapping("/getCurrentUser") public Object getCurrentUser(HttpServletRequest request,Authentication authentication){ return authentication; } }
4、主程序开启 OAuth2 自动配置
5、在授权服务器的配置增加配置
随后访问客户端资源 http://localhost:8081/user/getCurrentUser 就会先跳转到 http://localhost:8080/login ，也就是授权服务器进行授权验证，通过后经重定向回到 http://localhost:8081/login ，也就是客户端的登陆页面，并且携带授权服务器提供的jwt令牌，所以会自动解析通过验证，最后再访问客户端的资源
