shiro jwt 构建无状态分布式鉴权体系

一:JWT

1、令牌构造

JWT(json web token)是可在网络上传输的用于声明某种主张的令牌(token),以JSON 对象为载体的轻量级开放标准(RFC 7519)。

一个JWT令牌的定义包含头信息、荷载信息、签名信息三个部分:

Header//头信息
{
    "alg": "HS256",//签名或摘要算法
    "typ": "JWT"//token类型
}
Playload//荷载信息
{
    "iss": "token-server",//签发者
    "exp ": "Mon Nov 13 15:28:41 CST 2017",//过期时间
    "sub ": "wangjie",//用户名
    "aud": "web-server-1"//接收方,
    "nbf": "Mon Nov 13 15:40:12 CST 2017",//这个时间之前token不可用
    "jat": "Mon Nov 13 15:20:41 CST 2017",//签发时间
    "jti": "0023",//令牌id标识
    "claim": {“auth”:”ROLE_ADMIN”}//访问主张
}
Signature//签名信息
签名或摘要算法(
    base64urlencode(Header),
    Base64urlencode(Playload),
    secret-key
)

按照JWT规范,对这个令牌定义进行如下操作:

base64urlencode(Header)
+"."+
base64urlencode(Playload)
+"."+
signature(
    base64urlencode(Header)
    +"."+
    base64urlencode(Playload)
    ,secret-key
)

形成一个完整的JWT:
eyJhbGciOiJIUzUxMiIsInppcCI6IkRFRiJ9.eNqqVspMLFGyMjQ1NDA1tTA0NNRRKi5NUrJSKk_MS8_KTFXSUUqtKEAoMDKsBQAAAP__.dGLe7BVECKzQ_utZJqk4hbcBZthNhohuEjjue98vmpQSGn_9cCYHq7lPIfwKubW8M553F8Uhk933EJwgI5vbLQ

需要注意的是:

1:荷载信息(Playload)中的属性可以根据情况进行设置,不要求必须全部填写。

2:由token的生成方式发现,Header和Playload仅仅是base64编码,通过base64解码之后可见,基本相当于是明文传输,所以应避免敏感信息放入Playload。

2、令牌特点

紧凑性:体积较小、意味着传输速度快,可以作为POST参数或放置在HTTP头。

自包含性:有效的负载包含用户鉴权所需所有信息,避免多次查询数据库。

安全性:支持对称和非对称方式(HMAC、RSA)进行消息摘要签名。

标准化:开放标准,多语言支持,跨平台。

3、适用场景

1:无状态、分布式鉴权,比如rest api系统、微服务系统。

2:方便解决跨域授权的问题,比如SSO单点登陆。

3:JWT只是消息协议,不牵涉到会话管理和存储机制,所以单体WEB应用还是推荐session-cookie机制。

4、安全策略

1:重放攻击(Replay Attacks):应保证token只能使用一次,可以将有效期设置极短(这个时间不好控制);如果token只使用一次,可以将token的ID放入缓存(redis、memcached)进行阅后即焚(这个可操作性强);如果一个token需要连续穿梭多个系统进行鉴权,在最后一次使用后将token的ID放入销毁缓存(redis、memcached)。

2:跨站请求伪造(CSRF Cross-site request forgery):由于不依赖Cookie,所以一般情况下不需要考虑CSRF。

3:跨站脚本攻击(XSS Cross Site Scripting):相比较CSRF JWT更容易收到XSS的威胁,可以考虑使用过滤器进行处理,JAVA环境下的XSS HTMLFilter和PHP环境下的TWIG。

4:防止伪造令牌:如果使用公私钥密码体系,请注意公钥也应该保密,只对可信系统开放。

二:典型微服务鉴权架构

shiro jwt 构建无状态分布式鉴权体系
微服务鉴权架构

客户端(移动端或者pc端)根据口令或者APP KEY到认证服务鉴权并申请签发令牌,如果需要操作服务A,必须先拿着令牌到服务A进行权限问询。如果需要操作服务B,同样先拿着令牌到服务B进行权限问询,一个令牌可以一次,也可以多次使用连续穿梭多个服务系统,直至令牌过期失效或被销毁。

