Wie implementiere ich eine benutzerdefinierte FilterSecurityInterceptor mit grails 1.3.2-und plugin-spring-security-core 1?

Schreibe ich ein grails 1.3.2 Anwendung und Implementierung von security mit spring-security-core-1.0. Für Gründe, die außerhalb des Geltungsbereichs dieses Frage, ich bin Implementierung einer benutzerdefinierten FilterSecurityInterceptor zusätzlich zu den out-of-the-box-Abfangjäger. Ich habe angefangen mit einem blog-Eintrag auf das Thema und versucht zu justieren für Spring Security 3, ohne viel Erfolg.

Locker nach dem blog (seit es ist basierend auf einer älteren version von Spring Security), habe ich die folgenden Klassen:

Eine org.springframework.Sicherheit.die Authentifizierung.AbstractAuthenticationToken Unterklasse zu halten, meine Anmeldeinformationen.
Eine org.springframework.Sicherheit.die Authentifizierung.AuthenticationProvider Unterklasse zu implementieren, die die Authentifizierung und unterstützt Methoden zum Auffüllen eines Authentifizierungs-Instanz mit den Daten von meinem UserDetailsService.
Eine org.springframework.Sicherheit.web.- Zugang.abzufangen.FilterSecurityInterceptor Unterklasse zu implementieren doFilter und afterPropertiesSet Methoden.
Einige Konfiguration der beans und der spring-security-core-plugin zu erkennen meine AuthenticationProvider und legen Sie meinen filter in die filter-Kette.

Meine AbstractAuthenticationToken ist ziemlich einfach:

class InterchangeAuthenticationToken extends AbstractAuthenticationToken {
 String credentials
 Integer name
 Integer principal

 String getCredentials() { //necessary or I get compilation error
  return credentials
 }

 Integer getPrincipal() { //necessary or I get compilation error
  return principal
 }
}

Meine AuthenticationProvider ist ziemlich einfach:

class InterchangeAuthenticationProvider implements org.springframework.security.authentication.AuthenticationProvider {

 Authentication authenticate(Authentication customAuth) {
  def authUser = AuthUser.get(customAuth.principal)
  if (authUser) {
   customAuth.setAuthorities(authUser.getAuthorities())
   customAuth.setAuthenticated(true)
   return customAuth
  } else {
   return null
  }
 }

 boolean supports(Class authentication) {
  return InterchangeAuthenticationToken.class.isAssignableFrom(authentication)
 }

}

Ich habe implementiert eine triviale FilterSecurityInterceptor. Schließlich muss es etwas Interessantes:

class InterchangeFilterSecurityInterceptor extends FilterSecurityInterceptor implements InitializingBean {

 def authenticationManager
 def interchangeAuthenticationProvider
 def securityMetadataSource

 void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) {

  if (SecurityContextHolder.getContext().getAuthentication() == null) {
    def myAuth = new InterchangeAuthenticationToken()
    myAuth.setName(1680892)
    myAuth.setCredentials('SDYLWUYa:nobody::27858cff')
    myAuth.setPrincipal(1680892)
    myAuth = authenticationManager.authenticate(myAuth);
    if (myAuth) {
     println "Successfully Authenticated ${userId} in object ${myAuth}"

     //Store to SecurityContextHolder
     SecurityContextHolder.getContext().setAuthentication(myAuth);
     }    
  }
  chain.doFilter(request, response)
 }

 void afterPropertiesSet() {
  def providers = authenticationManager.providers
  providers.add(interchangeAuthenticationProvider)
  authenticationManager.providers = providers
 }
}

Schließlich muss ich konfigurieren, einige Bohnen:

beans = {
  interchangeAuthenticationProvider(com.bc.commerce.core.InterchangeAuthenticationProvider) {
  }
  interchangeFilterSecurityInterceptor(com.bc.commerce.core.InterchangeFilterSecurityInterceptor) {
    authenticationManager = ref('authenticationManager')
    interchangeAuthenticationProvider = ref('interchangeAuthenticationProvider')
    securityMetadataSource = ref('objectDefinitionSource')
  }
}

Und einige Konfiguration des plugins:

grails.plugins.springsecurity.dao.hideUserNotFoundExceptions = true //not setting this causes exception
grails.plugins.springsecurity.providerNames = [
'interchangeAuthenticationProvider',
'daoAuthenticationProvider',
'anonymousAuthenticationProvider',
'rememberMeAuthenticationProvider'
]

Und setzen Sie den filter, um in Bootstrap.groovy:

def init = {servletContext ->
  //insert our custom filter just after the filter security interceptor
  SpringSecurityUtils.clientRegisterFilter('interchangeFilterSecurityInterceptor', SecurityFilterPosition.SECURITY_CONTEXT_FILTER.order + 10)
  <snip />
}

Wenn ich eine URL bekomme ich folgende exception, die stümpfe mich:

2010-07-30 15:07:16,763 [http-8080-1] ERROR [/community-services].[default]  - Servlet.service() for servlet default threw exception
java.lang.NullPointerException
 at org.springframework.security.access.intercept.AbstractSecurityInterceptor.beforeInvocation(AbstractSecurityInterceptor.java:171)
 at org.springframework.security.web.access.intercept.FilterSecurityInterceptor.invoke(FilterSecurityInterceptor.java:106)
 at org.springframework.security.web.access.intercept.FilterSecurityInterceptor.doFilter(FilterSecurityInterceptor.java:83)
 at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:355)
 at org.springframework.security.web.authentication.rememberme.RememberMeAuthenticationFilter.doFilter(RememberMeAuthenticationFilter.java:112)
 at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:355)
 at org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter.doFilter(SecurityContextHolderAwareRequestFilter.java:54)
 at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:355)
 at org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter.doFilter(AbstractAuthenticationProcessingFilter.java:187)
 at org.codehaus.groovy.grails.plugins.springsecurity.RequestHolderAuthenticationFilter.doFilter(RequestHolderAuthenticationFilter.java:40)
 at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:355)
 at org.codehaus.groovy.grails.plugins.springsecurity.MutableLogoutFilter.doFilter(MutableLogoutFilter.java:79)
 at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:355)
 at org.springframework.security.web.context.SecurityContextPersistenceFilter.doFilter(SecurityContextPersistenceFilter.java:79)
 at org.springframework.security.web.FilterChainProxy$VirtualFilterChain.doFilter(FilterChainProxy.java:355)
 at org.springframework.security.web.FilterChainProxy.doFilter(FilterChainProxy.java:149)
 at org.springframework.web.filter.DelegatingFilterProxy.invokeDelegate(DelegatingFilterProxy.java:237)
 at org.springframework.web.filter.DelegatingFilterProxy.doFilter(DelegatingFilterProxy.java:167)
 at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:235)
 at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
 at org.codehaus.groovy.grails.web.servlet.filter.GrailsReloadServletFilter.doFilterInternal(GrailsReloadServletFilter.java:104)
 at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:76)
 at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:235)
 at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
 at org.codehaus.groovy.grails.web.servlet.mvc.GrailsWebRequestFilter.doFilterInternal(GrailsWebRequestFilter.java:67)
 at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:76)
 at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:235)
 at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
 at org.codehaus.groovy.grails.web.filters.HiddenHttpMethodFilter.doFilterInternal(HiddenHttpMethodFilter.java:66)
 at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:76)
 at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:235)
 at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
 at org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:88)
 at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:76)
 at org.springframework.web.filter.DelegatingFilterProxy.invokeDelegate(DelegatingFilterProxy.java:237)
 at org.springframework.web.filter.DelegatingFilterProxy.doFilter(DelegatingFilterProxy.java:167)
 at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:235)
 at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
 at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:233)
 at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:191)
 at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:128)
 at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:102)
 at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:109)
 at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:293)
 at org.apache.coyote.http11.Http11Processor.process(Http11Processor.java:849)
 at org.apache.coyote.http11.Http11Protocol$Http11ConnectionHandler.process(Http11Protocol.java:583)
 at org.apache.tomcat.util.net.JIoEndpoint$Worker.run(JIoEndpoint.java:454)
 at java.lang.Thread.run(Thread.java:637)

So, wo bin ich Durcheinander, oder habe ich diese zu Komplex und habe ich etwas verpasst einfach?

Übrigens, hier ist die Codezeile mit der NPE: grepcode.com/file/repo1.maven.org/maven2/...

InformationsquelleAutor Chris Alef | 2010-08-02

In das Ende, ich implementiert eine benutzerdefinierte filter, nicht aber eine FilterSecurityInterceptor. Ich steckte meinen filter nach dem OOTB rememberMe-filter. Zudem fand ich meine Authentifizierung Umsetzung etwas zu ressourcenintensiv und zu langsam, so machte ich es den rememberMe cookie auf der erfolgreichen Authentifizierung. Insgesamt war dies eine schmerzhafte Erfahrung, so werde ich den Versuch machen, zu dokumentieren es hier.

Meiner filter-Implementierung wurde wie folgt:

import javax.servlet.FilterChain
import javax.servlet.http.HttpServletRequest
import javax.servlet.http.HttpServletResponse
import javax.servlet.ServletException
import javax.servlet.ServletRequest
import javax.servlet.ServletResponse
import org.springframework.context.ApplicationEventPublisher
import org.springframework.context.ApplicationEventPublisherAware
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken
import org.springframework.security.core.Authentication
import org.springframework.security.core.AuthenticationException
import org.springframework.security.core.context.SecurityContextHolder
import org.springframework.web.filter.GenericFilterBean

class CustomRememberMeAuthenticationFilter extends GenericFilterBean implements ApplicationEventPublisherAware {

    def authenticationManager
    def eventPublisher
    def customService
    def rememberMeServices
    def springSecurityService

    //make certain that we've specified our beans
    void afterPropertiesSet() {
        assert authenticationManager != null, 'authenticationManager must be specified'
        assert customService != null, 'customService must be specified'
        assert rememberMeServices != null, 'rememberMeServices must be specified'
    }

    void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req
        HttpServletResponse response = (HttpServletResponse) res

