Generatorsicherheitstoken mit der WSS-API konfigurieren

Mit den APIs von Web Services Security können Sie die SOAP-Nachrichten ohne Richtliniensätze sichern. Wenn Sie das Token auf der Generatorseite konfigurieren, verwenden Sie die APIs von Web Services Security (WSS-API). Die Generatorsicherheitstoken gehören zum Schnittstellenpaket com.ibm.websphere.wssecurity.wssapi.token.

Vorbereitende Schritte

Das Framework für Plug-in-Token in WebSphere Application Server wurde neu gestaltet, damit dasselbe Framework über die WSS-APIs wiederverwendet werden kann. Für die Laufzeitumgebung von Web Services Security und für den WSS-API-Anwendungscode wird dieselbe Implementierung für das Erstellen und Validieren von Sicherheitstoken verwendet. Das neu gestaltete Framework vereinfacht auch das SPI-Programmiermodell und das Hinzufügen von Sicherheitstokentypen.

Sie können die WSS-API verwenden oder die Token über die Administrationskonsole konfigurieren. Zum Konfigurieren von Token müssen Sie die folgenden Tokentasks ausführen:

  • Generatortoken konfigurieren
  • Konsumententoken konfigurieren

Informationen zu diesem Vorgang

Das JAAS-Anmeldemodul und der JAAS-CallbackHandler sind für das Erstellen der Sicherheitstoken auf der Generatorseite verantwortlich.

Das Token wird auf der Generatorseite mit dem JAAS-Anmeldemodul erstellt, und mit dem JAAS-CallbackHandler werden die Authentifizierungsdaten übergeben. Anschließend erstellt das JAAS-Anmeldemodul das securityToken-Objekt, z. B. das UsernameToken, und übergibt es an die Laufzeitumgebung von Web Services Security.

Auf der Konsumentenseite wird das XML-Format zur Validierung und Authentifizierung an das JAAS-Anmeldemodul übergeben. Anschließend wird der JAAS-CallbackHandler verwendet, um Authentifizierungsdaten von der Laufzeitumgebung von Web Services Security an das Anmeldemodul zu übergeben. Nach der Authentifizierung des Tokens und der Erstellung des Sicherheitstokenobjekts wird das Token an die Laufzeitumgebung von Web Services Security übergeben.

Wenn die WSS-API für die Erstellung des Generatortokens verwendet wird, sind bestimmte Verhalten zu beobachten. Die API WSS lässt sich am einfachsten über den Einsatz des Standardverhaltens verwenden (siehe Beispielcode). Die WSS-API stellt Standardeinstellungen für den Tokentyp, den Tokenwert und den JAAS-Konfigurationsnamen bereit. Im Folgenden sind die Standardverhalten für Token beschrieben:

Tabelle 1. Tokenentscheidungen und Standardverhalten. Verschiedene Kenndaten von Token werden standardmäßig konfiguriert.
Entscheidungen bzgl. Generatortoken Standardverhalten
Zu verwendender Tokentyp

Der Tokentyp gibt an, welcher Typ von Token für die Nachrichtenintegrität, die Nachrichtenvertraulichkeit oder die Nachrichtenauthentizität verwendet wird.

WebSphere Application Server stellt die folgenden vorkonfigurierten Generatortokentypen für die Nachrichtenintegrität und Nachrichtenvertraulichkeit bereit:
  • Abgeleitetes Schlüsseltoken
  • X509-Token
Bei Bedarf können Sie aus angepasste Tokentypen erstellen:

WebSphere Application Server stellt außerdem die folgenden vorkonfigurierten Generatortokentypen für die Nachrichtenauthentizität bereit:

  • Benutzernamenstoken
  • LTPA-Token
  • X509-Token

Bei Bedarf können Sie aus angepasste Tokentypen erstellen:

Anzugebender Name für die JAAS-Anmeldekonfiguration

Der Name für die JAAS-Anmeldekonfiguration gibt an, welche JAAS-Anmeldekonfiguration verwendet werden soll.

