(Delphi DLL) Verify an XML Signature with Multiple References

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

Chilkat for Delphi Downloads Chilkat non-ActiveX DLL for Delphi Chilkat ActiveX DLL for Delphi * The examples here use the non-ActiveX DLL.

uses
    Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
    Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Http, StringBuilder, XmlDSig;

...

procedure TForm1.Button1Click(Sender: TObject);
var
http: HCkHttp;
sbXml: HCkStringBuilder;
success: Boolean;
verifier: HCkXmlDSig;
verifyReferenceDigests: Boolean;
verified: Boolean;
signedInfoVerified: Boolean;
numRefs: Integer;
i: Integer;
refDigestVerified: Boolean;

begin
// 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.
http := CkHttp_Create();
sbXml := CkStringBuilder_Create();
success := CkHttp_QuickGetSb(http,'https://www.chilkatsoft.com/exampleData/envelopedMultipleRefs.xml',sbXml);
if (success <> True) then
  begin
    Memo1.Lines.Add(CkHttp__lastErrorText(http));
    Exit;
  end;

// Load the XML containing the signature to be verified.
verifier := CkXmlDSig_Create();
success := CkXmlDSig_LoadSignatureSb(verifier,sbXml);
if (success <> True) then
  begin
    Memo1.Lines.Add(CkXmlDSig__lastErrorText(verifier));
    Exit;
  end;

verifyReferenceDigests := True;

// The quick way to validate all references and the signature over the SignedInfo
// is to call VerifySignature with verifyReferenceDigests equal to True.
verified := CkXmlDSig_VerifySignature(verifier,verifyReferenceDigests);
Memo1.Lines.Add('Signature and all reference digests verified = ' + IntToStr(Ord(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;
signedInfoVerified := CkXmlDSig_VerifySignature(verifier,verifyReferenceDigests);
Memo1.Lines.Add('Neglecting the reference hashes, the SignedInfo validation result = ' + IntToStr(Ord(signedInfoVerified)));

// We can also verify each reference digest separately
numRefs := CkXmlDSig_getNumReferences(verifier);
i := 0;
while i < numRefs do
  begin
    refDigestVerified := CkXmlDSig_VerifyReferenceDigest(verifier,i);
    Memo1.Lines.Add('Reference ' + IntToStr(i) + ' digest verified = ' + IntToStr(Ord(refDigestVerified)));
    i := i + 1;
  end;

// 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

CkHttp_Dispose(http);
CkStringBuilder_Dispose(sbXml);
CkXmlDSig_Dispose(verifier);

end;