SpringBoot中使用Shiro和JWT做认证和鉴权

转x33g5p2x  于2021-12-12 转载在 Spring  
字(22.7k)|赞(0)|评价(0)|浏览(515)

最近新做的项目中使用了shiro和jwt来做简单的权限验证，在和springboot集成的过程中碰到了不少坑。做完之后对shiro的体系架构了解的也差不多了，现在把中间需要注意的点放出来，给大家做个参考。
相对于spring security来说，shiro出来较早，框架也相对简单。后面会另起一篇文章对这两个框架做一个简单的对比。

Shiro的关注点

首先看一下shiro中需要关注的几个概念。

  • SecurityManager，可以理解成控制中心，所有请求最终基本上都通过它来代理转发，一般我们程序中不需要直接跟他打交道。
  • Subject ，请求主体。比如登录用户，比如一个被授权的app。在程序中任何地方都可以通过SecurityUtils.getSubject()获取到当前的subject。subject中可以获取到Principal，这个是subject的标识，比如登陆用户的用户名或者id等，shiro不对值做限制。但是在登录和授权过程中，程序需要通过principal来识别唯一的用户。
  • Realm，这个实在不知道怎么翻译合适。通俗一点理解就是realm可以访问安全相关数据，提供统一的数据封装来给上层做数据校验。shiro的建议是每种数据源定义一个realm，比如用户数据存在数据库可以使用JdbcRealm；存在属性配置文件可以使用PropertiesRealm。一般我们使用shiro都使用自定义的realm。
    当有多个realm存在的时候，shiro在做用户校验的时候会按照定义的策略来决定认证是否通过，shiro提供的可选策略有一个成功或者所有都成功等。
    一个realm对应了一个CredentialsMatcher，用来做用户提交认证信息和realm获取得用户信息做比对，shiro已经提供了常用的比如用户密码和存储的Hash后的密码的对比。

JWT的应用场景

关于JWT是什么，请参考JWT官网。这里就不多解释了，可理解为使用带签名的token来做用户和权限验证，现在流行的公共开放接口用的OAuth 2.0协议基本也是类似的套路。这里只是说下选择使用jwt不用session的原因。
首先，是要支持多端，一个api要支持H5, PC和APP三个前端，如果使用session的话对app不是很友好，而且session有跨域攻击的问题。
其次，后端的服务是无状态的，所以要支持分布式的权限校验。当然这个不是主要原因了，因为session持久化在spring里面也就是加一行注解就解决的问题。不过，spring通过代理httpsession来做，总归觉得有点复杂。

项目搭建

需求

需求相对简单，1）支持用户首次通过用户名和密码登录；2）登录后通过http header返回token；3）每次请求，客户端需通过header将token带回，用于权限校验；4）服务端负责token的定期刷新，刷新后新的token仍然放到header中返给客户端

pom.xml

