Spring Security + JWT基础整合_springsecurity+jwt

Spring Security + JWT基础整合

在前后端分离的项目中，登录策略也有不少，JWT 算是目前比较流行的一种解决方案了，本文就和大家来分享一下如何将 Spring Security 和 JWT 结合在一起使用，进而实现前后端分离时的登录解决方案。

1 概念

1.1 无状态、有状态服务

• 有状态服务

服务端每次记录会话的客户端信息，从而可以识别客户端身份，根据用户身份进行请求的处理。如：tomcat中的session

• 服务端保存大量数据，增加服务端压力
• 服务端保存用过户状态，不支持集群化部署

• 无状态服务

服务端不保存客户端请求者的任何信息，客户端每次请求都必须具备自描述信息，通过这些信息识别客户端身份

• 客户端请求不依赖服务端信息，多次请求不需要必须访问到同一台服务器
• 服务端的集群和状态对客户端透明（存在但不干预）
• 服务端可以任意的迁移和伸缩（方便集群化部署）
• 减小服务端存储压力

1.2 无状态登录的流程

认证 - 返回token - 携带token请求 - 判断是否有效

1. 客户端发送账户名/密码到服务端进行认证
2. 认证通过后，服务端将用户信息你加密并且编码成一个token，返回给客户端
3. 以后客户端每次发送请求，都需要携带认证的token
4. 服务端对客户端发送来的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存在问题

1. 续签问题

传统的cookie+session方案天然支持续签，但jwt因为服务端不保存用户状态，很难完美解决续签问题，如果引入redis，虽然可以解决问题，但是jwt也变得不伦不类了

2. 注销问题

因为服务端不保存用户信息，因此可以通过修改secret来实现注销。服务端secret修改后，已经颁发的token就会认证失败，进而达到注销效果

3. 密码重置问题

密码重置后，原本的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>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

②创建实体类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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

③创建controller层

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "hello jwt !";
    }
    @GetMapping("/admin")
    public String admin() {
        return "hello admin !";
    }
}
1
2
3
4
5
6
7
8
9
10
11

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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

1. 我们自定义的JwtLoginFilter继承AbstractAuthenticationProcessingFilter并实现三个默认方法
2. attemptAuthentication 方法中，从登录参数中取出用户名密码，然后调用AuthenticationManager.authenticate() 方法进行校验
3. 如果第二步校验成功，就会来到 successfulAuthentication 回调中，在 successfulAuthentication 方法中，将用户角色遍历然后用一个 , 连接起来，然后再利用 Jwts 去生成 token，按照代码的顺序，生成过程一共配置了四个参数，分别是用户角色、主题、过期时间以及加密算法和密钥，然后将生成的 token 写出到客户端。
4. 第二步如果校验失败就会来到 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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

关于这个过滤器，我说如下几点：

• 首先从请求头中提取出 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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

1. 简单起见，这里我并未对密码进行加密，因此配置了 NoOpPasswordEncoder 的实例。
2. 简单起见，这里并未连接数据库，我直接在内存中配置了两个用户，两个用户具备不同的角色。
3. 配置路径规则时， /hello 接口必须要具备 user 角色才能访问， /admin 接口必须要具备 admin 角色才能访问，POST 请求并且是 /login 接口则可以直接通过，其他接口必须认证后才能访问。
4. 最后配置上两个自定义的过滤器并且关闭掉 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;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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);
1
2
3
4
5
6
7

参考文章：
https://cloud.tencent.com/developer/article/1555599
https://blog.csdn.net/qq_31617121/article/details/79156063