Spring Security + JWT基础整合

淩亂°似流年 2024-03-27 14:26 0阅读 0赞

#### 文章目录 ####

*  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请求 - 判断是否有效 #####

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 中配置的加密算法生成。用于验证整个数据完整和可靠性。

生成的数据格式如图：  
![在这里插入图片描述][91fc7053e1dc4c12814e00dadf6b930b.png]

> 注意，这里的数据通过 `.`隔开成了三部分，分别对应前面提到的三部分，另外，这里数据是不换行的，图片换行只是为了展示方便而已。

#### 2.3 JWT交互流程 ####

![在这里插入图片描述][dc71799062bc473abf04a5d0aa5ce3dd.png]  
流程如下：

*  应用程序或客户端向授权服务器请求授权
 *  获取到授权后，授权服务器会向应用程序返回访问令牌
 *  应用程序使用访问令牌来访问受保护的资源（如API）

> 因为 JWT 签发的 token 中已经包含了用户的身份信息，并且每次请求都会携带，这样服务的就无需保存用户信息，甚至无需去数据库查询，这样就完全符合了 RESTful 的无状态规范。

#### 2.4 JWT存在问题 ####

1.  续签问题

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

1.  注销问题

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

1.  密码重置问题

> 密码重置后，原本的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>
    
    	
    <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();
        }
    }

> 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);
        }
    }

> 关于这个过滤器，我说如下几点：
> 
>  *  首先从请求头中提取出 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.  简单起见，这里我并未对密码进行加密，因此配置了 NoOpPasswordEncoder 的实例。
2.  简单起见，这里并未连接数据库，我直接在内存中配置了两个用户，两个用户具备不同的角色。
3.  配置路径规则时， /hello 接口必须要具备 user 角色才能访问， /admin 接口必须要具备 admin 角色才能访问，POST 请求并且是 /login 接口则可以直接通过，其他接口必须认证后才能访问。
4.  最后配置上两个自定义的过滤器并且关闭掉 csrf 保护。

#### 3.4 验证效果 ####

##### 3.4.1 输入正确的用户名、密码，返回token #####

![在这里插入图片描述][0d38299dec794e0f96ea54fe4db69482.png]

> 登录成功后返回的字符串就是经过 base64url 转码的 token，一共有三部分，通过一个 . 隔开，`header.payload.signature`  
> 可以看到，我们设置信息，由于 base64 并不是加密方案，只是一种编码方案，因此，不建议将敏感的用户信息放到 token 中。

jwt官网：https://jwt.io/  
解码如下：  
![在这里插入图片描述][8ab763613b714f309d6df24df4889c6b.png]

##### 3.4.2 携带token，访问资源 #####

> 接下来再去访问 /hello 接口，注意认证方式选择 Bearer Token(持有者令牌，是一种安全令牌)，Token 值为刚刚获取到的值，如下：

![在这里插入图片描述][d7954cd7ed4a439b94744bde887b1433.png]

> 需要注意，我代码中的token是设置了有效期的，如果过期了将无法成功访问资源，需要重新登录来获取新的token

##### 3.4.3 输入错误的账户 #####

![在这里插入图片描述][a94cfa91f5e2416dac688db8a32a235c.png]

##### 3.4.4 权限管理，尝试越权访问 #####

> 用普通用户的token去访问管理员的资源

![在这里插入图片描述][a8990a04afc94ed3a4aeaefb1f394c59.png]

> 使用管理员的token访问：

![在这里插入图片描述][1c5934caed8b4ee28da757bb9e5c0a09.png]  
对应token：`eyJhbGciOiJIUzI1NiJ9.eyJhdXRob3JpdGllcyI6IlJPTEVfYWRtaW4sIiwic3ViIjoiYWRtaW4iLCJleHAiOjE2NzU4MjMwMTl9.1_5MdZS5D-7-_kD0fq_uataABduU8UDm7VHV1h6aYJo`

![在这里插入图片描述][747fbfe3f7d7473f8e427ef8f201562e.png]

### 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)，一共要进行M*N次比对，所以时间复杂度是O(M*N\*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

[91fc7053e1dc4c12814e00dadf6b930b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/67180a8e76cd40c6a1ba635db945b5ee.png
[dc71799062bc473abf04a5d0aa5ce3dd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/f0ec12ad8ce040888b78d02f5fa6ba57.png
[0d38299dec794e0f96ea54fe4db69482.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/83a1bd9349cd4950a548f22c47174530.png
[8ab763613b714f309d6df24df4889c6b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/51199d84eacc4b2da4cdc6039fd4bdd3.png
[d7954cd7ed4a439b94744bde887b1433.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/ec6452e403ac407e99e5cf0a94f20ee9.png
[a94cfa91f5e2416dac688db8a32a235c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/09ba9c0ab3f7414a90f593a2a1b80144.png
[a8990a04afc94ed3a4aeaefb1f394c59.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/e9d67b46edbb4bbf915719dcc9ffabcb.png
[1c5934caed8b4ee28da757bb9e5c0a09.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/8236a5fd63884be8bb760b8cafaaa564.png
[747fbfe3f7d7473f8e427ef8f201562e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/28c9202747bc4ba3903165ab5122b37f.png