Vérification des portions signées à l'aide de l'API WSSVerifyPart

Pour sécuriser les messages SOAP côté destinataire, utilisez les API Web Services Security (API WSS) afin de paramétrer la vérification des portions de message pour la liaison du destinataire de la réponse (côté client). Vous pouvez spécifier les algorithmes utilisés et les portions des messages SOAP à vérifier. Utilisez l'API WSSVerifyPart pour changer de méthode de synthèse (digest) ou de transformation. L'API WSSVerifyPart se trouve dans le package com.ibm.websphere.wssecurity.wssapi.verification.

Avant de commencer

Pour sécuriser les messages SOAP à l'aide des paramètres de vérification de la signature, exécutez l'une des tâches suivantes :

  • Paramétrez la vérification de la signature à l'aide de l'API WSSVerification.
  • Configurez les portions à vérifier à l'aide de l'API WSSVerifyPart, si besoin est.
L'API WSSVerifyPart sert à définir les méthodes de transformation ou de synthèse (digest) utilisées pour la vérification. Utilisez-la ou configurez des ensembles de règles à l'aide de la console d'administration.

Pourquoi et quand exécuter cette tâche

WebSphere Application Server utilise les paramètres de vérification de la signature définis pour le destinataire par défaut pour vérifier les portions signées des messages. L'API WSSVerifyPart est uniquement prise en charge sur le destinataire de la réponse (le demandeur).

Le tableau suivant contient les portions dont la vérification peut être requise lorsque la contrainte de sécurité de signature numérique (intégrité) est définie :

Tableau 1. Définition des portions à vérifier. Sécurisez les messages en mettant en oeuvre la vérification de la signature de certaines portions.
Définition des portions à vérifier Description
keyword Définit les portions à vérifier avec les mots clés suivants :
  • BODY
  • ADDRESSING_HEADERS
  • TIMESTAMP

Les en-têtes WS-Addressing ne sont pas déchiffrés, mais ils peuvent être signés et vérifiés.

xpath Définit les portions à vérifier à l'aide d'une expression XPath.
header Définit l'en-tête, indiqué par QName, comme portion à vérifier.

