XmlDSigGen Zig Reference Documentation

XmlDSigGen

Current Version: 11.6.1

Chilkat.XmlDSigGen

Create XML Digital Signatures with precise control over references, transforms, keys, and placement.

Chilkat.XmlDSigGen creates XML Digital Signatures for same-document XML, external XML, text, binary, file, and Object-based references. It supports enveloped, enveloping, and detached-style signing workflows; X.509 certificate KeyInfo; custom KeyInfo XML; RSA, DSA, and ECDSA private keys; HMAC signatures; canonicalization options; reference transforms; signature insertion placement; timestamp authority settings; and compatibility options for systems with strict or unusual XML signature requirements.

Same-document signatures

Sign XML already present in the document, including enveloped signatures where the signature is inserted into the signed XML.

External references

Add references to external XML, text, binary data, files, or custom application-provided content.

Object and enveloping signatures

Build signatures that include signed data inside XML Object elements or produce enveloping signature structures.

Keys and KeyInfo

Sign with private keys or HMAC secrets and include certificate-based, public-key, or fully custom KeyInfo XML.

Canonicalization and transforms

Configure canonicalization, digest algorithms, signature algorithms, and reference transforms required by the receiving system.

Placement and compatibility

Control where the signature is inserted and enable compatibility behaviors for XML signature profiles with special formatting rules.

Common pattern: Configure the signature algorithm, canonicalization method, signing key or certificate, and KeyInfo style; add one or more references with the required transforms and digest methods; choose where the signature should be placed; then generate the signed XML. Use Chilkat.XmlDSigGen to create signatures and Chilkat.XmlDSig to inspect or verify them.

Object Creation

// Add the package once:
//     zig fetch --save https://chilkatdownload.com/11.6.1/chilkat-zig-11.6.1.tar.gz
// and in build.zig:
//     const chilkat = b.dependency("chilkat", .{ .target = target, .optimize = optimize });
//     exe.root_module.addImport("chilkat", chilkat.module("chilkat"));
const chilkat = @import("chilkat");

// Once per process, before any other Chilkat call:
try chilkat.unlockBundle("Anything for 30-day trial");

const xml_d_sig_gen = try chilkat.XmlDSigGen.init();
defer xml_d_sig_gen.deinit();
pub fn init() Allocator.Error!XmlDSigGen

Creates the underlying native Chilkat object. XmlDSigGen is a one-pointer struct passed by value; copying it copies the handle (two names for one object). Returns error.OutOfMemory if the library could not allocate the object. Use an object from one thread at a time; it may be handed from one thread to another.

pub fn deinit(self: XmlDSigGen) void

Releases the native object. Call it exactly once per object (usually with defer); the handle is invalid afterwards. Objects returned by methods are owned by the caller too and are released the same way.

pub fn fromHandle(h: *chilkat.c.CkXmlDSigGen.HCkXmlDSigGen) XmlDSigGen

Wraps a handle obtained from the C API (chilkat.c.CkXmlDSigGen), taking ownership of it. The struct's handle field goes the other way, for anything the Zig API does not cover.

Errors and memory

Methods that can fail return an error union: a method whose only outcome is success or failure returns Error!void; a method producing a string returns (Error || Allocator.Error)![:0]u8; a method producing an object returns Error!T. chilkat.Error is error{ChilkatFailed}; the reason for a failure is in getLastErrorText, and the object remains usable. Properties never fail, and methods that answer a question (hasMember, isUnlocked, ...) return a plain bool.

String arguments are [:0]const u8 (UTF-8; string literals can be passed as is). String results are copies allocated with the allocator argument and owned by the caller, so they stay valid across later calls on the same object.

const text = xml_d_sig_gen.someMethod(allocator, ...) catch |err| {
    const why = try xml_d_sig_gen.getLastErrorText(allocator);
    defer allocator.free(why);
    std.debug.print("{s}\n", .{why});
    return err;
};
defer allocator.free(text);

Properties