JWT令牌使用了数字签名可以有效的防止数据篡改和窃取,同样申请令牌时的数据也需要有这样的安全保障,可以使用HMAC(哈希运算消息认证码)进行签名(摘要)和验签(参考:基于hmac的rest api鉴权处理)。

shiro是java业界普遍采用的安全框架,简单、够用、扩展性强。我们可以在shiro中添加对HMAC和JWT这两种鉴权方式的支持。

三:shiro集成

1、令牌签发服务

签发服务的核心功能是验证客户端是否合法,如果合法则授予其包含特定访问主张的JWT。

shiro Token定义:

/**
 * HMAC令牌
 * @author wangjie (http://www.jianshu.com/u/ffa3cba4c604) 
 * @date 2016年6月24日 下午2:55:15
 */
public class HmacToken implements AuthenticationToken{
    private static final long serialVersionUID = -7838912794581842158L;
    
    private String clientKey;// 客户标识(可以是用户名、app id等等)
    private String digest;// 消息摘要
    private String timeStamp;// 时间戳
    private Map<String, String[]> parameters;// 访问参数
    private String host;// 客户端IP
    
    public HmacToken(String clientKey,String timeStamp,String digest
                                ,String host,Map<String, String[]> parameters){
        this.clientKey = clientKey;
        this.timeStamp = timeStamp;
        this.digest = digest;
        this.host = host;
        this.parameters = parameters;
    }
    
    @Override
    public Object getPrincipal() {
        return this.clientKey;
    }
    @Override
    public Object getCredentials() {
        return Boolean.TRUE;
    }
    
    // 省略getters and setters ... ...
}

shiro Realm即验证逻辑定义:

/**
 * 基于HMAC( 散列消息认证码)的控制域
 * @author wangjie (http://www.jianshu.com/u/ffa3cba4c604) 
 * @date 2016年6月24日 下午2:55:15
 */
public class HmacRealm extends AuthorizingRealm{
    
    private final AccountProvider accountProvider;//账号服务(持久化服务)
    private final CryptogramService cryptogramService;//密码服务

    public HmacRealm(AccountProvider accountProvider,CryptogramService cryptogramService){
        this.accountProvider = accountProvider;
        this.cryptogramService = cryptogramService;
    }
    
    public Class<?> getAuthenticationTokenClass() {
        return HmacToken.class;//此Realm只支持HmacToken
    }
    
    /**
     *  认证
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) 
                                                          throws AuthenticationException {
        HmacToken hmacToken = (HmacToken)token;
        List<String> keys = Lists.newArrayList();
        for (String key:hmacToken.getParameters().keySet()){
            if (!"digest".equals(key))
                keys.add(key);
        }
        Collections.sort(keys);//对请求参数进行排序参数->自然顺序
        StringBuffer baseString = new StringBuffer();
        for (String key : keys) {
            baseString.append(hmacToken.getParameters().get(key)[0]);
        }
        //认证端生成摘要
        String serverDigest = cryptogramService.hmacDigest(baseString.toString());
        //客户端请求的摘要和服务端生成的摘要不同
        if(!serverDigest.equals(hmacToken.getDigest())){
            throw new AuthenticationException("数字摘要验证失败!!!");
        }
        Long visitTimeStamp = Long.valueOf(hmacToken.getTimeStamp());
        Long nowTimeStamp = System.currentTimeMillis();
        Long jge = nowTimeStamp - visitTimeStamp;
        if (jge > 600000) {// 十分钟之前的时间戳,这是有效期可以双方约定由参数传过来
            throw new AuthenticationException("数字摘要失效!!!");
        }
        // 此处可以添加查询数据库检查账号是否存在、是否被锁定、是否被禁用等等逻辑
        return new SimpleAuthenticationInfo(hmacToken.getClientKey(),Boolean.TRUE,getName());
    }
    
    /** 
     * 授权 
     */  
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        String clientKey = (String)principals.getPrimaryPrincipal();
        SimpleAuthorizationInfo info =  new SimpleAuthorizationInfo();
        // 根据客户标识(可以是用户名、app id等等) 查询并设置角色
        Set<String> roles = accountProvider.loadRoles(clientKey);
        info.setRoles(roles);
      // 根据客户标识(可以是用户名、app id等等) 查询并设置权限
        Set<String> permissions = accountProvider.loadPermissions(clientKey);
        info.setStringPermissions(permissions);
        return info;  
    }
}

