一: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：防止伪造令牌：如果使用公私钥密码体系，请注意公钥也应该保密，只对可信系统开放。
二：典型微服务鉴权架构
微服务鉴权架构
客户端（移动端或者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使用说明请参见：使用说明
码字不易，转载请保留原文连接http://www.jianshu.com/p/0a5d3d07a151
作者：wangjie2016
链接：https://www.jianshu.com/p/0a5d3d07a151
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。