Zu verwendender Konfigurationstyp Das JAAS-Anmeldemodul gibt den Konfigurationstyp an. Nur die vorkonfigurierten Generatorkonfigurationstypen können als Generatortokentypen verwendet werden.

Die SecurityToken-Klasse (com.ibm.websphere.wssecurity.wssapi.token.SecurityToken) ist die generische Tokenklasse und stellt das Sicherheitstoken dar, das Methoden für das Abrufen der Identität, des XML-Formats und der Chiffrierschlüssel enthält. Mit der SecurityToken-Klasse können Sie Signatur und Verschlüsselung auf die SOAP-Nachricht anwenden. Wenn Sie beides anwenden möchten, müssen Sie jedoch zwei SecurityToken-Objekte haben, eines für die Signatur und eines für die Verschlüsselung.

Die folgenden Tokentypen sind Unterklassen der generischen Sicherheitstokenklasse:

Tabelle 2. Unterklassen von SecurityToken. Verwenden Sie die Unterklassen zur Darstellung des Sicherheitstokens.
Tokentyp Name der JAAS-Anmeldekonfiguration
Benutzernamenstoken system.wss.generate.unt
Sicherheitskontexttoken system.wss.generate.sct
Abgeleitetes Schlüsseltoken system.wss.generate.dkt

Die folgenden Tokentypen sind Unterklassen der Klasse für binäre Sicherheitstoken:

Tabelle 3. Unterklassen von BinarySecurityToken. Verwenden Sie die Unterklassen zur Darstellung des binären Sicherheitstokens.
Tokentyp Name der JAAS-Anmeldekonfiguration
LTPA-Token system.wss.generate.ltpa
LTPA-Weitergabetoken system.wss.generate.ltpaProp
X.509-Token system.wss.generate.x509
X.509-PKIPath-Token system.wss.generate.pkiPath
X.509-PKCS7-Token system.wss.generate.pkcs7
Anmerkung:
  • Für jede JAAS-Anmeldekonfiguration auf Generatortokenseite gibt es eine entsprechende Konfiguration auf Tokenkonsumentenseite. Für das Benutzernamenstoken ist "system.wss.consume.unt" der Name der Tokenkonsumentenkonfiguration.
  • Die LTPA- und LTPA-Weitergabetoken sind nur für einen Anforderer verfügbar, der als serverbasierter Client ausgeführt wird. Die LTPA-Token und LTPA-Weitergabetoken werden für Anwendungsclients des Typs Java™ SE 6 und Java EE nicht unterstützt.

Vorgehensweise

  1. Zum Konfigurieren des securityToken-Pakets com.ibm.websphere.wssecurity.wssapi.token müssen Sie zuerst sicherstellen, dass der Anwendungsserver installiert ist.
  2. Verwenden Sie den Generatorprozess für WSS-Token, um die Token zu konfigurieren. Für alle Tokentypen gleicht der Prozess dem folgenden Prozess, der den Tokengeneratorprozess für Benutzernamenstoken veranschaulicht:
    1. Mit WSSFactory.getInstance() die Instanz der WSS-API-Implementierung abrufen.
    2. WSSGenerationContext-Instanz aus der WSSFactory-Instanz erstellen.
    3. JAAS-CallbackHandler erstellen. Die Authentifizierungsdaten, wie z. B. der Benutzername und das Kennwort, werden im CallbackHandler angegeben. Im folgenden Code wird beispielsweise Chris als Benutzername und sirhC als Kennwort angegeben: UNTGenerationCallbackHandler("Chris", "sirhC");
    4. Alle JAAS-CallbackHandler-Parameter aufrufen und die Informationen zur Tokenklasse überprüfen, für die Parameter erforderlich oder optional sind. Für Benutzernamenstoken können beispielsweise auch die folgenden Parameter konfiguriert werden:
      Nonce
      Gibt an, ob ein Nonce-Element in das Benutzernamenstoken für den Tokengenerator aufgenommen wird. "Nonce" ist eine eindeutige verschlüsselte Nummer, die in eine Nachricht eingebettet wird, um wiederholte, unbefugte Hacker-Attacken auf Benutzernamenstoken zu verhindern. Der Nonce-Wert ist nur gültig, wenn Benutzernamenstoken der Typ des generierten Token ist und wenn das Token für die Anforderungsgeneratorbindung gilt.
      Erstellte Zeitmarke
      Gibt an, ob eine Zeitmarke in das Benutzernamenstoken eingefügt werden soll. Der Zeitmarkenwert ist nur gültig, wenn Benutzernamenstoken (UsernameToken) als Typ für das generierte Token verwendet werden und wenn das Token für die Anforderungsgeneratorbindung gilt.
    5. SecurityToken aus WSSFactory erstellen.

      Standardmäßig gibt die API UsernameToken den ValueType mit "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#UsernameToken" an.

      Die API "UsernameToken" stellt den QName dieser Klasse standardmäßig bereit und gibt "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" für NamespaceURI und "UsernameToken" für LocalPart an.

    6. Optional: Namen der JAAS-Anmeldemodulkonfiguration angeben. Auf der Generatorseite ist der Konfigurationstyp immer generate (z. B. system.wss.generate.unt).
    7. SecurityToken zum WSSGenerationContext hinzufügen.
    8. WSSGenerationContext.process() aufrufen und WS-Security-Header generieren.