        if (SecurityContextHolder.getContext().getAuthentication() == null) {           
            Authentication auth
            try {
                auth = customService.getUsernamePasswordAuthenticationToken(request)
                if (auth != null) {
                    springSecurityService.reauthenticate(auth.getPrincipal(), auth.getCredentials())
                    logger.debug("SecurityContextHolder populated with auth: '"
                        + SecurityContextHolder.getContext().getAuthentication() + "'")
                    onSuccessfulAuthentication(request, response, SecurityContextHolder.getContext().getAuthentication())
                } else {
                    logger.debug('customService did not return an authentication from the request')
                }
            } catch (AuthenticationException authenticationException) {
                logger.warn("SecurityContextHolder not populated with auth, as "
                    + "springSecurityService rejected Authentication returned by customService: '"
                    + auth + "'", authenticationException)
                onUnsuccessfulAuthentication(request, response, auth)
            } catch(e) {
                logger.warn("Unsuccessful authentication in customRememberMeAuthenticationFilter", e)
                onUnsuccessfulAuthentication(request, response, auth)
            }
        } else {
            logger.debug("SecurityContextHolder not populated with auth, as it already contained: '"
                + SecurityContextHolder.getContext().getAuthentication() + "'")
        }
        chain.doFilter(request, response)
    }

    protected void onSuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, Authentication authResult) {
        //sets the rememberMe cookie, but cannot call "loginSuccess" because that filters out requests
        //that don't set the rememberMe cookie, like this one
        rememberMeServices.onLoginSuccess(request, response, authResult)
    }

    protected void onUnsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) {
        //clear the rememberMe cookie
        rememberMeServices.loginFail(request, response)
    }

    public void setApplicationEventPublisher(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher
    }
}

Hoffentlich andere finden das hilfreich bei der Umsetzung Ihrer benutzerdefinierten Authentifizierungs-Lösungen. Wir fanden, dies war für uns bei der Integration unserer Anwendung mit unserem alten system.

Ich habe eine etwas umfangreichere Beschreibung der Umsetzung hier: cricker.tumblr.com/post/953860464/...

InformationsquelleAutor Chris Alef

1

Gegeben, wo es fehlschlägt (eher nicht) würde ich sagen, dass es die verschachtelte Eigenschaften. Versuchen
```
grails.plugins.springsecurity.dao.hideUserNotFoundExceptions = true
grails.plugins.springsecurity.providerNames = [
    'interchangeAuthenticationProvider',
    'daoAuthenticationProvider',
    'anonymousAuthenticationProvider',
    'rememberMeAuthenticationProvider'
]
```
Meine Vermutung ist, dass es beim zurücksetzen der rest der Konfiguration (Grails/ConfigSlurper quirk) und dass dies die Zusammenführung der Eigenschaften statt. Sie sollten nicht brauchen, setzen Sie "active = true", aber ich vermute, Sie benötigt, um hinzuzufügen, dass, da es ist auch immer zurückgesetzt.

btw - Sie können entfernen Sie die Getter aus InterchangeAuthenticationToken werden, da öffentliche Felder generieren von Getter automatisch.

Ich habe versucht, die wiederholte config und ich bekomme das gleiche Ergebnis. RE der Getter, wenn ich kommentieren Sie Sie aus, und bauen, dann kann ich nicht kompilieren: [groovyc] /Users/calef/community-services/src/groovy/com/bc/commerce/core/InterchangeAuthenticationToken.groovy: 7: Kann nicht über eine abstrakte Methode in einer nicht-abstrakten Klasse. Die Klasse 'com.bc.commerce.core.InterchangeAuthenticationToken' muss als Abstrakt deklariert werden oder die Methode java.lang.Objekt getCredentials()' implementiert werden müssen. [groovyc] @ Zeile 7, Spalte 1. [groovyc] Klasse InterchangeAuthenticationToken erstreckt AbstractAuthenticationToken { [groovyc] ^
Stellen Sie sicher, dass Sie 'grails clean' zu zwingen, eine vollständige Neukompilierung. Sie könnten auch installieren Sie die spring-security-ui-plugin die info-Seiten zeige die eingetragene Authentifikatoren, Filter, Eigenschaften, etc. und Sie können Sie verwenden, um zu überprüfen, dass die Dinge einrichten, wie Sie es erwarten.

InformationsquelleAutor Burt Beckwith
1

Dies scheint ein bug in der spring-security-core-plugin, weil die securityMetadataSource ist nicht injiziert in das Standard-spring security -FilterSecurityInterceptor. Vielleicht ist das plugin Durcheinander kommt und injiziert securityMetadataSource in Ihre benutzerdefinierten FilterSecurityInterceptor und vernachlässigt die anderen (Standard -)? Burt möglicherweise bereit, tiefer zu schauen info.

Vielleicht könnten Sie versuchen ersetzen die Standard - FilterSecurityInterceptor mit Ihren custom one mit der grails.plugins.springsecurity.filterNames Eigenschaft...

Ich habe versucht, den Ansatz der Einstellung filterNames zu ersetzen FilterSecurityInterceptor, aber seltsamerweise die filternames nicht ändern, wenn ich die Eigenschaft festlegen.

InformationsquelleAutor Ryan Heaton

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.