Configuration des jetons de sécurité du générateur à l'aide de l'API WSS
Vous pouvez sécuriser les messages SOAP sans recourir à des ensembles de règles, en utilisant les API Web Services Security. Pour configurer le jeton côté générateur, utilisez les API Web Services Security (API WSS). Les jetons de sécurité du générateur se trouvent dans le package de l'interface com.ibm.websphere.wssecurity.wssapi.token.
Avant de commencer
L'infrastructure du jeton connectable dans WebSphere Application Server a été recréée pour pouvoir être réutilisable à partir de l'API WSS. La même implémentation de création et de validation du jeton de sécurité peut être utilisée pour l'exécution de la sécurité des services Web et pour le code d'application de l'API WSS. La nouvelle structure simplifie également le modèle de programmation de la SPI, ainsi que l'ajout de types de jeton de sécurité.
Vous pouvez utiliser l'API WSS ou configurer les jetons à l'aide de la console d'administration. Pour configurer des jetons, vous devez procéder comme suit :
- Configurez les jetons du générateur.
- Configurez les jetons du destinataire.
Pourquoi et quand exécuter cette tâche
Le module de connexion et le gestionnaire d'appel JAAS sont chargés de créer le jeton de sécurité côté générateur.
Côté générateur, le jeton est créé à l'aide du module de connexion JAAS, puis le gestionnaire d'appel JAAS sert à transmettre les données d'authentification. Ensuite, le module de connexion JAAS crée l'objet securityToken, tel que UsernameToken, et le transmet au module d'exécution WSS.
Côté destinataire, le format XML est transmis au module de connexion pour validation ou authentification. Ensuite, le gestionnaire d'appel permet d'envoyer les données d'authentification du module d'exécution de la sécurité des services Web au module de connexion. Une fois le jeton authentifié, un objet de jeton de sécurité est créé et le premier est transmis au module d'exécution de la sécurité des services Web.
Lorsque vous utilisez l'API WSS pour créer le jeton du générateur, certains comportements par défaut se produisent. La façon la plus simple d'utiliser l'API WSS est d'appliquer le comportement par défaut (voir l'exemple de code). L'API WSS fournit des valeurs par défaut pour le type de jeton, sa valeur et le nom de confirmation JAAS. Les comportements par défaut des jetons sont les suivants :
Choix relatifs aux jetons du générateur | Comportement par défaut |
---|---|
Type de jeton à utiliser | Il s'agit du type de jeton à utiliser pour l'intégrité, la confidentialité ou l'authenticité des messages. WebSphere Application
Server fournit les types de jetons de générateur préconfigurés suivants pour l'intégrité et la confidentialité
des messages :
WebSphere Application Server fournit aussi les types de jeton de générateur préconfigurés suivants pour l'authenticité des messages :
Vous pouvez aussi créer des types de jeton personnalisés, si besoin est. |
Nom de configuration de connexion JAAS à indiquer | Il s'agit du nom de configuration de connexion JAAS à utiliser. |
Type de configuration à utiliser | Le module de connexion JAAS indique le type de configuration. Seuls les types de configuration de générateur préconfigurés peuvent être employés pour les types de jeton du générateur. |
La classe SecurityToken (com.ibm.websphere.wssecurity.wssapi.token.SecurityToken) est la classe de jeton générique et représente le jeton de sécurité doté de méthodes pour obtenir l'identité, le format XML et des clés de chiffrement. A l'aide de cette classe, vous pouvez réaliser une signature et un chiffrement dans le message SOAP. Pour appliquer les deux opérations en revanche, vous devez disposer de deux objets SecurityToken : l'un pour la signature, l'autre pour le chiffrement, respectivement.
Les types de jeton suivants sont des sous-classes de la classe de jeton de sécurité générique :
Type de jeton | Nom de configuration de connexion JAAS |
---|---|
Jeton de nom d'utilisateur | system.wss.generate.unt |
Jeton de contexte de sécurité | system.wss.generate.sct |
Jeton de clé dérivée | system.wss.generate.dkt |
Les types de jeton suivants sont des sous-classes de la classe de jeton de sécurité binaire :
Type de jeton | Nom de configuration de connexion JAAS |
---|---|
Jeton LTPA | system.wss.generate.ltpa |
Jeton de propagation LTPA | system.wss.generate.ltpaProp |
Jeton X.509 | system.wss.generate.x509 |
X.509 PKI Path token | system.wss.generate.pkiPath |
Jeton X.509 PKCS7 | system.wss.generate.pkcs7 |
- Pour chaque nom de configuration du générateur de jetons de connexion JAAS, il existe un nom de configuration du destinataire de jeton correspondant. Par exemple, pour le jeton Username, le nom de configuration du destinataire de jeton équivalent est system.wss.consume.unt.
- Les jetons de propagation sont uniquement disponibles pour un demandeur exécutant un client basé serveur. La LTPA et les jetons de propagation LTPA ne sont pas compatibles avec le client d'application Java™ SE 6 ou Java EE.
Procédure
Résultats
Exemple
Le code exemple suivant présente comment utiliser les API WSS pour créer un jeton de sécurité Username, associer le jeton Username au message SOAP et configurer le jeton Username dans la liaison de générateur.
// importer les packages
import javax.xml.ws.BindingProvider;
import com.ibm.websphere.wssecurity.wssapi.*;
import com.ibm.websphere.wssecurity.callbackhandler.*;
...
// Obtenir le fournisseur de liaison
BindingProvider bp = ... ;
// Obtenir le contexte de requête
Map<String, Object> reqContext = bp.getRequestContext();
// Générer une instance WSSFactory
WSSFactory factory = WSSFactory.getInstance();
// Générer une instance WSSGenerationContext
WSSGenerationContext gencont = factory.newWSSGenerationContext();
// Générer le gestionnaire d'appel
UNTGenerateCallbackHandler untCallbackHandler =
new UNTGenerateCallbackHandler("Chris", "sirhC");
// Générer le jeton username
SecurityToken unt = factory.newSecurityToken(UsernameToken.class, untCallbackHandler);
// Ajouter SecurityToken à WSSGenerationContext
gencont.add(unt);
// Générer l'en-tête WS-Security
gencont.process(reqContext);
// generate callback handler
LTPAGenerateCallbackHandler ltpaCallbackHandler = new LTPAGenerateCallbackHandler(null, null);
// Générer le jeton LTPAv2
SecurityToken ltpa = wssfactory.newSecurityToken(LTPAv2Token.class, ltpaCallbackHandler);
L'instanciation de l'objet LTPAGenerateCallbackHandler avec (null, null) indique que le jeton LTPA doit être généré à partir de l'identité runAs en cours. Si le gestionnaire d'appel est instancié avec les informations basicAuth, ("userName", "password"), un jeton LTPA est créé à l'aide des informations basicAuth spécifiées.
// importer les packages
import javax.xml.ws.BindingProvider;
import com.ibm.websphere.wssecurity.wssapi.*;
import com.ibm.websphere.wssecurity.callbackhandler.*;
...
// Obtenir le fournisseur de liaison
BindingProvider bp = ... ;
// Obtenir le contexte de requête
Map<String, Object> reqContext = bp.getRequestContext();
// Générer une instance WSSFactory
WSSFactory wssFactory = WSSFactory.getInstance();
WSSGenerationContext bootstrapGenCon = wssFactory.newWSSGenerationContext();
// Créer un horodatage
...
// Ajouter l'horodatage
...
// Signer le corps SOAP, les en-têtes WS-Addressing et l'horodatage
X509GenerateCallbackHandler btspReqSigCbHandler = new X509GenerateCallbackHandler(...);
SecurityToken btspReqSigToken = wssFactory.newSecurityToken(X509Token.class,
btspReqSigCbHandler);
WSSSignature bootstrapReqSig = wssFactory.newWSSSignature(btspReqSigToken);
bootstrapReqSig.setCanonicalizationMethod(WSSSignature.EXC_C14N);
// Ajouter des parties de signature
...
bootstrapGenCon.add(bootstrapReqSig);
// Chiffrer le corps SOAP et la signature
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);
// Ajouter des parties de chiffrement
...
bootstrapGenCon.add(bootstrapReqEnc);
WSSConsumingContext bootstrapConCon = wssFactory.newWSSConsumingContext();
X509ConsumeCallbackHandler btspRspVfyCbHandler = new X509ConsumeCallbackHandler(....);
WSSVerification bootstrapRspVfy = wssFactory.newWSSVerification(X509Token.class,
btspRspVfyCbHandler);
bootstrapRspVfy.addAllowedCanonicalizationMethod(WSSVerification.EXC_C14N);
// Ajouter des parties de vérification
...
bootstrapConCon.add(bootstrapRspVfy);
X509ConsumeCallbackHandler btspRspDecCbHandler = new X509ConsumeCallbackHandler(...);
WSSDecryption bootstrapRspDec = wssFactory.newWSSDecryption(X509Token.class,
btspRspDecCbHandler);
bootstrapRspDec.addAllowedEncryptionMethod(WSSDecryption.AES128);
bootstrapRspDec.addAllowedKeyEncryptionMethod(WSSDecryption.KW_RSA15);
// Ajouter des parties de déchiffrement
...
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];
// Utiliser SCT pour générer des DKT pour la conversation sécurisée
// Algorithme de signature et libellés client et service
DerivedKeyToken dktSig = sct.getDerivedKeyToken(WSSSignature.HMAC_SHA1, "WS-SecureConversation", "WS-SecureConversation");
// Algorithme de déchiffrement et libellés client et service
DerivedKeyToken dktEnc = sct.getDerivedKeyToken(WSSEncryption.AES128, "WS-SecureConversation", "WS-SecureConversation");
// Créer le contexte de génération de l'application pour le message de demande
WSSGenerationContext applicationGenCon = wssFactory.newWSSGenerationContext();
// Créer et ajouter un horodatage
...
// Ajouter le jeton de clé dérivée et signer le corps SOAP et les en-têtes WS-Addressing
WSSSignature appReqSig = wssFactory.newWSSSignature(dktSig);
appReqSig.setSignatureMethod(WSSSignature.HMAC_SHA1);
appReqSig.setCanonicalizationMethod(WSSSignature.EXC_C14N);
...
applicationGenCon.add(appReqSig);
// Ajouter le jeton de clé dérivée et chiffrer le corps SOAP et la signature
WSSEncryption appReqEnc = wssFactory.newWSSEncryption(dktEnc);
appReqEnc.setEncryptionMethod(WSSEncryption.AES128);
appReqEnc.setTokenReference(SecurityToken.REF_STR);
appReqEnc.encryptKey(false);
...
applicationGenCon.add(appReqEnc);
// Créer le contexte de destination de l'application pour le message de réponse
WSSConsumingContext applicationConCon = wssFactory.newWSSConsumingContext();
// Libellés client et service et algorithme de déchiffrement
SCTConsumeCallbackHandler sctCbHandler = new SCTConsumeCallbackHandler("WS-SecureConversation", "WS-SecureConversation", WSSDecryption.AES128);
// Dériver le jeton de SCT et l'utiliser pour déchiffrer le corps SOAP et la signature
WSSDecryption appRspDec = wssFactory.newWSSDecryption(SecurityContextToken.class,
sctCbHandler);
appRspDec.addAllowedEncryptionMethod(WSSDecryption.AES128);
appRspDec.encryptKey(false);
...
applicationConCon.add(appRspDec);
// Dériver le jeton de SCT et l'utiliser pour vérifier la
// signature sur le corps SOAP, les en-têtes WS-Addressing et l'horodatage
WSSVerification appRspVfy = wssFactory.newWSSVerification(SecurityContextToken.class,
sctCbHandler);
...
applicationConCon.add(appRspVfy);
...
applicationGenCon.process(reqContext);
applicationConCon.process(reqContext);
Que faire ensuite
Pour chaque type de jeton, configurez le jeton à l'aide des API WSS ou de la console d'administration. Indiquez ensuite les jetons similaires de destinataire si ce n'est pas déjà fait.
Si les jetons du générateur et du destinataire sont configurés, continuez à sécuriser les messages SOAP en signant le message SOAP ou en déchiffrant le message, selon les besoins. Vous pouvez utiliser les API WSS ou la console d'administration pour sécuriser les messages SOAP.