Shiro JWT教程

问题
JWT
Shiro集成JWT

问题

Vue SPA之后，前后端完全分离，后端不再托管前端的页面，session也不再起作用。继而引发出一个问题，如何继续的保持前后端的状态？
一种流行的解决方案是JWT。

JWT

Json web token 官网： https://jwt.io/
JWT是由三段信息构成的，将这三段信息文本用.链接一起就构成了Jwt字符串。就像这样:
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

JWT的构成

第一部分我们称它为头部（header),第二部分我们称其为载荷（payload, 类似于飞机上承载的物品)，第三部分是签证（signature).

header

jwt的头部承载两部分信息：

声明类型，这里是jwt
声明加密的算法通常直接使用 HMAC SHA256

完整的头部就像下面这样的JSON：
{
‘typ’: ‘JWT’,
‘alg’: ‘HS256’
}
然后将头部进行base64加密（该加密是可以对称解密的),构成了第一部分.
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9

playload

载荷就是存放有效信息的地方。这个名字像是特指飞机上承载的货品，这些有效信息包含三个部分

标准中注册的声明
公共的声明
私有的声明

标准中注册的声明 (建议但不强制使用) ：

iss: jwt签发者
sub: jwt所面向的用户
aud: 接收jwt的一方
exp: jwt的过期时间，这个过期时间必须要大于签发时间
nbf: 定义在什么时间之前，该jwt都是不可用的.
iat: jwt的签发时间
jti: jwt的唯一身份标识，主要用来作为一次性token,从而回避重放攻击。

公共的声明 ：公共的声明可以添加任何的信息，一般添加用户的相关信息或其他业务需要的必要信息.但不建议添加敏感信息，因为该部分在客户端可解密.
私有的声明 ：私有声明是提供者和消费者所共同定义的声明，一般不建议存放敏感信息，因为base64是对称解密的，意味着该部分信息可以归类为明文信息。
定义一个payload:
{
“sub”: “1234567890”,
“name”: “John Doe”,
“admin”: true
}
然后将其进行base64加密，得到Jwt的第二部分。
eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9

signature

jwt的第三部分是一个签证信息，这个签证信息由三部分组成：

header (base64后的)
payload (base64后的)
secret

这个部分需要base64加密后的header和base64加密后的payload使用.连接组成的字符串，然后通过header中声明的加密方式进行加盐secret组合加密，然后就构成了jwt的第三部分。
// javascript
var encodedString = base64UrlEncode(header) + ‘.’ + base64UrlEncode(payload);
var signature = HMACSHA256(encodedString, ‘secret’); // TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ
将这三部分用.连接成一个完整的字符串,构成了最终的jwt:
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ
注意：secret是保存在服务器端的，jwt的签发生成也是在服务器端的，secret就是用来进行jwt的签发和jwt的验证，所以，它就是你服务端的私钥，在任何场景都不应该流露出去。一旦客户端得知这个secret, 那就意味着客户端是可以自我签发jwt了。

如何应用

一般是在请求头里加入Authorization，并加上Bearer标注：
fetch(‘api/user/1’, {
headers: {
‘Authorization’: ‘Bearer ‘ + token
}
})
服务端会验证token，如果验证通过就会返回相应的资源。整个流程就是这样的:
Shiro JWT教程 - 图1
jwt-diagram

总结

优点

因为json的通用性，所以JWT是可以进行跨语言支持的，像JAVA,JavaScript,NodeJS,PHP等很多语言都可以使用。
因为有了payload部分，所以JWT可以在自身存储一些其他业务逻辑所必要的非敏感信息。
便于传输，jwt的构成非常简单，字节占用很小，所以它是非常便于传输的。
它不需要在服务端保存会话信息, 所以它易于应用的扩展

安全相关
不应该在jwt的payload部分存放敏感信息，因为该部分是客户端可解密的部分。
保护好secret私钥，该私钥非常重要。
如果可以，请使用https协议

