Canonicalize and sign xml

[Igor Delac]

Should those two xml docs. have same signature?

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<Items Id="signXmlId">
    <Item2>second item</Item2>
    <Item1>first item</Item1>
</Items> 

and

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<Items Id="signXmlId">
    <Item1>first item</Item1>
    <Item2>second item</Item2>
</Items>

I noticed that if I sign them, digest and signature values are different in both cases. Any idea how to transform it to have same signature?
Here's code I use:

public static void signDocument() {
			
        String providerName = System.getProperty("jsr105Provider", "org.jcp.xml.dsig.internal.dom.XMLDSigRI");

        try {
        	
        	@SuppressWarnings("rawtypes")
        	ArrayList transformList = new ArrayList();

        	XMLSignatureFactory factory = 
        			XMLSignatureFactory.getInstance("DOM", (Provider) Class.forName(providerName).newInstance());

        	DigestMethod digestMethod = factory.newDigestMethod(DigestMethod.SHA1, null);
        	Transform envTransform = factory.newTransform(Transform.ENVELOPED, (TransformParameterSpec) null);
        	Transform exc14nTransform = factory.newTransform("http://www.w3.org/2001/10/xml-exc-c14n#", (TransformParameterSpec) null);

        	transformList.add(envTransform);
        	transformList.add(exc14nTransform);            

        	Reference reference = factory.newReference("#signXmlId", digestMethod, transformList, null, null);
        	CanonicalizationMethod canonicalizationMethod = 
        			factory.newCanonicalizationMethod(CanonicalizationMethod.EXCLUSIVE_WITH_COMMENTS, (C14NMethodParameterSpec) null);

        	SignatureMethod signatureMethod = factory.newSignatureMethod(SignatureMethod.RSA_SHA1, null);
        	SignedInfo signedInfo = factory.newSignedInfo(canonicalizationMethod, signatureMethod, Collections.singletonList(reference));

        	PrivateKeyEntry keyEntry = null;
        	KeyPair keyPair = null;
        	Key key = null;
        	PublicKey publicKey = null;
        	PrivateKey privateKey = null;
        	X509Certificate cert = null;

        	KeyInfoFactory keyInfoFactory = factory.getKeyInfoFactory();

        	keyEntry = (PrivateKeyEntry) keyStore.getEntry(keyStore.aliases().nextElement(),
        			new KeyStore.PasswordProtection(keyPassword.toCharArray()));
        	cert = (X509Certificate) keyEntry.getCertificate();
        	publicKey = cert.getPublicKey();
        	privateKey = keyEntry.getPrivateKey();            	 

        	@SuppressWarnings("rawtypes")
        	List x509 = new ArrayList();

        	X509IssuerSerial issuer = keyInfoFactory.newX509IssuerSerial
        			(cert.getIssuerX500Principal().getName(), cert.getSerialNumber());

        	x509.add(cert);
        	x509.add(issuer);
        	X509Data x509Data = keyInfoFactory.newX509Data(x509);


        	@SuppressWarnings("rawtypes")
        	List items = new ArrayList();
        	items.add(x509Data);         

        	KeyInfo keyInfo = keyInfoFactory.newKeyInfo(items);            

        	DOMSignContext dsc = new DOMSignContext(privateKey, xmlDocument.getDocumentElement());

        	XMLSignature signature = factory.newXMLSignature(signedInfo, keyInfo);

        	signature.sign(dsc);


        } catch (Exception e) {
        	// TODO Auto-generated catch block
        	e.printStackTrace();
        } 

	}

[g tsuji]

I noticed that if I sign them, digest and signature values are different in both cases. Any idea how to transform it to have same signature?

Maybe one should ask the question in the other direction. Why would you think that would give the same signature? They are "different" in the sense of being an octet stream even after the canonicalization should be the first intuition and that is the correct conclusion, though.

Any idea how to transform it to have same signature?

You sure can transform them to some common output. But that is heavily dependent of detail setting of the formatter and the error prong white-space treatment... For that reason, maybe you should both apply a transformation so that they share the common defaut behaviour in the formatting and white-space treatment.

For instance, the first xml you reverse the positions under items with an template like this.

<xsl:template match="Items">
    <xsl:copy>
        <xsl:for-each select="@*">
            <xsl:copy />
        </xsl:for-each>
        <xsl:for-each select="*">
            <xsl:sort select="position()" order="descending" data-type="number" />
            <xsl:copy-of select="." />
        </xsl:for-each>
    </xsl:copy>
</xsl:template>

whereas, you apply a similar template on the second.

<xsl:template match="Items">
    <xsl:copy>
        <xsl:for-each select="@*">
            <xsl:copy />
        </xsl:for-each>
        <xsl:for-each select="*">
            <xsl:sort select="position()" order="ascending" data-type="number" />
            <xsl:copy-of select="." />
        </xsl:for-each>
    </xsl:copy>
</xsl:template>

That is the basic idea.

Signature is a technology rigorous to the detail. You need to ask why such kind of mixed up turns up at all from the source.

[Igor Delac]

Thank you for explanation. It make sense. Also your suggestion to arrange items in xml is also very useful.