(JavaScript) Verify an XML Signature with Multiple References

Demonstrates how to verify an XML digital signature that contains multiple references.

Note

This example is intended for running within a Chilkat.Js embedded JavaScript engine. All Chilkat JavaScript examples require Chilkat v11.4.0 or greater.

var success = false;

// This example requires the Chilkat API to have been previously unlocked.
// See Global Unlock Sample for sample code.

// An example of an enveloping XML signature with mulitple references is available at
// https://www.chilkatsoft.com/exampleData/envelopedMultipleRefs.xml

// This example will show how to verify the signature and all references, and also how
// to verify each reference individually.  This is useful to distinguish which part
// of the XML signature validation failed.  It could be that one or more of the references
// failed because of a hash computation mismatch.  Or it could be that the signature over
// the SignedInfo failed.  

// First, let's grab the sample XML signature.
var http = new CkHttp();
var sbXml = new CkStringBuilder();
success = http.QuickGetSb("https://www.chilkatsoft.com/exampleData/envelopedMultipleRefs.xml",sbXml);
if (success !== true) {
    console.log(http.LastErrorText);
    return;
}

// Load the XML containing the signature to be verified.
var verifier = new CkXmlDSig();
success = verifier.LoadSignatureSb(sbXml);
if (success !== true) {
    console.log(verifier.LastErrorText);
    return;
}

var verifyReferenceDigests = true;

// The quick way to validate all references and the signature over the SignedInfo
// is to call VerifySignature with verifyReferenceDigests equal to true.
var verified = verifier.VerifySignature(verifyReferenceDigests);
console.log("Signature and all reference digests verified = " + verified);

// Let's pretend the call to VerifySignature returned false.  Something did not validate.
// Was it one or more of the References that did not hash to the correct value?
// Or was it the signature over the SignedInfo that failed?
// We can check just the signature over the SignedInfo by passing false to VerifySignature.
// This allows us to skip the hashing and checking each Reference.  
verifyReferenceDigests = false;
var signedInfoVerified = verifier.VerifySignature(verifyReferenceDigests);
console.log("Neglecting the reference hashes, the SignedInfo validation result = " + signedInfoVerified);

// We can also verify each reference digest separately
var numRefs = verifier.NumReferences;
var i = 0;
while (i < numRefs) {
    var refDigestVerified = verifier.VerifyReferenceDigest(i);
    console.log("Reference " + i + " digest verified = " + refDigestVerified);
    i = i+1;
}

// For this sample XML signature with 3 References, we get the following output:

// Signature and all reference digests verified = True
// Neglecting the reference hashes, the SignedInfo validation result = True
// Reference 0 digest verified = True
// Reference 1 digest verified = True
// Reference 2 digest verified = Tru