这里使用了shiro的web starter。jwt是用的auth0的工具包，其实自己实现也比较简单，我们这里就不自己重新造轮子了。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.     <modelVersion>4.0.0</modelVersion>
  5.     <groupId>com.github.springboot</groupId>
  6.     <artifactId>shiro-jwt-demo</artifactId>
  7.     <version>1.0-SNAPSHOT</version>
  8.     <packaging>jar</packaging>
  10.     <name>Spring Boot with Shiro and JWT Demo</name>
  11.     <description>Demo project for Spring Boot with Shiro and JWT</description>
  12.     <parent>
  13.         <groupId>org.springframework.boot</groupId>
  14.         <artifactId>spring-boot-starter-parent</artifactId>
  15.         <version>2.0.4.RELEASE</version>
  16.     </parent>
  17.     <properties>
  18.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  19.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  20.         <java.version>1.8</java.version>
  21.         <shiro.spring.version>1.4.0</shiro.spring.version>
  22.         <jwt.auth0.version>3.2.0</jwt.auth0.version>
  23.     </properties>
  25.     <dependencies>
  26.         <dependency>
  27.             <groupId>org.springframework.boot</groupId>
  28.             <artifactId>spring-boot-starter-web</artifactId>
  29.         </dependency>
  30.         <dependency>
  31.             <groupId>org.springframework.boot</groupId>
  32.             <artifactId>spring-boot-starter-test</artifactId>
  33.         </dependency>
  34.         <!-- 使用redis做数据缓存，如果不需要可不依赖 -->
  35.         <dependency>
  36.             <groupId>org.springframework.boot</groupId>
  37.             <artifactId>spring-boot-starter-data-redis</artifactId>
  38.         </dependency>
  39.         <dependency>
  40.             <groupId>org.apache.shiro</groupId>
  41.             <artifactId>shiro-spring-boot-web-starter</artifactId>
  42.             <version>${shiro.spring.version}</version>
  43.         </dependency>
  44.         <dependency>
  45.             <groupId>com.auth0</groupId>
  46.             <artifactId>java-jwt</artifactId>
  47.             <version>${jwt.auth0.version}</version>
  48.         </dependency>
  49.         <dependency>
  50.             <groupId>org.apache.httpcomponents</groupId>
  51.             <artifactId>httpclient</artifactId>
  52.             <version>4.5.5</version>
  53.         </dependency>
  54.         <dependency>
  55.             <groupId>org.apache.commons</groupId>
  56.             <artifactId>commons-lang3</artifactId>
  57.             <version>3.7</version>
  58.         </dependency>
  59.     </dependencies>
  60.     <build>
  61.         <plugins>
  62.             <plugin>
  63.                 <groupId>org.springframework.boot</groupId>
  64.                 <artifactId>spring-boot-maven-plugin</artifactId>
  65.             </plugin>
  66.             <plugin>
  67.                 <groupId>org.apache.maven.plugins</groupId>
  68.                 <artifactId>maven-compiler-plugin</artifactId>
  69.                 <configuration>
  70.                     <source>${java.version}</source>
  71.                     <target>${java.version}</target>
  72.                 </configuration>
  73.             </plugin>
  74.             <plugin>
  75.                 <groupId>org.apache.maven.plugins</groupId>
  76.                 <artifactId>maven-surefire-plugin</artifactId>
  77.                 <configuration>
  78.                     <skipTests>true</skipTests>
  79.                 </configuration>
  80.             </plugin>
  81.         </plugins>
  82.     </build>
  83. </project>
shiro 配置

