安全框架shiro入门示例

最近做了一个简单的线上支付网关。就是接收客户端发起的支付请求，然后转发给第三方的支付通道处理。这个网关是公司内部使用的，接口都是自定义的。为了防止外部攻击，我用shiro做了一个简易的授权机制。

基本原理

原理也很简单，客户端的请求报文如下(考虑到保密性，做了部分删减):

http://localhost:8080/paygateway/core/pay?amount=2&seq=12345678&username=admin&hmac=c85d26f8747da774447de3ef51e715773c8f077fc9f062972862956fefaa7a05

seq是流水号，每笔订单都不一样。username是固定admin，我用它来辨识身份。HMAC是密钥相关的哈希运算消息认证码，HMAC运算利用哈希算法，以一个密钥和一个消息为输入，生成一个消息摘要作为输出。

这里密钥是通过username去从数据库获取(相当于不同的username用不同的密钥)，消息就是流水号，因为每笔交易都不同，所以hmac值也是每次请求都不一样。除非外部攻击者知道我的密钥，否则不可能伪造支付请求。

源码分析

首先是要重写subject工厂的创建方法，因为我希望创建的是不保存session(无状态)的subject

public class StatelessDefaultSubjectFactory extends DefaultWebSubjectFactory{

private static Logger logger = LoggerFactory.getLogger(StatelessDefaultSubjectFactory.class);

@Override
public Subject createSubject(SubjectContext context) {

//不创建session
context.setSessionCreationEnabled(false);
return super.createSubject(context);
}

}

然后是重写认证过滤器。

public class StatelessAuthcFilter extends AccessControlFilter{

private static Logger logger = LoggerFactory.getLogger(StatelessAuthcFilter.class);

@Override
protected boolean isAccessAllowed(ServletRequest arg0, ServletResponse arg1, Object arg2) throws Exception {

return false;
}

@Override
protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {

//1、客户端生成的消息摘要
String clientDigest = request.getParameter("hmac");

logger.debug("clientDigest:"+clientDigest);

//2、客户端传入的用户身份
String username = request.getParameter("username");
logger.debug("username:"+username);

//订单流水
String seq = request.getParameter("seq");
logger.debug("seq:"+seq);

//4、生成无状态Token
StatelessToken token = new StatelessToken(username, seq, clientDigest);

try {
//5、委托给Realm进行登录
logger.debug("try login");
getSubject(request, response).login(token);
} catch (Exception e) {
e.printStackTrace();
logger.error(e.getMessage());
onLoginFail(response); //6、登录失败
return false;
}
return true;
}

//登录失败时默认返回401状态码
private void onLoginFail(ServletResponse response) throws IOException {
HttpServletResponse httpResponse = (HttpServletResponse) response;
httpResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
response.setContentType("text/html;charset=utf-8");
String errmsg = "{\"err\":\"005\", \"msg\":\"没有权限\"}";
httpResponse.getWriter().write(errmsg);
}

}

AccessControlFilter是shiro-web模块当中比较重要的类，所有的拦截器都继承此类。它提供了访问控制的基础功能；比如是否允许访问/当访问拒绝时如何处理。

isAccessAllowed方法表示是否允许访问，如果允许访问返回true，否则false；

onAccessDenied方法表示当访问拒绝时是否已经处理了；如果返回true表示需要继续处理；如果返回false表示该拦截器实例已经处理了，将直接返回即可。

在onAccessDenied方法里，我获取客户端传递的用户名，流水号以及摘要字段，并用这些字段生成一个token用于验证(login)。流程如下:

首先调用Subject.login(token)进行登录，其会自动委托给Security Manager，调用之前必须通过SecurityUtils. setSecurityManager()设置；

SecurityManager负责真正的身份验证逻辑；它会委托给Authenticator进行身份验证；Authenticator才是真正的身份验证者，Shiro API中核心的身份认证入口点，此处可以自定义插入自己的实现；

Authenticator会把相应的token传入Realm，从Realm获取身份验证信息，如果没有返回/抛出异常表示身份验证失败了。

所以下面就是自定义realm了，

