Spring Security + JWT基础整合
文章目录
- Spring Security + JWT基础整合
-
- 1 概念
-
- 1.1 无状态、有状态服务
- 1.2 无状态登录的流程
-
- 认证 - 返回token - 携带token请求 - 判断是否有效
- 2 JWT
-
- 2.1 概念
- 2.2 数据格式
- 2.3 JWT交互流程
- 2.4 JWT存在问题
- 3 Spring Security + JWT实战
-
- 3.1 创建项目，编写entity，controller
- 3.2 编写Jwt的过滤器(登录过滤器、验证过滤器)
- 3.3 SpringSecurity的配置
- 3.4 验证效果
-
- 3.4.1 输入正确的用户名、密码，返回token
- 3.4.2 携带token，访问资源
- 3.4.3 输入错误的账户
- 3.4.4 权限管理，尝试越权访问
- 4 用户名密码加盐处理
-
- 4.1 发展历史、概念
- 4.2 MD5算法
- 4.3 实际操作
Spring Security + JWT基础整合
在前后端分离的项目中，登录策略也有不少，JWT 算是目前比较流行的一种解决方案了，本文就和大家来分享一下如何将 Spring Security 和 JWT 结合在一起使用，进而实现前后端分离时的登录解决方案。
1 概念
1.1 无状态、有状态服务
- 有状态服务
服务端每次记录会话的客户端信息，从而可以识别客户端身份，根据用户身份进行请求的处理。如：tomcat中的session
- 服务端保存大量数据，增加服务端压力
- 服务端保存用过户状态，不支持集群化部署
- 无状态服务
服务端不保存客户端请求者的任何信息，客户端每次请求都必须具备自描述信息，通过这些信息识别客户端身份
- 客户端请求不依赖服务端信息，多次请求不需要必须访问到同一台服务器
- 服务端的集群和状态对客户端透明（存在但不干预）
- 服务端可以任意的迁移和伸缩（方便集群化部署）
- 减小服务端存储压力
1.2 无状态登录的流程
认证 - 返回token - 携带token请求 - 判断是否有效
- 客户端发送账户名/密码到服务端进行认证
- 认证通过后，服务端将用户信息你加密并且编码成一个token，返回给客户端
- 以后客户端每次发送请求，都需要携带认证的token
- 服务端对客户端发送来的token进行解密，判断是否有效，并且获取用户登录信息
2 JWT
2.1 概念
JWT，全称是 Json Web Token， 是一种 JSON 风格的轻量级的授权和身份认证规范，可实现无状态、分布式的 Web 应用授权
- JWT 作为一种规范，并没有和某一种语言绑定在一起，常用的 Java 实现是 GitHub 上的开源项目 jjwt，地址如下：https://github.com/jwtk/jjwt
- JWT实际上就是token的一种形式
2.2 数据格式
JWT 包含三部分数据：
①Header：头部，通常头部有两部分信息：
声明类型，这里是JWT
加密算法，自定义
我们会对头部进行 Base64Url 编码（可解码），得到第一部分数据。
②Payload：载荷，就是有效数据，在官方文档中(RFC7519)，这里给了7个示例信息：
iss (issuer)：表示签发人
exp (expiration time)：表示token过期时间
sub (subject)：主题
aud (audience)：受众
nbf (Not Before)：生效时间
iat (Issued At)：签发时间
jti (JWT ID)：编号
这部分也会采用 Base64Url 编码，得到第二部分数据。
③Signature：签名，是整个数据的认证信息。
一般根据前两步的数据，再加上服务的的密钥secret（密钥保存在服务端，不能泄露给客户端），通过 Header 中配置的加密算法生成。用于验证整个数据完整和可靠性。
生成的数据格式如图：
注意，这里的数据通过
.隔开成了三部分，分别对应前面提到的三部分，另外，这里数据是不换行的，图片换行只是为了展示方便而已。
2.3 JWT交互流程
流程如下：
- 应用程序或客户端向授权服务器请求授权
- 获取到授权后，授权服务器会向应用程序返回访问令牌
- 应用程序使用访问令牌来访问受保护的资源（如API）
因为 JWT 签发的 token 中已经包含了用户的身份信息，并且每次请求都会携带，这样服务的就无需保存用户信息，甚至无需去数据库查询，这样就完全符合了 RESTful 的无状态规范。
2.4 JWT存在问题
- 续签问题
传统的cookie+session方案天然支持续签，但jwt因为服务端不保存用户状态，很难完美解决续签问题，如果引入redis，虽然可以解决问题，但是jwt也变得不伦不类了
- 注销问题
因为服务端不保存用户信息，因此可以通过修改secret来实现注销。服务端secret修改后，已经颁发的token就会认证失败，进而达到注销效果
- 密码重置问题
密码重置后，原本的token依然可以访问系统，因此需要强制修改secret
对于第2点和第3点，一般建议不同用户取不同的secret
3 Spring Security + JWT实战
3.1 创建项目，编写entity，controller
①引入依赖
首先我们来创建一个 Spring Boot 项目，创建时需要添加 Spring Security 依赖，创建完成后，添加 jjwt 依赖，完整的 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>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>
<!--lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
②创建实体类User
@Data
public class User implements UserDetails { //实现UserDeails接口
private String username;
private String password;
private List<GrantedAuthority> authorities;
@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
public class HelloController {
@GetMapping("/hello")
public String hello() {
return "hello jwt !";
}
@GetMapping("/admin")
public String admin() {
return "hello admin !";
}
}
HelloController 很简单，这里有两个接口，设计是 /hello 接口可以被具有 user 角色的用户访问，而 /admin 接口则可以被具有 admin 角色的用户访问。
3.2 编写Jwt的过滤器(登录过滤器、验证过滤器)
- 一个是用户登录的过滤器，在用户的登录的过滤器中校验用户是否登录成功，如果登录成功，则生成一个token返回给客户端，登录失败则给前端一个登录失败的提示。
- 第二个过滤器则是当其他请求发送来，校验token的过滤器，如果校验成功，就让请求继续执行。
①JwtLoginFilter登录过滤器：
/**
* @author zhouYi
* @description 用户名密码校验过滤器
* @date 2023/2/8 9:03
*/
public class JwtLoginFilter extends AbstractAuthenticationProcessingFilter {
public JwtLoginFilter(String defaultFilterProcessesUrl, AuthenticationManager authenticationManager) {
super(new AntPathRequestMatcher(defaultFilterProcessesUrl));
setAuthenticationManager(authenticationManager);
}
@Override
public Authentication attemptAuthentication(HttpServletRequest req, HttpServletResponse resp) throws AuthenticationException, IOException, ServletException, IOException {
User user = new ObjectMapper().readValue(req.getInputStream(), User.class);
return getAuthenticationManager().authenticate(new UsernamePasswordAuthenticationToken(user.getUsername(), user.getPassword()));
}
@Override
protected void successfulAuthentication(HttpServletRequest req, HttpServletResponse resp, FilterChain chain, Authentication authResult) throws IOException, ServletException {
Collection<? extends GrantedAuthority> authorities = authResult.getAuthorities();
StringBuffer as = new StringBuffer();
for (GrantedAuthority authority : authorities) {
as.append(authority.getAuthority())
.append(",");
}
String jwt = Jwts.builder()
.claim("authorities", as)//配置用户角色
.setSubject(authResult.getName())
.setExpiration(new Date(System.currentTimeMillis() + 10 * 60 * 1000))
.signWith(SignatureAlgorithm.HS256,"wRJSMeKKF2QT4fwpMeJf36POk6yJV8sVHsowhqaoWOSHAOJAKOXHC223W")
.compact();
resp.setContentType("application/json;charset=utf-8");
PrintWriter out = resp.getWriter();
out.write(new ObjectMapper().writeValueAsString(jwt));
out.flush();
out.close();
}
@Override
protected void unsuccessfulAuthentication(HttpServletRequest req, HttpServletResponse resp, AuthenticationException failed) throws IOException, ServletException {
resp.setContentType("application/json;charset=utf-8");
PrintWriter out = resp.getWriter();
out.write("登录失败!");
out.flush();
out.close();
}
}
- 我们自定义的JwtLoginFilter继承AbstractAuthenticationProcessingFilter并实现三个默认方法
- attemptAuthentication 方法中，从登录参数中取出用户名密码，然后调用AuthenticationManager.authenticate() 方法进行校验
- 如果第二步校验成功，就会来到 successfulAuthentication 回调中，在 successfulAuthentication 方法中，将用户角色遍历然后用一个 , 连接起来，然后再利用 Jwts 去生成 token，按照代码的顺序，生成过程一共配置了四个参数，分别是用户角色、主题、过期时间以及加密算法和密钥，然后将生成的 token 写出到客户端。
- 第二步如果校验失败就会来到 unsuccessfulAuthentication 方法中，在这个方法中返回一个错误提示给客户端即可。
其中
wRJSMeKKF2QT4fwpMeJf36POk6yJV8sVHsowhqaoWOSHAOJAKOXHC223W是我们的盐值，SignatureAlgorithm.HS256的签名算法表示我们的盐值（密钥）必须是超过256bit的
②token校验过滤器JwtFilter :
/**
* @author zhouYi
* @description Token校验过滤器
* @date 2023/2/8 9:12
*/
public class JwtFilter extends GenericFilterBean {
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws ServletException, IOException {
HttpServletRequest req = (HttpServletRequest) servletRequest;
String jwtToken = req.getHeader("authorization");
System.out.println(jwtToken);
Claims claims = Jwts.parser().setSigningKey("wRJSMeKKF2QT4fwpMeJf36POk6yJV8sVHsowhqaoWOSHAOJAKOXHC223W").parseClaimsJws(jwtToken.replace("Bearer",""))
.getBody();
String username = claims.getSubject();//获取当前登录用户名
List<GrantedAuthority> authorities = AuthorityUtils.commaSeparatedStringToAuthorityList((String) claims.get("authorities"));
UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(username, null, authorities);
SecurityContextHolder.getContext().setAuthentication(token);
filterChain.doFilter(req,servletResponse);
}
}
关于这个过滤器，我说如下几点：
- 首先从请求头中提取出 authorization 字段，这个字段对应的 value 就是用户的 token。
- 将提取出来的 token 字符串转换为一个 Claims 对象，再从 Claims 对象中提取出当前用户名和用户角色，创建一个 UsernamePasswordAuthenticationToken 放到当前的 Context 中，然后执行过滤链使请求继续执行下去。
3.3 SpringSecurity的配置
@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
PasswordEncoder passwordEncoder() {
return NoOpPasswordEncoder.getInstance();
}
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.inMemoryAuthentication().withUser("admin")
.password("123").roles("admin")
.and()
.withUser("sang")
.password("456")
.roles("user");
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests()
.antMatchers("/hello").hasRole("user")
.antMatchers("/admin").hasRole("admin")
.antMatchers(HttpMethod.POST, "/login").permitAll()
.anyRequest().authenticated()
.and()
.addFilterBefore(new JwtLoginFilter("/login",authenticationManager()),UsernamePasswordAuthenticationFilter.class)
.addFilterBefore(new JwtFilter(),UsernamePasswordAuthenticationFilter.class)
.csrf().disable();
}
}
- 简单起见，这里我并未对密码进行加密，因此配置了 NoOpPasswordEncoder 的实例。
- 简单起见，这里并未连接数据库，我直接在内存中配置了两个用户，两个用户具备不同的角色。
- 配置路径规则时， /hello 接口必须要具备 user 角色才能访问， /admin 接口必须要具备 admin 角色才能访问，POST 请求并且是 /login 接口则可以直接通过，其他接口必须认证后才能访问。
- 最后配置上两个自定义的过滤器并且关闭掉 csrf 保护。
3.4 验证效果
3.4.1 输入正确的用户名、密码，返回token
登录成功后返回的字符串就是经过 base64url 转码的 token，一共有三部分，通过一个 . 隔开，
header.payload.signature
可以看到，我们设置信息，由于 base64 并不是加密方案，只是一种编码方案，因此，不建议将敏感的用户信息放到 token 中。
jwt官网：https://jwt.io/
解码如下：
3.4.2 携带token，访问资源
接下来再去访问 /hello 接口，注意认证方式选择 Bearer Token(持有者令牌，是一种安全令牌)，Token 值为刚刚获取到的值，如下：
需要注意，我代码中的token是设置了有效期的，如果过期了将无法成功访问资源，需要重新登录来获取新的token
3.4.3 输入错误的账户
3.4.4 权限管理，尝试越权访问
用普通用户的token去访问管理员的资源
使用管理员的token访问：
对应token：eyJhbGciOiJIUzI1NiJ9.eyJhdXRob3JpdGllcyI6IlJPTEVfYWRtaW4sIiwic3ViIjoiYWRtaW4iLCJleHAiOjE2NzU4MjMwMTl9.1_5MdZS5D-7-_kD0fq_uataABduU8UDm7VHV1h6aYJo
4 用户名密码加盐处理
4.1 发展历史、概念
①第一代的用户名密码是：直接存储明文，如果被黑客攻击，那么黑客将可以直接获取到正确的用户名密码
②第二代的用户名密码是：MD5加密处理，数据库中存储的是加密之后的密码，就算被黑客攻击，那么黑客得到的也只是加密后的密码。但是随着密码字典的流行，就算md5无法被解析，但是黑客可以通过收集明文密码与md5加密后的值，做成一个md5密码字典，这样的话，如果我们的密码简单，黑客便可以直接进行暴力破解。复杂度：O（M*N），直接去密码库进行比对即可
③第三代的用户名密码是：MD5+盐值。随机生成一系列的值，叫作salt，放在用户名和密码的开头，中间或者最后，这个自己服务器约定即可，然后将新生成的密码用MD5运算，得到新的密码，存入数据库中，记得salt也要存入数据库中。这样在用户下次登录的时候也可以验证。破解复杂度：O(M*N*N)，多了一个盐值选择。
比如说我有一个数据字典库有N = 500W条密码。泄漏的数据库里有M = 30万条代码。如果没加盐，我得到泄漏的数据库后，一一和数据字典比对就好，碰到相同的，我就知道了原来的密码了。全部比对完的时间复杂度是O(M*N)。
- 如果加盐后，有30万条盐。我要破解一条的代价是 我要从数据字典里选一条明文密码，在泄漏的数据库中选一条盐，匹配进行MD5运算，然后在数据字典里查询。时间复杂度是O(N)，一共要进行MN次比对，所以时间复杂度是O(MN*N)。破解难度大大提高。
4.2 MD5算法
public static String MD5(String key) {
char hexDigits[] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
};
try {
byte[] btInput = key.getBytes();
// 获得MD5摘要算法的 MessageDigest 对象
MessageDigest mdInst = MessageDigest.getInstance("MD5");
// 使用指定的字节更新摘要
mdInst.update(btInput);
// 获得密文
byte[] md = mdInst.digest();
// 把密文转换成十六进制的字符串形式
int j = md.length;
char str[] = new char[j * 2];
int k = 0;
for (int i = 0; i < j; i++) {
byte byte0 = md[i];
str[k++] = hexDigits[byte0 >>> 4 & 0xf];
str[k++] = hexDigits[byte0 & 0xf];
}
return new String(str);
} catch (Exception e) {
logger.error("生成MD5失败", e);
return null;
}
}
4.3 实际操作
user = new User();
user.setName(username);
user.setSalt(UUID.randomUUID().toString().substring(0, 5)); //加盐
String head = String.format("http://images.nowcoder.com/head/%dt.png", new Random().nextInt(1000));
user.setHeadUrl(head);
user.setPassword(ToutiaoUtil.MD5(password+user.getSalt())); //MD5运算
userDAO.addUser(user);
参考文章：
https://cloud.tencent.com/developer/article/1555599
https://blog.csdn.net/qq_31617121/article/details/79156063