Informationen zum Framework für Single Sign-on

Das SSO-Framework von Build Forge bietet die Möglichkeit zur Einbindung zahlreicher auf dem Markt erhältlicher SSO-Lösungen. Das SSO-Framework basiert auf Abfangprozessen, d. h., HTTP-Anforderungen werden abgefangen und es werden Methoden für deren Verarbeitung bereitgestellt. Sie können angepasste Abfangprozesse schreiben, damit Sicherheitsartefakte in einer HTTP-Anforderung empfangen und validiert werden. Insbesondere können von einem Abfangprozess Token in der HTTP-Antwort gesetzt werden, nach denen dann in einer nachfolgenden Anforderung gesucht wird.

Im Lieferumfang von Build Forge sind zwei SSO-Lösungen enthalten:

Methoden im SSO-Framework

Ein SSO-Abfangprozess ist eine Java-Klasse, durch die eine vom Build Forge-SSO-Framework verwendete Schnittstelle implementiert wird:
com.buildforge.services.server.sso.ISSOIntercaptor
Sie befindet sich in der Komponente Services Layer:
<bf-installationsverzeichnis>/Apache/tomcat/webapps/rbf-services/WEB-INF/classes

Die Schnittstelle stellt folgende Methoden bereit:

initInterceptor
Diese Methode wird aufgerufen, wenn der Abfangprozess geladen wird. Eine Zuordnung von Konfigurationseigenschaften wird an die Methode initInterceptor() übergeben. Konfigurationseigenschaften werden in der Build Forge-Konsole unter Verwaltung > Sicherheit > SSO erstellt.
isTargetInterceptor
Durch diese Methode werden Attribute in der ankommenden Anforderung überprüft, um festzustellen, ob der Abfangprozess für diese aktiv werden muss. Wenn dies der Fall ist, muss der Abfangprozess die Anforderung mit der Methode authenticateRequest() authentifizieren. Andernfalls wird der Abfangprozess übersprungen. Bei der Auswahl eines Abfangprozesses wird davon ausgegangen, dass mehrere Abfangprozesse konfiguriert und aktiv sind. Diese werden nacheinander angesprochen.
authenticateRequest
Durch diese Methode wird die Anforderung anhand der darin enthaltenen Daten authentifiziert. Es wird ein Antwortattribut verwendet, um Daten zurück an den Client zu senden.
logoutRequest
Durch diese Methode werden benutzerbezogene Sicherheitsinformationen nach der Verarbeitung der Anforderung bereinigt.

Konfiguration und Reihenfolge von Abfangprozessen

Abfangprozesse werden unter Verwaltung > Sicherheit > SSO konfiguriert. Build Forge wird mit folgenden Konfigurationen ausgeliefert:

Nachdem Sie eine Klasse als Abfangprozess implementiert und auf dem Apache Tomcat-Anwendungsserver für Build Forge abgelegt haben, definieren Sie nun eine neue SSO-Konfiguration. Die Klasse ist nur eine Eigenschaft der SSO-Konfiguration.

Die Reihenfolge in der Liste ist ausschlaggebend für die Reihenfolge, in der die Abfangprozesse für die Verarbeitung von Anforderungen herangezogen werden. Sie können mehrere Abfangprozesse für die Verarbeitung von Anforderungen konfigurieren. Während eines Anmeldevorgangs werden die einzelnen Abfangprozesse nacheinander aufgerufen. Der Abfangprozess, der die Anforderung verarbeitet, ist der erste aktive Abfangprozess, dessen Attribute für die Attribute in der Anforderung geeignet sind. Die Anforderung wird nur von einem Abfangprozess verarbeitet. Dabei handelt es sich immer um den ersten Abfangprozess, bei dem für isTargetInterceptor der Wert "true" zurückgegeben wird.

Anmerkung: Der Form SSO-Abfangprozess sollte aktiv bleiben, damit im Fall eines Fehlers darauf zurückgegriffen werden kann. Angepasste Abfangprozesse sollten in der Liste vor diesem angeordnet werden.

Angepassten SSO-Abfangprozess hinzufügen

