Come creare metodi personalizzati da utilizzare nelle annotazioni del linguaggio delle espressioni di sicurezza primaverili

Vorrei creare una classe che aggiunge metodi personalizzati da utilizzare nel linguaggio delle espressioni di sicurezza primaverili per l'autorizzazione basata su metodo tramite annotazioni.

Ad esempio, vorrei creare un metodo personalizzato come 'customMethodReturningBoolean' da utilizzare in qualche modo in questo modo:

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

La mia domanda è questa. Se è possibile, quale classe dovrei sottoclassare per creare i miei metodi personalizzati, come dovrei configurarlo nei file di configurazione xml di primavera e qualcuno mi dia un esempio di un metodo personalizzato utilizzato in questo modo?

Avrai bisogno di sottoclassare due classi.

Per prima cosa, imposta un nuovo gestore di espressioni del metodo

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

myMethodSecurityExpressionHandlersarà una sottoclasse di DefaultMethodSecurityExpressionHandlerquali sostituzioni createEvaluationContext(), impostando una sottoclasse MethodSecurityExpressionRootsul MethodSecurityEvaluationContext.

Per esempio:

@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;
}

Nessuna delle tecniche menzionate funzionerà più. Sembra che Spring abbia fatto di tutto per impedire agli utenti di sovrascrivere SecurityExpressionRoot.

EDIT 19/11/14 Imposta Spring per utilizzare le annotazioni di sicurezza:

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

Crea un fagiolo come questo:

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

Quindi fai qualcosa di simile nel tuo jsp:

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

Oppure annota un metodo:

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

Inoltre, puoi usare Spring Expression Language nelle tue @PreAuthorizeannotazioni per accedere all'autenticazione corrente e agli argomenti del metodo.

Per esempio:

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

Quindi aggiorna il tuo @PreAuthorizein modo che corrisponda alla nuova firma del metodo:

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

Grazie ericacm , ma non funziona per alcuni motivi:

• Le proprietà di DefaultMethodSecurityExpressionHandler sono private (la visibilità della riflessione kludges è indesiderabile)
• Almeno nel mio Eclipse, non riesco a risolvere un oggetto MethodSecurityEvaluationContext

Le differenze sono che chiamiamo il metodo createEvaluationContext esistente e quindi aggiungiamo il nostro oggetto root personalizzato. Infine ho appena restituito un tipo di oggetto StandardEvaluationContext poiché MethodSecurityEvaluationContext non si risolveva nel compilatore (sono entrambi dalla stessa interfaccia). Questo è il codice che ora ho in produzione.

Fai in modo che MethodSecurityExpressionHandler utilizzi la nostra radice personalizzata:

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;
    }
}

Questo sostituisce la radice predefinita estendendo SecurityExpressionRoot . Qui ho rinominato hasRole in 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);
    }

}

Infine aggiorna securityContext.xml (e assicurati che sia referenziato dal tuo 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: l'annotazione @Secured non accetterà questa sostituzione poiché viene eseguita attraverso un gestore di convalida diverso. Quindi, nell'XML sopra li ho disabilitati per evitare confusione successiva.