Child pages
  • Crowd Dokumentation - Crowd in Spring Security integrieren
Skip to end of metadata
Go to start of metadata



Die Inhalte auf dieser Seite beziehen sich auf Plattformen, die nicht von Crowd unterstützt werden. Folglich kann Atlassian keinen Support für die hier beschriebenen Schritte anbieten. Bitte beachten Sie, dass dieses Material nur zu Ihrer Information dient und Sie es auf eigenes Risiko verwenden.


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.


Spring, Acegi und Crowd Versionen

Spring Security war früher als Acegi bekannt. Es gibt ein eigenes Tutorial für die Integration von Crowd in Acegi (https://confluence.atlassian.com/crowd/integrating-crowd-with-acegi-security-107184799.html). Der Konnektor wurde entwickelt und getestet mit Spring Security 3.1 von Crowd 2.5 und neuer. Bitte benutzen Sie frühere, unterstützte Versionen von Crowd, wenn Sie die Kompatibilität mit Spring Security 2.0.4 benötigen.


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).


Dieses Handbuch setzt die Kenntnisse eines Entwicklers und eine auf Spring Security basierende Web-Applikation voraus.

Dieses Handbuch ist eher für Entwickler, als für Administratoren, geschrieben. Es setzt voraus, dass Sie Crowd 2.5 oder neuer installiert haben und, dass Sie Crowds Security Server in Ihre auf Spring Security basierende Web-Applikation integrieren möchten. Die Dokumentation unten beschreibt, wie Sie Crowd in Ihre eigene Applikation integrieren, die das Spring Security Framework verwendet. Es wird davon ausgegangen, dass Sie bereits Spring Security in Ihrer Applikation verwenden. Wenn Sie Hilfe bei der Integration des Spring Security Frameworks in Ihrer Web-Applikation benötigen, dann sehen Sie sich einige Teile der Spring Security Dokumentation an.


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

(Info) 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:

Kopieren Sie aus...Fügen Sie ein in...
CROWD/client/crowd-integration-client-X.X.X.jarSpringSecApp/WEB-INF/lib
CROWD/client/lib/*.jarSpringSecApp/WEB-INF/lib


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

(Info) 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:

Kopieren Sie aus...Fügen Sie ein in...
CROWD/client/conf/crowd-ehcache.xmlSpringSecApp/WEB-INF/classes/crowd-ehcache.xml

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.propertiesSpringSecApp/WEB-INF/classes
  2. Editieren Sie die crowd.properties Datei und pflegen Sie die Felder wie folgt ein:

    SchlüsselWert
    application.nameIdentisch zum Applikationsnamen, den Sie definierten als Sie die Applikation in Schritt 1 zu Crowd hinzugefügt haben.
    application.passwordIdentisch zum Applikations-Passwort, das Sie definierten als Sie die Applikation in Schritt 1 zu Crowd hinzugefügt haben.
    crowd.server.urlhttp://localhost:8095/crowd/services/
    session.validationintervalDas 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>


Steuerung der gewährten Autoritätsnamen

Anstatt, dass Sie den Gruppennamen nehmen und einen Prefix festlegen, können Sie ein Mapping definieren, um bestimmte Autoritäten zu gewähren, wenn ein Benutzer zu Crowd-Gruppen gehört:

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

Und dann setzen Sie es auf den crowdUserDetailsService:

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


Weitere Erweiterungen

  • Wenn Sie ein existierendes Benutzerdaten-Modell haben, dann können Sie den CrowdDetailsService für die Benutzerobjekte in Ihrer Applikationsdomain erweitern oder einschränken.
  • Wenn Sie Benutzer in Crowd benötigen, die in dem Persistenz-Modell erstellt wurden, damit Sie applikationsspezifische Benutzerdaten speichern können, dann können Sie den CrowdAuthenticationProvider erweitern um Einträge für erfolgreich authentifizierte Crowd-Benutzer zu erstellen.


Crowds Remote-API

Wir empfehlen, dass die Applikationen die Crowd-Benutzer nicht lokal speichern. Stattdessen sollten die Applikationen die Benutzer via Crowds Remote-API abfragen.



3.2 Konfiguration des Single Sign-Ons (SSO)

Das SSO ist optional und erfordert die zentralisierte Benutzerverwaltung.

Single Sign-On ist optional. Wenn Sie das SSO konfigurieren möchten, dann müssen Sie zuerst die zentralisierte Benutzerverwaltung konfigurieren, wie in Schritt 3.1 beschrieben.


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>




Crowd Dokumentation Übersicht:




Crowd Doku

  • No labels