ShiroConfiguration
首先是初始化shiro的bean，主要是初始化Realm，注册Filter，定义filterChain。这些配置的用处后面会逐渐讲到。

  1. @Configuration
  2. public class ShiroConfig {
  3.     /** * 注册shiro的Filter，拦截请求 */
  4.     @Bean
  5.     public FilterRegistrationBean<Filter> filterRegistrationBean(SecurityManager securityManager,UserService userService) throws Exception{
  6.         FilterRegistrationBean<Filter> filterRegistration = new FilterRegistrationBean<Filter>();
  7.         filterRegistration.setFilter((Filter)shiroFilter(securityManager, userService).getObject());
  8.         filterRegistration.addInitParameter("targetFilterLifecycle", "true");
  9.         filterRegistration.setAsyncSupported(true);
  10.         filterRegistration.setEnabled(true);
  11.         filterRegistration.setDispatcherTypes(DispatcherType.REQUEST);
  13.         return filterRegistration;
  14.     }
  16.     /** * 初始化Authenticator */
  17.     @Bean
  18.     public Authenticator authenticator(UserService userService) {
  19.         ModularRealmAuthenticator authenticator = new ModularRealmAuthenticator();
  20.         //设置两个Realm，一个用于用户登录验证和访问权限获取；一个用于jwt token的认证
  21.         authenticator.setRealms(Arrays.asList(jwtShiroRealm(userService), dbShiroRealm(userService)));
  22.         //设置多个realm认证策略，一个成功即跳过其它的
  23.         authenticator.setAuthenticationStrategy(new FirstSuccessfulStrategy());
  24.         return authenticator;
  25.     }
  27.     /** * 禁用session, 不保存用户登录状态。保证每次请求都重新认证。 * 需要注意的是，如果用户代码里调用Subject.getSession()还是可以用session，如果要完全禁用，要配合下面的noSessionCreation的Filter来实现 */
  28.     @Bean
  29.     protected SessionStorageEvaluator sessionStorageEvaluator(){
  30.         DefaultWebSessionStorageEvaluator sessionStorageEvaluator = new DefaultWebSessionStorageEvaluator();
  31.         sessionStorageEvaluator.setSessionStorageEnabled(false);
  32.         return sessionStorageEvaluator;
  33.     }
  34.     /** * 用于用户名密码登录时认证的realm */
  35.     @Bean("dbRealm")
  36.     public Realm dbShiroRealm(UserService userService) {
  37.         DbShiroRealm myShiroRealm = new DbShiroRealm(userService);
  38.         return myShiroRealm;
  39.     }
  40.     /** * 用于JWT token认证的realm */
  41.     @Bean("jwtRealm")
  42.     public Realm jwtShiroRealm(UserService userService) {
  43.         JWTShiroRealm myShiroRealm = new JWTShiroRealm(userService);
  44.         return myShiroRealm;
  45.     }
  47.     /** * 设置过滤器，将自定义的Filter加入 */
  48.     @Bean("shiroFilter")
  49.     public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager, UserService userService) {
  50.         ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
  51.         factoryBean.setSecurityManager(securityManager);
  52.         Map<String, Filter> filterMap = factoryBean.getFilters();
  53.         filterMap.put("authcToken", createAuthFilter(userService));
  54.         filterMap.put("anyRole", createRolesFilter());
  55.         factoryBean.setFilters(filterMap);
  56.         factoryBean.setFilterChainDefinitionMap(shiroFilterChainDefinition().getFilterChainMap());
  58.         return factoryBean;
  59.     }
  61.     @Bean
  62.     protected ShiroFilterChainDefinition shiroFilterChainDefinition() {
  63.         DefaultShiroFilterChainDefinition chainDefinition = new DefaultShiroFilterChainDefinition();
  64.         chainDefinition.addPathDefinition("/login", "noSessionCreation,anon");  //login不做认证，noSessionCreation的作用是用户在操作session时会抛异常
  65.         chainDefinition.addPathDefinition("/logout", "noSessionCreation,authcToken[permissive]"); //做用户认证，permissive参数的作用是当token无效时也允许请求访问，不会返回鉴权未通过的错误
  66.         chainDefinition.addPathDefinition("/image/**", "anon");
  67.         chainDefinition.addPathDefinition("/admin/**", "noSessionCreation,authcToken,anyRole[admin,manager]"); //只允许admin或manager角色的用户访问
  68.         chainDefinition.addPathDefinition("/article/list", "noSessionCreation,authcToken");
  69.         chainDefinition.addPathDefinition("/article/*", "noSessionCreation,authcToken[permissive]");
  70.         chainDefinition.addPathDefinition("/**", "noSessionCreation,authcToken"); // 默认进行用户鉴权
  71.         return chainDefinition;
  72.     }
  73.     //注意不要加@Bean注解，不然spring会自动注册成filter
  74.     protected JwtAuthFilter createAuthFilter(UserService userService){
  75.         return new JwtAuthFilter(userService);
  76.     }
  77.     //注意不要加@Bean注解，不然spring会自动注册成filter
  78.     protected AnyRolesAuthorizationFilter createRolesFilter(){
  79.         return new AnyRolesAuthorizationFilter();
  80.     }
  82. }

校验流程

我们使用Shiro主要做3件事情，1）用户登录时做用户名密码校验；2）用户登录后收到请求时做JWT Token的校验；3）用户权限的校验

登录认证流程

登录controller
从前面的ShiroFilterChainDefinition配置可以看出，对于登录请求，Filter直接放过，进到controller里面。Controller会调用shiro做用户名和密码的校验，成功后返回token。

  1. @PostMapping(value = "/login")
  2.     public ResponseEntity<Void> login(@RequestBody UserDto loginInfo, HttpServletRequest request, HttpServletResponse response){      
  3.         Subject subject = SecurityUtils.getSubject();
  4.         try {
  5.             //将用户请求参数封装后，直接提交给Shiro处理
  6.             UsernamePasswordToken token = new UsernamePasswordToken(loginInfo.getUsername(), loginInfo.getPassword());
  7.             subject.login(token);
  8.             //Shiro认证通过后会将user信息放到subject内，生成token并返回
  9.             UserDto user = (UserDto) subject.getPrincipal();
  10.             String newToken = userService.generateJwtToken(user.getUsername());
  11.             response.setHeader("x-auth-token", newToken);
  12.             
  13.             return ResponseEntity.ok().build();
  14.         } catch (AuthenticationException e) { 
  15.            // 如果校验失败，shiro会抛出异常，返回客户端失败
  16.             logger.error("User {} login fail, Reason:{}", loginInfo.getUsername(), e.getMessage());
  17.             return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
  18.         } catch (Exception e) {
  19.             return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
  20.         }
  21.     }