Certains comportements par défaut s'appliquent à la vérification de la signature. La façon la plus simple d'utiliser l'API WSSVerification est d'appliquer les comportements par défaut (voir l'exemple de code). L'API WSS définit des valeurs par défaut pour les algorithmes de signature et de canonisation et les portions à vérifier.

Tableau 2. Comportement par défaut vis à vis des portions à vérifier. Il existe une configuration par défaut pour certaines caractéristiques des portions à vérifier.
Choix relatifs aux portions à vérifier Comportement par défaut
Mots clés à indiquer

Les différentes portions des messages SOAP à signer et utiliser pour la protection des messages. WebSphere Application Server prend en charge les mots clés suivants :

  • WSSVerification.BODY
  • WSSVerification.ADDRESSING_HEADERS
  • WSSVerification.TIMESTAMP
Méthode de transformation à utiliser (algorithme) Ajoute la méthode de transformation. L'algorithme de transformation est précisé dans l'élément <Transform> et indique celui utilisé pour la signature. La méthode de transformation par défaut est TRANSFORM_EXC_C14N.

WebSphere Application Server prend en charge les algorithmes de transformation préconfigurés suivants :

  • WSSVerifyPart.TRANSFORM_EXC_C14N (la valeur par défaut) : http://www.w3.org/2001/10/xml-exc-c14n#
  • WSSVerifyPart.TRANSFORM_XPATH2_FILTER : http://www.w3.org/2002/06/xmldsig-filter2

    Utilisez cette méthode de transformation pour vérifier la conformité avec le profil de sécurité de base (BSP).

  • WSSVerifyPart.TRANSFORM_STRT10 : http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#STR-Transform
  • WSSVerifyPart.TRANSFORM_ENVELOPED_SIGNATURE : http://www.w3.org/2000/09/xmldsig#enveloped-signature
Méthode de synthèse (digest) à utiliser (algorithme) Définit la méthode d'algorithme de synthèse. L'algorithme de la méthode de synthèse (digest) indiqué dans l'élément <DigestMethod> est utilisé dans l'élément <SigningInfo>t. La méthode de synthèse par défaut est SHA1.
WebSphere Application Server prend en charge les algorithmes de méthode de synthèse (digest) suivants :
  • WSSVerifyPart.SHA1 : http://www.w3.org/2000/09/xmldsig#sha1
  • WSSVerifyPart.SHA256 : http://www.w3.org/2001/04/xmlenc#sha256
  • WSSVerifyPart.SHA512 : http://www.w3.org/2001/04/xmlenc#sha512

Procédure

  1. Pour vérifier les portions signées à l'aide de l'API WSSVerifyPart, assurez-vous d'abord que le serveur d'applications est installé.
  2. Utilisez l'API WSS (Web Services Security) pour vérifier les messages SOAP. Le processus de vérification de la signature mis en oeuvre par l'API WSS est le suivant :
    1. Utilise WSSFactory.getInstance() pour obtenir l'instance d'implémentation d'API WSS.
    2. Création de l'instance WSSConsumingContext à partir de l'instance WSSFactory. Elle garantit que l'instance WSSConsumingContext est appelée dans la classe d'implémentation du fournisseur JAX-WS. En raison de la nature du modèle de programmation JAX-WS, un fournisseur JAX-WS doit être implémenté et appelé l'instance WSSConsumingContext pour vérifier la signature du message SOAP.
    3. Création de CallbackHandler pour la vérification.
    4. Création de l'objet WSSVerification à partir de l'instance WSSFactory.
    5. Création de l'objet WSSVerifyPart à partir de l'instance WSSFactory.
    6. Définition de la portion à vérifier si celle par défaut n'est pas appropriée.
    7. Définition des candidats pour la méthode de synthèse (digest) si ceux par défaut ne sont pas appropriés.
    8. Définition des candidats pour la méthode de transformation si ceux par défaut ne sont pas appropriés.
    9. Ajout de WSSVerifyPart à WSSVerification.
    10. Ajout de WSSVerification à WSSConsumingContext.
    11. Appel de WSSConsumingContext.process() avec SOAPMessageContext.

Résultats

La procédure de vérification des portions signées, côté destinataire, est terminée. En cas d'erreur lors de la vérification des informations de signature, une exception WSSException est lancée. Si l'opération aboutit, la méthode WSSConsumingContext.process() est appelée et la sécurité des services Web est vérifiée pour les messages SOAP.

Exemple

L'exemple suivant fournit un exemple de code pour l'API WSSVerification, afin de vérifier les informations de signature dans un message SOAP :

// 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 WSSConsumingContext (étape : b)
   WSSConsumingContext concont = factory.newWSSConsumingContext();

// Générer la liste de certificats
   String certpath = 
   "c:/WebSphere/AppServer/etc/ws-security/samples/intca2.cer";
// Emplacement du fichier de certificat X509
   X509Certificate x509cert = null;
      try {
          InputStream is = new FileInputStream(certpath);
          CertificateFactory cf = CertificateFactory.getInstance("X.509");
          x509cert = (X509Certificate)cf.generateCertificate(is);
      } catch(FileNotFoundException e1){
            throw new WSSException(e1);
      } catch (CertificateException e2) {
            throw new WSSException(e2);
      }

      Set<Object> eeCerts = new HashSet<Object>();
      eeCerts.add(x509cert);  
// Créer certStore
      java.util.List<CertStore> certList = new 
          java.util.ArrayList<CertStore>();
      CollectionCertStoreParameters certparam = new 
          CollectionCertStoreParameters(eeCerts);
      CertStore cert = null;
      try {
	        cert = CertStore.getInstance("Collection", 
              certparam, "IBMCertPath");
      } catch (NoSuchProviderException e1) {
           throw new WSSException(e1);
      } catch (InvalidAlgorithmParameterException e2) {
           throw new WSSException(e2);
      } catch (NoSuchAlgorithmException e3) {
           throw new WSSException (e3);
      }
      if(certList != null ){
      certList.add(cert);
      }

// Générer le gestionnaire d'appel (étape : c)  
   X509ConsumeCallbackHandler callbackHandler = new 
       X509ConsumeCallbackHandler(
                                  "dsig-receiver.ks", 
                                  "jks",
                                  "server".toCharArray(), 
                                  certList, 
       java.security.Security.getProvider("IBMCertPath")
);

// Générer l'instance WSSVerification (étape : d)
   WSSVerification ver = factory.newWSSVerification(X509Token.class, 
       callbackHandler);

// Définir la partie qui doit être spécifiée par WSSVerifyPart (étape : e)
   WSSVerifyPart verPart = factory.newWSSVerifyPart();

// Définir la partie que le mot clé doit indiquer (étape : f)
   verPart.setRequiredVerifyPart(WSSVerification.BODY);

// Définir les candidats pour la méthode de synthèse (digest) pour vérification (étape : g)
// DEFAULT : WSSVerifyPart.SHA1
   verPart.addAllowedDigestMethod(WSSVerifyPart.SHA256);

// Définir les candidats pour la méthode de transformation pour vérification (étape : h)
// PAR DEFAUT : WSSVerifypart.TRANSFORM_EXC_C14N : String
   verPart.addAllowedTransform(WSSVerifyPart.TRANSFORM_STRT10);

// Définir WSSVerifyPart à WSSVerification (étape : i)
   ver.addRequiredVerifyPart(verPart);

// Ajouter WSSVerification à WSSConsumingContext (étape : j)
   concont.add(ver);

//Valider l'en-tête WS-Security (étape : k)
concont.process(msgcontext);

Que faire ensuite

Vous avez terminé la configuration de la partie signée à vérifier.

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_confsignaturepartcon
Nom du fichier : twbs_confsignaturepartcon.html