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 :

Tableau 1. Choix relatifs aux jetons et comportements par défaut. Certaines caractéristiques des jetons sont configurées par défaut.
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 :
  • Jeton de clé dérivée
  • Jetons X509
Vous pouvez aussi créer des types de jeton personnalisés, si besoin est.

WebSphere Application Server fournit aussi les types de jeton de générateur préconfigurés suivants pour l'authenticité des messages :

  • Jeton de nom d'utilisateur
  • Jetons LTPA
  • Jetons X509

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 :

Tableau 2. Sous-classes de SecurityToken. Utilisez les sous-classes pour représenter le jeton de sécurité.
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 :

Tableau 3. Sous-classes de BinarySecurityToken. Utilisez les sous-classes pour représenter le 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
Remarque :
  • 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

  1. Pour configurer le package com.ibm.websphere.wssecurity.wssapi.token, vérifiez d'abord que le serveur d'applications est installé.
  2. Utilisez le processus du générateur de jetons pour la sécurité des services Web pour configurer les jetons. Pour chaque type de jeton, la procédure est similaire à celle qui suit illustrant le générateur de jetons UsernameToken :
    1. Utilisez WSSFactory.getInstance() pour obtenir l'instance d'implémentation d'API WSS.
    2. Créez l'instance WSSGenerationContext à partir de l'instance WSSFactory.
    3. Créez un gestionnaire d'appel JAAS. Les données d'authentification, comme le nom d'utilisateur et le mot de passe, sont indiqués dans le gestionnaire d'appel. Par exemple, le code suivant indique que Chris est le nom d'utilisateur et sirhC le mot de passe : UNTGenerationCallbackHandler("Chris", "sirhC");
    4. Appelez les paramètres CallbackHandler JAAS et consultez les informations sur la classe du jeton pour savoir quels paramètres sont obligatoires et quels paramètres sont facultatifs. Par exemple, pour UsernameToken, les paramètres suivants peuvent aussi être configurés :
      Nonce
      Indique si un nonce est inclus dans le jeton de nom d'utilisateur pour le générateur de jetons. Nonce est un numéro cryptographique unique, incorporé dans un message pour aider à arrêter les attaques à répétition et non autorisées des jetons de nom d'utilisateur. Cette valeur est uniquement valide lorsque le type de jeton généré est UsernameToken et quand elle s'applique à la liaison de générateur de demande.
      Horodatage créé
      Indique si un horodatage doit être inséré dans UsernameToken. La valeur d'horodatage est uniquement valide lorsque le type de jeton généré est UsernameToken et quand elle s'applique à la liaison de générateur de demande.
    5. Créez SecurityToken à partir de WSSFactory.

      Par défaut, l'API UsernameToken indique ValueType comme : "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#UsernameToken"

      Par défaut, l'API UsernameToken indique le QName de cette classe et précise l'URI espace de nom comme http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd ; elle indique aussi LocalPart comme UsernameToken.

    6. Facultatif : Spécifiez le nom de configuration du module de connexion JAAS. Côté générateur, le type de configuration type est toujours generate (par exemple, system.wss.generate.unt).
    7. Ajoutez l'élément SecurityToken à WSSGenerationContext.
    8. Appelez WSSGenerationContext.process() et générez l'en-tête WS-Security.

Résultats

S'il existe une condition d'erreur, une WSSException est fournie. Si l'opération aboutit, la méthode WSSGenerationContext process() est appelée et le jeton de sécurité pour la liaison de générateur est associé.

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);
Le code exemple suivant présente comment modifier l'exemple de jeton Username précédent pour créer un jeton LTPAv2 à partir de l'identité runAs sur l'unité d'exécution en cours. Les deux lignes de code qui instancient le gestionnaire d'appel et créent le jeton de sécurité sont remplacées par les deux lignes de code suivantes :
// 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.

L'exemple suivant montre comment utiliser la conversation sécurisée avec les API WSS pour configurer les jetons de générateur, ainsi que les jetons de destinataire. Dans cet exemple, le jeton SecurityContextToken est créé )à l'aide du projet d'espace de nom WS-SecureConversation : http://schemas.xmlsoap.org/ws/2005/02/sc/sct. Pour utiliser l'espace de nom WS-SecureConversation version 1.3, http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512/sct, spécifiez SecurityContextToken13.class à la place de SecurityContextToken.class.
// 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.


Icône indiquant le type de rubrique Rubrique de tâche



Icône d'horodatage Dernière mise à jour: last_date
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=twbs_confwssgeneratortoken
Nom du fichier : twbs_confwssgeneratortoken.html