实战篇：Security+JWT组合拳 | 附源码

绝地灬酷狼 2023-10-03 09:55 12阅读 0赞

Good morning, everyone！

之前我们已经说过用Shiro和JWT来实现身份认证和用户授权，今天我们再来说一下Security和JWT的组合拳。

简介

先赘述一下身份认证和用户授权：

  • 用户认证（Authentication）：系统通过校验用户提供的用户名和密码来验证该用户是否为系统中的合法主体，即是否可以访问该系统；
  • 用户授权（Authorization）：系统为用户分配不同的角色，以获取对应的权限，即验证该用户是否有权限执行该操作；

Web应用的安全性包括用户认证和用户授权两个部分，而Spring Security（以下简称Security）基于Spring框架，正好可以完整解决该问题。

它的真正强大之处在于它可以轻松扩展以满足自定义要求。

原理

Security可以看做是由一组filter过滤器链组成的权限认证。它的整个工作流程如下所示：
d13ed9f0fec8d59df10effad5e932a01.png
图中绿色认证方式是可以配置的，橘黄色和蓝色的位置不可更改：

  • FilterSecurityInterceptor：最后的过滤器，它会决定当前的请求可不可以访问Controller
  • ExceptionTranslationFilter：异常过滤器，接收到异常消息时会引导用户进行认证；

实战

项目准备

我们使用Spring Boot框架来集成。

1.pom文件引入的依赖

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter</artifactId>
  4. </dependency>
  6. <dependency>
  7.     <groupId>org.springframework.boot</groupId>
  8.     <artifactId>spring-boot-starter-web</artifactId>
  9.     <exclusions>
  10.         <exclusion>
  11.             <groupId>org.springframework.boot</groupId>
  12.             <artifactId>spring-boot-starter-tomcat</artifactId>
  13.         </exclusion>
  14.     </exclusions>
  15. </dependency>
  17. <dependency>
  18.     <groupId>org.springframework.boot</groupId>
  19.     <artifactId>spring-boot-starter-undertow</artifactId>
  20. </dependency>
  22. <dependency>
  23.     <groupId>mysql</groupId>
  24.     <artifactId>mysql-connector-java</artifactId>
  25. </dependency>
  27. <dependency>
  28.     <groupId>com.baomidou</groupId>
  29.     <artifactId>mybatis-plus-boot-starter</artifactId>
  30.     <version>3.4.0</version>
  31. </dependency>
  33. <dependency>
  34.     <groupId>org.projectlombok</groupId>
  35.     <artifactId>lombok</artifactId>
  36. </dependency>
  38. <!-- 阿里JSON解析器 -->
  39. <dependency>
  40.     <groupId>com.alibaba</groupId>
  41.     <artifactId>fastjson</artifactId>
  42.     <version>1.2.74</version>
  43. </dependency>
  45. <dependency>
  46.     <groupId>joda-time</groupId>
  47.     <artifactId>joda-time</artifactId>
  48.     <version>2.10.6</version>
  49. </dependency>
  51. <dependency>
  52.     <groupId>org.springframework.boot</groupId>
  53.     <artifactId>spring-boot-starter-test</artifactId>
  54. </dependency>

