PowerBuilder

Verify an XML Signature with Multiple References

See more XML Digital Signatures Examples

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

integer li_rc
integer li_Success
oleobject loo_Http
oleobject loo_SbXml
oleobject loo_Verifier
integer li_VerifyReferenceDigests
integer li_Verified
integer li_SignedInfoVerified
integer li_NumRefs
integer i
integer li_RefDigestVerified

li_Success = 0

// 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.
loo_Http = create oleobject
li_rc = loo_Http.ConnectToNewObject("Chilkat.Http")
if li_rc < 0 then
    destroy loo_Http
    MessageBox("Error","Connecting to COM object failed")
    return
end if
loo_SbXml = create oleobject
li_rc = loo_SbXml.ConnectToNewObject("Chilkat.StringBuilder")

li_Success = loo_Http.QuickGetSb("https://www.chilkatsoft.com/exampleData/envelopedMultipleRefs.xml",loo_SbXml)
if li_Success <> 1 then
    Write-Debug loo_Http.LastErrorText
    destroy loo_Http
    destroy loo_SbXml
    return
end if

// Load the XML containing the signature to be verified.
loo_Verifier = create oleobject
li_rc = loo_Verifier.ConnectToNewObject("Chilkat.XmlDSig")

li_Success = loo_Verifier.LoadSignatureSb(loo_SbXml)
if li_Success <> 1 then
    Write-Debug loo_Verifier.LastErrorText
    destroy loo_Http
    destroy loo_SbXml
    destroy loo_Verifier
    return
end if

li_VerifyReferenceDigests = 1

// The quick way to validate all references and the signature over the SignedInfo
// is to call VerifySignature with verifyReferenceDigests equal to 1.
li_Verified = loo_Verifier.VerifySignature(li_VerifyReferenceDigests)
Write-Debug "Signature and all reference digests verified = " + string(li_Verified)

// Let's pretend the call to VerifySignature returned 0.  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 0 to VerifySignature.
// This allows us to skip the hashing and checking each Reference.  
li_VerifyReferenceDigests = 0
li_SignedInfoVerified = loo_Verifier.VerifySignature(li_VerifyReferenceDigests)
Write-Debug "Neglecting the reference hashes, the SignedInfo validation result = " + string(li_SignedInfoVerified)

// We can also verify each reference digest separately
li_NumRefs = loo_Verifier.NumReferences
i = 0
do while i < li_NumRefs
    li_RefDigestVerified = loo_Verifier.VerifyReferenceDigest(i)
    Write-Debug "Reference " + string(i) + " digest verified = " + string(li_RefDigestVerified)
    i = i + 1
loop

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


destroy loo_Http
destroy loo_SbXml
destroy loo_Verifier