Ergebnisse

Wenn eine Fehlerbedingung eintritt, wird eine Ausnahme vom Typ "WSSException" angezeigt. Bei erfolgreicher Ausführung wird WSSGenerationContext.process() aufgerufen, und das Sicherheitstoken für die Generatorbindung wird zugeordnet.

Beispiel

Der folgende Beispielcode veranschaulicht, wie die WSS-APIs verwendet werden, um ein Benutzernamenssicherheitstoken zu erstellen, das Benutzernamenstoken der SOAP-Nachricht zuzuordnen und das Benutzernamenstoken in der Generatorbindung zu konfigurieren.

// Pakete importieren
import javax.xml.ws.BindingProvider;
import com.ibm.websphere.wssecurity.wssapi.*;
import com.ibm.websphere.wssecurity.callbackhandler.*;
...
   // Bindungsprovider anfordern
   BindingProvider bp = ... ;

   // Anforderungskontext abrufen
   Map<String, Object> reqContext = bp.getRequestContext();

   // WSSFactory-Instanz generieren
   WSSFactory factory = WSSFactory.getInstance();

   // WSSGenerationContext-Instanz generieren
   WSSGenerationContext gencont = factory.newWSSGenerationContext();

   // Callback-Handler generieren
   UNTGenerateCallbackHandler untCallbackHandler = 
   	         new UNTGenerateCallbackHandler("Chris", "sirhC");		

   // Benutzernamenstoken generieren
   SecurityToken unt = factory.newSecurityToken(UsernameToken.class, untCallbackHandler);

   // SecurityToken zum WSSGenerationContext hinzufügen
   gencont.add(unt);

   // WS-Security-Header generieren
   gencont.process(reqContext);
Der folgende Beispielcode veranschaulicht, wie das vorhergehende Beispiel eines Benutzernamenstokens dahingehend abgeändert wird, dass es ein LTPAv2-Token aus der RunAs-ID des aktuellen Thread erstellt. Die beiden Codezeilen, die den Callback-Handler instanziieren und das Sicherheitstoken erstellen, werden durch die folgenden zwei Codezeilen ersetzt:
// Callback-Handler generieren
LTPAGenerateCallbackHandler ltpaCallbackHandler = new LTPAGenerateCallbackHandler(null, null);

// LTPAv2-Token generieren
SecurityToken ltpa = wssfactory.newSecurityToken(LTPAv2Token.class, ltpaCallbackHandler);

Die Instanziierung des Objekts "LTPAGenerateCallbackHandler" mit "(null, null)" zeigt an, dass das LTPA-Token aus der aktuellen RunAs-ID erstellt werden soll. Wenn der Callback-Handler mit "basicAuth"-Angaben instanziiert wird ("userName", "password"), wird ein neues LTPA-Token mit diesen "basicAuth"-Angaben erstellt.