登录的Realm
从上面的controller实现我们看到，controller只负责封装下参数，然后扔给Shiro了，这时候Shiro收到后，会到所有的realm中找能处理UsernamePasswordToken的Realm（我们这里是DbShiroRealm），然后交给Realm处理。Realm的实现一般直接继承AuthorizingRealm即可，只需要实现两个方法，doGetAuthenticationInfo()会在用户验证时被调用，我们看下实现。

  1. public class DbShiroRealm extends AuthorizingRealm {
  2.     //数据库存储的用户密码的加密salt，正式环境不能放在源代码里
  3.     private static final String encryptSalt = "F12839WhsnnEV$#23b";
  4.     private UserService userService;
  5.     
  6.     public DbShiroRealm(UserService userService) {
  7.         this.userService = userService;
  8.         //因为数据库中的密码做了散列，所以使用shiro的散列Matcher
  9.         this.setCredentialsMatcher(new HashedCredentialsMatcher(Sha256Hash.ALGORITHM_NAME));
  10.     }
  11.     /** * 找它的原因是这个方法返回true */ 
  12.     @Override
  13.     public boolean supports(AuthenticationToken token) {
  14.         return token instanceof UsernamePasswordToken;
  15.     }
  16.    /** * 这一步我们根据token给的用户名，去数据库查出加密过用户密码，然后把加密后的密码和盐值一起发给shiro，让它做比对 */
  17.     @Override
  18.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
  19.         UsernamePasswordToken userpasswordToken = (UsernamePasswordToken)token;
  20.         String username = userpasswordToken.getUsername();
  21.         UserDto user = userService.getUserInfo(username);
  22.         if(user == null)
  23.             throw new AuthenticationException("用户名或者密码错误");
  24.         
  25.         return new SimpleAuthenticationInfo(user, user.getEncryptPwd(), ByteSource.Util.bytes(encryptSalt), "dbRealm");
  26.     }
  28. }

我们可以看到doGetAuthenticationInfo里面只判断了用户存不存在，其实也没做密码比对，只是把数据库的数据封装一下就返回了。真正的比对逻辑在Matcher里实现的，这个shiro已经替我们实现了。如果matcher返回false，shiro会抛出异常，这样controller那边就会知道验证失败了。
登出
登出操作就比较简单了，我们只需要把用户登录后保存的salt值清除，然后调用shiro的logout就可以了，shiro会将剩下的事情做完。

  1. @GetMapping(value = "/logout")
  2.     public ResponseEntity<Void> logout() {
  3.         Subject subject = SecurityUtils.getSubject();
  4.         if(subject.getPrincipals() != null) {
  5.             UserDto user = (UserDto)subject.getPrincipals().getPrimaryPrincipal();
  6.             userService.deleteLoginInfo(user.getUsername());
  7.         }
  8.         SecurityUtils.getSubject().logout();
  9.         return ResponseEntity.ok().build();
  10.     }

这样整个登录/登出就结束了，我们可以看到shiro对整个逻辑的拆解还是比较清楚的，各个模块各司其职。

请求认证流程