So erstellen Sie einen angepassten Abfangprozess in Build Forge:

  1. Erstellen Sie eine angepasste Java-Klasse.

    Diese Klasse muss die Schnittstelle ISSOInterceptor implementieren.

  2. Implementieren Sie die angepasste Klasse in der WAR-Datei der Komponente Services Layer.
    1. Erstellen Sie eine JAR-Datei, die die kompilierte angepasste Klasse für den SSO-Abfangprozess enthält.
    2. Kopieren Sie die JAR-Datei an folgender Position in die Build Forge-Komponente Services Layer:
      <bf-installationsverzeichnis>/Apache/tomcat/webapps/rbf-services/WEB-INF/classes
    3. Dekomprimieren Sie die JAR-Datei in diesem Verzeichnis. Der SSO-Manager sucht hier nach der zu ladenden Klasse.
    4. Starten Sie Build Forge erneut.
  3. Optional: Definieren Sie eine Umgebung. Diese Umgebung kann als Eigenschaftenobjekt an die Methode initInterceptor() übergeben werden.
    1. Wechseln Sie in der Managementkonsole zu Umgebungen.
    2. Klicken Sie auf Umgebung hinzufügen.
    3. Definieren Sie alle Eigenschaften, die für die Initialisierung des SSO-Abfangprozesses erforderlich sind.
  4. Fügen Sie den SSO-Abfangprozess zu Build Forge hinzu:
    1. Wechseln Sie in der Managementkonsole zu Verwaltung > Sicherheit > SSO.
    2. Klicken Sie auf SSO-Konfiguration hinzufügen. Geben Sie Werte für die entsprechenden Eigenschaften an:
      • Name: Geben Sie einen Namen für die SSO-Konfiguration ein.
      • Aktiv: Setzen Sie diese Eigenschaft auf "Ja". Während einer Authentifizierungsanforderung wird auf alle aktiven Konfigurationen zugegriffen. Der Zugriff erfolgt in der Reihenfolge, in der die Konfigurationen in der Anzeige erscheinen.
      • Java-Klasse: Geben Sie den vollständigen Paketnamen der Klasse ein. Eine Klasse kann nur einem SSO-Abfangprozess zugeordnet werden.
      • Umgebung: Wenn Sie eine Umgebung für die Verwendung mit diesem SSO-Abfangprozess definiert haben, wählen Sie sie aus.
    3. Klicken Sie auf Speichern.
    Der SSO-Abfangprozess wird nun in der Liste angezeigt.
  5. Bringen Sie die SSO-Konfigurationen in die gewünschte Reihenfolge. Klicken Sie auf das Symbol links neben Ihrem SSO-Abfangprozess und wählen Sie dann An den Anfang verschieben aus.

    Bei einer Anforderung erfolgt der Zugriff auf aktive SSO-Konfigurationen in der Reihenfolge, in der die Konfigurationen in dieser Anzeige erscheinen. Die von Ihnen hinzugefügte Konfiguration muss vor der Konfiguration für Form SSO platziert werden, da diese standardmäßig aktiv ist und beim Zugriff immer "true" zurückgibt. Die Konfiguration für SPNEGO SSO ist standardmäßig inaktiv.

Beispielimplementierung von "authenticateRequest"

Das folgende Beispiel bezieht sich auf den WebSphere-SSO-Abfangprozess, der zum Einbinden der WebSphere-Sicherheit in Build Forge verwendet wird.

Bei dem Abfangprozess wird die Reflexion verwendet, um die WebSphere-Klasse "WSSubject" zu finden. Diese Klasse verfügt über die Methode getCallerPrincipal, von der der Principal für die Anmeldung beim Authentifizierungsservlet (AuthServlet) zurückgegeben wird. Das Authentifizierungsservlet muss geschützt werden, bevor die Authentifizierung für WAS darüber ausgeführt wird.

Zusätzlich stehen weitere Methoden zur Verfügung, von denen noch mehr Informationen zurückgegeben werden können. Ähnliche Methoden sind für die Arbeit mit beliebigen Anwendungsservern verfügbar.