HMAC认证过滤器定义:

/**
 * 基于HMAC( 散列消息认证码)的无状态认证过滤器
 * @author wangjie (http://www.jianshu.com/u/ffa3cba4c604) 
 * @date 2016年6月24日 下午2:55:15
 */
public class HmacFilter extends AccessControlFilter{
    
    private static final Logger log = LoggerFactory.getLogger(AccessControlFilter.class);
    
    public static final String DEFAULT_CLIENTKEY_PARAM = "clientKey";
    public static final String DEFAULT_TIMESTAMP_PARAM = "timeStamp";
    public static final String DEFAUL_DIGEST_PARAM = "digest";

    /**
     * 是否放行
     */
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, 
                                                        Object mappedValue) throws Exception {
        if (null != getSubject(request, response) 
                && getSubject(request, response).isAuthenticated()) {
            return true;//已经认证过直接放行
        }
        return false;//转到拒绝访问处理逻辑
    }

    /**
     * 拒绝处理
     */
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response)  
                                                                          throws Exception {
        if(isHmacSubmission(request)){//如果是Hmac鉴权的请求
            //创建令牌
            AuthenticationToken token = createToken(request, response);
            try {
                Subject subject = getSubject(request, response);
                subject.login(token);//认证
                return true;//认证成功,过滤器链继续
            } catch (AuthenticationException e) {//认证失败,发送401状态并附带异常信息
                log.error(e.getMessage(),e);
                WebUtils.toHttp(response).sendError(HttpServletResponse.SC_UNAUTHORIZED,e.getMessage());
            }
        }
        return false;//打住,访问到此为止
    }

    protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) {
        String clientKey = request.getParameter(DEFAULT_CLIENTKEY_PARAM);
        String timeStamp= request.getParameter(DEFAULT_TIMESTAMP_PARAM);
        String digest= request.getParameter(DEFAUL_DIGEST_PARAM);
        Map<String, String[]> parameters = request.getParameterMap();
        String host = request.getRemoteHost();
        return new HmacToken(clientKey, timeStamp, digest, host,parameters);
    }
    
    protected boolean isHmacSubmission(ServletRequest request) {
        String clientKey = request.getParameter(DEFAULT_CLIENTKEY_PARAM);
        String timeStamp= request.getParameter(DEFAULT_TIMESTAMP_PARAM);
        String digest= request.getParameter(DEFAUL_DIGEST_PARAM);
        return (request instanceof HttpServletRequest)
                            && StringUtils.isNotBlank(clientKey)
                            && StringUtils.isNotBlank(timeStamp)
                            && StringUtils.isNotBlank(digest);
    }
}

HMAC鉴权最基础的工作就此完成,需要注意的是鉴权是无状态的不需要创建SESSION,所以需要对shiro的SubjectFactory做一下改造,并设置到SecurityManager :

/**
 * 扩展自DefaultWebSubjectFactory,对于无状态的TOKEN 类型不创建session
 * @author wangjie (http://www.jianshu.com/u/ffa3cba4c604)
 * @date 2016年6月24日 下午2:55:15
 */
public class AgileSubjectFactory extends DefaultWebSubjectFactory { 

    public Subject createSubject(SubjectContext context) { 
        AuthenticationToken token = context.getAuthenticationToken();
        if((token instanceof HmacToken)){
            // 当token为HmacToken时, 不创建 session 
            context.setSessionCreationEnabled(false);
        }
        return super.createSubject(context); 
    }
}

