Apache Shiro 是功能强大并且容易集成的开源权限框架，它能够完成认证、授权、加密、会话管理等功能。认证和授权为权限控制的核心，简单来说，“认证”就是证明你是谁？ Web 应用程序一般做法通过表单提交用户名及密码达到认证目的。“授权”即是否允许已认证用户访问受保护资源。关于 Shiro 的一系列特征及优点，很多文章已有列举，这里不再逐一赘述，本文重点介绍 Shiro 在 Web Application 中如何实现验证码认证以及如何实现单点登录。

用户权限模型

在揭开 Shiro 面纱之前，我们需要认知用户权限模型。本文所提到用户权限模型，指的是用来表达用户信息及用户权限信息的数据模型。即能证明“你是谁？”、“你能访问多少 受保护资源？”。为实现一个较为灵活的用户权限数据模型，通常把用户信息单独用一个实体表示，用户权限信息用两个实体表示。

  1. 用户信息用 LoginAccount 表示，最简单的用户信息可能只包含用户名 loginName 及密码 password 两个属性。实际应用中可能会包含用户是否被禁用，用户信息是否过期等信息。
  2. 用户权限信息用 Role 与 Permission 表示，Role 与 Permission 之间构成多对多关系。Permission 可以理解为对一个资源的操作，Role 可以简单理解为 Permission 的集合。
  3. 用户信息与 Role 之间构成多对多关系。表示同一个用户可以拥有多个 Role，一个 Role 可以被多个用户所拥有。

图 1. 用户权限模型 

图 1. 用户权限模型

 

认证与授权

Shiro 认证与授权处理过程

  • 被 Shiro 保护的资源，才会经过认证与授权过程。使用 Shiro 对 URL 进行保护可以参见“与 Spring 集成”章节。
  • 用户访问受 Shiro 保护的 URL；例如 http://host/security/action.do。
  • Shiro 首先检查用户是否已经通过认证，如果未通过认证检查，则跳转到登录页面，否则进行授权检查。认证过程需要通过 Realm 来获取用户及密码信息，通常情况我们实现 JDBC Realm，此时用户认证所需要的信息从数据库获取。如果使用了缓存，除第一次外用户信息从缓存获取。
  • 认证通过后接受 Shiro 授权检查，授权检查同样需要通过 Realm 获取用户权限信息。Shiro 需要的用户权限信息包括 Role 或 Permission，可以是其中任何一种或同时两者，具体取决于受保护资源的配置。如果用户权限信息未包含 Shiro 需要的 Role 或 Permission，授权不通过。只有授权通过，才可以访问受保护 URL 对应的资源，否则跳转到“未经授权页面”。

Shiro Realm

在 Shiro 认证与授权处理过程中，提及到 Realm。Realm 可以理解为读取用户信息、角色及权限的 DAO。由于大多 Web 应用程序使用了关系数据库，因此实现 JDBC Realm 是常用的做法，后面会提到 CAS Realm，另一个 Realm 的实现。

清单 1. 实现自己的 JDBC Realm

 

 

01 public class MyShiroRealm extendsAuthorizingRealm{
02    
03    // 用于获取用户信息及用户权限信息的业务接口
04    privateBusinessManager businessManager;
05     
06    // 获取授权信息
07    protectedAuthorizationInfo doGetAuthorizationInfo(
08       PrincipalCollection principals) {
09       String username = (String) principals.fromRealm(
10          getName()).iterator().next();
11       
12       if( username != null){
13       // 查询用户授权信息
14          Collection<String> pers=businessManager.queryPermissions(username);
15          if( pers != null&& !pers.isEmpty() ){
16             SimpleAuthorizationInfo info = newSimpleAuthorizationInfo();
17             for( String each:pers )
18                info.addStringPermissions( each );
19             
20             returninfo;
21          }
22       }
23       
24       returnnull;
25    }
26    
27    // 获取认证信息
28    protectedAuthenticationInfo doGetAuthenticationInfo(
29       AuthenticationToken authcToken ) throwsAuthenticationException {
30       UsernamePasswordToken token = (UsernamePasswordToken) authcToken;
31       // 通过表单接收的用户名
32       String username = token.getUsername();
33       
34       if( username != null&& !"".equals(username) ){
35          LoginAccount account = businessManager.get( username );
36          
37          if( account != null){
38             return newSimpleAuthenticationInfo(
39                account.getLoginName(),account.getPassword(),getName() );
40          }
41       }
42       
43       returnnull;
44    }
45  }

 

 

