(JavaScript) Create/Verify XML Signature with External Text Reference

See more XML Digital Signatures Examples

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.

// This example inserts an XML signature into the following XML:

// <?xml version="1.0" encoding="UTF-8" standalone="no"?>
// <abc>
//   <xyz>
// 	<name>helloWorld.txt</name>
// 	<url>https://www.chilkatsoft.com/helloWorld.txt</url>
//   </xyz>
// </abc>

// Build the above XML to be signed.
var xml = new CkXml();
xml.Tag = "abc";
xml.UpdateChildContent("xyz|name","helloWorld.txt");
xml.UpdateChildContent("xyz|url","https://www.chilkatsoft.com/helloWorld.txt");

var cert = new CkCert();

success = cert.LoadPfxFile("qa_data/pfx/test_secret.pfx","secret");
if (success == false) {
    console.log(cert.LastErrorText);
    return;
}

var gen = new CkXmlDSigGen();

// Indicate the location within the XML the Signature will be inserted.
gen.SigLocation = "abc|xyz";

// Get the content of the text data to be referenced.
var http = new CkHttp();
var sbExternalTxt = new CkStringBuilder();
success = http.QuickGetSb("https://www.chilkatsoft.com/helloWorld.txt",sbExternalTxt);
if (success == false) {
    console.log(http.LastErrorText);
    return;
}

success = gen.AddExternalTextRef("https://www.chilkatsoft.com/helloWorld.txt",sbExternalTxt,"utf-8",false,"sha256","");
if (success == false) {
    console.log(gen.LastErrorText);
    return;
}

// Provide the private key for signing via the certificate, and indicate that
// we want the base64 of the certificate embedded in the KeyInfo.
gen.KeyInfoType = "X509Data";
gen.X509Type = "Certificate";

var bUsePrivateKey = true;
success = gen.SetX509Cert(cert,bUsePrivateKey);
if (success !== true) {
    console.log(gen.LastErrorText);
    return;
}

// Indicate we want an indented signature for readability.
// This can be removed after debugging is finished..
gen.Behaviors = "IndentedSignature";

// Now create and insert the Signature
var sbXml = new CkStringBuilder();
xml.GetXmlSb(sbXml);
success = gen.CreateXmlDSigSb(sbXml);
if (success !== true) {
    console.log(gen.LastErrorText);
    return;
}

// Examine the XML with the digital signature inserted
console.log(sbXml.GetAsString());

// Here is the output:

// <?xml version="1.0" encoding="utf-8"?>
// <abc>
//     <xyz>
//         <name>helloWorld.txt</name>
//         <url>https://www.chilkatsoft.com/helloWorld.txt</url>
//     <ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
//   <ds:SignedInfo>
//     <ds:CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
//     <ds:SignatureMethod Algorithm="http://www.w3.org/2001/04/xmldsig-more#rsa-sha256"/>
//     <ds:Reference URI="https://www.chilkatsoft.com/helloWorld.txt">
//       <ds:DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"/>
//       <ds:DigestValue>f4OxZX/x/FO5LcGBSKHWXfwtSx+j1ncoSt3SABJtkGk=</ds:DigestValue>
//     </ds:Reference>
//   </ds:SignedInfo>
//   <ds:SignatureValue>syFSl...pZDiFQ==</ds:SignatureValue>
//   <ds:KeyInfo>
//     <ds:X509Data>
//       <ds:X509Certificate>MIIHAz...GwnUZWCaDE=</ds:X509Certificate>
//     </ds:X509Data>
//   </ds:KeyInfo>
// </ds:Signature></xyz>
// </abc>

// Let's verify the signature...
var verifier = new CkXmlDSig();
success = verifier.LoadSignatureSb(sbXml);
if (success !== true) {
    console.log(verifier.LastErrorText);
    return;
}

// Let's examine the external references, and fetch the data for each..
var sbExternalData = new CkStringBuilder();
var numRefs = verifier.NumReferences;
var i = 0;
while (i < numRefs) {
    var bExternal = verifier.IsReferenceExternal(i);
    if (bExternal == true) {
        var uri = verifier.ReferenceUri(i);

        // We're assuming the URI is an https:// or http:// URL...
        // Let's also assume we know that the referenced data is text and we want the utf-8 byte representation.
        sbExternalData.Clear();
        success = http.QuickGetSb(uri,sbExternalData);
        if (success == false) {
            console.log(http.LastErrorText);
            return;
        }

        success = verifier.SetRefDataSb(i,sbExternalData,"utf-8");
        if (success == false) {
            console.log(verifier.LastErrorText);
            return;
        }

    }

    i = i+1;
}

// Now that we have the external data available, we can verify the reference digest(s) and the signature.
var bVerified = verifier.VerifySignature(true);
if (bVerified !== true) {
    console.log(verifier.LastErrorText);
    return;
}

console.log("Signature verified!");