请求认证的流程其实和登录认证流程是比较相似的，因为我们的服务是无状态的，所以每次请求带来token，我们就是做了一次登录操作。
JwtAuthFilter
首先我们先从入口的Filter开始。从AuthenticatingFilter继承，重写isAccessAllow方法，方法中调用父类executeLogin()。父类的这个方法首先会createToken()，然后调用shiro的Subject.login()方法。是不是跟LoginController中的逻辑很像。

  1. public class JwtAuthFilter extends AuthenticatingFilter {
  2.     /** * 父类会在请求进入拦截器后调用该方法，返回true则继续，返回false则会调用onAccessDenied()。这里在不通过时，还调用了isPermissive()方法，我们后面解释。 */
  3.     @Override
  4.     protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
  5.         if(this.isLoginRequest(request, response))
  6.             return true;
  7.         boolean allowed = false;
  8.         try {
  9.             allowed = executeLogin(request, response);
  10.         } catch(IllegalStateException e){ //not found any token
  11.             log.error("Not found any token");
  12.         }catch (Exception e) {
  13.             log.error("Error occurs when login", e);
  14.         }
  15.         return allowed || super.isPermissive(mappedValue);
  16.     }
  17.     /** * 这里重写了父类的方法，使用我们自己定义的Token类，提交给shiro。这个方法返回null的话会直接抛出异常，进入isAccessAllowed（）的异常处理逻辑。 */
  18.     @Override
  19.     protected AuthenticationToken createToken(ServletRequest servletRequest, ServletResponse servletResponse) {
  20.         String jwtToken = getAuthzHeader(servletRequest);
  21.         if(StringUtils.isNotBlank(jwtToken)&&!JwtUtils.isTokenExpired(jwtToken))
  22.             return new JWTToken(jwtToken);
  24.         return null;
  25.     }
  26.     /** * 如果这个Filter在之前isAccessAllowed（）方法中返回false,则会进入这个方法。我们这里直接返回错误的response */
  27.     @Override
  28.     protected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {
  29.         HttpServletResponse httpResponse = WebUtils.toHttp(servletResponse);
  30.         httpResponse.setCharacterEncoding("UTF-8");
  31.         httpResponse.setContentType("application/json;charset=UTF-8");
  32.         httpResponse.setStatus(HttpStatus.SC_NON_AUTHORITATIVE_INFORMATION);
  33.         fillCorsHeader(WebUtils.toHttp(servletRequest), httpResponse);
  34.         return false;
  35.     }
  36.     /** * 如果Shiro Login认证成功，会进入该方法，等同于用户名密码登录成功，我们这里还判断了是否要刷新Token */
  37.     @Override
  38.     protected boolean onLoginSuccess(AuthenticationToken token, Subject subject, ServletRequest request, ServletResponse response) throws Exception {
  39.         HttpServletResponse httpResponse = WebUtils.toHttp(response);
  40.         String newToken = null;
  41.         if(token instanceof JWTToken){
  42.             JWTToken jwtToken = (JWTToken)token;
  43.             UserDto user = (UserDto) subject.getPrincipal();
  44.             boolean shouldRefresh = shouldTokenRefresh(JwtUtils.getIssuedAt(jwtToken.getToken()));
  45.             if(shouldRefresh) {
  46.                 newToken = userService.generateJwtToken(user.getUsername());
  47.             }
  48.         }
  49.         if(StringUtils.isNotBlank(newToken))
  50.             httpResponse.setHeader("x-auth-token", newToken);
  52.         return true;
  53.     }
  54.     /** * 如果调用shiro的login认证失败，会回调这个方法，这里我们什么都不做，因为逻辑放到了onAccessDenied（）中。 */
  55.     @Override
  56.     protected boolean onLoginFailure(AuthenticationToken token, AuthenticationException e, ServletRequest request, ServletResponse response) {
  57.         log.error("Validate token fail, token:{}, error:{}", token.toString(), e.getMessage());
  58.         return false;
  59.     }
  60. }

JWT token封装
在上面的Filter中我们创建了一个Token提交给了shiro，我们看下这个Token，其实很简单，就是把jwt的token放在里面。

  1. public class JWTToken implements HostAuthenticationToken {
  2.     private String token;
  3.     private String host;
  4.     public JWTToken(String token) {
  5.         this(token, null);
  6.     }
  7.     public JWTToken(String token, String host) {
  8.         this.token = token;
  9.         this.host = host;
  10.     }
  11.     public String getToken(){
  12.         return this.token;
  13.     }
  14.     public String getHost() {
  15.         return host;
  16.     }
  17.     @Override
  18.     public Object getPrincipal() {
  19.         return token;
  20.     }
  21.     @Override
  22.     public Object getCredentials() {
  23.         return token;
  24.     }
  25.     @Override
  26.     public String toString(){
  27.         return token + ':' + host;
  28.     }
  29. }

