转载

Spring Security（16）——基于表达式的权限控制

基于表达式的权限控制

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 。

1.1 通过表达式控制 URL 权限

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 。

< security:http use-expressions = "true" >

< security:form-login />

< security:logout />

< security:intercept-url pattern = "/**" access = "hasRole('ROLE_USER')" />

</ security:http >

在上述配置中我们定义了只有拥有 ROLE_USER 角色的用户才能访问系统。

使用表达式控制 URL 权限使用的表达式对象类是继承自 SecurityExpressionRoot 的 WebSecurityExpressionRoot 类。其相比基类而言新增了一个表达式 hasIpAddress 。 hasIpAddress 可用来限制只有指定 IP 或指定范围内的 IP 才可以访问。

< security:http use-expressions = "true" >

< security:form-login />

< security:logout />

< security:intercept-url pattern = "/**" access = "hasRole('ROLE_USER') and hasIpAddress('10.10.10.3')" />

</ security:http >

在上面的配置中我们限制了只有 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.

* <p>

* 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( '/' ) > 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 < 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 = new byte [nMaskBytes];

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

if (oddBits != 0) {

int finalByte = (1 << oddBits) - 1;

finalByte <<= 8-oddBits;

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

}

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

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

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

return alse ;

}

return true ;

}

private InetAddress parseAddress(String address) {

try {

return InetAddress. getByName (address);

} catch (UnknownHostException e) {

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

}

1.2 通过表达式控制方法权限

Spring Security 中定义了四个支持使用表达式的注解，分别是 @PreAuthorize 、 @PostAuthorize 、 @PreFilter 和 @PostFilter 。其中前两者可以用来在方法调用前或者调用后进行权限检查，后两者可以用来对集合类型的参数或者返回值进行过滤。要使它们的定义能够对我们的方法的调用产生影响我们需要设置 global-method-security 元素的 pre-post-annotations=”enabled” ，默认为 disabled 。

< security:global-method-security pre-post-annotations = "disabled" />

1.2.1使用@PreAuthorize和@PostAuthorize进行访问控制

@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 角色。使用表达式时我们还可以在表达式中使用方法参数。

public class UserServiceImpl implements UserService {

/**

* 限制只能查询 Id 小于 10 的用户

@PreAuthorize ( "#id<10" )

public User find( int id) {

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

return null ;

}

/**

* 限制只能查询自己的信息

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

public User find(String username) {

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

return null ;

}

/**

* 限制只能新增用户名称为 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" )

public User find( int id) {

User user = new User();

user.setId(id);

return user;

}

上面这一段代码表示将在方法 find() 调用完成后进行权限检查，如果返回值的 id 是偶数则表示校验通过，否则表示校验失败，将抛出 AccessDeniedException 。需要注意的是 @PostAuthorize 是在方法调用完成后进行权限检查，它不能控制方法是否能被调用，只能在方法调用完成后检查权限决定是否要抛出 AccessDeniedException 。

1.2.2使用@PreFilter和@PostFilter进行过滤

使用 @PreFilter 和 @PostFilter 可以对集合类型的参数或返回值进行过滤。使用 @PreFilter 和 @PostFilter 时， Spring Security 将移除使对应表达式的结果为 false 的元素。

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

public List<User> findAll() {

List<User> userList = new ArrayList<User>();

User user;

for ( int i=0; i<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<Integer> ids, List<String> usernames) {

...

}

1.3 使用 hasPermission 表达式

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 ;

}

/**

* 总是认为有权限

public boolean hasPermission(Authentication authentication,

Serializable targetId, String targetType, Object permission) {

return true ;

}

/**

* 简单的字符串比较，相同则认为有权限

private boolean hasPermission(Authentication authentication, Object permission) {

Collection<? extends GrantedAuthority> authorities = authentication.getAuthorities();

for (GrantedAuthority authority : authorities) {

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

return true ;

}

return false ;

}

接下来在 ApplicationContext 中显示的配置一个将使用 PermissionEvaluator 的 SecurityExpressionHandler 实现类，然后指定其所使用的 PermissionEvaluator 为我们自己实现的那个。这里我们选择配置一个针对于方法调用使用的表达式处理器， DefaultMethodSecurityExpressionHandler ，具体如下所示。

< bean id = "expressionHandler"

class = "org.springframework.security.access.expression.method.DefaultMethodSecurityExpressionHandler" >

< property name = "permissionEvaluator" ref = "myPermissionEvaluator" />

</ bean >

< bean id = "myPermissionEvaluator" class = "com.xxx.MyPermissionEvaluator" />

有了 SecurityExpressionHandler 之后，我们还要告诉 Spring Security ，在使用 SecurityExpressionHandler 时应该使用我们显示配置的那个，这样我们自定义的 PermissionEvaluator 才能起作用。因为我们上面定义的是针对于方法的 SecurityExpressionHandler ，所以我们要指定在进行方法权限控制时应该使用它来进行处理，同时注意设置 pre-post-annotations=”true” 以启用对支持使用表达式的 @PreAuthorize 等注解的支持。

< security:global-method-security

pre-post-annotations = "enabled" >

< security:expression-handler ref = "expressionHandler" />

</ security:global-method-security >

之后我们就可以在需要进行权限控制的方法上使用 @PreAuthorize 以及 hasPermission() 表达式进行权限控制了。

@Service

public class UserServiceImpl implements UserService {

/**

* 将使用方法 hasPermission(Authentication authentication,

Object targetDomainObject, Object permission) 进行验证。

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

public User find( int id) {

return null ;

}

/**

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

Serializable targetId, String targetType, Object permission) 进行验证。

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

public User find(String username) {

return null ;

}

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

public void add(User user) {

}

在上面的配置中， find(int id) 和 add() 方法将使用 PermissionEvaluator 中接收三个参数的 hasPermission() 方法进行验证，而 find(String username) 方法将使用四个参数的 hasPermission() 方法进行验证。因为 hasPermission() 表达式与 PermissionEvaluator 中 hasPermission() 方法的对应关系就是在 hasPermission() 表达式使用的参数基础上加上当前 Authentication 对象调用对应的 hasPermission() 方法进行验证。