Vérification signature d'un document

Version imprimable

1 pièce(s) jointe(s)

Bonjour,

je suis actuellement en train de développer une méthode me permettant de vérifier la signature généré d'un document.
Pour cela, j'ai pas mal chercher sur le net et le même bout de code revient à chque fois :
Code:

1 2 3 4 5 XMLSignatureFactory xmlSignatureFactory = XMLSignatureFactory.getInstance("DOM", new XMLDSigRI()); DOMValidateContext domValidateContext = new DOMValidateContext(publicKey, signature); XMLSignature xmlSignature = xmlSignatureFactory.unmarshalXMLSignature(domValidateContext); boolean coreValidity = xmlSignature.validate(domValidateContext);
Pour vérifier ce bout de code, j'utilise un fichier que j'ai moi même signer. Et en retour j'ai toujours la valeur false qui m'est retourné. Je ne sais donc pas si mon erreur intervient lors de la signature ou de la vérification de la signature.
J'ai joins mon fichier signé.

Quelqu'un pourrait-il m'aider et me dire si mon erreur intervient lors de la signature de mon fichier ou lors de la vérification de la signature?

merci d'avance pour votre aide

23/09/2009, 21h23
ajmaster

Après test le certificat est correctement validé, mais la signature du fichier XML est invalide, c'est donc à la signature qu'il y a un problème

merci pour ta réponse.
Peux tu m'aider un peu plus si cela est possible et me dire quel est le problème au niveau de ma signature....

voici le code que j'utilise pour signer mon document :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
// création d'une factory pour créer des signatures basées sur le méchanisme DOM et avec le système d'algo DSIG
XMLSignatureFactory signatureFactory = XMLSignatureFactory.getInstance(
"DOM",(Provider) new XMLDSigRI());
 
// définition de la méthode d'assimilation (hashage) basée sur l'algo en paramètre et sans paramètre spécifique
DigestMethod digestMethod = signatureFactory.newDigestMethod("http://www.w3.org/2000/09/xmldsig#sha1" null);
 
// paramètre défini car sinon il y a ambiguité sur le typage
C14NMethodParameterSpec methodParameterSpec = null;
 
// définition de la méthode qui met tout à plat avec l'algo en paramètre et sans paramètre spécifique
CanonicalizationMethod canonicalizationMethod = signatureFactory.newCanonicalizationMethod("http://www.w3.org/2001/10/xml-exc-c14n#", methodParameterSpec);
 
// définition de la méthode de signature avec l'algo en paramètre et sans paramètres spécifiques
SignatureMethod signatureMethod = signatureFactory.newSignatureMethod("http://www.w3.org/2000/09/xmldsig#rsa-sha1", null);
 
// paramètre défini car sinon il y a ambiguité sur le typage
TransformParameterSpec transformSpec = null;
 
/* 
* définition des méthodes de transformation avec l'algo en paramètre et sans paramètres spécifiques
*  reprise de l'algo de canonisation pour le mettre dans la signature
*  spécification de l'emplacement de la signature (signature enveloppée dans le XML, mais exclue du hashage)
*  ces 2 algo seront dans la signature : c'est un copier coller
*/
Transform envTransform = signatureFactory.newTransform("http://www.w3.org/2001/10/xml-exc-c14n#", transformSpec);
Transform exc14nTransform = signatureFactory.newTransform("http://www.w3.org/2000/09/xmldsig#enveloped-signature", transformSpec);
 
// liste des transformations à ajouter à la signature
List < Transform > transformList = new ArrayList < Transform > ();
transformList.add(envTransform);
transformList.add(exc14nTransform);
 
// regroupement des différents algo pour affichage dans la signature du XML
Reference reference = signatureFactory.newReference("", digestMethod, transformList, null, null);
List < Reference > referenceList = new ArrayList < Reference > ();
referenceList.add(reference);
 
// regroupement des "vrais" algos et des algo pour affichage dans le XML
SignedInfo signedInfo = signatureFactory.newSignedInfo(canonicalizationMethod, signatureMethod, referenceList);
 
// lecture du XML et récupération du premier élement
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
 
Document document = documentBuilderFactory.newDocumentBuilder().parse(new InputSource(new StringReader(fluxASignerString)));
Element element = (Element) document.getFirstChild();
 
// récupération de la clé privée au format DER
Key key = signatureHelper.getPrivateKey(ConstantesMetierBackProdDocs.PATH_PRIVATE_KEY); 
 
// définition du contexte de signature avec la clé privée et l'élement à signer
DOMSignContext signContext = new DOMSignContext(key, element);
 