JWT Realm
Token有了，filter中也调用了shiro的login()方法了，下一步自然是Shiro把token提交到Realm中，获取存储的认证信息来做比对。

  1. public class JWTShiroRealm extends AuthorizingRealm {
  2.     protected UserService userService;
  4.     public JWTShiroRealm(UserService userService){
  5.         this.userService = userService;
  6.         //这里使用我们自定义的Matcher
  7.         this.setCredentialsMatcher(new JWTCredentialsMatcher());
  8.     }
  9.     /** * 限定这个Realm只支持我们自定义的JWT Token */ 
  10.     @Override
  11.     public boolean supports(AuthenticationToken token) {
  12.         return token instanceof JWTToken;
  13.     }
  15.     /** * 更controller登录一样，也是获取用户的salt值，给到shiro，由shiro来调用matcher来做认证 */
  16.     @Override
  17.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authcToken) throws AuthenticationException {
  18.         JWTToken jwtToken = (JWTToken) authcToken;
  19.         String token = jwtToken.getToken();
  20.         
  21.         UserDto user = userService.getJwtTokenInfo(JwtUtils.getUsername(token));
  22.         if(user == null)
  23.             throw new AuthenticationException("token过期，请重新登录");
  25.         SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(user.getUsername(), user.getSalt(), "jwtRealm");
  27.         return authenticationInfo;
  28.     }
  29. }

JWT Matcher
跟controller登录不一样，shiro并没有实现JWT的Matcher，需要我们自己来实现。代码如下：

  1. public class JWTCredentialsMatcher implements CredentialsMatcher {
  2.     /** * Matcher中直接调用工具包中的verify方法即可 */
  3.     @Override
  4.     public boolean doCredentialsMatch(AuthenticationToken authenticationToken, AuthenticationInfo authenticationInfo) {
  5.         String token = (String) authenticationToken.getCredentials();
  6.         Object stored = authenticationInfo.getCredentials();
  7.         String salt = stored.toString();
  9.         UserDto user = (UserDto)authenticationInfo.getPrincipals().getPrimaryPrincipal();
  10.         try {
  11.             Algorithm algorithm = Algorithm.HMAC256(salt);
  12.             JWTVerifier verifier = JWT.require(algorithm)
  13.                     .withClaim("username", user.getUsername())
  14.                     .build();
  15.             verifier.verify(token);
  16.             return true;
  17.         } catch (UnsupportedEncodingException | JWTVerificationException e) {
  18.             log.error("Token Error:{}", e.getMessage());
  19.         }
  20.         return false;
  21.     }
  22. }

这样非登录请求的认证处理逻辑也结束了，看起来是不是跟登录逻辑差不多。其实对于无状态服务来说，每次请求都相当于做了一次登录操作，我们用session的时候之所以不需要做，是因为容器代替我们把这件事干掉了。
关于permissive
前面Filter里面的isAccessAllow方法，除了使用jwt token做了shiro的登录认证之外，如果返回false还会额外调用isPermissive()方法。这里面干了什么呢？我们看下父类的方法：

  1. /** * Returns <code>true</code> if the mappedValue contains the {@link #PERMISSIVE} qualifier. * * @return <code>true</code> if this filter should be permissive */
  2.     protected boolean isPermissive(Object mappedValue) {
  3.         if(mappedValue != null) {
  4.             String[] values = (String[]) mappedValue;
  5.             return Arrays.binarySearch(values, PERMISSIVE) >= 0;
  6.         }
  7.         return false;
  8.     }

逻辑很简单，如果filter的拦截配置那里配置了permissive参数，即使登录认证没通过，因为isPermissive返回true，还是会让请求继续下去的。细心的同学或许已经发现我们之前shiroConfig里面的配置了，截取过来看一下：

  1. chainDefinition.addPathDefinition("/logout", "noSessionCreation,authcToken[permissive]"); //做用户认证，permissive参数的作用是当token无效时也允许请求访问，不会返回鉴权未通过的错误

