Crowd bietet zentralisierte Authentifizierungs- und Single-sing-on-Konnektoren für das Web Security Framework Spring Security. Spring Security stellt einen modularen und höchst konfigurierbaren Ansatz für die Authentifizierung und Autorisierung für J2EE-Applikationen dar.

Wenn Ihre Web-Applikation bereits das Spring Security Framework für die Authentifizierung und Autorisierung verwendet, dann können Sie den Crowd Spring Security Konnektor dazu benutzen Ihrer Applikation ganz einfach die Delegierung von Authentifizierungs- und Autorisierungsanfragen an Crowd zu erlauben.

Für einen umfassenden Einblick in das Spring Security Framework, konsultieren Sie bitte die empfohlen Schritte oder das Referenzhandbuch für Spring Security (auf Englisch).

Grundvoraussetzungen

1. Laden Sie Crowd herunter und konfigurieren Sie es. Beziehen Sie sich auf Crowds Installtionshandbuch für detaillierte Informationen zur Vorgehensweise. Wir werden uns mit "CROWD" auf den Crowd Root-Ordner beziehen.
2. Haben Sie Ihre auf Spring Security basierende, benutzerdefinierte Applikation bereit für die Feinabstimmung. Wir werden uns mit "SpringSecApp" auf Ihre benutzerdefinierte Applikation beziehen.

Schritt 1: Konfigurieren Sie Crowd für die Kommunikation mit Ihrer Spring Security Applikation

Crowd muss darüber bescheid wissen, dass die SpringSecApp Authentifizierungsanfragen an Crowd stellen wird. Kurz gesagt müssen Sie folgendes tun:

