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:
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:
WebSphere Application Server stellt außerdem die folgenden vorkonfigurierten Generatortokentypen für die Nachrichtenauthentizität bereit:
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:
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:
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 |
- 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
Ergebnisse
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);
// 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.
// 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.