// création de la factory basé sur la méthode DOM avec l'algo DSIG
KeyInfoFactory keyFactory = KeyInfoFactory.getInstance(
"DOM", (Provider) new XMLDSigRI());
 
// futur élement du keyinfo
Document signatureDocument = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
List < DOMStructure > dOMStructureList = new ArrayList<DOMStructure>();
dOMStructureList.add(this.getX509DataDOMStructure(signatureDocument, cheminCertificatString));
KeyInfo keyInfo = keyFactory.newKeyInfo(dOMStructureList);
 
// création de la signature
XMLSignature signature = signatureFactory.newXMLSignature(signedInfo, keyInfo);
 
// signature du contexte
signature.sign(signContext);

J'ai pas testé ton code, mais à la lecture j'ai rien trouvé qui saute aux yeux.

Il faut peut être vérifier les URI voir les remplacer par les constantes java correspondante
ex: Transform.ENVELOPED au lieu de "http://www.w3.org/2000/09/xmldsig#enveloped-signature"

Voici le code que j'utilise et qui est issue de la documentation de sun

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
// Create a DOM XMLSignatureFactory that will be used to
// generate the enveloped signature.
XMLSignatureFactory fac = XMLSignatureFactory.getInstance("DOM"); //$NON-NLS-1$
 
// Create a Reference to the enveloped document (in this case,
// you are signing the whole document, so a URI of "" signifies
// that, and also specify the SHA1 digest algorithm and
// the ENVELOPED Transform.
Reference ref = fac.newReference("", fac.newDigestMethod(DigestMethod.SHA256, null), //$NON-NLS-1$
    Collections.singletonList(fac.newTransform(Transform.ENVELOPED, (TransformParameterSpec) null)), null, null);
 
// Create the SignedInfo.
SignedInfo si = fac.newSignedInfo(
    fac.newCanonicalizationMethod(CanonicalizationMethod.INCLUSIVE, (C14NMethodParameterSpec) null),
    fac.newSignatureMethod(SignatureMethod.RSA_SHA1, null),
    Collections.singletonList(ref));
 
// Load the KeyStore and get the signing key and certificate.
KeyStore ks = KeyStore.getInstance("JKS"); //$NON-NLS-1$
ks.load(new FileInputStream(keyStorePath), keyStorePassword.toCharArray());
KeyStore.PrivateKeyEntry keyEntry = (KeyStore.PrivateKeyEntry) ks.getEntry(signKeysAlias,
    new KeyStore.PasswordProtection(signKeysAliasPassword.toCharArray()));
X509Certificate cert = (X509Certificate) keyEntry.getCertificate();
 
// Create the KeyInfo containing the X509Data.
KeyInfoFactory kif = fac.getKeyInfoFactory();
List<Object> x509Content = new ArrayList<Object>();
x509Content.add(cert.getSubjectX500Principal().getName());
x509Content.add(cert);
X509Data xd = kif.newX509Data(x509Content);
KeyInfo ki = kif.newKeyInfo(Collections.singletonList(xd));
 
// Instantiate the document to be signed.
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setNamespaceAware(true);
Document doc = dbf.newDocumentBuilder().parse(new FileInputStream(tmpXML));
 
// Create a DOMSignContext and specify the RSA PrivateKey and
// location of the resulting XMLSignature's parent element.
DOMSignContext dsc = new DOMSignContext(keyEntry.getPrivateKey(), doc.getDocumentElement());
 
// Create the XMLSignature, but don't sign it yet.
XMLSignature signature = fac.newXMLSignature(si, ki);
 
// Marshal, generate, and sign the enveloped signature.
signature.sign(dsc);

24/09/2009, 16h00
dormouse

Merci
Je vais essayé de me baser sur ton code pour signer mon fichier.

Sinon aurais tu un fichier signé contenant un certificat afin que je sois également sur que ma méthode de vérification fonctionne correctement.

En fait il me faudrait un moyen me permettant de tester ma signature et ma vérification de signature. Pour le moment je pense à un jeu de test ( fichier de départ, fichier signé contenant le certificat) mais si quelqu'un connait un autre moyen je suis partant
25/09/2009, 17h56
ajmaster

1 pièce(s) jointe(s)

Ci joint ton fichier XML dans lequel j'ai supprimé et regénérer la signature avec un certificat de test.

Le fichier devrait passer la vérification à condition que ton KeySelector accepte les certificats "self-signed"
28/09/2009, 10h30
dormouse

merci ajmaster
grâce à ton aide j'ai réussi à voir d'où venaient mes problèmes.
En fait ma vérification fonctionnait correctement. Le problème venait de la signature de mon fichier.