Behaviors
// read/write
pub fn getBehaviors(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setBehaviors(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.70

A comma-separated list of keywords to specify special behaviors to work around potential oddities or special requirements needed for providing signatures to particular systems. This is an open-ended property where new behaviors can be implemented depending on the needs encountered by Chilkat customers. The possible behaviors are listed below.

  • AttributeSortingBug (introduced in v9.5.0.79) Tells Chilkat to produce a signature that duplicates a common XML canonicalization attribute sorting bug found in some XML signature implementations (such as JPK VAT signed XML documents for Polish government, i.e. mf.gov.pl, csioz.gov.pl, crd.gov.pl, etc). See XML Signature Canonicalization Bug for details.
  • Base64CrEntity Produce multi-line base64 for XML elements such as SignatureValue and X509Certificate, with each line ending in a CR hex entity, except for the last line. For example:
    <ds:X509Certificate>MIIFNTCCBB2gAwIBAgIQHozVnBl1lTsusAh26u6WZTANBgkqhkiG9w0BAQsFADCBlzELMAkGA1UE&#xD;
    BhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgG&#xD;
    A1UEChMRQ09NT0RPIENBIExpbWl0ZWQxPTA7BgNVBAMTNENPTU9ETyBSU0EgQ2xpZW50IEF1dGhl&#xD;
    ...
    sp3FRlACVeb1Qlytr4vgc5FlCqn0rMtjlF4=
    </ds:X509Certificate>
    
  • Base64Cr13Entity Produce multi-line base64 for XML elements such as SignatureValue and X509Certificate, with each line ending in a CR decimal entity, except for the last line. For example:
    <ds:X509Certificate>MIIFNTCCBB2gAwIBAgIQHozVnBl1lTsusAh26u6WZTANBgkqhkiG9w0BAQsFADCBlzELMAkGA1UE&#13;
    BhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgG&#13;
    A1UEChMRQ09NT0RPIENBIExpbWl0ZWQxPTA7BgNVBAMTNENPTU9ETyBSU0EgQ2xpZW50IEF1dGhl&#13;
    ...
    sp3FRlACVeb1Qlytr4vgc5FlCqn0rMtjlF4=
    </ds:X509Certificate>
    
  • Base64Multiline Produce multi-line base64 for XML elements such as SignatureValue and X509Certificate. For example:
    <ds:X509Certificate>MIIFNTCCBB2gAwIBAgIQHozVnBl1lTsusAh26u6WZTANBgkqhkiG9w0BAQsFADCBlzELMAkGA1UE
    BhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgG
    A1UEChMRQ09NT0RPIENBIExpbWl0ZWQxPTA7BgNVBAMTNENPTU9ETyBSU0EgQ2xpZW50IEF1dGhl
    ...
    sp3FRlACVeb1Qlytr4vgc5FlCqn0rMtjlF4=
    </ds:X509Certificate>
    
  • ForceAddEnvelopedSignatureTransform The <Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature" /> is normally only added when the Signature is contained within the XML fragment that is signed. The meaning of this tranformation is to tell the verifier to remove the Signature from the data prior to canonicalizing. If the Signature is not contained within the XML fragment that was signed, then the signature was not enveloped. There would be no need to remove the Signature because the Signature is not contained in the XML fragment being verified. However.. some brain-dead verifiying systems require this Transform to be present regardless of whether it makes sense. This behavior will cause Chilkat to add the Transform regardless.
  • NoEnvelopedSignatureTransform (introduced in v9.5.0.82) Prevents the <Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature" /> from being added in all cases.
  • EnvelopedTransformFirst (introduced in v9.5.0.87) Forces the http://www.w3.org/2000/09/xmldsig#enveloped-signature to be listed first when there are multiple transforms for a reference.
  • ebXmlTransform (introduced in v9.5.0.73) Causes the following tranform to be added for ebXml messages:
    <Transform Algorithm=http://www.w3.org/TR/1999/REC-xpath-19991116>
        <XPath xmlns:SOAP-ENV=http://schemas.xmlsoap.org/soap/envelope/>not(ancestor-or-self::node()[@SOAP-ENV:actor=urn:oasis:names:tc:ebxml-msg:actor:nextMSH]
             | ancestor-or-self::node()[@SOAP-ENV:actor=http://schemas.xmlsoap.org/soap/actor/next])</XPath>
    </Transform>
    
  • TransformSignatureXPath (introduced in v9.5.0.75) Causes the following tranform to be added:
    <ds:Transform Algorithm=http://www.w3.org/TR/1999/REC-xpath-19991116>
       <ds:XPath>not(ancestor-or-self::ds:Signature)</ds:XPath>
    </ds:Transform>
    
  • CompactSignedXml (introduced in v9.5.0.73) The passed-in XML to be signed is first reformatted to a compact representation by removing all CR's, LF's, and unnecessary whitespace so that the XML to be signed is on a single line. The resulting XML (with signature) is also entirely contained on a single line. (If an XML declarator is present, then it will remain on it's own line.)
  • IndentedSignature (introduced in v9.5.0.73) Causes the XML Signature to be produced on multiple lines with indentation for easier human readability. The CompactSignedXml behavior takes precedence over this behavior.
  • FullLocalSigningTime (introduced in v9.5.0.76) Causes the signing time to be formatted like this: 2017-05-20T19:16:05.649+01:00.nnn, where the .nnn is added to indicate milliseconds.
  • LocalSigningTime (introduced in v9.5.0.76) Causes the signing time to be formatted using a local time (with a timezone offset such as +01:00 rather than Z to signify GMT).
  • NoReplaceSigningTime Don't replace the <SigningTime> content with a timestamp of the current date/time. Instead keep the current value provided by the application.
  • NoTimestampBias Exclude the timestamp bias from the generated <SigningTime>
  • DnReverseOrder (introduced in v9.5.0.77) Causes DN's (certificate Distinguished Names) to be written in reverse order. Reverse order leads with CN, such as CN=..., O=..., OU=..., C=..., whereas normal order ends with CN, such as C=..., OU=..., O=..., CN=...
  • IssuerSerialHex (introduced in v9.5.0.77) Causes the issuer serial number located in SignedProperties.SignedSignatureProperties.SigningCertificate to be emitted as uppercase hex instead of decimal. (Also, when signing XML for e-dokumenty.mf.gov.pl, Chilkat automatically recognizes it and uses IssuerSerialHex.)
  • IssuerSerialHexLower (introduced in v9.5.0.77) Causes the issuer serial number located in SignedProperties.SignedSignatureProperties.SigningCertificate to be emitted as lowercase hex instead of decimal.
  • SigningTimeAdjust-<numSeconds> (introduced in v9.5.0.80) When Chilkat automatically fills in the value for a SigningTime, it will use the current system date/time. This behavior can be used to adjust the generate time to numSeconds in the past. For example: SigningTimeAdjust-60 will generate a signing time 60 seconds prior to the current time.
  • SigningTimeAdjust+<numSeconds> (introduced in v9.5.0.88) When Chilkat automatically fills in the value for a SigningTime, it will use the current system date/time. This behavior can be used to adjust the generate time to numSeconds in the future. For example: SigningTimeAdjust+60 will generate a signing time 60 seconds past the current time.
  • UBLDocumentSignatures Causes an XPath ancestor-or-self Transform to be added for the 1st reference. See the example at UBL XAdES Enveloped Signature
  • SignExistingSignatures This keyword can be used when applying a 2nd or greater signature and the new signature will encompass one or more existing signatures. The default behavior is that existing signatures are not included in the canonicalization/digest before signing. Adding this keyword will cause existing signatures to be included in the canonicalization/digest.

top
CustomKeyInfoXml
// read/write
pub fn getCustomKeyInfoXml(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setCustomKeyInfoXml(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.69

Specifies custom XML to be inserted in the KeyInfo element of the Signature. A common use is to provide a wsse:SecurityTokenReference fragment of XML.

top
DebugLogFilePath
// read/write
pub fn getDebugLogFilePath(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setDebugLogFilePath(self: XmlDSigGen, value: [:0]const u8) void

If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. This logging helps identify the context and history of Chilkat calls leading up to any crash or hang, aiding in debugging.

Enabling the VerboseLogging property provides more detailed information. This property is mainly used for debugging rare instances where a Chilkat method call causes a hang or crash, which should generally not happen.

Possible causes of hangs include:

  • A timeout property set to 0, indicating an infinite timeout.
  • A hang occurring within an event callback in the application code.
  • An internal bug in the Chilkat code causing the hang.

More Information and Examples
top
IncNamespacePrefix
// read/write
pub fn getIncNamespacePrefix(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setIncNamespacePrefix(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.70

The namespace prefix to use for InclusiveNamespaces elements. The default value is ec. Set this property to the empty string to omit an InclusiveNamespaces prefix. For example, given the default values of IncNamespaceUri and IncNamespacePrefix, generated InclusiveNamespaces elements will appear like this:

<ec:InclusiveNamespaces xmlns:ec="http://www.w3.org/2001/10/xml-exc-c14n#"> ... </ec:InclusiveNamespaces>

top
IncNamespaceUri
// read/write
pub fn getIncNamespaceUri(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setIncNamespaceUri(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.70

The namespace URI for any InclusiveNamespaces elements that are created. The default value is http://www.w3.org/2001/10/xml-exc-c14n#. For example, if the IncNamespacePrefix equals ec and this property remains at the default value, then the generated Signature element will be:

<ec:InclusiveNamespaces xmlns:ec="http://www.w3.org/2001/10/xml-exc-c14n#"> ... </ec:InclusiveNamespaces>

top
KeyInfoId
// read/write
pub fn getKeyInfoId(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setKeyInfoId(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.75

If set, causes the generated KeyInfo element to include an Id attribute with this value. For example:

...
   <ds:KeyInfo Id="KeyInfo">
      <ds:X509Data>
         <ds:X509SubjectName>CERTIFICADO DE ABC</ds:X509SubjectName>
         <ds:X509Certificate>MIIITTCC....fIsIZeZOeQ=</ds:X509Certificate>
      </ds:X509Data>
   </ds:KeyInfo>
...

top
KeyInfoKeyName
// read/write
pub fn getKeyInfoKeyName(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setKeyInfoKeyName(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.69

Specifies the KeyName to be inserted in the KeyInfo element of the Signature if the KeyInfoType equals KeyName.

More Information and Examples
top
KeyInfoType
// read/write
pub fn getKeyInfoType(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setKeyInfoType(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.69

Specifies the type of information that will be included in the optional KeyInfo element of the Signature. Possible values are:

  • None
  • KeyName
  • KeyValue
  • X509Data
  • X509Data+KeyValue
  • Custom

The default value is KeyValue. The X509Data+KeyValue option was added in Chilkat v9.5.0.73.

If None, then no KeyInfo element is added to the Signature when generated.

If KeyValue, then the KeyInfo will contain the public key (RSA, DSA, or ECDSA).

If X509Data, then the KeyInfo will contain information about an X.509 certificate as specified by the X509Type property.

If Custom, then the KeyInfo will contain the custom XML contained in the CustomKeyInfoXml property.

top
LastErrorHtml
// read-only
pub fn getLastErrorHtml(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8

Provides HTML-formatted information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.

top
LastErrorText
// read-only
pub fn getLastErrorText(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8

Provides plain text information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.

top
LastErrorXml
// read-only
pub fn getLastErrorXml(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8

Provides XML-formatted information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.

top
LastMethodSuccess
// read/write
pub fn getLastMethodSuccess(self: XmlDSigGen) bool
pub fn setLastMethodSuccess(self: XmlDSigGen, value: bool) void

Indicates the success or failure of the most recent method call: true means success, false means failure. This property remains unchanged by property setters or getters. This method is present to address challenges in checking for null or Nothing returns in certain programming languages. Note: This property does not apply to methods that return integer values or to boolean-returning methods where the boolean does not indicate success or failure.

top
SigId
// read/write
pub fn getSigId(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setSigId(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.69

An option Id attribute value for the Signature element. The default value is the empty string, which generates a Signature element with no Id attribute. For example:

<ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
If this property is set to "abc123", then the Signature element would be generated like this:
<ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#" Id="abc123">

top
SigLocation
// read/write
pub fn getSigLocation(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setSigLocation(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.69

Indicates where the Signature is to be located within the XML that is signed. This is a path to the position in the XML where the Signature will be inserted, using Chilkat path syntax (using vertical bar characters to delimit tag names. If the Signature element is to be the root of XML document, then set this property equal to the empty string.

For example, if we have the following SOAP XML and wish to insert the Signature at the indicated location, then the SigLocation property should be set to SOAP-ENV:Envelope|SOAP-ENV:Header|wsse:Security.

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
    <SOAP-ENV:Header>
	<wsse:Security xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" SOAP-ENV:mustUnderstand="1">
		** The XML Signature is to be inserted here **
	</wsse:Security>
    </SOAP-ENV:Header>
...
</SOAP-ENV:Envelope>

top
SigLocationIdx
// read/write
pub fn getSigLocationIdx(self: XmlDSigGen) i32
pub fn setSigLocationIdx(self: XmlDSigGen, value: i32) void
Introduced in version 11.1.0

Insert the signature at the Nth occurrence of the SigLocation. The default is 0, which is to insert (according to SigLocationMod ) at the 1st occurrence. (An index value of 1 is for the 2nd occurrence, and so on.)

top
SigLocationMod
// read/write
pub fn getSigLocationMod(self: XmlDSigGen) i32
pub fn setSigLocationMod(self: XmlDSigGen, value: i32) void
Introduced in version 9.5.0.77

Modifies the placement of the signature at the location specified by SigLocation. Possible values are:

  • 0: Insert the Signature as the last child of the element at SigLocation. This is the default.
  • 1: Insert the Signature as a sibling directly after the element at SigLocation.
  • 2: Insert the Signature as a sibling directly before the element at SigLocation.

top
SigNamespacePrefix
// read/write
pub fn getSigNamespacePrefix(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setSigNamespacePrefix(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.69

The namespace prefix of the Signature that is to be created. The default value is ds. Set this property to the empty string to omit a Signature namespace URI and prefix. For example, given the default values of SigNamespaceUri and SigNamespacePrefix, the generated Signature element will be:

<ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#"> ... </ds:Signature>

top
SigNamespaceUri
// read/write
pub fn getSigNamespaceUri(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setSigNamespaceUri(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.69

The namespace URI of the Signature that is to be created. The default value is http://www.w3.org/2000/09/xmldsig#. For example, if the SigNamespacePrefix equals ds and this property remains at the default value, then the generated Signature element will be:

<ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#"> ... </ds:Signature>

top
SignedInfoCanonAlg
// read/write
pub fn getSignedInfoCanonAlg(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setSignedInfoCanonAlg(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.69

The canonicalization method to be used for the SignedInfo when creating the XML signature.

  • C14N -- for Inclusive Canonical XML (without comments)
  • C14N_11 -- for Inclusive Canonical XML 1.1 (without comments)
  • EXCL_C14N -- for Exclusive Canonical XML (without comments)
  • C14N_WithComments -- for Inclusive Canonical XML (with comments)
  • C14N_11_WithComments -- for Inclusive Canonical XML 1.1 (with comments)
  • EXCL_C14N_WithComments -- for Exclusive Canonical XML (with comments)
  • Note: The WithComments options are available in Chilkat v9.5.0.71 and later.

The default value is EXCL_C14N.

top
SignedInfoDigestMethod
// read/write
pub fn getSignedInfoDigestMethod(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setSignedInfoDigestMethod(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.69

The digest method to be used for signing the SignedInfo part of the Signature. Possible values are sha1, sha256, sha384, and sha512. The default is sha256.

top
SignedInfoId
// read/write
pub fn getSignedInfoId(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setSignedInfoId(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.75

Optional Id attribute to be added to the SignedInfo element. The default value is the empty string, meaning that the SignedInfo is generated without an Id attribute.

top
SignedInfoPrefixList
// read/write
pub fn getSignedInfoPrefixList(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setSignedInfoPrefixList(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.69

The inclusive namespace prefix list to be added, if any, when the SignedInfoCanonAlg is equal to EXCL_C14N. The defautl value is the empty string. If namespaces are listed, they are separated by space characters.

If, for example, this property is set to wsse SOAP-ENV, then the CanonicalizationMethod part of the SignedInfo that is generated would look like this:

<ds:SignedInfo>
    <ds:CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#">
      <InclusiveNamespaces xmlns="http://www.w3.org/2001/10/xml-exc-c14n#" PrefixList="wsse SOAP-ENV" />
    </ds:CanonicalizationMethod>
...
</ds:SignedInfo>

top
SigningAlg
// read/write
pub fn getSigningAlg(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setSigningAlg(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.69

Selects the signature algorithm to be used when using an RSA key to sign. The default value is PKCS1-v1_5. This can be set to RSASSA-PSS (or simply pss) to use the RSASSA-PSS signature scheme.

Note: This property only applies when signing with an RSA private key. It does not apply for ECC or DSA private keys.

top
SigValueId
// read/write
pub fn getSigValueId(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setSigValueId(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.75

An option Id attribute value for the SignatureValue element. The default value is the empty string, which generates a SignatureValue element with no Id attribute. For example:

<ds:SignatureValue>
If this property is set to "value-id-7d4a", then the Signature element would be generated like this:
<ds:SignatureValue  Id="value-id-7d4a">

top
UncommonOptions
// read/write
pub fn getUncommonOptions(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setUncommonOptions(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.87

This is a catch-all property to be used for uncommon needs. This property defaults to the empty string, and should typically remain empty.

top
VerboseLogging
// read/write
pub fn getVerboseLogging(self: XmlDSigGen) bool
pub fn setVerboseLogging(self: XmlDSigGen, value: bool) void

If set to true, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. The default value is false. Verbose logging should only be used for debugging. The potentially large quantity of logged information may adversely affect peformance.

top
Version
// read-only
pub fn getVersion(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8

Version of the component/library, such as "10.1.0"

More Information and Examples
top
X509Type
// read/write
pub fn getX509Type(self: XmlDSigGen, allocator: Allocator) Allocator.Error![:0]u8
pub fn setX509Type(self: XmlDSigGen, value: [:0]const u8) void
Introduced in version 9.5.0.69

Specifies the kind of X.509 certificate information is provided in the KeyInfo element when the KeyInfoType equals X509Data. Possible values are:

  • Certificate
  • CertChain
  • IssuerSerial
  • SubjectName
  • SKI

The default value is Certificate.

Note: This property can be set to a comma-separated list of the keywords above. For example, If set to SubjectName,Certificate, then both the X509SubjectName and X509Certificate parts will be added to the KeyInfo.

If Certificate, then the KeyInfo will contain the base64 encoded X.509v3 certificate.

If CertChain, then the KeyInfo will contain the base64 encoded X.509v3 certificate as well as any certificates available in the chain of authentication to the root cert.

If IssuerSerial, then the KeyInfo will contain the X.509 issuer's distinguished name and the signing certificate's serial number.

If SubjectName, then the KeyInfo will contain the X.509 subject distinguished name.

If SKI, then the KeyInfo will contain the base64 encoded value of the cert's X.509 SubjectKeyIdentifier extension.

top

Methods

AddEnvelopedRef
pub fn addEnvelopedRef(self: XmlDSigGen, id: [:0]const u8, content: chilkat.StringBuilder, digest_method: [:0]const u8, canon_method: [:0]const u8, ref_type: [:0]const u8) Error!void
Introduced in version 9.5.0.69

Specifies an enveloped Reference to be added to the Signature when generated. An enveloped Reference is for data contained within the Signature. (The Signature is to be an enveloping signature, and the data is enveloped by the Signature.)

The id is the value of the Id attribute of the Object element that is to be contained within the generated Signature. The content is the text content to be contained in the Object. Binary data can be signed by passing the bytes in content in an encoded format (such as base64 or hex).

The digest_method is the digest method and can be one of the following: sha1, sha256, sha384, sha512, ripemd160, or md5.

The canon_method is the canonicalization method, and can be one of the following.

  • C14N -- for Inclusive Canonical XML (without comments)
  • C14N_11 -- for Inclusive Canonical XML 1.1 (without comments)
  • EXCL_C14N -- for Exclusive Canonical XML (without comments)
  • C14N_WithComments -- for Inclusive Canonical XML (with comments)
  • C14N_11_WithComments -- for Inclusive Canonical XML 1.1 (with comments)
  • EXCL_C14N_WithComments -- for Exclusive Canonical XML (with comments)
  • Note: The WithComments options are available in Chilkat v9.5.0.71 and later.

The ref_type is optional and is usually not needed. Set this to the empty string unless it is desired to add a Type attribute to the Reference that is advisory only.

Returns error.ChilkatFailed on failure; getLastErrorText explains why.

top
AddExternalBinaryRef
pub fn addExternalBinaryRef(self: XmlDSigGen, uri: [:0]const u8, content: chilkat.BinData, digest_method: [:0]const u8, ref_type: [:0]const u8) Error!void
Introduced in version 9.5.0.69

Specifies an external non-XML binary data Reference to be added to the Signature when generated.

The uri is the value of the URI attribute of the Reference.

The content contains the binary data to be digested according to the digest_method.

The digest_method is the digest method and can be one of the following: sha1, sha256, sha384, sha512, ripemd160, or md5.

The ref_type is optional and is usually not needed. Set this to the empty string unless it is desired to add a Type attribute to the Reference that is advisory only.

Returns error.ChilkatFailed on failure; getLastErrorText explains why.

top
AddExternalFileRef
pub fn addExternalFileRef(self: XmlDSigGen, uri: [:0]const u8, local_file_path: [:0]const u8, digest_method: [:0]const u8, ref_type: [:0]const u8) Error!void
Introduced in version 9.5.0.69

Specifies an external file Reference to be added to the Signature when generated.

The uri is the value of the URI attribute of the Reference. It can (and likely will) be different than the local_file_path which is the path to the local file to be added. (The local file is not read until the XML digital signature is actually created.)

The digest_method is the digest method and can be one of the following: sha1, sha256, sha384, sha512, ripemd160, or md5.

The ref_type is optional and is usually not needed. Set this to the empty string unless it is desired to add a Type attribute to the Reference that is advisory only.

Returns error.ChilkatFailed on failure; getLastErrorText explains why.

top
AddExternalTextRef
pub fn addExternalTextRef(self: XmlDSigGen, uri: [:0]const u8, content: chilkat.StringBuilder, charset: [:0]const u8, include_bom: bool, digest_method: [:0]const u8, ref_type: [:0]const u8) Error!void
Introduced in version 9.5.0.69

Specifies an external non-XML text data Reference to be added to the Signature when generated.

The uri is the value of the URI attribute of the Reference.

The content contains the non-XML data to be digested according to the charset. The charset specifies the charset (such as utf-8, windows-1252, etc.) for the byte reprsentation of the text to be digested. The include_bom indicates whether the BOM (Byte Order Mark, also known as the preamble) is included in the byte representation that is digested.

The digest_method is the digest method and can be one of the following: sha1, sha256, sha384, sha512, ripemd160, or md5.

The ref_type is optional and is usually not needed. Set this to the empty string unless it is desired to add a Type attribute to the Reference that is advisory only.

Returns error.ChilkatFailed on failure; getLastErrorText explains why.

top
AddExternalXmlRef
pub fn addExternalXmlRef(self: XmlDSigGen, uri: [:0]const u8, content: chilkat.StringBuilder, digest_method: [:0]const u8, canon_method: [:0]const u8, ref_type: [:0]const u8) Error!void
Introduced in version 9.5.0.69

Specifies an external XML Reference to be added to the Signature when generated.

The uri is the value of the URI attribute of the Reference.

The content contains the XML document to be referenced.

The digest_method is the digest method and can be one of the following: sha1, sha256, sha384, sha512, ripemd160, or md5.

The canon_method is the canonicalization method, and can be one of the following.

  • C14N -- for Inclusive Canonical XML (without comments)
  • C14N_11 -- for Inclusive Canonical XML 1.1 (without comments)
  • EXCL_C14N -- for Exclusive Canonical XML (without comments)
  • C14N_WithComments -- for Inclusive Canonical XML (with comments)
  • C14N_11_WithComments -- for Inclusive Canonical XML 1.1 (with comments)
  • EXCL_C14N_WithComments -- for Exclusive Canonical XML (with comments)
  • -- An empty string indicates that no transformation should be included / applied for this reference.
  • Note: The WithComments options are available in Chilkat v9.5.0.71 and later.
  • Note: The empty-string canonMethod is available in Chilkat v9.5.0.75 and later.

The ref_type is optional and is usually not needed. Set this to the empty string unless it is desired to add a Type attribute to the Reference that is advisory only.

Returns error.ChilkatFailed on failure; getLastErrorText explains why.

top
AddObject
pub fn addObject(self: XmlDSigGen, id: [:0]const u8, content: [:0]const u8, mime_type: [:0]const u8, encoding: [:0]const u8) Error!void
Introduced in version 9.5.0.75

Specifies an Object to be added to the Signature.

  1. The id is the value of the Object element's Id attribute.
  2. The content contains the content of the Object element, which may be XML or plain text.
  3. The mime_type is the value of the Object element's MimeType attribute
  4. The encoding is the value of the Object element's Encoding attribute
In most cases, the mime_type and encoding are empty strings which cause the MimeType and Encoding attributes to be omitted.

Returns error.ChilkatFailed on failure; getLastErrorText explains why.

top
AddObjectRef
pub fn addObjectRef(self: XmlDSigGen, id: [:0]const u8, digest_method: [:0]const u8, canon_method: [:0]const u8, prefix_list: [:0]const u8, ref_type: [:0]const u8) Error!void
Introduced in version 9.5.0.75

This is the same as the AddSameDocRef method, except the reference is to content within an Object previously added via the AddObject method. The id must be an Id equal to the Id attribute of an Object, or the Id attribute of an element within the Object.

Note: The canon_method can be set to Base64 to use the http://www.w3.org/2000/09/xmldsig#base64 transform.

Returns error.ChilkatFailed on failure; getLastErrorText explains why.

More Information and Examples
top
AddObjectRef2
pub fn addObjectRef2(self: XmlDSigGen, id: [:0]const u8, digest_method: [:0]const u8, transforms: chilkat.Xml, ref_type: [:0]const u8) Error!void
Introduced in version 9.5.0.90

This method is the same as AddObjectRef, except it allows the Transforms to be specified exactly with a fragment of XML. See the example below.

Returns error.ChilkatFailed on failure; getLastErrorText explains why.

top
AddSameDocRef
pub fn addSameDocRef(self: XmlDSigGen, id: [:0]const u8, digest_method: [:0]const u8, canon_method: [:0]const u8, prefix_list: [:0]const u8, ref_type: [:0]const u8) Error!void
Introduced in version 9.5.0.69

Specifies a same document Reference to be added to the Signature when generated. A same document Reference can be the entire XML document, or a fragment of the XML document.

The id can be the empty string to sign the entire XML document, or it can be the fragment identifier to sign a portion of the XML document.

The digest_method is the digest method and can be one of the following: sha1, sha256, sha384, sha512, ripemd160, or md5.

The canon_method is the canonicalization method, and can be one of the following:

  • C14N -- for Inclusive Canonical XML (without comments)
  • C14N_11 -- for Inclusive Canonical XML 1.1 (without comments)
  • EXCL_C14N -- for Exclusive Canonical XML (without comments)
  • C14N_WithComments -- for Inclusive Canonical XML (with comments)
  • C14N_11_WithComments -- for Inclusive Canonical XML 1.1 (with comments)
  • EXCL_C14N_WithComments -- for Exclusive Canonical XML (with comments)
  • -- An empty string indicates that no transformation should be included / applied for this reference.
  • Note: The WithComments options are available in Chilkat v9.5.0.71 and later.
  • Note: The empty-string canonMethod is available in Chilkat v9.5.0.75 and later.

If exclusive canonicalization is selected, then the prefix_list can contain a space separated list of inclusive namespace prefixes. For inclusive canonicalization, this argument is ignored. In general, pass an empty string for this argument unless you have specific knowledge of namespace prefixes that need to be treated as inclusive when EXCL_C14N is used.

Starting in Chilkat v9.5.0.70, the prefix_list can be set to the keyword _EMPTY_ to force the generation of an empty PrefixList under the Transform. For example:

  <ds:Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#">
	<ec:InclusiveNamespaces xmlns:ec="http://www.w3.org/2001/10/xml-exc-c14n#" PrefixList=""/>
  </ds:Transform>

The ref_type is optional and is usually not needed. Set this to the empty string unless it is desired to add a Type attribute to the Reference that is advisory only.

Returns error.ChilkatFailed on failure; getLastErrorText explains why.

More Information and Examples
top
AddSameDocRef2
pub fn addSameDocRef2(self: XmlDSigGen, id: [:0]const u8, digest_method: [:0]const u8, transforms: chilkat.Xml, ref_type: [:0]const u8) Error!void
Introduced in version 9.5.0.90

This method is the same as AddSameDocRef, except it allows the Transforms to be specified exactly with a fragment of XML. See the example below.

Returns error.ChilkatFailed on failure; getLastErrorText explains why.

top
AddSignatureNamespace
pub fn addSignatureNamespace(self: XmlDSigGen, ns_prefix: [:0]const u8, ns_uri: [:0]const u8) Error!void
Introduced in version 9.5.0.75

Can be called one or more times to add additional namespaces to the Signature element.

Returns error.ChilkatFailed on failure; getLastErrorText explains why.

top
ConstructSignedInfo
pub fn constructSignedInfo(self: XmlDSigGen, allocator: Allocator, sb_xml: chilkat.StringBuilder) (Error || Allocator.Error)![:0]u8
Introduced in version 9.5.0.74

This method will construct and return the canonicalized SignedInfo XML. The digests of each Reference are computed and included in the SignedInfo. This method is provided for certain special circumstances where one wants to get the exact canonicalized SignedInfo that would be signed using the private key.

Note: Properties such as SigLocation, SigningAlg, etc. and references must be set exactly as if an XML signature was to be actually generated because they determine the content of the SignedInfo.

Note, the sb_xml is not signed by this method. It is not modified.

Returns error.ChilkatFailed on failure; getLastErrorText explains why. The string is allocated with allocator and owned by the caller (defer allocator.free(s)).

top
CreateXmlDSig
pub fn createXmlDSig(self: XmlDSigGen, allocator: Allocator, in_xml: [:0]const u8) (Error || Allocator.Error)![:0]u8
Introduced in version 9.5.0.69

Creates an XML Digital Signature. The application passes in the XML to be signed, and the signed XML is returned. If creating an enveloping signature where the Signature element is the root, then the in_xml may be the empty string.

  • Chilkat v9.5.0.76 or greater is required for XML signatures for www.csioz.gov.pl

Returns error.ChilkatFailed on failure; getLastErrorText explains why. The string is allocated with allocator and owned by the caller (defer allocator.free(s)).

top
CreateXmlDSigSb
pub fn createXmlDSigSb(self: XmlDSigGen, sb_xml: chilkat.StringBuilder) Error!void
Introduced in version 9.5.0.69

Creates an XML Digital Signature. The application passes the XML to be signed in sb_xml, and it is replaced with the signed XML if successful. (Thus, sb_xml is both an input and output argument.) Note: If creating an enveloping signature where the Signature element is to be the root element, then the passed-in sb_xml may be empty.

Returns error.ChilkatFailed on failure; getLastErrorText explains why.

top
SetHmacKey
pub fn setHmacKey(self: XmlDSigGen, key: [:0]const u8, encoding: [:0]const u8) Error!void
Introduced in version 9.5.0.69

Sets the HMAC key to be used if the Signature is to use an HMAC signing algorithm. The encoding specifies the encoding of key, and can be hex, base64, ascii, or any of the binary encodings supported by Chilkat in the link below.

Returns error.ChilkatFailed on failure; getLastErrorText explains why.

top
SetHttpObj
pub fn setHttpObj(self: XmlDSigGen, http: chilkat.Http) void
Introduced in version 9.5.0.90

Sets the HTTP object to be used to communicate with OCSP responders, CRL distribution points, or timestamp authority (TSA) servers if needed. The http is used to send the requests, and it allows for connection related settings and timeouts to be set. For example, if HTTP or SOCKS proxies are required, these features can be specified on the http.

More Information and Examples
top
SetPrivateKey
pub fn setPrivateKey(self: XmlDSigGen, priv_key: chilkat.PrivateKey) Error!void
Introduced in version 9.5.0.69

Sets the private key to be used for creating the XML signature. The private key may be an RSA key, a DSA key, or an ECDSA key.

Returns error.ChilkatFailed on failure; getLastErrorText explains why.

top
SetRefIdAttr
pub fn setRefIdAttr(self: XmlDSigGen, uri_or_id: [:0]const u8, value: [:0]const u8) Error!void
Introduced in version 9.5.0.75

Sets the Id attribute for a Reference.

Returns error.ChilkatFailed on failure; getLastErrorText explains why.

More Information and Examples
top
SetTsa
pub fn setTsa(self: XmlDSigGen, json: chilkat.JsonObject) Error!void
Introduced in version 9.5.0.90

Sets the TSA (Timestamp Authority) URL and other related settings for automatically adding an EncapsulatedTimestamp.

Returns error.ChilkatFailed on failure; getLastErrorText explains why.

top
SetX509Cert
pub fn setX509Cert(self: XmlDSigGen, cert: chilkat.Cert, use_private_key: bool) Error!void
Introduced in version 9.5.0.69

Specifies the X.509 certificate to be used for the KeyInfo element when the KeyInfoType equals X509Data. If use_private_key is true, then the private key will also be set using the certificate's private key. Thus, the SetPrivateKey method does not need to be called. If use_private_key is true, and the certificate does not have an associated private key available, then this method will return false.

Note: A certificate's private key is not stored within a certificate itself. If the certificate (cert) was obtained from a PFX, Java KeyStore, or other such source, which are containers for both certs and private keys, then Chilkat would have associated the cert with the private key when loading the PFX or JKS, and all is good. The same holds true if, on a Windows system, the certificate was obtained from a Windows-based registry certificate store where the private key was installed with the permission to export.

If, however, the certificate was loaded from a .cer file, or another type of file that contains only the certificate and not the private key, then the associated private key needs to be obtained by the application and provided by calling SetPrivateKey.

Returns error.ChilkatFailed on failure; getLastErrorText explains why.

More Information and Examples
top

Events

All Chilkat methods are synchronous: the call returns when the work is done. During a call, XmlDSigGen raises three events so your program can show progress and offer a way out. Declare any subset of abortCheck, percentDone and progressInfo in a struct of your own and install a pointer to it with setEventHandler:

const Progress = struct {
    pub fn percentDone(_: *Progress, pct: i32) bool {
        std.debug.print("{d}%\n", .{pct});
        return false; // return true to abort the method in progress
    }
    pub fn progressInfo(_: *Progress, name: [:0]const u8, value: [:0]const u8) void {
        std.debug.print("{s}: {s}\n", .{ name, value });
    }
};

var progress = Progress{};
xml_d_sig_gen.setEventHandler(&progress); // progress must outlive the installation
defer xml_d_sig_gen.clearEventHandler();
xml_d_sig_gen.setHeartbeatMs(250); // abortCheck 4 times per second during Chilkat calls
pub fn setEventHandler(self: XmlDSigGen, handler: anytype) void

Installs handler, a pointer to any struct, as the receiver of this object's events, replacing any handler installed earlier. The dispatch is resolved at compile time: only the methods the struct declares are called, and a struct declaring none of the three is a compile error. The struct must stay alive, at the same address, until clearEventHandler or deinit.

pub fn clearEventHandler(self: XmlDSigGen) void

Removes the handler; events are no longer delivered.

AbortCheck fires at regular intervals controlled by the HeartbeatMs property (0, the default, disables it); PercentDone fires when an operation's completion percentage is known; ProgressInfo delivers named progress values. Returning true from abortCheck or percentDone aborts the running method, which then returns error.ChilkatFailed.

Events fire on the thread that called the method, before that method returns. To abort a long operation from another thread, have abortCheck read a std.atomic.Value(bool), or set the object's AbortCurrent property.

AbortCheck
// handler struct method (optional); install with setEventHandler
pub fn abortCheck(self: *T) bool

Enables a method call to be aborted by triggering the AbortCheck event at intervals defined by the HeartbeatMs property. If HeartbeatMs is set to its default value of 0, no events will occur. For instance, set HeartbeatMs to 200 to trigger 5 AbortCheck events per second.

More Information and Examples

Example

const Abort = struct {
    stop: std.atomic.Value(bool) = .init(false),
    pub fn abortCheck(self: *Abort) bool {
        return self.stop.load(.acquire); // another thread may call abort.stop.store(true, .release)
    }
};

var abort = Abort{};
xml_d_sig_gen.setHeartbeatMs(250); // call abortCheck 4 times per second
xml_d_sig_gen.setEventHandler(&abort);
defer xml_d_sig_gen.clearEventHandler();
top
PercentDone
// handler struct method (optional); install with setEventHandler
pub fn percentDone(self: *T, pct: i32) bool

This provides the percentage completion for any method involving network communications or time-consuming processing, assuming the progress can be measured as a percentage. This event is triggered only when it's possible and logical to express the operation's progress as a percentage. The pctDone argument will range from 1 to 100. For methods that finish quickly, the number of PercentDone callbacks may vary, but the final callback will have pctDone equal to 100. For longer operations, callbacks will not exceed one per percentage point (e.g., 1, 2, 3, ..., 98, 99, 100).

The PercentDone callback also acts as an AbortCheck event. For fast methods where PercentDone fires, an AbortCheck event may not trigger since the PercentDone callback already provides an opportunity to abort. For longer operations, where time between PercentDone callbacks is extended, AbortCheck callbacks enable more responsive operation termination.

To abort the operation, set the abort output argument to true. This will cause the method to terminate and return a failure status or corresponding failure value.

More Information and Examples

Example

const Progress = struct {
    pub fn percentDone(_: *Progress, pct: i32) bool {
        // pct ranges from 1 to 100.
        std.debug.print("Percent done: {d}\n", .{pct});
        return false; // return true to abort the method in progress
    }
};

var progress = Progress{};
xml_d_sig_gen.setEventHandler(&progress);
defer xml_d_sig_gen.clearEventHandler();
top
ProgressInfo
// handler struct method (optional); install with setEventHandler
pub fn progressInfo(self: *T, name: [:0]const u8, value: [:0]const u8) void

This event callback provides tag name/value pairs that detail what occurs during a method call. To discover existing tag names, create code to handle the event, emit the pairs, and review them. Most tag names are self-explanatory.

Note: Some Chilkat methods don't fire any ProgressInfo events.

More Information and Examples

Example

const Info = struct {
    pub fn progressInfo(_: *Info, name: [:0]const u8, value: [:0]const u8) void {
        std.debug.print("{s}: {s}\n", .{ name, value });
    }
};

var info = Info{};
xml_d_sig_gen.setEventHandler(&info);
defer xml_d_sig_gen.clearEventHandler();
top