安全框架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)。流程如下:

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

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

3. 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》