JWT签发逻辑定义:

@RestController
@RequestMapping("/auth")
public class AuthenticateAction {
    private final String SECRET_KEY = "*(-=4eklfasdfarerf41585fdasf";

    @RequestMapping(value="/apply-token",method=RequestMethod.POST)
    public Map<String,Object> applyToken(@RequestParam(name="clientKey") String clientKey) {
        // 签发一个Json Web Token
        // 令牌ID=uuid,用户=clientKey,签发者=clientKey
        // token有效期=1分钟,用户角色=null,用户权限=create,read,update,delete
        String jwt = issueJwt(UUID.randomUUID().toString(), clientKey, 
                                    "token-server",60000l, null, "create,read,update,delete");
        Map<String,Object> respond = Maps.newHashMap();
        respond.put("jwt", jwt);
        return respond;
    }
    
    /**
     * @param id 令牌ID
     * @param subject 用户ID
     * @param issuer 签发人
     * @param period 有效时间(毫秒)
     * @param roles 访问主张-角色
     * @param permissions 访问主张-权限
     * @param algorithm 加密算法
     * @return json web token 
     */
    private String issueJwt(String id,String subject,String issuer,Long period,String roles
                                            ,String permissions,SignatureAlgorithm algorithm) {
        long currentTimeMillis = System.currentTimeMillis();// 当前时间戳
        byte[] secretKeyBytes = DatatypeConverter.parseBase64Binary(SECRET_KEY);// 秘钥
        JwtBuilder jwt  =  Jwts.builder();
        if(Strings.isNotBlank(id)) jwt.setId(id);
        jwt.setSubject(subject);// 用户名主题
        if(Strings.isNotBlank(issuer)) jwt.setIssuer(issuer);//签发者
        if(Strings.isNotBlank(issuer)) jwt.setIssuer(issuer);//签发者  
        jwt.setIssuedAt(new Date(currentTimeMillis));//签发时间
        if(null != period){
            Date expiration = new Date(currentTimeMillis+period);
            jwt.setExpiration(expiration);//有效时间
        }
        if(Strings.isNotBlank(roles)) jwt.claim("roles", roles);//角色
        if(Strings.isNotBlank(permissions)) jwt.claim("perms", permissions);//权限
        jwt.compressWith(CompressionCodecs.DEFLATE);//压缩,可选GZIP
        jwt.signWith(algorithm, secretKeyBytes);//加密设置
        return jwt.compact();
    }
}

添加过滤器:filterChainManager.addFilter( "hmac", new HmacFilter());
配置过滤规则:filterChainManager.addToChain("/auth/**", "hmac");
如果有需要可以在规则中添加其他过滤器。
JWT申请测试:

@Test
    public String applyToken(){
        Long current = System.currentTimeMillis() ;
        String url = "http://localhost:8080/tokenServer/auth/apply-token";
        MultiValueMap<String, Object> dataMap = new LinkedMultiValueMap<String, Object>();  
        String clientKey = "administrator";// 客户端标识(用户名)
        String mix = String.valueOf(new Random().nextFloat());// 随机数,进行混淆
        String timeStamp = current.toString();// 时间戳
        dataMap.add("clientKey", clientKey);
        dataMap.add("mix", mix);
        dataMap.add("timeStamp", timeStamp);
        String baseString = clientKey+mix+timeStamp;
        String digest =  hmacDigest(baseString);// 生成HMAC摘要
        dataMap.add("digest", digest);
        Map result = rt.postForObject(url, dataMap, Map.class);
        return (String)result.get("jwt");
    }

返回JWT:

eyJhbGciOiJIUzUxMiIsInppcCI6IkRFRiJ9.eNo8y80KwjAQBOB32XMCTfNj7NvsNluI2jYkWxHEdzf14GUYPmbecJMMEwzXGAjnUdvBR-2cdzpSRE2jiUtwSLQEUNAO6mNMa95yk4qy1665ta6y33nTjeuTf4gCk_HGWBvtxSjgV_mDsx0K1_U8zpVRWPVM6ijp7IkfLAyfLwAAAP__.GK7EJibs7n50uGksvvLK6Y39Ur6ZYXoXI9LOlFwEpIijHGAZjIyDhiYD-1nv1YbPJ46BI-gDTntV3KC0d8NSrA

