AppFuse bietet einen guten Startpunkt für die Entwicklung von Web-Applikationen. Sie wählen die Frameworks aus und AppFuse generiert das Applikations-Gerüst.

Im Kern stützt sich die Web-Security der AppFuse 2.0.2+ Applikationen auf das modulare und erweiterbare Spring Security Authentifizierungs-Framework. In diesem Tutorial konzentrieren wir uns auf die grundlegende Integration von Crowd in Spring Security, mithilfe einer von AppFuse generierten Applikation.

Schritt 1: Beschaffen Sie AppFuse

In diesem Tutorial werden wir den Struts2-basic Archetyp für die Erstellung des Projekts verwenden, aber die anderen Typen sollten gleich sein. Konsultieren Sie für weitere Informationen die AppFuse Schnellstart-Anleitung (auf Englisch). Dort werden insbesondere die Datenbank-Anforderungen für AppFuse beschrieben.

1. Erstellen Sie das Projekt.

   mvn archetype:create -DarchetypeGroupId=org.appfuse.archetypes \
   -DarchetypeArtifactId=appfuse-basic-struts \
   -DremoteRepositories=http://static.appfuse.org/releases -DarchetypeVersion=2.0.2 \
   -DgroupId=com.mycompany.app -DartifactId=myproject

2. Da wir die Kern Spring Security Konfiguration editieren werden, benötigen wir den ganzen Quellcode der Applikation.

   cd myproject
   mvn appfuse:full-source

3. Erstellen Sie es.

   mvn clean install

4. Starten Sie es.

   mvn jetty:run-war -Dmaven.test.skip

5. Spielen Sie damit.

   http://localhost:8080/

6. Fahren Sie es herunter.

   ctrl+c

Schritt 2: Fügen Sie AppFuse als Applikation hinzu

Fügen Sie Appfuse als Applikation über die Crowd-Konsole hinzu. Lesen Sie für weitere Informationen darüber die Dokumentation über das Hinzufügen einer Applikation.

Schritt 3: Fügen Sie den Crowd Spring Security Konnektor zu AppFuse hinzu

Öffnen Sie die pom.xml und fügen Sie die Crowd Client-Libraries als Projekt-Abhängigkeiten hinzu:

<dependencies>
  <dependency>
    <groupId>com.atlassian.crowd</groupId>
    <artifactId>crowd-integration-client</artifactId>
    <version>1.6</version>
  </dependency>
...
</dependencies>

Sie müssen außerdem noch die Datei myproject/src/main/resources/crowd.properties erstellen:

application.name                        appfuse
application.password                    password
application.login.url                   http://localhost:8095/crowd/
crowd.server.url                        http://localhost:8095/crowd/services/
session.isauthenticated                 session.isauthenticated
session.tokenkey                        session.tokenkey
session.validationinterval              0
session.lastvalidation                  session.lastvalidation

Besonders der Applikationsname und das Passwort müssen mit den Werten, die beim Hinzufügen der Applikation definiert wurden, übereinstimmen (Sehen Sie Schritt 2).

Kopieren Sie schließlich die STANDALONE/client/conf/crowd-ehcache.xml zu myproject/src/main/resources/crowd-ehcache.xml herüber. Diese Datei definiert die Cache-Einstellungen, wie die Cache-Timeouts, die beim Zugriff der Daten vom Crowd Server verwendet werden.

Schritt 4: Verbinden Sie die zentralisierte Authentifizierung

Bevor Sie die Sicherheitskonfiguration modifizieren, müssen Sie die Spring Konfigurationsdatei hinzufügen, um die Crowd Client-Beans zu verbinden. Fügen Sie die applicationContext-CrowdClient.xml Konfigurationsdatei zu der Liste der contextConfigLocations in myproject/src/main/webapp/WEB-INF/web.xml hinzu:

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
        classpath:/applicationContext-resources.xml
        classpath:/applicationContext-dao.xml
        classpath:/applicationContext-service.xml
        classpath*:/applicationContext.xml
        classpath:/applicationContext-CrowdClient.xml
        /WEB-INF/applicationContext*.xml
        /WEB-INF/xfire-servlet.xml
        /WEB-INF/security.xml
    </param-value>
</context-param>

AppFuse speichert alle Spring Security Konfigurationen ordentlich in der myproject/src/main/webapp/WEB-INF/security.xml. Um die zentralisierte Authentifizierung zu erhalten, müssen wir die Spring Security für die Verwendung der Crowd-Komponenten einrichten, um die Benutzerinformationen zu beziehen. Editieren Sie die Beans in der security.xml:

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

   <beans:bean id="crowdUserDetailsService" class="com.atlassian.crowd.integration.springsecurity.user.CrowdUserDetailsServiceImpl">
           <beans:property name="authenticationManager" ref="crowdAuthenticationManager"/>
           <beans:property name="groupMembershipManager" ref="crowdGroupMembershipManager"/>
           <beans:property name="userManager" ref="crowdUserManager"/>
           <beans:property name="authorityPrefix" value="ROLE_"/>
   </beans:bean>

2. Fügen Sie die Definition des RemoteCrowdAuthenticationProvider hinzu, der die Spring Security Authentifizierungsanfragen zu Crowd delegiert:

   <beans:bean id="crowdAuthenticationProvider" class="com.atlassian.crowd.integration.springsecurity.RemoteCrowdAuthenticationProvider">
   	<custom-authentication-provider />
   	<beans:constructor-arg ref="crowdAuthenticationManager"/>
           <beans:constructor-arg ref="httpAuthenticator"/>
           <beans:constructor-arg ref="crowdUserDetailsService"/>
   </beans:bean>