来自： https://www.jianshu.com/p/576dbf44b2ae

Shiro集成JWT

JWT需要在客户端存储，并且随请求发送，所以传统的验证方式将会发生改变

思路：

登录请求不走shiro，自行实现，并在成功后颁发jwt
所有的请求都走shiro自定义过滤器
自定义过滤器内部获取jwt，并根据jwt中的用户信息获取权限信息并判断是否有权限

修改方式：

登录请求处理
认证逻辑

登录时不走shiro，直接走controller，成功后颁发jwt

package me.maiz.shiro.shirojwt.controller;
import lombok.extern.slf4j.Slf4j;
import me.maiz.shiro.shirojwt.common.JwtUtils;
import me.maiz.shiro.shirojwt.common.Result;
import me.maiz.shiro.shirojwt.model.User;
import me.maiz.shiro.shirojwt.service.LoginService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@RestController
@CrossOrigin("*")
@Slf4j
public class LoginController {
    @Autowired
    private LoginService loginService;
    @PostMapping("login")
    public Result login(HttpServletResponse response, String username, String password){
        //执行登录操作，签发jwt ,但不走shiro
        log.info("登录操作：{},{}",username,password);
        User user = loginService.login(username, password);
        String jwt = JwtUtils.createJWT(user);
        response.setHeader(JwtUtils.AUTH_TOKEN_NAME,jwt);
        return Result.success(jwt);
    }
}

创建filter，验证jwt，filter调用realm

package me.maiz.shiro.shirojwt.component;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.base.Strings;
import io.jsonwebtoken.Claims;
import me.maiz.shiro.shirojwt.common.JwtUtils;
import me.maiz.shiro.shirojwt.common.Result;
import me.maiz.shiro.shirojwt.model.User;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.authc.AuthenticatingFilter;
import org.apache.shiro.web.util.WebUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.RequestMethod;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class JWTFilter extends AuthenticatingFilter {
 private static final Logger logger = LoggerFactory.getLogger(JWTFilter.class);
 @Override
 protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
     logger.info("进入预处理");
     //全局允许跨域
     HttpServletRequest httpServletRequest = (HttpServletRequest) request;
     HttpServletResponse httpServletResponse = (HttpServletResponse) response;
     httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
     httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
     httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
     // 跨域时会首先发送一个 option请求，这里我们给 option请求直接返回正常状态
     if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
         httpServletResponse.setStatus(HttpStatus.OK.value());
         return false;
     }
     return super.preHandle(request, response);
 }
 @Override
 protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
     return getTokenHeader(request)!=null||super.isAccessAllowed(request, response, mappedValue);
 }
 private String getTokenHeader(ServletRequest req){
     HttpServletRequest request = (HttpServletRequest) req;
     String token = request.getHeader(JwtUtils.AUTH_TOKEN_NAME);
     return token;
 }
 /**
  * 从请求中提取Token
  * @param req
  * @param response
  * @return
  * @throws Exception
  */
 @Override
 protected AuthenticationToken createToken(ServletRequest req, ServletResponse response) throws Exception {
     String token = getTokenHeader(req);
     if(Strings.isNullOrEmpty(token)){
         throw new UnknownAccountException("请求不合法，JWT token未传入");
     }
     return new JwtToken(token);
 }
 @Override
 protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
     HttpServletRequest httpServletRequest = WebUtils.toHttp(request);
     HttpServletResponse httpServletResponse = WebUtils.toHttp(response);
     // 返回401
     httpServletResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
     // 设置响应码为401或者直接输出消息
     String url = httpServletRequest.getRequestURI();
     ObjectMapper objectMapper = new ObjectMapper();
     Result fail = Result.fail("未授权的请求，请先登录");
     httpServletResponse.setContentType("application/json;charset=utf-8");
     httpServletResponse.getWriter().print(objectMapper.writeValueAsString(fail));
     return false;
 }
 @Override
 protected boolean onLoginSuccess(AuthenticationToken token, Subject subject, ServletRequest request, ServletResponse response) throws Exception {
     //TODO 刷新token
     return super.onLoginSuccess(token, subject, request, response);
 }
}

