Spring Security（16）——基于表達式的權限控制

目錄

<a href="#_Toc431483135">1.1      通過表達式控制URL權限</a>

<a href="#_Toc431483136">1.2      通過表達式控制方法權限</a>

<a href="#_Toc431483137">1.2.1     使用@PreAuthorize和@PostAuthorize進行通路控制</a>

<a href="#_Toc431483138">1.2.2     使用@PreFilter和@PostFilter進行過濾</a>

<a href="#_Toc431483139">1.3      使用hasPermission表達式</a>

       Spring Security允許我們在定義URL通路或方法通路所應有的權限時使用Spring EL表達式，在定義所需的通路權限時如果對應的表達式傳回結果為true則表示擁有對應的權限，反之則無。Spring Security可用表達式對象的基類是SecurityExpressionRoot，其為我們提供了如下在使用Spring EL表達式對URL或方法進行權限控制時通用的内置表達式。

表達式

描述

hasRole([role])

目前使用者是否擁有指定角色。

hasAnyRole([role1,role2])

多個角色是一個以逗号進行分隔的字元串。如果目前使用者擁有指定角色中的任意一個則傳回true。

hasAuthority([auth])

等同于hasRole

hasAnyAuthority([auth1,auth2])

等同于hasAnyRole

Principle

代表目前使用者的principle對象

authentication

直接從SecurityContext擷取的目前Authentication對象

permitAll

總是傳回true，表示允許所有的

denyAll

總是傳回false，表示拒絕所有的

isAnonymous()

目前使用者是否是一個匿名使用者

isRememberMe()

表示目前使用者是否是通過Remember-Me自動登入的

isAuthenticated()

表示目前使用者是否已經登入認證成功了。

isFullyAuthenticated()

如果目前使用者既不是一個匿名使用者，同時又不是通過Remember-Me自動登入的，則傳回true。

       URL的通路權限是通過http元素下的intercept-url元素進行定義的，其access屬性用來定義通路配置屬性。預設情況下該屬性值隻能是以字元串進行分隔的字元串清單，且每一個元素都對應着一個角色，因為預設使用的是RoleVoter。通過設定http元素的use-expressions=”true”可以啟用intercept-url元素的access屬性對Spring EL表達式的支援，use-expressions的值預設為false。啟用access屬性對Spring EL表達式的支援後每個access屬性值都應該是一個傳回結果為boolean類型的表達式，當表達式傳回結果為true時表示目前使用者擁有通路權限。此外WebExpressionVoter将加入AccessDecisionManager的AccessDecisionVoter清單，是以如果不使用NameSpace時應當手動添加WebExpressionVoter到AccessDecisionVoter。

   &lt;security:http use-expressions="true"&gt;

      &lt;security:form-login/&gt;

      &lt;security:logout/&gt;

      &lt;security:intercept-url pattern="/**" access="hasRole('ROLE_USER')" /&gt;

   &lt;/security:http&gt;

       在上述配置中我們定義了隻有擁有ROLE_USER角色的使用者才能通路系統。

       使用表達式控制URL權限使用的表達式對象類是繼承自SecurityExpressionRoot的WebSecurityExpressionRoot類。其相比基類而言新增了一個表達式hasIpAddress。hasIpAddress可用來限制隻有指定IP或指定範圍内的IP才可以通路。

      &lt;security:intercept-url pattern="/**" access="hasRole('ROLE_USER') and hasIpAddress('10.10.10.3')" /&gt;

       在上面的配置中我們限制了隻有IP為”10.10.10.3”，且擁有ROLE_USER角色的使用者才能通路。hasIpAddress是通過Ip位址或子網路遮罩來進行比對的。如果要設定10.10.10下所有的子網都可以使用，那麼我們對應的hasIpAddress的參數應為“10.10.10.n/24”，其中n可以是合法IP内的任意值。具體規則可以參照hasIpAddress()表達式用于比較的IpAddressMatcher的matches方法源碼。以下是IpAddressMatcher的源碼。

package org.springframework.security.web.util;

import java.net.InetAddress;

import java.net.UnknownHostException;

import java.util.Arrays;

import javax.servlet.http.HttpServletRequest;

import org.springframework.util.StringUtils;

/**

 * Matches a request based on IP Address or subnet mask matching against the remote address.

 * &lt;p&gt;

 * Both IPv6 and IPv4 addresses are supported, but a matcher which is configured with an IPv4 address will

 * never match a request which returns an IPv6 address, and vice-versa.

 *

 * @author Luke Taylor

 * @since 3.0.2

 */

public final class IpAddressMatcher implements RequestMatcher {

    private final int nMaskBits;

    private final InetAddress requiredAddress;

    /**

     * Takes a specific IP address or a range specified using the

     * IP/Netmask (e.g. 192.168.1.0/24 or 202.24.0.0/14).

     *

     * @param ipAddress the address or range of addresses from which the request must come.

     */