public Result authenticateRequest 
      (Request requestAttributes, Response responseAttributes) 
       throws SSOException {

  Result result = null;

try {
  Class<?> cl = 
    Class.forName(“com.ibm.websphere.security.auth.WSSubject”);
      Method theMethod = cl.getMethod("getCallerPrincipal", 
        (Class[])null);
    String principal = (String)theMethod.invoke((Object[])null, 
          (Object[])null);

if (principal != null 
      && principal.length() > 0 
      && !principal.equals("UNAUTHENTICATED")) {
  result = new Result(Result.UseridOnlyOID, domain, principal);
	responseAttributes.setStatus(HttpServletResponse.SC_OK);	
} catch (Exception e) {
		throw new SSOException(e);
}

return result;
}

Bei der Implementierung von authenticateRequest müssen Sie vor der Rückgabe einen Antwortstatus setzen:

Es können zusätzliche Statuswerte verwendet werden. Weitere Informationen finden Sie im JavaDoc für HttpServletResponse.

Wiederherstellung nach einem Anmeldefehler

Wenn Ihr angepasster Abfangprozess im Test nicht ordnungsgemäß funktioniert, besteht wahrscheinlich ein Problem mit der Authentifizierung. Es wird eine Fehlerseite mit folgenden Informationen angezeigt:

Build Forge-Fehler

     Zugriff auf BuildForge-Konsole verweigert.

     "Fehler beim Authentifizieren:
     com.buildforge.services.common.api.APIException - API:
     Zugriff verweigert."

     Klicken Sie hier, um dieselbe Anmeldung erneut zu versuchen,
     oder klicken Sie hier, um eine formelle Anmeldung (mit Benutzer-ID und Kennwort) zu erzwingen.

Sie haben zwei Möglichkeiten für die Wiederherstellung:

Quellenliste für Methoden

Die folgenden Kommentare und Quellenlisten bieten weitere Informationen zu den Methoden in der Schnittstelle ISSOInterceptor.

initInterceptor
	/**
	 * This method is called when the interceptor is loaded.  A map of the 
     configuration properties is passed into the init method.  You can create 
     the configuration properties from a BuildForge Environment and associate 
     it with the SSO configuration.
	 *
	 * @param initializationProps used to configure the implementation
	 * @return true if successful, false if an error should be reported.
	 * @throws SSOException if the initialization fails
	 **/
	public boolean initInterceptor (Properties initializationProps) throws SSOException; 
isTargetInterceptor

	/**
	 * This methods will review the attributes in the requestAttributes Map 
     to determine if there is something that this interceptor should 
     act on.  If the interceptor return is "true", then the interceptor will 
     be responsible for authenticating the request and the authenticateRequest 
     method is invoked.   If the interceptor return is "false", then this 
     interceptor is skipped and the next isTargetInterceptor in the list will 
     be called.  Ordering of the interceptors during the configuration will 
     return which interceptor has the first shot at authenticating a request.
	 *
	 * @param requestAttributes attributes found in the inbound request	 
   * @return true if this interceptor will authenticate the request, 
             false if it will not.
	 * @throws SSOException
	 *
	 **/
	public boolean isTargetInterceptor(Request requestAttributes) throws SSOException;
	authenticateRequest

  /**
	 * This method is called on an interceptor that returns true for the 
     isTargetInterceptor method.  The Request will contain data used 
     to perform the authentication.  The Response is for the interceptor 
     to send information back to the client.  The Result returned will contain 
     the following information if the status code is 200:
	 * 
	 * OID:  an object identifier of the SecurityContext that can process token 
     information stored in this map when going to an Agent.
	 * Domain:  a valid BF domain name or <default> if not known 
     (the username must be valid in the configured realm).
	 * Username:  a valid BF username.   This will be used to lookup BFUser attributes 
     that are used in checking authorization policy.
	 * @see com.buildforge.services.common.security.context.Result
	 * 
	 * @param requestAttributes attributes found in the inbound request
	 * @param responseAttributes sent back in the outbound response
	 * @return com.buildforge.services.common.security.context.Result - result 
          information that tells BF how to handle the authentication request.
	 * @throws com.buildforge.services.server.sso.SSOException
	 **/
	public Result authenticateRequest(
			Request requestAttributes, 
			Response responseAttributes)
		throws SSOException;
	logoutRequest

  /**
	 * This method is called to logout a request.  The first interceptor that 
     returns true for the isTargetInterceptor method will perform the logout.   
     The main point is to clean up any user-related security information that 
     should not be kept.  The interceptor can inspect the request and response 
     objects to determine what needs to be removed.
	 * 
	 * @param requestAttributes attributes found in the inbound request
	 * @param responseAttributes sent back in the outbound response
	 * @return boolean - true if request redirect to exit page, 
                       false if redirect to login page.
	 * @throws com.buildforge.services.server.sso.SSOException
	 **/
	public boolean logoutRequest(
			Request requestAttributes, 
			Response responseAttributes)
		throws SSOException;

Feedback