Cómo crear métodos personalizados para usar en anotaciones de lenguaje de expresión de seguridad de Spring

Me gustaría crear una clase que agregue métodos personalizados para usar en el lenguaje de expresión de seguridad de Spring para la autorización basada en métodos a través de anotaciones.

Por ejemplo, me gustaría crear un método personalizado como 'customMethodReturningBoolean' para usarlo de alguna manera así:

  @PreAuthorize("customMethodReturningBoolean()")
  public void myMethodToSecure() { 
    // whatever
  }

Mi pregunta es esta. Si es posible, ¿qué clase debería subclase para crear mis métodos personalizados, cómo haría para configurarlo en los archivos de configuración xml de primavera y si alguien me da un ejemplo de un método personalizado utilizado de esta manera?

Necesitará subclasificar dos clases.

Primero, establezca un nuevo controlador de expresión de método

<global-method-security>
  <expression-handler ref="myMethodSecurityExpressionHandler"/>
</global-method-security>

myMethodSecurityExpressionHandlerserá una subclase de la DefaultMethodSecurityExpressionHandlerque anula createEvaluationContext(), estableciendo una subclase de MethodSecurityExpressionRooten el MethodSecurityEvaluationContext.

Por ejemplo:

@Override
public EvaluationContext createEvaluationContext(Authentication auth, MethodInvocation mi) {
    MethodSecurityEvaluationContext ctx = new MethodSecurityEvaluationContext(auth, mi, parameterNameDiscoverer);
    MethodSecurityExpressionRoot root = new MyMethodSecurityExpressionRoot(auth);
    root.setTrustResolver(trustResolver);
    root.setPermissionEvaluator(permissionEvaluator);
    root.setRoleHierarchy(roleHierarchy);
    ctx.setRootObject(root);

    return ctx;
}

Ninguna de las técnicas mencionadas funcionará más. Parece que Spring ha hecho todo lo posible para evitar que los usuarios anulen SecurityExpressionRoot.

EDITAR 19/11/14 Configure Spring para usar anotaciones de seguridad:

<beans ... xmlns:sec="http://www.springframework.org/schema/security" ... >
...
<sec:global-method-security pre-post-annotations="enabled" />

Crea un frijol como este:

@Component("mySecurityService")
public class MySecurityService {
    public boolean hasPermission(String key) {
        return true;
    }
}

Luego haz algo como esto en tu jsp:

<sec:authorize access="@mySecurityService.hasPermission('special')">
    <input type="button" value="Special Button" />
</sec:authorize>

O anote un método:

@PreAuthorize("@mySecurityService.hasPermission('special')")
public void doSpecialStuff() { ... }

Además, puede usar Spring Expression Language en sus @PreAuthorizeanotaciones para acceder a la autenticación actual, así como a los argumentos del método.

Por ejemplo:

@Component("mySecurityService")
public class MySecurityService {
    public boolean hasPermission(Authentication authentication, String foo) { ... }
}

Luego actualice su @PreAuthorizepara que coincida con la nueva firma del método:

@PreAuthorize("@mySecurityService.hasPermission(authentication, #foo)")
public void doSpecialStuff(String foo) { ... }

Gracias ericacm , pero no funciona por algunas razones:

• Las propiedades de DefaultMethodSecurityExpressionHandler son privadas (la visibilidad de la reflexión es indeseable)
• Al menos en mi Eclipse, no puedo resolver un objeto MethodSecurityEvaluationContext

Las diferencias son que llamamos al método createEvaluationContext existente y luego agregamos nuestro objeto raíz personalizado. Finalmente, acabo de devolver un tipo de objeto StandardEvaluationContext ya que MethodSecurityEvaluationContext no se resolvería en el compilador (ambos son de la misma interfaz). Este es el código que ahora tengo en producción.

Haga que MethodSecurityExpressionHandler use nuestra raíz personalizada:

public class CustomMethodSecurityExpressionHandler extends DefaultMethodSecurityExpressionHandler  {

    // parent constructor
    public CustomMethodSecurityExpressionHandler() {
        super();
    }

    /**
     * Custom override to use {@link CustomSecurityExpressionRoot}
     * 
     * Uses a {@link MethodSecurityEvaluationContext} as the <tt>EvaluationContext</tt> implementation and
     * configures it with a {@link MethodSecurityExpressionRoot} instance as the expression root object.
     */
    @Override
    public EvaluationContext createEvaluationContext(Authentication auth, MethodInvocation mi) {
        // due to private methods, call original method, then override it's root with ours
        StandardEvaluationContext ctx = (StandardEvaluationContext) super.createEvaluationContext(auth, mi);
        ctx.setRootObject( new CustomSecurityExpressionRoot(auth) );
        return ctx;
    }
}

Esto reemplaza la raíz predeterminada al extender SecurityExpressionRoot . Aquí he cambiado el nombre de hasRole a hasEntitlement:

public class CustomSecurityExpressionRoot extends SecurityExpressionRoot  {

    // parent constructor
    public CustomSecurityExpressionRoot(Authentication a) {
        super(a);
    }

    /**
     * Pass through to hasRole preserving Entitlement method naming convention
     * @param expression
     * @return boolean
     */
    public boolean hasEntitlement(String expression) {
        return hasRole(expression);
    }

}

Finalmente, actualice securityContext.xml (y asegúrese de que se haga referencia a él desde su applcationContext.xml):

<!-- setup method level security using annotations -->
<security:global-method-security
        jsr250-annotations="disabled"
        secured-annotations="disabled"
        pre-post-annotations="enabled">
    <security:expression-handler ref="expressionHandler"/>
</security:global-method-security>

<!--<bean id="expressionHandler" class="org.springframework.security.access.expression.method.DefaultMethodSecurityExpressionHandler">-->
<bean id="expressionHandler" class="com.yourSite.security.CustomMethodSecurityExpressionHandler" />

Nota: la anotación @Secured no aceptará esta anulación ya que se ejecuta a través de un controlador de validación diferente. Entonces, en el xml anterior, los desactivé para evitar confusiones posteriores.