代码说明：

  1. businessManager 表示从数据库获取用户信息及用户权限信息的业务类，实际情况中可能因用户权限模型设计不同或持久化框架选择不同，这里没给出示例代码。
  2. doGetAuthenticationInfo 方法，取用户信息。对照用户权限模型来说，就是取 LoginAccount 实体。最终我们需要为 Shiro 提供 AuthenticationInfo 对象。
  3. doGetAuthorizationInfo 方法，获取用户权限信息。代码给出了获取用户 Permission 的示例，获取用户 Role 的代码类似。为 Shiro 提供的用户权限信息以 AuthorizationInfo 对象形式返回。

为何对 Shiro 情有独钟

或许有人要问，我一直在使用 Spring，应用程序的安全组件早已选择了 Spring Security，为什么还需要 Shiro ？当然，不可否认 Spring Security 也是一款优秀的安全控制组件。本文的初衷不是让您必须选择 Shiro 以及必须放弃 Spring Security，秉承客观的态度，下面对两者略微比较：

  1. 简单性，Shiro 在使用上较 Spring Security 更简单，更容易理解。
  2. 灵活性，Shiro 可运行在 Web、EJB、IoC、Google App Engine 等任何应用环境，却不依赖这些环境。而 Spring Security 只能与 Spring 一起集成使用。
  3. 可插拔，Shiro 干净的 API 和设计模式使它可以方便地与许多的其它框架和应用进行集成。Shiro 可以与诸如 Spring、Grails、Wicket、Tapestry、Mule、Apache Camel、Vaadin 这类第三方框架无缝集成。Spring Security 在这方面就显得有些捉衿见肘。

 

 

与 Spring 集成

在 Java Web Application 开发中，Spring 得到了广泛使用；与 EJB 相比较，可以说 Spring 是主流。Shiro 自身提供了与 Spring 的良好支持，在应用程序中集成 Spring 十分容易。

有了前面提到的用户权限数据模型，并且实现了自己的 Realm，我们就可以开始集成 Shiro 为应用程序服务了。

Shiro 的安装

Shiro 的安装非常简单，在 Shiro 官网下载 shiro-all-1.2.0.jar、shiro-cas-1.2.0.jar（单点登录需要），及 SLF4J 官网下载 Shiro 依赖的日志组件 slf4j-api-1.6.1.jar。Spring 相关的 JAR 包这里不作列举。这些 JAR 包需要放置到 Web 工程 /WEB-INF/lib/ 目录。至此，剩下的就是配置了。

配置过滤器

首先，配置过滤器让请求资源经过 Shiro 的过滤处理，这与其它过滤器的使用类似。

web.xml