2:令牌验签

有了JWT签发服务,要使用JWT就需要业务系统有JWT验鉴功能,同样在shiro中集成。
由于JWT是自包含的,令牌中已经声明了访问主张(比如角色、权限等),验签功能只需要验证令牌合法就行了,不需要访问数据库。

shiro Token定义:

/**
 * JWT令牌
 * @author wangjie (http://www.jianshu.com/u/ffa3cba4c604) 
 * @date 2016年6月24日 下午2:55:15
 */
public class JwtToken implements AuthenticationToken{

    private static final long serialVersionUID = -790191688300000066L;
    
    private String jwt;// json web token
    private String host;// 客户端IP
    
    public JwtToken(String jwt,String host){
        this.jwt = jwt;
        this.host = host;
    }

    @Override
    public Object getPrincipal() {
        return this.jwt;
    }

    @Override
    public Object getCredentials() {
        return Boolean.TRUE;
    }
    
    // 忽略getters and setters
}

JWT Realm即认证逻辑定义:

/**
 * 基于JWT( JSON WEB TOKEN)的认证域
 * 
 * @author wangjie (http://www.jianshu.com/u/ffa3cba4c604)
 * @date 2016年6月24日 下午2:55:15
 */
public class JwtRealm extends AuthorizingRealm {

    public Class<?> getAuthenticationTokenClass() {
        return JwtToken.class;//此Realm只支持JwtToken
    }

    /**
     * 认证
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) 
                                                        throws AuthenticationException {
        JwtToken jwtToken = (JwtToken) token;
        String jwt = (String) jwtToken.getPrincipal();
        JwtPlayload jwtPlayload;
        try {
            Claims claims = Jwts.parser()
                    .setSigningKey(DatatypeConverter.parseBase64Binary(SECRETKEY))
                    .parseClaimsJws(jwt)
                    .getBody();
            jwtPlayload = new JwtPlayload();
            jwtPlayload.setId(claims.getId());
            jwtPlayload.setUserId(claims.getSubject());// 用户名
            jwtPlayload.setIssuer(claims.getIssuer());// 签发者
            jwtPlayload.setIssuedAt(claims.getIssuedAt());// 签发时间
            jwtPlayload.setAudience(claims.getAudience());// 接收方
            jwtPlayload.setRoles(claims.get("roles", String.class));// 访问主张-角色
            jwtPlayload.setPerms(claims.get("perms", String.class));// 访问主张-权限
        } catch (ExpiredJwtException e) {
            throw new AuthenticationException("JWT 令牌过期:" + e.getMessage());
        } catch (UnsupportedJwtException e) {
            throw new AuthenticationException("JWT 令牌无效:" + e.getMessage());
        } catch (MalformedJwtException e) {
            throw new AuthenticationException("JWT 令牌格式错误:" + e.getMessage());
        } catch (SignatureException e) {
            throw new AuthenticationException("JWT 令牌签名无效:" + e.getMessage());
        } catch (IllegalArgumentException e) {
            throw new AuthenticationException("JWT 令牌参数异常:" + e.getMessage());
        } catch (Exception e) {
            throw new AuthenticationException("JWT 令牌错误:" + e.getMessage());
        }
        // 如果要使token只能使用一次,此处可以过滤并缓存jwtPlayload.getId()
        // 可以做签发方验证
        // 可以做接收方验证
        return new SimpleAuthenticationInfo(jwtPlayload, Boolean.TRUE, getName());
    }

    /**
     * 授权,JWT已包含访问主张只需要解析其中的主张定义就行了
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        JwtPlayload jwtPlayload = (JwtPlayload) principals.getPrimaryPrincipal();
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        // 解析角色并设置
        Set<String> roles = Sets.newHashSet(StringUtils.split(jwtPlayload.getRoles(), ","));
        info.setRoles(roles);
        // 解析权限并设置
        Set<String> permissions = Sets.newHashSet(StringUtils.split(jwtPlayload.getPerms(), ","));
        info.setStringPermissions(permissions);
        return info;
    }
}

处理逻辑中抛出的异常信息很详细,其实这样并不安全只是对调试友好,线上环境不用把异常信息给那么细。

JWT鉴权过滤器定义:

/**
 * 基于JWT标准的无状态认证过滤器
 * @author wangjie (http://www.jianshu.com/u/ffa3cba4c604) 
 * @date 2016年6月24日 下午2:55:15
 * 
 */ 
public class JwtFilter extends AccessControlFilter {
    