1. Fügen Sie die SpringSecApp Applikation zu Crowd hinzu.
2. Fügen Sie die Verzeichnisse hinzu und konfigurieren (https://confluence.atlassian.com/crowd/mapping-a-directory-to-an-application-18579599.html) Sie sie sichtbar für SpringSecApp.
3. Fügen Sie die Gruppen hinzu (https://confluence.atlassian.com/crowd/adding-a-group-20807693.html), die sich mit SpringSecApp authentifizieren können und mappen Sie sie (https://confluence.atlassian.com/crowd/specifying-which-groups-can-access-an-application-25788430.html).

Lesen Sie für eine detaillierte Anleitung die Dokumentation über das Hinzufügen einer Applikation.

Schritt 2: Installation des Crowd Spring Security Konnektors

2.1 Hinzufügen des Crowd Spring Security Konnektors zu Ihrer Spring Security Applikation

Sie werden die Crowd Spring Security Konnektor Library und dessen einhergehenden Abhängigkeiten zu Ihrer Spring Security Applikation hinzufügen müssen. Dies können Sie manuell durch Herüberkopieren der JAR-Dateien zu Ihrer Spring Security Applikation tun oder, wenn Ihre Spring Security Applikation ein Maven Projekt ist, durch Hinzufügen des Crowd Spring Security Konnektors als Projekt-Abhängigkeit. Beide Methoden sind unten beschrieben.

2.1.1 Manuelles Hinzufügen der Crowd Spring Security Konnektor Libraries

Befolgen Sie entweder dem Schritt 2.1.1 oder 2.1.2 (nicht beiden).

Kopieren Sie die Crowd Integrations-Libraries und Konfigurationsdateien. Das ist in der Dokumentation über die Client Konfiguration (https://confluence.atlassian.com/crowd/integrating-crowd-with-a-custom-application-192511.html) beschrieben. Sie müssen zumindest die folgenden Dateien zu Ihrer Spring Security Applikation herüberkopieren:

2.1.2 Hinzufügen des Crowd Spring Security Konnektors als eine Maven-Abhängigkeit

Befolgen Sie entweder dem Schritt 2.1.1 oder 2.1.2 (nicht beiden).

Fügen Sie folgendes zu Ihrer pom.xml hinzu:

<properties>
    <crowd.version>2.5.0</crowd.version>
    <spring.version>3.1.0.RELEASE</spring.version>
</properties>

<dependencies>
    ...

    <dependency>
        <groupId>com.atlassian.crowd</groupId>
        <artifactId>crowd-integration-springsecurity</artifactId>
        <version>${crowd.version}</version>
        <scope>runtime</scope>
    </dependency>

    <!-- Crowd needs at runtime -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
        <scope>runtime</scope>
    </dependency>
    ...
</dependencies>

Stellen Sie sicher, dass Sie Abhängigkeiten auf den "spring-" Modulen haben, damit die von Crowd erforderlichen Spring Versionen abgerufen werden, anstatt möglicherweise ältere Versionen zu verwenden, die von Spring Security definiert wurden.

2.2 Hinzufügen der Cache Konfigurationsdatei

Kopieren Sie die folgende Datei in den Klassenpfad Ihrer Applikation:

Diese Datei kann fein-abgestimmt werden, um das Cache-Verhalten zu ändern.

2.3 Konfiguration der Crowd Spring Security Konnektor Eigenschaften

Der Crowd Spring Security Konnektor muss mit den Details des Crowd Servers konfiguriert werden:

1. Kopieren Sie die Standard crowd.properties Datei in den Klassenpfad Ihrer Spring Security Application:

   Kopieren Sie aus...	Fügen Sie ein in...
   CROWD/client/conf/crowd.properties	SpringSecApp/WEB-INF/classes

2. Editieren Sie die crowd.properties Datei und pflegen Sie die Felder wie folgt ein:

   Schlüssel	Wert
   application.name	Identisch zum Applikationsnamen, den Sie definierten als Sie die Applikation in Schritt 1 zu Crowd hinzugefügt haben.
   application.password	Identisch zum Applikations-Passwort, das Sie definierten als Sie die Applikation in Schritt 1 zu Crowd hinzugefügt haben.
   crowd.server.url	http://localhost:8095/crowd/services/
   session.validationinterval	Das ist der Zeitintervall, der zwischen den Anfragen vergeht, bis geprüft wird, ob der Benutzer im Crowd SSO Server ein- oder ausgeloggt ist. Setzen Sie den Wert 0, wenn Sie möchten, dass die Authentifizierungs-Überprüfungen bei jeder Anfrage durchgeführt werden. Andernfalls legen Sie die Anzahl an Minuten fest, die zwischen den Anfragen gewartet werden soll. Das Setzen des Wertes auf 1 oder höher, erhöht die Performance der Crowd-Integration.

Sie können mehr darüber auf der Seite über die crowd.properties Datei (https://confluence.atlassian.com/crowd/the-crowd-properties-file-98665664.html) lesen.

Schritt 3: Konfiguration Ihrer Spring Security Applikation für die Verwendung des Crowd Spring Security Konnektors

Es gibt zwei Möglichkeiten wie Sie Crowd in Ihre Applikation integrieren können:

• Zentralisierte Benutzerverwaltung: Das für Ihre Applikation verfügbare Benutzer-Repository wird das via Crowd zu Ihrer Applikation zugeordnete Benutzer-Repository sein. Das bedeutet, dass Ihre Applikation das zentralisierte Benutzer-Repository für das Abrufen der Benutzerdetails sowie der Authentifizierung verwenden wird.
• Single Sign-On: Zusätzlich zur zentralisierten Authentifizierung wird das SSO für Ihre Applikation verfügbar. Wenn Crowd in andere SSO-aktivierte Applikationen (wie Jira, Confluence oder Ihre eigenen, benutzerdefinierten Applikationen) integriert ist, dann wird das SSO-Verhalten über all diese Applikationen hinweg etabliert. Wenn Sie sich in einer Applikation einloggen, dann sind Sie in allen Applikationen eingeloggt. Wenn Sie sich aus einer Applikation ausloggen, dann sind Sie aus allen Applikationen ausgeloggt.

Als erstes müssen Sie den Crowd Client Applikations-Kontext hinzufügen, um die Crowd-Beans zu verbinden, die die Kommunikation zu Crowd verwalten. Das tun Sie indem Sie die applicationContext-CrowdRestClient.xml Spring Konfigurationsdatei inkludieren, die Sie in crowd-integration-client-rest.jar finden. Wenn Sie zum Beispiel Spring mit einem Kontext-Listener konfigurieren, dann können Sie den folgenden Parameter in Ihre Spring Security Applikations WEB-INF/web.xml hinzufügen:

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            ...
            classpath:/applicationContext-CrowdRestClient.xml
            ...
        </param-value>
    </context-param>

3.1 Konfiguration der zentralisierten Benutzerverwaltung

Die folgenden Abschnitte setzen voraus, dass Sie das Spring Security Schema zu dem "security" Namespace zugewiesen haben. Führen Sie die folgenden Updates in Ihrer Spring Security Konfiguration durch:

1. Fügen Sie die Definition des CrowdUserDetailsService hinzu:

   <bean id="crowdUserDetailsService" class="com.atlassian.crowd.integration.springsecurity.user.CrowdUserDetailsServiceImpl">
           <property name="crowdClient" ref="crowdClient"/>
           <property name="authorityPrefix" value="ROLE_"/>
   </bean>

2. Fügen Sie die Definition des RemoteCrowdAuthenticationProvider hinzu:

   <bean id="crowdAuthenticationProvider" class="com.atlassian.crowd.integration.springsecurity.RemoteCrowdAuthenticationProvider">
   	<constructor-arg ref="crowdClient"/>
       <constructor-arg ref="crowdHttpAuthenticator"/>
       <constructor-arg ref="crowdUserDetailsService"/>
   </bean>

    <util:map id="groupToAuthorityMappings">
        <beans:entry key="crowd-administrators" value="ROLE_crowd-administrators" />
        <beans:entry key="some-other-group" value="specific-authority-for-other-group" />
    </util:map>

    <beans:bean id="crowdUserDetailsService" class="com.atlassian.crowd.integration.springsecurity.user.CrowdUserDetailsServiceImpl">
    ...
        <beans:property name="groupToAuthorityMappings">
            <beans:bean factory-bean="groupToAuthorityMappings" factory-method="entrySet" />
        </beans:property>

3.2 Konfiguration des Single Sign-Ons (SSO)

Führen Sie die folgenden, zusätzlichen Updates in Ihrer Spring Security Konfiguration durch:

1. Entfernen Sie die Standards aus dem <http/> Element:
   1. Entfernen Sie das auto-config Attribut und fügen Sie ein entry-point-ref="crowdAuthenticationProcessingFilterEntryPoint" Attribut zu dem Http-Element hinzu.
   2. Entfernen Sie das <form-login> Element.

   3. Inkludieren Sie custom-filters für das Login und Logout.
      Sie sollten schlussendlich folgende Http-Elemente haben:

      <http pattern='/styles/*' security='none'/>
      <http pattern='/scripts/*' security='none'/>
      
      <http auto-config="false"
            entry-point-ref="crowdAuthenticationProcessingFilterEntryPoint">
      
          <custom-filter position="FORM_LOGIN_FILTER" ref='authenticationProcessingFilter'/>
          <custom-filter position="LOGOUT_FILTER" ref='logoutFilter'/>
      
          <intercept-url pattern="/admin/*" access="ROLE_application-administrators"/>
          <intercept-url pattern="/passwordHint.html" access="ROLE_ANONYMOUS,ROLE_ADMIN,ROLE_USER"/>
          <intercept-url pattern="/**/*.html*" access="IS_AUTHENTICATED_FULLY"/>
      </http>

2. Ändern Sie den Standard Bearbeitungsfilter zu Crowds SSO Filter, indem Sie die folgenden Bean-Definitionen hinzufügen:

   <authentication-manager alias="authenticationManager">
       <authentication-provider ref='crowdAuthenticationProvider' />
   </authentication-manager>
   
   <beans:bean id="crowdAuthenticationProcessingFilterEntryPoint" class="org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint">
   	<beans:constructor-arg value="/login.jsp"/>
   </beans:bean>
   	
   <beans:bean id="authenticationProcessingFilter" class="com.atlassian.crowd.integration.springsecurity.CrowdSSOAuthenticationProcessingFilter">
       <beans:constructor-arg ref="tokenHelper"/>
       <beans:constructor-arg ref="crowdClient"/>
       <beans:constructor-arg ref="clientProperties"/>
       <beans:property name="httpAuthenticator" ref="crowdHttpAuthenticator"/>
       <beans:property name="authenticationManager" ref="authenticationManager"/>
       <beans:property name="filterProcessesUrl" value="/j_security_check"/>
       <beans:property name="authenticationFailureHandler">
           <beans:bean class="com.atlassian.crowd.integration.springsecurity.UsernameStoringAuthenticationFailureHandler">
               <beans:property name="defaultFailureUrl" value="/login.jsp?error=true"/>
           </beans:bean>
       </beans:property>
   
       <beans:property name="authenticationSuccessHandler">
           <beans:bean class="org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler">
               <beans:property name="defaultTargetUrl" value="/"/>
           </beans:bean>
       </beans:property>
   </beans:bean>

3. Fügen Sie die Definition des CrowdLogoutHandler hinzu und geben Sie einen LogoutFilter hinzu, der ihn referenziert:

   <beans:bean id="crowdLogoutHandler" class="com.atlassian.crowd.integration.springsecurity.CrowdLogoutHandler">
       <beans:property name="httpAuthenticator" ref="crowdHttpAuthenticator"/>
   </beans:bean>
   
   <beans:bean id="logoutFilter" class="org.springframework.security.web.authentication.logout.LogoutFilter">
       <beans:constructor-arg value="/index.jsp"/>
       <beans:constructor-arg>
           <beans:list>
               <beans:ref bean="crowdLogoutHandler"/>
               <beans:bean class="org.springframework.security.web.authentication.logout.SecurityContextLogoutHandler"/>
           </beans:list>
       </beans:constructor-arg>
       <beans:property name="filterProcessesUrl" value="/logout.jsp"/>
   </beans:bean>

Schritt 4: Starten Sie Ihre Spring Security Applikation neu

Bouncen Sie Ihre Applikation. Sie sollten nun zentralisierte Authentifizierte und das Single Sign-On mit Crowd haben.

Autorisierung

Für die Zwecke der Crowd-Integration in Spring Security, sollten Sie die Spring Security Rollen zu den Crowd-Gruppen zuweisen. In anderen Worten: Um die Authorisierungs-Features von Spring Security verwenden zu können, müssen die Spring Security Rollen der Benutzer durch deren Gruppennamen definiert sein.

Die gewährten Autoritäten werden das im crowdUserDetailsService definierte authorityPrefix verwenden. Wenn kein Suffix definiert ist, dann werden die Autoritäten den Crowd-Gruppennamen anhängen.

Wenn zum Beispiel der Benutzer "admin" in der "crowd-admin" Gruppe ist, dann wird der Benutzer "admin" dazu autorisiert sein die Seiten anzusehen, die auf die "ROLE_crowd-admin" Rolle in Spring Security eingeschränkt sind.

<http>
    ...
    <intercept-url pattern="/console/secure/**" access="ROLE_crowd-administrators"/>
    <intercept-url pattern="/console/info/**" access="ROLE_crowd-users"/>
    <intercept-url pattern="/console/user/**" access="IS_AUTHENTICATED_FULLY"/>
    ...
</http>

Wenn das authoritySuffix ebenfalls definiert ist, dann werden alle Benutzer in den zugewiesenen Gruppen in Crowd der "authorityPrefix + authoritySuffix" gewährt (zum Beispiel: ROLE_ADMIN).

<beans:bean id="crowdUserDetailsService" ...>
    ...
    <beans:property name="authorityPrefix" value="ROLE_"/>
    <beans:property name="authorityPrefix" value="ADMIN"/>
</beans:bean>

<http>
    ...
    <intercept-url pattern="/console/secure/**" access="ROLE_ADMIN"/>
    <intercept-url pattern="/console/user/**" access="IS_AUTHENTICATED_FULLY"/>
    ...
</http>