就是这么简单直接，字符串匹配。当然这里也可以重写这个方法插入更复杂的逻辑。
这么做的目的是什么呢？因为有时候我们对待请求，并不都是非黑即白，比如登出操作，如果用户带的token是正确的，我们会将保存的用户信息清除；如果带的token是错的，也没关系，大不了不干啥，没必要返回错误给用户。还有一个典型的案例，比如我们阅读博客，匿名用户也是可以看的。只是如果是登录用户，我们会显示额外的东西，比如是不是点过赞等。所以认证这里的逻辑就是token是对的，我会给把人认出来；是错的，我也直接放过，留给controller来决定怎么区别对待。
JWT Token刷新
前面的Filter里面还有一个逻辑（是不是太多了??），就是如果用户这次的token校验通过后，我们还会顺便看看token要不要刷新，如果需要刷新则将新的token放到header里面。
这样做的目的是防止token丢了之后，别人可以拿着一直用。我们这里是固定时间刷新。安全性要求更高的系统可能每次请求都要求刷新，或者是每次POST，PUT等修改数据的请求后必须刷新。判断逻辑如下：

  1. protected boolean shouldTokenRefresh(Date issueAt){
  2.         LocalDateTime issueTime = LocalDateTime.ofInstant(issueAt.toInstant(), ZoneId.systemDefault());
  3.         return LocalDateTime.now().minusSeconds(tokenRefreshInterval).isAfter(issueTime);
  4.     }

以上就是jwt token校验的所有逻辑了，是不是有点绕，画一个流程图出来，对比着看应该更清楚一点。

jwt filter逻辑

角色配置

认证讲完了，下面看下访问控制。对于角色检查的拦截，是通过继承一个AuthorizationFilter的Filter来实现的。Shiro提供了一个默认的实现RolesAuthorizationFilter，比如可以这么配置：

  1. chainDefinition.addPathDefinition("/article/edit", "authc,role[admin]");

表示要做文章的edit操作，需要满足两个条件，首先authc表示要通过用户认证，这个我们上面已经讲过了；其次要具备admin的角色。shiro是怎么做的呢？就是在请求进入这个filter后，shiro会调用所有配置的Realm获取用户的角色信息，然后和Filter中配置的角色做对比，对上了就可以通过了。
所以我们所有的Realm还要另外一个方法doGetAuthorizationInfo，不得不吐槽一下，realm里面要实现的这两个方法的名字实在太像了。
在JWT Realm里面，因为没有存储角色信息，所以直接返回空就可以了：

  1. @Override
  2.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
  3.         return new SimpleAuthorizationInfo();
  4.     }

在DbRealm里面，实现如下：

  1. @Override
  2.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
  3.         SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
  4.         UserDto user = (UserDto) principals.getPrimaryPrincipal();
  5.         List<String> roles = user.getRoles();
  6.         if(roles == null) {
  7.             roles = userService.getUserRoles(user.getUserId());
  8.             user.setRoles(roles);
  9.         }
  10.         if (roles != null)
  11.             simpleAuthorizationInfo.addRoles(roles);
  13.         return simpleAuthorizationInfo;
  14.     }

这里需要注意一下的就是Shiro默认不会缓存角色信息，所以这里调用service的方法获取角色强烈建议从缓存中获取。
自己实现RoleFilter
在实际的项目中，对同一个url多个角色都有访问权限很常见，shiro默认的RoleFilter没有提供支持，比如上面的配置，如果我们配置成下面这样，那用户必须同时具备admin和manager权限才能访问，显然这个是不合理的。

  1. chainDefinition.addPathDefinition("/admin/**", "authc,role[admin,manager]");

所以自己实现一个role filter，只要任何一个角色符合条件就通过，只需要重写AuthorizationFilter中两个方法就可以了：

  1. public class AnyRolesAuthorizationFilter  extends AuthorizationFilter {
  3.     @Override
  4.     protected boolean isAccessAllowed(ServletRequest servletRequest, ServletResponse servletResponse, Object mappedValue) throws Exception {
  5.         Subject subject = getSubject(servletRequest, servletResponse);
  6.         String[] rolesArray = (String[]) mappedValue;
  7.         if (rolesArray == null || rolesArray.length == 0) { //没有角色限制，有权限访问
  8.             return true;
  9.         }
  10.         for (String role : rolesArray) {
  11.             if (subject.hasRole(role)) //若当前用户是rolesArray中的任何一个，则有权限访问
  12.                 return true;
  13.         }
  14.         return false;
  15.     }
  16.     /** * 权限校验失败，错误处理 */
  17.     @Override
  18.     protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws IOException {
  19.         HttpServletResponse httpResponse = WebUtils.toHttp(response);
  20.         httpResponse.setCharacterEncoding("UTF-8");
  21.         httpResponse.setContentType("application/json;charset=utf-8");
  22.         httpResponse.setStatus(HttpStatus.SC_UNAUTHORIZED);
  23.         return false;
  24.     }
  26. }

