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.
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 :
Définition des portions à vérifier | Description |
---|---|
keyword | Définit les portions à vérifier avec les mots clés
suivants :
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.
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 :
|
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 :
|
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 :
|
Procédure
Résultats
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);