Vérification de la signature à l'aide de l'API WSSVerification

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 vérifier les informations de signature pour la liaison de destinataire concernant les demandes côté client, utilisez l'API WSSVerification. Vous devez aussi indiquer les méthodes d'algorithme et les portions signées du message SOAP à vérifier. L'API WSSVerification se trouve dans le package com.ibm.websphere.wssecurity.wssapi.verification.

Avant de commencer

Utilisez les API WSS ou configurez des ensembles de règles à l'aide de la console d'administration pour vérifier les informations de signature. Pour sécuriser les messages SOAP, vous devez procéder comme suit :

  • Configurez les informations de signature.
  • Choisissez les méthodes d'algorithme pour la signature et sa vérification.
  • Vérifiez les informations de signature.

Pourquoi et quand exécuter cette tâche

WebSphere Application Server utilise les informations de signature du générateur par défaut pour signer les portions de message, et la signature numérique XML avec les algorithmes existants tels que RSA-SHA1 et HMAC-SHA1.

La signature XML définit un grand nombre de méthodes de description des informations clé et active la définition d'une nouvelle méthode. La canonisation XML (C14N) est souvent nécessaire lorsque vous utilisez la signature XML. Les informations peuvent être représentées de différentes manières dans les documents XML sérialisés. Le processus C14N sert à canoniser les informations XML. Sélectionnez un algorithme C14N approprié, sachant que les informations canonisées dépendent de cet algorithme.

Le tableau suivant montre les informations de liaison obligatoires et facultatives lorsque la contrainte de sécurité de la signature numérique (intégrité) est définie.

Tableau 1. Portions dont la signature est à vérifier. Il est recommandé de faire appel à la vérification de la signature de portions de messages pour les sécuriser.
Portions à vérifier Description
keywords
Ajoute, à l'aide de mots clés, des portions dont la signature doit être vérifiée. Il est possible de définir diverses portions de message à protéger pour la demande côté générateur. Employez les mots clés suivants pour les portions dont la signature est à vérifier :
  • ADDRESSING_HEADERS
  • BODY
  • TIMESTAMP
Les en-têtes WS-Addressing ne sont pas chiffrés mais peuvent être signés.
xpath Ajoute des portions à vérifier à l'aide d'une expression XPath.
part Ajoute l'objet WSSVerifyPart comme portion à vérifier.
header Ajoute l'en-tête, indiqué par QName, comme portion à protéger.

Certains comportements par défaut s'appliquent aux informations de vérification de la signature. La façon la plus simple d'utiliser l'API WSSVerification est d'appliquer les comportements par défaut.

Les valeurs par défaut sont définies par l'API WSS pour la méthode de synthèse (digest), la méthode de transformation, le jeton de sécurité et les portions à vérifier.

Tableau 2. Comportements par défaut de la vérification de la signature. Certaines caractéristiques des portions dont la signature doit être vérifiée sont configurées par défaut.
Choix relatifs à la vérification de la signature Comportement par défaut
Méthode de signature à utiliser (algorithm) Définit la méthode d'algorithme de signature. Le chiffrement des données, la signature et la canonisation peuvent être indiqués. La méthode de signature par défaut est RSA SHA1. WebSphere Application Server prend en charge les méthodes de signature préconfigurées suivantes :
  • WSSVerification.RSA_SHA1 : http://www.w3.org/2000/09/xmldsig#rsa-sha1
  • WSSVerification.HMAC_SHA1 : http://www.w3.org/2000/09/xmldsig#hmac-sha1
