Chiffrement du message SOAP à l'aide de l'API WSSEncryption

Vous pouvez sécuriser les messages SOAP, sans utiliser d'ensemble de règles de configuration, en utilisant les API Web Services Security (WSS API). Pour configurer le client pour le chiffrement des demandes côté générateur, utilisez l'API WSSEncryption afin de chiffrer le message SOAP. L'API WSSEncryption indique les portions du message SOAP à chiffrer lors de la configuration du client.

Avant de commencer

Vous pouvez utiliser l'API WSS ou des ensembles de règles dans la console d'administration pour activer le chiffrement et ajouter des jetons de sécurité du générateur dans le message SOAP. Pour sécuriser des messages SOAP, utilisez les API WSS afin d'exécuter les tâches de chiffrement suivantes, si besoin est :

  • Configurez le chiffrement et choisissez les méthodes de chiffrement à l'aide de l'API WSSEncryption.
  • Configurez les portions chiffrées, si besoin est, à l'aide de l'API WSSEncryptPart.

Pourquoi et quand exécuter cette tâche

Les informations de chiffrement côté générateur servent à chiffrer un message SOAP sortant pour les liaisons du générateur de la demande (côté client). La configuration du générateur client doit correspondre à celle du fournisseur destinataire.

Utilisation de l'API WSSEncryption pour chiffrer un message SOAP sortant

Les paramètres de confidentialité exigent l'application de contraintes de confidentialité aux messages générés. Ces contraintes incluent l'indication des portions du message généré à chiffrer et celles auxquelles associer des éléments nonce et d'horodatage chiffrés.

Les portions chiffrées suivantes peuvent être configurées :

Tableau 1. Parties chiffrées. Utilisation des portions chiffrées pour l'activation du chiffrement dans les messages.
Parties chiffrées Description
part Ajoute l'objet WSSEncryptPart comme cible de la portion chiffrée.
keyword Ajoute, à l'aide de mots clés, les portions chiffrées. WebSphere Application Server prend en charge les mots clés suivants :
  • BODY_CONTENT
  • SIGNATURE
xpath Ajoute la portion chiffrée à l'aide d'une expression XPath.
signature Ajoute le composant WSSignature comme cible de la portion chiffrée.
header Ajoute l'en-tête SOAP, indiqué par QName, comme cible de la portion chiffrée.
securityToken Ajoute l'objet SecurityToken comme cible de la partie chiffrée.