Das folgende Beispiel veranschaulicht, wie SecureConversation mit den WSS-APIs verwendet wird, um die Generatortoken und die Konsumententoken zu konfigurieren. In diesem Beispiel wird das Token "SecurityContextToken" unter Verwendung des Namespace von WS-SecureConversation Draft erstellt: http://schemas.xmlsoap.org/ws/2005/02/sc/sct. Wenn Sie den Namespace von WS-SecureConversation Version 1.3, http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512/sct, verwenden möchten, geben Sie SecurityContextToken13.class anstelle von SecurityContextToken.class an.
// Pakete importieren
import javax.xml.ws.BindingProvider;
import com.ibm.websphere.wssecurity.wssapi.*;
import com.ibm.websphere.wssecurity.callbackhandler.*;
...
   // Bindungsprovider anfordern
   BindingProvider bp = ... ;

   // Anforderungskontext abrufen
   Map<String, Object> reqContext = bp.getRequestContext();

   // WSSFactory-Instanz generieren
   WSSFactory wssFactory = WSSFactory.getInstance();

   WSSGenerationContext bootstrapGenCon = wssFactory.newWSSGenerationContext();

   		// Zeitmarke erstellen
   ...
   // Zeitmarke hinzufügen
   ...

   		// SOAP-Hauptteil, WS-Addressing-Header und Zeitmarke signieren
   X509GenerateCallbackHandler btspReqSigCbHandler = new X509GenerateCallbackHandler(...);
   SecurityToken btspReqSigToken = wssFactory.newSecurityToken(X509Token.class,
                                                               btspReqSigCbHandler);
   		WSSSignature bootstrapReqSig = wssFactory.newWSSSignature(btspReqSigToken);
   bootstrapReqSig.setCanonicalizationMethod(WSSSignature.EXC_C14N);

   // Signaturabschnitte hinzufügen
   ...
   bootstrapGenCon.add(bootstrapReqSig);

   		// SOAP-Hauptteil und Signatur verschlüsseln
   X509GenerateCallbackHandler btspReqEncCbHandler = new X509GenerateCallbackHandler(...);
   		SecurityToken btspReqEncToken = wssFactory.newSecurityToken(X509Token.class, btspReqEncCbHandler);
   WSSEncryption bootstrapReqEnc = wssFactory.newWSSEncryption(btspReqEncToken);
   bootstrapReqEnc.setEncryptionMethod(WSSEncryption.AES128);
   bootstrapReqEnc.setKeyEncryptionMethod(WSSEncryption.KW_RSA15);

   // Verschlüsselungsabschnitte hinzufügen
   ...
   bootstrapGenCon.add(bootstrapReqEnc);
   WSSConsumingContext bootstrapConCon = wssFactory.newWSSConsumingContext();
   X509ConsumeCallbackHandler btspRspVfyCbHandler = new X509ConsumeCallbackHandler(....);
   WSSVerification bootstrapRspVfy = wssFactory.newWSSVerification(X509Token.class, btspRspVfyCbHandler);
   bootstrapRspVfy.addAllowedCanonicalizationMethod(WSSVerification.EXC_C14N);

   // Prüfabschnitte hinzufügen
   ...
   bootstrapConCon.add(bootstrapRspVfy);
   X509ConsumeCallbackHandler btspRspDecCbHandler = new X509ConsumeCallbackHandler(...);
   WSSDecryption bootstrapRspDec = wssFactory.newWSSDecryption(X509Token.class, btspRspDecCbHandler);
   bootstrapRspDec.addAllowedEncryptionMethod(WSSDecryption.AES128);
   bootstrapRspDec.addAllowedKeyEncryptionMethod(WSSDecryption.KW_RSA15);

   // Entschlüsselungsabschnitte hinzufügen
   ...
   bootstrapConCon.add(bootstrapRspDec);
   SCTGenerateCallbackHandler sctgch = new SCTGenerateCallbackHandler(bootstrapGenCon,
                                                                      bootstrapConCon,
                                                                      ENDPOINT_URL,
                                                                      WSSEncryption.AES128);
   SecurityToken[] scts = wssFactory.newSecurityTokens(new Class[]{SecurityContextToken.class}, sctgch);
   SecurityContextToken sct = (SecurityContextToken)scts[0];

   // Sicherheitskontexttoken zum Generieren der abgeleiteten Schlüssel für Secure Conversation verwenden
   // Signaturalgorithmus und Client- und Servicekennsätze
   		DerivedKeyToken dktSig = sct.getDerivedKeyToken(WSSSignature.HMAC_SHA1, "WS-SecureConversation", "WS-SecureConversation");

   // Verschlüsselungsalgorithmus und Client- und Servicekennsätze
   		DerivedKeyToken dktEnc = sct.getDerivedKeyToken(WSSEncryption.AES128, "WS-SecureConversation", "WS-SecureConversation");

   // Anwendungsgenerierungskontext für die Anforderungsnachricht erstellen
   WSSGenerationContext applicationGenCon = wssFactory.newWSSGenerationContext();

   		// Zeitmarke erstellen und hinzufügen
   ...

   // Abgeleitetes Schlüsseltoken hinzufügen und SOAP-Hauptteil und WS-Addressing-Header signieren
   WSSSignature appReqSig = wssFactory.newWSSSignature(dktSig);
   appReqSig.setSignatureMethod(WSSSignature.HMAC_SHA1);
   appReqSig.setCanonicalizationMethod(WSSSignature.EXC_C14N);
   ...
   applicationGenCon.add(appReqSig);

   // Abgeleitetes Schlüsseltoken hinzufügen und SOAP-Hauptteil und Signatur verschlüsseln
   WSSEncryption appReqEnc = wssFactory.newWSSEncryption(dktEnc);
   appReqEnc.setEncryptionMethod(WSSEncryption.AES128);
   appReqEnc.setTokenReference(SecurityToken.REF_STR);
   appReqEnc.encryptKey(false);
   ...
   applicationGenCon.add(appReqEnc);

   // Anwendungskonsumkontext für Antwortnachricht erstellen
   WSSConsumingContext applicationConCon = wssFactory.newWSSConsumingContext();

   // Client- und Servicebezeichnungen und Entschlüsselungsalgorithmus
   		SCTConsumeCallbackHandler sctCbHandler = new SCTConsumeCallbackHandler("WS-SecureConversation", "WS-SecureConversation", WSSDecryption.AES128);

   		// Token aus Sicherheitstoken ableiten und zum Entschlüsseln des SOAP-Hauptteils und der Signatur verwenden
   		WSSDecryption appRspDec = wssFactory.newWSSDecryption(SecurityContextToken.class, sctCbHandler);
   appRspDec.addAllowedEncryptionMethod(WSSDecryption.AES128);
   appRspDec.encryptKey(false);
   ...
   applicationConCon.add(appRspDec);

   // Token aus Sicherheitstoken ableiten und für die Prüfung der
   // Signatur in SOAP-Hauptteil, WS-Addressing-Headern und Zeitmarke verwenden
   		WSSVerification appRspVfy = wssFactory.newWSSVerification(SecurityContextToken.class, sctCbHandler);
   ...
   applicationConCon.add(appRspVfy);
   ...
   applicationGenCon.process(reqContext);
   applicationConCon.process(reqContext);

Nächste Schritte

Konfigurieren Sie für jeden Tokentyp das Token mit den WSS-APIs oder über die Administrationskonsole. Geben Sie als Nächstes ähnliche Konsumententoken an, sofern Sie dies noch nicht getan haben.

Wenn die Generator- und Konsumententoken konfiguriert sind, fahren Sie mit dem Sichern der SOAP-Nachrichten durch Signieren der SOAP-Nachricht bzw. durch Verschlüsseln der Nachricht fort. Sie können zum Sichern der SOAP-Nachrichten die WSS-APIs oder die Administrationskonsole verwenden.


Symbol, das den Typ des Artikels anzeigt. Taskartikel



Symbol für Zeitmarke Letzte Aktualisierung: 25.05.2016
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=twbs_confwssgeneratortoken
Dateiname:twbs_confwssgeneratortoken.html