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.
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 :
|
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.
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 :
|
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 :
|
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 :
|
Procédure
Résultats
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.