3. Kommentieren Sie den Standard Authentifizierungsanbieter aus, da wir ihn mit Crowd ersetzt haben:

   <!--
       <authentication-provider user-service-ref="userDao">
           <password-encoder ref="passwordEncoder"/>
       </authentication-provider>
   -->

4. Nun führen Sie folgendes aus:

   mvn clean install

   Dadurch werden die Konfigurationsänderungen übernommen und die Crowd Client-Library zu Ihrer App hinzugefügt. Starten Sie danach folgendes:

   mvn jetty:run-war -Dmaven.test.skip

5. Wechseln Sie zu http://localhost:8080/.
   Sie sollten nun in der Lage sein die Benutzer in Ihrem Crowd-Repository zu authentifizieren, die die folgenden Bedingungen erfüllen:
   
   • Sie sind in einem Crowd-Verzeichnis, das zu der AppFuse Applikation in Crowd zugewiesen ist. Lesen Sie mehr darüber.
   • Sie sind in Crowd-Gruppen namens "USER" und "ADMIN". Sie müssen diese Gruppen hinzufügen und die Benutzer als Mitglieder dieser Gruppen zuweisen. Diese Crowd-Gruppennamen, die zu den Spring Security Autorisierungsrollen zugewiesen sind, sind in der AppFuse Applikation definiert. 
   • Die Benutzer dürfen sich mit der AppFuse Applikation authentifizierten, weil Sie ENTWEDER in einer Gruppe sind, die sich mit Crowd authentifizieren darf (klicken Sie hier für Details), ODER weil Ihr Container-Verzeichnis allen Benutzern die Authentifizierung erlaubt (klicken Sie hier für Details). 

Glückwunsch! Sie haben nun die zentralisierte Authentifizierung. 

Schritt 5: Binden Sie das Single Sign-On ein

Die Aktivierung des Single Sign-Ons (SSO) erfordert eine kleine Anpassung der security.xml:

1. Entfernen Sie die Standards vom <http/> Element:
   1. Entfernen Sie die auto-config Attribute und fügen Sie ein entry-pont-ref="crowdAuthenticationProcessingFilterEntryPoint" Attribut zu dem Http-Element hinzu.

   2. Entfernen Sie das <form-login> Element.
      Sie sollten ein ähnliches Http-Element vorliegen haben, wie dieses:

      <http lowercase-comparisons="false" entry-point-ref="crowdAuthenticationProcessingFilterEntryPoint"> <!-- note: no auto-config attribute! -->
          <!--intercept-url pattern="/images/*" filters="none"/>
          <intercept-url pattern="/styles/*" filters="none"/>
          <intercept-url pattern="/scripts/*" filters="none"/-->
          <intercept-url pattern="/admin/*" access="ROLE_ADMIN"/>
          <intercept-url pattern="/passwordHint.html*" access="ROLE_ANONYMOUS,ROLE_ADMIN,ROLE_USER"/>
          <intercept-url pattern="/signup.html*" access="ROLE_ANONYMOUS,ROLE_ADMIN,ROLE_USER"/>
          <intercept-url pattern="/a4j.res/*.html*" access="ROLE_ANONYMOUS,ROLE_ADMIN,ROLE_USER"/>
          <!-- APF-737, OK to remove line below if you're not using JSF -->
          <intercept-url pattern="/**/*.html*" access="ROLE_ADMIN,ROLE_USER"/>
      <!--  <form-login login-page="/login.jsp" authentication-failure-url="/login.jsp?error=true" login-processing-url="/j_security_check"/> -->
          <remember-me user-service-ref="userDao" key="e37f4b31-0c45-11dd-bd0b-0800200c9a66"/>
      </http>

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

   <authentication-manager alias="authenticationManager"/>
    
   <beans:bean id="crowdAuthenticationProcessingFilterEntryPoint" class="org.springframework.security.ui.webapp.AuthenticationProcessingFilterEntryPoint">
   	<beans:property name="loginFormUrl" value="/login.jsp"/>
   </beans:bean>
   	
   <beans:bean id="crowdAuthenticationProcessingFilter" class="com.atlassian.crowd.integration.springsecurity.CrowdSSOAuthenticationProcessingFilter">
       <custom-filter position="AUTHENTICATION_PROCESSING_FILTER"/>       
       <beans:property name="httpAuthenticator" ref="httpAuthenticator"/>
       <beans:property name="authenticationManager" ref="authenticationManager"/>
       <beans:property name="authenticationFailureUrl" value="/login.jsp?error=true"/>
       <beans:property name="defaultTargetUrl" value="/"/>
       <beans:property name="filterProcessesUrl" value="/j_security_check"/>
   </beans:bean>

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

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

4. Nun wiederholen Sie folgendes:

   mvn jetty:run-war -Dmaven.test.skip=true

Das SSO wird nur für Benutzer funktionieren, die sich bei beiden Applikationen authentifizieren können und autorisiert sind die Applikationen zu verwenden. Probieren Sie folgendes aus:

• Loggen Sie sich in Crowd ein - Sie sollten in AppFuse eingeloggt sein.
• Loggen Sie sich aus AppFuse aus - Sie sollten aus Crowd ausgeloggt sein.
• Loggen Sie sich in AppFuse ein, loggen Sie sich aus Crowd aus, loggen Sie sich als anderer Benutzer in Crowd ein und aktualisieren Sie AppFuse - Sie sollten als der neue Benutzer eingeloggt sein.

Glückwunsch, Sie haben SSO.