2.application.yml配置

  1. spring:
  2.   application:
  3.     name: securityjwt
  4.   datasource:
  5.     driver-class-name: com.mysql.cj.jdbc.Driver
  6.     url: jdbc:mysql://127.0.0.1:3306/cheetah?characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
  7.     username: root
  8.     password: 123456
  10. server:
  11.   port: 8080
  13. mybatis:
  14.   mapper-locations: classpath:mapper/*.xml
  15.   type-aliases-package: com.itcheetah.securityjwt.entity
  16.   configuration:
  17.     map-underscore-to-camel-case: true
  19. rsa:
  20.   key:
  21.     pubKeyFile: C:\Users\Desktop\jwt\id_key_rsa.pub
  22.     priKeyFile: C:\Users\Desktop\jwt\id_key_rsa

3.SQL文件

  1. /**
  2. * sys_user_info
  3. **/
  5. SET NAMES utf8mb4;
  6. SET FOREIGN_KEY_CHECKS = 0;
  8. -- ----------------------------
  9. -- Table structure for sys_user_info
  10. -- ----------------------------
  11. DROP TABLE IF EXISTS `sys_user_info`;
  12. CREATE TABLE `sys_user_info`  (
  13.   `id` bigint(20) NOT NULL AUTO_INCREMENT,
  14.   `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  15.   `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  16.   PRIMARY KEY (`id`) USING BTREE
  17. ) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
  19. SET FOREIGN_KEY_CHECKS = 1;
  22. /**
  23. * product_info
  24. **/
  26. SET NAMES utf8mb4;
  27. SET FOREIGN_KEY_CHECKS = 0;
  29. -- ----------------------------
  30. -- Table structure for product_info
  31. -- ----------------------------
  32. DROP TABLE IF EXISTS `product_info`;
  33. CREATE TABLE `product_info`  (
  34.   `id` bigint(20) NOT NULL AUTO_INCREMENT,
  35.   `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  36.   `price` decimal(10, 4) NULL DEFAULT NULL,
  37.   `create_date` datetime(0) NULL DEFAULT NULL,
  38.   `update_date` datetime(0) NULL DEFAULT NULL,
  39.   PRIMARY KEY (`id`) USING BTREE
  40. ) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
  42. SET FOREIGN_KEY_CHECKS = 1;

引入依赖

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-security</artifactId>
  4. </dependency>
  6. <!--Token生成与解析-->
  7. <dependency>
  8.     <groupId>io.jsonwebtoken</groupId>
  9.     <artifactId>jjwt</artifactId>
  10.     <version>0.9.1</version>
  11. </dependency>

引入之后启动项目，会有如图所示：
f3657c4ac1e6f76abaf9fe05d4079914.png
其中用户名为user，密码为上图中的字符串。

SecurityConfig类

  1. //开启全局方法安全性
  2. @EnableGlobalMethodSecurity(prePostEnabled=true, securedEnabled=true)
  3. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  6.     //认证失败处理类
  7.     @Autowired
  8.     private AuthenticationEntryPointImpl unauthorizedHandler;
  10.     //提供公钥私钥的配置类
  11.     @Autowired
  12.     private RsaKeyProperties prop;
  14.     @Autowired
  15.     private UserInfoService userInfoService;
  17.     @Override
  18.     protected void configure(HttpSecurity httpSecurity) throws Exception {
  20.         httpSecurity
  21.                 // CSRF禁用，因为不使用session
  22.                 .csrf().disable()
  23.                 // 认证失败处理类
  24.                 .exceptionHandling().authenticationEntryPoint(unauthorizedHandler).and()
  25.                 // 基于token，所以不需要session
  26.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
  27.                 // 过滤请求
  28.                 .authorizeRequests()
  29.                 .antMatchers(
  30.                         HttpMethod.GET,
  31.                         "/*.html",
  32.                         "/**/*.html",
  33.                         "/**/*.css",
  34.                         "/**/*.js"
  35.                 ).permitAll()
  36.                 // 除上面外的所有请求全部需要鉴权认证
  37.                 .anyRequest().authenticated()
  38.                 .and()
  39.                 .headers().frameOptions().disable();
  40.         // 添加JWT filter
  41.         httpSecurity.addFilter(new TokenLoginFilter(super.authenticationManager(), prop))
  42.                 .addFilter(new TokenVerifyFilter(super.authenticationManager(), prop));
  43.     }
  45.     //指定认证对象的来源
  46.     public void configure(AuthenticationManagerBuilder auth) throws Exception {
  49.         auth.userDetailsService(userInfoService)
  50.         //从前端传递过来的密码就会被加密，所以从数据库
  51.         //查询到的密码必须是经过加密的，而这个过程都是
  52.         //在用户注册的时候进行加密的。
  53.         .passwordEncoder(passwordEncoder());
  54.     }
  56.     //密码加密
  57.     @Bean
  58.     public BCryptPasswordEncoder passwordEncoder(){
  60.         return new BCryptPasswordEncoder();
  61.     }
  62. }

拦截规则

  • anyRequest：匹配所有请求路径
  • access：SpringEl表达式结果为true时可以访问
  • anonymous：匿名可以访问
  • `denyAll：用户不能访问
  • fullyAuthenticated：用户完全认证可以访问（非remember-me下自动登录）
  • hasAnyAuthority：如果有参数，参数表示权限，则其中任何一个权限可以访问
  • hasAnyRole：如果有参数，参数表示角色，则其中任何一个角色可以访问
  • hasAuthority：如果有参数，参数表示权限，则其权限可以访问
  • hasIpAddress：如果有参数，参数表示IP地址，如果用户IP和参数匹配，则可以访问
  • hasRole：如果有参数，参数表示角色，则其角色可以访问
  • permitAll：用户可以任意访问
  • rememberMe：允许通过remember-me登录的用户访问
  • authenticated：用户登录后可访问
认证失败处理类
  1. /**
  2.  *  返回未授权
  3.  */
  4. @Component
  5. public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint, Serializable {
  8.     private static final long serialVersionUID = -8970718410437077606L;
  10.     @Override
  11.     public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException e)
  12.             throws IOException {
  14.         int code = HttpStatus.UNAUTHORIZED;
  15.         String msg = "认证失败，无法访问系统资源，请先登陆";
  16.         ServletUtils.renderString(response, JSON.toJSONString(AjaxResult.error(code, msg)));
  17.     }
  18. }