Certains comportements par défaut s'appliquent aux portions chiffrées. La façon la plus simple d'utiliser l'API WSSEncryption est d'appliquer les comportements par défaut (voir l'exemple de code).

WSSEncryption fournit des valeurs par défaut pour l'algorithme de chiffrement de clé, l'algorithme de chiffrement de données, la méthode de référence du jeton de sécurité et les portions chiffrées, comme le contenu du corps SOAP et la signature. Le comportement par défaut des portions chiffrées inclut :

Tableau 2. Choix de chiffrement. Utilisation du comportement de chiffrement par défaut pour la sécurisation du contenu du corps du message et de la signature.
Choix de chiffrement Comportement par défaut
Parties de message SOAP à chiffrer à l'aide de mots clés

Définit les portions chiffrées que vous pouvez ajouter à l'aide de mots clés. Celles par défaut sont BODY_CONTENT et SIGNATURE. WebSphere Application Server prend en charge les mots clés suivants :

  • WSSEncryption.BODY_CONTENT
  • WSSEncryption.SIGNATURE
La méthode de chiffrement de données (algorithm)

Définit la méthode de chiffrement de données. La méthode de chiffrement de données et la méthode de chiffrement de clé peuvent toutes les deux être spécifiées. La méthode d'algorithme de chiffrement de données par défaut est AES 128. WebSphere Application Server prend en charge les méthodes de chiffrement de données suivantes :

  • WSSEncryption.AES128 : http://www.w3.org/2001/04/xmlenc#aes128-cbc
  • WSSEncryption.AES192 : http://www.w3.org/2001/04/xmlenc#aes192-cbc
  • WSSEncryption.AES256 : http://www.w3.org/2001/04/xmlenc#aes256-cbc
  • WSSEncryption.TRIPLE_DES : http://www.w3.org.2001/04/xmlenc#tripledes-cbc
Le chiffrement, ou non, de la clé (isEncrypt)

Indique si la clé doit être chiffrée. Les valeurs sont true ou false. La valeur par défaut consiste à chiffrer la clé (true).

La méthode de chiffrement de clé (algorithm)

Définit la méthode de chiffrement de clé. La méthode de chiffrement de données et la méthode de chiffrement de clé peuvent toutes les deux être spécifiées. La méthode d'algorithme de chiffrement de clé par défaut est l'encapsulation de clé RSA OAEP. WebSphere Application Server prend en charge les méthodes de chiffrement suivantes :

  • WSSEncryption.KW_AES128 : http://www.w3.org/2001/04/xmlenc#kw-aes128
  • WSSEncryption.KW_AES192 : http://www.w3.org/2001/04/xmlenc#kw-aes192
  • WSSEncryption.KW_AES256 : http://www.w3.org/2001/04/xmlenc#kw-aes256
  • WSSEncryption.KW_RSA_OAEP : http://www.w3.org/2001/04/xmlenc#rsa-oaep-mgf1p
  • WSSEncryption.KW_RSA15 : http://www.w3.org/2001/04/xmlenc#rsa-1_5
  • WSSEncryption.KW_TRIPLE_DES : http://www.w3.org/2001/04/xmlenc#kw-tripledes
Jeton de sécurité à spécifier (securityToken)

Détermine l'objet SecurityToken. Le type de jeton de sécurité par défaut est X509Token. WebSphere Application Server fournit les types de jeton de destinataire préconfigurés suivants :

  • Jeton de clé dérivée
  • Jetons X.509
La référence de jeton à utiliser (refType) Définit le type de référence de jeton de sécurité. Celle par défaut est SecurityToken.REF_KEYID. WebSphere Application Server prend en charge les types de référence de jeton suivants :
  • SecurityToken.REF_KEYID
  • SecurityToken.REF_STR
  • SecurityToken.REF_EMBEDDED
  • SecurityToken.REF_THUMBPRINT
L'utilisation, ou non, de MTOM (mtomOptimize) Définit l'optimisation MTOM (Message Transmission Optimization Mechanism) pour la portion chiffrée.

Procédure

  1. Pour déchiffrer le message SOAP à l'aide de l'API WSSEncryption, vérifiez d'abord que le serveur d'applications est installé.
  2. L'API WSS pour le chiffrement suit la procédure ci-après :
    1. Utilisation de WSSFactory.getInstance() pour obtenir l'instance d'implémentation d'API WSS.
    2. Crée l'instance WSSGenerationContext à partir de l'instance WSSFactory.
    3. Création de SecurityToken à partir de WSSFactory utilisé pour le chiffrement.
    4. Création de WSSEncryption à partir de l'instance WSSFactory à l'aide de SecurityToken. Par défaut, WSSEncryption chiffre le contenu du corps et la signature.
    5. Ajout d'une nouvelle portion chiffrée dans WSSEncryption si celle existante n'est pas appropriée. Après l'appel d'addEncryptPart(), d'addEncryptHeader() ou d'addEncryptPartByXPath(), la portion par défaut est effacée.
    6. Appel de l'instance encryptKey(false) si la clé ne doit pas être chiffrée.
    7. Définition de la méthode de chiffrement de données si celle par défaut n'est pas appropriée.
    8. Définition de la méthode de chiffrement de clé si celle par défaut n'est pas appropriée.
    9. Définition de la référence de jeton si celle par défaut n'est pas appropriée.
    10. Ajout de WSSEncryption à WSSConsumingContext.
    11. Appelle WSSGenerationContext.process() avec le contexte SOAPMessageContext.

Résultats

En cas d'erreur lors du chiffrement, une exception WSSException est lancée. Si l'opération aboutit, l'API appelle la méthode WSSGenerationContext.process(), l'en-tête WS-Security est généré et le message SOAP est sécurisé avec la sécurité des services Web.

Exemple

L'exemple suivant fournit un code utilisant des méthodes définies dans l'API WSSEncryption :

// Obtenir le contexte de message
   Object msgcontext = getMessageContext();

// Générer l'instance WSSFactory (étape : a)
WSSFactory factory = WSSFactory.getInstance();		

// Générer l'instance WSSGenerationContext (étape : b)
WSSGenerationContext gencont = factory.newWSSGenerationContext();

// Générer le gestionnaire d'appel
X509GenerateCallbackHandler callbackHandler = new 
         X509GenerateCallbackHandler(
			  "",
			  "enc-sender.jceks",
			  "jceks", 
			  "storepass".toCharArray(), 
			  "bob", 
			  null, 
			  "CN=Bob, O=IBM, C=US", 
			  null);

// Générer le jeton de sécurité utilisé pour le chiffrement (étape : c)
SecurityToken token = factory.newSecurityToken(X509Token.class , callbackHandler);

// Générer l'instance WSSEncryption (étape : d)
WSSEncryption enc = factory.newWSSEncryption(token);

// Définir la portion à chiffrer (étape : e)
// PAR DEFAUT : WSSEncryption.BODY_CONTENT and WSSEncryption.SIGNATURE

// Définir la portion indiquée par le mot clé (étape : e)
   enc.addEncryptPart(WSSEncryption.BODY_CONTENT);

// Définir la portion dans l'en-tête SOAP indiquée par QName (étape : e)
   enc.addEncryptHeader(new QName("http://www.w3.org/2005/08/addressing",
                                  "MessageID"));

// Définir la portion indiquée par WSSSignature (étape : e)
   SecurityToken sigToken = getSecurityToken();
      WSSSignature sig = factory.newWSSSignature(sigToken);
   enc.addEncryptPart(sig);

// Définir la portion indiquée par SecurityToken (étape : e)
   UNTGenerateCallbackHandler untCallbackHandler = 
	         new UNTGenerateCallbackHandler("Chris", "sirhC");		
      SecurityToken unt = factory.newSecurityToken(UsernameToken.class, 
                                                   untCallbackHandler);
   enc.addEncryptPart(unt, false);

// Définir la portion indiquée par l'expression XPath (étape : e)
   StringBuffer sb = new StringBuffer();
      sb.append("/*[namespace-uri()='http://schemas.xmlsoap.org/soap/envelope/' 
         and local-name()='Envelope']");
      sb.append("/*[namespace-uri()='http://schemas.xmlsoap.org/soap/envelope/' 
         and local-name()='Body']");
      sb.append("/*[namespace-uri()='http://xmlsoap.org/Ping' 
         and local-name()='Ping']");
      sb.append("/*[namespace-uri()='http://xmlsoap.org/Ping' 
         and local-name()='Text']");
   enc.addEncryptPartByXPath(sb.toString());

// Déterminer si la clé est chiffrée (étape : f)
// PAR DEFAUT : true
   enc.encryptKey(true);

// Définir la méthode de chiffrement de données (étape : g)
// DEFAULT: WSSEncryption.AES128
   enc.setEncryptionMethod(WSSEncryption.TRIPLE_DES);

// Définir la méthode de chiffrement de clé (étape : h)
// DEFAULT: WSSEncryption.KW_RSA_OAEP
   enc.setEncryptionMethod(WSSEncryption.KW_RSA15);

// Définir la référence de jeton (étape : i)
// PAR DEFAUT : SecurityToken.REF_KEYID 
	 enc.setTokenReference(SecurityToken.REF_STR);

// Ajouter WSSEncryption à WSSGenerationContext (étape : j)
  gencont.add(enc);

// Traiter l'en-tête WS-Security (étape : k)
gencont.process(msgcontext);
Remarque : X509GenerationCallbackHandler n'a pas besoin du mot de passe de clé car la clé publique est utilisée pour le chiffrement. Vous n'avez pas besoin de mot de passe pour obtenir la clé publique du fichier de clés Java™.

Que faire ensuite

Si vous n'avez pas déjà défini les méthodes de chiffrement, utilisez l'API WSS ou configurez les ensembles de règles à l'aide de la console d'administration pour choisir les méthodes d'algorithme de chiffrement de données et de clé.


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_confwssencryption
Nom du fichier : twbs_confwssencryption.html