public class StatelessRealm extends AuthorizingRealm{

private static Logger logger = LoggerFactory.getLogger(StatelessRealm.class);

//判断此Realm是否支持此Token
@Override
public boolean supports(AuthenticationToken token) {

//仅支持StatelessToken类型的Token
return token instanceof StatelessToken;
}

//Authenticator才是真正的身份验证者，Shiro API中核心的身份认证入口点，此处可以自定义插入自己的实现
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

logger.debug("doGetAuthenticationInfo");

StatelessToken statelessToken = (StatelessToken) token;
String username = statelessToken.getUsername();
logger.debug("username:"+username);

String key = getKey(username);//根据用户名获取密钥（和客户端的一样）
//在服务器端生成客户端参数消息摘要
String serverDigest = HmacSHA256Utils.digest(key, statelessToken.getSeq());

//然后进行客户端消息摘要和服务器端消息摘要的匹配
return new SimpleAuthenticationInfo(
username,
serverDigest,
getName());
}

private String getKey(String username) {//得到密钥，此处硬编码一个
if("admin".equals(username)) {
return "aaaaaa22222222333333";
}
return null;
}

}

AuthorizingRealm负责授权，通常自定义的realm继承AuthorizingRealm。Shiro从从Realm获取安全数据，然后和客户端传递的进行比较验证用户身份的合法性。

简单起见，我写了一个固定密钥，没有从数据库中取，不过原理是一样的。

最后是StatelessToken的实现,

public class StatelessToken implements AuthenticationToken{

/**
*
*/
private static final long serialVersionUID = 1L;

private static Logger logger = LoggerFactory.getLogger(StatelessToken.class);

private String username;
private String seq; //流水号
private String clientDigest;

public StatelessToken(String username,  String seq, String clientDigest) {

logger.debug("StatelessToken");
this.username = username;
this.seq = seq;
this.clientDigest = clientDigest;
}

public String getSeq() {
return seq;
}

public void setSeq(String seq) {
this.seq = seq;
}

public String getUsername() {
return username;
}

public void setUsername(String username) {
this.username = username;
}

public String getClientDigest() {
return clientDigest;
}

public void setClientDigest(String clientDigest) {
this.clientDigest = clientDigest;
}

@Override
public Object getCredentials() {
return clientDigest;
}

@Override
public Object getPrincipal() {
return username;
}

}

shiro的配置文件如下,都加了注释说明，不多讲了。

<!--statelessReealm-->
<bean id="statelessRealm" class="com.inn.pay.shiro.StatelessRealm">

</bean>

<!-- Subject工厂 -->
<bean id="subjectFactory" class="com.inn.pay.shiro.StatelessDefaultSubjectFactory"/>

<!-- 会话管理器 -->
<bean id="sessionManager" class="org.apache.shiro.session.mgt.DefaultSessionManager">
<property name="sessionValidationSchedulerEnabled" value="false"/>
</bean>

<!--配置securityManager-->
<!-- Shiro安全管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<property name="realm" ref="statelessRealm"/>
<property name="subjectDAO.sessionStorageEvaluator.sessionStorageEnabled"  value="false"/>
<property name="subjectFactory" ref="subjectFactory"/>
<property name="sessionManager" ref="sessionManager"/>
</bean>

<!-- 相当于调用SecurityUtils.setSecurityManager(securityManager) -->
<bean class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="staticMethod"
value="org.apache.shiro.SecurityUtils.setSecurityManager"/>
<property name="arguments" ref="securityManager"/>
</bean>

<!--statelessFilter-->
<bean id="statelessAuthcFilter" class="com.inn.pay.shiro.StatelessAuthcFilter"/>

<!--配置shiroFilter-->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<!-- Shiro的核心安全接口，这个属性是必须的 -->
<property name="securityManager" ref="securityManager"/>
<property name="filters">
<util:map>
<entry key="statelessAuthc" value-ref="statelessAuthcFilter"/>
</util:map>
</property>
<!--过滤链定义-->
<property name="filterChainDefinitions">
<value>
/core/getNotify=anon
/core/**=statelessAuthc
</value>
</property>
</bean>

<!-- Shiro生命周期处理器-->
<bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>

有一处特殊强调下：

<property name="filterChainDefinitions">
<value>
/core/getNotify=anon
/core/**=statelessAuthc
</value>
</property>

filterChainDefinitions的配置顺序为自上而下,以最上面的为准, 如果你写成这样:

<property name="filterChainDefinitions">
<value>
/core/**=statelessAuthc
/core/getNotify=anon
</value>
</property>

效果是完全不同的。可以自己试试。

参考

第二十章 无状态Web应用集成——《跟我学Shiro》