La méthode de signature numérique DSA-SHA1 (http://www.w3.org/2000/09/xmldsig#dsa-sha1) n'est pas prise en charge.
Méthode de canonisation à utiliser (algorithm) Définit la méthode d'algorithme de canonisation. Le chiffrement des données, la signature et la canonisation peuvent être indiqués. La méthode de signature par défaut est EXC_C14N. WebSphere Application Server prend en charge les méthodes de canonisation préconfigurées suivantes :
  • WSSVerification.EXC_C14N : http://www.w3.org/2001/10/xml-exc-c14n#
  • WSSVerification.C14N : http://www.w3.org/2001/10/xml-c14n#
Indique si la confirmation de signature est requise. Si l'API WSSSignature indique que la confirmation de signature est obligatoire, l'API WSSVerification vérifie la valeur de confirmation de signature dans le message de réponse auquel elle est associée. La confirmation de signature est définie dans la spécification OASIS Web Services Security version 1.1.

La confirmation de signature par défaut est false.

Jeton de sécurité à spécifier (securityToken)

Ajoute l'objet securityToken comme portion signée. WebSphere Application Server configure les informations de jeton à utiliser pour la vérification.

WebSphere Application Server prend en charge les jetons préconfigurés suivants pour la signature :

  • Jeton X.509
  • Jeton de clé dérivée
Les informations obligatoires pour des jetons comprennent la classe, les informations du gestionnaire d'appel et le nom du module de connexion JAAS.

Procédure

  1. Pour vérifier la signature dans un message SOAP à l'aide de l'API WSSVerification, assurez-vous d'abord que le serveur d'application est installé.
  2. Utilisez l'API WSSVerification pour définir les portions du message à vérifier et pour indiquer les algorithmes utilisés dans les messages SOAP. L'API WSS pour la vérification de la signature suit la procédure ci-après :
    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.
    3. 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.
    4. Elle crée WSSVerification à partir de l'instance WSSFactory.
    5. Elle ajoute la portion à vérifier. Si la méthode de synthèse (digest) ou de transformation a changé, créez WSSVerifyPart et définissez-la dans WSSVerification.
    6. Elle définit les candidats de la méthode de canonisation si celle par défaut n'est pas appropriée.
    7. Elle définit les candidats pour la méthode de signature si celle par défaut n'est pas appropriée.
    8. Elle définit le jeton de sécurité candidat si celui par défaut n'est pas approprié.
    9. Elle appelle requireSignatureConfirmation(), si la confirmation de signature est appliquée.
    10. Ajout de WSSVerification à WSSConsumingContext.
    11. Elle appelle WSSConsumingContext.process() avec le contexte du message SOAP.

Résultats

Vous avez terminé la procédure de vérification de la signature pour les liaisons de destinataire. S'il existe une condition d'erreur, une WSSException est fournie. Si l'opération aboutit, la méthode WSSConsumingContext.process() est appelée et la sécurité des services Web est appliquée au message SOAP.

Exemple

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

// 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 le magasin de certificats
	  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
	  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 portion à vérifier (étape : e)
// PAR DEFAUT : WSSVerification.BODY, WSSSignature.ADDRESSING_HEADERS 
// et WSSSignature.TIMESTAMP.

// Définir la portion dans l'en-tête SOAP que QName doit indiquer (étape : e)
	    ver.addRequiredVerifyHeader(new QName("http://www.w3.org/2005/08/addressing", "MessageID"));

// Définir la portion que le mot clé doit indiquer (étape : e)
	    ver.addRequiredVerifyPart(WSSVerification.BODY);

// Définir la partie qui doit être spécifiée par WSSVerifyPart (étape : e)
	 WSSVerifyPart verPart = factory.newWSSVerifyPart();
	    verPart.setRequiredVerifyPart(WSSVerification.BODY);
	    verPart.addAllowedDigestMethod(WSSVerifyPart.SHA256);
	    ver.addRequiredVerifyPart(verPart);

// 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']");		
	    ver.addRequiredVerifyPartByXPath(sb.toString());


// Définir un ou plusieurs candidats de méthode de canonisation pour la vérification (étape : f)
// DEFAULT : WSSVerification.EXC_C14N
	   ver.addAllowedCanonicalizationMethod(WSSVerification.C14N);
	   ver.addAllowedCanonicalizationMethod(WSSVerification.EXC_C14N);

// Définir un ou plusieurs candidats de méthode de signature pour la vérification (étape : g)
// DEFAULT : WSSVerification.RSA_SHA1
	   ver.addAllowedSignatureMethod(WSSVerification.HMAC_SHA1);

// Définir le jeton de sécurité candidat à utiliser pour vérification (étape : h)
	 X509ConsumeCallbackHandler callbackHandler2 = getCallbackHandler2();
	   ver.addToken(X509Token.class, callbackHandler2);


// Définir l'option pour demander la confirmation de signature (étape : i)
	  ver.requireSignatureConfirmation();

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

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

Que faire ensuite

Une fois la signature vérifiée et les méthodes d'algorithme définies pour le message SOAP, vous pouvez définir la méthode de synthèse (digest) ou la méthode de transformation. Pour ce faire, utilisez l'API WSSVerifyPart ou configurez des ensembles de règles à l'aide de la console d'administration.


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_confsignaturecon
Nom du fichier : twbs_confsignaturecon.html