认证流程

自定义认证过滤器
  1. public class TokenLoginFilter extends UsernamePasswordAuthenticationFilter {
  4.     private AuthenticationManager authenticationManager;
  6.     private RsaKeyProperties prop;
  8.     public TokenLoginFilter(AuthenticationManager authenticationManager, RsaKeyProperties prop) {
  10.         this.authenticationManager = authenticationManager;
  11.         this.prop = prop;
  12.     }
  14.     /**
  15.      * @author cheetah
  16.      * @description 登陆验证
  17.      * @date 2021/6/28 16:17
  18.      * @Param [request, response]
  19.      * @return org.springframework.security.core.Authentication
  20.      **/
  21.     public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
  23.         try {
  25.             UserPojo sysUser = new ObjectMapper().readValue(request.getInputStream(), UserPojo.class);
  26.             UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(sysUser.getUsername(), sysUser.getPassword());
  27.             return authenticationManager.authenticate(authRequest);
  28.         }catch (Exception e){
  30.             try {
  32.                 response.setContentType("application/json;charset=utf-8");
  33.                 response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
  34.                 PrintWriter out = response.getWriter();
  35.                 Map resultMap = new HashMap();
  36.                 resultMap.put("code", HttpServletResponse.SC_UNAUTHORIZED);
  37.                 resultMap.put("msg", "用户名或密码错误！");
  38.                 out.write(new ObjectMapper().writeValueAsString(resultMap));
  39.                 out.flush();
  40.                 out.close();
  41.             }catch (Exception outEx){
  43.                 outEx.printStackTrace();
  44.             }
  45.             throw new RuntimeException(e);
  46.         }
  47.     }
  50.     /**
  51.      * @author cheetah
  52.      * @description 登陆成功回调
  53.      * @date 2021/6/28 16:17
  54.      * @Param [request, response, chain, authResult]
  55.      * @return void
  56.      **/
  57.     public void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
  59.         UserPojo user = new UserPojo();
  60.         user.setUsername(authResult.getName());
  61.         user.setRoles((List<RolePojo>)authResult.getAuthorities());
  62.         //通过私钥进行加密：token有效期一天
  63.         String token = JwtUtils.generateTokenExpireInMinutes(user, prop.getPrivateKey(), 24 * 60);
  64.         response.addHeader("Authorization", "Bearer "+token);
  65.         try {
  67.             response.setContentType("application/json;charset=utf-8");
  68.             response.setStatus(HttpServletResponse.SC_OK);
  69.             PrintWriter out = response.getWriter();
  70.             Map resultMap = new HashMap();
  71.             resultMap.put("code", HttpServletResponse.SC_OK);
  72.             resultMap.put("msg", "认证通过！");
  73.             resultMap.put("token", token);
  74.             out.write(new ObjectMapper().writeValueAsString(resultMap));
  75.             out.flush();
  76.             out.close();
  77.         }catch (Exception outEx){
  79.             outEx.printStackTrace();
  80.         }
  81.     }
  82. }
流程

Security默认登录路径为/login，当我们调用该接口时，它会调用上边的attemptAuthentication方法；
74b88fa270d61bd26cd62414cd4d096b.png
b85a345b378631ec784d225790d7a3b6.png
157b99da015195c5f062dbd35f6cdd98.png
4c6c3c0cf0c1bdfbabdab39fcebe73a5.png
所以我们要自定义UserInfoService继承UserDetailsService实现loadUserByUsername方法；

  1. public interface UserInfoService extends UserDetailsService {
  4. }
  6. @Service
  7. @Transactional
  8. public class UserInfoServiceImpl implements UserInfoService {
  11.     @Autowired
  12.     private SysUserInfoMapper userInfoMapper;
  14.     @Override
  15.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  17.         UserPojo user = userInfoMapper.queryByUserName(username);
  18.         return user;
  19.     }
  20. }