    private static final Logger log = LoggerFactory.getLogger(AccessControlFilter.class);
    
    public static final String DEFAULT_JWT_PARAM = "jwt";

    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
        if (null != getSubject(request, response) 
                && getSubject(request, response).isAuthenticated()) {
            return true;
        }
        return false;
    }

    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        if(isJwtSubmission(request)){
            AuthenticationToken token = createToken(request, response);
            try {
                Subject subject = getSubject(request, response);
                subject.login(token);
                return true;
            } catch (AuthenticationException e) {
                log.error(e.getMessage(),e);
                WebUtils.toHttp(response).sendError(HttpServletResponse.SC_UNAUTHORIZED,e.getMessage());
            } 
        }
        return false;
    }

    protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) {
        String jwt = request.getParameter(DEFAULT_JWT_PARAM);
        String host = request.getRemoteHost();
        log.info("authenticate jwt token:"+jwt);
        System.out.println("jwt:"+jwt);
        return new JwtToken(jwt, host);
    }
    
    protected boolean isJwtSubmission(ServletRequest request) {
        String jwt = request.getParameter(DEFAULT_JWT_PARAM);
        return (request instanceof HttpServletRequest)
                                && StringUtils.isNotBlank(jwt);
    }
    
}

资源访问权限过滤器定义:

/**
 * 基于JWT( JSON WEB TOKEN)的无状态资源过滤器
 * @author wangjie (http://www.jianshu.com/u/ffa3cba4c604) 
 * @date 2016年6月24日 下午2:55:15
 */
public class JwtPermFilter extends HmacFilter{
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, 
                                                    Object mappedValue) throws Exception {
        Subject subject = getSubject(request, response);
        String[] perms = (String[]) mappedValue;
        boolean isPermitted = true;
        if (perms != null && perms.length > 0) {
            if (perms.length == 1) {
                if (!subject.isPermitted(perms[0])) {
                    isPermitted = false;
                }
            } else {
                if (!subject.isPermittedAll(perms)) {
                    isPermitted = false;
                }
            }
        }
        return isPermitted;
    }
    
}

添加过滤器:filterChainManager.addFilter( "jwt", new JwtFilter());
filterChainManager.addFilter( "jwtPerms", new JwtPermFilter());
配置过滤规则:filterChainManager.addToChain("/api/", "jwt");
filterChainManager.addToChain("/api/delete/
", "jwtPerms["api:delete"]");
如果有需要可以在规则中添加其他过滤器。
同令牌申请服务一样,需要设置shiro不创建SESSION。

jsets-shiro-spring-boot-starter中封装了JWT的鉴权,请参见:

项目文档、源码

项目中经常用到的功能比如:验证码、密码错误次数限制、账号唯一用户登陆、动态URL过滤规则、无状态鉴权等等jsets-shiro-spring-boot-starter对这些常用的功能进行了封装和自动导入,少量的配置就可以应用在项目中。

1、jsets-shiro-spring-boot-starter项目详情请参见:jsets-shiro-spring-boot-starter
2、应用示例源码请参见:jsets-shiro-demo
3、jsets-shiro-spring-boot-starter使用说明请参见:使用说明

相关推荐