01 <filter>
02    <filter-name>shiroFilter</filter-name>
03    <filter-class>
04       org.springframework.web.filter.DelegatingFilterProxy
05    </filter-class>
06  </filter>
07  <filter-mapping>
08    <filter-name>shiroFilter</filter-name>
09    <url-pattern>/*</url-pattern>
10  </filter-mapping>

Spring 配置

接下来仅仅配置一系列由 Spring 容器管理的 Bean，集成大功告成。各个 Bean 的功能见代码说明。

01 <bean id="shiroFilter"class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
02    <property name="securityManager"ref="securityManager"/>
03    <property name="loginUrl"value="/login.do"/>
04    <property name="successUrl"value="/welcome.do"/>
05    <property name="unauthorizedUrl"value="/403.do"/>
06    <propertyname="filters">
07       <util:map>
08          <entry key="authc"value-ref="formAuthenticationFilter"/>
09       </util:map>
10    </property>
11    <propertyname="filterChainDefinitions">
12       <value>
13          /=anon
14          /login.do*=authc
15          /logout.do*=anon
16          
17          # 权限配置示例
18          /security/account/view.do=authc,perms[SECURITY_ACCOUNT_VIEW]
19          
20          /** = authc
21       </value>
22    </property>
23  </bean>
24  
25  <bean id="securityManager"
26    class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
27    <property name="realm"ref="myShiroRealm"/>
28  </bean>
29  
30  <bean id="myShiroRealm"class="xxx.packagename.MyShiroRealm">
31    <!-- businessManager 用来实现用户名密码的查询 -->
32    <property name="businessManager"ref="businessManager"/>
33    <property name="cacheManager"ref="shiroCacheManager"/>
34  </bean>
35  
36  <bean id="lifecycleBeanPostProcessor"
37     class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>
38  
39  <bean id="shiroCacheManager"
40    class="org.apache.shiro.cache.ehcache.EhCacheManager">
41    <property name="cacheManager"ref="cacheManager"/>
42  </bean>
43  
44  <bean id="formAuthenticationFilter"
45    class="org.apache.shiro.web.filter.authc.FormAuthenticationFilter"/>

代码说明：

  1. shiroFilter 中 loginUrl 为登录页面地址，successUrl 为登录成功页面地址（如果首先访问受保护 URL 登录成功，则跳转到实际访问页面），unauthorizedUrl 认证未通过访问的页面（前面提到的“未经授权页面”）。
  2. shiroFilter 中 filters 属性，formAuthenticationFilter 配置为基于表单认证的过滤器。
  3. shiroFilter 中 filterChainDefinitions 属性，anon 表示匿名访问（不需要认证与授权），authc 表示需要认证，perms[SECURITY_ACCOUNT_VIEW] 表示用户需要提供值为“SECURITY_ACCOUNT_VIEW”Permission 信息。由此可见，连接地址配置为 authc 或 perms[XXX] 表示为受保护资源。
  4. securityManager 中 realm 属性，配置为我们自己实现的 Realm。关于 Realm，参见前面“Shiro Realm”章节。
  5. myShiroRealm 为我们自己需要实现的 Realm 类，为了减小数据库压力，添加了缓存机制。
  6. shiroCacheManager 是 Shiro 对缓存框架 EhCache 的配置。

实现验证码认证

验证码是有效防止暴力破解的一种手段，常用做法是在服务端产生一串随机字符串与当前用户会话关联（我们通常说的放入 Session），然后向终端用户展现一张经过“扰乱”的图片，只有当用户输入的内容与服务端产生的内容相同时才允许进行下一步操作。

产生验证码

作为演示，我们选择开源的验证码组件 kaptcha。这样，我们只需要简单配置一个 Servlet，页面通过 IMG 标签就可以展现图形验证码。

01 <!-- captcha servlet-->
02  <servlet>
03    <servlet-name>kaptcha</servlet-name>
04    <servlet-class>
05       com.google.code.kaptcha.servlet.KaptchaServlet
06    </servlet-class>
07  </servlet>
08  <servlet-mapping>
09  <servlet-name>kaptcha</servlet-name>
10  <url-pattern>/images/kaptcha.jpg</url-pattern>
11  </servlet-mapping>

扩展 UsernamePasswordToken

Shiro 表单认证，页面提交的用户名密码等信息，用 UsernamePasswordToken 类来接收，很容易想到，要接收页面验证码的输入，我们需要扩展此类：

01 public class CaptchaUsernamePasswordToken extendsUsernamePasswordToken{
02  
03  privateString captcha;
04  
05  // 省略 getter 和 setter 方法
06  
07  publicCaptchaUsernamePasswordToken(String username, char[] password,
08  booleanrememberMe, String host,String captcha) {
09  super(username, password, rememberMe, host);
10  this.captcha = captcha;
11  }
12  }

扩展 FormAuthenticationFilter

接下来我们扩展 FormAuthenticationFilter 类，首先覆盖 createToken 方法，以便获取 CaptchaUsernamePasswordToken 实例；然后增加验证码校验方法 doCaptchaValidate；最后覆盖 Shiro 的认证方法 executeLogin，在原表单认证逻辑处理之前进行验证码校验。

01 public class CaptchaFormAuthenticationFilter extendsFormAuthenticationFilter{
02  
03    public static finalString DEFAULT_CAPTCHA_PARAM = "captcha";
04    
05    privateString captchaParam = DEFAULT_CAPTCHA_PARAM;
06    
07    publicString getCaptchaParam() {
08       returncaptchaParam;
09    }
10    
11    public voidsetCaptchaParam(String captchaParam) {
12       this.captchaParam = captchaParam;
13    }
14    
15    protectedString getCaptcha(ServletRequest request) {
16       returnWebUtils.getCleanParam(request, getCaptchaParam());
17    }
18    
19    // 创建 Token
20    protectedCaptchaUsernamePasswordToken createToken(
21       ServletRequest request, ServletResponse response) {
22    
23       String username = getUsername(request);
24       String password = getPassword(request);
25       String captcha = getCaptcha(request);
26       booleanrememberMe = isRememberMe(request);
27       String host = getHost(request);
28                    
29       return newCaptchaUsernamePasswordToken(
30          username, password, rememberMe, host,captcha);
31    }
32    
33    // 验证码校验
34    protected voiddoCaptchaValidate( HttpServletRequest request
35       ,CaptchaUsernamePasswordToken token ){
36  
37       String captcha = (String)request.getSession().getAttribute(
38          com.google.code.kaptcha.Constants.KAPTCHA_SESSION_KEY);
39       
40       if( captcha!=null&&
41          !captcha.equalsIgnoreCase(token.getCaptcha()) ){
42          throw newIncorrectCaptchaException ("验证码错误！");
43       }
44    }
45     
46    // 认证
47    protected booleanexecuteLogin(ServletRequest request,
48       ServletResponse response) throwsException {
49       CaptchaUsernamePasswordToken token = createToken(request, response);
50        
51       try{
52          doCaptchaValidate( (HttpServletRequest)request,token );
53                  
54          Subject subject = getSubject(request, response);
55          subject.login(token);
56                      
57          returnonLoginSuccess(token, subject, request, response);
58       } catch(AuthenticationException e) {
59          returnonLoginFailure(token, e, request, response);
60       }
61    }
62  
63  }

代码说明：

  1. 添加 captchaParam 变量，为的是页面表单提交验证码的参数名可以进行灵活配置。
  2. doCaptchaValidate 方法中，验证码校验使用了框架 KAPTCHA 所提供的 API。

添加 IncorrectCaptchaException

前面验证码校验不通过，我们抛出一个异常 IncorrectCaptchaException，此类继承 AuthenticationException，之所以需要扩展一个新的异常类，为的是在页面能更精准显示错误提示信息。

01 public class IncorrectCaptchaException extendsAuthenticationException{
02    
03    publicIncorrectCaptchaException() {
04       super();
05    }
06    
07    publicIncorrectCaptchaException(String message, Throwable cause) {
08       super(message, cause);
09    }
10    
11    publicIncorrectCaptchaException(String message) {
12       super(message);
13    }
14    
15    publicIncorrectCaptchaException(Throwable cause) {
16       super(cause);
17    }
18  }

页面展现验证码错误提示信息

01 Object obj=request.getAttribute(
02    org.apache.shiro.web.filter.authc.FormAuthenticationFilter
03       .DEFAULT_ERROR_KEY_ATTRIBUTE_NAME);
04  AuthenticationException authExp = (AuthenticationException)obj;
05  if( authExp != null){
06    String expMsg="";
07    
08    if(authExp instanceofUnknownAccountException ||
09       authExp instanceofIncorrectCredentialsException){
10       expMsg="错误的用户账号或密码！";
11    }else if( authExp instanceofIncorrectCaptchaException){
12       expMsg="验证码错误！";
13    }else{
14       expMsg="登录异常 :"+authExp.getMessage() ;
15    }
16     
17    out.print("<div class=\"error\">"+expMsg+"</div>");
18  }

实现单点登录

前面章节，我们认识了 Shiro 的认证与授权，并结合 Spring 作了集成实现。现实中，有这样一个场景，我们拥有很多业务系统，按照前面的思路，如果访问每个业务系统，都要进行认证，这样是否有点难让人授受。有没有一 种机制，让我们只认证一次，就可以任意访问目标系统呢？

上面的场景，就是我们常提到的单点登录 SSO。Shiro 从 1.2 版本开始对 CAS 进行支持，CAS 就是单点登录的一种实现。

Shiro CAS 认证流程

  • 用户首次访问受保护的资源；例如 http://casclient/security/view.do
  • 由于未通过认证，Shiro 首先把请求地址（http://casclient/security/view.do）缓存起来。
  • 然后跳转到 CAS 服务器进行登录认证，在 CAS 服务端认证完成后需要返回到请求的 CAS 客户端，因此在请求时，必须在参数中添加返回地址 ( 在 Shiro 中名为 CAS Service)。 例如 http://casserver/login?service=http://casclient/shiro-cas
  • 由 CAS 服务器认证通过后，CAS 服务器为返回地址添加 ticket。例如 http://casclient/shiro-cas?ticket=ST-4-BWMEnXfpxfVD2jrkVaLl-cas
  • 接下来，Shiro 会校验 ticket 是否有效。由于 CAS 客户端不提供直接认证，所以 Shiro 会向 CAS 服务端发起 ticket 校验检查，只有服务端返回成功时，Shiro 才认为认证通过。
  • 认证通过，进入授权检查。Shiro 授权检查与前面提到的相同。
  • 最后授权检查通过，用户正常访问到 http://casclient/security/view.do。

CAS Realm

Shiro 提供了一个名为 CasRealm 的类，与前面提到的 JDBC Realm 相似，该类同样包括认证和授权两部分功能。认证就是校验从 CAS 服务端返回的 ticket 是否有效；授权还是获取用户权限信息。

实现单点登录功能，需要扩展 CasRealm 类。

01 public class MyCasRealm extendsCasRealm{
02    
03    // 获取授权信息
04    protectedAuthorizationInfo doGetAuthorizationInfo(
05       PrincipalCollection principals) {
06       //... 与前面 MyShiroRealm 相同
07    }
08    
09     publicString getCasServerUrlPrefix() {
10       return"http://casserver/login";
11    }
12    
13    publicString getCasService() {
14       return"http://casclient/shiro-cas";
15    }
16  }

代码说明：

  1. doGetAuthorizationInfo 获取授权信息与前面章节“实现自己的 JDBC Realm”相同。
  2. 认证功能由 Shiro 自身提供的 CasRealm 实现。
  3. getCasServerUrlPrefix 方法返回 CAS 服务器地址，实际使用一般通过参数进行配置。
  4. getCasService 方法返回 CAS 客户端处理地址，实际使用一般通过参数进行配置。
  5. 认证过程需 keystore，否则会出现异常。可以通过设置系统属性的方式来指定，例如 System.setProperty("javax.net.ssl.trustStore","keystore-file");

CAS Spring 配置

实现单点登录的 Spring 配置与前面类似，不同之处参见代码说明。

01 <bean id="shiroFilter"
02    class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
03    <property name="securityManager"ref="securityManager"/>
04    <property name="loginUrl"
05       value="http://casserver/login?service=http://casclient/shiro-cas"/>
06    <property name="successUrl"value="/welcome.do"/>
07    <property name="unauthorizedUrl"value="/403.do"/>
08    <propertyname="filters">
09       <util:map>
10          <entry key="authc"value-ref="formAuthenticationFilter"/>
11          <entry key="cas"value-ref="casFilter"/>
12       </util:map>
13    </property>
14    <propertyname="filterChainDefinitions">
15       <value>
16          /shiro-cas*=cas
17          /logout.do*=anon
18          /casticketerror.do*=anon
19           
20          # 权限配置示例
21          /security/account/view.do=authc,perms[SECURITY_ACCOUNT_VIEW]
22           
23          /** = authc
24       </value>
25    </property>
26  </bean>
27  
28  <bean id="securityManager"
29    class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
30    <property name="realm"ref="myShiroRealm"/>
31  </bean>