package me.maiz.shiro.shirojwt.component;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import me.maiz.shiro.shirojwt.common.JwtUtils;
import me.maiz.shiro.shirojwt.model.User;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
@Slf4j
public class ShiroRealm extends AuthorizingRealm {
 @Override
 protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
     Object primaryPrincipal = principals.getPrimaryPrincipal();
     User user = (User) primaryPrincipal;
     //查询权限等
     SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
     simpleAuthorizationInfo.setRoles(null);
     simpleAuthorizationInfo.setStringPermissions(null);
     return simpleAuthorizationInfo;
 }
 @Override
 public boolean supports(AuthenticationToken token) {
     return token instanceof JwtToken;
 }
 @Override
 protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
     log.info("登录操作：{}",token);
     JwtToken jwtToken = (JwtToken) token;
     //从token中解析出jwt附带的数据，如果jwt过期会抛出异常
     User user = JwtUtils.parseJwt(jwtToken.getToken());
     return new SimpleAuthenticationInfo(user,jwtToken.getToken(),getName());
 }
}

配置过滤器，使其生效

package me.maiz.shiro.shirojwt.config;
import me.maiz.shiro.shirojwt.component.JWTFilter;
import me.maiz.shiro.shirojwt.component.ShiroRealm;
import org.apache.shiro.cache.MemoryConstrainedCacheManager;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.spring.web.config.DefaultShiroFilterChainDefinition;
import org.apache.shiro.spring.web.config.ShiroFilterChainDefinition;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.apache.shiro.mgt.SecurityManager;
import javax.servlet.Filter;
import java.util.LinkedHashMap;
@Configuration
public class ShiroConfig {
 /**
  * 自定义Realm 提供数据源
  * @return
  */
 @Bean
 public Realm shiroRealm(){
     ShiroRealm shiroRealm = new ShiroRealm();
     shiroRealm.setCacheManager(cacheManager());
     return shiroRealm;
 }
 @Bean
 public MemoryConstrainedCacheManager cacheManager(){
     return new MemoryConstrainedCacheManager();
 }
 /**
  * shiro的过滤器链
  * @return
  */
 @Bean
 public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager){
     ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
     shiroFilterFactoryBean.setSecurityManager(securityManager);
     DefaultShiroFilterChainDefinition sfcd = new DefaultShiroFilterChainDefinition();
     // 在 Shiro过滤器链上加入 自定义过滤器JWTFilter 并取名为jwt
     LinkedHashMap<String, Filter> filters = new LinkedHashMap<>();
     filters.put("jwt", new JWTFilter());
     shiroFilterFactoryBean.setFilters(filters);
     //放行 使用
     sfcd.addPathDefinition("/","anon");
     sfcd.addPathDefinition("/login","anon");
     sfcd.addPathDefinition("/error/404.html","anon");
     sfcd.addPathDefinition("/css/**","anon");
     sfcd.addPathDefinition("/js/**","anon");
     sfcd.addPathDefinition("/images/**","anon");
     sfcd.addPathDefinition("/fonts/**","anon");
     sfcd.addPathDefinition("/html/**","anon");
     //logout 登出
     sfcd.addPathDefinition("/logout","logout");
     //其他则需要认证
     sfcd.addPathDefinition("/**","jwt");
     shiroFilterFactoryBean.setFilterChainDefinitionMap(sfcd.getFilterChainMap());
     return shiroFilterFactoryBean;
 }
}

https://segmentfault.com/a/1190000018856394
https://github.com/just-right/shiro
https://juejin.cn/post/6893859365359468557

问题

JWT