    public IpAddressMatcher(String ipAddress) {

        if (ipAddress.indexOf('/') &gt; 0) {

            String[] addressAndMask = StringUtils.split(ipAddress, "/");

            ipAddress = addressAndMask[0];

            nMaskBits = Integer.parseInt(addressAndMask[1]);

        } else {

            nMaskBits = -1;

        }

        requiredAddress = parseAddress(ipAddress);

    }

    public boolean matches(HttpServletRequest request) {

        return matches(request.getRemoteAddr());

    public boolean matches(String address) {

        InetAddress remoteAddress = parseAddress(address);

        if (!requiredAddress.getClass().equals(remoteAddress.getClass())) {

            return false;

        if (nMaskBits &lt; 0) {

            return remoteAddress.equals(requiredAddress);

        byte[] remAddr = remoteAddress.getAddress();

        byte[] reqAddr = requiredAddress.getAddress();

        int oddBits = nMaskBits % 8;

        int nMaskBytes = nMaskBits/8 + (oddBits == 0 ? 0 : 1);

        byte[] mask = newbyte[nMaskBytes];

        Arrays.fill(mask, 0, oddBits == 0 ? mask.length : mask.length - 1, (byte)0xFF);

        if (oddBits != 0) {

            int finalByte = (1 &lt;&lt; oddBits) - 1;

            finalByte &lt;&lt;= 8-oddBits;

            mask[mask.length - 1] = (byte) finalByte;

 //       System.out.println("Mask is " + new sun.misc.HexDumpEncoder().encode(mask));

        for (int i=0; i &lt; mask.length; i++) {

            if ((remAddr[i] &amp; mask[i]) != (reqAddr[i] &amp; mask[i])) {

                return alse;

            }

        return true;

    private InetAddress parseAddress(String address) {

        try {

            return InetAddress.getByName(address);

        } catch (UnknownHostException e) {

            thrownew IllegalArgumentException("Failed to parse address" + address, e);

}

       Spring Security中定義了四個支援使用表達式的注解，分别是@PreAuthorize、@PostAuthorize、@PreFilter和@PostFilter。其中前兩者可以用來在方法調用前或者調用後進行權限檢查，後兩者可以用來對集合類型的參數或者傳回值進行過濾。要使它們的定義能夠對我們的方法的調用産生影響我們需要設定global-method-security元素的pre-post-annotations=”enabled”，預設為disabled。

   &lt;security:global-method-security pre-post-annotations="disabled"/&gt;

       @PreAuthorize可以用來控制一個方法是否能夠被調用。

@Service

public class UserServiceImpl implements UserService {

   @PreAuthorize("hasRole('ROLE_ADMIN')")

   public void addUser(User user) {

      System.out.println("addUser................" + user);

   }

   @PreAuthorize("hasRole('ROLE_USER') or hasRole('ROLE_ADMIN')")

   public User find(int id) {

      System.out.println("find user by id............." + id);

      return null;

       在上面的代碼中我們定義了隻有擁有角色ROLE_ADMIN的使用者才能通路adduser()方法，而通路find()方法需要有ROLE_USER角色或ROLE_ADMIN角色。使用表達式時我們還可以在表達式中使用方法參數。

   /**

    * 限制隻能查詢Id小于10的使用者

    */

   @PreAuthorize("#id&lt;10")

      System.out.println("find user by id........." + id);

    * 限制隻能查詢自己的資訊

   @PreAuthorize("principal.username.equals(#username)")

   public User find(String username) {

      System.out.println("find user by username......" + username);

    * 限制隻能新增使用者名稱為abc的使用者

   @PreAuthorize("#user.name.equals('abc')")

   public void add(User user) {

      System.out.println("addUser............" + user);

       在上面代碼中我們定義了調用find(int id)方法時，隻允許參數id小于10的調用；調用find(String username)時隻允許username為目前使用者的使用者名；定義了調用add()方法時隻有當參數user的name為abc時才可以調用。

       有時候可能你會想在方法調用完之後進行權限檢查，這種情況比較少，但是如果你有的話，Spring Security也為我們提供了支援，通過@PostAuthorize可以達到這一效果。使用@PostAuthorize時我們可以使用内置的表達式returnObject表示方法的傳回值。我們來看下面這一段示例代碼。

   @PostAuthorize("returnObject.id%2==0")

      User user = new User();

      user.setId(id);

      return user;

       上面這一段代碼表示将在方法find()調用完成後進行權限檢查，如果傳回值的id是偶數則表示校驗通過，否則表示校驗失敗，将抛出AccessDeniedException。       需要注意的是@PostAuthorize是在方法調用完成後進行權限檢查，它不能控制方法是否能被調用，隻能在方法調用完成後檢查權限決定是否要抛出AccessDeniedException。

       使用@PreFilter和@PostFilter可以對集合類型的參數或傳回值進行過濾。使用@PreFilter和@PostFilter時，Spring Security将移除使對應表達式的結果為false的元素。

   @PostFilter("filterObject.id%2==0")

   public List&lt;User&gt; findAll() {

      List&lt;User&gt; userList = new ArrayList&lt;User&gt;();

      User user;

      for (int i=0; i&lt;10; i++) {

         user = new User();

         user.setId(i);

         userList.add(user);

      }

      return userList;

       上述代碼表示将對傳回結果中id不為偶數的user進行移除。filterObject是使用@PreFilter和@PostFilter時的一個内置表達式，表示集合中的目前對象。當@PreFilter标注的方法擁有多個集合類型的參數時，需要通過@PreFilter的filterTarget屬性指定目前@PreFilter是針對哪個參數進行過濾的。如下面代碼就通過filterTarget指定了目前@PreFilter是用來過濾參數ids的。

   @PreFilter(filterTarget="ids", value="filterObject%2==0")

   public void delete(List&lt;Integer&gt; ids, List&lt;String&gt; usernames) {

      ...

       Spring Security為我們定義了hasPermission的兩種使用方式，它們分别對應着PermissionEvaluator的兩個不同的hasPermission()方法。Spring Security預設處理Web、方法的表達式處理器分别為DefaultWebSecurityExpressionHandler和DefaultMethodSecurityExpressionHandler，它們都繼承自AbstractSecurityExpressionHandler，其所持有的PermissionEvaluator是DenyAllPermissionEvaluator，其對于所有的hasPermission表達式都将傳回false。是以當我們要使用表達式hasPermission時，我們需要自已手動定義SecurityExpressionHandler對應的bean定義，然後指定其PermissionEvaluator為我們自己實作的PermissionEvaluator，然後通過global-method-security元素或http元素下的expression-handler元素指定使用的SecurityExpressionHandler為我們自己手動定義的那個bean。

       接下來看一個自己實作PermissionEvaluator使用hasPermission()表達式的簡單示例。

       首先實作自己的PermissionEvaluator，如下所示：

public class MyPermissionEvaluator implements PermissionEvaluator {

   public boolean hasPermission(Authentication authentication,

         Object targetDomainObject, Object permission) {

      if ("user".equals(targetDomainObject)) {

         return this.hasPermission(authentication, permission);

      return false;

    * 總是認為有權限

         Serializable targetId, String targetType, Object permission) {

      return true;

    * 簡單的字元串比較，相同則認為有權限

   private boolean hasPermission(Authentication authentication, Object permission) {

      Collection&lt;? extends GrantedAuthority&gt; authorities = authentication.getAuthorities();

      for (GrantedAuthority authority : authorities) {

         if (authority.getAuthority().equals(permission)) {

            returntrue;

         }

       接下來在ApplicationContext中顯示的配置一個将使用PermissionEvaluator的SecurityExpressionHandler實作類，然後指定其所使用的PermissionEvaluator為我們自己實作的那個。這裡我們選擇配置一個針對于方法調用使用的表達式處理器，DefaultMethodSecurityExpressionHandler，具體如下所示。

   &lt;bean id="expressionHandler"

   class="org.springframework.security.access.expression.method.DefaultMethodSecurityExpressionHandler"&gt;

      &lt;property name="permissionEvaluator" ref="myPermissionEvaluator" /&gt;

   &lt;/bean&gt;

   &lt;!-- 自定義的PermissionEvaluator實作 --&gt;

   &lt;bean id="myPermissionEvaluator" class="com.xxx.MyPermissionEvaluator"/&gt;

       有了SecurityExpressionHandler之後，我們還要告訴Spring Security，在使用SecurityExpressionHandler時應該使用我們顯示配置的那個，這樣我們自定義的PermissionEvaluator才能起作用。因為我們上面定義的是針對于方法的SecurityExpressionHandler，是以我們要指定在進行方法權限控制時應該使用它來進行處理，同時注意設定pre-post-annotations=”true”以啟用對支援使用表達式的@PreAuthorize等注解的支援。

   &lt;security:global-method-security

      pre-post-annotations="enabled"&gt;

      &lt;security:expression-handler ref="expressionHandler" /&gt;

   &lt;/security:global-method-security&gt;

       之後我們就可以在需要進行權限控制的方法上使用@PreAuthorize以及hasPermission()表達式進行權限控制了。

    * 将使用方法hasPermission(Authentication authentication,

         Object targetDomainObject, Object permission)進行驗證。

   @PreAuthorize("hasPermission('user', 'ROLE_USER')")

    * 将使用PermissionEvaluator的第二個方法，即hasPermission(Authentication authentication,

         Serializable targetId, String targetType, Object permission)進行驗證。

   @PreAuthorize("hasPermission('targetId','targetType','permission')")

   @PreAuthorize("hasPermission('user', 'ROLE_ADMIN')")

       在上面的配置中，find(int id)和add()方法将使用PermissionEvaluator中接收三個參數的hasPermission()方法進行驗證，而find(String username)方法将使用四個參數的hasPermission()方法進行驗證。因為hasPermission()表達式與PermissionEvaluator中hasPermission()方法的對應關系就是在hasPermission()表達式使用的參數基礎上加上目前Authentication對象調用對應的hasPermission()方法進行驗證。

       其實Spring Security已經針對于ACL實作了一個AclPermissionEvaluator。關于ACL的内容将在後文進行介紹。

（注：本文是基于Spring Security3.1.6所寫）