其中的loadUserByUsername返回的是UserDetails类型，所以UserPojo继承UserDetails类

  1. @Data
  2. public class UserPojo implements UserDetails {
  5.     private Integer id;
  7.     private String username;
  9.     private String password;
  11.     private Integer status;
  13.     private List<RolePojo> roles;
  15.     @JsonIgnore
  16.     @Override
  17.     public Collection<? extends GrantedAuthority> getAuthorities() {
  19.         //理想型返回 admin 权限，可自已处理这块
  20.         List<SimpleGrantedAuthority> auth = new ArrayList<>();
  21.         auth.add(new SimpleGrantedAuthority("ADMIN"));
  22.         return auth;
  23.     }
  25.     @Override
  26.     public String getPassword() {
  28.         return this.password;
  29.     }
  31.     @Override
  32.     public String getUsername() {
  34.         return this.username;
  35.     }
  37.     /**
  38.      * 账户是否过期
  39.      **/
  40.     @JsonIgnore
  41.     @Override
  42.     public boolean isAccountNonExpired() {
  44.         return true;
  45.     }
  47.     /**
  48.      * 是否禁用
  49.      */
  50.     @JsonIgnore
  51.     @Override
  52.     public boolean isAccountNonLocked() {
  54.         return true;
  55.     }
  57.     /**
  58.      * 密码是否过期
  59.      */
  60.     @JsonIgnore
  61.     @Override
  62.     public boolean isCredentialsNonExpired() {
  64.         return true;
  65.     }
  67.     /**
  68.      * 是否启用
  69.      */
  70.     @JsonIgnore
  71.     @Override
  72.     public boolean isEnabled() {
  74.         return true;
  75.     }
  76. }

当认证通过之后会在SecurityContext中设置Authentication对象，回调调用successfulAuthentication方法返回token信息，
7db8e465adb8c86aa6ce8aacb22f1943.png

整体流程图如下

bdbe7accbb4b1637981f7a1b977534de.png

鉴权流程

自定义token过滤器
  1. public class TokenVerifyFilter extends BasicAuthenticationFilter {
  3.     private RsaKeyProperties prop;
  5.     public TokenVerifyFilter(AuthenticationManager authenticationManager, RsaKeyProperties prop) {
  7.         super(authenticationManager);
  8.         this.prop = prop;
  9.     }
  11.     public void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
  13.         String header = request.getHeader("Authorization");
  14.         if (header == null || !header.startsWith("Bearer ")) {
  16.             //如果携带错误的token，则给用户提示请登录！
  17.             chain.doFilter(request, response);
  18.         } else {
  20.             //如果携带了正确格式的token要先得到token
  21.             String token = header.replace("Bearer ", "");
  22.             //通过公钥进行解密：验证tken是否正确
  23.             Payload<UserPojo> payload = JwtUtils.getInfoFromToken(token, prop.getPublicKey(), UserPojo.class);
  24.             UserPojo user = payload.getUserInfo();
  25.             if(user!=null){
  27.                 UsernamePasswordAuthenticationToken authResult = new UsernamePasswordAuthenticationToken(user.getUsername(), null, user.getAuthorities());
  28.                 //将认证信息存到安全上下文中
  29.                 SecurityContextHolder.getContext().setAuthentication(authResult);
  30.                 chain.doFilter(request, response);
  31.             }
  32.         }
  33.     }
  34. }

当我们访问时需要在header中携带token信息
90b47a67ad87b05611f4b0adbbd0c288.png

至于关于文中JWT生成token和RSA生成公钥、私钥的部分，可在源码中查看，回复“sjwt”可获取完整源码呦！

以上就是今天的全部内容了，如果你有不同的意见或者更好的idea，欢迎联系阿Q，添加阿Q可以加入技术交流群参与讨论呦！

后台留言领取 java 干货资料:学习笔记与大厂面试题

发表评论

表情：
评论列表 （有 0 条评论，12人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Redis未授权+CVE-2019-0708组合拳利用

    0x01 简介 本次测试为实战测试，测试环境是授权项目中的一部分，敏感信息内容已做打码处理，仅供讨论学习。请大家测试的时候，务必取得授权。 拿到授权项目的时候，客户只给

    清疚清疚/ 0 赞/ 128 阅读