禁用session

因为用了jwt的访问认证，所以要把默认session支持关掉。这里要做两件事情，一个是ShiroConfig里面的配置：

  1. @Bean
  2.     protected SessionStorageEvaluator sessionStorageEvaluator(){
  3.         DefaultWebSessionStorageEvaluator sessionStorageEvaluator = new DefaultWebSessionStorageEvaluator();
  4.         sessionStorageEvaluator.setSessionStorageEnabled(false);
  5.         return sessionStorageEvaluator;
  6.     }

另外一个是在对请求加上noSessionCreationFilter,具体原因上面的代码中已经有解释，用法如下：

  1. chainDefinition.addPathDefinition("/**", "noSessionCreation,authcToken");
跨域支持

对于前后端分离的项目，一般都需要跨域访问，这里需要做两件事，一个是在JwtFilter的postHandle中在头上加上跨域支持的选项（理论上应该重新定义一个Filter的，图省事就让它多干点吧??）。

  1. @Override
  2.     protected void postHandle(ServletRequest request, ServletResponse response){
  3.         this.fillCorsHeader(WebUtils.toHttp(request), WebUtils.toHttp(response));
  4.     }

在实际使用中发现，对于controller返回@ResponseBody的请求，filter中添加的header信息会丢失。对于这个问题spring已经给出解释，并建议实现ResponseBodyAdvice类，并添加@ControllerAdvice。

所以如果存在返回@ResponseBody的controller，需要添加一个ResponseBodyAdvice实现类

  1. @ControllerAdvice
  2. public class ResponseHeaderAdvice implements ResponseBodyAdvice<Object> {
  3.     @Override
  4.     public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
  5.         return true;
  6.     }
  8.     @Override
  9.     public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass,
  10.                                   ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
  11.         ServletServerHttpRequest serverRequest = (ServletServerHttpRequest)serverHttpRequest;
  12.         ServletServerHttpResponse serverResponse = (ServletServerHttpResponse)serverHttpResponse;
  13.         if(serverRequest == null || serverResponse == null
  14.                 || serverRequest.getServletRequest() == null || serverResponse.getServletResponse() == null) {
  15.             return o;
  16.         }
  18.         // 对于未添加跨域消息头的响应进行处理
  19.         HttpServletRequest request = serverRequest.getServletRequest();
  20.         HttpServletResponse response = serverResponse.getServletResponse();
  21.         String originHeader = "Access-Control-Allow-Origin";
  22.         if(!response.containsHeader(originHeader)) {
  23.             String origin = request.getHeader("Origin");
  24.             if(origin == null) {
  25.                 String referer = request.getHeader("Referer");
  26.                 if(referer != null)
  27.                     origin = referer.substring(0, referer.indexOf("/", 7));
  28.             }
  29.             response.setHeader("Access-Control-Allow-Origin", origin);
  30.         }
  32.         String allowHeaders = "Access-Control-Allow-Headers";
  33.         if(!response.containsHeader(allowHeaders))
  34.             response.setHeader(allowHeaders, request.getHeader(allowHeaders));
  36.         String allowMethods = "Access-Control-Allow-Methods";
  37.         if(!response.containsHeader(allowMethods))
  38.             response.setHeader(allowMethods, "GET,POST,OPTIONS,HEAD");
  39.         //这个很关键，要不然ajax调用时浏览器默认不会把这个token的头属性返给JS
  40.         String exposeHeaders = "access-control-expose-headers";
  41.         if(!response.containsHeader(exposeHeaders))
  42.             response.setHeader(exposeHeaders, "x-auth-token");
  44.         return o;
  45.     }
  46. }

好了，到这里使用shiro和jwt做用户认证和鉴权的实现就结束了。

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/qq_43842093/article/details/121890065

内容来源于网络，如有侵权，请联系作者删除！

Javaspringboot安全

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com